\begin{frame}[fragile]{Štruktúra nášho projektu}
\begin{verbatim}
.
├── Cargo.toml        # závislosti (burn, clap, npyz, ...)
├── mnist.npz         # dataset
└── src/
    ├── lib.rs        # modul deklarácie
    ├── main.rs       # tréningová slučka, načítanie dát
    └── model.rs      # parametre siete
\end{verbatim}

  \vspace{0.5em}
  Celý projekt --- 3 súbory. Žiadne skripty, žiadny Python glue.
\end{frame}

\begin{frame}[fragile]{Definícia parametrov siete}
\begin{verbatim}
pub struct Parameters<B: Backend> {
    pub w1: Tensor<B, 2>,  // [784, hidden]
    pub b1: Tensor<B, 1>,  // [hidden]
    pub w2: Tensor<B, 2>,  // [hidden, 10]
    pub b2: Tensor<B, 1>,  // [10]
}
\end{verbatim}

  \vspace{0.5em}
  \begin{itemize}
    \item Generický typ \texttt{B: Backend} --- funguje na akomkoľvek backendu
    \item Rozmery tenzorov sú súčasťou typu (\texttt{Tensor<B, 2>})
    \item Kompilátor zachytí chyby v rozmeroch ešte \textbf{pred spustením}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Inicializácia váh}
\begin{verbatim}
let w1 = random_tensor([784, hidden_size],
                        0.1, seed, device);
let b1 = Tensor::zeros([hidden_size], device);
\end{verbatim}

  \vspace{0.5em}
  \begin{itemize}
    \item Váhy: náhodné z $\mathcal{N}(0,\; 0.1)$
    \item Biasy: inicializované na nulu
    \item \texttt{device} určuje, kde žijú dáta (CPU/GPU)
    \item Seed zabezpečuje \textbf{reprodukovateľnosť}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Načítanie MNIST dát}
\begin{verbatim}
fn load_mnist_items(path: &str, examples: usize)
    -> Vec<(Vec<f32>, u8)>
\end{verbatim}

  \vspace{0.5em}
  \begin{itemize}
    \item Otvoríme \texttt{mnist.npz} ako ZIP archív
    \item Načítame obrázky + labely z \texttt{.npy} súborov
    \item Normalizujeme pixely: $[0, 255] \rightarrow [0.0, 1.0]$
    \item Výstup: vektor párov \texttt{(obrázok, číslica)}
  \end{itemize}

  \vspace{0.5em}
  Rustový typový systém garantuje, že dáta majú správny formát.
\end{frame}

\begin{frame}[fragile]{CLI parametre s Clap}
\begin{verbatim}
#[derive(Parser, Debug)]
struct Args {
    #[arg(long, default_value_t = 50)]
    batch_size: usize,
    #[arg(long, default_value_t = 0.1)]
    learning_rate: f64,
    #[arg(long, default_value_t = 10)]
    epochs: usize,
}
\end{verbatim}

  \vspace{0.5em}
  Jeden derive makro --- automatický parsing, help text, validácia.

  \texttt{cargo run -- --epochs 20 --learning-rate 0.01}
\end{frame}

\begin{frame}{Tréningová slučka --- logika}
  Pre každú epochu:
  \begin{enumerate}
    \item Rozdeľ trénovacie dáta na \textbf{mini-batche}
    \item Pre každý batch:
    \begin{itemize}
      \item Forward pass: $\hat{y} = \text{softmax}((\mathbf{x} \cdot W_1 + b_1)_{\text{ReLU}} \cdot W_2 + b_2)$
      \item Spočítaj cross-entropy loss
      \item Backpropagation: gradienty pre $W_1, b_1, W_2, b_2$
      \item Update: $\theta \leftarrow \theta - \eta \cdot \nabla L$
    \end{itemize}
    \item Vyhodnoť presnosť na dev sete
  \end{enumerate}
\end{frame}

