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

গ্রেডিয়েন্টের ভূমিকা এবং স্বয়ংক্রিয় পার্থক্য

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

স্বয়ংক্রিয় পার্থক্য এবং গ্রেডিয়েন্ট

স্বয়ংক্রিয় বিভেদ যেমন মেশিন লার্নিং আলগোরিদিম বাস্তবায়ন জন্য দরকারী backpropagation স্নায়ুর নেটওয়ার্ক প্রশিক্ষণ জন্য।

এই সহায়িকার জন্য, আপনাকে TensorFlow সঙ্গে গ্রেডিয়েন্ট গনা, বিশেষ করে কোন উপায়ে অন্বেষণ করা হবে উৎসুক মৃত্যুদন্ড

সেটআপ

import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf

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

স্বয়ংক্রিয়ভাবে আলাদা করতে, TensorFlow কি অপারেশন ফরওয়ার্ড পাস সময় কি অনুক্রমে ঘটতে মনে রাখা দরকার। তারপর, অনগ্রসর পাস সময়, TensorFlow কম্পিউট গ্রেডিয়েন্ট থেকে বিপরীত ক্রম অপারেশনের এই তালিকা ঘোরে।

গ্রেডিয়েন্ট টেপ

TensorFlow উপলব্ধ tf.GradientTape স্বয়ংক্রিয় বিভেদ জন্য API; যে কিছু ইনপুট, সাধারণত সম্মান সঙ্গে একটি গুনতি গ্রেডিয়েন্ট কম্পিউটিং হল, tf.Variable গুলি। TensorFlow "রেকর্ড" প্রাসঙ্গিক অপারেশন একটি প্রেক্ষাপটে ভিতরে মৃত্যুদন্ড কার্যকর tf.GradientTape একটি "টেপ" সম্মুখের। TensorFlow তারপর যে টেপ ব্যবহার করে একটি "নথিভুক্ত" গুনতি গ্রেডিয়েন্ট গনা ব্যবহার বিপরীত মোড বিভেদ

এখানে একটি সহজ উদাহরণ:

x = tf.Variable(3.0)

with tf.GradientTape() as tape:
  y = x**2

আপনি একবার কিছু অপারেশন রেকর্ড করে থাকেন, ব্যবহার GradientTape.gradient(target, sources) কিছু লক্ষ্য (প্রায়ই একটি ক্ষতি) কিছু উৎস (প্রায়ই মডেলের ভেরিয়েবল) এর আপেক্ষিক গ্রেডিয়েন্ট নিরূপণ করা:

# dy = 2x * dx
dy_dx = tape.gradient(y, x)
dy_dx.numpy()
6.0

উপরোক্ত উদাহরণে scalars ব্যবহার করে, কিন্তু tf.GradientTape কোনো টেন্সর হিসাবে সহজে কাজ করে:

w = tf.Variable(tf.random.normal((3, 2)), name='w')
b = tf.Variable(tf.zeros(2, dtype=tf.float32), name='b')
x = [[1., 2., 3.]]

with tf.GradientTape(persistent=True) as tape:
  y = x @ w + b
  loss = tf.reduce_mean(y**2)

নতিমাত্রা পেতে loss উভয় ভেরিয়েবল থেকে সম্মান সঙ্গে, আপনি সোর্স হিসেবে পাস করতে পারেন gradient পদ্ধতি। টেপ কিভাবে উৎস পাস সম্পর্কে নমনীয় এবং তালিকা বা অভিধান কোন নেস্টেড সমন্বয় গ্রহণ এবং গ্রেডিয়েন্ট একই ভাবে (দেখুন কাঠামোবদ্ধ ফিরে আসবে tf.nest )।

[dl_dw, dl_db] = tape.gradient(loss, [w, b])

প্রতিটি উৎসের ক্ষেত্রে গ্রেডিয়েন্টের উৎসের আকৃতি রয়েছে:

print(w.shape)
print(dl_dw.shape)
(3, 2)
(3, 2)

এখানে আবার গ্রেডিয়েন্ট গণনা, এবার ভেরিয়েবলের একটি অভিধান পাস করা হচ্ছে:

my_vars = {
    'w': w,
    'b': b
}

