Deep Learning with Python: Beginners Guide to Deep Learning

er et af de hotteste emner i 2018-19 og med god grund. Der har været så mange fremskridt inden for branchen, hvor tiden er inde, når maskiner eller computerprogrammer rent faktisk erstatter mennesker. Dette Dyb læring med Python Denne artikel hjælper dig med at forstå, hvad der er Deep Learning, og hvordan denne overgang er blevet mulig. Jeg vil dække følgende emner i denne artikel:

• Datavidenskab og dets komponenter
• Behovet for dyb læring
• Hvad er dyb læring?
• Perceptron og kunstige neurale netværk
• Anvendelser af dyb læring
• Hvorfor Python til dyb læring?
• Deep Learning with Python: Perceptron Eksempel
• Deep Learning With Python: Oprettelse af et Deep Neural Network

Datavidenskab og dets komponenter

Datavidenskab er noget, der har været der i årevis. Datavidenskab er udvinding af viden fra data ved hjælp af forskellige teknikker og algoritmer.

er en teknik, der gør det muligt for maskiner at efterligne menneskelig adfærd. Ideen bag AI er ret enkel, men alligevel fascinerende, nemlig at lave intelligente maskiner, der kan tage beslutninger alene. I årevis troede man, at computere aldrig ville matche kraften i den menneskelige hjerne.

Nå, dengang havde vi ikke nok data og beregningskraft, men nu med Big Data ved at blive til og med fremkomsten af ​​GPU'er er kunstig intelligens mulig.

er en delmængde af AI-teknik, der bruger statistiske metoder til at gøre det muligt for maskiner at forbedre sig med erfaring.

Dyb læring er en delmængde af ML, som gør beregningen af ​​flerlags neuralt netværk mulig. Det bruger neurale netværk til at simulere menneskelignende beslutningstagning.

Behovet for dyb læring

Et skridt mod kunstig intelligens er maskinindlæring. Machine Learning er en delmængde af AI og er baseret på ideen om, at maskiner skal have adgang til data og skal overlades til at lære og udforske selv. Det handler om udvinding af mønstre fra store datasæt. Håndtering af store datasæt var ikke et problem.

• Machine Learning Algoritmer kan ikke håndtere højdimensionelle data - hvor vi har et stort antal input og output: runde tusinder af dimensioner. Håndtering og behandling af en sådan type data bliver meget kompleks og ressourceudtømmende. Dette betegnes som Dimensionalitets forbandelse.

• En anden udfordring stod overfor var at specificere funktioner, der skal udvindes . Dette spiller en vigtig rolle i forudsigelsen af ​​resultatet såvel som at opnå bedre nøjagtighed. Uden ekstraktion af funktioner, udfordringen for programmøren stiger, da effektiviteten af ​​algoritmen meget afhænger af, hvor indsigtsfuld programmøren er.

Det er her Deep Learning kom til undsætning. Dyb læring er i stand til at håndtere de højdimensionelle data og er også effektiv i med fokus på de rigtige funktioner alene.

Hvad er dyb læring?

Deep Learning er en delmængde af Machine Learning, hvor lignende Machine Learning-algoritmer bruges til at træne for at opnå bedre nøjagtighed i de tilfælde, hvor førstnævnte ikke presterede op til mærket. I bund og grund, Dyb læring efterligner den måde, vores hjerne fungerer på dvs. det lærer af erfaring.

Som du ved,vores hjerne består af milliarder af neuroner det giver os mulighed for at gøre fantastiske ting. Selv et lille barns hjerne er i stand til at løse komplekse problemer, som det er meget vanskeligt at løse, selv ved hjælp af supercomputere. Så hvordan kan vi opnå den samme funktionalitet i et program? Det er her, vi forstår Kunstig neuron (Perceptron) og Kunstigt neuralt netværk.

Perceptron og kunstige neurale netværk

