###2018/6/16 keras_bp###
###非原创 对他人文章进行改编 侵删###
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt 
from keras.optimizers import SGD,adam
from keras.models import Sequential
from keras.layers.core import Dense, Activation

#####参数设置
epoch = 500		#迭代次数
inputnum = 4		#输入节点数
midnum = 10		#隐层节点数
outputnum = 1		#输出节点数
learnrate = 0.1 	#学习率
Terror = 1e-7		#迭代中止条件
datannum = 2688		#样本总数
trainX = 0.7		#训练数据比例
Terror = 0.2		#预测误差低于Terror的比例
#输入数据文件地址
inputfile = 'C:\\Users\\37989\\Desktop\\input.xlsx'   		 	
#输出预测的文件地址
outputfile = 'C:\\Users\\37989\\Desktop\\output.xlsx' 			
#模型保存地址
modelfile = 'C:\\Users\\37989\\Desktop\\modelweight.model' 	
#因子所在列
factor = ['F1','F2','F3','F4']														
#目标所在列
label = ['L1'] 		
																					
#初始处理
trainnum = int(datannum * trainX)
validnum = int((datannum - trainnum) / 2)
testnum = datannum - (trainnum + validnum)
data = pd.read_excel(inputfile,index='Date',sheetname=0) 
listnum = np.random.permutation(datannum)		#打乱序列
data_train = data.loc[listnum[0:trainnum]].copy() 
data_valid = data.loc[listnum[trainnum:trainnum + validnum]].copy()
data_test = data.loc[listnum[trainnum + validnum:datannum]].copy()
data_std = data.max() - data.min()
data_train = (data_train - data.min()) / data_std
data_valid = (data_valid - data.min()) / data_std
x_train = data_train[factor].as_matrix()
y_train = data_train[label].as_matrix()
x_valid = data_valid[factor].as_matrix()
y_valid = data_valid[label].as_matrix() 

#构建模型
model = Sequential()
#初始化权值阈值
model.add(Dense(midnum,input_dim = inputnum,init = 'random_uniform'))	
model.add(Activation('sigmoid'))			#激活函数
model.add(Dense(outputnum,input_dim = midnum))
sgd = SGD(lr = learnrate,decay = Terror,momentum = 0.9,nesterov=True)
model.compile(loss = 'mse',optimizer=sgd)		#目标函数MSE
model.fit(x_train,y_train,nb_epoch = epoch,batch_size = 6,validation_data = (x_valid,y_valid))
model.save_weights(modelfile)

#预测数据
x = ((data_test[factor] - data.min()[factor]) / data_std[factor]).as_matrix()

#写入训练结果
data_test[u'L1_pred'] = model.predict(x) * data_std['L1'] + data.min()['L1']
data_test[u'L1_error'] = round(data_test['L1'] - data_test['L1_pred'],3)
data_test[u'L1_e-per'] =abs(round((data_test['L1_error'] / data_std['L1']) * 100,2))
data_test.to_excel(outputfile) 

#初步分析预测性能
Emin = min(data_test['L1_error'])
Emax = max(data_test['L1_error'])
MSE = (sum(data_test['L1_error'] ** 2) / testnum) ** 0.5
percent = sum(data_test['L1_error'] < Terror) / testnum * 100
print('Emin=',Emin,' Emax=',Emax,' mse=',MSE,'误差低于' + str(Terror) + '的占',percent,'%')

简单的神经网络
从零编写一个简单的神经网络模型，网络模型采用三层架构，分别L0，L1，L2层。假设第一层3个特征（x1，x2，x3），第二层5个神经元，第三层一个输出。
代码实现如下：
import numpy as np

#定义一个sigmoid函数
def sigmoid(x,deriv=False): #False表示正向传播，True表示反向传播
	if deriv==True:
		return x*(1-x) #反向传播，sigmoid函数对x求导（注意x表示什么）
	return 1/(1+np.exp(-x)) #正向传播

