Embed Size (px)
DESCRIPTION
documento que estudia el comportamiento de las redes neuronales
Citation preview
[
][Escriba aquí una descripción breve del documento. Una descripción breve es un resumen corto del contenido del documento. Escriba aquí una descripción breve del documento. Una descripción breve es un resumen corto del contenido del documento.]
UNIVERSIDAD POLITECNICA DE PACHUCA
RAUL CORTES ESAU VILLANUEVAGABRIEL MENDOZA
INTRODUCCION
Aunque las computadoras son sistemas digitales que trabajan en 1 y 0, nuestras mentes funcionan a un bit de diferencia. Como los científicos han explorado el funcionamiento de los cerebros humanos, encontraron que consisten en una red de neuronas que se comunican con cada una a través de señales eléctricas y químicas, y así forman nuestros pensamientos. Estas neuronas se encienden basándose en la fuerza o en la debilidad de las señales que pasan por ellas.
Una red Neural es simulada en una computadora creando los nodos cargados que se interconectan el uno al otro con diversas capas: la capa de la entrada, algunas capas ocultas, y una capa de la salida. Una señal pasa a un nodo de entrada en la capa de la entrada y luego es multiplicada por los pesos en todas las conexiones a los nodos en la capa siguiente y sumada para formar un valor de la activación.
En la “Propagación hacia Atrás”, una red neural es entrenada comparando el valor final que ocurre en la salida de la red, al valor deseado de la salida y que alimenta el error a través de la red.
Este error se usa para ajustar los pesos en los nodos de los nervios, si se envía el respaldo del error con los nodos para muchas iteraciones esperanzadamente los pesos convergerán eventualmente a los valores que darán la salida real de la red.
A continuación se describe brevemente brevemente el algoritmo de entrenamiento y activación de una red neuronal.
1.-Se demuestra la función sigmoidea debajo de la cual acerca a 1 para los valores grandes de x; y a 0 para los valores muy pequeños de x. Esto tras todas las activaciones a una aproximación no linear de la neurona:
sigmoid (x) =
1
1 + e-x
Lhidden = sigmoid ( Linput * [Weightsinput-hidden])
2.- El paso siguiente en la activación delantera es computar las activaciones de la capa de la salida de la capa ocultada (en el paso1) y la matriz sináptica del peso que tiende un puente sobre la capa ocultada a la capa de la salida. Entonces nosotros finalmente tenemos que aplicar el sigmoideo a la matriz del producto que resulta.
Loutput (o los valores de la capa de la salida) contiene los resultados de alimentar nuestra entrada inicial en la red Neural.
Loutput = sigmoid ( Lhidden * [Weightshidden-output])
3.- Una vez que hayamos calculado las activaciones para nuestras neuronas, necesitamos calcular el error que resulta entre la salida real y la salida deseada. Este error se retroactúa a través de la red de los nervios y se utiliza para ajustar los para pesos adaptarse a un modelo más exacto de nuestros datos. El primer paso es computar el error de la capa de la salida:
El primer paso para proponer una red neuronal es determinar el comportamiento dinamico de nuestro sistema.
Para que la red neuronal pueda hacer la identificación de un sistema es necesario seguir los siguientes pasos.
El procedimiento que se llevo a cabo para la realización del control por modelo inverso es el siguiente:
Identificación de la planta.
Identificación del modelo inverso.
Simular el modelo de control directo.
Implementar el controlador.
Analizar los resultados en tiempo real.
Eoutput = Loutput * (1- Loutput ) * (Loutput - Ldesired
4.- Ahora alimentamos este error en la capa ocultada para computar el error ocultado de la capa:
Ehidden = Lhidden * (1 - Lhidden ) * [Weightshidden-output ] * Eoutput
5.- Necesitamos después ajustar la matriz del peso entre el capa ocultada y la capa de la salida para adaptar nuestra red y compensar el error. Para ajustar los pesos agregaremos dos factores constantes a nuestro algoritmo. El primer factor es una tarifa que aprende (LR), cuál ajusta cuánto afecta el error computado del cambio del peso en un solo ciclo a través de la red neural. El segundo factor es un factor del ímpetu (frecuencia intermedia) usado conjuntamente con el cambio anterior del peso para afectar el cambio final en el ciclo actual a través de la red. El ímpetu puede ayudar a menudo a una red a entrenar un poco más rápido.
[Weightshidden-output ] = [Weightshidden-output ] + D[Weightshidden-output
]
Donde:
D[Weightshidden-output ] = (LR) * Lhidden * Eoutput + (MF) * D[Weightshidden-output
(previous)]
6.- Finalmente necesitamos ajustar los pesos para que haya la capa de la entrada de la misma manera:
[Weightsinput-hidden] =[Weightsinput-hidden] + D[Weightsinput-hidden]
Donde:
D[Weightsinput-hidden] = (LR) * Linput * Ehidden + (MF) * D[Weightsinput-
hidden(previous)]
Después de que se ajusten los pesos, los pasos 1 a 6 se repiten para el sistema siguiente de entrada y de valores deseados de la salida. El sistema entero de datos se va de una vez, y repetimos el algoritmo para todos los datos otra vez. Este proceso continúa hasta que converge la red o hasta que elegimos detener la iteración de los datos.
Se presenta el código en “c” del entrenamiento y activación de la red neuronal:
Entrenar a la Red
public void TrainNetwork(double[,] inputlist, double[,] outputlist, int iterations)
{
// Arreglos que contienen las entradas y Salidas
inputsToNetwork = new double[this.i];
desiredOutputs = new double[this.o];
int outputlistSampleLength = outputlist.GetUpperBound(0) + 1;
int outputlistLength = outputlist.GetUpperBound(1) + 1;
int inputlistLength = inputlist.GetUpperBound(1) + 1;
for (int i = 0; i < iterations; i++)
{
for (int sampleindex = 0; sampleindex < outputlistSampleLength; sampleindex++)
{
for (int j = 0; j < inputlistLength; j++)
{
inputsToNetwork[j] = inputlist[sampleindex, j];
}
for (int k = 0; k < outputlistLength; k++)
{
desiredOutputs[k] = outputlist[sampleindex, k];
}
// Entrenar para el siguiente set de E/S
Training_for_one_pattern();
}
}
}
public void Training_for_one_pattern(){ // Calcula la Activación para todas las Capas (pasos 1 y 2) Calc_Activation();
// Calcula el error en la capa de salida (paso 3) Calc_error_output();
// Calcula el error en la capa de ocultación (paso 4) Calc_error_hidden();
// Calcula nuevos pesos in la capa oculta ajustando con el error de la capa de salida (paso 5) Calc_new_weights_in_hidden();
// Calcula nuevos pesos en la capa de entrada ajustando con el error de la c. oculta (paso 6) Calc_new_weights_in_input();}
private void Calc_Activation()
{
// Iteración entre el conjunto de activaciones en la capa oculta.
int ch=0;
while(ch<this.h)
{
for(int ci=0 ; ci<this.i ; ci++)
hidden[ch].Activation += inputsToNetwork[ci] * input[ci].weights[ch];
ch++;
}
// calcular la salida de la capa oculta
for(int x=0 ; x<this.h ; x++)
{
hidden[x].Activation = sigmoid(hidden[x].Activation );
}
// Iteración entre el conjunto de activaciones en la capa de salida.
int co=0;
while(co<this.o)
{
for(int chi=0 ; chi<this.h ; chi++)
output[co].Activation += hidden[chi].Activation * hidden[chi].weights[co];
co++;
}
// Calcular la salida de la capa de Salida
for(int x=0 ; x<this.o ; x++)
{
output[x].Activation = sigmoid(output[x].Activation );
}
}
El código acontinuacion es el de la simulación en MATLAB del entrenamiento y activación de nuestra red neuronal.
net = newff([ 0 1; 0 1;0 1;0 1], [4 1],{'logsig','logsig','logsig','logsig'}) input = [1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0; 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0; 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0; 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0]; output= sim(net,input); target= [0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0];% plot(target,'o')% hold on% plot(output,'+r') net = train(net,input,target) output= sim(net,input) plot(target,'o') hold on plot(output,'+r')
resultado del entrenamiento de la red 1
forma del entrenamiento 1
estado del entranamiento 1estado del entrenamiento 1
En la siguiente imagen se presenta el resultado del etranamiento del codigo previamente mostrado (código c), en el software de visual basic.
