سیکھنے کی شرح گہری سیکھنے کے نیٹ ورکس میں ایک اہم ہائپر پیرامیٹر ہے - اور یہ براہ راست حکم دیتا ہے۔ ڈگری جس میں وزن کی تازہ کاری کی جاتی ہے، جس کا تخمینہ کچھ دیئے گئے نقصان کے فنکشن کو کم کرنے کے لیے لگایا جاتا ہے۔ SGD میں:
$$
weight_{t+1} = weight_t – lr * frac{derror}{dweight_t}
$$
کی سیکھنے کی شرح کے ساتھ 0, اپ ڈیٹ شدہ وزن خود پر واپس آ گیا ہے - وزنt. سیکھنے کی شرح مؤثر طریقے سے ایک نوب ہے جسے ہم سیکھنے کو فعال یا غیر فعال کرنے کے لیے تبدیل کر سکتے ہیں، اور اس کا اثر اس بات پر ہوتا ہے کہ سیکھنے کے کتنے کام ہو رہے ہیں، براہ راست وزن کی تازہ کاری کی ڈگری کو کنٹرول کر کے۔
مختلف اصلاح کار سیکھنے کی شرح کو مختلف طریقے سے استعمال کرتے ہیں – لیکن بنیادی تصور ایک ہی رہتا ہے۔ یہ کہنے کی ضرورت نہیں کہ سیکھنے کی شرح بہت سے مطالعات، کاغذات اور پریکٹیشنر کے معیارات کا مقصد رہی ہے۔
عام طور پر، تقریباً سبھی اس بات سے متفق ہیں کہ سیکھنے کی ایک مستحکم شرح اس میں کمی نہیں کرے گی، اور زیادہ تر تکنیکوں میں سیکھنے کی شرح میں کچھ قسم کی کمی واقع ہوتی ہے جو تربیت کے دوران سیکھنے کی شرح کو ٹیون کرتی ہے - چاہے یہ ایک یک، کوزائن، مثلث یا دیگر اقسام کی ہو۔ کمی
ایک تکنیک جو حالیہ برسوں میں قدم جما رہی ہے۔ سیکھنے کی شرح وارم اپ، جس کو عملی طور پر کسی دوسری کمی کی تکنیک کے ساتھ جوڑا جا سکتا ہے۔
سیکھنے کی شرح وارم اپ
سیکھنے کی شرح وارم اپ کے پیچھے خیال آسان ہے۔ تربیت کے ابتدائی مراحل میں - وزن اپنی مثالی حالتوں سے بہت دور ہیں۔ اس کا مطلب ہے پورے بورڈ میں بڑی اپ ڈیٹس، جنہیں ہر وزن کے لیے "زیادہ تصحیح" کے طور پر دیکھا جا سکتا ہے - جہاں کسی دوسرے کی سخت اپ ڈیٹ کسی دوسرے وزن کی تازہ کاری کی نفی کر سکتی ہے، جس سے تربیت کے ابتدائی مراحل مزید غیر مستحکم ہو جاتے ہیں۔
یہ تبدیلیاں ختم ہو جاتی ہیں، لیکن سیکھنے کی ایک چھوٹی شرح کے ساتھ شروع کرنے، زیادہ مستحکم ذیلی بہترین حالت تک پہنچنے، اور پھر سیکھنے کی ایک بڑی شرح کو لاگو کرنے سے بچا جا سکتا ہے۔ آپ نیٹ ورک کو ان کے ساتھ مارنے کے بجائے اپ ڈیٹس میں آسانی پیدا کر سکتے ہیں۔
یہ سیکھنے کی شرح وارم اپ ہے! کم (یا 0) سیکھنے کی شرح کے ساتھ شروع کرنا اور سیکھنے کی ابتدائی شرح تک بڑھنا (جس سے آپ بہرحال شروع کریں گے)۔ یہ اضافہ واقعی کسی بھی فنکشن کی پیروی کرسکتا ہے، لیکن عام طور پر لکیری ہوتا ہے۔
ابتدائی شرح تک پہنچنے کے بعد، تربیت کے اختتام تک شرح کو بتدریج کم کرنے کے لیے دیگر نظام الاوقات جیسے کوزائن ڈے، لکیری کمی، وغیرہ کا اطلاق کیا جا سکتا ہے۔ سیکھنے کی شرح وارم اپ عام طور پر دو شیڈول شیڈول کا حصہ ہوتی ہے، جہاں LR وارم اپ پہلا ہوتا ہے، جب کہ شرح کے نقطہ آغاز تک پہنچنے کے بعد دوسرا شیڈول ختم ہو جاتا ہے۔
اس گائیڈ میں، ہم Keras/TensorFlow میں سیکھنے کی شرح وارم اپ کو لاگو کریں گے۔ keras.optimizers.schedules.LearningRateSchedule ذیلی کلاس اور keras.callbacks.Callback کال بیک سے سیکھنے کی شرح میں اضافہ کیا جائے گا۔ 0 کرنے کے لئے target_lr اور کوزائن ڈے کا اطلاق کریں، کیونکہ یہ ایک بہت ہی عام ثانوی شیڈول ہے۔ ہمیشہ کی طرح، Keras لچکدار حل کو مختلف طریقوں سے نافذ کرنا اور انہیں آپ کے نیٹ ورک کے ساتھ بھیجنا آسان بناتا ہے۔
نوٹ: نفاذ عام ہے اور اس سے متاثر ہے۔ ٹونی کے کیراس کا نفاذ میں بیان کردہ چالوں کا "Convolutional Neural نیٹ ورک کے ساتھ تصویری درجہ بندی کے لیے ترکیبوں کا بیگ".
کیراس کال بیکس کے ساتھ سیکھنے کی شرح
سیکھنے کی شرح کے کسی بھی نظام الاوقات کو لاگو کرنے کا سب سے آسان طریقہ ایک فنکشن بنانا ہے جو لیتا ہے۔ lr پیرامیٹر (float32)، اسے کچھ تبدیلی سے گزرتا ہے، اور اسے واپس کرتا ہے۔ اس فنکشن کو پھر منتقل کیا جاتا ہے۔ LearningRateScheduler کال بیک، جو فنکشن کو سیکھنے کی شرح پر لاگو کرتا ہے۔
اب، tf.keras.callbacks.LearningRateScheduler() epoch نمبر کو اس فنکشن میں منتقل کرتا ہے جسے وہ سیکھنے کی شرح کا حساب لگانے کے لیے استعمال کرتا ہے، جو کافی موٹا ہے۔ ہر ایک پر ایل آر وارم اپ کیا جانا چاہیے۔ قدم (بیچ)، دور نہیں، لہذا ہمیں ایک اخذ کرنا پڑے گا۔ global_step (تمام عہدوں میں) اس کے بجائے سیکھنے کی شرح کا حساب لگانے کے لیے، اور ذیلی کلاس Callback کلاس کو صرف فنکشن پاس کرنے کے بجائے اپنی مرضی کے مطابق کال بیک بنانے کے لیے، کیونکہ ہمیں ہر کال پر دلائل دینے کی ضرورت ہوگی، جو کہ صرف فنکشن کو پاس کرتے وقت ناممکن ہے:
def func():
return ...
keras.callbacks.LearningRateScheduler(func)
یہ نقطہ نظر اس وقت سازگار ہے جب آپ اعلیٰ درجے کی تخصیص نہیں چاہتے ہیں اور آپ کیراس کے ساتھ سلوک کرنے کے طریقے میں مداخلت نہیں کرنا چاہتے ہیں۔ lr، اور خاص طور پر اگر آپ کال بیکس استعمال کرنا چاہتے ہیں۔ ReduceLROnPlateau() چونکہ یہ صرف فلوٹ پر مبنی کے ساتھ کام کرسکتا ہے۔ lr. آئیے ایک سہولت فنکشن کے ساتھ شروع کرتے ہوئے Keras کال بیک کا استعمال کرتے ہوئے سیکھنے کی شرح وارم اپ کو نافذ کریں:
def lr_warmup_cosine_decay(global_step,
warmup_steps,
hold = 0,
total_steps=0,
start_lr=0.0,
target_lr=1e-3):
learning_rate = 0.5 * target_lr * (1 + np.cos(np.pi * (global_step - warmup_steps - hold) / float(total_steps - warmup_steps - hold)))
warmup_lr = target_lr * (global_step / warmup_steps)
if hold > 0:
learning_rate = np.where(global_step > warmup_steps + hold,
learning_rate, target_lr)
learning_rate = np.where(global_step < warmup_steps, warmup_lr, learning_rate)
return learning_rate
ہر قدم پر، ہم سیکھنے کی شرح اور وارم اپ سیکھنے کی شرح (شیڈول کے دونوں عناصر) کا حساب لگاتے ہیں۔ start_lr اور target_lr. start_lr عام طور پر شروع ہو جائے گا 0.0، جبکہ target_lr آپ کے نیٹ ورک اور آپٹیمائزر پر منحصر ہے - 1e-3 ہو سکتا ہے کہ ایک اچھا ڈیفالٹ نہ ہو، لہذا طریقہ کو کال کرتے وقت اپنا ہدف LR شروع کرنے کو یقینی بنائیں۔
اگر global_step تربیت میں سے زیادہ ہے warmup_steps ہم نے سیٹ کر لیا ہے - ہم کوزائن ڈے شیڈول LR استعمال کرتے ہیں۔ اگر نہیں، تو اس کا مطلب ہے کہ ہم ابھی بھی گرم ہو رہے ہیں، اس لیے وارم اپ LR استعمال کیا جاتا ہے۔ اگر hold دلیل مقرر ہے، ہم منعقد کریں گے target_lr وارم اپ کے بعد اور کوزائن کے زوال سے پہلے اس تعداد کے لیے۔ np.where() اس کے لیے ایک بہترین نحو فراہم کرتا ہے:
np.where(condition, value_if_true, value_if_false)
آپ فنکشن کو اس کے ساتھ تصور کر سکتے ہیں:
steps = np.arange(0, 1000, 1)
lrs = []
for step in steps:
lrs.append(lr_warmup_cosine_decay(step, total_steps=len(steps), warmup_steps=100, hold=10))
plt.plot(lrs)
اب، ہم اس فنکشن کو کال بیک کے ایک حصے کے طور پر استعمال کرنا چاہیں گے، اور آپٹیمائزر مرحلہ کو global_step کسی صوابدیدی صف کے عنصر کے بجائے – یا آپ کلاس کے اندر حساب کتاب کر سکتے ہیں۔ آئیے سبکلس کریں۔ Callback کلاس:
from keras import backend as K
class WarmupCosineDecay(keras.callbacks.Callback):
def __init__(self, total_steps=0, warmup_steps=0, start_lr=0.0, target_lr=1e-3, hold=0):
super(WarmupCosineDecay, self).__init__()
self.start_lr = start_lr
self.hold = hold
self.total_steps = total_steps
self.global_step = 0
self.target_lr = target_lr
self.warmup_steps = warmup_steps
self.lrs = []
def on_batch_end(self, batch, logs=None):
self.global_step = self.global_step + 1
lr = model.optimizer.lr.numpy()
self.lrs.append(lr)
def on_batch_begin(self, batch, logs=None):
lr = lr_warmup_cosine_decay(global_step=self.global_step,
total_steps=self.total_steps,
warmup_steps=self.warmup_steps,
start_lr=self.start_lr,
target_lr=self.target_lr,
hold=self.hold)
K.set_value(self.model.optimizer.lr, lr)
بہترین طرز عمل، صنعت کے لیے منظور شدہ معیارات، اور چیٹ شیٹ کے ساتھ Git سیکھنے کے لیے ہمارے ہینڈ آن، عملی گائیڈ کو دیکھیں۔ گوگلنگ گٹ کمانڈز کو روکیں اور اصل میں سیکھ یہ!
سب سے پہلے، ہم کلاس کے لیے کنسٹرکٹر کی وضاحت کرتے ہیں اور اس کے فیلڈز کا سراغ لگاتے ہیں۔ ختم ہونے والے ہر بیچ پر، ہم عالمی قدم بڑھائیں گے، موجودہ LR کو نوٹ کریں گے اور اسے اب تک کے LRs کی فہرست میں شامل کریں گے۔ ہر بیچ کے آغاز پر - ہم استعمال کر کے LR کا حساب لگائیں گے۔ lr_warmup_cosine_decay() فنکشن کریں اور اس LR کو آپٹیمائزر کے موجودہ LR کے طور پر سیٹ کریں۔ یہ بیک اینڈ کے ساتھ کیا جاتا ہے۔ set_value().
اس کے ساتھ - صرف کل مراحل (لمبائی/بیچ_سائز*ایپوچس) کا حساب لگائیں اور اس نمبر کا ایک حصہ اپنے لیے لیں warmup_steps:
total_steps = len(train_set)*config['EPOCHS']
warmup_steps = int(0.05*total_steps)
callback = WarmupCosineDecay(total_steps=total_steps,
warmup_steps=warmup_steps,
hold=int(warmup_steps/2),
start_lr=0.0,
target_lr=1e-3)
آخر میں، اپنا ماڈل بنائیں اور کال بیک فراہم کریں۔ fit() کال:
model = keras.applications.EfficientNetV2B0(weights=None,
classes=n_classes,
input_shape=[224, 224, 3])
model.compile(loss="sparse_categorical_crossentropy",
optimizer='adam',
jit_compile=True,
metrics=['accuracy'])
تربیت کے اختتام پر، آپ تبدیل شدہ LRs کو حاصل کر سکتے ہیں اور بذریعہ تصور کر سکتے ہیں:
lrs = callback.lrs
plt.plot(lrs)
اگر آپ LR وارم اپ کے ساتھ اور اس کے بغیر تربیت یافتہ ماڈل کی تاریخ کی منصوبہ بندی کرتے ہیں تو - آپ کو تربیت کے استحکام میں ایک واضح فرق نظر آئے گا:
LearningRateSchedule ذیلی کلاس کے ساتھ سیکھنے کی شرح
کال بیک بنانے کا ایک متبادل ایک تخلیق کرنا ہے۔ LearningRateSchedule ذیلی کلاس، جو LR میں ہیرا پھیری نہیں کرتا ہے - یہ اس کی جگہ لے لیتا ہے۔ یہ نقطہ نظر آپ کو Keras/TensorFlow کے پس منظر میں تھوڑا سا مزید پیش کرنے کی اجازت دیتا ہے، لیکن جب استعمال کیا جائے تو، LR سے متعلق دیگر کال بیکس کے ساتھ نہیں ملایا جا سکتا، جیسے ReduceLROnPlateau()، جو LRs کو فلوٹنگ پوائنٹ نمبرز کے طور پر ڈیل کرتا ہے۔
مزید برآں، ذیلی طبقے کو استعمال کرنے کے لیے آپ کو اسے سیریلائز کرنے کی ضرورت ہوگی (اوورلوڈ get_config()) جیسا کہ یہ ماڈل کا حصہ بن جاتا ہے، اگر آپ ماڈل کے وزن کو بچانا چاہتے ہیں۔ ایک اور بات قابل غور ہے کہ کلاس اس کے ساتھ خصوصی طور پر کام کرنے کی توقع کرے گی۔ tf.Tensors شکر ہے، ہمارے کام کرنے کے طریقے میں فرق صرف کال ہوگا۔ tf.func() بجائے np.func() چونکہ TensorFlow اور NumPy APIs حیرت انگیز طور پر ایک جیسے اور مطابقت پذیر ہیں۔
آئیے سہولت کو دوبارہ لکھتے ہیں۔ lr_warmup_cosine_decay() اس کے بجائے TensorFlow آپریشنز استعمال کرنے کے لیے فنکشن:
def lr_warmup_cosine_decay(global_step,
warmup_steps,
hold = 0,
total_steps=0,
start_lr=0.0,
target_lr=1e-3):
learning_rate = 0.5 * target_lr * (1 + tf.cos(tf.constant(np.pi) * (global_step - warmup_steps - hold) / float(total_steps - warmup_steps - hold)))
warmup_lr = target_lr * (global_step / warmup_steps)
if hold > 0:
learning_rate = tf.where(global_step > warmup_steps + hold,
learning_rate, target_lr)
learning_rate = tf.where(global_step < warmup_steps, warmup_lr, learning_rate)
return learning_rate
convinience فنکشن کے ساتھ، ہم ذیلی کلاس کر سکتے ہیں۔ LearningRateSchedule کلاس سب پر __call__() (بیچ)، ہم فنکشن کا استعمال کرتے ہوئے LR کا حساب لگائیں گے اور اسے واپس کریں گے۔ آپ قدرتی طور پر حساب کتاب کو ذیلی طبقے کے اندر بھی پیک کر سکتے ہیں۔
نحو اس سے زیادہ صاف ہے۔ Callback sublcass، بنیادی طور پر کیونکہ ہم تک رسائی حاصل کرتے ہیں step فیلڈ، بجائے اس کے کہ ہم خود اس پر نظر رکھیں، بلکہ طبقاتی خصوصیات کے ساتھ کام کرنا کسی حد تک مشکل بنا دیتا ہے - خاص طور پر، یہ اسے نکالنا مشکل بنا دیتا ہے۔ lr ایک سے tf.Tensor() فہرست میں ٹریک رکھنے کے لیے کسی دوسری قسم میں۔ اس کو تکنیکی طور پر بے چین موڈ میں چلا کر روکا جا سکتا ہے، لیکن ڈیبگنگ کے مقاصد کے لیے LR پر نظر رکھنے کے لیے ایک جھنجھلاہٹ پیش کرتا ہے اور اس سے بہترین پرہیز کیا جاتا ہے:
class WarmUpCosineDecay(keras.optimizers.schedules.LearningRateSchedule):
def __init__(self, start_lr, target_lr, warmup_steps, total_steps, hold):
super().__init__()
self.start_lr = start_lr
self.target_lr = target_lr
self.warmup_steps = warmup_steps
self.total_steps = total_steps
self.hold = hold
def __call__(self, step):
lr = lr_warmup_cosine_decay(global_step=step,
total_steps=self.total_steps,
warmup_steps=self.warmup_steps,
start_lr=self.start_lr,
target_lr=self.target_lr,
hold=self.hold)
return tf.where(
step > self.total_steps, 0.0, lr, name="learning_rate"
)
پیرامیٹرز ایک جیسے ہیں، اور اس کا حساب پہلے کی طرح ہی کیا جا سکتا ہے:
total_steps = len(train_set)*config['EPOCHS']
warmup_steps = int(0.05*total_steps)
schedule = WarmUpCosineDecay(start_lr=0.0, target_lr=1e-3, warmup_steps=warmup_steps, total_steps=total_steps, hold=warmup_steps)
اور ٹریننگ پائپ لائن صرف اس میں مختلف ہے کہ ہم آپٹیمائزر کے LR کو سیٹ کرتے ہیں۔ schedule:
model = keras.applications.EfficientNetV2B0(weights=None,
classes=n_classes,
input_shape=[224, 224, 3])
model.compile(loss="sparse_categorical_crossentropy",
optimizer=tf.keras.optimizers.Adam(learning_rate=schedule),
jit_compile=True,
metrics=['accuracy'])
history3 = model.fit(train_set,
epochs = config['EPOCHS'],
validation_data=valid_set)
اگر آپ ماڈل کو بچانا چاہتے ہیں تو WarmupCosineDecay شیڈول کو اوور رائیڈ کرنا پڑے گا۔ get_config() طریقہ:
def get_config(self):
config = {
'start_lr': self.start_lr,
'target_lr': self.target_lr,
'warmup_steps': self.warmup_steps,
'total_steps': self.total_steps,
'hold': self.hold
}
return config
آخر میں، ماڈل لوڈ کرتے وقت، آپ کو پاس کرنا پڑے گا۔ WarmupCosineDecay حسب ضرورت آبجیکٹ کے طور پر:
model = keras.models.load_model('weights.h5',
custom_objects={'WarmupCosineDecay', WarmupCosineDecay})
نتیجہ
اس گائیڈ میں، ہم نے لرننگ ریٹ وارم اپ کے پس پردہ وجدان پر ایک نظر ڈالی ہے – جو کہ عصبی نیٹ ورکس کی تربیت کے دوران سیکھنے کی شرح میں ہیرا پھیری کی ایک عام تکنیک ہے۔
ہم نے کوزائن ڈے کے ساتھ لرننگ ریٹ وارم اپ کو لاگو کیا ہے، جو کہ وارم اپ کے ساتھ جوڑا LR میں کمی کی سب سے عام قسم ہے۔ آپ کمی کے لیے کسی دوسرے فنکشن کو نافذ کر سکتے ہیں، یا سیکھنے کی شرح کو بالکل کم نہیں کر سکتے ہیں – اسے دوسرے کال بیکس پر چھوڑ سکتے ہیں جیسے ReduceLROnPlateau(). ہم نے سیکھنے کی شرح وارم اپ کو Keras کال بیک کے ساتھ ساتھ Keras Optimizer شیڈول کے طور پر لاگو کیا ہے اور سیکھنے کی شرح کو دوروں کے ذریعے تیار کیا ہے۔
