我们都可以就一个问题达成共识，那就是“数字无处不在”。无论您是在办公室，厨房，当地的超级市场等等，我们始终都被数字包围。您的笔记本电脑具有HDD存储器，您要购买的蔬菜具有数字价格，您具有高度，天气温度以数字摄氏度（在我的位置是52）进行测量。

类似地，机器学习领域的新手总是与MNIST数据集一起呈现。MNIST就像是第一次吃奶到蹒跚学步的ML新手。它是什么？

该MNIST数据库（修改国家标准技术研究所的数据库）是一个大型数据库的手写数字是通常用于训练各种图像处理系统。该数据库还广泛用于机器学习领域的培训和测试。它是通过“重新混合” NIST原始数据集中的样本而创建的。创作者认为，由于NIST的培训数据集是从美国人口普查局员工那里获取的，而测试数据集是从美国高中获取的学生们，它不适合进行机器学习实验。此外，对来自NIST的黑白图像进行了归一化处理，以适应28x28像素的边框，并进行了抗锯齿处理，从而引入了灰度级。

MNIST数据库包含60,000个训练图像和10,000个测试图像。训练集的一半和测试集的一半来自NIST的训练数据集，而训练集的另一半和测试集的另一半则来自NIST的测试数据集。数据库的原始创建者保留了一些经过测试的方法的列表。在他们的原始论文中，他们使用支持向量机获得0.8％的错误率。与MNIST类似的扩展数据集称为EMNIST，已在2017年发布，其中包含240,000个训练图像和40,000个手写数字和字符的测试图像。

SVHN数据集

这是斯坦福大学收集的数据集，可供公众进行实验和学习。

SVHN是一个现实世界的图像数据集，用于开发机器学习和对象识别算法，而对数据预处理和格式化的要求最低。可以看出它的风格与MNIST相似（例如，图像的裁剪数字很小），但是合并了更多数量级的标记数据（超过600,000位数字图像），并且来自一个更加困难，尚未解决的现实问题（识别自然场景图像中的数字和数字）。SVHN是从Google街景图像中的门牌号获得的。

这些图像尚未经过预处理或可以使用。因此，任何想使用它的人都必须做一些工作！

挑战

建立一种算法，对数据集中的不同门牌号进行分类。

问题

可用的数据集上的网站是在.MAT格式。而且，如果您不知道，Python Notebooks和所有算法都无法使用此类文件进行处理。因此，为什么要在进入很酷的东西之前将数据转换为可接受的数据格式是一种强迫。

老实说，作为一个新手，我不能自己编写函数来转换文件，因此做了很多挖掘工作。经过数十篇文章和youtube视频，我终于偶然发现了一个很有帮助的存储库。

现在，让我们继续进行模型创建！

环境与工具

• Keras

• Numpy

• Scipy

• Numpy

代码

import os
import sys
import keras
import tarfile
import numpy as np
import urllib.request as urllib
import matplotlib.pyplot as plt
from keras.regularizers import l2
from keras.models import Sequential
from keras.optimizers import Adam, SGD
from keras.engine.training import Model
from keras import backend as K, regularizers
from keras.callbacks import LearningRateScheduler
from keras.preprocessing.image import ImageDataGenerator
from keras.layers import Add, Conv2D, MaxPooling2D, Dropout, Flatten,
BatchNormalization, Activation Dense,

接下来，让我们预处理数据：

#Dataset location
train_location = 'Drive link to the Train.mat file'
test_location = 'Drive link to the Test.mat file'
def load_train_data():train_dict = sio.loadmat(train_location)X = np.asarray(train_dict['X'])X_train = []
for i in range(X.shape[3]):X_train.append(X[:,:,:,i])X_train = np.asarray(X_train)Y_train = train_dict['y']
for i in range(len(Y_train)):
if Y_train[i]%10 == 0:Y_train[i] = 0Y_train = to_categorical(Y_train,10)
return (X_train,Y_train)
def load_test_data():test_dict = sio.loadmat(test_location)X = np.asarray(test_dict['X'])X_test = []for i in range(X.shape[3]):X_test.append(X[:,:,:,i])X_test = np.asarray(X_test)Y_test = test_dict['y']
for i in range(len(Y_test)):if Y_test[i]%10 == 0:Y_test[i] = 0Y_test = to_categorical(Y_test,10)return (X_test,Y_test)

我们将此函数用作：

(x_train, y_train) = load_train_data()
(x_test, y_test) = load_test_data()
x_train.shape      # (73257, 32, 32, 3)
x_test.shape       # (26032, 32, 32, 3)

现在，当我们掌握了数据时，就可以对其进行扩展。现在，在将数据加载到体系结构之前对数据进行规范化已成为当今时代的规范，因为从缩放数据中学习模型比从随机分布的数据中学习更为容易。

规范化数据：

# Converting the arrays to Float type
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
# Normalizing
x_train = x_train / 255.0
x_test = x_test / 255.0

现在，我们确实有73,257张图片，但是

训练集是永远不够的！

因此，我们在这里使用ImageDataGenerator创建更多图像

