Python学习之路

Python 神经网络编程

全部 代码片.

#-*- coding = utf-8 -*-
#@Time :  17:39
#@Author : zhang
#@File : irNeuralNet.py
#@Software: PyCharm

#-*- coding = utf-8 -*-
#@Time :  11:44
#@Author : zhang
#@File : neuralNet.py
#@Software: PyCharm

import numpy as np
import scipy.special #S函数所必须得库
import matplotlib.pyplot as plt

class neuralNetwork :
    #初始化代码,只需将设定设置好
    def __init__(self,inputnodes,hiddenodes,outputnodes,learningrate):
        #设置输入输出隐藏点的数量
        self.inodes = inputnodes
        self.hnodes = hiddenodes
        self.onodes = outputnodes
        #以正态分布（第二个参数为边界）正态分布中心值0，0，随机分布权重，最后一个参数为数组形状 3 X 3  当训练的时候权重为转置
        self.wih = np.random.normal(0.0,pow(self.hnodes,-0.5),(self.hnodes,self.inodes))# input 到 hidden,最后一个参数为大小
        self.who = np.random.normal(0.0,pow(self.onodes,-0.5),(self.onodes,self.hnodes))
        # numpy.random.normal(loc=0,scale=1e-2,size=shape)
        #
        #
        # 参数loc(float)：正态分布的均值，对应着这个分布的中心。
        # 参数scale(float)：正态分布的标准差,两边边界
        # 参数size(int 或者整数元组)：输出矩阵的shape，默认为None。
        #权重为随机函数

        # a = np.random.rand(3,3)- 0.5
        #
        # self.wih =(np.random.rand(self.hnodes,self.inodes)-0.5)
        # self.who=(np.random.rand(self.onodes,self.inodes)-0.5)

        #学习率
        self.lr = learningrate
        #s函数
        self.activation_function = lambda x: scipy.special.expit(x) #这里为输出所必须的S函数1+e（-X)分之一
        self.inverse_activation_function = lambda x: scipy.special.logit(x) #为他的反函数
        pass

    def train(self,inputs_list,target_list) : #target就是目标要得到的值
        inputs = np.array(inputs_list,ndmin=2).T#转置变成二维[3][1]
        targets = np.array(target_list,ndmin=2).T#目标函数转置，变成列函数

        #输入层输出和权重相乘；从左到右
        hidden_inputs = np.dot(self.wih,inputs) #矩阵进行点乘获得隐藏层的输入[3][3]*[3][1]
        hidden_outputs = self.activation_function(hidden_inputs)#经过s函数隐藏层的输出[3][1]
        final_inputs = np.dot(self.who,hidden_outputs)
        final_outputs = self.activation_function(final_inputs)
        #计算误差
        output_error = targets - final_outputs      #[3][1]
        hidden_error = np.dot(self.who.T,output_error)
        #神经网络训练  *是对应元素之间的乘法 = e*最终输出（3乘1列） 矩阵相乘前一层矩阵的转置 1乘3 列
        self.who += self.lr*np.dot((output_error*final_outputs*(1.0-final_outputs)),np.transpose(hidden_outputs))
        #print(final_outputs)
        self.wih += self.lr*np.dot((hidden_error*hidden_outputs*(1.0-hidden_outputs)),np.transpose(inputs))

        pass


    def query(self,inputs_list) : #这里为输入列表
        inputs = np.array(inputs_list,ndmin=2).T #转置？？？变成二维数组a[2][3]，变成一竖列
        hidden_inputs = np.dot(self.wih,inputs) #矩阵进行点乘获得隐藏层的输入
        hidden_outputs = self.activation_function(hidden_inputs)#经过s函数隐藏层的输出
        final_inputs = np.dot(self.who,hidden_outputs)
        final_outputs = self.activation_function(final_inputs)

        return final_outputs
    def backquery(self, targets_list):
        # transpose the targets list to a vertical array
        final_outputs = np.array(targets_list, ndmin=2).T

        # calculate the signal into the final output layer
        # 通过反函数得到最终的输入；使用S函数输出的是大于0小于1的数
        final_inputs = self.inverse_activation_function(final_outputs)#P35这里 可能大于1的数值，为各值求和
        # calculate the signal out of the hidden layer
        # 这里的who反置将进一步得到隐藏层的输出
        hidden_outputs = np.dot(self.who.T, final_inputs)#如果不是反转；则正好表达式隐藏层输出和最终层输入相反
        # scale them back to 0.01 to .99
        #从这里开始没看懂
        hidden_outputs -= np.min(hidden_outputs)
        hidden_outputs /= np.max(hidden_outputs)
        hidden_outputs *= 0.98
        hidden_outputs += 0.01
        # calculate the signal into the hidden layer
        hidden_inputs = self.inverse_activation_function(hidden_outputs)
        # calculate the signal out of the input layer
        inputs = np.dot(self.wih.T, hidden_inputs)
        # scale them back to 0.01 to .99
        inputs -= np.min(inputs)
        inputs /= np.max(inputs)
        inputs *= 0.98
        inputs += 0.01

        return inputs


