人工智能 实验4.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'

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字符串数组转换成整数数组,在这里我们可以使用sklearnLabelEncoder

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.csvmnist_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

       

        #链接权重矩阵,wihwho

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

 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 博客之星2020 设计师:CY__ 返回首页