এমএল কমিউনিটি দিবস 9 নভেম্বর! TensorFlow, Jax থেকে আপডেটের জন্য আমাদের সাথে যোগ দিন, এবং আরও আরও জানুন

আগ্রহী মৃত্যুদণ্ড কার্যকর

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

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

আগ্রহী বাস্তবায়ন গবেষণা এবং পরীক্ষার জন্য একটি নমনীয় মেশিন লার্নিং প্ল্যাটফর্ম, যা প্রদান করে:

  • আপনার কোড -Structure একটি স্বজ্ঞামূলক ইন্টারফেস স্বাভাবিকভাবেই এবং পাইথন ডাটা স্ট্রাকচার ব্যবহার করুন। ছোট মডেল এবং ছোট ডেটাতে দ্রুত পুনরাবৃত্তি করুন।
  • আরো সহজ ডাকো অপস ডিবাগ সরাসরি চলমান মডেল এবং পরীক্ষা পরিবর্তন পরিদর্শন করা। অবিলম্বে ত্রুটি রিপোর্টিংয়ের জন্য আদর্শ পাইথন ডিবাগিং সরঞ্জামগুলি ব্যবহার করুন।
  • প্রাকৃতিক নিয়ন্ত্রণ -Use পাইথন নিয়ন্ত্রণ প্রবাহ প্রবাহিত পরিবর্তে গ্রাফ নিয়ন্ত্রণ প্রবাহ, ডায়নামিক মডেলের স্পেসিফিকেশন সরল।

আগ্রহী এক্সিকিউশন অধিকাংশ TensorFlow অপারেশন এবং GPU ত্বরণ সমর্থন করে।

সেটআপ এবং মৌলিক ব্যবহার

import os

import tensorflow as tf

import cProfile

টেন্সরফ্লো 2.0 তে, আগ্রহী এক্সিকিউশন ডিফল্টরূপে সক্ষম করা হয়।

tf.executing_eagerly()
True

এখন আপনি TensorFlow অপারেশন চালাতে পারেন এবং ফলাফল অবিলম্বে ফিরে আসবে:

x = [[2.]]
m = tf.matmul(x, x)
print("hello, {}".format(m))
hello, [[4.]]

টেনসারফ্লো অপারেশনগুলি কীভাবে আচরণ করে তা আগ্রহীভাবে কার্যকর করতে সক্ষম করে - এখন তারা অবিলম্বে মূল্যায়ন করে এবং তাদের মানগুলি পাইথনে ফিরিয়ে দেয়। tf.Tensor একটি গণনীয় গ্রাফে নোড প্রতি সিম্বলিক হ্যান্ডলগুলি পরিবর্তে রেফারেন্স কংক্রিট মান অবজেক্ট। যেহেতু বিল্ড করার জন্য একটি গণনীয় গ্রাফ এবং পরে একটি সেশনে চালানো নয়, এটা সহজ ব্যবহার ফলাফল পরিদর্শন করার print() বা ডিবাগার। মূল্যায়ন, মুদ্রণ, এবং টেন্সর মান পরীক্ষা করা গ্রেডিয়েন্ট গণনার জন্য প্রবাহ ভেঙ্গে না।

উৎসুক সঞ্চালনের সঙ্গে চমত্কারভাবে কাজ করে NumPy । NumPy অপারেশন গ্রহণ tf.Tensor আর্গুমেন্ট। TensorFlow tf.math করার অপারেশন পাইথন বস্তু এবং NumPy অ্যারে রূপান্তর tf.Tensor অবজেক্ট। tf.Tensor.numpy পদ্ধতি NumPy যেমন বস্তুর মান ndarray

a = tf.constant([[1, 2],
                 [3, 4]])
print(a)
tf.Tensor(
[[1 2]
 [3 4]], shape=(2, 2), dtype=int32)
# Broadcasting support
b = tf.add(a, 1)
print(b)
tf.Tensor(
[[2 3]
 [4 5]], shape=(2, 2), dtype=int32)
# Operator overloading is supported
print(a * b)
tf.Tensor(
[[ 2  6]
 [12 20]], shape=(2, 2), dtype=int32)
# Use NumPy values
import numpy as np

c = np.multiply(a, b)
print(c)
[[ 2  6]
 [12 20]]
