🧠 MLP Builder

Jednoduchý perceptron má pouze vstupní a výstupní vrstvu. Chybu můžeme přímo připsat každé váze – kolik přispěla k chybě, tolik ji upravíme.

Vícevrstvá síť (MLP) má problém: Jak zjistit, kolik k chybě přispěla váha ve skryté vrstvě?

Klíčový rozdíl: Perceptron = přímá úprava vah. MLP = chyba se "rozloží" mezi všechny vrstvy pomocí gradientu.

Kolik skrytých vrstev?

• 1 vrstva – stačí pro většinu běžných úloh
• 2+ vrstvy – složitější vzory, hlubší abstrakce
• Více vrstev = těžší trénink (mizící gradient)

Kolik neuronů ve skryté vrstvě?

Sigmoid "zmáčkne" jakýkoliv vstup do rozsahu (0, 1):

Proč je důležitá pro backpropagation?

• Je diferencovatelná – můžeme počítat gradient
• Derivace: σ'(x) = σ(x) × (1 - σ(x))
• Umožňuje "jemné" úpravy vah

💡 Srovnej s perceptronem, který používal skokovou funkci (0 nebo 1).

Learning Rate (η) – jak velké kroky děláme:

• Příliš malá → učení trvá věčnost
• Příliš velká → přeskakujeme optimum, síť diverguje
• Typicky: 0.01 – 0.3

Momentum (α) – "setrvačnost" učení:

Vzorec: Δw = η × δ × input + α × Δwpředchozí

1. Normalizujte vstupy – hodnoty v rozsahu 0-1 fungují nejlépe
2. Inicializujte váhy náhodně – malé hodnoty kolem nuly
3. Míchejte tréninková data – zabraňuje uvíznutí v lokálních minimech
4. Sledujte chybovou křivku – měla by klesat
5. Validujte na nových datech – testujte na vzorech, které síť neviděla

XOR (exkluzivní OR) není lineárně separabilní – nemůžete nakreslit jednu přímku, která oddělí 0 od 1.

Vyzkoušej v simulátoru nahoře! Načti XOR data a sleduj, jak síť najde řešení.

1. Třída neuronové sítě

class NeuralNetwork {

    constructor(inputSize, hiddenSize, outputSize) {

        this.inputSize = inputSize;

        this.hiddenSize = hiddenSize;

        this.outputSize = outputSize;

        

        // Inicializace vah (náhodné malé hodnoty)

        // +1 pro bias v každé vrstvě

        this.weightsIH = this.randomMatrix(inputSize + 1, hiddenSize, 0.5);

        this.weightsHO = this.randomMatrix(hiddenSize + 1, outputSize, 0.5);

        

        // Hodnoty aktivací

        this.hiddenValues = new Array(hiddenSize).fill(0);

        this.outputValues = new Array(outputSize).fill(0);

    }

    

    randomMatrix(rows, cols, range) {

        return Array.from({ length: rows }, () =>

            Array.from({ length: cols }, () => 

                (Math.random() - 0.5) * 2 * range

            )

        );

    }

    

    sigmoid(x) { return 1 / (1 + Math.exp(-x)); }

    sigmoidDerivative(y) { return y * (1 - y); }

}

2. Forward Pass (dopředný průchod)

forward(inputs) {

    this.inputValues = [...inputs];

    

    // Skrytá vrstva

    for (let j = 0; j < this.hiddenSize; j++) {

        let sum = this.weightsIH[this.inputSize][j]; // Bias

        for (let i = 0; i < this.inputSize; i++) {

            sum += inputs[i] * this.weightsIH[i][j];

        }

        this.hiddenValues[j] = this.sigmoid(sum);

    }

    

    // Výstupní vrstva

    for (let k = 0; k < this.outputSize; k++) {

        let sum = this.weightsHO[this.hiddenSize][k]; // Bias

        for (let j = 0; j < this.hiddenSize; j++) {

            sum += this.hiddenValues[j] * this.weightsHO[j][k];

        }

        this.outputValues[k] = this.sigmoid(sum);

    }

    

    return this.outputValues;

}

3. Backpropagation (zpětná propagace)

backward(targets, learningRate, momentum = 0.1) {

    // 1. Výpočet chyby výstupní vrstvy

    const outputDeltas = [];

    for (let k = 0; k < this.outputSize; k++) {

        const error = targets[k] - this.outputValues[k];

        outputDeltas[k] = error * this.sigmoidDerivative(this.outputValues[k]);

    }

    

    // 2. Výpočet chyby skryté vrstvy (backprop)

    const hiddenDeltas = [];

    for (let j = 0; j < this.hiddenSize; j++) {

        let error = 0;

        for (let k = 0; k < this.outputSize; k++) {

            error += this.weightsHO[j][k] * outputDeltas[k];

        }

        hiddenDeltas[j] = error * this.sigmoidDerivative(this.hiddenValues[j]);

    }

    

    // 3. Aktualizace vah Hidden→Output

    for (let j = 0; j <= this.hiddenSize; j++) {

        for (let k = 0; k < this.outputSize; k++) {

            const input = j < this.hiddenSize ? this.hiddenValues[j] : 1;

            const change = learningRate * outputDeltas[k] * input;

            this.weightsHO[j][k] += change + momentum * this.deltaHO[j][k];

            this.deltaHO[j][k] = change;

        }

    }

    

    // 4. Aktualizace vah Input→Hidden (podobně)

    for (let i = 0; i <= this.inputSize; i++) {

        for (let j = 0; j < this.hiddenSize; j++) {

            const input = i < this.inputSize ? this.inputValues[i] : 1;

            const change = learningRate * hiddenDeltas[j] * input;

            this.weightsIH[i][j] += change + momentum * this.deltaIH[i][j];

            this.deltaIH[i][j] = change;

        }

    }

}

4. Tréninková smyčka

function trainEpoch(network, trainingData, learningRate) {

    // Zamíchat data (důležité!)

    const shuffled = [...trainingData].sort(() => Math.random() - 0.5);

    

    for (const pattern of shuffled) {

        network.forward(pattern.inputs);

        network.backward(pattern.outputs, learningRate);

    }

    

    // Spočítat celkovou chybu

    let totalError = 0;

    for (const pattern of trainingData) {

        network.forward(pattern.inputs);

        totalError += calculateMSE(network.outputValues, pattern.outputs);

    }

    

    return totalError / trainingData.length;

}



function calculateMSE(outputs, targets) {

    let error = 0;

    for (let i = 0; i < outputs.length; i++) {

        error += Math.pow(targets[i] - outputs[i], 2);

    }

    return error / outputs.length;

}



// Trénink

let epoch = 0;

while (totalError > 0.01 && epoch < 10000) {

    totalError = trainEpoch(network, trainingData, 0.2);

    epoch++;

}