Loading [MathJax]/jax/output/CommonHTML/config.js
前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >resnet18[通俗易懂]

resnet18[通俗易懂]

作者头像
全栈程序员站长
发布于 2022-09-01 08:56:20
发布于 2022-09-01 08:56:20
1.6K00
代码可运行
举报
运行总次数:0
代码可运行

大家好,又见面了,我是你们的朋友全栈君。

前言

在前篇vgg16之后,无法成功训练vgg16,发现是自己电脑可用的显存太低了,遂放弃。

在2015 ILSVRC&COCO比赛中,何恺明团队提出的Resnet网络斩获第一,这是一个经典的网络。李沐说过,如果要学习一个CNN网络,一定是残差网络Resnet。与VGG相比,Resnet则更加出色,为后续的研究做下铺垫 这是Resnet论文翻译参考链接:https://blog.csdn.net/weixin_42858575/article/details/93305238

在之前的神经网络,存在两个问题:

  1. 网络收敛速度很慢,在用vgg16训练做cifar分类的时候,收敛速度很慢,与resnet相比,收敛速度慢至几倍甚至十倍。而且一旦出现梯度爆炸或者梯度消失,则会影响网络的收敛
  2. 随着网络的加深,准确率达到饱和,然后开始下降。这称之为退化。

从上面这幅图可以看出,在一定的训练迭代中,适合的浅层网络要比深层网络有更低的训练误差和测试误差

Resnet在当时打破了网络越深,性能越好的共识,而且残差结构能加速学习,使得模型更加容易学习,也能有效地防止梯度爆炸或者消失。

为什么残差网络更容易学习特征?

  1. 从论文中可以看出,Resnet网络没有使用Dropout,而是利用了Bn层和平均池化层进行正则化,有效加快训练。
  2. 使用很少的池化层,间接加快训练
  3. 残差结构能够减少学习压力,在学习过程中,可以通过Shortcut连接学习冗余度比较高的地方,整体看,网络不再依赖整个映射,因此能够学习地更好。
  4. 还有一个可能,Resnet就像是集成学习,将每一个残差模块以某种加权方式学习起来。该观点属于猜测,写下来是为了做个标记,在未来可以根据资料印证。

区分退化和过拟合: 退化:指的是网络深度增加,网络准确度出现饱和,甚至出现下降 过拟合:指的是网络在训练集训练的很好,但是在未知的测试集表现地很差

下图是Resnet系列,包括Resnet18、Resnet34、Resnet50、Resnet101、Resnet152

在keras中没有找到Resnet18的网络,所以本次复现的是Resnet18,如果有问题,请联系我。本次我根据一些帖子以及pytorch的源码去核对我复现的版本,复现的代码参照了keras源码。

代码
Resnet18
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
from keras import backend
from keras.applications import imagenet_utils
from keras.engine import training
from keras.layers import VersionAwareLayers

layers = VersionAwareLayers()
def ResNet18(input_tensor=None,
             input_shape=None,
             classes=1000,
             use_bias=True,
             classifier_activation='softmax',
             weights=None):
    bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
    if input_tensor is None:
        img_input = layers.Input(shape=input_shape)
    else:
        if not backend.is_keras_tensor(input_tensor):
            img_input = layers.Input(tensor=input_tensor, shape=input_shape)
        else:
            img_input = input_tensor

    # conv1_conv
    x = layers.ZeroPadding2D(
        padding=((3, 3), (3, 3)), name='conv1_pad')(img_input)
    x = layers.Conv2D(64, 7, strides=2, use_bias=use_bias, name='conv1_conv')(x)
    x = layers.BatchNormalization(
        axis=bn_axis, epsilon=1.001e-5, name='conv1_bn')(x)
    x = layers.Activation('relu', name='conv1_relu')(x)
    x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name='pool1_pad')(x)
    x = layers.MaxPooling2D(3, strides=2, name='pool1_pool')(x)

    # 第二段卷积
    x = block1(x, filters=64, kernel_size=3, conv_shortcut=False, name="conv2_block1")
    x = block1(x, filters=64, kernel_size=3, conv_shortcut=False, name="conv2_block2")

    # 第三段卷积
    x = block1(x, filters=128, kernel_size=3, stride=2, conv_shortcut=True, name="conv3_block1")
    x = block1(x, filters=128, kernel_size=3, conv_shortcut=False, name="conv3_block2")

    # 第四段卷积
    x = block1(x, filters=256, kernel_size=3, stride=2, conv_shortcut=True, name="conv4_block1")
    x = block1(x, filters=256, kernel_size=3, conv_shortcut=False, name="conv4_block2")

    # 第五段卷积
    x = block1(x, filters=512, kernel_size=3, stride=2, conv_shortcut=True, name="conv5_block1")
    x = block1(x, filters=512, kernel_size=3, conv_shortcut=False, name="conv5_block2")

    x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
    imagenet_utils.validate_activation(classifier_activation, weights)
    x = layers.Dense(classes, activation=classifier_activation,
                     name='predictions')(x)

    model = training.Model(img_input, x, name="Resnet18")
    return model


