Etude d’un exemple
Cours 7
Cnn-master
A. Belaïd 1
Mon schéma de cnn
cnnTrain Config, cnnInitParams,
minFuncSGD, cnnCost
MonInterfaceCNN
(GUI)
Test.m loadMNISTImages, cnnConvolve, cnnPool,
nextBlock, nonLinear
A. Belaïd 2
cnnTrain
% Etape 1: Configurer la structure du %Etape 3 : cnn Train : fixer les paramètres
réseau d’apprentissage
cnnConfig = config(); [Link] = 3;
% Initialiser les paramètres sur le réseau [Link] = 128;
ainsi configuré [Link] = 1e-1;
[theta meta] = cnnInitParams(cnnConfig); [Link] = .95;
% Etape 2: Charger les données MNIST et
leurs labels, mettre les images à la taille
indiquée dans la structure du réseau % Implementer le gradient stochastique et la
images = loadMNISTImages('train-images- fonction de coût
idx3-ubyte'); opttheta = minFuncSGD(@(x,y,z)
d = [Link]{1}.dimension; cnnCost(x,y,z,cnnConfig,meta),theta,image
s,labels,options);
images = reshape(images,d(1),d(2),d(3),[]);
labels = loadMNISTLabels('train-labels-idx1-
ubyte');
labels(labels==0) = 10; % Remap 0 to 10
A. Belaïd 3
cnnTrain (suite)
% Etape 4: Tester les performances du % Calcul de la précision avec la fonction de
modèle ainsi entraîné en utilisant coût sur les données préparées
l’ensemble de test : MNIST. La précision [cost,grad,preds]=cnnCost(opttheta,testImag
doit être au-dessus de 97% après 3 es,testLabels,cnnConfig,meta,true);
epochs
acc = sum(preds==testLabels)/length(preds);
testImages = loadMNISTImages('t10k-
images-idx3-ubyte');
fprintf('Accuracy is %f\n',acc);
testImages =
reshape(testImages,d(1),d(2),d(3),[]);
testLabels = loadMNISTLabels('t10k- %diary off;
labels-idx1-ubyte');
testLabels(testLabels==0) = 10; %
Remap 0 to 10
A. Belaïd 4
config
function cnnConfig = config()
[Link]{1}.type = 'input'; [Link]{5}.type = 'sigmoid';
[Link]{1}.dimension = [28 28 1]; [Link]{5}.dimension = 360;
[Link]{2}.type = 'conv'; [Link]{6}.type = 'sigmoid';
[Link]{2}.filterDim = [9 9]; [Link]{6}.dimension = 60;
[Link]{2}.numFilters = 20;
[Link]{2}.nonLinearType = [Link]{7}.type = 'softmax';
'sigmoid'; [Link]{7}.dimension = 10;
[Link]{2}.conMatrix =
ones(1,20); [Link] = 'crossEntropy';
end
[Link]{3}.type = 'pool';
[Link]{3}.poolDim = [2 2];
[Link]{3}.poolType = 'meanpool';
[Link]{4}.type = 'stack2line';
A. Belaïd 5
Architecture
L=1 L=2 L=3 L=4 L=5 L=6 L=7 L=9
12
FeatureMaps
crossEntropy
Stack2line
softmaxn
softsign sigmoid MaxPool (pour
MeanPool
2x2 transformer
2 x2
les matrices
en vecteur)
12
Dim=10
3 Filtres de FeatureMaps Vecteur
FC (sortie)
convolution 4 Filtres de
obtenu
(9 x 9) convolution
Input (5 x 5)
3 FeatureMaps
(28 x 28)
A. Belaïd 6
Config à tester
function cnnConfig = config()
l = 1; [Link]{l}.type = 'pool';
[Link]{l}.type = 'input'; [Link]{l}.poolDim = [5 5];
[Link]{l}.dimension = [224 224 [Link]{l}.poolType = 'maxpool';
1]; l = l + 1;
l = l + 1; [Link]{l}.type = 'stack2line';
[Link]{l}.type = 'conv'; l = l + 1;
[Link]{l}.filterDim = [5 5]; [Link]{l}.type = 'relu';
[Link]{l}.numFilters = 16; [Link]{l}.dimension = 512;
[Link]{l}.nonLinearType = 'relu'; l = l + 1;
[Link]{l}.conMatrix = ones(1,16); [Link]{l}.type = 'relu';
l = l + 1; [Link]{l}.dimension = 256;
[Link]{l}.type = 'pool'; l = l + 1;
[Link]{l}.poolDim = [5 5]; [Link]{l}.type = 'softmax';
[Link]{l}.poolType = 'meanpool'; [Link]{l}.dimension = 106;
l = l + 1; l = l + 1;
[Link]{l}.type = 'conv'; [Link] = 'crossEntropy';
[Link]{l}.filterDim = [5 5]; end
[Link]{l}.numFilters = 16;
[Link]{l}.nonLinearType = 'relu';
[Link]{l}.conMatrix =
A. Belaïd
ones(16,16); l = l + 1; 7
Config à tester
The learning parameters:
– [Link] = 3;
– [Link] = 128;
– [Link] = 0.01;
– [Link] = .9;
A. Belaïd 8
A. Belaïd 9
configTestGradient
l = 1;
[Link]{l}.type = 'input'; [Link]{l}.nonLinearType = 'sigmoid';
[Link]{l}.dimension = [28 28 1]; [Link]{l}.conMatrix = ones(3,4);
l = l + 1; l = l + 1;
[Link]{l}.type = 'conv'; [Link]{l}.type = 'pool';
[Link]{l}.filterDim = [9 9]; [Link]{l}.poolDim = [2 2];
[Link]{l}.numFilters = 3; [Link]{l}.poolType = 'maxpool';
[Link]{l}.nonLinearType = 'softsign'; l = l + 1;
[Link]{l}.conMatrix = ones(1,3); [Link]{l}.type = 'stack2line';
l = l + 1; l = l + 1;
[Link]{l}.type = 'pool'; % [Link]{l}.type = 'tanh';
[Link]{l}.poolDim = [2 2]; % [Link]{l}.dimension = 60;
[Link]{l}.poolType = 'meanpool'; % l = l + 1;
l = l + 1; [Link]{l}.type = 'softmax';
[Link]{l}.type = 'conv'; [Link]{l}.dimension = 10;
[Link]{l}.filterDim = [5 5]; l = l + 1;
[Link]{l}.numFilters = 4; [Link] = 'crossEntropy';
end
A. Belaïd 10
Les fonctions Matlab
Layer : Convolution et pooling
Ce répertoire contient du code qui vous aide à démarrer l'exercice de convolution et
de mise en commun (pooling). Dans ce répertoire, vous devez uniquement utiliser
Test.m, cnnConvolve.m et cnnPool.m
cnnConvolve
Layer Test.m
cnnPool
A. Belaïd 11
Test.m
% STEP 0: Initialisation des paramètres % STEP 1: on implémente la convolution et
utilisés ici et chargement des données on la teste sur une petite partie des données
imageDim = 28; % STEP 1a: Implementer la convolution
filterDim = 8; % Utiliser uniquement 8 images pour tester
numFilters = 100; % nb de feature maps convImages = images(:, :, 1,1:8);
numImages = 60000; convolvedFeatures =
poolDim = 3; % dimension de la region de cnnConvolve(convImages, W, b);
pooling
% Chargement des images MNIST pour
l’apprentissage
addpath(genpath('C:\Abelaid\1-…\Dataset'));
images = loadMNISTImages('C:\Abelaid\1-…
\MNIST\train-images-idx3-ubyte');
images =
reshape(images,imageDim,imageDim,1,numI
mages);
W = randn(filterDim,filterDim,1,numFilters);
b = rand(numFilters);
A. Belaïd 12
Test.m (suite 1)
%STEP 1b: Verifier la convolution feature = sum(sum(patch.*W(:,:,1,filterNum)))
% Pour s'assurer que vous avez convolué +b(filterNum);
les caractéristiques correctement, nous avons feature = 1./(1+exp(-feature));
fourni du code pour comparer les résultats de
votre convolution avec des activations de
if abs(feature -
l'auto-encodeur sparse (entrées = sorties)
convolvedFeatures(imageRow,
imageCol,filterNum, imageNum)) > 1e-9
% Pour 1000 points aléatoires fprintf('Convolved feature does not
for i = 1:1000 match test feature\n');
filterNum = randi([1, numFilters]); fprintf('Filter Number : %d\n', filterNum);
imageNum = randi([1, 8]); ….
imageRow = randi([1, imageDim - filterDim end
+ 1]); end
imageCol = randi([1, imageDim - filterDim + disp('Congratulations! Your convolution code
1]); passed the test.');
patch = convImages(imageRow:imageRow
+ filterDim - 1, imageCol:imageCol + filterDim
- 1,1, imageNum);
A. Belaïd 13
Test.m (suite 2)
% STEP 2: Implementer et tester le pooling pooledFeatures = squeeze(cnnPool([4 4],
testMatrix, 'meanpool'));
% STEP 2a: Implementer le pooling
pooledFeatures = cnnPool([poolDim if ~isequal(pooledFeatures, expectedMatrix)
poolDim], convolvedFeatures, 'meanpool'); disp('Pooling incorrect');
…
% STEP 2b : verifier votre pooling else
% Pour vous assurer que vous avez mis en disp('Congratulations! Your pooling code
œuvre correctement le pooling, nous allons passed the test.');
utiliser votre fonction de pooling sur une end
matrice de test et vérifier les résultats
testMatrix = reshape(1:64, 8, 8);
expectedMatrix = [mean(mean(testMatrix(1:4,
1:4))) mean(mean(testMatrix(1:4, 5:8))); ...
mean(mean(testMatrix(5:8, 1:4)))
mean(mean(testMatrix(5:8, 5:8))); ];
testMatrix = reshape(testMatrix, 8, 8, 1, 1);
A. Belaïd 14
cnnConvolve
%cnnConvolve Retourne la convolution des [filterDimRow,filterDimCol,channel,numFilter
entités données par W et b avec les images s] = size(W);
données if ~exist('con_matrix','var') ||
% Paramètres : isempty(con_matrix)
- images à convoluer avec une matrice sous la con_matrix = ones(channel, numFilters);
forme : images(row, col, channel, image end
number) if ~exist('nonlineartype','var')
- W est de la forme : nonlineartype = 'sigmoid';
(filterDim,filterDim,channel,numFilters)
end
- b est de la forme : (numFilters,1)
if ~exist('shape','var')
- nonlineartype : type de la non-linearité:
'sigmoid' : default, 'relu, 'tanh‘, 'softsign‘… shape = 'valid';
- con_matrix: la connexion entre le canal end
d'entrée et les cartes de sortie. Si le ième canal [imageDimRow, imageDimCol,~,
d'entrée a une connexion avec la jème carte de numImages] = size(images);
sortie, alors con_matrix(i,j) = 1, sinon, 0; convDimRow = imageDimRow -
filterDimRow + 1;
% Retourne : convolvedFeatures – matrice des convDimCol = imageDimCol - filterDimCol +
caractéristiques convoluées sous la forme : 1;
convolvedFeatures(imageRow, imageCol, convolvedFeatures = zeros(convDimRow,
featureNum, imageNum) convDimCol, numFilters, numImages); 15
cnnConvolve (suite 1)
% Convolue chaque filtre avec chaque image % Obtenir l’image
pour produire : :convolvedFeatures utilisant im = squeeze(images(:, :,
convolvedFeatures(imageRow, imageCol, channelNum,imageNum));
featureNum, imageNum)
% Convolue "filter" avec "im", en
for imageNum = 1:numImages ajoutant lee resultat à convolvedImage
for filterNum = 1:numFilters % s’assurer de faire une convolution
convolvedImage = zeros(convDimRow, 'valide'
convDimCol); convolvedImage = convolvedImage
for channelNum = 1:channel + conv2(im, filter, shape);
if con_matrix(channelNum,filterNum) ~= 0 end
% Obtenir thla caractéristique souhaitée % Ajouter l’unite de biais
(filterDim x filterDim) pendant la convolution end
filter = W(:,:,channelNum,filterNum); convolvedImage = convolvedImage +
% Retourner la matrice de b(filterNum);
caractéristiques en raison de la définition de % on obtient filterNum featureMaps
convolution, comme expliqué plus tard convolvedFeatures(:, :, filterNum,
filter = rot90(squeeze(filter),2); imageNum) = convolvedImage;
end
A. Belaid end 16
cnnConvolve (suite 2)
linTrans = convolvedFeatures;
%Effectuer la non-linéarité
switch nonlineartype
case 'sigmoid'
convolvedFeatures = 1./(1+exp(-convolvedFeatures));
case 'relu'
convolvedFeatures = max(0,convolvedFeatures);
case 'tanh'
convolvedFeatures = tanh(convolvedFeatures);
case 'softsign'
convolvedFeatures = convolvedFeatures ./ (1 + abs(convolvedFeatures));
case 'none'
% ne pas faire de nonlinearty
otherwise
fprintf('error: no such nonlieartype%s',nonlineartype);
end
end
A. Belaid 17
cnnPool
%cnnPool : regroupe (pools) les caractéristiques convoluées
% Paramètres:
- poolDim : dimension de la region de pooling, c’est un vecteur 2D :
(poolDimRow poolDimCol);
- convolvedFeatures : les caractéristiques convoluées à regrouper (celles
données par cnnConvolve)
- convolvedFeatures(imageRow, imageCol, featureNum, imageNum)
% Retourne :
- pooledFeatures – matrice des caractéristiques regroupées sous la forme :
pooledFeatures(poolRow, poolCol, featureNum, imageNum)
- weights : exprimant combine l’entrée contribute à la sortie
A. Belaid 18
cnnPool (suite 1)
if nargin < 3 if strcmp(pooltypes, 'meanpool')
pooltypes = 'meanpool'; weights(1:pooledDimRow*poolDim(1),
end 1:pooledDimCol*poolDim(2),:,:) =
ones(size(featuresTrim)) / poolDim(1) /
poolDim(2);
numImages = size(convolvedFeatures, 4);
end
numFilters = size(convolvedFeatures, 3);
convolvedDimRow = size(convolvedFeatures,
1); pooledFeatures = zeros(pooledDimRow,
pooledDimCol, numFilters, numImages);
convolvedDimCol = size(convolvedFeatures,
2);
pooledDimRow = floor(convolvedDimRow / poolFilter = ones(poolDim) *
poolDim(1)); 1/poolDim(1)/poolDim(2);
pooledDimCol = floor(convolvedDimCol /
poolDim(2));
weights = zeros(size(convolvedFeatures));
featuresTrim =
convolvedFeatures(1:pooledDimRow*poolDim(
1),1:pooledDimCol*poolDim(2),:,:);
A. Belaid 19
cnnPool (suite 2)
for imageNum = 1:numImages weights(1:pooledDimRow*poolDim(1),1:pool
for filterNum = 1:numFilters edDimCol*poolDim(2),filterNum,imageNum)
features = featuresTrim(:,:,filterNum, = col2im(temp,
imageNum); poolDim,[pooledDimRow*poolDim(1)
pooledDimCol*poolDim(2)], 'distinct');
switch pooltypes
case 'meanpool' pooledFeatures(:,:,filterNum,imageNum) =
poolConvolvedFeatures = reshape(m, size(pooledFeatures,1),
conv2(features,poolFilter,'valid'); size(pooledFeatures,2));
pooledFeatures(:,:,filterNum,imageNum)
= otherwise
poolConvolvedFeatures(1:poolDim:end,1:poolDi
m:end); error('wrongLayertype:
%s',pooltypes);
pooledFeatures(:,:,filterNum,imageNum) =
blockproc(features,poolDim,@maxblock); end
case 'maxpool' end
temp = im2col(features, poolDim, 'distinct'); end
[m, i] = max(temp); end
temp = zeros(size(temp)); function b= maxblock(a)
temp(sub2ind(size(temp),i,1:size(i,2))) = 1; b = max(max([Link]));
end
20
minFuncSGD
uçh uygèygg
21
Les fonctions Matlab
Demo : initialisation et apprentissage
Config : configure les layers du réseau
(7) en donnant les dimensions, les dim
des filtres, la function à seuil utilisée, et la Demo
function de coût
cnnInitParams : prend les paramètres
dans Config et prépare l’architecture pour
chaque type de layer : input, convolution,
Demo cnnTrain
pooling, … TrainingMethod
cnnCost : Calcule le coût et le gradient :
backbropgation
loadMNISTImages : ouvre le fichier
d’apprentissage et range les données
dans le fichier images MNIST
loadMNISTLabels : crée le vecteur label
A. Belaïd 22