מבוא למשתנים

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

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

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

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

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

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

# 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 כדי שווא על יצירה. דוגמה למשתנה שלא יזדקק למדרגות הוא מונה שלבי אימון.

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

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

לקבלת ביצועים טובים יותר, TensorFlow ינסה tensors במקום ומשתנה במכשיר המהיר התואם שלה 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)

למידע נוסף על אימון מופץ, לראות את המדריך שלנו .

הצעדים הבאים

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