Python实战演练之python实现神经网络模型算法

这篇具有很好参考价值的文章主要介绍了Python实战演练之python实现神经网络模型算法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

 文章来源地址https://www.toymoban.com/news/detail-771539.html

 

python实现神经网络模型算法

Python实战演练之python实现神经网络模型算法,python实战教学,python,开发语言

 

 

Python实战演练之python实现神经网络模型算法,python实战教学,python,开发语言

今天,厾罗和大家分享用Python实现神经网络模型算法,仅用于技术学习交流。

 

Python实战演练之python实现神经网络模型算法,python实战教学,python,开发语言

实现技巧

 

1.导入依赖库

主要是安装相关的依赖库。本文实现的环境为:python 3.7。


from __future__ import division    
import math      
import random    
import pandas as pd  

2.构建BP神经网络类

主要是构建三层反向传播神经网络类。


""" 三层反向传播神经网络 """
class NN:
    def __init__(self, ni, nh, no):
        self.ni = ni + 1                            # 输入层节点
        self.nh = nh + 1                    # 隐藏层节点
        self.no = no                      # 输出层种类
        self.ai = [1.0] * self.ni    
        self.ah = [1.0] * self.nh    
        self.ao = [1.0] * self.no    
        self.wi = self.makeMatrix(self.ni, self.nh)  # 输出层到隐藏层的映射矩阵
        self.wo = self.makeMatrix(self.nh, self.no)  # 隐藏层到输出层的映射矩阵
        for i in range(self.ni):          
            for j in range(self.nh):    
                self.wi[i][j] = self.rand(-0.2, 0.2)  
        for j in range(self.nh):
            for k in range(self.no):
                self.wo[j][k] = self.rand(-2, 2)  
 
    #前向传播,激活神经网络的所有节点
    def update(self, inputs):
        if len(inputs) != self.ni - 1:
            print(len(inputs),self.ni - 1)
            raise ValueError('与输入层节点数不符!')    
        for i in range(self.ni - 1):    
            self.ai[i] = inputs[i]    
        for j in range(self.nh):                  # self.nh表示隐藏层的节点数
            sum = 0.0                            # 激活项a = g(z)  z = Θ^T x ;sum相当于z,每次循环归零
            for i in range(self.ni):                  #通过循环z = Θ^T x ,因为Θ、x均为向量
                sum = sum + self.ai[i] * self.wi[i][j]  #〖 Z〗^((2))=Θ^((1)) a^((1))
            self.ah[j] = self.sigmoid(sum)    # a^((2))=g(z^((2))),这里使用sigmoid()函数作为激活函数
        for k in range(self.no):
            sum = 0.0
            for j in range(self.nh):
                sum = sum + self.ah[j] * self.wo[j][k]  #〖 Z〗^((3))=Θ^((2)) a^((2))
            self.ao[k] = self.sigmoid(sum)    # a^((3))=g(z^((3)))
        return self.ao[:]
    
    #反向传播,计算节点激活项的误差
    def backPropagate(self, targets, lr):               # targets为某样本实际种类分类,lr为梯度下降算法的学习率
        output_deltas = [0.0] * self.no
        for k in range(self.no):
            error = targets[k] - np.round_(self.ao[k])
            output_deltas[k] = self.dsigmoid(self.ao[k]) * error
        # 计算隐藏层的误差
        hidden_deltas = [0.0] * self.nh    
        for j in range(self.nh):
            error = 0.0
            for k in range(self.no):
                error = error + output_deltas[k] * self.wo[j][k]    
            hidden_deltas[j] = self.dsigmoid(self.ah[j]) * error
 
        # 更新输出层权重
        for j in range(self.nh):            # 反向传播算法,求出每个节点的误差后,反向更新权重
            for k in range(self.no):
                change = output_deltas[k] * self.ah[j]    
                self.wo[j][k] = self.wo[j][k] + lr * change   
        # 更新输入层权重
        for i in range(self.ni):                    
            for j in range(self.nh):
                change = hidden_deltas[j] * self.ai[i]
                self.wi[i][j] = self.wi[i][j] + lr * change
        # 计算误差
        error = 0.0
        for k in range(self.no):                                    
            error += 0.5 * (targets[k] - np.round_(self.ao[k])) ** 2  
        return error                                          
 
    #用测试集输出准确率
    def test(self, patterns):                            
        count = 0
        num=0
        for p in patterns:
            target = p[1]
            result = self.update(p[0])                    
            print(p[0], ':', target, '->', np.round_(result))
            num=0
            for k in range(self.no):
                if (target[k] == np.round_(result[k])):
                    num +=1
            print(num)
            if num==3:
                count +=1
            print("******************",(target) == (np.round_(result)),"******************")
            accuracy = int(float(count / len(patterns))*100)
        print('accuracy: %-.9f' % accuracy,"%")      
 
    #输出训练过后神经网络的权重矩阵
    def weights(self):
        print('输入层权重:')
        for i in range(self.ni):
            print(self.wi[i])
        print()
        print('输出层权重:')
        for j in range(self.nh):
            print(self.wo[j])
            
    #用训练集训练神经网络
    def train(self, patterns, iterations=1000, lr=0.1):  
        for i in range(iterations):
            error = 0.0                    
            for p in patterns:            
                inputs = p[0]            
                targets = p[1]            
                self.update(inputs)          
                error = error + self.backPropagate(targets, lr)  
            if i % 100 == 0:
                print("percent:",int(i/iterations*100),"%",'   error: %-.9f' % error)

    #生成区间[a, b)内的随机数
    def rand(self, a, b):    
        return (b - a) * random.random() + a    
    
    # 生成大小 I*J 的矩阵,默认零矩阵
    def makeMatrix(self, I, J, fill=0.0):    
        m = []    
        for i in range(I):    
            m.append([fill] * J)    
        return m   

    # 函数 sigmoid,bp神经网络前向传播的激活函数
    def sigmoid(self, x):
        return 1.0 / (1.0 + math.exp(-x))       
     
    # 函数 sigmoid 的导数,反向传播时使用
    def dsigmoid(self, x):
        return x * (1 - x)

