معرفی تنسورها

مشاهده در TensorFlow.org در Google Colab اجرا کنید مشاهده منبع در GitHub دانلود دفترچه یادداشت
import tensorflow as tf
import numpy as np

سنسورها آرایه های چند بعدی با نوع یکنواخت هستند ( dtype نامیده می dtype ). شما می توانید تمام پشتیبانی را ببینید dtypes درtf.dtypes.DType .

اگر با NumPy آشنا باشید ، np.arrays (به نوعی) مانند np.arrays .

همه سنسورها مانند اعداد و رشته های پایتون تغییرناپذیر هستند: شما هرگز نمی توانید محتوای تنسور را به روز کنید ، فقط یک مورد جدید ایجاد کنید.

اصول

بیایید چند حسگر اساسی ایجاد کنیم.

در اینجا یک تانسور "scalar" یا "rank-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]
اسکالر ، عدد 4خط با 3 بخش ، هر بخش حاوی یک عدد است.یک شبکه 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]

شما می توانید یک تنسور را به یک آرایه NumPy یا با استفاده از np.array یا روش tensor.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 پایه نیاز به "مستطیل شکل" 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)

سنسورها در انواع عملیات (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 است.
  • محور یا بعد : بعد خاصی از یک سنسور.
  • Size : تعداد کل موارد موجود در تنسور ، بردار شکل محصول.

اجسام تنسور و 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 شروع می شوند
  • شاخص های منفی از انتها معکوس می شوند
  • از colon ، : ، برای برش استفاده می شود: 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)
انتخاب آخرین ویژگی در تمام مکان ها در هر مثال در دسته
یک سنسور 3x2x5 با تمام مقادیر موجود در شاخص -4 آخرین محور انتخاب شده.مقادیر انتخاب شده در یک سنسور 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 از ترتیب حافظه "row-major" به سبک C استفاده می کند ، جایی که افزایش درست ترین شاخص مربوط به یک مرحله از حافظه است.

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 ، چنین اشکالی فقط در متن API های نمادین و نمودارساز TensorFlow وجود دارد :

اطلاعات بیشتر در مورد DTypes

برای کنترل tf.Tensor نوع داده استفاده 'ثانیهTensor.dtype اموال.

هنگام ایجاد tf.Tensor از یک شی پایتون ، می توانید نوع داده را به صورت اختیاری تعیین کنید.

اگر این کار را نکنید ، TensorFlow نوع داده ای را انتخاب می کند که می تواند داده های شما را نشان دهد. tf.int32 اعداد صحیح پایتون را به 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 را می توان برای مطابقت با سایر استدلال ها کشید. هر دو آرگومان می توانند در یک محاسبه یکسان باشند.

در این حالت ماتریس 3x1 ​​از نظر عناصر در ماتریس 1x4 ضرب می شود تا ماتریس 3x4 تولید می شود. توجه داشته باشید که چطور عدد 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)
یک افزودنی پخش شده: a [3, 1] برابر a [1, 4] یک [3,4]
افزودن ماتریس 3x1 ​​به ماتریس 4x1 منجر به ماتریس 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 کند ویژه هیچ چیز به صرفه جویی در حافظه. در اینجا ، شما در حال تحقق بخشیدن به تانسور هستید.

حتی می تواند پیچیده تر شود. این بخش از کتاب Jake VanderPlas کتاب Python Data Science Handbook ترفندهای پخش بیشتری را نشان می دهد (دوباره در NumPy).

tf.convert_to_tensor

بیشتر op ها مانند tf.matmul و tf.reshape آرگومان های کلاس tf.Tensor . با این حال ، در حالت فوق متوجه خواهید شد که اشیا Py پایتون که مانند سنسور هستند پذیرفته می شوند.

اکثر ، اما نه همه ، گزینه ها با استدلال های غیر تنش دهنده ، convert_to_tensor فراخوانی می کنند. است رجیستری از تبدیل، و بسیاری از کلاس های شی مانند نامپای وجود دارد ndarray ، TensorShape ، لیست Python و tf.Variable تمام خواهد شد تبدیل به صورت خودکار.

برای جزئیات بیشتر به tf.register_tensor_conversion_function مراجعه کنید ، و اگر نوع خود را دارید می خواهید به طور خودکار به تنسور تبدیل شوید.

Ragged Tensors

به یک تنسور با تعداد متغیر عناصر در امتداد برخی محورها "ragged" گفته می شود. برای داده های tf.ragged.RaggedTensor از tf.ragged.RaggedTensor استفاده کنید.

به عنوان مثال ، این را نمی توان به عنوان یک تانسور معمولی نشان داد:

یکtf.RaggedTensor ، شکل: [4, None]
یک تانسور دو محوره ، هر ردیف می تواند طول متفاوتی داشته باشد.
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 ، به این معنی که می توانید داده ها را به صورت رشته (آرایه های بایت با طول متغیر) در سنسورها نشان دهید.

رشته ها اتمی هستند و نمی توانند مانند رشته های Python نمایه شوند. طول رشته یکی از محورهای تنسور نیست. برای دستکاری در توابع ، به 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 یک رشته یونی کد نیست ، بلکه یک رشته بایت است. برای کسب اطلاعات بیشتر در مورد کار با متن unicode در TensorFlow ، به آموزش Unicode مراجعه کنید.

اگر از نویسه های یونیکد عبور کنید ، آنها 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)

tf.string dtype برای تمام داده های بایت خام در TensorFlow استفاده می شود. ماژول tf.io شامل توابعی برای تبدیل داده ها به بایت و از جمله رمزگشایی تصاویر و تجزیه csv است.

سنسورهای پراکنده

بعضی اوقات ، مانند فضای جاسازی بسیار گسترده ، داده های شما پراکنده است. tf.sparse.SparseTensor از 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)