Retropropagação em uma rede de duas camadas

Problema

A retropropagação aplica a regra da cadeia camada por camada, da saída de volta às entradas. A rede tem n entradas, h neurônios ocultos e uma saída, todos com ativação sigmoide (σ(z) = 1 / (1 + e^(-z))):

camada oculta: a_j = σ(inputs · hidden_weights[j] + hidden_biases[j])
saída: y = σ(a · output_weights + output_bias)
perda: L = (y - target)²

Gradientes:

delta_out = 2 × (y - target) × y × (1 - y)
Camada de saída: dL/doutput_weights[j] = delta_out × a_j e dL/doutput_bias = delta_out
delta_j = delta_out × output_weights[j] × a_j × (1 - a_j)
Camada oculta: dL/dhidden_weights[j][i] = delta_j × inputs[i] e dL/dhidden_biases[j] = delta_j

Implemente backprop_gradients(inputs, hidden_weights, hidden_biases, output_weights, output_bias, target).

Saída

Retorne uma matriz com h + 1 linhas:

Linha j (para cada neurônio oculto j, em ordem): os n gradientes de hidden_weights[j] e, depois, o gradiente de hidden_biases[j].
Última linha: os h gradientes de output_weights e, depois, o gradiente de output_bias.

Restrições

1 ≤ n, h ≤ 20

-5 ≤ cada entrada, peso e viés ≤ 5

0 ≤ target ≤ 1

Exemplos

Exemplo 1

Entrada:
inputs = [1.0]
target = 1.0
output_bias = 0.0
hidden_biases = [0.0]
hidden_weights = [
    [0.0]
]
output_weights = [0.0]

Saída esperada:
expected = [
    [0.0, 0.0],
    [-0.125, -0.25]
]

Entrada:
std::vector<double> inputs = {1.0};
double target = 1.0;
double output_bias = 0.0;
std::vector<double> hidden_biases = {0.0};
std::vector<std::vector<double>> hidden_weights = {
    {0.0}
};
std::vector<double> output_weights = {0.0};

Saída esperada:
std::vector<std::vector<double>> expected = {
    {0.0, 0.0},
    {-0.125, -0.25}
};

Entrada:
double[] inputs = new double[] {1.0};
double target = 1.0;
double output_bias = 0.0;
double[] hidden_biases = new double[] {0.0};
double[][] hidden_weights = new double[][] {
    new double[] {0.0}
};
double[] output_weights = new double[] {0.0};

Saída esperada:
double[][] expected = new double[][] {
    new double[] {0.0, 0.0},
    new double[] {-0.125, -0.25}
};

Explicação

a = σ(0) = 0.5 e y = σ(0) = 0.5. delta_out = 2 × (0.5 - 1) × 0.25 = -0.25. Linha de saída: [-0.25 × 0.5, -0.25] = [-0.125, -0.25]. delta_1 = -0.25 × 0 × 0.25 = 0, então a linha oculta é [0, 0]: um peso de saída igual a zero bloqueia o gradiente.

Exemplo 2

Entrada:
inputs = [1.0, 0.0]
target = 0.0
output_bias = -1.0
hidden_biases = [0.0, 0.0]
hidden_weights = [
    [0.0, 1.0],
    [0.0, -1.0]
]
output_weights = [1.0, 1.0]

Saída esperada:
expected = [
    [0.0625, 0.0, 0.0625],
    [0.0625, 0.0, 0.0625],
    [0.125, 0.125, 0.25]
]

Entrada:
std::vector<double> inputs = {1.0, 0.0};
double target = 0.0;
double output_bias = -1.0;
std::vector<double> hidden_biases = {0.0, 0.0};
std::vector<std::vector<double>> hidden_weights = {
    {0.0, 1.0},
    {0.0, -1.0}
};
std::vector<double> output_weights = {1.0, 1.0};

Saída esperada:
std::vector<std::vector<double>> expected = {
    {0.0625, 0.0, 0.0625},
    {0.0625, 0.0, 0.0625},
    {0.125, 0.125, 0.25}
};

Entrada:
double[] inputs = new double[] {1.0, 0.0};
double target = 0.0;
double output_bias = -1.0;
double[] hidden_biases = new double[] {0.0, 0.0};
double[][] hidden_weights = new double[][] {
    new double[] {0.0, 1.0},
    new double[] {0.0, -1.0}
};
double[] output_weights = new double[] {1.0, 1.0};

Saída esperada:
double[][] expected = new double[][] {
    new double[] {0.0625, 0.0, 0.0625},
    new double[] {0.0625, 0.0, 0.0625},
    new double[] {0.125, 0.125, 0.25}
};

Explicação

Os dois valores ocultos são σ(0) = 0.5, então y = σ(0.5 + 0.5 - 1) = 0.5 e delta_out = 2 × 0.5 × 0.25 = 0.25. Linha de saída: [0.125, 0.125, 0.25]. Cada delta_j = 0.25 × 1 × 0.25 = 0.0625, o que dá as linhas ocultas [0.0625, 0, 0.0625] (a segunda entrada é 0).

Como abordar

Tente sozinho primeiro e depois abra uma dica de cada vez.

Dica 1

Trabalhe de trás para frente a partir do neurônio de saída primeiro e depois reutilize esse sinal para calcular a contribuição de cada neurônio oculto.

Dica 2

Você precisa de um delta para a camada de saída e um delta por neurônio oculto, todos baseados em derivadas do sigmoid.

Dica 3

Tenha cuidado para usar o peso de saída do próprio neurônio oculto ao propagar o erro de volta para ele.

Complexidade esperada

tempo O(hn), espaço extra O(hn)

Referências

Este desafio foi adaptado para o CodeUtility. Siga o enunciado e as restrições acima.

O que você vai aprender

Problema

Saída

Restrições

Exemplos

Explicação

Explicação

Como abordar

Referências

Soluções da comunidade