तिथि को रक्षित करें! Google I / O 18-20 मई को पंजीकृत करता है
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

अंतर्निहित विधियों के साथ प्रशिक्षण और मूल्यांकन

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

सेट अप

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

परिचय

यह मार्गदर्शिका प्रशिक्षण, मूल्यांकन और भविष्यवाणी (अनुमान) मॉडल को शामिल करती है जब प्रशिक्षण और सत्यापन के लिए बिल्ट-इन एपीआई का उपयोग करते हैं (जैसे कि Model.fit() , Model.evaluate() और Model.predict() )।

यदि आप अपने स्वयं के प्रशिक्षण कदम समारोह को निर्दिष्ट करते हुए fit() लाभ उठाने में रुचि रखते हैं, तो fit() गाइड में क्या होता है को अनुकूलित करें देखें।

यदि आप स्क्रैच से अपने स्वयं के प्रशिक्षण और मूल्यांकन छोरों को लिखने में रुचि रखते हैं, तो गाइड को "स्क्रैच से एक प्रशिक्षण लूप लिखना" देखें

सामान्य तौर पर, चाहे आप बिल्ट-इन लूप का उपयोग कर रहे हों या अपना स्वयं का लिख ​​रहे हों, मॉडल प्रशिक्षण और मूल्यांकन हर तरह के कर्स मॉडल में समान रूप से काम करता है - अनुक्रमिक मॉडल, कार्यात्मक एपीआई के साथ निर्मित मॉडल, और खरोंच से लिखे गए मॉडल मॉडल उपवर्ग।

यह गाइड वितरित प्रशिक्षण को कवर नहीं करता है, जो मल्टी-जीपीयू और वितरित प्रशिक्षण के लिए हमारे गाइड में शामिल है।

एपीआई अवलोकन: एक पहला एंड-टू-एंड उदाहरण

किसी मॉडल के अंतर्निहित प्रशिक्षण लूप में डेटा पास करते समय, आपको या तो NumPy सरणियों का उपयोग करना चाहिए (यदि आपका डेटा छोटा है और मेमोरी में फिट बैठता है) या tf.data Dataset ऑब्जेक्ट । अगले कुछ पैराग्राफों में, हम ऑप्टिमाइज़र, लॉस और मेट्रिक्स का उपयोग करने के तरीके को प्रदर्शित करने के लिए, एमएनआईएसटी डेटासेट का उपयोग न्यूपे एरेज़ के रूप में करेंगे।

आइए निम्नलिखित मॉडल पर विचार करें (यहां, हम कार्यात्मक एपीआई के साथ निर्माण करते हैं, लेकिन यह एक अनुक्रमिक मॉडल या एक उपवर्ग मॉडल भी हो सकता है):

inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = layers.Dense(10, activation="softmax", name="predictions")(x)

model = keras.Model(inputs=inputs, outputs=outputs)

यहां बताया गया है कि सामान्य एंड-टू-एंड वर्कफ़्लो कैसा दिखता है, जिसमें निम्न शामिल हैं:

  • प्रशिक्षण
  • मूल प्रशिक्षण डेटा से उत्पन्न होल्डआउट सेट पर मान्यता
  • परीक्षण डेटा पर मूल्यांकन

हम इस उदाहरण के लिए MNIST डेटा का उपयोग करेंगे।

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

# Preprocess the data (these are NumPy arrays)
x_train = x_train.reshape(60000, 784).astype("float32") / 255
x_test = x_test.reshape(10000, 784).astype("float32") / 255

y_train = y_train.astype("float32")
y_test = y_test.astype("float32")

# Reserve 10,000 samples for validation
x_val = x_train[-10000:]
y_val = y_train[-10000:]
x_train = x_train[:-10000]
y_train = y_train[:-10000]
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step

हम प्रशिक्षण विन्यास (अनुकूलक, हानि, मैट्रिक्स) निर्दिष्ट करते हैं:

model.compile(
    optimizer=keras.optimizers.RMSprop(),  # Optimizer
    # Loss function to minimize
    loss=keras.losses.SparseCategoricalCrossentropy(),
    # List of metrics to monitor
    metrics=[keras.metrics.SparseCategoricalAccuracy()],
)

हम फोन fit() है, जो आकार का "बैचों" में डेटा टुकड़ा करने की क्रिया द्वारा मॉडल को प्रशिक्षित करेंगे batch_size , और बार बार की दी गई संख्या के लिए पूरे डाटासेट से अधिक पुनरावृत्ति epochs

print("Fit model on training data")
history = model.fit(
    x_train,
    y_train,
    batch_size=64,
    epochs=2,
    # We pass some validation for
    # monitoring validation loss and metrics
    # at the end of each epoch
    validation_data=(x_val, y_val),
)
Fit model on training data
Epoch 1/2
782/782 [==============================] - 3s 3ms/step - loss: 0.5769 - sparse_categorical_accuracy: 0.8386 - val_loss: 0.1833 - val_sparse_categorical_accuracy: 0.9464
Epoch 2/2
782/782 [==============================] - 2s 2ms/step - loss: 0.1621 - sparse_categorical_accuracy: 0.9518 - val_loss: 0.1467 - val_sparse_categorical_accuracy: 0.9579

लौटा history वस्तु प्रशिक्षण के दौरान नुकसान के मूल्यों और मीट्रिक मूल्यों का रिकॉर्ड रखती है:

history.history
{'loss': [0.3323673903942108, 0.15159013867378235],
 'sparse_categorical_accuracy': [0.9050800204277039, 0.9542400240898132],
 'val_loss': [0.18328842520713806, 0.14667865633964539],
 'val_sparse_categorical_accuracy': [0.946399986743927, 0.9578999876976013]}

हम मूल्यांकन के माध्यम से परीक्षण डेटा पर मॉडल का evaluate() :

02 बी डी 2 ए 5430
Evaluate on test data
79/79 [==============================] - 0s 2ms/step - loss: 0.1449 - sparse_categorical_accuracy: 0.9539
test loss, test acc: [0.14493884146213531, 0.9538999795913696]
Generate predictions for 3 samples
predictions shape: (3, 10)

अब, चलिए इस वर्कफ़्लो के प्रत्येक टुकड़े की विस्तार से समीक्षा करते हैं।

compile() विधि: एक हानि, मैट्रिक्स और एक ऑप्टिमाइज़र निर्दिष्ट करना

fit() साथ एक मॉडल को प्रशिक्षित करने के लिए, आपको एक हार फ़ंक्शन, एक ऑप्टिमाइज़र और वैकल्पिक रूप से, मॉनिटर करने के लिए कुछ मैट्रिक्स निर्दिष्ट करने की आवश्यकता है।

आप compile() विधि के तर्क के रूप में मॉडल को पास करते हैं:

model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(),
    metrics=[keras.metrics.SparseCategoricalAccuracy()],
)

metrics तर्क एक सूची होनी चाहिए - आपके मॉडल में किसी भी संख्या में मीट्रिक हो सकते हैं।

यदि आपके मॉडल में कई आउटपुट हैं, तो आप प्रत्येक आउटपुट के लिए अलग-अलग नुकसान और मैट्रिक्स निर्दिष्ट कर सकते हैं, और आप मॉडल के कुल नुकसान में प्रत्येक आउटपुट के योगदान को संशोधित कर सकते हैं। इसके बारे में अधिक विवरण आपको पासिंग डेटा से मल्टी-इनपुट, मल्टी-आउटपुट मॉडल सेक्शन में मिलेगा।

