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

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() गाइड

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

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

इस गाइड वितरित प्रशिक्षण, जो हमारे में शामिल है को कवर नहीं करता बहु GPU और वितरित प्रशिक्षण के लिए गाइड

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

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

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

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]

हम प्रशिक्षण कॉन्फ़िगरेशन (ऑप्टिमाइज़र, हानि, मीट्रिक) निर्दिष्ट करते हैं:

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.3483 - sparse_categorical_accuracy: 0.9025 - val_loss: 0.1949 - val_sparse_categorical_accuracy: 0.9443
Epoch 2/2
782/782 [==============================] - 2s 3ms/step - loss: 0.1611 - sparse_categorical_accuracy: 0.9519 - val_loss: 0.1420 - val_sparse_categorical_accuracy: 0.9612

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

history.history
{'loss': [0.3483238220214844, 0.16108229756355286],
 'sparse_categorical_accuracy': [0.9025400280952454, 0.9518600106239319],
 'val_loss': [0.19487273693084717, 0.14200106263160706],
 'val_sparse_categorical_accuracy': [0.9442999958992004, 0.9611999988555908]}

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

# Evaluate the model on the test data using `evaluate`
print("Evaluate on test data")
results = model.evaluate(x_test, y_test, batch_size=128)
print("test loss, test acc:", results)

# Generate predictions (probabilities -- the output of the last layer)
# on new data using `predict`
print("Generate predictions for 3 samples")
predictions = model.predict(x_test[:3])
print("predictions shape:", predictions.shape)
Evaluate on test data
79/79 [==============================] - 0s 2ms/step - loss: 0.1485 - sparse_categorical_accuracy: 0.9542
test loss, test acc: [0.1484519988298416, 0.954200029373169]
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 [==============================] - 2s 2ms/step - loss: 0.0161
<keras.callbacks.History at 0x7f4b14549e90>

आप एक नुकसान समारोह है कि बगल में मापदंडों में ले जाता है की जरूरत है y_true और 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.0383
<keras.callbacks.History at 0x7f4b143d8e10>

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

आप एक मीट्रिक कि एपीआई का हिस्सा नहीं है की जरूरत है, आप आसानी से उपवर्गीकरण द्वारा कस्टम मीट्रिक बना सकते हैं 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) , जिसमें मीट्रिक का राज्य reinitializes।

राज्य अद्यतन और परिणाम गणना अलग (में रखा जाता है 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)
Epoch 1/3
782/782 [==============================] - 2s 2ms/step - loss: 0.3441 - categorical_true_positives: 45120.0000
Epoch 2/3
 70/782 [=>............................] - ETA: 1s - loss: 0.1721 - categorical_true_positives: 4247.0000
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/metrics.py:257: UserWarning: Metric CategoricalTruePositives implements a `reset_states()` method; rename it to `reset_state()` (without the final "s"). The name `reset_states()` has been deprecated to improve API consistency.
  'consistency.' % (self.__class__.__name__,))
782/782 [==============================] - 2s 2ms/step - loss: 0.1625 - categorical_true_positives: 47585.0000
Epoch 3/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1202 - categorical_true_positives: 48190.0000
<keras.callbacks.History at 0x7f4b14228910>

मानक हस्ताक्षर के अनुरूप नहीं होने वाले नुकसान और मीट्रिक को संभालना

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

ऐसे मामलों में, आप कॉल कर सकते हैं self.add_loss(loss_value) एक कस्टम परत की कॉल विधि के अंदर से। इस तरह से जोड़ा घाटा प्रशिक्षण के दौरान "मुख्य" नुकसान में जुड़ती (एक के लिए पारित 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: 2.5364
<keras.callbacks.History at 0x7f4b140acc50>

आप मीट्रिक मान प्रवेश करने, प्रयोग करने के लिए भी ऐसा ही कर सकते हैं 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.3495 - std_of_activation: 0.9820
<keras.callbacks.History at 0x7f4af21e3bd0>

में कार्यात्मक एपीआई , आप भी कॉल कर सकते हैं 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: 2.4347 - std_of_activation: 0.0016
<keras.callbacks.History at 0x7f4af216d810>

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

पर विचार करें निम्नलिखित LogisticEndpoint परत: यह आदानों लक्ष्यों और logits के रूप में लेता है, और यह के माध्यम से एक crossentropy नुकसान पटरियों 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 242ms/step - loss: 0.9816 - binary_accuracy: 0.0000e+00
<keras.callbacks.History at 0x7f4af212bed0>

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

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

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

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

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

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

model = get_compiled_model()
model.fit(x_train, y_train, batch_size=64, validation_split=0.2, epochs=1)
625/625 [==============================] - 2s 3ms/step - loss: 0.3737 - sparse_categorical_accuracy: 0.8947 - val_loss: 0.2427 - val_sparse_categorical_accuracy: 0.9249
<keras.callbacks.History at 0x7f4af1847610>

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

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

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

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

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

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

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.3280 - sparse_categorical_accuracy: 0.9088
Epoch 2/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1550 - sparse_categorical_accuracy: 0.9525
Epoch 3/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1143 - sparse_categorical_accuracy: 0.9650
Evaluate
157/157 [==============================] - 0s 2ms/step - loss: 0.1126 - sparse_categorical_accuracy: 0.9659
{'loss': 0.11255467683076859,
 'sparse_categorical_accuracy': 0.9659000039100647}

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

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

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

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)

