Deep Learning with Python: Beginners Guide to Deep Learning

er et av de hotteste temaene i 2018-19 og med god grunn. Det har vært så mange fremskritt i bransjen hvor tiden har kommet når maskiner eller dataprogrammer faktisk erstatter mennesker. Dette Dyp læring med Python artikkelen vil hjelpe deg med å forstå hva som er Deep Learning og hvordan denne overgangen har blitt mulig. Jeg vil dekke følgende emner i denne artikkelen:

• Datavitenskap og dets komponenter
• Behovet for dyp læring
• Hva er Deep Learning?
• Perceptron og kunstige nevrale nettverk
• Anvendelser av dyp læring
• Hvorfor Python for dyp læring?
• Dyp læring med Python: Perceptron-eksempel
• Deep Learning With Python: Opprette et Deep Neural Network

Datavitenskap og dets komponenter

Datavitenskap er noe som har vært der i evigheter. Datavitenskap er utvinning av kunnskap fra data ved hjelp av forskjellige teknikker og algoritmer.

er en teknikk som gjør det mulig for maskiner å etterligne menneskelig atferd. Ideen bak AI er ganske enkel, men likevel fascinerende, som er å lage intelligente maskiner som kan ta beslutninger alene. I mange år trodde man at datamaskiner aldri ville matche kraften til den menneskelige hjerne.

Vel, da hadde vi ikke nok data og beregningskraft, men nå med Stor Data som kommer til og med fremkomsten av GPUer, er kunstig intelligens mulig.

er en delmengde av AI-teknikk som bruker statistiske metoder for å gjøre det mulig for maskiner å forbedre seg med erfaring.

Dyp læring er en delmengde av ML som gjør beregningen av flerlags nevrale nettverk mulig. Den bruker nevrale nettverk for å simulere menneskelignende beslutningstaking.

Behovet for dyp læring

Et skritt mot kunstig intelligens er maskinlæring. Machine Learning er en delmengde av AI og er basert på ideen om at maskiner skal få tilgang til data, og bør overlates til å lære og utforske selv. Den omhandler utvinning av mønstre fra store datasett. Håndtering av store datasett var ikke noe problem.

• Maskinlæringsalgoritmer kan ikke håndtere høydimensjonale data - der vi har et stort antall innganger og utganger: runde tusenvis av dimensjoner. Håndtering og behandling av slike typer data blir veldig komplisert og ressursuttømmende. Dette blir betegnet som Forbannelse av dimensjonalitet.

• En annen utfordring som sto overfor var å spesifisere funksjoner som skal hentes ut . Dette spiller en viktig rolle i å forutsi utfallet og i å oppnå bedre nøyaktighet. Derfor, uten funksjonsutvinning, utfordringen for programmereren øker ettersom effektiviteten til algoritmen avhenger veldig av hvor innsiktsfull programmereren er.

Nå er det her Deep Learning kom til unnsetning. Dyp læring er i stand til å håndtere høydimensjonale data og er også effektiv i med fokus på de rette funksjonene på egen hånd.

Hva er Deep Learning?

Deep Learning er en delmengde av maskinlæring der lignende maskinlæringsalgoritmer brukes til å trene for å oppnå bedre nøyaktighet i de tilfeller der førstnevnte ikke presterte opp til merket. I utgangspunktet, Dyp læring etterligner måten hjernen vår fungerer på dvs. det lærer av erfaring.

Som du vet,hjernen vår består av milliarder nevroner som lar oss gjøre fantastiske ting. Selv hjernen til et lite barn er i stand til å løse komplekse problemer som er svært vanskelige å løse, selv ved hjelp av superdatamaskiner. Så, hvordan kan vi oppnå den samme funksjonaliteten i et program? Nå er det her vi forstår Kunstig nevron (Perceptron) og Kunstig nevralt nettverk.

Perceptron og kunstige nevrale nettverk

Deep Learning studerer den grunnleggende enheten i en hjerne som kalles hjernecelle eller nevron. La oss nå forstå funksjonaliteten til biologiske nevroner og hvordan vi etterligner denne funksjonaliteten i persepsjonen eller et kunstig nevron.

• Dendrite: Mottar signaler fra andre nevroner
• Cellelegeme: Oppsummerer alle inngangene
• Axon: Den brukes til å overføre signaler til de andre cellene

En kunstig neuron eller en Perceptron er en lineær modell som brukes for binær klassifisering. Den modellerer et nevron som har et sett med innganger, som hver har en spesifikk vekt. Nevronen beregner noen funksjoner på disse vektet innganger og gir utdata.

hva er fastlåst i java

Den mottar n innganger (tilsvarende hver funksjon). Den summerer deretter inngangene, bruker en transformasjon og produserer en utgang. Den har to funksjoner:

• Oppsummering
• Transformasjon (aktivering)

Vekten viser effektiviteten til et bestemt innspill. Mer vekten av innspill, mer vil det ha innvirkning på nevrale nettverk . På den andre siden, Partiskhet er en tilleggsparameter i Perceptron som brukes til å justere produksjonen sammen med den vektede summen av inngangene til nevronet som hjelper modellen på en måte som passer best for de gitte dataene.

