Neural Networks: Mula Perceptrons Hanggang Deep Learning

Noong Marso 10, 2016, sa ikalawang laro ng limang-larong serye sa Seoul, naglagay ang isang makina na tinatawag na AlphaGo ng isang black stone sa ikalimang linya ng board. Kakaiba ang galaw na iyon na inisip ng mga human commentator na isang pagkakamali ito. May propesyunal na nagsabi nang malakas na isang beginner ay pagsasabihan kung ganito maglaro. Tumindig si Lee Sedol — 18-time world champion sa larong Go — at umalis ng silid para tumahimik.

Hindi ito pagkakamali. Limampung galaw ang pagkatapos, ang bato na iyon — kilala na ngayon bilang “Move 37” — ang pinagtuwiran ng buong laro. Nanalo ang AlphaGo. Natalo si Lee Sedol, isa sa mga itinuturing na pinakamagaling na maglaro pa, ng 4–1 sa serye. At ito ang mahalagang bahagi: walang taong tinuruan ang AlphaGo ng galaw na iyon. Wala ito sa kahit anong textbook. Natuklasan ito ng makina nang mag-isa, sa paglalaro ng milyon-milyong laro laban sa sarili nito at pag-aadjust ng bilyon-bilyong maliliit na internal na numero hanggang lumitaw ang isang pattern na wala pang taong nakita.

Ang Go ay may mas maraming posibleng board positions kaysa sa bilang ng atom sa observable universe. Hindi mo ito puwedeng brute-force. Hindi mo puwedeng isulat ang mga panuntunan para dito. Ang tanging paraan para maglaro nito sa superhuman na level ay pag-aralan ito — at ang bagay na nagpapaaral ay isang Neural Network: isang stack ng simpleng mathematical units na, dahil sa sapat na data at sapat na adjustment, nakakahanap ng structure na wala pang taong buong-buong maipapahayag.

Ang parehong makinarya — ang parehong weighted sums, ang parehong training loop, ang parehong gradient nudges — ang nagpapatakbo sa language model na kausap mo, ang system na nagfla-flag ng fraudulent card transactions, at ang mga modelong itinutok na ng mga quantitative fund sa financial markets. Ang leksyon na ito ay tungkol sa talagang nangyayari sa loob ng kahong iyon.

Ang bawat Neural Network — mula sa isang simpleng spam filter hanggang sa GPT hanggang sa AlphaGo — ay pinagmulan sa isang ideya: ang Perceptron, na inimbento ni Frank Rosenblatt noong 1958. Isang mathematical model ito na maluwag ang inspirasyon mula sa isang biological neuron. Ang totoong neuron ay tumatanggap ng electrical signals sa pamamagitan ng dendrites nito, naipupon ang mga ito sa cell body, at magpapaputok lang ng signal pababa sa axon nito kung tinatawid ang kombinasyong input ang isang threshold. Ginagawa ng Perceptron ang parehong bagay, lang na numero sa halip na voltage.

Kumukuha ang isang Perceptron ng isang vector ng mga input na x, i-multiply ang bawat input sa isang natutunang Weight na w, idagdag ang mga produkto, magdagdag ng isang Bias na term na b na nagbabago ng threshold, at ipapasa ang resulta sa isang Activation Function. Kung natapos ng resulta ang bar, “nagpaputok” ang neuron; kung hindi, tahimik ito. Ang buong bagay ay isang compact expression: output = f(w·x + b).

Isipin ang mga weight bilang volume knobs. Dumarating ang bawat input na may kaninong lakas, at ang weight ang nagpapasya kung gaano ang bagay na input na ito para sa partikular na neuron na ito. Ang isang neuron na natututong matukoy ang isang fraudulent na trade ay puwedeng itaas ang weight sa “transaction size relative to account history” at ibaba ang weight sa “time of day.” Ang pag-aaral, sa kaibuturan nito, ay hindi hihigit pa kaysa sa pagbabago sa mga knob patungo sa tamang settings.

May matigas na limitasyon ang iisang Perceptron: mahahati lang nito ang data sa pamamagitan ng isang tuwid na linya (o, sa mas mataas na dimensyon, isang flat hyperplane). Puwede nitong sagutin ang “nasa itaas o nasa ibaba ba ng linya ang puntong ito?” pero hindi ang “nasa loob ba ng curved region ang puntong ito?” Ang historikal na halimbawa ay ang XOR problem — isang pattern na napatunayang hindi kayang matutunan ng isang iisang Perceptron, isang limitasyon na nagtulong magyelo ng AI funding sa loob ng maraming taon noong 1970s. Ang eskapo ay halos absurdong simple kung babalikan: i-stack ang maraming Perceptron sa mga layer at ilagay ang isang nonlinear na activation sa pagitan nila. Gawin ito, at ang resultang network ay makakayukod, makakatiklop, at makakaukit ng espasyo sa arbitrong komplikadong hugis.

