CNN-MLP: Konvoluční neuronová síť

📚 Teorie: Konvoluční neuronové sítě (CNN)

🔮 Co je konvoluce?

Konvoluce je matematická operace, která "posouvá" malý filtr (kernel) přes vstupní obrázek a v každé pozici počítá skalární součin mezi kernelem a odpovídající oblastí vstupu.

                    Feature[y, x] = Σi,j (Input[y+i, x+j] × Kernel[i, j]) + bias

                

kde i, j ∈ {0, 1, 2} pro 3×3 kernel

Klíčový insight: Stejný kernel se aplikuje na všechny pozice vstupu. To znamená, že síť hledá stejný rys (např. hranu) kdekoli v obrázku. Toto se nazývá sdílení vah (weight sharing).

📐 Same Padding vs Valid

✓ Same Padding (použito zde)

Vstup se obalí nulami (zero padding), takže výstup má stejnou velikost jako vstup.

                        5×5 vstup + padding=1 → 7×7 → konvoluce 3×3 → 5×5 výstup

                    

Valid (bez paddingu)

Kernel se aplikuje pouze tam, kde se celý vejde. Výstup je menší.

                        5×5 vstup → konvoluce 3×3 → 3×3 výstup

                    

Proč same padding? Zachovává prostorovou informaci na okrajích a umožňuje hlubší sítě bez rychlého zmenšování feature map.

🔮×4 Více kernelů = více rysů

Jeden kernel detekuje jeden typ rysu (např. horizontální hranu). Pro rozpoznání složitých vzorů potřebujeme více kernelů, každý hledající jiný rys.

Kernel 1

horizontální hrany

Kernel 2

vertikální hrany

Kernel 3

diagonály

Kernel 4

rohy/textury

                    4 kernely × 5×5 feature map = 100 hodnot → MLP (100→16→10)

                

📦 Flatten: Z 2D map do 1D vektoru

Flatten je klíčový krok mezi konvoluční a plně propojenou (Dense) vrstvou. Převádí 2D mapy rysů na 1D vektor, který může zpracovat MLP.

4× Feature Map (5×5)

5×5

→

Flatten

100 hodnot

→

MLP vstup

...

100 neuronů

💡 Klíčový insight: Těch 100 hodnot je přesně to samé, jako kdyby MLP v mlp-builder měl vstupní vrstvu o 100 neuronech. Flatten jen "rozbalí" 2D mapy do 1D řady.

⏱️ Výpočetní náročnost

Konvoluce je náročnější než jednoduché násobení matic v MLP. Pro každou pozici feature mapy počítáme 9 násobení (3×3 kernel). V této malé síti to v prohlížeči běží rychle, ale ve větších sítích (např. s obrázky 224×224) se používají GPU pro paralelní výpočty.

⚡ Backpropagation pro kernely

Kernely se učí pomocí backpropagation. Gradient pro každou váhu kernelu se počítá jako součet gradientů ze všech pozic, kde byl kernel aplikován.

1. Gradient feature mapy (z MLP):

                    δ_feature[y,x] = Σj (δ_hidden[j] × W_hidden[y×width+x, j])

                

2. Gradient kernelu (akumulace přes všechny pozice):

                    ∂Loss/∂Kernel[i,j] = Σy,x (δ_feature[y,x] × Input[y+i, x+j])

                

3. Aktualizace váhy:

                    Kernel[i,j] -= learning_rate × ∂Loss/∂Kernel[i,j]

                

Důležité: Protože kernel je sdílený přes všechny pozice, jeho gradient je součtem gradientů ze všech těchto pozic.

📊 Aktivační funkce

ReLU (Konvoluční vrstva)

                        f(x) = max(0, x)

                    

Nuluje záporné hodnoty. Rychlá, efektivní, standard v CNN.

Sigmoid (MLP vrstvy)

                        σ(x) = 1 / (1 + e-x)

                    

Výstup v rozmezí (0, 1). Používáno pro pravděpodobnosti.

💻 Implementační průvodce

1. Konvoluce (forward pass)

function convolve(input, kernel, padding) {

    const padded = zeroPad(input, padding);  // Obal vstup nulami

    const output = [];

    

    for (let y = 0; y < outputHeight; y++) {

        for (let x = 0; x < outputWidth; x++) {

            let sum = 0;

            for (let ky = 0; ky < 3; ky++) {

                for (let kx = 0; kx < 3; kx++) {

                    sum += padded[y+ky][x+kx] * kernel[ky*3 + kx];

                }

            }

            output.push(relu(sum + bias));  // Aktivace

        }

    }

    return output;

}

2. Backpropagation pro kernel

function backpropKernel(featureGradients, paddedInput) {

    const kernelGradients = new Array(9).fill(0);

    

    for (let y = 0; y < featureHeight; y++) {

        for (let x = 0; x < featureWidth; x++) {

            const delta = featureGradients[y * width + x];

            for (let ky = 0; ky < 3; ky++) {

                for (let kx = 0; kx < 3; kx++) {

                    kernelGradients[ky*3 + kx] += delta * paddedInput[y+ky][x+kx];

                }

            }

        }

    }

    

    // Aktualizace vah

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

        kernel[i] -= learningRate * kernelGradients[i];

    }

}

3. Flatten (spojení feature map → MLP)

// 4 kernely × 5×5 feature map = 100 hodnot

const flattenedInput = [];

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

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

        flattenedInput.push(featureMaps[k][i]);

    }

}

// flattenedInput má nyní 100 prvků → vstup do MLP

🎯 Shrnutí klíčových konceptů

Sdílení vah

Stejný kernel = stejné rysy všude

Translační invariance

Vzor rozpoznán nezávisle na pozici

Feature extraction

CNN automaticky učí užitečné rysy

Hierarchie rysů

Hrany → tvary → objekty

🔮 CNN-MLP: Konvoluční síť

🎯 Problém pozice a jeho řešení

⚙️ Konfigurace

🔗 CNN → MLP Pipeline

📈 Výstup (Pravděpodobnosti)

Tréninková data