【Keras-Inception v2】CIFAR-10

最新推荐文章于 2023-09-01 23:26:07 发布
最新推荐文章于 2023-09-01 23:26:07 发布
阅读量1.2k 收藏 5
点赞数 3
CC 4.0 BY-SA版权
分类专栏： PyTorch/Keras/Caffe/TensroFlow 文章标签： Keras TensorFlow Tensorboard Inception v2 Batch Normalization
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/bryant_meng/article/details/85259112
本文详细介绍了如何使用Inception v2架构进行CIFAR-10图像分类任务，包括网络结构的搭建、参数设置、数据预处理、训练过程及结果分析。对比了不同版本的Inception模型在CIFAR-10数据集上的表现，并对模型进行了优化，最终实现了较高的分类准确率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

系列连载目录

  • 请查看博客 《Paper》 4.1 小节 【Keras】Classification in CIFAR-10 系列连载

学习借鉴

参考

代码下载

硬件

  • TITAN XP

文章目录

1 理论基础

参考【BN】《Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift》

在这里插入图片描述
更形象化的理解，四种 normalization 如下所示
在这里插入图片描述
在这里插入图片描述

Inception-v2 的结构如下，和Inception-v1相似，只是卷积之后都进行了 Batch Normalization 操作

在这里插入图片描述
需要注意以下几点：

  • Inception-v2 通过 strides 来进行 feature map 分辨率的倍减，而不像 Inception-v1 在两个 inception 模块之间加入 stride 为2的 max pooling 操作
  • #3×3 reduce表示 1×1→3×3 中的 1×1 操作
  • double #3×3 reduce表示 1×1→3×3→3×3 中的 1×1 操作
  • pass through 表示在上一个 Inception 中的 concatenation后的结果后接一个 max pooling（filter size = 3，stride = 2）
  • inception（4c）、inception（4d）中，最后一列的 channels 好像有错误，inception（4c）中 160+160+160+96=576 最后一项的 channels 不是128，而应该是96，inception（4d）中 96+192+192+96=576 最后一项的 channels 不是128，而应该是96。

2 代码实现

[D] Why aren’t Inception-style networks successful on CIFAR-10/100?
在这里插入图片描述

2.1 Inception_v2

1）导入库，设置好超参数

import os  
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"   
os.environ["CUDA_VISIBLE_DEVICES"]="3" 

import keras
import numpy as np
import math

from keras.datasets import cifar10
from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, ZeroPadding2D, GlobalAveragePooling2D
from keras.layers import Flatten, Dense, Dropout,BatchNormalization,Activation
from keras.models import Model
from keras.layers import Input, concatenate
from keras import optimizers, regularizers
from keras.preprocessing.image import ImageDataGenerator
from keras.initializers import he_normal
from keras.callbacks import LearningRateScheduler, TensorBoard, ModelCheckpoint

num_classes        = 10
batch_size         = 64         # 64 or 32 or other
epochs             = 300
iterations         = 782       
USE_BN=True
LRN2D_NORM = True
DROPOUT=0.4
CONCAT_AXIS=3
weight_decay=1e-4
DATA_FORMAT='channels_last' # Theano:'channels_first' Tensorflow:'channels_last'

log_filepath  = './inception_v2'

2）数据预处理并设置 learning schedule

def color_preprocessing(x_train,x_test):
    x_train = x_train.astype('float32')
    x_test = x_test.astype('float32')
    mean = [125.307, 122.95, 113.865]
    std  = [62.9932, 62.0887, 66.7048]
    for i in range(3):
        x_train[:,:,:,i] = (x_train[:,:,:,i] - mean[i]) / std[i]
        x_test[:,:,:,i] = (x_test[:,:,:,i] - mean[i]) / std[i]
    return x_train, x_test

def scheduler(epoch):
    if epoch < 70:
        return 0.01
    if epoch < 140:
        return 0.001
    return 0.0001

# load data
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test  = keras.utils.to_categorical(y_test, num_classes)
x_train, x_test = color_preprocessing(x_train, x_test)

3）定义网络结构
定义 inception 模块

