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

টেন্সরের ভূমিকা

TensorFlow.org এ দেখুন Google Colab-এ চালান GitHub-এ উৎস দেখুন নোটবুক ডাউনলোড করুন
import tensorflow as tf
import numpy as np

টেনসর হল বহুমাত্রিক অ্যারে যার একটি ইউনিফর্ম টাইপ (যাকে dtype বলা হয়)। আপনি tf.dtypes.DType এ সমস্ত সমর্থিত dtypes দেখতে পারেন।

আপনি যদি NumPy এর সাথে পরিচিত হন তবে np.arrays এর মত (ধরনের) হয়।

সমস্ত টেনসর পাইথন নম্বর এবং স্ট্রিংয়ের মতো অপরিবর্তনীয়: আপনি কখনই একটি টেনসরের বিষয়বস্তু আপডেট করতে পারবেন না, শুধুমাত্র একটি নতুন তৈরি করুন।

বেসিক

আসুন কিছু মৌলিক টেনসর তৈরি করি।

এখানে একটি "স্কেলার" বা "র্যাঙ্ক-0" টেনসর রয়েছে। একটি স্কেলার একটি একক মান ধারণ করে, এবং "অক্ষ" নেই।

# This will be an int32 tensor by default; see "dtypes" below.
rank_0_tensor = tf.constant(4)
print(rank_0_tensor)
tf.Tensor(4, shape=(), dtype=int32)

একটি "ভেক্টর" বা "র্যাঙ্ক-1" টেনসর মানগুলির একটি তালিকার মতো। একটি ভেক্টর একটি অক্ষ আছে:

# Let's make this a float tensor.
rank_1_tensor = tf.constant([2.0, 3.0, 4.0])
print(rank_1_tensor)
tf.Tensor([2. 3. 4.], shape=(3,), dtype=float32)

একটি "ম্যাট্রিক্স" বা "র্যাঙ্ক-2" টেনসরের দুটি অক্ষ রয়েছে:

# If you want to be specific, you can set the dtype (see below) at creation time
rank_2_tensor = tf.constant([[1, 2],
                             [3, 4],
                             [5, 6]], dtype=tf.float16)
print(rank_2_tensor)
tf.Tensor(
[[1. 2.]
 [3. 4.]
 [5. 6.]], shape=(3, 2), dtype=float16)
একটি স্কেলার, আকৃতি: [] একটি ভেক্টর, আকৃতি: [3] একটি ম্যাট্রিক্স, আকৃতি: [3, 2]
একটি স্কেলার, সংখ্যা 43টি বিভাগ সহ লাইন, প্রতিটিতে একটি সংখ্যা রয়েছে।একটি 3x2 গ্রিড, প্রতিটি কক্ষে একটি সংখ্যা রয়েছে।

টেনসরের আরও অক্ষ থাকতে পারে; এখানে তিনটি অক্ষ সহ একটি টেনসর রয়েছে:

# There can be an arbitrary number of
# axes (sometimes called "dimensions")
rank_3_tensor = tf.constant([
  [[0, 1, 2, 3, 4],
   [5, 6, 7, 8, 9]],
  [[10, 11, 12, 13, 14],
   [15, 16, 17, 18, 19]],
  [[20, 21, 22, 23, 24],
   [25, 26, 27, 28, 29]],])

print(rank_3_tensor)
tf.Tensor(
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]]

 [[10 11 12 13 14]
  [15 16 17 18 19]]

 [[20 21 22 23 24]
  [25 26 27 28 29]]], shape=(3, 2, 5), dtype=int32)

দুইটির বেশি অক্ষ সহ একটি টেনসরকে আপনি কল্পনা করতে পারেন এমন অনেক উপায় রয়েছে।

একটি 3-অক্ষ টেনসর, আকৃতি: [3, 2, 5]

আপনি np.array বা tensor.numpy পদ্ধতি ব্যবহার করে একটি টেনসরকে একটি NumPy অ্যারেতে রূপান্তর করতে পারেন:

np.array(rank_2_tensor)
array([[1., 2.],
       [3., 4.],
       [5., 6.]], dtype=float16)
rank_2_tensor.numpy()
array([[1., 2.],
       [3., 4.],
       [5., 6.]], dtype=float16)

টেনসরগুলিতে প্রায়শই ফ্লোট এবং ইনট থাকে তবে অন্যান্য অনেক প্রকার রয়েছে, যার মধ্যে রয়েছে:

  • জটিল সংখ্যা
  • স্ট্রিং