Isang knob ang isang neuron. Isang kapaki-pakinabang na network ay libo-libo sa kanila, na naayos sa mga Layer na nagpapasa ng impormasyon pasulong tulad ng isang bucket brigade.

• Input layer — kung saan pumapasok ang raw features mo: mga pixel ng isang larawan, mga salita ng isang pangungusap, o para sa isang trading model, mga bagay gaya ng presyo, volume, volatility, at order-book imbalance.
• Hidden layers — ang mga layer sa pagitan, kung saan nagaganap ang totoong trabaho. Kumukuha ang bawat layer ng outputs ng nauna at pinagsasama-samang ang mga ito patungong bago, mas abstract na features.
• Output layer — ang final na sagot: isang probability, isang price forecast, isang class label.

Simpleng ang kahulugan ng salitang “deep” sa deep learning ay maraming hidden layer. At binibigyan ka ng depth ng isang partikular na bagay: isang hierarchy ng features. Sa isang image network, natukoy ng unang layer ang mga edge, isinasama-sama ng susunod ang mga edge patungo sa mga hugis, isinasama-sama ng susunod pa ang mga hugis patungo sa mga bagay. Walang nag-program ng “edge detector” o “eye detector” — lumitaw ang mga konseptong iyon mula sa training. Iniimbento ng network ang sariling intermediate na bokabularyo nito.

May isang magandang teoretikal na resulta dito, ang universal approximation theorem: isang network na may isa lang na hidden layer, dahil sa sapat na neuron, ay puwedeng approximate-han ang kahit anong continuous function sa arbitraryong accuracy. Sa madaling salita, ang tamang network ay puwedeng, sa prinsipyo, i-represent ang kahit anong pattern na umiiral sa iyong data. Ang catch — at isa itong malaking catch — ay ang “sa prinsipyo” ay gumagawa ng mabigat na trabaho dito. Ipinapangako ng theorem na umiiral ang isang network na ganito; walang sinasabi ito kung mahahanap mo ito, kung sapat ang data mo para mapin-point ito, o kung totoo pa man ang pattern na hinahabol mo. Sa mga domain na may mababang signal gaya ng finance, ang gap na iyon sa pagitan ng “representable” at “learnable” ay eksakto kung saan namamatay ang karamihan sa mga modelo.

Ito ang isang katotohanang nagulantang sa mga tao: kung walang activation functions, walang halaga ang depth. Kung ang bawat layer ay isang plain weighted sum, mathematically identical ang pagstack ng sampung layer sa iisang layer — nagcollapse ang isang chain ng linear operations patungo sa isang linear operation. Nagastos ka ng malaking pera sa compute para makagawa ng napalamutiang tuwid na linya. Ang activation functions ang nonlinear na yukod na ipinasok sa pagitan ng mga layer na nagpapahintulot sa network na yumuko, at ang yumuko ang bagay na gumagawa nito na makapangyarihan.

Ang mga activation na dapat malaman ng bawat practitioner:

• Sigmoid — σ(x) = 1/(1+e⁻ˣ). Nagpipiga ng kahit anong input patungo sa (0, 1), na natural na nababasa bilang isang probability. Magaling para sa isang binary na output, pero masamang piliin sa loob ng hidden layers: para sa malaking positibo o negatibong input, papatag ang curve, magiging malapit sa zero ang gradient nito, at hihinto ang pag-aaral — ang vanishing gradient na problema.
• Tanh — outputs sa (−1, 1) at zero-centered, na nakakatulong sa optimization. Sumasaturate pa rin sa mga extreme, pero hindi kasingtindi ng sigmoid.
• ReLU — f(x) = max(0, x). Ang modernong default para sa hidden layers. Napakasimple nito, mura ang pagko-compute, at pinananatili ang isang malusog na gradient para sa lahat ng positibong input. Ang kahinaan nito ay ang “dying ReLU”: isang neuron na naitulak patungong laging output ng zero ay puwedeng maging permanenteng inert.
• Leaky ReLU — f(x) = max(0.01x, x). Pinapahintulutan ang isang maliit na patak ng gradient para sa negatives, na pinananatiling hindi namamatay ang mga neuron.
• GELU — isang makinis, probabilistikong pinsan ng ReLU na standard sa loob ng transformers gaya ng BERT at GPT.

