je jednou z najhorúcejších tém 2018-2019 a má na to dobrý dôvod. V priemysle nastalo toľko pokrokov, že nastal čas, keď stroje alebo počítačové programy skutočne nahradia človeka. Toto Hlboké učenie s Pythonom tento článok vám pomôže pochopiť, čo presne je Deep Learning a ako bol tento prechod umožnený. V tomto článku sa budem venovať nasledujúcim témam:
- Data Science and It’s Components
- Potreba hlbokého učenia
- Čo je to Deep Learning?
- Perceptron a umelé neurónové siete
- Aplikácie hlbokého učenia
- Prečo Python pre Deep Learning?
- Hlboké učenie s Pythonom: Príklad Perceptronu
- Deep Learning with Python: Creating a Deep Neural Network
Data Science and It’s Components
Data Science je niečo, čo tam je už celé veky. Dátová veda je získavanie poznatkov z údajov pomocou rôznych techník a algoritmov.
je technika, ktorá umožňuje strojom napodobňovať ľudské správanie. Myšlienka umelej inteligencie je pomerne jednoduchá, ale fascinujúca, a to robiť inteligentné stroje, ktoré môžu prijímať rozhodnutia samy. Po celé roky sa myslelo, že počítače sa nikdy nevyrovnajú sile ľudského mozgu.
Vtedy sme nemali dostatok údajov a výpočtového výkonu, ale teraz sme to mali Veľké dáta vznikom a s príchodom GPU je možná umelá inteligencia.
je podmnožinou techniky AI, ktorá využíva štatistické metódy, aby umožnila strojom zlepšovať sa so skúsenosťami.
Hlboké učenie je podmnožina ML, ktorá umožňuje uskutočňovanie výpočtu viacvrstvovej neurónovej siete. Využíva neurónové siete na simuláciu rozhodovania podobného človeku.
Potreba hlbokého učenia
Krokom k umelej inteligencii je strojové učenie. Strojové učenie je podmnožinou umelej inteligencie a je založené na myšlienke, že strojom by sa mal poskytnúť prístup k údajom a mali by sa nechať učiť a skúmať sami. Zaoberá sa extrakciou vzorov z veľkých súborov údajov. Zaobchádzanie s veľkými súbormi údajov nebol problém.
- Algoritmy strojového učenia nedokáže spracovať vysokodimenzionálne údaje - kde máme veľké množstvo vstupov a výstupov: okrúhle tisíce dimenzií. Spracovanie a spracovanie tohto typu údajov sa stáva veľmi zložitým a vyčerpávajúcim zdrojom. Toto sa nazýva ako Prekliatie dimenzionality.
- Ďalšou výzvou, ktorej čelili, bolo, spresniť funkcie, ktoré sa majú extrahovať . To hrá dôležitú úlohu pri predpovedaní výsledku, ako aj pri dosahovaní vyššej presnosti. Preto bez extrakcie funkcií výzva pre programátora rastie, pretože účinnosť algoritmu veľmi závisí od toho, aký je programátor bystrý.
Teraz sa tu dostalo na pomoc Deep Learning. Hlboké učenie je schopné spracovávať vysokodimenzionálne údaje a je tiež efektívny v so zameraním na správne funkcie na vlastnú päsť.
Čo je to Deep Learning?
Hlboké učenie je podmnožinou strojového učenia, kde sa podobné algoritmy strojového učenia používajú na školenie s cieľom dosiahnuť lepšiu presnosť v tých prípadoch, keď prvý nevykonával až po značku. V podstate Hlboké učenie napodobňuje spôsob fungovania nášho mozgu to znamená, že sa učí zo skúseností.
Ako vieš,náš mozog je tvorený miliardy neurónov to nám umožňuje robiť úžasné veci. Aj mozog malého dieťaťa je schopný vyriešiť zložité problémy, ktoré je veľmi ťažké vyriešiť aj pomocou superpočítačov. Ako teda môžeme v programe dosiahnuť rovnakú funkcionalitu? Teraz to chápeme Umelý neurón (Perceptron) a Umelá neurónová sieť.
Perceptron a umelé neurónové siete
Hlboké učenie študuje základnú jednotku mozgu nazývanú mozgová bunka alebo neurón. Poďme teda pochopiť funkčnosť biologických neurónov a to, ako napodobňujeme túto funkčnosť vo vnímaní alebo ako umelý neurón.
- Dendrit: Prijíma signály z iných neurónov
- Telo bunky: Sčíta všetky vstupy
- Axon: Používa sa na prenos signálov do ostatných buniek
Umelý neurón alebo a Perceptron je lineárny model používaný pre binárnu klasifikáciu. Modeluje neurón, ktorý má súbor vstupov, z ktorých každý má špecifickú váhu. Neurón na nich počíta určitú funkciu vážený vstupy a dáva výstup.
aký je rozdiel medzi triedou a rozhraním
Prijíma n vstupov (zodpovedajúcich každej funkcii). Potom tieto vstupy sčíta, použije transformáciu a vytvorí výstup. Má dve funkcie:
- Zhrnutie
- Transformácia (aktivácia)
Váha ukazuje účinnosť konkrétneho vstupu. Čím väčšia je váha vstupu, tým viac to bude mať vplyv na neurónovú sieť . Na druhej strane, Zaujatosť je ďalší parameter v Perceptrone, ktorý sa používa na úpravu výstupu spolu s váženým súčtom vstupov do neurónu, čo pomáha modelu tak, aby najlepšie vyhovoval daným údajom.
Aktivačné funkcie prekladá vstupy do výstupov. Na výrobu výstupu používa prahovú hodnotu. Existuje veľa funkcií, ktoré sa používajú ako aktivačné funkcie, ako napríklad:
- Lineárne alebo identita
- Jednotkový alebo binárny krok
- Sigmoid alebo Logistic
- Tanh
- ReLU
- Softmax
Nuž. ak si myslíte, že Perceptron problém rieši, tak sa mýlite. Vyskytli sa dva hlavné problémy:
- Jednovrstvové perceptróny nemôže klasifikovať nelineárne oddeliteľné údajové body .
- Zložité problémy, ktoré zahŕňajú veľa parametrov sa nedajú vyriešiť pomocou jednovrstvových perceptrónov.
Zvážte príklad na tomto mieste a zložitosť s parametrami, ktoré sú potrebné na prijatie rozhodnutia marketingového tímu.
Jeden neurón nemôže prijať toľko vstupov, a preto by sa na riešenie tohto problému použilo viac ako jeden neurón. Neurónová sieť je v skutočnosti len a zloženie perceptrónov, spojené rôznymi spôsobmi a pracujú na rôznych aktivačných funkciách.
- Vstupné uzly poskytujú sieti informácie z vonkajšieho sveta a sú spoločne označované ako „vstupná vrstva“.
- Skryté uzly vykonávať výpočty a prenášať informácie zo vstupných uzlov do výstupných uzlov. Zbierka skrytých uzlov vytvára „Skrytú vrstvu“.
- Výstupné uzly súhrnne označované ako „Výstupná vrstva“ a sú zodpovedné za výpočty a prenos informácií zo siete do vonkajšieho sveta.
Teraz, keď máte predstavu o tom, ako sa chová perceptron, rôzne použité parametre a rôzne vrstvy neurónovej siete, poďme pokračovať v tomto Deep Learning s blogom Python a pozrite si niekoľko skvelých aplikácií Deep Learning.
Aplikácie hlbokého učenia
V priemysle existujú rôzne aplikácie Deep Learning, tu je niekoľko dôležitých aplikácií, ktoré sú obsiahnuté v našich každodenných úlohách.
- Rozpoznávanie reči
- Strojový preklad
- Rozpoznávanie tváre a automatické označovanie
- Virtuálni osobní asistenti
- Samoriadiace auto
- Chatboti
Prečo Python pre Deep Learning?
- je jeden taký nástroj, ktorý má jedinečný atribút, byť univerzálny programovací jazyk ako bytie jednoduché použitie pokiaľ ide o analytické a kvantitatívne výpočty.
- Je to veľmi ľahko pochopiteľné
- Python je Dynamicky písané
- Obrovský
- Široká škála knižníc na rôzne účely, ako je Numpy, Seaborn, Matplotlib, Pandas a Scikit-learn
Teraz je už dosť teórie. Pozrime sa, ako môžeme začať s Deep Python pomocou Deep, ale malého vzrušujúceho príkladu.
Hlboké učenie s Pythonom: Príklad Perceptronu
Teraz som si istý, že musíte byť oboznámení s fungovaním „ ALEBO ” brána. Výstup je jeden ak je niektorý zo vstupov tiež jeden.
Preto môže byť Perceptron použitý ako oddeľovač alebo rozhodovací riadok, ktorý rozdeľuje vstupnú sadu brány OR na dve triedy:
Trieda 1: Vstupy s výstupom 0, ktorý leží pod rozhodovacím riadkom.
Trieda 2: Vstupy s výstupom 1, ktorý leží nad rozhodovacím riadkom alebo oddeľovačom.
Doteraz sme chápali, že na klasifikáciu sady vstupných údajov do dvoch tried je možné použiť lineárny perceptrón. Ako však vlastne klasifikuje údaje?
Matematicky možno perceptrón považovať za rovnicu váh, vstupov a skreslenia.
ako previesť binárny reťazec na desatinné v java -
Krok 1: Importujte všetku požadovanú knižnicu
Tu importujem iba jednu knižnicu, tj. TensorFlow
import tensorflow ako tf
Krok 2: Definujte vektorové premenné pre vstup a výstup
Ďalej musíme vytvoriť premenné na ukladanie vstupu, výstupu a skreslenia pre Perceptron.
train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1], [1]]
Krok 3: Definujte premennú hmotnosť
Tu definujeme tenzorovú premennú tvaru 3 × 1 pre naše váhy a na začiatku jej priradíme niekoľko náhodných hodnôt.
w = tf.Variable (tf.random_normal ([3, 1], seed = 15))
Krok 4: Definujte zástupné symboly pre vstup a výstup
Musíme definovať zástupné symboly, aby mohli prijímať externé vstupy za behu.
x = tf.placeholder (tf.float32, [None, 3]) y = tf.placeholder (tf.float32, [None, 1])
Krok 5: Vypočítajte výstup a aktivačnú funkciu
Ako už bolo uvedené skôr, vstup prijatý perceptrónom sa najskôr vynásobí príslušnými váhami a potom sa všetky tieto vážené vstupy spočítajú dohromady. Táto sčítaná hodnota sa potom privedie na aktiváciu na získanie konečného výsledku.
výstup = tf.nn.relu (tf.matmul (x, w))
Poznámka: V tomto prípade som použil relu ako moja aktivačná funkcia. Môžete použiť ktorúkoľvek z aktivačných funkcií podľa svojich potrieb.
Krok 6: Vypočítajte náklady alebo chybu
Musíme vypočítať Cost = Mean Squared Error, čo nie je nič iné ako druhá mocnina rozdielu výstupu perceptronu a požadovaného výkonu.
strata = tf.reduce_sum (tf.square (výstup - y))
Krok 7: Minimalizujte chybu
Cieľom perceptronu je minimalizovať stratu, náklady alebo chyby. Takže tu použijeme Gradient Descent Optimizer.
optimizer = tf.train.GradientDescentOptimizer (0,01) vlak = optimizer.minimize (strata)
Krok 8: Inicializujte všetky premenné
Premenné sú definované iba pomocou tf. Premenná. Musíme teda inicializovať definované premenné.
prejsť na príkaz v c ++
init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)
Krok 9: Výcvik perceptronu v iteráciách
Musíme trénovať náš perceptrón, t. J. Aktualizovať hodnoty váh a skreslenia v postupnej iterácii, aby sme minimalizovali chybu alebo stratu. Tu budem trénovať náš perceptron v 100 epochách.
pre i v rozsahu (100): sess.run (vlak, {x: train_in, y: train_out}) náklady = sess.run (strata, feed_dict = {x: train_in, y: train_out}) print ('Epocha - ', i,' - strata - ', náklady)Krok 10: Výstup
……
……
Ako vidíte tu, strata začala na 2.07 a skončili o 0,27
.
Deep Learning with Python: Creating a Deep Neural Network
Teraz, keď sme úspešne vytvorili perceptrón a natrénovali ho pre bránu OR. Poďme pokračovať v tomto článku a ukážeme si, ako môžeme vytvoriť našu vlastnú neurónovú sieť od začiatku, kde vytvoríme vstupnú vrstvu, skryté vrstvy a výstupnú vrstvu.
Budeme používať súbor údajov MNIST. Súbor údajov MNIST pozostáva z 60 000 školení vzorky a 10 000 testovaní vzorky ručne písaných číslic. Obrázky majú veľkosť 28 × 28 pixelov a výstup môže ležať medzi 0-9 .
Úlohou je vycvičiť model, ktorý dokáže presne identifikovať číslicu prítomnú na obrázku
Najskôr použijeme nasledujúci import, aby sme priniesli funkciu tlače z Pythonu 3 do Pythonu 2.6+. Príkazy __future__ musia byť v hornej časti súboru, pretože menia základné veci týkajúce sa jazyka, a preto o nich kompilátor musí vedieť od začiatku
z __future__ import print_function
Nasleduje kód s komentármi na každom kroku
# Import MNIST dát z tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) import tensorflow ako tf import matplotlib.pyplot ako plt # Parametre learning_rate = 0,001 training_epochs = 15 batch_size = 100 display_step = 1 # Network Parameters n_hidden_1 = 256 # 1st layer number of features n_hidden_2 = 256 # 2nd layer number of features n_input = 784 # MNIST data input (img shape: 28 * 28) n_classes = 10 # MNIST total classes ( 0-9 číslic) # tf Grafický vstup x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Vytvorenie modelu def multilayer_perceptron (x, váhy , skreslenia): # Skrytá vrstva s aktiváciou RELU vrstva_1 = tf.add (tf.matmul (x, váhy ['h1']), skreslenia ['b1']) vrstva_1 = tf.nn.relu (vrstva_1) # Skrytá vrstva s aktiváciou RELU layer_2 = tf.add (tf.matmul (layer_1, weights ['h2']), biases ['b2']) layer_2 = tf.nn.relu (layer_2) # Výstupná vrstva s lineárnou aktiváciou out_layer = tf. matmul (vrstva _2, weights ['out']) + biases ['out'] return out_layer # Store levels weight & bias weights = {'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]))}} # Construct model pred = multilayer_perceptron (x, váhy, odchýlky) # Definujte stratu a náklady optimalizátora = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (náklady) # Inicializácia premenných init = tf.global_variables_initializer () # vytvorte prázdny zoznam pre uloženie histórie nákladov a histórie presnosti cost_history = [] precision_history = [] # Spustite graf s tf.Session () ako sess: sess.run (init ) # Tréningový cyklus pre epochu v rozsahu (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Slučka pre všetky dávky pre i v rozsahu (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Spustiť optimalizáciu (backprop) a náklady op (na získanie hodnoty straty) _, c = sess.run ([optimizer, cost], feed_dict = {x: batch_x, y: batch_y}) # Vypočítať priemernú stratu avg_cost + = c / total_batch # Zobraziť protokoly na krok epochy, ak epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Vypočítať presnosť presnosti = tf.reduce_mean (tf.cast (correct_prediction, 'float')) ) acu_temp = precision.eval ({x: mnist.test.images, y: mnist.test.labels}) #appendzovať presnosť do zoznamu precision_history.append (acu_temp) #append históriu nákladov cost_history.append (avg_cost) tlačiť ('Epoch:', '% 04d'% (epocha + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Optimalizácia dokončená! ') # vykresliť históriu nákladov plt.plot (cost_history) plt.show () # vykresliť históriu presnosti plt.plot (presnosť _history) plt.show () # Testovací model correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Vypočítať presnosť presnosti = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Accuracy: ', precision.eval ({x: mnist.test.images, y: mnist.test.labels}))Výkon:
Týmto sa dostávame na koniec tohto článku o Deep Learning with Python. Dúfam, že ste pochopili rôzne komponenty Deep Learning, Ako to všetko začalo a Ako pomocou Pythonu môžeme vytvoriť jednoduchý perceptron a Deep Neural Network.
Edureka’s je zostavený profesionálmi v odbore podľa priemyselných požiadaviek a požiadaviek. Osvojíte si pojmy ako funkcia SoftMax, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM) a prácu s knižnicami ako Keras & TFLearn. Kurz bol špeciálne zostavený odborníkmi v odbore s prípadovými štúdiami v reálnom čase.
Máte na nás otázku? Uveďte to prosím v sekcii komentárov „Deep Learning with Python“ a my sa vám ozveme.