सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

टेंसर का परिचय

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें
import tensorflow as tf
import numpy as np

टेंसर एक समान प्रकार (जिसे dtype कहा जाता है) के साथ बहु-आयामी सरणियाँ हैं। आप सभी समर्थित dtypes को tf.dtypes.DType पर देख सकते हैं।

यदि आप NumPy से परिचित हैं, तो टेंसर np.arrays की तरह (तरह के) हैं।

सभी टेंसर अपरिवर्तनीय हैं जैसे कि पायथन नंबर और स्ट्रिंग्स: आप कभी भी एक टेंसर की सामग्री को अपडेट नहीं कर सकते हैं, केवल एक नया बना सकते हैं।

मूल बातें

आइए कुछ बुनियादी टेंसर बनाएं।

यहाँ एक "स्केलर" या "रैंक-0" टेंसर है। एक अदिश में एक ही मान होता है, और कोई "अक्ष" नहीं होता है।

# This will be an int32 tensor by default; see "dtypes" below.
rank_0_tensor = tf.constant(4)
print(rank_0_tensor)
tf.Tensor(4, shape=(), dtype=int32)

एक "वेक्टर" या "रैंक -1" टेंसर मूल्यों की एक सूची की तरह है। एक वेक्टर में एक अक्ष होता है:

# Let's make this a float tensor.
rank_1_tensor = tf.constant([2.0, 3.0, 4.0])
print(rank_1_tensor)
tf.Tensor([2. 3. 4.], shape=(3,), dtype=float32)

एक "मैट्रिक्स" या "रैंक -2" टेंसर में दो अक्ष होते हैं:

# If you want to be specific, you can set the dtype (see below) at creation time
rank_2_tensor = tf.constant([[1, 2],
                             [3, 4],
                             [5, 6]], dtype=tf.float16)
print(rank_2_tensor)
tf.Tensor(
[[1. 2.]
 [3. 4.]
 [5. 6.]], shape=(3, 2), dtype=float16)
एक अदिश, आकार: [] एक वेक्टर, आकार: [3] एक मैट्रिक्स, आकार: [3, 2]
एक अदिश, संख्या 43 खंडों वाली रेखा, प्रत्येक में एक संख्या होती है।एक 3x2 ग्रिड, जिसमें प्रत्येक सेल में एक नंबर होता है।

टेंसर में अधिक कुल्हाड़ियाँ हो सकती हैं; यहाँ तीन अक्षों वाला एक टेंसर है:

# There can be an arbitrary number of
# axes (sometimes called "dimensions")
rank_3_tensor = tf.constant([
  [[0, 1, 2, 3, 4],
   [5, 6, 7, 8, 9]],
  [[10, 11, 12, 13, 14],
   [15, 16, 17, 18, 19]],
  [[20, 21, 22, 23, 24],
   [25, 26, 27, 28, 29]],])

print(rank_3_tensor)
tf.Tensor(
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]]

 [[10 11 12 13 14]
  [15 16 17 18 19]]

 [[20 21 22 23 24]
  [25 26 27 28 29]]], shape=(3, 2, 5), dtype=int32)

ऐसे कई तरीके हैं जिनसे आप दो से अधिक अक्षों वाले टेंसर की कल्पना कर सकते हैं।

एक 3-अक्ष टेंसर, आकार: [3, 2, 5]

आप np.array या tensor.numpy विधि का उपयोग करके एक टेंसर को एक NumPy सरणी में बदल सकते हैं:

np.array(rank_2_tensor)
array([[1., 2.],
       [3., 4.],
       [5., 6.]], dtype=float16)
rank_2_tensor.numpy()
array([[1., 2.],
       [3., 4.],
       [5., 6.]], dtype=float16)

टेंसर में अक्सर फ़्लोट्स और इनट्स होते हैं, लेकिन कई अन्य प्रकार होते हैं, जिनमें शामिल हैं:

  • जटिल आंकड़े
  • स्ट्रिंग्स

