【树叶分类】kaggle竞赛

1.啃代码

1.line.rstrip().split(‘,’)

strip()用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
split（''）: 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

2.dict() 函数用于创造一个字典。

3.os.path.join()函数：连接两个或更多的路径名组件:

如果各组件名首字母不包含’\’,则函数会自动加上。
如果有一个组件是一个绝对路径，则在它之前的所有组件均会被舍弃。
如果最后一个组件为空，则生成的路径以一个’/'分隔符结尾。

import os

path1 = 'a'
path2 = 'b'
path3 = 'c'
path4 = "D:\classify_leaves\classify-leaves\classify-leaves\images"
path10 = path1 + path2 + path3
path20 = os.path.join(path1,path2,path3)

print(path20)
print(path10)

path30 = os.path.join(path20,path4)
print(path30)

C:\Users\admin\anaconda3\envs\torch11\python.exe D:/classify_leaves/classify-leaves/csdn.py
a\b\c
abc
D:\classify_leaves\classify-leaves\classify-leaves\images

Process finished with exit code 0

4.os.makedirs(name,mode=0o777,exist_ok=False)
递归目录创建函数，和mkdir很像，但是所有中间级目录都要包含叶目录。

参数解释：

name：所要创建的目录

如果exist_ok=False，默认情况下，当目标目录（即要创建的目录）已经存在，会抛出一个OsError。

所以创建时可以设置exist_ok=True，已经有的目录而不会报错。

import os

这里已经有csdn文件了

os.makedirs('csdn',exist_ok=False)
os.makedirs('csdn',exist_ok=False)

C:\Users\admin\anaconda3\envs\torch11\python.exe D:/classify_leaves/classify-leaves/csdn.py
Traceback (most recent call last):
  File "D:/classify_leaves/classify-leaves/csdn.py", line 16, in <module>
    os.makedirs('csdn',exist_ok=False)
  File "C:\Users\admin\anaconda3\envs\torch11\lib\os.py", line 223, in makedirs
    mkdir(name, mode)
FileExistsError: [WinError 183] 当文件已存在时，无法创建该文件。: 'csdn'

Process finished with exit code 1

import os



os.makedirs('csdn',exist_ok=True)

C:\Users\admin\anaconda3\envs\torch11\python.exe D:/classify_leaves/classify-leaves/csdn.py

Process finished with exit code 0

5.
1、shutil.copy() 模块具体用法
shutil.copy(source, destination)（这种复制形式使用的前提是必须要有 os.chdir(你要处理的路径)）
source/destination 都是字符串形式的路劲，其中destination是：
1、可以是一个文件的名称，则将source文件复制为新名称的destination
2、可以是一个文件夹，则将source文件复制到destination中
3、若这个文件夹不存在，则将source目标文件内的内容复制到destination中

2、shutil.copytree() 模块具体用法
shutil.copytree(source, destination)（这种复制形式无需 os.chdir() 便可操作）
source 、 destination 可以是不同的文件夹、不同的硬盘空间，
可以更为方便的实现文件的备份

6.set()
set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
Python 中有两种集合类型，一种是 set 类型的集合，另一种是 frozenset 类型的集合，它们唯一的区别是，set 类型集合可以做添加、删除元素的操作，而 forzenset 类型集合不行。本节先介绍 set 类型集合，后续章节再介绍 forzenset 类型集合。

7.collections.Counter(labels.values()).most_common()[-1][1]
这段代码使用了Python标准库中的collections.Counter类。Counter类用于对可迭代对象中各元素的出现次数进行计数，并返回一个字典类型的对象，其中键为元素，值为该元素出现的次数。

具体来说，代码中的labels.values()表示对一个包含标签的可迭代对象中的各个标签出现次数进行计数。most_common()方法返回计数结果中出现频率最高的元素及其出现次数，结果为一个列表，最后一个元素是出现频率最低的元素及其出现次数所组成的元组((element, count))。

因为我们只关心出现频率最低的元素出现的次数，所以使用[-1][1]来获取出现频率最低的元素的出现次数。[-1]表示获取列表最后一个元素，[1]表示获取该元素中的第二个值（即出现次数）。

8.math.floor()向下取整
math.ceil() 向上取整

9.torchvision.transforms.Compose（）
torchvision是pytorch的一个图形库，它服务于PyTorch深度学习框架的，主要用来构建计算机视觉模型。torchvision.transforms主要是用于常见的一些图形变换。以下是torchvision的构成：