Deep Learning studerer den grundlæggende enhed i en hjerne kaldet en hjernecelle eller en neuron. Lad os nu forstå funktionaliteten af ​​biologiske neuroner, og hvordan vi efterligner denne funktionalitet i opfattelsen eller en kunstig neuron.

• Dendrit: Modtager signaler fra andre neuroner
• Cellelegeme: Summerer alle input
• Axon: Det bruges til at transmittere signaler til de andre celler

En kunstig neuron eller en Perceptron er en lineær model, der anvendes til binær klassificering. Det modellerer en neuron, der har et sæt input, som hver især har en specifik vægt. Neuronen beregner nogle funktioner på disse vægtet input og giver output.

Den modtager n indgange (svarende til hver funktion). Det summerer derefter disse input, anvender en transformation og producerer et output. Den har to funktioner:

• Summation
• Transformation (aktivering)

Vægten viser effektiviteten af ​​et bestemt input. Mere vægten af ​​input, mere vil det have en indvirkning på det neurale netværk . På den anden side, Partiskhed er en yderligere parameter i Perceptron, som bruges til at justere output sammen med den vægtede sum af input til neuronen, som hjælper modellen på en måde, så den passer bedst til de givne data.

Aktiveringsfunktioner oversætter indgangene til udgange. Det bruger en tærskel til at producere et output. Der er mange funktioner, der bruges som aktiveringsfunktioner, som:

• Lineær eller identitet
• Enhed eller binært trin
• Sigmoid eller logistisk
• Tanh
• ReLU
• Softmax

Godt. hvis du tror, ​​at Perceptron løser problemet, så tager du fejl. Der var to store problemer:

• Enkeltlags perceptroner kan ikke klassificere ikke-lineært adskilte datapunkter .
• Komplekse problemer, der involverer mange parametre kan ikke løses af Single-Layer Perceptrons.

Overvej eksemplet her og kompleksiteten med de involverede parametre for at tage en beslutning fra marketingteamet.

En neuron kan ikke tage så mange input, og det er derfor, at mere end en neuron ville blive brugt til at løse dette problem. Neural Network er egentlig bare en sammensætning af Perceptrons, forbundet på forskellige måder og fungerer på forskellige aktiveringsfunktioner.

• Indtast noder give information fra omverdenen til netværket og betegnes sammen ”Input Layer”.
• Skjulte noder udføre beregninger og overføre information fra inputknudepunkterne til outputknudepunkterne. En samling af skjulte noder danner et 'skjult lag'.
• Output noder kaldes kollektivt 'Output Layer' og er ansvarlige for beregninger og overførsel af information fra netværket til omverdenen.

Nu hvor du har en idé om, hvordan en perceptron opfører sig, de forskellige involverede parametre og de forskellige lag i et neuralt netværk, lad os fortsætte denne Deep Learning med Python Blog og se nogle seje applikationer af Deep Learning.

java casting dobbelt til int

Anvendelser af dyb læring

Der er forskellige anvendelser af dyb læring i branchen, her er et par af de vigtige, der er til stede i vores daglige opgaver.

• Tale genkendelse

• Maskinoversættelse

• Ansigtsgenkendelse og automatisk tagging

• Virtuelle personlige assistenter

• Selvkørende bil

• Chatbots

Hvorfor Python til dyb læring?

• er et sådant værktøj, der har en unik attribut, at være en programmeringssprog til generelle formål som værende let at bruge når det kommer til analytisk og kvantitativ computing.
• Det er meget let at forstå
• Python er Dynamisk skrevet
• Kæmpe stor
• En lang række biblioteker til forskellige formål som Numpy, Seaborn, Matplotlib, Pandaer og Scikit-lær

Nu nok af teorien, lad os se, hvordan vi kan starte Deep Learning med Python med et lille, men alligevel spændende eksempel.

Deep Learning With Python: Eksempel på Perceptron

