卷积神经网络——简单的卷积神经网络构建（包含卷积、池化、全连接）

最新推荐文章于 2024-06-04 09:03:19 发布
最新推荐文章于 2024-06-04 09:03:19 发布
阅读量195 收藏
点赞数
文章标签： 1024程序员节 计算机视觉 人工智能 python 深度学习 cnn 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60461719/article/details/134018476
版权

参考：鱼书——斋藤康毅

网络结构

请添加图片描述
主要包含卷积层、激活函数、池化层、Dropout、全连接层。

首先初始化。
隐藏层就是一个小型的BP神经网络，放的是全连接层。图像经过卷积层得到像素特征，并在前向传播的过程中获得权重加持后的图像。在多次卷积后，特征图大小会有所减少。具体计算方式按照卷积和池化的顺序计算：
C o n v h = 1 + H + 2 ⋅ p a d − f i l t e r h s t r i d e ( C o n v w 同理 ) Conv_h = 1 + \frac{H + 2 \cdot pad - filter_h}{stride}\quad \quad(Conv_w同理) Convh​=1+strideH+2⋅pad−filterh​​(Convw​同理)

P o o l O u t h = 1 + C o n v h − p o o l h s t r i d e PoolOut_h = 1 + \frac{Conv_h - pool_h}{stride} PoolOuth​=1+strideConvh​−poolh​​

按照代码所给参数，经过六个卷积和多个池化的输出特征图大小为：

Modulesize, pad, strideFeature Map Size
Conv3, 1, 128
Relu–28
Conv3, 1, 128
Relu–28
Pool2, --, 214
Conv3, 1, 114
Relu–14
Conv3, 2, 116
Relu–16
Pool2, --, 28
Conv3, 1, 18
Relu–8
Conv3, 1, 18
Relu–8
Pool2, --, 24

