PyTorch主要组成模块 | 数据读入 | 数据预处理 | 模型构建 | 模型初始化 | 损失函数 | 优化器

文章目录

一、深度学习任务框架
二、数据读入
三、数据预处理模块—transforms
- 1.数据预处理transforms模块机制
- 2.二十二种transforms数据预处理方法
- - 1.裁剪
  - 2. 翻转与旋转
  - 3.图像变换
  - 4.transforms方法的选择操作
  - 5.自定义transfroms方法
四、模型构建
- 1.神经网络构造
- 2.神经网络中常见的层
- - 2.1 卷积层
  - 2.2 池化层
  - 2.3 线性层
  - 2.4 激活函数层
  - 2.5 自定义层
- 3.nn.Module
五、模型初始化
- 1.梯度消失与爆炸
- 2.Xavier方法与Kaiming方法
- - 2.1 Xavier方法
  - 2.2 Kaiming初始化
- 3.初始化函数的封装
六、损失函数
- 1.损失函数的概念
- 2.十六种损失函数
七、优化器
- 1.什么是优化器？
- 2.optimizer的基本属性
- 3.optimizer的基本方法
- 4.优化器中的常用参数
- - 4.1 learning rate 学习率
  - 4.2 momentum 动量
- 5.Pytorch十种优化器简介
八、训练与评估

PyTorch基础篇：

PyTorch基础知识 | 安装 | 张量 | 自动求导
PyTorch主要组成模块 | 数据读入 | 数据预处理 | 模型构建 | 模型初始化 | 损失函数 | 优化器 | 训练与评估
PyTorch主要组成模块 | hook函数 | 正则化weight decay与Dropout | 标准化
PyTorch模型定义 | 模型容器 | 模型块 | 修改模型 | 模型读取与保存
PyTorch进阶技巧 | 自定义损失函数 | 动态调整学习率 | 模型微调 | 半精度训练 | 使用argparse进行调参
PyTorch可视化 | 可视化网络结构 | 使用TensorBoard可视化训练过程

一、深度学习任务框架

回顾我们在完成一项机器学习任务时的步骤，首先需要对数据进行预处理，其中重要的步骤包括数据格式的统一和必要的数据变换，同时划分训练集和测试集。接下来选择模型，并设定损失函数和优化方法，以及对应的超参数（当然可以使用sklearn这样的机器学习库中模型自带的损失函数和优化器）。最后用模型去拟合训练集数据，并在验证集/测试集上计算模型表现。
深度学习和机器学习在流程上类似，但在代码实现上有较大的差异。首先，由于深度学习所需的样本量很大，一次加载全部数据运行可能会超出内存容量而无法实现；同时还有批（batch）训练等提高模型表现的策略，需要每次训练读取固定数量的样本送入模型中训练，因此深度学习在数据加载上需要有专门的设计。
在模型实现上，深度学习和机器学习也有很大差异。由于深度神经网络层数往往较多，同时会有一些用于实现特定功能的层（如卷积层、池化层、批正则化层、LSTM层等），因此深度神经网络往往需要“逐层”搭建，或者预先定义好可以实现特定功能的模块，再把这些模块组装起来。这种“定制化”的模型构建方式能够充分保证模型的灵活性，也对代码实现提出了新的要求。
接下来是损失函数和优化器的设定。这部分和经典机器学习的实现是类似的。但由于模型设定的灵活性，因此损失函数和优化器要能够保证反向传播能够在用户自行定义的模型结构上实现。
上述步骤完成后就可以开始训练了。我们前面介绍了GPU的概念和GPU用于并行计算加速的功能，不过程序默认是在CPU上运行的，因此在代码实现中，需要把模型和数据“放到”GPU上去做运算，同时还需要保证损失函数和优化器能够在GPU上工作。如果使用多张GPU进行训练，还需要考虑模型和数据分配、整合的问题。此外，后续计算一些指标还需要把数据“放回”CPU。这里涉及到了一系列有关于GPU的配置和操作。
深度学习中训练和验证过程最大的特点在于读入数据是按批的，每次读入一个批次的数据，放入GPU中训练，然后将损失函数反向传播回网络最前面的层，同时使用优化器调整网络参数。这里会涉及到各个模块配合的问题。训练/验证后还需要根据设定好的指标计算模型表现。
总结来说，打通深度学习流程需要搞懂以下几个部分：

