इस पेज का अनुवाद 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() में क्या होता है" को अनुकूलित करते हुए गाइड देखें।

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

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

यह गाइड वितरित प्रशिक्षण को कवर नहीं करता है। वितरित प्रशिक्षण के लिए, बहु-gpu और वितरित प्रशिक्षण के लिए हमारी मार्गदर्शिका देखें।

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

किसी मॉडल के अंतर्निहित प्रशिक्षण छोरों में डेटा पास करते समय, आपको या तो 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]

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

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() , जो मॉडल को "बैच_साइज़" के "बैच" में डेटा को स्लाइस करके मॉडल को प्रशिक्षित करेगा, और बार-बार "एपोच" की दी गई संख्या के लिए संपूर्ण डेटासेट पर पुनरावृत्ति करेगा।

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 [==============================] - 2s 2ms/step - loss: 0.3425 - sparse_categorical_accuracy: 0.9034 - val_loss: 0.1827 - val_sparse_categorical_accuracy: 0.9478
Epoch 2/2
782/782 [==============================] - 2s 2ms/step - loss: 0.1618 - sparse_categorical_accuracy: 0.9513 - val_loss: 0.1282 - val_sparse_categorical_accuracy: 0.9651

लौटाया गया "इतिहास" ऑब्जेक्ट प्रशिक्षण के दौरान हानि मूल्यों और मीट्रिक मूल्यों का रिकॉर्ड रखता है:

history.history
{'loss': [0.3424801528453827, 0.16180744767189026],
 'sparse_categorical_accuracy': [0.903439998626709, 0.9512799978256226],
 'val_loss': [0.18268445134162903, 0.12816601991653442],
 'val_sparse_categorical_accuracy': [0.9477999806404114, 0.9650999903678894]}

हम मूल्यांकन के माध्यम से परीक्षण डेटा पर मॉडल का 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 1ms/step - loss: 0.1310 - sparse_categorical_accuracy: 0.9637
test loss, test acc: [0.1309928148984909, 0.963699996471405]
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

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

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

Optimizers:

  • 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.0168

<tensorflow.python.keras.callbacks.History at 0x7f75581d56a0>

यदि आपको 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 [==============================] - 1s 2ms/step - loss: 0.0390

<tensorflow.python.keras.callbacks.History at 0x7f7558184c88>

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

यदि आपको एक मीट्रिक की आवश्यकता है जो एपीआई का हिस्सा नहीं है, तो आप आसानी से 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)
Epoch 1/3
782/782 [==============================] - 1s 2ms/step - loss: 0.3429 - categorical_true_positives: 45146.0000
Epoch 2/3
782/782 [==============================] - 1s 2ms/step - loss: 0.1560 - categorical_true_positives: 47637.0000
Epoch 3/3
782/782 [==============================] - 1s 2ms/step - loss: 0.1155 - categorical_true_positives: 48237.0000

<tensorflow.python.keras.callbacks.History at 0x7f755801bfd0>

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

नुकसान और मैट्रिक्स के भारी बहुमत की गणना 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 [==============================] - 1s 2ms/step - loss: 2.4756

<tensorflow.python.keras.callbacks.History at 0x7f75501e1f98>

आप 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 [==============================] - 1s 2ms/step - loss: 0.3493 - std_of_activation: 0.9813

<tensorflow.python.keras.callbacks.History at 0x7f75500321d0>

फ़ंक्शनल एपीआई में , आप 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 [==============================] - 1s 2ms/step - loss: 2.5230 - std_of_activation: 0.0020

<tensorflow.python.keras.callbacks.History at 0x7f74ec71d828>

ध्यान दें कि जब आप 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 1ms/step - loss: 0.9344 - binary_accuracy: 0.0000e+00

<tensorflow.python.keras.callbacks.History at 0x7f7558339f28>

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

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

पहली एंड-टू-एंड उदाहरण आपने देखा में, हम इस्तेमाल किया 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% उपयोग करें"।

जिस तरह से सत्यापन की गणना की जाती है, वह किसी भी फेरबदल से पहले, फिट कॉल द्वारा प्राप्त सरणियों के अंतिम 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 [==============================] - 1s 2ms/step - loss: 0.3753 - sparse_categorical_accuracy: 0.8927 - val_loss: 0.2252 - val_sparse_categorical_accuracy: 0.9344

<tensorflow.python.keras.callbacks.History at 0x7f755826f160>

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

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

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

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

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

