Aprendizaje supervisado

Como el nombre sugiere, supervised learningse lleva a cabo bajo la supervisión de un maestro. Este proceso de aprendizaje es dependiente. Durante el entrenamiento de ANN bajo aprendizaje supervisado, el vector de entrada se presenta a la red, que producirá un vector de salida. Este vector de salida se compara con el vector de salida deseado / objetivo. Se genera una señal de error si hay una diferencia entre la salida real y el vector de salida deseado / objetivo. Sobre la base de esta señal de error, los pesos se ajustarían hasta que la salida real coincida con la salida deseada.

Perceptrón

Desarrollado por Frank Rosenblatt utilizando el modelo de McCulloch y Pitts, el perceptrón es la unidad operativa básica de las redes neuronales artificiales. Emplea una regla de aprendizaje supervisado y puede clasificar los datos en dos clases.

Características operativas del perceptrón: Consiste en una sola neurona con un número arbitrario de entradas junto con pesos ajustables, pero la salida de la neurona es 1 o 0 dependiendo del umbral. También consta de un sesgo cuyo peso es siempre 1. La siguiente figura proporciona una representación esquemática del perceptrón.

Por tanto, el perceptrón tiene los siguientes tres elementos básicos:

• Links - Tendría un conjunto de enlaces de conexión, que tiene un peso que incluye un sesgo que siempre tiene un peso 1.

• Adder - Agrega la entrada después de multiplicarlos con sus respectivos pesos.

• Activation function- Limita la salida de neurona. La función de activación más básica es una función escalonada Heaviside que tiene dos salidas posibles. Esta función devuelve 1, si la entrada es positiva y 0 para cualquier entrada negativa.

Algoritmo de entrenamiento

La red Perceptron se puede entrenar para una sola unidad de salida, así como para múltiples unidades de salida.

Algoritmo de entrenamiento para unidad de salida única

Step 1 - Inicialice lo siguiente para iniciar el entrenamiento -

• Weights
• Bias
• Tasa de aprendizaje $ \ alpha $

Para facilitar el cálculo y la simplicidad, los pesos y el sesgo deben establecerse en 0 y la tasa de aprendizaje debe establecerse en 1.

Step 2 - Continúe con el paso 3-8 cuando la condición de parada no sea verdadera.

Step 3 - Continúe con el paso 4-6 para cada vector de entrenamiento x.

Step 4 - Active cada unidad de entrada de la siguiente manera -

$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: a \: n) $$

Step 5 - Ahora obtenga la entrada neta con la siguiente relación -

$$ y_ {in} \: = \: b \: + \: \ displaystyle \ sum \ limits_ {i} ^ n x_ {i}. \: w_ {i} $$

aquí ‘b’ es sesgo y ‘n’ es el número total de neuronas de entrada.

Step 6 - Aplicar la siguiente función de activación para obtener el resultado final.

$$ f (y_ {in}) \: = \: \ begin {cases} 1 & if \: y_ {in} \:> \: \ theta \\ 0 & if \: - \ theta \: \ leqslant \ : y_ {in} \: \ leqslant \: \ theta \\ - 1 & if \: y_ {in} \: <\: - \ theta \ end {cases} $$

Step 7 - Ajuste el peso y el sesgo de la siguiente manera -

Case 1 - si y ≠ t luego,

$$ w_ {i} (nuevo) \: = \: w_ {i} (antiguo) \: + \: \ alpha \: tx_ {i} $$

$$ b (nuevo) \: = \: b (antiguo) \: + \: \ alpha t $$

Case 2 - si y = t luego,

$$ w_ {i} (nuevo) \: = \: w_ {i} (antiguo) $$

$$ b (nuevo) \: = \: b (antiguo) $$

aquí ‘y’ es la salida real y ‘t’ es la salida deseada / objetivo.

Step 8 - Pruebe la condición de parada, que ocurriría cuando no hay cambio de peso.

Algoritmo de entrenamiento para múltiples unidades de salida

El siguiente diagrama es la arquitectura de perceptron para múltiples clases de salida.

Step 1 - Inicialice lo siguiente para iniciar el entrenamiento -

• Weights
• Bias
• Tasa de aprendizaje $ \ alpha $

Para facilitar el cálculo y la simplicidad, los pesos y el sesgo deben establecerse en 0 y la tasa de aprendizaje debe establecerse en 1.

Step 2 - Continúe con el paso 3-8 cuando la condición de parada no sea verdadera.

