With the release of TensorFlow 2.0 Alpha during the TensorFlow Developer Summit, we’d like to take a moment and look at how we can use it. One of the major updates in this version is the use of Keras as the high-level API and eager execution. If you’re familiar with Keras, you’ll find the code in this short tutorial to be very familiar. In this short tutorial, we’ll illustrate how you can use TensorFlow 2.0 to build a deep learning model.
The first step is to import TensorFlow and Keras. The Keras API is already implemented in TensorFlow, so we can import it from TensorFlow.
import tensorflow as tf from tensorflow import keras
Loading datasets is very similar to how we’d load them using Keras. Let’s show how we’d load in the fashion MNIST datasets.
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
Building the Model
Layers can be added using tf.keras.layers and specifying the layer to be added. Again, if you’ve worked with Keras, this will be very intuitive. We start by initializing the layers Sequential and afterward adding the different layers. Below, we’ll show how that can be accomplished.
model = keras.Sequential([ keras.layers.Flatten(input_shape=(28, 28)), keras.layers.Dense(128, activation=tf.nn.relu), keras.layers.Dense(10, activation=tf.nn.softmax) ])
Compiling the Model
The next step is usually to compile the model by specifying the loss, optimizer, and evaluation metrics. Let’s show how a model can be compiled using the adam optimizer, using sparse_categorical_crossentropy loss, and identifying accuracy as metrics.
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Training the Model
In order to train the model, we’ll need to pass in the training data, its labels, and the number of epochs.
model.fit(training_data, training_labels, epochs=1)
Evaluate the Accuracy
Evaluating the model can be done using the evaluate function as shown below.
test_loss, test_acc = model.evaluate(testing_data, testing_labels) print('Test accuracy:', test_acc)
As you guessed, predictions can be made using the predict method. All you have to do is pass in the testing set.
predictions = model.predict(testing_data)
Saving and Restoring the Model
In order to save a model, one has to first install these two dependencies.
pip install -q h5py pyyaml
Saving the entire model HDF5 file is also very easy, as we’ll see below.
Loading the Saved Model
Loading in the saved model is quite straightforward, as well. All we have to do is call the load_models function and pass in the path to the model.
my_model = keras.models.load_model('model.h5') my_model.summary()
This is obviously a very brief overview of how to use TensorFlow 2.0 Alpha. If you’re just starting out with TensorFlow, you can find some beginner tutorials here. For developers who are a bit more advanced, there’s something for you here.
As you’ve seen, TensorFlow 2.0 Alpha is much easier to implement compared to TensorFlow 1.0. It’s now much easier to define your model using the Keras implementation. Since TensorFlow 2.0 Alpha works in eager mode, you also don’t have to define a session in order to execute the code. You can also take advantage of the many tools in the TensorFlow ecosystem such as TensorBoard for visualizing your results and TensorFlow Serving for hosting your models.