El siguiente es el código de red neuronal de 3 capas más simple implementado en Python:
```pitón
importar numpy como np
# Definir la estructura de la red neuronal.
n_input = 2 #El número de nodos en la capa de entrada
n_hidden = 3 #El número de nodos en la capa oculta
n_output = 1 #Número de nodos en la capa de salida
# Inicializar los pesos de la red neuronal.
pesos = {
'oculto': np.random.uniform(tamaño=(n_input, n_hidden)),
'salida': np.random.uniform(tamaño=(n_hidden, n_output))
}
# Realizar propagación hacia adelante
def propagación_adelante(X):
oculta_capa_entrada = np.dot(X, pesos['oculto'])
salida_capa_oculta = sigmoide (entrada_capa_oculta)
salida_capa_entrada = np.dot(salida_capa_oculta, pesos['salida'])
salida_capa_salida = sigmoide(salida_capa_entrada)
devolver salida_capa_salida
#Definir función de activación (sigmoidea)
def sigmoide(x):
devolver 1 / (1 + np.exp(-x))
# Entrada de muestra
X = np.matriz([[1, 2], [3, 4], [5, 6]])
# Realizar propagación hacia adelante e imprimir salida
salida = propagación_adelante(X)
imprimir (salida)
```
Esta red neuronal simple de 3 capas tiene 2 nodos de entrada, 3 nodos de capa oculta y 1 nodo de salida. Durante la propagación hacia adelante, los datos de entrada pasan a través de los pesos y funciones de activación en la capa oculta, y finalmente se genera un valor predicho. Los pesos en el código anterior se inicializan aleatoriamente y la salida de la capa oculta se obtiene calculando el producto escalar de la entrada y el peso, y luego pasando el resultado a la función de activación (aquí se usa la función sigmoidea). Luego se calcula el producto escalar de la salida de la capa oculta y el peso de la capa de salida, y la salida final se obtiene a través de la función de activación.
El siguiente es el código de red neuronal de 3 capas más simple implementado en lenguaje C:
```c
#incluir <stdio.h>
#incluir <matemáticas.h>
#define N_INPUT 2 //Número de nodos en la capa de entrada
#define N_HIDDEN 3 //Número de nodos en la capa oculta
#define N_OUTPUT 1 // Número de nodos en la capa de salida
// declaración de función
doble sigmoide(doble x);
void forward_propagation(doble entrada[N_INPUT], doble salida_oculta[N_HIDDEN], doble salida[N_OUTPUT]);
int principal() {
//Inicializa los pesos de la red neuronal
pesos dobles_ocultos[N_INPUT][N_HIDDEN] = {
{0,1, 0,4, 0,7},
{0,2, 0,5, 0,8}
};
doble salida_pesos[N_HIDDEN][N_OUTPUT] = {
{0.6},
{0,9},
{0.3}
};
// entrada de muestra
doble entrada[N_INPUT] = {1, 2};
// Realizar propagación hacia adelante e imprimir salida
doble salida_oculta[N_HIDDEN];
doble salida[N_OUTPUT];
forward_propagation(entrada, salida_oculta, salida);
printf("%lf\n", salida[0]);
devolver 0;
}
//Realizar propagación hacia adelante
void forward_propagation(doble entrada[N_INPUT], doble salida_oculta[N_HIDDEN], doble salida[N_OUTPUT]) {
// Calcular la salida de la capa oculta
para (int i = 0; i < N_HIDDEN; i++) {
doble entrada_oculta = 0;
para (int j = 0; j < N_INPUT; j++) {
entrada_oculta += entrada[j] * pesos_hidden[j][i];
}
salida_oculta[i] = sigmoide(entrada_oculta);
}
// Calcular la salida de la capa de salida
para (int i = 0; i < N_SALIDA; i++) {
doble salida_entrada = 0;
para (int j = 0; j < N_HIDDEN; j++) {
entrada_salida += salida_oculta[j] * salida_pesos[j][i];
}
salida[i] = sigmoide(salida_entrada);
}
}
//Definir función de activación (sigmoidea)
doble sigmoide (doble x) {
devolver 1 / (1 + exp(-x));