Step 3 - Continúe con el paso 4-6 para cada vector de entrenamiento x.

Step 4 - Active cada unidad de entrada de la siguiente manera -

$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: a \: n) $$

Step 5 - Obtenga la entrada neta con la siguiente relación -

$$ y_ {in} \: = \: b \: + \: \ displaystyle \ sum \ limits_ {i} ^ n x_ {i} \: w_ {ij} $$

aquí ‘b’ es sesgo y ‘n’ es el número total de neuronas de entrada.

Step 6 - Aplicar la siguiente función de activación para obtener la salida final para cada unidad de salida j = 1 to m -

$$ f (y_ {in}) \: = \: \ begin {cases} 1 & if \: y_ {inj} \:> \: \ theta \\ 0 & if \: - \ theta \: \ leqslant \ : y_ {inj} \: \ leqslant \: \ theta \\ - 1 & if \: y_ {inj} \: <\: - \ theta \ end {cases} $$

Step 7 - Ajuste el peso y el sesgo para x = 1 to n y j = 1 to m como sigue -

Case 1 - si y_j ≠ t_j luego,

$$ w_ {ij} (nuevo) \: = \: w_ {ij} (antiguo) \: + \: \ alpha \: t_ {j} x_ {i} $$

$$ b_ {j} (nuevo) \: = \: b_ {j} (antiguo) \: + \: \ alpha t_ {j} $$

Case 2 - si y_j = t_j luego,

$$ w_ {ij} (nuevo) \: = \: w_ {ij} (antiguo) $$

$$ b_ {j} (nuevo) \: = \: b_ {j} (antiguo) $$

aquí ‘y’ es la salida real y ‘t’ es la salida deseada / objetivo.

Step 8 - Pruebe la condición de parada, que sucederá cuando no haya cambios en el peso.

Neurona lineal adaptativa (Adaline)

Adaline, que significa Adaptive Linear Neuron, es una red que tiene una sola unidad lineal. Fue desarrollado por Widrow y Hoff en 1960. Algunos puntos importantes sobre Adaline son los siguientes:

• Utiliza la función de activación bipolar.

• Utiliza la regla delta para el entrenamiento para minimizar el error cuadrático medio (MSE) entre la salida real y la salida deseada / objetivo.

• Los pesos y el sesgo son ajustables.

Arquitectura

La estructura básica de Adaline es similar a la del perceptrón que tiene un circuito de retroalimentación adicional con la ayuda del cual la salida real se compara con la salida deseada / objetivo. Después de la comparación sobre la base del algoritmo de entrenamiento, se actualizarán los pesos y el sesgo.

Algoritmo de entrenamiento

Step 1 - Inicialice lo siguiente para iniciar el entrenamiento -

• Weights
• Bias
• Tasa de aprendizaje $ \ alpha $

Para facilitar el cálculo y la simplicidad, los pesos y el sesgo deben establecerse en 0 y la tasa de aprendizaje debe establecerse en 1.

Step 2 - Continúe con el paso 3-8 cuando la condición de parada no sea verdadera.

Step 3 - Continúe con el paso 4-6 para cada par de entrenamiento bipolar s:t.

Step 4 - Active cada unidad de entrada de la siguiente manera -

$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: a \: n) $$

Step 5 - Obtenga la entrada neta con la siguiente relación -

$$ y_ {in} \: = \: b \: + \: \ displaystyle \ sum \ limits_ {i} ^ n x_ {i} \: w_ {i} $$

aquí ‘b’ es sesgo y ‘n’ es el número total de neuronas de entrada.

Step 6 - Aplicar la siguiente función de activación para obtener el resultado final -

$$ f (y_ {in}) \: = \: \ begin {cases} 1 & if \: y_ {in} \: \ geqslant \: 0 \\ - 1 & if \: y_ {in} \: < \: 0 \ end {cases} $$

Step 7 - Ajuste el peso y el sesgo de la siguiente manera -

Case 1 - si y ≠ t luego,

$$ w_ {i} (nuevo) \: = \: w_ {i} (antiguo) \: + \: \ alpha (t \: - \: y_ {in}) x_ {i} $$

$$ b (nuevo) \: = \: b (antiguo) \: + \: \ alpha (t \: - \: y_ {in}) $$

Case 2 - si y = t luego,

$$ w_ {i} (nuevo) \: = \: w_ {i} (antiguo) $$

$$ b (nuevo) \: = \: b (antiguo) $$

