Diep leren met Python: beginnershandleiding voor diep leren

Dit artikel geeft je een uitgebreide en gedetailleerde kennis van Deep Learning met Python en hoe nuttig het is in het dagelijks leven.

is een van de populairste onderwerpen van 2018-19 en om een ​​goede reden. Er zijn zoveel vorderingen gemaakt in de industrie dat de tijd is gekomen dat machines of computerprogramma's de mensen daadwerkelijk vervangen. Deze Diep leren met Python artikel zal u helpen begrijpen wat Deep Learning precies is en hoe deze overgang mogelijk is gemaakt. Ik behandel de volgende onderwerpen in dit artikel:

Datawetenschap en zijn componenten

Nou, Data Science is iets dat er al eeuwen bestaat. Gegevenswetenschap is de extractie van kennis uit gegevens door gebruik te maken van verschillende technieken en algoritmen.



AI-tijdlijn - diep leren met Python - Edureka

is een techniek waarmee machines menselijk gedrag kunnen nabootsen. Het idee achter AI is vrij eenvoudig maar fascinerend, namelijk om intelligente machines te maken die zelf beslissingen kunnen nemen. Jarenlang werd gedacht dat computers nooit de kracht van het menselijk brein zouden evenaren.

Nou, toen hadden we niet genoeg data en rekenkracht, maar nu met Big data ontstaan ​​en met de komst van GPU's is kunstmatige intelligentie mogelijk.

is een subset van AI-techniek die statistische methoden gebruikt om machines in staat te stellen te verbeteren met ervaring.

Diep leren is een subset van ML die de berekening van een meerlaags neuraal netwerk mogelijk maakt. Het maakt gebruik van neurale netwerken om mensachtige besluitvorming te simuleren.

De behoefte aan diep leren

Een stap op weg naar kunstmatige intelligentie is machine learning. Machine Learning is een subset van AI en is gebaseerd op het idee dat machines toegang moeten krijgen tot gegevens en dat ze zelf moeten leren en ontdekken. Het behandelt de extractie van patronen uit grote datasets. Het omgaan met grote datasets was geen probleem.

  • Algoritmen voor machine learning kan geen hoog-dimensionale gegevens aan - waar we een groot aantal inputs en outputs hebben: rond duizenden dimensies. Het verwerken en verwerken van dit soort gegevens wordt erg complex en uitputtend. Dit wordt genoemd als Vloek van de dimensionaliteit.

  • Een andere uitdaging was om de kenmerken die moeten worden geëxtraheerd . Dit speelt een belangrijke rol bij het voorspellen van de uitkomst en bij het bereiken van een betere nauwkeurigheid. Daarom, zonder functie-extractie, de uitdaging voor de programmeur neemt toe naarmate de effectiviteit van het algoritme sterk afhangt van hoe inzichtelijk de programmeur is.

Dit is waar Deep Learning te hulp kwam. Diep leren is in staat om de hoge dimensionale gegevens te verwerken en is ook efficiënt in gericht op de juiste eigenschappen op zichzelf.

Wat is diep leren?

Deep Learning is een subset van Machine Learning waarbij vergelijkbare Machine Learning-algoritmen worden gebruikt om te trainen om een ​​betere nauwkeurigheid te bereiken in die gevallen waarin de eerste niet tot de maat presteerde. Eigenlijk, Diep leren bootst de manier waarop onze hersenen functioneren na d.w.z. het leert van ervaring.

Zoals u weet,onze hersenen bestaan ​​uit miljarden neuronen waarmee we geweldige dingen kunnen doen. Zelfs het brein van een klein kind is in staat complexe problemen op te lossen die zelfs met supercomputers erg moeilijk op te lossen zijn. Dus, hoe kunnen we dezelfde functionaliteit in een programma bereiken? Dit is waar we het begrijpen Kunstmatig neuron (perceptron) en Kunstmatig neuraal netwerk.

Perceptron en kunstmatige neurale netwerken

Deep Learning bestudeert de basiseenheid van een brein die een hersencel of een neuron wordt genoemd. Laten we nu de functionaliteit van biologische neuronen begrijpen en hoe we deze functionaliteit nabootsen in de waarneming van een kunstmatig neuron.