#构建数据
#x表示5个训练集样本，3个特征
x=np.array([[0,0,1],[0,1,1],[1,0,1],[1,1,1],[0,0,1]])  # x.shape=5*3
y=np.array([[0],[1],[1],[0],[0]])  # y.shape=5*1

#随机初始化权重参数，为了得到相同的结果，设置一个种子
np.random.seed(1)
#想要随机的取值在[-1，1]之间，np.random.random((5,3))的取值在[0,1]之间
#w0权重参数，五行三列，第一层三个特征（输入），第二层五个神经元
w0=2*np.random.random((5,3))-1 #w0.shape(5*3)
#w1权重参数，一行五列，第三层一个神经元（输出），第二层五个神经元
w1=2*np.random.random((1,5))-1 #w1.shape(1*5)

#L0-输入层 L1-隐藏层 L2-输出层

for i in range(200000): #迭代次数200000
	L0=x #5*3
	#L1层激活单元矩阵
	L1=sigmoid(np.dot(w0,L0.T)) #5*5 
	#L2层激活单元矩阵
	L2=sigmoid(np.dot(w1,L1)) #1*5

	#得到的L2预测值与真实值y之间的误差
	L2_error=L2-y.T #1*5
	
	if i%10000==0: #显示每10000的迭代结果
		print("ERROR:"+str(np.mean(np.abs(L2_error))))
	
	#反向求导
	L2_delta=L2_error * sigmoid(L2,deriv=True) #1*5 不是矩阵相乘，是对应相乘
	L1_error=w1.T .dot(L2_delta) #5*5
	L1_delta=L1_error * sigmoid(L1,deriv=True) #5*5
	w1=w1-L2_delta.dot(L1) #1*5
	w0=w0-L1_delta.dot(L0) #5*3
	

实验结果如下：
ERROR:0.47623293376696657
ERROR:0.006051666884928206
ERROR:0.004165157389013795
ERROR:0.0033625266317263364
ERROR:0.0028926903427863955
ERROR:0.002575570488905583
ERROR:0.0023432574852742466
ERROR:0.0021637266232400823
ERROR:0.0020196546091931352
ERROR:0.0019007494572889055
ERROR:0.0018004632864876003
ERROR:0.0017144065263201853
ERROR:0.0016395123057161953
ERROR:0.00157356485203203
ERROR:0.0015149182685343045
ERROR:0.0014623210855210966
ERROR:0.001414802584411034
ERROR:0.0013715967418066462
ERROR:0.0013320899177631444
ERROR:0.0012957840000224993

1.全连接网络的基本流程
1.有一系列已经归一化的数据

2.一个网络模型y = fcNet(x)


其中





所以从第i层fc到第i+1层的递归公式




3.正向传播
先一个列向量



按照递推公式

输出到模型中得到label，也就是y



4.定义最普通的损失函数



5.bp反向传播

这里面我要解释一下有些数学表达式的写法以免误解
A * B 或者AB的意思是：向量对应分量乘积，既不是矩阵乘法也不是向量内积，因为numpy就是这么定义的比如


A mul B的意思的：A，B矩阵乘积


训练网络最终目的是让y与label（y的真实值）的差距越小越好，也就是使得loss的值最小，所以把loss当成因变量，把fcNet中的所有参数和y的真实值当成自变量，loss关于它们的函数，就是这个样子



分开来就是



其中




流程大家大概都知道，让loss对每个w求导，设求出来的值是


这个就是多元函数



对某一个w的梯度了对吧
然后设置一个学习率，learning = 0.01什么的

然后让每个w



就相当于是梯度更新
但是有三个问题不容易算清楚

1.越是前面的层，它的求导越麻烦，因为涉及到复合函数求导的链式法则

2.前向计算的时候正着来，一个接一个矩阵乘法，反向传播的时候反着往前求导，矩阵的递推关系相比正向计算要复杂一些