ध्यान दें कि यदि आप डिफ़ॉल्ट सेटिंग्स से संतुष्ट हैं, तो कई मामलों में स्ट्रिंग पहचानकर्ताओं के माध्यम से ऑप्टिमाइज़र, लॉस और मेट्रिक्स निर्दिष्ट किए जा सकते हैं:

model.compile(
    optimizer="rmsprop",
    loss="sparse_categorical_crossentropy",
    metrics=["sparse_categorical_accuracy"],
)

बाद में पुन: उपयोग के लिए, आइए हम अपने मॉडल की परिभाषा रखें और कार्यों में संकलन करें; हम इस गाइड में विभिन्न उदाहरणों में कई बार उन्हें कॉल करेंगे।

def get_uncompiled_model():
    inputs = keras.Input(shape=(784,), name="digits")
    x = layers.Dense(64, activation="relu", name="dense_1")(inputs)
    x = layers.Dense(64, activation="relu", name="dense_2")(x)
    outputs = layers.Dense(10, activation="softmax", name="predictions")(x)
    model = keras.Model(inputs=inputs, outputs=outputs)
    return model


def get_compiled_model():
    model = get_uncompiled_model()
    model.compile(
        optimizer="rmsprop",
        loss="sparse_categorical_crossentropy",
        metrics=["sparse_categorical_accuracy"],
    )
    return model

कई बिल्ट-इन ऑप्टिमाइज़र, नुकसान और मैट्रिक्स उपलब्ध हैं

सामान्य तौर पर, आपको स्क्रैच से अपने स्वयं के नुकसान, मीट्रिक या ऑप्टिमाइज़र बनाने की ज़रूरत नहीं होगी, क्योंकि आपको जो आवश्यकता है वह पहले से ही केरस एपीआई का हिस्सा हो सकता है:

ऑप्टिमाइज़र:

  • SGD() या (गति के बिना)
  • RMSprop()
  • Adam()
  • आदि।

नुकसान:

  • MeanSquaredError()
  • KLDivergence()
  • CosineSimilarity()
  • आदि।

मेट्रिक्स:

  • AUC()
  • Precision()
  • Recall()
  • आदि।

कस्टम नुकसान

यदि आपको एक कस्टम लॉस बनाने की आवश्यकता है, तो केरस ऐसा करने के दो तरीके प्रदान करता है।

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

def custom_mean_squared_error(y_true, y_pred):
    return tf.math.reduce_mean(tf.square(y_true - y_pred))


model = get_uncompiled_model()
model.compile(optimizer=keras.optimizers.Adam(), loss=custom_mean_squared_error)

# We need to one-hot encode the labels to use MSE
y_train_one_hot = tf.one_hot(y_train, depth=10)
model.fit(x_train, y_train_one_hot, batch_size=64, epochs=1)
782/782 [==============================] - 1s 1ms/step - loss: 0.0272
<tensorflow.python.keras.callbacks.History at 0x7fb6b01c09e8>

यदि आपको y_true और y_pred पास पैरामीटर में एक हानि फ़ंक्शन की आवश्यकता y_pred , तो आप tf.keras.losses.Loss वर्ग को उप-वर्ग कर सकते हैं और निम्नलिखित दो विधियों को लागू कर सकते हैं:

  • __init__(self) : अपने नुकसान फ़ंक्शन के कॉल के दौरान पारित करने के लिए मापदंडों को स्वीकार करें
  • call(self, y_true, y_pred) : मॉडल के नुकसान की गणना करने के लिए लक्ष्य (y_true) और मॉडल की भविष्यवाणी (y_pred) का उपयोग करें

मान लीजिए कि आप औसत चुकता त्रुटि का उपयोग करना चाहते हैं, लेकिन एक अतिरिक्त शब्द के साथ जो 0.5 से दूर की भविष्यवाणी मूल्यों को बढ़ावा देगा (हम मानते हैं कि श्रेणीबद्ध लक्ष्य एक-गर्म एन्कोडेड हैं और 0 और 1 के बीच मान लेते हैं)। यह मॉडल के लिए बहुत अधिक आश्वस्त न होने के लिए एक प्रोत्साहन बनाता है, जो ओवरफिटिंग को कम करने में मदद कर सकता है (हम यह नहीं जान पाएंगे कि जब तक हम कोशिश नहीं करते!)।

यहां बताया गया है कि आप इसे कैसे करेंगे:

class CustomMSE(keras.losses.Loss):
    def __init__(self, regularization_factor=0.1, name="custom_mse"):
        super().__init__(name=name)
        self.regularization_factor = regularization_factor

    def call(self, y_true, y_pred):
        mse = tf.math.reduce_mean(tf.square(y_true - y_pred))
        reg = tf.math.reduce_mean(tf.square(0.5 - y_pred))
        return mse + reg * self.regularization_factor


model = get_uncompiled_model()
model.compile(optimizer=keras.optimizers.Adam(), loss=CustomMSE())

