精华内容
下载资源
问答
  • 用高效Java矩阵库(EJML)编写的简单神经网络库 成功训练了MNIST。 使用784个输入,1个具有128个神经元隐藏层,10个输出,所有层均为Sigmoid以及45分钟训练,达到了95.07%精度。 RELU,泄漏RELU已添加。 ...
  • ###2018/6/16 keras_bp### ###非原创 对他人文章进行改编 侵删### import pandas as pd import numpy as np ...print('Emin=',Emin,' Emax=',Emax,' mse=',MSE,'误差低于' + str(Terror) + '占',percent,'%')
    ###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,'%')
    
    
    




    展开全文
  • 简单的神经网络

    千次阅读 2020-01-16 16:32:53
    从零编写一个简单的神经网络模型,网络模型采用三层架构,分别L0,L1,L2层。假设第一层3个特征(x1,x2,x3),第二层5个神经元,第三层一个输出。 代码实现如下: import numpy as np #定义一个sigmoid函数 ...

    简单的神经网络

    从零编写一个简单的神经网络模型,网络模型采用三层架构,分别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)
    #想要随机的取值在[-11]之间,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
    
    展开全文
  • 用matlab编写的BP神经网络用于预测房价一个程序。在人工神经网络的实际应用中, 大多数人工神经网络模型是采用前馈反向传播网络 ( Back- Propagation Net work , 简称 BP网络 )或它变化形式。它是前向网络...
  • 1.全连接网络的基本流程 1.有一系列已经归一化数据 2.一个网络模型y = fcNet(x) 其中 所以从第i层fc到第i+1层递归公式 3.正向传播 先一个列向量 按照递推公式 输出到模型中得到label,也就是y 4.定义最...

    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 Scratch1. Node2. Variable3. Linear4. Relu5. Sigmoid6.... inputs 指向该节点节点 outputs 出节点 is_trainable 是

    Build a neural network from Scratch

    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()
    
    展开全文
  • 简单的三层神经网络进行手写数字的图片内容的识别,全部代码是自行编写,用于神经网络的层次化学习
  • 亲自教你动手制作神经网络。Github源码地址:https://github.com/hzka/PythonNetworkBook2.1 Python Python是一种计算机程序设计语言。是一种动态、面向对象脚本语言,最初被设计用于编写自动化脚本(shell),...
  • python简单神经网络

    2017-09-18 15:23:34
    根据慕课网“机器学习-实现简单神经网络编写的python代码,实验环境为anaconda python3.6,感知器算法进行分类,数据为网上花瓣数据,100个样本
  • 原标题:用Keras编写你的第一个神经网络,用不了30行代码!回想起刚接触AI时,我清楚地...在自行用Python代码编写一个简单的神经网络之前,不妨介绍一下神经网络以及为何它如此令人兴奋!HNC Software的联合创始人Ro...
  • 目前已经有许多现成的深度学习框架,为什么我们还要用C++来编写一个神经网络?...这篇文章实现了一个最简单的神经网络框架,适合大家入门学习。 参考代码链接:https://github.com/webbery/MiniEngi...
  • 简单的三层神经网络

    千次阅读 2019-03-31 10:44:21
    简单的三层神经网络 上一篇是手动编写了一个感知机,对手写数字的数据集进行识别训练。趁热打铁,手动编写了一个三层的简单神经网络再次对手写数字的数据集进行识别训练,来看看最后的识别率能够达到什么程度。有...
  • 卷积神经网络是深度学习基础,但是学习CNN却不是那么简单,虽然网络上关于CNN相关代码很多,比较经典是tiny_cnn(C++)、DeepLearnToolbox(Matlab)等等,但通过C语言来编写CNN却比较少,本人因为想在多核...
  • 上一篇说到windows下面的Theano安装,在前面的文章中也介绍了几种常见的神经网络形式,今天就使用Theano来编写一个简单的神经网络   我把Theano形容成一个模子,这个模子提供了一些计算方法,然后我们只需要定义...
  • 全文共2392字,预计学习时长11分钟图源:unsplash人工智能,深度学习,这些词是不是...假如你只是了解人工神经网络基础理论,却从未踏足如何编写,跟着本文一起试试吧。你将会对如何在PyTorch 库中执行人工神经网络...
  • Caffe修炼之路(3)——自己编写卷积神经网络(一)前 言(二)网络proto文件编写(三)Solver配置(四)开始训练 (一)前 言 上一节我们跑了Caffe自带的MNIST示例,感觉用Caffe训练还是挺简单的,不由得说一句: ...
  • 一个神经网络来预测每日自行车出租量 Udacity深度学习纳米学位计划一部分。 在这个项目中,您将建立第一个神经网络,并用它来预测每日自行车租赁客流量。 我们提供了一些代码,但是神经网络的实现大部分由您...
  • 一个简单的三层神经网络,内含训练用数据集以及测试用数据集,手动用python编写
  • 学习人工智能时,我给自己定了一个目标--用Python写一个简单的神经网络。为了确保真得理解它,我要求自己不使用任何神经网络库,从头写起。多亏了Andrew Trask写得一篇精彩的博客,我做到了!下面贴出那九行代码:...
  • 基于《神经网络和深度学习》这本绝好的教材提供的相关资料和代码,我们自己动手编写“随机取样的梯度下降神经网络”。为了更好地说明问题,我们先从简单的开始: 1、sigmod函数,基本上就是基于定义的; ######...
  • 上一篇说到windows下面的Theano安装,在前面的文章中也介绍了几种常见的神经网络形式,今天就使用Theano来编写一个简单的神经网络   我把Theano形容成一个模子,这个模子提供了一些计算方法,然后我们只需要...
  • 一篇很好的文章,用Python编写简单的BP神经网络,并几乎将所有代码解释了一遍。原文链接如下:http://python.jobbole.com/82758/ 我在研究之后,自己试着重复那段程序,经过思考,终于理解了。下面是我在eclipse...
  • 基于《神经网络和深度学习》这本绝好的教材提供的相关资料和代码,我们自己动手编写“随机取样的梯度下降神经网络”。为了更好地说明问题,我们先从简单的开始: 1、sigmod函数,基本上就是基于定义的; #...
  • 同上一篇博客PyTorch笔记 入门:写一个简单的神经网络1:Regression(回归)相同 2.创建网络 3.优化器 4.训练网络 6.画出loss的图像 7.预测 完整代码 import torch import torch.nn.functional as F from ...
  • 卷积神经网络是深度学习基础,但是学习CNN却不是那么简单,虽然网络上关于CNN相关代码很多,比较经典是tiny_cnn(C++)、DeepLearnToolbox(Matlab)等等,但通过C语言来编写CNN却比较少,本人因为想在多核...
  • 文章目录让 tensorflow 编写神经网络像砍瓜切菜一样流畅在设计神经网络的过程中,用 tensorflow 是一个很好选择用 keras 可以调用tensorflow 让 tensorflow 编写神经网络像砍瓜切菜一样流畅 篇首语: 凡是能用...
  • 基于《神经网络和深度学习》这本绝好的教材提供的相关资料和代码,我们自己动手编写“随机取样的梯度下降神经网络”。为了更好地说明问题,我们先从简单的开始:1、sigmod函数,基本上就是基于定义的; ########...
  • 三、编写网络 1.设计网络 实现左边那个三层的简单网络 input layer的神经元个数:n_input hidden layer的神经元个数:n_hidden output layer的神经元个数:n_output 有些人又将n_input写为n_features 2.init(初始...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 415
精华内容 166
关键字:

编写简单的神经网络