Простой перцептрон состоит из нескольких входов inp_t[1], inp_t[2] ... inp_t[n].
Каждому входу соответствует некий вес w[1], w[2] ... w[n].
Также имеется вход активации inp_b с весом w_b.
На вход активации постоянно подается единица, а вес на входе активации задает порог срабатывания перцептрона.
На выходе перцептрона может быть либо единица 1 либо -1 в зависимости от входных сигналов и весовых коэффициентов.
Условие срабатывания перцептрона ( когда на выходе появляется единица) :
w_b + w[1] * inp_t[1] + w[2] * inp_t[2] + ...+ w[n] * inp_t[n] > 0
Но можно и не различать входы inp_t и inp_b, а просто предположить, что у перцептрона есть еще один вход inp_t[0], на который всегда подается единица, а w_b записать как w[0].
Тогда условие срабатывания перцептрона можно записать так:
w[0] * inp_t[0] + w[1] * inp_t[1] + w[2] * inp_t[2] + ...+ w[n] * inp_t[n] > 0
Обучение перцептрона сводится к такому подбору весов w[0]...w[n] , при которых для всех
входных наборов данных (inp_t[1], inp_t[2] ... inp_t[n]), (inp_t[1], inp_t[2] ... inp_t[n]) ... (inp_t[1], inp_t[2] ... inp_t[n]), на выходе появлялось бы требуемое целевое значение out_t , соответствующее каждому входному набору.
Если реальное выходное значение перцептрона out_r отличается от требуемого целевого значения out_t, то необходимо подправить веса w[0]....w[n] перцептрона.
На каждом шаге обучения веса w[0]....w[n] должны изменяться в соответствии с правилом:
w[i] += t * (out_t - out_r) * inp_t[i]
где t - это небольшая константа (обычно 0,05 - 0,2) , которая задает скорость обучения.
Например обучим перцептрон логической функции дизъюнкции (операции ИЛИ).
inp_t[1] inp_t[2] out_t
0 0 -1
0 1 1
1 0 1
1 1 1
На вход алгоритму подаем скорость обучения t = 0,1
и входной вектор из четырех тестовых наборов [[0,0,-1],[0,1,1],[1,0,1],[1,1,1]]
в соответствии с таблицей истинности логической операции ИЛИ.
на выходе должны получить вектор весовых коэффициентов w[0]....w[n]
Алгоритм обучения простого перцептрона:
import random
def PerTrain(t, v):
w = []
# инициализируем начальные веса маленькими случайными значениями
for i in range(len(v[0])):
w.append((random.randrange(-5,5))/50.0)
chw = True
while (chw == True):
chw = False
for tst_n in v:
# получаем входные значения из тесового набора
# единицу добавляем для входа активации ( inp_t[0] = 1)
inp_t = [1] + tst_n[0:len(tst_n) - 1]
# получаем целевое выходное значение из тестового набора
out_t = tst_n[len(tst_n) - 1]
# реальное выходное значение будет вычислено позже
out_r = 0
# вычисляем выходное значение перцептрона (out_r)
for i in range(len(w)):
out_r += w[i] * inp_t[i]
if out_r > 0:
out_r = 1
else:
out_r = -1
if (out_r != out_t):
chw = True
# если на каком либо тестовом наборе перцептрон не сработал, то пересчитываем веса
for i in range(len(w)):
w[i] += t * (out_t - out_r) * inp_t[i]
break
return w
rez = PerTrain(0.1,[[0,0,-1],[0,1,1],[1,0,1],[1,1,1]])
print(rez)
Например получили такие веса:
[-0.1, 0.14, 0.16]
Проверяем:
print(1*-0.1 + 0*0.14 + 0*0.16)
print(1*-0.1 + 0*0.14 + 1*0.16)
print(1*-0.1 + 1*0.14 + 0*0.16)
print(1*-0.1 + 1*0.14 + 1*0.16)
в результате получаем:
-0.1
0.06
0.04000000000000001
0.2
что действительно соответствует дизъюнкции:
-1
1
1
1
