কার্যকর টেনসরফ্লো 2

টেনসরফ্লো ব্যবহারকারীদের আরও উত্পাদনশীল করতে টেনসরফ্লো ২.০ এ একাধিক পরিবর্তন রয়েছে। TensorFlow 2.0 অপসারণ API গুলি অপ্রয়োজনীয় , API গুলি আরও বেশি সঙ্গতিপূর্ণ করে তোলে ( ইউনিফায়েড RNNs , ইউনিফায়েড Optimizers ), এবং সঙ্গে পাইথন রানটাইম সাথে উন্নত সংহত উৎসুক মৃত্যুদন্ড

অনেক RFCs যে পরিবর্তন TensorFlow 2.0 তৈরীর মধ্যে চলে গেছে ব্যাখ্যা করেছি। টেনসরফ্লো ২.০-তে কী কী বিকাশ হওয়া উচিত তার জন্য এই গাইডটি একটি দৃষ্টিভঙ্গি উপস্থাপন করে। এটি ধরে নেওয়া হয়েছে যে টেনসরফ্লো 1.x এর সাথে আপনার কিছুটা পরিচিতি রয়েছে

বড় পরিবর্তনগুলির একটি সংক্ষিপ্তসার

এপিআই ক্লিনআপ

অনেক API গুলি পারেন হয় সর্বস্বান্ত বা সরানো মেমরি 2.0। প্রধান পরিবর্তন কিছু সরানোর অন্তর্ভুক্ত tf.app , tf.flags এবং tf.logging এখন ওপেন সোর্স পক্ষে absl-PY , প্রকল্পের বাস করতেন পালক নিতে tf.contrib , এবং প্রধান পরিষ্কার আপ tf.* দ্বারা নামস্থান মত subpackages মধ্যে ক্ষুদ্রতর ব্যবহৃত ফাংশন চলন্ত tf.math । - কিছু API গুলি তাদের 2.0 সমতুল দিয়ে প্রতিস্থাপিত করা হয়েছে tf.summary , tf.keras.metrics এবং tf.keras.optimizers । সবচেয়ে সহজ উপায় স্বয়ংক্রিয়ভাবে এই renames আবেদন করতে ব্যবহার করা v2 আপগ্রেড স্ক্রিপ্ট

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

TensorFlow 1.x ব্যবহারকারীদের নিজে একসঙ্গে একটি সেলাই প্রয়োজন বিমূর্ত সিনট্যাক্স গাছ করে (গ্রাফ) tf.* API কল। তখনই নিজে একটি আউটপুট tensors এবং ইনপুট tensors একটি সেট ক্ষণস্থায়ী দ্বারা বিমূর্ত সিনট্যাক্স গাছ কম্পাইল করার জন্য ব্যবহারকারীদের প্রয়োজন session.run কল। টেনসরফ্লো ২.০ আগ্রহীভাবে কার্যকর করে (পাইথন যেমন সাধারণত হয়) এবং ২.০-তে গ্রাফ এবং সেশনগুলি প্রয়োগের বিশদগুলির মতো মনে হয়।

উৎসুক সঞ্চালনের এক উল্লেখযোগ্য উপজাত যে tf.control_dependencies আর প্রয়োজন বোধ করা হয় (ক মধ্যে যেমন কোড সব লাইন অনুক্রমে চালানো tf.function , যাতে পার্শ্ব প্রতিক্রিয়া, executes মাধ্যমে কোডের লিখিত)।

আর কোনও গ্লোবাল নেই