आधार tf.Tensor वर्ग को "आयताकार" होने के लिए टेंसर की आवश्यकता होती है --- अर्थात, प्रत्येक अक्ष के साथ, प्रत्येक तत्व समान आकार का होता है। हालांकि, विशेष प्रकार के टेंसर हैं जो विभिन्न आकृतियों को संभाल सकते हैं:

आप टेनर्स पर बुनियादी गणित कर सकते हैं, जिसमें जोड़, तत्व-वार गुणन और मैट्रिक्स गुणन शामिल हैं।

a = tf.constant([[1, 2],
                 [3, 4]])
b = tf.constant([[1, 1],
                 [1, 1]]) # Could have also said `tf.ones([2,2])`

print(tf.add(a, b), "\n")
print(tf.multiply(a, b), "\n")
print(tf.matmul(a, b), "\n")
tf.Tensor(
[[2 3]
 [4 5]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[1 2]
 [3 4]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[3 3]
 [7 7]], shape=(2, 2), dtype=int32)
print(a + b, "\n") # element-wise addition
print(a * b, "\n") # element-wise multiplication
print(a @ b, "\n") # matrix multiplication
tf.Tensor(
[[2 3]
 [4 5]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[1 2]
 [3 4]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[3 3]
 [7 7]], shape=(2, 2), dtype=int32)

Tensors का उपयोग सभी प्रकार के संचालन (ops) में किया जाता है।

c = tf.constant([[4.0, 5.0], [10.0, 1.0]])

# Find the largest value
print(tf.reduce_max(c))
# Find the index of the largest value
print(tf.argmax(c))
# Compute the softmax
print(tf.nn.softmax(c))
tf.Tensor(10.0, shape=(), dtype=float32)
tf.Tensor([1 0], shape=(2,), dtype=int64)
tf.Tensor(
[[2.6894143e-01 7.3105854e-01]
 [9.9987662e-01 1.2339458e-04]], shape=(2, 2), dtype=float32)

आकृतियों के बारे में

टेंसर के आकार होते हैं। कुछ शब्दावली:

  • आकार : एक टेंसर के प्रत्येक अक्ष की लंबाई (तत्वों की संख्या)।
  • रैंक : टेंसर कुल्हाड़ियों की संख्या। एक अदिश की रैंक 0 है, एक सदिश की रैंक 1 है, एक मैट्रिक्स रैंक 2 है।
  • अक्ष या आयाम : एक टेंसर का एक विशेष आयाम।
  • आकार : टेंसर में आइटम की कुल संख्या, उत्पाद आकार वेक्टर।

Tensors और tf.TensorShape ऑब्जेक्ट्स में इन तक पहुँचने के लिए सुविधाजनक गुण हैं:

rank_4_tensor = tf.zeros([3, 2, 4, 5])
एक रैंक -4 टेंसर, आकार: [3, 2, 4, 5]
एक टेंसर आकार एक वेक्टर की तरह होता है।एक 4-अक्ष टेंसर
print("Type of every element:", rank_4_tensor.dtype)
print("Number of axes:", rank_4_tensor.ndim)
print("Shape of tensor:", rank_4_tensor.shape)
print("Elements along axis 0 of tensor:", rank_4_tensor.shape[0])
print("Elements along the last axis of tensor:", rank_4_tensor.shape[-1])
print("Total number of elements (3*2*4*5): ", tf.size(rank_4_tensor).numpy())
Type of every element: <dtype: 'float32'>
Number of axes: 4
Shape of tensor: (3, 2, 4, 5)
Elements along axis 0 of tensor: 3
Elements along the last axis of tensor: 5
Total number of elements (3*2*4*5):  120
प्लेसहोल्डर22

जबकि कुल्हाड़ियों को अक्सर उनके सूचकांकों द्वारा संदर्भित किया जाता है, आपको हमेशा प्रत्येक के अर्थ का ध्यान रखना चाहिए। अक्सर कुल्हाड़ियों को वैश्विक से स्थानीय में क्रमबद्ध किया जाता है: बैच अक्ष पहले, उसके बाद स्थानिक आयाम, और प्रत्येक स्थान के लिए विशेषताएं अंतिम होती हैं। इस तरह फीचर वैक्टर मेमोरी के सन्निहित क्षेत्र हैं।

