Deep Learning

Kenali posisi deep learning di dalam peta kecerdasan buatan dan cara jaringan berlapis mengubah data mentah menjadi fitur yang berguna.

Bandingkan deep learning dan machine learning klasik dari sisi fitur, data, komputasi, hingga interpretabilitas.

Telusuri siklus training neural network dari forward pass, loss, backward pass, hingga pembaruan bobot dengan neuron NumPy yang dilatih dari nol.

Jelajahi penerapan deep learning pada visi komputer, bahasa, suara, reinforcement learning, kedokteran, dan sistem rekomendasi.

Timbang kelebihan dan keterbatasan deep learning dari sisi data, komputasi, dan interpretabilitas sebelum memilihnya untuk masalah Anda.

Petakan ekosistem deep learning mulai dari framework utama, pustaka pendukung, hingga perangkat komputasi dan layanan daring.

Pahami vektor, matriks, dot product, dan norma sebagai bahasa dasar yang dipakai neural network untuk menyimpan dan mengolah data.

Pahami turunan, gradien, dan aturan rantai sebagai dasar bagaimana neural network memperbaiki bobotnya melalui gradient descent.

Pahami distribusi probabilitas, softmax, ekspektasi, dan maximum likelihood sebagai bahasa untuk menafsirkan keluaran model deep learning.

Pahami siklus machine learning, perbedaan supervised dan unsupervised, train/test split, serta overfitting melalui contoh klasifikasi digit yang diuji nyata.

Kuasai normalisasi fitur, one-hot encoding, dan pemilihan dtype agar data siap diolah model deep learning tanpa jebakan skala dan presisi.

Pahami rank, shape, dan empat keluarga operasi tensor — elementwise, reduksi, reshape, transpose — yang menjadi kosa kata harian deep learning.

Pasang Python dari sumber resmi, verifikasi versi interpreter, dan pastikan pip siap dipakai untuk memasang paket deep learning.

Pelajari cara mengisolasi paket setiap proyek dengan venv: membuat, mengaktifkan, memasang paket, dan membekukan daftar dependensi.

Kenali Jupyter Notebook sebagai antarmuka interaktif eksperimen deep learning, dari struktur berkas .ipynb hingga kernel dan magic command.

Pasang PyTorch versi CPU dari index resmi, lalu verifikasi instalasi lewat versi paket dan operasi tensor dasar.

Pasang TensorFlow 2.21 beserta Keras 3, lalu verifikasi instalasi dengan melatih model Sequential mini pada data garis sederhana.

Pahami tumpukan driver, CUDA, dan cuDNN di balik GPU, lalu periksa ketersediaan GPU dari PyTorch dan TensorFlow dengan pola kode yang tetap berjalan di CPU.

Kelola dependensi proyek secara terkendali: membekukan versi ke requirements.txt, mendeklarasikan proyek di pyproject.toml, dan memakai uv sebagai alternatif modern.

Pelajari cara membuat array NumPy, membaca atribut shape dan dtype, serta membandingkan kecepatan ndarray dengan list Python.

Pahami aturan broadcasting NumPy, ganti perulangan Python dengan operasi vectorized, dan ukur sendiri selisih kecepatannya.

Bedakan perkalian matriks dari perkalian elemen, kenapa matmul menjadi inti forward pass, dan cara memakai operasi aljabar linear NumPy.

Gunakan DataFrame pandas untuk membaca tabel, menyaring baris, meringkas dengan groupby, dan menyiapkan array NumPy untuk model.

Gunakan object-oriented API matplotlib untuk membuat line, bar, histogram, dan scatter, lalu simpan grafik sebagai berkas PNG.

Pahami batasan angka titik mengambang, menangani NaN dan inf, serta menstabilkan softmax agar perhitungan model tetap dapat dipercaya.

Pahami unit komputasi terkecil neural network: dari analogi neuron biologis menuju rumus weighted sum, bias, dan fungsi aktivasi yang diimplementasikan dengan NumPy.

Implementasikan aturan pembelajaran perceptron dengan NumPy, buktikan keterbatasan linearnya pada XOR, dan kenali latar sejarah yang memicu era multilayer network.

Susun neuron menjadi jaringan berlapis dengan matriks bobot per layer, lalu buktikan dengan NumPy bahwa MLP 2-2-1 mampu menyelesaikan XOR yang tak mampu diselesaikan perceptron.

Kenali step, sigmoid, tanh, ReLU, Leaky ReLU, dan softmax beserta rumus, rentang, dan kegunaannya — semuanya diimplementasikan dan diplot dengan NumPy murni.

Rakit alur prediksi lengkap neural network dua layer dengan NumPy: batch data mengalir dari input, melewati hidden layer dan aktivasi, hingga keluar sebagai prediksi dengan bentuk matriks yang diperiksa tiap tahap.

Pahami mean squared error untuk regresi serta binary dan categorical cross-entropy untuk klasifikasi, lengkap dengan implementasi manual NumPy yang cocok dengan hitungan tangan.

Pelajari bagaimana aturan rantai dijalankan mundur dari loss ke setiap bobot, dibuktikan pada satu layer dua input dengan verifikasi beda hingga.

Jalankan aturan pembaruan w = w - lr x gradien dengan NumPy murni: lihat loss turun monoton pada regresi linear, pahami pengaruh learning rate, dan bandingkan varian batch, mini-batch, dan stochastic.

Representasikan neural network sebagai graf operasi, lalu bangun mesin autograd mini yang menjalankan forward dan backward pass secara otomatis pada graf kecil.

Rangkai seluruh konsep section menjadi MLP utuh dari nol dengan NumPy: kelas dengan init, forward, backward, dan step, dilatih pada make_moons hingga akurasi di atas 0.9.

Pahami tensor sebagai generalisasi skalar, vektor, dan matriks, kenali wadah data deep learning berbentuk 3D dan 4D, lalu bandingkan torch.Tensor dengan ndarray NumPy.

Baca shape tensor dengan dim, numel, dan size, lalu kuasai reshape, view, permute, transpose, squeeze, dan unsqueeze beserta efeknya terhadap bentuk tensor.

Ambil elemen, baris, sub-blok, dan nilai terpilih dari tensor lewat indexing, slicing, boolean mask, gather, dan index_select, plus jebakan memori antara view dan salinan.

Kuasai empat keluarga operasi tensor PyTorch — elementwise, reduksi dengan dim dan keepdim, matmul 2D hingga batch 3D, serta penggabungan cat dan stack.

Terapkan aturan broadcasting PyTorch untuk normalisasi batch gambar per channel, bedah pesan galat bentuk tidak cocok, dan pilih antara expand dan repeat.

Pahami cara autograd merekam graph operasi lalu menghitung gradien dengan backward, verifikasi hasilnya terhadap finite difference, dan kendalikan graph dengan no_grad serta detach.

Tulis kode device-agnostic dengan torch.device dan .to(device), pahami kapan GPU mengungguli CPU, dan baca benchmark matmul nyata pada CPU mesin uji.

Hitung konsumsi memori tensor dengan element_size dan numel, proses batch besar lewat chunk, pakai operasi in-place, dan terapkan kebiasaan hemat memori di CPU maupun GPU.

Telusuri sejarah PyTorch dari Torch hingga PyTorch Foundation, pahami filosofi Pythonic eager execution yang membedakannya dari TensorFlow, kenali ekosistemnya, lalu jalankan operasi tensor pertama yang terverifikasi.

Kuasai tensor dalam alur kerja nyata: lima cara membuatnya, memilih dtype dan device, serta bolak-balik antara NumPy dan torch lengkap dengan jebakan memori bersamanya.