数据读入
模型构建
模型初始化
损失函数
优化器
训练和评估

二、数据读入

PyTorch数据读取在Dataloader模块下，Dataloader又可以分为DataSet与Sampler。Sampler模块的功能是生成索引（样本序号）；DataSet是依据索引读取Img、Lable。数据读入主要是通过Dataset+DataLoader的方式完成的，Dataset定义好数据的格式和数据变换形式，DataLoader用iterative的方式不断读入批次数据。
torch.utils.data.DataLoader()：构建可迭代的数据装载器

DataLoader(dataset,batch_size=1,shuffle=False,sampler=None,batch_sampler=None,num_workers=0,collate_fn=None,pin_memory=False,drop_last=False,timeout=0,worker_init_fn=None,multiprocessing_context=None)

dataset: Dataset类,决定数据从哪读取及如何读取
batch_size :批大小
num_works:是否多进程读取数据
shuffle:每个epoch是否乱序
drop_last :当样本数不能被batchsize整除时，是否舍弃最后一批数据

Epoch：所有训练样本都已输入到模型中，称为一个Epoch
Iteration:一批样本输入到模型中，称之为一个lteration
Batchsize:批大小，决定一个Epoch有多少个lteration

样本总数:80，Batchsize : 8
1 Epoch = 10 lteration

样本总数:87， Batchsize: 8
1 Epoch = 10 lteration ? drop_last = True
1 Epoch = 11 lteration drop_last = False

torch.utils.data.Dataset()：Dataset抽象类,所有自定义的Dataset需要继承它,并且复写__getitem__()
getitem:接收一个索引，返回一个样本

class Dataset(object):def __getitem__(self,index):raise NotImplementedErrordef __add__(self, other) :return ConcatDataset([self, other])

数据读取流程如下：

我们可以定义自己的Dataset类来实现灵活的数据读取，定义的类需要继承PyTorch自身的Dataset类。主要包含三个函数：

__init__: 用于向类中传入外部参数，同时定义样本集
__getitem__: 用于逐个读取样本集合中的元素，可以进行一定的变换，并将返回训练/验证所需的数据
__len__: 用于返回数据集的样本数

class RMBDataset(Dataset):def __init__(self, data_dir, transform=None):"""rmb面额分类任务的Dataset:param data_dir: str, 数据集所在路径:param transform: torch.transform，数据预处理"""self.label_name = {"1": 0, "100": 1}self.data_info = self.get_img_info(data_dir)  # data_info存储所有图片路径和标签，在DataLoader中通过index读取样本self.transform = transformdef __getitem__(self, index):# 根据索引index获得数据与标签path_img, label = self.data_info[index]img = Image.open(path_img).convert('RGB')     # 0~255if self.transform is not None:img = self.transform(img)   # 在这里做transform，转为tensor等等return img, labeldef __len__(self):return len(self.data_info)@staticmethoddef get_img_info(data_dir):data_info = list()# 遍历一个目录内，各个子目录与子文件for root, dirs, _ in os.walk(data_dir):# 遍历类别for sub_dir in dirs:img_names = os.listdir(os.path.join(root, sub_dir))img_names = list(filter(lambda x: x.endswith('.jpg'), img_names))# 遍历图片for i in range(len(img_names)):img_name = img_names[i]path_img = os.path.join(root, sub_dir, img_name)label = rmb_label[sub_dir]data_info.append((path_img, int(label)))return data_info

构建好Dataset后，就可以使用DataLoader来按批次读入数据了，实现代码如下：

from torch.utils.data import DataLoadertrain_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, num_workers=4, shuffle=True, drop_last=True)
val_loader = torch.utils.data.DataLoader(val_data, batch_size=batch_size, num_workers=4, shuffle=False)

其中:

batch_size：样本是按“批”读入的，batch_size就是每次读入的样本数
num_workers：有多少个进程用于读取数据
shuffle：是否将读入的数据打乱
drop_last：对于样本最后一部分没有达到批次数的样本，使其不再参与训练