विशिष्ट अक्ष क्रम
प्रत्येक अक्ष क्या है, इस पर नज़र रखें। एक 4-अक्ष टेंसर हो सकता है: बैच, चौड़ाई, ऊंचाई, विशेषताएं

इंडेक्सिंग

एकल-अक्ष अनुक्रमण

TensorFlow मानक पायथन इंडेक्सिंग नियमों का पालन करता है, जैसे कि पायथन में एक सूची या एक स्ट्रिंग को अनुक्रमित करना, और NumPy अनुक्रमण के लिए बुनियादी नियम।

  • इंडेक्स 0 . से शुरू होते हैं
  • नकारात्मक सूचकांक अंत से पीछे की ओर गिनते हैं
  • कोलन, : , स्लाइस के लिए उपयोग किया जाता है: start:stop:step
rank_1_tensor = tf.constant([0, 1, 1, 2, 3, 5, 8, 13, 21, 34])
print(rank_1_tensor.numpy())
[ 0  1  1  2  3  5  8 13 21 34]

स्केलर के साथ अनुक्रमण अक्ष को हटा देता है:

print("First:", rank_1_tensor[0].numpy())
print("Second:", rank_1_tensor[1].numpy())
print("Last:", rank_1_tensor[-1].numpy())
First: 0
Second: 1
Last: 34
प्लेसहोल्डर26

: स्लाइस के साथ अनुक्रमण अक्ष को बनाए रखता है:

print("Everything:", rank_1_tensor[:].numpy())
print("Before 4:", rank_1_tensor[:4].numpy())
print("From 4 to the end:", rank_1_tensor[4:].numpy())
print("From 2, before 7:", rank_1_tensor[2:7].numpy())
print("Every other item:", rank_1_tensor[::2].numpy())
print("Reversed:", rank_1_tensor[::-1].numpy())
Everything: [ 0  1  1  2  3  5  8 13 21 34]
Before 4: [0 1 1 2]
From 4 to the end: [ 3  5  8 13 21 34]
From 2, before 7: [1 2 3 5 8]
Every other item: [ 0  1  3  8 21]
Reversed: [34 21 13  8  5  3  2  1  1  0]

बहु-अक्ष अनुक्रमण

उच्च रैंक के टेंसरों को कई सूचकांकों को पारित करके अनुक्रमित किया जाता है।

एकल-अक्ष के मामले में ठीक वही नियम प्रत्येक अक्ष पर स्वतंत्र रूप से लागू होते हैं।

print(rank_2_tensor.numpy())
[[1. 2.]
 [3. 4.]
 [5. 6.]]

प्रत्येक सूचकांक के लिए एक पूर्णांक पास करना, परिणाम एक अदिश राशि है।

# Pull out a single value from a 2-rank tensor
print(rank_2_tensor[1, 1].numpy())
4.0

आप पूर्णांक और स्लाइस के किसी भी संयोजन का उपयोग करके अनुक्रमित कर सकते हैं:

# Get row and column tensors
print("Second row:", rank_2_tensor[1, :].numpy())
print("Second column:", rank_2_tensor[:, 1].numpy())
print("Last row:", rank_2_tensor[-1, :].numpy())
print("First item in last column:", rank_2_tensor[0, -1].numpy())
print("Skip the first row:")
print(rank_2_tensor[1:, :].numpy(), "\n")
Second row: [3. 4.]
Second column: [2. 4. 6.]
Last row: [5. 6.]
First item in last column: 2.0
Skip the first row:
[[3. 4.]
 [5. 6.]]

यहाँ एक 3-अक्ष टेंसर के साथ एक उदाहरण दिया गया है:

print(rank_3_tensor[:, :, 4])
35 एल10एन-प्लेसहोल्डर
tf.Tensor(
[[ 4  9]
 [14 19]
 [24 29]], shape=(3, 2), dtype=int32)