Sa ngayon, may network tayong puno ng weights. Pero saan galing ang tamang mga value ng weight? Walang nag-type ng mga ito nang manual — milyon-milyon sila. Natuklasan ang mga ito sa pamamagitan ng isang feedback loop na, sa kaibuturan, organized na trial and error na may calculus na ginagawa ang bookkeeping.

Unang hakbang ay ang forward pass: ipasok ang isang halimbawa, hayaan itong dumaloy sa mga layer, at basahin ang isang prediction. Ikalawang hakbang ay sukatin kung gaano kali ang prediction na iyon gamit ang isang loss function. Para sa paghula ng isang numero (isang presyo), pinapa-average ng Mean Squared Error ang squared na agwat sa pagitan ng prediction at truth. Para sa classification, sinusukat ng cross-entropy kung gaano kalayo ang predicted na probabilities mula sa tamang sagot. Ang mataas na loss ay nangangahulugan ng “sobrang mali”; ang buong layunin ng training ay itulak pababa ang numerong iyon.

Ikatlong hakbang ang matalinong bahagi: backpropagation. Gamit ang chain rule ng calculus, gumagawa ang algorithm pabalik mula sa loss sa bawat layer at kina-kalkula, para sa bawat iisang weight, ang isang gradient — ang sagot sa “kung itataas ko nang bahagya ang isang weight na ito, tumaas o bumaba ba ang error, at gaano?” Ito ang trick na nagpainit ng AI winter. Ang backprop, na naging sikat noong 1980s, ay naghayag na posibleng i-assign ang blame sa milyon-milyong weight nang efficient sa halip na basta magpalagay.

Ikaapat na hakbang ay ang gradient descent: itulak ang bawat weight nang maliit na hakbang patungo sa direksyon na binabawasan ang loss, gamit ang panuntunan na w = w − α × ∂L/∂w. Isipin na nakatayo ka sa isang burol na may hamog na sinusubukang abutin ang sahig ng lambak; hindi mo makita ang ilalim, pero maramdaman mo kung saang direksyon ang pababa sa ilalim ng iyong paa, kaya humahakbang ka sa direksyon na iyon at ulit-ulitin. Ang Learning Rate na α ay ang iyong haba ng hakbang, at ito arguably ang pinakamahalagang dial sa buong system. Sobrang malaki at lalampas ka sa lambak at tatalbog nang walang tigil; sobrang maliit at kikuyad ka sa walang katapusan o matiklop sa isang ditch pahalfway.

Dalawang refinement na makikita mo agad. Mini-batches: sa halip na mag-update pagkatapos ng bawat iisang halimbawa (maingay) o pagkatapos lang ng buong dataset (mabagal), nag-update ka pagkatapos ng maliit na batch — karaniwang 32 hanggang 256 na halimbawa — na stable, GPU-friendly, at ang sweet spot sa praktika. At ang Adam: isang mas matalinong optimizer na nagbibigay sa bawat weight ng sariling adaptive stride at nagdadagdag ng momentum para pinuhin ang maingay na gradients. Ang Adam ang makatuwirang default para simulan sa halos kahit anong proyekto — bagama't sa finance, na may mababang signal-to-noise ratio, kailangan mo pa ring i-tune manually ang learning rate, weight decay, at stopping point.

Ito ang failure mode na sinisira ang mas marami pang financial model kaysa sa iba. Ang isang Neural Network ay sobrang flexible na function-fitter na, kung mabigyan ng pagkakataon, ma-memorize ang iyong training data nang tuluyan — kasama ang lahat ng random noise, ang one-off flukes, at ang mga pagkakataon na hindi na maulit. Napakaganda ang score nito sa data na nakita na nito at bumagsak sa sandaling makatagpo ng bago. Ito ang Overfitting, at sa mga market — kung saan mahina ang totoong signal at bingi ang ingay — ito ang default na kinalabasan, hindi ang exception. Tinatawag na Regularization ang mga tools na lumalaban dito.

Ang pinakasikat ay ang Dropout. Sa bawat hakbang ng training, may probability na p ang bawat neuron (madalas na 0.2–0.5) na pansamantalang isasarado. Pinuwersa na magtrabaho kahit kapag paulit-ulitng nawawala ang mga random na kasama, natuto ang network na ipakalat ang kaalaman nito sa marami-raming neuron sa halip na itaya lahat sa ilang pira-piraso — isang ensemble effect na baked in sa isang modelo. Sa oras ng prediction, bumalik ang lahat ng neuron, na naka-scale nang naaangkop.

