Más Crear un blog Acceder

Código Java
Una forma sencilla y rápida de aprender JAVA, observando y deduciendo cómo se comporta el lenguaje a través de ejemplos prácticos.

Archivo del blog

► 2010 (26)
► 2011 (9)
► 2012 (38)
► 2013 (7)
► 2014 (34)
► 2015 (2)
► 2016 (14)
► 2017 (7)
► 2018 (15)
▼ 2019 (6)
► abril (1)
▼ junio (3)
Perceptrón multicapa. Propagación hacia adelante.
Perceptrón multicapa. Propagación hacia atrás.
Perceptrón multicapa. Ajuste pesos.
► julio (1)
► agosto (1)

miércoles, 12 de junio de 2019

Perceptrón multicapa. Propagación hacia atrás.

Descripción:

En base al valor de salida del dataset (D02), se visualiza la base conceptual para el
cálculo de los errores (Exx) de cada neurona (Yxx) de una red neuronal tipo perceptrón
multicapa. Todo ese proceso se le llama propagación hacia atrás.

Nomenclatura:

Y[k][j]: Salida neurona (capa, posición j-enésima)

E[k][j]: Error neurona (δ) (capa, posición j-enésima)
W[k][j][i]: Peso (capa, neurona destino, neurona origen)

Código Java:

package backward;

import java.util.ArrayList;
import java.util.List;

public class Backward{

public static void main(String[] args) {

//sketch: num neuronas

List<Integer> nN = new ArrayList<>();
nN.add(2);
nN.add(3);
nN.add(2);
nN.add(1);

int r = 0; // num. registro del dataset

int nK = nN.size(); // num. de capas = 4
int nE = nN.get(0); // num. de entradas = 2
int nS = nN.get(nK - 1); // num. de salidas = 1
String tmp;

// 1.0:-------------------------------------------------------------------
System.out.println("Backward:\n");
int k = nK - 1;
for (int j = 0; j < nS; j++) {
System.out.format("E[%d][%d] = ( D[%d][%d] - Y[%d][%d] )\n", k, j, r, nE + j,
k, j);
}

// 1.1:-------------------------------------------------------------------
System.out.println("");
for (k = k - 1; k > 0; k--) {
for (int j = nN.get(k); j > 0; j--) {
tmp = "";
for (int i = nN.get(k + 1); i > 0; i--) {
tmp += String.format("( E[%d][%d] * W[%d][%d][%d] ) + ", k + 1, i - 1,
k + 1, i - 1, j - 1);
}
System.out.format("E[%d][%d] = %s%s\n", k, j - 1, tmp, "0 ");
}
System.out.println("");
}

Resultado:

run:
Backward:

E[3][0] = ( D[0][2] - Y[3][0] )

E[2][1] = ( E[3][0] * W[3][0][1] ) + 0

E[2][0] = ( E[3][0] * W[3][0][0] ) + 0

E[1][2] = ( E[2][1] * W[2][1][2] ) + ( E[2][0] * W[2][0][2] ) + 0

E[1][1] = ( E[2][1] * W[2][1][1] ) + ( E[2][0] * W[2][0][1] ) + 0
 E[1][0] = ( E[2][1] * W[2][1][0] ) + ( E[2][0] * W[2][0][0] ) + 0

BUILD SUCCESSFUL (total time: 1 second)

Publicado por censor cosmico

No hay comentarios:

Publicar un comentario

Introduce tu comentario...

Comentar como: ivan.peralta@e

Cerrar sesión

Publicar
P bli Vista
Vi t previa
i Avisarme

Entrada más reciente Página principal Entrada antigua

Suscribirse a: Enviar comentarios (Atom)

Con la tecnología de Blogger.