Pakai autograd dalam siklus pelatihan nyata: zero_grad, forward, loss, backward, step — lengkap dengan tiga jebakan klasik: gradien menumpuk, backward ganda, dan backward pada tensor non-skalar.

Rapikan parameter ke dalam kelas nn.Module dengan __init__ dan forward, baca struktur serta jumlah parameternya, susun model cepat dengan nn.Sequential, dan bedakan mode train() dari eval().

Pasangkan model dengan fungsi loss yang tepat — MSELoss, BCEWithLogitsLoss yang stabil, CrossEntropyLoss yang menuntut raw logits — lalu geser parameternya dengan SGD dan Adam dalam training mini yang benar-benar turun loss-nya.

Bungkus data menjadi class Dataset custom dengan __getitem__ dan __len__, lalu sajikan batch tensor melalui DataLoader dengan batch_size, shuffle, dan generator yang terkendali.

Rangkai model, loss, optimizer, dan DataLoader menjadi cetakan training loop lengkap dengan validasi tiap epoch, model.train()/eval(), dan torch.no_grad() — pola yang dipakai hampir semua proyek PyTorch.

Ukur performa model dengan benar: mode eval dan torch.no_grad, evaluasi batch-wise vs seluruh dataset, lalu akurasi, F1, confusion matrix, dan classification_report dari scikit-learn.

Simpan dan muat model PyTorch dengan benar: state_dict versus seluruh objek model, mode aman weights_only, pola checkpoint berisi epoch-loss-optimizer, serta resume training yang terverifikasi identik.

Kunci seluruh sumber ketidakpastian — seed torch, NumPy, random, generator DataLoader — hingga dua eksekusi dengan seed sama menghasilkan loss yang identik, dan catat versi environment agar hasil bisa diulang orang lain.

Kenali sejarah TensorFlow dari Google Brain, posisi Keras 3 sebagai API tingkat tinggi resmi, ekosistem pendukungnya, dan perbandingan filosofinya dengan PyTorch melalui operasi tensor pertama yang diuji nyata.

Bandingkan tf.constant dan tf.Variable, pahami dtype dan shape, jalankan operasi add, matmul, dan reduce_mean dengan sumbu tertentu, serta lintasi jembatan TensorFlow-NumPy pada angka kecil yang diuji nyata.

Pahami tf.GradientTape sebagai perekam operasi untuk menghitung gradien, gunakan persistent tape dan watch, lalu latih satu parameter regresi linear dengan GradientTape dan assign_sub yang diverifikasi terhadap beda hingga dan solusi analitik.

Susun model dengan Sequential API dan Functional API, baca model.summary(), pahami pembuatan bobot lewat build dan input_shape, hitung jumlah parameter tiap layer Dense, dan jalankan forward pass pertama.

Kenali fungsi loss Keras — MeanSquaredError, BinaryCrossentropy, SparseCategoricalCrossentropy — beserta arti from_logits, pilih optimizer SGD, RMSprop, atau Adam, lalu satukan semuanya lewat model.compile dan model.fit pada 200 sampel data sintetis.

Alirkan data lewat tf.data: from_tensor_slices, map untuk transformasi, shuffle, batch, dan prefetch — dirangkai jadi pipeline lengkap pada 200 sampel sintetis, lengkap dengan peringatan buffer_size dan perbandingan terhadap DataLoader PyTorch.

Latih model dengan model.fit(): atur epochs dan batch_size, pantau data validasi lewat validation_split atau validation_data, baca riwayat pelatihan dari objek History, dan kendalikan jalannya lewat callback EarlyStopping serta ModelCheckpoint pada dua konfigurasi yang diuji nyata.

Keluar dari model.fit() dan tulis training loop sendiri dengan tf.GradientTape: forward pass di dalam tape, tape.gradient pada model.trainable_variables, optimizer.apply_gradients, pembedaan langkah latih dan evaluasi, plus tabel padanan API terhadap training loop PyTorch.

Nilai model terlatih dengan model.evaluate dan model.predict, bedah classification_report dan confusion matrix untuk tiga kelas, lalu geser ambang keputusan pada kasus biner dan amati precision serta recall bergerak berlawanan arah.

Simpan dan muat model Keras: format modern .keras lewat model.save dan load_model, bobot saja lewat save_weights, verifikasi prediksi identik dengan np.testing, pola transfer bobot ke arsitektur yang dibangun ulang, serta peta format .keras, .weights.h5, dan SavedModel.

Rangkai siklus penyiapan dataset dari data mentah menjadi tensor siap dilatih — diagnosis nilai hilang, pembersihan duplikat, pemetaan label string, hingga batching dengan DataLoader.

Bagi dataset menjadi tiga subset dengan peran berbeda — training memindahkan bobot, validasi memandu keputusan, testing memberi angka final — memakai stratified split dua tahap dengan train_test_split.

Samakan skala fitur dengan MinMaxScaler dan StandardScaler — kalibrasi hanya pada data latih — lalu buktikan lewat eksperimen gradient descent bahwa standardisasi mempercepat konvergensi dan mencegah divergensi.

Pahami perbedaan batch, iterasi, dan epoch beserta trade-off ukuran batch — gradien lebih halus lawan pembaruan lebih sering — dibuktikan dengan training make_moons pada batch 8, 32, dan 128.

Kendalikan panjang langkah pembaruan parameter — learning rate — melalui eksperimen sweep 0.001, 0.1, dan 10 yang memperlihatkan lintasan loss lambat, sehat, dan berayun, plus panduan diagnosis gejala.

Pakai torch.optim.SGD dengan momentum — akumulasi kecepatan yang mempercepat gradien konsisten dan meredam gradien goyah — dibuktikan dengan perlombaan SGD polos melawan SGD momentum 0.9.

Pahami Adam — learning rate adaptif per parameter lewat momen pertama dan kedua dengan koreksi bias — lalu adu melawan SGD pada kondisi sama dan intip langkah efektif tiap koordinat di optimizer.state.

Telusuri evolusi keluarga optimizer dari SGD+momentum, AdaGrad, RMSProp, Adam, hingga AdamW: ide inti tiap generasi, rumus intuitifnya, dan trade-off kecepatan adaptif melawan generalisasi.

Atur learning rate sepanjang training dengan StepLR, CosineAnnealingLR, dan OneCycleLR — termasuk posisi benar scheduler.step() setelah optimizer.step() dan akibat yang diam bila pemanggilan itu terlewat.

Batasi gradien yang membengkak dengan clip_grad_norm_ dan clip_grad_value_ — bedah perbedaan norma L2 global dari pemotongan per elemen, lalu lihat clip_grad_norm_ menyelamatkan training saat batch bermasalah masuk.

Pahami mengapa bobot awal nol merusak arsitektur karena simetri, lalu pilih Xavier untuk tanh/sigmoid dan Kaiming untuk ReLU — dibuktikan lewat variansi aktivasi delapan layer yang diukur nyata.

Bedah BatchNorm1d dari dalam: statistik per channel per batch, parameter learnable gamma dan beta, perbedaan mode train dan eval yang memakai running stats, serta efek stabilnya pada training dengan learning rate besar.

Normalisasi per sampel per layer yang tidak bergantung pada batch: hitungan manual LayerNorm yang cocok bit demi bit dengan nn.LayerNorm, bukti bebas ketergantungan batch, dan tabel perbandingan lengkap dengan BatchNorm.

