Problema
El descenso de gradiente mejora los pesos poco a poco moviéndose en contra del gradiente:
w ← w - learning_rate × dL/dw
Entrena una neurona sigmoide con descenso de gradiente estocástico. En cada época, recorre los ejemplos en el orden dado y, para cada ejemplo:
- z = sample · weights + bias, y = 1 / (1 + e^(-z))
- delta = 2 × (y - target) × y × (1 - y)
- weights[i] ← weights[i] - learning_rate × delta × sample[i] (para cada i), y después bias ← bias - learning_rate × delta
Implementa train_neuron(samples, targets, weights, bias, learning_rate, epochs).
Entrada
samples: m ejemplos de entrenamiento, cada uno con n valores.
targets: Las m salidas correctas (entre 0 y 1).
weights, bias: Los pesos iniciales (n valores) y el sesgo.
learning_rate, epochs: El tamaño del paso y cuántas pasadas sobre los datos.
Salida
Devuelve los pesos entrenados seguidos del sesgo entrenado (n + 1 números).
Restricciones
1 ≤ m ≤ 50, 1 ≤ n ≤ 10, 1 ≤ epochs ≤ 1000
0 < learning_rate ≤ 5
-5 ≤ cada valor ≤ 5
Ejemplos
Entrada:
bias = 0.0
epochs = 1
samples = [
[1.0]
]
targets = [1.0]
weights = [0.0]
learning_rate = 1.0
Salida esperada:
expected = [0.25, 0.25]Entrada:
double bias = 0.0;
long long epochs = 1;
std::vector<std::vector<double>> samples = {
{1.0}
};
std::vector<double> targets = {1.0};
std::vector<double> weights = {0.0};
double learning_rate = 1.0;
Salida esperada:
std::vector<double> expected = {0.25, 0.25};Entrada:
double bias = 0.0;
long epochs = 1;
double[][] samples = new double[][] {
new double[] {1.0}
};
double[] targets = new double[] {1.0};
double[] weights = new double[] {0.0};
double learning_rate = 1.0;
Salida esperada:
double[] expected = new double[] {0.25, 0.25};Explicación
y = σ(0) = 0.5, delta = 2 × (0.5 - 1) × 0.25 = -0.25. Peso: 0 - 1 × (-0.25) × 1 = 0.25. Sesgo: 0 - 1 × (-0.25) = 0.25. Resultado: [0.25, 0.25].
Entrada:
bias = 0.0
epochs = 500
samples = [
[0.0, 0.0],
[0.0, 1.0],
[1.0, 0.0],
[1.0, 1.0]
]
targets = [0.0, 0.0, 0.0, 1.0]
weights = [0.0, 0.0]
learning_rate = 2.0
Salida esperada:
expected = [6.346558, 6.339863, -9.592092]Entrada:
double bias = 0.0;
long long epochs = 500;
std::vector<std::vector<double>> samples = {
{0.0, 0.0},
{0.0, 1.0},
{1.0, 0.0},
{1.0, 1.0}
};
std::vector<double> targets = {0.0, 0.0, 0.0, 1.0};
std::vector<double> weights = {0.0, 0.0};
double learning_rate = 2.0;
Salida esperada:
std::vector<double> expected = {6.346558, 6.339863, -9.592092};Entrada:
double bias = 0.0;
long epochs = 500;
double[][] samples = new double[][] {
new double[] {0.0, 0.0},
new double[] {0.0, 1.0},
new double[] {1.0, 0.0},
new double[] {1.0, 1.0}
};
double[] targets = new double[] {0.0, 0.0, 0.0, 1.0};
double[] weights = new double[] {0.0, 0.0};
double learning_rate = 2.0;
Salida esperada:
double[] expected = new double[] {6.346558, 6.339863, -9.592092};Explicación
Esta es la puerta lógica AND. Tras 500 épocas, ambos pesos son grandes y positivos y el sesgo es muy negativo, así que solo la entrada [1, 1] da una salida mayor que 0.5.
Cómo abordarlo
Inténtalo primero por tu cuenta y luego abre las pistas una a una.
Pista 1
Procesa las muestras de entrenamiento en orden para cada época, actualizando los pesos inmediatamente después de cada ejemplo.
Pista 2
Para cada muestra, calcula la salida sigmoid y luego usa su gradiente para mover pesos y sesgo cuesta abajo.
Pista 3
Como las actualizaciones son online, las muestras posteriores dentro de la misma época ven las actualizaciones anteriores.
Complejidad esperada
tiempo O(epochs × m × n), espacio extra O(1)
Referencias
Este reto está adaptado para CodeUtility. Sigue el enunciado y las restricciones indicadas arriba.