Nagdadagdag ang L1 at L2 penalties ng buwis sa malalaking weight patungo sa loss. Pumipigil ang L2 (weight decay) sa kahit anong iisang weight na lumaki nang labis, na kinakalat ang impluwensya nang pantay-pantay. Mas matalim ang L1: aktibong itinutulak nito ang mga walang-kwentang weight patungong eksaktong zero, na gumaganap ng automatic feature selection. Sa isang financial dataset kung saan karamihan sa iyong isang daang features ay ingay lang, puwedeng tahimik na mahanap ng L1 ang iilang naghahatid talaga ng signal.

Rinescale ng Batch normalization ang outputs ng bawat layer patungo sa isang stable na mean at variance, na nagpapatatag ng training at nagbibigay-daan sa mas mataas na learning rates. Ang Early stopping ang pinakasimple at pinaka-maaasahang guard sa lahat: bantayan ang error sa isang held-out na validation set, at sa sandaling magsimula itong tumaas habang bumabagsak pa rin ang training error, itigil — ang crossover na iyon ang eksaktong sandaling lumipat ang network mula pag-aaral ng patterns patungo sa pag-memorize ng ingay.

Ang plain feedforward networks ay tratado ang bawat input bilang isang unstructured na bag ng numero. Pero marami sa totoong data ay may structure — ang isang larawan ay may spatial layout, ang isang price series ay may temporal order — at dalawang specialized na architecture ang direktang nag-e-exploit ng structure na iyon.

Ang Convolutional Neural Networks (CNNs) ay ginawa para sa mga larawan. Sa halip na ikonekta ang bawat pixel sa bawat neuron, ang isang CNN ay nagpapadausdaus ng maliliit na filters sa buong input, hinahabol ang mga local patterns — isang edge dito, isang texture doon — at ginagamit ulit ang parehong filter sa lahat ng lugar. Nakikita ng mga maagang layer ang mga edge; nagbubuo ang mas malalim na layer ng mga hugis at mga bagay. Sa finance, itinutok ng mga researcher ang mga CNN sa:

• Mga imahen ng candlestick chart — muling binabalangkas ang pagbasa ng chart bilang isang visual pattern-recognition task.
• Order-book heatmaps — pinapansin ang supply/demand imbalances sa depth-of-market snapshots.
• 1D convolutions sa raw na price sequences — pinag-aaralan ang maiikling temporal motif sa parehong paraan na natutunan ng isang image CNN ang spatial motifs.

Ang Recurrent Neural Networks (RNNs) ay ginawa para sa sequences. Prinoproseso nila ang isang time step sa isang pagkakataon habang dinadala ang isang hidden state — isang tumatakbong memory — mula sa bawat hakbang patungo sa susunod. Sa teorya, ginagawa nito silang ideal para sa time series. Sa praktika, ang vanilla RNNs ay pilay dahil sa problemang vanishing gradient sa loob ng mahahabang sequences: nagliliit ang signal mula sa maraming hakbang na nakalipas patungo sa zero sa daan pabalik, kaya basta lang nakakalimutan ng network ang malayong nakaraan.

Inaayos ng mga Long Short-Term Memory (LSTM) na networks ito gamit ang isang maliit na grupo ng natutunang gates — forget, input, at output — na nagpapasya sa bawat hakbang kung ano ang buburahin sa memory, ano ang isusulat, at ano ang babasahin. Pinapahintulutan ng gating na hawakan ng isang LSTM ang mahalagang impormasyon sa loob ng daan-daang hakbang, na kung bakit ito naging workhorse para sa modeling ng financial time series kung saan ang isang kaganapan mula kahapon ay gumagalaw pa rin sa presyo ngayon.

import torch.nn as nn

class PricePredictor(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_layers):
        super().__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim,
                            num_layers, batch_first=True,
                            dropout=0.2)
        self.fc = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        out, _ = self.lstm(x)
        return self.fc(out[:, -1, :])

Sa isang platform gaya ng GaiaEx, kung saan streaming ang WebSocket feeds ng patuloy na price at order-book data, natural na puwedeng ubusin ng LSTM ang sequence na iyon. Gayunpaman, malaki na ang naisagawa ng field: ang transformers — ang architecture na nasa likod ng modernong language models — ay nakakatugma na o nakakatalo sa mga LSTM sa maraming sequence task sa paggamit ng “attention” para tingnan ang lahat ng time step nang sabay-sabay sa halip na dumadaan sa mga ito nang isa-isa.

