Kunstig intelligens (AI) har fått en betydelig popularitet de siste årene.
Hvis du er en programvareingeniør, informatiker eller entusiast for datavitenskap generelt, er du sannsynligvis fascinert av de fantastiske bruksområdene for bildebehandling, mønstergjenkjenning og objektgjenkjenning som tilbys av dette feltet.
Det viktigste underfeltet til AI som du sannsynligvis har hørt om er Deep Learning. Dette feltet fokuserer på kraftige algoritmer (dataprograminstruksjoner) modellert etter menneskelig hjernefunksjonalitet kjent som Nevrale nettverk.
I denne artikkelen skal vi gå over konseptet med nevrale nettverk og hvordan man bygger, kompilerer, tilpasser og evaluerer disse modellene ved å bruke Python.
Nevrale nettverk
Nevrale nettverk, eller NN-er, er en serie algoritmer som er modellert etter den biologiske aktiviteten til den menneskelige hjernen. Nevrale nettverk består av noder, også kalt nevroner.
En samling vertikale noder er kjent som lag. Modellen består av én inngang, én utgang og en rekke skjulte lag. Hvert lag består av noder, også kalt nevroner, hvor beregningene finner sted.
I det følgende diagrammet representerer sirklene nodene og den vertikale samlingen av noder representerer lagene. Det er tre lag i denne modellen.
Nodene til ett lag er koblet til det neste laget gjennom overføringslinjer som vist nedenfor.
Vårt datasett består av merkede data. Dette betyr at hver dataenhet har blitt tildelt en bestemt navneverdi.
Så for et dyreklassifiseringsdatasett vil vi ha bilder av katter og hunder som våre data, med "katt" og "hund" som våre etiketter.
Det er viktig å merke seg at etiketter må konverteres til numeriske verdier for at modellen vår skal gi mening om dem, så dyreetikettene våre blir '0' for katt og '1' for hund. Både dataene og etikettene sendes gjennom modellen.
Learning
Data mates til modellen én enhet om gangen. Disse dataene brytes ned i biter og sendes gjennom hver node i modellen. Noder utfører matematiske operasjoner på disse bitene.
Du trenger ikke å kunne de matematiske funksjonene eller beregningene for denne opplæringen, men det er viktig å ha en generell ide om hvordan disse modellene fungerer. Etter en rekke beregninger i ett lag, sendes data til neste lag og så videre.
Når den er fullført, forutsier modellen vår dataetiketten ved utgangslaget (for eksempel i et dyreklassifiseringsproblem får vi en prediksjon '0' for en katt).
Modellen fortsetter deretter med å sammenligne denne predikerte verdien med verdien til den faktiske etikettverdien.
Hvis verdiene samsvarer, vil modellen vår ta neste input, men hvis verdiene er forskjellige, vil modellen beregne forskjellen mellom begge verdiene, kalt tap, og justere nodeberegninger for å produsere samsvarende etiketter neste gang.
Deep Learning Frameworks
For å bygge nevrale nettverk i kode, må vi importere Rammer for dyp læring kjent som biblioteker som bruker vårt integrerte utviklingsmiljø (IDE).
Disse rammene er en samling av forhåndsskrevne funksjoner som vil hjelpe oss i denne opplæringen. Vi vil bruke Keras-rammeverket for å bygge modellen vår.
Keras er et Python-bibliotek som bruker en dyp lærings- og kunstig intelligens-backend kalt tensorflow å lage NN-er i form av enkle sekvensielle modeller med letthet.
Keras kommer også med sine egne eksisterende modeller som også kan brukes. For denne opplæringen skal vi lage vår egen modell ved å bruke Keras.
Du kan lære mer om dette rammeverket for dyp læring fra Keras nettsted.
Bygge et nevralt nettverk (opplæring)
La oss gå videre til å bygge et nevralt nettverk ved hjelp av Python.
Problemstilling
Nevrale nettverk er en type løsning på AI-baserte problemer. For denne opplæringen vil vi gå gjennom Pima Indians Diabetes Data, som er tilgjengelig her..
UCI Machine Learning har kompilert dette datasettet og inneholder en medisinsk journal over indiske pasienter. Vår modell må forutsi om pasienten har et utbrudd av diabetes innen 5 år eller ikke.
Laster inn datasett
Datasettet vårt er en enkelt CSV-fil kalt 'diabetes.csv' som enkelt kan manipuleres med Microsoft Excel.
Før vi lager modellen vår, må vi importere datasettet vårt. Ved å bruke følgende kode kan du gjøre dette:
importer pandaer som pd
data = pd.read_csv('diabetes.csv')
x = data.drop(“Utfall”)
y = data[“Utfall”]
Her bruker vi pandaer biblioteket for å kunne manipulere CSV-fildataene våre, read_csv() er en innebygd funksjon i Pandas som lar oss lagre verdiene i filen vår til en variabel kalt 'data'.
Variabelen x inneholder datasettet vårt uten utfallsdata (etiketter). Dette oppnår vi med data.drop()-funksjonen som fjerner etikettene for x, mens y kun inneholder utfalls(label)data.
Bygge sekvensiell modell
Trinn 1: Importere biblioteker
For det første må vi importere TensorFlow og Keras, sammen med visse parametere som kreves for modellen vår. Følgende kode lar oss gjøre dette:
importer tensorflow som tf
fra tensorflow import keras
fra tensorflow.keras.models import Sequential
fra tensorflow.keras.layers import Activation, Dense
fra tensorflow.keras.optimizers importerer Adam
fra tensorflow.keras.metrics importer categorical_crossentropy
For vår modell importerer vi tette lag. Disse er fullt koblede lag; dvs. hver node i et lag er fullstendig forbundet med en annen node i det neste laget.
Vi importerer også en aktivering funksjon nødvendig for å skalere data sendt til noder. optimizer har også blitt importert for å minimere tap.
Adam er en kjent optimizer som gjør vår modelloppdatering nodeberegninger mer effektivt, sammen med categorical_crossentropy som er typen tapsfunksjon (beregner forskjellen mellom faktiske og anslåtte etikettverdier) som vi skal bruke.
Trinn 2: Designe modellen vår
Modellen jeg lager har en inngang (med 16 enheter), en skjult (med 32 enheter) og en utgang (med 2 enheter). Disse tallene er ikke faste og vil avhenge helt av det gitte problemet.
Å sette riktig antall enheter og lag er en prosess som kan forbedres overtid gjennom øvelse. Aktivering tilsvarer typen skalering vi skal utføre på dataene våre før de sendes gjennom en node.
Relu og Softmax er kjente aktiveringsfunksjoner for denne oppgaven.
modell = Sekvensiell([
Tett(enheter = 16, input_shape = (1,), aktivering = 'relu'),
Tett(enheter = 32, aktivering = 'relu'),
Tett(enheter = 2, aktivering = 'softmax')
])
Slik skal sammendraget av modellen se ut:
Trening av modellen
Modellen vår vil trenes i to trinn, det første er å kompilere modellen (sette modellen sammen) og det neste er å tilpasse modellen på et gitt datasett.
Dette kan gjøres ved å bruke funksjonen model.compile() etterfulgt av funksjonen model.fit().
model.compile(optimizer = Adam(læringsrate = 0.0001), tap = 'binær_kryssentropi', metrikk = ['nøyaktighet'])
model.fit(x, y, epoker = 30, batch_size = 10)
Ved å spesifisere "nøyaktighet"-beregningen kan vi observere nøyaktigheten til modellen vår under trening.
Siden etikettene våre er i form av 1-er og 0-er, vil vi bruke en binær tapsfunksjon for å beregne forskjellen mellom faktiske og forutsagte etiketter.
Datasettet blir også delt opp i batcher på 10 (batch_size) og vil bli sendt gjennom modellen 30 ganger (epoker). For et gitt datasett vil x være dataene og y vil være etikettene som tilsvarer dataene.
Teste modell ved hjelp av spådommer
For å evaluere modellen vår lager vi spådommer på testdataene ved å bruke predict()-funksjonen.
prediksjoner = model.predict(x)
Og det er det!
Du bør nå ha en god forståelse av Dyp læring applikasjon, nevrale nettverk, hvordan de fungerer generelt og hvordan man bygger, trener og tester en modell i Python-kode.
Jeg håper denne opplæringen gir deg en kickstart for å lage og distribuere dine egne Deep Learning-modeller.
Gi oss beskjed i kommentarene om artikkelen var nyttig.
Legg igjen en kommentar