Эксперт

Сергей

Задать вопрос

Мы готовы помочь Вам.

Лабораторная работа №2
Обучение однослойного перцептрона с несколькими выходами
Используя заготовку программы на языке Python, выполнить обучение 1-слойной нейронной сети типа “перцептрон” распознаванию образов на растре (матрице) 5 на 7 (допускаются другие размеры по выбору студента, например, 5 на 8, 6 на 8, 6 на 9 и т.п.).
Можно использовать трансляторы языка Python (Python 3) на сайтах tio.run, ideon.com, pythonanywhere.com, onlinegdb.com, online-python.com и colab.research.google.com. Во всех этих случаях (кроме onlinegdb.com и online-python.com) лучше удалить из программы (или закомментировать) все операторы input.
Варианты исходных данных
Набор символов №1. Распознаваемые символы: две последние цифры номера зачѐтной книжки (если в номере есть цифра “1”, то она заменяется на “2”, если цифры совпадают (в том числе после замены “1” на “2”), то вторая цифра = первая цифра + 1);
Набор символов №2. Набор символов № 1 и первые буквы имени и фамилии, заглавные (русские или латинские – по выбору студента, если буквы совпадают, то одна из них заменяется на следующую по порядку, «Я» заменяется на «А»), цифра “1”, один символ по выбору студента, отличающийся от ранее указанных.
Задание на выполнение
1. Модифицировать программу в соответствии с выбранным вариантом, добавив в неѐ описания массива входного сигнала, массива эталонного сигнала и массива требуемых выходов (массивы (списки) signal1, signal2, netOut и metki).
Обучить сеть распознаванию символов набора №1. Зафиксировать в отчѐте количество циклов обучения.
Проверить состояния выходов сети для каждого входного сигнала.
2. Модифицировать программу, изменив значение переменной Nout с 2 на 6. Изменить массивы входного сигнала, эталонного сигнала, добавив в них символы набора №2. Изменить массив требуемых выходов. Обучить сеть распознаванию полного набора символов. Зафиксировать в отчѐте количество циклов обучения. Проверить состояния выходов сети для каждого входного сигнала.
3. Проверить ход обучения сети и его результаты для случаев использования при обучении только эталонных образов и “зашумлѐнных” образов. В первом случае нужно присвоить переменной noiseTrain значение 0, а во втором – значение 0.5. Величину шума (переменная noiseLevel) можно выбирать в диапазоне 0.15 – 0.25 (допускаются и другие значения). Сравнить результаты обучения сети (количество циклов обучения и сигналы на выходах сети) в обоих случаях.
import numpy as np
import random
from math import fabs
Nix,Niy=5,7
Ni=Nix*Niy
Nout=6
Ntest=7
Alpha=2
Beta=2 # 1
Nju=0.2 # 0.1
noiseLevel=0.15 #0.25
noiseTrain=0 #0.5
inp1=np.zeros(Ni)
w1=np.ones((Nout,Ni+1))
delta1=np.zeros((Nout,Ni+1))
layer1=np.zeros(Nout)
print(inp1)
print(w1)
def initWeights(w):
for i in range(len(w)):
w[i]=random.random()-0.5
def vvod(source,dest):
for i in range(len(source)):
dest[i]=source[i]
def noise(arr,n):
for i in range(len(arr)):
a=random.random()
if a<n:
if arr[i]==1:
arr[i]=0
else:
arr[i]=1
def showImage(arr,X,Y):
a1=np.array(arr).reshape(Y,X)
for y in range(Y):
for x in range(X):
if a1[y][x]==1:
print(‘#’,end=”)
else:
print(‘.’,end=”)
print()
def work(inp,wa,out,alpha):
for o in range(len(out)):
sum=0.0
for i in range(len(inp)):
sum+=inp[i]*wa[o][i]
sum+=wa[o][len(inp)]
out[o]=1/(1+np.exp(-sum*alpha))
def train(ideal,inp,wa,out,beta,nju):
nout=len(out)
ninp=len(inp)
err=np.zeros(nout)
for k in range(nout): # Вычисление ошибки выходного слоя
err[k]=(ideal[k]-out[k])*beta*out[k]*(1-out[k])
wa[k][ninp]+=nju*err[k]
for j in range(ninp):
for k in range(nout):
delta=nju*err[k]*inp[j]
wa[k][j]+=delta #[k][j]
def isConverged(ideal,out,prec):
c=0
for k in range(len(out)):
if fabs(ideal[k]-out[k])<=prec:
c+=1
return c
signal1=[[ # Обучающие образы по варианту (буква N)
1,0,0,0,1,
1,0,0,0,1,
1,1,0,0,1,
1,0,1,0,1,
1,0,0,1,1,
1,0,0,0,1,
1,0,0,0,1],
[1,1,1,0,0, # P
1,0,0,1,0,
1,0,0,1,0,
1,1,1,0,0,
1,0,0,0,0,
1,0,0,0,0,
1,0,0,0,0],
[0,0,1,0,0, # 1
0,1,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,1,1,1,0],
[0,1,1,0,0, # 2
1,0,0,1,0,
0,0,0,1,0,
0,0,1,0,0,
0,1,0,0,0,
1,0,0,0,0,
1,1,1,1,0],
[1,1,1,1,0, # 3
0,0,0,1,0,
0,0,1,0,0,
0,1,1,0,0,
0,0,0,1,0,
1,0,0,1,0,
0,1,1,0,0],
[1,1,1,1,1, # 7
0,0,0,0,1,
0,0,0,1,0,
0,0,1,0,0,
0,1,0,0,0,
1,0,0,0,0,
1,0,0,0,0]
]
signal2=[[ # Проверочные образы (в ЛР №2 – совпадают с обучающими)
1,0,0,0,1,
1,0,0,0,1,
1,1,0,0,1,
1,0,1,0,1,
1,0,0,1,1,
1,0,0,0,1,
1,0,0,0,1],
[1,1,1,0,0,
1,0,0,1,0,
1,0,0,1,0,
1,1,1,0,0,
1,0,0,0,0,
1,0,0,0,0,
1,0,0,0,0],
[0,0,1,0,0,
0,1,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,1,1,1,0],
[0,1,1,0,0,
1,0,0,1,0,
0,0,0,1,0,
0,0,1,0,0,
0,1,0,0,0,
1,0,0,0,0,
1,1,1,1,0],
[1,1,1,1,0,
0,0,0,1,0,
0,0,1,0,0,
0,1,1,0,0,
0,0,0,1,0,
1,0,0,1,0,
0,1,1,0,0],
[1,1,1,1,1,
0,0,0,0,1,
0,0,0,1,0,
0,0,1,0,0,
0,1,0,0,0,
1,0,0,0,0,
1,0,0,0,0],
[0,0,1,0,0, # Дополнительный образ – вертикальная черта
0,0,1,0,0, # (искаженная цифра «1»)
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0],
]
netOut=[ # массив (список) выходов сети для 6-и символов
[1,0,0,0,0,0], # для 2-х символов будет
[0,1,0,0,0,0], # [1,0],
[0,0,1,0,0,0], # [0,1]]
[0,0,0,1,0,0],
[0,0,0,0,1,0],
[0,0,0,0,0,1]]
metki=[‘N’,’P’,’1′,’2′,’3′,’7′,’1′]
print(‘Тест обучающего образа:’)
showImage(signal2[0],Nix,Niy); print()
input(‘Нажмите <Enter> для продолжения.’)
print(‘Тест входного образа:’)
vvod(signal1[0],inp1)
showImage(inp1,Nix,Niy); print()
print(‘Он же с шумом:’)
noise(inp1,noiseLevel)
showImage(inp1,Nix,Niy); print()
input(‘Нажмите <Enter> для продолжения.’)
print(‘Контроль входного сигнала в виде одномерного массива:’,inp1)
input(‘Нажмите <Enter> для продолжения.’)
work(inp1,w1,layer1,Alpha)
print(‘Проверка состояния одного выхода сети (сеть ещѐ не обучена):’,layer1[0])
input(‘Нажмите <Enter> для продолжения.’)
for i in range(Nout):
initWeights(w1[i])
print(‘Все весовые коэффициенты 1-слойной сети:\n’,w1)
input(‘Нажмите <Enter> для продолжения.’)
Corr=0
eps=0.01
epoch=0
input(‘Процесс обучения сети. Нажмите <Enter> для продолжения.’)
while Corr<Nout:
a=random.random()
print(a)
for i in range(len(netOut)):
vvod(signal1[i],inp1)
if a<noiseTrain:
noise(inp1,noiseLevel)
work(inp1,w1,layer1,Alpha)
train(netOut[i],inp1,w1,layer1,Beta,Nju)
Corr=isConverged(netOut[i],layer1,eps)
epoch+=1
print(‘Epoch=’,epoch,’No errors=’,Corr)
print(‘Число циклов обучения=’,epoch)
print(‘No errors=’,Corr)
print(‘Test signals:’)
for i in range(Ntest):
print(‘Signal-‘,i,’:’,metki[i],’:’)
showImage(signal2[i],Nix,Niy)
vvod(signal2[i],inp1)
work(inp1,w1,layer1,Alpha)
for j in range(Nout):
print(‘Out-‘,j,’=’,layer1[j])
print()
input(‘Continue.’)
print(‘Test signals with noise:’)
for i in range(Ntest):
print(‘Signal-‘,i,’:’,metki[i],’:’)
vvod(signal2[i],inp1)
noise(inp1,0.125)
showImage(inp1,Nix,Niy)
work(inp1,w1,layer1,Alpha)
for j in range(Nout):
print(‘Out-‘,j,’=’,layer1[j])
print()
input(‘Press <Enter>.’)
7
Лабораторная работа №5
Исследование активационных функций
Используя заготовку программы Lab5.py на языке Python, выполнить обучение 2-слойной нейронной сети типа “перцептрон” распознаванию образов на растре (матрице) 5 на 7 (допускаются другие размеры по выбору студента, например, 5 на 8, 6 на 8, 6 на 9 и т.п.).
Можно использовать трансляторы языка Python (Python 3) на сайтах tio.run, ideon.com, pythonanywhere.com, onlinegdb.com, online-python.com и colab.research.google.com. Во всех этих случаях (кроме onlinegdb.com и online-python.com) лучше удалить из программы (или закомментировать) все операторы input.
Нейронная сеть должна обучаться распознаванию тех же символов, что и в работах №2 – №4.
Задание на выполнение
1. Ознакомиться с текстом программы, обратив внимание на отличие в функциях work… и train…
2. Обучить сеть и проверить еѐ работу, используя логистическую активационную функцию (функции workLog() и trainLog()). Выполнить не менее 3-х попыток обучения, и получить среднее количество эпох, требуемых для обучения сети.
3. Модифицировать программу, закомментировав все вызовы функции workLog() (кроме цикла обучения в строках 466-502) и сняв комментарий (#) с вызовов функции workHeavi().
Проверить состояния выходов сети для каждого входного сигнала. Сравнить результат работы сети с результатом выполнения пункта №2, зафиксировать в отчѐте.
4. Модифицировать программу, закомментировав все вызовы функции workLog() (кроме цикла обучения в строках 466-502) и функции workHeavi() и сняв комментарий с вызовов функции workLin().
Проверить состояния выходов сети для каждого входного сигнала. Сравнить результат работы сети с результатами выполнения пунктов №2 и №3, зафиксировать в отчѐте. Сделать выводы.
5. Модифицировать программу, закомментировав все вызовы функций workLin() и workLog() и сняв комментарий с вызовов функций workHT() и trainHT(). Выполнить не менее 3-х попыток обучения, и получить среднее количество эпох, требуемых для обучения сети. Использовать те же значения
8
коэффициентов Альфа, Бета и Ню, что и в пункте 2. Проверить состояния выходов сети для каждого входного сигнала. Сравнить результаты с пунктами 2, 3, 4, зафиксировать в отчѐте. Сделать выводы.
6. Модифицировать программу, закомментировав все вызовы функций workHT(), trainHT() и isConverged() и сняв комментарий с вызовов функций workReLU(), trainReLU() и isConvergedReLU().
Выполнить не менее 3-х попыток обучения, и получить среднее количество эпох, требуемых для обучения сети. Использовать те же значения коэффициентов Альфа, Бета и Ню, что и в пункте 2. Проверить состояния выходов сети для каждого входного сигнала. Сравнить результаты с пунктами 2, 3, 4 и 5, зафиксировать в отчѐте. Сделать выводы.
import numpy as np
import random
from math import fabs
import math
import msvcrt
Nix,Niy=5,7
Ni=Nix*Niy
Nout=6
N1=int((Ni+Nout)/2)
Ntest=7
Alpha=2
Beta=1 # 1
Nju=0.2 # 0.1
Mju=0.1
noiseLevel=0.15 #0.25
noiseTrain=0.5
inp1=np.zeros(Ni)
w1=np.ones((N1,Ni+1))
layer1=np.zeros(N1)
delta1=np.zeros((N1,Ni+1))
w2=np.ones((Nout,N1+1))
layer2=np.zeros(Nout)
delta2=np.zeros((Nout,N1+1))
weights=[w1,w2]
#print(inp1)
#print(w1)
def initWeights(w):
for i in range(len(w)):
w[i]=random.random()-0.5
def vvod(source,dest):
for i in range(len(source)):
dest[i]=source[i]
def noise(arr,n):
for i in range(len(arr)):
9
a=random.random()
if a<n:
if arr[i]==1:
arr[i]=0
else:
arr[i]=1
def showImage(arr,X,Y):
a1=np.array(arr).reshape(Y,X)
for y in range(Y):
for x in range(X):
if a1[y][x]==1:
print(‘#’,end=”)
else:
print(‘.’,end=”)
print()
def workLog(inp,wa,out,alpha):
for o in range(len(out)):
sum=0.0
for i in range(len(inp)):
sum+=inp[i]*wa[o][i]
sum+=wa[o][len(inp)]
out[o]=1/(1+np.exp(-sum*alpha))
def workHeavi(inp,wa,out,alpha):
for o in range(len(out)):
s=0.0
for i in range(len(inp)):
s+=inp[i]*wa[o][i]
s+=wa[o][len(inp)]
if s>0:
out[o]=1
else:
out[o]=0
def workLin(inp,wa,out,alpha):
for o in range(len(out)):
sum=0.0
for i in range(len(inp)):
sum+=inp[i]*wa[o][i]
sum+=wa[o][len(inp)]
out[o]=sum
def workHT(inp,wa,out,alpha):
for o in range(len(out)):
sum=0.0
for i in range(len(inp)):
sum+=inp[i]*wa[o][i]
sum+=wa[o][len(inp)]
out[o]=math.tanh(sum*alpha)/2.+0.5
def workReLU(inp,wa,out,alpha):
for o in range(len(out)):
sum=0.0
for i in range(len(inp)):
sum+=inp[i]*wa[o][i]
sum+=wa[o][len(inp)]
10
if sum>0:
out[o]=sum
else:
out[o]=0
def logToHT(inp):
for i in range(len(inp)):
inp[i]=inp[i]-0.5
def trainLog(ideal,wa,layers,deltas,arch,beta,Nju,Mju):
N0=arch[0]
N1=arch[1]
N2=arch[2]
out=layers[2]
axon0=layers[0]
axon1=layers[1]
sinaps2=wa[1]
sinaps1=wa[0]
err2=np.zeros(N2)
err1=np.zeros(N1)
for k in range(N2): # Vychislenie oshibki vyhodnogo sloja
err2[k]=(ideal[k]-out[k])*beta*out[k]*(1-out[k])
wa[1][k][N1]+=Nju*err2[k] # smesh
for j in range(N1): # Vychislenie oshibki skrytogo sloja
s=0.;
for k in range(N2):
s+=err2[k]*sinaps2[k][j]
err1[j]=s*beta*axon1[j]*(1-axon1[j])
for i in range(N0):
for j in range(N1):
deltas[0][j][i]=Nju*(Mju*deltas[0][j][i]+(1-Mju)*err1[j]*axon0[i])
sinaps1[j][i]+=deltas[0][j][i]
for j in range(N1):
for k in range(N2):
deltas[1][k][j]=Nju*(Mju*deltas[1][k][j]+(1-Mju)*err2[k]*axon1[j])
sinaps2[k][j]+=deltas[1][k][j]
wa[0][j][N0]+=Nju*err1[j] # smesh
#end of trainLog
def trainHeavi(ideal,wa,layers,deltas,arch,beta,Nju,Mju):
N0=arch[0]
N1=arch[1]
N2=arch[2]
out=layers[2]
axon0=layers[0]
axon1=layers[1]
sinaps2=wa[1]
sinaps1=wa[0]
err2=np.zeros(N2)
err1=np.zeros(N1)
for k in range(N2): # Vychislenie oshibki vyhodnogo sloja
err2[k]=(ideal[k]-out[k])*beta*out[k]*(1-out[k])
11
wa[1][k][N1]+=Nju*err2[k] # smesh
for j in range(N1): # Vychislenie oshibki skrytogo sloja
s=0.
for k in range(N2):
s+=err1[j]*sinaps2[k][j]
err1[j]=s*beta*axon1[j]*(1-axon1[j])
for i in range(N0):
for j in range(N1):
deltas[0][j][i]=Nju*(Mju*deltas[0][j][i]+(1-Mju)*err1[j]*axon0[i])
sinaps1[j][i]+=deltas[0][j][i]
for j in range(N1):
for k in range(N2):
deltas[1][k][j]=Nju*(Mju*deltas[1][k][j]+(1-Mju)*err2[k]*axon1[j])
sinaps2[k][j]+=deltas[1][k][j]
wa[0][j][N0]+=Nju*err1[j] # smesh
#end of trainHeavi
def trainLin(ideal,wa,layers,deltas,arch,beta,Nju,Mju):
N0=arch[0]
N1=arch[1]
N2=arch[2]
out=layers[2]
axon0=layers[0]
axon1=layers[1]
sinaps2=wa[1]
sinaps1=wa[0]
err2=np.zeros(N2)
err1=np.zeros(N1)
for k in range(N2): # Vychislenie oshibki vyhodnogo sloja
if ideal[k]==1 and out[k]<=0.5 or ideal[k]==1 and out[k]>0.5:
err2[k]=(ideal[k]-out[k])*beta #*out[k]
wa[1][k][N1]+=Nju*err2[k] # smesh
for j in range(N1): # Vychislenie oshibki skrytogo sloja
s=0.
for k in range(N2):
s+=err2[k]*sinaps2[k][j]
err1[j]=s*beta #*axon1[j]
for i in range(N0):
for j in range(N1):
deltas[0][j][i]=Nju*err1[j]*axon0[i]
sinaps1[j][i]+=deltas[0][j][i]
for j in range(N1):
for k in range(N2):
deltas[1][k][j]=Nju*err2[k]*axon1[j]
sinaps2[k][j]+=deltas[1][k][j]
wa[0][j][N0]+=Nju*err1[j] # smesh
#end of trainLin
def trainHT(ideal,wa,layers,deltas,arch,beta,Nju,Mju):
12
N0=arch[0]
N1=arch[1]
N2=arch[2]
out=layers[2]
axon0=layers[0]
axon1=layers[1]
sinaps2=wa[1]
sinaps1=wa[0]
err2=np.zeros(N2)
err1=np.zeros(N1)
for k in range(N2): # Vychislenie oshibki vyhodnogo sloja
err2[k]=(ideal[k]-out[k])*beta*(1.-out[k]*out[k])
wa[1][k][N1]+=Nju*err2[k] # smesh
for j in range(N1): # Vychislenie oshibki skrytogo sloja
s=0.
for k in range(N2):
s+=err2[k]*sinaps2[k][j];
err1[j]=s*beta*(1.-axon1[j]*axon1[j])
for i in range(N0):
for j in range(N1):
deltas[0][j][i]=Nju*(Mju*deltas[0][j][i]+(1-Mju)*err1[j]*axon0[i])
sinaps1[j][i]+=deltas[0][j][i]
for j in range(N1):
for k in range(N2):
deltas[1][k][j]=Nju*(Mju*deltas[1][k][j]+(1-Mju)*err2[k]*axon1[j])
sinaps2[k][j]+=deltas[1][k][j]
wa[0][j][N0]+=Nju*err1[j] # smesh
#end of trainHT
def trainReLU(ideal,wa,layers,deltas,arch,beta,Nju,Mju):
N0=arch[0]
N1=arch[1]
N2=arch[2]
out=layers[2]
axon0=layers[0]
axon1=layers[1]
sinaps2=wa[1]
sinaps1=wa[0]
err2=np.zeros(N2)
err1=np.zeros(N1)
for k in range(N2): # Vychislenie oshibki vyhodnogo sloja
if out[k]<0:
err[2]=beta*out[k]
else:
err2[k]=(ideal[k]-out[k])*beta #*out[k]
wa[1][k][N1]+=Nju*err2[k] # smesh
for j in range(N1): # Vychislenie oshibki skrytogo sloja
s=0.
for k in range(N2):
s+=err2[k]*sinaps2[k][j]
13
if axon1[j]>=0:
err1[j]=s*beta #*axon1[j]
else:
err1[j]=0
for i in range(N0):
for j in range(N1):
# deltas[0][j][i]=Nju*(Mju*deltas[0][j][i]+(1-Mju)*err1[j]*axon0[i])
deltas[0][j][i]=Nju*err1[j]*axon0[i]
sinaps1[j][i]+=deltas[0][j][i]
for j in range(N1):
for k in range(N2):
# deltas[1][k][j]=Nju*(Mju*deltas[1][k][j]+(1-Mju)*err2[k]*axon1[j])
deltas[1][k][j]=Nju*err2[k]*axon1[j]
sinaps2[k][j]+=deltas[1][k][j]
wa[0][j][N0]+=Nju*err1[j] # smesh
#end of trainReLU
def isConverged(ideal,out,prec):
c=0
for k in range(len(out)):
if fabs(ideal[k]-out[k])<=prec:
c+=1
return c
def isConvergedLin(ideal,out,prec):
c=0
for k in range(len(out)):
if (ideal[k]==1 and out[k]>0.5) or (ideal[k]==0 and out[k]<=0.5):
# if (ideal[k]==1 and out[k]>(1-prec)) or (ideal[k]==0 and out[k]<=prec):
c+=1
return c
def isConvergedReLU(ideal,out,prec):
c=0
for k in range(len(out)):
if np.fabs(ideal[k]-out[k])<=prec or (ideal[k]==1 and out[k]>=1): # ‘or’ part – for ReLU
c+=1
return c
# end of isConverged()
def isConvergedHT(ideal,out,prec):
c=0
for k in range(len(out)):
# if fabs(ideal[k]*2-1-out[k])<=prec:
if fabs(ideal[k]-out[k])<=prec:
c+=1
return c
signal1=[[
1,0,0,0,1,
1,0,0,0,1,
14
1,1,0,0,1,
1,0,1,0,1,
1,0,0,1,1,
1,0,0,0,1,
1,0,0,0,1],
[1,1,1,0,0,
1,0,0,1,0,
1,0,0,1,0,
1,1,1,0,0,
1,0,0,0,0,
1,0,0,0,0,
1,0,0,0,0],
[0,0,1,0,0,
0,1,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,1,1,1,0],
[0,1,1,0,0,
1,0,0,1,0,
0,0,0,1,0,
0,0,1,0,0,
0,1,0,0,0,
1,0,0,0,0,
1,1,1,1,0],
[1,1,1,1,0,
0,0,0,1,0,
0,0,1,0,0,
0,1,1,0,0,
0,0,0,1,0,
1,0,0,1,0,
0,1,1,0,0],
[1,1,1,1,1,
0,0,0,0,1,
0,0,0,1,0,
0,0,1,0,0,
0,1,0,0,0,
1,0,0,0,0,
1,0,0,0,0]
]
signal2=[[
1,0,0,0,1,
1,0,0,0,1,
1,1,0,0,1,
1,0,1,0,1,
1,0,0,1,1,
1,0,0,0,1,
1,0,0,0,1],
[1,1,1,0,0,
1,0,0,1,0,
15
1,0,0,1,0,
1,1,1,0,0,
1,0,0,0,0,
1,0,0,0,0,
1,0,0,0,0],
[0,0,1,0,0,
0,1,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,1,1,1,0],
[0,1,1,0,0,
1,0,0,1,0,
0,0,0,1,0,
0,0,1,0,0,
0,1,0,0,0,
1,0,0,0,0,
1,1,1,1,0],
[1,1,1,1,0,
0,0,0,1,0,
0,0,1,0,0,
0,1,1,0,0,
0,0,0,1,0,
1,0,0,1,0,
0,1,1,0,0],
[1,1,1,1,1,
0,0,0,0,1,
0,0,0,1,0,
0,0,1,0,0,
0,1,0,0,0,
1,0,0,0,0,
1,0,0,0,0],
[0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0,
0,0,1,0,0],
]
netOut=[
[1,0,0,0,0,0],
[0,1,0,0,0,0],
[0,0,1,0,0,0],
[0,0,0,1,0,0],
[0,0,0,0,1,0],
[0,0,0,0,0,1]]
metki=[‘N’,’P’,’1′,’2′,’3′,’7′,’1′]
#workLog(inp1,w1,layer1,Alpha)
16
#workLog(layer1,w2,layer2,Alpha)
workHeavi(inp1,w1,layer1,Alpha)
workHeavi(layer1,w2,layer2,Alpha)
print(‘Проверка состояния одного выхода сети (сеть ещѐ не обучена):’,layer2[0])
#print(‘Out\n’,layer1[0])
input(‘Нажмите <Enter> для продолжения.’)
for i in range(N1):
initWeights(w1[i])
for i in range(Nout):
initWeights(w2[i])
print(‘Все весовые коэффициенты 2-слойной сети, w1:\n’,w1,’w2:\n’,w2)
input(‘Нажмите <Enter> для продолжения.’)
#workLog(inp1,w1,layer1,Alpha)
#workLog(layer1,w2,layer2,Alpha)
workHeavi(inp1,w1,layer1,Alpha)
workHeavi(layer1,w2,layer2,Alpha)
print(‘Out\n’,layer1[0])
input(‘Нажмите <Enter> для продолжения.’)
#Corr=0
Corr=np.zeros(Nout)
Corr1=0
eps=0.02
epoch=0
input(‘Процесс обучения сети. Нажмите <Enter> для продолжения.’)
while Corr1<Nout and msvcrt.kbhit()==False: # Начало цикла обучения
a=random.random()
# print(a)
for i in range(len(netOut)):
vvod(signal1[i],inp1)
if a<noiseTrain:
noise(inp1,noiseLevel)
# workLog(inp1,w1,layer1,Alpha)
# workLog(layer1,w2,layer2,Alpha)
# workHeavi(inp1,w1,layer1,Alpha)
# workHeavi(layer1,w2,layer2,Alpha)
# workLin(inp1,w1,layer1,Alpha)
# workLin(layer1,w2,layer2,Alpha)
workReLU(inp1,w1,layer1,Alpha)
workReLU(layer1,w2,layer2,Alpha)
# logToHT(inp1)
workHT(inp1,w1,layer1,Alpha)
workHT(layer1,w2,layer2,Alpha)
# trainLog(netOut[i],weights,[inp1,layer1,layer2],[delta1,delta2],[Ni,N1,Nout],Beta,Nju,Mju)
17
# trainHeavi(netOut[i],weights,[inp1,layer1,layer2],[delta1,delta2],[Ni,N1,Nout],Beta,Nju,Mju)
# trainLin(netOut[i],weights,[inp1,layer1,layer2],[delta1,delta2],[Ni,N1,Nout],Beta,Nju,Mju)
# trainReLU(netOut[i],weights,[inp1,layer1,layer2],[delta1,delta2],[Ni,N1,Nout],Beta,Nju,Mju)
trainHT(netOut[i],weights,[inp1,layer1,layer2],[delta1,delta2],[Ni,N1,Nout],Beta,Nju,Mju)
Corr[i]=isConverged(netOut[i],layer2,eps)
# Corr[i]=isConvergedLin(netOut[i],layer2,eps)
# Corr[i]=isConvergedReLU(netOut[i],layer2,eps)
Corr1=0
for c in range(Nout):
if Corr[c]==Nout:
Corr1+=1
epoch+=1
print(‘Epoch=’,epoch,’No errors=’,Corr) # Конец цикла обучения
print(‘Число циклов обучения=’,epoch)
print(‘No errors=’,Corr)
print(‘Test signals:’)
for i in range(Ntest):
print(‘Signal-‘,i,’:’,metki[i],’:’)
showImage(signal2[i],Nix,Niy)
vvod(signal2[i],inp1)
# workLog(inp1,w1,layer1,Alpha)
# workLog(layer1,w2,layer2,Alpha)
# workHeavi(inp1,w1,layer1,Alpha)
# workHeavi(layer1,w2,layer2,Alpha)
# workLin(inp1,w1,layer1,Alpha)
# workLin(layer1,w2,layer2,Alpha)
# workReLU(inp1,w1,layer1,Alpha)
# workReLU(layer1,w2,layer2,Alpha)
# logToHT(inp1)
workHT(inp1,w1,layer1,Alpha)
workHT(layer1,w2,layer2,Alpha)
for j in range(Nout):
print(‘Out-‘,j,’=’,layer2[j])
print()
input(‘Continue.’)
print(‘Test signals with noise:’)
for i in range(Ntest):
print(‘Signal-‘,i,’:’,metki[i],’:’)
vvod(signal2[i],inp1)
noise(inp1,0.125)
showImage(inp1,Nix,Niy)
18
# workLog(inp1,w1,layer1,Alpha)
# workLog(layer1,w2,layer2,Alpha)
# workHeavi(inp1,w1,layer1,Alpha)
# workHeavi(layer1,w2,layer2,Alpha)
# workLin(inp1,w1,layer1,Alpha)
# workLin(layer1,w2,layer2,Alpha)
# workReLU(inp1,w1,layer1,Alpha)
# workReLU(layer1,w2,layer2,Alpha)
# logToHT(inp1)
workHT(inp1,w1,layer1,Alpha)
workHT(layer1,w2,layer2,Alpha)
for j in range(Nout):
print(‘Out-‘,j,’=’,layer2[j])
print()
input(‘Press <Enter>.’)