def block1(x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None):
    bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1

    if conv_shortcut:
        shortcut = layers.Conv2D(
            filters, 1, strides=stride, name=name + '_0_conv')(x)
        shortcut = layers.BatchNormalization(
            axis=bn_axis, epsilon=1.001e-5, name=name + '_0_bn')(shortcut)
    else:
        shortcut = x

    x = layers.Conv2D(
        filters, kernel_size,strides=stride, padding='SAME', name=name + '_1_conv')(x)
    x = layers.BatchNormalization(
        axis=bn_axis, epsilon=1.001e-5, name=name + '_1_bn')(x)
    x = layers.Activation('relu', name=name + '_1_relu')(x)

    x = layers.Conv2D(
        filters, kernel_size, padding='SAME', name=name + '_2_conv')(x)
    x = layers.BatchNormalization(
        axis=bn_axis, epsilon=1.001e-5, name=name + '_2_bn')(x)

    x = layers.Add(name=name + '_add')([x, shortcut])
    x = layers.Activation('relu', name=name + '_out')(x)
    return x
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
from resnet18_version1.resnet import ResNet18
from keras.utils.vis_utils import plot_model

# 通过plot_model保存keras版本resnet18的模型结构
model = ResNet18(input_shape=(224,224,3),classes=10)
model.summary()
plot_model(model,to_file="./resnet18.png",show_shapes=True)
下图是plot_model函数保存下来的Resnet18网络结构,欢迎大家指出问题
训练

这次依旧训练cifar10,将cifar10分成训练集、验证集、测试集。接下来贴代码,本次训练和上篇vgg16一样,大家可以参照上一篇。按照其他大佬的经验,在不大修改模型的情况下,按照比赛的记录,测试的结果应该在85%+。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
import glob
import os, sys
import random
from concurrent.futures import ThreadPoolExecutor
import cv2
import numpy as np
import tensorflow as tf
from keras.applications.resnet import ResNet, ResNet50
from keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications.vgg16 import VGG16

from resnet18_version1.resnet import ResNet18

os.environ["CUDA_VISIBLE_DEVICES"] = "0"
# # tensorflow 2.0写法
config = tf.compat.v1.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.98
config.gpu_options.allow_growth = True
sess = tf.compat.v1.Session(config=config)

cifarlabel = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
train_path = r""
test_path = r""
valid_path = r""
batch_size = 8


def train():
    # 数据增强方式
    transform = ImageDataGenerator(rescale=1. / 255, rotation_range=random.randint(0, 30), width_shift_range=random.randint(0, 5),
                                   height_shift_range=random.randint(0, 5))

    train_data = transform.flow_from_directory(train_path, target_size=(32, 32), shuffle=True, batch_size=batch_size)
    valid_data = transform.flow_from_directory(valid_path, target_size=(32, 32), shuffle=True, batch_size=batch_size)

    model = ResNet18(
        weights=None,
        classes=10,
        input_shape=(32, 32, 3)
    )
    early_stopping = tf.keras.callbacks.EarlyStopping(monitor='loss', min_delta=0.001, patience=3, verbose=0,
                                                      mode='auto',
                                                      baseline=None, restore_best_weights=False)
    model.compile(optimizer="Adam",
                  loss=tf.keras.losses.categorical_crossentropy,
                  metrics=['accuracy'])
    model.fit_generator(train_data, epochs=50,
                        callbacks=[early_stopping], validation_data=valid_data)
    model.save("./resnet18.h5")


