לשמור את התאריך! קלט / פלט של Google חוזר 18-20 במאי הירשם עכשיו
דף זה תורגם על ידי Cloud Translation API.
Switch to English

מבוא למשתנים

צפה ב- TensorFlow.org הפעל בגוגל קולאב צפה במקור ב- GitHub הורד מחברת

משתנה TensorFlow הוא הדרך המומלצת לייצג מצב משותף ומתמשך שהתוכנה שלך מפעילה. מדריך זה מכסה כיצד ליצור, לעדכן ולנהל מקרים של tf.Variable ב- TensorFlow.

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

להכין

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

import tensorflow as tf

# Uncomment to see where your variables get placed (see below)
# tf.debugging.set_log_device_placement(True)

צור משתנה

כדי ליצור משתנה, ספק ערך התחלתי. ל- tf.Variable יהיה אותו סוג dtype כמו ערך האתחול.

my_tensor = tf.constant([[1.0, 2.0], [3.0, 4.0]])
my_variable = tf.Variable(my_tensor)

# Variables can be all kinds of types, just like tensors
bool_variable = tf.Variable([False, False, False, True])
complex_variable = tf.Variable([5 + 4j, 6 + 1j])

משתנה נראה ופועל כמו טנסור, ולמעשה, הוא מבנה נתונים המגובה על ידי tf.Tensor . כמו טנזורים, יש להם סוג dtype וצורה, וניתן לייצא אותם ל- NumPy.

print("Shape: ", my_variable.shape)
print("DType: ", my_variable.dtype)
print("As NumPy: ", my_variable.numpy())
Shape:  (2, 2)
DType:  <dtype: 'float32'>
As NumPy:  [[1. 2.]
 [3. 4.]]

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

print("A variable:", my_variable)
print("\nViewed as a tensor:", tf.convert_to_tensor(my_variable))
print("\nIndex of highest value:", tf.argmax(my_variable))

# This creates a new tensor; it does not reshape the variable.
print("\nCopying and reshaping: ", tf.reshape(my_variable, ([1,4])))
A variable: <tf.Variable 'Variable:0' shape=(2, 2) dtype=float32, numpy=
array([[1., 2.],
       [3., 4.]], dtype=float32)>

Viewed as a tensor: tf.Tensor(
[[1. 2.]
 [3. 4.]], shape=(2, 2), dtype=float32)

Index of highest value: tf.Tensor([1 1], shape=(2,), dtype=int64)

Copying and reshaping:  tf.Tensor([[1. 2. 3. 4.]], shape=(1, 4), dtype=float32)

כפי שצוין לעיל, המשתנים מגובים על ידי טנזורים. אתה יכול להקצות מחדש את הטנסור באמצעות tf.Variable.assign . משימת שיחות אינה assign (בדרך כלל) טנסור חדש; במקום זאת, נעשה שימוש חוזר בזיכרון הטנסור הקיים.

a = tf.Variable([2.0, 3.0])
# This will keep the same dtype, float32
a.assign([1, 2]) 
# Not allowed as it resizes the variable: 
try:
  a.assign([1.0, 2.0, 3.0])
except Exception as e:
  print(f"{type(e).__name__}: {e}")
ValueError: Shapes (2,) and (3,) are incompatible

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

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

a = tf.Variable([2.0, 3.0])
# Create b based on the value of a
b = tf.Variable(a)
a.assign([5, 6])

# a and b are different
print(a.numpy())
print(b.numpy())

# There are other versions of assign
print(a.assign_add([2,3]).numpy())  # [7. 9.]
print(a.assign_sub([7,9]).numpy())  # [0. 0.]
[5. 6.]
[2. 3.]
[7. 9.]
[0. 0.]

מחזורי חיים, שמות וצפייה

ב- TensorFlow מבוסס פיתון, למופע tf.Variable יש מחזור חיים זהה לאובייקטים אחרים של פייתון. כשאין הפניות למשתנה הוא מועבר אוטומטית.

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

# Create a and b; they will have the same name but will be backed by
# different tensors.
a = tf.Variable(my_tensor, name="Mark")
# A new variable with the same name, but different value
# Note that the scalar add is broadcast
b = tf.Variable(my_tensor + 1, name="Mark")

# These are elementwise-unequal, despite having the same name
print(a == b)
tf.Tensor(
[[False False]
 [False False]], shape=(2, 2), dtype=bool)

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

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

step_counter = tf.Variable(1, trainable=False)

הצבת משתנים וטנזורים

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

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

אם אתה מריץ מחברת זו על גבי גב שונה עם ובלי GPU, תראה רישום שונה. שים לב כי יש להפעיל את מיקום מכשיר הרישום בתחילת ההפעלה.

with tf.device('CPU:0'):

  # Create some tensors
  a = tf.Variable([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
  b = tf.constant([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
  c = tf.matmul(a, b)

print(c)
tf.Tensor(
[[22. 28.]
 [49. 64.]], shape=(2, 2), dtype=float32)

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

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

with tf.device('CPU:0'):
  a = tf.Variable([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
  b = tf.Variable([[1.0, 2.0, 3.0]])

with tf.device('GPU:0'):
  # Element-wise multiply
  k = a * b

print(k)
tf.Tensor(
[[ 1.  4.  9.]
 [ 4. 10. 18.]], shape=(2, 3), dtype=float32)

למידע נוסף על הכשרה מבוזרת, עיין במדריך שלנו .

הצעדים הבאים

כדי להבין כיצד משתמשים במשתנים בדרך כלל, עיין במדריך שלנו לבידול אוטומטי .