matlab手写数字识别初探

1下载数据集
获取MNIST
MNIST 数据集可在http://yann.lecun.com/exdb/mnist/获取，图片是以字节的形式进行存储，它包含了四个部分：

Training set images: train-images-idx3-ubyte.gz (9.9 MB, 解压后 47 MB, 包含 60,000 个样本)
Training set labels: train-labels-idx1-ubyte.gz (29 KB, 解压后 60 KB, 包含 60,000 个标签)
Test set images: t10k-images-idx3-ubyte.gz (1.6 MB, 解压后 7.8 MB, 包含 10,000 个样本)
Test set labels: t10k-labels-idx1-ubyte.gz (5KB, 解压后 10 KB, 包含 10,000 个标签)

此部分matlab上无法读出来，需要进行格式转换，所以有了function labels = loadMNISTLabels(filename),function labels = loadMNISTLabels(filename)
下面的代码用于转换格式

function labels = loadMNISTLabels(filename)

%loadMNISTLabels returns a [number of MNIST images]x1 matrix containing
%the labels for the MNIST images
fp = fopen(filename, ‘rb’);
assert(fp ~= -1, ['Could not open ', filename, ‘’]);
magic = fread(fp, 1, ‘int32’, 0, ‘ieee-be’);
assert(magic == 2049, ['Bad magic number in ', filename, ‘’]);
numLabels = fread(fp, 1, ‘int32’, 0, ‘ieee-be’);

labels = fread(fp, inf, ‘unsigned char’);
assert(size(labels,1) == numLabels, ‘Mismatch in label count’);
fclose(fp);
end

function images = loadMNISTImages(filename)

%loadMNISTImages returns a 28x28x[number of MNIST images] matrix containing
%the raw MNIST images
fp = fopen(filename, ‘rb’);
assert(fp ~= -1, ['Could not open ', filename, ‘’]);
magic = fread(fp, 1, ‘int32’, 0, ‘ieee-be’);
assert(magic == 2051, ['Bad magic number in ', filename, ‘’]);
numImages = fread(fp, 1, ‘int32’, 0, ‘ieee-be’);
numRows = fread(fp, 1, ‘int32’, 0, ‘ieee-be’);
numCols = fread(fp, 1, ‘int32’, 0, ‘ieee-be’);
images = fread(fp, inf, ‘unsigned char’);
images = reshape(images, numCols, numRows, numImages);
images = permute(images,[2 1 3]);
fclose(fp);
% Reshape to #pixels x #examples
images = reshape(images, size(images, 1) * size(images, 2), size(images, 3));
% Convert to double and rescale to [0,1]
images = double(images) / 255;
end

function [W1, W5, Wo] = MnistConv(W1, W5, Wo, X, D)

%
alpha = 0.01;
beta = 0.95;
momentum1 = zeros(size(W1));
momentum5 = zeros(size(W5));
momentumo = zeros(size(Wo));
N = length(D);
bsize = 100;
blist = 1:bsize:(N-bsize+1); %bilst=[1,101,201,…7901]
% One epoch loop
for batch = 1:length(blist) %length(blist)=80
dW1 = zeros(size(W1));
dW5 = zeros(size(W5));
dWo = zeros(size(Wo));
% Mini-batch loop
%
begin = blist(batch); %batch相当于是blist数组的序号
for k = begin:begin+bsize-1 %k=begin:begin+100-1
% Forward pass = inference
%
x = X(:, :, k); % Input, 28x28
y1 = Conv(x, W1); % Convolution, W1[9,9,20]
% y1=(28-9+1)(28-9+1)20
y2 = ReLU(y1); % 202020
y3 = Pool(y2); % Pool, 10x10x20
y4 = reshape(y3, [], 1); % 将y3转化为1列 2000
v5 = W5*y4; % ReLU, 100 （W5[100,2000]y4[2000,1]）
y5 = ReLU(v5); %
v = Woy5; % Softmax, 10
y = Softmax(v); %

% One-hot encoding

%
d = zeros(10, 1);          %真实标签
d(sub2ind(size(d), D(k), 1)) = 1;    %sub2ind(size(d),D(k),1)是针对行D（k）,列1的线性 索引处

% Backpropagation