在卷积和池化过程中，通道数逐渐被修改为filter_num，也就是滤波器个数（包含卷积和池化）。
在最后池化结束后，进入到全连接层，输入数据为 64 ⋅ P o o l O u t h ⋅ P o o l O u t w 64 \cdot PoolOut_h \cdot PoolOut_w 64⋅PoolOuth​⋅PoolOutw​.
在源代码中，有一个pre_node_nums = np.array([1*3*3, 16*3*3, 16*3*3, 32*3*3, 63*3*3, 64*4*4] + hidden_size_list，全连接层的神经元个数取决于上一层个数，而卷积的神经元个数取决于通道数（或者filter_num） * feature_map_h* feature_map_w。所以我认为，原作者在这里有点问题，应该写成1*28*28, 16*28*28, 16*28*28, 32*14*14, 32*16*16, 64*8*8, 64*4*4.
接下来就是构建网络层，没有什么好讲的。需要注意的是第一个全连接层的输入为64*4*4, 相当于有64个通道，4 * 4大小的图片。
最后就是权重更新之类的工作，训练写成了一个trainer类，就是斋藤老爷子的写法，代码放在最后。

网络代码：

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import pickle
import numpy as np
from collections import OrderedDict
from common.layers import *


class DeepConvNet:
    def __init__(self, hidden_size_list=[200, 10, 50, 20], input_dim=(1, 28, 28),
                 conv_param_1={'filter_num': 16, 'filter_size': 3, 'pad': 1, 'stride': 1},
                 conv_param_2={'filter_num': 16, 'filter_size': 3, 'pad': 1, 'stride': 1},
                 conv_param_3={'filter_num': 32, 'filter_size': 3, 'pad': 1, 'stride': 1},
                 conv_param_4={'filter_num': 32, 'filter_size': 3, 'pad': 2, 'stride': 1},
                 conv_param_5={'filter_num': 64, 'filter_size': 3, 'pad': 1, 'stride': 1},
                 conv_param_6={'filter_num': 64, 'filter_size': 3, 'pad': 1, 'stride': 1},
                 output_size=10, dropout_ratio=0.5):
        self.hidden_size_list = hidden_size_list

        pre_node_nums = np.array([1*28*28, 16*28*28, 16*28*28, 32*14*14, 32*16*16, 64*8*8, 64*4*4] + hidden_size_list)

        weight_init_scales = np.sqrt(2.0 / pre_node_nums)
        # if weight_init_scales.lower() in ('relu', 'he'):
        #     weight_init_scales = np.sqrt(2.0 / pre_node_num)
        # elif weight_init_scales.lower() in ('relu', 'he'):
        #     weight_init_scales = np.sqrt(1.0 / pre_node_num)

        self.params = {}
        pre_channel_num = input_dim[0]

        for idx, conv_param in enumerate([conv_param_1, conv_param_2, conv_param_3, conv_param_4, conv_param_5, conv_param_6]):
            self.params['W' + str(idx+1)] = weight_init_scales[idx] * np.random.randn(conv_param['filter_num'], pre_channel_num, conv_param['filter_size'], conv_param['filter_size'])
            self.params['b' + str(idx+1)] = np.zeros(conv_param['filter_num'])
            pre_channel_num = conv_param['filter_num']  # 要注意这个

        self.params['W7'] = weight_init_scales[6] * np.random.randn(64*4*4, hidden_size_list[0])
        self.params['b7'] = np.zeros(hidden_size_list[0])
        self.params['W' + str(7 + len(hidden_size_list))] = weight_init_scales[len(weight_init_scales)-1] * np.random.randn(hidden_size_list[-1], output_size)
        self.params['b' + str(7 + len(hidden_size_list))] = np.zeros(output_size)

        index = 0
        # for idx in range(7, 7+len(hidden_size_list)):
        for idx in range(7, 7+len(hidden_size_list)-1):
            self.params['W' + str(idx+1)] = weight_init_scales[idx] * np.random.randn(hidden_size_list[index], hidden_size_list[index+1])
            self.params['b' + str(idx+1)] = np.zeros(hidden_size_list[index+1])
            index = index + 1

        self.layers = []
        self.layers.append(Convolution(self.params['W1'], self.params['b1'],
                                       conv_param_1['stride'], conv_param_1['pad']))  # 0
        self.layers.append(Relu())  # 1
        self.layers.append(Convolution(self.params['W2'], self.params['b2'],
                                       conv_param_1['stride'], conv_param_1['pad']))  # 2
        self.layers.append(Relu())  # 3
        self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))  # 4
        self.layers.append(Convolution(self.params['W3'], self.params['b3'],
                                       conv_param_1['stride'], conv_param_1['pad']))  # 5
        self.layers.append(Relu())  # 6
        self.layers.append(Convolution(self.params['W4'], self.params['b4'],
                                       conv_param_4['stride'], conv_param_4['pad']))  # 7
        self.layers.append(Relu())  # 8
        self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))  # 9
        self.layers.append(Convolution(self.params['W5'], self.params['b5'],
                                       conv_param_5['stride'], conv_param_5['pad']))  # 10
        self.layers.append(Relu())  # 11
        self.layers.append(Convolution(self.params['W6'], self.params['b6'],
                                       conv_param_6['stride'], conv_param_6['pad']))  # 12
        self.layers.append(Relu())  # 13
        self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))  # 14
        self.layers.append(Affine(self.params['W7'], self.params['b7']))  # 15
        self.layers.append(Relu())  # 16
        self.layers.append(Dropout(0.5))  # 17
        # for idx in range(7, 7+len(hidden_size_list)):
        for idx in range(7, 7+len(hidden_size_list)-1):
            self.layers.append(Affine(self.params['W' + str(idx+1)], self.params['b' + str(idx+1)]))  # 18 21 24
            self.layers.append(Relu())  # 19 22 25
            self.layers.append(Dropout(dropout_ratio))  # 20 23 26
        self.layers.append(Affine(self.params['W' + str(7 + len(hidden_size_list))], self.params['b' + str(7 + len(hidden_size_list))]))  # 27
        self.layers.append(Dropout(dropout_ratio))

        self.last_layer = SoftmaxWithLoss()

    def predict(self, x, train_flg=False):
        for layer in self.layers:
            if isinstance(layer, Dropout):
                x = layer.forward(x, train_flg)
            else:
                x = layer.forward(x)
        return x

    def loss(self, x, t):
        y = self.predict(x, train_flg=True)
        return self.last_layer.forward(y, t)

    def accuracy(self, x, t, batch_size=100):
        if t.ndim != 1 : t = np.argmax(t, axis=1)

        acc = 0.0

        for i in range(int(x.shape[0] / batch_size)):
            tx = x[i*batch_size:(i+1)*batch_size]
            tt = t[i*batch_size:(i+1)*batch_size]
            y = self.predict(tx, train_flg=False)
            y = np.argmax(y, axis=1)
            acc += np.sum(y == tt)

        return acc / x.shape[0]

    def gradient(self, x, t):
        self.loss(x, t)

        dout = 1
        dout = self.last_layer.backward(dout)

        tmp_layers = self.layers.copy()
        tmp_layers.reverse()
        for layer in tmp_layers:
            dout = layer.backward(dout)

        grads = {}
        for i, layer_idx in enumerate((0, 2, 5, 7, 10, 12, 15, 18, 21, 24, 27)):
            grads['W' + str(i+1)] = self.layers[layer_idx].dW
            grads['b' + str(i+1)] = self.layers[layer_idx].db

        return grads

    def save_params(self, file_name="params.pkl"):
        params = {}
        for key, val in self.params.items():
            params[key] = val
        with open(file_name, 'wb') as f:
            pickle.dump(params, f)

    def load_params(self, file_name="params.pkl"):
        with open(file_name, 'rb') as f:
            params = pickle.load(f)
        for key, val in params.items():
            self.params[key] = val

        for i, layer_idx in enumerate((0, 2, 5, 7, 10, 12, 15, 18, 21, 24, 27)):
            self.layers[layer_idx].W = self.params['W' + str(i+1)]
            self.layers[layer_idx].b = self.params['b' + str(i+1)]

