Дълбоко обучение с Python: Ръководство за начинаещи за дълбоко обучение

е една от най-горещите теми за 2018-19 и с основателна причина. Има толкова много постижения в индустрията, че е дошло времето, когато машини или компютърни програми всъщност заместват хората. Това Дълбоко обучение с Python статията ще ви помогне да разберете какво точно представлява Дълбокото обучение и как е възможен този преход. Ще разгледам следните теми в тази статия:

• Data Science и компонентите
• Необходимостта от задълбочено обучение
• Какво е дълбоко обучение?
• Перцептрон и изкуствени невронни мрежи
• Приложения на дълбокото обучение
• Защо Python за дълбоко обучение?
• Дълбоко обучение с Python: пример за Perceptron
• Дълбоко обучение с Python: Създаване на дълбока невронна мрежа

Data Science и компонентите

Е, Data Science е нещо, което съществува от векове. Наука за данните е извличане на знания от данни чрез използване на различни техники и алгоритми.

е техника, която позволява на машините да имитират човешкото поведение. Идеята зад изкуствения интелект е доста проста, но завладяваща, а именно да се правят интелигентни машини, които могат да вземат решения сами. Години наред се смяташе, че компютрите никога няма да съответстват на силата на човешкия мозък.

Е, тогава нямахме достатъчно данни и изчислителна мощ, но сега с Голяма информация възниквайки и с появата на графичните процесори е възможен изкуствен интелект.

как да спра програмата в java -

е подмножество на техниката на ИИ, която използва статистически методи, за да позволи на машините да се подобрят с опит.

Дълбоко обучение е подмножество на ML, което прави изчислението на многослойна невронна мрежа осъществимо. Той използва невронни мрежи, за да симулира подобно на човека вземане на решения.

Необходимостта от задълбочено обучение

Стъпка към изкуствения интелект е машинното обучение. Машинното обучение е подмножество на ИИ и се основава на идеята, че машините трябва да получат достъп до данни и трябва да бъдат оставени да учат и изследват сами. Занимава се с извличане на модели от големи масиви от данни. Работата с големи масиви от данни не е проблем.

• Алгоритми за машинно обучение не може да обработва високоразмерни данни - където имаме голям брой входове и изходи: около хиляди измерения. Обработката и обработката на такъв тип данни става много сложна и изчерпателна. Това се нарича като Проклятието на измереността.

• Друго предизвикателство, пред което беше изправено, беше да се уточни функции за извличане . Това играе важна роля за прогнозиране на резултата, както и за постигане на по-добра точност. Следователно, без извличане на функции, предизвикателството за програмиста се увеличава, тъй като ефективността на алгоритъма много зависи от това колко прозорлив е програмистът.

Сега тук на помощ дойде Deep Learning. Дълбокото обучение е способни да обработват високоразмерните данни и също е ефективен в фокусирайки се върху правилните характеристики сам.

Какво е дълбоко обучение?

Дълбокото обучение е подмножество на машинното обучение, където се използват подобни алгоритми за машинно обучение за обучение така че да се постигне по-добра точност в онези случаи, когато първият не се е представял до марката. По принцип, Дълбокото учене имитира начина, по който функционира нашият мозък т.е. се учи от опит.

Както знаеш,нашият мозък е изграден от милиарди неврони което ни позволява да правим невероятни неща. Дори мозъкът на малко дете е способен да решава сложни проблеми, които са много трудни за решаване дори с помощта на Super-Computers. И така, как можем да постигнем една и съща функционалност в една програма? Сега тук разбираме Изкуствен неврон (Perceptron) и Изкуствена невронна мрежа.

Перцептрон и изкуствени невронни мрежи

Deep Learning изучава основната единица на мозъка, наречена мозъчна клетка или неврон. Нека сега разберем функционалността на биологичните неврони и как имитираме тази функционалност във възприятието или изкуствения неврон.

• Дендрит: Получава сигнали от други неврони
• Клетъчно тяло: Сумира всички входове
• Axon: Използва се за предаване на сигнали към останалите клетки

Изкуствен неврон или a Перцептрон е линеен модел, използван за двоична класификация. Той моделира неврон, който има набор от входове, всеки от които има определено тегло. Невронът изчислява някаква функция върху тях претеглена входове и дава изхода.

Той получава n входа (съответстващи на всяка функция). След това сумира тези входове, прилага трансформация и произвежда изход. Той има две функции:

• Сумиране
• Трансформация (активиране)

Тежестта показва ефективността на даден вход. Колкото повече теглото на входа, толкова повече ще окаже влияние върху невронната мрежа . От друга страна, Пристрастие е допълнителен параметър в Perceptron, който се използва за регулиране на изхода заедно с претеглената сума на входовете към неврона, което помага на модела по начин, който може да се побере най-добре за дадените данни.

Функции за активиране преобразува входовете в изходи. Той използва праг за производство на изход. Има много функции, които се използват като активиращи функции, като:

• Линеен или идентичност
• Единица или двоична стъпка
• Сигмоидна или логистична
• Тан
• ReLU
• Softmax

