import numpy as np

import pandas as pd

from IPython.display import display

import csv

from PIL import Image

from scipy.ndimage import rotate

letters_training_images_file_path = "dataset/csvTrainImages 13440x1024.csv"

letters_training_labels_file_path = "dataset/csvTrainLabel 13440x1.csv"

letters_testing_images_file_path = "dataset/csvTestImages 3360x1024.csv"

letters_testing_labels_file_path = "dataset/csvTestLabel 3360x1.csv"

training_letters_images = pd.read_csv(letters_training_images_file_path, header=None)

training_letters_labels = pd.read_csv(letters_training_labels_file_path, header=None)

testing_letters_images = pd.read_csv(letters_testing_images_file_path, header=None)

testing_letters_labels = pd.read_csv(letters_testing_labels_file_path, header=None)

print("%d个32x32像素的训练阿拉伯字母图像" % training_letters_images.shape[0])

print("%d个32x32像素的测试阿拉伯字母图像" % testing_letters_images.shape[0])

print(training_letters_images.head())

print(np.unique(training_letters_labels))

def convert_values_to_image(image_values, display=False):

#转换成32x32

image_array = np.asarray(image_values)

image_array = image_array.reshape(32,32).astype('uint8')

#翻转+旋转

image_array = np.flip(image_array, 0)

image_array = rotate(image_array, -90)

#图像显示

new_image = Image.fromarray(image_array)

if display == True:

new_image.show()

return new_image

training_letters_images_scaled = training_letters_images.values.astype('float32')/255

training_letters_labels = training_letters_labels.values.astype('int32')

testing_letters_images_scaled = testing_letters_images.values.astype('float32')/255

testing_letters_labels = testing_letters_labels.values.astype('int32')

print("Training images of letters after scaling")

print(training_letters_images_scaled.shape)

print(training_letters_images_scaled[0:5])

import keras

from keras.utils import to_categorical

number_of_classes = 28

training_letters_labels_encoded = to_categorical(training_letters_labels-1,

num_classes=number_of_classes)

testing_letters_labels_encoded = to_categorical(testing_letters_labels-1,

num_classes=number_of_classes)

print(training_letters_labels)

print(training_letters_labels_encoded)

print(training_letters_images_scaled.shape)

training_letters_images_scaled = training_letters_images_scaled.reshape([-1, 32, 32, 1])

testing_letters_images_scaled = testing_letters_images_scaled.reshape([-1, 32, 32, 1])

print(training_letters_images_scaled.shape,

training_letters_labels_encoded.shape,

testing_letters_images_scaled.shape,

testing_letters_labels_encoded.shape)

from keras.models import Sequential

from keras.layers import Conv2D, MaxPooling2D, GlobalAveragePooling2D, BatchNormalization, Dropout, Dense

def create_model(optimizer='adam', kernel_initializer='he_normal', activation='relu'):

#第一个卷积层

model = Sequential()

model.add(Conv2D(filters=16, kernel_size=3, padding='same', input_shape=(32, 32, 1), kernel_initializer=kernel_initializer, activation=activation))

model.add(BatchNormalization())

model.add(MaxPooling2D(pool_size=2))

model.add(Dropout(0.2))

#第二个卷积层

model.add(Conv2D(filters=32, kernel_size=3, padding='same', kernel_initializer=kernel_initializer, activation=activation))

model.add(BatchNormalization())

model.add(MaxPooling2D(pool_size=2))

model.add(Dropout(0.2))

#第三个卷积层

model.add(Conv2D(filters=64, kernel_size=3, padding='same', kernel_initializer=kernel_initializer, activation=activation))

model.add(BatchNormalization())

model.add(MaxPooling2D(pool_size=2))

model.add(Dropout(0.2))

#第四个卷积层

model.add(Conv2D(filters=128, kernel_size=3, padding='same', kernel_initializer=kernel_initializer, activation=activation))

model.add(BatchNormalization())

model.add(MaxPooling2D(pool_size=2))

model.add(Dropout(0.2))

model.add(GlobalAveragePooling2D())

#全连接层输出28类结果

model.add(Dense(28, activation='softmax'))

#损失函数定义

model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer=optimizer)

return model

model = create_model(optimizer='Adam', kernel_initializer='uniform', activation='relu')

model.summary()

from keras.utils.vis_utils import plot_model

from IPython.display import Image as IPythonImage