def inception_module(x,params,concat_axis,padding='same',data_format=DATA_FORMAT,increase=False,last=False,use_bias=True,kernel_initializer="he_normal",bias_initializer='zeros',kernel_regularizer=None,bias_regularizer=None,activity_regularizer=None,kernel_constraint=None,bias_constraint=None,lrn2d_norm=LRN2D_NORM,weight_decay=weight_decay):
    (branch1,branch2,branch3,branch4)=params
    if weight_decay:
        kernel_regularizer=regularizers.l2(weight_decay)
        bias_regularizer=regularizers.l2(weight_decay)
    else:
        kernel_regularizer=None
        bias_regularizer=None
    if increase:
        #1x1->3x3
        pathway2=Conv2D(filters=branch2[0],kernel_size=(1,1),strides=1,padding=padding,data_format=data_format,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(x)
        pathway2 = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(pathway2))
        pathway2=Conv2D(filters=branch2[1],kernel_size=(3,3),strides=2,padding=padding,data_format=data_format,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway2)
        pathway2 = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(pathway2))
        #1x1->3x3+3x3
        pathway3=Conv2D(filters=branch3[0],kernel_size=(1,1),strides=1,padding=padding,data_format=data_format,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(x)
        pathway3 = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(pathway3))
        pathway3=Conv2D(filters=branch3[1],kernel_size=(3,3),strides=1,padding=padding,data_format=data_format,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway3)
        pathway3 = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(pathway3))
        pathway3=Conv2D(filters=branch3[1],kernel_size=(3,3),strides=2,padding=padding,data_format=data_format,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway3)
        pathway3 = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(pathway3))
        #3x3->1x1
        pathway4=MaxPooling2D(pool_size=(3,3),strides=2,padding=padding,data_format=DATA_FORMAT)(x)
        return concatenate([pathway2,pathway3,pathway4],axis=concat_axis)
    else:
        #1x1
        pathway1=Conv2D(filters=branch1[0],kernel_size=(1,1),strides=1,padding=padding,data_format=data_format,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(x)
        pathway1 = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(pathway1))
        #1x1->3x3
        pathway2=Conv2D(filters=branch2[0],kernel_size=(1,1),strides=1,padding=padding,data_format=data_format,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(x)
        pathway2 = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(pathway2))
        pathway2=Conv2D(filters=branch2[1],kernel_size=(3,3),strides=1,padding=padding,data_format=data_format,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway2)
        pathway2 = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(pathway2))
        #1x1->3x3+3x3
        pathway3=Conv2D(filters=branch3[0],kernel_size=(1,1),strides=1,padding=padding,data_format=data_format,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(x)
        pathway3 = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(pathway3))
        pathway3=Conv2D(filters=branch3[1],kernel_size=(3,3),strides=1,padding=padding,data_format=data_format,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway3)
        pathway3 = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(pathway3))
        pathway3=Conv2D(filters=branch3[1],kernel_size=(3,3),strides=1,padding=padding,data_format=data_format,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway3)
        pathway3 = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(pathway3))
        #3x3->1x1
        if last:
            pathway4=MaxPooling2D(pool_size=(3,3),strides=1,padding=padding,data_format=DATA_FORMAT)(x)
        else:
            pathway4=AveragePooling2D(pool_size=(3,3),strides=1,padding=padding,data_format=DATA_FORMAT)(x)
        pathway4=Conv2D(filters=branch4[0],kernel_size=(1,1),strides=1,padding=padding,data_format=data_format,use_bias=use_bias,kernel_initializer=kernel_initializer,bias_initializer=bias_initializer,kernel_regularizer=kernel_regularizer,bias_regularizer=bias_regularizer,activity_regularizer=activity_regularizer,kernel_constraint=kernel_constraint,bias_constraint=bias_constraint)(pathway4)
        pathway4 = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(pathway4))
        return concatenate([pathway1,pathway2,pathway3,pathway4],axis=concat_axis)

4）搭建网络