Добре. ако смятате, че Perceptron решава проблема, значи грешите. Имаше два основни проблема:

• Еднослойни перцептрони не може да класифицира нелинейно разделими точки от данни .
• Сложни проблеми, които включват много параметри не може да бъде решен от еднослойни перцептрони.

Обмислете примера тук и сложността с включените параметри за вземане на решение от маркетинговия екип.

Един неврон не може да поеме толкова много входове и затова повече от един неврон биха били използвани за решаване на този проблем. Невронната мрежа всъщност е просто състав на перцептрони, свързани по различни начини и работещи с различни функции за активиране.

• Входни възли предоставят информация от външния свят на мрежата и заедно се наричат ​​„Входен слой“.
• Скрити възли извършват изчисления и прехвърлят информация от входните възли към изходните възли. Колекция от скрити възли образува „Скрит слой“.
• Изходни възли се наричат ​​общо „изходен слой“ и отговарят за изчисленията и прехвърлянето на информация от мрежата към външния свят.

Сега, когато имате представа за това как се държи персептронът, различните участващи параметри и различните слоеве на невронна мрежа, нека продължим това дълбоко обучение с Python Blog и да видим някои страхотни приложения на дълбокото обучение.

Приложения на дълбокото обучение

Има различни приложения на дълбокото обучение в индустрията, ето няколко от важните, които присъстват в нашите ежедневни задачи.

• Гласово разпознаване

• Машинен превод

• Разпознаване на лице и автоматично маркиране

• Виртуални лични асистенти

• Самоуправляваща се кола

• Чат ботове

Защо Python за дълбоко обучение?

• е един такъв инструмент, който има уникален атрибут, да бъде език за програмиране с общо предназначение като битие лесен за използване когато става въпрос за аналитични и количествени изчисления.
• Много е лесно за разбиране
• Python е Динамично въведен
• Огромно
• Голяма гама от библиотеки за различни цели като Numpy, Seaborn, Matplotlib, Pandas и Scikit-learn

Сега достатъчно на теория, нека да видим как можем да започнем Дълбоко обучение с Python с малък, но вълнуващ пример.

Дълбоко обучение с Python: пример за Perceptron

Сега съм сигурен, че вие ​​трябва да сте запознати с работата на „ ИЛИ' порта. Изходът е един ако някой от входовете също е един.

Следователно, Perceptron може да се използва като разделител или линия за вземане на решение, която разделя входния набор от OR Gate на два класа:

Клас 1: Входове с изход като 0, който се намира под линията на решение.
Клас 2: Входове с изход като 1, който се намира над линията за решение или разделителя.

Досега разбрахме, че линеен персептрон може да се използва за класифициране на набора от входни данни в два класа. Но как всъщност класифицира данните?

Математически персептрон може да се разглежда като уравнение на тегла, входове и пристрастия.

Стъпка 1: Импортирайте цялата необходима библиотека

Тук ще импортирам само една библиотека, т.е. TensorFlow

импортиране на tensorflow като tf

Стъпка 2: Определете векторни променливи за вход и изход

След това трябва да създадем променливи за съхраняване на входа, изхода и пристрастията за Perceptron.

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

Стъпка 3: Определете променлива на теглото

Тук ще дефинираме тензорната променлива с форма 3 × 1 за нашите тегла и първоначално ще й присвоим някои случайни стойности.

каква е функцията в sql

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

Стъпка 4: Дефинирайте заместители за вход и изход

Трябва да дефинираме заместители, така че те да могат да приемат външни входове в движение.

x = tf.placeholder (tf.float32, [Няма, 3]) y = tf.placeholder (tf.float32, [Няма, 1])

Стъпка 5: Изчислете изходната и активиращата функция

Както беше обсъдено по-рано, входът, получен от персептрон, първо се умножава по съответните тегла и след това всички тези претеглени входове се сумират заедно. След това тази обобщена стойност се подава към активиране за получаване на крайния резултат.

изход = tf.nn.relu (tf.matmul (x, w))

Забележка: В този случай съм използвал relu като моя функция за активиране. Можете да използвате която и да е от функциите за активиране според вашите нужди.

Стъпка 6: Изчислете цената или грешката

Трябва да изчислим разходите = средна квадратична грешка, която не е нищо друго освен квадратът на разликата в изхода на персептрон и желания изход.

загуба = tf.reduce_sum (tf.square (изход - y))

Стъпка 7: Минимизиране на грешката

Целта на перцептрона е да минимизира загубата или разходите или грешката. И така, тук ще използваме Gradient Descent Optimizer.

оптимизатор = tf.train.GradientDescentOptimizer (0,01) train = optimizer.minimize (загуба)

Стъпка 8: Инициализирайте всички променливи

Променливите са дефинирани само с tf.Променлива. И така, трябва да инициализираме дефинираните променливи.

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

Стъпка 9: Обучение на Perceptron в итерации

Трябва да обучим нашия перцепт, т.е.актуализираме стойности на тегла и пристрастия в последователната итерация, за да сведем до минимум грешката или загубата. Тук ще тренирам нашия перцептрон в 100 епохи.

