एमएल समुदाय दिवस 9 नवंबर है! TensorFlow, JAX से नई जानकारी के लिए हमसे जुड़ें, और अधिक जानें

TensorFlow Addons ऑप्टिमाइज़र: Cyclical LearningRate

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

अवलोकन

यह ट्यूटोरियल Addons पैकेज से साइकलिकल लर्निंग रेट के उपयोग को प्रदर्शित करता है।

चक्रीय सीखने की दरें

यह दिखाया गया है कि तंत्रिका नेटवर्क के लिए प्रशिक्षण की प्रगति के रूप में सीखने की दर को समायोजित करना फायदेमंद है। बैकप्रोपेगेशन के दौरान उत्पन्न होने वाली संख्यात्मक अस्थिरताओं को रोकने के लिए सैडल पॉइंट रिकवरी से लेकर इसके कई गुना लाभ हैं। लेकिन कोई कैसे जानता है कि किसी विशेष प्रशिक्षण टाइमस्टैम्प के संबंध में कितना समायोजन करना है? 2015 में, लेस्ली स्मिथ ने देखा कि आप हानि परिदृश्य में तेजी से आगे बढ़ने के लिए सीखने की दर में वृद्धि करना चाहते हैं, लेकिन अभिसरण के करीब पहुंचने पर आप सीखने की दर को भी कम करना चाहेंगे। इस विचार को साकार करने के लिए, उन्होंने चक्रीय सीखने की दर (सीएलआर) का प्रस्ताव रखा जहां आप एक समारोह के चक्रों के संबंध में सीखने की दर को समायोजित करेंगे। एक दृश्य प्रदर्शन के लिए, आप इस ब्लॉग को देख सकते हैं। CLR अब TensorFlow API के रूप में उपलब्ध है। अधिक जानकारी के लिए, यहां मूल पेपर देखें।

सेट अप

pip install -q -U tensorflow_addons
from tensorflow.keras import layers
import tensorflow_addons as tfa
import tensorflow as tf

import numpy as np
import matplotlib.pyplot as plt

tf.random.set_seed(42)
np.random.seed(42)

डेटासेट लोड करें और तैयार करें

