ভেরিয়েবলের ভূমিকা

সেভ করা পৃষ্ঠা গুছিয়ে রাখতে 'সংগ্রহ' ব্যবহার করুন আপনার পছন্দ অনুযায়ী কন্টেন্ট সেভ করুন ও সঠিক বিভাগে রাখুন।

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.]

জীবনচক্র, নামকরণ এবং দেখা

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 তার 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)

বিতরণ করা প্রশিক্ষণ সম্পর্কে আরও জানতে, আমাদের গাইড দেখুন।

পরবর্তী পদক্ষেপ

কীভাবে ভেরিয়েবলগুলি সাধারণত ব্যবহার করা হয় তা বোঝার জন্য, স্বয়ংক্রিয় পার্থক্য সম্পর্কে আমাদের নির্দেশিকা দেখুন।