神经网络原理及python实现（三）

四：ANN Classifier算法实现：

import numpy as np;
from numpy import random,mat,multiply,sqrt;
import scipy.special as ss;
import random as R;
import copy;
from sklearn.neighbors import KNeighborsClassifier;
import time;
class ANNclassifier:
    __all__=['fit','predict'];
    def __init__(self,learningrate=0.5):
        self.w_input_hidden=[];
        self.w_hidden_output=[];
        self.lr=learningrate;
        self.dict_label=dict();
        self.sigmoid=lambda x:ss.expit(x);
    
    def outputlabel(self,a):
        from collections import Counter
        b=[x[0] for x in Counter(a).most_common()];
        b.sort();
        c=[];
        for i in range(len(b)):
            temp=[0.01]*len(b);
            temp[i]=0.99;
            c.append(temp);
        e=[(i,c[b.index(i)]) for i in b];
        d=dict(e);
        return d;

    def findlabel(self,diction,value):
        for key in diction:
            if diction[key]==value:
                return key;
        return 0;
    
    def rate_err_w(self,err,inp,outp):
        # print(err,outp,'-------------------------',sep='\n');
        rate=multiply(err,outp);
        # print(rate,(1-outp),'----------------------',sep='\n');
        rate=multiply(rate,(1-outp));
        # print(rate,inp.T,'---------------------',sep='\n');
        rate=np.matmul(rate,inp.T);
        # print(rate,'----------------------',sep='\n')
        return rate;

    def fit(self,data,label):
        from collections import Counter
        # n: the number of candidate of data
        # m: the number of element of each candidate
        n,m=mat(data).shape;
        label=[x[0] for x in label];
        m2=len([x[0] for x in Counter(label).most_common()]);
        self.dict_label=self.outputlabel(label);

        self.w_input_hidden=random.normal(0.0,pow(int(m/2),-0.5),(int(m/2),m));
        self.w_hidden_output=random.normal(0.0,pow(m2,-0.5),(m2,int(m/2)));
        for i in range(n):
            layer_input=mat(data[i]).T;   #input layer
            layer_hidden=self.sigmoid(np.matmul(self.w_input_hidden,layer_input));    
            # hidden layer
            layer_output=self.sigmoid(np.matmul(self.w_hidden_output,layer_hidden));  
            # output layer
            # print(label[i],self.dict_label);
            err_output=mat(self.dict_label[label[i]]).T-layer_output;
            err_hidden=mat(np.matmul(self.w_hidden_output.T,err_output));  
            #upgrade---------------------------------------------------
            # err back with weight
             
          self.w_hidden_output+=self.lr*self.rate_err_w(err_output,layer_hidden,layer_output);
            self.w_input_hidden+=self.lr*self.rate_err_w(err_hidden,layer_input,layer_hidden);

    def predict(self,data):
        y=[];
        for i in range(len(data)):
            layer_input=mat(data[i]).T;
            layer_hidden=self.sigmoid(np.matmul(self.w_input_hidden,layer_input));
            layer_ouput=self.sigmoid(np.matmul(self.w_hidden_output,layer_hidden));
            xp=[x[0] for x in layer_ouput.tolist()];

            # print(xp);
            xp=np.round(xp)*0.98+0.01;
            xp=xp.tolist();
            # print(xp);

            y.append([self.findlabel(self.dict_label,xp)]);
        return y;

五：参考文献：

【1】智能优化算法及其MATLAB实例，包子阳，余继周，电子工业出版社

【2】python神经网络编程，[英]塔里克*拉希德，人民邮电出版社