on yksi vuosien 2018-19 kuumimmista aiheista ja hyvästä syystä. Teollisuudessa on tapahtunut niin monta edistystä, että on tullut aika, jolloin koneet tai tietokoneohjelmat todella korvaavat ihmisen. Tämä Syvä oppiminen Pythonin kanssa artikkeli auttaa sinua ymmärtämään, mikä on syvällinen oppiminen ja miten tämä siirtyminen on mahdollistettu. Käsittelen seuraavia aiheita tässä artikkelissa:
- Datatiede ja sen komponentit
- Syvän oppimisen tarve
- Mikä on syväoppiminen?
- Perceptron ja keinotekoiset hermoverkot
- Syvän oppimisen sovellukset
- Miksi Python syvälle oppimiselle?
- Syvä oppiminen Pythonilla: Perceptron-esimerkki
- Syvä oppiminen Pythonilla: Syvän hermoverkon luominen
Datatiede ja sen komponentit
No, datatiede on jotain, joka on ollut siellä ikuisesti. Datatiede on tiedon poiminta tiedoista käyttämällä erilaisia tekniikoita ja algoritmeja.
on tekniikka, jonka avulla koneet voivat jäljitellä ihmisten käyttäytymistä. Tekoälyn taustalla oleva ajatus on melko yksinkertainen mutta kiehtova, eli älykkäiden koneiden valmistaminen, jotka voivat tehdä päätöksiä yksin. Vuosien ajan ajateltiin, että tietokoneet eivät koskaan sovi ihmisen aivojen voimaan.
No, silloin meillä ei ollut tarpeeksi dataa ja laskentatehoa, mutta nyt Suuri data syntymässä ja GPU: iden tullessa keinotekoinen älykkyys on mahdollista.
erot abstraktin luokan ja käyttöliittymän välillä
on osa AI-tekniikkaa, joka käyttää tilastollisia menetelmiä koneiden parantamiseksi kokemuksen avulla.
Syvä oppiminen on ML: n osajoukko, joka tekee monikerroksisen hermoverkon laskennan mahdolliseksi. Se käyttää hermoverkkoja simuloimaan ihmisen kaltaista päätöksentekoa.
Syvän oppimisen tarve
Askel kohti tekoälyä on koneoppiminen. Koneoppiminen on tekoälyn osajoukko ja perustuu ajatukseen, että koneille olisi annettava pääsy tietoihin, ja niiden olisi jätettävä oppia ja tutkia itse. Se käsittelee kuvioiden poimintaa suurista tietojoukoista. Suurten tietojoukkojen käsittely ei ollut ongelma.
- Koneoppimisalgoritmit ei voi käsitellä suuria ulottuvuuksia - missä meillä on suuri määrä tuloja ja lähtöjä: tuhansia ulottuvuuksia. Tällaisten tietojen käsittelystä ja käsittelystä tulee hyvin monimutkaista ja resurssien tyhjentävää. Tätä kutsutaan Ulottuvuuden kirous.
- Toinen kohtaama haaste oli määritellä purettavat ominaisuudet . Tällä on tärkeä rooli ennustettaessa lopputulosta sekä parempaa tarkkuutta. Siksi ilman ominaisuuden purkamista ohjelmoijan haaste kasvaa, kun algoritmin tehokkuus riippuu suuresti siitä, kuinka oivaltava ohjelmoija on.
Täällä syvällinen oppiminen tuli apuun. Syvä oppiminen on pystyy käsittelemään suuria ulottuvuuksia koskevia tietoja ja on myös tehokas vuonna keskittyen oikeisiin ominaisuuksiin omillaan.
Mikä on syväoppiminen?
Syväoppiminen on koneoppimisen osajoukko, jossa samanlaisia koneoppimisalgoritmeja käytetään kouluttamiseen paremman tarkkuuden saavuttamiseksi niissä tapauksissa, joissa edellinen ei toiminut merkin tasolle asti. Pohjimmiltaan, Syvä oppiminen jäljittelee aivojemme toimintaa ts. se oppii kokemuksesta.
Kuten tiedät,aivomme koostuvat miljardeja hermosoluja jonka avulla voimme tehdä upeita asioita. Jopa pienen lapsen aivot pystyvät ratkaisemaan monimutkaisia ongelmia, joita on erittäin vaikea ratkaista jopa supertietokoneiden avulla. Joten, miten voimme saavuttaa saman toiminnallisuuden ohjelmassa? Nyt ymmärrämme tämän Keinotekoinen neuroni (Perceptron) ja Keinotekoinen hermoverkko.
Perceptron ja keinotekoiset hermoverkot
Deep Learning tutkii aivojen perusyksikköä, jota kutsutaan aivosoluksi tai neuroniksi. Olkaamme nyt ymmärrettävä biologisten hermosolujen toimivuus ja miten jäljittelemme tätä toiminnallisuutta havainnossa tai keinotekoisessa neuronissa.
- Dendrite: Vastaanottaa signaaleja muilta neuroneilta
- Solun elin: Summaa kaikki syötteet
- Axon: Sitä käytetään lähettämään signaaleja muille soluille
Keinotekoinen neuroni tai a Perceptron on lineaarinen malli, jota käytetään binääriluokituksessa. Se mallintaa hermosolua, jolla on joukko tuloja, joista jokaiselle annetaan erityinen paino. Neuroni laskee jonkin toiminnon näille painotettu syöttää ja antaa lähdön.
Se vastaanottaa n tuloa (vastaa kutakin ominaisuutta). Sitten se summaa nämä panokset, soveltaa muunnosta ja tuottaa tuotoksen. Sillä on kaksi toimintoa:
- Yhteenveto
- Muunnos (aktivointi)
Paino osoittaa tietyn syötteen tehokkuuden. Mitä enemmän panos painaa, sitä enemmän se vaikuttaa hermoverkkoon . Toisaalta, Puolueellisuus on lisäparametri Perceptronissa, jota käytetään säätämään lähtö ja hermosyötön painotettu summa, joka auttaa mallia tavalla, joka sopii parhaiten annettuihin tietoihin.
Aktivointitoiminnot kääntää tulot tuotoksiksi. Se käyttää kynnystä tuotoksen tuottamiseen. Aktivointitoimintoina käytetään monia toimintoja, kuten:
- Lineaarinen tai identiteetti
- Yksikkö tai binaarivaihe
- Sigmoid tai logistinen
- Tanh
- ReLU
- Softmax
Hyvin. jos luulet Perceptronin ratkaisevan ongelman, olet väärässä. Oli kaksi suurta ongelmaa:
- Yksikerroksiset perceptronit ei voi luokitella ei-lineaarisesti erotettavia datapisteitä .
- Monimutkaiset ongelmat, joihin liittyy paljon parametreja ei voida ratkaista yksikerroksisilla perceptroneilla.
Tarkastellaan tässä olevaa esimerkkiä ja monimutkaisuutta mukana olevien parametrien kanssa, jotta markkinointitiimi voi tehdä päätöksen.
Yksi neuroni ei voi ottaa vastaan niin monta tuloa ja siksi tämän ongelman ratkaisemiseksi käytettäisiin useampaa kuin yhtä neuronia. Neuroverkko on oikeastaan vain Perceptronien koostumus, yhdistettynä eri tavoin ja toimii eri aktivointitoiminnoilla.
- Tulosolmut tarjota tietoa ulkomaailmasta verkkoon ja niitä kutsutaan yhdessä nimellä 'Input Layer'.
- Piilotetut solmut suorittaa laskutoimituksia ja siirtää tietoja tulosolmuista ulostulosolmuihin. Piilotettujen solmujen kokoelma muodostaa 'piilotetun kerroksen'.
- Lähtösolmut Niitä kutsutaan yhdessä nimellä 'Output Layer' ja ne ovat vastuussa laskennasta ja tiedon siirtämisestä verkosta ulkomaailmaan.
Nyt kun sinulla on käsitys perceptronin käyttäytymisestä, erilaisista parametreista ja hermoverkon eri kerroksista, jatketaan tätä syvällistä oppimista Python-blogilla ja näemme joitain hienoja Deep Learning -sovelluksia.
Syvän oppimisen sovellukset
Deep Learning -sovelluksessa on useita sovelluksia, tässä on muutamia tärkeitä, jotka ovat läsnä päivittäisissä tehtävissämme.
- Puheentunnistus
- Konekäännös
- Kasvojentunnistus ja automaattinen koodaus
- Virtuaaliset henkilökohtaiset avustajat
- Itse ajava auto
- Chatbotit
Miksi Python syvälle oppimiselle?
- on yksi sellainen työkalu, jolla on ainutlaatuinen ominaisuus olla yleiskäyttöinen ohjelmointikieli sellaisena kuin se on helppokäyttöinen kun on kyse analyyttisestä ja kvantitatiivisesta laskennasta.
- Se on hyvin helppo ymmärtää
- Python on Dynaamisesti kirjoitettu
- Valtava
- Laaja valikoima kirjastoja eri tarkoituksiin, kuten Numpy, Seaborn, Matplotlib, Pandas ja Scikit-learn
Riittävästi teoriasta, katsotaanpa, kuinka voimme aloittaa syvällisen oppimisen Pythonin kanssa pienellä mutta jännittävällä esimerkillä.
Syvä oppiminen Pythonilla: Perceptron-esimerkki
Nyt olen varma, että teidän on tunnettava ” TAI' portti. Tulos on yksi jos jokin tuloista on myös yksi.
Siksi Perceptronia voidaan käyttää erottimena tai päätösrivinä, joka jakaa OR-portin tulojoukon kahteen luokkaan:
Luokka 1: Tulot, joiden lähtö on 0 ja joka on päätöslinjan alapuolella.
Luokka 2: Tulot, joiden lähtö on 1 ja joka on päätöslinjan tai erottimen yläpuolella.
Tähän asti olemme ymmärtäneet, että lineaarista perceptronia voidaan käyttää luokittelemaan tulodataryhmä kahteen luokkaan. Mutta miten se todella luokittelee tiedot?
Matemaattisesti perceptronia voidaan ajatella kuin painojen, panosten ja ennakkojen yhtälöä.
Vaihe 1: Tuo kaikki vaaditut kirjastot
Täällä tuon vain yhden kirjaston, ts. TensorFlow
tuo tensorflow tf: nä
Vaihe 2: Määritä vektorimuuttujat tuloa ja lähtöä varten
Seuraavaksi meidän on luotava muuttujia Perceptronin syötteen, lähdön ja esijännityksen tallentamiseksi.
junan_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] junan lähtö = [[0], [1], [1], [1]]
Vaihe 3: Määritä painomuuttuja
Tässä määritellään painojemme muodon 3 × 1 tensorimuuttuja ja määritetään sille alun perin joitain satunnaisia arvoja.
mikä on Salesforce-palvelupilvi
w = tf Muuttuja (tf.satunnainen_normaali ([3, 1], siemen = 15))
Vaihe 4: Määritä syötteen ja lähdön paikkamerkit
Meidän on määriteltävä paikkamerkit, jotta ne voivat hyväksyä ulkoiset syötteet ajon aikana.
x = tf.placeholder (tf.float32, [Ei mitään, 3]) y = tf.placeholder (tf.float32, [Ei mitään, 1])
Vaihe 5: Laske lähtö- ja aktivointitoiminto
Kuten aiemmin keskusteltiin, perceptronin vastaanottama tulo kerrotaan ensin vastaavilla painoilla ja sitten kaikki nämä painotetut tulot summataan yhteen. Tämä summa-arvo syötetään sitten aktivointiin lopullisen tuloksen saamiseksi.
lähtö = tf.nn.relu (tf.matmul (x, w))
Huomaa: Tässä tapauksessa olen käyttänyt relu aktivointitoimintona. Voit käyttää mitä tahansa aktivointitoimintoa tarpeen mukaan.
Vaihe 6: Laske hinta tai virhe
Meidän on laskettava kustannus = keskimääräinen neliövirhe, joka ei ole muuta kuin perceptronilähdön ja halutun ulostulon eron neliö.
tappio = tf.reduce_sum (tf.neliö (lähtö - y))
Vaihe 7: Minimoi virhe
Perceptronin tavoitteena on minimoida tappio tai kustannus tai virhe. Joten tässä aiomme käyttää Gradient Descent Optimizer -ohjelmaa.
optimoija = tf.train.GradientDescentOptimizer (0.01) juna = optimizer.minimoi (menetys)
Vaihe 8: Alusta kaikki muuttujat
Muuttujat määritellään vain tf Muuttuja. Joten meidän on alustettava määritellyt muuttujat.
init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)
Vaihe 9: Perceptronin kouluttaminen iteraatioissa
Meidän on koulutettava perceptronimme eli päivitettävä painojen ja ennakkoluulojen arvot peräkkäisessä iteroinnissa virheiden tai menetysten minimoimiseksi. Täällä koulutan perceptroniamme sadassa aikakaudessa.
i: lle alueella (100): sess.run (juna, {x: train_in, y: train_out}) hinta = sess.run (loss, feed_dict = {x: train_in, y: train_out}) tulosta ('Epoch-- ', i,' - menetys - ', kustannus)
Vaihe 10: Tulos
……
……
Kuten näette täällä, menetys alkoi 2.07 ja päättyi klo 0,27
.
Syvä oppiminen Pythonilla: Syvän hermoverkon luominen
Nyt kun olemme onnistuneesti luoneet perceptronin ja kouluttaneet sen TAI-portille. Jatketaan tätä artikkelia ja katsotaan, miten voimme luoda oman hermoverkostomme Scratchista, jossa luomme syöttökerroksen, piilotetut kerrokset ja tulostuskerroksen.
menetelmä ylikuormittaa ja ohittaa Java-sovelluksessa
Aiomme käyttää MNIST-tietojoukkoa. MNIST-tietojoukko koostuu 60000 koulutusta näytteet ja 10000 testausta näytteet käsinkirjoitetuista numeroista. Kuvat ovat kooltaan 28 × 28 pikseliä ja tulos voi olla välillä 0-9 .
Tehtävänä on kouluttaa malli, joka tunnistaa tarkasti kuvassa olevan numeron
Ensinnäkin aiomme käyttää alla olevaa tuontia tuoda tulostustoiminto Python 3: sta Python 2.6+: een. __future__ -lausekkeiden on oltava lähellä tiedoston yläosaa, koska ne muuttavat kielen perusasioita, joten kääntäjän on tiedettävä niistä alusta alkaen
from __future__ import print_function
Seuraava on koodi, joka sisältää kommentteja jokaisessa vaiheessa
# Tuo MNIST-tiedot osoitteesta tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) tuo tensorflow tf-tuontina matplotlib.pyplot plt-muodossa # Parametrit learning_rate = 0.001 training_epoch batch_size = 100 display_step = 1 # Verkon parametrit n_hidden_1 = 256 # 1. kerroksen ominaisuuksien määrä n_hidden_2 = 256 # 2. kerroksen ominaisuuksien lukumäärä n_input = 784 # MNIST-tietojen syöttö (img-muoto: 28 * 28) n_classes = 10 # MNIST-luokkien kokonaismäärä ( 0-9 numeroa) # tf Kaaviosyöttö x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Luo malli def multilayer_perceptron (x, painot , biases): # Piilotettu kerros, jossa RELU-aktivointikerros RELU-aktivointikerroksella_2 = tf.add (tf.matmul (kerros_1, painot ['h2']), esijännitykset ['b2']) layer_2 = tf.nn.relu (layer_2) # Lineaarisen aktivoinnin antava taso out_layer = tf. matmul (kerros _2, painot ['ulos']) + esijännitykset ['pois'] palauttavat_kerros # Tallentaa kerrosten paino- ja esijännityspainot = {'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]))}} # Rakenna malli pred = monikerroksinen_perceptron (x, painot, ennakkoarvot) # Määritä tappio ja optimoijan kustannukset = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimoi (kustannus) # Muuttujien alustaminen init = tf.global_variables_initializer () #luoda tyhjä luettelo kustannushistorian ja tarkkuushistorian tallentamiseksi cost_history = [] Tarkkuus_historia = [] # Käynnistä kaavio tf.Session (): lla sess: sess.run (init ) # Harjoitusjakso aikakaudelle vaihteluvälillä (koulutus_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Silmukka kaikkien alueen i erien välillä (yhteensä_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Suorita optimointi op (backprop) ja kustannukset op (tappioarvon saamiseksi) _, c = sess.run ([optimoija, hinta], feed_dict = {x: batch_x, y: batch_y}) # Laske keskimääräinen tappio keskim. kustannus + = c / total_batch # Näytä lokit jaksokohtaisesti aikakausi% display_step == 0: oikea_ennuste = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Laske tarkkuustarkkuus = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = Tarkkuus.eval ({x: mnist.test.images, y: mnist.test.labels}) # liitä tarkkuus luetteloon tarkkuushistoria.lisää (silmä_temp) #liitä kustannushistoria kustannushistoria.lisää (keskim. kustannus) -tulos ('Epoch:', '% 04d'% (epoch + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Optimointi valmis! ') # piirrä kustannushistoria plt.plot (kustannushistoria) plt.show () # piirrä tarkkuushistoria plt.plot (tarkkuus _historia) plt.show () # Testimalli oikea_ennuste = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Laske tarkkuustarkkuus = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Tarkkuus: ', Tarkkuus.eval ({x: mnist.test.images, y: mnist.test.labels}))
Tuotos:
Nyt olemme päässeet tämän Deep Learning with Python -artikkelin loppuun. Toivon, että sait käsityksen syvällisen oppimisen eri komponenteista, siitä, miten kaikki alkoi ja kuinka Pythonia käyttämällä voimme luoda yksinkertaisen perceptronin ja syvän hermoverkon.
Edurekan on kuratoinut alan ammattilaiset alan vaatimusten ja vaatimusten mukaisesti. Opit käsitteet, kuten SoftMax-toiminto, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM) ja työskentelet kirjastojen, kuten Keras & TFLearn, kanssa. Kurssin ovat erikoistuneet alan asiantuntijat reaaliaikaisilla tapaustutkimuksilla.
Onko sinulla kysymys meille? Mainitse se kommentissa 'Deep Learning with Python', niin palaamme sinuun.