Deep Learning with Python: Beginners Guide to Deep Learning

Tento článek vám poskytne komplexní a podrobné znalosti Deep Learning s Pythonem a jeho užitečnost v každodenním životě.

je jedním z nejžhavějších témat let 2018-19, a to z dobrého důvodu. V průmyslu došlo k mnoha pokrokům, kdy nastal čas, kdy stroje nebo počítačové programy skutečně nahrazují lidi. Tento Hluboké učení s Pythonem článek vám pomůže pochopit, co přesně je Deep Learning a jak byl tento přechod umožněn. V tomto článku se budu věnovat následujícím tématům:

Data Science and It’s Components

Data Science je něco, co tam je už věky. Datová věda je extrakce znalostí z dat pomocí různých technik a algoritmů.





AI Timeline - Deep Learning with Python - Edureka

je technika, která umožňuje strojům napodobovat lidské chování. Myšlenka AI je poměrně jednoduchá, ale fascinující, a to dělat inteligentní stroje, které mohou samy rozhodovat. Po celá léta se předpokládalo, že počítače se nikdy nevyrovnají síle lidského mozku.



Tehdy jsme neměli dostatek dat a výpočetní sílu, ale nyní s Velká data s příchodem GPU je možná umělá inteligence.

je podmnožinou techniky AI, která využívá statistické metody, aby umožnila strojům vylepšovat se zkušenostmi.



Hluboké učení je podmnožina ML, díky níž je výpočet vícevrstvé neuronové sítě proveditelný. Využívá neuronové sítě k simulaci rozhodování podobného člověku.

Potřeba hlubokého učení

Krokem k umělé inteligenci je strojové učení. Machine Learning je podmnožinou AI a je založeno na myšlence, že strojům by měl být umožněn přístup k datům a měl by jim být ponechán možnost učit se a zkoumat sami. Zabývá se extrakcí vzorů z velkých datových souborů. Manipulace s velkými datovými sadami nebyl problém.

  • Algoritmy strojového učení nemůže zpracovat vysokodimenzionální data - kde máme velké množství vstupů a výstupů: zaokrouhleno tisíce dimenzí. Zpracování a zpracování takového typu dat se stává velmi složitým a vyčerpávajícím zdrojem. Toto se nazývá jako Curse of Dimensionality.

  • Další výzvou, které čelil, bylo upřesnit funkce, které mají být extrahovány . To hraje důležitou roli při předpovídání výsledku i při dosahování lepší přesnosti. Proto bez extrakce funkcí výzva pro programátora se zvyšuje, protože účinnost algoritmu velmi závisí na tom, jak je programátor vhledný.

A právě teď přišel na pomoc Deep Learning. Hluboké učení je schopný zpracovat vysoce dimenzionální data a je také efektivní v se zaměřením na správné funkce sama o sobě.

Co je to Deep Learning?

Hluboké učení je podmnožinou strojového učení, kde se k trénování používají podobné algoritmy strojového učení aby se dosáhlo lepší přesnosti v případech, kdy první nedosahoval úrovně. V podstatě, Hluboké učení napodobuje způsob, jakým funguje náš mozek tj. učí se ze zkušenosti.

Jak víš,náš mozek je tvořen miliardy neuronů což nám umožňuje dělat úžasné věci. I mozek malého dítěte je schopen vyřešit složité problémy, které je velmi obtížné vyřešit i pomocí superpočítačů. Jak tedy můžeme dosáhnout stejné funkce v programu? To je místo, kde rozumíme Umělý neuron (Perceptron) a Umělá neuronová síť.

Perceptron a umělé neuronové sítě

Deep Learning studuje základní jednotku mozku zvanou mozková buňka nebo neuron. Nyní pochopme funkčnost biologických neuronů a to, jak tuto funkci napodobujeme ve vnímání nebo umělém neuronu.

  • Dendrit: Přijímá signály z jiných neuronů
  • Buněčné tělo: Sčítá všechny vstupy
  • Axon: Používá se k přenosu signálů do ostatních buněk

Umělý neuron nebo a Perceptron je lineární model používaný pro binární klasifikaci. Modeluje neuron, který má sadu vstupů, z nichž každý má určitou váhu. Neuron na nich spočítá nějakou funkci vážený vstupy a dává výstup.

jaký je rozdíl mezi třídou a rozhraním

Přijímá n vstupů (odpovídající každé funkci). Pak tyto vstupy sečte, použije transformaci a vytvoří výstup. Má dvě funkce:

  • Shrnutí
  • Transformace (aktivace)

Váha ukazuje účinnost konkrétního vstupu. Čím větší váha bude mít vstup, tím více to bude mít dopad na neuronovou síť . Na druhou stranu, Zaujatost je další parametr v Perceptronu, který se používá k úpravě výstupu spolu s váženým součtem vstupů do neuronu, což pomáhá modelu takovým způsobem, aby nejlépe vyhovoval daným datům.

