from google.colab import drive
drive.mount('/content/gdrive')
!ls "/content/gdrive/My Drive/polsl-hanke/SL8"

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'])

model.build()
model.summary()

trainGen = 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
trainFlow = trainGen.flow_from_directory(directory = "test/train",
                                          class_mode = "categorical",
                                          target_size = (50, 50),
                                          color_mode = "rgb",
                                          shuffle = True,
                                          batch_size = BS)
valueGen = ImageDataGenerator(rescale=1/255)
valueFlow = valueGen.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
fit = model.fit_generator(trainFlow,
                          steps_per_epoch = n_train // BS,
                          epochs = 4,
                          validation_data = valueFlow,
                          validation_steps = n_val // BS)

acc = fit.history['acc']
valAcc = fit.history['val_acc']
loss = fit.history['loss']
valueLoss = fit.history['val_loss']
epochs = range(1, len(acc) + 1)

fig = plt.figure()
plt.plot(epochs, acc, 'b', label='Training accuracy')
plt.plot(epochs, valAcc, 'r', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend()
fig.savefig('trainAcc.png', dpi=fig.dpi)

fig = plt.figure()
plt.plot(epochs, loss, 'b', label='Training loss')
plt.plot(epochs, valueLoss, 'r', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
fig.savefig('trainLoss.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)

testGen = ImageDataGenerator(rescale=1/255)
testFlow = testGen.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(testFlow, steps = (n_test // BS) + 1)

pred = np.argmax(pred_prob, axis=1)
print('Confusion Matrix')
confusionMatrix = confusion_matrix(testFlow.classes, pred)
print(confusionMatrix)
namesTarget = [str(i) for i in range(0,43)]
print(classification_report(testFlow.classes, pred, namesTarget=namesTarget))

result = sum(sum(confusionMatrix))
TP = [];
TN = [];
FN = [];
FP = [];
P = [];
N = [];
accuracy = [];
specificity = [];
sensitivity = [];
print("Class / Accuracyuracy / Sensitivityitivity / Specificityificity")
for i in np.arange(n_class):
  TP.append(confusionMatrix[i, i])
  P.append(sum(ConfusionMatrix[i,:]))
  N.append(result - P[i])
  FP.append(sum(confusionMatrix[:,i]) - TP[i])
  FN.append(sum(confusionMatrix[i,:]) - TP[i])
  TN.append(N[i] - FP[i])
  accuracy_ = (TP[i] + TN[i])/result
  accuracy.append(accuracy_)
  specificity_ = TN[i] / (TN[i] + FP[i])
  specificity.append(specificity_)
  sensitivity_ = TP[i] / (TP[i] + FN[i])
  sensitivity.append(sensitivity_)
  print(str(i) + ' / ' + str(accuracy_) + ' / ' + str(sensitivity_) + ' /
  ' + str(specificity_))

fig = plt.figure()
sb.heatmap(confusionMatrix)
fig.savefig('confusionMatrix.png', dpi=fig.dpi)