神经网络学习算法的实现

导包

import numpy as np
import sys ,os
sys.path.append(os.pardir)
from  common.functions  import *
from common.gradient import numerical_gradient

定义类

分析代码架构

初始参量W的确定,通过pararms这个变量来收集
predict；给出x和W 就可以算出 y
loss:给出y和t； 就可以输出loss
accuracy:写出y和t最大的索引，统计二者相等的次数，除以X的行数
grad:通过关于W的函数和输入值就可以算出对应的grad
grad和pararms都是一对多的字典

class twolayernet:
    def __init__(self,input_size,hidden_size,output_size,weight_init_std=0.01):
        self.pararms={}
        self.pararms['W1']=weight_init_std*np.random.rand(input_size,hidden_size)
        self.pararms['b1']=np.zeros(hidden_size)
        self.pararms['W2']=weight_init_std*np.random.rand(hidden_size,output_size)
        self.pararms['b1']=np.zeros(output_size)

    def predict(self,x):
        W1,W2=self.pararms['W1'],self.pararms['W2']
        b1,b2=self.pararms['b1'],self.pararms['b2']
        a1=np.dot(x,W1)+b1
        z=sigmoid(a1)
        a2=np.dot(z,W2)+b2
        y=softmax(a2)
        return y

    def loss(self,x,t):
        y= self.predict(x)
        loss=cross_entropy_error(y, t)
        return loss
    def accuracy(self,x,t):
        y=self.predict(x)
        y=np.argmax(y,axis=1)
        t=np.argmax(t,axis=1)
        accuracy=np.sum(y==t)/float(x.shape[0])
    def numerical_gradient(self,x,t):
        loss_W=lambda W:self.loss(x,t)
        grads={}
        grads['W1']=numerical_gradient(loss_W,self.pararms['W1'])
        grads['b1']=numerical_gradient(loss_W,self.pararms['b1'])
        grads['W2']=numerical_gradient(loss_W,self.pararms['W2'])
        grads['b2']=numerical_gradient(loss_W,self.pararms['b2'])
        return grads
     

测试

net=twolayernet(input_size=784,hidden_size=100,output_size=10)
print(net.params['W1'].shape)
print(net.params['b1'].shape)
print(net.params['W2'].shape)
print(net.params['b2'].shape)
x=np.random.rand(10,784)  ## 比如图片是一维的，一次神经网络的学习，其实只是占一行而已，784是（1,784）这样的列表
# print(net.predict(x))  # 算一百次它的输出值
t=np.random.rand(10,10)
print(numerical_gradient(x,t))

附属小类

import sys,os
sys.path.append(os.pardir)
import numpy as np
from  common.functions import  cross_entropy_error,softmax
from common.gradient import  numerical_gradient
from common.functions import  softmax,cross_entropy_error
class simplenet:
    def __init__(self):
        self.w=np.random.randn(2,3)  #高斯分布的2X3的矩阵

    def predict(self,x):
        return np.dot(x,self.w)
    def loss(self,x,t):
        z=self.predict(x)
        y=softmax(z)
        loss=cross_entropy_error(y,t)
        return loss

net=simplenet()
# print(net.w)
x=np.array([0.6,0.9])
# p=net.predict(x)
# print(p)
# print(np.argmax(p))
t=np.array([0,0,1])
# print(net.loss(x,t))

##求W的梯度
def f(w):
    return net.loss(x,t)

# f=lambda w:net.loss(x,t)
dw=numerical_gradient(f,net.w)
print(dw)