3.编程的时候不像我们在纸上面计算，所有的东西都相当于全局变量，随时可以取到它们的值，我编程的时候，一层作为一个fc类，那么这一层的全连接神经网络只能知道本层的

（输入向量值，W参数，输出向量值）

想要知道前一层或者后一层的数据，只能通过前向计算或者反向传播的时候，前层或者后层返回的数据才知道。那么前一层或者后一层传过来的数据，是什么维度的，表示什么含义，一定要统一，不然就乱套了，没有办法传递了

从任意多的全连接层扣出2层来看

考虑这样一个第i层和第i+1层的问题，假如要对第i层的W矩阵求导

那么一定是这样的



其中第一项，跟i+1层有关，第i层是不可能算出来的，所以它应该作为第i+1层传过来的参数


这边可以看出来，表达式（1）的后面两项是可以在本层内计算的，且并不复杂，那第一项呢？
要考虑第一项是怎么样的，可以先考虑一下目前作为第i层，又该往i-1层传什么？先看第i-1层对W求导需要什么


很显然第一项，是需要第i层提供的，而这一项等于



在这个表达式中，第一项是第i+1层提供给第i层的，后两项是第i层自己可以计算到的，这样子，整个bp传播的递推就完整了，整理一下
对于第i层来说


化简一下（4），（5）表达式



所以整个反向传播函数大概这样
def bp(self,last,learning_rate):
        act = np.reshape(self.outx*(1-self.outx),[-1,1])
        p=last*act
        grad = np.matmul(p,np.reshape(self.inx,[1,self.input_dim]))
        pass_next = np.matmul(np.reshape(p,[1,-1]),self.w)
        self.w -= learning_rate*grad 
        return np.reshape(pn,[-1,1])

在整个对loss的前向计算过程中



对于这个图片所描述的网络



把y看成X5(in)

那么第一个last输入就是



也就是说，对于一个回归网络，且用方差作为损失函数的话，第一个last就是


然后就开始试着用自己写的网络训练了，以下为代码
2代码
1.定义自己的全连接层结构fc

默认激活函数为sigmoid
import numpy as np
class fc():
    def __init__(self,input_dim,out_dim,name):
        self.name = name
        self.input_dim = input_dim
        self.out_dim = out_dim
        self.w = np.random.uniform(-0.2,0.2,(self.out_dim,self.input_dim)) 
        self.b = np.random.uniform(-0.5,0.5,(self.out_dim))
        self.disable = np.ones([self.out_dim,self.input_dim])
        self.inx =np.zeros([self.input_dim])
        self.outx =np.zeros([self.out_dim])
    
    def forward(self,x):
        self.inx = x
        self.outx = self.sigmoid(np.matmul(self.w,self.inx))+self.b
        return self.outx
    
    def bp(self,last,learning_rate):
        act = np.reshape(self.outx*(1-self.outx),[-1,1])
        p=last*act
        grad = np.matmul(p,np.reshape(self.inx,[1,self.input_dim]))
        pn = np.matmul(np.reshape(p,[1,-1]),self.w)
        self.w -= learning_rate*grad 
        return np.reshape(pn,[-1,1])

    def sigmoid(self,x):
        return 1/(1+np.exp(-x))

    

2.定义网络结构Net

这里定义了4层
class Net():
    def __init__(self):
        self.fc1 = fc(4,256,'fc1')
        self.fc2 = fc(256,64,'fc2')
        self.fc3 = fc(64,128,'fc3')
        self.fc4 = fc(128,1,'fc3')
    
    def forword(self,x):
        x = self.fc1.forward(x)
        x = self.fc2.forward(x)
        x = self.fc3.forward(x)
        x = self.fc4.forward(x)
        return x
    
    def bp(self,E,learning_rate):
        E4 = self.fc4.bp(E,learning_rate)
        E3 = self.fc3.bp(E4,learning_rate)
        E2 = self.fc2.bp(E3,learning_rate)
        E1 = self.fc1.bp(E2,learning_rate)