# Only use the 100 batches per epoch (that's 64 * 100 samples)
model.fit(train_dataset, epochs=3, steps_per_epoch=100)
Epoch 1/3
100/100 [==============================] - 1s 2ms/step - loss: 0.8098 - sparse_categorical_accuracy: 0.8011
Epoch 2/3
100/100 [==============================] - 0s 2ms/step - loss: 0.3844 - sparse_categorical_accuracy: 0.8933
Epoch 3/3
100/100 [==============================] - 0s 2ms/step - loss: 0.3357 - sparse_categorical_accuracy: 0.9002
<keras.callbacks.History at 0x7f4af1f95150>

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

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

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.3319 - sparse_categorical_accuracy: 0.9069 - val_loss: 0.1979 - val_sparse_categorical_accuracy: 0.9418
<keras.callbacks.History at 0x7f4af1e3ce50>

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

आप केवल इस डेटासेट से बैचों की एक विशिष्ट संख्या पर मान्यता चलाना चाहते हैं, तो आप पास कर सकते हैं 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 3ms/step - loss: 0.3502 - sparse_categorical_accuracy: 0.9024 - val_loss: 0.3006 - val_sparse_categorical_accuracy: 0.9125
<keras.callbacks.History at 0x7f4af1c9b050>

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

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

अन्य इनपुट प्रारूप समर्थित

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

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

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

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

एक का उपयोग करना keras.utils.Sequence इनपुट के रूप में वस्तु

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

  • यह मल्टीप्रोसेसिंग के साथ अच्छी तरह से काम करता है।
  • यह फेरबदल किया जा सकता है (उदाहरण के लिए जब गुजर 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)

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

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

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

वर्ग भार

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

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

उदाहरण के लिए, यदि वर्ग "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.3809 - sparse_categorical_accuracy: 0.8990
<keras.callbacks.History at 0x7f4af1b95b10>

नमूना वजन

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

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

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

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

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.3844 - sparse_categorical_accuracy: 0.8997
<keras.callbacks.History at 0x7f4af19ef1d0>

यहाँ एक मिलान है 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 3ms/step - loss: 0.3669 - sparse_categorical_accuracy: 0.9033
<keras.callbacks.History at 0x7f4af18a6dd0>

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

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