1.torchvision.datasets: 一些加载数据的函数及常用的数据集接口；
2.torchvision.models: 包含常用的模型结构（含预训练模型），例如AlexNet、VGG、ResNet等；
3.torchvision.transforms: 常用的图片变换，例如裁剪、旋转等；
4.torchvision.utils: 其他的一些有用的方法。

其中Compose主要作用是串联多个图片变换的操作。
from torchvision.transforms import transforms

train_transforms = transforms.Compose([
transforms.Resize([224, 224]), # 将输入图片resize成统一尺寸
transforms.RandomRotation(degrees=(-10, 10)), # 随机旋转，-10到10度之间随机选
transforms.RandomHorizontalFlip(p=0.5), # 随机水平翻转 选择一个概率概率
transforms.RandomVerticalFlip(p=0.5), # 随机垂直翻转
transforms.RandomPerspective(distortion_scale=0.6, p=1.0), # 随机视角
transforms.GaussianBlur(kernel_size=(5, 9), sigma=(0.1, 5)), # 随机选择的高斯模糊模糊图像
transforms.ToTensor(), # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
transforms.Normalize( # 标准化处理–>转换为标准正太分布（高斯分布），使模型更容易收敛
mean=[0.485, 0.456, 0.406],
std = [0.229, 0.224, 0.225]) # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])
torchvision.transforms模块中的RandomResizedCrop类来对输入图像进行随机裁剪（crop）和缩放（resize）。
(1) Crop：随机大小和随机宽高比的裁剪，且随机的范围可以指定。

(2) Resize： Resize到指定的大小。

先进行随机大小和随机宽高比的Crop操作，再对Crop出来的区域进行Resize操作。
其中参数包括：

• 96：指定裁剪后输出的图像的尺寸为96x96像素，裁剪后的图像会被缩放到该尺寸。
• scale=(0.64,1.0)：指定随机裁剪时的面积比（area ratio）的范围，用一个元组表示，其实就是在0.64和1之间取一个数作为面积比，面积比越小表示裁剪后的区域与原图的比例越小。
• ratio=(1.0,1.0)：指定随机裁剪时的宽高比（aspect ratio）的范围，用一个元组表示，这里指定的是固定的1:1的宽高比，即裁剪后的区域宽和高相等。

这里需要注意的是，该随机裁剪方法并不是对图像按照随机位置、随机大小进行裁剪，而是从原图中随机选择一个子区域进行裁剪，该子区域的长宽比以及面积比都会在上述参数范围内随机取值，最后再将子区域缩放到指定的输出尺寸（96x96像素）。

通过使用该随机裁剪方法，在训练图像分类模型时可以增加数据集的多样性，从而帮助模型更好地泛化和适应不同的测试数据。

10.torchvision.transforms.Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])
标准化为什么总是这几个数值[0.485, 0.456, 0.406],[0.229, 0.224, 0.225]，
因为使用了使用ImageNet的均值和标准差。使用Imagenet的均值和标准差是一种常见的做法。它们是根据数百万张图像计算得出的。如果要在自己的数据集上从头开始训练，则可以计算新的均值和标准差。否则，建议使用Imagenet预设模型及其平均值和标准差。

在图像送入网络训练之前，减去图片的均值，算是一种归一化操作。
图像其实是一种平稳的分布，减去数据对应维度的统计平均值，可以消除公共部分。
以凸显个体之前的差异和特征。

如果要在自己的数据集上从头开始训练，则可以计算新的均值和标准差。否则，建议使用Imagenet预设模型及其平均值和标准差。

对于我们特定数据集，如遥感图像或者医学图像不采用该处理方式。

11.torchvision.datasets.ImageFolder 是一个 torchvision 库中的通用图像读取类，用于加载包含子文件夹类别的图像数据集。

该函数的参数如下：

• root：表示数据集所在目录的路径。
• transform（可选）：表示需要对图像进行转换的处理方式，如裁剪，归一化等，常用的可选处理函数有 torchvision.transforms.ToTensor()，torchvision.transforms.Normalize()，torchvision.transforms.Resize() 等。
• target_transform（可选）：表示需要对标签变换的处理方式，通常不需要进行额外操作，可以只留一个默认值None。
• loader（可选）：表示使用的图像加载函数，默认情况下使用Pillow库中的默认处理方式（即 torchvision.datasets.folder.default_loader，支持.bmp, .jpg, .jpeg,和.png格式）。
• is_valid_file（可选）：表示一个函数或者类，用来过滤指定数据集目录中的图像文件，返回 True 的文件将会被加载，默认为 None。