3.创建网络实例
fcNet = Net()

4.读取数据并查看了前4行

这边我随便找了一个aistudio上的数据集

股票数据集

因为这个代码可以处理的是回归问题，多个输入，一个输出
import pandas as pd
CSV_FILE_PATH = './work/AAPL.csv'
df = pd.read_csv(CSV_FILE_PATH)
df[:4]



5.简单处理数据，归一化，减均值除以标准差
x = df[['Open', 'High', 'Low', 'Close', 'Volume']]
x = np.array(x)
avg = x.sum(axis=0)/len(x)
avg
o =[0,0,0,0,0] 
for i in x:
    o[0]+=i[0]**2
    o[1]+=i[1]**2
    o[2]+=i[2]**2
    o[3]+=i[3]**2
    o[4]+=i[4]**2
xn = (x-avg)/(np.array(o)**0.5)

6.定义一次训练过程的函数
import random
def once(losses,learning_rate):
    c =0
    losssum =0
    index = [i for i in range(len(xn))]
    random.shuffle(index)
    for i in index:
        c+=1
        d = xn[i][:4]
        l = xn[i][4:5]
        loss= abs(fcNet.forword(d) - l)
        fcNet.bp(loss,learning_rate)
        losssum+=loss**2
        if(c%300==0):
            print(losssum)
            losses.append(losssum)
            losssum=0
    

7.开始训练，用一个列表保存每300次更新后，损失函数的值，并打印输出
losses = []
learn_rate = 0.0003
for i in range(1,10):
    print('now,learning_rate={}'.format(learn_rate))
    once(losses,learn_rate)

8.画图，看一下训练过程中损失函数的减小趋势
import matplotlib.pyplot as plt
plt.plot([i for i in range(len(losses))],losses)

Build a neural network from Scratch
文章目录
Build a neural network from Scratch
1. Node
2. Variable
3. Linear
4. Relu
5. Sigmoid
6. MSE
7. Session
8. main

1. Node
class Node:
    '''
        name 该节点标识
        inputs 指向该节点的节点
        outputs 出节点
        is_trainable 是否在梯度下降中更新，只有参数is_trainable=True,中间结果不必更新,输入输出数据不能更新
        value 前向传播求值
        gradients 记录loss对inputs的偏导
    '''
    def __init__(self,name=None,inputs=None,is_trainable=None):
        self.inputs=inputs
        self.outputs=[]
        self.name=name
        self.is_trainable=is_trainable
        '''
                编程时为每个节点指定输入节点，每个node自动为输入节点添加出节点，从而每个节点获取输入和输出节点
        '''
        if self.inputs:
            for _ in self.inputs:
                _.outputs.append(self)
        
    self.value=None
    
    self.gradients={}
    '''
                在当前自身完成前向计算
                例如linear self.value=weight*x+bias
    '''
    def forward(self):
        raise NotImplementedError
    '''
        loss对每个参数的偏导由该参数指向的output节点计算出
        x-k->output
        partial loss/partial k = partial loss/partial output * partial output/partial k
                其中partial loss/partial output在反向传播到该节点之前已经计算好，在反向传播到output结点时
        output节点需要将partial output/partial k计算好并存储到output节点上
    '''
    def backward(self):
        raise NotImplementedError

    def __repr__(self):
        return self.name
    '''
        toString()
    '''
    def __str__(self):
        return self.name

2. Variable
from selfMadeNeutralNetwork.Node import Node
'''
    Variable表示k,b,x等变量
        在图中为叶节点
'''
class Variable(Node):
    
    def __init__(self,name=None,is_trainable=True):
        super().__init__(name=name,is_trainable=is_trainable)
    
    def forward(self,value=None):
        if value:
            self.value=value
    
    def backward(self):
        for output in self.outputs:
            self.gradients[self]=output.gradients[self] * 1