%
e      = d - y;                   % Output layer
delta  = e;
e5     = Wo' * delta;             % Hidden(ReLU) layer
delta5 = (y5 > 0) .* e5;      %（y5>0）.      是matlab中reLU函数求导的形式
e4     = W5' * delta5;            % Pooling layer
e3     = reshape(e4, size(y3));       % size y3[10,10,20]
e2 = zeros(size(y2));
W3 = ones(size(y2)) / (2*2);      %size y2[20，20，20]
for c = 1:20
  e2(:, :, c) = kron(e3(:, :, c), ones([2 2])) .* W3(:, :, c);  %kron积用来将e3的维度扩展成[20,20,20]
end
delta2 = (y2 > 0) .* e2;          % ReLU layer
delta1_x = zeros(size(W1));       % Convolutional layer
for c = 1:20
  delta1_x(:, :, c) = conv2(x(:, :）, rot90(delta2(:, :, c), 2), 'valid');
  %rot90(delta2(：，：，c),2)是将delta2矩阵旋转180度。
  %conv2这句话是将x输入与delta2卷积
end
dW1 = dW1 + delta1_x;
dW5 = dW5 + delta5*y4';
dWo = dWo + delta *y5';

end

kron积

% Update weights

%
dW1 = dW1 / bsize;
dW5 = dW5 / bsize;
dWo = dWo / bsize;
momentum1 = alphadW1 + betamomentum1;
W1 = W1 + momentum1;
momentum5 = alphadW5 + betamomentum5;
W5 = W5 + momentum5;
momentumo = alphadWo + betamomentumo;
Wo = Wo + momentumo;
end
end

function y = Conv(x, W)

%
%
[wrow, wcol, numFilters] = size(W);
[xrow, xcol, ~ ] = size(x);
yrow = xrow - wrow + 1;
ycol = xcol - wcol + 1;
y = zeros(yrow, ycol, numFilters);
for k = 1:numFilters
filter = W(:, :, k);
filter = rot90(squeeze(filter), 2);
y(:, :, k) = conv2(x, filter, ‘valid’);
end
end

function y = Pool(x)

%
% 2x2 mean pooling
%
[xrow, xcol, numFilters] = size(x);
y = zeros(xrow/2, xcol/2, numFilters);
for k = 1:numFilters
filter = ones(2) / (2*2); % for mean
image = conv2(x(:, :, k), filter, ‘valid’);
y(:, :, k) = image(1:2:end, 1:2:end); %设定池化时卷积步长为2
end
end

function y = ReLU(x)

y=max(0,x);
end

function y = Softmax(x)

ex=exp(x);
y=ex/sum(ex);
end

main函数

train_images = loadMNISTImages(‘train-images.idx3-ubyte’);
train_images= reshape(train_images, 28, 28, []);
test_images=loadMNISTImages(‘t10k-images.idx3-ubyte’);
test_images=reshape(test_images,28,28,[]);
train_labels = loadMNISTLabels(‘train-labels.idx1-ubyte’);
test_labels = loadMNISTLabels(‘t10k-labels.idx1-ubyte’);
train_labels(train_labels==0)=10;
test_labels(test_labels == 0) = 10; % 0 --> 10 将0处置为10
rng(1);
% Learning
%
W1 = 1e-2randn([9 9 20]);
W5 = (2rand(100, 2000) - 1) * sqrt(6) / sqrt(360 + 2000);
Wo = (2rand( 10, 100) - 1) * sqrt(6) / sqrt( 10 + 100);
X = train_images(:, :, 1:50000);
D = train_labels(1:50000);
for epoch = 1
[W1, W5, Wo] = MnistConv(W1, W5, Wo, X, D);
end
save(‘MnistConv.mat’);
% Test
%
X = test_images(:,:,1:10000);
D =test_labels(1:10000);
acc = 0;
N = length(D);
for k = 1:N
x = X(:, :, k); % Input, 28x28
y1 = Conv(x, W1); % Convolution, 20x20x20
y2 = ReLU(y1); %
y3 = Pool(y2); % Pool, 10x10x20
y4 = reshape(y3, [], 1); % 2000
v5 = W5y4; % ReLU, 360
y5 = ReLU(v5); %
v = Wo*y5; % Softmax, 10
y = Softmax(v); %
[~, i] = max(y); %i是每列中最大元素在y中显示的行索引
if i == D(k)
acc = acc + 1;
end
end
acc = acc / N;
fprintf(‘Accuracy is %f\n’, acc);


本文摘自Kim - 2017 - MATLAB Deep Learning With Machine Learning, Neural