最终，ImageFolder会将所有符合要求的图像文件路径存储在内存中，同时也会生成一个 class_to_idx 的映射字典，用于将图像的类别名映射为整数标签。

使用 ImageFolder 类读取数据集时需要将数据集按照类别放在不同的子文件夹中，每个子文件夹的名称表示该子文件夹中存放的图像的类别，文件名表示图像文件的名称。读取数据集后可以通过直接以索引的方式访问到对应的图像和标签。

在训练深度学习模型时，经常需要使用这个库来加载图像数据集，并将其转换成 PyTorch 中 Tensor 类型的数据，方便进行模型训练并进行其它的处理。

12.torch.utils.data.DataLoader 是 PyTorch 中用于数据加载的一个类，它提供了一个数据加载的迭代器，并且可以通过多线程或多进程的方式，实现快速、效率高的数据读取。它的使用非常方便，可以帮助我们将数据打包成批量进行处理，提高模型训练的效率。 下面是 DataLoader 的详细解释： 1. 必要参数： * dataset：数据集，需要实现 __getitem__ 和 __len__ 两个方法。 * batch_size：批量大小，即每次迭代载入的数据量。 * shuffle：是否在每个 epoch 之前打乱数据集。 2. 可选参数： * num_workers：表示用几个进程来加速加载数据集，默认为 0，表示在主进程中进行数据加载。如果设置为值大于 0 的整数，将会使用多进程进行数据加载。 * collate_fn：将一个批次的数据弄在一起操作的函数，通常情况下无需自定义。如果在数据集中某些样本的维度不一致，可以通过这个函数来分配合适的内存大小，以防止训练出错。 * pin_memory：是否将样本复制到 CUDA 主机内存中，在 GPU 上加载时会加速数据传输。 * drop_last：是否在迭代至最后一个 batch 时直接丢弃少于 batch size 的数据。

dataset：传入torch.utils.data.Dataset类的一个实例。

batch_size：mini batch的大小，应为int型。

shuffle：True的话是指数据是否会被随机打乱，默认False。

sampler：自定义的采样器（shuffle=True时会构建默认的采样器，如果想使用自定义的方法需要构造一个torch.utils.data.Sampler的实例来进行采样，并设置shuffle=False，将实例作为参数传入），返回一个数据数据的下标索引。

batch_sampler：和sampler类似，不过batch_sampler返回的是一个mini batch的数据索引，而sampler返回的是下标索引。

num_workers：dataloader使用的进程数目，应为int型。

collect_fn：传入一个自定义的函数，定义如何把一批Dataset的实例转换为包含迷你批次的数据张量，例如这里是YoloV3里的collect_fn：

def yolo_dataset_collate(batch):
    images = []
    bboxes = []
    for img, box in batch:
        images.append(img)
        bboxes.append(box)
    images = np.array(images)
    return images, bboxes

pin_memory：True的话会把数据转移到和GPU内存相关联的CPU内存中，从而能够加快GPU载入数据的速度。

drop_last：设置为True的话，当batch_size不能整除dataset里的数据总数时，会将最后一个batch抛弃，也就是说每一个batch都严格等于batch_size。

timeout：值如果大于零，就会决定在多进程情况下对载入数据的等待时间。

worker_init_fn：决定了每个子进程开始时运行的函数，这个函数运行在随机种子设置以后、载入数据之前。

multiprocessing_context：官方文档暂时未给出。

generator：如果不是none，这个随机数发生器将用来生成随机索引和多进程。（官方文档翻译过来的）

prefetch_factor：每个进程开始之前预加载的sample数。

persistent_workers：如果设置为True，dataloader不会在数据集被使用一次后关闭工作进程。

13.优化器函数
SGD（Stochastic Gradient Descent）是深度学习中最基本的优化器之一，它的核心思想是每次迭代时，随机选择一个样本来计算梯度并更新权重。具体来说，SGD 的更新公式如下：

$${\mathbf{w}}_{t+1}={\mathbf{w}}_t-{\eta }_t{\mathbf{g}}_t,$$

其中 ${\mathbf{w}}_t$ 表示第 $t$ 个迭代时的权重，${\mathbf{g}}_t$ 表示第 $t$ 个迭代时的梯度，${\eta }_t$ 表示第 $t$ 个迭代时的学习率。

除了 SGD，还有很多其他的优化器函数，下面简要介绍一些常用的优化器函数：