টেনসরফ্লো ১.x সুস্পষ্টভাবে গ্লোবাল নেমস্পেসের উপর প্রচুর নির্ভর করে। আপনি যখন বলা tf.Variable , এটি ডিফল্ট গ্রাফ পুরা করা হবে এবং সেখানে থাকবে, এমনকি যদি আপনি পাইথন পরিবর্তনশীল এটি এর প্রতি নির্দেশ ট্র্যাক হারিয়ে। তারপর আপনি যে পুনরুদ্ধার পারে tf.Variable , কিন্তু আপনি নাম জানত শুধুমাত্র যদি এটি সঙ্গে তৈরি করা হয়েছে। আপনি ভেরিয়েবলের তৈরির নিয়ন্ত্রণে না রাখলে এটি করা কঠিন ছিল। ফলস্বরূপ, মেকানিজম সমস্ত প্রকারের সাহায্য ব্যবহারকারীরা তাদের ভেরিয়েবল আবার খুঁজে পেতে প্রচেষ্টা বৃদ্ধি, এবং পরিকাঠামোর ব্যবহারকারী-নির্মিত ভেরিয়েবল খুঁজে পায় তার জন্য: চলক সুযোগ, গ্লোবাল সংগ্রহের মত সাহায্যকারী পদ্ধতি tf.get_global_step , tf.global_variables_initializer , optimizers পরোক্ষভাবে কম্পিউটিং গ্রেডিয়েন্ট সমস্ত প্রশিক্ষণযোগ্য ভেরিয়েবল, এবং উপর। TensorFlow 2.0 এই সব প্রক্রিয়া (এর ঘটিয়েছে ভেরিয়েবল 2.0 বোঝায় যা RFC ) ডিফল্ট প্রক্রিয়া পক্ষে: আপনার ভেরিয়েবল সম্পর্কে অবগত থাকুন! আপনি যদি একটি ট্র্যাক হারিয়ে ফেলেন, তাহলে tf.Variable , এটা আবর্জনা সংগ্রহ পায়।

ভেরিয়েবলগুলি ট্র্যাক করার প্রয়োজনীয়তা ব্যবহারকারীর জন্য কিছু অতিরিক্ত কাজ তৈরি করে তবে কেরাস অবজেক্ট (নীচে দেখুন) দিয়ে বোঝা হ্রাস করা হয়।

ফাংশন, সেশন নয়

একজন session.run কল প্রায় এক ফাংশন কল মত হল: আপনি ইনপুট এবং ফাংশন বলা হবে উল্লেখ, এবং আপনি ফিরে আউটপুট একটি সেট পেতে। TensorFlow 2.0, আপনি ব্যবহার করে একটি পাইথন ফাংশন সাজাইয়া পারেন tf.function জে আই টি JIT সংকলন জন্য চিহ্নিত যাতে TensorFlow একটি একক গ্রাফ (যেমন রান কার্যাবলী 2.0 বোঝায় যা RFC )। এই প্রক্রিয়াটি টেনসরফ্লো ২.০ কে গ্রাফ মোডের সমস্ত সুবিধা অর্জন করতে দেয়:

  • পারফরম্যান্স: ফাংশনটি অপ্টিমাইজ করা যায় (নোড ছাঁটাই, কার্নেল ফিউশন ইত্যাদি)
  • পোর্টেবিলিটি: ফাংশন রপ্তানি করা যেতে পারে / reimported ( SavedModel 2.0 বোঝায় যা RFC ,) ব্যবহারকারীদের পুনরায় ব্যবহার এবং ভাগ মডুলার TensorFlow ফাংশন করতে সক্ষম হবেন।
# TensorFlow 1.X
outputs = session.run(f(placeholder), feed_dict={placeholder: input})
# TensorFlow 2.0
outputs = f(input)

অবাধে পাইথন এবং টেনসরফ্লো কোড ছেদ করার ক্ষমতা সহ ব্যবহারকারীরা পাইথনের অভিব্যক্তির সুবিধা নিতে পারেন। তবে পোর্টেবল টেনসরফ্লো মোবাইল, সি ++ এবং জাভাস্ক্রিপ্টের মতো পাইথন দোভাষী ছাড়া প্রসঙ্গে প্রযোজ্য। সাহায্যের ব্যবহারকারীদের যোগ তাদের কোড পুনর্লিখন থাকার এড়াতে @tf.function , অটোগ্রাফ তাদের TensorFlow সমতুল মধ্যে পাইথন নির্মানের একটি উপসেট পরিবর্তন করে:

  • for / while -> tf.while_loop ( break এবং continue সমর্থিত)
  • if -> tf.cond
  • for _ in dataset -> dataset.reduce

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

আইডেম্যাটিক টেনসরফ্লো ২.০ এর জন্য প্রস্তাবনা

আপনার কোডটিকে ছোট ফাংশনে রিফ্যাক্টর করুন

