Teskari tarqalishli neyronlarni (kitobda 7-bob) kelgusi mavzuda kiritasizmi? Agar kelgusi mavzuga kiritmasangiz shu mavzuning oxiridan kiritish kerak

Delta qoidasi - bu xato yuzasiga gradiyent tushish prinsipiga asoslangan neyronni tayyorlash usuli.


13.5. Katta hajmli ma'lumotlarni tanib olishni dasturi

Ushbu paragrafda biz kirish va neyronlarning tarmoqlarini ko'rib chiqamiz. Bunday tarmoqlar yordamida biz ko'proq chiqadigan ma'lumotlarni taniy olamiz.

Bir nechta ma'lumotlarni qanday aniqlash mumkin
Hozirgacha biz chiziqli sinflash va faollashtirish funksiyalari yordamida faqat bitta ma'lumot turini boshqalardan ajratish yoki tanib olish masalasini qaradik. Agar neyron tarmoq yordamida faqat 0 raqamini emas (13.11 –rasm), balki 1 raqamini ham tanib olish masalasini qarasak (13.12 –rasm), u holda neyron tarmoq qanday quriladi. Mantiqiy nuqtai-nazardan qaraydigan bo’lsak, u holda o raqamini taniydigan neyron kabi 1 raqamini taniydigan ikkinchi neyronni hosil qilishimiz kerak:

13.11–rasm. neyron tarmoq yordamida faqat 0 raqamini tanib olish.

13.12 –rasm. neyron tarmoq yordamida faqat 1 raqamini tanib olish.
Ular (13.11 va 13.12–rasmlar) bir vaqtning o'zida bir xil ma'lumotlarni hosil qiladi, shuning uchun ularni birlashtirish mantiqan to'g'ri bo'ladi (13.13 –rasm).

13.13 –rasm. Bir vaqtning o'zida bir xil ma'lumotlarni hosil qiladi, shuning uchun ularni birlashtirish.
13.13 –rasmda neyronlarning kirishlari umumiy va vaznlari turli xil bo’ladi. Har bir koeffitsientning o'ziga xos identifikatsiya raqami mavjud bo'lib, u qaysi kirishga tegishli ekanligini bildiradi. Bunday koeffitsientlar to'plamini ikki o'lchovli qator shaklida ifodalash qulay hisoblanadi, bu erda koeffitsient raqamlari elementlar manzillaridan iborat bo'ladi.
Matritsa amallari
Endi neyron tarmoqlarda matritsa ustida amallar bajarishni 4-mavzuda qarab chiqqanmiz.
Matritsalardagi amallar bizga qanday yordam berishi mumkin? Keling, soddalik uchun ikkita kirish va ikkita neyron borligini tasavvur qilaylik. Har bir kirish signal o'tadigan har bir neyron bilan bitta aloqaga ega bo’ladi. Ushbu ulanish turi to'liq ulanish deb nomlanadi (13.14 –rasm):

13.14 –rasm. To'liq ulanish.
Ushbu iborani yanada ixcham shaklda yozish mumkin:
O = W * I.
Bu erda W-vaznlar matritsasi, I - kirish ma'lumotlari matritsasi, O esa neyronlarning umumiy yig'indisi matritsasi.
Ta’kidlaymizki, vazn ko'rsatkichlarining indeks raqamlanishi biroz o'zgarganligini ko’ramiz. Endi n indeks (satr raqami) - bu bog'lanish qaysi neyron bilan o'rnatilishini va m indeks (ustun raqami) - kirish ma'lumotlari raqamining indeksini bildiradi.
Neyronlarga qancha aloqa kelishi haqida qayg'urishingizga hojat yo'q. Kirishning ko'payishi ustunlardagi matritsa hajmining oshishiga olib keladi. Va neyronlar sonining ko'payishi matritsa hajmining qatorlar bo'yicha o'sishiga olib keladi.
Shunday qilib, matritsani ko'paytirish yordamida osonlikcha biz neyronlarda umumiy yig’indini hisoblashimiz mumkin.
Misol. Keling, bir nechta chiqish ma'lumotlarini, ya'ni bizning kirish ma'lumotlar to'plamimizdan nafaqat 0 raqamini, balki 1 raqamini ham taniy oladigan dasturni yozaylik. Buning uchun biz test tanlanmasidagi ma'lumotlarni to'ldiramiz, ya’ni 0 ning oltita sinov qiymatidan tashqari yana 1 ning oltita sinov qiymati bilan qo'shimcha ravishda to’ldiramiz:

Bunday tarmoqning tuzilishi oldin ham qaralgan, ammo vaznlarni raqamlash o'zgarishini hisobga olgan holda yana bir bor qaraymiz (13.15-rasm):

