CNN框架（LeNet,AlexNet,VGGNet,inception,GoogLeNet,ResNet)

最新推荐文章于 2024-09-17 16:52:57 发布
最新推荐文章于 2024-09-17 16:52:57 发布
阅读量471 收藏 12
点赞数 13
文章标签： cnn 人工智能 神经网络 python 深度学习 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lahzylj/article/details/140246512
版权

LeNet

网络结构

model = Sequential()

# C1 Convolutional Layer
model.add(Conv2D(6, kernel_size=(5, 5), strides=(1, 1), activation='tanh', input_shape=input_shape, padding='same'))

# S2 Pooling Layer
model.add(AveragePooling2D(pool_size=(2, 2), strides=2, padding='valid'))

# C3 Convolutional Layer
model.add(Conv2D(16, kernel_size=(5, 5), strides=(1, 1), activation='tanh', padding='valid'))

# S4 Pooling Layer
model.add(AveragePooling2D(pool_size=(2, 2), strides=2, padding='valid'))

# C5 Fully Connected Convolutional Layer
model.add(Conv2D(120, kernel_size=(5, 5), strides=(1, 1), activation='tanh', padding='valid'))

#Flatten the CNN output so that we can connect it with fully connected layers
model.add(Flatten())

# FC6 Fully Connected Layer
model.add(Dense(84, activation='tanh'))

# Output Layer with softmax activation
model.add(Dense(10, activation='softmax'))

# print the model summary
model.summary()

设置学习超参数

from keras.callbacks import ModelCheckpoint, LearningRateScheduler

# set the learning rate schedule as created in the original paper
def lr_schedule(epoch):
    if epoch <= 2:     
        lr = 5e-4
    elif epoch > 2 and epoch <= 5:
        lr = 2e-4
    elif epoch > 5 and epoch <= 9:
        lr = 5e-5
    else: 
        lr = 1e-5
    return lr

lr_scheduler = LearningRateScheduler(lr_schedule)

# set the checkpointer
checkpointer = ModelCheckpoint(filepath='model.weights.best.hdf5', verbose=1, 
                               save_best_only=True)

# train the model
hist = model.fit(X_train, y_train, batch_size=32, epochs=20,
          validation_data=(X_test, y_test), callbacks=[checkpointer, lr_scheduler], 
          verbose=2, shuffle=True)

AlexNet

网络架构图

请添加图片描述

代码

# Instantiate an empty sequential model
model = Sequential(name="Alexnet")
# 1st layer (conv + pool + batchnorm)
model.add(Conv2D(filters= 96, kernel_size= (11,11), strides=(4,4), padding='valid', kernel_regularizer=l2(0.0005),
input_shape = (227,227,3)))
model.add(Activation('relu'))  #<---- activation function can be added on its own layer or within the Conv2D function
model.add(MaxPool2D(pool_size=(3,3), strides= (2,2), padding='valid'))
model.add(BatchNormalization())
    
# 2nd layer (conv + pool + batchnorm)
model.add(Conv2D(filters=256, kernel_size=(5,5), strides=(1,1), padding='same', kernel_regularizer=l2(0.0005)))
model.add(Activation('relu'))
model.add(MaxPool2D(pool_size=(3,3), strides=(2,2), padding='valid'))
model.add(BatchNormalization())
            
# layer 3 (conv + batchnorm)      <--- note that the authors did not add a POOL layer here
model.add(Conv2D(filters=384, kernel_size=(3,3), strides=(1,1), padding='same', kernel_regularizer=l2(0.0005)))
model.add(Activation('relu'))
model.add(BatchNormalization())
        
# layer 4 (conv + batchnorm)      <--- similar to layer 3
model.add(Conv2D(filters=384, kernel_size=(3,3), strides=(1,1), padding='same', kernel_regularizer=l2(0.0005)))
model.add(Activation('relu'))
model.add(BatchNormalization())
            
# layer 5 (conv + batchnorm)  
model.add(Conv2D(filters=256, kernel_size=(3,3), strides=(1,1), padding='same', kernel_regularizer=l2(0.0005)))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(MaxPool2D(pool_size=(3,3), strides=(2,2), padding='valid'))

# Flatten the CNN output to feed it with fully connected layers
model.add(Flatten())