trainer代码:

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
from common.optimizer import *

class Trainer:
    """进行神经网络的训练的类
    """
    def __init__(self, network, x_train, t_train, x_test, t_test,
                 epochs=20, mini_batch_size=100,
                 optimizer='SGD', optimizer_param={'lr':0.01}, 
                 evaluate_sample_num_per_epoch=None, verbose=True):
        self.network = network
        self.verbose = verbose
        self.x_train = x_train
        self.t_train = t_train
        self.x_test = x_test
        self.t_test = t_test
        self.epochs = epochs
        self.batch_size = mini_batch_size
        self.evaluate_sample_num_per_epoch = evaluate_sample_num_per_epoch

        # optimzer
        optimizer_class_dict = {'sgd':SGD, 'momentum':Momentum, 'nesterov':Nesterov,
                                'adagrad':AdaGrad, 'rmsprpo':RMSprop, 'adam':Adam}
        self.optimizer = optimizer_class_dict[optimizer.lower()](**optimizer_param)
        
        self.train_size = x_train.shape[0]
        self.iter_per_epoch = max(self.train_size / mini_batch_size, 1)
        self.max_iter = int(epochs * self.iter_per_epoch)
        self.current_iter = 0
        self.current_epoch = 0
        
        self.train_loss_list = []
        self.train_acc_list = []
        self.test_acc_list = []

    def train_step(self):
        batch_mask = np.random.choice(self.train_size, self.batch_size)
        x_batch = self.x_train[batch_mask]
        t_batch = self.t_train[batch_mask]
        
        grads = self.network.gradient(x_batch, t_batch)
        self.optimizer.update(self.network.params, grads)
        
        loss = self.network.loss(x_batch, t_batch)
        self.train_loss_list.append(loss)
        if self.verbose: print("train loss:" + str(loss))
        
        if self.current_iter % self.iter_per_epoch == 0:
            self.current_epoch += 1
            
            x_train_sample, t_train_sample = self.x_train, self.t_train
            x_test_sample, t_test_sample = self.x_test, self.t_test
            if not self.evaluate_sample_num_per_epoch is None:
                t = self.evaluate_sample_num_per_epoch
                x_train_sample, t_train_sample = self.x_train[:t], self.t_train[:t]
                x_test_sample, t_test_sample = self.x_test[:t], self.t_test[:t]
                
            train_acc = self.network.accuracy(x_train_sample, t_train_sample)
            test_acc = self.network.accuracy(x_test_sample, t_test_sample)
            self.train_acc_list.append(train_acc)
            self.test_acc_list.append(test_acc)

            if self.verbose: print("=== epoch:" + str(self.current_epoch) + ", train acc:" + str(train_acc) + ", test acc:" + str(test_acc) + " ===")
        self.current_iter += 1

    def train(self):
        for i in range(self.max_iter):
            self.train_step()

        test_acc = self.network.accuracy(self.x_test, self.t_test)

        if self.verbose:
            print("=============== Final Test Accuracy ===============")
            print("test acc:" + str(test_acc))

