Artificiell intelligens (AI) har vunnit en betydande popularitet de senaste åren.
Om du är en mjukvaruingenjör, datavetare eller entusiast för datavetenskap i allmänhet, är du förmodligen fascinerad av de fantastiska tillämpningarna av bildbehandling, mönsterigenkänning och objektdetektering som detta område erbjuder.
Det viktigaste underområdet för AI som du förmodligen hört talas om är Deep Learning. Detta fält fokuserar på kraftfulla algoritmer (instruktioner för datorprogram) modellerade efter mänskliga hjärnans funktionalitet som kallas Neurala nätverk.
I den här artikeln går vi igenom konceptet med neurala nätverk och hur man bygger, kompilerar, anpassar och utvärderar dessa modeller med Python.
Neurala nätverk
Neurala nätverk, eller NN, är en serie algoritmer som modelleras efter den biologiska aktiviteten i den mänskliga hjärnan. Neurala nätverk består av noder, även kallade neuroner.
En samling vertikala noder kallas lager. Modellen består av en ingång, en utgång och ett antal dolda lager. Varje lager består av noder, även kallade neuroner, där beräkningarna sker.
I följande diagram representerar cirklarna noderna och den vertikala samlingen av noder representerar lagren. Det finns tre lager i denna modell.
Noderna i ett lager är anslutna till nästa lager genom transmissionsledningar som visas nedan.
Vår datauppsättning består av märkta data. Det betyder att varje dataenhet har tilldelats ett visst namnvärde.
Så för en djurklassificeringsdatauppsättning kommer vi att ha bilder av katter och hundar som våra data, med "katt" och "hund" som våra etiketter.
Det är viktigt att notera att etiketter måste konverteras till numeriska värden för att vår modell ska kunna förstå dem, så våra djuretiketter blir '0' för katt och '1' för hund. Både data och etiketterna skickas genom modellen.
Learning
Data matas till modellen en enhet i taget. Dessa data bryts ner i bitar och skickas genom varje nod i modellen. Noder utför matematiska operationer på dessa bitar.
Du behöver inte känna till de matematiska funktionerna eller beräkningarna för denna handledning, men det är viktigt att ha en allmän uppfattning om hur dessa modeller fungerar. Efter en serie beräkningar i ett lager skickas data vidare till nästa lager och så vidare.
När den är klar förutsäger vår modell dataetiketten vid utlagret (till exempel i ett djurklassificeringsproblem får vi en förutsägelse '0' för en katt).
Modellen fortsätter sedan med att jämföra detta förutsagda värde med det faktiska etikettvärdet.
Om värdena matchar kommer vår modell att ta nästa inmatning men om värdena skiljer sig kommer modellen att beräkna skillnaden mellan båda värdena, kallad förlust, och justera nodberäkningar för att skapa matchande etiketter nästa gång.
Deep Learning Frameworks
För att bygga neurala nätverk i kod måste vi importera Deep Learning ramar känd som bibliotek som använder vår Integrated Development Environment (IDE).
Dessa ramverk är en samling förskrivna funktioner som hjälper oss i den här handledningen. Vi kommer att använda Keras ramverk för att bygga vår modell.
Keras är ett Python-bibliotek som använder en backend för djupinlärning och artificiell intelligens som kallas Tensorflöde att skapa NN i form av enkla sekventiella modeller med lätthet.
Keras kommer också med sina egna redan existerande modeller som också kan användas. För den här handledningen kommer vi att skapa vår egen modell med hjälp av Keras.
Du kan lära dig mer om detta ramverk för Deep Learning från Keras hemsida.
Bygga ett neuralt nätverk (handledning)
Låt oss gå vidare till att bygga ett neuralt nätverk med Python.
Problemdeklaration
Neurala nätverk är en typ av lösning på AI-baserade problem. För denna handledning kommer vi att gå över Pima Indians Diabetes Data, som är tillgänglig här..
UCI Machine Learning har sammanställt denna datauppsättning och innehåller en journal över indiska patienter. Vår modell måste förutsäga om patienten har en diabetesdebut inom 5 år eller inte.
Laddar datauppsättning
Vår datauppsättning är en enda CSV-fil som heter 'diabetes.csv' som enkelt kan manipuleras med Microsoft Excel.
Innan vi skapar vår modell måste vi importera vår datauppsättning. Med hjälp av följande kod kan du göra detta:
importera pandor som pd
data = pd.read_csv('diabetes.csv')
x = data.drop(“Utfall”)
y = data["Utfall"]
Här använder vi pandas biblioteket för att kunna manipulera våra CSV-fildata, read_csv() är en inbyggd funktion i Pandas som låter oss lagra värdena i vår fil till en variabel som kallas 'data'.
Variabeln x innehåller vår datauppsättning utan resultatdata (etiketter). Vi uppnår detta med funktionen data.drop() som tar bort etiketterna för x, medan y endast innehåller utfallsdata (etikett).
Bygga sekventiell modell
Steg 1: Importera bibliotek
För det första måste vi importera TensorFlow och Keras, tillsammans med vissa parametrar som krävs för vår modell. Följande kod låter oss göra detta:
importera tensorflöde som tf
från tensorflow importkeras
från tensorflow.keras.models import Sequential
från tensorflow.keras.layers import Activation, Dense
från tensorflow.keras.optimizers importera Adam
från tensorflow.keras.metrics importera categorical_crossentropy
Till vår modell importerar vi täta lager. Dessa är helt sammankopplade lager; dvs varje nod i ett lager är helt ansluten till en annan nod i nästa lager.
Vi importerar även en aktivering funktion som behövs för att skala data som skickas till noder. optimerare har också importerats för att minimera förlusten.
Adam är en välkänd optimerare som gör vår modelluppdateringsnodberäkningar mer effektivt, tillsammans med categorical_crossentropy som är typen av förlustfunktion (beräknar skillnaden mellan faktiska och förutspådda etikettvärden) som vi kommer att använda.
Steg 2: Designa vår modell
Modellen jag skapar har en ingång (med 16 enheter), en dold (med 32 enheter) och en utgång (med 2 enheter) lager. Dessa siffror är inte fasta och beror helt på det givna problemet.
Att ställa in rätt antal enheter och lager är en process som kan förbättras övertid genom övning. Aktivering motsvarar den typ av skalning vi kommer att utföra på vår data innan vi skickar den genom en nod.
Relu och Softmax är kända aktiveringsfunktioner för denna uppgift.
modell = Sekventiell([
Dense(enheter = 16, input_shape = (1,), aktivering = 'relu'),
Dense(enheter = 32, aktivering = 'relu'),
Dense(enheter = 2, aktivering = 'softmax')
])
Så här ska sammanfattningen av modellen se ut:
Träna modellen
Vår modell kommer att tränas i två steg, det första är att kompilera modellen (sätta ihop modellen) och nästa är att anpassa modellen på en given datamängd.
Detta kan göras med funktionen model.compile() följt av funktionen model.fit().
model.compile(optimizer = Adam(learning_rate = 0.0001), loss = 'binary_crossentropy', metrics = ['precision'])
model.fit(x, y, epoker = 30, batch_size = 10)
Genom att specificera "noggrannhetsmåttet" kan vi observera noggrannheten hos vår modell under träning.
Eftersom våra etiketter är i form av 1:or och 0:or kommer vi att använda en binär förlustfunktion för att beräkna skillnaden mellan faktiska och förutspådda etiketter.
Datauppsättningen delas också upp i satser om 10 (batch_size) och kommer att passeras genom modellen 30 gånger (epoker). För en given datauppsättning skulle x vara data och y skulle vara etiketterna som motsvarar data.
Testa modell med hjälp av förutsägelser
För att utvärdera vår modell gör vi förutsägelser på testdata med hjälp av predict()-funktionen.
predictions = model.predict(x)
Och det är allt!
Du bör nu ha en god förståelse för Deep Learning applikation, Neural Networks, hur de fungerar i allmänhet och hur man bygger, tränar och testar en modell i Python-kod.
Jag hoppas att den här handledningen ger dig en kickstart för att skapa och distribuera dina egna Deep Learning-modeller.
Låt oss veta i kommentarerna om artikeln var till hjälp.
Kommentera uppropet