def write_img(path, img, label, index):
    print(index)
    label = str(label)
    dir = os.path.join(path, label)
    if not os.path.exists(dir):
        os.makedirs(dir)
    img_path = os.path.join(dir, str(index) + ".jpg")
    cv2.imwrite(img_path, img)


def gen_data():
    (train_image, train_label), (test_image, test_label) = tf.keras.datasets.cifar10.load_data()
    print(train_image[3].shape, cifarlabel[int(train_label[3])])  # 查看数据格式
    path = train_path
    with ThreadPoolExecutor(max_workers=None) as t:
        for index, i in enumerate(range(len(train_image))):
            t.submit(write_img, path, train_image[index], int(train_label[index]), index)
    path = test_path
    with ThreadPoolExecutor(max_workers=None) as t:
        for index, i in enumerate(range(len(test_image))):
            t.submit(write_img, path, test_image[index], int(test_label[index]), index)
    valid_path = os.path.join(os.path.dirname(train_path), "valid")
    for i in os.listdir(train_path):
        dirname = os.path.join(train_path, i)
        valid_dir = os.path.join(valid_path, i)
        if not os.path.exists(valid_dir):
            os.makedirs(valid_dir)
        files = os.listdir(dirname)
        files = random.sample(files, len(files))
        for j in files[:int(len(files) * 0.1)]:
            os.rename(os.path.join(dirname, j), os.path.join(valid_dir, j))


# keras flow_from_directory会无限循环提供batch图片,
# 现在写一个伪迭代,仿flow_from_directory会无限循环提供batch图片,
# 缺点很多,比不上源代码,而且路径只有2级。我定义的是数字类名,这里刚好也使用数字。
# 如果自己自定义数据集的话,需要自己修改此处代码
def loader(path, batch_size, target_size=(224, 224), shuffle=True):
    files = glob.glob(os.path.join(path, "*", "*.jpg"))
    if shuffle:
        random.shuffle(files)
    labels = [os.path.basename(os.path.dirname(file)) for file in files]
    # print(files[0],labels[0])
    for i in range(0, len(files), batch_size):
        imgs = files[i:i + batch_size]
        imgs = [cv2.imread(img) for img in imgs]
        imgs = [cv2.resize(img, target_size) for img in imgs]
        imgs = [tf.convert_to_tensor(img) for img in imgs]
        imgs = tf.convert_to_tensor(imgs)
        labelss = labels[i:i + batch_size]
        yield (imgs, labelss)


def test():
    # 数据增强方式 刚开始没有给图片归一化,准确率一直在10%左右
    transform = ImageDataGenerator(rescale=1. / 255)

    test_data = transform.flow_from_directory(test_path, target_size=(224, 224), shuffle=True, batch_size=batch_size,class_mode="sparse")

    model = tf.keras.models.load_model("/data/kile/other/vgg16/resnet18_version1/model/0.415565_resnet18.h5",compile=False)
    allCount = 0
    trueCount = 0
    for index, i in enumerate(test_data):
        if index >= len(test_data):
            break
        predict_result = model.predict(i[0])
        # 预测的label
        predict_label = np.argmax(predict_result, axis=1).tolist()
        # 实际的label
        label = i[1]
        print(allCount, predict_label, label)
        for a, b in zip(predict_label, label):
            allCount += 1
            if a == int(b):
                trueCount += 1
    print(f"allCount:{ 
     allCount} trueCount:{ 
     trueCount} true_percent:{ 
     trueCount / allCount}")


if __name__ == '__main__':
    # gen_data() 第一次使用就好了 不用重复
    train()
    test()
训练结果:总共训练了20个epoches,但是在第15-18个epoches时,模型达到比较优秀的结果
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
Epoch 1/20
2022-01-02 13:55:16.442882: I tensorflow/stream_executor/cuda/cuda_dnn.cc:369] Loaded cuDNN version 8204
2813/2813 [==============================] - 472s 166ms/step - loss: 1.4426 - accuracy: 0.4791 - lr: 0.0100 - val_loss: 1.2521 - val_accuracy: 0.5508 - val_lr: 0.0100
/root/anaconda3/envs/py36/lib/python3.6/site-packages/keras/utils/generic_utils.py:497: CustomMaskWarning: Custom mask layers require a config and must override get_config. When loading, the custom mask layer must be passed to the custom_objects argument.
  category=CustomMaskWarning)