训练代码：

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import pickle
import numpy as np
from collections import OrderedDict
from common.layers import *


class DeepConvNet:
    def __init__(self, hidden_size_list=[200, 10, 50, 20], input_dim=(1, 28, 28),
                 conv_param_1={'filter_num': 16, 'filter_size': 3, 'pad': 1, 'stride': 1},
                 conv_param_2={'filter_num': 16, 'filter_size': 3, 'pad': 1, 'stride': 1},
                 conv_param_3={'filter_num': 32, 'filter_size': 3, 'pad': 1, 'stride': 1},
                 conv_param_4={'filter_num': 32, 'filter_size': 3, 'pad': 2, 'stride': 1},
                 conv_param_5={'filter_num': 64, 'filter_size': 3, 'pad': 1, 'stride': 1},
                 conv_param_6={'filter_num': 64, 'filter_size': 3, 'pad': 1, 'stride': 1},
                 output_size=10, dropout_ratio=0.5):
        self.hidden_size_list = hidden_size_list

        pre_node_nums = np.array([1*28*28, 16*28*28, 16*28*28, 32*14*14, 32*16*16, 64*8*8, 64*4*4] + hidden_size_list)

        weight_init_scales = np.sqrt(2.0 / pre_node_nums)
        # if weight_init_scales.lower() in ('relu', 'he'):
        #     weight_init_scales = np.sqrt(2.0 / pre_node_num)
        # elif weight_init_scales.lower() in ('relu', 'he'):
        #     weight_init_scales = np.sqrt(1.0 / pre_node_num)

        self.params = {}
        pre_channel_num = input_dim[0]

        for idx, conv_param in enumerate([conv_param_1, conv_param_2, conv_param_3, conv_param_4, conv_param_5, conv_param_6]):
            self.params['W' + str(idx+1)] = weight_init_scales[idx] * np.random.randn(conv_param['filter_num'], pre_channel_num, conv_param['filter_size'], conv_param['filter_size'])
            self.params['b' + str(idx+1)] = np.zeros(conv_param['filter_num'])
            pre_channel_num = conv_param['filter_num']  # 要注意这个

        self.params['W7'] = weight_init_scales[6] * np.random.randn(64*4*4, hidden_size_list[0])
        self.params['b7'] = np.zeros(hidden_size_list[0])
        self.params['W' + str(7 + len(hidden_size_list))] = weight_init_scales[len(weight_init_scales)-1] * np.random.randn(hidden_size_list[-1], output_size)
        self.params['b' + str(7 + len(hidden_size_list))] = np.zeros(output_size)

        index = 0
        # for idx in range(7, 7+len(hidden_size_list)):
        for idx in range(7, 7+len(hidden_size_list)-1):
            self.params['W' + str(idx+1)] = weight_init_scales[idx] * np.random.randn(hidden_size_list[index], hidden_size_list[index+1])
            self.params['b' + str(idx+1)] = np.zeros(hidden_size_list[index+1])
            index = index + 1

        self.layers = []
        self.layers.append(Convolution(self.params['W1'], self.params['b1'],
                                       conv_param_1['stride'], conv_param_1['pad']))  # 0
        self.layers.append(Relu())  # 1
        self.layers.append(Convolution(self.params['W2'], self.params['b2'],
                                       conv_param_1['stride'], conv_param_1['pad']))  # 2
        self.layers.append(Relu())  # 3
        self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))  # 4
        self.layers.append(Convolution(self.params['W3'], self.params['b3'],
                                       conv_param_1['stride'], conv_param_1['pad']))  # 5
        self.layers.append(Relu())  # 6
        self.layers.append(Convolution(self.params['W4'], self.params['b4'],
                                       conv_param_4['stride'], conv_param_4['pad']))  # 7
        self.layers.append(Relu())  # 8
        self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))  # 9
        self.layers.append(Convolution(self.params['W5'], self.params['b5'],
                                       conv_param_5['stride'], conv_param_5['pad']))  # 10
        self.layers.append(Relu())  # 11
        self.layers.append(Convolution(self.params['W6'], self.params['b6'],
                                       conv_param_6['stride'], conv_param_6['pad']))  # 12
        self.layers.append(Relu())  # 13
        self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))  # 14
        self.layers.append(Affine(self.params['W7'], self.params['b7']))  # 15
        self.layers.append(Relu())  # 16
        self.layers.append(Dropout(0.5))  # 17
        # for idx in range(7, 7+len(hidden_size_list)):
        for idx in range(7, 7+len(hidden_size_list)-1):
            self.layers.append(Affine(self.params['W' + str(idx+1)], self.params['b' + str(idx+1)]))  # 18 21 24
            self.layers.append(Relu())  # 19 22 25
            self.layers.append(Dropout(dropout_ratio))  # 20 23 26
        self.layers.append(Affine(self.params['W' + str(7 + len(hidden_size_list))], self.params['b' + str(7 + len(hidden_size_list))]))  # 27
        self.layers.append(Dropout(dropout_ratio))

        self.last_layer = SoftmaxWithLoss()

    def predict(self, x, train_flg=False):
        for layer in self.layers:
            if isinstance(layer, Dropout):
                x = layer.forward(x, train_flg)
            else:
                x = layer.forward(x)
        return x

    def loss(self, x, t):
        y = self.predict(x, train_flg=True)
        return self.last_layer.forward(y, t)

    def accuracy(self, x, t, batch_size=100):
        if t.ndim != 1 : t = np.argmax(t, axis=1)

        acc = 0.0

        for i in range(int(x.shape[0] / batch_size)):
            tx = x[i*batch_size:(i+1)*batch_size]
            tt = t[i*batch_size:(i+1)*batch_size]
            y = self.predict(tx, train_flg=False)
            y = np.argmax(y, axis=1)
            acc += np.sum(y == tt)

        return acc / x.shape[0]

    def gradient(self, x, t):
        self.loss(x, t)

        dout = 1
        dout = self.last_layer.backward(dout)

        tmp_layers = self.layers.copy()
        tmp_layers.reverse()
        for layer in tmp_layers:
            dout = layer.backward(dout)

        grads = {}
        for i, layer_idx in enumerate((0, 2, 5, 7, 10, 12, 15, 18, 21, 24, 27)):
            grads['W' + str(i+1)] = self.layers[layer_idx].dW
            grads['b' + str(i+1)] = self.layers[layer_idx].db

        return grads

    def save_params(self, file_name="params.pkl"):
        params = {}
        for key, val in self.params.items():
            params[key] = val
        with open(file_name, 'wb') as f:
            pickle.dump(params, f)

    def load_params(self, file_name="params.pkl"):
        with open(file_name, 'rb') as f:
            params = pickle.load(f)
        for key, val in params.items():
            self.params[key] = val

        for i, layer_idx in enumerate((0, 2, 5, 7, 10, 12, 15, 18, 21, 24, 27)):
            self.layers[layer_idx].W = self.params['W' + str(i+1)]
            self.layers[layer_idx].b = self.params['b' + str(i+1)]
 load_params(self, file_name="params.pkl"):
        with open(file_name, 'rb') as f:
            params = pickle.load(f)
        for key, val in params.items():
            self.params[key] = val

        for i, layer_idx in enumerate((0, 2, 5, 7, 10, 12, 15, 18, 21, 24, 27)):
            self.layers[layer_idx].W = self.params['W' + str(i+1)]
            self.layers[layer_idx].b = self.params['b' + str(i+1)]