बैच में प्रत्येक उदाहरण में सभी स्थानों पर अंतिम सुविधा का चयन
चयनित अंतिम अक्ष के सूचकांक -4 में सभी मानों के साथ एक 3x2x5 टेंसर।चयनित मान 2-अक्ष टेंसर में पैक किए गए हैं।

यह जानने के लिए कि आप अपने टेंसर में अलग-अलग तत्वों में हेरफेर करने के लिए इंडेक्सिंग कैसे लागू कर सकते हैं, टेंसर स्लाइसिंग गाइड पढ़ें।

आकृतियों में हेरफेर

एक टेंसर को फिर से आकार देना बहुत उपयोगी है।

# Shape returns a `TensorShape` object that shows the size along each axis
x = tf.constant([[1], [2], [3]])
print(x.shape)
(3, 1)
# You can convert this object into a Python list, too
print(x.shape.as_list())
[3, 1]

आप एक टेंसर को एक नए आकार में बदल सकते हैं। tf.reshape ऑपरेशन तेज और सस्ता है क्योंकि अंतर्निहित डेटा को डुप्लिकेट करने की आवश्यकता नहीं है।

# You can reshape a tensor to a new shape.
# Note that you're passing in a list
reshaped = tf.reshape(x, [1, 3])
print(x.shape)
print(reshaped.shape)
(3, 1)
(1, 3)

डेटा मेमोरी में अपने लेआउट को बनाए रखता है और उसी डेटा की ओर इशारा करते हुए अनुरोधित आकार के साथ एक नया टेंसर बनाया जाता है। TensorFlow सी-स्टाइल "पंक्ति-प्रमुख" मेमोरी ऑर्डरिंग का उपयोग करता है, जहां सबसे दाहिने इंडेक्स को बढ़ाना मेमोरी में एक चरण से मेल खाता है।

print(rank_3_tensor)
tf.Tensor(
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]]

 [[10 11 12 13 14]
  [15 16 17 18 19]]

 [[20 21 22 23 24]
  [25 26 27 28 29]]], shape=(3, 2, 5), dtype=int32)

यदि आप एक टेंसर को समतल करते हैं, तो आप देख सकते हैं कि यह किस क्रम में मेमोरी में रखा गया है।

# A `-1` passed in the `shape` argument says "Whatever fits".
print(tf.reshape(rank_3_tensor, [-1]))
tf.Tensor(
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 24 25 26 27 28 29], shape=(30,), dtype=int32)

आम तौर पर tf.reshape का एकमात्र उचित उपयोग आसन्न अक्षों को जोड़ना या विभाजित करना है (या 1 एस जोड़ें/निकालें)।

इस 3x2x5 टेंसर के लिए, (3x2)x5 या 3x (2x5) को फिर से आकार देना दोनों ही उचित काम हैं, क्योंकि स्लाइस मिश्रित नहीं होते हैं:

print(tf.reshape(rank_3_tensor, [3*2, 5]), "\n")
print(tf.reshape(rank_3_tensor, [3, -1]))
tf.Tensor(
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]
 [25 26 27 28 29]], shape=(6, 5), dtype=int32) 

tf.Tensor(
[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]
 [20 21 22 23 24 25 26 27 28 29]], shape=(3, 10), dtype=int32)
कुछ अच्छे आकार।
एक 3x2x5 टेंसरवही डेटा (3x2)x5 . पर फिर से आकार दिया गयासमान डेटा को 3x(2x5) के रूप में फिर से आकार दिया गया

तत्वों की समान संख्या के साथ किसी भी नए आकार के लिए रीशेपिंग "काम" करेगा, लेकिन यदि आप कुल्हाड़ियों के क्रम का सम्मान नहीं करते हैं तो यह कुछ भी उपयोगी नहीं होगा।

tf.reshape में कुल्हाड़ियों की अदला-बदली काम नहीं करती है; इसके लिए आपको tf.transpose की जरूरत है।