y_train_one_hot = tf.one_hot(y_train, depth=10)
model.fit(x_train, y_train_one_hot, batch_size=64, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 0.0489
<tensorflow.python.keras.callbacks.History at 0x7fb6b00725f8>

कस्टम मेट्रिक्स

यदि आपको एक मीट्रिक की आवश्यकता है जो एपीआई का हिस्सा नहीं है, तो आप आसानी से tf.keras.metrics.Metric वर्ग को उप-वर्ग करके कस्टम मीट्रिक बना सकते हैं। आपको 4 विधियों को लागू करने की आवश्यकता होगी:

  • __init__(self) , जिसमें आप अपने मीट्रिक के लिए राज्य चर बनाएंगे।
  • update_state(self, y_true, y_pred, sample_weight=None) , जो लक्ष्य y_true और मॉडल की भविष्यवाणी का उपयोग करता है y_pred राज्य चर को अद्यतन करने के लिए।
  • result(self) , जो अंतिम परिणामों की गणना करने के लिए राज्य चर का उपयोग करता है।
  • reset_states(self) , जो मीट्रिक की स्थिति को फिर से reset_states(self) करता है।

राज्य अद्यतन और परिणाम संगणना को अलग-अलग रखा जाता है ( update_state() और result() , क्योंकि कुछ मामलों में, परिणाम गणना बहुत महंगी हो सकती है और केवल समय-समय पर की जाएगी।

यहाँ एक सरल उदाहरण दिखाया गया है कि कैसे एक CategoricalTruePositives गुणात्मक मीट्रिक को लागू किया जाए जो यह बताता है कि दिए गए वर्ग से संबंधित कितने नमूनों को सही ढंग से वर्गीकृत किया गया है:

class CategoricalTruePositives(keras.metrics.Metric):
    def __init__(self, name="categorical_true_positives", **kwargs):
        super(CategoricalTruePositives, self).__init__(name=name, **kwargs)
        self.true_positives = self.add_weight(name="ctp", initializer="zeros")

    def update_state(self, y_true, y_pred, sample_weight=None):
        y_pred = tf.reshape(tf.argmax(y_pred, axis=1), shape=(-1, 1))
        values = tf.cast(y_true, "int32") == tf.cast(y_pred, "int32")
        values = tf.cast(values, "float32")
        if sample_weight is not None:
            sample_weight = tf.cast(sample_weight, "float32")
            values = tf.multiply(values, sample_weight)
        self.true_positives.assign_add(tf.reduce_sum(values))

    def result(self):
        return self.true_positives

    def reset_states(self):
        # The state of the metric will be reset at the start of each epoch.
        self.true_positives.assign(0.0)


model = get_uncompiled_model()
model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(),
    metrics=[CategoricalTruePositives()],
)
model.fit(x_train, y_train, batch_size=64, epochs=3)
07fbb31c0

नुकसान और मैट्रिक्स को संभालना जो मानक हस्ताक्षर के लायक नहीं है

नुकसान और मैट्रिक्स के भारी बहुमत की गणना y_true और y_pred से की जा सकती है, जहां y_pred आपके मॉडल का आउटपुट है - लेकिन उनमें से सभी नहीं। उदाहरण के लिए, एक नियमितीकरण हानि के लिए केवल एक परत के सक्रियण की आवश्यकता हो सकती है (इस मामले में कोई लक्ष्य नहीं हैं), और यह सक्रियण एक मॉडल आउटपुट नहीं हो सकता है।

ऐसे मामलों में, आप कस्टम लेयर की कॉल विधि के अंदर से self.add_loss(loss_value) कॉल कर सकते हैं। इस तरह से जोड़े गए नुकसान प्रशिक्षण के दौरान "मुख्य" नुकसान में जुड़ जाते हैं (एक compile() करने के compile() पारित compile() )। यहां एक सरल उदाहरण है जो गतिविधि नियमितीकरण जोड़ता है (ध्यान दें कि गतिविधि नियमितीकरण अंतर्निहित है सभी केरस परतों में - यह परत सिर्फ एक ठोस उदाहरण प्रदान करने के लिए है):

class ActivityRegularizationLayer(layers.Layer):
    def call(self, inputs):
        self.add_loss(tf.reduce_sum(inputs) * 0.1)
        return inputs  # Pass-through layer.


inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu", name="dense_1")(inputs)

# Insert activity regularization as a layer
x = ActivityRegularizationLayer()(x)

x = layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = layers.Dense(10, name="predictions")(x)

model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
)

# The displayed loss will be much higher than before
# due to the regularization component.
model.fit(x_train, y_train, batch_size=64, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 3.4140
<tensorflow.python.keras.callbacks.History at 0x7fb6a4233748>

आप add_metric() का उपयोग करके मीट्रिक मान लॉग करने के लिए भी ऐसा कर सकते हैं:

class MetricLoggingLayer(layers.Layer):
    def call(self, inputs):
        # The `aggregation` argument defines
        # how to aggregate the per-batch values
        # over each epoch:
        # in this case we simply average them.
        self.add_metric(
            keras.backend.std(inputs), name="std_of_activation", aggregation="mean"
        )
        return inputs  # Pass-through layer.


inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu", name="dense_1")(inputs)

# Insert std logging as a layer.
x = MetricLoggingLayer()(x)

x = layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = layers.Dense(10, name="predictions")(x)

model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
)
model.fit(x_train, y_train, batch_size=64, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 0.5646 - std_of_activation: 0.9702
<tensorflow.python.keras.callbacks.History at 0x7fb6a40cf6a0>

फ़ंक्शनल एपीआई में , आप model.add_loss(loss_tensor) , या model.add_metric(metric_tensor, name, aggregation) भी कह सकते हैं।

यहाँ एक सरल उदाहरण है:

inputs = keras.Input(shape=(784,), name="digits")
x1 = layers.Dense(64, activation="relu", name="dense_1")(inputs)
x2 = layers.Dense(64, activation="relu", name="dense_2")(x1)
outputs = layers.Dense(10, name="predictions")(x2)
model = keras.Model(inputs=inputs, outputs=outputs)

model.add_loss(tf.reduce_sum(x1) * 0.1)

model.add_metric(keras.backend.std(x1), name="std_of_activation", aggregation="mean")

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
)
model.fit(x_train, y_train, batch_size=64, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 3.6195 - std_of_activation: 0.0020
<tensorflow.python.keras.callbacks.History at 0x7fb6a07d42b0>

ध्यान दें कि जब आप add_loss() माध्यम से नुकसान से add_loss() , तो एक नुकसान फ़ंक्शन के बिना compile() को कॉल compile() संभव हो जाता है, क्योंकि मॉडल में पहले से ही कम से कम नुकसान होता है।

निम्नलिखित LogisticEndpoint परत पर विचार करें: यह इनपुट लक्ष्य और लॉग के रूप में लेता है, और यह add_loss() माध्यम से add_loss() हानि को ट्रैक करता है। यह add_metric() माध्यम से वर्गीकरण सटीकता को भी ट्रैक करता है।

class LogisticEndpoint(keras.layers.Layer):
    def __init__(self, name=None):
        super(LogisticEndpoint, self).__init__(name=name)
        self.loss_fn = keras.losses.BinaryCrossentropy(from_logits=True)
        self.accuracy_fn = keras.metrics.BinaryAccuracy()

    def call(self, targets, logits, sample_weights=None):
        # Compute the training-time loss value and add it
        # to the layer using `self.add_loss()`.
        loss = self.loss_fn(targets, logits, sample_weights)
        self.add_loss(loss)

        # Log accuracy as a metric and add it
        # to the layer using `self.add_metric()`.
        acc = self.accuracy_fn(targets, logits, sample_weights)
        self.add_metric(acc, name="accuracy")

        # Return the inference-time prediction tensor (for `.predict()`).
        return tf.nn.softmax(logits)

आप दो इनपुट (इनपुट डेटा और लक्ष्य) के साथ एक मॉडल में इसका उपयोग कर सकते हैं, एक loss तर्क के बिना संकलित, इस तरह से:

import numpy as np

inputs = keras.Input(shape=(3,), name="inputs")
targets = keras.Input(shape=(10,), name="targets")
logits = keras.layers.Dense(10)(inputs)
predictions = LogisticEndpoint(name="predictions")(logits, targets)

model = keras.Model(inputs=[inputs, targets], outputs=predictions)
model.compile(optimizer="adam")  # No loss argument!

data = {
    "inputs": np.random.random((3, 3)),
    "targets": np.random.random((3, 10)),
}
model.fit(data)
1/1 [==============================] - 0s 222ms/step - loss: 0.9652 - binary_accuracy: 0.0000e+00
<tensorflow.python.keras.callbacks.History at 0x7fb6a05e01d0>

मल्टी-इनपुट मॉडल के प्रशिक्षण के बारे में अधिक जानकारी के लिए, मल्टी-इनपुट, मल्टी-आउटपुट मॉडल को डेटा पास करना अनुभाग देखें।

स्वचालित रूप से एक सत्यापन होल्डआउट सेट करने के अलावा

पहली एंड-टू-एंड उदाहरण आपने देखा में, हम इस्तेमाल किया validation_data NumPy सरणी के एक टपल पारित करने के लिए तर्क (x_val, y_val) प्रत्येक युग के अंत में एक मान्यता नुकसान और सत्यापन मीट्रिक का मूल्यांकन करने के लिए मॉडल के लिए।

यहां एक अन्य विकल्प है: तर्क validation_split आपको validation_split के लिए अपने प्रशिक्षण डेटा का हिस्सा स्वचालित रूप से आरक्षित करने की अनुमति देता है। तर्क मान सत्यापन के लिए आरक्षित किए जाने वाले डेटा के अंश का प्रतिनिधित्व करता है, इसलिए इसे 0 से अधिक संख्या में सेट किया जाना चाहिए और 1. से कम होना चाहिए। उदाहरण के लिए, validation_split=0.2 अर्थ है "सत्यापन के लिए डेटा का 20% उपयोग करें", और validation_split=0.6 अर्थ है " validation_split=0.6 के लिए डेटा का 60% उपयोग करें"।

जिस तरह से सत्यापन की गणना की जाती है, वह fit() कॉल से प्राप्त सरणियों के अंतिम x% नमूनों को किसी भी हड़बड़ी से पहले लेने से होती है।

ध्यान दें कि आप केवल NumPy डेटा के साथ प्रशिक्षण के दौरान validation_split उपयोग कर सकते हैं।

model = get_compiled_model()
model.fit(x_train, y_train, batch_size=64, validation_split=0.2, epochs=1)
625/625 [==============================] - 2s 2ms/step - loss: 0.6075 - sparse_categorical_accuracy: 0.8389 - val_loss: 0.2291 - val_sparse_categorical_accuracy: 0.9322
<tensorflow.python.keras.callbacks.History at 0x7fb6a0504240>

प्रशिक्षण और मूल्यांकन से tf.data डेटासेट

पिछले कुछ पैराग्राफ में, आप देखा है कि कैसे नुकसान, मैट्रिक्स, और अनुकूलक को संभालने के लिए, और आप देखा है कि कैसे उपयोग करने के लिए validation_data और validation_split में तर्क fit() , जब आपके डेटा को NumPy सरणी के रूप में पारित कर दिया है।

आइए अब उस मामले पर एक नज़र डालते हैं जहां आपका डेटाtf.data.Dataset ऑब्जेक्ट के रूप में आता है।

tf.data API एक तेज़ और स्केलेबल डेटा को लोड करने और प्रीप्रोसेसिंग के लिए TensorFlow 2.0 में उपयोगिताओं का एक सेट है।

Datasets बनाने के बारे में पूरी गाइड के लिए, tf.data प्रलेखन देखें।

आप fit() , evaluate() , और predict() के तरीकों से सीधे एक Dataset उदाहरण पारित कर सकते हैं:

model = get_compiled_model()

# First, let's create a training Dataset instance.
# For the sake of our example, we'll use the same MNIST data as before.
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
# Shuffle and slice the dataset.
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

# Now we get a test dataset.
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))
test_dataset = test_dataset.batch(64)

