%% Gerar Imagem.

% As imagens foram geradas aleatriamente, criandos dgitos de diferentes

% fontes.
%Cada imagem de 28x28 pixels.
%Carregar os dados de treinamento para a memria:
[xTrainImages, tTrain] = digittrain_dataset;
% Mostra algumas das imagens de treinamento:
clf
for i = 1:20
subplot(4,5,i);
imshow(xTrainImages{i});
end
%% Converter imagens para matriz.
%Para usar as imagens para treinamento de uma rede neural, voc tem que
%organiz-los em uma matriz onde cada coluna representa uma nica imagem.
%Voc pode fazer isso pelo empilhamento das colunas de uma imagem para
%formar um vetor e, em seguida, formando uma matriz a partir desses
%vetores.
% As imagens so armazenadas em uma matriz de 10 por 5000,
%onde em cada coluna de um nico elemento ser de 1 para indicar a classe
%que o dgito pertence, e todos os outros elementos da coluna ser 0. Deve
%notar-se que se o dcimo elemento 1, ento a imagem de dgito um
%zero.
% Definir o nmero de pixels em cada imagem:
imageWidth = 28;
imageHeight = 28;
inputSize = imageWidth*imageHeight;
%Transformar as imagens em vetores e as adiciona em matriz:
xTrain = zeros(inputSize, numel(xTrainImages));
for i = 1:numel(xTrainImages)
xTrain(:,i) = xTrainImages{i}(:);
end
%% Defir o Autoencoder.
%Um autoencoder uma rede neural utilizada para aprender cdigos
%eficientes. O objectivo aprender, um codificao para um conjunto de
%dados, tipicamente para o efeito de reduo de dimensionalidade.Quando o
%nmero de neurnios na camada escondida menor do que o tamanho da
%entrada, o autoencoder ir aprender uma representao comprimida da
%entrada.
%Voc pode criar um autoencoder atravs da criao de uma rede
%feed-forward, e em seguida, modificar algumas das configuraes.
%Tamanho da camada oculta para o autoencoder:
hiddenSize1 = 100;
%Criando a rede. Define o tipo de rede, funo de treinamento e nmero de
%pocas.
autoenc1 = feedforwardnet(hiddenSize1);
autoenc1.trainFcn = 'trainscg';
autoenc1.trainParam.epochs = 400;

% No usar funes de processo na entrada ou sada.

autoenc1.inputs{1}.processFcns = {};
autoenc1.outputs{2}.processFcns = {};
% Definir a funo de transferncia para ambas as camadas para o sigmide logstica
autoenc1.layers {1} .transferFcn = 'logsig';
autoenc1.layers {2} .transferFcn = 'logsig';
% Utilize todos os dados para o treinamento
autoenc1.divideFcn = 'dividetrain';
%% Melhorar o treinamento.
%Ao usar a funo de desempenho | msesparse | voc pode controlar a
%influncia de irregularidades ajustando vrios parmetros:
% | L2WeightRegularization | controla a ponderao para os pesos da rede.
% | SparsityRegularization | controla a ponderao de grandes fraes dos
%neurnios na camada oculta de ativar em resposta a uma entrada.
% | sparsity | controla a fraco desejada de neurnios que devem
%desencadear na primeira camada, em resposta a uma entrada. Este deve estar
%entre 0 e 1.
autoenc1.performFcn = 'msesparse';
autoenc1.performParam.L2WeightRegularization = 0.004;
autoenc1.performParam.sparsityRegularization = 4;
autoenc1.performParam.sparsity = 0.15;
%% Treinando o primeiro Autoencoder.
%Para um autoencoder, os dados de entrada e sida so idnticos.
% Treinar o autoencoder:
autoenc1 = train(autoenc1,xTrain,xTrain);
% possvel ver um diagrama do autoencoder, que mostra o tamanho da
% entrada, de sada e de camada oculta, bem como as funes de
% transferncia para as duas camadas.
view(autoenc1);
%% Visualizar os resultados do primeiro Autoencoder.
%
%
%
%
%
%