3.读取数据并进行预处理

主要是读取构建分类模型的数据,并进行预处理。

  data = []                            
    raw = pd.read_csv('iris.csv')    
    raw_data = raw.values            
    raw_feature = raw_data[1:, 1:5]    
    for i in range(len(raw_feature)):          
        ele = []                    
        ele.append(list(raw_feature[i]))  
        if raw_data[i][5] == 0:   
            ele.append([0, 0,1])    
        elif raw_data[i][5] == 1:
            ele.append([0,1, 0])
        elif raw_data[i][5] == 2:
            ele.append([1, 1,1])
        else:
            ele.append([0, 0,0])
        data.append(ele)

4.利用构建的BP神经网络预测类,创建神经网络模型

主要是用BP神经网络预测类创建神经网络类模型。

  nn = NN(4, 10, 3)  

5.BP分类模型训练及预测

主要是划分训练集和测试集,并进行BP分类模型训练和预测。

   training = data[1:100]            
    test = data[101:]            
    nn.train(training, iterations=1000)  
    nn.test(test) 

完整源代码


from __future__ import division    
import math      
import random    
import pandas as pd    
import numpy as np
 
""" 三层反向传播神经网络 """
class NN:
    def __init__(self, ni, nh, no):
        self.ni = ni + 1                            # 输入层节点
        self.nh = nh + 1                    # 隐藏层节点
        self.no = no                      # 输出层种类
        self.ai = [1.0] * self.ni    
        self.ah = [1.0] * self.nh    
        self.ao = [1.0] * self.no    
        self.wi = self.makeMatrix(self.ni, self.nh)  # 输出层到隐藏层的映射矩阵
        self.wo = self.makeMatrix(self.nh, self.no)  # 隐藏层到输出层的映射矩阵
        for i in range(self.ni):          
            for j in range(self.nh):    
                self.wi[i][j] = self.rand(-0.2, 0.2)  
        for j in range(self.nh):
            for k in range(self.no):
                self.wo[j][k] = self.rand(-2, 2)  
 
    #前向传播,激活神经网络的所有节点
    def update(self, inputs):
        if len(inputs) != self.ni - 1:
            print(len(inputs),self.ni - 1)
            raise ValueError('与输入层节点数不符!')    
        for i in range(self.ni - 1):    
            self.ai[i] = inputs[i]    
        for j in range(self.nh):                  # self.nh表示隐藏层的节点数
            sum = 0.0                            # 激活项a = g(z)  z = Θ^T x ;sum相当于z,每次循环归零
            for i in range(self.ni):                  #通过循环z = Θ^T x ,因为Θ、x均为向量
                sum = sum + self.ai[i] * self.wi[i][j]  #〖 Z〗^((2))=Θ^((1)) a^((1))
            self.ah[j] = self.sigmoid(sum)    # a^((2))=g(z^((2))),这里使用sigmoid()函数作为激活函数
        for k in range(self.no):
            sum = 0.0
            for j in range(self.nh):
                sum = sum + self.ah[j] * self.wo[j][k]  #〖 Z〗^((3))=Θ^((2)) a^((2))
            self.ao[k] = self.sigmoid(sum)    # a^((3))=g(z^((3)))
        return self.ao[:]
    
    #反向传播,计算节点激活项的误差
    def backPropagate(self, targets, lr):               # targets为某样本实际种类分类,lr为梯度下降算法的学习率
        output_deltas = [0.0] * self.no
        for k in range(self.no):
            error = targets[k] - np.round_(self.ao[k])
            output_deltas[k] = self.dsigmoid(self.ao[k]) * error
        # 计算隐藏层的误差
        hidden_deltas = [0.0] * self.nh    
        for j in range(self.nh):
            error = 0.0
            for k in range(self.no):
                error = error + output_deltas[k] * self.wo[j][k]    
            hidden_deltas[j] = self.dsigmoid(self.ah[j]) * error
 
        # 更新输出层权重
        for j in range(self.nh):            # 反向传播算法,求出每个节点的误差后,反向更新权重
            for k in range(self.no):
                change = output_deltas[k] * self.ah[j]    
                self.wo[j][k] = self.wo[j][k] + lr * change   
        # 更新输入层权重
        for i in range(self.ni):                    
            for j in range(self.nh):
                change = hidden_deltas[j] * self.ai[i]
                self.wi[i][j] = self.wi[i][j] + lr * change
        # 计算误差
        error = 0.0
        for k in range(self.no):                                    
            error += 0.5 * (targets[k] - np.round_(self.ao[k])) ** 2  
        return error                                          
 
    #用测试集输出准确率
    def test(self, patterns):                            
        count = 0
        num=0
        for p in patterns:
            target = p[1]
            result = self.update(p[0])                    
            print(p[0], ':', target, '->', np.round_(result))
            num=0
            for k in range(self.no):
                if (target[k] == np.round_(result[k])):
                    num +=1
            print(num)
            if num==3:
                count +=1
            print("******************",(target) == (np.round_(result)),"******************")
            accuracy = int(float(count / len(patterns))*100)
        print('accuracy: %-.9f' % accuracy,"%")      
 
    #输出训练过后神经网络的权重矩阵
    def weights(self):
        print('输入层权重:')
        for i in range(self.ni):
            print(self.wi[i])
        print()
        print('输出层权重:')
        for j in range(self.nh):
            print(self.wo[j])
 
    #用训练集训练神经网络
    def train(self, patterns, iterations=1000, lr=0.1):  
        for i in range(iterations):
            error = 0.0                    
            for p in patterns:            
                inputs = p[0]            
                targets = p[1]            
                self.update(inputs)          
                error = error + self.backPropagate(targets, lr)  
            if i % 100 == 0:
                print("percent:",int(i/iterations*100),"%",'   error: %-.9f' % error)

    #生成区间[a, b)内的随机数
    def rand(self, a, b):    
        return (b - a) * random.random() + a    
    
    # 生成大小 I*J 的矩阵,默认零矩阵
    def makeMatrix(self, I, J, fill=0.0):    
        m = []    
        for i in range(I):    
            m.append([fill] * J)    
        return m   

    # 函数 sigmoid,bp神经网络前向传播的激活函数
    def sigmoid(self, x):
        return 1.0 / (1.0 + math.exp(-x))       
     
    # 函数 sigmoid 的导数,反向传播时使用
    def dsigmoid(self, x):
        return x * (1 - x)

