Record model.compile options

Suppose we have a model of two hidden layers as follows:

?

1 2 3

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(),                                     tf.keras.layers.Dense(128, activation=tf.nn.relu),                                     tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

Then our model.compile might have the following as arguments:

?

1 2 3

model.compile(optimizer = tf.optimizers.Adam(),               loss = 'sparse_categorical_crossentropy',               metrics=['accuracy'])

With a callback that stop training at desired loss:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

import tensorflow as tf print(tf.__version__)   class myCallback(tf.keras.callbacks.Callback):   def on_epoch_end(self, epoch, logs={}):     if(logs.get('loss')<0.4):       print("\nReached 60% accuracy so cancelling training!")       self.model.stop_training = True   callbacks = myCallback() mnist = tf.keras.datasets.fashion_mnist (training_images, training_labels), (test_images, test_labels) = mnist.load_data() training_images=training_images/255.0 test_images=test_images/255.0 model = tf.keras.models.Sequential([   tf.keras.layers.Flatten(),   tf.keras.layers.Dense(512, activation=tf.nn.relu),   tf.keras.layers.Dense(10, activation=tf.nn.softmax) ]) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy') model.fit(training_images, training_labels, epochs=5, callbacks=[callbacks])

ResNet

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

def identity_block(X, f, filters, stage, block):     """     Implementation of the identity block as defined in Figure 3           Arguments:     X -- input tensor of shape (m, n_H_prev, n_W_prev, n_C_prev)     f -- integer, specifying the shape of the middle CONV's window for the main path     filters -- python list of integers, defining the number of filters in the CONV layers of the main path     stage -- integer, used to name the layers, depending on their position in the network     block -- string/character, used to name the layers, depending on their position in the network           Returns:     X -- output of the identity block, tensor of shape (n_H, n_W, n_C)     """           # defining name basis     conv_name_base = 'res' + str(stage) + block + '_branch'    bn_name_base = 'bn' + str(stage) + block + '_branch'           # Retrieve Filters     F1, F2, F3 = filters           # Save the input value. You'll need this later to add back to the main path.     X_shortcut = X           # First component of main path     X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)     X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)     X = Activation('relu')(X)           ### START CODE HERE ###           # Second component of main path (≈3 lines)     X = Conv2D(filters = F2, kernel_size = (f,f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)     X = BatchNormalization(axis=3, name=bn_name_base+'2b')(X)     X = Activation('relu')(X)           # Third component of main path (≈2 lines)     X = Conv2D(filters = F3, kernel_size = (1,1), strides = (1,1), padding = 'valid', name = conv_name_base+'2c', kernel_initializer = glorot_uniform(seed=0))(X)     X = BatchNormalization(axis=3, name=bn_name_base+'2c')(X)       # Final step: Add shortcut value to main path, and pass it through a RELU activation (≈2 lines)     X = Add()([X, X_shortcut])     X = Activation('relu')(X)           ### END CODE HERE ###

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

def convolutional_block(X, f, filters, stage, block, s = 2):     """     Implementation of the convolutional block as defined in Figure 4           Arguments:     X -- input tensor of shape (m, n_H_prev, n_W_prev, n_C_prev)     f -- integer, specifying the shape of the middle CONV's window for the main path     filters -- python list of integers, defining the number of filters in the CONV layers of the main path     stage -- integer, used to name the layers, depending on their position in the network     block -- string/character, used to name the layers, depending on their position in the network     s -- Integer, specifying the stride to be used           Returns:     X -- output of the convolutional block, tensor of shape (n_H, n_W, n_C)     """           # defining name basis     conv_name_base = 'res' + str(stage) + block + '_branch'     bn_name_base = 'bn' + str(stage) + block + '_branch'           # Retrieve Filters     F1, F2, F3 = filters           # Save the input value     X_shortcut = X         ##### MAIN PATH #####     # First component of main path     X = Conv2D(F1, (1, 1), strides = (s,s), name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)     X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)     X = Activation('relu')(X)           ### START CODE HERE ###       # Second component of main path (≈3 lines)     X = Conv2D(F2, (f, f), strides = (1,1), padding="same", name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)     X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)     X = Activation('relu')(X)       # Third component of main path (≈2 lines)     X = Conv2D(F3, (1, 1), strides = (1,1), padding="valid", name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)     X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)       ##### SHORTCUT PATH #### (≈2 lines)     X_shortcut = Conv2D(F3, (1, 1), strides = (s,s), padding="valid", name = conv_name_base + '1', kernel_initializer = glorot_uniform(seed=0))(X_shortcut)     X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)             # Final step: Add shortcut value to main path, and pass it through a RELU activation (≈2 lines)     X = Add()([X,  X_shortcut])     X = Activation("relu")(X)           ### END CODE HERE ###           return X

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