Nu er jeg sikker på, at jer skal være fortrolige med funktionen af ​​' ELLER' Port. Outputtet er en hvis nogen af ​​indgangene også er en.

Derfor kan en Perceptron bruges som en separator eller en beslutningslinje, der deler indgangssættet til OR Gate i to klasser:

Klasse 1: Indgange med output som 0, der ligger under beslutningslinjen.
Klasse 2: Indgange med output som 1, der ligger over beslutningslinjen eller separatoren.

Indtil nu forstod vi, at en lineær perceptron kan bruges til at klassificere inputdatasættet i to klasser. Men hvordan klassificerer det dataene?

Matematisk kan en perceptron betragtes som en ligning af vægte, input og bias.

Trin 1: Importer alt det krævede bibliotek

Her skal jeg kun importere et bibliotek, dvs. TensorFlow

importer tensorflow som tf

Trin 2: Definer vektorvariabler til input og output

Dernæst skal vi oprette variabler til lagring af input, output og bias til Perceptron.

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

Trin 3: Definer vægtvariabel

Her definerer vi tensorvariablen for form 3 × 1 for vores vægte og tildeler nogle tilfældige værdier til den oprindeligt.

w = tf. variabel (tf. tilfældig_normal ([3, 1], frø = 15))

Trin 4: Definer pladsholdere for input og output

Vi er nødt til at definere pladsholdere, så de kan acceptere eksterne input på farten.

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

Trin 5: Beregn output- og aktiveringsfunktion

Som diskuteret tidligere ganges input modtaget af en perceptron først med de respektive vægte, og derefter opsummeres alle disse vægtede input. Denne summerede værdi tilføres derefter til aktivering for at opnå det endelige resultat.

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

Bemærk: I dette tilfælde har jeg brugt relu som min aktiveringsfunktion. Du er fri til at bruge en af ​​aktiveringsfunktionerne efter dit behov.

Trin 6: Beregn omkostningen eller fejlen

Vi er nødt til at beregne Cost = Mean Squared Error, som ikke er andet end kvadratet af forskellen mellem perceptron output og ønsket output.

tab = tf.reduce_sum (tf.square (output - y))

Trin 7: Minimer fejl

Målet med en perceptron er at minimere tabet eller omkostningerne eller fejlen. Så her skal vi bruge Gradient Descent Optimizer.

optimizer = tf.train.GradientDescentOptimizer (0.01) tog = optimizer.minimere (tab)

Trin 8: Initialiser alle variabler

Variabler er kun defineret med tf. variabel. Så vi er nødt til at initialisere de definerede variabler.

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

Trin 9: Træning af Perceptron i iterationer

Vi er nødt til at træne vores perceptron, dvs. opdatere værdier for vægte og bias i den efterfølgende iteration for at minimere fejlen eller tabet. Her vil jeg træne vores perceptron i 100 epoker.

hvordan man håndterer popup i selen

for jeg inden for rækkevidde (100): sess.run (tog, {x: train_in, y: train_out}) cost = sess.run (loss, feed_dict = {x: train_in, y: train_out}) print ('Epoch-- ', i,' - tab - ', pris)

Trin 10: Output

……

……

Som du kan se her, begyndte tabet kl 2,07 og sluttede kl 0,27

.

Deep Learning With Python: Oprettelse af et Deep Neural Network

Nu hvor vi med succes har oprettet en perceptron og trænet den til en ELLER-port. Lad os fortsætte denne artikel og se, hvordan vi kan oprette vores eget neurale netværk fra Scratch, hvor vi opretter et inputlag, skjulte lag og outputlag.

Vi skal bruge MNIST-datasættet. MNIST-datasættet består af 60.000 træning prøver og 10.000 test eksempler på håndskrevne cifferbilleder. Billederne er af størrelse 28 × 28 pixels og output kan ligge imellem 0-9 .

Opgaven her er at træne en model, der nøjagtigt kan identificere det ciffer, der findes på billedet

