Running MNIST on Cloud TPU

This tutorial contains a high-level description of the MNIST model, instructions on downloading the MNIST TensorFlow TPU code sample, and a guide to running the code on Cloud TPU.

Note: This information is also covered in the Cloud TPU quickstart.

Disclaimer

This tutorial uses a third-party dataset. Google provides no representation, warranty, or other guarantees about the validity, or any other aspects of, this dataset.

Model description

The MNIST dataset contains a large number of images of hand-written digits in the range 0 to 9, as well as the labels identifying the digit in each image.

This tutorial trains a machine learning model to classify images based on the MNIST dataset. After training, the model classifies incoming images into 10 categories (0 to 9) based on what it's learned about handwritten images from the MNIST dataset. You can then send the model an image that it hasn't seen before, and the model identifies the digit in the image based on what the model has learned during training.

The MNIST dataset has been split into three parts:

• 55,000 examples of training data
• 10,000 examples of test data
• 5,000 examples of validation data

You can find more information about the dataset at the MNIST database site.

The model has a mixture of seven layers:

• 2 x convolution
• 2 x max pooling
• 2 x dense (fully connected)
• 1 x dropout

Loss is computed via softmax.

This version of the MNIST model uses tf.estimator —a high-level TensorFlow API—which is the recommended way to build and run a machine learning model on a Cloud TPU.

The Tensorflow Estimator API simplifies the model development process by hiding most of the low-level implementation, which also makes it easy to switch between TPU and other test platforms such as GPUs or CPUs.

Note: This model performs training only.

Before you begin

Before starting this tutorial, check that your Google Cloud Platform project is correctly set up.

1. Sign in to your Google Account.

   If you don't already have one, sign up for a new account.

2. Select or create a Google Cloud Platform project.

   Note: If you don't plan to keep the resources you create in this tutorial, create a new project instead of selecting an existing project. After you finish, you can delete the project, removing all resources associated with the project and tutorial.

   Go to the Manage resources page

3. Make sure that billing is enabled for your Google Cloud Platform project.

   Learn how to enable billing

This walkthrough uses billable components of Google Cloud Platform. Check the Cloud TPU pricing page to estimate your costs. Be sure to clean up resources you create when you've finished with them to avoid unnecessary charges.

Set up your resources

This section provides information on setting up Cloud Storage storage, VM, and Cloud TPU resources for tutorials.

Important: Be sure to set up all resources in the same region/zone.

Create a Cloud Storage bucket

You need a Cloud Storage bucket to store the data you use to train your model and the training results. The ctpu up tool used in this tutorial sets up default permissions for the Cloud TPU service account. If you want finer-grain permissions, review the access level permissions.

The bucket you create must reside in the same region as your virtual machine (VM) and your Cloud TPU device or Cloud TPU slice (multiple TPU devices) do.

1. Go to the Cloud Storage page on the GCP Console.

   Go to the Cloud Storage page

2. Create a new bucket, specifying the following options:

   • A unique name of your choosing.
   • Default storage class: Regional
   • Location: If you want to use a Cloud TPU device, accept the default presented. If you want to use a Cloud TPU Pod slice, you must specify a region where Cloud TPU Pods are available.

Use the ctpu tool

This section demonstrates using the Cloud TPU provisioning tool (ctpu) for creating and managing Cloud TPU project resources. The resources are comprised of a virtual machine (VM) and a Cloud TPU resource that have the same name. These resources must reside in the same region/zone as the bucket you just created.

You can also set up your VM and TPU resources using gcloud commands or through the Cloud Console. See the managing VM and TPU resources page to learn all the ways you can set up and manage your Compute Engine VM and Cloud TPU resources.

Run ctpu up to create resources

1. Open a Cloud Shell window.

   Open Cloud Shell

2. Run ctpu up specifying the flags shown for either a Cloud TPU device or Pod slice. Refer to CTPU Reference for flag options and descriptions.