# Bad examples: don't do this

# You can't reorder axes with reshape.
print(tf.reshape(rank_3_tensor, [2, 3, 5]), "\n") 

# This is a mess
print(tf.reshape(rank_3_tensor, [5, 6]), "\n")

# This doesn't work at all
try:
  tf.reshape(rank_3_tensor, [7, -1])
except Exception as e:
  print(f"{type(e).__name__}: {e}")
tf.Tensor(
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]
  [10 11 12 13 14]]

 [[15 16 17 18 19]
  [20 21 22 23 24]
  [25 26 27 28 29]]], shape=(2, 3, 5), dtype=int32) 

tf.Tensor(
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]
 [24 25 26 27 28 29]], shape=(5, 6), dtype=int32) 

InvalidArgumentError: Input to reshape is a tensor with 30 values, but the requested shape requires a multiple of 7 [Op:Reshape]
कुछ खराब आकार।
आप कुल्हाड़ियों को पुन: व्यवस्थित नहीं कर सकते, उसके लिए tf.transpose का उपयोग करेंकुछ भी जो डेटा के स्लाइस को एक साथ मिलाता है वह शायद गलत है।नया आकार बिल्कुल फिट होना चाहिए।

आप पूरी तरह से निर्दिष्ट आकृतियों में दौड़ सकते हैं। या तो आकृति में कोई None है (अक्ष-लंबाई अज्ञात है) या संपूर्ण आकार None है (टेंसर का रैंक अज्ञात है)।

tf.RaggedTensor को छोड़कर, ऐसी आकृतियाँ केवल TensorFlow के प्रतीकात्मक, ग्राफ़-बिल्डिंग API के संदर्भ में होंगी:

DTypes पर अधिक

tf.Tensor के डेटा प्रकार का निरीक्षण करने के लिए Tensor.dtype गुण का उपयोग करें।

पायथन ऑब्जेक्ट से tf.Tensor बनाते समय आप वैकल्पिक रूप से डेटाटाइप निर्दिष्ट कर सकते हैं।

यदि आप नहीं करते हैं, तो TensorFlow एक डेटाटाइप चुनता है जो आपके डेटा का प्रतिनिधित्व कर सकता है। TensorFlow पायथन पूर्णांकों को tf.int32 और पायथन फ्लोटिंग पॉइंट नंबरों को tf.float32 में परिवर्तित करता है। अन्यथा TensorFlow उन्हीं नियमों का उपयोग करता है जो NumPy सरणियों में कनवर्ट करते समय उपयोग करता है।

आप टाइप से टाइप में कास्ट कर सकते हैं।

the_f64_tensor = tf.constant([2.2, 3.3, 4.4], dtype=tf.float64)
the_f16_tensor = tf.cast(the_f64_tensor, dtype=tf.float16)
# Now, cast to an uint8 and lose the decimal precision
the_u8_tensor = tf.cast(the_f16_tensor, dtype=tf.uint8)
print(the_u8_tensor)
tf.Tensor([2 3 4], shape=(3,), dtype=uint8)

प्रसारण

प्रसारण एक अवधारणा है जो NumPy में समकक्ष सुविधा से उधार ली गई है। संक्षेप में, कुछ शर्तों के तहत, छोटे टेंसर स्वचालित रूप से बड़े टेंसर फिट करने के लिए "विस्तारित" होते हैं जब उन पर संयुक्त संचालन चलाते हैं।

सबसे सरल और सबसे आम मामला तब होता है जब आप एक स्केलर में एक टेंसर को गुणा करने या जोड़ने का प्रयास करते हैं। उस स्थिति में, स्केलर को अन्य तर्क के समान आकार में प्रसारित किया जाता है।

x = tf.constant([1, 2, 3])

y = tf.constant(2)
z = tf.constant([2, 2, 2])
# All of these are the same computation
print(tf.multiply(x, 2))
print(x * y)
print(x * z)
tf.Tensor([2 4 6], shape=(3,), dtype=int32)
tf.Tensor([2 4 6], shape=(3,), dtype=int32)
tf.Tensor([2 4 6], shape=(3,), dtype=int32)