def create_model(img_input):
    x = Conv2D(64,kernel_size=(7,7),strides=(2,2),padding='same',
               kernel_initializer="he_normal",kernel_regularizer=regularizers.l2(weight_decay))(img_input)
    x=MaxPooling2D(pool_size=(3,3),strides=2,padding='same',data_format=DATA_FORMAT)(x)
    x = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(x))
    
    x = Conv2D(64,kernel_size=(1,1),strides=(1,1),padding='same',
               kernel_initializer="he_normal",kernel_regularizer=regularizers.l2(weight_decay))(x)
    x = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(x))   
    
    x = Conv2D(192,kernel_size=(3,3),strides=(1,1),padding='same',
               kernel_initializer="he_normal",kernel_regularizer=regularizers.l2(weight_decay))(x)
    x = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(x))    
    x=MaxPooling2D(pool_size=(3,3),strides=2,padding='same',data_format=DATA_FORMAT)(x)
    
    x=inception_module(x,params=[(64,),(64,64),(64,96),(32,)],concat_axis=CONCAT_AXIS) #3a
    x=inception_module(x,params=[(64,),(64,96),(64,96),(64,)],concat_axis=CONCAT_AXIS) #3b
    x=inception_module(x,params=[(0,),(128,160),(64,96),(0,)],concat_axis=CONCAT_AXIS,increase=True) #3c
    x=inception_module(x,params=[(224,),(64,96),(96,128),(128,)],concat_axis=CONCAT_AXIS) #4a
    x=inception_module(x,params=[(192,),(96,128),(96,128),(128,)],concat_axis=CONCAT_AXIS) #4b
    x=inception_module(x,params=[(160,),(128,160),(128,160),(96,)],concat_axis=CONCAT_AXIS) #4c
    x=inception_module(x,params=[(96,),(128,192),(160,192),(96,)],concat_axis=CONCAT_AXIS) #4d
    x=inception_module(x,params=[(0,),(128,192),(192,256),(0,)],concat_axis=CONCAT_AXIS,increase=True) #4e
    x=inception_module(x,params=[(352,),(192,320),(160,224),(128,)],concat_axis=CONCAT_AXIS) #5a
    x=inception_module(x,params=[(352,),(192,320),(192,224),(128,)],concat_axis=CONCAT_AXIS,last=True) #5b

    x=Flatten()(x)
    x=Dropout(DROPOUT)(x)
    #x=Dense(output_dim=10,activation='linear')(x)
    x = Dense(num_classes,activation='softmax',kernel_initializer="he_normal",
              kernel_regularizer=regularizers.l2(weight_decay))(x)
    return x

5）生成模型

img_input=Input(shape=(32,32,3))
output = create_model(img_input)
model=Model(img_input,output)
model.summary()

模型的参数量如下：

Total params: 10,210,090
Trainable params: 10,190,186
Non-trainable params: 19,904

对比 Inception v1 的参数量

Total params: 5,984,936
Trainable params: 5,984,424
Non-trainable params: 512

有 Batch Normalization 的参数量计算参考 【Keras-NIN】CIFAR-10

6）开始训练

# set optimizer
sgd = optimizers.SGD(lr=.1, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])

# set callback
tb_cb = TensorBoard(log_dir=log_filepath, histogram_freq=0)
change_lr = LearningRateScheduler(scheduler)
cbks = [change_lr,tb_cb]

# dump checkpoint if you need.(add it to cbks)
# ModelCheckpoint('./checkpoint-{epoch}.h5', save_best_only=False, mode='auto', period=10)

# set data augmentation
datagen = ImageDataGenerator(horizontal_flip=True,
                             width_shift_range=0.125,
                             height_shift_range=0.125,
                             fill_mode='constant',cval=0.)
datagen.fit(x_train)

# start training
model.fit_generator(datagen.flow(x_train, y_train,batch_size=batch_size),
                    steps_per_epoch=iterations,
                    epochs=epochs,
                    callbacks=cbks,
                    validation_data=(x_test, y_test))
model.save('inception_v2.h5')

7）结果分析
training accuracy 和 training loss
在这里插入图片描述 在这里插入图片描述 在这里插入图片描述
在这里插入图片描述在这里插入图片描述

  • accuracy
    在这里插入图片描述
  • loss
    在这里插入图片描述

