|
|
Neural Network Toolkit - função "linearlayer"
Início
1. Introdução
Início
2. Como criar uma rede linear estática
Uma rede diz estática se não tem nem feedbacks nem atrasos. Neste caso, a sequência em que ocorrem os dados
não é importante.
Para criar um rede linear estática, comecemos por um caso simples: uma rede com um neurónio
com duas entradas, uma saída e viés (bias). Para treinar a rede definem-se as entradas "P"
e os respectivos resultados (alvos) "T". Vamos fazer o treino com a função
"adapt" em modo incremental, por isso,
as entradas e os alvos são definidos como sequências:
| P = {[1;2] [2;1] [2;3] [3;1]}; | Entradas |
| T = {4 5 7 7}; | Alvos |
| net = linearlayer(0,0); | Cria uma rede linear |
| net = configure(net,P,T); | Configura a rede para a entrada 'P' e alvo 'T') |
| net.IW{1,1} = [0 0]; | Valores iniciais dos pesos |
| net.b{1} = 0; | Valor inicial do viés (bias) |
| net.trainParam.epochs = 1; | Indica para fazer apenas uma iteração |
| [net,a,e,pf] = adapt(net,P,T); | Para treinar incrementalmente a rede |
Caso neste caso, "a" vem igual a "0" porque a taxa de
aprendizagem é "0". Assim, devemos alterá-la para os pesos e para o viés (bias):
| net.inputWeights{1,1}.learnParam.lr = 0.1; | Taxa de aprendizagem dos pesos |
| net.biases{1,1}.learnParam.lr = 0.1; | Taxa de aprendizagem do viés (bias) |
Os resultados agora obtidos são para
| [net,a,e,pf] = adapt(net,P,T); | Para treinar rede (primeira iteração) |
| a -> [0] [2] [6] [5.8] | Valores obtidos após a primeira iteração |
| e -> [4] [3] [1] [1.2] | Erros obtidos após a primeira iteração |
| [net,a,e,pf] = adapt(net,P,T); | Para treinar rede (segunda iteração) |
| a -> [5.52] [4.8] [7.392] [5.976] | Valores obtidos após a segunda iteração |
| e -> [-1.52] [0.2] [-0.392] [1.024] | Erros obtidos após a segunda iteração |
Se se pretender fazer o treino em modo batch devem ser feitas pequenas
alterações na representação das entradas e dos alvos (a vermelho escuro o que se alterou):
| P = [1 2 2 3 ; 2 1 3 1]; | Entradas |
| T = [4 5 7 7]; | Alvos |
| net = linearlayer(0, 0.01); | Cria uma rede linear com atraso e taxa de aprendizagem "0.1" |
| net = configure(net, P, T); | Configura a rede para a entrada 'P' e alvo 'T') |
| net.IW{1,1} = [0 0]; | Valores iniciais dos pesos |
| net.b{1} = 0; | Valor inicial do viés (bias) |
| net.trainParam.epochs = 1; | Indica para fazer apenas uma iteração |
| net = train(net,P,T); | Para treinar incrementalmente a rede |
| net.IW{1,1} -> 0.4900 0.4100 | Valores dos pesos ao fim de uma iteração |
| net.b{1} -> 0.2300 | Valor do viés ao fim de uma iteração |
Nota: A alteração nas definições de "P" e
de "T" são essencial se o treino for feito com a função
"adapt". Se for feito com a função "train"
o treino é sempre feito em modo batch.
Início
3. Como criar uma rede linear dinâmica com estradas sequenciais
Uma rede diz dinâmica se tem feedbacks e/ou atrasos. Quando há atrasos, as entradas são normalmente uma
sequência numa certa ordem.
Consideremos um caso em que se tem uma única entrada, um mecanismo de atraso de um passo, um neurónio,
sem viés, e uma saída com uma função de transferência linear. Vamos fazer o treino com a função
"adapt" em modo incremental, por isso, as entradas e os alvos são
definidos como sequências:
Podemos ainda considerar as entradas
"P" e a matriz dos pesos "W"
| net = linearlayer([0,1], 0.1); | Cria uma rede linear com atraso e taxa de aprendizagem "0.1" |
| net.inputs{1}.size = 1; | Indica que se tem apenas um valor de entrada |
| net.layers{1}.dimensions = 1; | Indica que se tem a primeira camada comum único neurónio |
| net.IW{1,1} = [0 0]; | Indicam-se os valores iniciais dos pesos da primeira camada |
| net.biasConnect = 0; | Indica que não se considera nenhum viés (bias) |
| net.trainParam.epochs = 1; | Indica para fazer apenas uma iteração |
| Pi = {1}; | Valor inicial do atraso |
| P = {2 3 4}; | Valores das entradas |
| T = {3 5 7}; | Valores dos alvos |
| [net,a,e,pf] = adapt(net,P,T,Pi); | Treino da rede primeira iteração |
| a -> [0] [2.4] [7.98] | Valores obtidos após a primeira iteração |
| e -> [3] [2.6] [-0.98] | Erros obtidos após a primeira iteração |
Para fazer o mesmo em "modo batch" usando a função de treino
"train", apenas se vai alterar a chamada da função de treino:
| net = train(net,P,T,Pi); | Treino da rede primeira iteração |
| net.IW{1,1} -> [0.90] [0.62] | Resultados obtidos |
Início
4.
Início
5.
Início
6. Links úteis
Início
|
|