Malalim na Pag-aaral gamit ang Python: Mga Gabay sa Mga Nagsisimula sa Malalim na Pag-aaral

Magbibigay sa iyo ang artikulong ito ng isang komprehensibo at detalyadong kaalaman tungkol sa Deep Learning na may Python at kung gaano ito kapaki-pakinabang sa pang-araw-araw na buhay.

ay isa sa Pinakamainit na paksa ng 2018-19 at para sa isang magandang dahilan. Maraming mga pagsulong sa industriya kung saan dumating ang oras na ang mga machine o Computer Programs ay talagang pinapalitan ang Tao. Ito Malalim na Pag-aaral kasama ng Python tutulong sa iyo ang artikulo na maunawaan kung ano ang eksaktong Malalim na Pag-aaral at Paano Ginawang posible ang paglipat na ito. Sasaklawin ko ang mga sumusunod na paksa sa artikulong ito:

Data Science at Mga Bahagi Ito

Sa gayon, ang Data Science ay isang bagay na naroroon nang maraming panahon. Data science ay ang pagkuha ng kaalaman mula sa data sa pamamagitan ng paggamit ng iba't ibang mga diskarte at algorithm.





Timeline ng AI - Malalim na Pag-aaral kasama ang Python - Edureka

ay isang pamamaraan na nagbibigay-daan sa mga makina na gayahin ang pag-uugali ng tao. Ang ideya sa likod ng AI ay medyo simple ngunit kamangha-manghang, na kung saan ay upang gumawa ng mga intelihente machine na maaaring magpasyang mag-isa. Sa loob ng maraming taon, naisip na ang mga computer ay hindi kailanman magtutugma sa lakas ng utak ng tao.



c ++ label ng goto

Sa gayon, noon ay wala kaming sapat na data at kapangyarihan sa pagkalkula, ngunit mayroon na ngayon Malaking Data sa pagkakaroon at sa pagkakaroon ng mga GPU, posible ang Artipisyal na Intelihensiya.

ay isang subset ng diskarteng AI na gumagamit ng mga pamamaraang pang-istatistiko upang paganahin ang mga makina na may karanasan.



Malalim na pag aaral ay isang subset ng ML na ginagawang posible ang pagkalkula ng multi-layer neural network. Gumagamit ito ng mga Neural network upang gayahin ang paggawa ng desisyon na tulad ng tao.

Ang pangangailangan para sa Deep Learning

Isang Hakbang patungo sa Artipisyal na Katalinuhan ay Pag-aaral ng Machine. Ang Machine Learning ay isang subset ng AI at batay sa ideya na ang mga machine ay dapat bigyan ng pag-access sa data, at dapat iwanang upang malaman at tuklasin para sa kanilang sarili. Nakikipag-usap ito sa pagkuha ng mga pattern mula sa malalaking mga hanay ng data. Ang paghawak ng malalaking mga hanay ng data ay hindi isang problema.

  • Mga Algorithm sa Pagkatuto ng Makina hindi maaaring hawakan ang Data na Mataas ang Dimensyon - kung saan mayroon kaming isang malaking bilang ng mga input at output: pag-ikot ng libu-libong mga sukat. Ang paghawak at pagproseso ng naturang uri ng data ay naging napaka-kumplikado at lubusang mapagkukunan. Ito ay tinatawag na bilang Sumpa ng dimensionalidad.

  • Ang isa pang Hinaharap na Hamon ay, upang tukuyin ang mga tampok na nakuha . Ginampanan nito ang isang mahalagang papel sa paghula ng kinalabasan pati na rin sa pagkamit ng mas mahusay na kawastuhan. Samakatuwid, nang walang tampok na pagkuha, ang hamon para sa programmer ay nagdaragdag habang ang pagiging epektibo ng algorithm ay higit na nakasalalay sa kung gaano nakakaintindi ang programmer.

Ngayon, dito na nagligtas ang Deep Learning. Malalim na pag-aaral ay may kakayahang hawakan ang data ng mataas na dimensional at mahusay din sa nakatuon sa tamang mga tampok sa sarili nitong

Ano ang Deep Learning?

Ang Deep Learning ay isang subset ng Pag-aaral ng Machine kung saan ginagamit ang mga katulad na Machine Algorithm ng Pagkatuto upang sanayin upang makamit ang mas mahusay na kawastuhan sa mga kasong iyon kung saan ang dating ay hindi gumaganap hanggang sa marka. Talaga, Ginagaya ng malalim na pag-aaral ang paraan ng paggana ng ating utak ibig sabihin natututo ito mula sa karanasan.

Sa iyong pagkakaalam,binubuo ang ating utak bilyun-bilyong mga neuron na nagpapahintulot sa amin na gumawa ng mga kamangha-manghang bagay. Kahit na ang utak ng isang maliit na bata ay may kakayahang malutas ang mga kumplikadong problema na napakahirap malutas kahit na gumagamit ng Super-Computer. Kaya, Paano natin makakamit ang parehong pag-andar sa isang programa? Ngayon, dito natin naiintindihan Artipisyal na Neuron (Perceptron) at Artipisyal na neural network.

Perceptron at Mga Artipisyal na Neural Networks

Pinag-aaralan ng Deep Learning ang pangunahing yunit ng isang utak na tinatawag na utak cell o isang neuron. Ngayon, ipaalam sa amin na maunawaan ang pag-andar ng biological neurons at kung paano namin ginaya ang pagpapaandar na ito sa pang-unawa o isang artipisyal na neuron.

  • Dendrite: Nakatanggap ng mga signal mula sa iba pang mga neuron
  • Cell Body: Binuo ang lahat ng mga input
  • Axon: Ginagamit ito upang magpadala ng mga signal sa iba pang mga cell

Isang Artipisyal na Neuron o a Perceptron ay isang linear na modelo na ginamit para sa pag-uuri ng binary. Nagmomodelo ito ng isang neuron na mayroong isang hanay ng mga input, na ang bawat isa ay binibigyan ng isang tiyak na timbang. Kinakalkula ng neuron ang ilang pagpapaandar sa mga ito tinimbang mga input at nagbibigay ng output.

Nakatanggap ito ng mga n input (naaayon sa bawat tampok). Pagkatapos ay binubuo nito ang mga input, naglalapat ng isang pagbabago at gumagawa ng isang output. Mayroon itong dalawang pag-andar:

  • Paglalagom
  • Pagbabago (Pag-activate)

Ipinapakita ng timbang ang pagiging epektibo ng isang partikular na input. Mas maraming bigat ng pag-input, higit na magkakaroon ito ng epekto sa neural network . Sa kabilang kamay, Bias ay isang karagdagang parameter sa Perceptron na ginagamit upang ayusin ang output kasama ang timbang na kabuuan ng mga input sa neuron na tumutulong sa modelo sa isang paraang mas magkasya ito para sa ibinigay na data.

Mga Pag-andar ng Pag-activate isinasalin ang mga input sa mga output. Gumagamit ito ng isang threshold upang makabuo ng isang output. Maraming mga pagpapaandar na ginagamit bilang Mga Pag-andar ng Pag-aktibo, tulad ng:

  • Linear o Pagkakakilanlan
  • Yunit o Binary Hakbang
  • Sigmoid o Logistic
  • Tanh
  • ReLU
  • Softmax

Well kung sa palagay mo malulutas ng Perceptron ang problema, mali ka. Mayroong dalawang pangunahing mga problema:

  • Single-Layer Perceptrons hindi mai-uri-uri ang mga hindi linear na mapaghihiwalay na mga puntos ng data .
  • Mga kumplikadong problema, kasangkot doon maraming mga parameter hindi malulutas ng Single-Layer Perceptrons.

Isaalang-alang ang halimbawa dito at ang pagiging kumplikado sa mga parameter na kasangkot upang kumuha ng isang Desisyon ng pangkat ng marketing.

Ang isang Neuron, ay hindi makakatanggap ng maraming mga input at iyon ang dahilan kung bakit higit sa isang neuron ang gagamitin upang malutas ang problemang ito. Ang Neural Network ay talagang isang komposisyon ng Perceptrons, na konektado sa iba't ibang paraan at pagpapatakbo sa iba't ibang mga pagpapaandar ng pag-aktibo.

  • Mga Input Node magbigay ng impormasyon mula sa labas ng mundo sa network at magkakasamang tinukoy bilang 'Input Layer'.
  • Mga Nakatagong Node magsagawa ng mga pagkalkula at maglipat ng impormasyon mula sa mga input node patungo sa mga output node. Ang isang koleksyon ng mga nakatagong node ay bumubuo ng isang 'Nakatagong Layer'.
  • Mga output node ay sama-sama na tinukoy bilang 'Output Layer' at responsable para sa pagkalkula at paglilipat ng impormasyon mula sa network patungo sa labas ng mundo.

Ngayon mayroon kang ideya kung paano kumilos ang isang perceptron, ang iba't ibang mga kasangkot na parameter at ang iba't ibang mga layer ng isang Neural Network, Ipagpatuloy natin ang Deep Learning na ito sa Python Blog at makita ang ilang mga cool na application ng Deep Learning.

Mga Aplikasyon ng Malalim na Pag-aaral

Mayroong iba't ibang mga aplikasyon ng Deep Learning sa Industriya, narito ang ilan sa mga mahahalagang naroroon sa aming mga gawain sa Araw-araw.

  • Pagkilala sa pagsasalita

  • Pagsasalin ng Makina

  • Pagkilala sa Mukha at Awtomatikong Pag-tag

  • Mga Virtual na Personal na Katulong

  • Sariling Kotse sa Pagmamaneho

  • Mga chatbot

Bakit Python para sa Malalim na Pag-aaral?

  • ay isang kagamitang kasangkapan na mayroong natatanging katangian, ng pagiging a wikang pangkalahatang layunin sa pagprograma bilang pagiging madaling gamitin pagdating sa analytical at dami ng computing.
  • Ito ay napaka madaling intindihin
  • Ang sawa ay Dynamic na Na-type
  • Napakalaki
  • Ang isang malawak na hanay ng Mga Aklatan para sa iba't ibang mga layunin tulad ng Numpy, Seaborn, Matplotlib, Pandas, at Scikit-matuto

Sapat na ngayon sa teorya, Tingnan natin kung paano natin masisimulan ang Deep Learning gamit ang Python na may isang maliit ngunit kapanapanabik na halimbawa.

Malalim na Pag-aaral Sa Python: Halimbawa ng Perceptron

Ngayon sigurado akong dapat pamilyar kayo sa pagtatrabaho ng ' O ” gate. Ang output ay isa kung alinman sa mga input din isa

Samakatuwid, ang isang Perceptron ay maaaring magamit bilang isang separator o isang linya ng desisyon na hinahati ang input set ng OR Gate, sa dalawang klase:

kung paano lumabas ng isang programa sa java

Class 1: Ang mga input na mayroong output bilang 0 na nasa ilalim ng linya ng desisyon.
Klase 2: Ang mga input na mayroong output bilang 1 na nasa itaas ng linya ng desisyon o separator.

Hanggang ngayon, naintindihan namin na ang isang linear perceptron ay maaaring magamit upang maiuri ang naka-set na data ng input sa dalawang klase. Ngunit, paano nito talagang naiuuri ang data?

Sa matematika ang isang perceptron ay maaaring maiisip tulad ng isang equation ng Timbang, Mga Input, at Bias.

Hakbang 1: I-import ang lahat ng kinakailangang library

Dito ko lang mai-i-import ang isang silid-aklatan, ibig sabihin. TensorFlow

i-import ang tensorflow bilang tf

Hakbang 2: Tukuyin ang Mga Variable ng Vector para sa Input at Output

Susunod, kailangan naming lumikha ng mga variable para sa pag-iimbak ng input, output, at bias para sa Perceptron.

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

Hakbang 3: Tukuyin ang Variable ng Timbang

Dito bibigyan namin ng kahulugan ang variable na variable ng hugis 3 × 1 para sa aming mga timbang at magtalaga ng ilang mga random na halaga dito nang una.

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

Hakbang 4: Tukuyin ang mga placeholder para sa Input at Output

Kailangan naming tukuyin ang mga placeholder upang makatanggap sila ng mga panlabas na input sa pagtakbo.

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

Hakbang 5: Kalkulahin ang Output at Pag-andar ng Pag-aktibo

Tulad ng tinalakay nang mas maaga, ang input na natanggap ng isang perceptron ay unang pinarami ng kani-kanilang mga timbang at pagkatapos, lahat ng mga may timbang na input ay pinagsama-sama. Ang summed na halaga na ito ay pagkatapos ay fed sa activation para sa pagkuha ng panghuling resulta.

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

Tandaan: Sa kasong ito, ginamit ko na relu bilang aking pagpapaandar na pagpapaandar. Malaya kang gumamit ng anuman sa mga pagpapaandar ng pag-aktibo alinsunod sa iyong pangangailangan.

Hakbang 6: Kalkulahin ang Gastos o Error

Kailangan nating kalkulahin ang Gastos = Ibig sabihin ng Squared Error na walang anuman kundi ang parisukat ng pagkakaiba ng output ng perceptron at nais na output.

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

Hakbang 7: I-minimize ang Error

Ang layunin ng isang perceptron ay upang i-minimize ang Pagkawala o Gastos o Error. Kaya narito gagamitin namin ang Gradient Descent Optimizer.

optimizer = tf.train.GradientDescentOptimizer (0.01) tren = optimizer.minimize (pagkawala)

Hakbang 8: Pasimulan ang lahat ng mga variable

Ang mga variable ay tinukoy lamang sa tf.Variable. Kaya, kailangan nating simulan ang mga tinukoy na variable.

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

Hakbang 9: Pagsasanay sa Perceptron sa Iterations

Kailangan naming sanayin ang aming perceptron ibig sabihin, i-update ang mga halaga ng timbang at bias sa sunud-sunod na pag-ulit upang mabawasan ang error o pagkawala. Dito, sanayin ko ang aming perceptron sa 100 mga kapanahunan.

para ako sa saklaw (100): sess.run (tren, {x: train_in, y: train_out}) gastos = sess.run (pagkawala, feed_dict = {x: train_in, y: train_out}) print ('Epoch-- ', i,' - pagkawala - ', gastos)

Hakbang 10: Output

……

……

Tulad ng nakikita mo rito, ang pagkawala ay nagsimula sa 2.07 at natapos sa 0.27

.

Deep Learning With Python: Lumilikha ng isang Deep Neural Network

Ngayon na matagumpay na nakalikha kami ng isang perceptron at sinanay ito para sa isang OR gate. Ipagpatuloy natin ang artikulong ito at tingnan kung paano makalikha ng aming sariling Neural Network mula sa Scratch, kung saan lilikha kami ng isang Input Layer, Mga Nakatagong Layer at Output Layer.

Gagamitin namin ang hanay ng data ng MNIST. Ang set ng data ng MNIST ay binubuo ng 60,000 pagsasanay mga sample at 10,000 pagsubok mga sample ng sulat-kamay na mga imahe ng digit. Ang laki ng mga imahe 28 × 28 mga pixel at ang output ay maaaring namamalagi sa pagitan 0-9 .

Ang gawain dito ay upang sanayin ang isang modelo na maaaring tumpak na makilala ang kasalukuyang digit sa imahe

Una, gagamitin namin ang pag-import sa ibaba upang dalhin ang pagpapa-print mula sa Python 3 papunta sa Python 2.6+. Ang mga pahayag na __future__ ay kailangang malapit sa tuktok ng file dahil binago nila ang mga pangunahing bagay tungkol sa wika, at sa gayon kailangang malaman ng tagatala ang tungkol sa kanila mula sa simula

mula sa __future__ import print_unction

Ang sumusunod ay ang code na may mga komento sa bawat hakbang

# Mag-import ng data ng MNIST mula sa tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) i-import ang tensorflow bilang tf import matplotlib.pyplot bilang plt # Parameter learning_rate = 0.001 training_epochs = 15 batch_size = 100 display_step = 1 # Parameter ng Network n_hidden_1 = 256 # Ika-1 na layer na bilang ng mga tampok n_hidden_2 = 256 # Pangalawang numero ng layer ng mga tampok n_input = 784 # MNIST input ng data (img na hugis: 28 * 28) n_class = 10 # MNIST kabuuang mga klase ( 0-9 na mga digit) # tf Grow input x = tf.placeholder ('float', [Wala, n_input]) y = tf.placeholder ('float', [Wala, n_class]) # Lumikha ng modelo ng def multilayer_perceptron (x, mga timbang , bias): # Nakatagong layer na may layer ng pag-aktibo ng RELU_1 = tf.add (tf.matmul (x, weights ['h1']), bias ['b1']) layer_1 = tf.nn.relu (layer_1) # Nakatagong layer na may layer ng pagsasaaktibo ng RELU_2 = tf.add (tf.matmul (layer_1, mga timbang ['h2']), bias ['b2']) layer_2 = tf.nn.relu (layer_2) # Output layer na may linear activation out_layer = tf. matmul (layer _2, weights ['out']) + bias ['out'] return out_layer # Mga layer ng timbang at timbang ng bias = {'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])}} bias = {'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_class]))} # Bumuo ng modelo ng pred = multilayer_perceptron (x, weights, bias) # Tukuyin ang gastos ng pagkawala at pag-optimize = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (mga log = pred, label = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (gastos) # Pinasimulan ang mga variable init = tf.global_variables_initializer () #gumawa ng isang walang laman na listahan upang maiimbak ang kasaysayan ng gastos at katumpakan na kasaysayan cost_history = [] kawastuhan_history = [] # Ilunsad ang grap na may tf.Session () bilang sess: sess.run (init ) # Siklo ng pagsasanay para sa epoch sa saklaw (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Loop over all batch for i in range (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Run optimization op (backprop) and cost op (upang makakuha ng halaga ng pagkawala) _, c = sess.run ([optimizer, gastos], feed_dict = {x: batch_x, y: batch_y}) # Compute average loss avg_cost + = c / total_batch # Display log per epoch step if epoch% display_step == 0: tamang_prediksiyon = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Kalkulahin ang katumpakan ng katotohan = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = correction.eval ({x: mnist.test.images, y: mnist.test.labels}) #adugtong ang kawastuhan sa listahan ng katumpakan_history.append (acu_temp) # ilakip ang kasaysayan ng gastos na cost_history.append (avg_cost) na naka-print ('Epoch:', '% 04d'% (epoch + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Tapos na ang Pag-optimize! ') #plot ang kasaysayan ng gastos plt.plot (cost_history) plt.show () #plot ang kasaysayan ng katumpakan plt.plot (kawastuhan _history) plt.show () # modelong Pagsubok tama_prediksiyon = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Kalkulahin ang katumpakan ng katumpakan = tf.reduce_mean (tf.cast (tamang_prediksiyon, ' float ')) print (' Ganap na Kawastuhan: ', correction.eval ({x: mnist.test.images, y: mnist.test.labels})

Output:

Ngayon kasama nito, natapos na namin ang artikulong ito ng Deep Learning with Python. Inaasahan kong nakakuha ka ng pag-unawa sa iba't ibang mga bahagi ng Deep Learning, Paano nagsimula ang lahat at Paano ang paggamit ng Python maaari kaming lumikha ng isang simpleng perceptron at isang Deep Neural Network.

Edureka’s ay na-curate ng mga propesyonal sa industriya ayon sa mga kinakailangan at hinihingi sa industriya. Mapagtutuunan mo ang mga konsepto tulad ng pag-andar ng SoftMax, Autoencoder Neural Networks, Pinaghihigpitang Boltzmann Machine (RBM) at gagana sa mga aklatan tulad ng Keras & TFLearn. Ang kurso ay espesyal na na-curate ng mga eksperto sa industriya na may real-time na mga pag-aaral ng kaso.

May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng 'Deep Learning with Python' at babalikan ka namin.