grad = tape.gradient(loss, my_vars)
grad['b']
<tf.Tensor: shape=(2,), dtype=float32, numpy=array([-1.6920902, -3.2363236], dtype=float32)>

একটি মডেলের সাপেক্ষে গ্রেডিয়েন্ট

এটা তোলে এর সংগ্রহ করতে সাধারণ tf.Variables একটি মধ্যে tf.Module বা তার উপশ্রেণী (এক layers.Layer , keras.Model ) জন্য checkpointing এবং রপ্তানি

বেশিরভাগ ক্ষেত্রে, আপনি একটি মডেলের প্রশিক্ষণযোগ্য ভেরিয়েবলের সাপেক্ষে গ্রেডিয়েন্ট গণনা করতে চাইবেন। যেহেতু সব উপশ্রেণী tf.Module তাদের ভেরিয়েবল সমষ্টি Module.trainable_variables সম্পত্তি, আপনি কোড কয়েক লাইন এই গ্রেডিয়েন্ট নিরূপণ করতে পারেন:

layer = tf.keras.layers.Dense(2, activation='relu')
x = tf.constant([[1., 2., 3.]])

with tf.GradientTape() as tape:
  # Forward pass
  y = layer(x)
  loss = tf.reduce_mean(y**2)

# Calculate gradients with respect to every trainable variable
grad = tape.gradient(loss, layer.trainable_variables)
for var, g in zip(layer.trainable_variables, grad):
  print(f'{var.name}, shape: {g.shape}')
dense/kernel:0, shape: (3, 2)
dense/bias:0, shape: (2,)

টেপ ঘড়ি কি নিয়ন্ত্রণ

ডিফল্ট আচরণ একটি trainable অ্যাক্সেস পর সমস্ত কাজকর্মের রেকর্ড হয় tf.Variable । এর কারণগুলি হল:

  • পিছনের পাসে গ্রেডিয়েন্ট গণনা করার জন্য ফরোয়ার্ড পাসে কোন অপারেশনগুলি রেকর্ড করতে হবে তা টেপটিকে জানতে হবে।
  • টেপটি মধ্যবর্তী আউটপুটগুলির রেফারেন্স ধারণ করে, তাই আপনি অপ্রয়োজনীয় ক্রিয়াকলাপগুলি রেকর্ড করতে চান না।
  • সবচেয়ে সাধারণ ব্যবহারের ক্ষেত্রে একটি মডেলের প্রশিক্ষণযোগ্য ভেরিয়েবলের ক্ষেত্রে ক্ষতির গ্রেডিয়েন্ট গণনা করা জড়িত।

উদাহরণস্বরূপ, নিম্নলিখিত একটি গ্রেডিয়েন্ট নিরূপণ করা কারণ ব্যর্থ tf.Tensor ডিফল্টরূপে নয় "প্রেক্ষিত" করা হয়, এবং tf.Variable trainable নয়:

# A trainable variable
x0 = tf.Variable(3.0, name='x0')
# Not trainable
x1 = tf.Variable(3.0, name='x1', trainable=False)
# Not a Variable: A variable + tensor returns a tensor.
x2 = tf.Variable(2.0, name='x2') + 1.0
# Not a variable
x3 = tf.constant(3.0, name='x3')

with tf.GradientTape() as tape:
  y = (x0**2) + (x1**2) + (x2**2)

grad = tape.gradient(y, [x0, x1, x2, x3])

for g in grad:
  print(g)
tf.Tensor(6.0, shape=(), dtype=float32)
None
None
None

আপনি তালিকার পারে এমন বিভিন্ন ব্যবহার টেপ দ্বারা দেখা হচ্ছে GradientTape.watched_variables পদ্ধতি:

[var.name for var in tape.watched_variables()]
['x0:0']

tf.GradientTape আঙ্গুলসমূহ এটা কী করা বা দেখা হয় না বেশি ব্যবহারকারী নিয়ন্ত্রণ প্রদান প্রদান করে।

একটি সম্মান সঙ্গে রেকর্ড গ্রেডিয়েন্ট করার tf.Tensor , আপনাকে কল করার প্রয়োজন GradientTape.watch(x) :

x = tf.constant(3.0)
with tf.GradientTape() as tape:
  tape.watch(x)
  y = x**2

