Deep Learning with Python: Beginners Guide to Deep Learning

är ett av de hetaste ämnena 2018-19 och med goda skäl. Det har gjorts så många framsteg inom industrin där tiden har kommit när maskiner eller datorprogram faktiskt ersätter människor. Detta Djupt lärande med Python artikeln hjälper dig att förstå vad exakt Deep Learning är och hur denna övergång har möjliggjorts. Jag kommer att behandla följande ämnen i den här artikeln:

• Datavetenskap och dess komponenter
• Behovet av Deep Learning
• Vad är Deep Learning?
• Perceptron och artificiella neurala nätverk
• Tillämpningar av Deep Learning
• Varför Python för Deep Learning?
• Deep Learning with Python: Perceptron Exempel
• Deep Learning With Python: Skapa ett djupt neuralt nätverk

Datavetenskap och dess komponenter

Datavetenskap är något som har funnits i åldrar. Datavetenskap är utvinning av kunskap från data med hjälp av olika tekniker och algoritmer.

är en teknik som gör det möjligt för maskiner att efterlikna mänskligt beteende. Tanken bakom AI är ganska enkel men fascinerande, det vill säga att göra intelligenta maskiner som kan fatta beslut på egen hand. I flera år trodde man att datorer aldrig skulle matcha kraften hos den mänskliga hjärnan.

Tja, då hade vi inte tillräckligt med data och beräkningskraft, men nu med Big Data med tillkomsten av GPU: er är artificiell intelligens möjlig.

är en delmängd av AI-teknik som använder statistiska metoder för att göra det möjligt för maskiner att förbättra sig med erfarenhet.

Djup lärning är en delmängd av ML som gör beräkningen av flera lager neuralt nätverk genomförbart. Den använder neurala nätverk för att simulera människoliknande beslutsfattande.

Behovet av Deep Learning

Ett steg mot artificiell intelligens är maskininlärning. Maskininlärning är en delmängd av AI och bygger på tanken att maskiner ska få tillgång till data och bör lämnas för att lära sig och utforska själva. Det handlar om utvinning av mönster från stora datamängder. Att hantera stora datamängder var inte ett problem.

• Maskininlärningsalgoritmer kan inte hantera högdimensionella data - där vi har ett stort antal in- och utgångar: runda tusentals dimensioner. Hantering och bearbetning av sådan typ av data blir mycket komplex och resursuttömmande. Detta kallas Dimensionalitetens förbannelse.

• En annan utmaning inför var att specificera funktioner som ska extraheras . Detta spelar en viktig roll för att förutsäga resultatet samt för att uppnå bättre noggrannhet. Därför, utan extrahering av funktioner, utmaningen för programmeraren ökar eftersom algoritmens effektivitet beror mycket på hur insiktsfull programmeraren är.

Det är här Deep Learning kom till undsättning. Djupt lärande är kan hantera högdimensionella data och är också effektiv i med fokus på rätt funktioner på egen hand.

Vad är Deep Learning?

Deep Learning är en delmängd av maskininlärning där liknande maskininlärningsalgoritmer används för att träna för att uppnå bättre noggrannhet i de fall där den förra inte presterade upp till märket. I grund och botten, Deep learning efterliknar hur vår hjärna fungerar dvs det lär sig av erfarenhet.

Som du vet,vår hjärna består av miljarder neuroner som gör att vi kan göra fantastiska saker. Till och med hjärnan hos ett litet barn kan lösa komplexa problem som är mycket svåra att lösa även med superdatorer. Så, hur kan vi uppnå samma funktionalitet i ett program? Nu är det här vi förstår Artificiell neuron (Perceptron) och Artificiellt neuralt nätverk.

Perceptron och artificiella neurala nätverk

Deep Learning studerar den grundläggande enheten i en hjärna som kallas en hjärncell eller neuron. Låt oss nu förstå funktionaliteten hos biologiska neuroner och hur vi härmar denna funktion i uppfattningen eller en artificiell neuron.

• Dendrit: Tar emot signaler från andra nervceller
• Cellkropp: Sammanfattar alla ingångar
• Axon: Den används för att sända signaler till de andra cellerna

En artificiell neuron eller en Perceptron är en linjär modell som används för binär klassificering. Den modellerar en neuron som har en uppsättning ingångar, som alla har en viss vikt. Neuronen beräknar vissa funktioner på dessa viktad ingångar och ger utdata.

Den tar emot n ingångar (motsvarande varje funktion). Den summerar sedan dessa ingångar, tillämpar en transformation och producerar en utgång. Den har två funktioner:

• Summering
• Transformation (Aktivering)

Vikten visar effektiviteten för en viss insats. Mer vikten av inmatning, mer kommer det att påverka det neurala nätverket . Å andra sidan, Partiskhet är en ytterligare parameter i Perceptron som används för att justera utgången tillsammans med den viktade summan av ingångarna till neuronen som hjälper modellen på ett sätt som passar bäst för den givna informationen.

Aktiveringsfunktioner översätter ingångarna till utgångar. Den använder en tröskel för att producera en utdata. Det finns många funktioner som används som aktiveringsfunktioner, som:

• Linjär eller identitet
• Enhet eller binärt steg
• Sigmoid eller logistisk
• Tanh
• ReLU
• Softmax

Väl. om du tror att Perceptron löser problemet, har du fel. Det fanns två stora problem:

• Perspektroner i ett lager kan inte klassificera icke-linjärt separerade datapunkter .
• Komplexa problem, som involverar många parametrar kan inte lösas av enskiktsperspektroner.

Tänk på exemplet här och komplexiteten med parametrarna för att fatta ett beslut av marknadsföringsteamet.

En neuron, kan inte ta in så många ingångar och det är därför mer än en neuron skulle användas för att lösa detta problem. Neural Network är egentligen bara en sammansättning av Perceptrons, kopplade på olika sätt och fungerar på olika aktiveringsfunktioner.

• Inmatningsnoder tillhandahålla information från omvärlden till nätverket och kallas tillsammans ”Input Layer”.
• Dolda noder utföra beräkningar och överföra information från ingångsnoderna till utgångsnoderna. En samling dolda noder bildar ett 'Hidden Layer'.
• Utgångsnoder kallas kollektivt 'Output Layer' och ansvarar för beräkningar och överföring av information från nätverket till omvärlden.

Nu när du har en uppfattning om hur en perceptron beter sig, de olika parametrarna som är involverade och de olika lagren i ett neuralt nätverk, låt oss fortsätta detta Deep Learning med Python Blogg och se några coola applikationer av Deep Learning.

Tillämpningar av Deep Learning

Det finns olika tillämpningar av Deep Learning in the Industry, här är några av de viktiga som finns i våra dagliga uppgifter.

• Taligenkänning

• Maskinöversättning

• Ansiktsigenkänning och automatisk märkning

• Virtuella personliga assistenter

• Självkörande bil

• Chatbots

Varför Python för Deep Learning?

• är ett sådant verktyg som har ett unikt attribut, att vara en programmeringsspråk för allmänt ändamål som att vara lätt att använda när det gäller analytisk och kvantitativ databehandling.
• Det är mycket lätt att förstå
• Python är Dynamiskt typad
• Enorm
• Ett brett utbud av bibliotek för olika ändamål som Numpy, Seaborn, Matplotlib, Pandas och Scikit-lär

Nu tillräckligt med teori, låt oss se hur vi kan starta Deep Learning med Python med ett litet men ändå spännande exempel.

Deep Learning With Python: Exempel på Perceptron

Nu är jag säker på att ni måste känna till hur ' ELLER' Port. Utgången är ett om någon av ingångarna också är ett.

Därför kan en Perceptron användas som en separator eller en beslutsrad som delar in ingångssatsen för OR Gate, i två klasser:

Klass 1: Ingångar med utdata som 0 som ligger under beslutsraden.
Klass 2: Ingångar med utgång som 1 som ligger ovanför beslutslinjen eller avgränsaren.

Hittills har vi förstått att en linjär perceptron kan användas för att klassificera indatauppsättningen i två klasser. Men hur klassificerar den faktiskt data?

Matematiskt kan en perceptron betraktas som en ekvation av vikter, ingångar och förspänning.

Steg 1: Importera allt bibliotek som krävs

Här ska jag bara importera ett bibliotek, dvs. TensorFlow

importera tensorflöde som tf

Steg 2: Definiera vektorvariabler för in- och utdata

Därefter måste vi skapa variabler för lagring av ingång, utgång och förspänning för Perceptron.

Java-kod för att avsluta programmet

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

Steg 3: Definiera viktvariabel

Här kommer vi att definiera tensorvariabeln för form 3 × 1 för våra vikter och tilldela några slumpmässiga värden till den initialt.

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

Steg 4: Definiera platshållare för in- och utdata

Vi måste definiera platshållare så att de kan acceptera externa ingångar på språng.

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

Steg 5: Beräkna utdata och aktiveringsfunktion

Som diskuterats tidigare multipliceras ingången som mottas av en perceptron först med respektive vikter och sedan summeras alla dessa viktade ingångar tillsammans. Detta summerade värde matas sedan till aktivering för att uppnå slutresultatet.

utgång = tf.nn.relu (tf.matmul (x, w))

Obs: I det här fallet har jag använt relu som min aktiveringsfunktion. Du är fri att använda någon av aktiveringsfunktionerna efter ditt behov.

Steg 6: Beräkna kostnaden eller felet

Vi måste beräkna Cost = Mean Squared Error, som inte är annat än kvadraten för skillnaden mellan perceptronutmatning och önskad utmatning.

förlust = tf.reduce_sum (tf.square (output - y))

Steg 7: Minimera fel

Målet med en perceptron är att minimera förlusten eller kostnaden eller felet. Så här ska vi använda Gradient Descent Optimizer.

optimizer = tf.train.GradientDescentOptimizer (0.01) tåg = optimizer.minimera (förlust)

Steg 8: Initiera alla variabler