1. Momentum：在 SGD 的基础上，引入动量（momentum）的概念，可以加速模型的训练过程。具体来说，动量是指在更新权重时，不仅考虑当前的梯度，还考虑之前的梯度对当前权重的影响。更新公式如下：

   $$\begin{array}{rl}{\mathbf{v}}_{t+1}& =\gamma {\mathbf{v}}_t+{\eta }_t{\mathbf{g}}_t,\\ {\mathbf{w}}_{t+1}& ={\mathbf{w}}_t-{\mathbf{v}}_{t+1},\end{array}$$

   其中 ${\mathbf{v}}_t$ 表示第 $t$ 个迭代时的动量，$\gamma$ 表示动量系数，通常取 0.9。

2. Adagrad：自适应调整每个参数的学习率，适合稀疏数据集。更新公式如下：

   $${\mathbf{w}}_{t+1,i}={\mathbf{w}}_{t,i}-\frac{{\eta }_t}{\sqrt{{\sum }_{j=1}^t{\mathbf{g}}_{j,i}^2}}{\mathbf{g}}_{t,i},$$

   其中 ${\mathbf{g}}_{t,i}$ 表示第 $t$ 个迭代时第 $i$ 个参数的梯度，${\sum }_{j=1}^t{\mathbf{g}}_{j,i}^2$ 表示前 $t$ 个迭代时第 $i$ 个参数梯度的平方和。

3. Adadelta：对 Adagrad 进行改进，不需要手动设置学习率，适合长时间训练。更新公式如下：

   $$\begin{array}{rl}{\mathbf{s}}_{t,i}& =\gamma {\mathbf{s}}_{t-1,i}+(1-\gamma ){\mathbf{g}}_{t,i}^2,\\ {\mathbf{w}}_{t+1,i}& ={\mathbf{w}}_{t,i}-\frac{\sqrt{{\mathbf{\Delta }}_{t,i}+ϵ}}{\sqrt{{\mathbf{s}}_{t,i}+ϵ}}{\mathbf{g}}_{t,i},\\ {\mathbf{\Delta }}_{t,i}& =\gamma {\mathbf{\Delta }}_{t-1,i}+(1-\gamma )({\mathbf{w}}_{t+1,i}-{\mathbf{w}}_{t,i}{)}^2,\end{array}$$

   其中 ${\mathbf{s}}_{t,i}$ 表示前 $t$ 个迭代时第 $i$ 个参数梯度平方的滑动平均，${\mathbf{\Delta }}_{t,i}$ 表示前 $t$ 个迭代时第 $i$ 个参数更新量平方的滑动平均，$ϵ$ 是一个小常数，防止除以 0。

4. Adam：结合了 Momentum 和 Adagrad 的优点，可以自适应调整每个参数的学习率，并且具有动量。更新公式如下：

   $$\begin{array}{rl}{\mathbf{m}}_t& ={\beta }_1{\mathbf{m}}_{t-1}+(1-{\beta }_1){\mathbf{g}}_t,\\ {\mathbf{s}}_t& ={\beta }_2{\mathbf{s}}_{t-1}+(1-{\beta }_2){\mathbf{g}}_t^2,\\ {\hat{\mathbf{m}}}_t& =\frac{{\mathbf{m}}_t}{1-{\beta }_1^t},\\ {\hat{\mathbf{s}}}_t& =\frac{{\mathbf{s}}_t}{1-{\beta }_2^t},\\ {\mathbf{w}}_{t+1}& ={\mathbf{w}}_t-\frac{{\eta }_t}{\sqrt{{\hat{\mathbf{s}}}_t}+ϵ}{\hat{\mathbf{m}}}_t,\end{array}$$

   其中 ${\mathbf{m}}_t$ 和 ${\mathbf{s}}_t$ 分别表示第 $t$ 个迭代时的动量和梯度平方的滑动平均，${\hat{\mathbf{m}}}_t$ 和 ${\hat{\mathbf{s}}}_t$ 分别表示第 $t$ 个迭代时的动量和梯度平方的无偏估计，${\beta }_1$ 和 ${\beta }_2$ 分别是动量和梯度平方的滑动平均系数，通常取 0.9 和 0.999，$ϵ$ 是一个小常数，防止除以 0。

除了上述优化器函数，还有很多其他的优化器函数，例如 RMSprop、Nadam 等。不同的优化器函数适用于不同的场景，需要根据具体情况进行选择。