阿燃定律
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
卷积神经网络~简单的卷积网络
fatfairyyy的博客
05-22 606
简单卷积网络示例 一个卷积网络的例子，假设我们有一张图，我们要识别它是否是一张猫图。 〇假设这张图是39×39×3的图。 则，nH^[0] = nW^[0] = 39，即图片的高度和宽度都是39。nC^[0] = 3。 ①假设第一层我们使用3×3的过滤器来提取特征，则f^[1] = 3，s^[1] = 1 ， p^[1] = 0，并且有10个过滤器。则第二层的卷积输入是37×37×10的矩阵。37为[(n+2p-f)/s+1]的值，而10为第一层到第二层之间过滤器的个数。 则，第一层的标记为，nH^[1
一个简单的卷积神经网络
axiaoquan的专栏
11-02 1080
一个简单的卷积神经网络
Keras深度学习框架实战（6）：使用CNN-RNN架构实现视频分类
最新发布
MUKAMO的博客
06-04 1298
视频分类任务是将视频按内容分类的重要计算机视觉任务，常用于推荐系统和安全监控等领域。常使用CNN-RNN混合模型处理视频的空间和时间特征。在UCF101数据集上训练模型，通过预训练CNN提取帧特征，RNN处理时序信息，最终通过全连接层进行分类。实验结果通过准确率评估，模型可用于视频推荐和异常检测。为提升性能，可尝试微调预训练模型、改变模型架构或加入高级特性如自注意力机制。随着技术发展，视频分类任务性能将不断提升。
简单:卷积神经网络
Yhkcxy的博客
07-13 602
概念：受Hubel和Wiesel对猫视觉皮层电生理研究启发，有人提出卷积神经网络（CNN），Yann Lecun 最早将CNN用于手写数字识别并一直保持了其在该问题的霸主地位。近年来卷积神经网络在多个方向持续发力，在语音识别、人脸识别、通用物体识别、运动分析、自然语言处理甚至脑电波分析方面均有突破。       卷积神经网络与普通神经网络的区别在于，卷积神经网络包含了一个由卷积层和子采样层构成的特...
笔记二：最简单的卷积神经网络(带卷积层 池化层 全连接层)
知其然而后知其所以然
01-29 928
最基础的卷积神经网络图解 小结： 将Layer2层得到的5516的单元展开为一维400长度的向量通过权重参数w[3]w^{[3]}w[3]和偏置参数b[3]b^{[3]}b[3]进行全连接,得到一长度为120的一维向量，后面类似，最终经过softmax函数进行判别。 笔记一中没有对通道数进行说明：通道数即为滤波器的数量，如图所示：Layer1为6，所以得到28286的单元，Layer2为16，...
一个简单的卷积神经网络——layers.py
小杨的博客
10-02 382
# coding： utf-8 import numpy as np from functions import * from util import im2col, col2im # ------------------------------激活函数relu层------------------------------------------------- class Relu: ...
一个简单的卷积神经网络——gradient.py
小杨的博客
10-02 453
# coding: utf-8 import numpy as np def _numerical_gradient_1d(f, x): h = 1e-4 # 0.0001 grad = np.zeros_like(x) for idx in range(x.size): tmp_val = x[idx] x[idx] = float...
TensorFlow1.x入门（9）——卷积神经网络（CNN）
12-21
卷积神经网络（CNN）是深度学习中一种关键的模型，尤其在图像识别任务中表现卓越，同时也被广泛应用于自然语言处理和语音识别领域。CNN的核心在于其卷积层和池化层的设计。 卷积层是CNN的基础，通过一组可学习的...
卷积神经网络CNN故障分类，振动信号故障分类（代码完整，数据齐全）
10-27
卷积神经网络（CNN，Convolutional Neural Network）是一种深度学习模型，尤其在图像处理领域表现出色，但近年来也被广泛应用于其他领域，如声音识别、自然语言处理以及我们的主题——故障分类。本项目中，CNN被应用...
MATLAB实现CNN卷积神经网络多输入回归预测（完整源码和数据）
10-13
卷积神经网络（CNN，Convolutional Neural Network）是一种在图像处理领域广泛应用的深度学习模型，近年来也逐渐被引入到其他领域，如自然语言处理和时间序列预测。在这个MATLAB实现的项目中，CNN被用来进行多输入...
cnn.zip_CNN_卷积神经_卷积神经网络
07-14
卷积神经网络（CNN，Convolutional Neural Network）是一种深度学习模型，专为处理具有网格状结构数据，如图像、声音或时间序列等设计。在本压缩包“cnn.zip”中，我们可以找到一个关于M语言实现CNN的相关项目，包含...
最简单的利用tensorflow实现卷积神经网络分类任务（ubuntu windows都适用）提供代码
04-23
下载可用， 最简单的 tensorflow图像分类实现，适用入门深度学习tensorflow，可快速入门
构建一个简单的卷积神经网络，使用DRL框架tianshou匹配DQN算法
12-20
在本篇文章中，我们将探讨如何使用深度强化学习（Deep Reinforcement Learning, DRL）框架tianshou来构建一个简单的卷积神经网络，并将其应用于匹配DQN（Deep Q-Network）算法，实现对一个小游戏的自动控制。...
简单卷积神经网络讲解
rodneyzhaonet的专栏
01-02 2238
卷积神经网络动机CNN是一个从生物启发而创建出来的一个多层神经网络，它是hubel 和wiesel共同搞定的。我们知道视觉皮层包含一个复杂的细胞排列。这些细胞对子区的视觉区域比较敏感，叫做易接受区域。这些细胞在这些输入空间上扮演了一个本地过滤器的窘册，并且是一个非常适合强空间本地纠正，在自然图像上。另外，两个基本细胞类型已经被证实了：简单细胞 负责最大化的去描述物体的边的模式，在他的可接受区域。复杂
卷积神经网络(CNN)最简单，最清晰的解释
Li Zou的博客
04-21 4140
卷积神经网络CNN及代码实现示例 一、CNN的引入 在人工的全连接神经网络中，每相邻两层之间的每个神经元之间都是有边相连的。当输入层的特征维度变得很高时，这时全连接网络需要训练的参数就会增大很多，计算速度就会变得很慢，例如一张黑白的 28×2828×28 的手写数字图片，输入层的神经元就有784个，如下图所示： 若在中间只使用一层隐藏层，参数 w 就有 784×15=11760784×15=11...
Tensorflow实例：实现简单的卷积神经网络
蚊子爱牛牛的博客
11-17 1915
CNN最大的特点在于卷积的权值共享结构，可以大幅减少神经网络的参数量，防止过拟合的同时又降低了神经网络模型的复杂度。本文通过Tensorflow实现一个简单的CNN，用于MNIST手写数字识别。
深度学习入门：一个简单的卷积神经网络的实现
yangzijiangtou
03-22 783
深度学习中，卷积神经网络（CNN）用的场合比较多，尤其是视觉系统中，下面是一个手写数字的识别的简单卷积神经网络： 网络的构成是“Convolution（卷积层） - ReLU（阶跃） - Pooling（池化） -Affine（全连接） - ReLU（阶跃） - Affine（全连接） - Softmax（逻辑回归）”，我们将它实现为名为 SimpleConvNet 的类， #coding:utf...
从零实现一个简单卷积神经网络
热门推荐
Lucky_Q的博客
02-07 1万+
对于卷积公式 可能有的人知道，可能有的人不知道，或者也仅仅只是知道而不理解。但是不管你知不知道这个公式的意义，都不影响你自己去实现一个卷积。他具体的数学意义，我先不讲，因为有很多人讲的都比我清楚透彻。而我要告诉你的，则是再卷积神经网络里面的卷积操作是如何实现的 提到卷积神经网络，听到的最多的应该就是卷积，激活，池化这三个操作。就拿VGG16这个经典网络模型来说，其实就是通过卷积+激活+池化这三种操作堆叠而成的。 那么他们具体是什么东西，又是如何实现的，这次就来用numpy手撸一下他们的具体实现原理。 卷积
卷积神经网络的简单认识
qq_36499794的博客
01-07 266
一：卷积层      1. 卷积层的作用是降低数据量级，如果说一个图像的像素是1000*1000，全部放到神经网络里面，数据量是非常大的。所以引入了卷积核，相当于一个过滤器。例如：5*5的图像，用3*3的卷积核，就变成了3*3的卷积结果。具体应用中，往往有多个卷积核。      2. 池化的目的是降低数据维度。原因在于即使经过了卷积，但是图像仍然很大，所以为了降低数据维度，就对其进行了采样的操...
深度学习实践：详解卷积神经网络与关键组件
《解析卷积神经网络——深度学习实践手册》不仅涵盖了理论层面，还体现了“端到端”设计的思想，让读者理解整个网络构建的过程。通过阅读本书，无论是初学者还是经验丰富的从业者，都能收获关于卷积神经网络的扎实...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值