Epoch 2/20
2813/2813 [==============================] - 468s 166ms/step - loss: 0.9934 - accuracy: 0.6509 - lr: 0.0100 - val_loss: 1.1318 - val_accuracy: 0.6276 - val_lr: 0.0100
Epoch 3/20
2813/2813 [==============================] - 465s 165ms/step - loss: 0.7994 - accuracy: 0.7200 - lr: 0.0100 - val_loss: 1.0890 - val_accuracy: 0.6560 - val_lr: 0.0100
Epoch 4/20
2813/2813 [==============================] - 465s 165ms/step - loss: 0.6785 - accuracy: 0.7641 - lr: 0.0100 - val_loss: 1.0904 - val_accuracy: 0.6406 - val_lr: 0.0100
Epoch 5/20
2813/2813 [==============================] - 466s 166ms/step - loss: 0.5909 - accuracy: 0.7921 - lr: 0.0100 - val_loss: 0.7205 - val_accuracy: 0.7576 - val_lr: 0.0100
Epoch 6/20
2813/2813 [==============================] - 469s 167ms/step - loss: 0.5240 - accuracy: 0.8202 - lr: 0.0100 - val_loss: 0.6743 - val_accuracy: 0.7686 - val_lr: 0.0100
Epoch 7/20
2813/2813 [==============================] - 468s 166ms/step - loss: 0.4629 - accuracy: 0.8409 - lr: 0.0100 - val_loss: 0.7149 - val_accuracy: 0.7650 - val_lr: 0.0100
Epoch 8/20
2813/2813 [==============================] - 464s 165ms/step - loss: 0.4110 - accuracy: 0.8576 - lr: 0.0100 - val_loss: 0.7091 - val_accuracy: 0.7670 - val_lr: 0.0100
Epoch 9/20
2813/2813 [==============================] - 466s 166ms/step - loss: 0.3740 - accuracy: 0.8717 - lr: 0.0100 - val_loss: 0.6305 - val_accuracy: 0.7976 - val_lr: 0.0100
Epoch 10/20
2813/2813 [==============================] - 470s 167ms/step - loss: 0.3314 - accuracy: 0.8846 - lr: 0.0100 - val_loss: 0.7267 - val_accuracy: 0.7786 - val_lr: 0.0100
Epoch 11/20
2813/2813 [==============================] - 463s 165ms/step - loss: 0.3009 - accuracy: 0.8947 - lr: 0.0100 - val_loss: 0.6524 - val_accuracy: 0.7990 - val_lr: 0.0100
Epoch 12/20
2813/2813 [==============================] - 463s 165ms/step - loss: 0.2707 - accuracy: 0.9073 - lr: 0.0100 - val_loss: 0.6691 - val_accuracy: 0.7934 - val_lr: 0.0100
Epoch 13/20
2813/2813 [==============================] - 464s 165ms/step - loss: 0.1561 - accuracy: 0.9498 - lr: 9.9999e-04 - val_loss: 0.4140 - val_accuracy: 0.8664 - val_lr: 1.0000e-03
Epoch 14/20
2813/2813 [==============================] - 463s 165ms/step - loss: 0.1306 - accuracy: 0.9608 - lr: 9.9999e-04 - val_loss: 0.4191 - val_accuracy: 0.8628 - val_lr: 1.0000e-03
Epoch 15/20
2813/2813 [==============================] - 472s 168ms/step - loss: 0.1198 - accuracy: 0.9646 - lr: 9.9999e-04 - val_loss: 0.4149 - val_accuracy: 0.8644 - val_lr: 1.0000e-03
Epoch 16/20
2813/2813 [==============================] - 463s 165ms/step - loss: 0.1080 - accuracy: 0.9682 - lr: 9.9999e-04 - val_loss: 0.4156 - val_accuracy: 0.8644 - val_lr: 1.0000e-03
Epoch 17/20
2813/2813 [==============================] - 472s 168ms/step - loss: 0.1019 - accuracy: 0.9697 - lr: 9.9999e-04 - val_loss: 0.4225 - val_accuracy: 0.8684 - val_lr: 1.0000e-03
Epoch 18/20
2813/2813 [==============================] - 464s 165ms/step - loss: 0.0959 - accuracy: 0.9721 - lr: 9.9999e-04 - val_loss: 0.4228 - val_accuracy: 0.8670 - val_lr: 1.0000e-03
Epoch 19/20
2813/2813 [==============================] - 470s 167ms/step - loss: 0.0883 - accuracy: 0.9750 - lr: 9.9999e-04 - val_loss: 0.4216 - val_accuracy: 0.8654 - val_lr: 1.0000e-03
Epoch 20/20
2813/2813 [==============================] - 476s 169ms/step - loss: 0.0868 - accuracy: 0.9752 - lr: 9.9999e-04 - val_loss: 0.4166 - val_accuracy: 0.8664 - val_lr: 1.0000e-03
接下来 我们取其中第16个epoches做测试,得到结果,准确率大概在88%
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
9968 [3, 4, 6, 7, 4, 9, 2, 5] [3. 4. 6. 7. 4. 2. 5. 5.]
9976 [9, 9, 3, 4, 4, 7, 4, 5] [9. 9. 3. 4. 4. 7. 4. 5.]
9984 [1, 9, 1, 3, 4, 0, 2, 8] [1. 9. 1. 3. 4. 0. 2. 8.]
9992 [3, 1, 9, 1, 9, 5, 1, 4] [3. 1. 9. 9. 9. 5. 1. 7.]
allCount:10000   trueCount:8792  true_percent:0.8792