数据整理器将数据由下面的形式：
转化为batch形式：

三、数据预处理模块—transforms

1.数据预处理transforms模块机制

torchvision.transforms模块包含了很多图像预处理方法：

数据中心化
数据标准化
缩放
裁剪
旋转
翻转
填充
噪声添加
灰度变换
线性变换
仿射变换
亮度、饱和度及对比度变换

这个模块可以进行数据增强与数据预处理，增强模型的泛化能力。数据预处理transforms在数据读取过程中，最后生成数据预处理完的batch data。

class RMBDataset(Dataset):def __init__(self, data_dir, transform=None):"""rmb面额分类任务的Dataset:param data_dir: str, 数据集所在路径:param transform: torch.transform，数据预处理"""self.label_name = {"1": 0, "100": 1}self.data_info = self.get_img_info(data_dir)  # data_info存储所有图片路径和标签，在DataLoader中通过index读取样本self.transform = transformdef __getitem__(self, index):path_img, label = self.data_info[index]img = Image.open(path_img).convert('RGB')     # 0~255# 在数据读取的这个节点开始调用transform，迭代使用多种tansform方法if self.transform is not None:img = self.transform(img)   # 在这里做transform，转为tensor等等return img, labeldef __len__(self):return len(self.data_info)@staticmethoddef get_img_info(data_dir):data_info = list()for root, dirs, _ in os.walk(data_dir):# 遍历类别for sub_dir in dirs:img_names = os.listdir(os.path.join(root, sub_dir))img_names = list(filter(lambda x: x.endswith('.jpg'), img_names))# 遍历图片for i in range(len(img_names)):img_name = img_names[i]path_img = os.path.join(root, sub_dir, img_name)label = rmb_label[sub_dir]data_info.append((path_img, int(label)))return data_info

2.二十二种transforms数据预处理方法

1.裁剪

transforms.CenterCrop：从图像中心裁剪图片。

size:所需裁剪图片尺寸

transforms.RandomCrop：从图片中随机裁剪出尺寸为size的图片。

transforms.RandomCrop(size,padding=None,pad_if_needed=False,fill=6,padding_mode= 'constant ' )

size:所需裁剪图片尺寸
padding:设置填充大小
当为a时，上下左右均填充a个像素
当为(a, b)时,上下填充b个像素,左右填充a个像素
当为(a，b，c，d)时，左，上，右，下分别填充a， b，c， d
pad_if_need:若图像小于设定size，则填充
padding_mode:填充模式，有4种模式
1、constant:像素值由fill设定
2、edge:像素值由图像边缘像素决定
3、reflect:镜像填充，最后一个像素不镜像，eg:[1,2,3.4] →[3,2,1,2,3,4,3,2]
4、symmetric:镜像填充，最后一个像素镜像，eg:[1,2,3,4]→[2,1,1,2,3,4,4,3]
fill: constant时,设置填充的像素值

transforms.RandomResizedCrop：随机大小、长宽比裁剪图片。

RandomResizedCrop(size,scale=(0.08,1.0),ratio=(3/4，4/3),interpolation)

size:所需裁剪图片尺寸
scale :随机裁剪面积比例，默认(0.08，1)
ratio:随机长宽比，默认(3/4，4/3)
interpolation:插值方法
- PIL.lmage.NEAREST
- PIL.lmage.BILINEAR
- PIL.lmage.BICUBIC

transforms.FiveCrop：在图像的上下左右以及中心裁剪出尺寸为size的5张图片。

transforms .FiveCrop(size)

# 将tuple格式转换为Tensor格式
transforms.FiveCrop(112),
transforms.Lambda(lambda crops: torch.stack([(transforms.ToTensor()(crop)) for crop in crops]))

transforms.TenCrop：TenCrop对这5张图片进行水平或者垂直镜像获得10张图片

size :所需裁剪图片尺寸
vertical_flip :是否垂直翻转

transforms.TenCrop(112, vertical_flip=False),
transforms.Lambda(lambda crops: torch.stack([(transforms.ToTensor()(crop)) for crop in crops]))