比不上 Inception-v1

test accuracy 和 test loss
在这里插入图片描述 在这里插入图片描述 在这里插入图片描述
在这里插入图片描述在这里插入图片描述

  • accuracy
    在这里插入图片描述
  • loss
    在这里插入图片描述

…………

在这里插入图片描述
耐克标志，过拟合了，试试把网络瘦身下，去掉 stem 结构。

在这里插入图片描述 在这里插入图片描述

2.2 Inception_v2_slim

把 Inception_v2 中 stern 结构直接替换成一个卷积，inception 结构不变，因为stem 结构会把原图降到1/8的分辨率，对于 ImageNet（224x224） 还行，CIFRA-10（32x32）的话有些吃不消了。

  • 调整 learning rate schedule
def scheduler(epoch):
    if epoch < 100:
        return 0.01
    if epoch < 200:
        return 0.001
    return 0.0001
  • 调整网络结构
def create_model(img_input):
    x = Conv2D(192,kernel_size=(3,3),strides=(1,1),padding='same',
               kernel_initializer="he_normal",kernel_regularizer=regularizers.l2(weight_decay))(img_input)
    x = Activation('relu')(BatchNormalization(momentum=0.9, epsilon=1e-5)(x))
    x=inception_module(x,params=[(64,),(64,64),(64,96),(32,)],concat_axis=CONCAT_AXIS) #3a
    x=inception_module(x,params=[(64,),(64,96),(64,96),(64,)],concat_axis=CONCAT_AXIS) #3b
    x=inception_module(x,params=[(0,),(128,160),(64,96),(0,)],concat_axis=CONCAT_AXIS,increase=True) #3c
    x=inception_module(x,params=[(224,),(64,96),(96,128),(128,)],concat_axis=CONCAT_AXIS) #4a
    x=inception_module(x,params=[(192,),(96,128),(96,128),(128,)],concat_axis=CONCAT_AXIS) #4b
    x=inception_module(x,params=[(160,),(128,160),(128,160),(96,)],concat_axis=CONCAT_AXIS) #4c
    x=inception_module(x,params=[(96,),(128,192),(160,192),(96,)],concat_axis=CONCAT_AXIS) #4d
    x=inception_module(x,params=[(0,),(128,192),(192,256),(0,)],concat_axis=CONCAT_AXIS,increase=True) #4e
    x=inception_module(x,params=[(352,),(192,320),(160,224),(128,)],concat_axis=CONCAT_AXIS) #5a
    x=inception_module(x,params=[(352,),(192,320),(192,224),(128,)],concat_axis=CONCAT_AXIS) #5b
    x=GlobalAveragePooling2D()(x)
    x = Dense(num_classes,activation='softmax',kernel_initializer="he_normal",
              kernel_regularizer=regularizers.l2(weight_decay))(x)
    return x

其它代码同 Inception_v2
参数量如下：

Total params: 10,090,538
Trainable params: 10,070,890
Non-trainable params: 19,648

对比 Inception_v2

Total params: 10,210,090
Trainable params: 10,190,186
Non-trainable params: 19,904

结果分析如下：

training accuracy 和 training loss
在这里插入图片描述 在这里插入图片描述 在这里插入图片描述 在这里插入图片描述

在这里插入图片描述在这里插入图片描述

  • accuracy
    在这里插入图片描述

  • loss
    在这里插入图片描述
    还行，符合 inception 2.0 的风范，别过拟合就好

test accuracy 和 test loss
在这里插入图片描述 在这里插入图片描述 在这里插入图片描述 在这里插入图片描述
在这里插入图片描述 在这里插入图片描述

  • accuracy
    在这里插入图片描述
  • loss
    在这里插入图片描述

哇，精度快到了（95%），过拟合缓解了。哈哈哈，海王拿到他的叉了……
在这里插入图片描述
和前辈们对比下
在这里插入图片描述
在这里插入图片描述

3 总结

模型大小
在这里插入图片描述