补充,其实还有一种方式可以画出keras的结构图。而且是网页版的 https://netron.app/

结果模型我已经放在云盘 欢迎大家下载测试 https://url25.ctfile.com/f/34628125-532522905-23a4e6 (访问密码:3005)

发布者:全栈程序员栈长,转载请注明出处:https://javaforall.cn/141112.html原文链接:https://javaforall.cn

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2022年5月2,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
暂无评论
推荐阅读
编辑精选文章
换一批
深度学习图片分类CNN模板
其中A,B,C都代表label,三个文件夹存在具体的图片。只要是这样类型的,直接套下面模板。
润森
2022/09/22
1.1K0
深度学习图片分类CNN模板
tensorflow2.2_实现Resnet34_花的识别[通俗易懂]
    Resnet是由许多残差块组成的,而残差块可以解决网络越深,效果越差的问题。     残差块的结构如下图所示。
全栈程序员站长
2022/11/10
6380
tensorflow2.2_实现Resnet34_花的识别[通俗易懂]
深入解析EfficientNet:高效深度学习网络与ResNet的对比(使用keras进行代码复现,并使用cifar10数据集进行实战)
在深度学习领域,卷积神经网络(CNN)是解决图像分类、目标检测等问题的关键技术之一。近年来,随着深度学习的不断发展,新的网络架构不断涌现。在众多网络架构中,EfficientNet和ResNet都成为了深度学习模型的佼佼者,分别在高效性和深度特性上得到了广泛应用。本文将详细介绍EfficientNet,并与经典的ResNet进行对比,分析它的架构、使用场景、适用问题及实例。
机器学习司猫白
2025/03/05
4160
深入解析EfficientNet:高效深度学习网络与ResNet的对比(使用keras进行代码复现,并使用cifar10数据集进行实战)
ResNet18代码实现[通俗易懂]
from tensorflow.keras import layers, Sequential, Model, datasets, optimizers
全栈程序员站长
2022/08/24
1K0
rock数据集ResNet34实现「建议收藏」
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
全栈程序员站长
2022/11/10
5100
rock数据集ResNet34实现「建议收藏」
【tensorflow2.0】处理图片数据-cifar2分类
cifar2数据集为cifar10数据集的子集,只包括前两种类别airplane和automobile。
西西嘛呦
2020/08/26
7680
【tensorflow2.0】处理图片数据-cifar2分类
【tensorflow2.0】构建模型的三种方法
可以使用以下3种方式构建模型:使用Sequential按层顺序构建模型,使用函数式API构建任意结构模型,继承Model基类构建自定义模型。
西西嘛呦
2020/08/26
8390
【tensorflow2.0】构建模型的三种方法
训练模型的3种方法
Pytorch没有官方的高阶API。一般通过nn.Module来构建模型并编写自定义训练循环。
lyhue1991
2020/07/20
1.7K0
训练模型的3种方法
什么?自如租房价格是图片【2】【Python爬虫】
灰度转换公式:L = R * 299/1000 + G * 587/1000 + B * 114/1000
lpe234
2021/07/29
5790
什么?自如租房价格是图片【2】【Python爬虫】
用Keras Tensorflow 2.0实现YOLO V1
本文尝试使用Tensorflow 2.0复现论文<You Only Look Once: Unified, Real-Time Object Detection>的效果。
YoungTimes
2022/04/28
1.3K0
用Keras Tensorflow 2.0实现YOLO V1
深度学习检测疟疾
欢迎来到AI for Social Good系列,将重点关注人工智能(AI)与流行的开源工具,技术和框架如何用于发展和改善社会的不同方面。“健康就是财富”也许是一个陈词滥调,但却非常真实!在这篇特别的文章中,将研究如何利用AI来检测疟疾,这是一种致命的疾病,并且有望建立一个低成本,有效和准确的开源解决方案。本文的目的是双重的 - 了解致命疾病疟疾的动机和重要性以及深度学习在检测疟疾方面的有效性。将在本文中介绍以下主要主题:
代码医生工作室
2019/06/21
1.1K0
深度学习检测疟疾
ResNet18-TensorFlow[通俗易懂]
发布者:全栈程序员栈长,转载请注明出处:https://javaforall.cn/144894.html原文链接:https://javaforall.cn
全栈程序员站长
2022/08/30
2410
使用CNN进行情感分类
参考文章: Embedding层详解 Keras: GlobalMaxPooling vs. MaxPooling
Michael阿明
2021/02/19
1.1K0
使用CNN进行情感分类
医生再添新助手!深度学习诊断传染病 | 完整代码+实操
【导读】文本基于深度学习和迁移学习方法,对疟疾等传染病检测问题进行了研究。作者对疟疾的检测原理以及迁移学习理论进行了介绍,并使用VGG-19预训练模型,进行了基于特征提取和基于参数微调的迁移学习实践。
AI科技大本营
2019/05/14
9620
医生再添新助手!深度学习诊断传染病 | 完整代码+实操
[Kaggle] Digit Recognizer 手写数字识别(卷积神经网络)
相关博文: [Hands On ML] 3. 分类(MNIST手写数字预测) [Kaggle] Digit Recognizer 手写数字识别 [Kaggle] Digit Recognizer 手写数字识别(简单神经网络) 04.卷积神经网络 W1.卷积神经网络
Michael阿明
2021/02/19
1.4K0
[Kaggle] Digit Recognizer 手写数字识别(卷积神经网络)
Tensorflow2.0使用Resnet18进行数据训练
为了数据获取方便,这里使用的是CIFAR10的数据,可以在代码中直接使用keras.datasets.cifar10.load_data()方法获取,非常的方便
陶陶name
2022/05/12
8450
04.卷积神经网络 W2.深度卷积网络:实例探究(作业:Keras教程+ResNets残差网络)
Keras 是更高级的框架,对普通模型来说很友好,但是要实现更复杂的模型需要 TensorFlow 等低级的框架
Michael阿明
2021/02/19
7730
使用GPU训练模型
Pytorch没有官方的高阶API。一般通过nn.Module来构建模型并编写自定义训练循环。
lyhue1991
2020/07/22
3K0
模型剪枝
在这个过程中很有可能因为连接剪枝是一个非常不规则的操作,我们实现的时候通常会维护一个维度相等的矩阵,称为掩膜(mask)矩阵。掩膜矩阵为1的地方表示要保持的权重,为0的地方表示要剪掉的权重。
算法之名
2022/05/06
9570
模型剪枝
利用深度学习实现验证码识别-3-ResNet18
在当今数字化时代,验证码作为一种重要的安全验证手段,广泛应用于各种网络场景。然而,传统的验证码识别方法往往效率低下,准确率不高。今天,我们将介绍一种基于 ResNet18 的验证码识别方法,它能够高效、准确地识别验证码,为网络安全提供有力保障。
井九
2024/10/12
1720
利用深度学习实现验证码识别-3-ResNet18
相关推荐
深度学习图片分类CNN模板
更多 >
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档
本文部分代码块支持一键运行,欢迎体验
本文部分代码块支持一键运行,欢迎体验