#见证输入隐藏和输出的不同了！
# 隐藏结点选择比输入节点小的值强制网络尝试总结输入的主要特点
input_nodes = 784 #图像共有784个图像
hidden_nodes = 100 #随机没有固定的限制
output_nodes = 10 #输出层应有的节点数量
learning_rate = 0.3
n = neuralNetwork(input_nodes,hidden_nodes,output_nodes,learning_rate)


training_data_file = open("D:\\PycharmProjects\\neuralNetData\\mnist_train.csv",'r')
training_data_list = training_data_file.readlines()#整篇读下来
training_data_file.close()


epochs = 1
for e in range(epochs):
    for record in training_data_list:
        #将记录按行读取出来，每次读取一行
        all_values = record.split(',')#对每一行文本将，号去掉
        inputs = (np.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 #
        targets = np.zeros(output_nodes) + 0.01
        targets[int(all_values[0])] = 0.99
        #将其训练之后得到10个结果，对应哪个值最大便为其中的值
        n.train(inputs,targets)
        pass

    pass


#测试打开csv文件
test_data_file = open("D:\\PycharmProjects\\neuralNetData\\mnist_test.csv",'r')
test_data_list = test_data_file.readlines()#整篇读下来
test_data_file.close()

scorecard = []

for record in test_data_list:#将记录按行读取出来，每次读取一行
    all_values = record.split(',')#对每一行文本将，号去掉

    correct_lable = int(all_values[0])#第一个值即为输出值
    print(correct_lable,"correct_lable")

    #asfarray文本变成实数
    #将其中的值变为0，01到1的区间
    inputs = (np.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 #
    outputs = n.query(inputs)
    lable = np.argmax(outputs)#返回最大值的位置
    print(lable,"networks answer")
    if (lable == correct_lable):
        scorecard.append(1)
    else :
        scorecard.append(0)
        pass
    pass

scorecard_array = np.asarray(scorecard)
print("performance = ",scorecard_array.sum()/scorecard_array.size)

# targets = np.zeros(output_nodes)+0.01
# targets[int(all_values[0])] = 0.99
# #将其训练之后得到10个结果，对应哪个值最大便为其中的值
# n.train(inputs,targets)


# label to test
label = 0
# create the output signals for this label
targets = np.zeros(output_nodes) + 0.01
# all_values[0] is the target label for this record
targets[label] = 0.99
print(targets)

# get image data
image_data = n.backquery(targets)

# plot image data
plt.imshow(image_data.reshape(28,28), cmap='Greys', interpolation='None')
plt.savefig("D:\\PycharmProjects\\neuralNetData\\irrevs.jpg",dpi=500)

'''

data_file1 = open("D:\\PycharmProjects\\neuralNetData\\mnist_test.csv",'r')
data_list1 = data_file1.readlines()
data_file1.close()
# print(len(data_list))
# print(data_list[0])
all_value1 = data_list1[0].split(',')#0便为第1行，1便位第二行
print(all_value1[0])
image_array = np.asfarray(all_value1[1:]).reshape((28,28))
#[1:]表示除了第一个列表以为的所有，即第一个值5 ;;asfarray将文本字符串转化为实数（数字）并创建28乘28的数组
plt.imshow(image_array,cmap='Greys',interpolation='None')#cmp更好的显示手写字符，interpolation每个格之间得区分度
plt.savefig("D:\\PycharmProjects\\neuralNetData\\shu5.jpg",dpi=500)
print(n.query((np.asfarray(all_value1[1:]) / 255.0 * 0.99) + 0.01))

'''