NeuralNetwork
 Tudo Estruturas de dados Funções Páginas
Referência à classe Network

Membros públicos

void backPropagation ()
 
int getSizeExpectedOutputs ()
 
void makeDefaultInputs ()
 Inicializa o multimap myDefaultInputs O multimap myDefaultInputs representa as entradas padres no formato Matrix.
 
void makeManuallyNetwork (vector< double >)
 Inicializa a rede neural myLayers As entradas so repassadas para a primeira camada, seguidamente atribui-se manualmente pesos sinpticos para cada neurnio de cada camada(incluindo camada de entrada) na forma de um vetor Por fim atribui-se manualmente ao vetor de entrada de cada neurnio o valor "zero" seguido de um setter manual para o bias.
 
void makeNetwork (vector< double >, int, int, int)
 Inicializa a rede neural myLayers As entradas so repassadas para a primeira camada, seguidamente atribui-se a todos os pesos sinpticos valores aleatrios.
 
void printNeuralNetwork ()
 
void printVector (vector< double >)
 
vector< Neuronpropagation (vector< double >)
 
void readjustsWeights ()
 
void setExpectedOutputs (int, vector< double >)
 
vector< double > startProcess (vector< double >)
 Inicializa o processo de treinamento para um padro de entrada Recebe um vetor de entrada e retorna um vetor de sada
 

Campos de Dados

vector< vector< Neuron > > myLayers
 

Atributos Privados

vector< vector< double > > ExpectedOutputs
 

Documentação dos métodos

void Network::backPropagation ( )

calculando erro e delta para a ULTIMA CAMADA

sada de um neurnio

erro de um neurnio

setter para a sada esperada de um neurnio

setter para o erro de um neurnio

setter para o delta de um neurnio

calculando erro e delta da CAMADA OCULTA

Referenciado por startProcess().

{
double error;
double y;
size_t size = myLayers[ static_cast<int> (myLayers.size()-1) ].size();
int index = static_cast<int> (myLayers.size()-1);
//cout << "TAM" << endl;
//cout << size << " " << index << endl;
//cout << ExpectedOutputs[ size ].size() << endl;
cout << "EXPECTED OUTPUT" << endl;
for(size_t i = 0 ; i < ExpectedOutputs.size() ; i++)
{
for(size_t j = 0 ; j < ExpectedOutputs[i].size() ; j++)
cout << ExpectedOutputs[ i ][j] << " " ;
//cout << ExpectedOutputs[ i ][j] << endl ;
//cout << endl << endl << endl;
cout << endl;
}
cout << endl << endl;
for(size_t i = 0 ; i < size ; i++)
{
y = myLayers[ index ][i].sigmoidFunction();
cout << "Y" << " [" << i << "]" << " "<< y << endl ;
error = ExpectedOutputs[ 0 ][i] - y;
myLayers[ index ][i].setExpectedOutput( ExpectedOutputs[ 0 ][i] );
myLayers[ index ][i].setError(error);
myLayers[ index ][i].setDelta( (1.0-pow(y,2))*error );
}
cout << endl << endl;
cout << "SAIDA ESPERADA" << setw(10);
cout << "Y" << setw(25);
cout << "ERRO" << setw(20);
cout << "DELTA" << endl;
for(size_t i = 0 ; i < size ; i++)
{
cout << myLayers[ index ][i].getExpectedOutput() << setw(30);
cout << myLayers[ index ][i].sigmoidFunction() << setw(20);
cout << myLayers[ index ][i].getError() << setw(20);
cout << myLayers[ index ][i].getDelta() << endl;
}
cout << endl << endl;
for( size_t i = myLayers.size()-2 ; i != -1 ; i-- )
{
//cout << "LAYER " << i << endl << endl;
for(size_t j = 0 ; j < myLayers[i].size() ; j++)
{
double value = 0;
//cout << "NEURON- " << i << " = " << myLayers[i][j].sigmoidFunction() << endl << endl;
for(size_t k = 0 ; k < myLayers[i+1].size() ; k++)
{
//cout << "NEURON+ " << k << " = " << myLayers[i+1][k].sigmoidFunction() << endl;
//cout << myLayers[i+1][k].deltaWeight(j) << endl;
//double var = myLayers[i+1][k].deltaWeight(k);
value += myLayers[i+1][k].deltaWeight(j);
//cout << endl;
}
//cout << "#" << value << endl;
myLayers[i][j].setError( value );
double y = myLayers[i][j].sigmoidFunction();
myLayers[i][j].setDelta( (1.0-pow(y,2))*value );
//cout << endl << endl;
//cout << myLayers[i][j].deltaWeight(j) << endl;
}
//myLayers[i][j].print();
}
for(size_t i = 0 ; i < myLayers.size() ; i++)
{
cout << "LAYER " << i << endl << endl;
for(size_t j = 0 ; j < myLayers[i].size() ; j++)
cout << "ERROR NEURON " << j << " = " << myLayers[i][j].getError() << setw(30) << "DELTA NEURON " << j << " = " << myLayers[i][j].getDelta() << endl;
cout << endl << endl;
}
}