(x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()

x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
8192/5148 [===============================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 0s 0us/step

हाइपरपैरामीटर को परिभाषित करें

BATCH_SIZE = 64
EPOCHS = 10
INIT_LR = 1e-4
MAX_LR = 1e-2

मॉडल निर्माण और मॉडल प्रशिक्षण उपयोगिताओं को परिभाषित करें

def get_training_model():
    model = tf.keras.Sequential(
        [
            layers.Input((28, 28, 1)),
            layers.experimental.preprocessing.Rescaling(scale=1./255),
            layers.Conv2D(16, (5, 5), activation="relu"),
            layers.MaxPooling2D(pool_size=(2, 2)),
            layers.Conv2D(32, (5, 5), activation="relu"),
            layers.MaxPooling2D(pool_size=(2, 2)),
            layers.SpatialDropout2D(0.2),
            layers.GlobalAvgPool2D(),
            layers.Dense(128, activation="relu"),
            layers.Dense(10, activation="softmax"),
        ]
    )
    return model

def train_model(model, optimizer):
    model.compile(loss="sparse_categorical_crossentropy", optimizer=optimizer,
                       metrics=["accuracy"])
    history = model.fit(x_train,
        y_train,
        batch_size=BATCH_SIZE,
        validation_data=(x_test, y_test),
        epochs=EPOCHS)
    return history

प्रतिलिपि प्रस्तुत करने योग्यता के हित में, प्रारंभिक मॉडल भारों को क्रमबद्ध किया जाता है जिसका उपयोग आप हमारे प्रयोग करने के लिए करेंगे।

initial_model = get_training_model()
initial_model.save("initial_model")
WARNING:tensorflow:Please add `keras.layers.InputLayer` instead of `keras.Input` to Sequential model. `keras.Input` is intended to be used by Functional model.
WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.
INFO:tensorflow:Assets written to: initial_model/assets

सीएलआर के बिना एक मॉडल को प्रशिक्षित करें

standard_model = tf.keras.models.load_model("initial_model")
no_clr_history = train_model(standard_model, optimizer="sgd")
WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.
Epoch 1/10
938/938 [==============================] - 11s 12ms/step - loss: 2.2091 - accuracy: 0.2183 - val_loss: 1.7595 - val_accuracy: 0.4123
Epoch 2/10
938/938 [==============================] - 10s 11ms/step - loss: 1.2961 - accuracy: 0.5130 - val_loss: 0.9587 - val_accuracy: 0.6489
Epoch 3/10
938/938 [==============================] - 10s 11ms/step - loss: 1.0104 - accuracy: 0.6182 - val_loss: 0.9155 - val_accuracy: 0.6576
Epoch 4/10
938/938 [==============================] - 10s 11ms/step - loss: 0.9276 - accuracy: 0.6570 - val_loss: 0.8495 - val_accuracy: 0.7016
Epoch 5/10
938/938 [==============================] - 10s 11ms/step - loss: 0.8856 - accuracy: 0.6719 - val_loss: 0.8399 - val_accuracy: 0.6664
Epoch 6/10
938/938 [==============================] - 10s 11ms/step - loss: 0.8482 - accuracy: 0.6850 - val_loss: 0.7982 - val_accuracy: 0.6818
Epoch 7/10
938/938 [==============================] - 10s 11ms/step - loss: 0.8219 - accuracy: 0.6941 - val_loss: 0.7609 - val_accuracy: 0.7008
Epoch 8/10
938/938 [==============================] - 10s 11ms/step - loss: 0.7996 - accuracy: 0.7011 - val_loss: 0.7267 - val_accuracy: 0.7271
Epoch 9/10
938/938 [==============================] - 10s 11ms/step - loss: 0.7833 - accuracy: 0.7064 - val_loss: 0.7157 - val_accuracy: 0.7450
Epoch 10/10
938/938 [==============================] - 10s 11ms/step - loss: 0.7640 - accuracy: 0.7135 - val_loss: 0.7017 - val_accuracy: 0.7465

सीएलआर शेड्यूल को परिभाषित करें

tfa.optimizers.CyclicalLearningRate मॉड्यूल एक सीधा शेड्यूल देता है जिसे एक ऑप्टिमाइज़र को पास किया जा सकता है। शेड्यूल अपने इनपुट के रूप में एक कदम उठाता है और पेपर में निर्धारित सीएलआर फॉर्मूला का उपयोग करके गणना किए गए मूल्य को आउटपुट करता है।

steps_per_epoch = len(x_train) // BATCH_SIZE
clr = tfa.optimizers.CyclicalLearningRate(initial_learning_rate=INIT_LR,
    maximal_learning_rate=MAX_LR,
    scale_fn=lambda x: 1/(2.**(x-1)),
    step_size=2 * steps_per_epoch
)
optimizer = tf.keras.optimizers.SGD(clr)

यहां, आप सीखने की दर की निचली और ऊपरी सीमा निर्दिष्ट करते हैं और शेड्यूल उस सीमा के बीच में दोलन करेगा ([1e-4, 1e-2] इस मामले में)। scale_fn का उपयोग उस फ़ंक्शन को परिभाषित करने के लिए किया जाता है जो किसी दिए गए चक्र के भीतर सीखने की दर को scale_fn है। step_size एकल चक्र की अवधि को परिभाषित करता है। step_size 2 का मतलब है कि आपको एक चक्र पूरा करने के लिए कुल 4 पुनरावृत्तियों की आवश्यकता है। step_size लिए अनुशंसित मान इस प्रकार है:

factor * steps_per_epoch जहाँ फ़ैक्टर [2, 8] रेंज के भीतर है।

उसी सीएलआर पेपर में , लेस्ली ने सीखने की दर के लिए सीमा चुनने के लिए एक सरल और सुरुचिपूर्ण तरीका भी प्रस्तुत किया। आपको इसे भी जांचने के लिए प्रोत्साहित किया जाता है। यह ब्लॉग पोस्ट विधि के लिए एक अच्छा परिचय प्रदान करता है।

नीचे, आप कल्पना करते हैं कि clr शेड्यूल कैसा दिखता है।

step = np.arange(0, EPOCHS * steps_per_epoch)
lr = clr(step)
plt.plot(step, lr)
plt.xlabel("Steps")
plt.ylabel("Learning Rate")
plt.show()

पीएनजी

सीएलआर के प्रभाव को बेहतर ढंग से देखने के लिए, आप अधिक चरणों के साथ शेड्यूल तैयार कर सकते हैं।

०७६७९बी२२९०

पीएनजी

इस ट्यूटोरियल में आप जिस फ़ंक्शन का उपयोग कर रहे हैं, उसे CLR पेपर में triangular2 मेथड कहा जाता है। वहाँ अन्य दो कार्य हैं जिनका पता लगाया गया था अर्थात् triangular और namely exp (घातांक के लिए छोटा)।

CLR . के साथ एक मॉडल को प्रशिक्षित करें

clr_model = tf.keras.models.load_model("initial_model")
clr_history = train_model(clr_model, optimizer=optimizer)
WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.
Epoch 1/10
938/938 [==============================] - 11s 11ms/step - loss: 2.3005 - accuracy: 0.1165 - val_loss: 2.2852 - val_accuracy: 0.2377
Epoch 2/10
938/938 [==============================] - 10s 11ms/step - loss: 2.1931 - accuracy: 0.2398 - val_loss: 1.7386 - val_accuracy: 0.4523
Epoch 3/10
938/938 [==============================] - 10s 11ms/step - loss: 1.3131 - accuracy: 0.5053 - val_loss: 1.0110 - val_accuracy: 0.6492
Epoch 4/10
938/938 [==============================] - 10s 11ms/step - loss: 1.0746 - accuracy: 0.5934 - val_loss: 0.9492 - val_accuracy: 0.6621
Epoch 5/10
938/938 [==============================] - 10s 11ms/step - loss: 1.0528 - accuracy: 0.6029 - val_loss: 0.9439 - val_accuracy: 0.6518
Epoch 6/10
938/938 [==============================] - 11s 11ms/step - loss: 1.0197 - accuracy: 0.6170 - val_loss: 0.9096 - val_accuracy: 0.6622
Epoch 7/10
938/938 [==============================] - 10s 11ms/step - loss: 0.9778 - accuracy: 0.6337 - val_loss: 0.8784 - val_accuracy: 0.6748
Epoch 8/10
938/938 [==============================] - 10s 11ms/step - loss: 0.9534 - accuracy: 0.6486 - val_loss: 0.8665 - val_accuracy: 0.6901
Epoch 9/10
938/938 [==============================] - 10s 11ms/step - loss: 0.9510 - accuracy: 0.6497 - val_loss: 0.8690 - val_accuracy: 0.6856
Epoch 10/10
938/938 [==============================] - 11s 11ms/step - loss: 0.9424 - accuracy: 0.6529 - val_loss: 0.8570 - val_accuracy: 0.6918

जैसा कि अपेक्षित था, नुकसान सामान्य से अधिक शुरू होता है और फिर चक्र की प्रगति के रूप में यह स्थिर हो जाता है। आप नीचे दिए गए भूखंडों के साथ नेत्रहीन इसकी पुष्टि कर सकते हैं।

नुकसान की कल्पना करें

(fig, ax) = plt.subplots(2, 1, figsize=(10, 8))

ax[0].plot(no_clr_history.history["loss"], label="train_loss")
ax[0].plot(no_clr_history.history["val_loss"], label="val_loss")
ax[0].set_title("No CLR")
ax[0].set_xlabel("Epochs")
ax[0].set_ylabel("Loss")
ax[0].set_ylim([0, 2.5])
ax[0].legend()

ax[1].plot(clr_history.history["loss"], label="train_loss")
ax[1].plot(clr_history.history["val_loss"], label="val_loss")
ax[1].set_title("CLR")
ax[1].set_xlabel("Epochs")
ax[1].set_ylabel("Loss")
ax[1].set_ylim([0, 2.5])
ax[1].legend()

fig.tight_layout(pad=3.0)
fig.show()

पीएनजी

भले ही इस खिलौना उदाहरण के लिए, आपने सीएलआर के प्रभावों को ज्यादा नहीं देखा, लेकिन ध्यान दें कि यह सुपर कन्वर्जेंस के पीछे मुख्य अवयवों में से एक है और बड़े पैमाने पर सेटिंग्स में प्रशिक्षण के दौरान वास्तव में अच्छा प्रभाव डाल सकता है।