keras inception_resnet_v2训练
jacke121的专栏
01-02 7887
keras inception_resnet_v2训练
Inception-resnet-v2
04-16
Inception-resnet-v2的caffe版本训练相关包括：solver.prototxt，trainval.prototxt，对应预训练模型：inception-resnet-v2.caffemodel
四、经典网络8（Inception v2）
myani的博客
05-04 2431
在 V1 的基础之上主要做了以下改进： (1) 使用 BN 层，将每一层的输出都规范化到一个 N(0,1)的正态分布，这将有助于训练，因为下一层不必学习输入数据中的偏移，并且可以专注与如何更好地组合特征（也因为在 v2 里有较好的效果，BN 层几乎是成了深度网络的必备）； （在 Batch-normalized 论文中只增加了 BN 层，而之后的 Inception V3 的论文提及到的 inception v2 还做了下面的优化） (2)使用 2 个 3x3 的卷积代替梯度（特征图，下同）为
Python-Keras实现Inceptionv4InceptionResnetv1和v2网络架构
08-11
Keras实现Inception-v4, Inception - Resnet-v1和v2网络架构
keras_inception_v4_finetune.py例子
01-28
官方例子，深度学习专用，机器学习专用，代码简单，一看就会(keras inception v4 finetune)
[计算机视觉]-经典网络inception v1、v2、v3、v4核心工作详解及总结
ai_faker的博客
04-21 4860
资源 inception v1 Going deeper with convolutions：https://arxiv.org/abs/1409.4842 BN算法 Batch Normalization：https://arxiv.org/pdf/1502.03167.pdf inception v2/v3 Rethinking the Inception Architecture for Computer Vision：https://arxiv.org/pdf/1512.00567.pdf ince
Keras 入门课4 -- 使用ResNet识别cifar10数据集
热门推荐
史丹利复合田的博客
12-21 1万+
Keras入门课4：使用ResNet识别cifar10数据集前面几节课都是用一些简单的网络来做图像识别，这节课我们要使用经典的ResNet网络对cifar10进行分类。
关于CIFAR-10图像分类总结
MirrorN的博客
05-08 1万+
之前一段时间学习深度学习在CIFAR-10数据集上图像分类问题，在此做一点点总结，关于这个问题，网络上已经有很多优秀的资源了，因此，主要是汇总一些博客等资料。 关于图像分类算法的总结 很多网站都转载了这篇文章，文章比较了五种图像分类算法，传统机器学习以及深度学习的方法都有涉及，了解图像分类可以看一看 原文：Image Classification in 5 Methods 翻译等可见：图像分类 |...
实战LeNet-5 AlexNet ResNet 实践 Cifar-10问题
pengdali的专栏
12-30 4497
一、Cifar-10的说明cifar10是一个32*32 的图像10分类问题，一共有60000张图片，我们拿50000张做训练数据，另外拿2000张做测试数据。 为了学习不同网络，这里统一拿这个用作实验材料，关于下载cifar10，或更多说明可以查看官网CIFAR-10二、LeNet5模型 如图所示这个模型就是2个卷积、池化，再连3个全连接 第一个卷积层6个大小为5＊5卷积核，第二卷积层为
深度学习经典网络: Inception系列网络(Inception v4 和Inception-ResNet)
weixin_42615068的博客
07-31 1307
Inception v4 & Inception-ResNet:https://arxiv.org/abs/1602.07261 前言   主要受ResNet 网络的启发，他们基于inception v3的基础上，引入了残差结构，提出了inception-resnet-v1和inception-resnet-v2，并修改inception模块提出了inception v4结构。基于ince...
EfficientNetV2
qq_42057562的博客
07-04 765
Backbone：EfficientNetV2采用MBConv与Fused-MBConv混合使用来提高网络的训练速度。经过多次实验发现将1-3模块替换为Fused-MBConv效果最好。 训练时改变输入图像的大小： 在训练时不同大小的图片训练速度和参数大小是不一样的，所以该网络采用大小不同的图片进行训练，可以进一步提高网络的训练速度，并且减少参数量 实验结果： ...
keras实现Inception模块
weixin_47289438的博客
11-17 2755
1.Conv_bn的实现 也就是说，这里默认是卷积后(默认relu) + 一个BN层 另外，这里的形式参数的默认值，取的太巧妙了 反正是’same’模式，高和宽不会改变 当然，你想改的时候，只要改成valid就行了 。 像步长也是可以改的 1x1 、 3x3 、 5x5 通通只要在这个函数完成就行了 函数的封装性真的强大 from keras.models import Model from keras.layers import Dense,add,Input,Flatten,Conv2D,MaxPo
Inception-Resnet-v1、Inception-Resnet-v2学习笔记（附Pytorch代码）
你好，明天，，的博客
02-14 6700
介绍Inception-Resnet-v1和IInception-Resnet-v2网络结构，并基于pytorch实现这两种网络结构。nception-V4在Inception-V3的基础上进一步改进了Inception模块，提升了模型性能和计算效率，但没有使用残差模块， Inception-ResNet将Inception模块和深度残差网络ResNet结合，提出了三种包含残差连接的Inception模块，残差连接显著加快了训练收敛速度。
Inceptionv4阅读+实现笔记
飞翔的荷兰人
11-18 1155
文章目录1. inception v42. Inception-resnet-v1 &amp; Inception-resnet-v22.1 Inception-resnet-v1的组成模块2.2 Inception-resnet-v2的组成模块3. 模型训练4. 代码4.1 Inception-V44.2 inception_resnet_v14.3 inception_resnet_v2 在下...
nnU-Netv2在服务器上使用全流程（小白边踩坑边学习的记录）
最新发布
m0_61420917的博客
09-01 9387
小白第一次使用nnunet做医学影像分割任务的经历，记录记录踩的坑，憧憬下未来的继续使用
【keras实战】用Inceptionv3实现五种花的分类
m0_37935211的博客
10-10 7873
参考：keras系列︱迁移学习：利用InceptionV3进行fine-tuning及预测、完美案例（五）   一、数据集准备 训练数据花朵图片下载：地址 图片下载好后划分数据集，分为训练集和验证集，训练集每类图片500张，验证集每类图片100张。 这是我数据集的树图： 二、训练模型 环境：Ubuntu,Anaconda2,python2.7,tensorflow,keras ...
keras搬砖系列-inception v2与v3
Cutepingping的博客
03-13 1101
keras搬砖系列-inception v2与v3与v4inception v2的基础上在v1的基础上，进行了改进，一方面加了BN层，减少了Internal Convariate Shift，每一层的输出都规范化到一个高斯，另外一个方面学习VGG用2个conv替代inception模块中的5*5模块，降低了参数的数量，也进行了加速计算；一个5*5的网络等于两个3*3的网络：再修正后的incepti...
Keras-API实现 Inception 模块和残差连接
yaoxunji的博客
04-23 3817
使用keras框架常见的神经网络都是用 Sequential 模型实现的。 Sequential 模型假设，网络只有一个输入和一个输出，而且网络是层的线性堆叠。这是一个经过普遍验证的假设。这种网络配置非常常见，以至于只用 Sequential模型类就能够涵盖许多主题和实际应用。但有些情况下这种假设过于死板。有些网络需要多个独立的输入，有些网络则需要多个输出，而有些网络在层与层之间具有内部分支，这使...
CNN模型之GoogLeNet(Inception) v2
励志的小胡子
11-10 688
一、介绍          2015年谷歌团队提出了Inception V2，首次提出了批量(Batch Normalization)归一化方法，可以提高网络的收敛速度。应用范围广泛。主要的创新点包括： Batch Normalization：在神经网络的每层计算中，参数变化导致数据分布不一致，会产生数据的协方差偏移...
Inception-ResNet v2模型在Keras的应用与权重文件使用指南
10. 压缩包子文件信息：文件名称列表中提到的"keras-inception-resnet-v2-master"表明了这是一个包含Inception-ResNet v2模型实现的主仓库文件夹。开发者可以下载并解压该文件，以便对代码进行查看、修改和使用。 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值