main.py

import Import_Data
import Data_Description
import Data_Augmentation
import Model_Evaluation

import random
import math
import json
import tensorflow as tf
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Activation, Dense, Dropout, Flatten, BatchNormalization
from tensorflow.keras.layers import RandomFlip, RandomRotation, RandomZoom
from tensorflow.keras.models import Sequential
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
# from tensorflow.keras.regularizers import l1, l2

import warnings
warnings.filterwarnings('ignore')


# -----------------------------------------------------------
print('\n******  Import Data ******')

# Data_dir = 'dataset'
Data_dir = 'CNN_Model_HandWriting_Digits/dataset'

random.seed(42)

batch_size = input('Please enter batch size: *** it must be a positive Integer ***\n')
batch_size = Import_Data.evaluate_digit(batch_size)

train_indeces, test_indeces = Import_Data.number_images_class(Data_dir,
                                                              batch_size= batch_size)

print("--------------------------------------------------------------\n")

n_sample_in_each_class = input(
    'Please enter the number of samples in each classes that you'
     ' want to train the model: *** it must be a positive Integer ***\n'
     )
n_sample_in_each_class = Import_Data.evaluate_digit(n_sample_in_each_class)
n_total_imgs, differ_samples = Import_Data.n_samples_evaluation(n_sample_in_each_class,
                                                                train_indeces,
                                                                batch_size= batch_size)

train_paths, test_paths = Import_Data.load_Directory(Data_dir= Data_dir,
                                                     train_indeces= train_indeces,
                                                     test_indeces= test_indeces)

label_to_index = {label: idx for idx, label in enumerate(train_paths['label'].unique())}

train_dataset, test_dataset = Import_Data.create_tf_dataset(train_paths,
                                                            test_paths,
                                                            label_to_index,
                                                            n_total_imgs= n_total_imgs,
                                                            differ_samples= differ_samples,
                                                            show_sample= True)

# -----------------------------------------------------------
print('******  Data Description ******')

index_to_label = {value: key for key, value in label_to_index.items()}
print(f"\nlabel to index is:\n  {label_to_index}")

print('\nTable of Train Dataset:')
Data_Description.label_count(train_dataset, index_to_label)
print('\n--------------------------------------------------------------\n')
print('Table of Test Dataset:')
Data_Description.label_count(test_dataset, index_to_label)

Data_Description.plot_dataset_sample(train_dataset,
                    index_to_label,
                    'Train',
                    n_classes= 10,
                    n_plot= 5,
                    img_size= (28, 28))

print('\n*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n')

# -----------------------------------------------------------
# If you want to have data augmentation seperatly, run this section
# Data Augmentation
#print('******  Data Augmentation ******')
# more_samples= int(input('How many samples do you want to produce?\n '))
# n_augmented_samples = len(train_dataset) + more_samples
# train_dataset = Data_Augmentation.data_augmentation(train_dataset,
#                                                     n_labels= 10,
#                                                     n_augmented_samples= n_augmented_samples,
#                                                     is_batched= 1,
#                                                     batch_size= batch_size
#                                                     )

# Data_Description.label_count(train_dataset, index_to_label)

# Data_Description.plot_dataset_sample(train_dataset,
#                                      index_to_label,
#                                      'Train_Augmentation',
#                                      n_classes= 10,
#                                      is_batched= True,
#                                      n_samples_each_label= 320320,
#                                      n_plot= 5,
#                                      img_size= (28, 28))

# print('\n*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n')

# -----------------------------------------------------------
print('******  Create Validation Dataset ******\n')

total_length = Data_Description.size_dataset(train_dataset)

validation_ratio = 0.2

validation_size = round(validation_ratio * total_length)

train = train_dataset.skip(validation_size)
validation = train_dataset.take(validation_size)

train_size = Data_Description.size_dataset(train)
validation_siz = Data_Description.size_dataset(validation)

steps_per_epoch = train_size
validation_steps = validation_siz

print(f'\nShape of Train set is:\n {train_size* batch_size}')
print(f'\nShape of validation set is:\n {validation_siz* batch_size}')
print(f'\nnumber of batches for train is:\n {train_size}')
print(f'\nnumber of batches for validation is:\n {validation_siz}')
print('\n==============================================================\n')

print('\nShape of Training samples:')
Data_Description.describe_dataset_sample(train)

print('----------------------------------------\n')

print('Shape of validation samples:')
Data_Description.describe_dataset_sample(validation)

print('----------------------------------------\n')

print('Shape of Test samples:')
Data_Description.describe_dataset_sample(test_dataset)

print('\n*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n')

# -----------------------------------------------------------
# print('\n****** Convert to categorical Values ******')

# If you want to convert labels to categorical values, run bellow.
# Consider that you must use Categorical Cross Entropy function as loss function when using categorical values in model.
# This function is defined as Loss_CCE in Model Architect section.
# anyway, in this surway numbers are used as labels so that Sparse Categorical Cross Entropy function is
# used as loss function by Loss_SCCE name in Model Architect section.

# def one_hot_labels(image, label):
#     label = tf.cast(label, tf.int32)
#     one_hot_label = to_categorical(label, num_classes=10)
#     return image, one_hot_label