आप fit() , evaluate() , और predict() के तरीकों के लिए सीधे Dataset उदाहरण पास कर सकते 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.3404 - sparse_categorical_accuracy: 0.9048
Epoch 2/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1596 - sparse_categorical_accuracy: 0.9529
Epoch 3/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1165 - sparse_categorical_accuracy: 0.9658
Evaluate
157/157 [==============================] - 0s 1ms/step - loss: 0.1147 - sparse_categorical_accuracy: 0.9659

{'loss': 0.11471886932849884,
 '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 [==============================] - 0s 2ms/step - loss: 0.8448 - sparse_categorical_accuracy: 0.7734
Epoch 2/3
100/100 [==============================] - 0s 2ms/step - loss: 0.3912 - sparse_categorical_accuracy: 0.8922
Epoch 3/3
100/100 [==============================] - 0s 2ms/step - loss: 0.3399 - sparse_categorical_accuracy: 0.9011

<tensorflow.python.keras.callbacks.History at 0x7f74ec5cf7f0>

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

आप 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 2ms/step - loss: 0.3384 - sparse_categorical_accuracy: 0.9032 - val_loss: 0.1752 - val_sparse_categorical_accuracy: 0.9518

<tensorflow.python.keras.callbacks.History at 0x7f74ec4d2ba8>

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

यदि आप इस डेटासेट से केवल कुछ विशिष्ट बैचों पर सत्यापन चलाना चाहते हैं, तो आप 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.3503 - sparse_categorical_accuracy: 0.9021 - val_loss: 0.3226 - val_sparse_categorical_accuracy: 0.9156

<tensorflow.python.keras.callbacks.History at 0x7f74ec4caa58>

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

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.3729 - sparse_categorical_accuracy: 0.9025

<tensorflow.python.keras.callbacks.History at 0x7f74ec265358>

नमूना वजन

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

  • 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.3837 - sparse_categorical_accuracy: 0.8984

<tensorflow.python.keras.callbacks.History at 0x7f74ec11afd0>

यहाँ एक मिलान 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.3792 - sparse_categorical_accuracy: 0.9030

<tensorflow.python.keras.callbacks.History at 0x7f74d47f2208>

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

पिछले उदाहरणों में, हम एक एकल इनपुट (आकार का (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)

png

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

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()},
)

एक मल्टी-इनपुट या मल्टी-आउटपुट मॉडल को डेटा को फिट करने के लिए पास करना एक समान तरीके से काम करता है जैसा कि संकलन में हानि फ़ंक्शन को निर्दिष्ट करता है: आप 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 [==============================] - 0s 6ms/step - loss: 20.0184 - score_output_loss: 0.5383 - class_output_loss: 19.4800
4/4 [==============================] - 0s 4ms/step - loss: 17.7266 - score_output_loss: 0.3122 - class_output_loss: 17.4145

<tensorflow.python.keras.callbacks.History at 0x7f755022feb8>

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

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 [==============================] - 0s 8ms/step - loss: 17.2156 - score_output_loss: 0.2522 - class_output_loss: 16.9634

<tensorflow.python.keras.callbacks.History at 0x7f75c56c1128>

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

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

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

कॉलबैक को 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 [==============================] - 1s 2ms/step - loss: 0.3816 - sparse_categorical_accuracy: 0.8913 - val_loss: 0.2325 - val_sparse_categorical_accuracy: 0.9304
Epoch 2/20
625/625 [==============================] - 1s 2ms/step - loss: 0.1773 - sparse_categorical_accuracy: 0.9477 - val_loss: 0.2088 - val_sparse_categorical_accuracy: 0.9343
Epoch 3/20
625/625 [==============================] - 1s 2ms/step - loss: 0.1293 - sparse_categorical_accuracy: 0.9606 - val_loss: 0.1515 - val_sparse_categorical_accuracy: 0.9568
Epoch 4/20
625/625 [==============================] - 1s 2ms/step - loss: 0.1009 - sparse_categorical_accuracy: 0.9700 - val_loss: 0.1376 - val_sparse_categorical_accuracy: 0.9607
Epoch 5/20
625/625 [==============================] - 1s 2ms/step - loss: 0.0821 - sparse_categorical_accuracy: 0.9747 - val_loss: 0.1533 - val_sparse_categorical_accuracy: 0.9545
Epoch 6/20
625/625 [==============================] - 1s 2ms/step - loss: 0.0704 - sparse_categorical_accuracy: 0.9794 - val_loss: 0.1319 - val_sparse_categorical_accuracy: 0.9616
Epoch 00006: early stopping