aquí ‘y’ es la salida real y ‘t’ es la salida deseada / objetivo.

$ (t \: - \; y_ {in}) $ es el error calculado.

Step 8 - Pruebe la condición de parada, que sucederá cuando no haya cambio de peso o cuando el cambio de peso más alto ocurrido durante el entrenamiento sea menor que la tolerancia especificada.

Neurona lineal adaptativa múltiple (Madaline)

Madaline, que significa Multiple Adaptive Linear Neuron, es una red que consta de muchas Adalines en paralelo. Tendrá una sola unidad de salida. Algunos puntos importantes sobre Madaline son los siguientes:

• Es como un perceptrón multicapa, donde Adaline actuará como una unidad oculta entre la entrada y la capa Madaline.

• Los pesos y el sesgo entre la entrada y las capas Adaline, como vemos en la arquitectura Adaline, son ajustables.

• Las capas Adaline y Madaline tienen pesos fijos y sesgo de 1.

• El entrenamiento se puede realizar con la ayuda de la regla Delta.

Arquitectura

La arquitectura de Madaline consiste en “n” neuronas de la capa de entrada, “m”neuronas de la capa Adaline y 1 neurona de la capa Madaline. La capa Adaline puede considerarse como la capa oculta, ya que está entre la capa de entrada y la capa de salida, es decir, la capa Madaline.

Algoritmo de entrenamiento

Ahora sabemos que solo se deben ajustar los pesos y el sesgo entre la entrada y la capa Adaline, y los pesos y el sesgo entre la capa Adaline y Madaline son fijos.

Step 1 - Inicialice lo siguiente para iniciar el entrenamiento -

• Weights
• Bias
• Tasa de aprendizaje $ \ alpha $

Para facilitar el cálculo y la simplicidad, los pesos y el sesgo deben establecerse en 0 y la tasa de aprendizaje debe establecerse en 1.

Step 2 - Continúe con el paso 3-8 cuando la condición de parada no sea verdadera.

Step 3 - Continúe con el paso 4-6 para cada par de entrenamiento bipolar s:t.

Step 4 - Active cada unidad de entrada de la siguiente manera -

$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: a \: n) $$

Step 5 - Obtenga la entrada neta en cada capa oculta, es decir, la capa Adaline con la siguiente relación -

$$ Q_ {inj} \: = \: b_ {j} \: + \: \ Displaystyle \ sum \ limits_ {i} ^ n x_ {i} \: w_ {ij} \: \: \: j \: = \: 1 \: a \: m $$

aquí ‘b’ es sesgo y ‘n’ es el número total de neuronas de entrada.

Step 6 - Aplicar la siguiente función de activación para obtener el resultado final en la capa Adaline y Madaline -

$$ f (x) \: = \: \ begin {cases} 1 & if \: x \: \ geqslant \: 0 \\ - 1 & if \: x \: <\: 0 \ end {cases} $ PS

Salida en la unidad oculta (Adaline)

$$ Q_ {j} \: = \: f (Q_ {inj}) $$

Salida final de la red

$$ y \: = \: f (y_ {in}) $$

i.e. $ \: \: y_ {inj} \: = \: b_ {0} \: + \: \ sum_ {j = 1} ^ m \: Q_ {j} \: v_ {j} $

Step 7 - Calcule el error y ajuste los pesos de la siguiente manera -

Case 1 - si y ≠ t y t = 1 luego,

$$ w_ {ij} (nuevo) \: = \: w_ {ij} (antiguo) \: + \: \ alpha (1 \: - \: Q_ {inj}) x_ {i} $$

$$ b_ {j} (nuevo) \: = \: b_ {j} (antiguo) \: + \: \ alpha (1 \: - \: Q_ {inj}) $$

En este caso, los pesos se actualizarían en Q_j donde la entrada neta es cercana a 0 porque t = 1.

Case 2 - si y ≠ t y t = -1 luego,

$$ w_ {ik} (nuevo) \: = \: w_ {ik} (antiguo) \: + \: \ alpha (-1 \: - \: Q_ {ink}) x_ {i} $$

$$ b_ {k} (nuevo) \: = \: b_ {k} (antiguo) \: + \: \ alpha (-1 \: - \: Q_ {ink}) $$

En este caso, los pesos se actualizarían en Q_k donde la entrada neta es positiva porque t = -1.

aquí ‘y’ es la salida real y ‘t’ es la salida deseada / objetivo.

Case 3 - si y = t luego