3. Linear
from selfMadeNeutralNetwork.Node import Node
import numpy as np

class Linear(Node):
    
    def __init__(self,x=None,weight=None,bias=None,name=None,is_trainable=False):
        super().__init__(inputs=[x,weight,bias],name=name,is_trainable=is_trainable)
    
    def forward(self):
        k,x,b = self.inputs[1].value,self.inputs[0].value,self.inputs[2].value
        self.value=np.dot(k,x)+b
    
    def backward(self):
        k,x,b = self.inputs[1],self.inputs[0],self.inputs[2]
        
        for output in self.outputs:
            loss_for_linear_gradient = output.gradients[self]
            
            self.gradients[k] = np.dot(loss_for_linear_gradient,x.value)
            self.gradients[x] = np.dot(loss_for_linear_gradient,k.value)
            self.gradients[b] = loss_for_linear_gradient*1

4. Relu
from selfMadeNeutralNetwork.Node import Node
import numpy as np

class Relu(Node):
    
    def __init__(self,x=None,name=None,is_trainable=False):
        super().__init__(inputs=[x],name=name,is_trainable=is_trainable)
        self.x=x
    
    def forward(self):
        self.value=self.x.value
    
    def backward(self):
        for output in self.outputs:
            grad_cost = output.gradients[self]
            self.gradients[self.x]=np.dot(grad_cost,(self.x.value>0))

5. Sigmoid
from selfMadeNeutralNetwork.Node import Node
import numpy as np

class Sigmoid(Node):
    def __init__(self,x=None,name=None,is_trainable=False):
        super().__init__(inputs=[x],name=name,is_trainable=is_trainable)
        self.x=self.inputs[0]
        
    def _sigmoid(self,x):
        return 1/(1+np.exp(-1*x))
    
    def forward(self):
        self.value=self._sigmoid(self.x.value)
        
    def partial(self):
        return np.dot(self._sigmoid(self.x.value), 1-self._sigmoid(self.x.value))
    
    def backward(self):
        for output in self.outputs:
            loss_for_sigmoid_gradient = output.gradients[self]
            self.gradients[self.x] = np.dot(loss_for_sigmoid_gradient,self.partial())

6. MSE
from selfMadeNeutralNetwork.Node import Node
import numpy as np

class MSE(Node):
    
    def __init__(self,y=None,yhat=None,name=None,is_trainable=False):
        super().__init__(inputs=[y,yhat],name=name,is_trainable=is_trainable)
        self.y=y
        self.yhat=yhat
    
    def forward(self):
        y_v = np.array(self.y.value)
        yhat_v = np.array(self.yhat.value)
        
        self.value=np.mean((y_v-yhat_v)**2)
    
    def backward(self):
        y_v = np.array(self.y.value)
        yhat_v = np.array(self.yhat.value)
        
        self.gradients[self.y]=2*np.mean(y_v-yhat_v)
        self.gradients[self.yhat]=-2*np.mean(y_v-yhat_v)

7. Session
from _collections import defaultdict

import matplotlib.pyplot as plt
import networkx as nx
from selfMadeNeutralNetwork.Variable import Variable

