Dziļa mācīšanās ar Python: iesācēju padziļinātas mācīšanās ceļvedis



Šis raksts sniegs jums visaptverošas un detalizētas zināšanas par padziļinātu mācīšanos ar Python un to, cik noderīga tā ir ikdienas dzīvē.

ir viena no karstākajām 2018.-19. Gada tēmām un laba iemesla dēļ. Rūpniecībā ir tik daudz sasniegumu, ka ir pienācis laiks, kad mašīnas vai datorprogrammas patiešām aizstāj cilvēkus. Šis Dziļa mācīšanās ar Python raksts palīdzēs jums saprast, kas īsti ir padziļināta mācīšanās un kā šī pāreja ir bijusi iespējama. Šajā rakstā apskatīšu šādas tēmas:

Datu zinātne un tā komponenti

Nu, Datu zinātne ir kaut kas tāds, kas tur ir bijis jau sen. Datu zinātne ir zināšanu iegūšana no datiem, izmantojot dažādas metodes un algoritmus.





AI laika skala - padziļināta mācīšanās ar Python - Edureka

ir tehnika, kas ļauj mašīnām atdarināt cilvēku uzvedību. AI ideja ir diezgan vienkārša, bet aizraujoša, proti, izveidot viedas mašīnas, kas pašas var pieņemt lēmumus. Gadiem ilgi tika uzskatīts, ka datori nekad neatbilst cilvēka smadzeņu jaudai.



Nu, toreiz mums nebija pietiekami daudz datu un aprēķina jaudas, bet tagad ar Lielie dati un GPU parādīšanās, mākslīgais intelekts ir iespējams.

ir AI tehnikas apakškopa, kurā tiek izmantotas statistikas metodes, lai mašīnas varētu pilnveidoties ar pieredzi.



Dziļa mācīšanās ir ML apakškopa, kas padara iespējamu daudzslāņu neironu tīkla aprēķināšanu. Tas izmanto neironu tīklus, lai simulētu cilvēkiem līdzīgu lēmumu pieņemšanu.

Nepieciešamība pēc dziļas mācīšanās

Solis ceļā uz mākslīgo intelektu ir mašīnmācīšanās. Mašīnmācība ir AI apakškopa un balstās uz ideju, ka mašīnām jādod piekļuve datiem, un tām jāatstāj pašiem mācīties un izpētīt. Tas nodarbojas ar modeļu iegūšanu no lielām datu kopām. Apstrāde ar lielām datu kopām nebija problēma.

  • Mašīnmācīšanās algoritmi nevar apstrādāt augstas dimensijas datus - kur mums ir daudz ieejas un izejas: ap tūkstošiem dimensiju. Šāda veida datu apstrāde un apstrāde kļūst ļoti sarežģīta un resursu izsmeļoša. To sauc par Dimensijas lāsts.

  • Vēl viens izaicinājums, ar kuru saskārās, bija, lai precizētu iegūstamās funkcijas . Tam ir svarīga loma rezultāta prognozēšanā, kā arī labākas precizitātes sasniegšanā. Tāpēc bez iezīmju ekstrakcijas izaicinājums programmētājam palielinās, jo algoritma efektivitāte ir ļoti atkarīga no tā, cik ieskatīgs ir programmētājs.

Lūk, šeit Deep Learning nāca talkā. Dziļa mācīšanās ir kas spēj apstrādāt augstas dimensijas datus un ir efektīvs arī koncentrējoties uz pareizajām funkcijām pats.

Kas ir dziļa mācīšanās?

Dziļā mācīšanās ir mašīnmācīšanās apakškopa, kurā apmācībai tiek izmantoti līdzīgi mašīnmācīšanās algoritmi lai panāktu labāku precizitāti tajos gadījumos, kad pirmais nedarbojās līdz atzīmei. Būtībā Dziļa mācīšanās atdarina mūsu smadzeņu darbību i., tas mācās no pieredzes.

Kā Jūs zinat,mūsu smadzenes sastāv no miljardiem neironu kas ļauj mums izdarīt pārsteidzošas lietas. Pat maza bērna smadzenes spēj atrisināt sarežģītas problēmas, kuras ir ļoti grūti atrisināt, pat izmantojot superdatorus. Tātad, kā mēs varam sasniegt tādu pašu funkcionalitāti programmā? Tagad mēs saprotam Mākslīgais neirons (Perceptron) un Mākslīgais neironu tīkls.

Perceptron un mākslīgie neironu tīkli

Dziļā mācīšanās pēta smadzeņu pamatvienību, ko sauc par smadzeņu šūnu vai neironu. Tagad ļaujiet mums saprast bioloģisko neironu funkcionalitāti un to, kā mēs atdarinām šo funkcionalitāti uztverē vai mākslīgajā neironā.

  • Dendrīts: Saņem signālus no citiem neironiem
  • Šūnas korpuss: Apkopo visus ievadītos datus
  • Aksons: To izmanto signālu pārraidīšanai uz citām šūnām

Mākslīgais neirons vai a Perceptron ir lineārs modelis, ko izmanto binārai klasifikācijai. Tas modelē neironu, kuram ir izejvielu kopums, un katram no tiem ir noteikts svars. Neirons aprēķina kādu no šīm funkcijām svērts ievada un dod izvadi.

Tas saņem n ieejas (atbilst katrai funkcijai). Pēc tam tā summē šos ieguldījumus, piemēro transformāciju un rada izvadi. Tam ir divas funkcijas:

  • Apkopojums
  • Pārveidošana (aktivizēšana)

Svars parāda konkrēta ieguldījuma efektivitāti. Jo lielāks būs ievades svars, jo vairāk tas ietekmēs neironu tīklu . No otras puses, Aizspriedums ir papildu parametrs Perceptronā, ko izmanto, lai pielāgotu izvadi kopā ar neirona izejvielu svērto summu, kas palīdz modelim tā, lai tas vislabāk atbilstu dotajiem datiem.

Aktivizācijas funkcijas pārveido ievadi izvadēs. Produkcijas iegūšanai tā izmanto slieksni. Ir daudzas funkcijas, kuras tiek izmantotas kā aktivizācijas funkcijas, piemēram:

dinamiskās atmiņas piešķiršana c ++
  • Lineārā vai identitāte
  • Vienība vai binārā darbība
  • Sigmoid vai loģistika
  • Tanh
  • ReLU
  • Softmax

Nu. ja jūs domājat, ka Perceptron atrisina problēmu, tad jūs kļūdāties. Bija divas galvenās problēmas:

  • Vienslāņu perceptroni nevar klasificēt nelineāri atdalāmus datu punktus .
  • Sarežģītas problēmas, kas saistītas daudz parametru nevar atrisināt ar viena slāņa perceptroniem.

Apsveriet šeit sniegto piemēru un sarežģītību ar saistītajiem parametriem, lai mārketinga komanda pieņemtu lēmumu.

Viens neirons nevar uzņemt tik daudz ievadu, un tāpēc šīs problēmas risināšanai tiktu izmantoti vairāk nekā viens neirons. Neironu tīkls patiesībā ir tikai Perceptrons sastāvs, kas savienots dažādos veidos un darbojas ar dažādām aktivizācijas funkcijām.

  • Ievades mezgli sniedz informāciju no ārpasaules tīklam un tos kopā dēvē par “ievades slāni”.
  • Slēptie mezgli veikt aprēķinus un pārsūtīt informāciju no ievades mezgliem uz izvades mezgliem. Slēpto mezglu kolekcija veido “slēpto slāni”.
  • Izejas mezgli tiek kopīgi dēvēti par “Izejas slāni” un ir atbildīgi par aprēķiniem un informācijas pārsūtīšanu no tīkla uz ārpasauli.

Tagad, kad jums ir ideja par perceptrona izturēšanos, dažādiem iesaistītajiem parametriem un dažādiem neironu tīkla slāņiem, turpināsim šo padziļināto mācīšanos ar Python emuāru un skatīsim dažas foršas Deep Learning lietojumprogrammas.

Dziļās mācīšanās pielietojumi

Nozarē ir dažādas dziļas mācīšanās iespējas. Šeit ir daži no svarīgākajiem, kas ir iekļauti mūsu ikdienas uzdevumos.

  • Runas atpazīšana

  • Mašīntulkošana

  • Sejas atpazīšana un automātiska iezīmēšana

  • Virtuālie personīgie asistenti

  • Pašbraucoša automašīna

  • Tērzēšanas roboti

Kāpēc Python for Deep Learning?

  • ir viens no šādiem rīkiem, kam ir unikāls atribūts - būt vispārējas nozīmes programmēšanas valoda kā būt viegli izmantot kad runa ir par analītisko un kvantitatīvo skaitļošanu.
  • Tas ir ļoti viegli saprast
  • Python ir Dinamiski ierakstīts
  • Milzīgs
  • Plašs bibliotēku klāsts dažādiem mērķiem, piemēram, Numpy, Seaborn, Matplotlib, Pandas un Scikit-learn

Tagad pietiek ar teoriju. Apskatīsim, kā mēs varam sākt dziļu mācīšanos ar Python ar nelielu, bet aizraujošu piemēru.

Dziļa mācīšanās ar Python: Perceptron piemērs

Tagad es esmu pārliecināts, ka jums, puiši, ir jāpārzina “ VAI ” vārti. Rezultāts ir viens ja arī kāda no ieejām ir viens.

Tāpēc Perceptron var izmantot kā atdalītāju vai lēmumu līniju, kas OR Gate ieejas kopu sadala divās klasēs:

1. klase: Ieejas, kuru izeja ir 0 un kas atrodas zem lēmuma līnijas.
2. klase: Ieejas ar izeju kā 1, kas atrodas virs lēmuma līnijas vai atdalītāja.

Līdz šim mēs sapratām, ka lineāro perceptronu var izmantot, lai klasificētu ievades datu kopu divās klasēs. Bet kā tas faktiski klasificē datus?

Matemātiski perceptronu var uzskatīt par svaru, ievades un novirzes vienādojumu.

1. darbība: importējiet visu nepieciešamo bibliotēku

Šeit es importēšu tikai vienu bibliotēku, ti. TensorFlow

importēt tensorflow kā tf

2. solis: definējiet ievades un izvades vektoru mainīgos

Tālāk mums jāizveido mainīgie Perceptron ievades, izvades un aizspriedumu glabāšanai.

vilciena_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] vilciena izeja = [[0], [1], [1], [1]]

3. solis: definējiet mainīgo svaru

Šeit mēs definēsim 3 × 1 formas tenzora mainīgo mūsu svariem un sākotnēji tam piešķirsim dažas nejaušas vērtības.

w = tf. Mainīgais (tf.random_normal ([3, 1], sēkla = 15))

4. darbība: definējiet ievades un izvades vietturus

Mums ir jādefinē vietturi, lai tie varētu pieņemt ārējus ievadus.

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

5. solis: Aprēķiniet izejas un aktivizācijas funkciju

Kā jau tika apspriests iepriekš, perceptrona saņemtā ieeja vispirms tiek reizināta ar attiecīgajiem svariem un pēc tam visas šīs svērtās ieejas tiek summētas kopā. Pēc tam šī summētā vērtība tiek aktivizēta, lai iegūtu galīgo rezultātu.

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

Piezīme: Šajā gadījumā es esmu izmantojis relu kā mana aktivizācijas funkcija. Jūs varat brīvi izmantot jebkuru no aktivizācijas funkcijām atbilstoši savām vajadzībām.

6. solis: aprēķiniet izmaksas vai kļūdu

Mums jāaprēķina izmaksas = vidējā kvadrāta kļūda, kas nav nekas cits kā perceptrona izejas un vēlamās izejas starpības kvadrāts.

zaudējumi = tf.reduce_sum (tf.kvadrāts (izeja - y))

7. darbība: samaziniet kļūdu

Perceptrona mērķis ir samazināt zaudējumus vai izmaksas vai kļūdas. Tātad šeit mēs izmantosim gradienta nolaišanās optimizētāju.

optimizētājs = tf.train.GradientDescentOptimizer (0,01) vilciens = optimizētājs.minimizēt (zaudējumi)

8. solis: inicializējiet visus mainīgos

Mainīgos lielumus definē tikai ar tf. Mainīgs. Tātad mums ir jāinicializē definētie mainīgie.

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

9. solis: Perceptrona apmācība atkārtojumos

Mums ir jāapmāca perceptrons, t.i., jāatjaunina svaru un aizspriedumu vērtības secīgā atkārtojumā, lai samazinātu kļūdu vai zaudējumus. Šeit es apmācīšu mūsu perceptronu 100 laikmetos.

i diapazonā (100): sess.run (vilciens, {x: train_in, y: train_out}) izmaksas = sess.run (loss, feed_dict = {x: train_in, y: train_out}) drukāt ('Epoch-- ', i,' - zaudējumi - ', izmaksas)

10. solis: izeja

……

……

Kā redzat šeit, zaudējums sākās plkst 2.07 un beidzās plkst 0,27

.

Dziļa mācīšanās ar Python: dziļa neironu tīkla izveide

Tagad, kad esam veiksmīgi izveidojuši perceptronu un apmācījuši to OR vārtiem. Turpināsim šo rakstu un uzzināsim, kā no Scratch izveidot savu neironu tīklu, kurā mēs izveidosim ievades slāni, slēptos slāņus un izejas slāni.

Mēs izmantosim MNIST datu kopu. MNIST datu kopa sastāv no 60 000 apmācība paraugi un 10 000 testēšana ar roku rakstītu ciparu attēlu paraugi. Attēli ir lieluma 28 × 28 pikseļi un izeja var būt starp 0-9 .

Uzdevums šeit ir apmācīt modeli, kas var precīzi noteikt attēlā esošo ciparu

Pirmkārt, mēs izmantosim zemāk esošo importēšanu, lai drukas funkciju no Python 3 pārvestu uz Python 2.6+. __future__ paziņojumiem jābūt netālu no faila augšdaļas, jo tie maina valodas pamatprincipus, un kompilatoram par tiem jāzina jau no paša sākuma

from __future__ importēt print_function

Tālāk ir kods ar komentāriem katrā solī

# Importēt MNIST datus no tensorflow.examples.tutorials.mnist importēt ievades datus mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) importēt tensorflow kā tf importēt matplotlib.pyplot kā plt # Parametri learning_rate = 0.001 training_epoch batch_size = 100 display_step = 1 # Tīkla parametri n_hidden_1 = 256 # 1. slāņa funkciju skaits n_hidden_2 = 256 # 2. slāņa objektu skaits n_input = 784 # MNIST datu ievade (img forma: 28 * 28) n_classes = 10 # MNIST kopējās klases ( 0–9 cipari) # tf Grafika ievade x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Izveidot mod def deflayer_perceptron (x, svari , aizspriedumi): # Slēpts slānis ar RELU aktivizācijas slāni_1 = tf.add (tf.matmul (x, svars ['h1']), aizspriedumi ['b1']) slānis_1 = tf.nn.relu (slānis_1) # Slēpts slānis ar RELU aktivācijas slāni_2 = tf.add (tf.matmul (slānis_1, svari ['h2']), aizspriedumi ['b2']) layer_2 = tf.nn.relu (layer_2) # Izejas slānis ar lineāru aktivizāciju out_layer = tf. matmul (slānis _2, svari ['ārā']) + novirzes [ārā '] atgriežas_layer # Veikalu slāņu svars un slīpo svaru = {' 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]))} aizspriedumi = {'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]))}} # Konstruēt modeli pred = daudzslāņu_perceptron (x, svari, aizspriedumi) # Definējiet zaudējumus un optimizētāja izmaksas = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimizēt (izmaksas) # Inicializējot mainīgos init = tf.global_variables_initializer () # izveidojiet tukšu sarakstu izmaksu vēstures un precizitātes vēstures glabāšanai cost_history = [] precizitātes_vēsture = [] # Palaidiet diagrammu ar tf.Session () kā sess: sess.run (init ) # Apmācības cikls laikmetam diapazonā (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Pārliecinieties par visām diapazona i partijām (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Palaist optimizāciju op (backprop) un izmaksas op (lai iegūtu zaudējumu vērtību) _, c = sess.run ([optimizētājs, izmaksas], feed_dict = {x: batch_x, y: batch_y}) # Aprēķiniet vidējo zaudējumu vidējo_izmaksu + = c / total_batch # Parādiet žurnālus katrā laikposmā, ja laikmets% display_step == 0: pareizs_prognoze = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Aprēķināt precizitātes precizitāti = tf.reduce_mean (tf.cast (pareizs_prognoze, 'pludiņš') ) acu_temp = precizitāte.eval ({x: mnist.test.images, y: mnist.test.labels}) #pievienojiet precizitāti sarakstam precizitāte_vēsture.append (acu_temp) # pievienojiet izmaksu vēstures izmaksu_vēsture.append (vid ._izmaksa) druku ('Laikmets:', '% 04d'% (laikmets + 1), '- izmaksas =', '{: .9f}'. Formāts (vid ._maks.), '- Precizitāte =', acu_temp) izdruka ('Optimizācija pabeigta! ') # uzzīmējiet izmaksu vēsturi plt.plot (izmaksu_vēsture) plt.show () # uzzīmējiet precizitātes vēsturi plt.plot (precizitāte _vēsture) plt.show () # Pārbaudes modeļa pareizā prognoze = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Aprēķiniet precizitātes precizitāti = tf.reduce_mean (tf.cast (correct_prediction, ' pludiņš ')) print (' Precizitāte: ', precizitāte.eval ({x: mnist.test.images, y: mnist.test.labels}))

Izeja:

Ar šo mēs esam nonākuši pie šī Deep Learning with Python raksta beigām. Es ceru, ka jūs sapratāt dažādus dziļas mācīšanās komponentus, kā tas viss sākās un kā, izmantojot Python, mēs varam izveidot vienkāršu perceptronu un dziļu neironu tīklu.

leļļu šefpavāra sāls salīdzinājums

Edureka to kurē nozares profesionāļi atbilstoši nozares prasībām un prasībām. Jūs apgūsiet tādus jēdzienus kā SoftMax funkcija, Autoencoder neironu tīkli, Restricted Boltzmann Machine (RBM) un strādāsiet ar tādām bibliotēkām kā Keras & TFLearn. Kursu ir īpaši kurējuši nozares eksperti ar reāllaika gadījumu izpēti.

Vai mums ir jautājums? Lūdzu, pieminējiet to komentāru sadaļā “Deep Learning with Python”, un mēs ar jums sazināsimies.