教你使用TensorFlow2对阿拉伯语手写字符数据集进行识别

发布时间：2026-11-14 来源：不仁不义网 作者：企业内刊

在本教程中，我们将使用 TensorFlow (Keras API) 实现一个用于多分类任务的深度学习模型，该任务需要对阿拉伯语手写字符数据集进行识别。

数据集下载地址：https://www.kaggle.com/mloey1/ahcd1

数据集介绍

该数据集由 60 名参与者书写的16,800 个字符组成，年龄范围在 19 至 40 岁之间，90% 的参与者是右手。

每个参与者在两种形式上写下每个字符(从“alef”到“yeh”)十次，如图 7(a)和 7(b)所示。表格以 300 dpi 的分辨率扫描。使用 Matlab 2016a 自动分割每个块以确定每个块的坐标。该数据库分为两组：训练集(每类 13,440 个字符到 480 个图像)和测试集(每类 3,360 个字符到 120 个图像)。数据标签为1到28个类别。在这里，所有数据集都是CSV文件，表示图像像素值及其相应标签，并没有提供对应的图片数据。

导入模块

import numpy as np import pandas as pd #允许对dataframe使用display（） from IPython.display import display # 导入读取和处理图像所需的库 import csv from PIL import Image from scipy.ndimage import rotate 

读取数据

# 训练数据images letters_training_images_file_path = "../input/ahcd1/csvTrainImages 13440x1024.csv" # 训练数据labels letters_training_labels_file_path = "../input/ahcd1/csvTrainLabel 13440x1.csv" # 测试数据images和labels letters_testing_images_file_path = "../input/ahcd1/csvTestImages 3360x1024.csv" letters_testing_labels_file_path = "../input/ahcd1/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]) training_letters_images.head() 

13440个32x32像素的训练阿拉伯字母图像。3360个32x32像素的测试阿拉伯字母图像。

查看训练数据的head

np.unique(training_letters_labels) array([ 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], dtype=int32) 

下面需要将csv值转换为图像，我们希望展示对应图像的像素值图像。

def convert_values_to_image(image_values, display=False):     image_array = np.asarray(image_values)     image_array = image_array.reshape(32,32).astype('uint8')     # 原始数据集被反射，因此我们将使用np.flip翻转它，然后通过rotate旋转，以获得更好的图像。     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 convert_values_to_image(training_letters_images.loc[0], True) 

这是一个字母f。

下面，我们将进行数据预处理，主要进行图像标准化，我们通过将图像中的每个像素除以255来重新缩放图像，标准化到[0，1]

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) training_letters_images_scaled[0:5] 

输出如下

Training images of letters after scaling (13440, 1024) 

从标签csv文件我们可以看到，这是一个多类分类问题。下一步需要进行分类标签编码，建议将类别向量转换为矩阵类型。

输出形式如下：将1到28，变成0到27类别。从“alef”到“yeh”的字母有0到27的分类号。to_categorical就是将类别向量转换为二进制(只有0和1)的矩阵类型表示

在这里，我们将使用keras的一个热编码对这些类别值进行编码。

一个热编码将整数转换为二进制矩阵，其中数组仅包含一个“1”，其余元素为“0”。

from keras.utils import to_categorical  # one Tehot encoding 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) 

# (13440, 1024) 

下面将输入图像重塑为32x32x1，因为当使用TensorFlow作为后端时，Keras CNN需要一个4D数组作为输入，并带有形状(nb_samples、行、列、通道)

其中 nb_samples对应于图像(或样本)的总数，而行、列和通道分别对应于每个图像的行、列和通道的数量。

# reshape input letter images to 32x32x1 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) # (13440, 32, 32, 1) (13440, 28) (3360, 32, 32, 1) (3360, 28) 

因此，我们将把输入图像重塑成4D张量形状(nb_samples，32，32，1)，因为我们图像是32x32像素的灰度图像。

