Kunsmatige intelligensie (KI) het die afgelope paar jaar aansienlike gewildheid verwerf.
As jy 'n sagteware-ingenieur, rekenaarwetenskaplike of datawetenskap-entoesias in die algemeen is, dan is jy waarskynlik geïntrigeerd deur die wonderlike toepassings van beeldverwerking, patroonherkenning en objek-opsporing wat deur hierdie veld verskaf word.
Die belangrikste subveld van KI waarvan u waarskynlik gehoor het, is Deep Learning. Hierdie veld fokus op kragtige algoritmes (rekenaarprograminstruksies) gemodelleer na menslike breinfunksionaliteit bekend as Neurale netwerke.
In hierdie artikel gaan ons oor die konsep van neurale netwerke en hoe om hierdie modelle te bou, saam te stel, te pas en te evalueer deur gebruik te maak van Python.
Neurale netwerke
Neurale netwerke, of NN'e, is 'n reeks algoritmes wat gemodelleer is na die biologiese aktiwiteit van die menslike brein. Neurale netwerke bestaan uit nodusse, ook genoem neurone.
'n Versameling vertikale nodusse staan bekend as lae. Die model bestaan uit een inset, een uitset en 'n aantal versteekte lae. Elke laag bestaan uit nodusse, ook genoem neurone, waar die berekeninge plaasvind.
In die volgende diagram verteenwoordig die sirkels die nodusse en die vertikale versameling nodusse verteenwoordig die lae. Daar is drie lae in hierdie model.
Die nodusse van een laag is deur transmissielyne aan die volgende laag verbind, soos hieronder gesien.
Ons datastel bestaan uit benoemde data. Dit beteken dat elke data-entiteit 'n sekere naamwaarde toegeken is.
Dus vir 'n diereklassifikasiedatastel sal ons beelde van katte en honde as ons data hê, met 'kat' en 'hond' as ons etikette.
Dit is belangrik om daarop te let dat etikette na numeriese waardes omgeskakel moet word vir ons model om daarvan sin te maak, dus word ons diere-etikette '0' vir kat en '1' vir hond. Beide die data en die byskrifte word deur die model gestuur.
Leer
Data word een entiteit op 'n slag na die model gevoer. Hierdie data word in stukke opgebreek en deur elke nodus van die model gestuur. Nodes voer wiskundige bewerkings op hierdie stukke uit.
Jy hoef nie die wiskundige funksies of berekeninge vir hierdie tutoriaal te ken nie, maar dit is belangrik om 'n algemene idee te hê van hoe hierdie modelle werk. Na 'n reeks berekeninge in een laag, word data na die volgende laag deurgegee, ensovoorts.
Sodra dit voltooi is, voorspel ons model die data-etiket by die uitsetlaag (byvoorbeeld, in 'n diereklassifikasieprobleem kry ons 'n voorspelling '0' vir 'n kat).
Die model gaan dan voort om hierdie voorspelde waarde met dié van die werklike etiketwaarde te vergelyk.
As die waardes ooreenstem, sal ons model die volgende invoer neem, maar as die waardes verskil, sal die model die verskil tussen beide waardes, genoem verlies, bereken en nodusberekeninge aanpas om volgende keer bypassende etikette te produseer.
Diep leerraamwerke
Om neurale netwerke in kode te bou, moet ons invoer Diep leer raamwerke bekend as biblioteke wat ons Geïntegreerde Ontwikkelingsomgewing (IDE) gebruik.
Hierdie raamwerke is 'n versameling voorafgeskrewe funksies wat ons in hierdie tutoriaal sal help. Ons sal die Keras-raamwerk gebruik om ons model te bou.
Keras is 'n Python-biblioteek wat 'n diep leer- en kunsmatige intelligensie-agtergrond gebruik genaamd Tensorstroom om NN'e in die vorm van eenvoudige opeenvolgende modelle met gemak te skep.
Keras kom ook met sy eie bestaande modelle wat ook gebruik kan word. Vir hierdie tutoriaal sal ons ons eie model skep deur Keras te gebruik.
Jy kan meer leer oor hierdie Deep Learning-raamwerk by die Keras webwerf.
Bou 'n neurale netwerk (tutoriaal)
Kom ons gaan voort met die bou van 'n neurale netwerk met Python.
Probleemstelling
Neurale netwerke is 'n tipe oplossing vir KI-gebaseerde probleme. Vir hierdie tutoriaal sal ons die Pima Indians Diabetes Data oorgaan, wat beskikbaar is na hierdie skakel.
ICU Masjienleer het hierdie datastel saamgestel en bevat 'n mediese rekord van Indiese pasiënte. Ons model moet voorspel of die pasiënt binne 5 jaar 'n aanvang van diabetes het of nie.
Laai tans datastel
Ons datastel is 'n enkele CSV-lêer genaamd 'diabetes.csv' wat maklik met Microsoft Excel gemanipuleer kan word.
Voordat ons ons model skep, moet ons ons datastel invoer. Deur die volgende kode te gebruik, kan jy dit doen:
voer pandas in as pd
data = pd.read_csv('diabetes.csv')
x = data.drop(“Uitkoms”)
y = data[“Uitkoms”]
Hier gebruik ons die pandas biblioteek om ons CSV-lêerdata te kan manipuleer, read_csv() is 'n ingeboude funksie van Pandas wat ons toelaat om die waardes in ons lêer te stoor na 'n veranderlike genaamd 'data'.
Die veranderlike x bevat ons datastel sonder die uitkoms (etikette) data. Ons bereik dit met die data.drop() funksie wat die etikette vir x verwyder, terwyl y slegs die uitkoms (etiket) data bevat.
Bou opeenvolgende model
Stap 1: Die invoer van biblioteke
Eerstens moet ons TensorFlow en Keras invoer, saam met sekere parameters wat vir ons model benodig word. Die volgende kode laat ons dit doen:
voer tensorvloei in as tf
van tensorflow invoer keras
vanaf tensorflow.keras.models invoer Sequential
vanaf tensorflow.keras.layers invoer Aktivering, Dig
van tensorflow.keras.optimizers invoer Adam
vanaf tensorflow.keras.metrics voer categorical_crossentropy in
Vir ons model voer ons digte lae in. Dit is volledig gekoppelde lae; dit wil sê, elke nodus in 'n laag is ten volle verbind met 'n ander nodus in die volgende laag.
Ons voer ook 'n in aktivering funksie wat nodig is vir die skaal van data wat na nodusse gestuur word. Optimeerders is ook ingevoer om verlies te minimaliseer.
Adam is 'n bekende optimaliseerder wat ons model-opdateringsnodusberekeninge meer doeltreffend maak, tesame met kategoriese_kruisentropie wat is die tipe verliesfunksie (bereken verskil tussen werklike en voorspelde etiketwaardes) wat ons gaan gebruik.
Stap 2: Ontwerp ons model
Die model wat ek skep het een inset (met 16 eenhede), een versteekte (met 32 eenhede) en een uitset (met 2 eenhede) laag. Hierdie getalle is nie vas nie en sal geheel en al afhang van die gegewe probleem.
Die opstel van die regte aantal eenhede en lae is 'n proses wat oortyd verbeter kan word deur oefening. Aktivering stem ooreen met die tipe skaal wat ons op ons data sal uitvoer voordat dit deur 'n nodus gestuur word.
Relu en Softmax is bekende aktiveringsfunksies vir hierdie taak.
model = Opeenvolgend([
Dig (eenhede = 16, invoervorm = (1,), aktivering = 'relu'),
Dig (eenhede = 32, aktivering = 'relu'),
Dig (eenhede = 2, aktivering = 'softmax')
])
Hier is hoe die opsomming van die model moet lyk:
Opleiding van die model
Ons model sal in twee stappe opgelei word, die eerste is die samestelling van die model (om die model saam te stel) en die volgende is om die model op 'n gegewe datastel te pas.
Dit kan gedoen word deur die model.compile()-funksie gevolg deur die model.fit()-funksie te gebruik.
model.compile(optimizer = Adam(leerkoers = 0.0001), verlies = 'binêre_kruisentropie', metrieke = ['akkuraatheid'])
model.fit(x, y, tydperke = 30, bondelgrootte = 10)
Deur die 'akkuraatheid'-metriek te spesifiseer, kan ons die akkuraatheid van ons model tydens opleiding waarneem.
Aangesien ons etikette in die vorm van 1'e en 0'e is, sal ons 'n binêre verliesfunksie gebruik om die verskil tussen werklike en voorspelde etikette te bereken.
Die datastel word ook opgedeel in groepe van 10 (batch_size) en sal 30 keer deur die model gestuur word (epogs). Vir 'n gegewe datastel sal x die data wees en y sal die byskrifte wees wat ooreenstem met die data.
Toetsmodel deur voorspellings te gebruik
Om ons model te evalueer, maak ons voorspellings oor die toetsdata deur die predict() funksie te gebruik.
voorspellings = model.predict(x)
En dit is dit!
Jy behoort nou 'n goeie begrip te hê van die Diep leer toepassing, neurale netwerke, hoe hulle in die algemeen werk en hoe om 'n model in Python-kode te bou, op te lei en te toets.
Ek hoop hierdie tutoriaal gee jou die wegspring om jou eie Deep Learning-modelle te skep en te ontplooi.
Laat weet ons in die kommentaar of die artikel nuttig was.
Lewer Kommentaar