इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

Tf.function के साथ XLA का उपयोग करें

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें

यह ट्यूटोरियल MNIST डेटासेट को वर्गीकृत करने के लिए एक TensorFlow मॉडल को प्रशिक्षित करता है, जहाँ XLA का उपयोग करके प्रशिक्षण कार्य संकलित किया जाता है।

सबसे पहले, TensorFlow लोड करें और उत्सुक निष्पादन को सक्षम करें।

import tensorflow as tf
tf.compat.v1.enable_eager_execution()

फिर कुछ आवश्यक स्थिरांक परिभाषित करें और MNIST डेटासेट तैयार करें।

# Size of each input image, 28 x 28 pixels
IMAGE_SIZE = 28 * 28
# Number of distinct number labels, [0..9]
NUM_CLASSES = 10
# Number of examples in each training batch (step)
TRAIN_BATCH_SIZE = 100
# Number of training steps to run
TRAIN_STEPS = 1000

# Loads MNIST dataset.
train, test = tf.keras.datasets.mnist.load_data()
train_ds = tf.data.Dataset.from_tensor_slices(train).batch(TRAIN_BATCH_SIZE).repeat()

# Casting from raw data to the required datatypes.
def cast(images, labels):
  images = tf.cast(
      tf.reshape(images, [-1, IMAGE_SIZE]), tf.float32)
  labels = tf.cast(labels, tf.int64)
  return (images, labels)
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 1s 0us/step

अंत में, मॉडल और ऑप्टिमाइज़र को परिभाषित करें। मॉडल एकल घने परत का उपयोग करता है।

layer = tf.keras.layers.Dense(NUM_CLASSES)
optimizer = tf.keras.optimizers.Adam()

प्रशिक्षण समारोह को परिभाषित करें

प्रशिक्षण फ़ंक्शन में, आपको ऊपर बताई गई परत का उपयोग करके अनुमानित लेबल मिलते हैं, और फिर ऑप्टिमाइज़र का उपयोग करके नुकसान की प्रवणता को कम करते हैं। tf.function का उपयोग करके अभिकलन संकलित करने के लिए, इसे experimental_compile=True tf.function में experimental_compile=True साथ tf.function

@tf.function(experimental_compile=True)
def train_mnist(images, labels):
    images, labels = cast(images, labels)

    with tf.GradientTape() as tape:
      predicted_labels = layer(images)
      loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
          logits=predicted_labels, labels=labels
      ))
    layer_variables = layer.trainable_variables
    grads = tape.gradient(loss, layer_variables)
    optimizer.apply_gradients(zip(grads, layer_variables))

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

एक बार जब आप प्रशिक्षण फ़ंक्शन को परिभाषित कर लेते हैं, तो मॉडल को परिभाषित करें।

for images, labels in train_ds:
  if optimizer.iterations > TRAIN_STEPS:
    break
  train_mnist(images, labels)

और, अंत में, सटीकता की जांच करें:

images, labels = cast(test[0], test[1])
predicted_labels = layer(images)
correct_prediction = tf.equal(tf.argmax(predicted_labels, 1), labels)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print("Prediction accuracy after training: %s" % accuracy)
Prediction accuracy after training: tf.Tensor(0.8829, shape=(), dtype=float32)