🎨 MLP Grayscale

🔢 Kontinuální vs Binární vstup

V binární síti je pixel buď zapnutý (1) nebo vypnutý (0). V kontinuální síti pixel vyjadřuje intenzitu – hodnotu mezi 0 a 1.

Příklad: 0.7 = „poměrně jasný pixel" – síť tuto nuanci zpracuje.

📊 Neuron měří, nerozhoduje

V binární síti výstupní neuron říká ANO/NE. V kontinuální síti říká „jak moc" – míru přesvědčení.

Výstup 0.73 pro číslici „7" = síť si je 73% jistá.

⚖️ Softmax – pravděpodobnostní výstup

Softmax převede surové výstupy neuronů na pravděpodobnosti. Součet všech výstupů je vždy 100%.

Síť „rozděluje svou jistotu" mezi všechny možnosti.

📉 Loss ≠ Přesnost

Loss (chyba) měří, jak daleko jsou predikce od reality. Přesnost měří, kolik odpovědí je správných.

Síť může mít nízkou chybu, ale stále dělat špatná rozhodnutí (a naopak).

🎭 I špatná odpověď má strukturu

Když síť odpoví špatně, její „nejistota" ukazuje, co ji zmátlo. Např. záměna 8 a 0 – oba mají podobný tvar.

Tato informace je cenná pro ladění a pochopení sítě.

🌈 Cesta k férovosti (Fairness)

Kontinuální výstupy otevírají otázky o férovosti. Jak síť rozděluje svou „jistotu"? Je pro všechny skupiny stejně sebevědomá?

Toto je základ pro pochopení biasu v AI.

⚠️ Problém pozice – limit MLP sítí

MLP síť se učí přesnou pozici každého pixelu. Pokud nakreslíš „7" o pixel doleva, síť ji nemusí poznat – pro ni je to úplně jiný vzor.

💡 Řešení? Konvoluční neuronové sítě (CNN) – hledají vzory kdekoli v obrázku.

function sigmoid(x) {

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

}



function sigmoidDerivative(y) {

    // y je již výstup sigmoidu!

    return y * (1 - y);

}

function forward(inputs) {

    // Skrytá vrstva

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

        let sum = biasHidden[j];

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

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

        }

        hiddenValues[j] = sigmoid(sum);

    }

    

    // Výstupní vrstva

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

        let sum = biasOutput[k];

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

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

        }

        outputValues[k] = sigmoid(sum);

    }

    return outputValues;

}

function backward(targets, learningRate) {

    // Výstupní chyby

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

        outputDeltas[k] = (targets[k] - outputValues[k]) 

                        * sigmoidDerivative(outputValues[k]);

    }

    

    // Skryté chyby (backprop)

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

        let error = 0;

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

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

        }

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

    }

    

    // Aktualizace vah

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

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

            weightsHO[j][k] += learningRate * outputDeltas[k] * hiddenValues[j];

        }

    }

    // ... podobně pro weightsIH

}