from keras.preprocessing.image import ImageDataGenerator
# applying transformation to image
train_gen = ImageDataGenerator(
rotation_range=15,
zoom_range = 0.10,
width_shift_range=0.3,
height_shift_range=0.3,
brightness_range=[0.2,1.0]
)
# test_gen = ImageDataGenerator()
train_gen.fit(x_train)
test_set = train_gen.flow(x_test, y_test, batch_size=256)

我们现在仅生成测试图像，稍后将发布Training设置，因为我喜欢这种方式。

模型架构

这是有趣的部分！我在这里设计的架构包含8个卷积模块！

现在，我将卷积层用于：

• 内核大小：5

• 内核初始化程序：he_uniform

• 内核正则化：l2

• 激活方式：elu

• 最大池数（2，2）

• 批量归一化

• Dropout 30％

model = Sequential()
# Block 1
model.add(Conv2D(32, kernel_size=5, kernel_initializer='he_uniform', kernel_regularizer=l2(0.0005), padding='same', input_shape=(32, 32, 3)))
model.add(Activation('elu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(2, 2))
model.add(Dropout(0.3))
# Block 2
model.add(Conv2D(64, kernel_size=5, kernel_initializer='he_uniform', kernel_regularizer=l2(0.0005), padding='same'))
model.add(Activation('elu'))
model.add(BatchNormalization())
# model.add(MaxPooling2D(2, 2))
model.add(Dropout(0.3))
# Block 3model.add(Conv2D(128, kernel_size=5, kernel_initializer='he_uniform', kernel_regularizer=l2(0.0005), padding='same'))
model.add(Activation('elu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(2, 2))
model.add(Dropout(0.3))
# Block 4model.add(Conv2D(180, kernel_size=5, kernel_initializer='he_uniform', kernel_regularizer=l2(0.0005), padding='same'))
model.add(Activation('elu'))
model.add(BatchNormalization())
# model.add(MaxPooling2D(2, 2))
model.add(Dropout(0.3))
# Block 5model.add(Conv2D(256, kernel_size=5, kernel_initializer='he_uniform', kernel_regularizer=l2(0.0005), padding='same'))
model.add(Activation('elu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(2, 2))
model.add(Dropout(0.3))
# Block 6model.add(Conv2D(280, kernel_size=5, kernel_initializer='he_uniform', kernel_regularizer=l2(0.0005), padding='same'))
model.add(Activation('elu'))
model.add(BatchNormalization())
# model.add(MaxPooling2D(2, 2))
model.add(Dropout(0.3))
# Block 7model.add(Conv2D(300, kernel_size=5, kernel_initializer='he_uniform', kernel_regularizer=l2(0.0005), padding='same'))
model.add(Activation('elu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(2, 2))
model.add(Dropout(0.3))
# Block 8model.add(Conv2D(320, kernel_size=5, kernel_initializer='he_uniform', kernel_regularizer=l2(0.0005), padding='same'))
model.add(Activation('elu'))
model.add(BatchNormalization())
# model.add(MaxPooling2D(2, 2))
model.add(Dropout(0.3))

然后是三个密集层：

• 内核正则化：l2

• 激活方式：elu

• 批量归一化

• Dropout 30％

model.add(Flatten())
# Dense 1
model.add(Dense(2800,  kernel_regularizer=l2(0.0005)))
model.add(Activation('elu'))
model.add(BatchNormalization())
model.add(Dropout(0.3))
# Dense 2model.add(Dense(1200,  kernel_regularizer=l2(0.0005)))
model.add(Activation('elu'))
model.add(BatchNormalization())
model.add(Dropout(0.3))
# Dense 3model.add(Dense(10,  kernel_regularizer=l2(0.0005), activation='softmax'))

超参数设置

在机器学习中，超参数优化或调整是为学习算法选择一组最佳超参数的问题。超参数是一个参数，其值用于控制学习过程。相反，其他参数的值（通常是节点权重）被学习。

我使用了自定义学习率修改器功能：

initial_lr = 1e-3
def lr_scheduler(epoch):
if epoch < 20:
return initial_lr
elif epoch < 40:
return initial_lr / 2
elif epoch < 50:
return initial_lr / 4
elif epoch < 60:
return initial_lr / 8
elif epoch < 70:
return initial_lr / 16
elif epoch < 80:
return initial_lr / 32
elif epoch < 90:
return initial_lr / 64
else:
return initial_lr / 128

参数：

• Loss Function: Categorical Cross Entropy

• Optimizer: Adam

• metrics = [‘accuracy’]

训练

history = model.fit(
train_gen.flow(x_train, y_train, batch_size=YOUR_CHOICE),
epochs=YOUR_CHOICE,
verbose=YOUR_CHOICE,
validation_data=test_set,
callbacks=[LearningRateScheduler(lr_scheduler)],
shuffle=True
)

结果与结论

经过训练，我们的水平为96.0％，老实说，我对此感到非常满意。

SVHN是一个非常大而广泛的数据集，它来自一个非常棘手的问题，其中图像包含许多混乱和嘈杂的特征。与MNIST，CIFAR-10和CIFAR-100相比，它在文献中似乎没有得到充分利用。与MNIST和其他数据集不同，预处理是常见的做法，对于公平比较结果非常重要。对比度标准化的一种形式，特别是局部对比度标准化，是预处理SVHN数据集图像的常用技术。

希望本文对您有所帮助。