<tensorflow.python.keras.callbacks.History at 0x7f74d46abdd8>

कई बिल्ट-इन कॉलबैक उपलब्ध हैं

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

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

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

आप बेस क्लास keras.callbacks.Callback विस्तार करके एक कस्टम कॉलबैक बना सकते हैं। एक कॉलबैक को क्लास प्रॉपर्टी self.model माध्यम से अपने संबंधित मॉडल तक पहुंच 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
608/625 [============================>.] - ETA: 0s - loss: 0.3797 - sparse_categorical_accuracy: 0.8940
Epoch 00001: val_loss improved from inf to 0.23986, saving model to mymodel_1
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: mymodel_1/assets
625/625 [==============================] - 2s 3ms/step - loss: 0.3765 - sparse_categorical_accuracy: 0.8949 - val_loss: 0.2399 - val_sparse_categorical_accuracy: 0.9276
Epoch 2/2
606/625 [============================>.] - ETA: 0s - loss: 0.1758 - sparse_categorical_accuracy: 0.9474
Epoch 00002: val_loss improved from 0.23986 to 0.19765, saving model to mymodel_2
INFO:tensorflow:Assets written to: mymodel_2/assets
625/625 [==============================] - 2s 3ms/step - loss: 0.1751 - sparse_categorical_accuracy: 0.9477 - val_loss: 0.1976 - val_sparse_categorical_accuracy: 0.9409

<tensorflow.python.keras.callbacks.History at 0x7f7550171f28>

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
  94/1563 [>.............................] - ETA: 3s - loss: 0.9261 - sparse_categorical_accuracy: 0.7420INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.90/assets
 192/1563 [==>...........................] - ETA: 6s - loss: 0.6734 - sparse_categorical_accuracy: 0.8097INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.66/assets
 292/1563 [====>.........................] - ETA: 6s - loss: 0.5676 - sparse_categorical_accuracy: 0.8390INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.56/assets
 393/1563 [======>.......................] - ETA: 6s - loss: 0.5077 - sparse_categorical_accuracy: 0.8543INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.51/assets
 490/1563 [========>.....................] - ETA: 5s - loss: 0.4665 - sparse_categorical_accuracy: 0.8652INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.46/assets
 589/1563 [==========>...................] - ETA: 5s - loss: 0.4356 - sparse_categorical_accuracy: 0.8735INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.43/assets
 690/1563 [============>.................] - ETA: 4s - loss: 0.4077 - sparse_categorical_accuracy: 0.8813INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.41/assets
 791/1563 [==============>...............] - ETA: 4s - loss: 0.3883 - sparse_categorical_accuracy: 0.8873INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.39/assets
 892/1563 [================>.............] - ETA: 3s - loss: 0.3715 - sparse_categorical_accuracy: 0.8921INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.37/assets
 992/1563 [==================>...........] - ETA: 3s - loss: 0.3569 - sparse_categorical_accuracy: 0.8964INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.36/assets
1092/1563 [===================>..........] - ETA: 2s - loss: 0.3444 - sparse_categorical_accuracy: 0.8994INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.34/assets
1194/1563 [=====================>........] - ETA: 2s - loss: 0.3315 - sparse_categorical_accuracy: 0.9025INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.33/assets
1293/1563 [=======================>......] - ETA: 1s - loss: 0.3217 - sparse_categorical_accuracy: 0.9056INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.32/assets
1383/1563 [=========================>....] - ETA: 1s - loss: 0.3145 - sparse_categorical_accuracy: 0.9077INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.31/assets
1478/1563 [===========================>..] - ETA: 0s - loss: 0.3057 - sparse_categorical_accuracy: 0.9102INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.30/assets
1563/1563 [==============================] - 9s 6ms/step - loss: 0.2996 - sparse_categorical_accuracy: 0.9119

<tensorflow.python.keras.callbacks.History at 0x7f74ec20d668>

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

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

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

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

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

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

आप किसी शेड्यूल ऑब्जेक्ट को अपने ऑप्टिमाइज़र में 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 कॉलबैक का उपयोग करना

त्सेरबोर्ड को केरस मॉडल और फिट विधि के साथ उपयोग करने का सबसे आसान तरीका 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 0x7f74ec5179e8>

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