इसी तरह, लंबाई 1 के साथ कुल्हाड़ियों को अन्य तर्कों से मेल खाने के लिए बढ़ाया जा सकता है। दोनों तर्कों को एक ही गणना में बढ़ाया जा सकता है।

इस मामले में एक 3x4 मैट्रिक्स का उत्पादन करने के लिए एक 3x1 मैट्रिक्स को 1x4 मैट्रिक्स द्वारा तत्व-वार गुणा किया जाता है। ध्यान दें कि अग्रणी 1 वैकल्पिक कैसे है: y का आकार [4] है।

# These are the same computations
x = tf.reshape(x,[3,1])
y = tf.range(1, 5)
print(x, "\n")
print(y, "\n")
print(tf.multiply(x, y))
tf.Tensor(
[[1]
 [2]
 [3]], shape=(3, 1), dtype=int32) 

tf.Tensor([1 2 3 4], shape=(4,), dtype=int32) 

tf.Tensor(
[[ 1  2  3  4]
 [ 2  4  6  8]
 [ 3  6  9 12]], shape=(3, 4), dtype=int32)
एक ब्रॉडकास्ट ऐड: एक [3, 1] गुना [1, 4] एक [3,4] देता है
4x1 मैट्रिक्स में 3x1 मैट्रिक्स जोड़ने से 3x4 मैट्रिक्स प्राप्त होता है

यहाँ प्रसारण के बिना एक ही ऑपरेशन है:

x_stretch = tf.constant([[1, 1, 1, 1],
                         [2, 2, 2, 2],
                         [3, 3, 3, 3]])

y_stretch = tf.constant([[1, 2, 3, 4],
                         [1, 2, 3, 4],
                         [1, 2, 3, 4]])

print(x_stretch * y_stretch)  # Again, operator overloading
tf.Tensor(
[[ 1  2  3  4]
 [ 2  4  6  8]
 [ 3  6  9 12]], shape=(3, 4), dtype=int32)

अधिकांश समय, प्रसारण समय और स्थान दोनों कुशल होता है, क्योंकि प्रसारण संचालन स्मृति में विस्तारित टेंसर को कभी भी अमल में नहीं लाता है।

आप देखते हैं कि tf.broadcast_to का उपयोग करके प्रसारण कैसा दिखता है।

print(tf.broadcast_to(tf.constant([1, 2, 3]), [3, 3]))
tf.Tensor(
[[1 2 3]
 [1 2 3]
 [1 2 3]], shape=(3, 3), dtype=int32)

गणितीय ऑप के विपरीत, उदाहरण के लिए, broadcast_to स्मृति को बचाने के लिए कुछ खास नहीं करता है। यहां, आप टेंसर को अमल में ला रहे हैं।

यह और भी जटिल हो सकता है। जेक वेंडरप्लास की पुस्तक पायथन डेटा साइंस हैंडबुक का यह खंड अधिक प्रसारण तरकीबें दिखाता है (फिर से NumPy में)।

tf.convert_to_tensor

अधिकांश ऑप्स, जैसे tf.matmul और tf.reshape वर्ग tf.Tensor के तर्क लेते हैं। हालाँकि, आप उपरोक्त मामले में देखेंगे, टेंसर के आकार की पायथन वस्तुएं स्वीकार की जाती हैं।

अधिकांश, लेकिन सभी नहीं, ops गैर-टेंसर तर्कों पर convert_to_tensor को कॉल करते हैं। रूपांतरणों की एक रजिस्ट्री है, और अधिकांश वस्तु वर्ग जैसे NumPy's ndarray , TensorShape , Python सूचियाँ, और tf.Variable सभी स्वचालित रूप से परिवर्तित हो जाएंगे।

अधिक विवरण के लिए tf.register_tensor_conversion_function देखें, और यदि आपका अपना प्रकार है तो आप स्वचालित रूप से एक टेंसर में कनवर्ट करना चाहेंगे।

