1.Softmax回归模型实现MNIST手写数字分类（python代码详解）
Softmax回归模型实现MNIST手写数字分类（python代码详解）
关键点：
- Softmax回归处理多分类问题，其是Logistic回归在多分类问题上的推广
- softmax回归使用交叉熵损失函数来学习最优的参数矩阵W，对样本进行分类
- Softmax回归是有监督的。
STEP 1：读取数据
'''读取数据'''
from tensorflow.keras.datasets import mnist
from __future__ import division
import tensorflow as tf
import numpy as np
data = mnist.load_data()
(x_train, y_train), (x_test,y_test) = data# x_train.shape=(60000, 28, 28)
x_train, x_test = np.array(x_train, np.float32), np.array(x_test, np.float32)
# reshape中值等于-1的话，那么Numpy会根据剩下的维度计算出数组的另外一个shape属性值。
x_train, x_test = x_train.reshape([-1,28*28]),x_test.reshape([-1,28*28]) # x_train.shape=(60000, 784)
STEP 2：特征缩放
该步骤可以让数据处于同一数值量级，也可以加快算法的收敛速度
- 特征缩放包含数据标准化、数据归一化
- 数据归一化：X = (X-Xmin)/(Xmax-Xmin)
- 归一化意义：让数据处于0-1之间，让不同维度之间的特征在数值上有一定比较性，可以大大提高分类器的准确性
- 归一化缺点：当有新数据加入时，可能导致max和min的变化，需要重新定义。另外，最大值与最小值非常容易受异常点影响，所以这种方法鲁棒性较差，只适合传统精确小数据场景
- 标准化公式：X = (X-μ)/σ
- 最好选择标准化
- 标准化最大的注意事项：就是先拆分出test集，不要在整个数据集上做标准化，因为那样会将test集的信息引入到训练集中
- sklearn.preprocessing.scale(X, axis=0, with_mean=True, with_std=True, copy=True)可以直接实现标准化， 其中 X：数组或者矩阵；axis：int类型，初始值为0，如果是0，则单独的标准化每列，如果是1，则标准化每行。with_mean：boolean类型，默认为True，表示将数据均值规范到0。with_std：boolean类型，默认为True，表示将数据方差规范到1。
from sklearn import preprocessing
x_train = preprocessing.scale(x_train)
STEP 3：初始化参数
- W是随机生成了符合高斯分布的数，再*0.001，使得W很小，W很小是因为，可以参照激活函数sigmoid和tanh，当W很大，用W * X+b=a得到的a很大，再用对a用激活函数如sigmoid(a)，由于a很大了，sigmoid(a)中的a会趋向正无穷或负无穷，则函数值sigmoid(a)趋向于一个平缓的趋势，在梯度下降的时候计算的梯度很小，会导致学习的很慢，故使得W取一个很小的值。
- 设置batch_size的原因是如果一次加载所有数据，那么单次迭代耗时太久，而一次加载一个数据，那么会失去所有向量化给算法带来的加速，所以取中选择batchsize。
- 后续根据输出结果效果调整该部分参数，主要调整学习率。
import numpy as np
w = tf.Variable(tf.cast(np.random.randn(784,10)*0.001,tf.float32),name="weight")
b = tf.Variable(tf.cast(np.random.randn(10),tf.float32),name="bias")
learning_rate = 0.1
step = 2000
batch_size = 256
STEP 4：数据配对并洗牌
该步骤打乱数据，这样可以保证每批次训练的时候所用到的数据集是不一样的，可以提高模型训练效果
train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.repeat().shuffle(5000).batch(batch_size).prefetch(1)
STEP 5：定义逻辑方程
- tf.nn.softmax把向量归一化为（0，1）之间的值
- softmax的输出向量就是概率，该样本属于各个类的概率！
def logistic_f(x):
z = x@w+b
y = tf.nn.softmax(z)
return y
STEP 5：交叉熵损失
- 损失函数 = -∑ylogy’
- one_hot(indices, #输入的tensor，
depth #用于定义一个 one hot 维度的深度) - reduce_sum( ) 是求和函数
def loss_f(y_pred, y_true):
y_true = tf.one_hot(y_true, depth=10)
term1 = -y_true*tf.math.log(y_pred)
loss = tf.reduce_mean(tf.reduce_sum(term1,1))
return loss
STEP 6：梯度下降
'''定义随机梯度下降优化器'''
optimizer = tf.optimizers.SGD(learning_rate)
def run_optimizer(x,y):
with tf.GradientTape() as g:
pred = logistic_f(x)
loss = loss_f(pred,y)
gradients = g.gradient(loss, [w, b])
optimizer.apply_gradients(zip(gradients,[w,b]))
STEP 7：计算准确度
- tf.argmax(input,axis)根据axis取值的不同返回每行或者每列最大值的索引
- tf.cast()函数的作用是执行 tensorflow 中张量数据类型转换
def accuracy(y_pred,y_true):
y_pred = tf.argmax(y_pred,1)
y_true = tf.cast(y_true, y_pred.dtype)
correct = tf.equal(y_pred, y_true)
correct = tf.cast(correct, tf.float32)
accuracy = tf.reduce_mean(correct)
return accuracy
STEP 8：模型训练
'''迭代执行优化器计算出w,b'''
all_loss = []
all_acc = []
for i, (batch_x, batch_y) in enumerate(train_data.take(step), 1):
run_optimizer(batch_x, batch_y)
if i % 50 == 0:
pred = logistic_f(batch_x)
loss = loss_f(pred, batch_y)
all_loss.append(loss)
acc = accuracy(pred, batch_y)
all_acc.append(acc)
print("step: %i, loss: %f, accuracy: %f" % (i, loss, acc))
第2000次迭代结果
step: 2000, loss: 0.308024, accuracy: 0.929688
STEP 9：可视化损失函数
'''可视化损失函数'''
import numpy as np
import matplotlib.pyplot as plt
step_list = np.linspace(0,2000,40)
plt.plot(step_list,all_loss,label="loss")
plt.plot(step_list,all_acc,label="acc")
plt.legend()
plt.show()
可视化结果如图
STEP 10：可视化测试集图片并预测
import matplotlib.pyplot as plt
n_images = 5
test = x_test[:n_images]
predictions = logistic_f(test_images)
for i in range(n_images):
plt.imshow(np.reshape(test_images[i], [28, 28]), cmap='gray')
plt.show()
print("Model prediction: %i" % np.argmax(predictions.numpy()[i]))