'''
graph 建图
valid_order 拓扑排序节点顺序
X_node 填入数据节点
y_node 结果节点
yhat 预测节点
cost cost节点
cost_history cost历史记录
'''
class Session:
    
    def __init__(self,session_result=None):
        self.graph=None
        self.valid_order=None
        self.X_node=session_result[0]
        self.y_node=session_result[1]
        self.yhat=session_result[2]
        self.cost_history=[]
    
    def feed(self,feed_dict):
        self.graph = self.convert_feed_dict_to_graph(feed_dict)
        nx_graph = nx.DiGraph(self.graph)
        self.valid_order = list(nx.topological_sort(nx_graph))
    '''
            梯度下降优化
    '''
    def optimize(self, learning_rate=1e-3):
        for node in self.graph:
            if node.is_trainable:
                node.value = node.value + (-1)*node.gradients[node]*learning_rate
    
    def forward(self):
        for node in self.valid_order:
            node.forward()
    
    def backward(self):
        for node in self.valid_order[::-1]:
            node.backward()
    
    '''
            前向传播和反向传播一轮
    '''
    def run_one_epoch(self):
        self.forward()
        self.backward()
    '''
    feed_dict={
            X_node:X_rm,
            y_node:y,
            w1:w1_,
            w2:w2_,
            b1:b1_,
            b2:b2_
        }
    feed_dict中只有初始化的参数和要输入的数据，
    注意在定义output的时候已经把每个节点的output设置好，定义变量就是一个建图的过程
    
    最终返回一个字典
    {
    node1:[outputs]
    node2:[outputs]
    node3:[outputs]
    }
    '''
    def convert_feed_dict_to_graph(self,feed_dict):
        computing_graph=defaultdict(list)
        # 只获得每个节点的内存
        nodes = [n for n in feed_dict]
        
        while nodes:
            n = nodes.pop(0)
            if isinstance(n, Variable):
                n.value=feed_dict[n]
            
            if n in computing_graph:
                continue
            
            for m in n.outputs:
                computing_graph[n].append(m)
                nodes.append(m)
    
        return computing_graph

    def predict(self,predict_x):
        self.X_node.value=predict_x
        self.run_one_epoch()
        return self.yhat.value

8. main
from sklearn.datasets import load_boston
from tqdm import tqdm

import numpy as np
from matplotlib import pyplot as plt
from selfMadeNeutralNetwork.Session import Session
from selfMadeNeutralNetwork.Linear import Linear
from selfMadeNeutralNetwork.MSE import MSE
from selfMadeNeutralNetwork.Sigmoid import Sigmoid
from selfMadeNeutralNetwork.Variable import Variable

def show_loss_history(loss_history):
    plt.plot(loss_history)
    plt.show()

def main():
    data=load_boston()
    X,y=data["data"],data["target"]
    # 卧室数量
    X_rm=X[:,5]
    # 随机参数
    w1_,b1_=np.random.normal(),np.random.normal()
    w2_,b2_=np.random.normal(),np.random.normal()
    
    X_node,y_node = Variable(name="X"),Variable(name="y")
    w1,b1 = Variable(name="w1"),Variable(name="b1")
    w2,b2 = Variable(name="w2"),Variable(name="b2")
    
    output1 = Linear(x=X_node,weight=w1,bias=b1,name="Linear-01")
    output2 = Sigmoid(x=output1,name="activation")
    yhat = Linear(x=output2,weight=w2,bias=b2,name="yhat")
    cost = MSE(y=y_node,yhat=yhat,name="cost")
    
    feed_dict={
        X_node:X_rm,
        y_node:y,
        w1:w1_,
        w2:w2_,
        b1:b1_,
        b2:b2_
    }
    session_result=[X_node,y_node,yhat]
    session = Session(session_result)
    session.feed(feed_dict)
    
    # 总体的轮数
    epoch = 1000
    # 每个batch的数目
    batch_num=len(X_rm)
    # 学习率
    learning_rate=1e-3
    loss_history = []
    
    for _ in tqdm(range(epoch)):
        loss=0
        for __ in range(batch_num):
            # 每次从X_rm中随机抽取一个元素
            index = np.random.choice(range(len(X_rm)))
            X_node.value=X_rm[index]
            y_node.value=y[index]
            
            session.run_one_epoch()
            session.optimize(learning_rate)
            loss+=cost.value
        loss_history.append(loss/batch_num)
        if _%100==0:
            print("Epoch:{},Loss:{:.3f}".format(_+1, loss/batch_num))
    
    show_loss_history(loss_history)
    print(session.predict(6))

if __name__=="__main__":
    main()