Pangkas memori dan percepat training dengan float16 dan bfloat16: anatomi tiga tingkat presisi, autocast di jalur CPU dengan bfloat16, konsep loss scaling lewat GradScaler, serta batas jujur hasil CPU dibanding GPU.

Definisikan overfitting dan underfitting secara presisi lewat gap metrik latih-validasi, kenali kurva karakteristiknya, lalu ukur keduanya secara nyata dengan tiga MLP berkapasitas berbeda pada 100 sampel make_moons.

Uraikan galat prediksi menjadi bias, variance, dan noise lewat dekomposisi klasik, lihat trade-offnya pada regresi polinomial derajat 1, 3, dan 15, lalu estimasi variance secara empiris dengan 40 ulangan pengacakan data latih.

Pahami mekanisme inverted dropout lewat nn.Dropout — neuron dimatikan acak selama latih dan diskalakan 1/(1-p), lalu buktikan efeknya pada gap latih-validasi dua MLP berbobot awal identik dengan dan tanpa dropout.

Pahami penalti L2 yang menarik bobot menuju nol, buktikan kesetaraannya dengan weight_decay pada SGD, lalu bandingkan weight decay 0, 0.01, dan 0.1 pada AdamW — optimizer yang memisahkan decay dari penskalaan adaptif gradien.

Hentikan pelatihan saat loss validasi berhenti membaik: pantau val loss dengan patience, simpan dan pulihkan bobot terbaik — kerangka manual PyTorch dan callbacks.EarlyStopping Keras yang sama-sama diuji nyata.

Perluas data latih tanpa mengumpulkan satu sampel pun lewat transformasi label-preserving — flip, geser, dan noise gaussian — yang diimplementasikan dengan NumPy murni dan diuji nyata: 12 sampel diperluas menjadi 60, akurasi test naik dari 0.792 ke 1.000, sementara validasi dan test tetap bersih tanpa augmentasi.

Pakai ulang representasi dari model pretrained untuk tugas baru berdata kecil: pahami dua strategi feature extraction dan fine-tuning, bekukan layer dengan requires_grad=False, lalu lihat demo buatan tanpa unduhan — head baru di atas body beku mencapai validasi 0.95 pada epoch 4, sementara model dari nol berhenti di 0.908 setelah 20 epoch.

Buka kembali layer beku dengan learning rate kecil: pelajari urutan benar freeze-latih head-unfreeze-poles, differential learning rate lewat param group optimizer, dan demo teruji nyata yang menunjukkan lr body 0.005 menaikkan validasi ke 0.920 sementara lr 5.0 menurunkannya ke 0.815 dengan pergeseran bobot 200x lebih besar.

Sintesis penutup section: definisi generalisasi sebagai performa pada data baru, peta seluruh alat dari dropout hingga fine-tuning beserta kapan dipakainya, pengukuran dengan k-fold cross validation teruji nyata lewat cross_val_score, dan posisi test set sebagai hakim final yang dipakai sekali.

Bongkar jebakan akurasi pada kelas tak seimbang, kuasai presisi, recall, dan F1 beserta trade-off ambang keputusannya, lalu pilih strategi rata-rata macro, micro, atau weighted yang sesuai tujuan model.

Kuasai MAE, MSE, RMSE, dan R-kuadrat lewat perhitungan manual yang diverifikasi scikit-learn, saksikan bagaimana satu pencilan menggeser tiap metrik dengan porsi berbeda, lalu pahami hubungan loss pelatihan dengan metrik evaluasi.

Baca confusion matrix dengan benar — baris aktual, kolom prediksi — verifikasi orientasinya lewat contoh tangan, bedah satu kelas menjadi TP/FP/FN/TN, lalu normalisasi per baris dan temukan pasangan kelas yang paling sering tertukar.

Rekam loss latih dan validasi setiap epoch, kenali empat pola kurva — sehat, underfit, overfit, dan learning rate terlalu besar — lalu ubah diagnosis menjadi tindakan perbaikan yang terarah.

Bangun kebiasaan praktisi: kumpulkan prediksi salah, kelompokkan polanya, ukur statistik fiturnya, lalu rumuskan hipotesis dan tindakan — semuanya pada model digits nyata yang keliru.

Pantau norm gradien per layer, baca histogram gradien, tangani kasus gradien None, dan verifikasi kebenaran turunan dengan gradient check beda hingga — semua pada contoh yang diuji nyata.

Lihat secara kuantitatif mengapa jaringan 15 layer sigmoid kehilangan gradien di layer awal (rasio 8e-14) sementara ReLU + Kaiming bertahan, mengapa gradien RNN membengkak 1.5^t, dan obat apa yang tersedia untuk keduanya.

Catat setiap eksperimen dengan pola manual dict config, nama run, dan log JSON — lalu bandingkan tiga konfigurasi dari log yang dibaca ulang — sebelum mengenal MLflow, Weights & Biases, dan TensorBoard.

Naikkan reproducibility tiga tingkat — seed, rekaman config dan hash dataset, environment lock — dengan fungsi run_experiment(seed) yang menghasilkan dua run identik dan rekaman JSON yang bisa dibaca ulang.

Pahami mengapa fully connected layer tidak cocok untuk gambar, lalu lihat tiga ide kunci convolution: koneksi lokal, weight sharing, dan hierarki fitur visual.

Lihat gambar sebagai tensor (H, W, C): channel, rentang nilai 0-255 vs 0-1, perbedaan urutan dimensi NCHW dan NHWC, serta patch lokal sebagai unit kerja convolution.

Bedah operasi konvolusi 2D langkah demi langkah dengan implementasi NumPy murni: jendela geser, perkalian, penjumlahan, bias, rumus ukuran keluaran, lalu verifikasi angka dengan torch F.conv2d.

Lihat kernel sebagai detektor pola: kernel tepi, blur, dan sharpen klasik diterapkan pada citra digits, lalu pahami mengapa CNN modern membiarkan bobot kernel dipelajari dari data alih-alih dirancang manual.

Kendalikan pergerakan jendela convolution dengan stride, jaga ukuran spasial dengan padding, dan perluas jangkauan dengan dilation — lengkap dengan tabel ukuran keluaran hasil uji nyata dan verifikasi rumusnya.

Pahami max pooling dan average pooling sebagai downsampling tanpa parameter, rumus ukuran keluarannya, invariance kecil terhadap pergeseran, dan global average pooling pada arsitektur modern.

Bongkar isi channel keluaran CNN: satu filter menghasilkan satu feature map, banyak filter membangun hierarki fitur visual dari tepi hingga objek, dan receptive field tumbuh tiap layer yang ditumpuk.

Rangkai seluruh komponen menjadi arsitektur CNN utuh: blok konvolusi berulang dengan channel naik dan spatial turun, ditutup classifier head fully connected, lalu latih CNN mini lengkap pada dataset digits sampai akurasi di atas 0.95.

Telusuri dua tonggak sejarah CNN: LeNet-5 tahun 1998 untuk pembaca digit cek bank dan AlexNet tahun 2012 yang memenangkan ImageNet lewat GPU, ReLU, dan dropout — lengkap dengan implementasi mini LeNet-5 yang teruji nyata.

Pelajari dua arah desain CNN tahun 2014: kedalaman seragam ala VGG dengan kernel 3x3 dan percabangan multi-skala ala Inception dengan bottleneck 1x1.

Pelajari masalah degradasi jaringan sangat dalam dan bagaimana skip connection pada Residual Network memberi jalan pintas bagi gradien.