TensorFlow 1.x মধ্যে একটি সাধারণ ব্যবহার প্যাটার্ন "রান্নাঘরের সিংক" কৌশল, যেখানে সব সম্ভব কম্পিউটেশন ইউনিয়ন preemptively পরিপূর্ণ ছিল ছিল, এবং তারপর নির্বাচিত tensors মাধ্যমে মূল্যায়ন করা হয় session.run । টেনসরফ্লো ২.০-তে ব্যবহারকারীদের তাদের কোডটিকে ছোট ছোট ফাংশনগুলিতে রিফ্যাক্টর করা উচিত যা প্রয়োজনীয় হিসাবে ডাকা হয়। সাধারণত, এই ছোট ফাংশন প্রতিটি সাজাইয়া রাখা জরুরি নয় tf.function ; শুধুমাত্র ব্যবহার tf.function , উদাহরণস্বরূপ প্রশিক্ষণ অথবা আপনার মডেল ফরওয়ার্ড পাস এক ধাপ - উচ্চ পর্যায়ের কম্পিউটেশন সাজাইয়া রাখা হয়।

ভেরিয়েবলগুলি পরিচালনা করতে কেরাস স্তর এবং মডেলগুলি ব্যবহার করুন

Keras মডেল এবং স্তর সুবিধাজনক প্রস্তাব variables এবং trainable_variables সম্পত্তি, যা যাও recursively সব নির্ভরশীল ভেরিয়েবল জড়ো করা পর্যন্ত। এটি স্থানীয়ভাবে ভেরিয়েবলগুলি যেখানে ব্যবহৃত হচ্ছে সেখানে পরিচালনা করা সহজ করে তোলে।

বিপরীতে:

def dense(x, W, b):
  return tf.nn.sigmoid(tf.matmul(x, W) + b)

@tf.function
def multilayer_perceptron(x, w0, b0, w1, b1, w2, b2 ...):
  x = dense(x, w0, b0)
  x = dense(x, w1, b1)
  x = dense(x, w2, b2)
  ...

# You still have to manage w_i and b_i, and their shapes are defined far away from the code.

কেরাস সংস্করণ সহ:

# Each layer can be called, with a signature equivalent to linear(x)
layers = [tf.keras.layers.Dense(hidden_size, activation=tf.nn.sigmoid) for _ in range(n)]
perceptron = tf.keras.Sequential(layers)

# layers[3].trainable_variables => returns [w3, b3]
# perceptron.trainable_variables => returns [w0, b0, ...]

Keras স্তর / মডেল থেকে উত্তরাধিকারী tf.train.Checkpointable এবং সাথে একত্রিত হয় @tf.function , যা এটা সম্ভব সরাসরি চেকপয়েন্ট বা রপ্তানি SavedModels করার Keras বস্তু থেকে তোলে। আপনি অগত্যা Keras এর ব্যবহার করতে হবে না Model.fit এপিআই এই ঐক্যবদ্ধতার সুবিধা গ্রহণ করতে।

এখানে ট্রান্সফার শেখার উদাহরণ যা দেখায় যে কীভাবে কেরাস প্রাসঙ্গিক ভেরিয়েবলগুলির একটি উপসেট সংগ্রহ করা সহজ করে। ধরা যাক আপনি একটি ভাগযুক্ত ট্রাঙ্ক সহ একটি বহু-মাথা মডেল প্রশিক্ষণ দিচ্ছেন:

trunk = tf.keras.Sequential([...])
head1 = tf.keras.Sequential([...])
head2 = tf.keras.Sequential([...])

path1 = tf.keras.Sequential([trunk, head1])
path2 = tf.keras.Sequential([trunk, head2])

# Train on primary dataset
for x, y in main_dataset:
  with tf.GradientTape() as tape:
    # training=True is only needed if there are layers with different
    # behavior during training versus inference (e.g. Dropout).
    prediction = path1(x, training=True)
    loss = loss_fn_head1(prediction, y)
  # Simultaneously optimize trunk and head1 weights.
  gradients = tape.gradient(loss, path1.trainable_variables)
  optimizer.apply_gradients(zip(gradients, path1.trainable_variables))

# Fine-tune second head, reusing the trunk
for x, y in small_dataset:
  with tf.GradientTape() as tape:
    # training=True is only needed if there are layers with different
    # behavior during training versus inference (e.g. Dropout).
    prediction = path2(x, training=True)
    loss = loss_fn_head2(prediction, y)
  # Only optimize head2 weights, not trunk weights
  gradients = tape.gradient(loss, head2.trainable_variables)
  optimizer.apply_gradients(zip(gradients, head2.trainable_variables))