# Obtain numpy value from a tensor:
print(a.numpy())
# => [[1 2]
#     [3 4]]
[[1 2]
 [3 4]]

গতিশীল নিয়ন্ত্রণ প্রবাহ

আগ্রহী এক্সিকিউশনের একটি বড় সুবিধা হল যে আপনার মডেল এক্সিকিউট করার সময় হোস্ট ভাষার সমস্ত কার্যকারিতা পাওয়া যায়। সুতরাং, উদাহরণস্বরূপ, এটি লেখার সহজ fizzbuzz :

def fizzbuzz(max_num):
  counter = tf.constant(0)
  max_num = tf.convert_to_tensor(max_num)
  for num in range(1, max_num.numpy()+1):
    num = tf.constant(num)
    if int(num % 3) == 0 and int(num % 5) == 0:
      print('FizzBuzz')
    elif int(num % 3) == 0:
      print('Fizz')
    elif int(num % 5) == 0:
      print('Buzz')
    else:
      print(num.numpy())
    counter += 1
fizzbuzz(15)
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

এটির শর্ত রয়েছে যা টেন্সর মানগুলির উপর নির্ভর করে এবং এটি রানটাইমের সময় এই মানগুলি মুদ্রণ করে।

আগ্রহী প্রশিক্ষণ

কম্পিউটিং গ্রেডিয়েন্টস

স্বয়ংক্রিয় বিভেদ যেমন মেশিন লার্নিং আলগোরিদিম বাস্তবায়ন জন্য দরকারী backpropagation স্নায়ুর নেটওয়ার্ক প্রশিক্ষণ জন্য। উৎসুক সম্পাদনের সময়, ব্যবহার tf.GradientTape কম্পিউটিং গ্রেডিয়েন্ট পরবর্তী সময়ের জন্য অপারেশন ট্রেস।

আপনি ব্যবহার করতে পারেন tf.GradientTape উৎসুক এবং / বা কম্পিউট গ্রেডিয়েন্ট প্রশিক্ষণের। এটি বিশেষ করে জটিল প্রশিক্ষণ লুপগুলির জন্য দরকারী।

যেহেতু প্রতিটি কলের সময় বিভিন্ন অপারেশন ঘটতে পারে, তাই সমস্ত ফরওয়ার্ড-পাস অপারেশন "টেপ" এ রেকর্ড করা হয়। গ্রেডিয়েন্ট গণনা করতে, টেপটি পিছনের দিকে প্লে করুন এবং তারপর ফেলে দিন। একটি বিশেষ tf.GradientTape শুধুমাত্র একটি গ্রেডিয়েন্ট গনা করতে পারেন; পরবর্তী কলগুলি রানটাইম ত্রুটি ফেলে দেয়।

w = tf.Variable([[1.0]])
with tf.GradientTape() as tape:
  loss = w * w

grad = tape.gradient(loss, w)
print(grad)  # => tf.Tensor([[ 2.]], shape=(1, 1), dtype=float32)
tf.Tensor([[2.]], shape=(1, 1), dtype=float32)

একটি মডেল প্রশিক্ষণ

নিম্নলিখিত উদাহরণটি একটি মাল্টি-লেয়ার মডেল তৈরি করে যা স্ট্যান্ডার্ড MNIST হাতে লেখা অঙ্কগুলিকে শ্রেণীবদ্ধ করে। এটি একটি আগ্রহী এক্সিকিউশন পরিবেশে প্রশিক্ষণযোগ্য গ্রাফ তৈরির জন্য অপ্টিমাইজার এবং লেয়ার API গুলি প্রদর্শন করে।

# Fetch and format the mnist data
(mnist_images, mnist_labels), _ = tf.keras.datasets.mnist.load_data()

dataset = tf.data.Dataset.from_tensor_slices(
  (tf.cast(mnist_images[...,tf.newaxis]/255, tf.float32),
   tf.cast(mnist_labels,tf.int64)))
dataset = dataset.shuffle(1000).batch(32)
# Build the model
mnist_model = tf.keras.Sequential([
  tf.keras.layers.Conv2D(16,[3,3], activation='relu',
                         input_shape=(None, None, 1)),
  tf.keras.layers.Conv2D(16,[3,3], activation='relu'),
  tf.keras.layers.GlobalAveragePooling2D(),
  tf.keras.layers.Dense(10)
])