বেস tf. টেনসর ক্লাসের জন্য tf.Tensor "আয়তক্ষেত্রাকার" হতে হবে---অর্থাৎ, প্রতিটি অক্ষ বরাবর, প্রতিটি উপাদান একই আকারের। যাইহোক, বিশেষ ধরণের টেনসর রয়েছে যা বিভিন্ন আকার পরিচালনা করতে পারে:

আপনি যোগ, উপাদান-ভিত্তিক গুণ এবং ম্যাট্রিক্স গুণন সহ টেনসরগুলিতে মৌলিক গণিত করতে পারেন।

a = tf.constant([[1, 2],
                 [3, 4]])
b = tf.constant([[1, 1],
                 [1, 1]]) # Could have also said `tf.ones([2,2])`

print(tf.add(a, b), "\n")
print(tf.multiply(a, b), "\n")
print(tf.matmul(a, b), "\n")
tf.Tensor(
[[2 3]
 [4 5]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[1 2]
 [3 4]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[3 3]
 [7 7]], shape=(2, 2), dtype=int32)
print(a + b, "\n") # element-wise addition
print(a * b, "\n") # element-wise multiplication
print(a @ b, "\n") # matrix multiplication
tf.Tensor(
[[2 3]
 [4 5]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[1 2]
 [3 4]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[3 3]
 [7 7]], shape=(2, 2), dtype=int32)

সমস্ত ধরণের অপারেশনে (অপস) টেনসর ব্যবহার করা হয়।

c = tf.constant([[4.0, 5.0], [10.0, 1.0]])

# Find the largest value
print(tf.reduce_max(c))
# Find the index of the largest value
print(tf.argmax(c))
# Compute the softmax
print(tf.nn.softmax(c))
tf.Tensor(10.0, shape=(), dtype=float32)
tf.Tensor([1 0], shape=(2,), dtype=int64)
tf.Tensor(
[[2.6894143e-01 7.3105854e-01]
 [9.9987662e-01 1.2339458e-04]], shape=(2, 2), dtype=float32)

আকার সম্পর্কে

টেনসরের আকার আছে। কিছু শব্দভান্ডার:

  • আকৃতি : একটি টেনসরের প্রতিটি অক্ষের দৈর্ঘ্য (উপাদানের সংখ্যা)।
  • র‌্যাঙ্ক : টেনসর অক্ষের সংখ্যা। একটি স্কেলারের র‍্যাঙ্ক 0, একটি ভেক্টরের র‍্যাঙ্ক 1, একটি ম্যাট্রিক্সের র‍্যাঙ্ক 2।
  • অক্ষ বা মাত্রা : একটি টেনসরের একটি নির্দিষ্ট মাত্রা।
  • আকার : টেনসরে আইটেমের মোট সংখ্যা, পণ্যের আকৃতি ভেক্টর।

Tensors এবং tf.TensorShape অবজেক্টের এইগুলি অ্যাক্সেস করার জন্য সুবিধাজনক বৈশিষ্ট্য রয়েছে:

rank_4_tensor = tf.zeros([3, 2, 4, 5])
একটি র্যাঙ্ক-4 টেনসর, আকৃতি: [3, 2, 4, 5]
একটি টেনসর আকৃতি একটি ভেক্টরের মত।একটি 4-অক্ষ টেনসর
print("Type of every element:", rank_4_tensor.dtype)
print("Number of axes:", rank_4_tensor.ndim)
print("Shape of tensor:", rank_4_tensor.shape)
print("Elements along axis 0 of tensor:", rank_4_tensor.shape[0])
print("Elements along the last axis of tensor:", rank_4_tensor.shape[-1])
print("Total number of elements (3*2*4*5): ", tf.size(rank_4_tensor).numpy())
Type of every element: <dtype: 'float32'>
Number of axes: 4
Shape of tensor: (3, 2, 4, 5)
Elements along axis 0 of tensor: 3
Elements along the last axis of tensor: 5
Total number of elements (3*2*4*5):  120

