चर का परिचय

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

एक TensorFlow चर सिफारिश की जिस तरह से साझा प्रतिनिधित्व करने के लिए, लगातार राज्य अपने कार्यक्रम manipulates है। यह इसमें यह सब अद्यतन बनाने के लिए, और के उदाहरण का प्रबंधन tf.Variable TensorFlow में।

चर बनाया है और के माध्यम से पता लगाया जाता है 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 । Tensors की तरह, वे एक है 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.]

जीवनचक्र, नामकरण, और देखना

अजगर आधारित 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 निर्माण में गलत पर। एक चर का एक उदाहरण जिसे ग्रेडिएंट की आवश्यकता नहीं होगी, एक प्रशिक्षण चरण काउंटर है।

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

चर और टेंसर रखना

बेहतर प्रदर्शन के लिए TensorFlow सबसे तेजी से अपने साथ संगत डिवाइस पर जगह tensors और चर करने का प्रयास करेंगे dtype । इसका मतलब है कि यदि कोई उपलब्ध है तो अधिकांश चर 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)

वितरित प्रशिक्षण के बारे में अधिक के लिए, देखें हमारे मार्गदर्शक

अगला कदम

समझने के लिए कैसे चर आम तौर पर उपयोग किया जाता है, पर हमारे मार्गदर्शिका देखें स्वचालित भेदभाव