# Since the dataset already takes care of batching,
# we don't pass a `batch_size` argument.
model.fit(train_dataset, epochs=3)

# You can also evaluate or predict on a dataset.
print("Evaluate")
result = model.evaluate(test_dataset)
dict(zip(model.metrics_names, result))
Epoch 1/3
782/782 [==============================] - 2s 2ms/step - loss: 0.5652 - sparse_categorical_accuracy: 0.8404
Epoch 2/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1721 - sparse_categorical_accuracy: 0.9497
Epoch 3/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1170 - sparse_categorical_accuracy: 0.9645
Evaluate
157/157 [==============================] - 0s 2ms/step - loss: 0.1308 - sparse_categorical_accuracy: 0.9602
{'loss': 0.13075917959213257,
 'sparse_categorical_accuracy': 0.9602000117301941}

ध्यान दें कि डेटासेट प्रत्येक युग के अंत में रीसेट हो जाता है, इसलिए इसे अगले युग का पुन: उपयोग किया जा सकता है।

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

यदि आप ऐसा करते हैं, तो प्रत्येक युग के अंत में डेटासेट रीसेट नहीं होता है, इसके बजाय हम बस अगले बैचों को खींचते रहते हैं। डेटासेट अंततः डेटा से बाहर चला जाएगा (जब तक कि यह एक अनन्त-लूपिंग डेटासेट नहीं है)।

0a0081a00
Epoch 1/3
100/100 [==============================] - 1s 2ms/step - loss: 1.2664 - sparse_categorical_accuracy: 0.6389
Epoch 2/3
100/100 [==============================] - 0s 2ms/step - loss: 0.3868 - sparse_categorical_accuracy: 0.8875
Epoch 3/3
100/100 [==============================] - 0s 2ms/step - loss: 0.3578 - sparse_categorical_accuracy: 0.8981
<tensorflow.python.keras.callbacks.History at 0x7fb6a02a5358>

एक सत्यापन डेटासेट का उपयोग करना

आप fit() में validation_data तर्क के रूप में Dataset उदाहरण पास कर सकते हैं:

model = get_compiled_model()

# Prepare the training dataset
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

# Prepare the validation dataset
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(64)

model.fit(train_dataset, epochs=1, validation_data=val_dataset)
782/782 [==============================] - 2s 3ms/step - loss: 0.5754 - sparse_categorical_accuracy: 0.8384 - val_loss: 0.1829 - val_sparse_categorical_accuracy: 0.9465
<tensorflow.python.keras.callbacks.History at 0x7fb6a01651d0>

प्रत्येक युग के अंत में, मॉडल सत्यापन डेटासेट पर पुनरावृत्ति करेगा और सत्यापन हानि और सत्यापन मैट्रिक्स की गणना करेगा।

यदि आप इस डेटासेट से केवल कुछ बैचों पर सत्यापन चलाना चाहते हैं, तो आप validation_steps तर्क पारित कर सकते हैं, जो निर्दिष्ट करता है कि सत्यापन को बाधित करने और अगले युग में जाने से पहले मॉडल को सत्यापन डेटासेट के साथ कितने सत्यापन चरण चलना चाहिए:

model = get_compiled_model()

# Prepare the training dataset
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

# Prepare the validation dataset
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(64)

model.fit(
    train_dataset,
    epochs=1,
    # Only run validation using the first 10 batches of the dataset
    # using the `validation_steps` argument
    validation_data=val_dataset,
    validation_steps=10,
)
782/782 [==============================] - 2s 2ms/step - loss: 0.5503 - sparse_categorical_accuracy: 0.8507 - val_loss: 0.3296 - val_sparse_categorical_accuracy: 0.9062
<tensorflow.python.keras.callbacks.History at 0x7fb6a02e4630>

ध्यान दें कि सत्यापन डेटासेट प्रत्येक उपयोग के बाद रीसेट हो जाएगा (ताकि आप हमेशा समान नमूनों पर युगांतर से युगांतर तक का मूल्यांकन करेंगे)।

Dataset ऑब्जेक्ट्स से प्रशिक्षण के दौरान तर्क validation_split (प्रशिक्षण डेटा से एक सेटआउट उत्पन्न करना) समर्थित नहीं है, क्योंकि इस सुविधा के लिए डेटासेट के नमूनों को सूचीबद्ध करने की क्षमता की आवश्यकता होती है, जो Dataset एपीआई के साथ सामान्य रूप से संभव नहीं है।

अन्य इनपुट स्वरूपों का समर्थन किया