रैग्ड टेंसर

कुछ अक्ष के साथ तत्वों की चर संख्या वाले एक टेंसर को "रैग्ड" कहा जाता है। रैग्ड डेटा के लिए tf.ragged.RaggedTensor का उपयोग करें।

उदाहरण के लिए, इसे नियमित टेंसर के रूप में प्रदर्शित नहीं किया जा सकता है:

एक tf.RaggedTensor , आकार: [4, None]
एक 2-अक्ष रैग्ड टेंसर, प्रत्येक पंक्ति की एक अलग लंबाई हो सकती है।
ragged_list = [
    [0, 1, 2, 3],
    [4, 5],
    [6, 7, 8],
    [9]]
try:
  tensor = tf.constant(ragged_list)
except Exception as e:
  print(f"{type(e).__name__}: {e}")
ValueError: Can't convert non-rectangular Python sequence to Tensor.

इसके बजाय tf.ragged.constant का उपयोग करके एक tf.RaggedTensor tf.ragged.constant :

ragged_tensor = tf.ragged.constant(ragged_list)
print(ragged_tensor)
<tf.RaggedTensor [[0, 1, 2, 3], [4, 5], [6, 7, 8], [9]]>

tf.RaggedTensor के आकार में अज्ञात लंबाई वाली कुछ कुल्हाड़ियाँ होंगी:

print(ragged_tensor.shape)
(4, None)

स्ट्रिंग टेंसर

tf.string एक dtype है, जिसका अर्थ है कि आप टेंसर में डेटा को स्ट्रिंग्स (वेरिएबल-लेंथ बाइट एरेज़) के रूप में प्रस्तुत कर सकते हैं।

तार परमाणु हैं और जिस तरह से पायथन के तार हैं, उन्हें अनुक्रमित नहीं किया जा सकता है। स्ट्रिंग की लंबाई टेंसर की कुल्हाड़ियों में से एक नहीं है। कार्यों में हेरफेर करने के लिए tf.strings देखें।

यहाँ एक अदिश स्ट्रिंग टेंसर है:

# Tensors can be strings, too here is a scalar string.
scalar_string_tensor = tf.constant("Gray wolf")
print(scalar_string_tensor)
tf.Tensor(b'Gray wolf', shape=(), dtype=string)

और तार का एक वेक्टर:

स्ट्रिंग्स का एक वेक्टर, आकार: [3,]
स्ट्रिंग की लंबाई टेंसर की कुल्हाड़ियों में से एक नहीं है।
# If you have three string tensors of different lengths, this is OK.
tensor_of_strings = tf.constant(["Gray wolf",
                                 "Quick brown fox",
                                 "Lazy dog"])
# Note that the shape is (3,). The string length is not included.
print(tensor_of_strings)
tf.Tensor([b'Gray wolf' b'Quick brown fox' b'Lazy dog'], shape=(3,), dtype=string)

उपरोक्त प्रिंटआउट में b उपसर्ग इंगित करता है कि tf.string dtype एक यूनिकोड स्ट्रिंग नहीं है, बल्कि एक बाइट-स्ट्रिंग है। TensorFlow में यूनिकोड टेक्स्ट के साथ काम करने के बारे में अधिक जानकारी के लिए यूनिकोड ट्यूटोरियल देखें।

यदि आप यूनिकोड वर्ण पास करते हैं तो वे utf-8 एन्कोडेड हैं।

tf.constant("🥳👍")
<tf.Tensor: shape=(), dtype=string, numpy=b'\xf0\x9f\xa5\xb3\xf0\x9f\x91\x8d'>

स्ट्रिंग्स के साथ कुछ बुनियादी कार्य tf.strings में पाए जा सकते हैं, जिनमें tf.strings.split शामिल हैं।