Variabler definieras endast med tf. variabel. Så vi måste initialisera de definierade variablerna.

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

Steg 9: Träna Perceptron i iterationer

Vi måste träna vår perceptron, dvs. uppdatera värden på vikter och förspänning i den successiva iterationen för att minimera felet eller förlusten. Här kommer jag att träna vår perceptron i 100 epoker.

för jag inom intervall (100): sess.run (tåg, {x: train_in, y: train_out}) kostnad = sess.run (loss, feed_dict = {x: train_in, y: train_out}) print ('Epoch-- ', i,' - förlust - ', kostnad)

Steg 10: Utdata

……

……

Som du kan se här började förlusten kl 2,07 och slutade kl 0,27

.

Deep Learning With Python: Skapa ett djupt neuralt nätverk

Nu när vi framgångsrikt har skapat en perceptron och tränat den för en ELLER-grind. Låt oss fortsätta den här artikeln och se hur vi kan skapa vårt eget neurala nätverk från Scratch, där vi skapar ett Input Layer, Hidden Layers och Output Layer.

Vi ska använda MNIST-datauppsättningen. MNIST-datauppsättningen består av 60 000 utbildning prover och 10 000 test exempel på handskrivna siffror. Bilderna är av storlek 28 × 28 pixlar och produktionen kan ligga mellan 0-9 .

Uppgiften här är att träna en modell som exakt kan identifiera siffran som finns på bilden

För det första ska vi använda importen nedan för att ta med utskriftsfunktionen från Python 3 till Python 2.6+. __future__-uttalanden måste vara nära toppen av filen eftersom de ändrar grundläggande saker om språket, och därför måste kompilatorn veta om dem från början

från __future__ importutskriftsfunktion

Följande är koden med kommentarer i varje steg

# Importera MNIST-data från tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) importera tensorflow som tf importera matplotlib.pyplot som plt # Parametrar learning_rate = 0,001 tränings_epochs = 15 batch_size = 100 display_step = 1 # Nätverksparametrar n_hidden_1 = 256 # 1: a lager antal funktioner n_hidden_2 = 256 # 2: a lager antal funktioner n_input = 784 # MNIST dataingång (bildform: 28 * 28) n_classes = 10 # MNIST totala klasser ( 0-9 siffror) # tf Grafinmatning x = tf.platshållare ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Skapa modell def multilayer_perceptron (x, vikter , förspänningar): # Doldt lager med RELU-aktiveringsskikt_1 = tf.add (tf.matmul (x, vikter ['h1']), förspänningar ['b1']) lager_1 = tf.nn.relu (lager_1) # Doldt lager med RELU aktiveringslager_2 = tf.add (tf.matmul (lager_1, vikter ['h2']), förspänningar ['b2']) lager_2 = tf.nn.relu (lager_2) # Utmatningsskikt med linjär aktivering utlager = tf. matmul (lager _2, vikter ['ut']) + förspänningar ['ut'] returnera utlager # Lagra lager vikt och förspänningsvikter = {'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]))} # Konstruktionsmodell pred = multilayer_perceptron (x, vikter, förspänningar) # Definiera förlust och optimeringskostnad = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimera (kostnad) # Initiera variablerna init = tf.global_variables_initializer () # skapa en tom lista för att lagra kostnadshistorik och noggrannhetshistorik cost_history = [] precision_history = [] # Starta grafen med tf.Session () som sess: sess.run (init ) # Träningscykel för epok inom räckvidd (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Loop över alla batcher för i inom intervallet (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Kör optimering op (backprop) och kostnad op (för att få förlustvärde) _, c = sess.run ([optimizer, cost], feed_dict = {x: batch_x, y: batch_y}) # Beräkna genomsnittlig förlust avg_cost + = c / total_batch # Visa loggar per epoksteg om epok% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Beräkna noggrannhet noggrannhet = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = precision.eval ({x: mnist.test.images, y: mnist.test.labels}) # lägg till noggrannheten i listan precision_history.append (acu_temp) # lägg till kostnadshistorik cost_history.append (avg_cost) print ('Epoch:', '% 04d'% (epoke + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Optimization Finished! ') #plot the cost history plt.plot (cost_history) plt.show () # plot the precision history plt.plot (precision _history) plt.show () # Testmodell correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Beräkna noggrannhetsnoggrannhet = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Accuracy: ', accuracy.eval ({x: mnist.test.images, y: mnist.test.labels}))

Produktion:

Nu med detta kommer vi till slutet av denna Deep Learning with Python-artikel. Jag hoppas att du fick förståelse för de olika komponenterna i Deep Learning, hur allt började och hur vi använder Python kan vi skapa en enkel perceptron och ett Deep Neural Network.

Edureka's är kuraterad av branschpersonal enligt branschens krav och krav. Du kommer att behärska begreppen som SoftMax-funktion, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM) och arbeta med bibliotek som Keras & TFLearn. Kursen har specialiserats av branschexperter med fallstudier i realtid.

Har du en fråga till oss? Vänligen nämna det i kommentarsektionen i ”Deep Learning with Python” så återkommer vi till dig.