এমনকি প্রশিক্ষণ ছাড়াই, মডেলকে কল করুন এবং উত্সাহিত সম্পাদনে আউটপুট পরিদর্শন করুন:

for images,labels in dataset.take(1):
  print("Logits: ", mnist_model(images[0:1]).numpy())
Logits:  [[-0.01775933 -0.01194787 -0.08372174 -0.06535977  0.00338565 -0.01974326
  -0.04763228  0.00904049 -0.00144051 -0.01944664]]

যদিও keras মডেলের একটি builtin প্রশিক্ষণ লুপ (ব্যবহার আছে fit পদ্ধতি), কখনও কখনও আপনি আরো স্বনির্ধারণ প্রয়োজন। আগ্রহের সাথে বাস্তবায়িত একটি প্রশিক্ষণ লুপের একটি উদাহরণ এখানে দেওয়া হল:

optimizer = tf.keras.optimizers.Adam()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

loss_history = []
def train_step(images, labels):
  with tf.GradientTape() as tape:
    logits = mnist_model(images, training=True)

    # Add asserts to check the shape of the output.
    tf.debugging.assert_equal(logits.shape, (32, 10))

    loss_value = loss_object(labels, logits)

  loss_history.append(loss_value.numpy().mean())
  grads = tape.gradient(loss_value, mnist_model.trainable_variables)
  optimizer.apply_gradients(zip(grads, mnist_model.trainable_variables))
def train(epochs):
  for epoch in range(epochs):
    for (batch, (images, labels)) in enumerate(dataset):
      train_step(images, labels)
    print ('Epoch {} finished'.format(epoch))
train(epochs = 3)
Epoch 0 finished
Epoch 1 finished
Epoch 2 finished
import matplotlib.pyplot as plt

plt.plot(loss_history)
plt.xlabel('Batch #')
plt.ylabel('Loss [entropy]')
Text(0, 0.5, 'Loss [entropy]')

png

ভেরিয়েবল এবং অপটিমাইজার

tf.Variable বস্তু চপল সংরক্ষণ tf.Tensor স্বয়ংক্রিয় বিভেদ সহজ করতে প্রশিক্ষণের সময় অ্যাক্সেস মান -একটি।

ভেরিয়েবলের সংগ্রহগুলি স্তর বা মডেলগুলিতে আবদ্ধ করা যেতে পারে, তাদের সাথে পরিচালিত পদ্ধতিগুলির সাথে। দেখুন কাস্টম Keras স্তর এবং মডেল বিস্তারিত জানার জন্য। স্তর এবং মডেল মধ্যে মূল পার্থক্য হল যে মডেলের মত পদ্ধতি যোগ Model.fit , Model.evaluate এবং Model.save

উদাহরণস্বরূপ, উপরের স্বয়ংক্রিয় পার্থক্য উদাহরণ পুনরায় লেখা যেতে পারে:

class Linear(tf.keras.Model):
  def __init__(self):
    super(Linear, self).__init__()
    self.W = tf.Variable(5., name='weight')
    self.B = tf.Variable(10., name='bias')
  def call(self, inputs):
    return inputs * self.W + self.B
# A toy dataset of points around 3 * x + 2
NUM_EXAMPLES = 2000
training_inputs = tf.random.normal([NUM_EXAMPLES])
noise = tf.random.normal([NUM_EXAMPLES])
training_outputs = training_inputs * 3 + 2 + noise

# The loss function to be optimized
def loss(model, inputs, targets):
  error = model(inputs) - targets
  return tf.reduce_mean(tf.square(error))

def grad(model, inputs, targets):
  with tf.GradientTape() as tape:
    loss_value = loss(model, inputs, targets)
  return tape.gradient(loss_value, [model.W, model.B])

পরবর্তী:

  1. মডেল তৈরি করুন।
  2. মডেল প্যারামিটারের ক্ষেত্রে লস ফাংশনের ডেরিভেটিভস।
  3. ডেরিভেটিভের উপর ভিত্তি করে ভেরিয়েবল আপডেট করার কৌশল।
model = Linear()
optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)