Pelajari depthwise separable convolution, blok MBConv, dan compound scaling yang membuat EfficientNet mencapai akurasi tinggi dengan parameter jauh lebih sedikit.

Terapkan pola transfer learning pada tugas visual: bekukan backbone pretrained, latih head baru, dan bandingkan hasilnya dengan melatih model dari nol.

Jalankan pipeline inferensi klasifikasi gambar dari awal sampai akhir — load, resize/normalize, forward, softmax, top-k — pada CNN mini dataset digits, lalu bedah prediksi salah dan keandalan skor keyakinan model.

Terapkan transformasi augmentasi gambar — flip, rotasi, crop, geser, brightness, noise — dengan implementasi NumPy murni pada digits, lalu buktikan dampaknya lewat eksperimen noise + geser: akurasi kondisi bergeser melonjak dari 0.150 ke 0.600 tanpa menurunkan akurasi kondisi bersih.

Perluas klasifikasi menjadi deteksi objek: klasifikasi plus lokalisasi untuk tiap objek dalam satu gambar, pahami dua keluarga detektor one-stage dan two-stage, lalu jalankan demo mekanisme NumPy murni — grid 4x4, skor objectness, dan NMS — pada gambar sintetis berisi dua objek.

Kuasai bahasa koordinat object detection: tiga format bounding box dan konversinya, IoU dari formula sampai lima kasus konkret dengan angka nyata, serta NMS langkah demi langkah yang memangkas 4 kandidat menjadi 2 deteksi — fondasi langsung bagi metrik evaluasi deteksi.

Ukur kualitas deteksi objek dengan benar: precision dan recall versi deteksi lewat pencocokan IoU, Average Precision sebagai luas di bawah kurva P-R, serta mAP dengan ambang 0.5 dan 0.5:0.95, semuanya dihitung dari nol dengan NumPy.

Geser unit keputusan dari gambar utuh ke tiap piksel: pahami arsitektur encoder-decoder dengan skip connection ala U-Net, loss cross-entropy per piksel dan Dice, lalu hitung pixel accuracy, IoU per kelas, dan Dice dengan NumPy pada mask digits.

Pisahkan tiap objek menjadi mask tersendiri: kenali bedanya dengan semantic segmentation, pahami Mask R-CNN dan RoIAlign, lalu uji keterbatasan connected components pada dua objek sekelas yang saling menempel dengan NumPy dan scipy.

Ubah gambar menjadi vektor fitur lewat backbone tanpa classifier head, ukur kemiripan dengan cosine similarity, lalu bangun sistem pencarian gambar sederhana: CNN dilatih pada digits, embedding 32 dimensi diambil dari layer kedua terakhir, dan 5 query mengembalikan top-3 gambar paling mirip.

Deteksi wajah dengan anchor multi-scale, tandai titik kunci mata, hidung, dan mulut sebagai landmark, uji pipeline klasik blur-threshold-connected components pada citra sintetis NumPy, lalu pahami kewajiban etika dan privasi saat mengolah data wajah.

Ganti convolution dengan attention: potong gambar menjadi patch, proyeksikan jadi token dengan class token dan positional embedding, lalu jalankan encoder transformer standar; uji patchify pada digits dengan NumPy dan bandingkan karakter CNN lawan ViT.

Kenali struktur data berurutan — teks, deret waktu, audio — lalu ubah menjadi dataset supervised dengan windowing, padding, dan truncation dalam bentuk batch (N, T, D).

Pahami hidden state yang dibawa antar langkah waktu, implementasikan RNN cell murni dengan NumPy, lalu verifikasi hasilnya cocok angka demi angka dengan torch.nn.RNN.

Unroll RNN menjadi rantai langkah waktu lalu jalankan backpropagation biasa: turunkan gradien lintas langkah secara manual dengan NumPy dan verifikasi terhadap finite difference.

Lihat secara kuantitatif mengapa perkalian matriks Wh berulang menyusutkan gradien secara eksponensial, ukur normanya untuk T = 5 sampai 40, dan pahami akibatnya bagi dependensi jangka panjang.

Bedah tiga gate LSTM dan cell state yang menyediakan jalur gradien hampir konstan, implementasikan LSTM cell murni dengan NumPy, dan verifikasi cocok dengan torch.nn.LSTM.

Pelajari GRU dengan dua gate — reset dan update — yang lebih ramping dari LSTM, implementasikan murni dengan NumPy, dan verifikasi cocok dengan torch.nn.GRU.

Gabungkan hidden state maju dan mundur agar setiap langkah melihat konteks masa lalu sekaligus masa depan, lalu verifikasi penggabungan manual cocok dengan torch.nn.LSTM bidirectional.

Susun encoder dan decoder menjadi model yang mengubah satu sekuens menjadi sekuens lain, latih pada tugas salin-geser sintetis, dan kenali bottleneck context vector.

Latih decoder dengan token asli sebagai masukan langkah berikutnya agar konvergen cepat, lalu ukur exposure bias yang muncul saat inferensi memakai prediksi model sendiri.

Bersihkan teks mentah bahasa Indonesia sebelum masuk model: normalisasi unicode NFKC, pembersihan tanda baca, stop words dengan perlindungan negasi, serta konsep stemming dan lemmatization.

Pecah teks menjadi token — unit terkecil yang dipahami model — dengan tiga granularitas: word, subword ala BPE, dan karakter, beserta konsekuensi ukuran vocabulary dan OOV.

Bangun kamus token-ke-integer dari korpus, lengkapi dengan token khusus <pad>, <unk>, <sos>, <eos>, atasi OOV, dan setarakan panjang sekuens dengan padding sebelum data masuk model.

Wakili kata sebagai vektor berdimensi rendah yang maknanya terukur: kemiripan kosinus, hipotesis distribusional, aritmetika vektor raja - pria + wanita = ratu, serta alasan one-hot tidak cukup.

Latih word embedding dari korpus dengan skip-gram dan negative sampling di PyTorch, pahami CBOW versus skip-gram, lalu lihat fastText menangani kata berimbuhan lewat subword n-gram.

Bedah torch.nn.Embedding sebagai tabel pencari: shape weight (vocab, d), lookup batch token ID menjadi (N, T, d), kesetaraan dengan one-hot, padding_idx, serta mode trainable versus frozen.

Rangkai pipeline klasifikasi teks lengkap — tokenisasi, vocabulary, embedding, encoder mean pooling, classifier linear — menjadi satu model PyTorch utuh pada dataset ulasan mini, lengkap dengan bedah arsitektur encoder populer.

Bedah studi kasus text classification paling populer — sentimen positif, negatif, netral — pada ulasan produk dan media sosial, lalu uji nyata TF-IDF + LogisticRegression yang gagal pada negasi 'tidak bagus' dan pulih lewat bigram.

Tandai entitas orang, lokasi, organisasi, dan tanggal di dalam kalimat bahasa Indonesia dengan format BIO, lalu latih classifier fitur sederhana per token dan baca bias kesalahannya pada dataset mini 20 kalimat.

Generalisasi NER menjadi keluarga tugas tag-per-token — POS tagging, chunking, NER — dengan struktur input-output sejajar, loss CrossEntropy yang mengabaikan padding, dan perbedaan penting evaluasi token-level vs entity-level.

Peta lengkap metrik NLP — akurasi token vs entity-level dengan presisi, recall, dan F1 per jenis entitas, exact match, BLEU dengan clipping dan brevity penalty, serta perplexity — semuanya dihitung manual langkah demi langkah pada contoh mini.