যদিও অক্ষগুলিকে প্রায়শই তাদের সূচক দ্বারা উল্লেখ করা হয়, আপনার সর্বদা প্রতিটির অর্থের উপর নজর রাখা উচিত। প্রায়শই অক্ষগুলি বিশ্ব থেকে স্থানীয় পর্যন্ত অর্ডার করা হয়: প্রথমে ব্যাচ অক্ষ, তারপরে স্থানিক মাত্রা এবং প্রতিটি অবস্থানের জন্য বৈশিষ্ট্যগুলি শেষ হয়৷ এইভাবে বৈশিষ্ট্য ভেক্টর মেমরির সংলগ্ন অঞ্চল।

সাধারণ অক্ষ ক্রম
প্রতিটি অক্ষ কি ট্র্যাক রাখুন. একটি 4-অক্ষ টেনসর হতে পারে: ব্যাচ, প্রস্থ, উচ্চতা, বৈশিষ্ট্য

ইনডেক্সিং

একক-অক্ষ সূচীকরণ

TensorFlow স্ট্যান্ডার্ড পাইথন ইন্ডেক্সিং নিয়ম অনুসরণ করে, পাইথনে একটি তালিকা বা একটি স্ট্রিং ইন্ডেক্স করার অনুরূপ, এবং NumPy ইন্ডেক্সিংয়ের প্রাথমিক নিয়ম।

  • সূচকগুলি 0 থেকে শুরু হয়
  • নেতিবাচক সূচকগুলি শেষ থেকে পিছনের দিকে গণনা করে
  • কোলন, : , স্লাইস এর জন্য ব্যবহৃত হয়: start:stop:step
rank_1_tensor = tf.constant([0, 1, 1, 2, 3, 5, 8, 13, 21, 34])
print(rank_1_tensor.numpy())
[ 0  1  1  2  3  5  8 13 21 34]

একটি স্কেলার দিয়ে সূচীকরণ অক্ষকে সরিয়ে দেয়:

print("First:", rank_1_tensor[0].numpy())
print("Second:", rank_1_tensor[1].numpy())
print("Last:", rank_1_tensor[-1].numpy())
First: 0
Second: 1
Last: 34

একটি : স্লাইস দিয়ে সূচীকরণ অক্ষটিকে রাখে:

print("Everything:", rank_1_tensor[:].numpy())
print("Before 4:", rank_1_tensor[:4].numpy())
print("From 4 to the end:", rank_1_tensor[4:].numpy())
print("From 2, before 7:", rank_1_tensor[2:7].numpy())
print("Every other item:", rank_1_tensor[::2].numpy())
print("Reversed:", rank_1_tensor[::-1].numpy())
Everything: [ 0  1  1  2  3  5  8 13 21 34]
Before 4: [0 1 1 2]
From 4 to the end: [ 3  5  8 13 21 34]
From 2, before 7: [1 2 3 5 8]
Every other item: [ 0  1  3  8 21]
Reversed: [34 21 13  8  5  3  2  1  1  0]

বহু-অক্ষ সূচীকরণ

উচ্চতর র্যাঙ্ক টেনসরগুলি একাধিক সূচক অতিক্রম করে সূচীকৃত হয়।

একক-অক্ষ ক্ষেত্রের মতো ঠিক একই নিয়ম প্রতিটি অক্ষে স্বাধীনভাবে প্রযোজ্য।

print(rank_2_tensor.numpy())
[[1. 2.]
 [3. 4.]
 [5. 6.]]

প্রতিটি সূচকের জন্য একটি পূর্ণসংখ্যা পাস করলে, ফলাফলটি একটি স্কেলার।

# Pull out a single value from a 2-rank tensor
print(rank_2_tensor[1, 1].numpy())
4.0

আপনি পূর্ণসংখ্যা এবং স্লাইসের যেকোনো সমন্বয় ব্যবহার করে সূচক করতে পারেন:

# Get row and column tensors
print("Second row:", rank_2_tensor[1, :].numpy())
print("Second column:", rank_2_tensor[:, 1].numpy())
print("Last row:", rank_2_tensor[-1, :].numpy())
print("First item in last column:", rank_2_tensor[0, -1].numpy())
print("Skip the first row:")
print(rank_2_tensor[1:, :].numpy(), "\n")
Second row: [3. 4.]
Second column: [2. 4. 6.]
Last row: [5. 6.]
First item in last column: 2.0
Skip the first row:
[[3. 4.]
 [5. 6.]]

এখানে একটি 3-অক্ষ টেনসর সহ একটি উদাহরণ রয়েছে:

print(rank_3_tensor[:, :, 4])
tf.Tensor(
[[ 4  9]
 [14 19]
 [24 29]], shape=(3, 2), dtype=int32)
ব্যাচের প্রতিটি উদাহরণে সমস্ত অবস্থান জুড়ে শেষ বৈশিষ্ট্যটি নির্বাচন করা
একটি 3x2x5 টেনসর যা শেষ অক্ষের সূচী-4-এ সমস্ত মান রয়েছে।নির্বাচিত মানগুলি একটি 2-অক্ষ টেনসরে প্যাক করা হয়েছে৷

আপনি কীভাবে আপনার টেনসরগুলিতে পৃথক উপাদানগুলিকে ম্যানিপুলেট করতে ইন্ডেক্সিং প্রয়োগ করতে পারেন তা শিখতে টেনসর স্লাইসিং গাইডটি পড়ুন।

আকৃতি ম্যানিপুলেট করা

একটি টেনসরের আকার পরিবর্তন করা দুর্দান্ত উপযোগী।

# Shape returns a `TensorShape` object that shows the size along each axis
x = tf.constant([[1], [2], [3]])
print(x.shape)
(3, 1)
# You can convert this object into a Python list, too
print(x.shape.as_list())
[3, 1]

আপনি একটি টেনসরকে একটি নতুন আকারে পুনরায় আকার দিতে পারেন। tf.reshape অপারেশনটি দ্রুত এবং সস্তা কারণ অন্তর্নিহিত ডেটা সদৃশ করার প্রয়োজন নেই৷

# You can reshape a tensor to a new shape.
# Note that you're passing in a list
reshaped = tf.reshape(x, [1, 3])
print(x.shape)
print(reshaped.shape)
(3, 1)
(1, 3)

ডেটা মেমরিতে তার বিন্যাস বজায় রাখে এবং একই ডেটার দিকে নির্দেশ করে অনুরোধকৃত আকৃতি সহ একটি নতুন টেনসর তৈরি করা হয়। টেনসরফ্লো সি-স্টাইলের "রো-মেজর" মেমরি অর্ডারিং ব্যবহার করে, যেখানে ডানদিকের সূচক বৃদ্ধি করা মেমরির একক ধাপের সাথে মিলে যায়।

print(rank_3_tensor)
tf.Tensor(
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]]

 [[10 11 12 13 14]
  [15 16 17 18 19]]

 [[20 21 22 23 24]
  [25 26 27 28 29]]], shape=(3, 2, 5), dtype=int32)

আপনি যদি একটি টেনসরকে সমতল করেন তবে আপনি দেখতে পাবেন যে এটি মেমরিতে কী ক্রম তৈরি করা হয়েছে।

# A `-1` passed in the `shape` argument says "Whatever fits".
print(tf.reshape(rank_3_tensor, [-1]))
tf.Tensor(
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 24 25 26 27 28 29], shape=(30,), dtype=int32)

সাধারণত tf.reshape এর একমাত্র যুক্তিসঙ্গত ব্যবহার হল সংলগ্ন অক্ষগুলিকে একত্রিত করা বা বিভক্ত করা (বা 1 s যোগ/সরানো)।

এই 3x2x5 টেনসরের জন্য, (3x2)x5 বা 3x(2x5) তে পুনরায় আকার দেওয়া উভয়ই যুক্তিসঙ্গত জিনিস, কারণ স্লাইসগুলি মিশ্রিত হয় না:

print(tf.reshape(rank_3_tensor, [3*2, 5]), "\n")
print(tf.reshape(rank_3_tensor, [3, -1]))
tf.Tensor(
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]
 [25 26 27 28 29]], shape=(6, 5), dtype=int32) 

tf.Tensor(
[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]
 [20 21 22 23 24 25 26 27 28 29]], shape=(3, 10), dtype=int32)
কিছু ভাল রুপান্তর.
একটি 3x2x5 টেনসরএকই ডেটা (3x2)x5 এ পুনরায় আকার দেওয়া হয়েছেএকই ডেটা 3x (2x5) এ পুনরায় আকার দেওয়া হয়েছে

একই মোট সংখ্যক উপাদানের সাথে যেকোন নতুন আকৃতির জন্য পুনর্নির্মাণ "কাজ করবে", কিন্তু আপনি অক্ষের ক্রমকে সম্মান না করলে এটি কার্যকর কিছু করবে না।

