През последните години се наблюдава възраждане в областта на изкуствения интелект. Той се разпространява извън академичния свят с големи играчи като Google , Microsoft и Facebook създават свои собствени изследователски екипи и правят впечатляващи придобивания .

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

Но освен тези явления, това възраждане е задвижено в немалка част от нова тенденция в AI, по-специално в машинно обучение , известен като „Дълбоко обучение“. В този урок ще ви запозная с ключовите концепции и алгоритми зад дълбокото обучение, започвайки с най-простата единица за композиране и изграждане на концепциите за машинно обучение в Java.

(За пълно разкриване: Също така съм автор на налична библиотека за дълбоко обучение на Java тук , а примерите в тази статия са реализирани с помощта на горната библиотека. Ако ви харесва, можете да го подкрепите, като му дадете звезда в GitHub , за което ще бъда благодарен. Инструкциите за употреба са налични на начална страница .)

Тридесет и втори урок за машинно обучение

В случай, че не сте запознати, проверете това въведение в машинното обучение :

Общата процедура е следната:

1. Имаме алгоритъм, който дава шепа етикетирани примери, да речем 10 изображения на кучета с етикет 1 („Куче“) и 10 изображения на други неща с етикет 0 („Не куче“) - имайте предвид, че ние се придържаме главно да се контролиран , бинарна класификация за този пост.
2. Алгоритъмът „се учи“ да идентифицира изображения на кучета и, когато се храни с ново изображение, се надява да създаде правилния етикет (1, ако е изображение на куче, и 0 в противен случай).

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

Перцептрони: Ранни алгоритми за дълбоко обучение

Един от най-ранните контролирани алгоритми за обучение е този на персептрона, основен градивен елемент на невронната мрежа.

Кажете, че имаме н точки в равнината, обозначени с „0“ и „1“. Дадена ни е нова точка и искаме да познаем нейния етикет (това е подобно на сценария „Куче“ и „Не е куче“ по-горе). Как да го направим?

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

В този случай всяко парче входни данни ще бъде представено като вектор х = ( x_1, x_2 ) и нашата функция ще бъде нещо като „‘ 0 ’, ако е под реда,‘ 1 ’, ако е по-горе“.

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

Резултатът от тази трансферна функция ще бъде подаден във функция за активиране, за да се получи етикетиране. В горния пример нашата функция за активиране е била прагова граница (например 1, ако е по-голяма от някаква стойност):

Обучение на Перцептрона

Обучението на персептрона се състои в подаването му на множество тренировъчни проби и изчисляване на изхода за всяка от тях. След всяка проба, тежестите в са коригирани по такъв начин, че да минимизират изходна грешка , дефинирана като разлика между желано (цел) и текущ изходи. Има и други функции за грешки, като средна квадратична грешка , но основният принцип на обучение остава същият.

Недостатъци на единичен перцептрон

Подходът с единствен перцептрон към дълбокото обучение има един основен недостатък: той може само да се учи линейно разделими функции . Колко основен е този недостатък? Вземете XOR, сравнително проста функция, и забележете, че тя не може да бъде класифицирана чрез линеен разделител (забележете неуспешния опит, по-долу):

c++ език за кодиране

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

Обратни невронни мрежи за задълбочено обучение

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

За начало ще разгледаме невронната мрежа за пренасочване, която има следните свойства:

• Вход, изход и един или повече скрити слоеве. Фигурата по-горе показва мрежа с входен слой от 3 единици, скрит слой от 4 единици и изходен слой с 2 ​​единици (термините единици и неврони са взаимозаменяеми).
• Всяка единица е единичен персептрон като този, описан по-горе.
• Единиците на входния слой служат като входове за единиците на скрития слой, докато единиците на скрития слой са входове към изходния слой.
• Всяка връзка между два неврона има тегло в (подобно на теглото на персептрона).
• Всяка единица слой т обикновено е свързан с всеки единица от предишния слой t - 1 (въпреки че можете да ги разкачите, като зададете теглото им на 0).
• За да обработите входните данни, вие „притискате“ входния вектор към входния слой, като задавате стойностите на вектора като „изходи“ за всяка от входните единици. В този конкретен случай мрежата може да обработва триизмерен входен вектор (поради 3-те входни единици). Например, ако вашият входен вектор е [7, 1, 2], тогава ще зададете изхода на горната единица за въвеждане на 7, средната единица на 1 и т.н. След това тези стойности се разпространяват напред към скритите единици, като се използва претеглената функция за прехвърляне на сумата за всяка скрита единица (оттук и терминът разпространение напред), която от своя страна изчислява техните изходи (функция за активиране).
• Изходният слой изчислява резултатите си по същия начин като скрития слой. Резултатът от изходния слой е изходът на мрежата.