print("Initial loss: {:.3f}".format(loss(model, training_inputs, training_outputs)))

steps = 300
for i in range(steps):
  grads = grad(model, training_inputs, training_outputs)
  optimizer.apply_gradients(zip(grads, [model.W, model.B]))
  if i % 20 == 0:
    print("Loss at step {:03d}: {:.3f}".format(i, loss(model, training_inputs, training_outputs)))
Initial loss: 69.909
Loss at step 000: 67.145
Loss at step 020: 30.170
Loss at step 040: 13.859
Loss at step 060: 6.659
Loss at step 080: 3.479
Loss at step 100: 2.074
Loss at step 120: 1.453
Loss at step 140: 1.178
Loss at step 160: 1.056
Loss at step 180: 1.003
Loss at step 200: 0.979
Loss at step 220: 0.968
Loss at step 240: 0.963
Loss at step 260: 0.961
Loss at step 280: 0.960
print("Final loss: {:.3f}".format(loss(model, training_inputs, training_outputs)))
Final loss: 0.960
print("W = {}, B = {}".format(model.W.numpy(), model.B.numpy()))
W = 2.9515867233276367, B = 2.0210201740264893

বস্তু ভিত্তিক সঞ্চয়

একজন tf.keras.Model একটি সুবিধাজনক অন্তর্ভুক্ত save_weights পদ্ধতি আপনি সহজেই চেকপয়েন্ট তৈরি করতে সক্ষম হবেন:

model.save_weights('weights')
status = model.load_weights('weights')

ব্যবহার tf.train.Checkpoint আপনি এই প্রক্রিয়াটি উপর পূর্ণ নিয়ন্ত্রণ নিতে পারে।

এই বিভাগে একজন সংক্ষিপ্ত সংস্করণ প্রশিক্ষণ চেকপয়েন্ট গাইড

x = tf.Variable(10.)
checkpoint = tf.train.Checkpoint(x=x)
x.assign(2.)   # Assign a new value to the variables and save.
checkpoint_path = './ckpt/'
checkpoint.save(checkpoint_path)
'./ckpt/-1'
x.assign(11.)  # Change the variable after saving.

# Restore values from the checkpoint
checkpoint.restore(tf.train.latest_checkpoint(checkpoint_path))

print(x)  # => 2.0
<tf.Variable 'Variable:0' shape=() dtype=float32, numpy=2.0>

সংরক্ষণ করুন এবং লোড মডেল, করতে tf.train.Checkpoint , বস্তু অভ্যন্তরীণ স্থিতি সঞ্চয় করে গোপন ভেরিয়েবল প্রয়োজন ছাড়া। একটি রাজ্যের রেকর্ড করার model , একটি optimizer , এবং একটি বিশ্বব্যাপী পদক্ষেপ, তাদের একটি পাস tf.train.Checkpoint :

model = tf.keras.Sequential([
  tf.keras.layers.Conv2D(16,[3,3], activation='relu'),
  tf.keras.layers.GlobalAveragePooling2D(),
  tf.keras.layers.Dense(10)
])
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
checkpoint_dir = 'path/to/model_dir'
if not os.path.exists(checkpoint_dir):
  os.makedirs(checkpoint_dir)
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")
root = tf.train.Checkpoint(optimizer=optimizer,
                           model=model)

root.save(checkpoint_prefix)
root.restore(tf.train.latest_checkpoint(checkpoint_dir))
<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f4ba0648310>

বস্তু ভিত্তিক মেট্রিক্স

tf.keras.metrics বস্তু হিসেবে সংরক্ষণ করা হয়। Callable নতুন ডাটা ক্ষণস্থায়ী দ্বারা একটি মেট্রিক আপডেট করে এবং ব্যবহার ফলাফলের উদ্ধার tf.keras.metrics.result পদ্ধতি, উদাহরণস্বরূপ:

m = tf.keras.metrics.Mean("loss")
m(0)
m(5)
m.result()  # => 2.5
m([8, 9])
m.result()  # => 5.5
<tf.Tensor: shape=(), dtype=float32, numpy=5.5>

সংক্ষিপ্তসার এবং TensorBoard