NumPy सरणी, उत्सुक tensors, और TensorFlow इसके अलावा Datasets , यह पांडा dataframes का उपयोग कर एक Keras मॉडल प्रशिक्षित करने के लिए संभव है, या अजगर जनरेटर से है कि डेटा और लेबल की उपज बैचों।

विशेष रूप से, keras.utils.Sequence वर्ग पायथन डेटा जनरेटर का निर्माण करने के लिए एक सरल इंटरफ़ेस प्रदान करता है जो कि बहु-जागरूक हैं और इसे फेरबदल किया जा सकता है।

सामान्य तौर पर, हम अनुशंसा करते हैं कि आप उपयोग करें:

  • यदि आपका डेटा छोटा है और मेमोरी में फिट बैठता है तो NumPy इनपुट डेटा
  • यदि आपके पास बड़े डेटासेट हैं तो Dataset ऑब्जेक्ट्स और आपको वितरित प्रशिक्षण करने की आवश्यकता है
  • Sequence ऑब्जेक्ट्स यदि आपके पास बड़े डेटासेट हैं और आपको बहुत सारे कस्टम पायथन-साइड प्रोसेसिंग करने की आवश्यकता है जो कि TensorFlow में नहीं किया जा सकता है (जैसे यदि आप डेटा लोडिंग या प्रीप्रोसेसिंग के लिए बाहरी पुस्तकालयों पर निर्भर हैं)।

इनपुट के रूप में keras.utils.Sequence ऑब्जेक्ट का उपयोग करना

keras.utils.Sequence एक उपयोगिता है जिसे आप दो महत्वपूर्ण गुणों के साथ पायथन जनरेटर प्राप्त करने के लिए उप-वर्ग कर सकते हैं:

  • यह मल्टीप्रोसेसिंग के साथ अच्छी तरह से काम करता है।
  • इसे फेरबदल किया जा सकता है (जैसे कि shuffle=True fit() में shuffle=True fit() )।

Sequence को दो विधियों को लागू करना चाहिए:

  • __getitem__
  • __len__

विधि __getitem__ को एक पूर्ण बैच लौटना चाहिए। यदि आप युगों के बीच अपने डेटासेट को संशोधित करना चाहते हैं, तो आप on_epoch_end को लागू कर सकते हैं।

यहाँ एक त्वरित उदाहरण है:

from skimage.io import imread
from skimage.transform import resize
import numpy as np

# Here, `filenames` is list of path to the images
# and `labels` are the associated labels.

class CIFAR10Sequence(Sequence):
    def __init__(self, filenames, labels, batch_size):
        self.filenames, self.labels = filenames, labels
        self.batch_size = batch_size

    def __len__(self):
        return int(np.ceil(len(self.filenames) / float(self.batch_size)))

    def __getitem__(self, idx):
        batch_x = self.filenames[idx * self.batch_size:(idx + 1) * self.batch_size]
        batch_y = self.labels[idx * self.batch_size:(idx + 1) * self.batch_size]
        return np.array([
            resize(imread(filename), (200, 200))
               for filename in batch_x]), np.array(batch_y)

sequence = CIFAR10Sequence(filenames, labels, batch_size)
model.fit(sequence, epochs=10)

नमूना भार और वर्ग भार का उपयोग करना

डिफ़ॉल्ट सेटिंग्स के साथ एक नमूना का वजन डेटासेट में इसकी आवृत्ति से तय होता है। डेटा को भारित करने के दो तरीके हैं, नमूना आवृत्ति से स्वतंत्र:

  • वर्ग भार
  • नमूना वजन

वर्ग भार

यह Model.fit() के class_weight तर्क के लिए एक शब्दकोश पारित करके निर्धारित किया गया है। यह शब्दकोश उस वर्ग के वजन को इंगित करता है जिसका उपयोग इस वर्ग से संबंधित नमूनों के लिए किया जाना चाहिए।

इसका उपयोग बिना पुनरुत्पादन के वर्गों को संतुलित करने, या एक मॉडल को प्रशिक्षित करने के लिए किया जा सकता है जो किसी विशेष वर्ग को अधिक महत्व देता है।

उदाहरण के लिए, यदि वर्ग "0" आपके डेटा में वर्ग "1" के रूप में आधा है, तो आप Model.fit(..., class_weight={0: 1., 1: 0.5}) उपयोग कर सकते हैं।

यहाँ एक NumPy उदाहरण है जहाँ हम कक्षा 5 (जो MNIST डेटासेट में "5" अंक है) के सही वर्गीकरण को अधिक महत्व देने के लिए वर्ग वज़न या नमूना भार का उपयोग करते हैं।

import numpy as np

class_weight = {
    0: 1.0,
    1: 1.0,
    2: 1.0,
    3: 1.0,
    4: 1.0,
    # Set weight "2" for class "5",
    # making this class 2x more important
    5: 2.0,
    6: 1.0,
    7: 1.0,
    8: 1.0,
    9: 1.0,
}

print("Fit with class weight")
model = get_compiled_model()
model.fit(x_train, y_train, class_weight=class_weight, batch_size=64, epochs=1)
Fit with class weight
782/782 [==============================] - 2s 2ms/step - loss: 0.6269 - sparse_categorical_accuracy: 0.8396
<tensorflow.python.keras.callbacks.History at 0x7fb6ca2479b0>

नमूना वजन

ठीक दानेदार नियंत्रण के लिए, या यदि आप एक क्लासिफायरियर का निर्माण नहीं कर रहे हैं, तो आप "नमूना भार" का उपयोग कर सकते हैं।

  • NumPy डेटा से प्रशिक्षण लेते समय: sample_weight तर्क को Model.fit()
  • जब tf.data या किसी अन्य प्रकार के tf.data से प्रशिक्षण लिया tf.data है: यील्ड (input_batch, label_batch, sample_weight_batch) ट्यूपल्स।

एक "नमूना वजन" सरणी संख्याओं की एक सरणी है जो यह निर्दिष्ट करती है कि बैच में प्रत्येक नमूने का कुल नुकसान की गणना में कितना वजन होना चाहिए। यह आमतौर पर असंतुलित वर्गीकरण समस्याओं (शायद ही कभी देखे गए वर्गों को अधिक वजन देने के लिए किया जा रहा है) में उपयोग किया जाता है।

जब उपयोग किए जाने वाले वजन वाले होते हैं और शून्य होते हैं, तो सरणी को नुकसान फ़ंक्शन के लिए मुखौटा के रूप में इस्तेमाल किया जा सकता है (पूरी तरह से कुल नुकसान के लिए कुछ नमूनों के योगदान को त्यागना)।

sample_weight = np.ones(shape=(len(y_train),))
sample_weight[y_train == 5] = 2.0

print("Fit with sample weight")
model = get_compiled_model()
model.fit(x_train, y_train, sample_weight=sample_weight, batch_size=64, epochs=1)
Fit with sample weight
782/782 [==============================] - 2s 2ms/step - loss: 0.6540 - sparse_categorical_accuracy: 0.8302
<tensorflow.python.keras.callbacks.History at 0x7fb6b03db128>

यहाँ एक मिलान Dataset उदाहरण दिया गया है:

sample_weight = np.ones(shape=(len(y_train),))
sample_weight[y_train == 5] = 2.0

# Create a Dataset that includes sample weights
# (3rd element in the return tuple).
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train, sample_weight))