sql-zelfstudie voor serverintegratieservices

  • Dendriet: Ontvangt signalen van andere neuronen
  • Cellichaam: Telt alle invoer op
  • Axon: Het wordt gebruikt om signalen naar de andere cellen te verzenden

Een kunstmatig neuron of een Perceptron is een lineair model dat wordt gebruikt voor binaire classificatie. Het modelleert een neuron met een reeks ingangen, die elk een specifiek gewicht krijgen. Het neuron berekent hier een functie op gewogen inputs en geeft de output.

Het ontvangt n ingangen (corresponderend met elk kenmerk). Het telt vervolgens die inputs op, past een transformatie toe en produceert een output. Het heeft twee functies:

  • Sommatie
  • Transformatie (activering)

Het gewicht toont de effectiviteit van een bepaalde input. Hoe zwaarder de input, hoe meer het een impact zal hebben op het neurale netwerk . Anderzijds, Vooroordeel is een aanvullende parameter in de Perceptron die wordt gebruikt om de output aan te passen, samen met de gewogen som van de inputs naar het neuron, wat het model helpt op een manier die het beste past bij de gegeven data.

Activeringsfuncties vertaalt de inputs in outputs. Het gebruikt een drempel om een ​​output te produceren. Er zijn veel functies die worden gebruikt als activeringsfuncties, zoals:

  • Lineair of identiteit
  • Eenheid of binaire stap
  • Sigmoid of logistiek
  • Tanh
  • ReLU
  • Softmax

Goed. als u denkt dat Perceptron het probleem oplost, dan heeft u het mis. Er waren twee grote problemen:

  • Perceptrons met één laag kan geen niet-lineair scheidbare gegevenspunten classificeren .
  • Complexe problemen, die te maken hebben met veel parameters kan niet worden opgelost door enkellaagse perceptrons.

Beschouw het voorbeeld hier en de complexiteit met de betrokken parameters om een ​​beslissing te nemen door het marketingteam.

Eén neuron kan niet zoveel inputs opnemen en daarom zou meer dan één neuron worden gebruikt om dit probleem op te lossen. Neuraal netwerk is eigenlijk gewoon een samenstelling van Perceptrons, op verschillende manieren verbonden en werken met verschillende activeringsfuncties.

  • Invoerknooppunten verstrekken informatie van de buitenwereld aan het netwerk en worden samen de “Input Layer” genoemd.
  • Verborgen knooppunten berekeningen uitvoeren en informatie overbrengen van de invoerknooppunten naar de uitvoerknooppunten. Een verzameling verborgen knooppunten vormt een 'verborgen laag'.
  • Uitvoerknooppunten worden gezamenlijk de 'outputlaag' genoemd en zijn verantwoordelijk voor berekeningen en het overbrengen van informatie van het netwerk naar de buitenwereld.

Nu je een idee hebt van hoe een perceptron zich gedraagt, de verschillende parameters die erbij betrokken zijn en de verschillende lagen van een neuraal netwerk, gaan we door met deze Deep Learning met Python Blog en enkele coole toepassingen van Deep Learning bekijken.

Toepassingen van diep leren

Er zijn verschillende toepassingen van Deep Learning in de industrie, hier zijn enkele van de belangrijkste die aanwezig zijn in onze dagelijkse taken.

  • Spraakherkenning

  • Machine vertaling

  • Gezichtsherkenning en automatische tagging

  • Virtuele persoonlijke assistenten

  • Zelfrijdende auto

  • Chatbots

Waarom Python voor diep leren?

  • is zo'n tool die een uniek kenmerk heeft, namelijk een programmeertaal voor algemene doeleinden als zijnde makkelijk te gebruiken als het gaat om analytisch en kwantitatief computergebruik.
  • Het is erg makkelijk te begrijpen
  • Python is Dynamisch getypt
  • Reusachtig
  • Een breed scala aan bibliotheken voor verschillende doeleinden, zoals Numpy, Seaborn, Matplotlib, Panda's en Scikit-learn

Nu genoeg theorie. Laten we eens kijken hoe we Deep Learning met Python kunnen starten met een klein maar opwindend voorbeeld.

Diep leren met Python: Perceptron-voorbeeld

Nu weet ik zeker dat jullie bekend moeten zijn met de werking van de ' OF' poort. De output is een als een van de ingangen ook is een.

Daarom kan een Perceptron worden gebruikt als scheidingsteken of als beslissingslijn die de invoerset van OR Gate in twee klassen verdeelt:

Klas 1: Inputs met output als 0 die onder de beslissingslijn ligt.
Klasse 2: Inputs met output als 1 die boven de beslissingslijn of scheidingsteken ligt.

Tot nu toe begrepen we dat een lineair perceptron kan worden gebruikt om de invoergegevensverzameling in twee klassen te classificeren. Maar hoe classificeert het de gegevens eigenlijk?

Wiskundig gezien kan een perceptron worden gezien als een vergelijking van gewichten, invoer en afwijking.

Stap 1: Importeer alle vereiste bibliotheken

Hier ga ik slechts één bibliotheek importeren, dwz. TensorFlow

importeer tensorflow als tf

Stap 2: Definieer vectorvariabelen voor invoer en uitvoer

Vervolgens moeten we variabelen maken voor het opslaan van de invoer, uitvoer en bias voor de Perceptron.

train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1], [1]]

Stap 3: Definieer de gewichtsvariabele

Hier zullen we de tensorvariabele van vorm 3 × 1 voor onze gewichten definiëren en er aanvankelijk enkele willekeurige waarden aan toewijzen.

w = tf.Variable (tf.random_normal ([3, 1], seed = 15))

Stap 4: Definieer tijdelijke aanduidingen voor invoer en uitvoer

We moeten tijdelijke aanduidingen definiëren, zodat ze tijdens het uitvoeren externe invoer kunnen accepteren.

x = tf.placeholder (tf.float32, [None, 3]) y = tf.placeholder (tf.float32, [None, 1])

Stap 5: Bereken de output en activeringsfunctie

Zoals eerder besproken, wordt de input ontvangen door een perceptron eerst vermenigvuldigd met de respectievelijke gewichten en vervolgens worden al deze gewogen inputs bij elkaar opgeteld. Deze opgetelde waarde wordt vervolgens naar de activering gevoerd om het eindresultaat te verkrijgen.

uitvoer = tf.nn.relu (tf.matmul (x, w))

Opmerking: in dit geval heb ik relu als mijn activeringsfunctie. U bent vrij om alle activeringsfuncties naar behoefte te gebruiken.

Stap 6: Bereken de kosten of fout

We moeten de kosten = gemiddelde kwadratische fout berekenen, die niets anders is dan het kwadraat van het verschil tussen perceptronuitvoer en gewenste uitvoer.

verschil tussen override en overload
loss = tf.reduce_sum (tf.square (uitvoer - y))

Stap 7: Minimaliseer de fout

Het doel van een perceptron is om het verlies, de kosten of de fout te minimaliseren. Dus hier gaan we de Gradient Descent Optimizer gebruiken.

optimizer = tf.train.GradientDescentOptimizer (0.01) train = optimizer.minimize (verlies)

Stap 8: Initialiseer alle variabelen

Variabelen worden alleen gedefinieerd met tf.Variabele. We moeten dus de gedefinieerde variabelen initialiseren.

init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)

Stap 9: Perceptron trainen in iteraties

We moeten ons perceptron trainen, d.w.z. de waarden van gewichten en bias bijwerken in de opeenvolgende iteratie om de fout of het verlies te minimaliseren. Hier zal ik onze perceptron in 100 tijdperken trainen.

for i in range (100): sess.run (train, {x: train_in, y: train_out}) cost = sess.run (loss, feed_dict = {x: train_in, y: train_out}) print ('Epoch-- ', i,' - verlies - ', kosten)

Stap 10: Uitvoer

……

……

Zoals u hier kunt zien, begon het verlies bij 2.07 en eindigde op 0.27

.

Diep leren met Python: een diep neuraal netwerk creëren

Nu we met succes een perceptron hebben gemaakt en deze hebben getraind voor een OK-poort. Laten we doorgaan met dit artikel en kijken hoe we ons eigen neurale netwerk vanuit het niets kunnen maken, waar we een invoerlaag, verborgen lagen en een uitvoerlaag zullen maken.

We gaan de MNIST-dataset gebruiken. De MNIST-dataset bestaat uit 60.000 trainingen monsters en 10.000 testen voorbeelden van handgeschreven cijferafbeeldingen. De afbeeldingen zijn van formaat 28 × 28 pixels en de output kan tussen liggen 0-9 .

