Ang Artificial Intelligence (AI) ay nakakuha ng malaking halaga ng katanyagan sa mga nakaraang taon.
Kung ikaw ay isang software engineer, computer scientist, o data science sa pangkalahatan, malamang na interesado ka sa mga kamangha-manghang application ng pagpoproseso ng imahe, pagkilala ng pattern at pagtukoy ng bagay na ibinigay ng field na ito.
Ang pinakamahalagang subfield ng AI na malamang na narinig mo ay ang Deep Learning. Nakatuon ang field na ito sa mga mahuhusay na algorithm (mga tagubilin sa computer program) na namodelo sa functionality ng utak ng tao na kilala bilang Mga Neural Network.
Sa artikulong ito, tatalakayin natin ang konsepto ng Mga Neural Network at kung paano bumuo, mag-compile, magkasya at suriin ang mga modelong ito gamit ang Sawa.
Mga Neural Network
Ang mga Neural Network, o NN, ay isang serye ng mga algorithm na na-modelo ayon sa biological na aktibidad ng utak ng tao. Ang mga Neural Network ay binubuo ng mga node, na tinatawag ding mga neuron.
Ang isang koleksyon ng mga vertical node ay kilala bilang mga layer. Ang modelo ay binubuo ng isang input, isang output, at isang bilang ng mga nakatagong layer. Ang bawat layer ay binubuo ng mga node, na tinatawag ding mga neuron, kung saan nagaganap ang mga kalkulasyon.
Sa sumusunod na diagram, ang mga bilog ay kumakatawan sa mga node at ang patayong koleksyon ng mga node ay kumakatawan sa mga layer. Mayroong tatlong mga layer sa modelong ito.
Ang mga node ng isang layer ay konektado sa susunod na layer sa pamamagitan ng mga linya ng paghahatid tulad ng nakikita sa ibaba.
Ang aming dataset ay binubuo ng may label na data. Nangangahulugan ito na ang bawat entity ng data ay itinalaga ng isang tiyak na halaga ng pangalan.
Kaya para sa isang dataset ng pag-uuri ng hayop magkakaroon kami ng mga larawan ng mga pusa at aso bilang aming data, na may 'pusa' at 'aso' bilang aming mga label.
Mahalagang tandaan na ang mga label ay kailangang i-convert sa mga numerical value para sa aming modelo upang magkaroon ng kahulugan ang mga ito, kaya ang aming mga label ng hayop ay nagiging '0' para sa pusa at '1' para sa aso. Parehong ang data at ang mga label ay ipinapasa sa modelo.
Pag-aaral
Ang data ay ibinibigay sa modelo ng isang entity sa isang pagkakataon. Ang data na ito ay pinaghiwa-hiwalay sa mga chunks at ipinasa sa bawat node ng modelo. Ang mga node ay nagsasagawa ng mga mathematical na operasyon sa mga chunks na ito.
Hindi mo kailangang malaman ang mga mathematical function o kalkulasyon para sa tutorial na ito, ngunit mahalagang magkaroon ng pangkalahatang ideya kung paano gumagana ang mga modelong ito. Pagkatapos ng isang serye ng mga kalkulasyon sa isang layer, ang data ay ipinapasa sa susunod na layer at iba pa.
Kapag nakumpleto na, hinuhulaan ng aming modelo ang label ng data sa output layer (halimbawa, sa isang problema sa pag-uuri ng hayop nakakakuha kami ng hula na '0' para sa isang pusa).
Magpapatuloy ang modelo upang ihambing ang hinulaang halaga na ito sa aktwal na halaga ng label.
Kung magkatugma ang mga halaga, kukunin ng aming modelo ang susunod na input ngunit kung magkaiba ang mga halaga, kakalkulahin ng modelo ang pagkakaiba sa pagitan ng parehong mga halaga, na tinatawag na pagkawala, at isasaayos ang mga kalkulasyon ng node upang makagawa ng mga katugmang label sa susunod na pagkakataon.
Deep Learning Frameworks
Upang bumuo ng mga Neural Network sa code, kailangan nating mag-import Mga balangkas ng Deep Learning kilala bilang mga aklatan gamit ang ating Integrated Development Environment (IDE).
Ang mga framework na ito ay isang koleksyon ng mga paunang nakasulat na function na makakatulong sa amin sa tutorial na ito. Gagamitin namin ang balangkas ng Keras para buuin ang aming modelo.
Ang Keras ay isang Python library na gumagamit ng deep learning at artificial intelligence backend na tinatawag daloy ng tensor upang lumikha ng mga NN sa anyo ng mga simpleng sunud-sunod na modelo nang madali.
Ang Keras ay mayroon ding sarili nitong mga preexisting na modelo na magagamit din. Para sa tutorial na ito, gagawa kami ng sarili naming modelo gamit ang Keras.
Maaari kang matuto nang higit pa tungkol sa Deep Learning framework na ito mula sa website ng Keras.
Pagbuo ng Neural Network (Tutorial)
Lumipat tayo sa pagbuo ng isang Neural Network gamit ang Python.
Pahayag ng Suliranin
Ang mga Neural Network ay isang uri ng solusyon sa mga problemang nakabatay sa AI. Para sa tutorial na ito, tatalakayin natin ang Pima Indians Diabetes Data, na available dito.
UCI Na-compile ng Machine Learning ang dataset na ito at naglalaman ng talaang medikal ng mga pasyenteng Indian. Kailangang hulaan ng aming modelo kung ang pasyente ay may simula ng diabetes sa loob ng 5 taon o hindi.
Naglo-load ng Dataset
Ang aming dataset ay isang CSV file na tinatawag na 'diabetes.csv' na madaling mamanipula gamit ang Microsoft Excel.
Bago gawin ang aming modelo, kailangan naming i-import ang aming dataset. Gamit ang sumusunod na code magagawa mo ito:
import pandas bilang pd
data = pd.read_csv('diabetes.csv')
x = data.drop(“Resulta”)
y = data[“Kinalabasan”]
Dito ginagamit namin ang Pandas library upang magawang manipulahin ang aming data ng CSV file, ang read_csv() ay isang built-in na function ng Pandas na nagpapahintulot sa amin na iimbak ang mga halaga sa aming file sa isang variable na tinatawag na 'data'.
Ang variable na x ay naglalaman ng aming dataset nang walang resulta (mga label) na data. Nakamit namin ito gamit ang data.drop() function na nag-aalis ng mga label para sa x, habang ang y ay naglalaman lamang ng resulta (label) na data.
Pagbuo ng Sequential Model
Hakbang 1: Pag-import ng Mga Aklatan
Una, kailangan naming mag-import ng TensorFlow at Keras, kasama ang ilang partikular na parameter na kinakailangan para sa aming modelo. Ang sumusunod na code ay nagpapahintulot sa amin na gawin ito:
mag-import ng tensorflow bilang tf
mula sa tensorflow import keras
mula sa tensorflow.keras.models import Sequential
mula sa tensorflow.keras.layers import Activation, Dense
mula sa tensorflow.keras.optimizers import Adam
mula sa tensorflow.keras.metrics import categorical_crossentropy
Para sa aming modelo nag-i-import kami ng mga siksik na layer. Ang mga ito ay ganap na konektado na mga layer; ibig sabihin, ang bawat node sa isang layer ay ganap na konektado sa isa pang node sa susunod na layer.
Nag-import din kami ng isang aktibasyon function na kailangan para sa pag-scale ng data na ipinadala sa mga node. Mga optimizer ay na-import din upang mabawasan ang pagkalugi.
Si Adam ay isang kilalang optimizer na ginagawang mas mahusay ang aming mga pagkalkula ng node sa pag-update ng modelo, kasama ng categorical_crossentropy which is ang uri ng function ng pagkawala (kinakalkula ang pagkakaiba sa pagitan ng aktwal at hinulaang mga halaga ng label) na aming gagamitin.
Hakbang 2: Pagdidisenyo ng Aming Modelo
Ang modelong ginagawa ko ay may isang input (na may 16 na yunit), isang nakatago (na may 32 na yunit) at isang output (na may 2 yunit) na layer. Ang mga numerong ito ay hindi naayos at ganap na magdedepende sa ibinigay na problema.
Ang pagtatakda ng tamang bilang ng mga unit at layer ay isang proseso na maaaring pahusayin sa overtime sa pamamagitan ng pagsasanay. Ang activation ay tumutugma sa uri ng scaling na aming gagawin sa aming data bago ito ipasa sa isang node.
Ang Relu at Softmax ay mga kilalang activation function para sa gawaing ito.
modelo = Sequential([
Siksik(mga yunit = 16, input_shape = (1,), activation = 'relu'),
Siksik(mga yunit = 32, activation = 'relu'),
Siksik(mga yunit = 2, activation = 'softmax')
])
Narito kung ano ang dapat na hitsura ng buod ng modelo:
Pagsasanay sa Modelo
Ang aming modelo ay sasanayin sa dalawang hakbang, ang una ay ang pag-compile ng modelo (pagsasama-sama ng modelo) at ang susunod ay ang paglalagay ng modelo sa isang ibinigay na dataset.
Magagawa ito gamit ang model.compile() function na sinusundan ng model.fit() function.
model.compile(optimizer = Adam(learning_rate = 0.0001), loss = 'binary_crossentropy', metrics = ['katumpakan'])
model.fit(x, y, epochs = 30, batch_size = 10)
Ang pagtukoy sa sukatan ng 'katumpakan' ay nagbibigay-daan sa amin na obserbahan ang katumpakan ng aming modelo sa panahon ng pagsasanay.
Dahil ang aming mga label ay nasa anyo ng 1's at 0's, gagamit kami ng binary loss function upang kalkulahin ang pagkakaiba sa pagitan ng aktwal at hinulaang mga label.
Hinahati din ang dataset sa mga batch ng 10 (batch_size) at ipapasa sa modelo nang 30 beses (mga panahon). Para sa isang naibigay na dataset, x ang magiging data at y ang mga label na naaayon sa data.
Pagsubok ng Modelo Gamit ang Mga Hula
Upang suriin ang aming modelo, gumagawa kami ng mga hula sa data ng pagsubok gamit ang predict() function.
hula = model.predict(x)
At iyan!
Dapat ay mayroon ka na ngayong mahusay na pag-unawa sa Malalim na Pag-aaral application, Neural Networks, kung paano gumagana ang mga ito sa pangkalahatan at kung paano bumuo, magsanay at sumubok ng modelo sa Python code.
Umaasa ako na ang tutorial na ito ay nagbibigay sa iyo ng kickstart upang lumikha at mag-deploy ng sarili mong mga modelo ng Deep Learning.
Ipaalam sa amin sa mga komento kung nakatulong ang artikulo.
Mag-iwan ng Sagot