40 深度学习（四）：卷积神经网络|深度可分离卷积|colab和kaggle的基础使用

最新推荐文章于 2024-05-31 16:14:40 发布
最新推荐文章于 2024-05-31 16:14:40 发布
阅读量616 收藏 1
点赞数 1
分类专栏： 个人python流程学习 文章标签： 深度学习 cnn 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Micoreal/article/details/134082577
版权

文章目录

卷积神经网络

卷积神经网络的基本结构 1：
(卷积层+(可选)池化层) * N+全连接层 * M（N>=1,M>=0）
卷积层的输入和输出都是矩阵，全连接层的输入和输出都是向量，在最后一层的卷积上，把它做一个展平，这样就可以和全连接层进行运算了，为什么卷积要放到前面，因为展平丧失了维度信息，因此全连接层后面不能再放卷积层。

卷积神经网络的基本结构 2：
(卷积层+(可选)池化层)N+反卷积层K
反卷积层用来放大，可以让输出和输入一样大，当输出和输入一样大时，适用场景是物体分割（因为我们就是要确定这个点属于哪一个物体）。

为什么要卷积

一般从两个角度进行回答这个问题：

  1. 参数过多内存装不下，比如说：图像大小 10001000 一层神经元数目为 10^6
    ，而如果采用全连接的话，全连接参数为 1000    1000*10^ 6=10^12， 一层就是 1 万亿个参数，内存是装不下这么多参数的。
  2. 参数过多容易过拟合，计算资源不足与容易过拟合,发生过拟合，我们就需要更多训练数据，但是很多时候我们没有更多的数据，因为获取数据需要成本。

而卷积通过使用参数共享的方法进行解决这种相关的问题。

主要的理论支持：

  1. 局部连接：图像的区域性—爱因斯坦的嘴唇附近的色彩等是相似的
  2. 参数共享与平移不变性：图像特征与位置无关—左边是脸，右边也是脸，这样无论脸放在什么地方都检查出来，刚好可以解决过拟合的问题（否则脸放到其他地方就检测不出来）

可参考链接

卷积的具体流程

这边由于在之前的博客也已经介绍过了，这边就不再介绍，但是会进行相关的参数介绍，到后面的代码当中需要我们去计算相关的层数 以及 相关的shape和参数的数目，到时候会体会的更深。

参数计算流程：链接

这边搬运一下计算公式：
在这里插入图片描述
这个只是长宽，这边给出计算例子，如果有不太清楚的人，到时候可以可移步到代码部分进行学习：

格式：(B,H,W,C)