# train_dataset = train.map(one_hot_labels, num_parallel_calls = tf.data.AUTOTUNE
# ).prefetch(buffer_size=tf.data.AUTOTUNE)
# validation_dataset = validation.map(one_hot_labels, num_parallel_calls = tf.data.AUTOTUNE
# ).prefetch(buffer_size=tf.data.AUTOTUNE)
# test_dataset = test_dataset.map(one_hot_labels, num_parallel_calls = tf.data.AUTOTUNE
# ).prefetch(buffer_size=tf.data.AUTOTUNE)

# print("Train Dataset Sample:\n")
# describe_final_Dataset(train_dataset)
# print('\n-----------------------------------------\n')
# print("Validation Dataset Sample:\n")
# describe_final_Dataset(validation_dataset)
# print('\n-----------------------------------------\n')
# print("Test Dataset Sample:\n")
# describe_final_Dataset(test_dataset)

# -----------------------------------------------------------
print('\n******  CNN Model ******')

#Data Augmentation for modeling
data_augmentation = Sequential(
    [
        RandomFlip('horizontal'),
        RandomRotation(0.1),
        RandomZoom(height_factor=0.2, width_factor=0.2)
    ]
)

# Simple Model Definition

optimizer = tf.keras.optimizers.Adam(learning_rate=0.005)
loss_SCCE = tf.keras.losses.SparseCategoricalCrossentropy()
loss_CCE = tf.keras.losses.CategoricalCrossentropy()

input = tf.keras.Input(shape = (28, 28, 4))
x = (data_augmentation)(input)

x1 = (Conv2D(64, kernel_size=(3, 3), padding = 'same'))(x)
x1 = (BatchNormalization())(x1)
x1 = (Activation('relu'))(x1)
x1 = (Conv2D(64, kernel_size=(3, 3), padding = 'same'))(x1)
x1 = (BatchNormalization())(x1)
x1 = (Activation('relu'))(x1)
x1 = (MaxPooling2D(pool_size=(2, 2), padding = 'same'))(x1)
x1 = (Dropout(0.25))(x1)

x2 = (Conv2D(128, kernel_size=(3, 3)))(x1)
x2 = (BatchNormalization())(x2)
x2 = (Activation('relu'))(x2)
x2 = (Conv2D(128, kernel_size=(3, 3)))(x2)
x2 = (BatchNormalization())(x2)
x2 = (Activation('relu'))(x2)
x2 = (MaxPooling2D(pool_size=(2, 2), strides = (2, 2), padding = 'same'))(x2)
x2 = (Dropout(0.25))(x2)

x3 = (Conv2D(256, kernel_size=(3, 3)))(x2)
x3 = (BatchNormalization())(x3)
x3 = (Activation('relu'))(x3)
x3 = (Conv2D(256, kernel_size=(3, 3)))(x3)
x3 = (BatchNormalization())(x3)
x3 = (Activation('relu'))(x3)
x3 = (MaxPooling2D(pool_size=(2, 2), strides = (2, 2), padding = 'same'))(x3)
x3 = (Dropout(0.25))(x3)

x4 = (Flatten())(x3)
x4 = (Dense(512, activation='relu'))(x4)
x4 = (BatchNormalization())(x4)
x4 = (Dropout(0.5))(x4)

output = (Dense(10, activation='softmax'))(x4)

model_simple = tf.keras.Model(inputs = input, outputs = output)
model_simple.compile(loss= loss_SCCE, optimizer= optimizer, metrics=['accuracy'])

# If you want to see model Summary run code below
print(model_simple.summary())

checkpoint_filepath_simple = 'CNN_Model_HandWriting_Digits/checkpoints1/simple/model_simple.weights.h5'


checkpoint_callback = ModelCheckpoint(
    filepath=checkpoint_filepath_simple,
    monitor='val_loss',
    mode='min',
    save_weights_only=True,
    save_best_only=True
                                    )

early_stopping = EarlyStopping(monitor='val_loss',
                                patience=10,
                                mode='min',
                                verbose = 1,
                                start_from_epoch=5
                                )

epoch= 200
history_simple = model_simple.fit(
    train,
    verbose = 1,
    epochs=epoch,
    validation_data= validation,
    batch_size = 512,
    callbacks=[checkpoint_callback, early_stopping]
)
print('\n*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n')

# -----------------------------------------------------------
print('\n******  Model Evaluation ******')

Model_Evaluation.plotting_report(history_simple)

config_simple = model_simple.get_config()

with open('./CNN_Model_HandWriting_Digits/checkpoints1/simple/model_config_simple.json', 'w') as f:
    json.dump(config_simple, f, indent = 4)

with open('./CNN_Model_HandWriting_Digits/checkpoints1/simple/model_config_simple.json', 'r') as f:
    configoration = json.load(f)

model_conf_simple = tf.keras.Model.from_config(configoration)
model_conf_simple.compile(loss= loss_SCCE, optimizer= optimizer, metrics=['accuracy'])
model_conf_simple.load_weights(f'CNN_Model_HandWriting_Digits/checkpoints1/simple/model_simple.weights.h5')

Model_Evaluation.model_Evaluation(train, model_conf_simple, label_to_index)
Model_Evaluation.model_Evaluation(test_dataset, model_conf_simple, label_to_index, Mode= 'Test')
# tf.keras.utils.plot_model(model_conf_simple, show_shapes=True)

print('End of the code!\nGood luck :)')