Inhaltsverzeechnes[Verstoppen][Show]
Kënschtlech Intelligenz (AI) huet an de leschte Joeren e wesentleche Betrag u Popularitéit gewonnen.
Wann Dir e Softwareingenieur, Informatiker oder Datenwëssenschaftsbegeeschterten am Allgemengen sidd, da sidd Dir wahrscheinlech begeeschtert vun den erstaunlechen Uwendunge vu Bildveraarbechtung, Mustererkennung an Objekterkennung, déi vun dësem Feld geliwwert ginn.
Dat wichtegst Ënnerfeld vun AI iwwer dat Dir wahrscheinlech héieren hutt ass Deep Learning. Dëst Feld konzentréiert sech op mächteg Algorithmen (Computerprogramminstruktiounen) modelléiert nom mënschleche Gehirfunktionalitéit bekannt als Neural Netzwierker.
An dësem Artikel wäerte mir iwwer d'Konzept vun Neural Netzwierker goen a wéi dës Modeller bauen, kompiléieren, passen an evaluéieren mat Python.
Neural Netzwierker
Neural Netzwierker, oder NNs, sinn eng Serie vun Algorithmen modelléiert no der biologescher Aktivitéit vum mënschleche Gehir. Neural Netzwierker besteet aus Wirbelen, och Neuronen genannt.
Eng Sammlung vu vertikale Wirbelen sinn als Schichten bekannt. De Modell besteet aus engem Input, engem Output an enger Zuel vu verstoppte Schichten. All Schicht besteet aus Wirbelen, och Neuronen genannt, wou d'Berechnunge stattfannen.
Am folgenden Diagramm representéieren d'Krees d'Knäppchen an d'vertikal Sammlung vun de Wirbelen representéieren d'Schichten. Et ginn dräi Schichten an dësem Modell.
D'Node vun enger Schicht si mat der nächster Schicht duerch Iwwerdroungslinnen verbonne wéi hei ënnendrënner.
Eis Dataset besteet aus markéierten Donnéeën. Dëst bedeit datt all Datenentitéit e bestëmmten Nummwäert zougewisen huet.
Also fir en Déiereklassifizéierungsdates hu mir Biller vu Kazen an Hënn als eis Donnéeën, mat "Kat" an "Hond" als eis Etiketten.
Et ass wichteg ze notéieren datt Etiketten op numeresch Wäerter ëmgewandelt musse ginn fir datt eise Modell Sënn mécht, sou datt eis Déieretiketten '0' fir Kaz an '1' fir Hond ginn. Souwuel d'Donnéeën wéi d'Etikette ginn duerch de Modell passéiert.
learning
D'Donnéeë ginn un de Modell eng Entitéit gläichzäiteg gefüttert. Dës Donnéeë ginn a Stécker opgedeelt an duerch all Node vum Modell passéiert. Node maachen mathematesch Operatiounen op dëse Stécker.
Dir musst net déi mathematesch Funktiounen oder Berechnunge fir dësen Tutorial kennen, awer et ass wichteg eng allgemeng Iddi ze hunn wéi dës Modeller funktionnéieren. No enger Serie vu Berechnungen an enger Schicht ginn d'Donnéeën op déi nächst Schicht weiderginn a sou weider.
Eemol ofgeschloss, prognostizéiert eise Modell den Dateetikett an der Ausgangsschicht (zum Beispill, an engem Déiereklassifikatiounsproblem kréie mir eng Prognose '0' fir eng Kaz).
De Modell geet dann weider fir dëse virausgesote Wäert mat deem vum aktuellen Labelwäert ze vergläichen.
Wann d'Wäerter passen, wäert eise Modell den nächsten Input huelen, awer wann d'Wäerter ënnerscheeden, berechent de Modell den Ënnerscheed tëscht béide Wäerter, genannt Verloscht, an ajustéiert Node Berechnungen fir d'nächst Kéier passende Etiketten ze produzéieren.
Deep Learning Frameworks
Fir Neural Netzwierker am Code ze bauen, musse mir importéieren Deep Learning Kaderen bekannt als Bibliothéike mat eisem Integrated Development Environment (IDE).
Dës Kadere sinn eng Sammlung vu virgeschriwwene Funktiounen déi eis an dësem Tutorial hëllefen. Mir wäerten de Keras Kader benotzen fir eise Modell ze bauen.
Keras ass eng Python Bibliothéik déi en Deep Learning a kënschtlech Intelligenz Backend benotzt tensor Flux NNs a Form vun einfache sequentiellen Modeller mat Liichtegkeet ze kreéieren.
Keras kënnt och mat hiren eegene viraus existéierende Modeller déi och kënne benotzt ginn. Fir dësen Tutorial kreéiere mir eisen eegene Modell mat Keras.
Dir kënnt méi iwwer dësen Deep Learning Kader vun der Keras Websäit.
En neuralt Netzwierk bauen (Tutorial)
Loosst eis weidergoen fir en Neuralt Netzwierk mat Python ze bauen.
Problem Ausso
Neural Netzwierker sinn eng Zort Léisung fir AI-baséiert Probleemer. Fir dësen Tutorial wäerte mir iwwer d'Pima Indianer Diabetes Daten goen, déi verfügbar ass hei.
ICU Machine Learning huet dësen Dataset zesummegesat an enthält e medizinesche Rekord vun indesche Patienten. Eise Modell muss viraussoen ob de Patient en Ufank vun Diabetis bannent 5 Joer huet oder net.
Lueden Dataset
Eis Dataset ass eng eenzeg CSV-Datei genannt 'diabetes.csv' déi einfach mat Microsoft Excel manipuléiert ka ginn.
Ier Dir eise Modell erstallt, musse mir eis Datesaz importéieren. Mat de folgende Code kënnt Dir dëst maachen:
importéiert Pandaen als PD
data = pd.read_csv('diabetes.csv')
x = data.drop("Outcome")
y = Daten["Resultat"]
Hei benotze mir de Pandas Bibliothéik fir eis CSV Dateidaten ze manipuléieren, read_csv () ass eng agebaute Funktioun vu Pandas déi et eis erlaabt d'Wäerter an eiser Datei op eng Variabel genannt 'Daten' ze späicheren.
D'Variabel x enthält eis Dataset ouni d'Resultat (Etiketten) Daten. Mir erreechen dat mat der Funktioun data.drop () déi d'Etiketten fir x läscht, während y nëmmen d'Resultat (Label) Daten enthält.
Sequenziell Modell bauen
Schrëtt 1: Bibliothéiken importéieren
Als éischt musse mir TensorFlow a Keras importéieren, zesumme mat bestëmmte Parameteren erfuerderlech fir eise Modell. De folgende Code erlaabt eis dëst ze maachen:
importéieren Tensorflow als tf
aus tensorflow Import Keras
aus tensorflow.keras.models Import Sequenziell
aus tensorflow.keras.layers Import Aktivéierung, Dicht
aus tensorflow.keras.optimizers importéieren Adam
aus tensorflow.keras.metrics import categorical_crossentropy
Fir eise Modell importéiere mir dichte Schichten. Dës sinn voll verbonne Schichten; dh, all Node an enger Layer ass voll mat engem aneren Node an der nächster Layer verbonnen.
Mir importéieren och eng Aktivatioun Funktioun néideg fir d'Skaléierungsdaten op Noden geschéckt. Optimizer goufen och importéiert fir de Verloscht ze minimiséieren.
Den Adam ass e renomméierten Optimizer deen eise Modell Update Node Berechnungen méi effizient mécht, zesumme mat categorical_crossentropy déi ass der Zort Verloscht Funktioun (berechent Ënnerscheed tëscht aktuellen a virausgesot Label Wäerter) datt mir wäerten benotzen.
Schrëtt 2: Designt eise Modell
De Modell, deen ech erstellen, huet een Input (mat 16 Eenheeten), ee verstoppt (mat 32 Eenheeten) an eng Ausgang (mat 2 Eenheeten) Layer. Dës Zuelen sinn net fix a wäert ofhängeg vun der gegebene Problem ganz.
Déi richteg Unzuel vun Unitéiten a Schichten astellen ass e Prozess deen Iwwerstonnen duerch Praxis verbessert ka ginn. Aktivatioun entsprécht der Aart vun der Skaléierung déi mir op eisen Donnéeën ausféieren ier se duerch en Node passéieren.
Relu a Softmax si renomméiert Aktivéierungsfunktiounen fir dës Aufgab.
model = Sequentiell([
Dense(Unitéiten = 16, input_shape = (1,), Aktivéierung = 'relu'),
Dense(Unitéiten = 32, Aktivatioun = 'relu'),
Dicht (Unitéiten = 2, Aktivatioun = 'softmax')
])
Hei ass wéi de Resumé vum Modell soll ausgesinn:
Ausbildung vum Model
Eise Modell gëtt an zwee Schrëtt trainéiert, déi éischt ass de Modell ze kompiléieren (de Modell zesummesetzen) an déi nächst ass de Modell op e bestëmmten Dataset ze passen.
Dëst kann mat der Funktioun model.compile gemaach ginn () gefollegt vun der Funktioun model.fit ().
model.compile (Optimizer = Adam (learning_rate = 0.0001), Verloscht = 'binary_crossentropy', Metriken = ['Genauegkeet'])
model.fit(x, y, epochs = 30, batch_size = 10)
D'Spezifikatioun vun der 'Genauegkeet' Metrik erlaabt eis d'Genauegkeet vun eisem Modell während dem Training ze beobachten.
Well eis Etiketten a Form vun 1'en an 0'en sinn, benotze mir eng binär Verloschtfunktioun fir den Ënnerscheed tëscht aktuellen a virausgesoten Etiketten ze berechnen.
Den Dataset gëtt och a Chargen vun 10 opgedeelt (batch_size) a gëtt duerch de Modell 30 Mol (Epoken) passéiert. Fir e bestëmmten Dataset wier x d'Donnéeën an y wieren d'Etiketten, déi d'Daten entspriechen.
Testen Modell Benotzt Prognosen
Fir eise Modell ze evaluéieren, maache mir Prognosen iwwer d'Testdaten mat der Predict () Funktioun.
Predictions = model.predict(x)
An dat ass et!
Dir sollt elo e gutt Verständnis vun der Deep Learning Applikatioun, Neural Netzwierker, wéi se am Allgemengen funktionnéieren a wéi ee Modell am Python Code bauen, trainéieren an testen.
Ech hoffen dësen Tutorial gëtt Iech de Kickstart fir Är eegen Deep Learning Modeller ze kreéieren an z'installéieren.
Loosst eis an de Kommentaren wëssen ob den Artikel hëllefräich war.
Hannerlooss eng Äntwert