No habría cambios en los pesos.

Step 8 - Pruebe la condición de parada, que sucederá cuando no haya cambio de peso o cuando el cambio de peso más alto ocurrido durante el entrenamiento sea menor que la tolerancia especificada.

Redes neuronales de propagación trasera

Back Propagation Neural (BPN) es una red neuronal multicapa que consta de la capa de entrada, al menos una capa oculta y la capa de salida. Como sugiere su nombre, la retropropagación tendrá lugar en esta red. El error que se calcula en la capa de salida, comparando la salida de destino y la salida real, se propagará hacia la capa de entrada.

Arquitectura

Como se muestra en el diagrama, la arquitectura de BPN tiene tres capas interconectadas que tienen pesos sobre ellas. Tanto la capa oculta como la capa de salida también tienen sesgo, cuyo peso es siempre 1, sobre ellas. Como se desprende del diagrama, el funcionamiento de BPN se realiza en dos fases. Una fase envía la señal desde la capa de entrada a la capa de salida, y la otra fase propaga el error desde la capa de salida a la capa de entrada.

Algoritmo de entrenamiento

Para el entrenamiento, BPN utilizará la función de activación sigmoidea binaria. El entrenamiento de BPN tendrá las siguientes tres fases.

• Phase 1 - Fase de avance

• Phase 2 - Propagación de error hacia atrás

• Phase 3 - Actualización de pesos

Todos estos pasos se concluirán en el algoritmo de la siguiente manera

Step 1 - Inicialice lo siguiente para iniciar el entrenamiento -

• Weights
• Tasa de aprendizaje $ \ alpha $

Para facilitar el cálculo y la simplicidad, tome algunos valores aleatorios pequeños.

Step 2 - Continúe con el paso 3-11 cuando la condición de parada no sea verdadera.

Step 3 - Continúe con los pasos 4-10 para cada par de entrenamiento.

Fase 1

Step 4 - Cada unidad de entrada recibe una señal de entrada x_i y lo envía a la unidad oculta para todos i = 1 to n

Step 5 - Calcule la entrada neta en la unidad oculta usando la siguiente relación -

$$ Q_ {inj} \: = \: b_ {0j} \: + \: \ sum_ {i = 1} ^ n x_ {i} v_ {ij} \: \: \: \: j \: = \ : 1 \: a \: p $$

aquí b_0j es el sesgo en la unidad oculta, v_ij es el peso sobre j unidad de la capa oculta procedente de i unidad de la capa de entrada.

Ahora calcule la salida neta aplicando la siguiente función de activación

$$ Q_ {j} \: = \: f (Q_ {inj}) $$

Envíe estas señales de salida de las unidades de la capa oculta a las unidades de la capa de salida.

Step 6 - Calcule la entrada neta en la unidad de la capa de salida usando la siguiente relación -

$$ y_ {ink} \: = \: b_ {0k} \: + \: \ sum_ {j = 1} ^ p \: Q_ {j} \: w_ {jk} \: \: k \: = \ : 1 \: a \: m $$

aquí b_0k ⁡Es el sesgo en la unidad de salida, w_jk es el peso sobre k unidad de la capa de salida procedente de j unidad de la capa oculta.

Calcule la producción neta aplicando la siguiente función de activación

$$ y_ {k} \: = \: f (y_ {tinta}) $$

Fase 2

Step 7 - Calcule el término de corrección de errores, en correspondencia con el patrón objetivo recibido en cada unidad de salida, como sigue -