For det første skal vi bruge nedenstående import til at bringe udskrivningsfunktionen fra Python 3 til Python 2.6+. __future__-udsagn skal være tæt på toppen af ​​filen, fordi de ændrer grundlæggende ting om sproget, og derfor skal kompilatoren vide om dem fra starten

fra __future__ import udskrivningsfunktion

Følgende er koden med kommentarer på hvert trin

# Importer MNIST-data fra tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) importer tensorflow som tf import matplotlib.pyplot som plt # Parametre learning_rate = 0,001 træning_epochs = 15 batch_size = 100 display_step = 1 # Netværksparametre n_hidden_1 = 256 # 1. lag antal funktioner n_hidden_2 = 256 # 2. lag antal funktioner n_input = 784 # MNIST data input (img form: 28 * 28) n_classes = 10 # MNIST samlede klasser ( 0-9 cifre) # tf Grafindgang x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Opret model def multilayer_perceptron (x, vægte , forspændinger): # Skjult lag med RELU-aktiveringslag_1 = tf.add (tf.matmul (x, vægte ['h1']), forspændinger ['b1']) lag_1 = tf.nn.relu (lag_1) # Skjult lag med RELU aktiveringslag_2 = tf.add (tf.matmul (lag_1, vægte ['h2']), forspændinger ['b2']) lag_2 = tf.nn.relu (lag_2) # Outputlag med lineær aktivering ud_lag = tf. matmul (lag _2, vægte ['ud']) + forspændinger ['ud'] returnere ud_lag # Gem lagvægt og forspændingsvægt = {'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]))} # Konstruktionsmodel pred = multilayer_perceptron (x, vægte, forspændinger) # Definer tab og optimeringsomkostninger = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimer (omkostning) # Initialisering af variablerne init = tf.global_variables_initializer () # Opret en tom liste for at gemme omkostningshistorikken og nøjagtighedshistorikken cost_history = [] accuracy_history = [] # Start grafen med tf.Session () som sess: sess.run (init ) # Træningscyklus for epoke inden for rækkevidde (træningsperioder): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Loop over alle batches for i i området (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Kør optimering op (backprop) og omkostning op (for at få tabsværdi) _, c = sess.run ([optimizer, cost], feed_dict = {x: batch_x, y: batch_y}) # Beregn gennemsnitstab avg_cost + = c / total_batch # Vis logfiler pr. periode, hvis epoke% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Beregn nøjagtighed nøjagtighed = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = accuracy.eval ({x: mnist.test.images, y: mnist.test.labels}) # tilføj nøjagtigheden til listen nøjagtighed_historie.append (acu_temp) # tilføj omkostningshistorik cost_history.append (avg_cost) print ('Epoch:', '% 04d'% (epoke + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Optimization Finished! ') # plot omkostningshistorik plt.plot (cost_history) plt.show () # plot nøjagtighedshistorik plt.plot (nøjagtighed _historie) plt.show () # Testmodel correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Beregn nøjagtighed nøjagtighed = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Nøjagtighed: ', accuracy.eval ({x: mnist.test.images, y: mnist.test.labels}))

Produktion:

Nu med dette kommer vi til slutningen af ​​denne Deep Learning with Python-artikel. Jeg håber, du fik en forståelse af de forskellige komponenter i Deep Learning, hvordan det hele begyndte, og hvordan vi ved hjælp af Python kan skabe en simpel perceptron og et Deep Neural Network.

Edureka's er kurateret af fagfolk i branchen i henhold til branchens krav og krav. Du vil mestre begreberne som SoftMax-funktion, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM) og arbejde med biblioteker som Keras & TFLearn. Kurset er specielt kurateret af brancheeksperter med realtids casestudier.

Har du et spørgsmål til os? Nævn det i kommentarfeltet i 'Deep Learning with Python', så vender vi tilbage til dig.