Отвъд линейността

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

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

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

Обучение на Перцептрони

Най-често срещаният алгоритъм за дълбоко обучение за контролирано обучение на многослойните персептрони е известен като обратно размножаване. Основната процедура:

1. Представя се извадка от обучение и се разпространява напред през мрежата.

2. Изходната грешка се изчислява, обикновено средната квадратична грешка:

   

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

3. Грешката в мрежата се свежда до минимум с помощта на метод, наречен стохастичен градиент спускане .

   Градиентното спускане е универсално, но в случай на невронни мрежи това би било графика на грешката при обучението като функция от входните параметри. Оптималната стойност за всяко тегло е тази, при която грешката постига a глобален минимум . По време на тренировъчната фаза тежестите се актуализират на малки стъпки (след всяка тренировъчна проба или мини-партида от няколко проби) по такъв начин, че те винаги се опитват да достигнат глобалния минимум, но това не е лесна задача, тъй като често се озовават в местни минимуми, като този отдясно. Например, ако теглото има стойност 0,6, трябва да се промени към 0,4.

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

   За щастие, обратното размножаване осигурява метод за актуализиране на всяко тегло между два неврона по отношение на изходната грешка. The деривация само по себе си е доста сложно, но актуализацията на теглото за даден възел има следната (проста) форма:

   

   Където Е е грешката на изхода и w_i е теглото на входа i към неврона.

   По същество целта е да се движите по посока на градиента по отношение на теглото i . Ключовият термин е, разбира се, производната на грешката, която не винаги е лесно да се изчисли: как бихте намерили тази производна за произволно тегло на случаен скрит възел в средата на голяма мрежа?

   Отговорът: чрез обратно размножаване. Грешките първо се изчисляват в изходните единици, където формулата е съвсем проста (въз основа на разликата между целевите и прогнозираните стойности) и след това се разпространяват обратно по мрежата по хитър начин, което ни позволява ефективно да актуализираме тежестите си по време на обучение и (надявам се) да достигне минимум.

Скрит слой

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

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

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

Примерна мрежа

Можете да видите проста (4-2-3 слой) невронна мрежа за пренасочване, която класифицира ИРИС набор от данни, внедрен в Java тук през testMLPSigmoidBP метод. Наборът от данни съдържа три класа растения ирис с характеристики като дължина на чаша, дължина на венчелистчетата и др. Мрежата предоставя 50 проби на клас. Характеристиките са закрепени към входните единици, докато всяка изходна единица съответства на един клас от набора от данни: „1/0/0“ показва, че централата е от клас Setosa, „0/1/0“ показва Versicolour и „ 0/0/1 ”показва Вирджиния). Класификационната грешка е 2/150 (т.е. погрешно класифицира 2 проби от 150).

Проблемът с големите мрежи

Невронната мрежа може да има повече от един скрит слой: в този случай по-горните слоеве „изграждат“ нови абстракции върху предишните слоеве. И както споменахме по-рано, често можете да научите по-добре на практика с по-големи мрежи.

Увеличаването на броя на скритите слоеве обаче води до два известни проблема:

1. Изчезващи градиенти : тъй като добавяме все повече скрити слоеве, размножаването става все по-малко полезно при предаване на информация към долните слоеве. Всъщност, когато информацията се предава обратно, градиентите започват да изчезват и стават малки спрямо тежестите на мрежите.
2. Прекалено подходящо : може би централният проблем в машинното обучение. Накратко, прекаленото оборудване описва феномена на приспособяване на данните за обучение също отблизо, може би с хипотези, които са също комплекс. В такъв случай вашият обучаем в крайна сметка се побира наистина добре в данните за обучението, но ще се представи много, много по-зле на реални примери.

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

Автокодери

Повечето уводни класове за машинно обучение обикновено спират с невронни мрежи за пренасочване. Но пространството на възможните мрежи е далеч по-богато - така че нека продължим.

Автокодерът обикновено е невронна мрежа за пренасочване, която има за цел да научете компресирано, разпределено представяне (кодиране) на набор от данни.