# dy = 2x * dx
dy_dx = tape.gradient(y, x)
print(dy_dx.numpy())
6.0

বিপরীতভাবে, সব দেখার ডিফল্ট আচরণ নিষ্ক্রিয় করতে tf.Variables , সেট watch_accessed_variables=False যখন গ্রেডিয়েন্ট টেপ তৈরি করা। এই গণনা দুটি ভেরিয়েবল ব্যবহার করে, কিন্তু শুধুমাত্র একটি ভেরিয়েবলের জন্য গ্রেডিয়েন্টকে সংযুক্ত করে:

x0 = tf.Variable(0.0)
x1 = tf.Variable(10.0)

with tf.GradientTape(watch_accessed_variables=False) as tape:
  tape.watch(x1)
  y0 = tf.math.sin(x0)
  y1 = tf.nn.softplus(x1)
  y = y0 + y1
  ys = tf.reduce_sum(y)

যেহেতু GradientTape.watch আহ্বান করা হয় নি x0 , কোন গ্রেডিয়েন্ট এটা থেকে সম্মান সঙ্গে নির্ণিত হয়:

# dys/dx1 = exp(x1) / (1 + exp(x1)) = sigmoid(x1)
grad = tape.gradient(ys, {'x0': x0, 'x1': x1})

print('dy/dx0:', grad['x0'])
print('dy/dx1:', grad['x1'].numpy())
dy/dx0: None
dy/dx1: 0.9999546

মধ্যবর্তী ফলাফল

এছাড়াও আপনি ভিতরে নির্ণিত অন্তর্বর্তী মান সম্মান সঙ্গে আউটপুট গ্রেডিয়েন্ট অনুরোধ করতে পারেন tf.GradientTape প্রসঙ্গ।

x = tf.constant(3.0)

with tf.GradientTape() as tape:
  tape.watch(x)
  y = x * x
  z = y * y

# Use the tape to compute the gradient of z with respect to the
# intermediate value y.
# dz_dy = 2 * y and y = x ** 2 = 9
print(tape.gradient(z, y).numpy())
18.0

ডিফল্টরূপে, একটি দ্বারা অনুষ্ঠিত সম্পদের GradientTape যত তাড়াতাড়ি মুক্তি পাচ্ছে GradientTape.gradient পদ্ধতি বলা হয়। একই গণনার উপর একাধিক গ্রেডিয়েন্ট গনা করতে, এটি দিয়ে একটি গ্রেডিয়েন্ট টেপ তৈরি persistent=True । এই একাধিক কল করতে পারবেন gradient পদ্ধতি হিসাবে সম্পদ মুক্তি যখন টেপ বস্তু আবর্জনা সংগ্রহ করা হয়। উদাহরণ স্বরূপ:

x = tf.constant([1, 3.0])
with tf.GradientTape(persistent=True) as tape:
  tape.watch(x)
  y = x * x
  z = y * y

print(tape.gradient(z, x).numpy())  # [4.0, 108.0] (4 * x**3 at x = [1.0, 3.0])
print(tape.gradient(y, x).numpy())  # [2.0, 6.0] (2 * x at x = [1.0, 3.0])
[  4. 108.]
[2. 6.]
del tape   # Drop the reference to the tape

কর্মক্ষমতা উপর নোট

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

  • গ্রেডিয়েন্ট টেপগুলি ব্যাকওয়ার্ড পাসের সময় ব্যবহারের জন্য ইনপুট এবং আউটপুট সহ মধ্যবর্তী ফলাফলগুলি সংরক্ষণ করতে মেমরি ব্যবহার করে।

    দক্ষতা, কিছু অপস (যেমন ReLU ) এবং তাদের মধ্যবর্তী ফলাফল রাখার প্রয়োজন হবে না তারা ফরওয়ার্ড পাস সময় ছেঁটে হয় না। যাইহোক, যদি আপনি ব্যবহার persistent=True আপনার টেপ, কিছুই বাতিল করা হয় এবং আপনার শিখর মেমোরি ব্যবহার বেশী হতে হবে।

অ-স্কেলার লক্ষ্যগুলির গ্রেডিয়েন্ট

একটি গ্রেডিয়েন্ট মূলত একটি স্কেলারে একটি অপারেশন।

x = tf.Variable(2.0)
with tf.GradientTape(persistent=True) as tape:
  y0 = x**2
  y1 = 1 / x

print(tape.gradient(y0, x).numpy())
print(tape.gradient(y1, x).numpy())
4.0
-0.25

এইভাবে, আপনি যদি একাধিক লক্ষ্যগুলির গ্রেডিয়েন্টের জন্য জিজ্ঞাসা করেন, প্রতিটি উত্সের ফলাফল হল:

  • লক্ষ্যের সমষ্টির গ্রেডিয়েন্ট বা সমতুল্য
  • প্রতিটি লক্ষ্যের গ্রেডিয়েন্টের যোগফল।
x = tf.Variable(2.0)
with tf.GradientTape() as tape:
  y0 = x**2
  y1 = 1 / x

print(tape.gradient({'y0': y0, 'y1': y1}, x).numpy())
3.75

একইভাবে, লক্ষ্য(গুলি) স্কেলার না হলে যোগফলের গ্রেডিয়েন্ট গণনা করা হয়:

x = tf.Variable(2.)

with tf.GradientTape() as tape:
  y = x * [3., 4.]

print(tape.gradient(y, x).numpy())
7.0

এটি ক্ষতির সংগ্রহের যোগফলের গ্রেডিয়েন্ট বা উপাদান-ভিত্তিক ক্ষতি গণনার যোগফলের গ্রেডিয়েন্ট নেওয়া সহজ করে তোলে।

আপনি প্রতিটি আইটেমের জন্য পৃথক গ্রেডিয়েন্ট প্রয়োজন হয়, তাহলে পড়ুন Jacobians

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

x = tf.linspace(-10.0, 10.0, 200+1)

with tf.GradientTape() as tape:
  tape.watch(x)
  y = tf.nn.sigmoid(x)

dy_dx = tape.gradient(y, x)
plt.plot(x, y, label='y')
plt.plot(x, dy_dx, label='dy/dx')
plt.legend()
_ = plt.xlabel('x')

png

নিয়ন্ত্রণ প্রবাহ

একটি গ্রেডিয়েন্ট টেপ রেকর্ড কারণ অপারেশন হিসাবে তারা মৃত্যুদন্ড কার্যকর করা হয়, পাইথন নিয়ন্ত্রণ প্রবাহ স্বাভাবিকভাবেই পরিচালিত হয় (উদাহরণস্বরূপ, if এবং while বিবৃতি)।

এখানে একটি ভিন্ন পরিবর্তনশীল একটি প্রতিটি ডালে ব্যবহার করা হয় if । গ্রেডিয়েন্ট শুধুমাত্র ব্যবহৃত ভেরিয়েবলের সাথে সংযোগ করে:

x = tf.constant(1.0)

v0 = tf.Variable(2.0)
v1 = tf.Variable(2.0)

with tf.GradientTape(persistent=True) as tape:
  tape.watch(x)
  if x > 0.0:
    result = v0
  else:
    result = v1**2 

dv0, dv1 = tape.gradient(result, [v0, v1])

print(dv0)
print(dv1)
tf.Tensor(1.0, shape=(), dtype=float32)
None

শুধু মনে রাখবেন যে কন্ট্রোল স্টেটমেন্টগুলি নিজেই পার্থক্যযোগ্য নয়, তাই তারা গ্রেডিয়েন্ট-ভিত্তিক অপ্টিমাইজারদের কাছে অদৃশ্য।

মান উপর নির্ভর করে x উপরোক্ত উদাহরণের, টেপ পারেন রেকর্ড result = v0 বা result = v1**2 । থেকে সম্মান সঙ্গে গ্রেডিয়েন্ট x সবসময় None

dx = tape.gradient(result, x)

print(dx)
None

একটি গ্রেডিয়েন্ট পথ None

লক্ষ্য একটি উৎস সংযুক্ত নেই আপনি যখন একটি গ্রেডিয়েন্ট পাবেন None

x = tf.Variable(2.)
y = tf.Variable(3.)

with tf.GradientTape() as tape:
  z = y * y
print(tape.gradient(z, x))
None

এখানে z স্পষ্টত সংযুক্ত নেই x , কিন্তু বিভিন্ন কম সুস্পষ্ট উপায়ে যে একটি গ্রেডিয়েন্ট সংযোগ বিচ্ছিন্ন করা যায়।

