# coding: utf-8

import matplotlib.pyplot as plt

# ### Global Constants

# Fixed for our Cats & Dogs classes

NUM_CLASSES = 2

# Fixed for Cats & Dogs color images

CHANNELS = 3

IMAGE_RESIZE = 224

RESNET50_POOLING_AVERAGE = 'avg'

DENSE_LAYER_ACTIVATION = 'softmax'

OBJECTIVE_FUNCTION = 'categorical_crossentropy'

# Common accuracy metric for all outputs, but can use different metrics for different output

LOSS_METRICS = ['accuracy']

# EARLY_STOP_PATIENCE must be < NUM_EPOCHS

NUM_EPOCHS = 50

EARLY_STOP_PATIENCE = 3

# These steps value should be proper FACTOR of no.-of-images in train & valid folders respectively

# Training images processed in each step would be no.-of-train-images / STEPS_PER_EPOCH_TRAINING

STEPS_PER_EPOCH_TRAINING = 4030

STEPS_PER_EPOCH_VALIDATION = 1009

# These steps value should be proper FACTOR of no.-of-images in train & valid folders respectively

# NOTE that these BATCH* are for Keras ImageDataGenerator batching to fill epoch step input

BATCH_SIZE_TRAINING = 32

BATCH_SIZE_VALIDATION = 32

# Using 1 to easily manage mapping between test_generator & prediction for submission preparation

BATCH_SIZE_TESTING = 1

from tensorflow.python.keras.applications import ResNet50

from tensorflow.python.keras.models import Sequential

from tensorflow.python.keras.layers import Dense

#### ResNet50

resnet_weights_path = 'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5'

model = Sequential()

# 1st layer as the lumpsum weights from resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5

# NOTE that this layer will be set below as NOT TRAINABLE, i.e., use it as is

model.add(ResNet50(include_top = False, pooling = RESNET50_POOLING_AVERAGE, weights = resnet_weights_path))

# 2nd layer as Dense for 2-class classification, i.e., dog or cat using SoftMax activation

model.add(Dense(NUM_CLASSES, activation = DENSE_LAYER_ACTIVATION))

# Say not to train first layer (ResNet) model as it is already trained

model.layers[0].trainable = False

model.summary()

# ### Compile Our Transfer Learning Model

from tensorflow.python.keras import optimizers

sgd = optimizers.SGD(lr = 0.001, decay = 1e-6, momentum = 0.9, nesterov = True)

model.compile(optimizer = sgd, loss = OBJECTIVE_FUNCTION, metrics = LOSS_METRICS)

# Load Saved_weight

from pathlib import Path

my_file = Path("working/best.hdf5")

if my_file.is_file():

model.load_weights('working/best.hdf5')

# ### Prepare Keras Data Generators

#

from keras.applications.resnet50 import preprocess_input

from keras.preprocessing.image import ImageDataGenerator

image_size = IMAGE_RESIZE

# preprocessing_function is applied on each image but only after re-sizing & augmentation (resize => augment => pre-process)

# Each of the keras.application.resnet* preprocess_input MOSTLY mean BATCH NORMALIZATION (applied on each batch) stabilize the inputs to nonlinear activation functions

# Batch Normalization helps in faster convergence

data_generator = ImageDataGenerator(preprocessing_function=preprocess_input)

# flow_From_directory generates batches of augmented data (where augmentation can be color conversion, etc)

# Both train & valid folders must have NUM_CLASSES sub-folders

train_generator = data_generator.flow_from_directory(

class_mode='categorical')

validation_generator = data_generator.flow_from_directory(

class_mode='categorical')

# Max number of steps that these generator will have opportunity to process their source content

# len(train_generator) should be 'no. of available train images / BATCH_SIZE_TRAINING'

# len(valid_generator) should be 'no. of available train images / BATCH_SIZE_VALIDATION'

(BATCH_SIZE_TRAINING, len(train_generator), BATCH_SIZE_VALIDATION, len(validation_generator))

# ### Train Our Model With Train (splitted) Data Set

# Early stopping & checkpointing the best model in ../working dir & restoring that as our model for prediction

from tensorflow.python.keras.callbacks import EarlyStopping, ModelCheckpoint

cb_early_stopper = EarlyStopping(monitor = 'val_loss', patience = EARLY_STOP_PATIENCE)

cb_checkpointer = ModelCheckpoint(filepath = 'working/best.hdf5', monitor = 'val_loss', save_best_only = True, mode = 'auto')

# ### Start Training Network

import time

Time_start = time.time()

fit_history = model.fit_generator(

)

Time_end = time.time()

print("Training Time (minutes):",round((Time_end - Time_start)/60))

# ### Training Metrics

#

# One of the default callbacks that is registered when training all deep learning models is the History callback. It records training metrics (training accuracy, training loss, validation loss & validation accuracy) for each epoch. Note that training accuracy & loss during epoch steps are somewhat incomplete information and they are not recorded in history.

#

# Observe that training uses early stopping, hence metrics is available for epochs run, not for NUM_EPOCHS.

print(fit_history.history.keys())

plt.figure(1, figsize = (15,8))

plt.subplot(221)

plt.plot(fit_history.history['acc'])

plt.plot(fit_history.history['val_acc'])

plt.title('model accuracy')

plt.ylabel('accuracy')

plt.xlabel('epoch')

plt.legend(['train', 'valid'])

plt.subplot(222)

plt.plot(fit_history.history['loss'])

plt.plot(fit_history.history['val_loss'])

plt.title('model loss')

plt.ylabel('loss')

plt.xlabel('epoch')

plt.legend(['train', 'valid'])

plt.show()