tf.reshape এ অক্ষ অদলবদল করা কাজ করে না; এর জন্য আপনার প্রয়োজন tf.transpose .

# Bad examples: don't do this

# You can't reorder axes with reshape.
print(tf.reshape(rank_3_tensor, [2, 3, 5]), "\n") 

# This is a mess
print(tf.reshape(rank_3_tensor, [5, 6]), "\n")

# This doesn't work at all
try:
  tf.reshape(rank_3_tensor, [7, -1])
except Exception as e:
  print(f"{type(e).__name__}: {e}")
tf.Tensor(
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]
  [10 11 12 13 14]]

 [[15 16 17 18 19]
  [20 21 22 23 24]
  [25 26 27 28 29]]], shape=(2, 3, 5), dtype=int32) 

tf.Tensor(
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]
 [24 25 26 27 28 29]], shape=(5, 6), dtype=int32) 

InvalidArgumentError: Input to reshape is a tensor with 30 values, but the requested shape requires a multiple of 7 [Op:Reshape]
কিছু খারাপ রুপান্তর।
আপনি অক্ষগুলিকে পুনরায় সাজাতে পারবেন না, এর জন্য tf.transpose ব্যবহার করুনডেটার স্লাইসগুলিকে একসাথে মিশ্রিত করে এমন কিছু সম্ভবত ভুল।নতুন আকৃতি ঠিক মাপসই করা আবশ্যক.

আপনি অ-পূর্ণ-নির্দিষ্ট আকার জুড়ে দৌড়াতে পারেন। হয় আকৃতিতে একটি None (একটি অক্ষ-দৈর্ঘ্য অজানা) বা পুরো আকৃতিটি None (টেনসরের র‌্যাঙ্ক অজানা)।

tf.RaggedTensor ব্যতীত, এই ধরনের আকারগুলি শুধুমাত্র TensorFlow-এর প্রতীকী, গ্রাফ-বিল্ডিং API-এর প্রসঙ্গে ঘটবে:

DTypes সম্পর্কে আরো

একটি tf.Tensor এর ডেটা টাইপ পরিদর্শন করতে Tensor.dtype প্রপার্টি ব্যবহার করুন।

পাইথন অবজেক্ট থেকে tf.Tensor তৈরি করার সময় আপনি ঐচ্ছিকভাবে ডেটাটাইপ নির্দিষ্ট করতে পারেন।

যদি আপনি না করেন, TensorFlow একটি ডেটাটাইপ বেছে নেয় যা আপনার ডেটা উপস্থাপন করতে পারে। TensorFlow পাইথন পূর্ণসংখ্যাকে tf.int32 এবং Python ফ্লোটিং পয়েন্ট সংখ্যাকে tf.float32 তে রূপান্তর করে। অন্যথায় TensorFlow একই নিয়ম ব্যবহার করে NumPy অ্যারেতে রূপান্তর করার সময় ব্যবহার করে।

আপনি টাইপ থেকে টাইপ কাস্ট করতে পারেন।

the_f64_tensor = tf.constant([2.2, 3.3, 4.4], dtype=tf.float64)
the_f16_tensor = tf.cast(the_f64_tensor, dtype=tf.float16)
# Now, cast to an uint8 and lose the decimal precision
the_u8_tensor = tf.cast(the_f16_tensor, dtype=tf.uint8)
print(the_u8_tensor)
tf.Tensor([2 3 4], shape=(3,), dtype=uint8)

সম্প্রচার

সম্প্রচার হল NumPy-এর সমতুল্য বৈশিষ্ট্য থেকে ধার করা একটি ধারণা। সংক্ষেপে, নির্দিষ্ট অবস্থার অধীনে, ছোট টেনসরগুলিকে সম্মিলিত ক্রিয়াকলাপ চালানোর সময় বড় টেনসরগুলির সাথে ফিট করার জন্য স্বয়ংক্রিয়ভাবে "প্রসারিত" হয়।

সবচেয়ে সহজ এবং সবচেয়ে সাধারণ ঘটনা হল যখন আপনি একটি স্কেলারে একটি টেনসর গুণ বা যোগ করার চেষ্টা করেন। সেক্ষেত্রে, স্কেলারটি অন্য আর্গুমেন্টের মতো একই আকারে সম্প্রচারিত হয়।

x = tf.constant([1, 2, 3])

