Mély tanulás a Pythonnal: Útmutató a mély tanuláshoz kezdőknek

a 2018-19-es évek egyik legforróbb témája és jó okkal. Olyan sok előrelépés történt az iparban, ahol elérkezett az az idő, amikor a gépek vagy a számítógépes programok valóban felváltják az embereket. Ez Mély tanulás a Pythonnal cikk segít megérteni, mi is pontosan a mély tanulás, és hogyan tette lehetővé ezt az átállást. A cikk a következő témákkal foglalkozik:

• Data Science and It Components
• A mély tanulás szükségessége
• Mi a mély tanulás?
• Perceptron és mesterséges neurális hálózatok
• A mély tanulás alkalmazásai
• Miért a Python a mély tanuláshoz?
• Mély tanulás a Pythonnal: Perceptron példa
• Mély tanulás a Pythonnal: Mély neurális hálózat létrehozása

Data Science and It Components

Nos, a Data Science olyan dolog, amely már évek óta létezik. Adattudomány a tudás kinyerése az adatokból különböző technikák és algoritmusok alkalmazásával.

olyan technika, amely lehetővé teszi a gépek számára az emberi viselkedés utánzását. Az AI mögött rejlő ötlet meglehetősen egyszerű, mégis lenyűgöző, vagyis olyan intelligens gépek létrehozása, amelyek egyedül képesek döntéseket hozni. Éveken át azt hitték, hogy a számítógépek soha nem fognak megfelelni az emberi agy erejének.

Nos, akkor még nem volt elegendő adatunk és számítási erőnk, de most Nagy adat létrejöttével és a GPU-k megjelenésével a mesterséges intelligencia lehetséges.

hogyan állítsuk le a programot a java-ban

az AI technika egy olyan részhalmaza, amely statisztikai módszereket használ annak lehetővé tétele érdekében, hogy a gépek tapasztalattal javuljanak.

Mély tanulás az ML olyan részhalmaza, amely megvalósíthatóvá teszi a többrétegű neurális hálózat kiszámítását. Az ideghálózatokat használja az emberhez hasonló döntéshozatal szimulálására.

A mély tanulás szükségessége

A mesterséges intelligencia felé vezető lépés a gépi tanulás. A gépi tanulás a mesterséges intelligencia részhalmaza, és azon az elgondoláson alapul, hogy a gépeknek hozzáférést kell biztosítani az adatokhoz, és hagyni kell őket maguknak tanulni és felfedezni. A minták nagy adatkészletekből történő kinyerésével foglalkozik. A nagy adatkészletek kezelése nem jelentett problémát.

• Gépi tanulási algoritmusok nem tudja kezelni a nagydimenziós adatokat - ahol sok be- és kimenetünk van: több ezer dimenzió kerek. Az ilyen típusú adatok kezelése és feldolgozása nagyon összetetté és erőforrás-kimerítővé válik. Ezt nevezik A dimenzió átka.

• Egy másik kihívás, amellyel szembe kellett néznie, az volt kinyerendő funkciók . Ez fontos szerepet játszik az eredmény előrejelzésében, valamint a jobb pontosság elérésében. Ezért a funkció kibontása nélkül növekszik a kihívás a programozó számára, mivel az algoritmus hatékonysága nagyban függ attól, hogy a programozó mennyire éleslátó.

Most itt segített a mély tanulás. A mély tanulás az képes a nagy dimenziós adatok kezelésére és hatékony is a megfelelő funkciókra összpontosítva önmagában.

Mi a mély tanulás?

A mély tanulás a gépi tanulás olyan részhalmaza, ahol hasonló gépi tanulási algoritmusokat használnak a képzéshez jobb pontosság elérése érdekében azokban az esetekben, amikor az előbbi nem teljesített a jelig. Alapvetően, A mély tanulás utánozza az agyunk működését azaz tapasztalatból tanul.

Amint tudod,az agyunk áll neuronok milliárdjai ez csodálatos dolgokat tesz lehetővé. Még egy kisgyerek agya is képes olyan összetett problémák megoldására, amelyeket még a Szuperszámítógépek használata is nagyon nehéz megoldani. Tehát, hogyan érhetjük el ugyanazt a funkcionalitást egy programban? Most itt értjük meg Mesterséges neuron (Perceptron) és Mesterséges neurális hálózat.

Perceptron és mesterséges neurális hálózatok

A mély tanulás az agy alapvető egységét, az úgynevezett agysejtet vagy neuront vizsgálja. Most pedig értsük meg a biológiai idegsejtek funkcionalitását és azt, hogy miként utánozzuk ezt a funkciót az érzékelésben vagy egy mesterséges idegsejtben.

• Dendrite: Jeleket vesz más idegsejtektől
• Sejt test: Összegezi az összes bemenetet
• Axon: Jelek továbbítására szolgál a többi cellához

Mesterséges neuron vagy a Perceptron egy bináris osztályozáshoz használt lineáris modell. Modellez egy idegsejtet, amelynek egy sor bemenete van, amelyek mindegyikének adott súlya van. A neuron ezek alapján kiszámít valamilyen funkciót súlyozott bemeneti és megadja a kimenetet.

N bemenetet fogad (mindegyik tulajdonságnak megfelel). Ezután összegzi ezeket az inputokat, transzformációt alkalmaz és kimenetet állít elő. Két funkciója van:

• Összegzés
• Transzformáció (aktiválás)

A súly egy adott input hatékonyságát mutatja. Minél nagyobb az input súlya, annál inkább hatással lesz az ideghálózatra . Másrészről, Elfogultság egy további paraméter a Perceptron-ban, amelyet a kimenet és az idegsejt bemeneteinek súlyozott összegével együtt állítanak be, amely úgy segíti a modellt, hogy az a legjobban illeszkedjen az adott adatokhoz.

Aktiválási funkciók az inputokat kimenetekké alakítja. A kimenet előállításához küszöböt használ. Számos olyan funkció van, amelyet aktiválási funkcióként használnak, például:

• Lineáris vagy identitás
• Egység vagy bináris lépés
• Sigmoid vagy Logistic
• Tanh
• ReLU
• Softmax

Jól. ha úgy gondolja, hogy a Perceptron megoldja a problémát, akkor téved. Két fő probléma volt:

• Egyrétegű perceptronok nem osztályozhat nem lineárisan elkülöníthető adatpontokat .
• Összetett problémák, amelyek magukban foglalják sok paraméter nem lehet megoldani egyrétegű perceptronokkal.

Tekintsük az itt bemutatott példát és az érintett paraméterek összetettségét a marketing csapat döntésének meghozatalához.

Egy Neuron nem képes annyi bemenetet befogadni, és ezért egynél több neuront használnának a probléma megoldására. A Neural Network valójában csak a Perceptrons összetétele, különböző módon kapcsolódik össze és különböző aktiválási funkciókat működtet.

• Bemeneti csomópontok információt szolgáltatnak a külvilágtól a hálózatnak, és együttesen „bemeneti rétegként” emlegetik őket.
• Rejtett csomópontok végezzen számításokat és továbbítson információkat a bemeneti csomópontokról a kimeneti csomópontokra. A rejtett csomópontok gyűjteménye „rejtett réteget” alkot.
• Kimeneti csomópontok együttesen „Output Layer” -nek nevezik őket, és felelősek a számításokért és az információknak a hálózatról a külvilág felé történő továbbításáért.

Most, hogy van ötlete arról, hogyan viselkedik a perceptron, a különböző paraméterek és a neurális hálózat különböző rétege, folytassuk ezt a mély tanulást a Python Bloggal, és nézzük meg a Deep Learning néhány jó alkalmazását.

A mély tanulás alkalmazásai

A mély tanulásnak számos alkalmazási lehetősége van az iparban, íme néhány fontos, amelyek jelen vannak a napi feladatainkban.

• Beszédfelismerés

• Gépi fordítás

• Arcfelismerés és automatikus címkézés

• Virtuális személyi asszisztensek

• Önvezető autó

• Chatbotok

Miért a Python a mély tanuláshoz?

• olyan eszköz, amelynek egyedi attribútuma van, a általános célú programozási nyelv mint létező könnyen kezelhető amikor az analitikai és kvantitatív számítástechnikáról van szó.
• Ez nagyon könnyen érthető
• A Python az Dinamikusan beírva
• Hatalmas
• A könyvtárak hatalmas választéka különböző célokra, például Numpy, Seaborn, Matplotlib, Pandas és Scikit-learn

Elég az elméletből: Lássuk, hogyan kezdhetjük el a mély tanulást a Pythonnal egy apró, mégis izgalmas példával.

Mély tanulás Python-nal: Példa a Perceptron-ra

Most biztos vagyok benne, hogy önöknek ismerniük kell a „ VAGY' kapu. A kimenet az egy ha bármelyik bemenet is egy.

Ezért a Perceptron elválasztóként vagy döntési sorként használható, amely az OR Gate bemeneti halmazát két osztályra osztja:

1. osztály: Azok a bemenetek, amelyeknek a kimenete 0, amely a döntési vonal alatt található.
2. osztály: 1-es kimenettel rendelkező bemenetek, amelyek a döntési vonal vagy elválasztó felett helyezkednek el.

Eddig megértettük, hogy lineáris perceptron használható a bemeneti adatsor két osztályba sorolására. De hogyan osztályozza az adatokat valójában?

Matematikailag a perceptron úgy gondolható, mint a súlyok, a bemenetek és a torzítás egyenlete.

1. lépés: Importálja az összes szükséges könyvtárat

Itt csak egy könyvtárat fogok importálni, azaz. TensorFlow

import tensorflow mint tf

2. lépés: Definiálja a bemenet és a kimenet vektorváltozóit

Ezután változókat kell létrehoznunk a Perceptron bemenetének, kimenetének és elfogultságának tárolásához.

vonat_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] vonatkimenet = [[0], [1], [1], [1]]

3. lépés: Definiálja a súlyváltozót

Itt meghatározzuk a 3 × 1 alakú tenzor változót a súlyainkhoz, és kezdetben hozzáadunk néhány véletlenszerű értéket.

belépő szintű python fejlesztő folytatása

w = tf. Változó (tf.véletlen_normális ([3, 1], mag = 15))

4. lépés: Adja meg a bemenet és a kimenet helyőrzőit

Meg kell határoznunk a helyőrzőket, hogy azok a futás során elfogadhassák a külső bemeneteket.

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

5. lépés: Számítsa ki a kimeneti és az aktiválási funkciót

Mint korábban tárgyaltuk, a perceptron által beérkezett bemenetet először meg kell szorozni a megfelelő súlyokkal, majd ezeket a súlyozott bemeneteket összesíteni kell. Ezt az összegzett értéket azután aktiváláshoz adják hozzá a végeredmény megszerzéséhez.

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

Megjegyzés: Ebben az esetben használtam relu mint az aktiválási funkcióm. Bármelyik aktiválási funkciót igény szerint használhatja.

6. lépés: Számolja ki a költséget vagy a hibát

Ki kell számolnunk a Cost = Mean Squared Error értéket, ami nem más, mint a perceptron és a kívánt kimenet különbségének négyzete.

veszteség = tf.reduce_sum (tf.square (output - y))

7. lépés: Minimalizálja a hibát

A perceptron célja a veszteség, költség vagy hiba minimalizálása. Tehát itt fogjuk használni a Gradient Descent Optimizer alkalmazást.

optimalizáló = tf.train.GradientDescentOptimizer (0,01) vonat = optimalizáló.minimalizálni (veszteség)

8. lépés: Inicializálja az összes változót

A változókat csak tf.Változó. Tehát inicializálnunk kell a definiált változókat.

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

9. lépés: A Perceptron kiképzése az iterációkban

Meg kell képeznünk a perceptronunkat, vagyis frissítenünk kell a súlyok és az elfogultság értékeit az egymást követő iterációban a hiba vagy a veszteség minimalizálása érdekében. Itt fogom képezni perceptronunkat 100 korszakban.

i tartományban (100): sess.run (vonat, {x: train_in, y: train_out}) költség = sess.run (loss, feed_dict = {x: train_in, y: train_out}) nyomtatás ('Epoch-- (i, '- veszteség -', költség)

10. lépés: Kimenet

……

……

Amint itt láthatja, a veszteség itt kezdődött 2.07 és ekkor ért véget 0,27

.

Mély tanulás a Pythonnal: Mély neurális hálózat létrehozása

Most, hogy sikeresen létrehoztunk egy perceptront és betanítottuk egy OR kapu számára. Folytassuk ezt a cikket, és nézzük meg, hogyan hozhatunk létre saját Neural Network-t a Scratch-ból, ahol létrehozunk egy Input Layer, Rejtett Rétegeket és Output Layer-t.

tizedesjegyet konvertálni bináris pythonra

Az MNIST adatkészletet fogjuk használni. Az MNIST adatkészlet a következőkből áll 60 000 képzés minták és 10.000 tesztelés kézzel írott számjegyű képek mintái. A képek nagyságúak 28 × 28 képpont és a kimenet között lehet 0–9 .

A feladat egy olyan modell kiképzése, amely pontosan képes azonosítani a képen lévő számjegyet

Először az alábbi importálást fogjuk használni, hogy a nyomtatási funkciót a Python 3-ból a Python 2.6+ verzióba vigyük. A __future__ utasításoknak a fájl tetejének közelében kell lenniük, mert megváltoztatják a nyelv alapvető elemeit, ezért a fordítónak kezdettől fogva tudnia kell róluk

a __future__ import nyomtatási funkcióból

Az alábbiakban megadjuk a kódot, amelyben minden lépésnél megjegyzéseket találunk

# MNIST-adatok importálása a tensorflow.examples.tutorials.mnist fájlból: input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) import tensorflow mint tf import matplotlib.pyplot mint plt # Paraméterek learning_rate = 0.001 training_epoch batch_size = 100 display_step = 1 # Hálózati paraméterek n_hidden_1 = 256 # Az első réteg funkcióinak száma n_hidden_2 = 256 # A második réteg jellemzőinek száma n_input = 784 # MNIST adatbevitel (img alak: 28 * 28) n_classes = 10 # MNIST összes osztály ( 0-9 számjegy) # tf Grafikon bemenet x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Modell létrehozása def multilayer_perceptron (x, súlyok , torzítások): # Rejtett réteg RELU aktiválási réteggel_1 = tf.add (tf.matmul (x, súlyok ['h1']), torzítások ['b1']) réteg_1 = tf.nn.relu (réteg_1) # Rejtett réteg RELU aktiválási réteggel_2 = tf.add (tf.matmul (réteg_1, súlyok ['h2']), torzítások ['b2']) layer_2 = tf.nn.relu (layer_2) # Kimeneti réteg lineáris aktiválással out_layer = tf. matmul (réteg _2, súlyok ['ki']) + torzítások ['ki'] visszatérnek_réteg # Tárolja a rétegek súlyát és elfogultsági súlyait = {'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]))} torzítások = {'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]))} # Modell megalkotása pred = többrétegű_perceptron (x, súlyok, torzítások) # Definiálja a veszteséget és az optimalizáló költségét = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimalizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimalizálja (költség) # A változók inicializálása init = tf.global_variables_initializer () # hozzon létre egy üres listát a költségelőzmények és a pontosság előzményeinek tárolásához cost_history = [] pontosság_história = [] # Indítsa el a grafikont a tf.Session () néven: ) # Képzési ciklus a korszak tartományában (képzési_korszakok): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Hurok a tartomány összes i-jére (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Optimalizálás futtatása (backprop) és költség op (a veszteségérték megszerzéséhez) _, c = sess.run ([optimalizáló, költség], feed_dict = {x: batch_x, y: batch_y}) # Az átlagos veszteség átlagának kiszámítása + = c / total_batch # Naplók megjelenítése korszakonként, ha % display_step == 0: helyes_predikció = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Pontosság kiszámítása = tf.reduce_mean (tf.cast (helyes_predikció, 'float') ) acu_temp = pontosság.eval ({x: mnist.test.images, y: mnist.test.labels}) # a pontosság hozzáfűzése a listához pontosság_história.apcsat (szem_hőmérséklet) # csatolja a költségelőzmények költség_história.append (átl ._költség) nyomtatást ('Epoch:', '% 04d'% (epoch + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Pontosság =', acu_temp) print ('Optimalizálás kész! ') # ábrázolja a költségelőzményeket plt.plot (költség_előzmények) plt.show () # ábrázolja a pontosság előzményeit plt.plot (pontosság _history) plt.show () # Tesztmodell helyes_predikció = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Pontossági pontosság kiszámítása = tf.reduce_mean (tf.cast (helyes_predikció, ' float ')) print (' Pontosság: ', pontosság.eval ({x: mnist.test.images, y: mnist.test.labels}))

Kimenet:

Ezzel ezzel a Deep Learning with Python című cikk végére értünk. Remélem, megértette a mély tanulás különféle összetevőit, az egész kezdetét és a Python használatával létrehozhatunk egy egyszerű perceptront és egy mély neurális hálózatot.

Edureka's ipari szakemberek gondozzák az ipar követelményeinek és igényeinek megfelelően. Elsajátítja az olyan fogalmakat, mint a SoftMax funkció, az Autoencoder Neural Networks, a Restricted Boltzmann Machine (RBM), és olyan könyvtárakkal fog dolgozni, mint a Keras és a TFLearn. A tanfolyamot ipari szakemberek készítették, valós idejű esettanulmányokkal.

Van egy kérdésünk? Kérjük, említse meg a „Mély tanulás a Pythonnal” megjegyzés rovatban, és kapcsolatba lépünk Önnel.