1. একটি ভেরিয়েবলকে একটি টেনসর দিয়ে প্রতিস্থাপন করা হয়েছে

উপর বিভাগে "নিয়ন্ত্রণ কি টেপ ঘড়ির" তোমাকে দেখেছিলাম যে টেপ স্বয়ংক্রিয়ভাবে একটি দেখবে tf.Variable কিন্তু না একটি tf.Tensor

এক সাধারণ ত্রুটি অনবধানতাবশত একটি প্রতিস্থাপন করতে হয় tf.Variable একটি সঙ্গে tf.Tensor পরিবর্তে ব্যবহার করার, Variable.assign আপডেট করতে tf.Variable । এখানে একটি উদাহরণ:

x = tf.Variable(2.0)

for epoch in range(2):
  with tf.GradientTape() as tape:
    y = x+1

  print(type(x).__name__, ":", tape.gradient(y, x))
  x = x + 1   # This should be `x.assign_add(1)`
ResourceVariable : tf.Tensor(1.0, shape=(), dtype=float32)
EagerTensor : None

2. TensorFlow এর বাইরে গণনা করেছেন

টেপ গ্রেডিয়েন্ট পাথ রেকর্ড করতে পারে না যদি গণনা TensorFlow থেকে বেরিয়ে যায়। উদাহরণ স্বরূপ:

x = tf.Variable([[1.0, 2.0],
                 [3.0, 4.0]], dtype=tf.float32)

with tf.GradientTape() as tape:
  x2 = x**2

  # This step is calculated with NumPy
  y = np.mean(x2, axis=0)

  # Like most ops, reduce_mean will cast the NumPy array to a constant tensor
  # using `tf.convert_to_tensor`.
  y = tf.reduce_mean(y, axis=0)

print(tape.gradient(y, x))
None

3. একটি পূর্ণসংখ্যা বা স্ট্রিং এর মাধ্যমে গ্রেডিয়েন্ট নিয়েছে

পূর্ণসংখ্যা এবং স্ট্রিং পার্থক্যযোগ্য নয়। যদি একটি গণনা পাথ এই ডেটা প্রকারগুলি ব্যবহার করে তবে কোনও গ্রেডিয়েন্ট থাকবে না।

কেউ স্ট্রিং differentiable হতে আশা, কিন্তু এটা ঘটনাক্রমে একটি তৈরি করা খুবই সহজ int ধ্রুবক বা পরিবর্তনশীল যদি আপনি এখানে কিছু উল্লেখ না dtype

x = tf.constant(10)

with tf.GradientTape() as g:
  g.watch(x)
  y = x * x

print(g.gradient(y, x))
WARNING:tensorflow:The dtype of the watched tensor must be floating (e.g. tf.float32), got tf.int32
WARNING:tensorflow:The dtype of the target tensor must be floating (e.g. tf.float32) when calling GradientTape.gradient, got tf.int32
WARNING:tensorflow:The dtype of the source tensor must be floating (e.g. tf.float32) when calling GradientTape.gradient, got tf.int32
None

TensorFlow স্বয়ংক্রিয়ভাবে প্রকারের মধ্যে কাস্ট করে না, তাই, অনুশীলনে, আপনি প্রায়ই অনুপস্থিত গ্রেডিয়েন্টের পরিবর্তে একটি টাইপ ত্রুটি পাবেন।

4. একটি রাষ্ট্রীয় বস্তুর মাধ্যমে গ্রেডিয়েন্ট গ্রহণ করা হয়েছে

স্টেট গ্রেডিয়েন্ট বন্ধ করে। আপনি যখন একটি রাষ্ট্রীয় বস্তু থেকে পড়েন, টেপটি শুধুমাত্র বর্তমান অবস্থা পর্যবেক্ষণ করতে পারে, এটির দিকে পরিচালিত ইতিহাস নয়।

একজন tf.Tensor অপরিবর্তনীয় হয়। একবার তৈরি হয়ে গেলে আপনি টেনসর পরিবর্তন করতে পারবেন না। এটা একটা মান, কিন্তু কোন রাষ্ট্র হয়েছে। সমস্ত কাজকর্মের এতদূর আলোচনা এছাড়াও আড়ম্বরহীন: একটি আউটপুট tf.matmul শুধুমাত্র তার ইনপুট উপর নির্ভর করে।

