机器学习 — 从mnist数据集谈起

　　做了一些简单机器学习任务后，发现必须要对数据集有足够的了解才能动手做一些事，这是无法避免的，否则可能连在干嘛都不知道，而一些官方例程并不会对数据集做过多解释，你甚至连它长什么样都不知道。。。

　　以sklearn的手写数字识别为例，例子中，一句

digits = datasets.load_digits()

　　就拿到数据了，然后又几句

images_and_labels = list(zip(digits.images, digits.target))
for index, (image, label) in enumerate(images_and_labels[:4]):
    plt.subplot(2, 4, index + 1)
    plt.axis('off')
    plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    plt.title('Training: %i' % label)

# To apply a classifier on this data, we need to flatten the image, to
# turn the data in a (samples, feature) matrix:
n_samples = len(digits.images)
data = digits.images.reshape((n_samples, -1))

　　就把数据集划分好了，对初学者来说，可能都不知道干了些啥。。。当然更重要的是，跑一边程序看到效果不错，想要用训练好的模型玩玩自己的数据集，却无从下手。。。于是，下面就以这个例子来说一下，如何基本的了解数据集，以及如何构造数据集，或许还会谈谈为什么要这样构造。。。

　　1.认识数据集。

　　看代码，我们发现，该数据集主要由两个部分组成:

　　　　1).images

　　　　2).target

　　target 的划分看起来不复杂，所以可以直接看看其中的部分内容：

>>> print(digits.target.shape)
# (1797,)
>>> print(digits.target[:10])
# [0 1 2 3 4 5 6 7 8 9]
>>> print(digits.target[-10:])
# [5 4 8 8 4 9 0 8 9 8]

　　含义是：target是一个形状为长度为1797的行向量，共有1797个（0~9）数字。

　　images 还需要做一些处理才能使用fit接口，但我们也先看看原本长什么样：

>>> print(digits.image.shape)
# (1797, 8, 8)
>>> print(digits.images[0].shape)
# (8, 8)
>>> print(digits.images[0])
'''
[[ 0.  0.  5. 13.  9.  1.  0.  0.]
 [ 0.  0. 13. 15. 10. 15.  5.  0.]
 [ 0.  3. 15.  2.  0. 11.  8.  0.]
 [ 0.  4. 12.  0.  0.  8.  8.  0.]
 [ 0.  5.  8.  0.  0.  9.  8.  0.]
 [ 0.  4. 11.  0.  1. 12.  7.  0.]
 [ 0.  2. 14.  5. 10. 12.  0.  0.]
 [ 0.  0.  6. 13. 10.  0.  0.  0.]]
'''

　　再画出来看看：

>>> import matplotlib.pyplot as plt
>>> plt.axis('off')
>>> plt.title('label: %i' % digits.target[0])
>>> plt.imshow(digits.images[0], cmap='gray_r')
>>> plt.show()

　　

　　含义是：images是由1797张尺寸为8*8的单通道图片组成，而图片内容对应每一张标签的数字的手写数字。

　　于是，这下我们了解了数据集了，但别急，图片集还要做点处理才能使用：

>>> data = digits.images.reshape((n_samples, -1))
>>> print(data.shape)
# (1797, 64)
>>> print(data[0])
'''
[ 0.  0.  5. 13.  9.  1.  0.  0.  0.  0. 13. 15. 10. 15.  5.  0.  0.  3.
 15.  2.  0. 11.  8.  0.  0.  4. 12.  0.  0.  8.  8.  0.  0.  5.  8.  0.
  0.  9.  8.  0.  0.  4. 11.  0.  1. 12.  7.  0.  0.  2. 14.  5. 10. 12.
  0.  0.  0.  0.  6. 13. 10.  0.  0.  0.]
'''

　　把原图片集形状 (numbers, w, h) 变成了 (numbers, w * h)，也就是把2维数组变为一维数组来存储，我个人认为有两个原因，1).算法本身；2).为了性能...处理一维数组的效率比二维数组高很多。（使用深度学习，我们可以利用神经网络自己构造输入形状和输出形状，便利许多。）

　　现在我们很清楚模型要输入什么样的数据才能进行训练了。

　　2.训练模型。

　　该例子使用svm，不同问题的选择不一，而是根据对算法的理解、经验和观察最终训练效果选择合适的算法。

from sklearn import datasets, svm

digits = datasets.load_digits()
n_samples = len(digits.images)
train_x = digits.images.reshape((n_samples, -1))
train_y = digits.target

model = svm.SVC(gamma=0.001)
model.fit(train_x, train_y,)

