Интерактивен учебник по информатика

От таблицата към програмата

В миналия час попълнихте на ръка осем стъпки от обучението на И и спряхте. Компютърът може да продължи — и да покаже след колко епохи грешките изчезват. Днес правилото на перцептрона става програма на C#. Няма нищо ново откъм езика: масиви, цикъл for, две условия и два метода — както в Модул 1.

Програмата е първата в модула, която се учи: не ѝ казваме кои са теглата за И, а ѝ даваме четирите примера и тя ги намира.

Как е устроена програмата

Примерите — три масива

static int[] x1 = { 0, 0, 1, 1 };   // първи вход
static int[] x2 = { 0, 1, 0, 1 };   // втори вход
static int[] y  = { 0, 0, 0, 1 };   // етикет (очакван изход) — това е И

Пример номер i е x1[i], x2[i] с етикет y[i]. Масивите са static, за да са достъпни от всички методи. Смените ли масива y, сменяте задачата — програмата не знае, че учи И.

Теглата — три променливи

static int w1 = 1, w2 = 1, b = 0;   // начални тегла
static int skorost = 1;

Работим с цели числа — при входове 0 и 1 и скорост 1 всички тегла остават цели и изходът е точно този, който сметнахте на хартия.

Изходът на неврона — метод

static int Izhod(int a, int c)
{
    int z = w1 * a + w2 * c + b;
    if (z > 0) return 1;
    return 0;
}

Точно формулата от урок 16: претеглена сума и праг. Методът връща 0 или 1.

Една епоха — метод

static int Epoha()
{
    int greshki = 0;
    for (int i = 0; i < y.Length; i++)
    {
        int greshka = y[i] - Izhod(x1[i], x2[i]);
        if (greshka != 0)
        {
            w1 = w1 + skorost * greshka * x1[i];
            w2 = w2 + skorost * greshka * x2[i];
            b  = b  + skorost * greshka;
            greshki++;
        }
    }
    return greshki;
}

Цикълът минава през всички примери. За всеки смята грешката очакван − получен и ако не е нула, поправя теглата по правилото на перцептрона. Методът връща колко грешки е имало в епохата — това число решава кога да спрем.

Главният цикъл

for (int e = 1; e <= 20; e++)
{
    int greshki = Epoha();
    Console.WriteLine($"Епоха {e}: w1={w1} w2={w2} b={b} грешки={greshki}");
    if (greshki == 0) break;
}

Двете условия за спиране от урок 17 са тук: break при нула грешки и най-много 20 епохи от цикъла for.

Какво да очаквате на екрана

Първата програма започва от теглата (1, 1, 0) — същите като в таблицата от миналия час. Първите два реда на изхода трябва да съвпадат с края на епоха 1 и епоха 2 от вашата таблица:

Епоха	w₁	w₂	b	Грешки
1	2	1	0	2
2	2	1	−1	3
3	2	2	−1	2
4	2	1	−2	1
5	2	1	−2	0

В епоха 5 няма грешки и цикълът спира. Забележете, че броят грешки не пада равномерно — в епоха 2 са повече, отколкото в епоха 1. Поправката за един пример разваля друг; чак след няколко обиколки всичко се намества.

Сходимост

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

Нов вход и обобщение

Втората програма обучава ИЛИ само върху три примера — (0,0), (0,1) и (1,0). Входът (1,1) нарочно го няма. След обучението питаме неврона за него. Това е обобщението от урок 15 на живо: отговор за вход, който не е бил сред примерите.

За ИЛИ невронът познава — научените тегла (1, 1, 0) дават 1 за (1,1). Но опитайте същото с етикети за И: трите примера са все с етикет 0, невронът не прави нито една грешка от самото начало и за новия вход отговаря 0. Грешно — и няма как да разбере. Примерите не са били достатъчно разнообразни.

Практикум: програмата се учи

Работете във Visual Studio с трите програми от раздела „Упражнения“. Първо пуснете всяка, както е дадена, и се уверете, че изходът съвпада с очаквания. После — задачите. Записвайте числата в тетрадката.

Задачи за в час

Пуснете първата програма. Сравнете редовете за епоха 1 и 2 с вашата таблица от миналия час. Съвпадат ли?
В първата програма сменете началните тегла на w1 = 0, w2 = 0, b = 0. Колко епохи трябват сега? А при w1 = 5, w2 = 5, b = 5? Запишете двете числа.
Във втората програма сменете етикетите на { 0, 0, 0 } (И върху три примера). След колко епохи спира и какво казва за (1,1)? Обяснете с една дума от урок 15 защо греши.
Във втората програма добавете четвъртия пример (1,1) с етикет 1 към трите масива. Променя ли се броят епохи? А ако разбъркате реда на примерите?
В третата програма вдигнете maxEpohi на 100. Променя ли се нещо в последния ред? Защо?
По желание: направете скоростта skorost = 3 в първата програма. Променя ли се броят епохи? Променят ли се крайните тегла?

За учителя: от нулеви тегла И се учи за 6 епохи, от (5, 5, 5) — за 4, до тегла (2, 2, −3). Трите примера с етикети 0 спират още в първата епоха без нито една поправка и невронът отговаря 0 за (1,1) — липсва разнообразие. С четвъртия пример ИЛИ пак се учи за 4 епохи. При XOR последният ред е същият и при 100, и при 1000 епохи. Скорост 3 върху И дава 8 епохи и тегла (7, 4, −9) — същата права, само мащабирана.

Какво трябва да запомниш

Програма, която се учи, има четири части: данни, модел (тегла + метод за изхода), обучение (епоха с поправки) и условие за спиране.
Примерите са масиви; етикетите са отделен масив — смени ли се той, сменя се задачата, не програмата.
Методът за епохата връща броя грешки; нула грешки означава сходимост и цикълът спира с break.
Броят епохи до сходимост зависи от началните тегла и от реда на примерите — не е свойство само на задачата.
За XOR грешките никога не стават нула — само предпазителят с максимален брой епохи спира програмата.