Концептуално мрежата е обучена да „пресъздава“ входа, т.е. входните и целевите данни са еднакви. С други думи: опитвате се да изведете същото, което сте въвели, но компресирано по някакъв начин. Това е объркващ подход, така че нека да разгледаме един пример.

Компресиране на входа: Изображения в сива скала

Кажете, че данните за обучение се състоят от 28x28 изображения в сива скала и стойността на всеки пиксел е закрепена към един неврон на входния слой (т.е. входният слой ще има 784 неврона). След това изходният слой ще има същия брой единици (784) като входния слой и целевата стойност за всяка изходна единица ще бъде стойността на сивата скала на един пиксел от изображението.

Интуицията зад тази архитектура е, че мрежата няма да научи „картографиране“ между данните за обучение и нейните етикети, а вместо това ще научи вътрешна структура и характеристиките на самите данни. (Поради това се нарича и скритият слой детектор на функции .) Обикновено броят на скритите единици е по-малък от входно / изходните слоеве, което принуждава мрежата да научи само най-важните характеристики и постига намаляване на размерите.

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

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

Грипно заболяване

За да демонстрираме допълнително автокодери, нека разгледаме още едно приложение.

В този случай ще използваме прост набор от данни, състоящ се от симптоми на грип (заслуга за това блог пост за идеята). Ако се интересувате, кодът за този пример може да бъде намерен в testAEBackpropagation метод .

Ето как се разбива наборът от данни:

• Има шест функции за двоично въвеждане.
• Първите три са симптоми на заболяването. Например, 1 0 0 0 0 0 показва, че този пациент има висока температура, докато 0 1 0 0 0 0 показва кашлица, 1 1 0 0 0 0 показва кашлица и висока температура и др.
• Последните три характеристики са „контра” симптоми; когато пациентът има едно от тях, е по-малко вероятно той или тя да е болен. Например, 0 0 0 1 0 0 показва, че този пациент има противогрипна ваксина. Възможно е да има комбинации от двата набора от функции: 0 1 0 1 0 0 показва ваксиниран пациент с кашлица и т.н.

Ще считаме пациента за болен, когато той или тя има поне две от първите три характеристики и здрави, ако той или тя има поне две от вторите три (с връзки, скъсани в полза на здравите пациенти), напр .:

• 111000, 101000, 110000, 011000, 011100 = болен
• 000111, 001110, 000101, 000011, 000110 = здравословно

Ще обучим автокодер (използващ обратното разпространение) с шест входни и шест изходни единици, но само две скрити единици .

След няколкостотин повторения наблюдаваме, че когато всяка от „болните“ проби се представя в мрежата за машинно обучение, една от двете скрити единици (една и съща единица за всяка „болна“ проба) винаги показва по-висока стойност на активиране от други. Напротив, когато е представена „здрава“ проба, другата скрита единица има по-високо активиране.

Връщане към машинното обучение

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

В известен смисъл, като фаворизираме тези по-прости представления, ние се опитваме да научим данните в по-истински смисъл.

Ограничени машини на Boltzmann

Следващата логична стъпка е да разгледате Ограничени машини на Boltzmann (RBM), до генеративна стохастична невронна мрежа, която може да научи разпределение на вероятностите по своя набор от входове .

RBM са съставени от скрит, видим и пристрастен слой. За разлика от мрежите за пренасочване, връзките между видимия и скрития слой не са насочени (стойностите могат да се разпространяват както в посоките видимо към скрито, така и скрито към видимо) и напълно свързани (всяка единица от даден слой е свързана към всяка единица в следващия - ако позволим на която и да е единица в който и да е слой да се свърже с всеки друг слой, тогава ще имаме Болцман (а не ограничен Болцман ) машина).

Стандартният RBM има двоични скрити и видими единици: т.е. активирането на единицата е 0 или 1 под a Разпределение на Бернули , но има варианти и с други нелинейности .

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

Контрастивна дивергенция

Алгоритъмът за контрастивна дивергенция в една стъпка (CD-1) работи по следния начин:

1. Положителна фаза :
   • Входна проба v е закрепен към входния слой.
   • v се разпространява към скрития слой по подобен начин на мрежите за пренасочване. Резултатът от активирането на скрития слой е з .
2. Отрицателна фаза :
   • Разпространявайте з обратно към видимия слой с резултат v ’ (връзките между видимия и скрития слой не са насочени и по този начин позволяват движение в двете посоки).
   • Разпространете новото v ’ обратно към скрития слой с резултат на активиране ч .