　　3.评估模型的效果。

from sklearn import metrics

y_real = dateset.target
...
y_pred = model.predict(test_x)
print(metrics.accuracy_score(y_real, y_pred))

　　4.保存和加载模型。

　　保存模型很简单，sklearn有专门提供便利的方法来保存和加载模型：

from sklearn.externals import joblib

joblib.dump(model, 'mnist.m')

　　加载模型：

model = joblib.load('mnist.m')
y_pred = model.predict(test_x)

　　5.最后，部署模型。

　　上面看到，图片的形状必须为8*8像素大小的单通道图片，假如我们有一批50*50的手写数字图片集，想用该模型测试一下效果怎么办，我们只需要改变一下图片分辨率，把形状变为8*8即可。这样，我们才能用自己的数据集来进行测试，或者部署该模型以提供给别人使用。

　　关于如何部署到web，可以参考前一篇随笔。

　　下面是一个例子，使用了一点opencv来把RGB图片转为灰度图、修改图片尺寸以及一些简单的额外处理：

from sklearn import datasets, svm, metrics
import matplotlib.pyplot as plt
from sklearn.externals import joblib
import numpy as np
import cv2 as cv

digits = datasets.load_digits()
n_samples = len(digits.images)
train_x = digits.images.reshape((n_samples, -1))
train_y = digits.target

model = svm.SVC(gamma=0.001)
model.fit(train_x, train_y,)
joblib.dump(model, 'mnist2.m')

w, h = 8, 8
labels = [0, 1, 4, 5]
lenght = len(labels)
images = np.zeros((lenght, h, w), np.uint8)
imgs = []
for i, name in enumerate(labels):
    img = cv.imread('digits/{}.png'.format(name))
    img = cv.resize(img, (h, w), interpolation=cv.INTER_CUBIC)
    for r in range(img.shape[0]):
        for c in range(img.shape[1]):
            img[r, c] = 255 - img[r, c]
    img = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
    imgs.append(img)
    images[i] = img
images = images / 255.0
images = images.reshape((lenght, -1))
pred = model.predict(images)
print(metrics.accuracy_score(labels, pred))
for index, (image, label) in enumerate(list(zip(imgs, pred))):
    plt.subplot(1, lenght, index + 1)
    plt.axis('off')
    plt.imshow(image, cmap='gray_r', interpolation='nearest')
    plt.title('pred: %i' % label)
plt.show()

　　嘛，虽然最后结果很糟。。4张图片识别率只有25%，唯一一张识别成功的，还是因为数据全部被识别为1，具体也不知道为啥，我想是因为我弄的数据集的问题。。。

　　6.使用深度学习

　　再来扩展一下，这次换一种方式来看看是如何处理的（依然使用sklearn提供的数据集）。

　　1).稍微老式一点的方法来处理，基本原理 $ y = Wx + b $，求解这个线性方程组，y是一个独热编码的列向量，W是权重系数矩阵，x是图像，b是偏移量，模型训练过程利用了梯度下降来学习 W 和 b（参考：http://tensorfly.cn/tfdoc/tutorials/mnist_pros.html）

# from keras import *
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
from sklearn.preprocessing import OneHotEncoder