#将输入字母图像重塑为32x32x1 training_letters_images_scaled = training_letters_images_scaled.reshape([-1, 32, 32, 1]) testing_letters_images_scaled = tenssting_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'):     # create model     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(MaorxPooling2D(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())      #Fully connected final layer     model.add(Dense(28, activation='softmax'))      # Compile model     model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer=optimizer)     return model  「模型结构」 第一隐藏层是卷积层。该层有16个特征图，大小为3×3和一个激活函数，它是relu。这是输入层，需要具有上述结构的图像。 第二层是批量标准化层，它解决了特征分布在训练和测试数据中的变化，BN层添加在激活函Fl数前，对输入激活函数的输入进行归一化。这样解决了输入数据发生偏移和增大的影响。 第三层是MaxPooling层。最大池层用于对输入进行下采样，使模型能够对特征进行假设，从而减少过拟合。它还减少了参数的学习次数，减少了训练时间。 下一层是使用dropout的正则化层。它被配置为随机排除层中20%的神经元，以减少过度拟合。 另一个隐藏层包含32个要素，大小为3×3和relu激活功能，从图像中捕捉更多特征。 其他隐藏层包含64和128个要素，大小为3×3和一个relu激活功能， 重复三次卷积层、MaxPooling、批处理规范化、正则化和* GlobalAveragePooling2D层。 最后一层是具有(输出类数)的输出层，它使用softmax激活函数，因为我们有多个类。每个神经元将给出该类的概率。 使用分类交叉熵作为损失函数，因为它是一个多类分类问题。使用精确度作为衡量标准来提高神经网络的性能。 model = create_model(optimizer='Adam', kernel_initializer='uniform', activation='relu') model.summary() 

「Keras支持在Keras.utils.vis_utils模块中绘制模型，该模块提供了使用graphviz绘制Keras模型的实用函数」

import pydot from keras.utils import plot_model  plot_model(model, to_file="model.png", show_shapes=True) from IPython.display import Image as IPythonImage display(IPythonImage('model.png')) 

训练模型，使用batch_size=20来训练模型，对模型进行15个epochs阶段的训练。

from keras.callbacks import ModelCheckpoint    # 使用检查点来保存稍后使用的模型权重。 checkpointer = ModelCheckpoint(filepath='weights.hdf5', verbose=1, save_best_only=True) history = model.fit(training_letters_images_scaled, training_letters_labels_encoded,validation_data=(testing_letters_images_scaled,testing_letters_labels_encoded),epochs=15, batch_size=20,&nowbsp;verbose=1, callbacks=[checkpointer]) 

训练结果如下所示：

最后Epochs绘制损耗和精度曲线。

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)  2对; plot_loss_accuracy(history) 

「加载具有最佳验证损失的模型」 # 加载具有最佳验证损失的模型 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])) 

输出如下：

3360/3360 [==============================] - 0s 87us/step Test Accuracy: 0.9678571224212646 Test Loss: 0.11759862171020359 

打印混淆矩阵。

from sklearn.metrics import classification_report  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))   y_pred, y_true, image_predictions = get_predicted_classes(model, testing_letters_images_scaled,&nb阿拉sp;testing_letters_labels_encoded) get_classification_report(y_true, y_pred) 

输出如下：

          precision    recall  f1-score   support          0       1.00      0.98      0.99       120         1       1.00      0.98      0.99       120         2       0.80      0.98      0.88       120         3       0.98      0.88      0.93       120         4       0.99      0.97      0.98     &n伯语bsp; 120         5       0.92      0.99      0.96       120         6       0.94      0.97      0.95       120         7       0.94      0.95      0.95       120         8       0.96      0.88      0.92       120         9       0.90      1.00      0.94       120        10       0.94      0.90      0.92       120&n手写bsp;       11       0.98      1.00      0.99       120        12       0.99      0.98      0.99       120        13       0.96      0.97      0.97       120        14       1.00      0.93      0.97       120        15       0.94      0.99      0.97       120        16       1.00      0.93      0.96       120      &nbs字符p; 17       0.97      0.97      0.97       120        18       1.00      0.93      0.96       120        19       0.92      0.95      0.93       120        20       0.97      0.93      0.94       120        21       0.99      0.96      0.97       120        22       0.99      0.98      0.99       120        23    &n数据bsp;  0.98      0.99      0.99       120        24       0.95      0.88      0.91       120        25       0.94      0.98      0.96       120        26       0.95      0.97      0.96       120        27       0.98      0.99      0.99       120   accuracy                           0.96      3360 macro avg       0.96      集进;0.96      0.96      3360 ghted avg       0.96      0.96      0.96      3360 

最后绘制随机几个相关预测的图片

indices = np.random.randint(0, testing_letters_labels.shape[0], size=49) y_pred = np.argmax(model.predict(training_letters_images_scaled), axis=1)  for i, idx in enumerate(indices):     plt.subplot(7,7,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("Pred: {} - Label: {}".format(y_pred[idx], (training_letters_labels[idx] -1)))     plt.xticks([])     plt.yticks([]) plt.show() 

相关文章