Aktivační funkce převádí vstupy na výstupy. K výrobě výstupu používá prahovou hodnotu. Existuje mnoho funkcí, které se používají jako aktivační funkce, například:

  • Lineární nebo identita
  • Jednotkový nebo binární krok
  • Sigmoid nebo Logistic
  • Tanh
  • ReLU
  • Softmax

Studna. pokud si myslíte, že Perceptron problém vyřeší, pak se mýlíte. Byly tam dva hlavní problémy:

  • Jednovrstvé perceptrony nelze klasifikovat nelineárně oddělitelné datové body .
  • Složité problémy, které zahrnují mnoho parametrů nelze vyřešit jednovrstvými perceptrony.

Zvažte zde příklad a složitost s použitými parametry k přijetí rozhodnutí marketingového týmu.

Jeden neuron nemůže přijmout tolik vstupů, a proto by k řešení tohoto problému bylo použito více než jednoho neuronu. Neural Network je opravdu jen a složení perceptronů, spojené různými způsoby a pracuje na různých aktivačních funkcích.

  • Vstupní uzly poskytují síti informace z vnějšího světa a jsou společně označovány jako „vstupní vrstva“.
  • Skryté uzly provádět výpočty a přenášet informace ze vstupních uzlů do výstupních uzlů. Kolekce skrytých uzlů tvoří „skrytou vrstvu“.
  • Výstupní uzly jsou souhrnně označovány jako „výstupní vrstva“ a jsou odpovědné za výpočty a přenos informací ze sítě do vnějšího světa.

Nyní, když máte představu o tom, jak se chová perceptron, různé použité parametry a různé vrstvy neuronové sítě, pojďme pokračovat v tomto Deep Learning s blogem Python a podívejte se na některé skvělé aplikace Deep Learning.

Aplikace hlubokého učení

V průmyslu existují různé aplikace Deep Learning, zde je několik důležitých aplikací, které jsou součástí našich každodenních úkolů.

  • Rozpoznávání řeči

  • Strojový překlad

  • Rozpoznávání obličeje a automatické značkování

  • Virtuální osobní asistenti

  • Řidičské auto

  • Chatboti

Proč Python pro hluboké učení?

  • je jeden takový nástroj, který má jedinečný atribut, být univerzální programovací jazyk jako bytí snadné použití pokud jde o analytické a kvantitativní výpočty.
  • Je to velmi snadno pochopitelné
  • Python je Dynamicky napsáno
  • Obrovský
  • Obrovská řada knihoven pro různé účely, jako je Numpy, Seaborn, Matplotlib, Pandas a Scikit-learn

Teď už je dost teorie, podívejme se, jak můžeme začít Deep Learning s Pythonem pomocí malého, ale vzrušujícího příkladu.

Hluboké učení s Pythonem: Příklad Perceptronu

Jsem si jistý, že musíte být obeznámeni s fungováním „ NEBO' brána. Výstup je jeden pokud je některý ze vstupů také jeden.

Proto může být Perceptron použit jako oddělovač nebo rozhodovací řádek, který rozděluje vstupní sadu brány OR na dvě třídy:

Třída 1: Vstupy s výstupem 0, který leží pod rozhodovacím řádkem.
Třída 2: Vstupy s výstupem 1, který leží nad rozhodovacím řádkem nebo oddělovačem.

Dosud jsme pochopili, že lineární perceptron lze použít ke klasifikaci vstupní datové sady do dvou tříd. Ale jak vlastně klasifikuje data?

Matematicky lze perceptron považovat za rovnici vah, vstupů a zkreslení.

jak převést binární řetězec na desítkové v java

Krok 1: Importujte veškerou požadovanou knihovnu

Zde importuji pouze jednu knihovnu, tzn. TensorFlow

importovat tensorflow jako tf

Krok 2: Definujte vektorové proměnné pro vstup a výstup

Dále musíme vytvořit proměnné pro ukládání vstupu, výstupu a zkreslení pro Perceptron.

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

Krok 3: Definujte proměnnou hmotnosti

Zde definujeme tenzorovou proměnnou tvaru 3 × 1 pro naše váhy a přiřadíme jí zpočátku nějaké náhodné hodnoty.

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

Krok 4: Definujte zástupné symboly pro vstup a výstup

Musíme definovat zástupné symboly, aby mohli přijímat externí vstupy za běhu.

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

Krok 5: Výpočet výstupu a aktivační funkce

Jak již bylo uvedeno dříve, vstup přijatý perceptronem se nejprve vynásobí příslušnými váhami a poté se všechny tyto vážené vstupy sečtou dohromady. Tato sečtená hodnota se poté přivede k aktivaci pro získání konečného výsledku.

výstup = tf.nn.relu (tf.matmul (x, w))

Poznámka: V tomto případě jsem použil relu jako moje aktivační funkce. Podle potřeby můžete aktivační funkce libovolně využívat.

Krok 6: Vypočítejte náklady nebo chybu