y = tf.constant(2)
z = tf.constant([2, 2, 2])
# All of these are the same computation
print(tf.multiply(x, 2))
print(x * y)
print(x * z)
tf.Tensor([2 4 6], shape=(3,), dtype=int32)
tf.Tensor([2 4 6], shape=(3,), dtype=int32)
tf.Tensor([2 4 6], shape=(3,), dtype=int32)

একইভাবে, দৈর্ঘ্য 1 সহ অক্ষগুলি অন্যান্য আর্গুমেন্টের সাথে মেলানোর জন্য প্রসারিত করা যেতে পারে। উভয় আর্গুমেন্ট একই গণনা প্রসারিত করা যেতে পারে.

এই ক্ষেত্রে একটি 3x1 ম্যাট্রিক্সকে উপাদান-ভিত্তিক 1x4 ম্যাট্রিক্স দ্বারা গুণ করলে একটি 3x4 ম্যাট্রিক্স উৎপন্ন হয়। লক্ষ্য করুন কিভাবে অগ্রণী 1 ঐচ্ছিক: y এর আকৃতি হল [4]

# These are the same computations
x = tf.reshape(x,[3,1])
y = tf.range(1, 5)
print(x, "\n")
print(y, "\n")
print(tf.multiply(x, y))
tf.Tensor(
[[1]
 [2]
 [3]], shape=(3, 1), dtype=int32) 

tf.Tensor([1 2 3 4], shape=(4,), dtype=int32) 

tf.Tensor(
[[ 1  2  3  4]
 [ 2  4  6  8]
 [ 3  6  9 12]], shape=(3, 4), dtype=int32)
একটি সম্প্রচারিত যোগ: একটি [3, 1] বার একটি [1, 4] একটি [3,4] দেয়
একটি 4x1 ম্যাট্রিক্সে একটি 3x1 ম্যাট্রিক্স যোগ করলে একটি 3x4 ম্যাট্রিক্স হয়

এখানে সম্প্রচার ছাড়া একই অপারেশন আছে:

x_stretch = tf.constant([[1, 1, 1, 1],
                         [2, 2, 2, 2],
                         [3, 3, 3, 3]])

y_stretch = tf.constant([[1, 2, 3, 4],
                         [1, 2, 3, 4],
                         [1, 2, 3, 4]])

print(x_stretch * y_stretch)  # Again, operator overloading
tf.Tensor(
[[ 1  2  3  4]
 [ 2  4  6  8]
 [ 3  6  9 12]], shape=(3, 4), dtype=int32)

বেশিরভাগ সময়, সম্প্রচার সময় এবং স্থান উভয়ই দক্ষ, কারণ সম্প্রচার অপারেশন কখনই মেমরিতে প্রসারিত টেনসরকে বাস্তবায়িত করে না।

আপনি tf.broadcast_to ব্যবহার করে সম্প্রচার দেখতে কেমন তা দেখতে পাচ্ছেন।

print(tf.broadcast_to(tf.constant([1, 2, 3]), [3, 3]))
tf.Tensor(
[[1 2 3]
 [1 2 3]
 [1 2 3]], shape=(3, 3), dtype=int32)

একটি গাণিতিক অপের বিপরীতে, উদাহরণস্বরূপ, broadcast_to মেমরি সংরক্ষণ করতে বিশেষ কিছু করে না। এখানে, আপনি টেনসরকে বাস্তবায়িত করছেন।

এটি আরও জটিল হতে পারে। জেক ভ্যান্ডারপ্লাসের বই পাইথন ডেটা সায়েন্স হ্যান্ডবুকের এই বিভাগটি আরও সম্প্রচারের কৌশল দেখায় (আবার NumPy-এ)।

tf.convert_to_tensor

বেশিরভাগ অপ্স, যেমন tf.matmul এবং tf.reshape ক্লাস tf.Tensor এর আর্গুমেন্ট নেয়। যাইহোক, আপনি উপরের ক্ষেত্রে লক্ষ্য করবেন, টেনসরের মতো আকৃতির পাইথন বস্তুগুলি গ্রহণ করা হয়।

বেশিরভাগ, কিন্তু সব নয়, অপ্স নন-টেনসর আর্গুমেন্টে convert_to_tensor কল করে। রূপান্তরের একটি রেজিস্ট্রি আছে, এবং NumPy এর ndarray , TensorShape , Python তালিকা এবং tf.Variable . ভেরিয়েবলের মতো বেশিরভাগ অবজেক্ট ক্লাস স্বয়ংক্রিয়ভাবে রূপান্তরিত হবে।

