तिथि को रक्षित करें! Google I / O 18-20 मई को पंजीकृत करता है
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

टेन्सर्स का परिचय

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

dtype एक समान प्रकार (जिसे 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 सरणी में या तो np.array या tensor.numpy विधि का उपयोग करके np.array सकते हैं:

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 वर्ग के लिए 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)

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

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 रैंक है।
  • एक्सिस या आयाम : एक टेंसर का एक विशेष आयाम।
  • आकार : टेंसर में उत्पाद की कुल संख्या, उत्पाद आकार वेक्टर।

tf.TensorShape और 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

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

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

इंडेक्सिंग

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

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

  • अनुक्रमित 0 से शुरू होते हैं
  • नकारात्मक सूचकांक अंत से पीछे की ओर गिने जाते हैं
  • colons, : , स्लाइस के लिए उपयोग किया जाता है: 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

अनुक्रमण के साथ : टुकड़ा अक्ष रखता है:

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])
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) में बदल दिया गया

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

tf.reshape में कुल्हाड़ियों को tf.reshape काम नहीं करता है; tf.transpose लिए आपको 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 Python पूर्णांकों को tf.int32 और Python के फ्लोटिंग पॉइंट नंबरों को 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)

प्रसारण

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

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

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 मैट्रिक्स का उत्पादन करने के लिए एक 1x4 मैट्रिक्स द्वारा 3x1 मैट्रिक्स तत्व-वार गुणा किया जाता है। ध्यान दें कि अग्रणी 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] देता है
3x4 मैट्रिक्स में 4x1 मैट्रिक्स के परिणाम में 3x1 मैट्रिक्स जोड़ना

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

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 मेमोरी को बचाने के लिए कुछ खास नहीं करता है। यहाँ, आप टेंसर को भौतिक कर रहे हैं।

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

tf.convert_to_tensor

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

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

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

टेढ़ा टेढ़ा

कुछ अक्ष के साथ तत्वों की चर संख्याओं के साथ एक टेंसर को "रैग्ड" कहा जाता है। tf.ragged.RaggedTensor डेटा के लिए 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.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.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))
00bea53400
तीन तार विभाजित, आकार: [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)

tf.string dtype का उपयोग TensorFlow के सभी कच्चे बाइट्स डेटा के लिए किया जाता है। 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)