Aktiveringsfunksjoner oversetter inngangene til utgangene. Den bruker en terskel for å produsere en utgang. Det er mange funksjoner som brukes som aktiveringsfunksjoner, som:

• Lineær eller identitet
• Enhet eller binært trinn
• Sigmoid eller logistisk
• Tanh
• ReLU
• Softmax

Vi vil. hvis du tror Perceptron løser problemet, så tar du feil. Det var to store problemer:

• Enkeltlags perseptroner kan ikke klassifisere ikke-lineært separerbare datapunkter .
• Komplekse problemer som involverer mange parametere kan ikke løses av enkeltlags perseptroner.

Tenk på eksemplet her og kompleksiteten med parametrene som er involvert for å ta en beslutning av markedsføringsteamet.

Én nevron, kan ikke ta inn så mange innganger, og det er grunnen til at mer enn en nevron vil bli brukt til å løse dette problemet. Neural Network er egentlig bare en sammensetning av Perceptrons, koblet på forskjellige måter og opererer på forskjellige aktiveringsfunksjoner.

• Inngangskoder gi informasjon fra omverdenen til nettverket og blir sammen referert til som 'Input Layer'.
• Skjulte noder utføre beregninger og overføre informasjon fra inngangsnodene til utgangsnodene. En samling skjulte noder danner et “Hidden Layer”.
• Utgangsnoder blir samlet referert til som 'Output Layer' og er ansvarlige for beregninger og overføring av informasjon fra nettverket til omverdenen.

Nå som du har en ide om hvordan en perseptron oppfører seg, de forskjellige parametrene som er involvert, og de forskjellige lagene i et nevralt nettverk, la oss fortsette denne Deep Learning med Python Blog og se noen kule applikasjoner av Deep Learning.

Anvendelser av dyp læring

Det er forskjellige anvendelser av Deep Learning in the Industry, her er noen av de viktige som er til stede i våre daglige oppgaver.

• Talegjenkjenning

• Maskinoversettelse

• Ansiktsgjenkjenning og automatisk merking

• Virtuelle personlige assistenter

• Selvkjørende bil

• Chatbots

Hvorfor Python for dyp læring?

• er et slikt verktøy som har en unik egenskap, å være en programmeringsspråk for generelle formål som å være lett å bruke når det gjelder analytisk og kvantitativ databehandling.
• Det er veldig enkelt å forstå
• Python er Dynamisk skrevet
• Enorm
• Et stort utvalg av biblioteker for forskjellige formål som Numpy, Seaborn, Matplotlib, Pandas og Scikit-lær

Nå er det nok av teorien, la oss se hvordan vi kan starte Deep Learning med Python med et lite, men likevel spennende eksempel.

Deep Learning With Python: Perceptron Eksempel

Nå er jeg sikker på at dere må være kjent med arbeidet med ' ELLER' Port. Resultatet er en hvis noen av inngangene også er en.

forskjellen mellom tilkoblet og ikke-tilkoblet oppslag

Derfor kan en Perceptron brukes som en separator eller en beslutningslinje som deler inngangssettet til OR Gate, i to klasser:

Klasse 1: Innganger med utgang som 0 som ligger under beslutningslinjen.
Klasse 2: Innganger med utgang som 1 som ligger over beslutningslinjen eller skilletegn.

Inntil nå forsto vi at en lineær perseptron kan brukes til å klassifisere inngangssettene i to klasser. Men hvordan klassifiserer det dataene?

Matematisk kan en perseptron tenkes på som en ligning av vekter, innganger og skjevhet.

Trinn 1: Importer alt ønsket bibliotek

Her skal jeg bare importere ett bibliotek, dvs. TensorFlow

importer tensorflow som tf

Trinn 2: Definer vektorvariabler for inngang og utgang

Deretter må vi lage variabler for lagring av inngang, utgang og forspenning for Perceptron.

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

Trinn 3: Definere vektvariabel

Her vil vi definere tensorvariabelen for form 3 × 1 for vektene våre og tilordne noen tilfeldige verdier til den i utgangspunktet.

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

Trinn 4: Definer plassholdere for Input and Output

Vi må definere plassholdere slik at de kan akseptere eksterne innganger på flukt.

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

Trinn 5: Beregn utdata og aktiveringsfunksjon

Som diskutert tidligere multipliseres inngangen som mottas av en perseptron først med de respektive vektene, og deretter summeres alle disse vektede inngangene sammen. Denne summerte verdien mates deretter til aktivering for å oppnå det endelige resultatet.

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

Merk: I dette tilfellet har jeg brukt relu som min aktiveringsfunksjon. Du står fritt til å bruke noen av aktiveringsfunksjonene etter ditt behov.

Trinn 6: Beregn kostnad eller feil

Vi må beregne Cost = Mean Squared Error, som ikke er noe annet enn kvadratet av forskjellen på perceptron-output og ønsket output.

tap = tf.reduser_sum (tf.square (utgang - y))

Trinn 7: Minimer feil

Målet med en perseptron er å minimere tap eller kostnader eller feil. Så her skal vi bruke Gradient Descent Optimizer.

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