TensorBoard বোঝার ডিবাগ এবং মডেল ট্রেনিং প্রক্রিয়াটির নিখুঁত জন্য ঠাহর হাতিয়ার। এটি প্রোগ্রামটি চালানোর সময় সংক্ষিপ্ত ঘটনাগুলি ব্যবহার করে।

আপনি ব্যবহার করতে পারেন tf.summary উৎসুক সম্পাদনের পরিবর্তনশীল রেকর্ড সারাংশ করতে। উদাহরণস্বরূপ, সারাংশ রেকর্ড করতে loss প্রতি 100 প্রশিক্ষণ পদক্ষেপ একবার:

logdir = "./tb/"
writer = tf.summary.create_file_writer(logdir)

steps = 1000
with writer.as_default():  # or call writer.set_as_default() before the loop.
  for i in range(steps):
    step = i + 1
    # Calculate loss with your real train function.
    loss = 1 - 0.001 * step
    if step % 100 == 0:
      tf.summary.scalar('loss', loss, step=step)
ls tb/
events.out.tfevents.1632342765.kokoro-gcp-ubuntu-prod-230753280.22287.0.v2

উন্নত স্বয়ংক্রিয় পার্থক্য বিষয়

গতিশীল মডেল

tf.GradientTape এছাড়াও গতিশীল মডেল ব্যবহার করা যাবে। একটি এই উদাহরণ backtracking না লাইন অনুসন্ধান স্বাভাবিক NumPy কোডের মত অ্যালগরিদম সৌন্দর্য ছাড়া সেখানে গ্রেডিয়েন্ট এবং differentiable হয়, জটিল নিয়ন্ত্রণ প্রবাহ সত্ত্বেও:

def line_search_step(fn, init_x, rate=1.0):
  with tf.GradientTape() as tape:
    # Variables are automatically tracked.
    # But to calculate a gradient from a tensor, you must `watch` it.
    tape.watch(init_x)
    value = fn(init_x)
  grad = tape.gradient(value, init_x)
  grad_norm = tf.reduce_sum(grad * grad)
  init_value = value
  while value > init_value - rate * grad_norm:
    x = init_x - rate * grad
    value = fn(x)
    rate /= 2.0
  return x, value

কাস্টম গ্রেডিয়েন্টস

কাস্টম গ্রেডিয়েন্টগুলি গ্রেডিয়েন্টগুলি ওভাররাইড করার একটি সহজ উপায়। ফরওয়ার্ড ফাংশনের মধ্যে, ইনপুট, আউটপুট বা মধ্যবর্তী ফলাফলের ক্ষেত্রে গ্রেডিয়েন্ট সংজ্ঞায়িত করুন। উদাহরণস্বরূপ, পিছনের পাসে গ্রেডিয়েন্টের আদর্শটি ক্লিপ করার একটি সহজ উপায়:

@tf.custom_gradient
def clip_gradient_by_norm(x, norm):
  y = tf.identity(x)
  def grad_fn(dresult):
    return [tf.clip_by_norm(dresult, norm), None]
  return y, grad_fn

কাস্টম গ্রেডিয়েন্টগুলি সাধারণত ক্রিয়াকলাপের ক্রমের জন্য একটি সংখ্যাসূচক স্থিতিশীল গ্রেডিয়েন্ট সরবরাহ করতে ব্যবহৃত হয়:

def log1pexp(x):
  return tf.math.log(1 + tf.exp(x))

def grad_log1pexp(x):
  with tf.GradientTape() as tape:
    tape.watch(x)
    value = log1pexp(x)
  return tape.gradient(value, x)
# The gradient computation works fine at x = 0.
grad_log1pexp(tf.constant(0.)).numpy()
0.5
# However, x = 100 fails because of numerical instability.
grad_log1pexp(tf.constant(100.)).numpy()
nan

এখানে, log1pexp ফাংশন বিশ্লেষণী একটি কাস্টম গ্রেডিয়েন্ট সঙ্গে সরলীকৃত করা যেতে পারে। পুনঃব্যবহৃত হয়নি নিচে বাস্তবায়নের মান tf.exp(x) যে এগিয়ে সময় নির্ণয় করা হয় এটি আরও দক্ষ পাস তৈরির অপ্রয়োজনীয় গণনার নির্মূল করে:

@tf.custom_gradient
def log1pexp(x):
  e = tf.exp(x)
  def grad(dy):
    return dy * (1 - 1 / (1 + e))
  return tf.math.log(1 + e), grad