2. 翻转与旋转

transforms.RandomHorizontalFlip：依概率水平（左右）翻转图片

transforms.RandomHorizontalFlip(p=0.5)

p:翻转概率

transforms.RandomVerticalFlip：依概率垂直（上下）翻转图片

transforms.RandomVerticalFlip(p=0.5)

p:翻转概率

transforms.RandomRotation：随机旋转图片

RandomRotation(degrees,resample=False,expand=False,center=None)

degrees :旋转角度
当为a时，在(-a，a)之间选择旋转角度
当为(a,b)时，在(a，b)之间选择旋转角度
resample :重采样方法
expand :是否扩大图片，以保持原图信息

3.图像变换

transforms.Pad：对图片边缘进行填充。

transforms.Pad(padding,fill=0,padding_mode= ' constant ' )

padding:设置填充大小
当为a时，上下左右均填充a个像素
当为(a, b)时，上下填充b个像素，左右填充a个像素
当为(a，b，c，d)时，左，上，右，下分别填充a，b，c，d
padding_mode:填充模式，有4种模式，
constant、edge、reflect和symmetric
fill:constant时，设置填充的像素值，(R，G,B)or(Gray)

transforms.colorjitter：调整亮度、对比度、饱和度和色相。

transforms.colorJitter(brightness=0,contrast=0,saturation=0,hue=0)

brightness:亮度调整因子
当为a时，从[max(0，1-a)，1+a]中随机选择
当为(a，b)时，从[a，b]中随机选择
contrast :对比度参数，同brightness
saturation:饱和度参数，同brightness
hue:色相参数，
当为a时，从[-a，a]中选择参数，
注:0<= a <= 0.5
当为(a，b)时:,从[a，b]中选择参数
注：-0.5<=a<=b<=0.5

transforms.Grayscale：将图片转换为灰度图

Grayscale(num_output_channels)

num_ouput_channels:输出通道数只能设1或3

transforms.RandomGrayscale：依概率将图片转换为灰度图

num_ouput_channels:输出通道数只能设1或3
p︰概率值，图像被转换为灰度图的概率

transforms.RandomAffine：对图像进行仿射变换，仿射变换是二维的线性变换，由五种基本原子变换构成，分别是旋转、平移、缩放、错切和翻转

transforms.RandomAffine(degrees,translate=None,scale=None,shear=None ,resample=False,fillcolor=)

degrees:旋转角度设置
translate:平移区间设置
如(a，b)，a设置宽(width)，b设置高(height)图像在宽维度平移的区间为
-img_width * a < dx < img_width * a
scale:缩放比例(以面积为单位)
fill_color:填充颜色设置
shear:错切角度设置,有水平错切和垂直错切
若为a，则仅在x轴错切，错切角度在(-a, a)之间
若为(a, b)，则a设置x轴角度，b设置y的角度
若为(a, b,c,d)，则a, b设置x轴角度，c，d设置y轴角度
resample:重采样方式，有NEAREST 、BILINEAR、BICUBIC

transforms.RandomErasing：对图像进行随机遮挡。

transforms.RandomErasing(p=0.5,scale=(0.02,0.33),ratio=(0.3,3.3),value=0,inplace=False)

p:概率值，执行该操作的概率
scale:遮挡区域的面积
ratio:遮挡区域长宽比
value:设置遮挡区域的像素值，(R，G，B) or (Gray)

transforms.Lambda(lambda)：用户自定义lambda方法。

lambd : lambda匿名函数
lambda [arg1 [,arg2, … , argn]] : expression

eg:

transforms. Lambda(lambda crops: torch.stack([transforms. Totensor()(crop) for crop in crops]))

4.transforms方法的选择操作

transforms.RandomChoice：从一系列transforms方法中随机挑选一个

transforms. RandomChoice([transforms1，transforms2，transforms3])

transforms.RandomApply：依据概率执行一组transforms操作

transforms.RandomApply([transforms1，transforms2，transforms3], p=0.5)

transforms.RandomOrder：:对一组transforms操作打乱顺序