# Shuffle and slice the dataset.
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

model = get_compiled_model()
model.fit(train_dataset, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 0.6052 - sparse_categorical_accuracy: 0.8477
<tensorflow.python.keras.callbacks.History at 0x7fb6a40cc908>

मल्टी-इनपुट, मल्टी-आउटपुट मॉडल के लिए डेटा पास करना

पिछले उदाहरणों में, हम एक एकल इनपुट (आकार का (764,) ) और एक एकल आउटपुट (आकृति का पूर्ववर्ती दशांश (10,) ) पर विचार कर रहे थे। लेकिन उन मॉडलों के बारे में जो कई इनपुट या आउटपुट हैं?

निम्नलिखित मॉडल पर विचार करें, जिसमें आकृति का एक छवि इनपुट (32, 32, 3) (जो कि (height, width, channels) ) और आकार का समय श्रृंखला इनपुट है (None, 10) (वह (timesteps, features) )। हमारे मॉडल में इन इनपुटों के संयोजन से गणना किए गए दो आउटपुट होंगे: एक "स्कोर" (आकार का (1,) ) और पांच वर्गों (आकार (5,) ) पर एक संभाव्यता वितरण।

image_input = keras.Input(shape=(32, 32, 3), name="img_input")
timeseries_input = keras.Input(shape=(None, 10), name="ts_input")

x1 = layers.Conv2D(3, 3)(image_input)
x1 = layers.GlobalMaxPooling2D()(x1)

x2 = layers.Conv1D(3, 3)(timeseries_input)
x2 = layers.GlobalMaxPooling1D()(x2)

x = layers.concatenate([x1, x2])

score_output = layers.Dense(1, name="score_output")(x)
class_output = layers.Dense(5, name="class_output")(x)

model = keras.Model(
    inputs=[image_input, timeseries_input], outputs=[score_output, class_output]
)

आइए इस मॉडल को प्लॉट करें, ताकि आप स्पष्ट रूप से देख सकें कि हम यहां क्या कर रहे हैं (ध्यान दें कि प्लॉट में दिखाए गए आकार बैच आकार हैं, बजाय प्रति-नमूना आकार के)।

keras.utils.plot_model(model, "multi_input_and_output_model.png", show_shapes=True)

पींग

संकलन समय पर, हम एक सूची के रूप में नुकसान कार्यों को पारित करके, अलग-अलग आउटपुट को अलग-अलग नुकसान निर्दिष्ट कर सकते हैं:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[keras.losses.MeanSquaredError(), keras.losses.CategoricalCrossentropy()],
)

यदि हमने केवल मॉडल के लिए एक एकल हानि फ़ंक्शन पारित किया है, तो उसी हानि फ़ंक्शन को हर आउटपुट पर लागू किया जाएगा (जो यहां उपयुक्त नहीं है)।

इसी तरह मैट्रिक्स के लिए:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[keras.losses.MeanSquaredError(), keras.losses.CategoricalCrossentropy()],
    metrics=[
        [
            keras.metrics.MeanAbsolutePercentageError(),
            keras.metrics.MeanAbsoluteError(),
        ],
        [keras.metrics.CategoricalAccuracy()],
    ],
)

चूँकि हमने अपनी आउटपुट लेयर्स को नाम दिया था, इसलिए हम प्रति-आउटपुट लॉस और मेट्रिक्स को एक तानाशाही के माध्यम से निर्दिष्ट कर सकते हैं:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss={
        "score_output": keras.losses.MeanSquaredError(),
        "class_output": keras.losses.CategoricalCrossentropy(),
    },
    metrics={
        "score_output": [
            keras.metrics.MeanAbsolutePercentageError(),
            keras.metrics.MeanAbsoluteError(),
        ],
        "class_output": [keras.metrics.CategoricalAccuracy()],
    },
)

यदि आपके पास 2 से अधिक आउटपुट हैं, तो हम स्पष्ट नाम और dicts के उपयोग की सलाह देते हैं।

यह अलग उत्पादन विशेष घाटे के लिए अलग अलग वजन देने के लिए (उदाहरण के लिए, एक, हमारे उदाहरण में "स्कोर" नुकसान विशेषाधिकार करना चाहते हो सकता है वर्ग नुकसान के महत्व को 2 गुना तक अधिक देकर) का उपयोग कर, संभव है loss_weights तर्क:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss={
        "score_output": keras.losses.MeanSquaredError(),
        "class_output": keras.losses.CategoricalCrossentropy(),
    },
    metrics={
        "score_output": [
            keras.metrics.MeanAbsolutePercentageError(),
            keras.metrics.MeanAbsoluteError(),
        ],
        "class_output": [keras.metrics.CategoricalAccuracy()],
    },
    loss_weights={"score_output": 2.0, "class_output": 1.0},
)

आप कुछ आउटपुट के लिए नुकसान की गणना नहीं करना चुन सकते हैं, यदि ये आउटपुट भविष्यवाणी के लिए हैं, लेकिन प्रशिक्षण के लिए नहीं:

# List loss version
model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[None, keras.losses.CategoricalCrossentropy()],
)

# Or dict loss version
model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss={"class_output": keras.losses.CategoricalCrossentropy()},
)

एक मल्टी-इनपुट या मल्टी-आउटपुट मॉडल के लिए डेटा को fit() एक समान तरीके से काम करता है जैसा कि संकलन में एक हानि फ़ंक्शन को निर्दिष्ट करता है: आप NumPy सरणियों की सूची पास कर सकते हैं (1: 1 मैपिंग के साथ आउटपुट पर जो कि एक हानि फ़ंक्शन प्राप्त किया है ) या NumPy सरणियों के लिए आउटपुट नाम मैपिंग dicts

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[keras.losses.MeanSquaredError(), keras.losses.CategoricalCrossentropy()],
)

# Generate dummy NumPy data
img_data = np.random.random_sample(size=(100, 32, 32, 3))
ts_data = np.random.random_sample(size=(100, 20, 10))
score_targets = np.random.random_sample(size=(100, 1))
class_targets = np.random.random_sample(size=(100, 5))

# Fit on lists
model.fit([img_data, ts_data], [score_targets, class_targets], batch_size=32, epochs=1)

# Alternatively, fit on dicts
model.fit(
    {"img_input": img_data, "ts_input": ts_data},
    {"score_output": score_targets, "class_output": class_targets},
    batch_size=32,
    epochs=1,
)
4/4 [==============================] - 10s 10ms/step - loss: 12.4255 - score_output_loss: 0.7638 - class_output_loss: 11.6617
4/4 [==============================] - 0s 5ms/step - loss: 11.1176 - score_output_loss: 0.6303 - class_output_loss: 10.4873
<tensorflow.python.keras.callbacks.History at 0x7fb6a02ed828>

यहाँ Dataset उपयोग मामला है: जैसा कि हमने NumPy सरणियों के लिए किया था, उसी तरह Dataset को टिक्स का वापस लौटना चाहिए।

043b2525a10
2/2 [==============================] - 0s 27ms/step - loss: 10.9011 - score_output_loss: 0.4919 - class_output_loss: 10.4092
<tensorflow.python.keras.callbacks.History at 0x7fb6b00ae9e8>

कॉलबैक का उपयोग करना

