to jeden z najgorętszych tematów 2018-19 i nie bez powodu. Nastąpiło tak wiele postępów w przemyśle, kiedy nadszedł czas, kiedy maszyny lub programy komputerowe faktycznie zastępują ludzi. To Głębokie uczenie z Pythonem artykuł pomoże ci zrozumieć, czym dokładnie jest Deep Learning i jak to przejście stało się możliwe. W tym artykule omówię następujące tematy:
- Nauka o danych i jej składniki
- Potrzeba głębokiego uczenia się
- Co to jest uczenie głębokie?
- Perceptron i sztuczne sieci neuronowe
- Zastosowania uczenia głębokiego
- Dlaczego Python do głębokiego uczenia się?
- Głębokie uczenie w Pythonie: przykład Perceptron
- Deep Learning w Pythonie: tworzenie głębokiej sieci neuronowej
Nauka o danych i jej składniki
Cóż, nauka o danych to coś, co istnieje od wieków. Nauka o danych to wydobywanie wiedzy z danych przy użyciu różnych technik i algorytmów.
to technika, która umożliwia maszynom naśladowanie ludzkich zachowań. Idea sztucznej inteligencji jest dość prosta, ale fascynująca, a mianowicie tworzenie inteligentnych maszyn, które mogą samodzielnie podejmować decyzje. Przez lata sądzono, że komputery nigdy nie dorównają mocy ludzkiego mózgu.
Cóż, wtedy nie mieliśmy wystarczającej ilości danych i mocy obliczeniowej, ale teraz mamy Big Data powstanie i pojawienie się procesorów graficznych, sztuczna inteligencja jest możliwa.
jak sortować liczby w C ++
jest podzbiorem techniki sztucznej inteligencji, która wykorzystuje metody statystyczne, aby umożliwić maszynom doskonalenie się wraz z doświadczeniem.
Głęboka nauka jest podzbiorem ML, które umożliwiają obliczenia wielowarstwowej sieci neuronowej. Wykorzystuje sieci neuronowe do symulacji podejmowania decyzji podobnych do ludzkich.
Potrzeba głębokiego uczenia się
Krokiem w kierunku sztucznej inteligencji jest uczenie maszynowe. Uczenie maszynowe jest podzbiorem sztucznej inteligencji i opiera się na założeniu, że maszyny powinny mieć dostęp do danych i powinny być pozostawione do samodzielnej nauki i eksploracji. Zajmuje się wyodrębnianiem wzorców z dużych zbiorów danych. Obsługa dużych zbiorów danych nie była problemem.
- Algorytmy uczenia maszynowego nie obsługuje danych wielowymiarowych - gdzie mamy dużą liczbę wejść i wyjść: zaokrąglić tysiące wymiarów. Obsługa i przetwarzanie tego typu danych staje się bardzo złożone i wyczerpuje zasoby. Nazywa się to Przekleństwo wymiarowości.
- Kolejnym wyzwaniem było określenie funkcje do wyodrębnienia . Odgrywa to ważną rolę w przewidywaniu wyniku, a także w osiąganiu lepszej dokładności. Dlatego bez wyodrębniania cech, wyzwanie dla programisty rośnie, ponieważ skuteczność algorytmu w dużej mierze zależy od tego, jak wnikliwy jest programista.
W tym miejscu z pomocą przyszło Deep Learning. Głębokie uczenie się jest zdolne do obsługi danych wysokowymiarowych i jest również skuteczny w skupiając się na właściwych funkcjach na własną rękę.
Co to jest uczenie głębokie?
Deep Learning to podzbiór uczenia maszynowego, w którym do szkolenia używane są podobne algorytmy uczenia maszynowego tak, aby uzyskać lepszą dokładność w tych przypadkach, w których ten pierwszy nie spełniał wymagań. Gruntownie, Uczenie głębokie naśladuje sposób funkcjonowania naszego mózgu czyli uczy się z doświadczenia.
Jak wiesz,nasz mózg jest zbudowany miliardy neuronów który pozwala nam robić niesamowite rzeczy. Nawet mózg małego dziecka jest w stanie rozwiązać złożone problemy, które są bardzo trudne do rozwiązania nawet przy użyciu super-komputerów. Jak więc możemy osiągnąć tę samą funkcjonalność w programie? Teraz to jest, gdy rozumiemy Sztuczny Neuron (Perceptron) i Sztuczna sieć neuronowa.
Perceptron i sztuczne sieci neuronowe
Deep Learning bada podstawową jednostkę mózgu zwaną komórką mózgową lub neuronem. Teraz zrozumiemy funkcjonalność neuronów biologicznych i sposób, w jaki naśladujemy tę funkcjonalność w percepcji lub w sztucznym neuronie.
- Dendryt: Odbiera sygnały od innych neuronów
- Ciało komórki: Sumuje wszystkie nakłady
- Akson: Służy do przesyłania sygnałów do innych komórek
Sztuczny neuron lub a Perceptron to model liniowy używany do klasyfikacji binarnej. Modeluje neuron, który ma zestaw wejść, z których każdy ma określoną wagę. Neuron oblicza na nich jakąś funkcję ważone dane wejściowe i podaje dane wyjściowe.
Otrzymuje n danych wejściowych (odpowiadających każdej funkcji). Następnie sumuje te dane wejściowe, stosuje transformację i generuje wynik. Posiada dwie funkcje:
- Podsumowanie
- Transformacja (aktywacja)
Waga pokazuje skuteczność określonego wkładu. Im większa waga danych wejściowych, tym bardziej będzie to miało wpływ na sieć neuronową . Z drugiej strony, Stronniczość jest dodatkowy parametr w Perceptronie, który służy do dostosowania wyjścia wraz z ważoną sumą wejść do neuronu, co pomaga modelowi w sposób, który najlepiej pasuje do podanych danych.
Funkcje aktywacji tłumaczy dane wejściowe na dane wyjściowe. Używa progu do wygenerowania wyniku. Istnieje wiele funkcji, które są używane jako funkcje aktywacji, na przykład:
- Liniowy lub tożsamość
- Jednostka lub krok binarny
- Sigmoid lub Logistic
- Tanh
- ReLU
- Softmax
Dobrze. jeśli uważasz, że Perceptron rozwiązuje problem, to się mylisz. Wystąpiły dwa główne problemy:
- Perceptrony jednowarstwowe nie może sklasyfikować nieliniowo rozdzielalnych punktów danych .
- Złożone problemy, które obejmują wiele parametrów nie można rozwiązać za pomocą perceptronów jednowarstwowych.
Rozważmy przykład tutaj i złożoność parametrów związanych z podjęciem decyzji przez zespół marketingowy.
Jeden neuron nie może przyjąć tylu sygnałów wejściowych i dlatego do rozwiązania tego problemu można użyć więcej niż jednego neuronu. Sieć neuronowa to tak naprawdę po prostu skład perceptronów połączonych na różne sposoby i działają na różnych funkcjach aktywacji.
- Węzły wejściowe dostarczają do sieci informacje ze świata zewnętrznego i są razem nazywane „warstwą wejściową”.
- Ukryte węzły wykonywać obliczenia i przesyłać informacje z węzłów wejściowych do węzłów wyjściowych. Zbiór ukrytych węzłów tworzy „ukrytą warstwę”.
- Węzły wyjściowe są łącznie określane jako „warstwa wyjściowa” i są odpowiedzialne za obliczenia i przesyłanie informacji z sieci do świata zewnętrznego.
Teraz, gdy masz już pojęcie o tym, jak zachowuje się perceptron, o różnych parametrach i różnych warstwach sieci neuronowej, kontynuujmy to głębokie uczenie z blogiem Python i zobaczmy kilka fajnych zastosowań Deep Learning.
Zastosowania uczenia głębokiego
Istnieją różne zastosowania Deep Learning w przemyśle, oto kilka z najważniejszych, które są obecne w naszych codziennych zadaniach.
- Rozpoznawanie mowy
- Tłumaczenie maszynowe
- Rozpoznawanie twarzy i automatyczne tagowanie
- Wirtualni asystenci osobiści
- Samojezdny samochód
- Chatboty
Dlaczego Python do głębokiego uczenia się?
- jest jednym z takich narzędzi, które ma unikalny atrybut bycia język programowania ogólnego przeznaczenia jako istota łatwy w użyciu jeśli chodzi o obliczenia analityczne i ilościowe.
- To jest bardzo łatwy do zrozumienia
- Python jest Wpisane dynamicznie
- Olbrzymi
- Szeroka gama bibliotek do różnych celów, takich jak Numpy, Seaborn, Matplotlib, Pandas i Scikit-learn
Dość teorii. Zobaczmy, jak możemy rozpocząć uczenie głębokie w Pythonie na małym, ale ekscytującym przykładzie.
Deep Learning w Pythonie: przykład Perceptron
Teraz jestem pewien, że musicie znać działanie „ LUB' brama. Wynik jest jeden jeśli którekolwiek z wejść jest również jeden.
Dlatego Perceptron może być używany jako separator lub linia decyzyjna, która dzieli wejściowy zestaw bramki OR na dwie klasy:
Klasa 1: Wejścia o wartości 0, która leży poniżej linii decyzji.
Klasa 2: Wejścia o wartości wyjściowej 1, które znajdują się powyżej linii decyzyjnej lub separatora.
Do tej pory zrozumieliśmy, że perceptron liniowy może służyć do klasyfikowania zbioru danych wejściowych na dwie klasy. Ale jak właściwie klasyfikuje dane?
Matematycznie perceptron można traktować jak równanie wag, danych wejściowych i odchylenia.
Krok 1: Zaimportuj całą wymaganą bibliotekę
Tutaj zamierzam zaimportować tylko jedną bibliotekę, tj. TensorFlow
importuj tensorflow jako tf
Krok 2: Zdefiniuj zmienne wektorowe dla wejścia i wyjścia
Następnie musimy utworzyć zmienne do przechowywania danych wejściowych, wyjściowych i odchylenia dla Perceptronu.
train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1], [1]]
Krok 3: Zdefiniuj zmienną wagi
Tutaj zdefiniujemy zmienną tensorową o kształcie 3 × 1 dla naszych wag i przypiszemy jej początkowo kilka losowych wartości.
jaka jest różnica między klasą a interfejsem
w = tf.Variable (tf.random_normal ([3, 1], seed = 15))
Krok 4: Zdefiniuj symbole zastępcze dla danych wejściowych i wyjściowych
Musimy zdefiniować symbole zastępcze, aby mogły akceptować zewnętrzne dane wejściowe podczas uruchamiania.
x = tf.placeholder (tf.float32, [None, 3]) y = tf.placeholder (tf.float32, [None, 1])
Krok 5: Oblicz dane wyjściowe i funkcję aktywacji
Jak omówiono wcześniej, wejście odbierane przez perceptron jest najpierw mnożone przez odpowiednie wagi, a następnie wszystkie te ważone wejścia są sumowane. Ta suma jest następnie przekazywana do aktywacji w celu uzyskania końcowego wyniku.
wyjście = tf.nn.relu (tf.matmul (x, w))
Uwaga: w tym przypadku użyłem relu jako moja funkcja aktywacji. Możesz dowolnie korzystać z funkcji aktywacji w zależności od potrzeb.
Krok 6: Oblicz koszt lub błąd
Musimy obliczyć koszt = błąd średniokwadratowy, który jest niczym innym jak kwadratem różnicy mocy perceptronu i żądanej mocy.
strata = tf.reduce_sum (tf.square (wyjście - y))
Krok 7: Zminimalizuj błąd
Celem perceptronu jest zminimalizowanie straty lub kosztu lub błędu. Więc tutaj użyjemy Gradient Descent Optimizer.
Optimizer = tf.train.GradientDescentOptimizer (0.01) train = optimizer.minimize (strata)
Krok 8: Zainicjuj wszystkie zmienne
Zmienne są definiowane tylko za pomocą tf.Variable. Musimy więc zainicjalizować zdefiniowane zmienne.
init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)
Krok 9: Trenowanie Perceptronu w iteracjach
Musimy wyszkolić nasz perceptron, tj. Zaktualizować wartości wag i odchylenia w kolejnej iteracji, aby zminimalizować błąd lub stratę. Tutaj będę trenować nasz perceptron w 100 epokach.
for i in range (100): sess.run (train, {x: train_in, y: train_out}) cost = sess.run (loss, feed_dict = {x: train_in, y: train_out}) print ('Epoch-- ', i,' - strata - ', koszt)Krok 10: Wyjście
……
……
Jak widać tutaj, strata zaczęła się o godz 2.07 i zakończyło się o 0,27
.
Deep Learning w Pythonie: tworzenie głębokiej sieci neuronowej
Teraz, gdy pomyślnie stworzyliśmy perceptron i wyszkoliliśmy go pod kątem bramki OR. Kontynuujmy ten artykuł i zobaczmy, jak można stworzyć własną sieć neuronową od podstaw, w której utworzymy warstwę wejściową, ukryte warstwy i warstwę wyjściową.
to związek w Javie
Będziemy używać zestawu danych MNIST. Zestaw danych MNIST składa się z 60000 szkoleń próbki i 10000 testów próbki odręcznych obrazów cyfrowych. Obrazy mają odpowiedni rozmiar 28 x 28 pikseli a wyjście może leżeć pomiędzy 0-9 .
Tutaj zadaniem jest wytrenowanie modelu, który będzie w stanie dokładnie zidentyfikować cyfrę obecną na obrazie
Po pierwsze, użyjemy poniższego importu, aby przenieść funkcję drukowania z Pythona 3 do Pythona 2.6+. Instrukcje __future__ muszą znajdować się blisko początku pliku, ponieważ zmieniają podstawowe rzeczy w języku, więc kompilator musi o nich wiedzieć od samego początku
from __future__ import print_function
Poniżej znajduje się kod z komentarzami na każdym kroku
# Importuj dane MNIST z tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) import tensorflow as tf import matplotlib.pyplot as plt # Parametry learning_rate = 0,001 training_epochs = 15 batch_size = 100 display_step = 1 # Parametry sieciowe n_hidden_1 = 256 # Pierwsza warstwa liczba funkcji n_hidden_2 = 256 # Druga warstwa liczba funkcji n_input = 784 # MNIST wejście danych (img shape: 28 * 28) n_classes = 10 # MNIST suma klas ( 0-9 cyfr) # tf Graph input x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Utwórz model def multilayer_perceptron (x, weights , odchylenia): # Ukryta warstwa z aktywacją RELU warstwa_1 = tf.add (tf.matmul (x, weights ['h1']), odchylenia ['b1']) warstwa_1 = tf.nn.relu (warstwa_1) # Ukryta warstwa z aktywacją RELU warstwa_2 = tf.add (tf.matmul (warstwa_1, wagi ['h2']), odchylenia ['b2']) warstwa_2 = tf.nn.relu (warstwa_2) # Warstwa wyjściowa z liniową aktywacją out_layer = tf. matmul (warstwa _2, wagi ['out']) + odchylenia ['out'] return out_layer # Przechowuj wagi warstw i odchylenia = {'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]))} odchylenia = {'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]))} # Skonstruuj model pred = multilayer_perceptron (x, wagi, odchylenia) # Zdefiniuj stratę i koszt optymalizatora = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (cost) # Inicjalizacja zmiennych init = tf.global_variables_initializer () # utwórz pustą listę do przechowywania historii kosztów i historii dokładności cost_history = [] dokładność_history = [] # Uruchom wykres za pomocą tf.Session () jako sess: sess.run (init ) # Cykl treningowy dla epoki w zakresie (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Pętla po wszystkich partiach dla i w zakresie (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Uruchom optymalizację op (backprop) i koszt op (aby uzyskać wartość straty) _, c = sess.run ([optymalizator, koszt], feed_dict = {x: batch_x, y: batch_y}) # Oblicz średnią stratę avg_cost + = c / total_batch # Wyświetl logi na krok epoki, jeśli epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Oblicz dokładność dokładności = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = dokładność.eval ({x: mnist.test.images, y: mnist.test.labels}) # dołącz dokładność do listy dokładność_history.append (acu_temp) # dołącz historię kosztów cost_history.append (avg_cost) drukuj ('Epoka:', '% 04d'% (epoka + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Optymalizacja zakończona! ') #plot historię kosztów plt.plot (cost_history) plt.show () #plot the dokładność history plt.plot (dokładność _history) plt.show () # Model testowy correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Oblicz dokładność dokładności = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Dokładność: ', dokładność.eval ({x: mnist.test.images, y: mnist.test.labels}))Wynik:
Teraz dochodzimy do końca tego artykułu Deep Learning with Python. Mam nadzieję, że rozumiesz różne elementy uczenia głębokiego, jak to się wszystko zaczęło i jak za pomocą Pythona możemy stworzyć prosty perceptron i głęboką sieć neuronową.
Edureka's jest nadzorowany przez profesjonalistów z branży, zgodnie z wymaganiami i wymaganiami branży. Opanujesz koncepcje, takie jak funkcja SoftMax, sieci neuronowe Autoencoder, Restricted Boltzmann Machine (RBM) i będziesz pracować z bibliotekami takimi jak Keras i TFLearn. Kurs został specjalnie wyselekcjonowany przez ekspertów branżowych z analizami przypadków w czasie rzeczywistym.
Masz do nas pytanie? Wspomnij o tym w sekcji komentarzy w „Deep Learning with Python”, a my skontaktujemy się z Tobą.