Neural Network on Keras
Create a new Jupyter notebook with python 2.7 kernel. Name it as TensorFlow Keras. Let’s import all the required modules. Import libraries and modules.
%pylab inline import numpy as np np.random.seed(123) # for reproducibility from keras.models import Sequential from keras.layers import Dense, Dropout, Activation, Flatten from keras.layers import Convolution2D, MaxPooling2D from keras.utils import np_utils
Populating the interactive namespace from numpy and matplotlib. Load image data from MNIST.
from keras.datasets import mnist # Load pre-shuffled MNIST data into train and test sets (X_train, y_train), (X_test, y_test) = mnist.load_data()
Shape of the dataset
print X_train.shape
60,000 samples in the training set, and the images are 28 pixels x 28 pixels each. Plotting the first sample in matplotlib
from matplotlib import pyplot as plt plt.imshow(X_train[0])
Preprocess input data for Keras. When using the Theano backend, you must explicitly declare a dimension for the depth of the input image. For example, a full-color image with all 3 RGB channels will have a depth of 3. Our MNIST images only have a depth of 1, but we must explicitly declare that. In other words, we want to transform our dataset from having shape (n, width, height) to (n, depth, width, height).
X_train = X_train.reshape(X_train.shape[0], 1, 28, 28) X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)
Show X_train’s dimensions again
print X_train.shape
The final preprocessing step for the input data is to convert our data type to float32 and normalize our data values to the range [0, 1].
X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train /= 255 X_test /= 255
Preprocess class labels for Keras. Check shape of our class label data.
print y_train.shape
Convert 1-dimensional class arrays to 10-dimensional class matrices
Y_train = np_utils.to_categorical(y_train, 10) Y_test = np_utils.to_categorical(y_test, 10)
Check shape of our class label data again
print Y_train.shape
Define model architecture. Declaring a sequential model format
model = Sequential()
Declare the input layer which is (1, 28, 28) that corresponds to the (depth, width, height) of each digit image
model.add(Convolution2D(32, (3, 3), activation='relu', input_shape=(1,28,28), data_format='channels_first'))
Shape of the current model output
print model.output_shape
Add more layers to our model. For Dense layers, the first parameter is the output size of the layer. Keras automatically handles the connections between layers.
Note that the final layer has an output size of 10, corresponding to the 10 classes of digits.
Also note that the weights from the Convolution layers must be flattened (made 1-dimensional) before passing them to the fully connected Dense layer.
model.add(Convolution2D(32, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(10, activation='softmax'))
Compile model. Declare the loss function and the optimizer (SGD, Adam, etc.).
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
Fit model on training data. Declare the batch size and number of epochs to train for, then pass in training data
model.fit(X_train, Y_train, batch_size=32, epochs=10, verbose=1)
Evaluate model on test data.
score = model.evaluate(X_test, Y_test, verbose=0)
Predict the image
Y_test = model.predict_classes(X_test, verbose=2)
One thought on “TensorFlow Tutorial for Data Scientist – Part 6”