निम्नलिखित मॉडल है, जो आकार की एक छवि इनपुट है पर विचार करें (32, 32, 3) (जो की (height, width, channels) ) और आकार का एक समय श्रृंखला इनपुट (None, 10) (जो की (timesteps, features) )। हमारे मॉडल दो outputs इन इनपुट के संयोजन से गणना की है: एक "स्कोर" (आकार की (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 से अधिक आउटपुट हैं, तो हम स्पष्ट नामों और डिक्ट्स के उपयोग की अनुशंसा करते हैं।

यह अलग उत्पादन विशेष घाटे के लिए अलग अलग वजन देने के लिए (उदाहरण के लिए, एक, हमारे उदाहरण में "स्कोर" नुकसान विशेषाधिकार करना चाहते हो सकता है वर्ग नुकसान के महत्व को 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() संकलन में कमी समारोह को निर्दिष्ट के रूप में एक समान तरीके से काम करता है: outputs कि एक नुकसान समारोह प्राप्त करने के लिए 1 मानचित्रण: यदि आप 1 के साथ NumPy सरणी की सूची (पारित कर सकते हैं ) या 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 [==============================] - 2s 12ms/step - loss: 17.8110 - score_output_loss: 0.3258 - class_output_loss: 17.4852
4/4 [==============================] - 0s 5ms/step - loss: 20.9269 - score_output_loss: 0.2376 - class_output_loss: 20.6893
<keras.callbacks.History at 0x7f4c70c26bd0>

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

train_dataset = tf.data.Dataset.from_tensor_slices(
    (
        {"img_input": img_data, "ts_input": ts_data},
        {"score_output": score_targets, "class_output": class_targets},
    )
)
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

model.fit(train_dataset, epochs=1)
2/2 [==============================] - 1s 24ms/step - loss: 20.7151 - score_output_loss: 0.2093 - class_output_loss: 20.5058
<keras.callbacks.History at 0x7f4af1955e10>

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

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

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

कॉलबैक करने के लिए अपने कॉल करने के लिए एक सूची के रूप में पारित किया जा सकता है 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.3584 - sparse_categorical_accuracy: 0.8986 - val_loss: 0.2179 - val_sparse_categorical_accuracy: 0.9345
Epoch 2/20
625/625 [==============================] - 1s 2ms/step - loss: 0.1624 - sparse_categorical_accuracy: 0.9520 - val_loss: 0.1745 - val_sparse_categorical_accuracy: 0.9465
Epoch 3/20
625/625 [==============================] - 1s 2ms/step - loss: 0.1205 - sparse_categorical_accuracy: 0.9642 - val_loss: 0.1472 - val_sparse_categorical_accuracy: 0.9557
Epoch 4/20
625/625 [==============================] - 1s 2ms/step - loss: 0.0962 - sparse_categorical_accuracy: 0.9704 - val_loss: 0.1441 - val_sparse_categorical_accuracy: 0.9572
Epoch 5/20
625/625 [==============================] - 1s 2ms/step - loss: 0.0819 - sparse_categorical_accuracy: 0.9749 - val_loss: 0.1451 - val_sparse_categorical_accuracy: 0.9589
Epoch 00005: early stopping
<keras.callbacks.History at 0x7f4b14273390>

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

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

  • 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 3ms/step - loss: 0.3701 - sparse_categorical_accuracy: 0.8956 - val_loss: 0.2327 - val_sparse_categorical_accuracy: 0.9291

Epoch 00001: val_loss improved from inf to 0.23265, saving model to mymodel_1
2021-08-25 17:57:17.429907: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: mymodel_1/assets
Epoch 2/2
625/625 [==============================] - 1s 2ms/step - loss: 0.1764 - sparse_categorical_accuracy: 0.9470 - val_loss: 0.1858 - val_sparse_categorical_accuracy: 0.9435

Epoch 00002: val_loss improved from 0.23265 to 0.18579, saving model to mymodel_2
INFO:tensorflow:Assets written to: mymodel_2/assets
<keras.callbacks.History at 0x7f4c71554f90>

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
  78/1563 [>.............................] - ETA: 2s - loss: 1.1340 - sparse_categorical_accuracy: 0.7011INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=1.01/assets
 197/1563 [==>...........................] - ETA: 5s - loss: 0.7358 - sparse_categorical_accuracy: 0.8006INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.73/assets
 299/1563 [====>.........................] - ETA: 5s - loss: 0.6081 - sparse_categorical_accuracy: 0.8313INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.61/assets
 400/1563 [======>.......................] - ETA: 5s - loss: 0.5317 - sparse_categorical_accuracy: 0.8511INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.53/assets
 495/1563 [========>.....................] - ETA: 5s - loss: 0.4909 - sparse_categorical_accuracy: 0.8622INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.49/assets
 598/1563 [==========>...................] - ETA: 5s - loss: 0.4576 - sparse_categorical_accuracy: 0.8722INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.46/assets
 676/1563 [===========>..................] - ETA: 5s - loss: 0.4326 - sparse_categorical_accuracy: 0.8793INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.43/assets
 775/1563 [=============>................] - ETA: 4s - loss: 0.4063 - sparse_categorical_accuracy: 0.8858INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.40/assets
 900/1563 [================>.............] - ETA: 3s - loss: 0.3810 - sparse_categorical_accuracy: 0.8925INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.38/assets
 976/1563 [=================>............] - ETA: 3s - loss: 0.3710 - sparse_categorical_accuracy: 0.8954INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.37/assets
1076/1563 [===================>..........] - ETA: 2s - loss: 0.3563 - sparse_categorical_accuracy: 0.8991INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.35/assets
1199/1563 [======================>.......] - ETA: 2s - loss: 0.3409 - sparse_categorical_accuracy: 0.9033INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.34/assets
1297/1563 [=======================>......] - ETA: 1s - loss: 0.3281 - sparse_categorical_accuracy: 0.9069INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.33/assets
1396/1563 [=========================>....] - ETA: 0s - loss: 0.3193 - sparse_categorical_accuracy: 0.9092INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.32/assets
1498/1563 [===========================>..] - ETA: 0s - loss: 0.3086 - sparse_categorical_accuracy: 0.9123INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.31/assets
1563/1563 [==============================] - 10s 6ms/step - loss: 0.3029 - sparse_categorical_accuracy: 0.9138
<keras.callbacks.History at 0x7f4c71394b90>

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

क्रमबद्धता और बचत पर एक पूरा गाइड के लिए, देखें बचत और मॉडल serializing के लिए गाइड

सीखने की दर अनुसूचियों का उपयोग करना

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

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

ऑप्टिमाइज़र को शेड्यूल पास करना

आप आसानी से के रूप में एक कार्यक्रम वस्तु पारित करके एक स्थिर सीखने दर क्षय अनुसूची का उपयोग कर सकते 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 - एक ब्राउज़र आधारित अनुप्रयोग है कि आप स्थानीय रूप से चला सकते हैं कि प्रदान करता है:

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

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

tensorboard --logdir=/full_path_to_your_logs

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

सबसे आसान तरीका है एक Keras मॉडल और साथ 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)
<keras.callbacks.TensorBoard at 0x7f4bd50d7910>

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