তারিখটা মনে রেখো! গুগল I / O মে 18-20 মে এখনই রেজিস্টার করুন
This page was translated by the Cloud Translation API.
Switch to English

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

টেনসরফ্লো.আর.জে দেখুন গুগল কোলাবে চালান গিটহাবের উত্স দেখুন নোটবুক ডাউনলোড করুন

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

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

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

আগ্রহী সম্পাদন বেশিরভাগ টেনসরফ্লো অপারেশন এবং জিপিইউ ত্বরণকে সমর্থন করে।

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

import os

import tensorflow as tf

import cProfile

টেনসরফ্লো ২.০-তে, আগ্রহী সম্পাদন ডিফল্টরূপে সক্ষম হয়।

tf.executing_eagerly()
True

এখন আপনি টেনসরফ্লো অপারেশন পরিচালনা করতে পারেন এবং ফলাফলগুলি অবিলম্বে ফিরে আসবে:

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

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

আগ্রহী এক্সিকিউশন NumPy এর সাথে সুন্দরভাবে কাজ করে। NumPy অপারেশনগুলি tf.Tensor আর্গুমেন্ট গ্রহণ করে। tf.math ক্রিয়াকলাপ পাইথন অবজেক্ট এবং tf.Tensor অ্যারেগুলিকে tf.Tensor অবজেক্টে tf.Tensor করে। tf.Tensor.numpy পদ্ধতিটি NumPy ndarray হিসাবে বস্তুর মান 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]]

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

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

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

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

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

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

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

আপনিtf.GradientTape . গ্রেডিয়েন্ট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)

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

নিম্নলিখিত উদাহরণটি একটি বহু-স্তরীয় মডেল তৈরি করে যা মানক MNIS হস্তাক্ষর অঙ্কগুলি শ্রেণিবদ্ধ করে। এটি একটি উত্সাহ কার্যকর কার্যকর পরিবেশে প্রশিক্ষণযোগ্য গ্রাফ তৈরি করতে অপ্টিমাইজার এবং স্তর 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)
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
# 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.03667693 -0.03049762 -0.00575869 -0.03993434  0.08212403 -0.04499513
  -0.00077433  0.08982861  0.0706538  -0.02175808]]

কেরাস মডেলগুলির বিল্টিন ট্রেনিং লুপ রয়েছে ( 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]')

পিএনজি

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

tf.Variable . পরিবর্তনশীল tf.Tensor পরিবর্তনযোগ্য tf.Tensor . স্বয়ংক্রিয় পার্থক্যকে আরও সহজ করার জন্য প্রশিক্ষণের সময় অ্যাক্সেস করা tf.Tensor মতো মানগুলি।

ভেরিয়েবলের সংগ্রহগুলি সেগুলি চালিত পদ্ধতিগুলির পাশাপাশি স্তর বা মডেলগুলিতে আবদ্ধ হতে পারে। বিস্তারিত জানতে কাস্টম কেরাস স্তর এবং মডেলগুলি দেখুন। স্তর এবং মডেলগুলির মধ্যে প্রধান পার্থক্য হ'ল মডেলগুলি 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: 68.712
Loss at step 000: 66.034
Loss at step 020: 30.012
Loss at step 040: 13.941
Loss at step 060: 6.772
Loss at step 080: 3.573
Loss at step 100: 2.146
Loss at step 120: 1.509
Loss at step 140: 1.225
Loss at step 160: 1.098
Loss at step 180: 1.042
Loss at step 200: 1.016
Loss at step 220: 1.005
Loss at step 240: 1.000
Loss at step 260: 0.998
Loss at step 280: 0.997
print("Final loss: {:.3f}".format(loss(model, training_inputs, training_outputs)))
Final loss: 0.997
print("W = {}, B = {}".format(model.W.numpy(), model.B.numpy()))
W = 3.022096633911133, B = 2.0270628929138184

অবজেক্ট-ভিত্তিক সংরক্ষণ

একটি 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 লুকানো ভেরিয়েবলের প্রয়োজন ছাড়াই অবজেক্টগুলির অভ্যন্তরীণ tf.train.Checkpoint সঞ্চয় করে। কোনও model , একটি optimizer এবং একটি বিশ্বব্যাপী পদক্ষেপের tf.train.Checkpoint রেকর্ড করতে, তাদের একটি 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 0x7ff0c18b14e0>

অবজেক্ট-ওরিয়েন্টেড মেট্রিক্স

tf.keras.metrics অবজেক্ট হিসাবে সংরক্ষণ করা হয়। tf.keras.metrics.result নতুন ডেটা পাস করে একটি মেট্রিক আপডেট করুন, এবং 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>

সংক্ষিপ্তসার এবং টেনসরবোর্ড

মডেল প্রশিক্ষণ প্রক্রিয়াটি বোঝার, ডিবাগিং এবং অনুকূলকরণের জন্য টেনসরবোর্ড একটি ভিজ্যুয়ালাইজেশন সরঞ্জাম tool এটি প্রোগ্রামটি সম্পাদন করার সময় লিখিত কিছু সংক্ষিপ্ত ইভেন্টগুলি ব্যবহার করে।

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

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.1617758981.kokoro-gcp-ubuntu-prod-1009344920.4448.636510.v2

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

গতিশীল মডেল

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

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

এখানে, লগ 1 log1pexp ফাংশনটি একটি কাস্টম গ্রেডিয়েন্ট দিয়ে বিশ্লেষণাত্মকভাবে সরল করা যায়। নীচের বাস্তবায়নটি tf.exp(x) এর মানটিকে পুনঃব্যবহার করে যা ফরওয়ার্ড পাসের সময় গণনা করা হয় 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

কর্মক্ষমতা

আগ্রহী এক্সিকিউশন চলাকালীন গণনা স্বয়ংক্রিয়ভাবে জিপিইউতে লোড হয়। আপনি যদি কোনও গণনা চালান সেখানে নিয়ন্ত্রণ রাখতে চান তবে আপনি এটি tf.device('/gpu:0') ব্লক (বা সিপিইউ সমতুল্য) দিয়ে আবদ্ধ করতে পারেন:

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: 0.8094048500061035 secs
GPU: 0.039966583251953125 secs

একটি tf.Tensor অবজেক্ট এর 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 <ipython-input-1-c99eaec55f9a>: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 <ipython-input-1-c99eaec55f9a>: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.

বেঞ্চমার্ক

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

ফাংশন দিয়ে কাজ

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