Kunstig intelligens (AI) har vundet en betydelig mængde popularitet i de seneste år.
Hvis du er softwareingeniør, datalog eller datavidenskabsentusiast generelt, så er du sandsynligvis fascineret af de fantastiske anvendelser af billedbehandling, mønstergenkendelse og objektgenkendelse, som dette felt tilbyder.
Det vigtigste underområde af AI, som du sikkert har hørt om, er Deep Learning. Dette felt fokuserer på kraftfulde algoritmer (computerprograminstruktioner) modelleret efter menneskelig hjernefunktionalitet kendt som Neurale netværk.
I denne artikel vil vi gennemgå begrebet neurale netværk og hvordan man opbygger, kompilerer, tilpasser og evaluerer disse modeller ved hjælp af Python.
Neurale netværk
Neurale netværk, eller NN'er, er en række algoritmer, der er modelleret efter den biologiske aktivitet i den menneskelige hjerne. Neurale netværk består af noder, også kaldet neuroner.
En samling af lodrette noder er kendt som lag. Modellen består af et input, et output og en række skjulte lag. Hvert lag består af noder, også kaldet neuroner, hvor beregningerne finder sted.
I det følgende diagram repræsenterer cirklerne noderne, og den lodrette samling af noder repræsenterer lagene. Der er tre lag i denne model.
Noderne i et lag er forbundet med det næste lag gennem transmissionslinjer som vist nedenfor.
Vores datasæt består af mærkede data. Det betyder, at hver dataenhed er blevet tildelt en bestemt navneværdi.
Så for et dyreklassificeringsdatasæt vil vi have billeder af katte og hunde som vores data, med 'kat' og 'hund' som vores etiketter.
Det er vigtigt at bemærke, at etiketter skal konverteres til numeriske værdier, for at vores model kan give mening med dem, så vores dyremærker bliver '0' for kat og '1' for hund. Både data og etiketter føres gennem modellen.
Learning
Data føres til modellen én enhed ad gangen. Disse data opdeles i bidder og føres gennem hver knude i modellen. Noder udfører matematiske operationer på disse bidder.
Du behøver ikke at kende de matematiske funktioner eller beregninger til denne øvelse, men det er vigtigt at have en generel idé om, hvordan disse modeller fungerer. Efter en række beregninger i et lag, sendes data til det næste lag og så videre.
Når den er afsluttet, forudsiger vores model dataetiketten ved outputlaget (for eksempel får vi i et dyreklassificeringsproblem en forudsigelse '0' for en kat).
Modellen fortsætter derefter med at sammenligne denne forudsagte værdi med værdien for den faktiske etiketværdi.
Hvis værdierne matcher, vil vores model tage det næste input, men hvis værdierne er forskellige, vil modellen beregne forskellen mellem begge værdier, kaldet tab, og justere nodeberegninger for at producere matchende etiketter næste gang.
Deep Learning Frameworks
For at bygge neurale netværk i kode skal vi importere Deep Learning rammer kendt som biblioteker, der bruger vores Integrated Development Environment (IDE).
Disse rammer er en samling af forudskrevne funktioner, som vil hjælpe os i denne øvelse. Vi vil bruge Keras-rammen til at bygge vores model.
Keras er et Python-bibliotek, der bruger en deep learning og kunstig intelligens-backend kaldet Tensorflow at skabe NN'er i form af simple sekventielle modeller med lethed.
Keras kommer også med sine egne allerede eksisterende modeller, som også kan bruges. Til denne tutorial vil vi skabe vores egen model ved hjælp af Keras.
Du kan lære mere om denne Deep Learning-ramme fra Keras hjemmeside.
Opbygning af et neuralt netværk (tutorial)
Lad os gå videre til at bygge et neuralt netværk ved hjælp af Python.
Problemformulering
Neurale netværk er en type løsning på AI-baserede problemer. Til denne tutorial vil vi gennemgå Pima Indians Diabetes Data, som er tilgængelig link..
UCI Machine Learning har kompileret dette datasæt og indeholder en lægejournal over indiske patienter. Vores model skal forudsige, om patienten har debut af diabetes inden for 5 år eller ej.
Indlæser datasæt
Vores datasæt er en enkelt CSV-fil kaldet 'diabetes.csv', som nemt kan manipuleres ved hjælp af Microsoft Excel.
Før vi opretter vores model, skal vi importere vores datasæt. Ved at bruge følgende kode kan du gøre dette:
importer pandaer som pd
data = pd.read_csv('diabetes.csv')
x = data.drop(“Resultat”)
y = data["Resultat"]
Her bruger vi pandas bibliotek for at kunne manipulere vores CSV-fildata, read_csv() er en indbygget funktion i Pandas, der giver os mulighed for at gemme værdierne i vores fil til en variabel kaldet 'data'.
Variablen x indeholder vores datasæt uden resultatdata (etiketter). Det opnår vi med data.drop()-funktionen, der fjerner etiketterne for x, mens y kun indeholder udfalds-(label)-data.
Opbygning af sekventiel model
Trin 1: Import af biblioteker
For det første skal vi importere TensorFlow og Keras sammen med visse parametre, der kræves til vores model. Følgende kode giver os mulighed for at gøre dette:
importer tensorflow som tf
fra tensorflow import keras
fra tensorflow.keras.models import Sequential
fra tensorflow.keras.layers importer Aktivering, tæt
fra tensorflow.keras.optimizers importerer Adam
fra tensorflow.keras.metrics importer categorical_crossentropy
Til vores model importerer vi tætte lag. Disse er fuldt forbundne lag; dvs. hver node i et lag er fuldt forbundet med en anden node i det næste lag.
Vi importerer også en aktivering funktion nødvendig for skalering af data sendt til noder. Optimerer er også blevet importeret for at minimere tab.
Adam er en kendt optimizer, der gør vores modelopdateringsknudeberegninger mere effektivt sammen med categorical_crossentropy som er typen af tabsfunktion (beregner forskellen mellem faktiske og forudsagte etiketværdier), som vi vil bruge.
Trin 2: Design af vores model
Den model, jeg opretter, har et input (med 16 enheder), et skjult (med 32 enheder) og et output (med 2 enheder) lag. Disse tal er ikke faste og vil helt afhænge af det givne problem.
At indstille det rigtige antal enheder og lag er en proces, der kan forbedres overarbejde gennem praksis. Aktivering svarer til den type skalering, vi udfører på vores data, inden vi sender dem gennem en node.
Relu og Softmax er kendte aktiveringsfunktioner til denne opgave.
model = Sekventiel([
Tæt(enheder = 16, input_shape = (1,), aktivering = 'relu'),
Tæt(enheder = 32, aktivering = 'relu'),
Tæt(enheder = 2, aktivering = 'softmax')
])
Sådan skal opsummeringen af modellen se ud:
Træning af modellen
Vores model vil blive trænet i to trin, hvor det første er at kompilere modellen (sætte modellen sammen) og det næste er at tilpasse modellen på et givet datasæt.
Dette kan gøres ved at bruge funktionen model.compile() efterfulgt af funktionen model.fit().
model.compile(optimizer = Adam(læringshastighed = 0.0001), tab = 'binær_krydsentropi', metrics = ['nøjagtighed'])
model.fit(x, y, epoker = 30, batch_size = 10)
Angivelse af 'nøjagtighed'-metrikken giver os mulighed for at observere nøjagtigheden af vores model under træning.
Da vores etiketter er i form af 1'er og 0'er, vil vi bruge en binær tabsfunktion til at beregne forskellen mellem faktiske og forudsagte etiketter.
Datasættet bliver også opdelt i batches af 10 (batch_size) og vil blive sendt gennem modellen 30 gange (epoker). For et givet datasæt vil x være dataene, og y ville være etiketterne svarende til dataene.
Test af model ved hjælp af forudsigelser
For at evaluere vores model laver vi forudsigelser på testdataene ved hjælp af predict()-funktionen.
forudsigelser = model.predict(x)
Og det er det!
Du burde nu have en god forståelse af Deep Learning applikation, Neurale netværk, hvordan de fungerer generelt og hvordan man bygger, træner og tester en model i Python-kode.
Jeg håber, at denne tutorial giver dig kickstarten til at skabe og implementere dine egne Deep Learning-modeller.
Fortæl os i kommentarerne, hvis artiklen var nyttig.
Giv en kommentar