Depois de treinar o autoencoder, possvel ver os recursos que ele

aprendeu, visualizando-los. Cada neurnio na camada
escondida ter um vetor de pesos associados na camada de entrada que
vai ser ajustado para responder a um efeito visual especial. Por
remodelar esses vetores de pesos, podemos ver uma representao desses
recursos.

W1 = autoenc1.IW{1};
weightsImage = helperWeightsToImageGallery(W1,imageHeight,imageWidth,10,10);
imshow(weightsImage);
%% Visualizar os resultados do primeiro Autoencoder.
% possvel observar que as caractersticas aprendidas pelo autoencoder

% representam padres de traados a partir das imagens dgitos.

%A sada dimensional de 100 da camada escondida do autoencoder uma verso
% compactada da entrada, que resume sua resposta aos recursos que foram
% visualizadas anteriormente.
%% Treinar o prximoo autoencoder:
%Para fazer isso, criar uma primeira igual verso do autoencoder com a
%camada final removida. Isto feito atravs da criao de um objeto de rede
%vazia, e, em seguida, configurar manualmente as configuraes.
%Voc copia os pesos e preconceitos do autoencoder treinado.
% Criar uma rede vazia:
autoencHid1 = network;
% Definir o nmero de entradas e camadas:
autoencHid1.numInputs = 1;
autoencHid1.numlayers = 1;
% Conectar a primeira camada com a priemira entrada
%e tambm conectar a primeira camada com a sada.
autoencHid1.inputConnect(1,1) = 1;
autoencHid1.outputConnect = 1;
% Adicionar uma conexo para polarizao da primeira camada:
autoencHid1.biasConnect = 1;
% Definir o tamanho da entrada e da primeira camada:
autoencHid1.inputs{1}.size = inputSize;
autoencHid1.layers{1}.size = hiddenSize1;
% Definir a funo de transferncia sigmide para a primeira camada.
% Ela calcula as sidas referente a camada.
autoencHid1.layers{1}.transferFcn = 'logsig';
%Copiar os pesos e a polarizao a partir da primeira camada j treinada:
autoencHid1.IW{1,1} = autoenc1.IW{1,1};
autoencHid1.b{1,1} = autoenc1.b{1,1};
%% Ativar a funo | view |:
% Poderemos verificar se a rede est equivalente ao primeiro autoencoder,
% com a ltima camada removida.
view(autoencHid1);
%% Gerar resursos para treinar o 2 Autoencoder:
% Usar a avaliao da autoencoder truncada no nos dados de treinamento.
feat1 = autoencHid1(xTrain);
%% Treinar o segundo Autoencoder
% Depois de treinar o primeiro autoencoder, treinaremos o segundo de forma
% semelhante.
%A diferena que os dados de treino so a caractersticas geradas
% a partir da camada oculta do autoencoder anterior. Mais uma vez, voc
% cria uma rede feed-forward e, em seguida, modifica o definies.

% Criar a rede. Mudar o tamanho da oculto camada, o

