人工智能 实验4.BP神经网络_用bp神经网络做一个手写数字的识别和预测,实验可以先从小样本尝试训练和测试,然后

实验四 BP神经网络

第一个http://www.pianshen.com/article/903699656/，源代码有错误

参考：http://www.mamicode.com/info-detail-2417017.html

seaborn官网上有更完整的示例，有兴趣可以查看：http://seaborn.pydata.org/generated/seaborn.pairplot.html

安装Keras：

http://www.mamicode.com/info-detail-2180288.html

https://blog.csdn.net/violetmokkkk/article/details/81709915

注意查看anaconda中的py版本，高于该版本安装会出现错误

安装pandas：

ModuleNotFoundError: No module named 'pandas'

conda install pandas缺啥就安装啥

报错：

解决：

 

一、实验目的与要求

1）掌握BP神经网络的原理。

2）了解BP神经网络的结构，以及前向传播和反向传播的过程。

3）学会利用BP神经网络建立训练模型，并对模型进行评估。

4）学会使用BP神经网络做预测。

二、实验内容

1）利用BP神经网络实现对鸢尾花的分类和预测，对数据进行可视化，分析数据的特点，建立模型，并对模型进行评估。数据集已给出

df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header=None)，可直接用。

 

 

2）用BP神经网络做一个手写数字的识别和预测，实验可以先从小样本尝试做一下训练和测试。然后再用大样本进行训练和测试，观察两者结果的差异性。本次实验给出的数据集是：mnist_train_10.csv，mnist_test_10.csv(小样本)

具体数据集见mnist_dataset压缩包

mnist_train.csv, mnist_test.csv（大样本，训练集为60000个.）

 

三、实验结果（截图+模型评估）

 

 

四、结果分析

   请分别对预测结果进行分析。

 第一个实验源码

 

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam
from sklearn.metrics import classification_report
 
dataset = pd.read_csv('iris.csv')
sns.pairplot(dataset.iloc[:, 1:6], hue='Species')
X=dataset.iloc[:, 1:5].values
y=dataset.iloc[:,5].values
encoder=LabelEncoder()
y1=encoder.fit_transform(y)
Y=pd.get_dummies(y1).values
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=0)
 
 
model = Sequential()
model.add(Dense(10, input_shape=(4,), activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(6, activation='relu'))
model.add(Dense(3, activation='softmax'))
 
model.compile(Adam(lr=0.04), 'categorical_crossentropy', metrics=['accuracy'])
model.summary()
 
model.fit(X_train, y_train, epochs=100)
y_pred=model.predict(X_test)
y_pred_class=np.argmax(y_pred,axis=1)
y_test_class=np.argmax(y_test,axis=1)
report=classification_report(y_test_class, y_pred_class)
print(report)

 第二个实验源码

import numpy as np
import scipy.special as S
import matplotlib.pyplot as plt
class neuralNetwork:
#初始化神经网络,构造函数
    def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
        #设置每个输入、隐藏、输出层中的节点数
        self.inodes = inputnodes
        self.hnodes = hiddennodes
        self.onodes = outputnodes
        
        #链接权重矩阵，wih和who
        # weights inside the arrays are w_i_j, where link is from node i to node j in the next layer
        # w11 w21
        # w12 w22 etc 
        self.wih = np.random.normal(0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))
        self.who = np.random.normal(0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))
        #学习率
        self.lr = learningrate
        #创建激活函数（函数的另一种定义方法,这样以后可以直接调用）
        self.activation_function = lambda x: S.expit(x)
        
        pass
#训练神经网络
    def train(self, inputs_list, targets_list):
        #将输入列表转换成二维数组
        inputs=np.array(inputs_list, ndmin = 2).T
        targets=np.array(targets_list, ndmin = 2).T
        
        #将输入信号计算到隐藏层
        hidden_inputs = np.dot(self.wih, inputs)
        #计算隐藏层中输出的信号(使用激活函数计算)
        hidden_outputs = self.activation_function(hidden_inputs)
        #将传输的信号计算到输出层
        final_inputs = np.dot(self.who, hidden_outputs)
        #计算输出层中输出的信号（使用激活函数）
        final_outputs = self.activation_function(final_inputs)
        
        #计算输出层的误差：（target - actual）(预期目标输出值-实际计算得到的输出值)
        output_errors = targets - final_outputs
        #隐藏层的误差：是输出层误差按权重分割，在隐藏节点上重新组合
        hidden_errors = np.dot(self.who.T, output_errors)
        
        #反向传播，更新各层权重
        #更新隐层和输出层之间的权重
        self.who += self.lr*np.dot((output_errors*final_outputs*(1.0 - final_outputs)), np.transpose(hidden_outputs))
        #更新输入层和隐藏层之间的权重
        self.wih += self.lr*np.dot((hidden_errors*hidden_outputs*(1.0 - hidden_outputs)), np.transpose(inputs))
        #pass一般用于占位置，定义一个空函数程序会报错，当没有想好函数的内容可以用pass填充，使得程序正常运行
        pass
    
#查询神经网络：接受神经网络的输入，返回神经网络的输出
    def query(self, inputs_list):
        #将输入列表转换成二维数组
        inputs = np.array(inputs_list, ndmin = 2).T
        
        #将输入信号计算到隐藏层
        hidden_inputs = np.dot(self.wih, inputs)
        #将信号从隐藏层输出
        hidden_outputs = self.activation_function(hidden_inputs)
        #将信号引入到输出层
        final_inputs = np.dot(self.who, hidden_outputs)
        #将信号从输出层输出
        final_outputs = self.activation_function(final_inputs)
        #返回输出层的输出值
        return final_outputs
#请设置输入、隐藏、输出层中的节点数，和学习率
input_nodes=784
hidden_nodes=200
output_nodes=10
learning_rate=0.3
n=neuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate)
#将mnist的训练数据CSV文件加载到一个列表中
training_data_file = open("mnist_train.csv", 'r')
training_data_list = training_data_file.readlines()
training_data_file.close()
#请输入代码
#训练神经网络
epochs = 5
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
        n.train(inputs, targets)
        pass
    pass
#请输入代码
#进行测试，输出测试结果
test_data_file = open("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_label = int(all_values[0])
    inputs = (np.asfarray(all_values[1:]) / 255.0*0.99) + 0.01
    outputs = n.query(inputs)
    outputs_max_label = np.argmax(outputs)
    if (outputs_max_label == correct_label):
        scorecard.append(1)
    else:
        scorecard.append(0)
        pass
    pass
 
scorecard_array=np.asarray(scorecard)
print("performace=", scorecard_array.sum()/scorecard_array.size)
#请输入代码