+ Este é o diagrama das funções que utilizam esta função:

void Network::makeDefaultInputs ( )

Inicializa o multimap myDefaultInputs O multimap myDefaultInputs representa as entradas padres no formato Matrix.

Parâmetros
voidNenhum
{
/*cout << "START : makeDefaultInputs" << endl;
Matrix (*MY_DEFAULTS[10]) ( ) = {DEFAULT_0, DEFAULT_1, DEFAULT_2, DEFAULT_3, DEFAULT_4, DEFAULT_5, DEFAULT_6, DEFAULT_7, DEFAULT_8, DEFAULT_9};
multimap<int, Matrix>::iterator it;
for(register int i = 0 ; i < SIZE_DEFAULTS ; i++)
Network::myDefaultInputs.insert( pair<int, Matrix > (i, (*MY_DEFAULTS[i]) () ) );
for(it = myDefaultInputs.begin() ; it != myDefaultInputs.end() ; it++ )
{
for(register int j = 0 ; j < 7 ; j++)
for(register int k = 0 ; k < 5 ; k++)
(*it).second.setNumber(j,k,0);
//(*it).second.printMatrix();
}
*/
}
void Network::makeManuallyNetwork ( vector< double >  defaults)

Inicializa a rede neural myLayers As entradas so repassadas para a primeira camada, seguidamente atribui-se manualmente pesos sinpticos para cada neurnio de cada camada(incluindo camada de entrada) na forma de um vetor Por fim atribui-se manualmente ao vetor de entrada de cada neurnio o valor "zero" seguido de um setter manual para o bias.

Parâmetros
voidNenhum
{
}
void Network::makeNetwork ( vector< double >  defaults,
int  sizeFirstLayer,
int  sizeHiddenLayer,
int  sizeOutputLayer 
)

Inicializa a rede neural myLayers As entradas so repassadas para a primeira camada, seguidamente atribui-se a todos os pesos sinpticos valores aleatrios.

Por fim atribui-se ao vetor de entrada de cada neurnio(no inclui a camada de entrada) o valor "zero" seguido de um setter aleatrio para o bias.

Parâmetros
voidNenhum

inicializando layer da camada de entrada

inicializando layers da camada oculta

inicializando layer da camada de saida

atribuindo vector(defaults) de entradas para cada neurnio da PRIMEIRA CAMADA

atribuindo vector(vazio) de camadas para cada neurnio das demais camadas

inicializando sada esperada para os neurnios da ultima camada

imprimindo rede neural, este proceso necessrio para fins de teste: OBSERVA-SE A ORGANIZAO DA CAMADA DE ENTRADA E PESOS SINPTICOS NO INICIO DO PROCESSO DE APRENDIZADO

atribuindo vector(defaults) de entradas para cada neurnio da PRIMEIRA CAMADA

{
if(ExpectedOutputs.size() == 0)
{
cout << "CRIANDO ESTRUTURA DA REDE NEURAL E PESOS SINPTICOS ALEATRIOS" << endl;
cout << "ATRIBUIINDO A PRIMEIRA ENTRADA DA REDE NEURAL" << endl;
vector <Neuron> firstLayer(sizeFirstLayer);
vector <Neuron> hiddenLayer(20);
vector <Neuron> outputLayer(sizeOutputLayer);
myLayers.push_back( firstLayer );
for(register int i = 0 ; i < sizeHiddenLayer ; i++)
myLayers.push_back( hiddenLayer );
myLayers.push_back( outputLayer );
for(size_t i = 0 ; i < myLayers[0].size() ; i++)
{
myLayers[0][i].setInputs(defaults);
myLayers[0][i].setLoadBias();
}
for(size_t i = 1 ; i < myLayers.size() ; i++)
for(size_t j = 0 ; j < myLayers[i].size() ; j++)
{
myLayers[i][j].setInputs( vector<double> ( myLayers[i-1].size() ,0) );
myLayers[i][j].setLoadBias();
}
//for(size_t i = 0 ; i < myLayers.size() ; i++)
for(size_t i = 0 ; i < 10 ; i++)
ExpectedOutputs.push_back( vector<double>(10) );
//Network::printNeuralNetwork();
}
else
{
cout << "PROXIMA ENTRADA DA REDE" << endl;
for(size_t i = 0 ; i < myLayers[0].size() ; i++)
{
myLayers[0][i].changeInput(defaults);
}
}
}
void Network::printNeuralNetwork ( )