केरस में कॉलबैक ऐसी वस्तुएं हैं जिन्हें प्रशिक्षण के दौरान अलग-अलग बिंदुओं पर बुलाया जाता है (एक युग की शुरुआत में, एक बैच के अंत में, एक युग के अंत में, आदि)। उनका उपयोग कुछ व्यवहारों को लागू करने के लिए किया जा सकता है, जैसे:

  • प्रशिक्षण के दौरान विभिन्न बिंदुओं पर सत्यापन करना (बिल्ट-इन-प्रति-युग सत्यापन से परे)
  • मॉडल को नियमित अंतराल पर चेक करना या जब यह एक निश्चित सटीकता सीमा से अधिक हो
  • जब प्रशिक्षण पठार लगता है तो मॉडल की सीखने की दर को बदलना
  • जब प्रशिक्षण पठार लगता है तो शीर्ष परतों की ठीक-ठीक ट्यूनिंग करना
  • जब प्रशिक्षण समाप्त होता है या जहां एक निश्चित प्रदर्शन सीमा पार हो जाती है तो ईमेल या त्वरित संदेश सूचना भेजना
  • आदि।

कॉलबैक को fit() करने के लिए आपकी कॉल की सूची के रूप में पारित किया जा सकता fit() :

model = get_compiled_model()

callbacks = [
    keras.callbacks.EarlyStopping(
        # Stop training when `val_loss` is no longer improving
        monitor="val_loss",
        # "no longer improving" being defined as "no better than 1e-2 less"
        min_delta=1e-2,
        # "no longer improving" being further defined as "for at least 2 epochs"
        patience=2,
        verbose=1,
    )
]
model.fit(
    x_train,
    y_train,
    epochs=20,
    batch_size=64,
    callbacks=callbacks,
    validation_split=0.2,
)
Epoch 1/20
625/625 [==============================] - 2s 3ms/step - loss: 0.6076 - sparse_categorical_accuracy: 0.8350 - val_loss: 0.2323 - val_sparse_categorical_accuracy: 0.9306
Epoch 2/20
625/625 [==============================] - 1s 2ms/step - loss: 0.1925 - sparse_categorical_accuracy: 0.9436 - val_loss: 0.1828 - val_sparse_categorical_accuracy: 0.9446
Epoch 3/20
625/625 [==============================] - 1s 2ms/step - loss: 0.1310 - sparse_categorical_accuracy: 0.9616 - val_loss: 0.1580 - val_sparse_categorical_accuracy: 0.9510
Epoch 4/20
625/625 [==============================] - 1s 2ms/step - loss: 0.0967 - sparse_categorical_accuracy: 0.9700 - val_loss: 0.1681 - val_sparse_categorical_accuracy: 0.9490
Epoch 5/20
625/625 [==============================] - 1s 2ms/step - loss: 0.0841 - sparse_categorical_accuracy: 0.9742 - val_loss: 0.1482 - val_sparse_categorical_accuracy: 0.9568
Epoch 00005: early stopping
<tensorflow.python.keras.callbacks.History at 0x7fb63c5945c0>

कई अंतर्निहित कॉलबैक उपलब्ध हैं

केरेस में पहले से ही उपलब्ध कई कॉलबैक हैं, जैसे:

  • ModelCheckpoint : समय-समय पर मॉडल को सहेजें।
  • EarlyStopping : प्रशिक्षण रोकें जब प्रशिक्षण अब सत्यापन मैट्रिक्स में सुधार नहीं कर रहा है।
  • TensorBoard : समय-समय पर मॉडल लॉग लिखें जो TensorBoard (अनुभाग "विज़ुअलाइज़ेशन" में अधिक विवरण) में देखे जा सकते हैं।
  • CSVLogger : CSV फ़ाइल में हानि और मैट्रिक्स डेटा स्ट्रीम करता है।
  • आदि।

पूरी सूची के लिए कॉलबैक दस्तावेज़ देखें।

अपना खुद का कॉलबैक लिखना

आप आधार वर्ग keras.callbacks.Callback विस्तार करके एक कस्टम कॉलबैक बना सकते हैं। एक कॉलबैक को क्लास प्रॉपर्टी self.model माध्यम से अपने संबंधित मॉडल तक पहुंच है।

कस्टम कॉलबैक लिखने के लिए पूरा गाइड पढ़ना सुनिश्चित करें।

प्रशिक्षण के दौरान प्रति बैच नुकसान मूल्यों की सूची को सहेजने का एक सरल उदाहरण यहां दिया गया है:

class LossHistory(keras.callbacks.Callback):
    def on_train_begin(self, logs):
        self.per_batch_losses = []

    def on_batch_end(self, batch, logs):
        self.per_batch_losses.append(logs.get("loss"))

चेकपॉइंटिंग मॉडल

जब आप अपेक्षाकृत बड़े डेटासेट पर मॉडल का प्रशिक्षण ले रहे होते हैं, तो लगातार अंतराल पर अपने मॉडल की चौकियों को बचाना महत्वपूर्ण होता है।

इसे प्राप्त करने का सबसे आसान तरीका ModelCheckpoint कॉलबैक है:

model = get_compiled_model()

callbacks = [
    keras.callbacks.ModelCheckpoint(
        # Path where to save the model
        # The two parameters below mean that we will overwrite
        # the current checkpoint if and only if
        # the `val_loss` score has improved.
        # The saved model name will include the current epoch.
        filepath="mymodel_{epoch}",
        save_best_only=True,  # Only save a model if `val_loss` has improved.
        monitor="val_loss",
        verbose=1,
    )
]
model.fit(
    x_train, y_train, epochs=2, batch_size=64, callbacks=callbacks, validation_split=0.2
)
Epoch 1/2
625/625 [==============================] - 2s 2ms/step - loss: 0.6397 - sparse_categorical_accuracy: 0.8210 - val_loss: 0.2310 - val_sparse_categorical_accuracy: 0.9326

Epoch 00001: val_loss improved from inf to 0.23098, saving model to mymodel_1
INFO:tensorflow:Assets written to: mymodel_1/assets
Epoch 2/2
625/625 [==============================] - 1s 2ms/step - loss: 0.1885 - sparse_categorical_accuracy: 0.9454 - val_loss: 0.1851 - val_sparse_categorical_accuracy: 0.9435

Epoch 00002: val_loss improved from 0.23098 to 0.18510, saving model to mymodel_2
INFO:tensorflow:Assets written to: mymodel_2/assets
<tensorflow.python.keras.callbacks.History at 0x7fb6a04271d0>

ModelCheckpoint कॉलबैक का उपयोग दोष-सहिष्णुता को लागू करने के लिए किया जा सकता है: मामले के प्रशिक्षण में मॉडल की अंतिम सहेजी गई स्थिति से प्रशिक्षण को फिर से शुरू करने की क्षमता बेतरतीब ढंग से बाधित हो जाती है। यहाँ एक मूल उदाहरण दिया गया है:

import os

# Prepare a directory to store all the checkpoints.
checkpoint_dir = "./ckpt"
if not os.path.exists(checkpoint_dir):
    os.makedirs(checkpoint_dir)