$$ \ delta_ {k} \: = \ :( t_ {k} \: - \: y_ {k}) f ^ {'} (y_ {ink}) $$

Sobre esta base, actualice el peso y el sesgo de la siguiente manera:

$$ \ Delta v_ {jk} \: = \: \ alpha \ delta_ {k} \: Q_ {ij} $$

$$ \ Delta b_ {0k} \: = \: \ alpha \ delta_ {k} $$

Luego, envía $ \ delta_ {k} $ de vuelta a la capa oculta.

Step 8 - Ahora cada unidad oculta será la suma de sus entradas delta de las unidades de salida.

$$ \ delta_ {inj} \: = \: \ Displaystyle \ sum \ limits_ {k = 1} ^ m \ delta_ {k} \: w_ {jk} $$

El término de error se puede calcular de la siguiente manera:

$$ \ delta_ {j} \: = \: \ delta_ {inj} f ^ {'} (Q_ {inj}) $$

Sobre esta base, actualice el peso y el sesgo de la siguiente manera:

$$ \ Delta w_ {ij} \: = \: \ alpha \ delta_ {j} x_ {i} $$

$$ \ Delta b_ {0j} \: = \: \ alpha \ delta_ {j} $$

Fase 3

Step 9 - Cada unidad de salida (y_kk = 1 to m) actualiza el peso y el sesgo de la siguiente manera:

$$ v_ {jk} (nuevo) \: = \: v_ {jk} (antiguo) \: + \: \ Delta v_ {jk} $$

$$ b_ {0k} (nuevo) \: = \: b_ {0k} (antiguo) \: + \: \ Delta b_ {0k} $$

Step 10 - Cada unidad de salida (z_jj = 1 to p) actualiza el peso y el sesgo de la siguiente manera:

$$ w_ {ij} (nuevo) \: = \: w_ {ij} (antiguo) \: + \: \ Delta w_ {ij} $$

$$ b_ {0j} (nuevo) \: = \: b_ {0j} (antiguo) \: + \: \ Delta b_ {0j} $$

Step 11 - Compruebe la condición de parada, que puede ser el número de épocas alcanzadas o la salida objetivo coincide con la salida real.

Regla de aprendizaje delta generalizada

La regla delta funciona solo para la capa de salida. Por otro lado, la regla delta generalizada, también llamada comoback-propagation regla, es una forma de crear los valores deseados de la capa oculta.

Formulación matemática

Para la función de activación $ y_ {k} \: = \: f (y_ {ink}) $ la derivación de la entrada neta en la capa oculta y en la capa de salida puede estar dada por

$$ y_ {tinta} \: = \: \ estilo de visualización \ sum \ límites_i \: z_ {i} w_ {jk} $$

Y $ \: \: y_ {inj} \: = \: \ sum_i x_ {i} v_ {ij} $

Ahora el error que debe minimizarse es

$$ E \: = \: \ frac {1} {2} \ Displaystyle \ sum \ limits_ {k} \: [t_ {k} \: - \: y_ {k}] ^ 2 $$

Al usar la regla de la cadena, tenemos

$$ \ frac {\ parcial E} {\ parcial w_ {jk}} \: = \: \ frac {\ parcial} {\ parcial w_ {jk}} (\ frac {1} {2} \ Displaystyle \ sum \ límites_ {k} \: [t_ {k} \: - \: y_ {k}] ^ 2) $$

$$ = \: \ frac {\ parcial} {\ parcial w_ {jk}} \ lgrupo \ frac {1} {2} [t_ {k} \: - \: t (y_ {tinta})] ^ 2 \ rgroup $$

$$ = \: - [t_ {k} \: - \: y_ {k}] \ frac {\ parcial} {\ parcial w_ {jk}} f (y_ {tinta}) $$

$$ = \: - [t_ {k} \: - \: y_ {k}] f (y_ {tinta}) \ frac {\ parcial} {\ parcial w_ {jk}} (y_ {tinta}) $$

$$ = \: - [t_ {k} \: - \: y_ {k}] f ^ {'} (y_ {ink}) z_ {j} $$

Ahora digamos $ \ delta_ {k} \: = \: - [t_ {k} \: - \: y_ {k}] f ^ {'} (y_ {ink}) $

Los pesos de las conexiones a la unidad oculta z_j puede ser dado por -

$$ \ frac {\ parcial E} {\ parcial v_ {ij}} \: = \: - \ estilo de visualización \ suma \ límites_ {k} \ delta_ {k} \ frac {\ parcial} {\ parcial v_ {ij} } \ :( y_ {ink}) $$

Poniendo el valor de $ y_ {ink} $ obtendremos lo siguiente

$$ \ delta_ {j} \: = \: - \ Displaystyle \ sum \ limits_ {k} \ delta_ {k} w_ {jk} f ^ {'} (z_ {inj}) $$

La actualización de peso se puede realizar de la siguiente manera:

Para la unidad de salida -

$$ \ Delta w_ {jk} \: = \: - \ alpha \ frac {\ parcial E} {\ parcial w_ {jk}} $$

$$ = \: \ alpha \: \ delta_ {k} \: z_ {j} $$

Para la unidad oculta -

$$ \ Delta v_ {ij} \: = \: - \ alpha \ frac {\ parcial E} {\ parcial v_ {ij}} $$

$$ = \: \ alpha \: \ delta_ {j} \: x_ {i} $$