if __name__ == '__main__':
    data = []                            
    raw = pd.read_csv('iris.csv')    
    raw_data = raw.values            
    raw_feature = raw_data[1:, 1:5]    
    for i in range(len(raw_feature)):          
        ele = []                    
        ele.append(list(raw_feature[i]))  
        if raw_data[i][5] == 0:   
            ele.append([0, 0,1])    
        elif raw_data[i][5] == 1:
            ele.append([0,1, 0])
        elif raw_data[i][5] == 2:
            ele.append([1, 1,1])
        else:
            ele.append([0, 0,0])
        data.append(ele)
    nn = NN(4, 10, 3)  
    training = data[1:100]            
    test = data[101:]            
    nn.train(training, iterations=1000)  
    nn.test(test)

 

Python实战演练之python实现神经网络模型算法,python实战教学,python,开发语言

 

到了这里,关于Python实战演练之python实现神经网络模型算法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Python实现PSO粒子群优化算法优化BP神经网络回归模型(BP神经网络回归算法)项目实战

    说明:这是一个机器学习实战项目(附带数据+代码+文档+视频讲解),如需数据+代码+文档+视频讲解可以直接到文章最后获取。 PSO是粒子群优化算法(Particle Swarm Optimization)的英文缩写,是一种基于种群的随机优化技术,由Eberhart和Kennedy于1995年提出。粒子群算法模仿昆虫、

    2024年02月13日
    浏览(55)
  • Python基于PyTorch实现循环神经网络回归模型(LSTM回归算法)项目实战

    说明:这是一个机器学习实战项目(附带 数据+代码+文档+视频讲解 ),如需 数据+代码+文档+视频讲解 可以直接到文章最后获取。 LSTM网络是目前更加通用的循环神经网络结构,全称为Long Short-Term Memory,翻译成中文叫作“长‘短记忆’”网络。读的时候,“长”后面要稍

    2024年02月16日
    浏览(57)
  • Python基于PyTorch实现循环神经网络分类模型(LSTM分类算法)项目实战

    说明:这是一个机器学习实战项目(附带 数据+代码+文档+视频讲解 ),如需 数据+代码+文档+视频讲解 可以直接到文章最后获取。 LSTM网络是目前更加通用的循环神经网络结构,全称为Long Short-Term Memory,翻译成中文叫作“长‘短记忆’”网络。读的时候,“长”后面要稍

    2024年02月16日
    浏览(52)
  • Python基于PyTorch实现卷积神经网络回归模型(CNN回归算法)项目实战

    说明:这是一个机器学习实战项目(附带 数据+代码+文档+视频讲解 ),如需 数据+代码+文档+视频讲解 可以直接到文章最后获取。 卷积神经网络,简称为卷积网络,与普通神经网络的区别是它的卷积层内的神经元只覆盖输入特征局部范围的单元,具有稀疏连接(sparse connec

    2024年02月15日
    浏览(50)
  • Python基于PyTorch实现卷积神经网络分类模型(CNN分类算法)项目实战

    说明:这是一个机器学习实战项目(附带 数据+代码+文档+视频讲解 ),如需 数据+代码+文档+视频讲解 可以直接到文章最后获取。 卷积神经网络,简称为卷积网络,与普通神经网络的区别是它的卷积层内的神经元只覆盖输入特征局部范围的单元,具有稀疏连接(sparse connec

    2024年02月15日
    浏览(50)
  • LSTM神经网络实现对股市收盘价格的预测实战(python实现 附源码 超详细)

    源码或数据集请点赞关注收藏后评论区留言或者私信博主要 由于独特的设计结构 LSTM适合于处理和预测时间序列中间隔和延迟非常长的重要事件。 LSTM是一种含有LSTM区块(blocks)或其他的一种类神经网络,文献或其他资料中LSTM区块可能被描述成智能网络单元,因为它可以记忆

    2024年02月11日
    浏览(42)
  • Python实现GA遗传算法优化循环神经网络分类模型(LSTM分类算法)项目实战

    说明:这是一个机器学习实战项目(附带数据+代码+文档+视频讲解),如需数据+代码+文档+视频讲解可以直接到文章最后获取。 遗传算法(Genetic Algorithm,GA)最早是由美国的 John holland于20世纪70年代提出,该算法是根据大自然中生物体进化规律而设计提出的。是模拟达尔文生

    2024年02月15日
    浏览(238)
  • Python深度学习实战-基于class类搭建BP神经网络实现分类任务(附源码和实现效果)

    实现功能 上篇文章介绍了用Squential搭建BP神经网络,Squential可以搭建出上层输出就是下层输入的顺序神经网络结构,无法搭出一些带有跳连的非顺序网络结构,这个时候我们可以选择类class搭建封装神经网络结构。 第一步:import tensorflow as tf:导入模块 第二步:制定输入网络

    2024年02月08日
    浏览(61)
  • Python深度学习实战-基于tensorflow原生代码搭建BP神经网络实现分类任务(附源码和实现效果)

            前面两篇文章分别介绍了两种搭建神经网络模型的方法,一种是基于tensorflow的keras框架,另一种是继承父类自定义class类,本篇文章将编写原生代码搭建BP神经网络。 本人读研期间发表5篇SCI数据挖掘相关论文,现在某研究院从事数据挖掘相关科研工作,对数据挖掘

    2024年02月08日
    浏览(54)
  • Python实现ACO蚁群优化算法优化卷积神经网络回归模型(CNN回归算法)项目实战

    说明:这是一个机器学习实战项目(附带数据+代码+文档+视频讲解),如需数据+代码+文档+视频讲解可以直接到文章最后获取。 蚁群优化算法(Ant Colony Optimization, ACO)是一种源于大自然生物世界的新的仿生进化算法,由意大利学者M. Dorigo, V. Maniezzo和A.Colorni等人于20世纪90年代初

    2024年02月05日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包