за i в обхват (100): sess.run (влак, {x: train_in, y: train_out}) разходи = sess.run (загуба, feed_dict = {x: train_in, y: train_out}) print ('Epoch-- ', i,' - загуба - ', цена)

Стъпка 10: Изход

......

......

Както можете да видите тук, загубата започна в 2.07 и завърши в 0,27

.

Дълбоко обучение с Python: Създаване на дълбока невронна мрежа

Сега, след като успешно създадохме персептрон и го обучихме за ИЛИ порта. Нека да продължим тази статия и да видим как можем да създадем наша собствена невронна мрежа от нулата, където ще създадем входен слой, скрити слоеве и изходен слой.

алгоритъм сортиране c ++

Ще използваме набора от данни MNIST. Наборът от данни MNIST се състои от 60 000 обучение проби и 10 000 теста образци от ръчно написани цифрови изображения. Изображенията са с размер 28 × 28 пиксела и изходът може да лежи между 0-9 .

Задачата тук е да се обучи модел, който може точно да идентифицира цифрата, присъстваща на изображението

Първо, ще използваме импортирането по-долу, за да внесем функцията за печат от Python 3 в Python 2.6+. Операторите __future__ трябва да са в горната част на файла, защото те променят основни неща за езика и затова компилаторът трябва да знае за тях от самото начало

от __future__ импортиране печат_функция

Следва кодът с коментари на всяка стъпка

# Импортиране на MNIST данни от 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 # Параметри learning_rate = 0.001 training_epoch batch_size = 100 display_step = 1 # Мрежови параметри n_hidden_1 = 256 # 1-ви слой брой функции n_hidden_2 = 256 # 2-ри слой брой функции n_input = 784 # MNIST въвеждане на данни (img форма: 28 * 28) n_classes = 10 # MNIST общо класове ( 0-9 цифри) # tf Графичен вход x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Създаване на модел def multilayer_perceptron (x, тежести , пристрастия): # Скрит слой с активиращ слой RELU_1 = tf.add (tf.matmul (x, тегла ['h1']), отклонения ['b1']) слой_1 = tf.nn.relu (слой_1) # Скрит слой с RELU активиращ слой_2 = tf.add (tf.matmul (слой_1, тегла ['h2']), пристрастия ['b2']) слой_2 = tf.nn.relu (слой_2) # Изходен слой с линейно активиране out_layer = tf. matmul (слой _2, тежести ['out']) + пристрастия ['out'] връщане out_layer # Съхраняване на тегло на слоеве и пристрастия тежести = {'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]))} отклонения = {'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]))} # Конструиране на модел pred = multilayer_perceptron (x, тежести, пристрастия) # Определете загубата и разходите за оптимизатора = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (разходи) # Инициализиране на променливите init = tf.global_variables_initializer () #създайте празен списък, за да съхраните историята на разходите и историята на точността cost_history = [] точността_история = [] # Стартирайте графиката с tf.Session () като sess: sess.run (init ) # Обучителен цикъл за епоха в обхвата (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Цикъл върху всички партиди за i в обхват (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Стартиране на оптимизация op (backprop) и разходи op (за получаване на стойност на загубата) _, c = sess.run ([оптимизатор, цена], feed_dict = {x: batch_x, y: batch_y}) # Изчисляване на средната загуба avg_cost + = c / total_batch # Показване на дневници за стъпка от епоха, ако епоха% display_step == 0: коректно_прогнозиране = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Изчисляване на точността на точността = tf.reduce_mean (tf.cast (правилно_прогнозиране, 'плаващ')) ) acu_temp = точност.eval ({x: mnist.test.images, y: mnist.test.labels}) # добавете точността към списъка точността_история.аппенд (acu_temp) # добавете историята на разходите cost_history.append (avg_cost) print ('Epoch:', '% 04d'% (epoch + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Оптимизацията завърши! ') #plot историята на разходите plt.plot (cost_history) plt.show () #plot историята на точността plt.plot (точност _history) plt.show () # Тестов модел коректно_прогнозиране = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Изчисляване на точността на точността = tf.reduce_mean (tf.cast (правилна_прогноза, ' float ')) print (' Точност: ', точността.eval ({x: mnist.test.images, y: mnist.test.labels}))

Изход:

Сега с това стигнахме до края на тази статия за Дълбоко обучение с Python. Надявам се, че сте разбрали различните компоненти на дълбокото обучение, как всичко е започнало и как с помощта на Python можем да създадем прост перцептрон и дълбока невронна мрежа.

Edureka’s се подготвя от професионалисти в бранша според изискванията и изискванията на бранша. Ще овладеете понятията като функцията SoftMax, автокодиращи невронни мрежи, ограничена машина на Boltzmann (RBM) и ще работите с библиотеки като Keras & TFLearn. Курсът е специално подготвен от експерти в бранша с казуси в реално време.

Имате въпрос към нас? Моля, споменете го в раздела за коментари на „Дълбоко обучение с Python“ и ние ще се свържем с вас.