13.15-rasm. Vaznlarni raqamlash o'zgarishini hisobga olish.
Dasturda vazn massivlarini sinf konstruktorida yaratish qulay. Buning uchun neyron_Net sinfini yaratish va uning konstruktoridagi parametrlarni ishga tushiring (__init__):
# Neyron tarmog'ining sinfini aniqlash
sinf neyron_Net:
# NTlarining vaznlarini belgilash
def __init __ (self, input_num, neuron_num, learningrate): # xususiyati (kirishlar soni, neyronlar soni)
# VAZNLAR MATRITSASI
# Vazn matritsasini tasodifiy ravishda -0,5 dan 0,5 gacha berish
self.weights = (np.random.rand (neyron_num, input_num) -0.5)
# O'qish tezligi parametrini o’rnatish
self.lr = learningrate
pass
Bu erda np.random.rand (neuron_num, input_num) -0.5) funksiyasidan foydalanib, vaznlarning qiymatini -0,5 dan 0,5 gacha o'rnatdik. Keyin, biz ushbu qiymatlarni o'zgaruvchiga ta’minlaymiz.
Shundan so'ng, bu erda (sinfda) biz tarmoqni o'qitish uchun usul (sinf funksiyasi) yaratamiz:
# Neyron tarmog'ini o'qitish usuli
def train (self, inputs_list, targets_list): # oladi (kirish ma'lumotlar ro'yxati, javoblar)
# Kirishlar ro'yxatini vertikal qatorga o'zgartirish. .T - transponirlash
inputs_x = np.array (inputs_list, ndmin = 2) .T # sonli matritsa
targets_Y = np.array (targets_list, ndmin = 2) .T # javoblar matritsasi: bu raqam nima
# SIGNALLARNI HISOBLASH
# Neyronlardagi signallarni hisoblash. Vaznlar yig’indisi.
x = np.dot (self.weights, inputs_x) # dot - matritsani ko'paytirish X = W * I = weights * inputs
# Neyrondan chiqadigan signallarni hisoblash. Faollashtirish funksiyasi - sigmoid (x)
y = 1 / (1 + np.exp (-x))
# XATOLARNI HISOBLASH
# Xatolik E = - (maqsad - haqiqiy qiymat)
E = -(targets_Y – y)
# VAZNNI YANGILASH
# Har bir aloqa bo’yicha vaznlarni o'zgartiramiz
self.weights -= self.lr * np.dot((E * y * (1.0 – y)), np.transpose(inputs_x))
pass
Np.array (inputs_list, ndmin = 2) .T va np.array (targets_list, ndmin = 2) .T funksiyalari mos ravishda kirish vektorini va chiqish qiymatlari vektorini aylantiradi. Buning nima uchun kerakligini tushunish uchun matritsalarda ishlash bo'yicha bilimlarni biroz ko'proq to'ldirish kerak bo’ladi. Biz matritsani transponirlash kabi harakatlar bilan tanishishimiz kerak.
Matritsaning yuqorisidagi "T" belgisi berilgan matritsaning transponirlanganligini anglatadi. Transponirlash jarayonining o'zi matritsadagi qatorlarni ustunlar bilan yoki ustunlarni qatorlar bilan almashtirishdan iborat.
Transponirlash jarayonidan so'ng kirish va chiqish ma'lumotlari o'qilishi oson shaklda, aniqrog'i vertikal qatorlarda keltirilgan bo'lib, ular bilan kelajakda ishlashimiz oson bo'ladi.
Kirish ma'lumotlariga vaznlar matritsasini ko'paytirish jarayonini qo'llash natijasida biz summatorda umumiy yig’indi qiymatlarini olishimiz mumkin:

qoidalarga ko'ra, uning argumentlarida joylashgan matritsalarni ko'paytiradi.
Keyin, xuddi oldingi dasturda bo'lgani kabi, biz faollashtirish funksiyasini umumiy yig’indi - y = 1/1 + np.exp (-x) ga qo'llash orqali chiqish qiymatlarini topamiz. Keyinchalik, biz chiqishlarimizdagi xatoni hisoblaymiz - E = - (maqsadlar_Y - y), so'ngra vazn koeffitsientlarini yangilaymiz - self.weights -= self.lr * np.dot((E*y*(1.0 – y)), np.transpose(inputs_x)).
Agar oxirgi np.dot ((E * y * (1.0 - y)), np.transpose (inputs_x)) ifodanini aniqroq ko'rib chiqsak, u holda y va (1 - y) matritsalar ko’paytmasining E xatoligi elementlararo bajariladi:

Ushbu matritsaning natijasi kirish ma'lumotlari matritsasi bilan ko'paytiriladi. Bizga ma’lumki, matritsani ko'paytirish qoidasiga ko'ra, birinchi matritsadagi ustunlar soni ikkinchi matritsadagi qatorlar soniga teng bo'lishi kerak. Buning uchun biz kirish matritsasini transponirlashimiz kerak.

Ushbu transponirlashni - .transpose () usuli bilan amalga oshiriladi. Va np.transpose (inputs_x) ifodasi, kirish matritsasini transponirlaydi. Bunda butun ifoda np.dot ((E * y * (1.0 - y)), np.transpose (inputs_x)), o'zaro argumentlarni (matritsalarni) ko'paytiradi:

Ushbu natija o'rganish tezligiga ko'paytiriladi va vazn koeffitsiyentlari yangilanadi - self.weights - = self.lr * np.dot ((E * y * (1.0 - y)), np.transpose (inputs_x)).
Bu erda biz sinfda chiqishdagi natijalarni qaytaradigan test qiymatlarini tarmoq orqali o'tkazish usulini yaratamiz:
# Sinov qiymatini ishlatish usuli
def so'rovi (self, inputs_list): # O'zining sinov ma’lumotlar naborini qabul qiladi
# Kirishlar ro'yxatini vertikal 2 o'lchovli qatorga o'tkazish.
inputs_x = np.array (inputs_list, ndmin = 2) .T
# Neyronlardagi signallarni hisoblash. Vaznlar yig’indisi.
x = np.dot(self.weights, inputs_x)
# Neyrondan chiqadigan signallarni hisoblash. Sigmoid (x)
y = 1 / (1 + np.exp (-x))
return y
Keyin biz tarmoq parametrlarini o'rnatamiz:
# Kirish ma'lumotlari soni, neyronlar
data_input = 15
ma'lumotlar_neuron = 2
# O'quv tezligi
learningrate = 0.1
# NT nusxasini yaratish
n = neyron_Net (data_input, data_neuron, learningrate)
Va biz uni o'qitamiz:
# Davrlar sonini o’rnatish
davrlar = 40000
# O'quv tanlanmasi bo'yicha ishlash
for e in range(epochs):
for i in training_data_list:
# Raqamning kirish ma’lumotlarini olish
all_values ​​= i.split (',') # split (',') - satrni belgilarga bo'ling, bu erda vergul "," bo'linadigan belgidir.
inputs_x = np.asfarray (all_values ​​[1:])
# Y maqsadli qiymatini olish, (javob qaysi raqam ekanligi)
targets_Y = int(all_values[0]) # belgilarni int ga o'tkazish, 0 element - javob
# maqsadli natijalarni yaratish (kerakli nishondan tashqari 0,01, ya'ni 0,99)
maqsadlar_Y = np.zeros (data_neuron) + 0.01
# Y maqsadli qiymatini olish, (javob qaysi raqam ekanligi). all_values ​​[0] - ushbu yozuv uchun maqsadli nishon
if int (all_values ​​[0]) <= 1: # maqsad <= 1, chunki biz faqat 0 va 1 raqamlarini taniymiz.
targets_Y[int(all_values[0])] = 0.99
n.train(inputs_x, targets_Y) # bizning usulimiz train - neyron tarmog'ini o'rgatishdir
Ushbu dasturda o'tgan kodning ko'p qismi saqlanib qolgan bo’lib, faqat oxirgi dasturda chiqish elementlari ikki element, ya’ni 0 va 1 raqamlaridan iborat. Boshida biz chiqadigan ma'lumotlarning nolli qatorini yaratamiz - targets_Y = np.zeros(data_neuron) + 0.01, so'ngra indeksga 0.99 qiymatini qo'yamiz, bu uning qaysi raqam ekanligini anglatadi. Masalan, agar bu raqam biz tanib olgan chegaralardan tashqarida bo'lsa, masalan, 3 raqami bo'lsa, unda if int(all_values[0]) <= 1 sharti maqsadli natijalarni beradi - targets_Y =([0.01,0.01]).T, ya'ni ikkalasi ham noto'g'ri javoblar. Agar bu biz tanigan raqamlardan biri bo'lsa, masalan 1, u holda if int(all_values[0]) <= 1 sharti bajariladi va maqsadli natija bo'ladi - targets_Y =([0.01,0.99]).T, ya'ni uning javobi 1. Va javob uning indeksida joylashgan bo'ladi. Aslida, qiymat joylashgan indeks raqami 0,99 ni tashkil qiladi va u bizga bu raqam nima ekanligini ko’rsatib beradi.
Minimal javoblar - 0,01 va maksimal - 0,99, agarda sigmasimon funksiya ishlatilsa - dastlab 0 yoki 1 bo'lmasligi kerak, chunki bu ma'lumotlarning yo'qolishiga olib kelishi mumkin.
Kirish ma'lumotlari va maqsadli qiymatlar bilan barcha kerakli o'zgarishlardan so'ng .train usulini chaqirib tarmoqni o'qitishga kirishamiz:
n.train(inputs_x, targets_Y)
An'anaga ko'ra, o’qitishdan so'ng olamizan natijalar quyidagicha:
# Chiqishdagi vaznlarning natijasi
print ('Vaznlar: \ n', n. weights)
# Keling, yana o’quv tanlanmasini ko'rib chiqaylik
for i in training_data_list:
all_values ​​= i.split (',') # split (',') - satrni belgilarga bo'ling, bu erda vergul "," bo'linadigan belgidir.
inputs_x = np.asfarray (all_values ​​[1:])
# Tarmoqni ishlashi
outputs = n.query(inputs_x)
print (i [0], 'Ehtimollik: \ n', outputs)
# Agar ehtimollik 0,5 dan katta bo'lsa va chiqish raqami javobga to'g'ri keladigan bo'lsa, unda tarmoq o'ziga xos chiqishi bo'yicha, raqamni tanidi.
for i in training_data_list:
all_values ​​= i.split (',') # split (',') - satrni belgilarga bo'lish, bu erda vergul "," bo'linadigan belgidir.
inputs_x = np.asfarray (all_values ​​[1:])
# Tarmoqni ishlashi
outputs = n.query(inputs_x)
# eng yuqori indeks nishonga to'g'ri keladi
label = np.argmax(outputs)
if outputs[label]>0.5 and int(all_values[0]) == label:
print (i [0], 'Bilasizmi?:', 'Ha!')
else:
print (i [0], 'Bilasizmi?:', 'Yo'q!')
# Sinov tanlanmasi bo’yicha tekshirish
t = 0 # Sinov tanlanmasi bo’yicha nol raqamli hisoblagich
t1 = 0 # Sinov tanlanmasi bo’yicha bir raqamli hisoblagich
for i in test_data_list:
all_values ​​= i.split (',') # split (',') - satrni belgilarga bo'ling, bu erda vergul "," bo'linadigan belgidir.
inputs_x = np.asfarray (all_values ​​[1:])
t + = 1
# Tarmoq bo’yicha ishlash
outputs = n.query(inputs_x)
# eng yuqori indeksga nishon to'g'ri keladi
label = np.argmax(outputs)
if t <= 6:
print ('Men 0 -', t, '?' ni o'rganganim ehtimolligi, outputs[label])
else:
t1 + = 1
print ('Men 1 -', t1, '?' ni o'rganganim ehtimolligi, outputs[label])
t = 0 # Sinov tanlanmasi bo’yicha nol raqamli hisoblagich
t1 = 0 # Sinov tanlanmasi bo’yicha bir raqamli hisoblagich
# Agar ehtimollik 0,5 dan katta bo'lsa va chiqish raqami javobga to'g'ri keladigan bo'lsa, unda biz tarmoq,
# o'ziga xos chiqishi bo'yicha, raqamni tanidi.
for i in test_data_list:
all_values ​​= i.split (',') # split (',') - satrni belgilarga bo'ling, bu erda vergul "," bo'linadigan belgidir.
inputs_x = np.asfarray (all_values ​​[1:])
# Tarmoq bo’yicha ishlash
outputs = n.query(inputs_x)
# eng yuqori indeks nishonga to'g'ri keladi
label = np.argmax(outputs)
t += 1
if outputs[label]>0.5 and int(all_values[0]) == label:
print (i [0], 'Aniqlanganmi ?:', t, 'Ha!')
else:
# Agar ehtimollik 0,5 dan katta bo'lsa va chiqish raqami javobga to'g'ri keladigan bo'lsa, unda tarmoq o'ziga xos chiqishi bo'yicha, raqamni tanidi.
t1 += 1
print(i[0], ' Aniqlanganmi?:',t1, 'Нет!')
O’rgatuvchi va sinov tanlanmadan o'tish davomida biz avval raqamni (tarmoq javoblari) tanib olish ehtimolligini aniqlaymiz, so'ngra shart bo'yicha: agar bu javoblar 0,5 dan katta va tarmoq javob natijalari matritsasining maksimal son ko'rsatkichi maqsadli qiymatlar matritsasi javob indeksiga teng bo'lsa, u holda tarmoq raqamni taniydi, aks holda u tanimaydi.