[转载] python(numpy) 实现神经网络训练 (卷积 全连接 池化)

最新推荐文章于 2024-09-10 09:53:43 发布
最新推荐文章于 2024-09-10 09:53:43 发布
阅读量524 收藏
点赞数
原文链接：https://blog.csdn.net/junqing_wu/article/details/105601246?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161162102216780264036470%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=161162102216780264036470&biz_id
版权

参考链接： Python中的numpy.flipud

cnn_numpy 

使用numpy实现神经网络，在mnist上进行训练、测试 

目前包括已下算子: 

 卷积 Conv2D(name="conv2",in_channels= 6, out_channels= 12,kernel_size=3,stride=1,padding=1)  全连接 FC FC(name="full1",in_channels=28*28, out_channels= 512)  池化  

MaxPollingAvgPolling MaxPooling('pool2',ksize=2,stride=2), # 7*7*32 AvgPolling('pool2',ksize=2,stride=2), # 7*7*32 

激活函数 

SigmoidReluTanhSoftmax 

损失函数 

CE 交叉熵损失MSE 均方根损失 

构建网络例子 

# 构建一个 conv+fc 的网络

class Net(Module):

    def __init__(self):

        super(Net,self).__init__()

        

        self.layers = [

            Conv2D(name="conv1",in_channels= 1, out_channels= 6,kernel_size=3,stride=1,padding=1), # 1*28*28

            MaxPooling('pool1',ksize=2,stride=2), # 6*14*14

            Tanh(name='relu'),

 

            Conv2D(name="conv2",in_channels= 6, out_channels= 12,kernel_size=3,stride=1,padding=1),

            MaxPooling('pool2',ksize=2,stride=2), # 12*7*7

            Tanh(name='relu2'),

 

            FC(name="full1",in_channels= 12*7*7 , out_channels= 512),

            Tanh(name="sigmoid1"),

            FC(name="full2",in_channels=512,out_channels=128),

            Tanh(name="sigmoid2"),

            FC(name="full3",in_channels=128,out_channels=10),

        ]

 

Layer Module 基类定义 

class Layers():

    def __init__(self,name):

        self.name = name

    # 前向

    def forward(self,x):

        pass

       # 梯度置零

    def zero_grad(self):

        pass

    # 后向

    def backward(self,grad_out):

        pass

    # 参数更新

    def update(self,lr=1e-3):

        pass

 

 

class Module():

    def __init__(self):

        self.layers = []  # 所有的Layer

 

    def forward(self,x):

        for layer in self.layers:

            x = layer.forward(x)

        return x

 

    def backward(self,grad):

        for layer in reversed(self.layers):

            layer.zero_grad()

            grad = layer.backward(grad)

    

    def step(self,lr=1e-3):

        for layer in reversed(self.layers):

            layer.update(lr)

 

Layer 层需要实现前向forward 、 反传backward 、置零梯度zero_grad 、更新参数update功能，Module 主要用来 拼接所有的Layer， 实现流程化的前向预测 后向训练 

FC层 

import numpy as np

from module import Layers

 

class FC(Layers):

    def __init__(self,name,in_channels,out_channels):

        super(FC,self).__init__(name)

        self.weights = np.random.standard_normal((in_channels,out_channels))

        self.bias = np.zeros(out_channels)

 

        self.grad_w = np.zeros((in_channels,out_channels))

        self.grad_b = np.zeros(out_channels)

 

    def forward(self, input):

        self.in_shape = input.shape 

        input = np.reshape(input,(input.shape[0],-1)) # flat

        self.input = input

        return np.dot(input,self.weights)+self.bias

 

    def backward(self,grad_out):

        N = grad_out.shape[0]

        dx = np.dot(grad_out,self.weights.T)

 

        self.grad_w = np.dot(self.input.T,grad_out)

        self.grad_b = np.sum(grad_out,axis=0)

 

        return dx.reshape(self.in_shape)

    

    def zero_grad(self):

        self.grad_w.fill(0)

        self.grad_b.fill(0)

 

    def update(self,lr=1e-3):

        self.weights -= lr*self.grad_w  

        self.bias -= lr*self.grad_b

 