def ResNet50(input_shape = (64, 64, 3), classes = 6):     """     Implementation of the popular ResNet50 the following architecture:     CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3     -> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER       Arguments:     input_shape -- shape of the images of the dataset     classes -- integer, number of classes       Returns:     model -- a Model() instance in Keras     """           # Define the input as a tensor with shape input_shape     X_input = Input(input_shape)             # Zero-Padding     X = ZeroPadding2D((3, 3))(X_input)           # Stage 1     X = Conv2D(64, (7, 7), strides = (2, 2), name = 'conv1', kernel_initializer = glorot_uniform(seed=0))(X)     X = BatchNormalization(axis = 3, name = 'bn_conv1')(X)     X = Activation('relu')(X)     X = MaxPooling2D((3, 3), strides=(2, 2))(X)       # Stage 2     X = convolutional_block(X, f = 3, filters = [64, 64, 256], stage = 2, block='a', s = 1)     X = identity_block(X, 3, [64, 64, 256], stage=2, block='b')     X = identity_block(X, 3, [64, 64, 256], stage=2, block='c')       ### START CODE HERE ###       # Stage 3 (≈4 lines)     X = convolutional_block(X, f = 3, filters=[128, 128, 512], stage = 3, block="a", s = 2)     X = identity_block(X, 3, filters=[128,128,512], stage=3, block="b")     X = identity_block(X, 3, filters=[128,128,512], stage=3, block="c")     X = identity_block(X, 3, filters=[128,128,512], stage=3, block="d")       # Stage 4 (≈6 lines)     X = convolutional_block(X, f = 3, filters=[256, 256, 1024], stage = 4, block="a", s = 2)     X = identity_block(X, 3, filters=[256, 256, 1024], stage=4, block="b")     X = identity_block(X, 3, filters=[256, 256, 1024], stage=4, block="c")     X = identity_block(X, 3, filters=[256, 256, 1024], stage=4, block="d")     X = identity_block(X, 3, filters=[256, 256, 1024], stage=4, block="e")     X = identity_block(X, 3, filters=[256, 256, 1024], stage=4, block="f")       # Stage 5 (≈3 lines)     X = convolutional_block(X, f = 3, filters=[512, 512, 2048], stage = 5, block="a", s = 2)     X = identity_block(X, f=3, filters=[512, 512, 2048], stage=5, block="b")     X = identity_block(X, f=3, filters=[512, 512, 2048], stage=5, block="c")       # AVGPOOL (≈1 line). Use "X = AveragePooling2D(...)(X)"     X = AveragePooling2D(pool_size=(2, 2), name="avg_pool")(X)           ### END CODE HERE ###       # output layer     X = Flatten()(X)     X = Dense(classes, activation='softmax', name='fc' + str(classes), kernel_initializer = glorot_uniform(seed=0))(X)                 # Create model     model = Model(inputs = X_input, outputs = X, name='ResNet50')       return model

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])   X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()   # Normalize image vectors X_train = X_train_orig/255. X_test = X_test_orig/255.   # Convert training and test labels to one hot matrices Y_train = convert_to_one_hot(Y_train_orig, 6).T Y_test = convert_to_one_hot(Y_test_orig, 6).T   model.fit(X_train, Y_train, epochs = 2, batch_size = 32)   preds = model.evaluate(X_test, Y_test) print ("Loss = " + str(preds[0])) print ("Test Accuracy = " + str(preds[1]))

Code Assignment

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

def HappyModel(input_shape):     X_input = Input(input_shape)           X = ZeroPadding2D((3,3))(X_input)     X = Conv2D(18,(7,7),strides=(1,1),name="conv0")(X)     X = BatchNormalization(axis=3, name="bn0")(X)     X = Activation("relu")(X)           X = MaxPooling2D((2,2), name="max_pool")(X)           X = Flatten()(X)     X = Dense(1,activation="sigmoid", name="fC")(X)           model = Model(input = X_input, outputs = X, name="happy model")      return model   happyModel = HappyModel(X_train.shape[1:])        happyModel.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"])       happyModel.fit(x=X_train, y=Y_train,epochs=10, batch_size=20)       preds = happyModel.evaluate(x=X_test,y=Y_test)   img_path = 'images/smile.jpg'     img = image.load_img(img_path, target_size=(64, 64)) imshow(img)   x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) print(happyModel.predict(x))