transforms. Randomorder([transforms1，transforms2，transforms3])

transforms.Resize：调整图片的大小
transforms.Totensor：将之前的数据结构转换为张量
transforms.Normalize：逐channel的对图像进行标准化(变换后的数据均值为0，标准差为1)，标准化的优点是加快模型的收敛。

transforms.Normalize(mean,std,inplace=False)

$o u tp u t = (in p u t - m e an) / s t d$

mean :各通道的均值
std:各通道的标准差
inplace :是否原地操作

源码如下：

def normalize(tensor, mean, std, inplace=False):"""Normalize a tensor image with mean and standard deviation... note::This transform acts out of place by default, i.e., it does not mutates the input tensor.See :class:`~torchvision.transforms.Normalize` for more details.Args:tensor (Tensor): Tensor image of size (C, H, W) to be normalized.mean (sequence): Sequence of means for each channel.std (sequence): Sequence of standard deviations for each channel.inplace(bool,optional): Bool to make this operation inplace.Returns:Tensor: Normalized Tensor image."""# 输入的合法性判断-是否为Tensorif not _is_tensor_image(tensor):raise TypeError('tensor is not a torch image.')# 是否原地操作，如果不是原地操作，需要将张量克隆一份if not inplace:tensor = tensor.clone()dtype = tensor.dtype# 将均值与方差转化为张量mean = torch.as_tensor(mean, dtype=dtype, device=tensor.device)std = torch.as_tensor(std, dtype=dtype, device=tensor.device)# sub_:下划线表示原地操作；(input - mean) / stdtensor.sub_(mean[:, None, None]).div_(std[:, None, None])# 返回变换后的张量return tensor

5.自定义transfroms方法

transforms方法是在Compose类中通过__call__方法调用的。

class Compose(object):"""Composes several transforms together.Args:transforms (list of ``Transform`` objects): list of transforms to compose.Example:>>> transforms.Compose([>>>     transforms.CenterCrop(10),>>>     transforms.ToTensor(),>>> ])"""def __init__(self, transforms):self.transforms = transformsdef __call__(self, img):# 循环执行transforms方法for t in self.transforms:img = t(img)return imgdef __repr__(self):format_string = self.__class__.__name__ + '('for t in self.transforms:format_string += '\n'format_string += '    {0}'.format(t)format_string += '\n)'return format_string

我们可以发现调用transforms时有如下特点:

仅接收一个参数，返回一个参数
注意上下游的输出与输入

下面我们自定义transforms，它的基本结构为：

class YourTransforms(object) :def __init_(self, ...):...def __cal1__(self, img):...return img

