☕
Python-ML
  • README
  • Chapter1
    • Hello Linux
    • Command Line
    • Vim
  • Chapter2
    • conda: the Python environment manager
    • Transfer to Python
    • Object Oriented
    • Importing modules
    • pip: Package manager
    • DS Utilities: Numpy
  • Chapter3
    • Implementation of Neural Networks from scratch
    • Gradient Descent
    • Introduction to Tensorflow
    • CNN: NN with image processing
    • Introduction to Data Augmentation
    • Brief introduction to miscellaneous Neural Networks
Powered by GitBook
On this page
  • TensorFlow 2 quickstart for beginners
  • Set up TensorFlow
  • Load a dataset
  • Build a machine learning model
  • Train and evaluate your model
  • Conclusion
  1. Chapter3

Introduction to Tensorflow

PreviousGradient DescentNextCNN: NN with image processing

Last updated 2 years ago

Copyright 2019 The TensorFlow Authors

#@title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

TensorFlow 2 quickstart for beginners

This short introduction uses to:

  1. Load a prebuilt dataset.

  2. Build a neural network machine learning model that classifies images.

  3. Train this neural network.

  4. Evaluate the accuracy of the model.

  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.

Set up TensorFlow

import tensorflow as tf
print("TensorFlow version:", tf.__version__)

Load a dataset

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

Build a machine learning model

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10)
])
predictions = model(x_train[:1]).numpy()
predictions

The tf.nn.softmax function converts these logits to probabilities for each class:

tf.nn.softmax(predictions).numpy()

Note: It is possible to bake the tf.nn.softmax function into the activation function for the last layer of the network. While this can make the model output more directly interpretable, this approach is discouraged as it's impossible to provide an exact and numerically stable loss calculation for all models when using a softmax output.

Define a loss function for training using losses.SparseCategoricalCrossentropy, which takes a vector of logits and a True index and returns a scalar loss for each example.

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

This loss is equal to the negative log probability of the true class: The loss is zero if the model is sure of the correct class.

This untrained model gives probabilities close to random (1/10 for each class), so the initial loss should be close to -tf.math.log(1/10) ~= 2.3.

loss_fn(y_train[:1], predictions).numpy()
model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['accuracy'])

Train and evaluate your model

model.fit(x_train, y_train, epochs=5)
model.evaluate(x_test,  y_test, verbose=2)

If you want your model to return a probability, you can wrap the trained model, and attach the softmax to it:

probability_model = tf.keras.Sequential([
  model,
  tf.keras.layers.Softmax()
])
probability_model(x_test[:5])

Conclusion

This tutorial is a notebook. 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.

If you are following along in your own development environment, rather than , see the for setting up TensorFlow for development.

Note: Make sure you have upgraded to the latest pip to install the TensorFlow 2 package if you are using your own development environment. See the for details.

For each example, the model returns a vector of or scores, one for each class.

Before you start training, configure and compile the model using Keras Model.compile. Set the class to adam, set the loss to the loss_fnfunction you defined earlier, and specify a metric to be evaluated for the model by setting the metrics parameter to accuracy.

The Model.evaluate method checks the models performance, usually on a "" or "".

The image classifier is now trained to ~98% accuracy on this dataset. To learn more, read the .

Congratulations! You have trained a machine learning model using a prebuilt dataset using the API.

For more examples of using Keras, check out the . To learn more about building models with Keras, read the . If you want learn more about loading and preparing data, see the tutorials on or .

Keras
Google Colaboratory
Colab
install guide
install guide
logits
log-odds
optimizer
Validation-set
Test-set
TensorFlow tutorials
Keras
tutorials
guides
image data loading
CSV data loading
View on TensorFlow.org
Run in Google Colab
View source on GitHub
Download notebook