\begin{frame}{Burn vs PyTorch --- porovnanie}
  \begin{center}
  \begin{tabular}{lcc}
    \hline
    \textbf{Vlastnosť} & \textbf{PyTorch} & \textbf{Burn} \\
    \hline
    Jazyk            & Python/C++  & Rust \\
    Typová bezpečnosť & runtime     & compile-time \\
    Pamäťová bezpečnosť & GC/manuálna & ownership \\
    Backendy         & CUDA, CPU   & CUDA, CPU, WebGPU \\
    Binárka          & $\sim$GB + Python & $\sim$MB standalone \\
    Nasadenie        & zložité     & jeden binárny súbor \\
    \hline
  \end{tabular}
  \end{center}
\end{frame}

\begin{frame}{Výhoda: Compile-time kontroly}
  V PyTorchi:
  \begin{itemize}
    \item Chyba v rozmeroch $\rightarrow$ \texttt{RuntimeError} po minútach tréningu
    \item Preklep v názve vrstvy $\rightarrow$ tichý bug
  \end{itemize}

  \vspace{0.5em}
  V Burn/Ruste:
  \begin{itemize}
    \item Nesprávne rozmery $\rightarrow$ \textbf{kompilátor to nepustí}
    \item Nepoužitá premenná, chýbajúci branch $\rightarrow$ warning/error
    \item Žiadne \texttt{None} prekvapenia --- \texttt{Option<T>} treba ošetriť
  \end{itemize}

  \vspace{0.5em}
  \textbf{Menej debugovania, viac istoty.}
\end{frame}

\begin{frame}{Výhoda: Nasadenie do produkcie}
  \begin{itemize}
    \item \texttt{cargo build --release} $\rightarrow$ jeden statický binárny súbor
    \item Žiadny Python runtime, žiadne virtuálne prostredia
    \item Možnosť kompilácie do WebAssembly $\rightarrow$ inferencia v prehliadači
    \item Ideálne pre embedded, edge zariadenia, IoT
  \end{itemize}

  \vspace{0.5em}
  \begin{center}
    PyTorch model: Docker kontajner $\sim$2\,GB \\
    Burn model: binárka $\sim$5\,MB
  \end{center}
\end{frame}

\begin{frame}{Výhoda: Fearless concurrency}
  \begin{itemize}
    \item Rustový ownership systém zabraňuje data races \textbf{v compile-time}
    \item Bezpečný multithreading pre data loading, augmentáciu
    \item Parameter \texttt{--threads} v našom projekte
    \item V Pythone: GIL (Global Interpreter Lock) blokuje paralelizmus
  \end{itemize}
\end{frame>

\begin{frame}{Kedy použiť Burn?}
  \textbf{Vhodné:}
  \begin{itemize}
    \item Nasadenie modelov do produkcie
    \item Edge/embedded inferencia
    \item Keď chcete maximálny výkon a bezpečnosť
    \item Keď už poznáte Rust
  \end{itemize}

  \vspace{0.5em}
  \textbf{Nevhodné (zatiaľ):}
  \begin{itemize}
    \item Rýchle prototypovanie --- Python je stále rýchlejší na experimenty
    \item Ekosystém --- PyTorch má tisíce hotových modelov
    \item Burn je stále mladý projekt (aktívny vývoj)
  \end{itemize}
\end{frame}

\begin{frame}{Zhrnutie}
  \begin{itemize}
    \item Neurónové siete = vrstvy neurónov, učenie cez gradienty
    \item \textbf{Burn} prináša deep learning do Rustu
    \item Backend-agnostický, typovo bezpečný, production-ready
    \item Náš projekt: MNIST klasifikátor v 3 súboroch
    \item Rust + Burn = bezpečnosť + výkon + jednoduchosť nasadenia
  \end{itemize}

  \vspace{1em}
  \begin{center}
    \Large Ďakujem za pozornosť!
  \end{center}
\end{frame}