python机器学习之神经网络(二)

(21) 2024-06-30 14:01:01

来自:http://blog.csdn.NET/cui134/article/details/

由于Rosenblatt感知器的局限性,对于非线性分类的效果不理想。为了对线性分类无法区分的数据进行分类,需要构建多层感知器结构对数据进行分类,多层感知器结构如下:

python机器学习之神经网络(二) (https://mushiming.com/)  第1张

该网络由输入层,隐藏层,和输出层构成,能表示种类繁多的非线性曲面,每一个隐藏层都有一个激活函数,将该单元的输入数据与权值相乘后得到的值(即诱导局部域)经过激活函数,激活函数的输出值作为该单元的输出,激活函数类似与硬限幅函数,但硬限幅函数在阈值处是不可导的,而激活函数处处可导。本次程序中使用的激活函数是tanh函数,公式如下:

python机器学习之神经网络(二) (https://mushiming.com/)  第2张

tanh函数的图像如下:

python机器学习之神经网络(二) (https://mushiming.com/)  第3张

程序中具体的tanh函数形式如下:

python机器学习之神经网络(二) (https://mushiming.com/)  第4张

python机器学习之神经网络(二) (https://mushiming.com/)  第5张就是神经元j的诱导局部域

它的局部梯度分两种情况:

(1)神经元j没有位于隐藏层:

python机器学习之神经网络(二) (https://mushiming.com/)  第6张

(2)神经元j位于隐藏层:

python机器学习之神经网络(二) (https://mushiming.com/)  第7张

其中k是单元j后面相连的所有的单元。

局部梯度得到之后,根据增量梯度下降法的权值更新法则

python机器学习之神经网络(二) (https://mushiming.com/)  第8张

即可得到下一次的权值w,经过若干次迭代,设定误差条件,即可找到权值空间的最小值。

Python程序如下,为了能够可视化,训练数据采用二维数据,每一个隐藏层有8个节点,设置了7个隐藏层,一个输出层,输出层有2个单元:

[python]  view plain copy

  1. import numpy as np  
  2. import random  
  3. import copy  
  4. import matplotlib.pyplot as plt  
  5.   
  6.   
  7. #x和d样本初始化  
  8. train_x = [[1,6],[3,12],[3,9],[3,21],[2,16],[3,15]]  
  9. d =[[1,0],[1,0],[0,1],[0,1],[1,0],[0,1]]  
  10. warray_txn=len(train_x[0])  
  11. warray_n=warray_txn*4  
  12.   
  13. #基本参数初始化  
  14. oldmse=10**100  
  15. fh=1  
  16. maxtrycount=500  
  17. mycount=0.0  
  18. if maxtrycount>=20:  
  19.         r=maxtrycount/5  
  20. else:  
  21.         r=maxtrycount/2  
  22. #sigmoid函数  
  23. ann_sigfun=None  
  24. ann_delta_sigfun=None  
  25. #总层数初始化,比非线性导数多一层线性层  
  26. alllevel_count=warray_txn*4  
  27. # 非线性层数初始化  
  28. hidelevel_count=alllevel_count-1  
  29.   
  30. #学习率参数   
  31. learn_r0=0.002    
  32. learn_r=learn_r0        
  33. #动量参数  
  34. train_a0=learn_r0*1.2  
  35. train_a=train_a0  
  36. expect_e=0.05  
  37. #对输入数据进行预处理  
  38. ann_max=[]  
  39. for m_ani in xrange(0,warray_txn):             #找出训练数据中每一项的最大值  
  40.     temp_x=np.array(train_x)  
  41.     ann_max.append(np.max(temp_x[:,m_ani]))  
  42. ann_max=np.array(ann_max)  
  43.   
  44. def getnowsx(mysx,in_w):  
  45.         '''''生成本次的扩维输入数据  '''  
  46.         '''''mysx==>输入数据,in_w==>权值矩阵,每一列为一个神经元的权值向量'''  
  47.         global warray_n  
  48.         mysx=np.array(mysx)  
  49.         x_end=[]     
  50.         for i in xrange(0,warray_n):  
  51.                 x_end.append(np.dot(mysx,in_w[:,i]))  
  52.         return x_end  
  53.   
  54. def get_inlw(my_train_max,w_count,myin_x):  
  55.         '''''找出权值矩阵均值接近0,输出结果方差接近1的权值矩阵'''  
  56.         #对随机生成的多个权值进行优化选择,选择最优的权值  
  57.         global warray_txn  
  58.         global warray_n  
  59.         mylw=[]  
  60.         y_in=[]  
  61.         #生成测试权值  
  62.         mylw=np.random.rand(w_count,warray_txn,warray_n)  
  63.         for ii in xrange (0,warray_txn):  
  64.             mylw[:,ii,:]=mylw[:,ii,:]*1/float(my_train_max[ii])-1/float(my_train_max[ii])*0.5  
  65.   
  66.         #计算输出  
  67.         for i in xrange(0,w_count):  
  68.                 y_in.append([])  
  69.                 for  xj in xrange(0,len(myin_x)):  
  70.                         y_in[i].append(getnowsx(myin_x[xj],mylw[i]))  
  71.         #计算均方差  
  72.         mymin=10**5  
  73.         mychoice=0  
  74.         for i in xrange(0,w_count):  
  75.                 myvar=np.var(y_in[i])  
  76.                 if abs(myvar-1)<mymin:  
  77.                         mymin=abs(myvar-1)  
  78.                         mychoice=i  
  79.         #返回数据整理的权值矩阵  
  80.         return mylw[mychoice]  
  81. mylnww=get_inlw(ann_max,300,train_x)  
  82.   
  83. def get_inputx(mytrain_x,myin_w):  
  84.         '''''将训练数据经过权值矩阵,形成扩维数据'''  
  85.         end_trainx=[]  
  86.         for i in xrange(0,len(mytrain_x)):  
  87.                 end_trainx.append(getnowsx(mytrain_x[i],myin_w))          
  88.         return end_trainx  
  89.           
  90. x=get_inputx(train_x,mylnww)#用于输入的扩维数据  
  91. #对测试数据进行扩维  
  92. def get_siminx(sim_x):  
  93.         global mylnww  
  94.         myxx=np.array(sim_x)  
  95.         return get_inputx(myxx,mylnww)  
  96. #计算一层的初始化权值矩阵  
  97. def getlevelw(myin_x,wo_n,wi_n,w_count):  
  98.         mylw=[]  
  99.         y_in=[]  
  100.         #生成测试权值  
  101.         mylw=np.random.rand(w_count,wi_n,wo_n)  
  102.         mylw=mylw*2.-1  
  103.   
  104.         #计算输出  
  105.         for i in xrange(0,w_count):  
  106.                 y_in.append([])  
  107.                 for  xj in xrange(0,len(myin_x)):  
  108.                     x_end=[]     
  109.                     for myii in xrange(0,wo_n):  
  110.                         x_end.append(np.dot(myin_x[xj],mylw[i,:,myii]))  
  111.                     y_in[i].append(x_end)  
  112.         #计算均方差  
  113.         mymin=10**3  
  114.         mychoice=0  
  115.         for i in xrange(0,w_count):  
  116.                 myvar=np.var(y_in[i])  
  117.                 if abs(myvar-1)<mymin:  
  118.                         mymin=abs(myvar-1)  
  119.                         mychoice=i  
  120.         #返回数据整理的权值矩阵  
  121.         csmylw=mylw[mychoice]  
  122.         return csmylw,y_in[mychoice]          
  123. ann_w=[]  
  124. def init_annw():  
  125.     global x  
  126.     global hidelevel_count  
  127.     global warray_n  
  128.     global d  
  129.     global ann_w  
  130.     ann_w=[]  
  131.    
  132.     lwyii=np.array(x)  
  133.     #初始化每层的w矩阵  
  134.     for myn in xrange(0,hidelevel_count):                 
  135.         #层数  
  136.         ann_w.append([])    
  137.         if myn==hidelevel_count-1:  
  138.             for iii in xrange(0,warray_n):  
  139.                 ann_w[myn].append([])  
  140.                 for jjj  in xrange(0,warray_n):  
  141.                                 ann_w[myn][iii].append(0.0)  
  142.         elif myn==hidelevel_count-2:              
  143.             templw,lwyii=getlevelw(lwyii,len(d[0]),warray_n,200)  
  144.             for xii in xrange(0,warray_n):  
  145.                 ann_w[myn].append([])  
  146.                 for xjj in xrange(0,len(d[0])):   
  147.                     ann_w[myn][xii].append(templw[xii,xjj])   
  148.                 for xjj in xrange(len(d[0]),warray_n):  
  149.                     ann_w[myn][xii].append(0.0)  
  150.         else:   
  151.             templw,lwyii=getlevelw(lwyii,warray_n,warray_n,200)  
  152.             for xii in xrange(0,warray_n):  
  153.                 ann_w[myn].append([])  
  154.                 for xjj in xrange(0,warray_n):   
  155.                     ann_w[myn][xii].append(templw[xii,xjj])                  
  156.     ann_w=np.array(ann_w)  
  157.   
  158. def generate_lw(trycount):  
  159.     global ann_w  
  160.     print u"产生权值初始矩阵",               
  161.     meanmin=1   
  162.     myann_w=ann_w         
  163.     alltry=30  
  164.     tryc=0  
  165.     while tryc<alltry:  
  166.         for i_i in range(trycount):  
  167.             print ".",  
  168.             init_annw()  
  169.             if abs(np.mean(np.array(ann_w)))<meanmin:  
  170.                 meanmin=abs(np.mean(np.array(ann_w)))  
  171.                 myann_w=ann_w  
  172.         tryc+=1  
  173.         if abs(np.mean(np.array(myann_w)))<0.008:break  
  174.           
  175.     ann_w=myann_w  
  176.     print  
  177.     print u"权值矩阵平均:%f"%(np.mean(np.array(ann_w)))  
  178.     print u"权值矩阵方差:%f"%(np.var(np.array(ann_w)))        
  179. generate_lw(15)  
  180.   
  181. #前次训练的权值矩阵  
  182. ann_oldw=copy.deepcopy(ann_w)  
  183. #梯度初始化  
  184. #输入层即第一层隐藏层不需要,所以第一层的空间无用  
  185. ann_delta=[]  
  186. for i in xrange(0,hidelevel_count):  
  187.         ann_delta.append([])       
  188.         for j in xrange(0,warray_n):  
  189.                 ann_delta[i].append(0.0)  
  190. ann_delta=np.array(ann_delta)  
  191.   
  192. #输出矩阵yi初始化  
  193. ann_yi=[]  
  194. for i in xrange(0,alllevel_count):  
  195.         #第一维是层数,从0开始  
  196.         ann_yi.append([])  
  197.         for j in xrange(0,warray_n):  
  198.                 #第二维是神经元  
  199.                 ann_yi[i].append(0.0)  
  200. ann_yi=np.array(ann_yi)       
  201.   
  202.   
  203.         
  204. #输出层函数          
  205. def o_func(myy):  
  206.         myresult=[]  
  207.         mymean=np.mean(myy)  
  208.         for i in xrange(0,len(myy)):  
  209.                 if myy[i]>=mymean:  
  210.                         myresult.append(1.0)  
  211.                 else:  
  212.                         myresult.append(0.0)  
  213.         return np.array(myresult)  
  214.           
  215. def get_e(myd,myo):  
  216.         return np.array(myd-myo)  
  217. def ann_atanh(myv):  
  218.         atanh_a=1.7159#>0  
  219.         atanh_b=2/float(3)#>0  
  220.         temp_rs=atanh_a*np.tanh(atanh_b*myv)  
  221.         return temp_rs  
  222. def ann_delta_atanh(myy,myd,nowlevel,level,n,mydelta,myw):  
  223.     anndelta=[]  
  224.     atanh_a=1.7159#>0  
  225.     atanh_b=2/float(3)#>0    
  226.     if nowlevel==level:  
  227.        #输出层  
  228.         anndelta=(float(atanh_b)/atanh_a)*(myd-myy)*(atanh_a-myy)*(atanh_a+myy)  
  229.     else:  
  230.        #隐藏层  
  231.         anndelta=(float(atanh_b)/atanh_a)*(atanh_a-myy)*(atanh_a+myy)              
  232.         temp_rs=[]  
  233.         for j in xrange(0,n):  
  234.                 temp_rs.append(sum(myw[j]*mydelta))                  
  235.         anndelta=anndelta*temp_rs         
  236.     return anndelta  
  237.   
  238. def sample_train(myx,myd,n,sigmoid_func,delta_sigfun):  
  239.         '''''一个样本的前向和后向计算'''  
  240.         global ann_yi  
  241.         global ann_delta  
  242.         global ann_w  
  243.         global ann_wj0  
  244.         global ann_y0  
  245.         global hidelevel_count  
  246.         global alllevel_count  
  247.         global learn_r  
  248.         global train_a  
  249.         global ann_oldw  
  250.         level=hidelevel_count  
  251.         allevel=alllevel_count  
  252.           
  253.         #清空yi输出信号数组          
  254.         hidelevel=hidelevel_count  
  255.         alllevel=alllevel_count  
  256.         for i in xrange(0,alllevel):  
  257.                 #第一维是层数,从0开始  
  258.                 for j in xrange(0,n):  
  259.                         #第二维是神经元  
  260.                         ann_yi[i][j]=0.0  
  261.         ann_yi=np.array(ann_yi)  
  262.         yi=ann_yi  
  263.   
  264.         #清空delta矩阵  
  265.         for i in xrange(0,hidelevel-1):      
  266.                 for j in xrange(0,n):  
  267.                         ann_delta[i][j]=0.0  
  268.         delta=ann_delta       
  269.         #保留W的拷贝,以便下一次迭代  
  270.         ann_oldw=copy.deepcopy(ann_w)  
  271.         oldw=ann_oldw  
  272.         #前向计算  
  273.   
  274.         #对输入变量进行预处理                
  275.         myo=np.array([])  
  276.         for nowlevel in xrange(0,alllevel):  
  277.                 #一层层向前计算  
  278.                 #计算诱导局部域  
  279.                 my_y=[]  
  280.                 myy=yi[nowlevel-1]   
  281.                 myw=ann_w[nowlevel-1]                  
  282.                 if nowlevel==0:  
  283.                         #第一层隐藏层  
  284.                         my_y=myx  
  285.                         yi[nowlevel]=my_y                          
  286.                 elif nowlevel==(alllevel-1):  
  287.                         #输出层  
  288.                         my_y=o_func(yi[nowlevel-1,:len(myd)])  
  289.                         yi[nowlevel,:len(myd)]=my_y  
  290.                 elif nowlevel==(hidelevel-1):  
  291.                         #最后一层输出层  
  292.                         for i in xrange(0,len(myd)):  
  293.                                 temp_y=sigmoid_func(np.dot(myw[:,i],myy))  
  294.                                 my_y.append(temp_y)                          
  295.                         yi[nowlevel,:len(myd)]=my_y   
  296.                 else:  
  297.                         #中间隐藏层  
  298.                         for i in xrange(0,len(myy)):  
  299.                                 temp_y=sigmoid_func(np.dot(myw[:,i],myy))  
  300.                                 my_y.append(temp_y)  
  301.                         yi[nowlevel]=my_y  
  302.   
  303.        
  304.         #计算误差与均方误差  
  305.         myo=yi[hidelevel-1][:len(myd)]  
  306.         myo_end=yi[alllevel-1][:len(myd)]  
  307.         mymse=get_e(myd,myo_end)  
  308.    
  309.         #反向计算  
  310.         #输入层不需要计算delta,输出层不需要计算W  
  311.   
  312.   
  313.         #计算delta  
  314.         for nowlevel in xrange(level-1,0,-1):  
  315.                 if nowlevel==level-1:  
  316.                         mydelta=delta[nowlevel]  
  317.                         my_n=len(myd)  
  318.                 else:  
  319.                         mydelta=delta[nowlevel+1]  
  320.                         my_n=n  
  321.                 myw=ann_w[nowlevel]                  
  322.                 if nowlevel==level-1:  
  323.                         #输出层  
  324.                         mydelta=delta_sigfun(myo,myd,None,None,None,None,None)  
  325. ##                        mydelta=mymse*myo  
  326.                 elif nowlevel==level-2:  
  327.                         #输出隐藏层的前一层,因为输出结果和前一层隐藏层的神经元数目可能存在不一致  
  328.                         #所以单独处理,传相当于输出隐藏层的神经元数目的数据  
  329.                         mydelta=delta_sigfun(yi[nowlevel],myd,nowlevel,level-1,my_n,mydelta[:len(myd)],myw[:,:len(myd)])  
  330.                 else:  
  331.                         mydelta=delta_sigfun(yi[nowlevel],myd,nowlevel,level-1,my_n,mydelta,myw)  
  332.                           
  333.                 delta[nowlevel][:my_n]=mydelta  
  334.         #计算与更新权值W   
  335.         for nowlevel in xrange(level-1,0,-1):  
  336.                 #每个层的权值不一样  
  337.                 if nowlevel==level-1:  
  338.                         #输出层  
  339.                         my_n=len(myd)  
  340.                         mylearn_r=learn_r*0.8  
  341.                         mytrain_a=train_a*1.6  
  342.                 elif nowlevel==1:  
  343.                         #输入层  
  344.                         my_n=len(myd)  
  345.                         mylearn_r=learn_r*0.9  
  346.                         mytrain_a=train_a*0.8                         
  347.                 else:  
  348.                         #其它层  
  349.                         my_n=n  
  350.                         mylearn_r=learn_r  
  351.                         mytrain_a=train_a  
  352.   
  353.                 pre_level_myy=yi[nowlevel-1]  
  354.                 pretrain_myww=oldw[nowlevel-1]  
  355.                 pretrain_myw=pretrain_myww[:,:my_n]  
  356.   
  357.                 #第二个调整参数  
  358.                 temp_i=[]                  
  359.                   
  360.                 for i in xrange(0,n):  
  361.                         temp_i.append([])  
  362.                         for jj in xrange(0,my_n):  
  363.                                 temp_i[i].append(mylearn_r*delta[nowlevel,jj]*pre_level_myy[i])  
  364.                 temp_rs2=np.array(temp_i)  
  365.                 temp_rs1=mytrain_a*pretrain_myw  
  366.                 #总调整参数  
  367.                 temp_change=temp_rs1+temp_rs2                 
  368.                 my_ww=ann_w[nowlevel-1]                  
  369.                 my_ww[:,:my_n]+=temp_change  
  370.   
  371.         return mymse  
  372.   
  373. def train_update(level,nowtraincount,sigmoid_func,delta_sigfun):  
  374.         '''''一次读取所有样本,然后迭代一次进行训练'''  
  375.         #打乱样本顺序  
  376.         global learn_r  
  377.         global train_a  
  378.         global train_a0  
  379.         global learn_r0  
  380.         global r  
  381.         global x  
  382.         global d  
  383.         global maxtrycount  
  384.         global oldmse  
  385.         x_n=len(x)  
  386.         ids=range(0,x_n)  
  387.         train_ids=[]  
  388.         sample_x=[]  
  389.         sample_d=[]  
  390.   
  391.         while len(ids)>0:  
  392.                 myxz=random.randint(0,len(ids)-1)  
  393.                 train_ids.append(ids[myxz])  
  394.                 del ids[myxz]  
  395.                           
  396.         for i in xrange(0,len(train_ids)):  
  397.                 sample_x.append(x[train_ids[i]])  
  398.                 sample_d.append(d[train_ids[i]])  
  399.         sample_x=np.array(sample_x)  
  400.         sample_d=np.array(sample_d)  
  401.   
  402.                   
  403.         #读入x的每个样本,进行训练          
  404.         totalmse=0.0  
  405.         mymse=float(10**-10)       
  406.         for i in xrange(0,x_n):  
  407.                   
  408.                 mymse=sample_train(sample_x[i],sample_d[i],warray_n,sigmoid_func,delta_sigfun)  
  409.                 totalmse+=sum(mymse*mymse)  
  410.         totalmse=np.sqrt(totalmse/float(x_n))  
  411.         print u"误差为:%f"  %(totalmse)  
  412.         nowtraincount[0]+=1  
  413.         learn_r=learn_r0/(1+float(nowtraincount[0])/r)  
  414.         train_a=train_a0/(1+float(nowtraincount[0])/r)  
  415.         if nowtraincount[0]>=maxtrycount:  
  416.                 return False,True,totalmse                   
  417.         elif totalmse<expect_e:  
  418.         #(totalmse-oldmse)/oldmse>0.1 and (totalmse-oldmse)/oldmse<1:  
  419.                 print u"训练成功,正在进行检验"  
  420.                 totalmse=0.0  
  421.                 for i in xrange(0,x_n):  
  422.                         mytemper=(sample_d[i]-simulate(sample_x[i],sigmoid_func,delta_sigfun))                         
  423.                         totalmse+=sum(mytemper*mytemper)  
  424.                 totalmse=np.sqrt(totalmse/float(x_n))  
  425.                 if totalmse<expect_e:  
  426.                         return False,False,totalmse  
  427.         oldmse=totalmse  
  428.         return True,False,totalmse  
  429.                                  
  430. def train():  
  431.         '''''训练样本,多次迭代'''  
  432.         global hidelevel_count  
  433.         nowtraincount=[]  
  434.         nowtraincount.append(0)  
  435.         #sigmoid函数指定  
  436.         delta_sigfun=ann_delta_atanh  
  437.         sigmoid_func=ann_atanh  
  438.           
  439.         tryerr=0          
  440.         while True:  
  441.                 print u"-------开始第%d次训练---------"%(nowtraincount[0]+1),  
  442.                 iscontinue,iscountout,mymse=train_update(hidelevel_count,nowtraincount,sigmoid_func,delta_sigfun)  
  443.                 if not iscontinue:  
  444.                         if iscountout :  
  445.                                 print u"训练次数已到,误差为:%f"%mymse   
  446.                                 tryerr+=1   
  447.                                 if tryerr>3:  
  448.                                     break  
  449.                                 else:  
  450.                                     print u"训练失败,重新尝试第%d次"%tryerr  
  451.                                     nowtraincount[0]=0  
  452.                                     generate_lw(15+tryerr*2)                                                                                                             
  453.                         else:  
  454.                                 print u"训练成功,误差为:%f"%mymse                                
  455.                                 break  
  456.                 
  457. def simulate(myx,sigmoid_func,delta_sigfun):  
  458.         '''''一个样本的仿真计算'''  
  459.         print u"仿真计算中"          
  460.         global ann_yi  
  461.         global ann_w  
  462.         global ann_wj0  
  463.         global ann_y0  
  464.         global hidelevel_count  
  465.         global alllevel_count  
  466.         global d  
  467.         myd=d[0]  
  468.   
  469.         myx=np.array(myx)  
  470.         n=len(myx)  
  471.   
  472.         level=hidelevel_count  
  473.         allevel=alllevel_count  
  474.           
  475.         #清空yi输出信号数组          
  476.         hidelevel=hidelevel_count  
  477.         alllevel=alllevel_count  
  478.         for i in xrange(0,alllevel):  
  479.                 #第一维是层数,从0开始  
  480.                 for j in xrange(0,n):  
  481.                         #第二维是神经元  
  482.                         ann_yi[i][j]=0.0  
  483.         ann_yi=np.array(ann_yi)  
  484.         yi=ann_yi  
  485.   
  486.         #前向计算  
  487.         myo=np.array([])  
  488.         myy=np.array([])  
  489.         for nowlevel in xrange(0,alllevel):  
  490.                 #一层层向前计算  
  491.                 #计算诱导局部域  
  492.                 my_y=[]  
  493.                 myy=yi[nowlevel-1]  
  494.                 myw=ann_w[nowlevel-1]                  
  495.                 if nowlevel==0:  
  496.                         #第一层隐藏层  
  497.                         my_y=myx  
  498.                         yi[nowlevel]=my_y                          
  499.                 elif nowlevel==(alllevel-1):  
  500.                         #线性输出层,使用线性激活  
  501.                         my_y=o_func(yi[nowlevel-1,:len(myd)])  
  502.                         yi[nowlevel,:len(myd)]=my_y                         
  503.                 elif nowlevel==(hidelevel-1):  
  504.                         #最后一层隐藏输出层,使用线性激活  
  505.                         for i in xrange(0,len(myd)):  
  506.                                 temp_y=sigmoid_func(np.dot(myw[:,i],myy))  
  507.                                 my_y.append(temp_y)                             
  508.                         yi[nowlevel,:len(myd)]=my_y   
  509.                 else:  
  510.                         #中间隐藏层  
  511.                         #中间隐藏层需要加上偏置  
  512.                         for i in xrange(0,len(myy)):  
  513.                                 temp_y=sigmoid_func(np.dot(myw[:,i],myy))  
  514.                                 my_y.append(temp_y)  
  515.                         yi[nowlevel]=my_y  
  516.   
  517.         return yi[alllevel-1,:len(myd)]          
  518. train()  
  519.   
  520. delta_sigfun=ann_delta_atanh  
  521. sigmoid_func=ann_atanh  
  522.   
  523.   
  524. for xn in xrange(0,len(x)):  
  525.         if simulate(x[xn],sigmoid_func,delta_sigfun)[0]>0:  
  526.                 plt.plot(train_x[xn][0],train_x[xn][1],"bo")  
  527.         else:  
  528.                 plt.plot(train_x[xn][0],train_x[xn][1],"b*")  
  529.   
  530.   
  531.                            
  532. temp_x=np.random.rand(20)*10  
  533. temp_y=np.random.rand(20)*20+temp_x  
  534. myx=temp_x  
  535. myy=temp_y  
  536. plt.subplot(111)  
  537. x_max=np.max(myx)+5  
  538. x_min=np.min(myx)-5  
  539. y_max=np.max(myy)+5  
  540. y_min=np.min(myy)-5  
  541. plt.xlim(x_min,x_max)  
  542. plt.ylim(y_min,y_max)  
  543. for i in xrange(0,len(myx)):  
  544.         test=get_siminx([[myx[i],myy[i]]])  
  545.         if simulate(test,sigmoid_func,delta_sigfun)[0]>0:              
  546.                 plt.plot(myx[i],myy[i],"ro")  
  547.         else:  
  548.                 plt.plot(myx[i],myy[i],"r*")    
  549.   
  550. plt.show()  



python机器学习之神经网络(二) (https://mushiming.com/)  第9张

图中蓝色是训练数据,红色是测试数据,圈圈代表类型[1,0],星星代表类型[0,1]

THE END

发表回复