Ukur tiga hambatan struktural RNN — komputasi berurutan yang tak bisa diparalelkan, pudarnya pengaruh token jauh, dan context vector berukuran tetap — sebelum Transformer menggantikannya.

Pahami ide dasar attention dari Bahdanau: decoder tidak lagi menerima satu context vector tetap, melainkan rata-rata berbobot dinamis dari seluruh hidden state encoder.

Bedah tiga peran attention — query bertanya, key diindeks, value berisi — beserta tiga proyeksi linear WQ, WK, WV yang membentuknya dari input yang sama.

Implementasikan rumus softmax(QK^T/√d)V dengan NumPy, buktikan kenapa pembagi √d mencegah softmax jenuh, dan verifikasi hasilnya terhadap fungsi resmi PyTorch.

Jalankan beberapa head attention pada subspace berbeda secara paralel, rangkai hasilnya dengan proyeksi WO, dan verifikasi implementasi manual terhadap torch.nn.MultiheadAttention.

Beri urutan pada token yang diproses paralel dengan gelombang sinus-kosinus, verifikasi properti rotasinya dengan angka, dan kenali alternatif modern seperti learned embedding dan RoPE.

Rangkai multi-head attention dan feed-forward menjadi satu blok encoder ber-residual connection dan layer normalization, bandingkan post-LN dengan pre-LN, dan susun beberapa blok menjadi tumpukan.

Bangun blok decoder tiga sub-layer: masked self-attention yang memutus pandangan ke masa depan, cross-attention yang membaca keluaran encoder, dan feed-forward; verifikasi kausalitas dan jalur memori dengan angka nyata.

Rakit Transformer lengkap dari embedding, positional encoding, tumpukan encoder-decoder, hingga layer linear; latih pada tugas salin-geser dengan teacher forcing, jalankan inferensi autoregressive, dan baca aturan yang dipelajari model langsung dari bobot cross-attention.

Buktikan dengan angka nyata mengapa attention autoregressive wajib dibatasi: isi skor posisi terlarang dengan -inf sebelum softmax sehingga bobot masa depan dan token <pad> menjadi nol persis, lalu gabungkan mask kausal dan mask padding dalam satu matriks.

Rakit Vision Transformer utuh dalam PyTorch: potong digits 8x8 menjadi 16 patch 2x2, proyeksikan linear, tambahkan token [CLS] dan positional embedding terlatih, jalankan blok encoder, lalu latih sampai akurasi uji nyata dan baca sorotan [CLS] atas grid patch.

Petakan keturunan Transformer dari makalah 2017: BERT encoder-only dengan masked language modeling, GPT decoder-only autoregressive, T5 dan BART encoder-decoder, lalu tiga teknik efisiensi modern — RoPE, FlashAttention, dan mixture-of-experts — yang menopang model berskala besar masa kini.

Kenali large language model: transformer decoder-only berskala besar yang dilatih memprediksi token berikutnya, kemampuan yang muncul dari skala, keluarga model modern, dan siklus hidupnya dari pretraining hingga alignment.

Bedah algoritma BPE dari nol — menggabungkan pasangan simbol terfrekuen hingga vocabulary tumbuh — beserta implementasi mini yang dilatih pada korpus kecil, special token chat, dan implikasi vocabulary besar pada LLM.

Telusuri tahap termahal siklus hidup LLM: korpus web triliunan token, klaster GPU, scaling laws ala Chinchilla, plus demo teruji bagaimana ukuran korpus menentukan loss language model hingga mendekati lantai entropi.

Bedah mekanisme inti LLM dari logits ke distribusi: cross-entropy dan teacher forcing di sisi pelatihan, loop autoregressive di sisi inference — semuanya pada decoder mini satu blok yang dilatih nyata.

Kenali jarak antara model yang melanjutkan teks dan model yang mengikuti perintah, lalu buktikan pada decoder mini: perilaku acak sebelum tuning berubah menjadi format instruksi-respons yang dipatuhi setelah SFT pada empat contoh instruksi.

Bedah training loop SFT: pasangan prompt-respons menjadi tensor, token prompt di-masking dengan ignore_index agar loss dihitung hanya pada respons, lalu seluruh bobot diperbarui — lengkap dengan bukti angka dan pengukuran catastrophic forgetting.

Kenali keluarga PEFT — adapter, LoRA, prefix tuning, BitFit — yang membekukan hampir seluruh bobot dan hanya melatih modul kecil, lalu buktikan pada demo adapter: 4,6% parameter mengalahkan full fine-tuning sekaligus menjaga kemampuan lama tetap utuh.

Pangkas biaya fine-tuning LLM dengan LoRA: delta bobot ber-rank rendah delta W = B kali A yang dilatih di atas bobot beku, lalu QLoRA yang menumpuk adapter pada model 4-bit — semua dibuktikan pada model attention mini dengan hitungan parameter nyata.

Dari RLHF tiga tahap (reward model plus PPO) menuju DPO yang melatih kebijakan langsung dari pasangan preferensi lewat rasio log-likelihood — dibuktikan pada LM mainan yang margin chosen-rejected-nya tumbuh dari nol tanpa reward model sama sekali.

Pangkas memori LLM dari 28 GB ke 3,5 GB lewat kuantisasi bobot int8 dan int4 dengan skala per grup, bedah grid NF4 yang mengikuti distribusi gaussian bobot, serta pilihan antara PTQ dan QAT — semuanya dibuktikan dengan kuantisasi NumPy murni dan angka error nyata.

Dari logits menuju teks: cara kerja temperature, top-k, top-p, dan beam search beserta strategi kapan masing-masing dipakai, plus KV cache yang membuat generasi panjang tetap terjangkau — semua diuji pada distribusi contoh dengan angka nyata.

Kenapa format percakapan menentukan kualitas jawaban: anatomi chat template dengan peran dan token khusus, dua gaya format yang umum, few-shot prompting, hingga risiko kebocoran system prompt — dirender dan ditokenisasi dengan mesin template mini yang bisa diaudit.

Cara menilai model bahasa besar tanpa tertipu: anatomi benchmark seperti MMLU dan HumanEval, bahaya data contamination, human eval dan LLM-as-judge beserta biasnya, serta perplexity yang membedakan teks pola dari teks acak pada demo LM mainan dengan angka yang berbeda jauh.

Peta jujur batas-batas large language model: halusinasi yang fasih tanpa dasar data, knowledge cutoff, bias warisan korpus, prompt injection, hingga privasi dan jejak karbon — disertai mitigasi praktis untuk tiap risiko dan posisi verifikasi manusia di tengahnya.

Bedah perbedaan model discriminative P(y|x) dan generative P(x)/P(x,y), peta keluarga VAE-GAN-diffusion-autoregressive, plus demo Gaussian fit yang benar-benar menghasilkan data sintetis.

Bangun jaringan yang memampatkan data lewat bottleneck laten lalu merekonstruksinya: loss MSE, hubungan dengan PCA, deteksi anomali lewat error rekonstruksi — semua pada autoencoder linear 2D ke 1D yang dilatih nyata.

Perbaiki ruang laten autoencoder yang berlubang dengan distribusi q(z|x), reparameterization trick, dan regularizer KL — dibuktikan angka nyata: sampling z dari prior menghasilkan titik dekat data.

Bedah permainan minmax dua jaringan — generator mengubah noise menjadi data tiruan, discriminator menilai asli vs palsu — dengan demo GAN mini PyTorch yang sampelnya konvergen ke statistik data dalam 2000 iterasi.