imprimindo toda a rede neural

Referenciado por propagation() e readjustsWeights().

{
cout << endl << endl << "REDE NEURAL" << endl << endl;
for(size_t i = 0 ; i < myLayers.size() ; i++)
{
cout << "LAYER " << i << endl << endl;
for(size_t j = 0 ; j < myLayers[i].size() ; j++)
{
cout << "NEURON " << j << " = " << myLayers[i][j].sigmoidFunction() << endl;
myLayers[i][j].print();
}
cout << endl << endl;
}
}

+ Este é o diagrama das funções que utilizam esta função:

vector< Neuron > Network::propagation ( vector< double >  inputs)

calculando sadas da camada i

repassando sadas da camada i para as entradas da camada i+1

Referências printNeuralNetwork().

Referenciado por startProcess().

{
for(size_t i = 0 ; i < myLayers.size() ; i++)
{
for(size_t j = 0 ; j < myLayers[i].size() ; j++)
{
myLayers[i][j].sumFunction();
//cout << myLayers[i][j].sigmoidFunction() << endl;
}
// bias input
//pair<double, double>
for(size_t j = 0 ; j < myLayers[i].size() ; j++)
{
if( i < myLayers.size()-1 )
{
for(size_t k = 0; k < myLayers[i+1].size() ; k++)
myLayers[i+1][k].addBuffer( myLayers[i][j].sigmoidFunction() );
}
}
if( i < myLayers.size()-1 )
{
for(size_t k = 0; k < myLayers[i+1].size() ; k++)
myLayers[i+1][k].startAssociation();
}
cout << endl;
}
return myLayers[ myLayers.size() - 1 ];
}

+ Grafo de chamadas desta função:

+ Este é o diagrama das funções que utilizam esta função:

void Network::readjustsWeights ( )

reajustando pesos sinpticos

reajustando pesos sinpticos dos baias

reajustando pesos sinpticos para CADA NEURONIO

Referências printNeuralNetwork().

Referenciado por startProcess().

{
for(size_t i = 0 ; i < myLayers.size() ; i++)
{
for(size_t j = 0 ; j < myLayers[i].size() ; j++)
{
myLayers[i][j].setBias( myLayers[i][j].getMyLoadBias() + ( TAXA*1.0*myLayers[i][j].getDelta() ) );
for(size_t k = 0 ; k < myLayers[i].size() ; k++)
{
//cout << myLayers[i][j].getXi(k) << " " << myLayers[i][j].getWi(k) << endl;
myLayers[i][j].changeWeight(k, myLayers[i][j].getWi(k) + ( TAXA*myLayers[i][j].getXi(k)*myLayers[i][j].getDelta() ) );
}
//cout << endl;
//" " << TAXA << " " << myLayers[i][j].getXi(i) << " " << myLayers[i][j].getDelta() << endl ;
//myLayers[i][j].changeWeight(k, myLayers[i][j].getWi(j) + ( TAXA*myLayers[i][j].getXi(j)*myLayers[i][j].getDelta() ) );
//myLayers[i][j].print();
}
}
}

+ Grafo de chamadas desta função:

+ Este é o diagrama das funções que utilizam esta função:

vector< double > Network::startProcess ( vector< double >  inputs)

Inicializa o processo de treinamento para um padro de entrada Recebe um vetor de entrada e retorna um vetor de sada

Parâmetros
vector<double>inputs contendo um vetor de entrada
Retorna
vector<double> outputs contendo um vetor de sada

atribuindo vector(inputs) de entradas para cada neurnio da PRIMEIRA CAMADA

vetor de neurnios da ULTIMA CAMADA

obtendo as respectivas sadas(double [-1,1] ) de cada neurnio da ultima camada

Referências backPropagation(), propagation() e readjustsWeights().

{
vector<double> output;
vector<Neuron> neurons;
for(size_t i = 0 ; i < myLayers[0].size() ; i++)
myLayers[0][i].changeInput(inputs);
this->propagation(inputs);
this->backPropagation();
neurons = myLayers[ myLayers.size()-1 ];
for(size_t i = 0 ; i < neurons.size() ; i++)
output.push_back( neurons[i].sigmoidFunction() );
return output;
}

+ Grafo de chamadas desta função:


A documentação para esta classe foi gerada a partir dos seguintes ficheiros: