Gilus mokymasis su „Python“: Gilus mokymasis pradedantiesiems

Šis straipsnis suteiks jums išsamias ir išsamias žinias apie gilų mokymąsi su „Python“ ir kaip tai naudinga kasdieniame gyvenime.

yra viena karščiausių 2018–1919 m. temų ir dėl rimtų priežasčių. Pramonėje buvo padaryta tiek pažangos, kai atėjo laikas, kai mašinos ar kompiuterinės programos iš tikrųjų keičia žmones. Tai Gilus mokymasis su „Python“ straipsnis padės suprasti, kas yra gilus mokymasis ir kaip šis perėjimas buvo įmanomas. Šiame straipsnyje aptarsiu šias temas:

Duomenų mokslas ir jo komponentai

Na, duomenų mokslas yra kažkas, kas buvo ten per amžius. Duomenų mokslas yra žinių gavimas iš duomenų, naudojant skirtingas technikas ir algoritmus.



AI laiko juosta - gilus mokymasis su „Python“ - „Edureka“

yra technika, leidžianti mašinoms imituoti žmogaus elgesį. Dirbtinio intelekto idėja yra gana paprasta, tačiau žavi, tai yra pagaminti intelektualias mašinas, kurios pačios galėtų priimti sprendimus. Ilgus metus buvo manoma, kad kompiuteriai niekada neprilygs žmogaus smegenų galiai.

Na, tada mes neturėjome pakankamai duomenų ir skaičiavimo galios, bet dabar su Dideli duomenys egzistuojant ir atsiradus GPU, dirbtinis intelektas yra įmanomas.

twitter nuotaikos analizė naudojant kibirkštį

yra dirbtinio intelekto technikos pogrupis, kuriame naudojami statistiniai metodai, leidžiantys mašinoms tobulėti patyrus.

Gilus mokymasis yra ML pogrupis, leidžiantis apskaičiuoti daugiasluoksnį neuroninį tinklą. Jis naudoja neuroninius tinklus, kad imituotų į žmones panašų sprendimų priėmimą.

Gilaus mokymosi poreikis

Žingsnis dirbtinio intelekto link yra mašininis mokymasis. Mašininis mokymasis yra dirbtinio intelekto pogrupis ir grindžiamas idėja, kad mašinoms turėtų būti suteikta prieiga prie duomenų ir palikta mokytis ir patiems patyrinėti. Jame nagrinėjami modelių išskyrimas iš didelių duomenų rinkinių. Didelių duomenų rinkinių tvarkymas nebuvo problema.

  • Mašinų mokymosi algoritmai negali apdoroti didelio matmens duomenų - kur turime daug įėjimų ir išėjimų: apvalūs tūkstančiai matmenų. Tokio tipo duomenų tvarkymas ir apdorojimas tampa labai sudėtingas ir išsamus. Tai vadinama Matmenų prakeiksmas.

  • Kitas iššūkis, su kuriuo susidūrė, buvo, norint nurodyti funkcijos, kurias reikia išgauti . Tai vaidina svarbų vaidmenį prognozuojant rezultatą, taip pat siekiant geresnio tikslumo. Todėl be funkcijų išskyrimo, didėja iššūkis programuotojui, nes algoritmo efektyvumas labai priklauso nuo to, koks įžvalgus yra programuotojas.

Čia gelbėjo gilus mokymasis. Gilus mokymasis yra galintis tvarkyti didelių matmenų duomenis taip pat yra efektyvus sutelkiant dėmesį į tinkamas funkcijas savaime.

Kas yra gilus mokymasis?

Gilus mokymasis yra mašininio mokymosi pogrupis, kuriame mokymui naudojami panašūs mašininio mokymosi algoritmai kad būtų pasiektas didesnis tikslumas tais atvejais, kai pirmasis neatliko žymės. Iš esmės, Gilus mokymasis imituoja mūsų smegenų funkciją y., jis mokosi iš patirties.

Kaip tu žinai,mūsų smegenys susideda iš milijardai neuronų tai leidžia mums padaryti nuostabius dalykus. Net mažo vaiko smegenys sugeba išspręsti sudėtingas problemas, kurias labai sunku išspręsti net naudojant superkompiuterius. Taigi, kaip mes galime pasiekti tą patį funkcionalumą programoje? Dabar mes tai suprantame Dirbtinis neuronas (Perceptron) ir Dirbtinis neuronų tinklas.

„Perceptron“ ir dirbtiniai neuroniniai tinklai

Gilus mokymasis tiria pagrindinį smegenų vienetą, vadinamą smegenų ląstele arba neuronu. Dabar supraskime biologinių neuronų funkcionalumą ir kaip mes imituojame šį funkcionalumą suvokime ar dirbtiniame neurone.

  • Dendritas: Gauna signalus iš kitų neuronų
  • Ląstelės kūnas: Susumuoja visus įvestis
  • Aksonas: Jis naudojamas signalams perduoti į kitas ląsteles

Dirbtinis neuronas arba a Perceptron yra tiesinis modelis, naudojamas dvejetainiai klasifikacijai. Jis modeliuoja neuroną, turintį įvesties rinkinį, kurio kiekvienam suteikiamas tam tikras svoris. Neuronas apskaičiuoja tam tikrą jų funkciją svertinis įvestis ir duoda išvestį.

Jis gauna n įvestį (atitinkančią kiekvieną funkciją). Tada jis susumuoja tuos įvestis, taiko transformaciją ir sukuria išvestį. Jis turi dvi funkcijas:

  • Apibendrinimas
  • Transformacija (aktyvinimas)

Svoris parodo konkretaus įvesties efektyvumą. Kuo didesnis įvesties svoris, tuo labiau tai paveiks nervų tinklą . Iš kitos pusės, Šališkumas yra papildomas parametras „Perceptron“, kuris naudojamas išvesties sureguliavimui kartu su svertine neurono įvesties suma, kuri padeda modeliui taip, kad jis geriausiai atitiktų pateiktus duomenis.

Aktyvinimo funkcijos įvestis paverčia išvestimis. Produkcijai gaminti naudojama riba. Yra daugybė funkcijų, kurios naudojamos kaip aktyvinimo funkcijos, pvz .:

  • Linijinis arba tapatumas
  • Vienetas arba dvejetainis žingsnis
  • „Sigmoid“ arba „Logistic“
  • Tanh
  • „ReLU“
  • „Softmax“

Na. jei manote, kad „Perceptron“ išsprendžia problemą, tada klystate. Buvo dvi pagrindinės problemos:

  • Vieno sluoksnio perceptronai negali klasifikuoti netiesiškai atskiriamų duomenų taškų .
  • Sudėtingos problemos, susijusios daugybė parametrų negali išspręsti vieno sluoksnio perceptronai.

Apsvarstykite čia pateiktą pavyzdį ir sudėtingumą, susijusį su parametrais, kad rinkodaros komanda priimtų sprendimą.

Vienas neuronas negali priimti tiek daug įvesties ir todėl šiai problemai išspręsti būtų naudojami daugiau nei vienas neuronas. Neuroninis tinklas iš tikrųjų yra tik Perceptronų kompozicija, sujungta skirtingais būdais ir veikia skirtingas aktyvavimo funkcijas.

  • Įvesties mazgai teikti informaciją iš išorinio pasaulio į tinklą ir kartu vadinamos „įvesties sluoksniu“.
  • Paslėpti mazgai atlikti skaičiavimus ir perkelti informaciją iš įvesties mazgų į išvesties mazgus. Paslėptų mazgų rinkinys sudaro „paslėptą sluoksnį“.
  • Išvesties mazgai yra bendrai vadinami „Output Layer“ ir yra atsakingi už skaičiavimus ir informacijos perdavimą iš tinklo į išorinį pasaulį.

Dabar, kai turite idėją, kaip elgiasi perceptronas, skirtingi parametrai ir skirtingi neuroninio tinklo sluoksniai, tęskime šį „Gilų mokymąsi su„ Python “tinklaraščiu“ ir pamatykime keletą puikių gilaus mokymosi programų.

Gilaus mokymosi programos

Pramonėje yra įvairių gilaus mokymosi pritaikymo būdų, pateikiame keletą svarbių dalykų, kuriuos atliekame vykdydami kasdienes užduotis.

  • Kalbos atpažinimas

  • Mašininis vertimas

  • Veido atpažinimas ir automatinis žymėjimas

  • Virtualūs asmeniniai padėjėjai

  • Savarankiškai vairuojantis automobilis

  • Pokalbių robotai

Kodėl „Python“ skirtas giliam mokymuisi?

  • yra vienas iš tokių įrankių, kurie turi unikalų atributą - būti a bendrosios paskirties programavimo kalba kaip būtis paprasta naudoti kai kalbama apie analitinį ir kiekybinį skaičiavimą.
  • Tai yra labai lengva suprasti
  • Python yra Dinamiškai įvestas
  • Didelis
  • Didelis asortimentas skirtingiems tikslams skirtų bibliotekų Numpy, Seaborn, Matplotlib, Pandas ir Scikit-learn

Pakanka teorijos. Pažiūrėkime, kaip mes galime pradėti gilų mokymąsi su „Python“ su mažu, bet įdomiu pavyzdžiu.

Gilus mokymasis naudojant „Python“: „Perceptron“ pavyzdys

Dabar esu įsitikinęs, kad jūs, vaikinai, turite būti susipažinę su „ ARBA “ vartai. Rezultatas yra vienas jei kuri nors iš įvesties taip pat yra vienas.

Todėl „Perceptron“ gali būti naudojamas kaip skyriklis arba sprendimo eilutė, padalijanti OR Gate įvesties rinkinį į dvi klases:

1 klasė: Įėjimai, kurių išėjimas yra 0 ir yra žemiau sprendimo linijos.
2 klasė: Įėjimai, kurių išėjimas yra 1 ir yra virš sprendimo linijos arba separatoriaus.

kaip padaryti dinaminį masyvą Java

Iki šiol supratome, kad linijinis perceptronas gali būti naudojamas klasifikuojant įvesties duomenų rinkinį į dvi klases. Bet kaip jis iš tikrųjų klasifikuoja duomenis?

Matematiškai perceptroną galima galvoti kaip apie svorių, įvesties ir šališkumo lygtį.

1 veiksmas: importuokite visą reikiamą biblioteką

Čia ketinu importuoti tik vieną biblioteką, t. „TensorFlow“

importuoti tensorflow kaip tf

2 žingsnis: Apibrėžkite įvesties ir išvesties vektorinius kintamuosius

Tada turime sukurti kintamuosius, skirtus saugoti „Perceptron“ įvestį, išvestį ir šališkumą.

traukinio_ = = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] traukinio išvykimo laikas = [[0], [1], [1], [1]]

3 žingsnis: Apibrėžkite kintamą svorį

Čia mes apibrėžsime savo svoriui 3 × 1 formos tenzoriaus kintamąjį ir iš pradžių priskirsime tam tikras atsitiktines reikšmes.

w = tf.Kintamasis (tf.normalus_normalus ([3, 1], sėkla = 15))

4 žingsnis: apibrėžkite įvesties ir išvesties vietos rezervavimo ženklus

Turime apibrėžti vietos rezervavimo ženklus, kad jie galėtų priimti išorinius įvestis.

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

5 žingsnis: Apskaičiuokite išvesties ir aktyvinimo funkciją

Kaip jau buvo aptarta anksčiau, perceptrono gaunama įvestis pirmiausia padauginama iš atitinkamų svorių ir tada visos šios svertinės įvestys sumuojamos kartu. Ši apibendrinta vertė paskui suaktyvinama siekiant galutinio rezultato.

išvestis = tf.nn.relu (tf.matmul (x, w))

Pastaba: Šiuo atveju aš naudojau relu kaip mano aktyvavimo funkcija. Galite laisvai naudoti bet kurią aktyvinimo funkciją pagal savo poreikius.

6 žingsnis: Apskaičiuokite kainą ar klaidą

Turime apskaičiuoti kainą = vidutinė kvadrato paklaida, kuri yra ne kas kita, o perceptrono ir norimos išvesties skirtumo kvadratas.

nuostolis = tf.reduce_sum (tf.kvadratas (išvestis - y))

7 veiksmas: sumažinkite klaidą

Perceptrono tikslas yra sumažinti nuostolį, kainą ar klaidą. Taigi čia mes naudosime „Gradient Descent Optimizer“.

optimizatorius = tf.train.GradientDescentOptimizer (0,01) traukinys = optimizatorius.minimizuoti (nuostoliai)

8 žingsnis: Inicializuokite visus kintamuosius

Kintamieji apibrėžiami tik su tf.Kintamas. Taigi, turime inicijuoti apibrėžtus kintamuosius.

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

9 žingsnis: Perceptrono treniravimas kartojimuose

Turime mokyti savo suvokimą, t. Y. Atnaujinti svorio ir šališkumo vertes iš eilės kartojant, kad sumažintume klaidą ar nuostolius. Čia aš mokysiu mūsų perceptroną 100 epochų.

i diapazone (100): sess.run (traukinys, {x: train_in, y: train_out}) kaina = sess.run (nuostolis, feed_dict = {x: train_in, y: train_out}) spausdinti ('Epoch-- ', i,' - nuostolis - ', kaina)

10 žingsnis: išvestis

……

……

Kaip matote čia, nuostoliai prasidėjo 2.07 ir baigėsi 0,27

.

Gilus mokymasis naudojant „Python“: gilaus neuroninio tinklo sukūrimas

Dabar, kai sėkmingai sukūrėme perceptroną ir išmokėme jį naudoti ARBA vartams. Tęskime šį straipsnį ir pažiūrėkime, kaip iš „Scratch“ sukurti savo neuroninį tinklą, kuriame sukursime įvesties, paslėptus ir išvesties sluoksnius.

Mes ketiname naudoti MNIST duomenų rinkinį. MNIST duomenų rinkinį sudaro 60 000 mokymų mėginiai ir 10 000 bandymų ranka rašytų skaitmeninių vaizdų pavyzdžiai. Vaizdai yra dydžio 28 × 28 taškų o išvestis gali būti tarp 0–9 .

Čia užduotis yra parengti modelį, kuris galėtų tiksliai identifikuoti paveikslėlyje esantį skaitmenį

Pirma, mes naudosime toliau pateiktą importavimą, kad spausdinimo funkciją iš „Python 3“ perkeltume į „Python 2.6+“. __future__ sakiniai turi būti šalia failo viršaus, nes jie keičia pagrindinius kalbos dalykus, todėl kompiliatorius turi žinoti apie juos nuo pat pradžių

iš __ ateities__ importuoti spausdinimo funkciją

Toliau pateikiamas kodas su komentarais kiekviename žingsnyje

# Importuoti MNIST duomenis iš tensorflow.examples.tutorials.mnist importuoti input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) importuoti tensorflow kaip tf importuoti matplotlib.pyplot kaip plt # Parametrai learning_rate = 0.001 training_epoch batch_size = 100 display_step = 1 # Tinklo parametrai n_hidden_1 = 256 # Pirmojo sluoksnio funkcijų skaičius n_hidden_2 = 256 # 2-ojo sluoksnio funkcijų skaičius n_input = 784 # MNIST duomenų įvestis (img forma: 28 * 28) n_classes = 10 # MNIST iš viso klasių ( 0–9 skaitmenys) # tf Grafiko įvestis x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Sukurti modelį def multilayer_perceptron (x, svoriai : # paslėptas sluoksnis su RELU aktyvavimo sluoksniu_1 = tf.add (tf.matmul (x, svoriai ['h1']), šališkumai ['b1']) sluoksnis_1 = tf.nn.relu (layer_1) su RELU aktyvinimo sluoksniu_2 = tf.add (tf.matmul (sluoksnis_1, svoriai ['h2']), šališkumai ['b2']) sluoksnis_2 = tf.nn.relu (sluoksnis_2) # Išvesties sluoksnis su tiesiniu aktyvinimu out_layer = tf. matmul (sluoksnis _2, svoriai ['out']) + šališkumai ['out'] grąžina out_layer # Laikykite sluoksnių svorį ir šališkumo svorius = {'h1': tf.Kintamasis (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]))} šališkumas = {'b1': tf.Kintamas (tf. random_normal ([n_hidden_1])), 'b2': tf.Kintamasis (tf.random_normal ([n_hidden_2_2])), 'out': tf.Variable (tf.random_normal ([n_classes]))}} # Konstruoti modelį pred = daugiasluoksnis_perceptron (x, svoriai, šališkumai) # Apibrėžkite nuostolius ir optimizavimo priemonės sąnaudas = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (cost) # Kintamųjų inicijavimas init = tf.global_variables_initializer () # sukurkite tuščią sąrašą, kad išsaugotumėte sąnaudų istoriją ir tikslumo istoriją cost_history = [] tikslumo_istorija = [] # Paleiskite diagramą su tf.Session () kaip sess: sess.run (init ) # Treniruočių ciklas pagal epochą diapazone (mokymo_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Peržiūrėkite visas diapazono i partijas (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Paleiskite optimizavimą op (backprop) ir kaina op (norint gauti nuostolių vertę) _, c = sess.run ([optimizatorius, kaina], feed_dict = {x: batch_x, y: batch_y}) # Apskaičiuokite vidutinį nuostolių vidurkį_cost + = c / total_batch # Rodyti žurnalus pagal epochos žingsnį epocha% display_step == 0: teisinga_predikcija = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Apskaičiuokite tikslumo tikslumą = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = tikslumas.eval ({x: mnist.test.images, y: mnist.test.labels}) #pridėkite tikslumą prie sąrašo tikslumo_historija.apieškoti (akies_temp) #apieškokite išlaidų istorijos sąnaudų istorijos.apdraudimo (vid. ('Epocha:', '% 04d'% (epocha + 1), '- cost =', '{: .9f}'. Formatas (avg_cost), '- Accuracy =', acu_temp) spausdinimas ('Optimizavimas baigtas! ') #plot išlaidų istoriją plt.plot (cost_history) plt.show () #plot tikslumo istoriją plt.plot (tikslumas _istorija) plt.show () # Testo modelis teisingas_prognozė = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Apskaičiuokite tikslumo tikslumą = tf.reduce_mean (tf.cast (correct_prediction, ' plūdė ')) print (' Tikslumas: ', tikslumas.val ({x: mnist.test.images, y: mnist.test.labels}))

Išvestis:

praeiti pagal vertę ir pereiti su nuoroda java

Dabar mes baigiame šį „Gilaus mokymosi su Python“ straipsnį. Tikiuosi, kad supratote įvairius gilaus mokymosi komponentus, kaip viskas prasidėjo ir kaip naudojant „Python“ galime sukurti paprastą perceptroną ir gilų neuronų tinklą.

„Edureka“ kuruoja pramonės specialistai pagal pramonės reikalavimus ir reikalavimus. Išmoksite tokias sąvokas kaip „SoftMax“ funkcija, „Autoencoder“ neuroniniai tinklai, „Restricted Boltzmann Machine“ (RBM) ir dirbsite su tokiomis bibliotekomis kaip „Keras & TFLearn“. Kursą specialiai kuravo pramonės ekspertai, atlikdami realaus laiko atvejų analizę.

Turite mums klausimą? Prašau paminėti tai komentarų skyriuje „Gilus mokymasis su Python“ ir mes su jumis susisieksime.