.png)
Sebuah micro library deep learning yang murni kubangun dari dasar matematika, rasa penasaran yang kelewatan, dan rasa muak sama kalimat “yang penting kodenya jalan”.
Ada satu jenis rasa frustrasi yang cuma dirasain sama orang-orang kepo—frustrasi pas makai tool yang kita nggak paham-paham amat cara kerjanya. Kebanyakan programmer belajar machine learning dengan cara yang sama: instal library, panggil fungsi, liat angka akurasi naik, kelar. Semuanya diurusin sama abstraksi. Abstraksi itu ngumpetin segalanya. Dulu aku juga gitu. Sampai akhirnya aku nonton satu lecture yang ngubah cara pandangku total.
MIT 6.S191: Introduction to Deep Learning. Slide-nya clean, matematikanya padat banget, dan di antara penurunan rumus sama diagram arsitektur itu, ada yang berubah di otakku. Aku nggak mau cuma jadi user neural networks lagi. Aku pengen jadi architect-nya. Aku pengen paham nggak cuma apa yang mereka lakuin, tapi kenapa mereka ngelakuin itu. Gimana ceritanya tiap perkalian matriks, tiap lekukan kurva activation function, dan tiap aliran gradien bisa bikin sebuah mesin “belajar”. Lecture series ini jadi gateway ke obsesi yang akhirnya lahir jadi AINO — Aino Is Neural Operation.
Pertanyaan pertamanya simpel: mulai dari mana? Jawabannya jelas—biologi. Otak kita kan isinya neuron. Jadi, aku bikin neuron. Aku bikin class Perceptron buat tiap unit komputasi di dalam network. Tiap neuron punya weight vector dan bias-nya sendiri, saling ngobrol satu sama lain lewat pemanggilan method dan referensi objek. Kodenya kelihatan persis kayak diagram di buku cetak. Rasanya bener dan memuaskan banget.
Tapi ternyata… lambatnya nauzubillah.
Nge-train network kecil pakai dataset mainan aja butuh waktu 32 menit full. Tiga puluh dua menit cuma buat ngeliatin progress bar yang jalannya ngesot, sambil dengerin kipas laptop muter kenceng padahal CPU-nya nggak ngerjain hal yang terlalu berguna. Prosesornya nggak sibuk ngitung matriks—dia sibuk ngurusin Python overhead. Sibuk bikin objek, nyari atribut, dan ngurusin birokrasi ribuan objek kecil yang ngantri giliran buat dieksekusi. Aku berhasil bikin neural network paling akurat secara biologis, tapi sistem itu nyekik dirinya sendiri karena terlalu “elegan”.
Pencerahannya datang bukan dari nambahin kode, tapi dari ngubah cara mikir soal apa itu komputasi. Sekumpulan neuron di satu layer itu sebenernya bukan individu-individu yang terpisah—mereka itu sebuah transformasi. Sebuah fungsi yang nerima input vector dan ngeluarin output vector. Dan transformasi itu, secara keseluruhan, bisa dieksekusi cuma lewat satu operasi matematika: np.dot(W, X) + b. Satu baris. Satu perkalian matriks. Nggak ada looping, nggak ada objek-objekan, nggak ada antrian.
Aku hapus class Perceptron. Aku pindahin semua logikanya ke layer.py pakai operasi vektor murni. Dan pas aku run, hal gila terjadi—komputasinya langsung turun dari level Python yang lambat ke level eksekusi C-level SIMD, di mana CPU modern mroses bongkahan data secara paralel pakai instruksi hardware yang jarang disentuh langsung sama programmer Python. Waktu training yang tadinya 32 menit anjlok jadi 19 detik. Bukan 20. Bukan 25. Sembilan belas. Aku sampai nge-run tiga kali saking nggak percayanya. Pelajaran ini nancep banget di kepalaku: kode yang paling kenceng itu hampir selalu kode yang paling jujur secara matematika.
Tapi secepet apa pun kodenya, percuma kalau network-nya nggak bisa belajar. Belajar di neural network itu cuma butuh satu hal: backpropagation—algoritma yang ngukur error di output terus ngalirin error itu mundur ke tiap layer, nyesuaiin weight berdasarkan seberapa besar kontribusi mereka ke kesalahan tersebut. Kebanyakan orang nganggep ini black box dan pasrah aja sama framework yang mereka pakai. Tapi aku nggak punya framework. Aku cuma punya coret-coretan, buku kalkulus, dan waktu.
Aku nge-turunin Chain Rule manual buat tiap activation function yang mau aku pakai. Buat Sigmoid: aku ngitung gimana perubahan kecil di input ngaruh ke output, yang ditahan sama kemiringan kurvanya. Buat ReLU: logikanya simpel banget—lolosin gradient kalau neuronnya aktif, matiin total kalau nggak. Buat Tanh: aku bedah simetrinya yang berpusat di nol, yang lebih stabil dari Sigmoid tapi tetep punya risiko vanishing gradient di ujung-ujungnya. Tiap turunan rumus ini bukan cuma soal matematika—ini soal pemahaman. Pemahaman soal kenapa ada arsitektur yang error-nya meledak (exploding), kenapa ada yang mati mendadak, dan kenapa learning rate itu bukan sekadar angka tebakan, tapi seberapa besar kamu percaya sama gradient-mu sendiri.
Selain matematika, aku juga ngebangun agnostic hardware backend buat AINO—sistem deteksi runtime yang ngecek kapabilitas hardware pas baru jalan. Kalau di laptop biasa, AINO jalan pakai array NumPy yang diatur di blok memori berdekatan buat maksimalin cache dan CPU. Tapi kalau laptopnya punya GPU NVIDIA, AINO bakal diem-diem nge-switch semua komputasi numeriknya ke CuPy—library mirip NumPy yang jalanin operasi di core GPU, ngebuka ribuan thread paralel sekaligus. Bagian paling kerennya: nggak ada satu baris kode arsitektur pun yang berubah. layer.py yang sama, logika backprop yang sama, training loop yang sama—semuanya otomatis pindah ke GPU. Hardware-agnostic by design. Scalable by default.
Dengan framework yang kenceng, bisa belajar, dan hardware-aware, aku butuh masalah yang sepadan buat dipecahin. Aku milih catur.
Mungkin ini agak nekat sih. Catur itu bukan sekadar pattern recognition—catur itu ledakan probabilitas, di mana satu langkah sekarang bisa ngaruh ke 15 langkah ke depan. Posisi catur nggak bisa dinilai sepotong-sepotong. Aku bikin Monte Carlo Tree Search (MCTS) dari nol: algoritma probabilistik yang ngeksplorasi cabang permainan lewat simulasi acak, nyari balance antara ngeksplor cabang baru sama ngeksploitasi cabang yang udah ketahuan bagus. Aku gabungin ini sama Dual-Head Neural Network—satu “kepala” buat nebak probabilitas langkah yang legal, satu lagi buat nebak value dari posisi papan. Arsitektur ini terinspirasi langsung dari AlphaZero, tapi dibikin dari konsep paling dasar murni pakai AINO.
Biar AI-nya peduli sama bidak, aku tambahin Hybrid Material Calculator—fungsi scoring yang ngasih value klasik ke tiap bidak biar neural network-nya punya patokan apa artinya “menang”. Sistem ini bisa main. Dia bisa ngalkulasi. Dan pas dites tanding… dia malah kena Fool’s Mate—skakmat 4 langkah paling konyol yang biasa ngenain anak pemula.
Pas aku bedah, masalahnya kelihatan. Kesalahannya bukan di komputasi, tapi di representasi. Papan catur itu punya struktur spasial: hubungan antar kotak itu bergantung sama koordinat, diagonal, dan jalur kosong. Pas aku jadiin representasinya flat vector buat dimasukin ke fully connected layer, semua unsur geometri itu hancur. Keterbatasan MCTS bikin AI-nya nggak bisa ngelihat ancaman yang lagi kebentuk di depan mata. Kalkulator material ngasih AI kosa kata buat “nilai”, tapi nggak ngajarin tata bahasa buat “bahaya”. Aku berhasil bikin sesuatu yang bisa mikir, tapi nggak bisa melihat.
Kalah karena Fool’s Mate itu momen paling edukatif di project ini. Benar-benar nampar aku soal betapa pentingnya nyocokin struktur masalah sama arsitektur model—pelajaran yang nggak bakal seefektif ini kalau cuma dibaca dari buku.
Akhirnya aku banting setir ke bahasa (NLP). Spesifiknya, aku pengen tau: bisa nggak sih sebuah neural network yang di-train bener-bener dari nol—tanpa pre-trained embeddings, tanpa transformer attention, tanpa LSTM, murni angka mentah dan gradient descent—belajar bedain review film yang seneng banget sama yang kecewa berat?
Dataset-nya: 50.000 review film IMDb, dibagi rata antara sentimen positif dan negatif. Aku pakai TF-IDF vectorization—teknik yang ngubah tiap kata di review jadi sparse vector (vektor yang isinya banyak nol) berukuran 5.000 dimensi. Kata-kata filler kayak “yang” atau “dan” nilainya bakal amblas ke nol. Tapi kata-kata langka yang penuh emosi kayak “masterpiece” atau “sampah” bakal jadi sinyal yang tajem. Bahasa, direduksi jadi geometri.
Arsitektur pertamaku lumayan ambisius: [5000 → 512 → 128 → 1]—tiga hidden layer yang makin lama makin mengecil, niatnya buat ngompres dimensi yang gede jadi representasi abstrak sebelum ngasih output final. Teorinya sih, makin deep makin bagus. Praktiknya? Vanishing gradients. Vektor TF-IDF itu terlalu sparse. Pas aktivasi yang nilainya mendekati nol ini ngelewatin layer demi layer, nilai gradient-nya makin nyusut. Pas sinyalnya nyampe ke weight paling awal, nilainya udah terlalu kecil buat bikin update yang berarti. Network-nya nge-stuck. Akurasinya cuma mantul-mantul di 50 sampai 76%, nggak beda jauh sama nebak koin, padahal udah dilatih pakai puluhan ribu dataset.
Solusinya lumayan nonjok ego: aku harus buang asumsi kalau “makin dalam makin bagus”. Aku pangkas arsitekturnya jadi super tipis: [5000 → 64 → 1]. Cuma satu hidden layer isi 64 neuron. Kedengarannya meremehkan banget. Tapi secara matematika ini valid—satu hidden layer yang cukup lebar itu udah jadi universal function approximator. Dan ruang TF-IDF 5.000 dimensi, biarpun sparse, punya sinyal yang cukup buat dipisah-pisahin asal dapet transformasi linear yang pas.
Pakai learning rate agresif dan akselerasi GPU, AINO ngelahap 40.000 review buat di-train cuma dalam hitungan detik per epoch. Akurasinya naik pelan tapi pasti, sampai akhirnya stabil di 88.88%.
AINO ternyata bisa paham emosi manusia. Memang nggak sempurna—nggak ada model from scratch yang sempurna—tapi konsisten dan setara sama performa model yang dibikin pakai framework gede. Semua ini dicapai murni sama satu orang yang nurunin tiap gradient, nulis tiap layer, dan nge-debug semua instabilitas numerik dari angka nol.
Tapi, framework yang cuma bisa jalan di satu sesi di satu laptop itu namanya script, bukan framework. Tantangan engineering terakhirku: persistance. Gimana caranya nge-save “otak” dari neural network ini—lengkap sama bobot, arsitektur, dan tipe memori backend-nya—terus di-load lagi di beda mesin dengan beda hardware tanpa masalah?
Aku bikin format file biner sendiri: .dit—format terstruktur yang nyimpen konfigurasi layer, tensor bobot, ID activation function, dan riwayat device jadi satu file portabel. Kalau kamu load model .dit di laptop pakai CPU padahal aslinya di-train di GPU, kamu nggak perlu repot konversi atau ganti kode. Format ini nanganin semuanya secara otomatis. Otaknya berhasil di-transfer.
Pas framework-nya udah selesai, di-tes, dan portabel, aku publish. Sekarang AINO udah ada di PyPI—bisa diinstal sama siapa aja di seluruh dunia cuma lewat satu perintah: pip install aino. Di GitHub, dokumentasinya udah sekelas standar industri: ada README yang rapi, benchmark waktu yang turun dari 32 menit ke 19 detik, dan API reference yang jelas buat tiap layer, activation, loss, dan modul training.
Buat ngevalidasi riset ini dan ngasih sesuatu ke komunitas, aku publish notebook eksperimenku di Kaggle: “Sentiment Analysis from Scratch: Evaluating Deep vs. Shallow Architectures”. Ini bukan sekadar pamer portofolio, tapi perbandingan objektif antara arsitektur deep dan shallow, lengkap sama kurva loss, metrik, dan post-mortem jujur soal kegagalananku. Dokumentasi nyata dari proses engineering, di mana model yang gagal justru ngasih pelajaran lebih banyak dari model yang sukses.
AINO jelas bukan TensorFlow. Bukan juga PyTorch. Dan nggak pernah berniat jadi pesaing mereka.
Tapi AINO itu adalah bukti—bahwa mesin di balik AI zaman now itu bukan magic. Bukan hal gaib yang cuma bisa disentuh sama lab riset dengan tim PhD atau budget superkomputer. Ini murni matematika. Aljabar linear. Kalkulus. Dan engineering yang sabar ngerjain turunan demi turunan.
Dan kalau kamu mau repot nurunin rumusnya sendiri—ngerasain aliran gradien di tiap baris kode yang kamu ketik, nge-debug aktivasi yang mati di jam 2 pagi, nghapus puluhan baris class cuma buat diganti jadi satu perkalian matriks, sampai rela kalah catur 4 langkah cuma buat paham kenapa logikamu salah—maka kamu nggak cuma makai AI.
Kamu memahaminya. Sepenuhnya. Dari dalam.
Pemahaman itulah yang ngebangun AINO. Di setiap baris kodenya.