def make_or_restore_model():
    # Either restore the latest model, or create a fresh one
    # if there is no checkpoint available.
    checkpoints = [checkpoint_dir + "/" + name for name in os.listdir(checkpoint_dir)]
    if checkpoints:
        latest_checkpoint = max(checkpoints, key=os.path.getctime)
        print("Restoring from", latest_checkpoint)
        return keras.models.load_model(latest_checkpoint)
    print("Creating a new model")
    return get_compiled_model()


model = make_or_restore_model()
callbacks = [
    # This callback saves a SavedModel every 100 batches.
    # We include the training loss in the saved model name.
    keras.callbacks.ModelCheckpoint(
        filepath=checkpoint_dir + "/ckpt-loss={loss:.2f}", save_freq=100
    )
]
model.fit(x_train, y_train, epochs=1, callbacks=callbacks)
Creating a new model
  85/1563 [>.............................] - ETA: 2s - loss: 1.4465 - sparse_categorical_accuracy: 0.5717INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.93/assets
 185/1563 [==>...........................] - ETA: 5s - loss: 1.1118 - sparse_categorical_accuracy: 0.6784INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.69/assets
 284/1563 [====>.........................] - ETA: 5s - loss: 0.9495 - sparse_categorical_accuracy: 0.7266INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.58/assets
 385/1563 [======>.......................] - ETA: 5s - loss: 0.8464 - sparse_categorical_accuracy: 0.7569INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.52/assets
 485/1563 [========>.....................] - ETA: 5s - loss: 0.7749 - sparse_categorical_accuracy: 0.7776INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.47/assets
 585/1563 [==========>...................] - ETA: 4s - loss: 0.7210 - sparse_categorical_accuracy: 0.7930INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.44/assets
 685/1563 [============>.................] - ETA: 4s - loss: 0.6788 - sparse_categorical_accuracy: 0.8050INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.42/assets
 785/1563 [==============>...............] - ETA: 4s - loss: 0.6445 - sparse_categorical_accuracy: 0.8149INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.40/assets
 883/1563 [===============>..............] - ETA: 3s - loss: 0.6165 - sparse_categorical_accuracy: 0.8229INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.38/assets
 984/1563 [=================>............] - ETA: 3s - loss: 0.5917 - sparse_categorical_accuracy: 0.8299INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.37/assets
1082/1563 [===================>..........] - ETA: 2s - loss: 0.5709 - sparse_categorical_accuracy: 0.8358INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.35/assets
1185/1563 [=====================>........] - ETA: 1s - loss: 0.5517 - sparse_categorical_accuracy: 0.8413INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.34/assets
1282/1563 [=======================>......] - ETA: 1s - loss: 0.5356 - sparse_categorical_accuracy: 0.8459INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.33/assets
1384/1563 [=========================>....] - ETA: 0s - loss: 0.5202 - sparse_categorical_accuracy: 0.8503INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.32/assets
1484/1563 [===========================>..] - ETA: 0s - loss: 0.5065 - sparse_categorical_accuracy: 0.8542INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.31/assets
1563/1563 [==============================] - 9s 5ms/step - loss: 0.4965 - sparse_categorical_accuracy: 0.8570
<tensorflow.python.keras.callbacks.History at 0x7fb6a036f5c0>

आप मॉडल को सहेजने और पुनर्स्थापित करने के लिए अपना कॉलबैक भी लिखते हैं।

सीरियलाइज़ेशन और सेविंग पर पूरी गाइड के लिए, मॉडल्स को सेविंग और सीरीज़ करने के लिए गाइड देखें।

सीखने की दर कार्यक्रम का उपयोग करना

एक सामान्य पैटर्न जब प्रशिक्षण सीखने वाले मॉडल को धीरे-धीरे प्रशिक्षण की प्रगति के रूप में सीखना कम करना है। यह आमतौर पर "सीखने की दर में गिरावट" के रूप में जाना जाता है।

शिक्षण क्षय अनुसूची स्थिर हो सकती है (अग्रिम में, वर्तमान युग या वर्तमान बैच सूचकांक के एक समारोह के रूप में), या गतिशील (मॉडल के वर्तमान व्यवहार पर प्रतिक्रिया, विशेष रूप से सत्यापन हानि)।

एक आशावादी के लिए एक कार्यक्रम गुजर रहा है

आप किसी शेड्यूल ऑब्जेक्ट को अपने ऑप्टिमाइज़र में learning_rate तर्क के रूप में पास करके आसानी से स्थैतिक सीखने की दर क्षय अनुसूची का उपयोग कर सकते हैं:

initial_learning_rate = 0.1
lr_schedule = keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate, decay_steps=100000, decay_rate=0.96, staircase=True
)

optimizer = keras.optimizers.RMSprop(learning_rate=lr_schedule)

कई अंतर्निहित कार्यक्रम उपलब्ध हैं: ExponentialDecay , PiecewiseConstantDecay , PolynomialDecay , और InverseTimeDecay

गतिशील सीखने की दर अनुसूची को लागू करने के लिए कॉलबैक का उपयोग करना

डायनेमिक लर्निंग रेट शेड्यूल (उदाहरण के लिए, सत्यापन दर में सुधार नहीं होने पर सीखने की दर कम करना) इन शेड्यूल ऑब्जेक्ट्स के साथ प्राप्त नहीं किया जा सकता है, क्योंकि ऑप्टिमाइज़र के पास सत्यापन मेट्रिक्स तक पहुंच नहीं है।

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

प्रशिक्षण के दौरान दृश्य हानि और मैट्रिक्स

प्रशिक्षण के दौरान अपने मॉडल पर नज़र रखने का सबसे अच्छा तरीका है कि आप TensorBoard का उपयोग करें - एक ब्राउज़र-आधारित एप्लिकेशन जिसे आप स्थानीय रूप से चला सकते हैं जो आपको प्रदान करता है:

  • प्रशिक्षण और मूल्यांकन के नुकसान और मैट्रिक्स के लाइव प्लॉट
  • (वैकल्पिक रूप से) आपकी परत सक्रियण के हिस्टोग्राम के विज़ुअलाइज़ेशन
  • (वैकल्पिक रूप से) एम्बेडिंग रिक्त स्थान की 3D विज़ुअलाइज़ेशन आपकी Embedding परतों द्वारा सीखी गई हैं

यदि आपने पाइप के साथ TensorFlow स्थापित किया है, तो आपको कमांड लाइन से TensorBoard लॉन्च करने में सक्षम होना चाहिए:

tensorboard --logdir=/full_path_to_your_logs

TensorBoard कॉलबैक का उपयोग करना

टेनसोरबार्ड को केरस मॉडल और fit() विधि के साथ उपयोग करने का सबसे आसान तरीका TensorBoard कॉलबैक है।

सबसे सरल स्थिति में, बस यह निर्दिष्ट करें कि आप लॉग्स लिखने के लिए कॉलबैक कहां चाहते हैं, और आप जाने के लिए अच्छे हैं:

keras.callbacks.TensorBoard(
    log_dir="/full_path_to_your_logs",
    histogram_freq=0,  # How often to log histogram visualizations
    embeddings_freq=0,  # How often to log embedding visualizations
    update_freq="epoch",
)  # How often to write logs (default: once per epoch)
<tensorflow.python.keras.callbacks.TensorBoard at 0x7fb6a422a748>

अधिक जानकारी के लिए, TensorBoard कॉलबैक के लिए दस्तावेज़ देखें।