# You can publish just the trunk computation for other people to reuse.
tf.saved_model.save(trunk, output_path)

Tf.data.Datasets এবং @ tf.function একত্রিত করুন

স্মৃতিতে ফিট হওয়া প্রশিক্ষণ ডেটা নিয়ে পুনরাবৃত্তি করার সময়, নিয়মিত পাইথন পুনরাবৃত্তিটি ব্যবহার করতে দ্বিধা বোধ করবেন। অন্যথায়, tf.data.Dataset সবচেয়ে ভালো উপায় ডিস্ক থেকে প্রশিক্ষণ ডাটা স্ট্রিম হয়। ডেটাসেট হয় iterables (না iterators) , এবং কাজের মাত্র উৎসুক মোডে অন্যান্য পাইথন iterables মত। আপনি সম্পূর্ণরূপে ডেটা সেটটি ASYNC পূর্বআনয়ন / আপনার কোড মোড়কে বৈশিষ্ট্য স্ট্রিমিং ব্যবহার করতে পারে tf.function , যা অটোগ্রাফ ব্যবহার সমতুল্য গ্রাফ অপারেশন সঙ্গে পাইথন পুনরাবৃত্তির প্রতিস্থাপন করে।

@tf.function
def train(model, dataset, optimizer):
  for x, y in dataset:
    with tf.GradientTape() as tape:
      # training=True is only needed if there are layers with different
      # behavior during training versus inference (e.g. Dropout).
      prediction = model(x, training=True)
      loss = loss_fn(prediction, y)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))

আপনি Keras ব্যবহার করেন তাহলে Model.fit এপিআই, আপনি ডেটা সেটটি পুনরাবৃত্তির সম্পর্কে চিন্তা করতে হবে না।

model.compile(optimizer=optimizer, loss=loss_fn)
model.fit(dataset)

পাইথন নিয়ন্ত্রণ প্রবাহের সাথে অটোগ্রাফের সুবিধা নিন

অটোগ্রাফ একটি উপায় মত গ্রাফ-মোড সমতুল ডেটা নির্ভর নিয়ন্ত্রণ প্রবাহ রূপান্তর করতে উপলব্ধ tf.cond এবং tf.while_loop

একটি সাধারণ জায়গা যেখানে ডেটা-নির্ভর নিয়ন্ত্রণ নিয়ন্ত্রণ প্রবাহ প্রদর্শিত হয় তা হল সিক্যুয়েন্স মডেলগুলি। tf.keras.layers.RNN একটি RNN সেল গোপন, হয় স্ট্যাটিক্যালি বা পরিবর্তনশীল পুনরাবৃত্তি উদ্ঘাটিত করা আপনার অনুমতি দেয়। বিক্ষোভের খাতিরে, আপনি নিম্নরূপে গতিশীল তালিকাভুক্তি পুনরায় প্রতিস্থাপন করতে পারেন:

class DynamicRNN(tf.keras.Model):

  def __init__(self, rnn_cell):
    super(DynamicRNN, self).__init__(self)
    self.cell = rnn_cell

  def call(self, input_data):
    # [batch, time, features] -> [time, batch, features]
    input_data = tf.transpose(input_data, [1, 0, 2])
    outputs = tf.TensorArray(tf.float32, input_data.shape[0])
    state = self.cell.zero_state(input_data.shape[1], dtype=tf.float32)
    for i in tf.range(input_data.shape[0]):
      output, state = self.cell(input_data[i], state)
      outputs = outputs.write(i, output)
    return tf.transpose(outputs.stack(), [1, 0, 2]), state

অটোগ্রাফ এর বৈশিষ্ট্য আরো বিস্তারিত ওভারভিউ জন্য, দেখুন নির্দেশিকা

tf.metrics ডেটা একত্রিত করে এবং tf.summary এগুলি লগ করে

সারাংশ লগ ইন করতে, ব্যবহার tf.summary.(scalar|histogram|...) এবং একটি প্রসঙ্গ ম্যানেজার ব্যবহার করে একজন লেখক তা পুনর্নির্দেশ। (আপনি যদি প্রসঙ্গ পরিচালককে বাদ দেন তবে কিছুই হয় না)) টিএফ 1.x এর বিপরীতে সংক্ষিপ্তসারগুলি সরাসরি লেখকের কাছে নির্গত হয়; কোন পৃথক "একত্রীকরণ" অপ এবং কোন পৃথক হয় add_summary কল, যার মানে step মান callsite এ প্রদান করা আবশ্যক।