3. Актуализация на теглото :

   

   Където да се е степента на обучение и v , v ’ , з , ч , и в са вектори.

Интуицията зад алгоритъма е, че положителната фаза ( з дадено v ) отразява вътрешното представяне на мрежата на реалния свят данни. Междувременно отрицателната фаза представлява опит за пресъздаване на данните въз основа на това вътрешно представяне ( v ’ дадено з ). Основната цел е за генерирани данни да бъде възможно най-близо до реалния свят и това е отразено във формулата за актуализиране на теглото.

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

Връщайки се към грипа

За да демонстрираме контрастираща дивергенция, ще използваме същия набор от данни за симптомите, както преди. Тестовата мрежа е RBM с шест видими и две скрити единици. Ще обучим мрежата, като използваме контрастираща дивергенция със симптомите v фиксиран към видимия слой. По време на тестването симптомите отново се представят на видимия слой; след това данните се разпространяват в скрития слой. Скритите единици представляват болно / здравословно състояние, много подобна архитектура на автокодера (разпространение на данни от видимия към скрития слой).

След няколкостотин итерации можем да наблюдаваме същия резултат като при автокодерите: една от скритите единици има по-висока стойност на активиране, когато е представена някоя от „болните“ проби, докато другата винаги е по-активна за „здравите“ проби.

Можете да видите този пример в действие в testContrastiveDivergence метод .

Дълбоки мрежи

Сега демонстрирахме, че скритите слоеве на автокодери и RBM действат като ефективни детектори на характеристики; но рядко можем да използваме тези функции директно. Всъщност наборът от данни по-горе е по-скоро изключение, отколкото правило. Вместо това трябва да намерим някакъв начин да използваме тези открити функции индиректно.

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

Получените структури често са доста мощни и дават впечатляващи резултати. Вземете например известния на Google „Котешка“ хартия в които те използват специален вид дълбоки автокодери, за да „научат“ разпознаване на лица на хора и котки въз основа немаркиран данни.

Нека разгледаме по-отблизо.

как да компилирам заглавни файлове в C++

Подредени автокодери

Както подсказва името, тази мрежа се състои от множество подредени автокодери.

Скритият слой на автокодера т действа като входен слой за автоматично кодиране t + 1 . Входният слой на първия автокодер е входният слой за цялата мрежа. Алчната процедура за обучение по слоеве работи по следния начин:

1. Обучете първия автокодер ( t = 1 , или червените връзки на фигурата по-горе, но с допълнителен изходен слой) поотделно, използвайки метода за обратно размножаване с всички налични данни за обучение.
2. Обучете втория автокодер t = 2 (зелени връзки). Тъй като входният слой за t = 2 е скритият слой на t = 1 ние вече не се интересуваме от изходния слой на t = 1 и го премахваме от мрежата. Обучението започва чрез затягане на входна проба към входния слой на t = 1 , който се разпространява напред към изходния слой на t = 2 . На следващо място, тежестите (входно-скрити и скрити-изход) на t = 2 се актуализират с помощта на обратното размножаване. t = 2 използва всички мостри за обучение, подобно на t = 1 .
3. Повторете предишната процедура за всички слоеве (т.е. премахнете изходния слой на предишния автокодер, заменете го с още един автокодер и тренирайте с обратно разпространение).
4. Извикват се стъпки 1-3 предварително обучение и оставете тежестите правилно инициализирани. Няма обаче картографиране между входните данни и изходните етикети. Например, ако мрежата е обучена да разпознава изображения на ръкописни цифри, все още не е възможно да се картографират единиците от последния детектор на функции (т.е. скрития слой на последния автокодер) към типа цифри на изображението. В този случай най-често срещаното решение е да добавите един или повече напълно свързани слоеве към последния слой (сини връзки). Цялата мрежа вече може да се разглежда като многослоен персептрон и се обучава с помощта на обратно разпространение (тази стъпка се нарича още фина настройка ).

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

Мрежи с дълбоко вярване

Както при автокодерите, ние също можем да подреждаме машини на Boltzmann, за да създадем клас, известен като мрежи с дълбоки вярвания (DBN) .

В този случай скритият слой на RBM т действа като видим слой за RBM t + 1 . Входният слой на първия RBM е входният слой за цялата мрежа и алчното предварително обучение по слой работи по следния начин:

1. Тренирайте първия RBM t = 1 използване на контрастираща дивергенция с всички учебни мостри.
2. Тренирайте втория RBM t = 2 . Тъй като видимият слой за t = 2 е скритият слой на t = 1 , обучението започва чрез затягане на входната проба към видимия слой на t = 1 , който се разпространява напред към скрития слой на t = 1 . Тези данни след това служат за започване на контрастивно обучение за дивергенция за t = 2 .
3. Повторете предишната процедура за всички слоеве.
4. Подобно на подредените автокодери, след предварително обучение мрежата може да бъде разширена чрез свързване на един или повече напълно свързани слоеве с крайния RBM скрит слой. Това образува многослоен персептрон, който след това може да бъде добре настроен използване на обратното размножаване.

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

(Забележка: за повече информация относно конструирането и обучението на подредени автокодери или мрежи с дълбоки убеждения, вижте примерния код тук .)

Конволюционни мрежи

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

Изображение чрез DeepLearning.net

Преди да разгледаме действителната структура на конволюционните мрежи, първо дефинираме изображение филтър или квадратна област със свързани тегла. Филтърът се прилага върху цялото входно изображение и често ще прилагате множество филтри. Например, можете да приложите четири 6x6 филтъра към дадено входно изображение. След това изходният пиксел с координати 1,1 е претеглената сума от 6x6 квадрат на входните пиксели с горния ляв ъгъл 1,1 и теглата на филтъра (който също е 6x6 квадрат). Изходният пиксел 2,1 е резултат от входящия квадрат с горния ляв ъгъл 2,1 и т.н.

По този начин тези мрежи се определят от следните свойства:

• Свиващи се слоеве прилагат редица филтри към входа. Например, първият конволюционен слой на изображението може да има четири 6x6 филтъра. Резултатът от един филтър, приложен върху изображението, се извиква карта на характеристиките (FM) и номерът на картите с функции е равен на броя на филтрите. Ако предишният слой също е конволюционен, филтрите се прилагат във всички негови FM с различно тегло, така че всеки входен FM е свързан към всеки изходен FM. Интуицията зад споделените тежести в изображението е, че характеристиките ще бъдат открити независимо от местоположението им, докато множеството филтри позволява на всеки от тях да открива различен набор от функции.
• Подпробни слоеве намаляване на размера на входа. Например, ако входът се състои от изображение 32x32 и слоят има подсемплираща област 2x2, изходната стойност ще бъде изображение 16x16, което означава, че 4 пиксела (всеки 2x2 квадрат) от входното изображение се комбинират в един изход пиксел. Има няколко начина за подпроба, но най-популярните са максимално обединяване , средно обединяване , и стохастично обединяване .
• Последният поддискретизиран (или конволюционен) слой обикновено е свързан с един или повече напълно свързани слоеве, последният от които представлява целевите данни.
• Обучението се извършва с помощта на модифицирано обратно размножаване, което отчита поддискретизиращите слоеве и актуализира теглите на конволюционния филтър въз основа на всички стойности, към които е приложен този филтър.

Можете да видите няколко примера за конволюционни мрежи, обучени (с обратно разпространение) на МНИСТ набор от данни (сиви изображения на ръкописни букви) тук , по-специално в testLeNet * методи (бих препоръчал testLeNetTiny2 тъй като постига нисък процент на грешки от около 2% за относително кратък период от време). Има и хубава JavaScript визуализация на подобна мрежа тук .

Изпълнение

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

Най-общо казано, целта ми в създаването на Deep Learning библиотека беше (и все още е) да изгради базирана на невронна мрежа рамка, която отговаря на следните критерии:

• Обща архитектура, която може да представя разнообразни модели (всички варианти на невронни мрежи, които сме виждали по-горе, например).
• Способността да се използват разнообразни обучителни алгоритми (размножаване на гърба, контрастираща дивергенция и др.).
• Достойно представяне.

За да удовлетворя тези изисквания, възприех диференциран (или модулен) подход към дизайна на софтуера.

Структура

Нека започнем с основите:

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

Тази структура е достатъчно гъвкава, за да се използва както за класически мрежи за пренасочване, така и за RBM и по-сложни архитектури като ImageNet .

Освен това позволява слой да бъде част от повече от една мрежа. Например слоевете в a Мрежа за дълбоко вярване също са слоеве в съответните им RBM.

В допълнение, тази архитектура позволява DBN да се разглежда като списък с подредени RBM по време на фазата на предварително обучение и мрежа за пренасочване по време на фазата на фина настройка, което е едновременно интуитивно приятно и програмно удобно.

Разпространение на данни