একজন tf.Variable অভ্যন্তরীণ রাষ্ট্রীয় তার মান আছে। আপনি যখন ভেরিয়েবল ব্যবহার করেন, তখন রাষ্ট্রটি পড়া হয়। একটি ভেরিয়েবলের সাপেক্ষে একটি গ্রেডিয়েন্ট গণনা করা স্বাভাবিক, তবে ভেরিয়েবলের অবস্থা গ্রেডিয়েন্ট গণনাকে আরও পিছনে যেতে বাধা দেয়। উদাহরণ স্বরূপ:

x0 = tf.Variable(3.0)
x1 = tf.Variable(0.0)

with tf.GradientTape() as tape:
  # Update x1 = x1 + x0.
  x1.assign_add(x0)
  # The tape starts recording from x1.
  y = x1**2   # y = (x1 + x0)**2

# This doesn't work.
print(tape.gradient(y, x0))   #dy/dx0 = 2*(x1 + x0)
None

একইভাবে, tf.data.Dataset iterators এবং tf.queue গুলি stateful হয়, এবং tensors যে তাদের মধ্য দিয়ে পাস সমস্ত গ্রেডিয়েন্ট বন্ধ করে দেব।

কোন গ্রেডিয়েন্ট নিবন্ধিত নেই

কিছু tf.Operation গুলি অ differentiable হচ্ছে হিসাবে নিবন্ধিত হয় এবং ফিরে আসবে Noneঅন্যান্যরা গ্রেডিয়েন্ট নিবন্ধিত আছে।

tf.raw_ops যা নিম্ন স্তরের অপস নিবন্ধিত গ্রেডিয়েন্ট আছে পৃষ্ঠা দেখায়।

আপনি যদি একটি ভাসা অপ নিবন্ধিত টেপ চুপটি ফেরার পরিবর্তে একটি ত্রুটি নিক্ষেপ করা হবে কোন গ্রেডিয়েন্ট আছে যে মাধ্যমে একটি গ্রেডিয়েন্ট আদায়ের চেষ্টা করে তাহলে None । এইভাবে আপনি জানেন যে কিছু ভুল হয়েছে।

উদাহরণস্বরূপ, tf.image.adjust_contrast ফাংশন গোপন raw_ops.AdjustContrastv2 , যা একটি গ্রেডিয়েন্ট থাকতে পারে কিন্তু গ্রেডিয়েন্ট বাস্তবায়িত হয়নি:

image = tf.Variable([[[0.5, 0.0, 0.0]]])
delta = tf.Variable(0.1)

with tf.GradientTape() as tape:
  new_image = tf.image.adjust_contrast(image, delta)

try:
  print(tape.gradient(new_image, [image, delta]))
  assert False   # This should not happen.
except LookupError as e:
  print(f'{type(e).__name__}: {e}')
LookupError: gradient registry has no entry for: AdjustContrastv2

আপনি এই অপ মাধ্যমে পার্থক্য করার প্রয়োজন হলে, আপনি হয় গ্রেডিয়েন্ট বাস্তবায়ন এবং এটি রেজিস্টার করো (ব্যবহার করতে হবে tf.RegisterGradient ) অথবা ফাংশন অন্যান্য অপস ব্যবহার পুনরায় বাস্তবায়ন।

None এর পরিবর্তে Zeros

কিছু কিছু ক্ষেত্রে এটা পরিবর্তে 0 পেতে সুবিধাজনক হবে None সম্পর্কহীন গ্রেডিয়েন্ট জন্য। আপনি সিদ্ধান্ত নিতে পারেন আপনি ব্যবহার সম্পর্কহীন গ্রেডিয়েন্ট আছে কি ফিরতে unconnected_gradients যুক্তি:

x = tf.Variable([2., 2.])
y = tf.Variable(3.)

with tf.GradientTape() as tape:
  z = y**2
print(tape.gradient(z, x, unconnected_gradients=tf.UnconnectedGradients.ZERO))
tf.Tensor([0. 0.], shape=(2,), dtype=float32)