Musíme vypočítat Cost = Mean Squared Error, což není nic jiného než druhá mocnina rozdílu výstupu perceptronu a požadovaného výstupu.

loss = tf.reduce_sum (tf.square (výstup - y))

Krok 7: Minimalizace chyby

Cílem perceptronu je minimalizovat ztrátu, náklady nebo chybu. Tady tedy použijeme Optimalizátor přechodu sestupu.

optimizer = tf.train.GradientDescentOptimizer (0,01) vlak = optimizer.minimize (ztráta)

Krok 8: Inicializujte všechny proměnné

Proměnné jsou definovány pouze pomocí tf. Proměnná. Musíme tedy inicializovat definované proměnné.

java rozdíl mezi implementuje a rozšiřuje
init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)

Krok 9: Výcvik perceptronu v iteracích

Musíme trénovat náš perceptron, tj. Aktualizovat hodnoty vah a zkreslení v postupné iteraci, abychom minimalizovali chybu nebo ztrátu. Zde budu trénovat náš perceptron ve 100 epochách.

pro i v rozsahu (100): sess.run (vlak, {x: train_in, y: train_out}) cost = sess.run (ztráta, feed_dict = {x: train_in, y: train_out}) print ('Epoch-- ', i,' - ztráta - ', cena)

Krok 10: Výstup

……

……

Jak vidíte zde, ztráta začala v 2.07 a skončila v 0,27

.

Deep Learning with Python: Creating a Deep Neural Network

Nyní, když jsme úspěšně vytvořili perceptron a trénovali jej pro bránu OR. Pojďme pokračovat v tomto článku a podívejme se, jak lze vytvořit naši vlastní Neuronovou síť od nuly, kde vytvoříme vstupní vrstvu, skryté vrstvy a výstupní vrstvu.

Budeme používat datovou sadu MNIST. Soubor dat MNIST se skládá z 60 000 školení vzorky a 10 000 testování vzorky ručně psaných číslic. Obrázky mají velikost 28 × 28 pixelů a výstup může ležet mezi 0-9 .

Úkolem je vycvičit model, který dokáže přesně identifikovat číslici přítomnou na obrázku

Nejprve použijeme níže uvedený import k přenesení tiskové funkce z Pythonu 3 do Pythonu 2.6+. Příkazy __future__ musí být v horní části souboru, protože mění základní věci týkající se jazyka, a proto o nich překladač musí vědět od začátku

z __future__ import print_function

Následuje kód s komentáři na každém kroku

# Import MNIST dat z tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) import tensorflow jako tf import matplotlib.pyplot jako plt # Parametry 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]) # Create model def multilayer_perceptron (x, weights , biases): # Skrytá vrstva s aktivací RELU layer_1 = tf.add (tf.matmul (x, weights ['h1']), biases ['b1']) layer_1 = tf.nn.relu (layer_1) # Skrytá vrstva s aktivací 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ární aktivací 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, weights, biases) # Definujte ztrátu a optimalizační náklady = 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) # Inicializace proměnných init = tf.global_variables_initializer () # vytvořte prázdný seznam pro uložení historie nákladů a historie přesnosti cost_history = [] přesnost_history = [] # spusťte graf s tf.Session () jako sess: sess.run (init ) # Tréninkový cyklus pro epochu v dosahu (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Loop over all batches for i in range (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Run optimization op (backprop) and cost op (pro získání hodnoty ztráty) _, c = sess.run ([optimalizátor, cena], feed_dict = {x: batch_x, y: batch_y}) # Vypočítat průměrnou ztrátu avg_cost + = c / total_batch # Zobrazit protokoly na krok epochy, pokud epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Vypočítat přesnost přesnosti = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = přesnost.eval ({x: mnist.test.images, y: mnist.test.labels}) #append přesnost do seznamu přesnost_history.append (acu_temp) #append historii nákladů cost_history.append (avg_cost) tisk ('Epoch:', '% 04d'% (epocha + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Optimalizace dokončena! ') #plot historie nákladů plt.plot (cost_history) plt.show () #plot historie přesnosti plt.plot (přesnost _history) plt.show () # Testovací model correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Vypočítat přesnost přesnosti = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Accuracy: ', přesnost.eval ({x: mnist.test.images, y: mnist.test.labels}))

Výstup:

Nyní se dostáváme na konec tohoto článku Deep Learning with Python. Doufám, že jste pochopili různé komponenty Deep Learning, Jak to všechno začalo a Jak pomocí Pythonu můžeme vytvořit jednoduchý perceptron a Deep Neural Network.

Edureka je vybrán odborníky v oboru podle požadavků a požadavků odvětví. Osvojíte si pojmy jako funkce SoftMax, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM) a pracujete s knihovnami jako Keras & TFLearn. Kurz byl speciálně připraven odborníky z oboru s případovými studiemi v reálném čase.

Máte na nás dotaz? Uveďte to prosím v sekci komentářů „Deep Learning with Python“ a my se vám ozveme.