সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

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

TensorFlow.org এ দেখুন GitHub-এ উৎস দেখুন নোটবুক ডাউনলোড করুন

একজন TensorFlow পরিবর্তনশীল প্রস্তাবিত উপায় ভাগ প্রতিনিধিত্ব করার ক্রমাগত রাষ্ট্র আপনার প্রোগ্রাম নিপূণভাবে ব্যবহার করেন হয়। এই নির্দেশিকাটি কভার কিভাবে আপডেট তৈরি করতে, এবং দৃষ্টান্ত পরিচালনা 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)

উপরে উল্লিখিত হিসাবে, ভেরিয়েবলগুলি টেনসর দ্বারা সমর্থিত। ব্যবহার করে আপনি টেন্সর reassign করতে 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)

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

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

বুঝতে ভেরিয়েবল সাধারণত ব্যবহার করা হয়, যে পথ দেখতে স্বয়ংক্রিয় বিভেদ