Bitta neyron va qaror chegarasi - Neyron tarmoqlar - noldan

Bitta neyron matematik jihatdan juda oddiy narsa qiladi: tekislikni ikkiga bo'ladi. Bu bo'linishni ko'rish - tarmoqni tushunishning eng qisqa yo'li.

Neyron chiziq chizadi #

Ikkita kirishli neyronni olamiz:

Natija

z = x₁·w₁ + x₂·w₂ + b

z > 0 bo'lganda neyron "ha", z < 0 bo'lganda "yo'q" deydi. z = 0 esa - chegara.

Python

import numpy as np

Python

ogirliklar = np.array([1.0, 1.0])
siljish = -1.5

nuqtalar = np.array([
    [0.0, 0.0],
    [1.0, 0.0],
    [0.0, 1.0],
    [1.0, 1.0],
])

z = nuqtalar @ ogirliklar + siljish
qaror = (z > 0).astype(int)

for nuqta, zq, q in zip(nuqtalar, z, qaror):
    print(f"({nuqta[0]:.0f}, {nuqta[1]:.0f})  z = {zq:>5.1f}  qaror = {q}")

Natija

(0, 0)  z =  -1.5  qaror = 0
(1, 0)  z =  -0.5  qaror = 0
(0, 1)  z =  -0.5  qaror = 0
(1, 1)  z =   0.5  qaror = 1

Bu neyron VA (AND) mantiqiy amalini bajardi: faqat ikkala kirish ham 1 bo'lganda 1 qaytardi.

Bitta neyron - bitta to'g'ri chiziq, boshqa hech nima

Og'irliklar chiziqni buradi #

Python

def qaror_chizigi(w1, w2, b, nuqtalar):
    z = nuqtalar @ np.array([w1, w2]) + b
    return (z > 0).astype(int)

nuqtalar = np.array([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]])

print("VA  (w=[1,1], b=-1.5):", qaror_chizigi(1.0, 1.0, -1.5, nuqtalar))
print("YOKI(w=[1,1], b=-0.5):", qaror_chizigi(1.0, 1.0, -0.5, nuqtalar))
print("EMAS x1 (w=[-1,0], b=0.5):", qaror_chizigi(-1.0, 0.0, 0.5, nuqtalar))

Natija

VA  (w=[1,1], b=-1.5): [0 0 0 1]
YOKI(w=[1,1], b=-0.5): [0 1 1 1]
EMAS x1 (w=[-1,0], b=0.5): [1 0 1 0]

Uchta mantiqiy amal - bir xil neyron, faqat uchta son o'zgardi.

Siljish chiziqni ko'chiradi, og'irliklar buradi

O'zgarish	Chiziqqa ta'siri
`b` ni oshirish	Chiziq markazga yaqinlashadi - ko'proq "ha"
`b` ni kamaytirish	Chiziq uzoqlashadi - kamroq "ha"
`w` ni ikki barobar	Chiziq o'zgarmaydi, faqat `z` kattalashadi
`w` belgisini almashtirish	Chiziqning tomonlari almashadi

Uchinchi qator qiziq: w va b ni birga ikki barobar oshirsangiz, qaror umuman o'zgarmaydi - chunki z > 0 sharti uchun faqat ishora muhim.

Lekin z ning kattaligi 4-bo'limdagi faollashtirish funksiyasi uchun juda muhim bo'lib chiqadi.

Python

nuqtalar = np.array([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]])
w = np.array([1.0, 1.0])
b = -1.5

z_oddiy = nuqtalar @ w + b
z_katta = nuqtalar @ (w * 10) + b * 10

print("z oddiy:", z_oddiy)
print("z katta:", z_katta)
print("qarorlar bir xilmi:", np.array_equal(z_oddiy > 0, z_katta > 0))

Natija

z oddiy: [-1.5 -0.5 -0.5  0.5]
z katta: [-15.  -5.  -5.   5.]
qarorlar bir xilmi: True

XOR - bitta neyron uddalay olmaydi #

Python

nuqtalar = np.array([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]])
xor_javob = np.array([0, 1, 1, 0])

