Guruh talabasi imomaliyer Mirjalol

Neyron tarmoqlarni o'qitish turlari
Sun'iy neyron tarmoq odatda o'qituvchi bilan, ya'ni nazorat qilinadigan usullar bilan o'qitiladi . Bu haqiqiy qiymatlarga ega bo'lgan misollarni o'z ichiga olgan o'quv majmuasi (ma'lumotlar to'plami) mavjudligini anglatadi: teglar, sinflar, ko'rsatkichlar.
Neyron tarmoqlarni o'rgatish uchun ajratilmagan to'plamlar ham qo'llaniladi va buning uchun tegishli nazoratsiz usullar ishlab chiqilgan.
Sun'iy neyron tarmoq uchta komponentdan iborat: kirish qatlami, yashirin (hisoblash) qatlamlari va chiqish qatlami.
Trening qatlamlardagi har bir neyron uchun koeffitsientlarni tanlashdan iborat bo'lib, ma'lum kirish signallari bilan biz kerakli chiqish signallari to'plamini olamiz.
Neyron tarmoqlar ikki bosqichda o'qitiladi: xatoning to'g'ridan-to'g'ri tarqalishi va xatoning teskari tarqalishi.
Neyron tarmog'idagi o'rganish usullari berilgan kirishlar bilan kerakli chiqish parametrlariga erishish uchun har bir neyron uchun og'irliklarni o'zgartirishga asoslangan. Ushbu usullar neyron tarmoqdagi xato qatlamini minimallashtiradi.
Xatolarni oldinga yo'naltirish vaqtida javobning bashorati amalga oshiriladi. Masalan, ikkita kirish, uchta neyron va bitta chiqishga ega neyron tarmoqlar uchun biz boshlang'ich og'irliklarni tasodifiy belgilashimiz mumkin: w1, w2. Yashirin qatlam hosil qilish uchun kirishni og'irliklarga ko'paytiring:
h1 = (x1 * w1) + (x2 * w1)
h2 = (x1 * w2) + (x2 * w2)
h3 = (x1 * w3) + (x2 * w3)
Yashirin qatlamdan chiqish tarmoq chiqishini olish uchun chiziqli bo'lmagan funksiya (faollashtirish funktsiyasi) orqali uzatiladi:
y = f (h1, h2, h3)
Orqaga tarqalish bilan haqiqiy javob va taxmin qilingan javob o'rtasidagi xatolik minimallashtiriladi.

Orqaga tarqalish bitta kirish-chiqish misoli uchun tarmoqning og'irligiga nisbatan yo'qotish funksiyasining gradientini samarali hisoblaydi. Bu ko'p qatlamli tarmoqlarni o'qitish, yo'qotishlarni minimallashtirish uchun og'irliklarni yangilash uchun gradient usullaridan foydalanish imkonini beradi. Gradient tushishi yoki stokastik gradient tushishi kabi variantlar odatda qo'llaniladi.
min (yo'qotish_qiymati = (y)2 - (y')2)
Umumiy xatolik y ning kutilayotgan qiymati (o‘quv majmuasidan) va olingan y’ qiymati (xatoning to‘g‘ridan-to‘g‘ri tarqalish bosqichida hisoblangan) xarajat funksiyasidan o‘tuvchi farq sifatida hisoblanadi. Xatoning qisman hosilasi har bir og'irlik uchun hisoblanadi (bu qisman farqlar har bir vaznning umumiy yo'qotishga qo'shgan hissasini aks ettiradi.
Keyin bu farqlar o'rganish tezligi (ē) deb ataladigan raqamga ko'paytiriladi. Keyin natija mos keladigan og'irliklardan chiqariladi. Natijada quyidagi yangilangan og'irliklar:
w1 = w1 - (ē * ∂ (yo'qotish qiymati) / ∂ (w1))
w2 = w2 - (ē * ∂ (yo'qotish qiymati) / ∂ (w2))
w3 = w3 - (ķ * ∂ (yo'qotish qiymati ) ) / ∂ (w3))
Og'irliklarni tasodifiy qabul qilishimiz va ishga tushirishimiz va ular to'g'ri javob berishlari juda mantiqiy tuyulmaydi; ammo, u yaxshi ishlaydi.
Murakkab neyron tarmog'i arxitekturalari uchun boshlang'ich nuqtani tanlash juda qiyin vazifadir, ammo ko'p hollarda dastlabki taxminiylikni tanlash uchun tasdiqlangan texnologiyalar mavjud.
Bundan tashqari, tarmoqni o'qitish hozirda butun ma'lumotlar to'plamida emas, balki ma'lum o'lchamdagi, partiyalar deb ataladigan namunalar bo'yicha o'tkazilmoqda. Bu shuni anglatadiki, neyron tarmoqlardagi og'irliklar yaxshi natijalarga erishish uchun davrdan davrga sozlangan.
Neyron tarmog’ini ishlab chiqish
Oddiy neyron tarmog’ini amalga oshirish kodi:
import numpy as np

# Sigmoid funksiyasi

# Og’irliklar qiymatlarini aniqlash uchun zarur
def sigmoid(x, der=False):
if der:
return x * (1 - x)
return 1 / (1 + np.exp(-x))

# Kiruvchi ma’lumotlar to’plami

x = np.array([[1, 0, 1],
[1, 0, 1],
[0, 1, 0],
[0, 1, 0]])

# Chiquvchi ma’lumotlar

y = np.array([[0, 0, 1, 1]]).T

# Tasodifiy sonlarni nisbatan aniqroq qilamiz

np.random.seed(1)

# Og’irliklarni tasodifiy tarzda o;rtacha 0 ga initsiallashtiramiz

syn0 = 2 * np.random.random((3, 1)) - 1

l1 = []
for iter in range(10000):

# To’g’ri tarqatish
l0 = x
l1 = sigmoid(np.dot(l0, syn0))
# Biz qanchalik xato qildik?
l1_error = y - l1
# Uni sigmoid og’ishiga ko’paytiramiz
# 11 qiymatlari asosida
l1_delta = l1_error * sigmoid(l1, True)
# Og’irliklarni yangilaymiz
syn0 += np.dot(l0.T, l1_delta)
print("Mashqdan keyingi chiquvchi ma’lumotlar:")
print(l1)