Следващият модул се грижи за разпространението на данни през мрежата, процес от две стъпки:

1. Определете реда на слоевете. Например, за да се получат резултатите от многослоен персептрон, данните се „закрепват“ към входния слой (следователно това е първият слой, който трябва да се изчисли) и се разпространяват до изходния слой. За да се актуализират тежестите по време на обратното разпространение, изходната грешка трябва да се разпространява през всеки слой в широк първи ред, започвайки от изходния слой. Това се постига с помощта на различни реализации на LayerOrderStrategy , който се възползва от графичната структура на мрежата, използвайки различни методи за обхождане на графики. Някои примери включват стратегия за ширина и насочване на определен слой . Редът всъщност се определя от връзките между слоевете, така че стратегиите връщат подреден списък с връзки.
2. Изчислете стойността на активиране. Всеки слой има асоцииран ConnectionCalculator който взема списък от връзки (от предишната стъпка) и входни стойности (от други слоеве) и изчислява полученото активиране. Например, в проста сигмоидална мрежа за пренасочване, скритият слой ConnectionCalculator приема стойностите на входния и пристрастния слой (които съответно са входните данни и масив от 1s ) и тежестите между единиците (в случай на напълно свързани слоеве тежестите всъщност се съхраняват в Напълно Свързан връзка като a Матрица ), изчислява претеглената сума и подава резултата във сигмоидната функция. Калкулаторите за връзка изпълняват различни функции за прехвърляне (напр. Претеглена сума, конволюционно) и активиране (например логистика и tanh за многослоен персептрон, двоичен за RBM). Повечето от тях могат да бъдат изпълнени на графичен процесор Апарапи и може да се използва с мини-партидно обучение.

GPU изчисление с Aparapi

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

Aparapi налага някои важни ограничения върху калкулаторите за връзка:

• Разрешени са само едномерни масиви (и променливи) от примитивни типове данни.
• Само методи на членове на Aparapi Ядро самия клас е позволено да се извиква от изпълнимия код на GPU.

Като такива, повечето от данните (тегла, входни и изходни масиви) се съхраняват в Матрица екземпляри, които използват едномерни поплавъчни масиви вътрешно. Всички калкулатори за свързване на Aparapi използват и двете AparapiWeightedSum (за напълно свързани слоеве и функции за въвеждане на претеглена сума), AparapiSubsampling2D (за подпробни слоеве), или AparapiConv2D (за конволюционни слоеве). Някои от тези ограничения могат да бъдат преодолени с въвеждането на Хетерогенна архитектура на системата . Aparapi също така позволява да се изпълнява един и същ код както на CPU, така и на GPU.

Обучение

The обучение модул реализира различни обучителни алгоритми. Разчита на предишните два модула. Например, BackPropagationTrainer (всички обучители използват Треньор базов клас) използва калкулатор на захранващия слой за фазата на пренасочване и специален калкулатор на първия слой за разпространение на грешката и актуализиране на тежестите.

Последната ми работа е върху поддръжката на Java 8 и някои други подобрения, които скоро ще бъдат обединени майстор .

Заключение

Целта на този урок за дълбоко обучение на Java беше да ви даде кратко въведение в областта на алгоритмите за дълбоко обучение, започвайки с най-основната композиционна единица (персептрона) и прогресирайки чрез различни ефективни и популярни архитектури, като тази на ограничен Boltzmann машина.

Идеите зад невронните мрежи съществуват отдавна; но днес не можете да стъпите в общността за машинно обучение, без да чуете за дълбоки мрежи или някакъв друг подход за задълбочено обучение. Hype не бива да се бърка с обосновка, но с напредъка на GPGPU изчисленията и впечатляващия напредък, постигнат от изследователи като Geoffrey Hinton, Yoshua Bengio, Yann LeCun и Andrew Ng, полето със сигурност дава много обещания. Няма по-подходящо време да се запознаете и да се включите като настоящето.

Приложение: Ресурси

Ако се интересувате да научите повече, намерих следните ресурси, които са много полезни по време на моята работа:

• DeepLearning.net : портал за всички неща дълбоко обучение. Има някои хубави уроци , софтуерна библиотека и страхотно списък за четене .
• Активен Общност в Google+ .
• Два много добри курса: Машинно обучение и Невронни мрежи за машинно обучение , и двете предлагани на Coursera.
• The Урок за невронни мрежи в Станфорд .

Свързани: Училище Flappy Bird: Учебен урок за подсилване