from google.colab import drive
drive.mount('/content/gdrive')
!ls "/content/gdrive/My Drive/LABSL"
from google.colab import drive
drive.mount('/content/drive')
import os
from PIL import Image
import numpy as np
import seaborn as sb
import random
import shutil
from keras import backend as K
import matplotlib
matplotlib.use("Agg")
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
import sys
sys.modules['Image'] = Image
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.optimizers import Adam
from keras.layers.normalization import BatchNormalization
from keras.utils import np_utils
from keras.layers import Conv2D, MaxPooling2D, ZeroPadding2D, GlobalAveragePooling2D
from keras.preprocessing.image import ImageDataGenerator
from keras import regularizers
model = Sequential()
n_filters = 64
model.add(Conv2D(n_filters, (3, 3), input_shape=(50, 50, 3)))
model.add(MaxPooling2D((3, 3)))
model.add(Conv2D(n_filters, (3, 3)))
model.add(MaxPooling2D((3, 3)))
model.add(Flatten())
model.add(Dense(n_filters))
n_class = 43
model.add(Dense(n_class))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',
              optimizer='Adam',
              metrics=['accuracy'])
! git clone https://github.com/Dynamech/test.git
train_gen = ImageDataGenerator(rescale = 1/255,
                                  rotation_range = 20,
                                  zoom_range = 0.05,
                                  width_shift_range = 0.1,
                                  height_shift_range = 0.1,
                                  shear_range = 0.05)


BS = 32
train_flow = train_gen.flow_from_directory(directory = "test/train",
                                           class_mode = "categorical",
                                           target_size = (50, 50),
                                           color_mode = "rgb",
                                           shuffle = True,
                                           batch_size = BS)

val_gen = ImageDataGenerator(rescale=1/255)
val_flow = val_gen.flow_from_directory(directory = "test/val",
                                      class_mode = "categorical",
                                      target_size = (50, 50),
                                      color_mode = "rgb",
                                      shuffle = True,
                                      batch_size = BS)
n_train = 27446
n_val = 3921
history = model.fit_generator(train_flow,
                              steps_per_epoch = n_train // BS,
                              epochs = 4,
                              validation_data = val_flow,
                              validation_steps = n_val // BS)
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
fig = plt.figure()
plt.plot(epochs, acc, 'b', label='Training accuracy')
plt.plot(epochs, val_acc, 'r', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend()
plt.show()
fig.savefig('trainval_acc.png', dpi=fig.dpi)
fig = plt.figure()
plt.plot(epochs, loss, 'b', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()
fig.savefig('trainval_loss.png', dpi=fig.dpi)
dir_path = os.listdir('test/train')
for subdir in dir_path:
  num = len(os.listdir('test/train/' + str(subdir)))
  print(str(subdir) + ":" + str(num))
number_files = len(dir_path)
print(number_files)
test_gen = ImageDataGenerator(rescale=1/255)
test_flow = test_gen.flow_from_directory(directory = "test/test",
                                      class_mode = "categorical",
                                      target_size = (50, 50),
                                      color_mode = "rgb",
                                      shuffle = False,
                                      batch_size = BS)
n_test = 7842
pred_prob = model.predict_generator(test_flow, steps = (n_test // BS) + 1)
pred = np.argmax(pred_prob, axis=1)
print('Confusion Matrix')
cm = confusion_matrix(test_flow.classes, pred)
print(cm)
target_names = [str(i) for i in range(0,43)]
print(classification_report(test_flow.classes, pred, target_names=target_names))
total = sum(sum(cm))
TP = []; TN = []; FN = []; FP = [];
P = []; N = [];
acc = []; spec = []; sens = [];
print("Class / Accuracy / Sensitivity / Specificity")
for i in np.arange(n_class):
  TP.append(cm[i, i])
  P.append(sum(cm[i,:]))
  N.append(total - P[i])
  FP.append(sum(cm[:,i]) - TP[i])
  FN.append(sum(cm[i,:]) - TP[i])
  TN.append(N[i] - FP[i])
  acc_ = (TP[i] + TN[i])/total
  acc.append(acc_)
  spec_ = TN[i] / (TN[i] + FP[i])
  spec.append(spec_)
  sens_ = TP[i] / (TP[i] + FN[i])
  sens.append(sens_)
  print(str(i) + ' / ' + str(acc_) + ' / ' + str(sens_) + ' / ' + str(spec_))
fig = plt.figure()
sb.heatmap(cm)
plt.show()
fig.savefig('cm.png', dpi=fig.dpi)