人工智能 实验4.BP神经网络

版权声明：本文为博主原创文章，转载请声明原创网址。 https://blog.csdn.net/lagoon_lala/article/details/88983462

实验四 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'

Anaconda Prompt中输入activate tensorflow

conda install pandas缺啥就安装啥

报错：

(tensorflow) C:\Users\laugo>conda install sklearn Solving environment: failed PackagesNotFoundError: The following packages are not available from current channels:   - sklearn

解决：

(tensorflow) C:\Users\laugo>pip install sklearn

 

一、实验目的与要求

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)，可直接用。

# 包引入，导入鸢尾花的数据 import pandas as pd import numpy as np import matplotlib.pyplot as plt import os     #读入数据集 df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header=None) #查看前十项，给出截图 df.head(10) #使用seaborn对数据进行观察 import seaborn as sns sns.pairplot(dataset.iloc[:, 1:6], hue='Species')   #生成测试数据 X = dataset.iloc[:, 1:4].values y = dataset.iloc[:,4].values #将y字符串数组转换成整数数组，在这里我们可以使用sklearn的LabelEncoder库 from sklearn.preprocessing import LabelEncoder encoder = LabelEncoder() y1 = encoder.fit_transform(y) y1 #最后将y1转成神经网络需要的数组结构 Y = pd.get_dummies(y1).values     #将训练数据与测试数据做分割 #请填入代码 from sklearn.model_selection import train_test_split#分割所需要的包     #创建神经网络模型 #请填入代码   #训练模型，并使用这个模型进行预测，并打印结果 #请填入代码   #对模型进行评估 #请填入代码

 

 

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

具体数据集见mnist_dataset压缩包

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

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 = hidden_nodes = output_nodes = learning_rate = #将mnist的训练数据CSV文件加载到一个列表中 #请输入代码 #训练神经网络 #请输入代码 #进行测试，输出测试结果 #请输入代码

 

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

 

 

四、结果分析

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

 第一个实验源码

 

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)
#请输入代码