מבוא למשתנים

צפה ב- 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 שיחות אינה 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: Cannot assign to variable Variable:0 due to variable shape (2,) and value shape (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)

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

הצעדים הבאים

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