Kunstmatige intelligentie (AI) heeft de afgelopen jaren een aanzienlijke populariteit gewonnen.
Als u een software-engineer, computerwetenschapper of data science-enthousiasteling in het algemeen bent, dan bent u waarschijnlijk geïntrigeerd door de verbazingwekkende toepassingen van beeldverwerking, patroonherkenning en objectdetectie die dit vakgebied biedt.
Het belangrijkste deelgebied van AI waar je waarschijnlijk van gehoord hebt, is Deep Learning. Dit veld richt zich op krachtige algoritmen (computerprogramma-instructies) gemodelleerd naar de functionaliteit van het menselijk brein, bekend als: Neurale netwerken.
In dit artikel bespreken we het concept van neurale netwerken en hoe deze modellen te bouwen, compileren, passen en evalueren met behulp van Python.
Neurale netwerken
Neurale netwerken, of NN's, zijn een reeks algoritmen die zijn gemodelleerd naar de biologische activiteit van het menselijk brein. Neurale netwerken bestaan uit knooppunten, ook wel neuronen genoemd.
Een verzameling verticale knooppunten worden lagen genoemd. Het model bestaat uit één invoer, één uitvoer en een aantal verborgen lagen. Elke laag bestaat uit knooppunten, ook wel neuronen genoemd, waar de berekeningen plaatsvinden.
In het volgende diagram stellen de cirkels de knooppunten voor en de verticale verzameling knooppunten de lagen. Er zijn drie lagen in dit model.
De knooppunten van de ene laag zijn via transmissielijnen verbonden met de volgende laag, zoals hieronder te zien is.
Onze dataset bestaat uit gelabelde data. Dit betekent dat aan elke data-entiteit een bepaalde naamwaarde is toegewezen.
Dus voor een dataset voor dierclassificatie hebben we afbeeldingen van katten en honden als onze gegevens, met 'kat' en 'hond' als onze labels.
Het is belangrijk op te merken dat labels moeten worden geconverteerd naar numerieke waarden zodat ons model ze kan begrijpen, dus onze dierenlabels worden '0' voor kat en '1' voor hond. Zowel de data als de labels worden door het model geleid.
Learning
Gegevens worden één entiteit tegelijk aan het model toegevoerd. Deze gegevens worden opgesplitst in brokken en doorgegeven aan elk knooppunt van het model. Knooppunten voeren wiskundige bewerkingen uit op deze brokken.
U hoeft de wiskundige functies of berekeningen voor deze tutorial niet te kennen, maar het is belangrijk om een algemeen idee te hebben van hoe deze modellen werken. Na een reeks berekeningen in één laag, worden gegevens doorgegeven aan de volgende laag, enzovoort.
Eenmaal voltooid, voorspelt ons model het gegevenslabel op de uitvoerlaag (bijvoorbeeld in een dierclassificatieprobleem krijgen we een voorspelling '0' voor een kat).
Het model gaat dan verder met het vergelijken van deze voorspelde waarde met die van de werkelijke labelwaarde.
Als de waarden overeenkomen, neemt ons model de volgende invoer, maar als de waarden verschillen, berekent het model het verschil tussen beide waarden, verlies genoemd, en past het de knooppuntberekeningen aan om de volgende keer overeenkomende labels te produceren.
Kaders voor diep leren
Om neurale netwerken in code te bouwen, moeten we importeren Deep Learning-frameworks bekend als bibliotheken die onze Integrated Development Environment (IDE) gebruiken.
Deze frameworks zijn een verzameling vooraf geschreven functies die ons in deze tutorial zullen helpen. We zullen het Keras-framework gebruiken om ons model te bouwen.
Keras is een Python-bibliotheek die een backend voor diep leren en kunstmatige intelligentie gebruikt, genaamd tensorstroom om met gemak NN's te maken in de vorm van eenvoudige sequentiële modellen.
Keras komt ook met zijn eigen reeds bestaande modellen die ook kunnen worden gebruikt. Voor deze tutorial zullen we ons eigen model maken met Keras.
U kunt meer te weten komen over dit Deep Learning-framework op de: Keras-website.
Een neuraal netwerk bouwen (zelfstudie)
Laten we verder gaan met het bouwen van een neuraal netwerk met Python.
Probleemstelling
Neurale netwerken zijn een soort oplossing voor op AI gebaseerde problemen. Voor deze tutorial gaan we over de Pima Indians Diabetes Data, die beschikbaar is hier.
UCI Machine Learning heeft deze dataset samengesteld en bevat een medisch dossier van Indiase patiënten. Ons model moet voorspellen of de patiënt binnen 5 jaar diabetes krijgt of niet.
Gegevensset laden
Onze dataset is een enkel CSV-bestand genaamd 'diabetes.csv' dat gemakkelijk kan worden gemanipuleerd met Microsoft Excel.
Voordat we ons model maken, moeten we onze dataset importeren. Met behulp van de volgende code kunt u dit doen:
importeer panda's als pd
data = pd.read_csv('diabetes.csv')
x = data.drop(“Resultaat”)
y = gegevens[“Resultaat”]
Hier gebruiken we de Pandas bibliotheek om onze CSV-bestandsgegevens te kunnen manipuleren, read_csv() is een ingebouwde functie van Pandas waarmee we de waarden in ons bestand kunnen opslaan in een variabele genaamd 'data'.
De variabele x bevat onze dataset zonder de uitkomst (labels) data. We bereiken dit met de functie data.drop() die de labels voor x verwijdert, terwijl y alleen de uitkomstgegevens (label) bevat.
Sequentieel model bouwen
Stap 1: Bibliotheken importeren
Ten eerste moeten we TensorFlow en Keras importeren, samen met bepaalde parameters die nodig zijn voor ons model. Met de volgende code kunnen we dit doen:
importeer tensorflow als tf
van tensorflow import keras
van tensorflow.keras.models import Sequential
van tensorflow.keras.layers import Activation, Dense
van tensorflow.keras.optimizers importeer Adam
van tensorflow.keras.metrics import categorical_crossentropy
Voor ons model importeren we dichte lagen. Dit zijn volledig verbonden lagen; dwz elk knooppunt in een laag is volledig verbonden met een ander knooppunt in de volgende laag.
We importeren ook een activering functie die nodig is voor het schalen van gegevens die naar knooppunten worden verzonden. Optimizers zijn ook geïmporteerd om verlies te minimaliseren.
Adam is een bekende optimizer die de berekeningen van onze modelupdateknooppunten efficiënter maakt, samen met: categorical_crossentropy dat is het type verliesfunctie (berekent het verschil tussen werkelijke en voorspelde labelwaarden) dat we zullen gebruiken.
Stap 2: Ons model ontwerpen
Het model dat ik aan het maken ben, heeft één invoerlaag (met 16 eenheden), één verborgen (met 32 eenheden) en één uitvoerlaag (met 2 eenheden). Deze aantallen staan niet vast en zijn volledig afhankelijk van het gegeven probleem.
Het instellen van het juiste aantal eenheden en lagen is een proces dat in de loop van de tijd door oefening kan worden verbeterd. Activering komt overeen met het type schaling dat we op onze gegevens zullen uitvoeren voordat deze door een knooppunt worden geleid.
Relu en Softmax zijn bekende activeringsfuncties voor deze taak.
model = sequentieel([
Dicht (eenheden = 16, input_shape = (1,), activatie = 'relu'),
Dicht (eenheden = 32, activering = 'relu'),
Dicht (eenheden = 2, activering = 'softmax')
])
Hier is hoe de samenvatting van het model eruit zou moeten zien:
Het model trainen
Ons model zal in twee stappen worden getraind, de eerste is het compileren van het model (het model samenstellen) en de volgende is het passen van het model op een bepaalde dataset.
Dit kan gedaan worden met de functie model.compile() gevolgd door de functie model.fit().
model.compile(optimizer = Adam(learning_rate = 0.0001), loss = 'binary_crossentropy', metrics = ['nauwkeurigheid'])
model.fit(x, y, tijdperken = 30, batch_size = 10)
Door de metriek 'nauwkeurigheid' te specificeren, kunnen we de nauwkeurigheid van ons model tijdens de training observeren.
Omdat onze labels de vorm hebben van enen en nullen, zullen we een binaire verliesfunctie gebruiken om het verschil tussen werkelijke en voorspelde labels te berekenen.
De dataset wordt ook opgesplitst in batches van 10 (batch_size) en zal 30 keer door het model gaan (epochs). Voor een gegeven dataset zou x de data zijn en y de labels die overeenkomen met de data.
Testmodel met voorspellingen
Om ons model te evalueren, doen we voorspellingen op de testgegevens met behulp van de predict()-functie.
voorspellingen = model.predict(x)
En dat is het!
U zou nu een goed begrip moeten hebben van de Diepe leren applicatie, neurale netwerken, hoe ze in het algemeen werken en hoe je een model in Python-code bouwt, traint en test.
Ik hoop dat deze tutorial je de kickstart geeft om je eigen Deep Learning-modellen te maken en te implementeren.
Laat ons in de reacties weten of het artikel nuttig was.
Laat een reactie achter