plot_model(model, to_file="model.png", show_shapes=True)

display(IPythonImage('model.png'))

from keras.callbacks import ModelCheckpoint

from sklearn.metrics import classification_report

import matplotlib.pyplot as plt

def plot_loss_accuracy(history):

# Loss

plt.figure(figsize=[8,6])

plt.plot(history.history['loss'],'r',linewidth=3.0)

plt.plot(history.history['val_loss'],'b',linewidth=3.0)

plt.legend(['Training loss', 'Validation Loss'],fontsize=18)

plt.xlabel('Epochs ',fontsize=16)

plt.ylabel('Loss',fontsize=16)

plt.title('Loss Curves',fontsize=16)

# Accuracy

plt.figure(figsize=[8,6])

plt.plot(history.history['accuracy'],'r',linewidth=3.0)

plt.plot(history.history['val_accuracy'],'b',linewidth=3.0)

plt.legend(['Training Accuracy', 'Validation Accuracy'],fontsize=18)

plt.xlabel('Epochs ',fontsize=16)

plt.ylabel('Accuracy',fontsize=16)

plt.title('Accuracy Curves',fontsize=16)

def get_predicted_classes(model, data, labels=None):

image_predictions = model.predict(data)

predicted_classes = np.argmax(image_predictions, axis=1)

true_classes = np.argmax(labels, axis=1)

return predicted_classes, true_classes, image_predictions

def get_classification_report(y_true, y_pred):

print(classification_report(y_true, y_pred, digits=4)) #小数点4位

checkpointer = ModelCheckpoint(filepath='weights.hdf5',

verbose=1,

save_best_only=True)

flag = "test"

if flag=="train":

history = model.fit(training_letters_images_scaled,

training_letters_labels_encoded,

validation_data=(testing_letters_images_scaled,

testing_letters_labels_encoded),

epochs=20,

batch_size=128,

verbose=1,

callbacks=[checkpointer])

print(history)

plot_loss_accuracy(history)

else:

#加载具有最佳验证损失的模型

model.load_weights('weights.hdf5')

metrics_ = model.evaluate(testing_letters_images_scaled,

testing_letters_labels_encoded,

verbose=1)

print("Test Accuracy: {}".format(metrics_[1]))

print("Test Loss: {}".format(metrics_[0]))

y_pre_test, y_true, image_predictions = get_predicted_classes(model,

testing_letters_images_scaled,

testing_letters_labels_encoded)

get_classification_report(y_true, y_pre_test)

#----------------------------------------------------------------

# 第九步 绘制测试图像

#----------------------------------------------------------------

plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签

plt.rcParams['axes.unicode_minus']=False #用来正常显示负号

fig = plt.figure(0, figsize=(14,14))

indices = np.random.randint(0, testing_letters_labels.shape[0], size=42)

y_pred = np.argmax(model.predict(training_letters_images_scaled), axis=1)

for i, idx in enumerate(indices):

plt.subplot(7,6,i+1)

image_array = training_letters_images_scaled[idx][:,:,0]

image_array = np.flip(image_array, 0)

image_array = rotate(image_array, -90)

plt.imshow(image_array, cmap='gray')

plt.title("预测:{} 真实:{}".format(y_pred[idx],

(training_letters_labels[idx] -1)))

plt.xticks([])

plt.yticks([])

plt.show()

plt.savefig("resutl.png", dpi=300)

## 评价预测效果，计算混淆矩阵

import seaborn as sns

from sklearn import metrics

Labname = [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]

print(y_pre_test)

y_pre_test = [num+1 for num in y_pre_test]

print(np.argmax(testing_letters_labels,axis=1))

confm = metrics.confusion_matrix(testing_letters_labels,

y_pre_test)

print(confm.T)

plt.figure(figsize=(10,10))

heatmap = sns.heatmap(confm.T, square=True, annot=True,

fmt='d', cbar=True, linewidths=.6,

cmap="YlGnBu")

bottom, top = heatmap.get_ylim()

heatmap.set_ylim(bottom + 0.5, top - 0.5)

plt.xlabel('True label',size = 12)

plt.ylabel('Predicted label', size = 12)

#plt.xticks(np.arange(28)+0.5, Labname, size = 10)

#plt.yticks(np.arange(28)+0.5, Labname, size = 10)

plt.savefig('headmap.png', dpi=300)

plt.show()