-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy path神经网络分类.py
265 lines (200 loc) · 6.35 KB
/
神经网络分类.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#code:[email protected]
#8-1.py
"""
Rosenblatt 感知器
1) 将数据输入神经元(这里是一个线性模型)或者将其转换为线性模型
2) 通过权值 W 和 输入 共同计算局部诱导域 V = sum [ w[i]x[i] ] + b
3) 调整权值W 找到能分类的超平面 ： sum [ w·[i]x[i] ] + b = 0
单样本修正算法：
神经网络每次读入一个样本，进行修正
批量样本修正法：
使用代价函数来进行分类误差率的控制。批量样本修正算法对样本进行多次读取，直到神经
网络误差率降到合适的程度才停止样本训练。其误差率使用嘴直观的错分类样本数量准则
核心：
权值更新策略：
"""
import numpy as np
b=0 #偏置
a=0.5 #学习速率，调整更新的步伐
x = np.array([[b,1,1],[b,1,0],[b,0,0],[b,0,1]])#输入向量，
d =np.array([1,1,0,1])#期望输出 == len(x)
w=np.array([b,0,0])#权值向量---
def sgn(v):#硬限幅函数（输入值）
if v>0:
return 1
else:
return 0
def comy(myw,myx):
return sgn(np.dot(myw.T,myx))
a=='''_____________这是训练的核心算法部分___________________________ '''
def neww(oldw,myd,myx,a):#权值的更新过程 ------
return oldw+a*(myd-comy(oldw,myx))*myx
i=0
for xn in x:
w=neww(w,d[i],xn,a)
i+=1
for xn in x:
print ("%d or %d => %d "%(xn[1],xn[2],comy(w,xn)))
ax___________________________________________________________= 0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#8-2.py
'''
2x+1 = y 第一类
7x+1 = y 第二类
单样本训练法
'''
import numpy as np
b=1
a=0.3
x=np.array([[b,1,3],[b,2,5],[b,1,8],[b,2,15],[b,3,7],[b,4,29]])
d=np.array([1,1,-1,-1,1,-1])
w=np.array([b,0,0])#初始全职
def sgn(v):
if v>=0:
return 1
else :
return -1
def comy(myw,myx):
return sgn(np.dot(myw.T,myx))
def neww(oldw,myd,myx,a):
return oldw+a*(myd-comy(oldw,myx))*myx
i=0
for xn in x:
w=neww(w,d[i],xn,a)
i+=1
test=np.array([b,9,19])
print( "%d ~ %d => %d "%(test[1],test[2],comy(w,test)))
test=np.array([b,9,64])
print( "%d ~ %d => %d "%(test[1],test[2],comy(w,test)))
#w[:1. , 1.2, -0.6]
得到神经网络的分类方程=' 1.2 x - 0.6 y + 1 =0 => y = 2x+1.68'
''' 批量样本修正的神经网络算法 代价函数 用到了 梯度更新权值 ————————————————————————————— '''
""" w(k+1) = w(k) - n(k)`J(w(k))
·J(w(k)) = sum[-y] y is incorrect
检查误差率： 或者训练次数
1，初始权值，学习率，期望误差率
2，读取所有样本
3，依次对样本进行训练，更新权值
4，检查 误差是否小于指定值
"""
import numpy as np
b = 1 #偏置
a = 0.5 #
x = np.array([[1,1,3],[1,2,3],[1,1,8],[1,2,15]])
d = np.array([1,1,-1,-1])#样本所属类别
w = np.array([b,0,0])
wucha = 0
ddcount = 50
def sgn(v):v>0 and 1 or -1#--------------------------
def sgn(v):
if v>0:
return 1
else:
return -1
def comy(myw,myx):
return sgn(np.dot(myw.T,myx))
def tiduxz(myw,myx,mya):
i = 0
sum_x = np.array([0,0,0])
for xn in myx:
if comy(myw,xn)!=d[i]:
sum_x += d[i]*xn
i+=1
return mya*sum_x
i=0
while True:
tdxz = tiduxz(w,x,a)
print(w)
w= w + tdxz
i = i+1
if abs(tdxz.sum())<= wucha or i>=ddcount:break
test = np.array([b,9,19])
print(comy(w,test))
test = np.array([b,9,64])
'''
_________________ = 0#'LMS 最小均方根算法'
MSE = mean((observed - predicted)**2)
e(n) = d(n) - X.T(n)W(n)im
梯度向量 = -X(x)e(n)
W(n+1) = W(n) + nX(n)e(n)
使用LMS实现逻辑或的运算，使用神经网络推导
使用固态退火来改变一层不变的学习率，让学习率随着时间变化
'''
b = 1
a = 0.1 #学习率
a = 0.0
a0 = 0.1
r = 5.0
mycount = 0
x = np.array([[1,1,1],[1,1,0],[1,0,1],[1,0,0]])
d = np.array([1,1,1,0])#是与不是标记为1或者0
def sgn(v):
if v>0:
return 1
else:
return 0
#----------------------------
#学习n% ==6 为第一类，若结果为3 输出为一类，输出-1
x = np.array([[1,1,6],[1,2,12],[1,3,9],[1,8,24]])
d = np.array([1,1,-1,-1])#是与不是标记为1或者-1
def sgn(v):
if v>0:
return 1
else:
return -1
#------------------------------------------
w = np.array([b,0,0])
expect_e=0.005
maxtrycount=20
#
def get_v(myw,myx):
return sgn(np.dot(myw.T,myx))
def get_e(myw,myx,myd):
return myd-get_v(myw,myx)
def neww(oldw,myd,myx,a):
mye=get_e(oldw,myx,myd)
return (oldw+a*mye*myx,mye)
''' _____________________________________使用固体退货原理的改变学习率的权值更新算法'''
def neww(oldw,myd,myx,a):
mye=get_e(oldw,myx,myd)
a = a0/(1+float(mycount)/r)
return (oldw+a*mye*myx,mye)
'''---____________-------------------------______________________------'''
#迭代次数或者迭代目标函数
mycount=0
while True:
mye=0#用于累加误差
i=0
for xn in x:
w,e=neww(w,d[i],xn,a)
i+=1
# x = '#误差平方的累加'
mye+=pow(e,2)
mye/=float(i)
# print(mye)
mycount+=1
print (u"第 %d 次调整后的权值："%mycount)
print (w)
print (u"误差：%f"%mye )
if mye<expect_e or mycount>maxtrycount:break
for xn in x:
print ("%d or %d => %d "%(xn[1],xn[2],get_v(w,xn)))
#验证被整除余数是属于哪一类的
test = np.array([1,9,27])
print("%d %d => %d"%(test[1],test[2],get_v(w,test)))
test = np.array([1,11,66])
print("%d %d => %d"%(test[1],test[2],get_v(w,test)))
Rosenblatt 感知器的局限性 只适用于线性方程分类，不适用于非线性分类
#基于梯度下降的额线性分类器
import mplannliner as nplann
traindatal = [[[9,25],-1],[[5,8],-1],[[15,31],-1],[[35,62],-1],[[19,40],-1],[[28,65],1],[[20,59],1],[[9,41],1],[[12,60],1],[[2,37],1]]
myann = nplann.mplannliner()
#样本初始化
myann.samples_init(traindatal)
#学习率初始化
myann.a_init(0.1)
#搜索时间初始化
myann.r_init()