יש שאלה? התחבר לקהילה בפורום הביקור של TensorFlow

מבוא לטנזורים

צפה ב- TensorFlow.org הפעל בגוגל קולאב צפה במקור ב- GitHub הורד מחברת
import tensorflow as tf
import numpy as np

טנזורים הם מערכים רב מימדיים עם סוג אחיד (המכונה dtype ). תוכל לראות את כל dtypes הנתמכים בכתובתtf.dtypes.DType .

אם אתה מכיר את NumPy , טנזורים הם (סוג) כמו np.arrays . 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]
סקלר, המספר 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]

באפשרותך להמיר טנסור למערך np.array באמצעות 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 מחייבת טנזורים להיות "מלבניים" - כלומר, לאורך כל ציר, כל אלמנט בגודל זהה. עם זאת, ישנם סוגים מיוחדים של טנזורים שיכולים להתמודד עם צורות שונות:

אתה יכול לעשות מתמטיקה בסיסית על טנזורים, כולל חיבור, כפל אלמנטים ומכפל מטריצה.

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.
  • ציר או ממד : מימד מסוים של טנסור.
  • גודל : המספר הכולל של הפריטים בטנסור, וקטור צורת המוצר.

לאובייקטים 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

בעוד שמדדים שלהם מכונים לעתים קרובות גרזנים, עליכם תמיד לעקוב אחר המשמעות של כל אחד מהם. לעתים קרובות צירים מסודרים מגלובלי למקומי: ציר האצווה תחילה, ואחריו ממדים מרחביים ותכונות עבור כל מיקום אחרון. בדרך זו וקטורי תכונות הם אזורים רצופים של זיכרון.

סדר ציר אופייני
עקוב אחר מהו כל ציר. טנסור בעל 4 צירים עשוי להיות: אצווה, רוחב, גובה, תכונות

אינדקס

אינדקס ציר יחיד

TensorFlow עוקב אחר כללי אינדקס סטנדרטיים של Python, בדומה לאינדקס רשימה או מחרוזת ב- Python , ואת הכללים הבסיסיים לאינדקס 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

אינדקס עם a : slice שומר על הציר:

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 של הציר האחרון שנבחר.הערכים שנבחרו ארוזים בטנזור דו-צירי.

קרא את המדריך לחיתוך טנסור כדי ללמוד כיצד ניתן ליישם אינדקס כדי לתפעל אלמנטים בודדים בטנזורים שלך.

מניפולציה של צורות

עיצוב מחדש של טנסור מועיל מאוד.

# 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 משתמש בסדר זיכרון "שורה-מז'ור" בסגנון 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אותם נתונים עוצבו מחדש פי 3 (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 (AN-אורך ציר אינו ידוע) או את הצורה כל הוא None (בדרגת לטנזור אינו ידוע).

למעט tf.RaggedTensor , צורות כאלה יתרחשו רק בהקשר של ממשקי ה- API הסמליים של TensorFlow:

עוד על DTypes

כדי לבדוק חלון tf.Tensor שימוש בסוג הנתונים "sTensor.dtype רכוש.

בעת יצירת tf.Tensor מאובייקט Python, באפשרותך לציין את סוג הנתונים.

אם לא, 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 כך שיתאימו לטיעונים האחרים. ניתן למתוח את שני הטיעונים באותה חישוב.

במקרה זה מטריצה ​​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 לא עושה שום דבר מיוחד כדי לחסוך בזיכרון. הנה אתה מממש את הטנזור.

זה יכול להסתבך עוד יותר. חלק זה בספר Python Data Science Handbook של ג'ייק ונדר פלאס מציג עוד טריקים של שידור (שוב ב- NumPy).

tf.convert_to_tensor

רוב tf.matmul , כמו tf.matmul ו- tf.reshape לוקחות טיעונים של tf.Tensor בכיתה. עם זאת, תבחין במקרה הנ"ל, מקובלים אובייקטים של פייתון בצורת טנזורים.

רוב convert_to_tensor , אך לא כולן, קוראות ל- convert_to_tensor שאינם טנזורים. יש רישום של המרות, ורוב מחלקות האובייקט כמו ndarray של ndarray , TensorShape , רשימות פיתון ו- 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.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 אינו מחרוזת unicode, אלא מחרוזת בתים. עיין במדריך 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 כדי להפוך 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 tf.string משמש לכל נתוני הבתים הגולמיים ב- TensorFlow. המודול tf.io מכיל פונקציות להמרת נתונים לבתים וממנה, כולל פענוח תמונות וניתוח CSV.

טנזורים דלילים

לפעמים הנתונים שלך דלילים, כמו שטח הטבעה רחב מאוד. 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)