3. Set up a Cloud TPU device:

   $ ctpu up 

   Note: If you have more than one project, you must specify the project name.

   The following configuration message appears:

   ctpu will use the following configuration:
   
   Name: [your TPU's name]
   Zone: [your project's zone]
   GCP Project: [your project's name]
   TensorFlow Version: 1.13
   VM:
    Machine Type: [your machine type]
    Disk Size: [your disk size]
    Preemptible: [true or false]
   Cloud TPU:
    Size: [your TPU size]
    Preemptible: [true or false]
   
   OK to create your Cloud TPU resources with the above configuration? [Yn]:
   

   Press y to create your Cloud TPU resources.

Note: The first time you run ctpu up on a project it takes about 5 minutes to perform startup tasks such as SSH key propagation and API turnup.

The ctpu up command creates a virtual machine (VM) and Cloud TPU services.

From this point on, a prefix of (vm)$ means you should run the command on the Compute Engine VM instance.

Verify your Compute Engine VM

When the ctpu up command has finished executing, verify that your shell prompt has changed from username@project to username@tpuname. This change shows that you are now logged into your Compute Engine VM.

Get the data

The MNIST dataset is hosted on the MNIST database site. Follow the instructions below to download and convert the data to the required format, and to upload the converted data to Cloud Storage.

Download and convert the MNIST data

The convert_to_records.py script downloads the data and converts it to the TFRecord format expected by the example MNIST model.

Use the following commands to run the script and decompress the files:

(vm)$ python /usr/share/tensorflow/tensorflow/examples/how_tos/reading_data/convert_to_records.py --directory=./data
(vm)$ gunzip ./data/*.gz

Upload the data to Cloud Storage

Upload the data to your Cloud Storage bucket so that the TPU server can access the data. When setting the variable in the commands below, replace YOUR-BUCKET-NAME with the name of your Cloud Storage bucket:

(vm)$ export STORAGE_BUCKET=gs://YOUR-BUCKET-NAME
(vm)$ gsutil cp -r ./data ${STORAGE_BUCKET}

Run the MNIST TPU model

The MNIST TPU model is pre-installed on your Compute Engine VM in the following directory:

/usr/share/models/official/mnist/

The source code for the MNIST TPU model is also available on GitHub. You can run the model on a Cloud TPU. Alternatively, see how to run the model on a local machine.

Running the model on Cloud TPU

In the following steps, a prefix of (vm)$ means you should run the command on your Compute Engine VM:

1. Run the MNIST model:

   (vm)$ python /usr/share/models/official/mnist/mnist_tpu.py \
     --tpu=$TPU_NAME \
     --data_dir=${STORAGE_BUCKET}/data \
     --model_dir=${STORAGE_BUCKET}/output \
     --use_tpu=True \
     --iterations=500 \
     --train_steps=2000
   

   • --tpu specifies the name of the Cloud TPU. Note that ctpu passes this name to the Compute Engine VM as an environment variable (TPU_NAME).
   • --data_dir specifies the Cloud Storage path for training input.
   • --model_dir specifies the directory where checkpoints and summaries are stored during model training. If the folder is missing, the program creates one. When using a Cloud TPU, the model_dir must be a Cloud Storage path (gs://...). You can reuse an existing folder to load current checkpoint data and to store additional checkpoints.
   • --iterations specifies the number of training steps to run on the TPU on each call before returning control to python. If this number is too small (for example, less than 100) then this can result in excessive communication overhead which negatively impacts performance.
   • --train_steps specifies the total number of steps (batches) for training to run.

Running the model on a local (non-TPU) machine

To run the model on a non-TPU machine, omit --tpu, and set the following flag:

--use_tpu=False

This causes the computation to land on a GPU if one is present. If no GPU is present, the computation falls back to the CPU.

What to expect

By default, the tf.estimator model reports loss value and step time in the following format:

    INFO:tensorflow:Calling model_fn.
    INFO:tensorflow:Create CheckpointSaverHook.
    INFO:tensorflow:Done calling model_fn.
    INFO:tensorflow:TPU job name tpu_worker
    INFO:tensorflow:Graph was finalized.
    INFO:tensorflow:Running local_init_op.
    INFO:tensorflow:Done running local_init_op.
    INFO:tensorflow:Init TPU system
    INFO:tensorflow:Start infeed thread controller
    INFO:tensorflow:Starting infeed thread controller.
    INFO:tensorflow:Start outfeed thread controller
    INFO:tensorflow:Starting outfeed thread controller.
    INFO:tensorflow:Enqueue next (500) batch(es) of data to infeed.
    INFO:tensorflow:Dequeue next (500) batch(es) of data from outfeed.
    INFO:tensorflow:Saving checkpoints for 500 into gs://ctpu-mnist-test/output/model.ckpt.
    INFO:tensorflow:loss = 0.08896458, step = 0
    INFO:tensorflow:loss = 0.08896458, step = 0
    INFO:tensorflow:Enqueue next (500) batch(es) of data to infeed.
    INFO:tensorflow:Dequeue next (500) batch(es) of data from outfeed.
    INFO:tensorflow:Enqueue next (500) batch(es) of data to infeed.
    INFO:tensorflow:Dequeue next (500) batch(es) of data from outfeed.
    INFO:tensorflow:global_step/sec: 242.829
    INFO:tensorflow:examples/sec: 248715
    INFO:tensorflow:Enqueue next (500) batch(es) of data to infeed.
    INFO:tensorflow:Dequeue next (500) batch(es) of data from outfeed.
    INFO:tensorflow:Saving checkpoints for 2000 into gs://ctpu-mnist-test/output/model.ckpt.
    INFO:tensorflow:Stop infeed thread controller
    INFO:tensorflow:Shutting down InfeedController thread.
    INFO:tensorflow:InfeedController received shutdown signal, stopping.
    INFO:tensorflow:Infeed thread finished, shutting down.
    INFO:tensorflow:Stop output thread controller
    INFO:tensorflow:Shutting down OutfeedController thread.
    INFO:tensorflow:OutfeedController received shutdown signal, stopping.
    INFO:tensorflow:Outfeed thread finished, shutting down.
    INFO:tensorflow:Shutdown TPU system.
    INFO:tensorflow:Loss for final step: 0.044236258.

Note: This model is extremely small and is not useful for benchmarking TPU performance.

Clean up

To avoid incurring charges to your GCP account for the resources used in this topic:

1. Disconnect from the Compute Engine VM:

   (vm)$ exit
   

   Your prompt should now be user@projectname, showing you are in the Cloud Shell.

2. In your Cloud Shell, run ctpu delete with the --zone flag you used when you set up the Cloud TPU to delete your Compute Engine VM and your Cloud TPU:

   $ ctpu delete [optional: --zone]
   

   Important: If you set the TPU resources name when you ran ctpu up, you must specify that name with the --name flag when you run ctpu delete in order to shut down your TPU resources.

3. Run ctpu status to make sure you have no instances allocated to avoid unnecessary charges for TPU usage. The deletion might take several minutes. A response like the one below indicates there are no more allocated instances:

   2018/04/28 16:16:23 WARNING: Setting zone to "us-central1-b"
   No instances currently exist.
           Compute Engine VM:     --
           Cloud TPU:             --
   

4. Run gsutil as shown, replacing YOUR-BUCKET-NAME with the name of the Cloud Storage bucket you created for this tutorial:

   $ gsutil rm -r gs://YOUR-BUCKET-NAME
   

Note: For free storage limits and other pricing information, see the Cloud Storage pricing guide.

What's next

• Learn more about ctpu, including how to install it on a local machine.
• Verify performance on a large-scale model by running the ResNet sample.
• Explore the TPU tools in TensorBoard.