# layer 6 (Dense layer + dropout)  
model.add(Dense(units = 4096, activation = 'relu'))
model.add(Dropout(0.5))

# layer 7 (Dense layers) 
model.add(Dense(units = 4096, activation = 'relu'))
model.add(Dropout(0.5))
                           
# layer 8 (softmax output layer) 
model.add(Dense(units = 1000, activation = 'softmax'))

# print the model summary
model.summary()

超参数的设置类似于第一个网络架构的代码

VGGNet

引入一个统一的配置层以减少设计网络时实验和试错次数，因此解决了前两个超参数太多而难以调整的问题。

与AlexNet不同的是，用33代替了AlexNet中第一卷积层（1111）和第二卷积层（5*5）的卷积核

所有卷积层的卷积核大小都为3✖3，strides=1,padding=same

所有池化层大小都为2✖2，strides=2

VGG16更常用，网络架构如下

请添加图片描述

model = Sequential()

# first block
model.add(Conv2D(filters=64, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same',input_shape=(224,224, 3)))
model.add(Conv2D(filters=64, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same'))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))

# second block
model.add(Conv2D(filters=128, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same'))
model.add(Conv2D(filters=128, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same'))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))

# third block
model.add(Conv2D(filters=256, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same'))
model.add(Conv2D(filters=256, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same'))
model.add(Conv2D(filters=256, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same'))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))

# forth block
model.add(Conv2D(filters=512, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same'))
model.add(Conv2D(filters=512, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same'))
model.add(Conv2D(filters=512, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same'))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))

# fifth block
model.add(Conv2D(filters=512, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same'))
model.add(Conv2D(filters=512, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same'))
model.add(Conv2D(filters=512, kernel_size=(3,3), strides=(1,1), activation='relu', padding='same'))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))

# sixth block (classifier)
model.add(Flatten())
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1000, activation='softmax'))

model.summary()

inception

inception 与经典CNN的特征提取方式不同，他引入了inception模块（由具有不同大小的卷积核的若干卷积层组成），然后将inception模块堆叠起来。

请添加图片描述

1、inception模块

组成示例：

请添加图片描述

2、inception模块与维数约减

维数约减层（1✖1卷积层）：假设输入尺寸为32✖32✖200，如果添加一个深度为16的1✖1的卷积层，因此维度从200减少到16，减少了网络的深度，同时也减少了操作数量。

当然只要适度的使用归约层就可以减少计算成本，而不影响性能。

一般来说只要在大的卷积层之前添加维数约减层后，可以在每个阶段显著增加隐藏单元数，可以避免计算量的复杂。

3、inception架构

通过inception模块堆叠来构建inception网络

请添加图片描述

GoogLeNet

GoogLeNet网络框架：堆叠了很多inception模块

请添加图片描述

keras代码实现

x = Conv2D(64, (7, 7), padding='same', strides=(2, 2), activation='relu', name='conv_1_7x7/2', kernel_initializer=kernel_init, bias_initializer=bias_init)(input_layer)
x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_1_3x3/2')(x)
# x = Conv2D(64, (1, 1), padding='same', strides=(1, 1), activation='relu', name='conv_2a_3x3/1')(x)
x = Conv2D(192, (3, 3), padding='same', strides=(1, 1), activation='relu', name='conv_2b_3x3/1')(x)
x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_2_3x3/2')(x)

x = inception_module(x,
                     filters_1x1=64,
                     filters_3x3_reduce=96,
                     filters_3x3=128,
                     filters_5x5_reduce=16,
                     filters_5x5=32,
                     filters_pool_proj=32,
                     name='inception_3a')

x = inception_module(x,
                     filters_1x1=128,
                     filters_3x3_reduce=128,
                     filters_3x3=192,
                     filters_5x5_reduce=32,
                     filters_5x5=96,
                     filters_pool_proj=64,
                     name='inception_3b')

x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_3_3x3/2')(x)

x = inception_module(x,
                     filters_1x1=192,
                     filters_3x3_reduce=96,
                     filters_3x3=208,
                     filters_5x5_reduce=16,
                     filters_5x5=48,
                     filters_pool_proj=64,
                     name='inception_4a')


classifier_1 = AveragePooling2D((5, 5), strides=3)(x)
classifier_1 = Conv2D(128, (1, 1), padding='same', activation='relu')(classifier_1)
classifier_1 = Flatten()(classifier_1)
classifier_1 = Dense(1024, activation='relu')(classifier_1)
classifier_1 = Dropout(0.7)(classifier_1)
classifier_1 = Dense(10, activation='softmax', name='auxilliary_output_1')(classifier_1)

x = inception_module(x,
                     filters_1x1=160,
                     filters_3x3_reduce=112,
                     filters_3x3=224,
                     filters_5x5_reduce=24,
                     filters_5x5=64,
                     filters_pool_proj=64,
                     name='inception_4b')

x = inception_module(x,
                     filters_1x1=128,
                     filters_3x3_reduce=128,
                     filters_3x3=256,
                     filters_5x5_reduce=24,
                     filters_5x5=64,
                     filters_pool_proj=64,
                     name='inception_4c')

x = inception_module(x,
                     filters_1x1=112,
                     filters_3x3_reduce=144,
                     filters_3x3=288,
                     filters_5x5_reduce=32,
                     filters_5x5=64,
                     filters_pool_proj=64,
                     name='inception_4d')


classifier_2 = AveragePooling2D((5, 5), strides=3)(x)
classifier_2 = Conv2D(128, (1, 1), padding='same', activation='relu')(classifier_2)
classifier_2 = Flatten()(classifier_2)
classifier_2 = Dense(1024, activation='relu')(classifier_2)
classifier_2 = Dropout(0.7)(classifier_2)
classifier_2 = Dense(10, activation='softmax', name='auxilliary_output_2')(classifier_2)

x = inception_module(x,
                     filters_1x1=256,
                     filters_3x3_reduce=160,
                     filters_3x3=320,
                     filters_5x5_reduce=32,
                     filters_5x5=128,
                     filters_pool_proj=128,
                     name='inception_4e')

x = MaxPool2D((3, 3), padding='same', strides=(2, 2), name='max_pool_4_3x3/2')(x)

x = inception_module(x,
                     filters_1x1=256,
                     filters_3x3_reduce=160,
                     filters_3x3=320,
                     filters_5x5_reduce=32,
                     filters_5x5=128,
                     filters_pool_proj=128,
                     name='inception_5a')

x = inception_module(x,
                     filters_1x1=384,
                     filters_3x3_reduce=192,
                     filters_3x3=384,
                     filters_5x5_reduce=48,
                     filters_5x5=128,
                     filters_pool_proj=128,
                     name='inception_5b')

x = AveragePooling2D(pool_size=(7,7), strides=1, padding='valid',name='avg_pool_5_3x3/1')(x)

x = Dropout(0.4)(x)
x = Dense(1000, activation='relu', name='linear')(x)
x = Dense(1000, activation='softmax', name='output')(x)

学习参数代码
epochs = 25
initial_lrate = 0.01

def decay(epoch, steps=100):
    initial_lrate = 0.01
    drop = 0.96
    epochs_drop = 8
    lrate = initial_lrate * math.pow(drop, math.floor((1+epoch)/epochs_drop))
    return lrate

sgd = SGD(lr=initial_lrate, momentum=0.9, nesterov=False)

lr_sc = LearningRateScheduler(decay, verbose=1)

model_with_classifiers.compile(loss=['categorical_crossentropy', 'categorical_crossentropy', 'categorical_crossentropy'], 
              loss_weights=[1, 0.3, 0.3], optimizer=sgd, metrics=['accuracy'])

history = model_with_classifiers.fit(X_train, [y_train, y_train, y_train], validation_data=(X_test, [y_test, y_test, y_test]), 
                    epochs=epochs, batch_size=256, callbacks=[lr_sc])

ResNet

残差神经网络引入了一种含跳跃连接的残差模块，该网络可以对隐藏层进行大批量归一，实现超深神经网络。

*跳跃连接是为了解决梯度消失的问题，他创建了一条旁路让梯度从旁路流过，它可以允许模型学习恒等函数（确保前一层和后一层的表现一样好）

请添加图片描述

残差块结构如下：

请添加图片描述

代码示例，与上图不对应：
X_shortcut = X
X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)
X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)
X = Activation('relu')(X)
X = Add()([X, X_shortcut])
X = Activation('relu')(X)

注意！残差块中没有池化层，因此会在首尾加一个1✖1结构的卷积层来降维，这被称为瓶颈残差块。但是由于残差块的堆叠，矩阵的维数必须相同否则不能进行加法运算，因此旁路需要通过添加一个1✖1的卷积层和批归一化来进行下采样。
请添加图片描述

残差块函数：

bottleneck_residual_block(X，reduce，f,filters,s):

reduce:为True时，使用约减旁路，否则是常规旁路;X(样本数量，高度，宽度，通道数)；f:主路卷积层中的窗口形状；filter：滤波器的数量；s=strides

代码：

def bottleneck_residual_block(X, f, filters, stage, block, reduce=False, s=2):
    """    
    Arguments:
    X -- input tensor of shape (m, height, width, channels)
    f -- integer, specifying the shape of the middle CONV's window for the main path
    filters -- python list of integers, defining the number of filters in the CONV layers of the main path
    stage -- integer, used to name the layers, depending on their position in the network
    block -- string/character, used to name the layers, depending on their position in the network
    
    reduce -- boolean, True = identifies the reduction layer at the beginning of each learning stage
    s -- integer, strides
    
    Returns:
    X -- output of the identity block, tensor of shape (H, W, C)
    """
    
    # defining name basis
    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base = 'bn' + str(stage) + block + '_branch'
    
    # Retrieve Filters
    F1, F2, F3 = filters
    
    # Save the input value. You'll need this later to add back to the main path. 
    X_shortcut = X
    
    if reduce:
        # if we are to reduce the spatial size, apply a 1x1 CONV layer to the shortcut path
        # to do that, we need both CONV layers to have similar strides 
        X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (s,s), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)
        X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)
        X = Activation('relu')(X)
        
        X_shortcut = Conv2D(filters = F3, kernel_size = (1, 1), strides = (s,s), padding = 'valid', name = conv_name_base + '1',
                        kernel_initializer = glorot_uniform(seed=0))(X_shortcut)
        X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)
    else: 
        # First component of main path
        X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)
        X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)
        X = Activation('relu')(X)
    
    # Second component of main path
    X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)
    X = Activation('relu')(X)

    # Third component of main path
    X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)

    # Final step: Add shortcut value to main path, and pass it through a RELU activation 
    X = Add()([X, X_shortcut])
    X = Activation('relu')(X)
    
    return X



def ResNet50(input_shape, classes):
    """
    Arguments:
    input_shape -- tuple shape of the images of the dataset
    classes -- integer, number of classes

    Returns:
    model -- a Model() instance in Keras
    """

    # Define the input as a tensor with shape input_shape
    X_input = Input(input_shape)

    # Stage 1
    X = Conv2D(64, (7, 7), strides=(2, 2), name='conv1', kernel_initializer=glorot_uniform(seed=0))(X_input)
    X = BatchNormalization(axis=3, name='bn_conv1')(X)
    X = Activation('relu')(X)
    X = MaxPooling2D((3, 3), strides=(2, 2))(X)

    # Stage 2
    X = bottleneck_residual_block(X, 3, [64, 64, 256], stage=2, block='a', reduce=True, s=1)
    X = bottleneck_residual_block(X, 3, [64, 64, 256], stage=2, block='b')
    X = bottleneck_residual_block(X, 3, [64, 64, 256], stage=2, block='c')

    # Stage 3 
    X = bottleneck_residual_block(X, 3, [128, 128, 512], stage=3, block='a', reduce=True, s=2)
    X = bottleneck_residual_block(X, 3, [128, 128, 512], stage=3, block='b')
    X = bottleneck_residual_block(X, 3, [128, 128, 512], stage=3, block='c')
    X = bottleneck_residual_block(X, 3, [128, 128, 512], stage=3, block='d')

    # Stage 4 
    X = bottleneck_residual_block(X, 3, [256, 256, 1024], stage=4, block='a', reduce=True, s=2)
    X = bottleneck_residual_block(X, 3, [256, 256, 1024], stage=4, block='b')
    X = bottleneck_residual_block(X, 3, [256, 256, 1024], stage=4, block='c')
    X = bottleneck_residual_block(X, 3, [256, 256, 1024], stage=4, block='d')
    X = bottleneck_residual_block(X, 3, [256, 256, 1024], stage=4, block='e')
    X = bottleneck_residual_block(X, 3, [256, 256, 1024], stage=4, block='f')

    # Stage 5 
    X = bottleneck_residual_block(X, 3, [512, 512, 2048], stage=5, block='a', reduce=True, s=2)
    X = bottleneck_residual_block(X, 3, [512, 512, 2048], stage=5, block='b')
    X = bottleneck_residual_block(X, 3, [512, 512, 2048], stage=5, block='c')

    # AVGPOOL 
    X = AveragePooling2D((1,1), name="avg_pool")(X)

    # output layer
    请添加图片描述

    # AVGPOOL 
    X = AveragePooling2D((1,1), name="avg_pool")(X)

    # output layer
    X = Flatten()(X)
    X = Dense(classes, activation='softmax', name='fc' + str(classes), kernel_initializer = glorot_uniform(seed=0))(X)
    
    # Create the model
    model = Model(inputs = X_input, outputs = X, name='ResNet50')

    return model

超参数学习类似与之前的网络

本文搬运《深度学习计算机视觉》内容代码。仅供学习。

懒癌患者-ylj
关注
什么是GoogLeNet？一文看懂CNN经典模型GoogLeNet 从Inception v1到v4的演进
Marcus-Bao的个人主页
05-06 630
上一次我们谈到了CNN经典模型VGGNet，今天我们来简单聊聊比VGG更强大的GoogLeNet。 为什么有GoogLeNet? 2014年，GoogLeNet和VGG是当年ImageNet挑战赛(ILSVRC14)的双雄，GoogLeNet获得了第一名、VGG获得了第二名，这两类模型结构的共同特点是层次更深了。VGG继承了LeNet以及AlexNet的一些框架结构，而GoogLeNet则做了...
CNN 常用的几个模型 LeNet5 AlexNet VGGNet Google Inception Net 微软ResNet残差神经网络
Dan的专栏
08-23 8091
LeNet5 LeNet-5：是Yann LeCun在1998年设计的用于手写数字识别的卷积神经网络，当年美国大多数银行就是用它来识别支票上面的手写数字的，它是早期卷积神经网络中最有代表性的实验系统之一。 LenNet-5共有7层（不包括输入层），每层都包含不同数量的训练参数，如下图所示。  LeNet-5中主要有2个卷积层、2个下抽样层（池化层）、3个全连接层3种连接方式 卷积层  卷积...
手撕深度学习：经典CNN网络结构理解汇总Lenet、Alexnet、VGG、Googlenet、Resnet
Nathan0921的博客
08-03 1468
这些网络在深度学习的发展过程中起到了至关重要的作用，它们的设计思想和创新点为后续的研究和应用提供了宝贵的经验和灵感。也算是对卷积神经网络的一个小总结了，对网络的单一手撕感觉在2024年这个时间节点已经没有必要了，寻求统一的方式对过往经典卷积神经网络进行汇总说明是快速进入下一阶段内容学习的小技巧。通过理解和掌握这五种经典的卷积神经网络结构，我们可以深入了解卷积神经网络的发展历程和设计思路，为后续的深度学习研究和应用奠定坚实的基础。在这一章节，我们将详细的给出五种模型的网络结构，以方便通用调用来实现模型训练。
Pytorch实现CNN经典网络框架（LeNet、AlexNet、VGGNet、GoogLeNet、ResNet）
小马日记
11-16 5670
卷积神经网络可谓是现在深度学习领域中大红大紫的网络框架，尤其在计算机视觉领域更是一枝独秀。CNN从90年代的LeNet开始，21世纪初沉寂了10年，直到12年AlexNet开始又再焕发第二春，从ZF Net到VGG，GoogLeNet再到ResNet和最近的DenseNet，网络越来越深，架构越来越复杂，解决反向传播时梯度消失的方法也越来越巧妙。下面介绍几种网络的结构框架和代码实现。 1、LeNe...
LeNet、AlexNet、GoogLeNet、VGG、ResNet
Fan2g
06-15 527
https://zhuanlan.zhihu.com/p/22094600 https://blog.csdn.net/u013989576/article/details/71600795 https://blog.csdn.net/wcy12341189/article/details/56281618 https://blog.csdn.net/sunbaigui/article/de...
机器学习之路四：CNN综述（Lenet,AlexNet,GoogleNet,VGG,ResNet,ResNeXt,DenseNet）
W_H_M_2018的博客
05-07 2558
CNN的发展历史 Lenet，1986年 Alexnet，2012年 GoogleNet，2014年 VGG，2014年 Deep Residual Learning，2015年 ResNeXt, 2016年 DenseNet，2017年 ImageNet历年冠军和相关CNN模型 https://www.cnblogs.com/liaohuiqiang/p/9609162....
CNN、LeNet、AlexNet、VGG、GoogLeNet、RCNN、Fast RCNN、Faster RCNN、YOLO、YOLOv2、SSD等的关系
maopig的专栏
03-23 1566
3、RCNN、Fast RCNN、Faster RCNN、YOLO、YOLOv2、SSD，也属于CNN，但和2是另一条路线。这些模型都是基于CNN单元构建起来的，本来是用来训练图像分类任务的。比如目标检测，RCNN系列、YOLO等都是利用了训练好的图像分类模型，利用它们提取的特征，再做下一步的工作；区别：从肤浅的层面说，2和3的区别在于，2属于用于图像分类的CNN，3属于用于目标检测的CNN。AlexNet、VGG这些模型都是基于CNN单元构建起来的，本来是用来训练图像分类任务的。
图像分类之经典卷积神经网络AlexNET、VGG、GoogLeNet、ResNet和DenseNet
qq_39987519的博客
06-28 3771
1、CNN的架构模型   CNN是一种前馈网络，即信息流从输入到输出都是单向的。正如人工神经网络(ANN)是受生物学启发的，CNN也是。大脑的视觉皮层由简单细胞和复杂细胞交替组成(Hubel & Wiesel, 1959, 1962)，这激发了他们对CNN架构的设计。CNN的架构有多种变体，通常，它们由卷积层和池化层(subsampling)组成，这些层被分组成模块。在前馈网络中，最后会连接一层或多层全连接层。这些模块通常堆叠在一起，形成一个深层模型。   图像直接输入到CNN网络中，接下来是几个
卷积神经网络AlexNet和ResNet比较[2021论文]
weixin_44972997的博客
07-10 5760
本文是一篇`人工智能`前沿算法课设小论文，主要内容是对于经典模型`AlexNet`和`ResNet`的比较。整体上比较完整，由于是从文档上搬上来，所以在排版上有一些不规范，需要`完整论文或者参考文献`私信可免费提供。
【AI大模型】Kimi API大模型接口实现
qq_25888559的博客
09-15 1042
Kimi智能助手在效率（免费榜）排名从2024年1月14日的第436名提升至3月19日的第11名。而尚未上线的GPT-4.5 Turbo上下文窗口指定为25.6万个token，能同时处理约20万个单词，Kimi升级后，长文本能力为其10倍。在2023年10月初次亮相时，该模型的处理能力还仅有约20万汉字。2024年3月18日，月之暗面宣布Kimi智能助手启动200万字无损上下文内测。
使用c#制作一个小型桌面程序
qq_44691564的博客
09-14 952
创建.NET Framework新项目，将之前生成的dll放在Demo文件夹的bin ->debug或是 release中（看你自己用的什么模式），创建完成后 系统会自动生成一些文件，其中 pch.cpp 先不要修改，pch.h中先导入自己需要用到的库，下面是我的代码。布局完了之后会自动生成Form1.Designer.cs 的窗口设计代码，点击控件按F4 还可以修改他们的属性。完成之后点击生成 就可以在bin中出现的你的.exe文件咯，是不是很简单呀~[狗头]我们还需要一个入口主程序。
生成式人工智能在新加坡的发展现状和地位
wukangjupingbb的博客
09-11 1153
依据国际隐私专业人员协会(IAPP)的相关报告，2020年，上述两机构更新了该模型框架，发布了第二版，并推出了《组织实施和自我评估指南》，帮助组织评估其人工智能治理实践与型框架的匹配程度，还发布了《案例汇编》，展示了组织如何实施负责任的人工智能治理实践。2019年，金融管理局宣布与金融行业合作创建Veritas框架，为金融机构提供可验证的方法，将FEAT原则纳入其人工智能和数据分析驱动的解决方案中。新加坡在人工智能治理方面采取了部门性的方法，即通过各个行业的监管机构来管理人工智能的使用。
开源 AI 智能名片链动 2+1 模式 O2O 商城小程序在社群活动中的应用与时机选择
最新发布
专注MarTech应用研究与实施方案
09-17 545
本文探讨了开源 AI 智能名片链动 2+1 模式 O2O 商城小程序在社群经济中的重要性，着重分析了如何借助该小程序适时举办大型活动以维持和引爆社群活跃度。通过对活动时机选择的研究，强调了针对社群用户量身定制活动时机的必要性，以赢得用户的高度参与。
opencv学习：calcHist 函数绘制图像直方图及代码实现
mohanyelong的博客
09-13 1499
opencv学习：calcHist 函数绘制图像直方图及代码实现
Djourney新手入门基础，AI摄影+AI设计+AI绘画-AIGC作图
DAMOXINGHAITAI的博客
09-14 1004
（全套教程文末领取哈）从大模型系统设计入手，讲解大模型的主要方法；在通过大模型提示词工程从Prompts角度入手更好发挥模型的作用；大模型平台应用开发借助阿里云PAI平台构建电商领域虚拟试衣系统；大模型知识库应用开发以LangChain框架为例，构建物流行业咨询智能问答系统；大模型微调开发借助以大健康、新零售、新媒体领域构建适合当前领域大模型；以SD多模态大模型为主，搭建了文生图小程序案例；以大模型平台应用与开发为主，通过星火大模型，文心大模型等成熟大模型构建大模型行业应用。
从AI到大数据，数字技术服务平台全栈赋能企业升级
smjt2024的博客
09-11 678
海量的数据中蕴含着丰富的信息和价值，数字技术服务平台能够收集、整理和分析这些数据，为企业提供精准的市场洞察和决策支持。企业可以通过参加树莓集团举办的培训课程和研讨会，了解最新的数字技术趋势和应用案例，提升自身的数字技术水平。从技术咨询、解决方案设计到系统实施和运维，数字技术服务平台为企业提供一站式的服务，让企业无需担心技术难题，专注于自身的核心业务。树莓集团的数字技术服务平台，以其先进的技术、专业的服务和丰富的经验，为企业提供了全栈赋能。在数字时代，让我们共同利用数字技术服务平台，开启企业升级的新篇章。
数据爬虫中遇到验证码的解决方法
sheji888的专栏
09-17 871
数据爬虫中遇到验证码是一个复杂而常见的问题，需要综合考虑多种因素并采取合适的解决策略。通过避免触发验证码、手动输入验证码、使用验证码识别技术、绕过验证码机制以及采用分布式爬虫和代理IP等方法，可以在一定程度上提高爬虫的稳定性和效率。然而，需要注意的是，爬虫的使用必须遵守相关法律法规和网站爬虫协议的要求，确保数据抓取活动的合法性和合规性。
常见本地大模型个人知识库工具部署、微调及对比选型
09-14 868
由于作者的眼界、精力和能力也有限，并且确实也不是专业的AI研究员，仅仅是一位兴趣使然的爱好者，这里列出的几款也单纯只是作者平常关注到的，所以可能也不全，请各位见谅！文章从起笔写到这里已经过了三天了，这三天也基本把上文提到的大模型侧工具全部体验了一遍，下面说一下主要结论吧。从功能丰富度和性能优化的角度综合评估，LM Studio明显更胜一筹。从工具本身使用及模型部署效率来看，Ollama的上手速度会更快，使用会更便捷，效率也会更高。从企业级稳定性和高可用。
文档内容识别系统源码分享
xuehaishijue的博客
09-17 1417
数据集信息展示在当今信息爆炸的时代，文档内容识别系统的有效性和准确性愈发重要。为了提升YOLOv8在文档内容识别任务中的表现，我们采用了名为“FULL 2”的数据集进行训练和评估。该数据集专为文档图像的多样性和复杂性而设计，涵盖了多种类别的文本元素，使其成为优化深度学习模型的理想选择。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值