def grad_log1pexp(x):
  with tf.GradientTape() as tape:
    tape.watch(x)
    value = log1pexp(x)
  return tape.gradient(value, x)
# As before, the gradient computation works fine at x = 0.
grad_log1pexp(tf.constant(0.)).numpy()
0.5
# And the gradient computation also works at x = 100.
grad_log1pexp(tf.constant(100.)).numpy()
1.0

কর্মক্ষমতা

আগ্রহী এক্সিকিউশনের সময় কম্পিউটেশন স্বয়ংক্রিয়ভাবে GPU গুলিতে অফলোড হয়। তোমাদের উপর নিয়ন্ত্রণ যেখানে একটি গণনার রান আপনি একটি এটা ঘিরা করতে পারেন tf.device('/gpu:0') ব্লক (অথবা CPU- র সমতুল্য):

import time

def measure(x, steps):
  # TensorFlow initializes a GPU the first time it's used, exclude from timing.
  tf.matmul(x, x)
  start = time.time()
  for i in range(steps):
    x = tf.matmul(x, x)
  # tf.matmul can return before completing the matrix multiplication
  # (e.g., can return after enqueing the operation on a CUDA stream).
  # The x.numpy() call below will ensure that all enqueued operations
  # have completed (and will also copy the result to host memory,
  # so we're including a little more than just the matmul operation
  # time).
  _ = x.numpy()
  end = time.time()
  return end - start

shape = (1000, 1000)
steps = 200
print("Time to multiply a {} matrix by itself {} times:".format(shape, steps))

# Run on CPU:
with tf.device("/cpu:0"):
  print("CPU: {} secs".format(measure(tf.random.normal(shape), steps)))

# Run on GPU, if available:
if tf.config.list_physical_devices("GPU"):
  with tf.device("/gpu:0"):
    print("GPU: {} secs".format(measure(tf.random.normal(shape), steps)))
else:
  print("GPU: not found")
Time to multiply a (1000, 1000) matrix by itself 200 times:
CPU: 1.007401466369629 secs
GPU: 0.04124784469604492 secs

একজন tf.Tensor বস্তুর তার অপারেশন চালানো একটি আলাদা ডিভাইস কপি করা যেতে পারে:

if tf.config.list_physical_devices("GPU"):
  x = tf.random.normal([10, 10])

  x_gpu0 = x.gpu()
  x_cpu = x.cpu()

  _ = tf.matmul(x_cpu, x_cpu)    # Runs on CPU
  _ = tf.matmul(x_gpu0, x_gpu0)  # Runs on GPU:0
WARNING:tensorflow:From /tmp/ipykernel_22287/406964202.py:4: _EagerTensorBase.gpu (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use tf.identity instead.
WARNING:tensorflow:From /tmp/ipykernel_22287/406964202.py:5: _EagerTensorBase.cpu (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use tf.identity instead.

বেঞ্চমার্ক

যেমন কম্পিউট ভারী মডেল, জন্য ResNet50 একটি GPU এর মাধ্যমে প্রশিক্ষণ, উৎসুক সঞ্চালনের কর্মক্ষমতা সাথে তুলনা করা যায় tf.function মৃত্যুদন্ড। কিন্তু কম গণনার মডেলগুলির জন্য এই ফাঁকটি আরও বড় হয় এবং প্রচুর ছোট অপারেশন সহ মডেলগুলির জন্য হট কোড পাথ অপ্টিমাইজ করার জন্য কাজ করা হয়।

ফাংশন নিয়ে কাজ করুন

আগ্রহী বাস্তবায়ন উন্নয়ন এবং ডিবাগিংকে আরও ইন্টারেক্টিভ করে তোলে, TensorFlow 1.x স্টাইল গ্রাফ এক্সিকিউশনের বিতরণ প্রশিক্ষণ, পারফরম্যান্স অপটিমাইজেশন এবং উৎপাদন স্থাপনার সুবিধা রয়েছে। এই ফাঁক সেতু বলে, TensorFlow 2.0 প্রবর্তন function মাধ্যমে গুলি tf.function API- টি। আরো তথ্যের জন্য, দেখুন tf.function গাইড।