আরও বিশদ বিবরণের জন্য tf.register_tensor_conversion_function দেখুন, এবং যদি আপনার নিজস্ব প্রকার থাকে তবে আপনি স্বয়ংক্রিয়ভাবে একটি টেনসরে রূপান্তর করতে চান।

রাগড টেনসর

কিছু অক্ষ বরাবর উপাদানের পরিবর্তনশীল সংখ্যা সহ একটি টেনসরকে "র্যাগড" বলা হয়। রাগ করা ডেটার জন্য tf.ragged.RaggedTensor ব্যবহার করুন।

উদাহরণস্বরূপ, এটি একটি নিয়মিত টেনসর হিসাবে উপস্থাপন করা যাবে না:

একটি tf.RaggedTensor , আকৃতি: [4, None]
একটি 2-অক্ষ রাগড টেনসর, প্রতিটি সারির একটি ভিন্ন দৈর্ঘ্য থাকতে পারে।
ragged_list = [
    [0, 1, 2, 3],
    [4, 5],
    [6, 7, 8],
    [9]]
try:
  tensor = tf.constant(ragged_list)
except Exception as e:
  print(f"{type(e).__name__}: {e}")
ValueError: Can't convert non-rectangular Python sequence to Tensor.

পরিবর্তে tf.RaggedTensor ব্যবহার করে একটি tf.ragged.constant তৈরি করুন:

ragged_tensor = tf.ragged.constant(ragged_list)
print(ragged_tensor)
<tf.RaggedTensor [[0, 1, 2, 3], [4, 5], [6, 7, 8], [9]]>

একটি tf.RaggedTensor এর আকারে অজানা দৈর্ঘ্য সহ কিছু অক্ষ থাকবে:

print(ragged_tensor.shape)
(4, None)

স্ট্রিং টেনসর

tf.string হল একটি dtype , যার অর্থ হল আপনি টেনসরগুলিতে স্ট্রিং (ভেরিয়েবল-লেন্থ বাইট অ্যারে) হিসাবে ডেটা উপস্থাপন করতে পারেন।

স্ট্রিংগুলি পারমাণবিক এবং পাইথন স্ট্রিংগুলির মতো সূচিবদ্ধ করা যায় না। স্ট্রিংয়ের দৈর্ঘ্য টেনসরের অক্ষগুলির মধ্যে একটি নয়। ফাংশন ম্যানিপুলেট করার জন্য tf.strings দেখুন।

এখানে একটি স্কেলার স্ট্রিং টেনসর রয়েছে:

# Tensors can be strings, too here is a scalar string.
scalar_string_tensor = tf.constant("Gray wolf")
print(scalar_string_tensor)
tf.Tensor(b'Gray wolf', shape=(), dtype=string)

এবং স্ট্রিংগুলির একটি ভেক্টর:

স্ট্রিংগুলির একটি ভেক্টর, আকৃতি: [3,]
স্ট্রিং দৈর্ঘ্য টেনসরের অক্ষগুলির মধ্যে একটি নয়।
# If you have three string tensors of different lengths, this is OK.
tensor_of_strings = tf.constant(["Gray wolf",
                                 "Quick brown fox",
                                 "Lazy dog"])
# Note that the shape is (3,). The string length is not included.
print(tensor_of_strings)
tf.Tensor([b'Gray wolf' b'Quick brown fox' b'Lazy dog'], shape=(3,), dtype=string)

উপরের প্রিন্টআউটে b উপসর্গটি নির্দেশ করে যে tf.string dtype একটি ইউনিকোড স্ট্রিং নয়, একটি বাইট-স্ট্রিং। TensorFlow-এ ইউনিকোড টেক্সট নিয়ে কাজ করার বিষয়ে আরও জানতে ইউনিকোড টিউটোরিয়াল দেখুন।

আপনি যদি ইউনিকোড অক্ষর পাস করেন তবে সেগুলি utf-8 এনকোড করা হয়।

tf.constant("🥳👍")
<tf.Tensor: shape=(), dtype=string, numpy=b'\xf0\x9f\xa5\xb3\xf0\x9f\x91\x8d'>

স্ট্রিং সহ কিছু বেসিক ফাংশন tf.strings.split এ পাওয়া যাবে, tf.strings সহ।