% nmero de pocas de treinamento, e a funo de treinamento:
hiddenSize2 = 50;
autoenc2 = feedforwardnet(hiddenSize2);
autoenc2.trainFcn = 'trainscg';
autoenc2.trainParam.epochs = 100;
%No usar funes de processamento de entrada e sada:
autoenc2.inputs{1}.processFcns = {};
autoenc2.outputs{2}.processFcns = {};
%Definir a funo de transferncia para ambas as camadas para a funo
%sigmide logstica:
autoenc2.layers{1}.transferFcn = 'logsig';
autoenc2.layers{2}.transferFcn = 'logsig';
%Usar todos os dados para o treinamento:
autoenc2.divideFcn = 'dividetrain';
% Definir a funo de desempenho para
% | Msesparse | e os valores para os parmetros da funo de desempenho.
% Usar o erro quadrado mdio para regularizar a funo de desempenho e
% alterar alguns parmetros:
autoenc2.performFcn = 'msesparse';
autoenc2.performParam.L2WeightRegularization = 0.002;
autoenc2.performParam.sparsityRegularization = 4;
autoenc2.performParam.sparsity = 0.1;
% Treinar o autoencoder sobre os recursos gerados a partir dos anteriores.
% Treinar o segundo autoencoder:
autoenc2 = train(autoenc2,feat1,feat1);
%Vizualizar o diagrama:
% O segundO autoencoder semelhante ao primeiro, mas o tamanho das camadas
% so diferentes.
view(autoenc2);
%% Remover a camada final do segundo autoencoder.
% Criar uma rede vazia:
autoencHid2 = network;
% Definir o nmero de entradas e camadas:
autoencHid2.numInputs = 1;
autoencHid2.numlayers = 1;
% Conectar a primeira camada com a priemira entrada
%e tambm conectar a primeira camada com a sada.
autoencHid2.inputConnect(1,1) = 1;
autoencHid2.outputConnect = 1;
% Adicionar uma conexo para polarizao da primeira camada:
autoencHid2.biasConnect = 1;
% Definir o tamanho da entrada e da primeira camada:
autoencHid2.inputs{1}.size = hiddenSize1;
autoencHid2.layers{1}.size = hiddenSize2;

% Definir a funo de transferncia sigmide para a primeira camada.

% Ela calcula as sidas referente a camada.
autoencHid2.layers{1}.transferFcn = 'logsig';
%Copiar os pesos e a polarizao a partir da primeira camada j treinada:
autoencHid2.IW{1,1} = autoenc2.IW{1,1};
autoencHid2.b{1,1} = autoenc2.b{1,1};
%Poderemos verificar se a rede est equivalente ao segundo autoencoder,
% com a ltima camada removida.
view(autoencHid2);
% Extrair o segundo conjunto de caractersticas, passando pelo
% conjunto anterior atravs do segundo autoencoder truncado.
feat2 = autoencHid2(feat1);
%% Observaes:
%
%
%
%

Os vetores originais, nos dados de treinamento tiveram 784 dimenses.

Depois de passar pelo o primeiro autoencoder, este foi reduzido para 100
dimenses. Depois de usar o segundo autoencoder, foi reduzido novamente
para 50 dimenses.

%A prxima etapa treinar uma camada final de classificar estes 50

%vetores dimensionais em diferentes classes dgitos.
%% Treinar a camada final Softmax.
% Criamos uma camada softmax, e treinamos a sada a partir da camada
% escondida do segundo autoencoder. Quando a camada softmax
% consistir em uma camada, criaremos manualmente.
%Criar uma rede vazia:
finalSoftmax = network;
% O nmero de entradas e camadas:
finalSoftmax.numInputs = 1;
finalSoftmax.numLayers = 1;
% Conectar a primeira camada com a primeira entrada
%e tambm conectar a primeira camada com a sada:
finalSoftmax.inputConnect(1,1) = 1;
finalSoftmax.outputConnect = 1;
% Adicionar uma conexo para polarizao da primeira camada:
finalSoftmax.biasConnect = 1;
% Tamanho da entrada e da primeira camada:
finalSoftmax.inputs{1}.size = hiddenSize2;
finalSoftmax.layers{1}.size = 10;
% Funo de transferncia softmax para a primeira camada:
finalSoftmax.layers{1}.transferFcn = 'softmax';
% Utilize todos os dados para a formao
finalSoftmax.divideFcn = 'dividetrain';
% Utilize a funo de desempenho cross-entropia
finalSoftmax.performFcn = 'crossentropy';

% nmero de pocas e funo de treinamento:

finalSoftmax.trainFcn = 'trainscg';
finalSoftmax.trainParam.epochs = 400;
%% Treinar a camada softmax de forma supervisionada.
finalSoftmax = train(finalSoftmax,feat2,tTrain);
%Vizualizar a camada softmax:
view(finalSoftmax);
%% Criar uma rede neural de multicamadas.
%Isoladamente treinamos os trs componentes de uma uma rede neural
%profunda.
%Vizualizar os trs componentes:
view(autoencHid1);
view(autoencHid2);
view(finalSoftmax);
%% Rede Neural Multicamadas:
%Com os trs compoentes formamos um conjunto, para criar a rede
%manualmente.
% Criar uma rede vazia:
finalNetwork = network;
% Definir uma entrada e trs camadas:
finalNetwork.numInputs = 1;
finalNetwork.numLayers = 3;
% Conectar a primeira camada com a entrada:
finalNetwork.inputConnect(1,1) = 1;
%Conectar a segunda camada com a primeira camada:
finalNetwork.layerConnect(2,1) = 1;
% Conectar a terceira camada com a segunda camada:
finalNetwork.layerConnect(3,2) = 1;
% Conectar a sada com a terceira camada:
finalNetwork.outputConnect(1,3) = 1;
% Adicionar uma polaridade para cada camada:
finalNetwork.biasConnect = [1; 1; 1];
% Definir o tamanho da entrada:
finalNetwork.inputs{1}.size = inputSize;
%Definir do tamanho da primeira camada para a camada em autoencHid1:
finalNetwork.layers{1}.size = hiddenSize1;
% Definir o tamanho da segunda camada para a camada em autoencHid2:
finalNetwork.layers{2}.size = hiddenSize2;
% Definir o tamanho da terceira camada para a camada em finalSoftmax:
finalNetwork.layers{3}.size = 10;

% Definir a funo de transferncia para a primeira camada como a camada

% AutoencHid1:
finalNetwork.layers{1}.transferFcn = 'logsig';
% Definir a funo de transferncia para a segunda camada como a camada
% AutoencHid2:
finalNetwork.layers{2}.transferFcn = 'logsig';
% Definir a funo de transferncia para a terceira camada como a camada
% FinalSoftmax:
finalNetwork.layers{3}.transferFcn = 'softmax';
% Utilizar todos os dados para a formao da rede:
finalNetwork.divideFcn = 'dividetrain';
% Copie os pesos e dados das trs redes que j foram treinados:
finalNetwork.IW{1,1} = autoencHid1.IW{1,1};
finalNetwork.b{1} = autoencHid1.b{1,1};
finalNetwork.LW{2,1} = autoencHid2.IW{1,1};
finalNetwork.b{2} = autoencHid2.b{1,1};
finalNetwork.LW{3,2} = finalSoftmax.IW{1,1};
finalNetwork.b{3} = finalSoftmax.b{1,1};
% Utilizar a funo de desempenho cross-entropy:
finalNetwork.performFcn = 'crossentropy';
% Alterando o nmero de pocas de treinamento e funo de treinamento:
finalNetwork.trainFcn = 'trainscg';
finalNetwork.trainParam.epochs = 100;
%% Vizualizar a rede de multicamadas:
view(finalNetwork);
%% Observaes:
% Com a rede treinada, calculamos os resultados no conjunto de teste. Para
% isso remodelamos as imagens de teste para matriz, como feito no o
% conjunto de treinamento.
% Carregar as imagens de teste:
[xTestImages, tTest] = digittest_dataset;
% Converter as imagens para matriz:
xTest = zeros(inputSize, numel(xTestImages));
for i = 1:numel(xTestImages)
xTest(:,i) = xTestImages{i}(:);
end
%% Quadro de Resultados com maior preciso:
y = finalNetwork(xTest);
plotconfusion(tTest,y);
%% Melhorar a deep learning:
%
%
%
%

Realizaremos de retropropagao em toda a rede multicamada para melhorar

a rede. Este processo referido como ajuste fino. Podemos afinar a rede
por reciclagem sobre os dados de forma supervisionada. E exibir os
resultados novamente utilizando o quadro de anlises.

finalNetwork = train(finalNetwork,xTrain,tTrain);
y = finalNetwork(xTest);
plotconfusion(tTest,y);