चर का परिचय

TensorFlow.org पर देखें

Google Colab में चलाएं

GitHub पर स्रोत देखें

नोटबुक डाउनलोड करें

एक TensorFlow चर साझा, लगातार स्थिति का प्रतिनिधित्व करने के लिए अनुशंसित तरीका है जो आपके प्रोग्राम में हेरफेर करता है। इस गाइड में tf.Variable में 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: 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 अपने 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)

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

अगले कदम

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