Trinn 8: Initialiser alle variablene

Variabler er bare definert med tf. variabel. Så vi må initialisere de definerte variablene.

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

Trinn 9: Trening av perseptron i iterasjoner

Vi trenger å trene vår perseptron, dvs. oppdatere verdier for vekter og skjevhet i den påfølgende iterasjonen for å minimere feilen eller tapet. Her skal jeg trene perseptronen vår i 100 epoker.

for jeg i rekkevidde (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,' - tap - ', kostnad)

Trinn 10: Utgang

……

……

ms sql tutorials for nybegynnere

Som du kan se her, startet tapet kl 2.07 og endte kl 0,27

.

Deep Learning With Python: Opprette et Deep Neural Network

Nå som vi med hell har opprettet en perseptron og trent den til en ELLER-port. La oss fortsette denne artikkelen og se hvordan vi kan lage vårt eget nevrale nettverk fra Scratch, hvor vi vil lage et Input Layer, Hidden Layers og Output Layer.

Vi skal bruke MNIST-datasettet. MNIST-datasettet består av 60.000 trening prøver og 10.000 tester eksempler på håndskrevne sifferbilder. Bildene er av størrelse 28 × 28 piksler og utgangen kan ligge mellom 0-9 .

Oppgaven her er å trene en modell som nøyaktig kan identifisere sifferet som er tilstede på bildet

For det første skal vi bruke importen nedenfor for å bringe utskriftsfunksjonen fra Python 3 til Python 2.6+. __future__-utsagn må være nær toppen av filen fordi de endrer grunnleggende ting om språket, og derfor må kompilatoren vite om dem fra begynnelsen

fra __future__ import utskriftsfunksjon

Følgende er koden med kommentarer på hvert trinn

# 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 importer matplotlib.pyplot som plt # Parametere learning_rate = 0,001 training_epochs = 15 batch_size = 100 display_step = 1 # Nettverksparametere n_hidden_1 = 256 # 1. lag antall funksjoner n_hidden_2 = 256 # 2. lag antall funksjoner n_inngang = 784 # MNIST datainngang (bildform: 28 * 28) n_klasser = 10 # MNIST totale klasser ( 0-9 sifre) # tf Grafinngang x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Opprett modell def multilayer_perceptron (x, vekter , skjevheter): # Skjult lag med RELU-aktiveringslag_1 = tf.add (tf.matmul (x, vekter ['h1']), skjevheter ['b1']) lag_1 = tf.nn.relu (lag_1) # Skjult lag med RELU aktiveringslag_2 = tf.add (tf.matmul (lag_1, vekter ['h2']), forspenninger ['b2']) lag_2 = tf.nn.relu (lag_2) # Utgangslag med lineær aktivering utlag = tf. matmul (lag _2, vekter ['ut']) + forspenninger ['ut'] returnerer ut_lag # Lagre lag vekt og forspenningsvekt = {'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]))} # Konstruer modell pred = multilayer_perceptron (x, vekter, skjevheter) # Definer tap og optimaliseringskostnad = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimer (kostnad) # Initialisere variablene init = tf.global_variables_initializer () # Opprett en tom liste for å lagre kostnadshistorikk og nøyaktighetshistorikk cost_history = [] accuracy_history = [] # Start grafen med tf.Session () som sess: sess.run (init ) # Treningssyklus for epoke innen rekkevidde (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Loop over all batches for i in range (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Kjør optimalisering op (backprop) og kostnad op (for å få tapsverdi) _, c = sess.run ([optimizer, cost], feed_dict = {x: batch_x, y: batch_y}) # Beregn gjennomsnittlig tap avg_cost + = c / total_batch # Vis logger per epoketrinn hvis epoke% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Beregn nøyaktighetsnøyaktighet = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = accuracy.eval ({x: mnist.test.images, y: mnist.test.labels}) # legg nøyaktigheten til listen nøyaktighet_historie.append (acu_temp) # tilføy kostnadshistorikk cost_history.append (avg_cost) print ('Epoch:', '% 04d'% (epoke + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Optimization Finished! ') # plott kostnadshistorikken plt.plot (cost_history) plt.show () # plott nøyaktighetshistorikken plt.plot (nøyaktighet _historie) plt.show () # Testmodell correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Beregn nøyaktighetsnøyaktighet = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Nøyaktighet: ', accuracy.eval ({x: mnist.test.images, y: mnist.test.labels}))

Produksjon:

Nå med dette kommer vi til slutten av denne Deep Learning with Python-artikkelen. Jeg håper du fikk forståelse for de ulike komponentene i Deep Learning, hvordan det hele begynte og hvordan vi bruker Python til å lage en enkel perseptron og et Deep Neural Network.

Edureka’s er kuratert av fagfolk i bransjen i henhold til bransjens krav og krav. Du vil mestre konseptene som SoftMax-funksjon, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM) og jobbe med biblioteker som Keras & TFLearn. Kurset er spesielt kuratert av bransjeeksperter med sanntidsstudier.

Har du et spørsmål til oss? Vennligst nevn det i kommentarfeltet i “Deep Learning with Python”, så kommer vi tilbake til deg.