输入:(B,H,W,C)
kennel-size(3,3) stride=(1,1) padding=0 filter=32
输出:(B,((H-3+0)//1)+1,((W-3+0)//1)+1,filter) 
参数的数目:kennel-size*通道*filter（个数）+ 偏置 = 3*3*C*32 + 32

卷积和池化的流程：链接

池化

卷积和池化的流程：链接

池化： 池化函数使用某一位置的相邻输出的总体统计特征来代替网络在该位置的输出。本质是降采样，可以大幅减少网络的参数量。
池化技术的本质：在尽可能保留图片空间信息的前提下，降低图片的尺寸，增大卷积核感受视野，提取高层特征，同时减少网络参数量，预防过拟合。简单来说：等比例缩小图片，图片的主体内容丢失不多，依然具有平移，旋转，尺度的不变性，简单来说就是图片的主体内容依旧保存着原来大部分的空间信息。

一般池化也分为几种：
最大值池化：能够抑制网络参数误差造成的估计均值偏移的现象。
平均值池化：主要用来抑制邻域值之间差别过大，造成的方差过大。

特点

  1. 常使用不重叠、不补零
  2. 没有用于求导的参数
  3. 池化层参数为步长和池化核大小
  4. 用于减少图像尺寸,从而减少计算量
  5. 一定程度平移鲁棒，比如一只猫移动了一个像素的另外一张图片，我们先做池化，再做卷积，那么最终还是可以识别这个猫。
  6. 损失了空间位置精度

tensorflow代码

import matplotlib as mpl
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import sklearn
import pandas as pd
import os
import sys
import time
import tensorflow as tf
from tensorflow import keras
from sklearn.preprocessing import StandardScaler
import os

# 数据准备
# -----------------------------------------------------------------------------
fashion_mnist = keras.datasets.fashion_mnist
(x_train_all, y_train_all), (x_test, y_test) = fashion_mnist.load_data()
x_valid, x_train = x_train_all[:5000], x_train_all[5000:]
y_valid, y_train = y_train_all[:5000], y_train_all[5000:]
print(x_valid.shape, y_valid.shape)
print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)
scaler = StandardScaler()
# 注意这边和之前的不一样，这边最后面的reshape变成了28，28，1，相比于之前多了个1，符合基础的形状（B，H，W，C）
x_train_scaled = scaler.fit_transform(x_train.astype(np.float32).reshape(-1, 1)).reshape(-1, 28, 28, 1)
x_valid_scaled = scaler.transform(x_valid.astype(np.float32).reshape(-1, 1)).reshape(-1, 28, 28, 1)
x_test_scaled = scaler.transform(x_test.astype(np.float32).reshape(-1, 1)).reshape(-1, 28, 28, 1)
# -----------------------------------------------------------------------------

# 模型准备
# -----------------------------------------------------------------------------
model = keras.models.Sequential()
#添加卷积层，filters输出有多少通道，就是有多少卷积核，kernel_size卷积核的大小，
# padding是否加上padding，same代表输出和输入大小一样，1代表通道数目是1
model.add(keras.layers.Conv2D(filters=32, kernel_size=3, padding='same', activation='selu', input_shape=(28, 28, 1)))
model.add(keras.layers.Conv2D(filters=32, kernel_size=3, padding='same', activation='selu'))
#添加池化层，pool_size是窗口大小，步长默认和窗口大小相等
model.add(keras.layers.MaxPool2D(pool_size=2))
#为了缓解损失，所以filters翻倍
model.add(keras.layers.Conv2D(filters=64, kernel_size=3, padding='same', activation='selu'))
model.add(keras.layers.Conv2D(filters=64, kernel_size=3, padding='same', activation='selu'))
model.add(keras.layers.MaxPool2D(pool_size=2))
model.add(keras.layers.Conv2D(filters=128, kernel_size=3, padding='same', activation='selu'))
model.add(keras.layers.Conv2D(filters=128, kernel_size=3, padding='same', activation='selu'))
model.add(keras.layers.MaxPool2D(pool_size=2))
model.add(keras.layers.Flatten())
model.add(keras.layers.Dense(128, activation='selu'))
model.add(keras.layers.Dense(10, activation="softmax"))

model.compile(loss="sparse_categorical_crossentropy", optimizer = "sgd", metrics = ["accuracy"])
model.summary()
# -----------------------------------------------------------------------------

输出：

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
下载过程略
(5000, 28, 28) (5000,)
(55000, 28, 28) (55000,)
(10000, 28, 28) (10000,)
Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d (Conv2D)             (None, 28, 28, 32)        320       
                                                                 
 conv2d_1 (Conv2D)           (None, 28, 28, 32)        9248      
                                                                 
 max_pooling2d (MaxPooling2  (None, 14, 14, 32)        0         
 D)                                                              
                                                                 
 conv2d_2 (Conv2D)           (None, 14, 14, 64)        18496     
                                                                 
 conv2d_3 (Conv2D)           (None, 14, 14, 64)        36928     
                                                                 
 max_pooling2d_1 (MaxPoolin  (None, 7, 7, 64)          0         
 g2D)                                                            
                                                                 
 conv2d_4 (Conv2D)           (None, 7, 7, 128)         73856     
                                                                 
 conv2d_5 (Conv2D)           (None, 7, 7, 128)         147584    
                                                                 
 max_pooling2d_2 (MaxPoolin  (None, 3, 3, 128)         0         
 g2D)                                                            
                                                                 
 flatten (Flatten)           (None, 1152)              0         
                                                                 
 dense (Dense)               (None, 128)               147584    
                                                                 
 dense_1 (Dense)             (None, 10)                1290      
                                                                 
=================================================================
Total params: 435306 (1.66 MB)
Trainable params: 435306 (1.66 MB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________

需要值得关注的点就是上文所展示的参数的数目，以及相对应的每一层参数的大小，这边虽然不需要我们自己进行填写，但是也需要了解。

然后就是开始训练：

# 存储训练的参数
# -----------------------------------------------------------------------------
logdir = './cnn-selu-callbacks'
if not os.path.exists(logdir):
    os.mkdir(logdir)
output_model_file = os.path.join(logdir, "fashion_mnist_model.h5")

callbacks = [
    keras.callbacks.TensorBoard(logdir),
    keras.callbacks.ModelCheckpoint(output_model_file,save_best_only = True),
    keras.callbacks.EarlyStopping(patience=5, min_delta=1e-3),
]

history = model.fit(x_train_scaled, y_train, epochs=10, validation_data=(x_valid_scaled, y_valid), callbacks = callbacks)
# -----------------------------------------------------------------------------

# 绘图
# -----------------------------------------------------------------------------
def plot_learning_curves(history):
    pd.DataFrame(history.history).plot(figsize=(8, 5))
    plt.grid(True)
    plt.gca().set_ylim(0, 1)
    plt.show()

plot_learning_curves(history)
# -----------------------------------------------------------------------------

# 评估模型
model.evaluate(x_test_scaled, y_test, verbose = 0)

输出：

Epoch 1/10
1719/1719 [==============================] - 23s 7ms/step - loss: 0.4335 - accuracy: 0.8442 - val_loss: 0.3615 - val_accuracy: 0.8728
······
Epoch 10/10
1719/1719 [==============================] - 11s 6ms/step - loss: 0.0748 - accuracy: 0.9746 - val_loss: 0.2589 - val_accuracy: 0.9190
图片见下
[0.2659706473350525, 0.9179999828338623]

在这里插入图片描述
selu相比于relu来说，他的效果更好，但是对于gpu不适合计算ex的函数，所以他的计算来说就会很慢。

深度可分离卷积

深度可分离卷积是对于卷积的再一次升级，你可以看到其的所需要的参数量更加的小了，这个体会可以放到后面的代码环节进行体会。

原理介绍

整个流程的过程，先按照图片进行介绍，一共是分为两步：

第一步：考虑的是图片本身的属性，他把图片按照通道进行分开，一层通道用一个kennel-size，然后使用kennel-size对一层一层进行卷积，得到同等通道的图，然后进行下一步。
在这里插入图片描述
第二步考虑的是通道的属性，将上一步的输出考虑上通道的属性，按照1 * 1 * C的kennel-size进行卷积，并且搭配上多个filter进行后面的升维计算。
在这里插入图片描述
最后得到升维后的特征图片。

计算量对比

首先参数对比一般会先忽略掉偏置项b，因为相比之下偏置项b的量级太小：

对于普通的卷积来说，他的计算量需求：(kennel-size * kennel-size * H的滑动次数 * W的滑动次数 * C * filter)

而对于深度可分离卷积来说，他的计算量由两部分组成：
第一部分深度可分离：（kennel-size * kennel-size * H的滑动次数 * W的滑动次数 * C）

第二部分1 * 1 卷积：（1 * 1 * filter * H的滑动次数 * W的滑动次数）

两部分相加之后计算量会小于卷积，原因就是正常情况下我们的filter取的值是越来越大，甚至十分大的，所以这种的效果会更加好。

而相同的进行参数量对比，相信学习过上面的原理，大家也可以轻易写出相关的比较式子，这边留给大家。

参数量计算后面也会给出计算例子

代码

import matplotlib as mpl
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import sklearn
import pandas as pd
import os
import sys
import time
import tensorflow as tf
from tensorflow import keras
from sklearn.preprocessing import StandardScaler
import os

# 数据准备
# -----------------------------------------------------------------------------
fashion_mnist = keras.datasets.fashion_mnist
(x_train_all, y_train_all), (x_test, y_test) = fashion_mnist.load_data()
x_valid, x_train = x_train_all[:5000], x_train_all[5000:]
y_valid, y_train = y_train_all[:5000], y_train_all[5000:]
print(x_valid.shape, y_valid.shape)
print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)
scaler = StandardScaler()
# 注意这边和之前的不一样，这边最后面的reshape变成了28，28，1，相比于之前多了个1，符合基础的形状（B，H，W，C）
x_train_scaled = scaler.fit_transform(x_train.astype(np.float32).reshape(-1, 1)).reshape(-1, 28, 28, 1)
x_valid_scaled = scaler.transform(x_valid.astype(np.float32).reshape(-1, 1)).reshape(-1, 28, 28, 1)
x_test_scaled = scaler.transform(x_test.astype(np.float32).reshape(-1, 1)).reshape(-1, 28, 28, 1)
# -----------------------------------------------------------------------------

# 模型准备
# -----------------------------------------------------------------------------
model = keras.models.Sequential()
model.add(keras.layers.Conv2D(filters=32, kernel_size=3, padding='same', activation='selu', input_shape=(28, 28, 1)))
#这里就是深度可分离卷积
model.add(keras.layers.SeparableConv2D(filters=32, kernel_size=3, padding='same', activation='selu'))
model.add(keras.layers.MaxPool2D(pool_size=2))
model.add(keras.layers.SeparableConv2D(filters=64, kernel_size=3, padding='same', activation='selu'))
model.add(keras.layers.SeparableConv2D(filters=64, kernel_size=3, padding='same', activation='selu'))
model.add(keras.layers.MaxPool2D(pool_size=2))
model.add(keras.layers.SeparableConv2D(filters=128, kernel_size=3, padding='same', activation='selu'))
model.add(keras.layers.SeparableConv2D(filters=128, kernel_size=3, padding='same', activation='selu'))
model.add(keras.layers.MaxPool2D(pool_size=2))
model.add(keras.layers.Flatten())
model.add(keras.layers.Dense(128, activation='selu'))
model.add(keras.layers.Dense(10, activation="softmax"))

model.compile(loss="sparse_categorical_crossentropy", optimizer = "sgd", metrics = ["accuracy"])
model.summary()
# -----------------------------------------------------------------------------

输出：

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
下载过程略
(5000, 28, 28) (5000,)
(55000, 28, 28) (55000,)
(10000, 28, 28) (10000,)
Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d (Conv2D)             (None, 28, 28, 32)        320       
                                                                 
 separable_conv2d (Separabl  (None, 28, 28, 32)        1344      
 eConv2D)                                                        
                                                                 
 max_pooling2d (MaxPooling2  (None, 14, 14, 32)        0         
 D)                                                              
                                                                 
 separable_conv2d_1 (Separa  (None, 14, 14, 64)        2400      
 bleConv2D)                                                      
                                                                 
 separable_conv2d_2 (Separa  (None, 14, 14, 64)        4736      
 bleConv2D)                                                      
                                                                 
 max_pooling2d_1 (MaxPoolin  (None, 7, 7, 64)          0         
 g2D)                                                            
                                                                 
 separable_conv2d_3 (Separa  (None, 7, 7, 128)         8896      
 bleConv2D)                                                      
                                                                 
 separable_conv2d_4 (Separa  (None, 7, 7, 128)         17664     
 bleConv2D)                                                      
                                                                 
 max_pooling2d_2 (MaxPoolin  (None, 3, 3, 128)         0         
 g2D)                                                            
                                                                 
 flatten (Flatten)           (None, 1152)              0         
                                                                 
 dense (Dense)               (None, 128)               147584    
                                                                 
 dense_1 (Dense)             (None, 10)                1290      
                                                                 
=================================================================
Total params: 184234 (719.66 KB)
Trainable params: 184234 (719.66 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________

然后就是开始训练模型

# 存储训练的参数 和 训练模型
# -----------------------------------------------------------------------------
logdir = './separable-cnn-selu-callbacks'
if not os.path.exists(logdir):
    os.mkdir(logdir)
output_model_file = os.path.join(logdir,"fashion_mnist_model.h5")

callbacks = [
    keras.callbacks.TensorBoard(logdir),
    keras.callbacks.ModelCheckpoint(output_model_file,save_best_only = True),
    keras.callbacks.EarlyStopping(patience=5, min_delta=1e-3),
]
history = model.fit(x_train_scaled, y_train, epochs=10, validation_data=(x_valid_scaled, y_valid), callbacks = callbacks)
# -----------------------------------------------------------------------------

# 绘图
# -----------------------------------------------------------------------------
def plot_learning_curves(history):
    pd.DataFrame(history.history).plot(figsize=(8, 5))
    plt.grid(True)
    plt.gca().set_ylim(0, 3)
    plt.show()

plot_learning_curves(history)
# -----------------------------------------------------------------------------

# 评估模型
# -----------------------------------------------------------------------------
model.evaluate(x_test_scaled, y_test, verbose = 0)
# -----------------------------------------------------------------------------

输出：

Epoch 1/10
1719/1719 [==============================] - 24s 7ms/step - loss: 2.2999 - accuracy: 0.1143 - val_loss: 2.2792 - val_accuracy: 0.0980
······
Epoch 10/10
1719/1719 [==============================] - 11s 6ms/step - loss: 0.4067 - accuracy: 0.8514 - val_loss: 0.3963 - val_accuracy: 0.8584
图片见下
[0.4277254343032837, 0.8440999984741211]

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

参数计算例子

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

大小计算：

首先对于input(None，28，28，32)来说，经历SeparableConv2D(filters=32, kernel_size=3, padding='same', activation='selu')后得到的大小:
很简单可以理解:(None,28,28,32)第一个None取决于Batch-size，所以是None，第二个28，因为有个same，他自然加上padding，自然就还是28，第三个28同理，第四个32取决于上一个filters，最后自然得到了(None,28,28,32)，这还是很简单的。

参数数量计算：

第一步深度可分离：
参数数量=kennel-size*kennel-size*C
所以自然就是 3*3*32=288

第二步1*1卷积：
参数数量=1*1*C*filter + b
所以自然就是 32*32+32 = 1056

最后两个相加 = 1344

后面可以自行计算一下子。

colab 和 kaggle

colab

首先关于colab的使用实际上和juptyer的使用十分相似，然后打开GPU的地方：
在这里插入图片描述
在这里插入图片描述
然后自然就有了。

下载文件呢?
在这里插入图片描述
然后工作目录是在content文件夹当中

kaggle

使用gpu的地方
在这里插入图片描述

工作目录是再working当中，然后你导入了数据集后，数据集是放在…/input当中

如何在colab上使用kaggle的数据

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
这个需要记住

然后在colab当中的代码：
先挂载

from google.colab import drive
drive.mount('/content/gdrive/')

然后根据提示上传kaggle.json

from google.colab import files
files.upload()

第三步就是设置对应的kaggle.json

!pip install -q kaggle
!mkdir -p /content/drive/Kaggle/
!cp kaggle.json /content/drive/Kaggle/
!chmod 600 /content/drive/Kaggle/kaggle.json
!mkdir -p ~/.kaggle
!cp kaggle.json ~/.kaggle/
!chmod 600 ~/.kaggle/kaggle.json

检测是否成功：

!kaggle datasets list

然后比如说我们要下载这个数据集：
在这里插入图片描述

!kaggle datasets download -d slothkong/10-monkey-species

解压：

!unzip -o -d /content /content/10-monkey-species.zip
Micoreal
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于深度学习神经网络的农业病虫害识别（完整代码+数据）
01-16 6216
基于深度学习神经网络的农业病虫害识别（完整代码+数据）
fastai 图像分类_使用Fastai进行深度学习图像分类
weixin_26752765的博客
09-05 1665
fastai 图像分类 TL; DR (TL;DR) If you are beginning to feel burnt out on learning a subject it is often beneficial to take a step out of the weeds. I like to build something fun and easy to regain positiv...
使用 PyTorch 进行高效图像分割：第 1 部分
gongdiwudu的专栏
08-17 3179
在这个由 4 部分组成的系列中，我们将使用 PyTorch 中的深度学习技术从头开始逐步实现图像分割。我们将在本文中从图像分割所需的基本概念和想法开始本系列。
ResNet和ResNeXt
weixin_43329973的博客
07-27 664
ResNet+ResNeXt，cat and dog
【杂谈】学深度学习的你有GPU了吗
hacker_long的专栏
02-26 392
随着人工智能越来越火，越来越多的人想从事人工智能相关的工作，如计算机视觉等。如果你正想或已经入门计算机视觉行业，你必须拥有GPU。因为深度学习的成功与否很大程度上取决于硬...
第七周编程学习笔记（4.17-4.23）
z377989129的博客
04-11 426
第一周4.10 星期一 第二周4.11 星期二 第三周4.12 星期三
使用keras创建自己的图像标题生成器
Together_CZ的博客
02-06 933
【翻译自 ： create-your-own-image-caption-generator-using-keras】 【说明：analyticsvidhya这里的文章个人很喜欢，所以闲暇时间里会做一点翻译和学习实践的工作，这里是相应工作的实践记录，希望能帮到有需要的人！】 总览 了解图像字幕生成器如何使用编码器-解码器工作 知道如何使用Keras创建自己的图像标题生成器 介绍 图像标题生成器是人工智能的热门研...
用 Keras 创建自己的图像标题生成器
Python中文社区
02-20 548
总览了解图像字幕生成器如何使用编码器-解码器工作知道如何使用Keras创建自己的图像标题生成器介绍图像标题生成器是人工智能的热门研究领域，涉及图像理解和该图像的语言描述。生成格式正确的句子...
深入浅出PyTorch: pytorch教程
天狼啸月1990的博客
03-15 1701
Module类是torch.nn模块里提供的一个模型构造类(nn.Module)，是所有神经网络模块的基类，我们可以继承它来定义我们想要的模型pytorch模型定义应包括两个主要部分：各个部分的初始化(__init__)；数据流向定义(forward)基于nn.Module，我们可以通过SequentialModuleList和ModuleDict三种方式定义pytorch模型。
tf:人工神经网络和使用Tensorflow的深度学习
04-15
使用Tensorflow 2.0.0进行深度学习和人工神经网络的实践项目 人工神经网络，数据集为“ cifar10”，用于检测（“飞机”，“汽车”，“鸟”，“猫”，“鹿”，“狗”，“青蛙”，“马”，“船”，“卡车” ） 如何将...
深度学习免费服务器 Google Colab使用教程
01-20
对于入门深度学习的同学开说，笔记本GPU性能太弱是一件非常让人头疼的事，而租用的gpu服务器又太贵，最近刚发现google提供的免费云平台，可供我们做训练网络服务器用，GPU型号为Tesla T4 ，性能也是不俗。...
深度学习必备：免费使用GPU
01-07
Google Colab 优点： GPU,TPU不限时长，一直免费使用。 可以配合谷歌网盘使用。 缺点： 需要科学上网。 我这里会时不时掉线。 DBC类 被同学邀请使用的，的确挺方便。 优点： 不用科学上网。 1080，2080型号都有，...
Colab_Bin_Image_Classification：应用Google Colaboratory免费GPU资源来完成深度学习卷积神经网路执行影像二元分类
02-04
Colab_Bin_Image_Classification：应用Google Colaboratory免费GPU资源来完成深度学习卷积神经网路执行影像二元分类
《TensorFlow2.0》一、机器学习和深度学习简介及基础编程 part 2
12-21
Python版本： Python3.x 运行平台： Windows IDE： jupyter / Colab ...资料下载，提取码：rscg ...上一章，讲解了简单的神经网络和卷积，卷积中的过滤器究竟是什么样的呢？这章我们要来看一下，然后完成一
RK3568笔记二十八：CRNN车牌识别部署
05-31 678
1、训练平台：Autodl2、运行板子：ATK-DLRK3568。
遥感图像的深度学习的任务类型
最新发布
weixin_42605076的博客
05-31 439
遥感图像的深度学习任务涉及广泛的应用领域和技术方法，通过使用卷积神经网络（CNN）、生成对抗网络（GAN）等先进的深度学习模型，能够有效提升遥感数据的处理和分析能力，支持各类环境监测、资源管理、灾害应对等实际需求。
【深度学习】第2章
m0_37932764的博客
05-29 502
字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。如果关系是非线性的，即便两个变量具有-一对应的关系，Pearson相关性也可能会接近0。皮尔森相关系数高，相关性高——>去掉特征之间相关性高的&目标值相关性较小的。其基本任务是确定句子的句法结构或者句子中词汇之间的依存关系。6.TF-iDF词条权重计算?方差小，相似度高——>去掉相似度较高的。三、特征处理（特征缩放、选择及降维）2.特征值的归一化（规范化）（2）主成分分析（PCA）（3）基于森林的特征选择。
ERV-Net：一种用于脑肿瘤分割的高效3D残差神经网络| 文献速递-深度学习肿瘤自动分割
weixin_38594676的博客
05-30 658
然而，手动分割是一个复杂的项目，因为不同的医师在培训过程中可能具有不同的标准，因此会受到不确定误差的影响（Nyúl，Udupa和Zhang，2000年）。在ERV-Net中，首先利用了计算高效的网络3D ShuffleNetV2作为编码器，以减少GPU内存并提高ERV-Net的效率，然后引入了具有残差块（Res-decoder）的解码器以避免性能退化。特别是，我们提出了一种新颖的后处理方法，充分利用了神经网络的概率和脑肿瘤的分布特性，有效提高了我们的分割性能。表3与模型集成的最先进方法的性能比较。
使用TensorFlow(Keras)搭建卷积神经网络VGG16，实现手写数字识别。
09-06
好的，下面是基于TensorFlow(Keras)搭建的VGG16卷积神经网络，实现手写数字识别的代码： ```python import tensorflow as tf from tensorflow.keras import layers, models, datasets, utils # 加载数据集 (train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data() # 数据预处理 train_images = train_images.reshape((60000, 28, 28, 1)) / 255.0 test_images = test_images.reshape((10000, 28, 28, 1)) / 255.0 # 将标签进行one-hot编码 train_labels = utils.to_categorical(train_labels) test_labels = utils.to_categorical(test_labels) # 构建VGG16模型 model = models.Sequential() model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=(28, 28, 1))) model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same')) model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same')) model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same')) model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same')) model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same')) model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same')) model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same')) model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dense(4096, activation='relu')) model.add(layers.Dense(4096, activation='relu')) model.add(layers.Dense(10, activation='softmax')) # 模型编译 model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) # 模型训练 model.fit(train_images, train_labels, epochs=5, batch_size=64, validation_data=(test_images, test_labels)) # 模型评估 test_loss, test_acc = model.evaluate(test_images, test_labels) print('Test accuracy:', test_acc) ``` 需要注意的是，这个模型的训练需要较长时间，可以在Colab等云环境中进行训练。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值