Bedah anatomi kedua jaringan GAN lapisan demi lapisan: generator yang membangun data dari noise dimensi kecil, discriminator sebagai classifier biner, hitungan parameter tiap lapisan, arsitektur tiap domain, efek kapasitas generator, dan label smoothing.

Kenali tiga kegagalan klasik training GAN — mode collapse, discriminator menang mutlak, dan gradien yang menipis — lewat tiga duel nyata pada data tiga mode, lalu susun tabel gejala, diagnosis, dan obat: loss non-saturating, label smoothing, laju belajar serta ritme update yang seimbang, hingga WGAN-GP dan spectral norm.

Pahami ide diffusion model: menambahkan derau bertahap pada data lalu mempelajari proses pembaliknya, lengkap dengan perbandingan keluarga VAE/GAN/diffusion dan demonstrasi derau bertahap pada sinyal 1D.

Formalkan forward process sebagai rantai Gaussian, turunkan bentuk tertutup x_t dari x_0, lalu pahami reverse process yang dipelajari jaringan denoiser — dengan implementasi NumPy yang angkanya bisa dicocokkan.

Bandingkan noise schedule linear dan cosine, pahami mengapa objectif diffusion cukup MSE pada prediksi derau, lalu latih denoiser mini PyTorch dan jalankan sampling reverse penuh dari derau murni sampai sampel data.

Pahami mengapa diffusion di ruang piksel mahal, bagaimana Latent Diffusion Model memindahkan proses ke ruang laten VAE, conditioning teks lewat cross-attention, dan classifier-free guidance — disertai analogi mini teruji dari kompresi sampai dekode.

Ukur kualitas model generatif dengan FID, Inception Score, precision-recall, dan implementasi kernel MMD mini NumPy yang membedakan distribusi sama, bergeser, hingga mode collapse — lalu rangkum seluruh keluarga model generatif dalam satu tabel.

Bandingkan biaya label beranotasi dengan sinyal supervisi gratis dari data mentah, lalu lihat tugas pretext membelah vektor membangun prediktor tanpa satu pun label.

Tarik pasangan sejenis mendekat dan dorong pasangan berbeda menjauh lewat loss InfoNCE dengan temperatur, lalu ukur kualitas representation hasil pretraining lewat linear probe.

Bangun pasangan positif-negatif dari data tanpa label, pahami in-batch negatives, hard negative, dan risiko false negative lewat statistik jarak pada cluster sintetis.

Sembunyikan sebagian token dan tebak dari konteks kiri dan kanan sekaligus: cara BERT belajar representation bahasa dua arah tanpa satu label, dibuktikan lewat MLM mini pada korpus karakter.

Belah gambar menjadi patch, sembunyikan sebagian besar, dan rekonstruksi pikselnya: pola MAE yang memindahkan MLM dari token ke citra, dibuktikan lewat autoencoder mini pada dataset digits.

Setiap layer jaringan menyimpan fitur berjenjang; ukur kualitasnya secara adil dengan linear probe di atas backbone beku, dan lihat angka nyata fitur terlatih melawan fitur acak.

Ukur kemiripan antar embedding dengan kosinus dan euclidean, bangun matriks kemiripan beserta pencarian nearest neighbor, lalu pahami mengapa skala jutaan vektor membutuhkan ANN.

Naiki tangga freeze, linear probe, fine-tune dengan anggaran label kecil, kenali risiko domain mismatch, dan pakai ekosistem pretrained model dari Hugging Face sebagai penutup section.

Kenali paradigma belajar dari interaksi: agent mengambil aksi, environment membalas state dan reward tanpa label, lalu ukur performa agen acak pada GridWorld 1D mini sebagai titik nol.

Bedah anatomi loop agent-environment langkah demi langkah, bedakan observasi dari state serta reward sparse dari dense, lalu buktikan pada dunia lumpur 2x4 bahwa dua desain reward menghasilkan kebijakan optimal yang berlawanan arah.

Formalkan dunia dan reward ke dalam lima komponen MDP, pahami Markov property dan return diskonto gamma=0.9, lalu hitung kebijakan optimal dengan value iteration NumPy yang konvergen dalam empat iterasi.

Bedakan V(s) dari Q(s,a), baca kebijakan greedy langsung dari tabel Q, lalu latih Q-learning tabular pada GridWorld 4x4 hingga Q konvergen dan jalur optimal enam langkah muncul dari tabel.

Ubah kebijakan menjadi distribusi softmax yang dapat dibediferensiasi, pahami rumus REINFORCE log-prob dikali return beserta masalah variansnya, lalu latih REINFORCE mini berbasis PyTorch hingga reward naik dari 0.02 ke 0.40.

Ganti tabel Q yang runtuh di ruang state besar dengan jaringan Q, atasi korelasi data dan target berpindah lewat replay buffer serta target network, lalu latih DQN mini PyTorch hingga reward naik dari -1.35 ke +0.73.

Gabungkan jaringan kebijakan dan jaringan nilai dalam satu arsitektur, ganti return episode REINFORCE dengan keunggulan TD yang variansnya rendah, lalu buktikan critic menaksir V(0) tepat 0.29 pada dunia 1D.

Pahami dilema mencoba aksi baru lawan memakai aksi terbaik yang diketahui, bandingkan epsilon-greedy tetap, epsilon meluruh, dan inisialisasi optimistik, lalu lihat empat strategi menghasilkan kurva belajar yang berbeda di GridWorld 4x4.

Ukur agen dengan mean return, success rate, dan sample efficiency, pisahkan evaluasi greedy dari return training, tunjukkan variansi antar seed dengan lima pelatihan, lalu rapikan kurva belajar dengan rata-rata bergerak.

Pahami mengapa model harus menggabungkan gambar, teks, dan suara: jenis kombinasi modalitas, tiga tantangan utama penyatuan ruang representasi, serta demo fusi dua encoder mini dengan bentuk tensor nyata.

Bangun ruang representasi bersama untuk gambar dan teks: encoder CNN dan embedding kata diproyeksikan ke dimensi sama, diselaraskan dengan loss MSE, lalu periksa statistik kosinusnya -- termasuk jebakan degenerasi yang menuntut solusi kontrastif.

Bangun mini CLIP dengan loss InfoNCE simetris: caption lain di batch menjadi negatif, dua encoder dipaksa ke ruang bersama yang terpisah per konsep, lalu uji retrieval gambar-teks dan klasifikasi zero-shot dengan akurasi nyata.

Bedah arsitektur VLM: vision encoder menghasilkan visual token, adapter memproyeksikannya ke ruang LLM, dan cross-attention menyatukan pertanyaan dengan isi gambar -- dibuktikan simulasi mekanis mini yang menjawab dua pertanyaan berbeda untuk satu gambar.

Olah suara sebagai data: dari waveform ke spektrogram magnitudo lewat FFT berbingkai, lalu latih model kecil pengklasifikasi nada dengan akurasi nyata -- plus peta arah audio-text dari speech-to-text hingga model gabungan.

Pipeline ASR dari audio ke teks — fitur akustik per bingkai, encoder akustik, decoder — plus intuisi CTC untuk alignment monotonic dengan token blank, fusi model bahasa, dan ASR mainan tiga tahap yang mentranskripsi pola nada morse dengan akurasi nyata.

Pipeline TTS neural dari teks ke suara: analisis linguistik, model akustik yang memprediksi spektrogram mel, dan vocoder yang membentuk waveform — dituntaskan demo mini prosodi pernyataan/pertanyaan yang disintesis menjadi berkas WAV sungguhan.