椒盐噪声又称为脉冲噪声，是一种随机出现的白点或者黑点，白点称为盐噪声，黑色为椒噪声。信噪比(Signal-Noise Rate，SNR）是衡量噪声的比例，图像中为图像像素的占比。我们以椒盐噪声为例来自定义transforms方法。

class AddPepperNoise(object):"""增加椒盐噪声Args:snr （float）: Signal Noise Ratep (float): 概率值，依概率执行该操作"""def __init__(self, snr, p=0.9):assert isinstance(snr, float) and (isinstance(p, float))    # 2020 07 26 or --> and# 信号百分比self.snr = snr# 概率self.p = pdef __call__(self, img):"""Args:img (PIL Image): PIL ImageReturns:PIL Image: PIL image."""# 概率的判断if random.uniform(0, 1) < self.p:# 数据格式转换到ndarrayimg_ = np.array(img).copy()# 高，宽，通道数h, w, c = img_.shape# 获取信号百分比signal_pct = self.snr# 噪声百分比noise_pct = (1 - self.snr)# 依概率选取3个maskmask = np.random.choice((0, 1, 2), size=(h, w, 1), p=[signal_pct, noise_pct/2., noise_pct/2.])mask = np.repeat(mask, c, axis=2)img_[mask == 1] = 255   # 盐噪声img_[mask == 2] = 0     # 椒噪声return Image.fromarray(img_.astype('uint8')).convert('RGB')else:return img

四、模型构建

1.神经网络构造

Module 类是 nn 模块里提供的一个模型构造类，是所有神经网络模块的基类。
模型构建有两个要素：

下面我们以LeNet模型为例，展示其模型创建过程

class LeNet(nn.Module):# 初始化构建子模块def __init__(self, classes):super(LeNet, self).__init__()self.conv1 = nn.Conv2d(3, 6, 5)self.conv2 = nn.Conv2d(6, 16, 5)self.fc1 = nn.Linear(16*5*5, 120)self.fc2 = nn.Linear(120, 84)self.fc3 = nn.Linear(84, classes)# 拼接子模块def forward(self, x):out = F.relu(self.conv1(x))out = F.max_pool2d(out, 2)out = F.relu(self.conv2(out))out = F.max_pool2d(out, 2)out = out.view(out.size(0), -1)out = F.relu(self.fc1(out))out = F.relu(self.fc2(out))out = self.fc3(out)return out# 权值的初始化def initialize_weights(self):for m in self.modules():if isinstance(m, nn.Conv2d):nn.init.xavier_normal_(m.weight.data)if m.bias is not None:m.bias.data.zero_()elif isinstance(m, nn.BatchNorm2d):m.weight.data.fill_(1)m.bias.data.zero_()elif isinstance(m, nn.Linear):nn.init.normal_(m.weight.data, 0, 0.1)m.bias.data.zero_()

但是我们什么时候实现模型的拼接与前向传播呢？LeNet模型继承于Module，Module类中有__call__函数，__call__函数表明这一实例是可以像函数一样被调用的，__call__函数中会调用上面定义好的forword前向传播函数。

# Module类
def __call__(self, *input, **kwargs):for hook in self._forward_pre_hooks.values():result = hook(self, input)if result is not None:if not isinstance(result, tuple):result = (result,)input = resultif torch._C._get_tracing_state():result = self._slow_forward(*input, **kwargs)else:# 前向传播result = self.forward(*input, **kwargs)for hook in self._forward_hooks.values():hook_result = hook(self, input, result)if hook_result is not None:result = hook_resultif len(self._backward_hooks) > 0:var = resultwhile not isinstance(var, torch.Tensor):if isinstance(var, dict):var = next((v for v in var.values() if isinstance(v, torch.Tensor)))else:var = var[0]grad_fn = var.grad_fnif grad_fn is not None:for hook in self._backward_hooks.values():wrapper = functools.partial(hook, self)functools.update_wrapper(wrapper, hook)grad_fn.register_hook(wrapper)return result

net = LeNet(4)
print(net)

LeNet((conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))(fc1): Linear(in_features=400, out_features=120, bias=True)(fc2): Linear(in_features=120, out_features=84, bias=True)(fc3): Linear(in_features=84, out_features=4, bias=True)
)

net(X)

net(X) 会调用LeNet 继承⾃自 Module 类的__call__函数，这个函数将调⽤用 LeNet 类定义的forward 函数来完成前向计算。

2.神经网络中常见的层

深度学习的一个魅力在于神经网络中各式各样的层，例如全连接层、卷积层、池化层与循环层等等。

2.1 卷积层

下面介绍几个概念：

卷积运算：卷积核在输入信号（图像）上滑动，相应位置上进行乘加。
卷积核：又称为滤波器，过滤器，可认为是某种模式，某种特征。
卷积维度：一般情况下，卷积核在几个维度上滑动，就是几维卷积。
PyTorch中提供了1d、2d、3d的卷积。

1d conv:

2d conv:

3d conv:

上述都是一个卷积核在一个信号上的卷积。如果涉及多个卷积核多个信号的操作，那么应该怎么判断卷积的维度？下面我们以一个三维卷积核实现二维卷积为例

每个卷积核分别在各自的通道进行卷积操作得到输出值，然后相加再加上偏置才会得到特征图的一个像素值。一个卷积核只在一个二维图像上进行滑动，所以这是二维卷积。为什么它是三维卷积核？正是因为它有多个通道，在多个通道上分别进行卷积。