dataset = datasets.load_digits()
n_samples = len(dataset.images)
images = dataset.images.reshape((n_samples, -1))
train_x = images[:n_samples//2]
test_x = images[n_samples//2:]
digits = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
digits = digits.reshape((10, 1))
onehot = OneHotEncoder()
onehot.fit(digits)
label = [onehot.transform([[_]]).toarray()[0] for _ in dataset.target]
train_y = label[:n_samples//2]
test_y = label[n_samples//2:]
x = tf.placeholder('float', [None, 64])
y_ = tf.placeholder('float', [None, 10])
W = tf.Variable(tf.zeros([64, 10]))
b = tf.Variable(tf.zeros([10]))
y = tf.nn.softmax(tf.matmul(x, W) + b)
cross_entropy = -tf.reduce_sum(y_*tf.log(y))
train_step = tf.train.GradientDescentOptimizer(learning_rate=0.15).minimize(cross_entropy)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
sess.run(train_step, feed_dict={x: train_x, y_: train_y})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print(sess.run(accuracy, feed_dict={x: test_x, y_: test_y}))
pred = sess.run(y, feed_dict={x: test_x})
print(pred)

　　准确率：

0.77864295

　　2).tensorflow还有更便利的办法构建网络层，我们可以自己定义输入形状和输出形状，不需要对数据集做太多处理，也不用对标签进行独热编码了（参考：https://www.tensorflow.org/tutorials/)：

# from keras import *
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
from sklearn.preprocessing import OneHotEncoder

dataset = datasets.load_digits()
n_samples = len(dataset.images)
sizes = n_samples // 2

train_x = dataset.images[:sizes] / 255.0
test_x = dataset.images[sizes:] / 255.0
train_y = dataset.target[:sizes]
test_y = dataset.target[sizes:]

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(8, 8)),
    tf.keras.layers.Dense(512, activation=tf.nn.relu),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(train_x, train_y, epochs=10)
test_loss, test_acc = model.evaluate(test_x, test_y)
print(test_acc)

y_pred = model.predict(test_x)
y_pred = [np.argmax(_) for _ in y_pred]

for i, (image, real, pred) in enumerate(zip(test_x[:12], test_y[:12], y_pred[:12])):
    plt.subplot(3, 4, i + 1)
    plt.title('real:{} pred:{}'.format(real, pred))
    plt.axis('off')
    plt.imshow(image, cmap='gray_r')
plt.show()

　　跑了几次，选了一个准确率稍微好看一点的：

0.8331479422242544

　　看看测试集的前12个预测结果如何：

　　当然准确率还可以再优化。

　　然后，我用所有sklearn的digits数据集训练了一个准确率93%的模型来测试我自己弄的数据：

import numpy as np
import matplotlib.pyplot as plt
import cv2 as cv

target = [0, 1, 4, 5]
images = np.zeros((4, 8, 8), np.uint8)
imgs = []
for _, i in enumerate(target):
    img = cv.imread('digits/%i.png' % i)
    img = cv.resize(img, (8, 8), interpolation=cv.INTER_CUBIC)
    for r in range(img.shape[0]):
        for c in range(img.shape[1]):
            img[r, c] = 255 - img[r, c]
    img = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
    # img = cv.Laplacian(img, cv.CV_64F)
    imgs.append(img)
    images[_] = img
model = tf.keras.models.load_model('mnist.h5')
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
y_pred = model.predict(images)
loss, acc = model.evaluate(images, target)
print(acc)
y_pred = [np.argmax(_) for _ in y_pred]
for i, (image, real, pred) in enumerate(zip(imgs, target, y_pred)):
    plt.subplot(1, 4, i + 1)
    plt.title('real:{} pred:{}'.format(real, pred))
    plt.axis('off')
    plt.imshow(image, cmap='gray_r')
plt.show()

　　只有4张图，准确率50%

　　效果：

　　# 2018-12-02

　　今天又换了一批数据集（训练集60000张，测试集10000张）使用sklearn的svm来训练了一个在测试集上准确率表现为94%的模型，来识别我的那4张。

　　训练代码如下：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import cv2 as cv
from sklearn import svm, metrics
from sklearn.externals import joblib

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# print(x_train.shape, y_train.shape)

x_train = x_train.reshape((60000, -1))
x_test = x_test.reshape((10000, -1))

model = svm.SVC(gamma=0.001)
model.fit(x_train, y_train)
joblib.dump(model, 'mnist.m')

y_pred = model.predict(x_test)
print(metrics.accuracy_score(y_test, y_pred))

　　然后测试我的数据集：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import cv2 as cv
from sklearn import svm, metrics, datasets
from sklearn.externals import joblib

y_test = [0, 1, 4, 5]
x_test = np.zeros((4, 28, 28), np.uint8)
imgs = []
for _, i in enumerate(y_test):
    img = cv.imread('digits/%i.png' % i)
    img = cv.resize(img, (28, 28), interpolation=cv.INTER_CUBIC)
    for r in range(img.shape[0]):
        for c in range(img.shape[1]):
            img[r, c] = 255 - img[r, c]
    img = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
    imgs.append(img)
    x_test[_] = img
x_test = x_test / 255.0
x_test = x_test.reshape((4, -1))

model = joblib.load('mnist.m')
print('loaded model')
y_pred = model.predict(x_test)
print(metrics.accuracy_score(y_test, y_pred))

for index, (image, real, pred) in enumerate(zip(imgs, y_test, y_pred)):
    plt.subplot(1, 4, index + 1)
    plt.axis('off')
    plt.imshow(image, cmap='gray_r', interpolation='nearest')
    plt.title('real:{} pred:{}'.format(real, pred))
plt.show()

　　准确率也是50%，之前没有加

x_test = x_test / 255.0

　　这句时，会全部识别为同一个数字。。。

　　AutoML可以看看：https://qiita.com/Hironsan/items/30fe09c85da8a28ebd63