Ang Neural Networks ay napakahusay na pattern-finders. Pero ang honest na edukasyon ay pagbanggit kung saan sila nasisira — at sa trading, nasisira sila sa mamahaling paraan.

• Nakakahanap sila ng patterns kahit walang umiiral. Bigyan mo ng ingay ang isang deep network at kumpiyansa nitong iaayos ito. Karamihan sa market ay ingay, kaya nasa iyo ang burden of proof para ipakita na totoo at paulit-ulit ang isang pattern — hindi lang basta present sa data ng huling taon.
• Sila ay black boxes. Puwedeng accurate ang isang modelo at hindi pa rin masabi sa iyo kung bakit. Kapag biglang nawalan ito ng pera, madalas walang malinis na paliwanag at walang malinaw na solusyon. Para sa capital na may panganib, ang “hindi ko alam bakit iyon ang gawa nito” ay isang seryosong liability.
• Sila ay gutom at marupok. Nagniningning ang deep learning kasama ang milyon-milyong malinis na halimbawa. Ang financial history ay maikli, non-stationary, at maingay — puwedeng basta huminto sa pag-iral ang regime na sumanay ng iyong modelo, isang problemang tinatawag na distribution shift.
• Hindi sila palaging tumatalo sa mas simpleng modelo nang libre. Sa tabular, feature-based na data na karaniwan sa finance, ang gradient-boosted trees gaya ng XGBoost ay madalas na humihigit sa neural networks habang mas mabilis mag-train at mas madaling interpretin. Ang complexity ay isang gastos, hindi isang virtue.
• Puwede silang atakehin. Ang maliit, sadyang perturbations sa isang input ay puwedeng biglain ang output ng isang network — isang adversarial example — na mahalaga saanman puwedeng hubugin ng isang adversary ang nakikita ng iyong modelo.

Mabigat sa arithmetic ang training ng neural networks — halos lahat matrix multiplications — at ang hardware na pinapatakbuhin mo ito ay binabago ang iyong bilis ng iteration mula “sa isang gabi” patungong “habang nagkape.”

Standard ang GPUs. Pinapatakbo ang parehong operasyon sa iba't ibang data nang sabay-sabay ng libo-libong cores nito, na eksaktong hugis ng matematika ng neural network. Ang isang modelong dumadausdaus sa 8 oras sa isang CPU ay puwedeng matapos sa 15 minuto sa isang modernong GPU. Dominante ang NVIDIA: ang mga consumer cards (isang RTX-class GPU) ay maganda para sa pag-aaral, habang ang data-center cards (A100, H100) at cloud instances ay hawakan ang production-scale training. Ang TPUs, ang custom chips ng Google para sa tensor math, ay nagniningning sa napakalaking modelo sa pamamagitan ng Google Cloud, pero ang GPUs ay nananatiling praktikal na default para sa karamihan ng practitioners salamat sa mas malawak na software support.

Hindi mo kailangang bumili ng anuman para magsimula. Nagbibigay ang Google Colab ng libreng GPU time na sapat para sa pag-aaral at prototyping; magrent ng cloud GPUs on demand habang lumalaki ang iyong modelo; bumili lang ng dedicated hardware kapag araw-araw ka nang nagsasanay at nagbibigay-katwiran na ang cloud bill.

Isang matinong learning path mula rito:

• Simulan sa isang plain feedforward network sa ilang engineered features — mabilis mag-train, madaling debug, at isang honest na baseline.
• Subukan ang isang 1D CNN sa raw price sequences at ikompara ito head-to-head laban sa baseline na iyon.
• Bumuo ng isang LSTM na naguubos ng sequences ng candlestick data mula sa API ng GaiaEx.
• Pag-aralan ang attention at transformers — nagiging arkitekturang pinipiling gamitin para sa sequences.
• Higit sa lahat, laging itaya ang iyong deep model laban sa isang gradient-boosting baseline gaya ng XGBoost. Kung hindi kaya ng neural network na talunin ang mas simpleng modelo out-of-sample sa iyong tabular financial data, i-ship ang mas simpleng modelo at magpatuloy.

Ang parehong loop na natagpuan ang Move 37 — hulaan, sukatin ang error, iadjust ang weights, ulitin — ang loop na tumatakbo sa loob ng bawat system sa listahang ito. Intindihin ang loop na iyon at maintindihan mo ang deep learning; ang natitira ay architecture at engineering sa ibabaw nito.