gen = np.random.default_rng(0)
eng_yaxshi = 0
for _ in range(20000):
    w = gen.uniform(-5, 5, 2)
    b = gen.uniform(-5, 5)
    togri = int((((nuqtalar @ w + b) > 0).astype(int) == xor_javob).sum())
    eng_yaxshi = max(eng_yaxshi, togri)

print("20000 tasodifiy urinishdan eng yaxshisi:", eng_yaxshi, "/ 4")

Natija

20000 tasodifiy urinishdan eng yaxshisi: 3 / 4

Yigirma ming tasodifiy chiziq sinaldi - hech biri to'rttadan to'rttasini to'g'ri ajrata olmadi.

Bu tasodif emas, isbotlangan chegara

XOR ni bitta neyron hech qachon yecha olmaydi - bu 1969 yilda Minsky va Papert tomonidan matematik isbotlangan.

Sabab oddiy: neyron faqat bitta to'g'ri chiziq chiza oladi. XOR ning ijobiy nuqtalari esa (1,0) va (0,1) - ular diagonalda joylashgan va ular orasida (0,0) bilan (1,1) turibdi.

Qog'ozga chizib ko'ring: bu ikki nuqtani qolgan ikkitasidan ajratadigan to'g'ri chiziq mavjud emas.

Bu kashfiyot neyron tarmoqlar tadqiqotini deyarli o'n besh yilga to'xtatib qo'ydi - "AI qishi" deb ataladigan davr.

Yechim esa juda oddiy bo'lib chiqdi: ikkinchi qatlam qo'shish. Uni 12-bo'limda quramiz.

Bir necha namunani birdan hisoblash #

Python

namunalar = np.array([
    [2.0, 1.0],
    [-1.0, 3.0],
    [0.5, -2.0],
    [4.0, 0.0],
])
w = np.array([0.6, -0.4])
b = 0.1

z = namunalar @ w + b
print("z:", np.round(z, 2))
print("shakl:", namunalar.shape, "->", z.shape)

Natija

z: [ 0.9 -1.7  1.2  2.5]
shakl: (4, 2) -> (4,)

To'rtta namuna bitta @ amali bilan hisoblandi. Bu naqsh butun darslikda takrorlanadi:

Shakl	Ma'nosi
`(N, K)`	N ta namuna, har birida K ta belgi
`(K, M)`	K ta kirish, M ta neyron
`(N, M)`	Har namuna uchun har neyronning chiqishi

Neyronni funksiya sifatida yozish #

Python

def neyron(X, w, b):
    """Chiziqli qism: har namuna uchun z qiymati."""
    return X @ w + b

X = np.array([[2.0, 1.0], [-1.0, 3.0]])
w = np.array([0.6, -0.4])
b = 0.1

print(np.round(neyron(X, w, b), 3))

Natija

[ 0.9 -1.7]

Kodni funksiyaga bo'lish - tasodifiy emas

Butun darslikda bir xil tuzilma ishlatiladi:

Funksiya	Vazifasi
`oldinga(...)`	Kirishdan chiqishga (5-bo'lim)
`yoqotish(...)`	Xatoni o'lchash (6-bo'lim)
`orqaga(...)`	Gradientlarni hisoblash (9-bo'lim)
`yangilash(...)`	Og'irliklarni o'zgartirish (8-bo'lim)

Har bir kutubxona - PyTorch ham, TensorFlow ham - aynan shu to'rtta qadamdan iborat. Ularning nomlari boshqacha (forward, loss, backward, step), lekin mohiyati bir xil.

Shuning uchun bu darslikni tugatgan odam istalgan kutubxona hujjatini tanish tuzilma sifatida o'qiy oladi.

Chegaraga qanchalik yaqin #

z ning qiymati faqat "ha yoki yo'q" emas - u ishonch darajasini ham bildiradi.

Python

namunalar = np.array([[1.0, 1.0], [0.1, 0.2], [1.5, 1.5]])
w = np.array([1.0, 1.0])
b = -0.3

z = namunalar @ w + b
for n, zq in zip(namunalar, z):
    holat = "chegaradan uzoq" if abs(zq) > 0.5 else "chegaraga YAQIN"
    print(f"({n[0]:.1f}, {n[1]:.1f})  z = {zq:>5.2f}  {holat}")

Natija

(1.0, 1.0)  z =  1.70  chegaradan uzoq
(0.1, 0.2)  z =  0.00  chegaraga YAQIN
(1.5, 1.5)  z =  2.70  chegaradan uzoq

Ikkinchi namuna aynan chegarada ko'rinadi: 0.1 + 0.2 - 0.3 matematik jihatdan aniq nol.

Lekin u aslida nol emas:

Python

a = 0.1 + 0.2 - 0.3
print("qiymat:", repr(a))
print("a == 0:", a == 0)
print("np.isclose(a, 0):", bool(np.isclose(a, 0)))

Natija

qiymat: 5.551115123125783e-17
a == 0: False
np.isclose(a, 0): True

Suzuvchi sonlarni == bilan solishtirmang

0.1 va 0.2 ikkilik sanoq sistemasida aniq ifodalanmaydi - ular eng yaqin ikkilik kasr bilan almashtiriladi. Yig'indi esa 0.3 ning ikkilik nusxasidan juda kichik miqdorda farq qiladi.

Natijada z == 0 False beradi, garchi ekranda 0.00 ko'rinsa ham.

Diqqat qiling: bu har doim shunday emas. 0.9 + 0.9 - 1.8 esa aniq 0.0 beradi - chunki u yerda xatolar bir-birini qoplaydi. Ya'ni "suzuvchi sonlar hech qachon aniq emas" degan qoida ham noto'g'ri.

To'g'ri qoida: ishonmang va tekshirmang.

Noto'g'ri	To'g'ri
`z == 0`	`abs(z) < 1e-9`
`a == b`	`np.isclose(a, b)`
`(a == b).all()`	`np.allclose(a, b)`

Darslikdagi barcha tekshiruvlarda np.allclose ishlatiladi - aynan shu sababdan.

Python

print("0.1 + 0.2 - 0.3 == 0 :", 0.1 + 0.2 - 0.3 == 0)
print("0.9 + 0.9 - 1.8 == 0 :", 0.9 + 0.9 - 1.8 == 0)

Natija

0.1 + 0.2 - 0.3 == 0 : False
0.9 + 0.9 - 1.8 == 0 : True

Bir xil ko'rinishdagi ikkita ifoda, ikki xil natija - va ikkalasi ham "to'g'ri". Shuning uchun taxmin qilmang.

Amaliy topshiriq

w=[1,1], b=-1.5 bilan VA amalini takrorlang.
b ni -0.5 ga o'zgartiring - qaysi amal chiqdi?
w ni manfiy qilib, natijaning teskarilanishini ko'ring.
w va b ni 10 barobar oshiring - qaror o'zgardimi?
XOR uchun tasodifiy chiziqlarni sinang - eng yaxshi natija nechta?
Nima uchun bitta neyron XOR ni yecha olmasligini tushuntiring.
To'rtta namunani bitta @ bilan hisoblang va shakllarni chop eting.
neyron(X, w, b) funksiyasini yozing.
Chegaraga eng yaqin namunani abs(z) bo'yicha toping.
0.1+0.2-0.3 va 0.9+0.9-1.8 ni nol bilan solishtiring.

Xulosa #

Bitta neyron - bitta to'g'ri chiziq, boshqa hech nima.
z > 0 - "ha", z < 0 - "yo'q", z = 0 - chegara.
Siljish chiziqni ko'chiradi, og'irliklar uni buradi.
w va b ni birga kattalashtirish qarorni o'zgartirmaydi.
VA, YOKI, EMAS - bitta neyron bilan yechiladi.
XOR yechilmaydi - bu isbotlangan chegara, sozlama muammosi emas.
Yechim - ikkinchi qatlam (12-bo'lim).
(N, K) @ (K, M) -> (N, M) - butun darslikning asosiy naqshi.
z ning kattaligi ishonch darajasini bildiradi.
0.1+0.2-0.3 nolga teng emas, 0.9+0.9-1.8 esa teng - taxmin qilmang.

Keyingi bo'limda faollashtirish funksiyalarini ko'ramiz - aynan ular chiziqli neyronni egri qiladi.

Neyron chiziq chizadi #

Og'irliklar chiziqni buradi #

XOR - bitta neyron uddalay olmaydi #

Bir necha namunani birdan hisoblash #

Neyronni funksiya sifatida yozish #

Chegaraga qanchalik yaqin #

Xulosa #

Xatolik topdingizmi?