nn.Conv2d：对多个二维信号进行二维卷积
```
nn.Conv2d(in_channels,out_channels,kernel_size,stride=1,padding=0,dilation=1,groups=1,bias=True,padding_mode= ' zeros ' )
```
主要参数:
- in_channels:输入通道数
- out_channels:输出通道数，等价于卷积核个数
- kernel_size:卷积核尺寸
- stride:步长
- padding :填充个数，用于保持输入与输出图像的尺寸是匹配的
- dilation:空洞卷积大小
- groups:分组卷积设置
- bias:偏置
尺寸计算公式为：
nn.ConvTranspose2d
nn.ConvTranspose2d是转置卷积。转置卷积用于对图像进行上采样(UpSample)，经常用于图像分割任务。那么，什么是转置卷积？它与正常卷积有什么区别？如图是正常2d卷积。

假设图像尺寸为 $4 * 4$ ，卷积核为 $3 * 3$ ，padding=0，stride=1
图像：

PyTorch主要组成模块 | 数据读入 | 数据预处理 | 模型构建 | 模型初始化 | 损失函数 | 优化器 | 训练与评估相关推荐
1. 06_基本的图像分类案例、导入图片数据、探索数据的格式、数据预处理、构建模型（设置层、编译模型）、训练模型（Fit模型、评估精确度）、得出预测结果（验证预测结果）、使用训练过的模型
  1.3.1.基本图像分类翻译自:https://tensorflow.google.cn/tutorials/keras/classification 该指南训练一个神经网络模型来对服装图像进行分类 ...
2. 【深度学习】——利用pytorch搭建一个完整的深度学习项目（构建模型、加载数据集、参数配置、训练、模型保存、预测）
  目录一.深度学习项目的基本构成二.实战(猫狗分类) 1.数据集下载 2.dataset.py文件 3.model.py 4.config.py 5.predict.py 一.深度学习项目的基本构成 ...
3. 深度之眼 PyTorch 训练营第 4 期（5）：构建模型 torch.nn.Module
  本文中,我们看一看如何构建模型. 创造一个模型分两步:构建模型和权值初始化.而构建模型又有"定义单独的网络层"和"把它们拼在一起"两步. 1. torch.nn ...
4. 金融贷款逾期的模型构建5——数据预处理
  文章目录一.相关库二.数据读取三.数据清洗--删除无关.重复数据四.数据清洗--类型转换 1.数据集划分 2.缺失值处理 3.异常值处理 4.离散特征编码 5.日期特征处理 6.特征组合五. ...
5. pytorch主要组成模块之：动手完成简单的深度学习模型搭建
  Pytorch学习第二部分:pytorch的主要组成模块 Let's go ! 一.深度学习的基本流程 1.1 回顾机器学习 1.2 深度学习二.基本配置 2.1 库/包 2.2 gpu配置 2.3 ...
6. 【Pytorch神经网络理论篇】 10 优化器模块+退化学习率
  1 优化器模块的作用 1.1 反向传播的核心思想反向传播的意义在于告诉模型我们需要将权重修改到什么数值可以得到最优解,在开始探索合适权重的过程中,正向传播所生成的结果与实际标签的目标值存在误差,反向 ...
7. oracle stalestats_深入理解oracle优化器统计数据(Optimizer Statistics)
  理解oracle优化器统计数据首先来介绍oracle数据库使用基于规则优化器(RBO)来决定如何执行一个sql语句.基于规则优化器顾名思义,它是遵循一组规则来判断一个sql语句的执行计划.这组规则是 ...
8. 【PyTorch教程】PyTorch分布式并行模块DistributedDataParallel(DDP)详解
  本期目录 DDP简介 1. 单卡训练回顾 2. 与DataParallel比较 1)DataParallel 2)DistributedDataParallel 3. 多卡DDP训练本章的重点是学习 ...
9. PyTorch的损失函数和优化器
  文章目录 PyTorch的损失函数和优化器损失函数优化器总结 PyTorch的损失函数和优化器损失函数一般来说,PyTorch的损失函数有两种形式:函数形式和模块形式.前者调用的是torch ...
最新文章
热门文章

PyTorch主要组成模块 | 数据读入 | 数据预处理 | 模型构建 | 模型初始化 | 损失函数 | 优化器 | 训练与评估