Olah video sebagai tensor (T, C, H, W): peta tugas dari klasifikasi aksi hingga retrieval momen, tiga keluarga arsitektur (temporal pooling, CNN 3D, video transformer), dan demo dua model pendeteksi arah gerak yang bersaing dengan akurasi nyata.

Metrik per tugas multimodal — recall@K untuk retrieval, BLEU/CIDEr untuk captioning, akurasi VQA dengan anotasi multi-manusia, dan WER untuk speech recognition — dihitung nyata pada contoh mini, ditutup tantangan halusinasi VLM dan bias komposisional sebagai sintesis penutup section.

Petakan sumber dataset publik — Kaggle, Hugging Face Datasets, UCI, torchvision — beserta lisensi, kriteria pemilihan, dan format berkas umum, lalu bangun katalog mini dari sumber lokal sklearn tanpa satu pun unduhan.

Bandingkan metode pelabelan — manual, crowdsourcing, weak supervision, model-assisted — lalu ukur kualitas anotator dengan double annotation dan Cohen's kappa yang dihitung manual dari nol memakai NumPy.

Diagnosis dan penanganan ketimpangan kelas — deteksi distribusi, oversampling minoritas, undersampling mayoritas, dan SMOTE — diimplementasikan dengan NumPy murni pada dataset 80/15/5 dan diuji nyata dengan angka sebelum-sesudah.

Bobot kelas di dalam loss tanpa mengubah satu baris data — rumus n_total/(K x n_k) diterapkan pada CrossEntropyLoss PyTorch dan class_weight sklearn, dengan demo teruji nyata: F1 kelas minoritas 0.167 menjadi 0.337 dan recall 0.100 menjadi 0.850.

Bongkar tiga kebocoran klasik yang menggelembungkan skor test — scaler di-fit pada seluruh data, duplikat lintas split, fitur turunan label — dengan demo terukur nyata: inflasi +0.053, +0.068, dan +0.138 poin akurasi, beserta protokol pencegahannya.

Kunci reproducibility dari sisi data — simpan versi dataset dengan folder arsip, hash sha256, dan manifest CSV yang terbukti mendeteksi perubahan satu nilai sensor, lalu kenali DVC dan versioning Hugging Face untuk skala lebih besar.

Rancang policy augmentasi per domain — gambar, teks, audio, tabular — dengan aturan train-only dan label-preserving, lalu buktikan policy gabungan noise + geser menaikkan akurasi validasi dari 0.882 ke 0.915 pada digits dengan hanya 80 sampel latih.

Bangun data baru ketika data asli tak tersedia — generator tabular berbasis aturan dengan constraint, validasi distribusi yang jujur menemukan ketidakcocokan, uji train-on-synthetic test-on-real, dan risiko model collapse yang menyertai data hasil model.

Ukur perlindungan data secara kuantitatif — k-anonymity yang naik dari 1 menjadi 3 lewat generalisasi bertahap, differential privacy dengan derau Laplace pada tiga nilai epsilon, konsep federated learning, serta ancaman balik seperti model inversion.

Pecahkan anatomi memori pelatihan: parameter, gradien, state optimizer, dan aktivasi dengan rumus byte yang bisa dihitung sebelum alokasi, diverifikasi nyata pada model mini, lalu petakan gejala galat out of memory.

Raih batch efektif besar dari micro-batch kecil lewat akumulasi gradien: pembobotan loss 1/N, posisi zero_grad yang benar, bukti nyata kesetaraan kurva loss, dan jebakan gradien yang menumpuk.

Tukar hitungan ulang dengan memori: simpan hanya aktivasi di batas segmen, hitung ulang sisanya saat backward lewat torch.utils.checkpoint, dengan pengukuran nyata penurunan memori dan biaya forward ganda.

Pecah data, bukan model: replika identik menghitung gradien di pecahan berbeda lalu digabung lewat all-reduce — dibuktikan nyata di CPU dengan dua replika manual dan tabel DP klasik vs DDP modern.

DistributedDataParallel dalam praktik: satu proses per perangkat, all-reduce gradien Ring, launcher torchrun, DistributedSampler, dan inisialisasi grup proses gloo yang diuji nyata di jalur CPU.

Saat model tak muat di satu GPU, pecah lapisannya ke beberapa perangkat: penempatan manual per tahap, aktivasi dan gradien mengalir melintasi perbatasan device, dibuktikan lewat simulasi dua perangkat di CPU.

Isi waktu nganggur model parallelism dengan micro-batch mengalir bertingkat: jadwal fill-drain, rumus efisiensi m/(m+s-1), gelembung pipeline, dan jadwal GPipe vs 1F1B — diuji nyata dengan pipeline mini 2 tahap di CPU.

Pecah state optimizer, gradien, dan parameter ke semua perangkat ala ZeRO stage 1/2/3: aritmetika memori untuk model 1 miliar parameter, simulasi shard tensor nyata dengan all-gather, serta posisi FSDP di PyTorch.

Atasi memori attention yang tumbuh kuadratik: hitung nyata matriks skor untuk seq 1k/4k/16k, tiling baris ala FlashAttention yang terbukti identik, API scaled_dot_product_attention, serta varian sparse dan linear attention.

Rangkai seluruh teknik menjadi toolkit praktis: urutan mencoba mixed precision, checkpoint, akumulasi, sharding; pemantauan memori CPU dan GPU; pengukuran nyata dua konfigurasi pelatihan dengan aktivasi turun 7,2x.

Susun artefak produksi yang lengkap: state_dict, konfigurasi arsitektur, parameter preprocessing, versi, dan metadata — lalu muat ulang seluruh paket dan buktikan prediksinya identik.

Pahami pola penyajian model — embedded library, HTTP service, batch offline — beserta aspek concurrency, latency SLO, dan health check, dibuktikan lewat server TCP mini yang melayani inference sungguhan.

Bungkus model dalam REST API FastAPI: skema Pydantic memvalidasi input, endpoint POST /predict menjalankan inference, dan galat input otomatis ditolak dengan status 422 — semuanya teruji lewat TestClient.

Serahkan throughput kepada batch: ukur perbedaan nyata kecepatan inference batch 1, 32, dan 256, pahami trade-off ukuran batch optimal, dan proses file besar secara streaming per potongan.

Ukur latensi real-time dengan benar: warm-up sebelum pengukuran, lalu P50, P95, dan P99 dari 100 request nyata — beserta mengapa rata-rata menyesatkan dan bagaimana pola streaming menghasilkan jawaban bertahap.

Bawa model keluar dari PyTorch: export graph computation ke format ONNX, jalankan inference dengan onnxruntime di CPU, dan verifikasi output yang cocok sampai ke angka terakhir.

Bedah sumber latensi jalur inference — preprocessing, model, I/O — lalu praktikkan dua pengungkit nyata di CPU dua core: pengaturan jumlah thread di PyTorch dan onnxruntime, plus graph optimization yang terbukti mempertahankan output.

Peringkas model untuk inference: dynamic quantization int8 yang memangkas ukuran state_dict hingga 3,4 kali lipat, dan magnitude pruning 30% yang diuji dampaknya terhadap akurasi — lengkap dengan perbandingan PTQ versus QAT.

Kenali kapan CPU sudah lebih dari cukup untuk inference, rangkai optimasi khas CPU — thread, quantization, onnxruntime — dan benchmark dengan metodologi yang benar: warm-up, banyak iterasi, laporan rentang.

Pahami anatomi inference GPU — CUDA context, transfer memori H2D/D2H, batching, dan TF32/AMP — serta alasan GPU menjadi pilihan mahal untuk request tunggal; disertai pola kode agnostik-perangkat yang diuji nyata di CPU.