De taak hier is om een ​​model te trainen dat het cijfer op de afbeelding nauwkeurig kan identificeren

Ten eerste gaan we de onderstaande import gebruiken om de printfunctie van Python 3 naar Python 2.6+ te brengen. __future__-statements moeten bovenaan het bestand staan ​​omdat ze fundamentele dingen in de taal veranderen, en dus moet de compiler er vanaf het begin vanaf weten

van __future__ import print_function

Hieronder volgt de code met opmerkingen bij elke stap

# Importeer MNIST-gegevens uit tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) importeer tensorflow als tf importeer matplotlib.pyplot als plt # Parameters learning_rate = 0.001 training_epochs = 15 batch_size = 100 display_step = 1 # Netwerkparameters n_hidden_1 = 256 # 1e laag aantal objecten n_hidden_2 = 256 # 2e laag aantal objecten n_input = 784 # MNIST gegevensinvoer (img vorm: 28 * 28) n_classes = 10 # MNIST totale klassen ( 0-9 cijfers) # tf Grafiekinvoer x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Maak een model def meerlaags_perceptron (x, gewichten , biases): # Verborgen laag met RELU-activeringslaag_1 = tf.add (tf.matmul (x, gewichten ['h1']), biases ['b1']) layer_1 = tf.nn.relu (laag_1) # Verborgen laag met RELU-activeringslaag_2 = tf.add (tf.matmul (layer_1, gewichten ['h2']), biases ['b2']) layer_2 = tf.nn.relu (layer_2) # Uitgangslaag met lineaire activering out_layer = tf. matmul (laag _2, weights ['out']) + biases ['out'] return out_layer # Store layers weight & bias weights = {'h1': tf.Variable (tf.random_normal ([n_input, n_hidden_1])), 'h2' : tf.Variable (tf.random_normal ([n_hidden_1, n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_hidden_2, n_classes]))} biases = {'b1': tf.Variable (tf. random_normal ([n_hidden_1])), 'b2': tf.Variable (tf.random_normal ([n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_classes]))} # Construct model pred = multilayer_perceptron (x, gewichten, biases) # Definieer verlies en optimalisatiekosten = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (kosten) # Initialisatie van de variabelen init = tf.global_variables_initializer () #creëer een lege lijst om de kostenhistorie en accuratessehistorie op te slaan cost_history = [] accuratesse_history = [] # Start de grafiek met tf.Session () als sess: sess.run (init ) # Trainingscyclus voor tijdvak binnen bereik (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Loop over alle batches voor i binnen bereik (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Run optimalisatie op (backprop) en kosten op (om verlieswaarde te krijgen) _, c = sess.run ([optimizer, kosten], feed_dict = {x: batch_x, y: batch_y}) # Bereken gemiddeld verlies avg_cost + = c / total_batch # Geef logboeken per epoch-stap weer als epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Bereken nauwkeurigheid nauwkeurigheid = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = accuratesse.eval ({x: mnist.test.images, y: mnist.test.labels}) #append de nauwkeurigheid aan de lijst accuratesse.append (acu_temp) #append the cost history cost_history.append (avg_cost) afdrukken ('Epoch:', '% 04d'% (epoch + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Optimalisatie voltooid! ') #plot de kostenhistorie plt.plot (cost_history) plt.show () #plot de nauwkeurigheidshistorie plt.plot (nauwkeurigheid _history) plt.show () # Testmodel correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Bereken nauwkeurigheid nauwkeurigheid = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Accuracy: ', accuratesse.eval ({x: mnist.test.images, y: mnist.test.labels}))

Uitgang:

Hiermee komen we aan het einde van dit Deep Learning with Python-artikel. Ik hoop dat je inzicht hebt gekregen in de verschillende componenten van Deep Learning, hoe het allemaal begon en hoe we met Python een eenvoudige perceptron en een diep neuraal netwerk kunnen creëren.

Edureka's wordt samengesteld door professionals uit de industrie volgens de eisen en eisen van de branche. Je beheerst de concepten zoals SoftMax-functie, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM) en werkt met bibliotheken zoals Keras en TFLearn. De cursus is speciaal samengesteld door experts uit de industrie met real-time casestudy's.

Heeft u een vraag voor ons? Vermeld het in het commentaargedeelte van 'Diep leren met Python' en we nemen zo snel mogelijk contact met u op.