summary_writer = tf.summary.create_file_writer('/tmp/summaries')
with summary_writer.as_default():
  tf.summary.scalar('loss', 0.1, step=42)

তাদের সারসংক্ষেপ, ব্যবহার লগিং আগে সমষ্টিগত তথ্য tf.metrics । মেট্রিক্স stateful হয়: তারা মান জমা এবং একটি ক্রমসঞ্চিত ফলাফলের আসতে আপনি কল যখন result (যেমন পদ্ধতি Mean.result )। সাফ সঞ্চিত সঙ্গে মান Model.reset_states

def train(model, optimizer, dataset, log_freq=10):
  avg_loss = tf.keras.metrics.Mean(name='loss', dtype=tf.float32)
  for images, labels in dataset:
    loss = train_step(model, optimizer, images, labels)
    avg_loss.update_state(loss)
    if tf.equal(optimizer.iterations % log_freq, 0):
      tf.summary.scalar('loss', avg_loss.result(), step=optimizer.iterations)
      avg_loss.reset_states()

def test(model, test_x, test_y, step_num):
  # training=False is only needed if there are layers with different
  # behavior during training versus inference (e.g. Dropout).
  loss = loss_fn(model(test_x, training=False), test_y)
  tf.summary.scalar('loss', loss, step=step_num)

train_summary_writer = tf.summary.create_file_writer('/tmp/summaries/train')
test_summary_writer = tf.summary.create_file_writer('/tmp/summaries/test')

with train_summary_writer.as_default():
  train(model, optimizer, dataset)

with test_summary_writer.as_default():
  test(model, test_x, test_y, optimizer.iterations)

সংক্ষিপ্ত লগ ডিরেক্টরিতে টেনসরবোর্ডকে নির্দেশ করে উত্পন্ন সংক্ষিপ্তগুলি ভিজ্যুয়ালাইজ করুন:

tensorboard --logdir /tmp/summaries

ডিবাগ করার সময় tf.config.run_funitions_eagely ব্যবহার করুন

টেনসরফ্লো ২.০-তে, আগ্রহী সম্পাদন আপনাকে আকার, ডেটা ধরণের এবং মানগুলি পরীক্ষা করার জন্য ধাপে ধাপে কোড চালাতে দেয়। কিছু API গুলি, মত tf.function , tf.keras , ইত্যাদি কর্মক্ষমতা এবং বহনযোগ্যতা জন্য গ্রাফ ফাঁসি, ব্যবহার করা ডিজাইন করা হয়। যখন ডিবাগ, ব্যবহার tf.config.run_functions_eagerly(True) এই কোড ভিতরে উৎসুক সঞ্চালনের ব্যবহার করতে।

উদাহরণ স্বরূপ:

@tf.function
def f(x):
  if x > 0:
    import pdb
    pdb.set_trace()
    x = x + 1
  return x

tf.config.run_functions_eagerly(True)
f(tf.constant(1))
f()
-> x = x + 1
(Pdb) l
  6     @tf.function
  7     def f(x):
  8       if x > 0:
  9         import pdb
 10         pdb.set_trace()
 11  ->     x = x + 1
 12       return x
 13
 14     tf.config.run_functions_eagerly(True)
 15     f(tf.constant(1))
[EOF]

এটি কেরাস মডেল এবং অন্যান্য এপিআইপিগুলির মধ্যেও কাজ করে যা উত্সর মৃত্যুদণ্ড সমর্থন করে:

class CustomModel(tf.keras.models.Model):

  @tf.function
  def call(self, input_data):
    if tf.reduce_mean(input_data) > 0:
      return input_data
    else:
      import pdb
      pdb.set_trace()
      return input_data // 2


tf.config.run_functions_eagerly(True)
model = CustomModel()
model(tf.constant([-2, -4]))
call()
-> return input_data // 2
(Pdb) l
 10         if tf.reduce_mean(input_data) > 0:
 11           return input_data
 12         else:
 13           import pdb
 14           pdb.set_trace()
 15  ->       return input_data // 2
 16
 17
 18     tf.config.run_functions_eagerly(True)
 19     model = CustomModel()
 20     model(tf.constant([-2, -4]))