# You can use split to split a string into a set of tensors
print(tf.strings.split(scalar_string_tensor, sep=" "))
tf.Tensor([b'Gray' b'wolf'], shape=(2,), dtype=string)
# ...but it turns into a `RaggedTensor` if you split up a tensor of strings,
# as each string might be split into a different number of parts.
print(tf.strings.split(tensor_of_strings))
<tf.RaggedTensor [[b'Gray', b'wolf'], [b'Quick', b'brown', b'fox'], [b'Lazy', b'dog']]>
तीन तार विभाजित, आकार: [3, None]
एकाधिक स्ट्रिंग्स को विभाजित करने से एक tf.RaggedTensor लौटाता है

और tf.string.to_number :

text = tf.constant("1 10 100")
print(tf.strings.to_number(tf.strings.split(text, " ")))
tf.Tensor([  1.  10. 100.], shape=(3,), dtype=float32)

यद्यपि आप स्ट्रिंग टेंसर को संख्याओं में बदलने के लिए tf.cast का उपयोग नहीं कर सकते हैं, आप इसे बाइट्स में और फिर संख्याओं में परिवर्तित कर सकते हैं।

byte_strings = tf.strings.bytes_split(tf.constant("Duck"))
byte_ints = tf.io.decode_raw(tf.constant("Duck"), tf.uint8)
print("Byte strings:", byte_strings)
print("Bytes:", byte_ints)
Byte strings: tf.Tensor([b'D' b'u' b'c' b'k'], shape=(4,), dtype=string)
Bytes: tf.Tensor([ 68 117  99 107], shape=(4,), dtype=uint8)
# Or split it up as unicode and then decode it
unicode_bytes = tf.constant("アヒル 🦆")
unicode_char_bytes = tf.strings.unicode_split(unicode_bytes, "UTF-8")
unicode_values = tf.strings.unicode_decode(unicode_bytes, "UTF-8")

print("\nUnicode bytes:", unicode_bytes)
print("\nUnicode chars:", unicode_char_bytes)
print("\nUnicode values:", unicode_values)
Unicode bytes: tf.Tensor(b'\xe3\x82\xa2\xe3\x83\x92\xe3\x83\xab \xf0\x9f\xa6\x86', shape=(), dtype=string)

Unicode chars: tf.Tensor([b'\xe3\x82\xa2' b'\xe3\x83\x92' b'\xe3\x83\xab' b' ' b'\xf0\x9f\xa6\x86'], shape=(5,), dtype=string)

Unicode values: tf.Tensor([ 12450  12498  12523     32 129414], shape=(5,), dtype=int32)

TensorFlow में सभी कच्चे बाइट्स डेटा के लिए tf.string dtype का उपयोग किया जाता है। tf.io मॉड्यूल में डेटा को बाइट से और में कनवर्ट करने के लिए फ़ंक्शन शामिल हैं, जिसमें छवियों को डिकोड करना और सीएसवी को पार्स करना शामिल है।

विरल टेंसर

कभी-कभी, आपका डेटा विरल होता है, जैसे कि बहुत विस्तृत एम्बेडिंग स्थान। TensorFlow विरल डेटा को कुशलतापूर्वक संग्रहीत करने के लिए tf.sparse.SparseTensor और संबंधित संचालन का समर्थन करता है।

एक tf.SparseTensor , आकार: [3, 4]
एक 3x4 ग्रिड, जिसमें केवल दो कक्षों में मान हैं।
# Sparse tensors store values by index in a memory-efficient manner
sparse_tensor = tf.sparse.SparseTensor(indices=[[0, 0], [1, 2]],
                                       values=[1, 2],
                                       dense_shape=[3, 4])
print(sparse_tensor, "\n")

# You can convert sparse tensors to dense
print(tf.sparse.to_dense(sparse_tensor))
SparseTensor(indices=tf.Tensor(
[[0 0]
 [1 2]], shape=(2, 2), dtype=int64), values=tf.Tensor([1 2], shape=(2,), dtype=int32), dense_shape=tf.Tensor([3 4], shape=(2,), dtype=int64)) 

tf.Tensor(
[[1 0 0 0]
 [0 0 2 0]
 [0 0 0 0]], shape=(3, 4), dtype=int32)