Awasi model yang sudah berjalan: pantau latensi, error rate, dan distribusi prediksi; bangun loop monitoring mini dengan deteksi drift sederhana yang memicu alert saat distribusi bergeser melewati ambang.

Naikkan pencatatan eksperimen dari catatan manual menjadi sistem: field wajib per run (config, versi kode, versi data, metrics, artifact), log JSON Lines yang bisa di-query, lalu kenali MLflow Tracking dan Weights & Biases.

Beri identitas permanen pada setiap artifact model: skema penomoran semver plus metadata versi dataset dan kode, artifact immutable dengan hash, dan registry file index.json yang merekam tiga versi model mini yang bisa dimuat ulang.

Jadikan registry sumber kebenaran tunggal untuk model: siklus stage staging-production-archived dengan gerbang akurasi, anotasi dan lineage tiap versi, lalu promosi versi 2 ke production pada registry mini yang benar-benar berjalan.

Rangkai pelatihan menjadi pipeline: DAG data-train-eval-register dengan trigger terjadwal, idempotency dan caching berbasis hash checkpoint, lalu bukti nyata re-run yang melewati tahap selesai dan hanya mengeksekusi tahap terdampak.

Bawa disiplin test ke proyek ML: test kualitas data dan test kualitas model berdampingan dengan test unit, mini test suite pola pytest yang benar-benar berjalan, serta contoh workflow GitHub Actions dengan gerbang akurasi.

Rilis model baru dengan eksposur terkendali: strategi canary, blue-green, dan shadow beserta risikonya, promotion gate berbasis metrik, rollback otomatis, dan simulasi canary 10-50-100 persen yang menghasilkan keputusan promote atau abort.

Deteksi pergeseran distribusi input dengan PSI dan KL divergence NumPy murni: tiga arus data dibandingkan terhadap baseline dengan ambang industri, alarm drift terpicu, dan drift yang sama terlihat sebagai penurunan akurasi model.

Pantau kualitas keputusan model, bukan hanya infrastrukturnya: akurasi berjalan per jendela waktu dengan label ground truth yang terlambat tiba, tabel metrik-sumber data-ambang umum, dan alert anti-flapping yang hanya berbunyi setelah dua jendela berturut-turut.

Bangun audit trail yang tidak bisa diubah tanpa bekas: artefak wajib per rekaman (siapa-apa-kapan-model versi mana), lineage penuh dari data ke prediksi, dan rantai hash sha256 yang membuktikan manipulasi satu bobot terdeteksi pada verifikasi ulang.

Tutup siklus MLOps dengan pembaruan yang aman: strategi big-bang lawan gradual, rollback cepat dengan versi lama selalu siap sebagai warm standby, kebutuhan data migration dan komunikasi perubahan, plus simulasi deploy v2 yang memburuk dan rollback otomatis ke v1.

Lacak tiga sumber bias pada data latih, ukur ketimpangan dengan demographic parity dan equalized odds, lalu ratakan laju persetujuan lewat threshold per kelompok — semua dengan angka nyata pada dataset kredit fiktif.

Hadapi privasi sebagai masalah keamanan: re-identification lewat join quasi-identifier pada data yang sudah dibuang namanya, lalu penyimpanan kredensial yang benar dengan hash dan salt — dua demo nyata dengan angka konkret.

Pahami mengapa model deep learning rapuh terhadap gangguan kecil: FGSM menggeser tiap fitur sebesar epsilon lewat tanda gradien, akurasi model mini runtuh dari 0.93 ke 0.50, dan gangguannya berpindah ke model lain yang tak dikenal penyerang.

Sisipkan racun ke data latih sebelum model dilatih: 5% label terbalik berpola menurunkan akurasi kelas tertentu, sampel backdoor bertanda titik kecil membuka pintu rahasia, dan deteksi statistik sederhana memulihkan sebagiannya.

Model yang dilatih bisa bocor: membership inference membedakan anggota data latih dari orang luar dengan akurasi 71% hanya dari confidence, model inversion merekonstruksi citra representatif, dan LLM menghafal potongan korpus — beserta mitigasinya.

Ketika dunia bergeser, model ikut jatuh: tiga jenis shift (covariate, label, concept) dipetakan lewat tabel, lalu demo nyata — MLP dengan akurasi sempurna runtuh menjadi 0% pada wilayah fitur yang tak pernah dilihat, dan augmentasi aturan memulihkannya.

Buka kotak hitam secara terukur: permutation importance menyingkap tiga fitur informatif di antara tiga derau lewat penurunan akurasi, surrogate tree merangkum random forest menjadi empat aturan dengan kesesuaian 90%, dan attention bukan penjelasan.

Rangkai delapan chapter keamanan menjadi kerangka kerja: prinsip yang diterjemahkan menjadi tindakan konkret, pola human-in-the-loop pada titik keputusan, model card sebagai dokumen standar, dan impact assessment sebelum model menyentuh pengguna.

Kepemilikan hukum atas tiga artefak berbeda — dataset, bobot model, kode — diatur lisensi berbeda: peta MIT, Apache-2.0, CC-BY, CC-BY-NC, hingga GPL beserta izin komersialnya, dan demo filter katalog yang menyingkirkan artefak NC sebelum proyek komersial dimulai.

Bangun dan latih neural network yang mengenali digit 0-9 dari gambar tulisan tangan, lalu evaluasi kualitas prediksinya.

Bangun model CNN untuk mengklasifikasikan gambar hewan, lalu tingkatkan hasilnya dengan transfer learning.

Latih model yang mengenali penyakit tanaman dari foto daun dan menganalisis kesalahan prediksinya secara sistematis.

Bangun pipeline NLP tiga kelas utuh dari data ulasan fiktif: preprocessing teks, model embedding dengan mean pooling, training, evaluasi, hingga prediksi teks baru.

Bangun pipeline prediksi deret waktu utuh dengan LSTM: data sintetis tren-musiman, windowing, pembagian temporal tanpa acak, training dengan early stopping, dan evaluasi melawan baseline naive.

Manfaatkan model pretrained untuk dataset kecil, lalu bandingkan hasilnya dengan model yang dilatih dari nol.

Fine-tune model bahasa Indonesia dengan LoRA pada dataset kecil, lalu evaluasi dan jalankan inference hasilnya.

Bangun sistem deteksi objek: siapkan label bounding box, pilih model, latih, lalu jalankan deteksi pada gambar baru.

Bawa model hasil pelatihan ke REST API, uji endpoint-nya, lalu optimasi dan jalankan sebagai layanan inference.

Peta rujukan dokumentasi resmi untuk setiap topik Course ini beserta cara membacanya secara efektif.

Empat buku terkurasi untuk melengkapi Course ini: posisi di jalur belajar, kekuatan masing-masing, dan catatan edisi.

Kursus terkurasi untuk melanjutkan belajar: fast.ai, CS231n, Deep Learning Specialization, dan Neural Networks Zero to Hero, beserta strategi belajar dari materi berbahasa Inggris.

Peta dataset publik penting per domain, portal pencariannya, dan cara menilai kelayakan dataset sebelum dipakai.

Peta pusat model pretrained, cara membaca model card, dan pilihan keluarga model umum untuk setiap tugas.

Cara membaca paper secara efisien, peta paper milestone yang membentuk deep learning, dan tempat mengikuti penelitian terbaru.

Kamus istilah Course Deep Learning dari A sampai Z: definisi satu kalimat untuk puluhan istilah yang dipakai konsisten sepanjang perjalanan belajar.