|---|---|---|---| | [View on TensorFlow.org](https://www.tensorflow.org/tutorials/quickstart/advanced) | [Run in Google Colab](https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/tutorials/quickstart/advanced.ipynb) | [View source on GitHub](https://github.com/tensorflow/docs/blob/master/site/en/tutorials/quickstart/advanced.ipynb) | [Download notebook](https://storage.googleapis.com/tensorflow_docs/docs/site/en/tutorials/quickstart/advanced.ipynb) | This is a [Google Colaboratory](https://colab.research.google.com/notebooks/welcome.ipynb) notebook file. Python programs are run directly in the browser---a great way to learn and use TensorFlow. To follow this tutorial, run the notebook in Google Colab by clicking the button at the top of this page. 1. In Colab, connect to a Python runtime: At the top-right of the menu bar, select *CONNECT*. 2. Run all the notebook code cells: Select *Runtime* \> *Run all*. Download and install TensorFlow 2. Import TensorFlow into your program: > [!NOTE] > **Note:** Upgrade `pip` to install the TensorFlow 2 package. See the [install guide](https://www.tensorflow.org/install) for details. Import TensorFlow into your program: import tensorflow as tf print("TensorFlow version:", tf.__version__) from tensorflow.keras.layers import Dense, Flatten, Conv2D from tensorflow.keras import Model ``` 2025-12-01 07:58:53.594395: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered WARNING: All log messages before absl::InitializeLog() is called are written to STDERR E0000 00:00:1764575933.617066 335130 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered E0000 00:00:1764575933.624660 335130 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered W0000 00:00:1764575933.642798 335130 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once. W0000 00:00:1764575933.642818 335130 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once. W0000 00:00:1764575933.642820 335130 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once. W0000 00:00:1764575933.642822 335130 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once. TensorFlow version: 2.19.1 ``` Load and prepare the [MNIST dataset](http://yann.lecun.com/exdb/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") Use [`tf.data`](https://www.tensorflow.org/api_docs/python/tf/data) to batch and shuffle the dataset: 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) ``` I0000 00:00:1764575938.765668 335130 gpu_device.cc:2019] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 13638 MB memory: -> device: 0, name: Tesla T4, pci bus id: 0000:00:05.0, compute capability: 7.5 I0000 00:00:1764575938.768025 335130 gpu_device.cc:2019] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 13756 MB memory: -> device: 1, name: Tesla T4, pci bus id: 0000:00:06.0, compute capability: 7.5 I0000 00:00:1764575938.770313 335130 gpu_device.cc:2019] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 13756 MB memory: -> device: 2, name: Tesla T4, pci bus id: 0000:00:07.0, compute capability: 7.5 I0000 00:00:1764575938.772495 335130 gpu_device.cc:2019] Created device /job:localhost/replica:0/task:0/device:GPU:3 with 13756 MB memory: -> device: 3, name: Tesla T4, pci bus id: 0000:00:08.0, compute capability: 7.5 ``` Build the [`tf.keras`](https://www.tensorflow.org/api_docs/python/tf/keras) model using the Keras [model subclassing API](https://www.tensorflow.org/guide/keras/custom_layers_and_models): class MyModel(Model): def __init__(self): super().__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() Choose an optimizer and loss function for training: loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) optimizer = tf.keras.optimizers.Adam() Select metrics to measure the loss and the accuracy of the model. These metrics accumulate the values over epochs and then print the overall result. 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') Use [`tf.GradientTape`](https://www.tensorflow.org/api_docs/python/tf/GradientTape) to train the model: @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) Test the model: @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_state() train_accuracy.reset_state() test_loss.reset_state() test_accuracy.reset_state() 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():0.2f}, ' f'Accuracy: {train_accuracy.result() * 100:0.2f}, ' f'Test Loss: {test_loss.result():0.2f}, ' f'Test Accuracy: {test_accuracy.result() * 100:0.2f}' ) ``` I0000 00:00:1764575941.678208 335298 cuda_dnn.cc:529] Loaded cuDNN version 91600 Epoch 1, Loss: 0.13, Accuracy: 96.07, Test Loss: 0.06, Test Accuracy: 98.00 Epoch 2, Loss: 0.04, Accuracy: 98.71, Test Loss: 0.06, Test Accuracy: 98.21 Epoch 3, Loss: 0.02, Accuracy: 99.39, Test Loss: 0.05, Test Accuracy: 98.36 Epoch 4, Loss: 0.01, Accuracy: 99.63, Test Loss: 0.05, Test Accuracy: 98.45 Epoch 5, Loss: 0.01, Accuracy: 99.72, Test Loss: 0.07, Test Accuracy: 98.08 ``` The image classifier is now trained to \~98% accuracy on this dataset. To learn more, read the [TensorFlow tutorials](https://www.tensorflow.org/tutorials).