विशेषज्ञों के लिए TensorFlow 2 क्विकस्टार्ट

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

यह एक Google सहयोगी नोटबुक फ़ाइल है। पायथन प्रोग्राम सीधे ब्राउज़र में चलाए जाते हैं - TensorFlow सीखने और उपयोग करने का एक शानदार तरीका। इस ट्यूटोरियल का अनुसरण करने के लिए, इस पृष्ठ के शीर्ष पर स्थित बटन पर क्लिक करके नोटबुक को Google Colab में चलाएँ।

  1. Colab में, Python रनटाइम से कनेक्ट करें: मेन्यू बार में सबसे ऊपर दाईं ओर, कनेक्ट करें चुनें.
  2. सभी नोटबुक कोड सेल चलाएँ : रनटाइम > सभी चलाएँ चुनें।

TensorFlow 2 डाउनलोड और इंस्टॉल करें। अपने प्रोग्राम में TensorFlow आयात करें:

अपने प्रोग्राम में TensorFlow आयात करें:

import tensorflow as tf

from tensorflow.keras.layers import Dense, Flatten, Conv2D
from tensorflow.keras import Model

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

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# Add a channels dimension
x_train = x_train[..., tf.newaxis].astype("float32")
x_test = x_test[..., tf.newaxis].astype("float32")

tf.data को tf.data और फेरबदल करने के लिए tf.data का उपयोग करें:

train_ds = tf.data.Dataset.from_tensor_slices(
    (x_train, y_train)).shuffle(10000).batch(32)

test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)

tf.keras मॉडल tf.keras एपीआई का उपयोग करके tf.keras मॉडल tf.keras :

class MyModel(Model):
  def __init__(self):
    super(MyModel, self).__init__()
    self.conv1 = Conv2D(32, 3, activation='relu')
    self.flatten = Flatten()
    self.d1 = Dense(128, activation='relu')
    self.d2 = Dense(10)

  def call(self, x):
    x = self.conv1(x)
    x = self.flatten(x)
    x = self.d1(x)
    return self.d2(x)

# Create an instance of the model
model = MyModel()

प्रशिक्षण के लिए एक अनुकूलक और हानि फ़ंक्शन चुनें:

loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

optimizer = tf.keras.optimizers.Adam()

मॉडल के नुकसान और सटीकता को मापने के लिए मेट्रिक्स का चयन करें। ये मेट्रिक्स युगों में मूल्यों को जमा करते हैं और फिर समग्र परिणाम प्रिंट करते हैं।

train_loss = tf.keras.metrics.Mean(name='train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

test_loss = tf.keras.metrics.Mean(name='test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')

मॉडल को प्रशिक्षित करने के लिएtf.GradientTape का उपयोग करें:

@tf.function
def train_step(images, labels):
  with tf.GradientTape() as tape:
    # training=True is only needed if there are layers with different
    # behavior during training versus inference (e.g. Dropout).
    predictions = model(images, training=True)
    loss = loss_object(labels, predictions)
  gradients = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

  train_loss(loss)
  train_accuracy(labels, predictions)

मॉडल का परीक्षण करें:

@tf.function
def test_step(images, labels):
  # training=False is only needed if there are layers with different
  # behavior during training versus inference (e.g. Dropout).
  predictions = model(images, training=False)
  t_loss = loss_object(labels, predictions)

  test_loss(t_loss)
  test_accuracy(labels, predictions)
EPOCHS = 5

for epoch in range(EPOCHS):
  # Reset the metrics at the start of the next epoch
  train_loss.reset_states()
  train_accuracy.reset_states()
  test_loss.reset_states()
  test_accuracy.reset_states()

  for images, labels in train_ds:
    train_step(images, labels)

  for test_images, test_labels in test_ds:
    test_step(test_images, test_labels)

  print(
    f'Epoch {epoch + 1}, '
    f'Loss: {train_loss.result()}, '
    f'Accuracy: {train_accuracy.result() * 100}, '
    f'Test Loss: {test_loss.result()}, '
    f'Test Accuracy: {test_accuracy.result() * 100}'
  )
Epoch 1, Loss: 0.13717158138751984, Accuracy: 95.86000061035156, Test Loss: 0.06587446480989456, Test Accuracy: 97.82999420166016
Epoch 2, Loss: 0.043185196816921234, Accuracy: 98.68500518798828, Test Loss: 0.05287541449069977, Test Accuracy: 98.27999877929688
Epoch 3, Loss: 0.022479964420199394, Accuracy: 99.26499938964844, Test Loss: 0.06215928494930267, Test Accuracy: 98.1500015258789
Epoch 4, Loss: 0.013441390357911587, Accuracy: 99.55000305175781, Test Loss: 0.06074066460132599, Test Accuracy: 98.23999786376953
Epoch 5, Loss: 0.009441041387617588, Accuracy: 99.6883316040039, Test Loss: 0.054912615567445755, Test Accuracy: 98.5199966430664

इमेज क्लासिफायरियर को अब इस डेटासेट पर ~98% सटीकता के लिए प्रशिक्षित किया गया है। अधिक जानने के लिए, TensorFlow ट्यूटोरियल पढ़ें।