# You can use split to split a string into a set of tensors
print(tf.strings.split(scalar_string_tensor, sep=" "))
tf.Tensor([b'Gray' b'wolf'], shape=(2,), dtype=string)
# ...but it turns into a `RaggedTensor` if you split up a tensor of strings,
# as each string might be split into a different number of parts.
print(tf.strings.split(tensor_of_strings))
<tf.RaggedTensor [[b'Gray', b'wolf'], [b'Quick', b'brown', b'fox'], [b'Lazy', b'dog']]>
তিনটি স্ট্রিং বিভক্ত, আকৃতি: [3, None]
একাধিক স্ট্রিং বিভক্ত করা একটি tf.RaggedTensor প্রদান করে

এবং tf.string.to_number :

text = tf.constant("1 10 100")
print(tf.strings.to_number(tf.strings.split(text, " ")))
tf.Tensor([  1.  10. 100.], shape=(3,), dtype=float32)

যদিও আপনি একটি স্ট্রিং টেনসরকে সংখ্যায় পরিণত করতে tf.cast ব্যবহার করতে পারবেন না, আপনি এটিকে বাইটে এবং তারপর সংখ্যায় রূপান্তর করতে পারেন।

byte_strings = tf.strings.bytes_split(tf.constant("Duck"))
byte_ints = tf.io.decode_raw(tf.constant("Duck"), tf.uint8)
print("Byte strings:", byte_strings)
print("Bytes:", byte_ints)
Byte strings: tf.Tensor([b'D' b'u' b'c' b'k'], shape=(4,), dtype=string)
Bytes: tf.Tensor([ 68 117  99 107], shape=(4,), dtype=uint8)
# Or split it up as unicode and then decode it
unicode_bytes = tf.constant("アヒル 🦆")
unicode_char_bytes = tf.strings.unicode_split(unicode_bytes, "UTF-8")
unicode_values = tf.strings.unicode_decode(unicode_bytes, "UTF-8")

print("\nUnicode bytes:", unicode_bytes)
print("\nUnicode chars:", unicode_char_bytes)
print("\nUnicode values:", unicode_values)
Unicode bytes: tf.Tensor(b'\xe3\x82\xa2\xe3\x83\x92\xe3\x83\xab \xf0\x9f\xa6\x86', shape=(), dtype=string)

Unicode chars: tf.Tensor([b'\xe3\x82\xa2' b'\xe3\x83\x92' b'\xe3\x83\xab' b' ' b'\xf0\x9f\xa6\x86'], shape=(5,), dtype=string)

Unicode values: tf.Tensor([ 12450  12498  12523     32 129414], shape=(5,), dtype=int32)

tf.string dtype TensorFlow-এর সমস্ত কাঁচা বাইট ডেটার জন্য ব্যবহার করা হয়। tf.io মডিউলটিতে বাইটে এবং থেকে ডেটা রূপান্তর করার ফাংশন রয়েছে, যার মধ্যে রয়েছে ছবি ডিকোডিং এবং csv পার্স করা।

স্পার্স টেনসর

কখনও কখনও, আপনার ডেটা খুব বিস্তৃত এমবেডিং স্থানের মতো বিক্ষিপ্ত হয়। tf.sparse.SparseTensor এবং সংশ্লিষ্ট ক্রিয়াকলাপগুলিকে স্পার্স ডেটা দক্ষতার সাথে সংরক্ষণ করতে সমর্থন করে।

একটি tf.SparseTensor , আকৃতি: [3, 4]
একটি 3x4 গ্রিড, মাত্র দুটি কক্ষে মান সহ।
# Sparse tensors store values by index in a memory-efficient manner
sparse_tensor = tf.sparse.SparseTensor(indices=[[0, 0], [1, 2]],
                                       values=[1, 2],
                                       dense_shape=[3, 4])
print(sparse_tensor, "\n")

# You can convert sparse tensors to dense
print(tf.sparse.to_dense(sparse_tensor))
SparseTensor(indices=tf.Tensor(
[[0 0]
 [1 2]], shape=(2, 2), dtype=int64), values=tf.Tensor([1 2], shape=(2,), dtype=int32), dense_shape=tf.Tensor([3 4], shape=(2,), dtype=int64)) 

tf.Tensor(
[[1 0 0 0]
 [0 0 2 0]
 [0 0 0 0]], shape=(3, 4), dtype=int32)