FC测试 

使用单个fc层 模拟 y=wx+b 函数 

if __name__ == '__main__':

    # 初始化一个 固定的 w b, 然后 根据w b 生成 训练数据

    w = np.random.randn(100,1)

    b = np.random.randn(1)

    x_data = np.random.randn(500,100)  # data

    label = np.dot(x_data,w)+b  # label

        

    layer = FC('fc',100,1)

 

    for i in range(10000):

        index = i%(500-10)

        x = x_data[index:index+10] # batch = 10

        y = label[index:index+10]  

 

        out = layer.forward(x)

        # mse loss 

        loss = np.mean(np.sum(np.square(out-y),axis=-1))

        # mse_loss 的 梯度  

        dy = out-y

        layer.zero_grad()

        grad = layer.backward(dy)

        layer.update(1e-3)  # 更新参数

 

        if i%1000==0:

            print(loss)

 

Conv2d 

import numpy as np

from module import Layers

 

class Conv2D(Layers):

    def __init__(self,name,in_channels,out_channels, kernel_size, stride,padding,bias=True):

        super(Conv2D,self).__init__(name)

 

        self.in_channels = in_channels

        self.out_channels = out_channels

        self.ksize = kernel_size

        self.stride = stride

        self.padding = padding

        

        self.weights = np.random.standard_normal((out_channels,in_channels,kernel_size,kernel_size))

        self.bias = np.zeros(out_channels)

        

        self.grad_w = np.zeros(self.weights.shape)

        self.grad_b = np.zeros(self.bias.shape)

    '''  另一种实现方式，效率比较低，多重循环 嵌套

    def _sing_conv(self,x):

        x = np.pad(x,((0,0),(0,0),(self.padding,self.padding),(self.padding,self.padding)),'constant',constant_values=0)

        b,c,h,w = x.shape

        oh = (h-self.ksize)//self.stride +1

        ow = (w-self.ksize)//self.stride +1

        out = np.zeros((b,self.out_channels,oh,ow))

        for n in range(b):

            for d in range(self.out_channels):

                for i in range(0,oh,1):

                    for j in range(0,ow,1):

                        _x = i*self.stride

                        _y = j*self.stride

                        out[n,d,i,j] = np.sum(x[n,:,_x:_x+self.ksize,_y:_y+self.ksize]*self.weights[d,:,:,:])#+self.bias[d]

        return out

    '''

    def forward(self,x):

        self.x = x

        weights = self.weights.reshape(self.out_channels,-1) # o,ckk

 

        x = np.pad(x,((0,0),(0,0),(self.padding,self.padding),(self.padding,self.padding)),'constant',constant_values=0)

        b,c,h,w = x.shape

 

        self.out = np.zeros((b,self.out_channels,(h-self.ksize)//self.stride +1,(w-self.ksize)//self.stride +1))

        

        self.col_img = self.im2col(x,self.ksize,self.stride) # bhw * ckk

        out = np.dot(weights,self.col_img.T).reshape(self.out_channels,b,-1).transpose(1,0,2)

        

        self.out = np.reshape(out,self.out.shape)

 

        return self.out

 

    def backward(self,grad_out):

        b,c,h,w = self.out.shape  # 

        

        grad_out_ = grad_out.transpose(1,0,2,3) #b,oc,h,w * (bhw , ckk)

        grad_out_flat = np.reshape(grad_out_, [self.out_channels, -1])

        

        self.grad_w = np.dot(grad_out_flat,self.col_img).reshape(self.grad_w.shape)

        self.grad_b = np.sum(grad_out_flat,axis=1)

        tmp = self.ksize - self.padding - 1

        grad_out_pad = np.pad(grad_out,((0,0),(0,0),(tmp,tmp),(tmp,tmp)),'constant',constant_values=0)

        

        flip_weights = np.flip(self.weights, (2, 3))

        # flip_weights = np.flipud(np.fliplr(self.weights)) # rot(180)

        flip_weights = flip_weights.swapaxes(0,1) # in oc

        col_flip_weights = flip_weights.reshape([self.in_channels,-1])

        

        weights = self.weights.transpose(1,0,2,3).reshape(self.in_channels,-1)

        

        col_grad = self.im2col(grad_out_pad,self.ksize,1) #bhw,ckk

        

        # (in,ckk) * (bhw,ckk).T 

        next_eta = np.dot(weights,col_grad.T).reshape(self.in_channels,b,-1).transpose(1,0,2) 

        

        next_eta = np.reshape(next_eta, self.x.shape)

       

        return next_eta

 

    def zero_grad(self):

        self.grad_w = np.zeros_like(self.grad_w)

        self.grad_b = np.zeros_like(self.grad_b)

 

    def update(self,lr=1e-3):

        self.weights -= lr*self.grad_w  

        self.bias -= lr*self.grad_b

 

    def im2col(self,x,k_size,stride):

        b,c,h,w = x.shape

        image_col = []

        for n in range(b):

            for i in range(0,h-k_size+1,stride):

                for j in range(0,w-k_size+1,stride):

                    col = x[n,:,i:i+k_size,j:j+k_size].reshape(-1)

                    image_col.append(col)

        

        return np.array(image_col)

 

# test_conv 

if __name__ == '__main__':

    x = np.random.randn(5,3,32,32)

    conv = Conv2D('conv1',3,12,4,1,1)

    y = conv.forward(x)

    print(y.shape)

    loss = y-(y+1)

    grad = conv.backward(loss)

    print(grad.shape)

 

实现主要借鉴了im2col的思想，将conv操作转换成 普通的矩阵乘操作(FC)，这个就不介绍了，感觉有很多介绍的文章，大家感兴趣可以去看一下； 

Pooling 

import numpy as np

from module import Layers

 

class MaxPooling(Layers):

    def __init__(self, name, ksize=2, stride=2):

        super(MaxPooling,self).__init__(name)

        self.ksize = ksize

        self.stride = stride 

 

    def forward(self, x):

        n,c,h,w = x.shape

        out = np.zeros([n, c, h//self.stride,w//self.stride])

        self.index = np.zeros_like(x)

        for b in range(n):

            for d in range(c):

                for i in range(h//self.stride):

                    for j in range(w//self.stride):

                        _x = i*self.stride

                        _y = j*self.stride

                        out[b, d ,i , j] = np.max(

                            x[b, d ,_x:_x+self.ksize, _y:_y+self.ksize])

                        index = np.argmax(x[b, d ,_x:_x+self.ksize, _y:_y+self.ksize])

                        self.index[b,d,_x+index//self.ksize, _y+index%self.ksize] = 1

        return out

 

    def backward(self, grad_out):

        return np.repeat(np.repeat(grad_out, self.stride, axis=2), self.stride, axis=3) * self.index

 

# AvgPooling 在完整代码中有实现

 

激活函数 

这个求导很容易，大家可以从激活函数开始一点点理解 反向传播的整个过程 

from module import Layers

import numpy as np

 

class Relu(Layers):

    def __init__(self,name):

        super(Relu,self).__init__(name)

 

    def forward(self,input):

        self.input = input

        return np.maximum(input, 0)

 

    def backward(self,grad_out):

        grad_out[self.input<0]=0

        return grad_out

 

class Sigmoid(Layers):

    def __init__(self, name):

        super(Sigmoid,self).__init__(name)

    def forward(self,input):

        self.output = 1/(1+np.exp(-input))

        return self.output

    def backward(self,grad):

        grad = grad * self.output*(1-self.output)

        return grad

 

class Tanh(Layers):

    def __init__(self, name):

        super(Tanh,self).__init__(name)

    def forward(self,input):

        a = np.exp(input)

        b = np.exp(-input)

        self.output = (a-b)/(a+b)

        return self.output

    def backward(self,grad):

        grad = grad * (1-self.output*self.output)

        return grad

 

Loss 

from module import Layers

import numpy as np

 

def Softmax(input):

    vec_max = np.max(input,axis=1,keepdims=True)  

    input -= vec_max

    exp = np.exp(input) 

    softmax_pro = exp/np.sum(exp,axis=1,keepdims=True)

    return softmax_pro

 

class CrossEntropyLoss():

    def __init__(self, reduce='mean'):

        super(CrossEntropyLoss,self).__init__()

        self.reduce = reduce

 

    def __call__(self,pred,label):

        # self.softmax_p = Softmax(pred)

        self.softmax_p = pred

        self.real = label

        loss = 0

        for i in range(label.shape[0]):

            loss += -np.log( self.softmax_p[i,label[i]] )

        if self.reduce == 'mean':

            loss /= label.shape[0]

        grad = self.grad()

        return loss,grad

        

    def grad(self):

        grad = self.softmax_p.copy()

        for i in range(self.real.shape[0]):

            grad[i,self.real[i]] -= 1

        return grad 

        

class MSELoss():

    def __init__(self, reduce='mean'):

        super(MSELoss,self).__init__()

        self.reduce = reduce

 

    def __call__(self,pred,label):

        assert pred.shape == label.shape, 'pred and gt shape must be same'

        loss = np.sum(np.square((pred-label)),axis=-1)

        if self.reduce == 'mean':

            loss = np.mean(loss)

        else:

            loss = np.sum(loss)

        grad = (pred-label)

        return loss,grad

 

这个比较麻烦的就是CE的求导，其实最后推导完 其导数就是pi-1，这个可以参考这个，解释的比较清楚，大家一步步推导就可以了 

softmax交叉熵损失函数及其求导 

Mnist训练 

 使用全连接层训练可以达到92%的准确率，这个使用了全部数据集 6w训练 1w测试  使用 Conv+FC 训练, 因为训练特别慢，只用了1w训练集进行训练, 训练5个epoch后,在测试集上达到70准确率，验证了代码的有效性  

 

 训练优化器使用基本的SGD，默认使用的1e-3初始学习率，使用过大学习率的话会学飞，有时间尝试一下Adam; 

 

# log print

epoch: 19 iter: 57500 loss: 0.2737244704525886 acc: 0.902 n_correct: 51956

epoch: 19 iter: 58000 loss: 0.1859380691846724 acc: 0.902 n_correct: 52417

epoch: 19 iter: 58500 loss: 0.2722464711524591 acc: 0.903 n_correct: 52894

epoch: 19 iter: 59000 loss: 0.06477324861968438 acc: 0.903 n_correct: 53369

epoch: 19 iter: 59500 loss: 0.08215275528987825 acc: 0.903 n_correct: 53844

 

 

TODO 

添加优化器算法添加BN层 

代码链接 Git仓库

ey_snail
关注
基于Python.Numpy实现BP卷积神经网络识别手写数字源码(含超详细注释+使用说明).zip
05-15
parameters：神经网络训练结果保存路径 figure：该文档中的图片 2.文件 activate.py：激活函数层，包含Sigmoid，SoftMax bp.py：BP神经网络层，全连接层 BPmain.py：BP神经网络测试文件 CNNmain.py：卷积神经网络...
【AI达人特训营】AdaptFormer：一种新型fine-tuning方法复现
m0_63642362的博客
06-23 771
AdaptFormer 论文地址：https://arxiv.org/abs/2205.13535简介： 港大，腾讯AI实验室，港中文贡献的文章：AdaptFormer: Adapting Vision Transformers for Scalable Visual Recognition. 研究人员认为最新的transformer文章做的是same network with task-specific weight工作，用的是同样的网络，但是对每个下游任务都要fine-tune模型，这样的模型是不可拓展
理解ViT（结合代码）
Orange_sparkle的博客
09-07 4247
关于vit的网络详解建议去b站看我b站导师的视频这篇文章只讲述我看完视频和代码之后对ViT的理解，特别是代码中是怎么实现的网络结构。
【机器学习】使用Numpy实现神经网络训练全流程
最新发布
weixin_43799388的博客
09-10 1170
曾经在面试一家大模型公司时遇到的面试真题，当时费力写了一个小时才写出来，自然面试也挂了。后来复盘，发现反向传播掌握程度还是太差，甚至连梯度链式传播法则都没有弄明白。
相对位置编码，绝对位置编码代码pytorch实现
qq_43733107的博客
09-29 4593
相对位置编码代码
卷积神经网络
u012132349的博客
05-10 2235
目录 概述 卷积层 卷积层的产生 卷积运算 填充 步幅 应用滤波器后的输出数据大小计算 三维数据的卷积运算 批处理（‘四维数据’） 池化层 卷积层和池化层的Python实现 im2col介绍 im2col的Python实现 卷积层的实现 池化层的实现 CNN的实现 概述 卷积神经网络（Convolutional Neural Network），简称CNN，CNN...
快速卷积运算_教你从何从0开始使用Numpy实现卷积层
weixin_39962770的博客
12-08 976
CNN中的卷积操作 卷积层是CNNs网络中可以说是最重要的层了，卷积层的主要作用是对输入图像求卷积运算。如下图所示，输入图片的维数为[c_0,h_0,w_0] ；卷积核的维数为[c_1,c_0,h_k,w_k]，其中c_0在图中没有表示出来，一个卷积核可以看成由c_1个维数为[c_0,h_k,w_k]的三维滤波器组成；除了这些参数通常在计算卷积运算的时候还有一些超参数比如：stride(步长)：S...
基于Python.Numpy实现卷积神经网络，识别手写数字.zip
05-18
基于Python.Numpy实现卷积神经网络，识别手写数字 卷积神经网络（Convolutional Neural Networks, CNNs 或 ConvNets）是一类深度神经网络，特别擅长处理图像相关的机器学习和深度学习任务。它们的名称来源于网络中...
Convnet:Python - Numpy 卷积神经网络
05-31
本项目"Convnet: Python - Numpy 卷积神经网络"旨在提供一个基础的实现，帮助开发者了解卷积层、池化层和全连接层等核心组件的工作细节。 在Numpy中实现CNN，首先需要理解以下几个关键概念： 1. **卷积操作**：...
深度学习入坑篇-池化及numpy实现
zqwwwm的博客
03-19 2865
前言       卷积神经网络（ConvNets或CNNs）作为一类神经网络，托起cv的发展，本文主要介绍卷积神经网络的另外一个操作——池化操作，其原理，并以小白视角，完成池化从0到1的numpy实现。 1       作为小白入坑篇系列，开始今天的算子池化，错过其他算子的请关注公众号所向披靡的张大刀后台领取。       池化一词开始视觉机制，指的是资源的合并、整合，英文为pooling，中文直译过来即为池化。池化操作（也称为子采样或下采样）主要为了降低每个特征图的维数，可以减少参数矩阵的尺寸，从而减少最
【图像分类案例】(9) MobileNetV3 癌症图像二分类，附Pytorch完整代码
博观而约取，厚积而薄发
06-06 3317
今天和各位分享一下如何使用 Pytorch 构建 MobileNetV3 卷积神经网络，并基于 权重迁移学习 方法解决图像二分类问题，并且评价数据集的 召回率、精准率、F1 等。MobileNetV3 的原理和 TensorFlow2 实现方法可以看我下面这篇博文，强烈建议大家先看一下，本文就不赘述原理了：https://blog.csdn.net/dgvv4/article/details/123476899把博文中的代码按顺序组合在一起就能直接运行首先导入网络构建过程中需要用到的所有工具包，本小....
【神经网络架构】Swin Transformer细节详解-1
博观约取，厚积薄发
01-29 5535
图3。(a) Swin Transformer (Swin-T)的架构; (b)两个连续的Swin Transformer Blocks(符号见公式(3))。W-MSA和SW-MSA分别是具有规则（regular）窗口配置和移动（shifted）窗口配置的multi-head self attention modules。 源码： GitHub - microsoft/Swin-Transformer: This is an official implementation for "Swin ...
【语义分割】语义分割经典模块
热门推荐
AI爱好者的博客，分享计算机领域相关知识
03-15 1万+
本文将介绍深度学习语义分割任务中常用的几个模块，主要包括：ASPP、PP、Encoding、JPU、DCM几个模块，分析其原理并给出对应的代码实现，相信一定对你有所帮助。
python(numpy) 实现神经网络训练 (卷积 全连接 池化)
junqing_wu的博客
04-18 1972
cnn_numpy 使用numpy实现神经网络，在mnist上进行训练、测试 目前包括已下算子: 卷积 Conv2D(name="conv2",in_channels= 6, out_channels= 12,kernel_size=3,stride=1,padding=1) 全连接 FC FC(name="full1",in_channels=28*28, out_channels= 5...
维度变换法
qq_44198647的博客
03-24 784
维度
深度学习之CNN入门基础——1.卷积及numpy实现
weixin_60368327的博客
06-02 769
本文转载自AIHIA盟友公众号：所向披靡的张大刀卷积神经网络（ConvNets或CNNs）作为人工智能的入门神经网络，已被广泛用于图像识别和分类等领域。除了为机器人和自动驾驶汽车提供视觉之外，ConvNets 在识别人脸、物体和交通标志方面也应用广泛。其中卷积操作作为cnn的灵魂，其出现加快了人工智能的发展。卷积一词一开始出现在数学中，为了表示一个函数对另外一个函数所有微量的响应的总叠加效应；其本质上是一种过滤器，在一维信号上完成对信号的过滤，在二维图像上完成为图像的一种过滤，过滤掉其不重要部分，提取主要特
Python Numpy中 keepdims解释
AI_JOKER的博客
08-22 618
import numpy as np a = np.array([[0,3],[1,4]]) #a.shape是（2,2） #axis=1表示按行相加，并且保持其二维特性 print(np.sum(a, axis=1, keepdims=True)) # 按行相加，不保持其二维特性 print(np.sum(a, axis=1)) 输出为 array([[3], [5]])，shape是（2,...
python有没有卷积神经网络库_python实现卷积神经网络
weixin_39818264的博客
12-10 515
1 #! /usr/bin/env python2 #-*- coding: utf-8 -*-34 from numpy import *5 importnumpy as np6 importmatplotlib.pyplot as plt7 importmatplotlib.image as mgimg8 importmath9 importgParam10 importcopy11 impo...
用NumPy搭建简单神经网络
weixin_43465794的博客
11-01 557
用NumPy搭建简单神经网络 模型代码 公共父类 后面所有类都需要继承该类，并实现其方法。 from abc import abstractmethod import numpy as np class Module(object): def __init__(self) -> None: super(Module, self).__init__() @abstractmethod def forward(self): pass
Python+Numpy构建手写数字BP卷积神经网络教程
资源包中包含一个完整的文件夹结构，其中包含了数据集、神经网络训练和测试的相关文件，以及绘制图像的文件夹。具体来说，包含了用于加载数据集、定义网络层、实现激活函数、卷积层、池化层、BP神经网络层以及测试...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值