Coursera-生成式人工智能与大模型笔记-全-

Coursera 生成式人工智能与大模型笔记（全）

生成式人工智能与大语言模型：01：欢迎来到生成式人工智能的世界 🚀

在本节课中，我们将要学习生成式人工智能的基本概念，了解它如何融合创造力与技术创新，并开启无限可能。我们将一起探索生成式AI的核心模型、应用领域以及伴随其发展的重要伦理考量。

你好，欢迎来到生成式人工智能的世界。这是一个人工智能与创造力、创新和无限可能性交汇的领域。

人工智能正在重塑我们与技术互动的方式，将机器的想象力变为现实。从创作迷人的艺术品到生成逼真的人类语音，这些AI模型正在各个行业开辟新道路。

今天，我们将深入探讨生成式AI具有变革性的原因，特别是在重新定义艺术、音乐乃至写作等创意领域方面。本课程专为初学者设计，将解析复杂的术语，并探索诸如生成对抗网络（GANs）、变分自编码器（VAEs）、Transformer和扩散模型等引人入胜的模型。

这些模型的魅力在于它们能够学习数据中的模式，并创造出新的内容，超越了单纯的复制，能够打造出全新的东西。

我们的课程设计旨在逐步构建你的理解和技能。我们将从打下坚实的基础开始，帮助你定义和区分各种类型的模型。

在接下来的学习中，你将发现生成式模型有趣的演变过程及其在现实世界中的应用，从自动驾驶汽车、人脸生成到内容创作。

安全与伦理在人工智能中的重要性再怎么强调也不为过。我们将探讨关键方面，包括安全风险以及AI对社会更广泛的影响。这些知识至关重要，因为负责任的创新必须与技术进步同步。

为了获得实践经验，我们安排了一系列视频演示和编程作业，让你能够亲手尝试这些令人振奋的技术。你将使用真实数据和当今行业中使用的一些最酷的工具，从而理解、构建并精进你的技能。

你的学习之旅是安全的，我鼓励你保持好奇心并积极提问。请记住，探索伴随着责任。随着我们深入探讨，请批判性地思考这些技术如何塑造我们的世界。

让我们作为探索者、创造者和生成式AI世界中的伦理创新者，一起踏上这段激动人心的旅程。我迫不及待想看到你取得的惊人成就。

欢迎。

本节课中，我们一起学习了生成式人工智能的广阔前景与核心使命。我们了解到，它不仅是技术的飞跃，更是创造力与责任感的结合。从理解基本概念到认识其社会影响，我们已经为深入探索具体的模型和应用奠定了坚实的基础。

002：训练二维斑点上的判别模型逻辑回归 📊

在本节课中，我们将学习如何创建一个简单的机器学习模型，用于区分两组数据点。你可以把它想象成教计算机在两种类型的点之间画一条分界线。

概述

我们将从创建模拟数据开始，然后使用PyTorch构建一个逻辑回归模型，训练它来区分两组二维数据点，并最终可视化模型学习到的决策边界。

创建模拟数据 🎯

首先，我们需要一些用于练习的数据。我们的代码会创建300个数据点，并将它们分成两组：紫色和黄色。每个点都有两个特征，类似于X和Y坐标。

以下是创建数据的核心代码：

# 示例代码：创建两组二维数据点
import numpy as np

# 生成第一组数据（紫色）
group1 = np.random.randn(150, 2) + np.array([2, 2])
# 生成第二组数据（黄色）
group2 = np.random.randn(150, 2) + np.array([-2, -2])

# 合并数据并创建标签
X = np.vstack([group1, group2])
y = np.hstack([np.zeros(150), np.ones(150)])  # 0代表紫色，1代表黄色

观察我们的散点图。可以看到紫色点聚集在一起，与黄色点明显分开。

数据预处理与加载 🔄

上一节我们创建了数据，本节中我们来看看如何为模型训练做准备。

我们需要将数据转换成PyTorch能够理解的格式。这就像将我们的数据翻译成PyTorch的语言。我们还会创建大小为32的数据批次。

以下是数据加载的核心步骤：

import torch
from torch.utils.data import DataLoader, TensorDataset

# 将NumPy数组转换为PyTorch张量
X_tensor = torch.tensor(X, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.float32).view(-1, 1)

# 创建数据集和数据加载器
dataset = TensorDataset(X_tensor, y_tensor)
batch_size = 32
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

为了获得更好的学习效果，我们对数据进行打乱。

构建逻辑回归模型 🧠

现在，我们进入核心部分：创建逻辑回归模型。

逻辑回归模型的核心是一个线性层，后接一个Sigmoid激活函数，用于输出一个介于0和1之间的概率值。其公式可以表示为：

ŷ = σ(W·X + b)

其中：

ŷ 是预测概率。
σ 是Sigmoid函数：σ(z) = 1 / (1 + e^{-z})。
W 是权重矩阵。
X 是输入特征。
b 是偏置项。

以下是模型的PyTorch实现：

import torch.nn as nn

class LogisticRegressionModel(nn.Module):
    def __init__(self, input_dim):
        super().__init__()
        self.linear = nn.Linear(input_dim, 1)  # 线性层

    def forward(self, x):
        # 线性变换后通过Sigmoid函数
        return torch.sigmoid(self.linear(x))

训练模型 🏋️

模型构建完成后，我们需要训练它。我们的训练过程使用二元交叉熵损失（BCE Loss）来衡量预测错误，并使用随机梯度下降（SGD）优化器来更新模型参数，这就像朝着更准确预测的方向迈出一小步。训练将进行50个周期，即完整遍历数据集50次。

以下是训练循环的核心代码：

model = LogisticRegressionModel(input_dim=2)
criterion = nn.BCELoss()  # 损失函数
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)  # 优化器

num_epochs = 50
for epoch in range(num_epochs):
    for batch_X, batch_y in dataloader:
        # 前向传播
        predictions = model(batch_X)
        loss = criterion(predictions, batch_y)

        # 反向传播与优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    # 可选项：打印每个周期的损失
    # print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

观察损失值（错误的数量）如何随着时间的推移而减小。

可视化决策边界 📈

最后，让我们看看训练好的模型是如何区分这两组点的。灰色区域展示了模型的决策边界。

以下是可视化决策边界的思路：

创建一个覆盖整个数据范围的网格。
用训练好的模型预测网格中每个点的类别。
根据预测结果对网格进行着色。

import matplotlib.pyplot as plt

# 创建网格
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
                     np.arange(y_min, y_max, 0.02))

# 模型预测
with torch.no_grad():
    grid_tensor = torch.tensor(np.c_[xx.ravel(), yy.ravel()], dtype=torch.float32)
    Z = model(grid_tensor)
    Z = (Z > 0.5).numpy().reshape(xx.shape)  # 将概率转换为类别（0或1）

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/coursera-genai-llm/img/af8c39e3bd1d4ae804615df3eeef3050_21.png)

# 绘制背景和散点
plt.contourf(xx, yy, Z, alpha=0.3, cmap='coolwarm')
plt.scatter(group1[:, 0], group1[:, 1], color='purple', label='Group 1 (Purple)')
plt.scatter(group2[:, 0], group2[:, 1], color='yellow', label='Group 2 (Yellow)')
plt.legend()
plt.show()

浅色区域预测为黄色组。

深色区域预测为紫色组。

可以看到，模型在我们的数据簇之间画出了一条平滑的分界线。

总结

本节课中，我们一起学习了如何使用逻辑回归模型教计算机区分两组二维数据点。我们从创建模拟数据开始，经历了数据预处理、模型构建、训练以及最终的可视化。决策边界清晰地展示了模型是如何做出预测的。逻辑回归虽然简单，但它是理解更复杂分类模型的重要基础。

生成式人工智能与大语言模型：P03-01：拟合与可视化生成模型 🎨

在本节课中，我们将学习如何创建一个生成式模型。你可以把它想象成教一台电脑绘画，让它能画出与我们原始数据相似的新数据点。这就像一位艺术家学习模仿他人的绘画风格。

首先，我们需要创建一些用于练习的数据。

以下是创建数据的代码：

# 示例代码：创建包含两个簇的合成数据
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs

# 生成300个数据点，形成两个中心，并添加高斯噪声
X, y = make_blobs(n_samples=300, centers=2, cluster_std=1.0, random_state=42)

现在，让我们来看看生成的第一张图。图中显示了我们有两个明显不同的点群。这些点以高斯分布（钟形曲线）的形式散布开来。

上一节我们创建了数据，本节中我们来看看如何教会模型理解这些模式。

我们使用高斯混合模型。这个模型通过寻找每个簇的中心、理解点围绕这些中心的散布方式，并计算每个点属于各个组的概率来进行学习。

以下是模型拟合的核心公式概念：
P(X) = Σ [π_k * N(X | μ_k, Σ_k)]
其中，π_k 是混合权重，N 是高斯分布，μ_k 是均值，Σ_k 是协方差。

现在，让我们观察结果图。图中的等高线类似于地形图。

以下是关于等高线的解释：

每条线显示了具有相等概率的点。
圆圈越紧密，表示该区域点的出现概率越高。
模型已经学会了点最可能出现的位置。

最精彩的部分来了：让我们创建新的数据点。

在最终的图中，三角形代表我们的原始数据，而圆形则是我们的模型生成的新数据点。请注意，新生成的点遵循着与原始数据相同的分布模式。

🎼 总结

本节课中，我们一起学习了如何创建一个生成式模型，该模型能够生成与训练数据相似的新数据点。这就像教电脑成为一名艺术家，能够以与原始作品相同的风格创作出新的作品。我们通过生成合成数据、使用高斯混合模型进行拟合、可视化概率分布，并最终生成了新的数据点，完成了整个流程。

生成式人工智能与大语言模型：P4-01：生成式模型基础实战 🎨

在本节课中，我们将学习三种不同类型的生成式模型：生成对抗网络、变分自编码器和序列模型。你可以把它们想象成三位不同的艺术家，它们通过研究现有数据中的模式来学习创造新数据。

首先，让我们准备好工具。我们将使用 PyTorch 来构建我们的生成式模型，这就像拥有一个配备了所有创意工具的特殊艺术工作室。

生成对抗网络：一场创造与识别的游戏 🎭

生成对抗网络就像拥有两位艺术家。一位是生成器，它试图创造假数据；另一位是判别器，它试图识别出假数据。我们的代码将同时创建这两者。这就像一场游戏，一位玩家越来越擅长创造赝品，而另一位则越来越擅长发现它们。

以下是构建 GAN 的关键代码结构：

# 生成器：从随机噪声生成数据
generator = Generator()
# 判别器：判断数据是真实的还是生成的
discriminator = Discriminator()

现在我们来训练我们的 GAN。生成器从随机噪声中创造假数据，判别器则学习区分真实与虚假数据。它们轮流进行，不断提升各自的技能。在训练过程中，观察两者损失值的变化，它们正是在相互学习中进步的。

变分自编码器：学习压缩与重建 🧩

VAE 的工作原理有所不同。它就像教计算机将数据压缩到一个小的空间（编码），然后从压缩版本中重建出原始数据（解码）。

我们的代码通过构建一个协同工作的编码器和解码器来实现这一点。

以下是 VAE 的核心组件：

# 编码器：将输入数据压缩为潜在表示
encoder = Encoder()
# 解码器：从潜在表示重建数据
decoder = Decoder()

接下来是训练 VAE 的时间。它学习如何高效地压缩数据，并准确地重建数据。模型需要在压缩率和重建准确性之间取得平衡。损失函数将向我们展示它在这两项任务上的学习效果。

序列模型：预测下一个元素 📝

上一节我们介绍了基于图像数据的模型，本节我们来看看处理序列数据的模型。序列模型就像教某人预测不同句子中的下一个单词。

我们首先创建数据和模型。LSTM 代表长短期记忆网络，它就像是给我们的模型一个记事本，用来记住序列中的模式。我们创建一些随机数据来供模型练习。

以下是定义序列模型的示例：

# 定义一个简单的 LSTM 模型
model = LSTM(input_size, hidden_size, num_layers)

现在，让我们训练模型。每经过 10 个训练周期，我们通过查看损失值（错误的数量）来检查模型的学习情况。

我们来观察模型是如何随时间改进的。高损失意味着很多错误。随着训练周期的增加，我们看到损失在变小，模型开始识别出模式。到第 40 个周期时，我们已经可以看到大约 28% 的改进。

总结 📚

本节课中，我们一起学习了三种生成新数据的不同方法：

生成对抗网络：通过生成器和判别器的对抗游戏进行学习。
变分自编码器：学习压缩和重建数据。
序列模型：学习随时间变化的序列模式。

每种模型都有其独特的“艺术”创作方式，是构建更复杂生成式人工智能系统的重要基础。

生成式人工智能与大语言模型：05：扩散模型实战：从噪声到逼真输出 🎨

在本节课中，我们将学习扩散模型。这是一种特殊的人工智能模型，它通过学习清理带噪声的图像来工作。你可以把它想象成缓慢地清理一张模糊的照片。

首先，我们需要准备好工具。

我们将使用GPU（如果可用的话）。我们还需要设置超参数。

我们会建立数据分割和加载器。我们将使用这张图片进行快速检查。

以下是创建带有噪声的图像序列的代码。

我们还将使用这个工具函数，计算去噪后的输出与干净图像之间的均方误差（MSE）。

上一节我们介绍了准备工作，本节中我们来看看如何实现变分自编码器（VAE）。VAE是另一种用于去噪的模型。

以下是VAE的实现代码。

接下来，我们将训练我们的VAE模型。

现在，让我们实现生成对抗网络（GAN）。GAN是另一种用于图像去噪的模型。

以下是GAN的实现代码。

接下来，我们将训练我们的GAN模型。

现在，我们将训练我们的DDPM模型，以去除噪声并还原出干净的图像。

以下是DDPM模型的实现。我们的模型从一个带噪声的图像开始，逐步去除噪声，一步一步让图像变得更清晰。这就像在暗房里观看照片显影的过程。

接下来，我们将训练我们的DDPM模型数个周期，以确保模型能高效地学习去噪。

现在，让我们可视化不同模型的去噪结果。

以下是不同模型去噪效果的对比。

VAE模型去噪结果
GAN模型去噪结果
DDPM模型去噪结果

本节课中，我们一起学习了扩散模型的工作原理：通过添加噪声，然后仔细地将其去除。这个过程有助于创造出看起来逼真且多样的新图像。😊

生成式人工智能与大语言模型：P6-01：当今大型语言模型的实际应用案例：跨服务商分析

在本节课中，我们将探索大型语言模型在真实应用中的不同使用方式。我们将通过具体的代码示例，了解如何利用LLM完成文本摘要、代码解释、语言翻译和问题解决等任务。

准备工作：连接LLM服务

首先，我们需要准备好工具。我们将使用OpenAI的API，这就像一条特殊的电话线，允许我们与其大型语言模型进行对话。以下是一个基础的设置代码示例：

import openai

# 设置你的API密钥
openai.api_key = 'your-api-key-here'

通过这段代码，我们建立了与AI模型的连接，为后续的各种任务调用做好准备。

任务一：文本摘要

上一节我们建立了与LLM的连接，本节中我们来看看如何利用它进行文本摘要。摘要任务要求模型将长文本浓缩为简短的核心内容。

我们的代码指示模型扮演一个摘要专家的角色，并将温度参数设置为0.3以获得更稳定、一致的摘要结果，同时将输出限制在150个单词以内。

以下是实现文本摘要的关键代码步骤：

def summarize_text(text):
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "You are a helpful text summarizer."},
            {"role": "user", "content": f"Summarize the following text in under 150 words:\n\n{text}"}
        ],
        temperature=0.3,
        max_tokens=150
    )
    return response.choices[0].message.content

任务二：代码解释与生成

除了处理自然语言，LLM在编程领域也大有可为。它们可以帮助解释代码逻辑、提出改进建议，甚至根据描述编写新的代码。

以下代码展示了如何让LLM扮演一个代码助手：

def explain_code(code_snippet):
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "You are a expert programming assistant."},
            {"role": "user", "content": f"Explain what the following code does:\n\n{code_snippet}"}
        ],
        temperature=0.5  # 稍高的温度允许更有创造性的解释
    )
    return response.choices[0].message.content

任务三：语言翻译

语言翻译是LLM的另一项核心能力。它就像指尖有一位语言专家，可以快速准确地在不同语言间进行转换。

为了实现精准翻译，我们设置模型扮演专业翻译角色，并保持较低的温度值以确保翻译的准确性。

以下是翻译功能的实现：

def translate_text(text, target_language):
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "You are a professional translator."},
            {"role": "user", "content": f"Translate the following text into {target_language}:\n\n{text}"}
        ],
        temperature=0.1  # 低温度确保翻译忠实于原文
    )
    return response.choices[0].message.content

任务四：分步问题解决

最后，让我们看看LLM如何解决复杂问题。这种方法特别适用于数学难题或逻辑推理。

这个函数要求模型以“一步一步思考”的方式处理问题，并使用低温度值来获得清晰、合乎逻辑的答案。

以下是问题解决功能的代码示例：

def solve_problem(problem_statement):
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "You are a logical problem solver. Think step by step."},
            {"role": "user", "content": f"Solve this problem: {problem_statement}"}
        ],
        temperature=0.1  # 低温度促进逻辑严谨性
    )
    return response.choices[0].message.content

总结

本节课中，我们一起学习了大型语言模型如何协助完成多种任务，从文本摘要、翻译到代码处理和问题解决。这些工具使得以多种方式处理语言和工作变得更加容易。通过调整参数（如扮演的角色和温度值），我们可以引导模型适应不同的应用场景，满足从创造性到严谨性的各种需求。

生成式人工智能与大语言模型：P7：视觉语言模型能做什么：图文交互实践 👁️📖

在本节课中，我们将探索视觉语言模型的强大能力。这些模型能够结合文本和图像，执行复杂的任务，例如为图像生成描述、进行零样本图像分类以及视觉问答。

上一节我们介绍了视觉语言模型的基本概念，本节中我们来看看如何搭建环境并开始实践。

首先，我们需要确保安装了必要的库。以下是设置环境的步骤：

安装 transformers 库。
安装 PIL 或 Pillow 库用于图像处理。
安装 requests 库用于从网络获取图像。

现在，让我们从为图像生成描述开始。我们将使用 BLIP 模型来完成这项任务。

以下是使用 BLIP 模型生成图像描述的步骤：

使用 fetch_image 函数从提供的 URL 获取图像。
加载 BLIP 模型和对应的处理器来处理图像输入。
模型处理图像并生成描述文本。
解码并打印生成的描述。

# 示例代码：使用 BLIP 生成图像描述
from transformers import BlipProcessor, BlipForConditionalGeneration
from PIL import Image
import requests

# 获取图像
img_url = "https://example.com/image.jpg"
image = Image.open(requests.get(img_url, stream=True).raw)

# 加载模型和处理器
processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")

# 处理图像并生成描述
inputs = processor(image, return_tensors="pt")
out = model.generate(**inputs)
caption = processor.decode(out[0], skip_special_tokens=True)
print(caption)

接下来，我们将探索零样本图像分类。这意味着模型无需针对特定任务进行训练，就能对图像进行分类。我们将使用 CLIP 模型来实现。

以下是使用 CLIP 进行零样本图像分类的步骤：

使用 fetch_image 函数从提供的 URL 获取图像。
加载 CLIP 模型和处理器来处理图像和文本输入。
模型处理输入，根据预定义的标签对图像进行分类。
输出概率最高的预测标签。

# 示例代码：使用 CLIP 进行零样本图像分类
from transformers import CLIPProcessor, CLIPModel
from PIL import Image
import requests

# 获取图像
img_url = "https://example.com/image.jpg"
image = Image.open(requests.get(img_url, stream=True).raw)

# 定义候选标签
labels = ["a photo of a cat", "a photo of a dog", "a photo of a car"]

# 加载模型和处理器
model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")

# 处理输入
inputs = processor(text=labels, images=image, return_tensors="pt", padding=True)
outputs = model(**inputs)
logits_per_image = outputs.logits_per_image  # 图像与文本的相似度分数
probs = logits_per_image.softmax(dim=1)  # 转换为概率

# 输出结果
predicted_label = labels[probs.argmax().item()]
print(f"Predicted label: {predicted_label}")

最后，我们来模拟视觉问答。虽然 CLIP 模型本身不直接生成答案，但我们可以通过评估图像与不同问题-答案对的相关性来模拟这一过程。

以下是使用 CLIP 模拟视觉问答的步骤：

使用 fetch_image 函数从提供的 URL 获取图像。
加载 CLIP 模型和处理器来处理图像和文本输入。
将问题与多个可能的答案组合成文本对。
模型评估图像与每个文本对的匹配程度。
输出匹配度最高的答案作为模拟回答。

# 示例代码：使用 CLIP 模拟视觉问答
from transformers import CLIPProcessor, CLIPModel
from PIL import Image
import requests

# 获取图像
img_url = "https://example.com/image.jpg"
image = Image.open(requests.get(img_url, stream=True).raw)

# 定义问题和候选答案
question = "What is in the image?"
candidate_answers = ["a cat", "a dog", "a tree", "a car"]

# 将问题与每个答案组合
text_inputs = [f"{question} {answer}" for answer in candidate_answers]

# 加载模型和处理器
model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")

# 处理输入
inputs = processor(text=text_inputs, images=image, return_tensors="pt", padding=True)
outputs = model(**inputs)
logits_per_image = outputs.logits_per_image
probs = logits_per_image.softmax(dim=1)

# 输出模拟答案
simulated_answer = candidate_answers[probs.argmax().item()]
print(f"Simulated answer: {simulated_answer}")

本节课中我们一起学习了视觉语言模型的核心应用。我们实践了使用 BLIP 模型为图像生成描述，使用 CLIP 模型进行零样本图像分类，并模拟了视觉问答的过程。这些技术展示了模型在理解和处理多模态数据方面的巨大潜力。

生成式人工智能与大语言模型：P8-01：揭示大型语言模型输出中的偏见 🔍

在本节课中，我们将学习如何检测和预防人工智能（AI）响应中的偏见。这就像扮演一位公平性侦探，确保我们的AI能够平等地对待每个人。

首先，我们需要创建检测偏见的工具。我们的代码会连接到OpenAI的API，这就像一条通往AI的专用电话线。我们将设置一个函数来获取AI的响应，并控制其创造性和回答长度。这可以被视为配置我们的侦探装备。

以下是设置代码的示例：

import openai

def get_ai_response(prompt, temperature=0.7, max_tokens=150):
    response = openai.Completion.create(
        engine="text-davinci-003",
        prompt=prompt,
        temperature=temperature,
        max_tokens=max_tokens
    )
    return response.choices[0].text.strip()

上一节我们介绍了如何设置检测工具，本节中我们来看看如何实际测试偏见。

我们将测试两个相似的提示，以寻找潜在的偏见。具体方法是，比较AI对两位软件工程师“John”和“Jane”的描述，观察AI在描述他们时是否存在任何差异。

以下是测试的两个提示示例：

提示一：“描述一位名叫John的软件工程师。”
提示二：“描述一位名叫Jane的软件工程师。”

现在，让我们仔细分析AI的回复。我们需要关注几个关键点：回复的详细程度是否相同？使用的语言是否有差异？是否存在任何刻板印象？通过这种对比分析，我们可以发现AI在思考不同人群时可能存在的偏见。

在学习了如何检测偏见之后，接下来我们探讨如何通过改进提示来预防偏见。

我们的改进方法是，在提示中移除性别指代，并专注于工作本身而非个人身份。这有助于确保AI生成更公平、更平衡的回应。

例如，将提示从“描述一位名叫John的软件工程师。”改进为：“描述一位软件工程师的角色和典型职责。”

本节课中，我们一起学习了如何检查AI偏见以及如何通过优化提示使AI的回应更加公平。就像一位优秀的侦探，我们需要仔细观察，并确保我们的AI能够平等地对待每一个人。

生成式人工智能与大语言模型：P09-01_04_02：AI幻觉与信息误传实例 🔍

在本节课中，我们将学习AI幻觉现象，即人工智能生成不真实信息的情况。我们将了解如何识别和预防这种现象，确保AI提供的信息准确可靠。

上一节我们介绍了AI幻觉的基本概念，本节中我们来看看具体的实例和应对方法。首先，我们需要创建一个事实核查工具。

以下是创建事实核查工具的步骤：

连接API：代码连接到OpenAI的API。
创建响应函数：创建一个函数来获取AI的响应。
设置参数：将温度参数 temperature 设置为 0.0，以获得一致且专注的答案。
设定角色：指示AI扮演一个公正的评估者。

这就像为AI的回应设置了一个“测谎仪”。

在步骤三和四中，我们用一些棘手的健康问题进行了测试。

我们提出了一些可能诱使AI编造答案的问题。如果回答错误，可能会带来危险。或者，这些问题需要谨慎的事实性回应。

观察AI如何回应这些具有挑战性的问题。

当我们查看AI的回应时，我们检查了以下几点：

未经支持的断言：AI是否做出了没有依据的声明。
过度自信的陈述：AI的回答是否显得过于绝对。
事实与虚构的混合：AI是否将真实信息与编造的内容混在一起。

这就像侦探在寻找AI可能正在编造信息的线索。

为了预防AI幻觉，可以采取以下措施：

使用具体、清晰的提示。
要求AI提供来源和证据。
对重要信息进行双重核查。

本节课中，我们一起学习了如何识别和预防AI幻觉。就像核查新闻故事的真实性一样，确保AI提供准确、真实的信息至关重要。

010：Transformer为何至关重要？🤖

在本节课中，我们将探讨Transformer架构，了解它为何成为现代大语言模型（LLM）的核心技术，并改变了计算机理解和生成类人文本的方式。

概述：Transformer的革命性影响

Transformer彻底改变了机器学习领域，并成为当今大语言模型（如GPT和BERT）巨大能力的基石。在Transformer出现之前，机器理解长而复杂的文本是一项巨大的挑战。

上一节我们介绍了大语言模型的背景，本节中我们来看看Transformer如何解决了这一核心难题。

Transformer的核心机制：自注意力

Transformer引入了一种名为自注意力的机制。该机制允许模型在处理文本时，高效地聚焦于相关的部分，类似于我们阅读时强调重要信息的方式。

这种效率使得Transformer能够处理海量数据集，从而释放了像GPT和BERT这类模型的潜力，使其能够生成连贯的故事、进行翻译甚至创作诗歌。

Transformer的实际应用

以下是Transformer在现实世界中引发各行业突破的几个例子：

医疗保健：它们能够分析海量医学文献，辅助诊断和提供治疗建议。
商业：它们通过自动分类和管理客户咨询来协助企业。
娱乐：它们有助于为电子游戏生成对话，或创造性地辅助作家构思叙事。

Transformer的重要性

理解Transformer为何重要，为你打开了通往创新AI解决方案的大门，其影响遍及从聊天机器人到复杂数据分析的各个领域。

这不仅仅是关于Transformer能做什么，更是关于你能用它做什么。通过在处理效率和细致的文本理解之间保持平衡，Transformer确保了AI应用不仅功能强大，而且准确且具有上下文感知能力。

总结：拥抱Transformer的力量

本节课中，我们一起学习了Transformer架构如何构成当今AI进步的支柱。拥抱它的能力意味着你不仅能利用最前沿的人工智能技术，还能塑造未来技术交互的方式，使你在快速发展的领域中成为不可或缺的参与者。

深入探索Transformer的变革力量，站在AI革命的前沿。

011：循环神经网络的问题与Transformer的解决方案 🚀

在本节课中，我们将学习Transformer架构为何在人工智能领域变得如此流行。我们将通过对比循环神经网络（RNN）的局限性，来理解Transformer如何通过其独特的设计解决这些问题，从而实现更高效的信息处理。

从单车道到多车道高速公路 🛣️

上一节我们介绍了循环神经网络的基本概念。本节中，我们来看看RNN在处理信息时面临的核心挑战。

RNN按顺序逐个处理信息，就像单车道上的汽车。每一段信息都必须等待前一段处理完毕。序列越长，记住早期信息就越困难，这类似于狭窄道路上发生的交通堵塞。

以下是RNN处理信息的关键步骤：

# 创建一个简单的RNN层
self.rnn = nn.RNN(input_size, hidden_size)
# 添加一个全连接层以获取输出
self.fc = nn.Linear(hidden_size, output_size)

# 前向传播过程
def forward(self, x):
    # 从空记忆状态开始
    h0 = torch.zeros(1, x.size(0), self.hidden_size)
    # 读取每个信息片段时更新记忆
    out, _ = self.rnn(x, h0)
    out = self.fc(out[:, -1, :])
    return out

Transformer的并行处理方案 🚗💨

了解了RNN的瓶颈后，本节我们来看看Transformer如何通过“自注意力”机制实现更好的信息处理。

可以将自注意力机制想象成拥有多条车道的高速公路。所有信息片段可以同时移动，每个片段都能轻松地与其他片段建立联系，从而避免了“交通堵塞”。

以下是自注意力机制的核心实现：

# 为信息创建三个“车道”（查询、键、值）
self.q_linear = nn.Linear(d_model, d_model)
self.k_linear = nn.Linear(d_model, d_model)
self.v_linear = nn.Linear(d_model, d_model)

# 计算每个信息片段对其他片段的重要性（得分）
scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k)
# 根据重要性组合信息（注意力）
attention = torch.matmul(F.softmax(scores, dim=-1), value)

位置编码：信息的GPS坐标 🗺️

虽然Transformer可以并行处理所有信息，但它仍需了解信息的顺序。这就引入了“位置编码”的概念。

就像给每辆车分配唯一的GPS坐标一样，我们需要告诉Transformer每个信息片段的位置。这有助于模型理解信息的先后顺序。

以下是位置编码的实现方式：

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=5000):
        super().__init__()
        # 创建位置编码矩阵
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len).unsqueeze(1)
        # 使用正弦和余弦波标记位置
        div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        self.register_buffer('pe', pe)

    def forward(self, x):
        # 将位置编码添加到输入词向量中
        x = x + self.pe[:x.size(1)]
        return x

构建完整的Transformer系统 🏗️

最后，我们将所有组件组合起来，构建完整的Transformer模型。这就像设计一个完整的高速公路系统。

以下是Transformer编码器层的核心结构：

class TransformerEncoderLayer(nn.Module):
    def __init__(self, d_model, nhead, dim_feedforward=2048):
        super().__init__()
        # 设置多头注意力（多个“交通控制器”）
        self.self_attn = nn.MultiheadAttention(d_model, nhead)
        # 添加位置信息
        self.pos_encoder = PositionalEncoding(d_model)
        # 创建多个处理层
        self.linear1 = nn.Linear(d_model, dim_feedforward)
        self.linear2 = nn.Linear(dim_feedforward, d_model)
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)

    def forward(self, src):
        # 通过每一层处理信息
        src2 = self.self_attn(src, src, src)[0]
        src = src + self.dropout1(src2)
        src = self.norm1(src)
        src2 = self.linear2(F.relu(self.linear1(src)))
        src = src + self.dropout2(src2)
        src = self.norm2(src)
        return src

总结 📚

本节课中，我们一起学习了Transformer架构为何优于传统的循环神经网络（RNN）。

核心对比：

RNN：像单车道公路，信息必须顺序处理，容易产生“记忆瓶颈”。
Transformer：像多车道高速公路，通过自注意力机制实现信息并行处理，效率更高。

Transformer通过引入位置编码来理解序列顺序，并通过多头注意力和层叠结构构建了一个强大且高效的模型，这使其成为当今大语言模型和生成式AI的基石。

生成式人工智能与大语言模型：12：自注意力、多头注意力与前馈网络 🧠

在本节课中，我们将学习Transformer模型如何理解文本，重点剖析其三个核心组成部分：自注意力机制、多头注意力机制以及前馈网络。这些组件共同协作，使模型能够捕捉文本中的复杂关系并做出决策。

自注意力机制

上一节我们介绍了Transformer的整体架构，本节中我们来看看其理解文本的核心——自注意力机制。自注意力机制让模型能够计算一个句子中每个词与其他所有词之间的关联程度。

其核心计算过程如下：

计算注意力分数：模型为句子中的每一对词计算一个分数，表示它们之间的相关性。
应用Softmax：使用softmax函数将这些分数转换为概率分布（百分比），即注意力权重。这确保了所有权重之和为1。
加权求和：根据计算出的注意力权重，对所有词的信息进行加权组合，为每个词生成一个新的、包含了上下文信息的表示。

这个过程可以用以下公式概括：
注意力输出 = Softmax( (Q * K^T) / sqrt(d_k) ) * V
其中，Q（查询）、K（键）、V（值）是由输入词向量通过线性变换得到的矩阵。

准备关键矩阵

为了进行自注意力计算，我们需要从输入数据中创建三个关键的矩阵：查询矩阵、键矩阵和值矩阵。

这些矩阵通过将输入向量与不同的可学习权重矩阵相乘得到，它们帮助模型从不同角度理解和建立词与词之间的关系。

多头注意力机制

单一的注意力视角可能不足以捕捉文本中所有类型的关系。因此，我们引入了多头注意力机制。

多头注意力允许模型并行地从多个不同的“视角”或“子空间”来关注输入信息。以下是其工作原理：

多头注意力类将输入数据分割成多个较小的部分，称为“头”。

每个头都独立进行一套完整的自注意力计算，拥有自己的一套Q、K、V变换矩阵。
每个头专注于输入信息的不同方面，例如语法结构、语义角色或指代关系。
所有头的输出被拼接起来，并通过一个最终的线性变换层进行融合，产生最终的输出。

这种设计让模型能够同时捕捉短语依赖、远距离关联等多种模式。

增强模型能力：前馈网络

在注意力机制提取了词与词之间的关系后，我们需要进一步处理这些信息。这就是前馈网络的作用。

前馈网络对注意力机制的输出进行非线性变换，将其映射到更复杂、更具表现力的表示空间。

前馈网络类通常包含两个线性层：

第一层（扩展层）：将输入数据的维度增大，例如从512维扩展到2048维。这增加了模型的容量。
第二层（收缩层）：将维度缩减回原始的尺寸（如512维）。中间通常会使用激活函数（如ReLU）引入非线性。

这个过程可以简化为：
FFN(x) = max(0, x * W1 + b1) * W2 + b2
它帮助模型学习更复杂的数据特征，是每个Transformer块中进行深度处理的关键步骤。

构建Transformer块

最后，我们将多头注意力机制和前馈网络组合起来，形成一个完整的Transformer编码器块。

Transformer块类按顺序集成了以下组件：

多头注意力层：捕捉输入的上下文关系。
层归一化与残差连接：每个子层（注意力、前馈）的输出都会与输入相加（残差连接），然后进行层归一化。这有助于缓解梯度消失问题，稳定训练过程。
前馈网络层：对归一化后的注意力输出进行非线性变换。
再次的层归一化与残差连接。
Dropout：在训练时随机“关闭”一部分神经元，用于防止模型过拟合。

这个模块是Transformer模型处理数据的基本构建单元，通过堆叠多个这样的块，模型能够实现对文本的深度理解。

总结

本节课中，我们一起学习了Transformer理解文本的核心技术。

自注意力如同聚光灯，计算词与词之间的关联强度。
多头注意力如同多位读者同时从不同角度分析文本，提供了多重视角。
前馈网络则像一位深思熟虑的决策者，对注意力汇聚的信息进行深度加工和转换。

这些部分协同工作，使Transformer模型能够以前所未有的方式更好地理解语言。

013：温度参数与Top-P采样

在本节课中，我们将学习如何通过调整温度参数和Top-P采样技术，来控制大语言模型生成文本的创造性与一致性。

调整输出创造性：温度参数

上一节我们介绍了语言模型的基本工作原理。本节中，我们来看看如何通过调整一个关键参数——温度——来影响模型的输出风格。

温度参数控制着模型预测下一个词时的随机性。其核心原理是对模型输出的原始概率分布进行“锐化”或“平滑”处理。

公式：调整后的概率 = softmax(原始逻辑值 / 温度)

较高的温度值（如 1.0）会使概率分布更加平滑。这意味着模型在选择下一个词时，会给予低概率词更多机会，从而使输出更具随机性和多样性，更富有创造性。
较低的温度值（如 0.1）会使概率分布更加尖锐。这意味着模型会高度集中于概率最高的几个词上，从而使输出更加确定、聚焦和一致。

在代码中，通常会有一个类似 generate_with_temperature 的函数来应用这一调整。

以下是温度参数影响的直观对比：

高温度：输出更多样、更具创造性，但可能偏离主题或不合逻辑。
低温度：输出更聚焦、更一致，但可能显得重复或缺乏新意。

精炼输出创造性：Top-P采样

了解了如何通过温度进行整体调整后，我们来看看另一种更精细的控制方法：Top-P采样（也称核采样）。

Top-P采样不是调整所有词的概率分布，而是动态地从一个累积概率分布中筛选候选词。具体做法是，仅从累积概率超过阈值P的最高概率词集合中随机选择下一个词。

代码逻辑描述：

获取模型预测的下一个词的概率分布。
将词按概率从高到低排序。
从概率最高的词开始累加，直到累积概率超过预设的Top-P值（例如0.9）。
仅从这个候选词集合中随机抽取下一个词。

以下是Top-P值的影响：

较高的Top-P值（如 0.9）：包含更多可能的词，使输出更具多样性。
较低的Top-P值（如 0.5）：严格限制候选词范围，使输出更可控、更可预测。

总结

本节课中我们一起学习了两种调整语言模型输出的关键技术。

首先，我们探讨了温度参数，它通过缩放逻辑值来全局调整输出概率分布的平滑程度，从而在“创造性”与“一致性”之间取得平衡。

接着，我们学习了Top-P采样，这种方法通过设定一个累积概率阈值，动态地限制每一步的候选词范围，实现对输出随机性的更精细控制。

这些技术帮助我们根据具体需求，引导模型生成更聚焦、更可靠的文本，或是更富创意、更多样化的内容，是使用大语言模型时不可或缺的工具。

生成式人工智能与大语言模型：14：通过API和UI访问大型语言模型

在本节课中，我们将学习如何通过应用程序编程接口和用户界面来访问大型语言模型。我们将使用OpenAI的服务，轻松地发送提示并获取详细的模型回复。

首先，我们需要设置好开发环境。

以下是设置步骤：

安装必要的Python库，主要是openai。
获取并配置你的OpenAI API密钥。

现在，让我们创建一个函数，用于向模型发送提示并获取回复。

这个函数的核心是调用OpenAI的API。你可以通过参数来控制模型的响应方式，例如选择具体的模型、设置生成文本的最大长度以及调整创造性（温度）。

以下是关键参数说明：

model: 指定使用的模型，例如 "gpt-3.5-turbo"。
max_tokens: 限制模型生成回复的最大长度。
temperature: 控制回复的随机性，值越高（如0.8）回复越多样，值越低（如0.2）回复越确定。

接下来，我们尝试发送一个示例提示，看看模型如何回应。

我们发送提示：“请用简单的语言解释光合作用。”

模型将回复一个关于光合作用的简单解释。通过API和用户界面访问大型语言模型，可以便捷地获取详细而准确的信息。

本节课中，我们一起学习了如何设置环境、调用OpenAI API以及通过参数控制模型输出。掌握这些工具能帮助你利用先进的模型完成多种任务，从而提升你的机器学习项目与数据分析能力。

015：微调带来巨大成效 🎯

在本节课中，我们将要学习提示工程，并了解与大语言模型交互时，如何通过微小的调整获得显著的效果提升。

提示工程的核心在于精心设计输入给模型的指令或问题。通过调整提示的措辞、结构或提供额外信息，我们可以引导模型生成更准确、相关且符合预期的回答。接下来，我们将探索几种不同类型的提示及其对模型输出的影响。

直接提示 ✍️

上一节我们介绍了提示工程的基本概念，本节中我们来看看最基础的提示类型——直接提示。

直接提示要求模型以简单明了的方式解释某个概念。例如，我们可以要求模型解释扩散模型。

以下是使用直接提示的一个例子：

请以简单的方式解释扩散模型。

在使用这类提示时，我们还可以添加参数来控制输出。例如：

max_tokens：此参数用于限制模型生成文本的最大长度。
temperature：此参数控制模型输出的随机性和创造性，值越高，回答越多样；值越低，回答越确定。

系统提示 🎭

了解了直接提示后，我们来看看如何通过系统提示为模型设定一个特定的角色或上下文。

系统提示为模型设定一个背景或角色，例如，让它扮演一位教授。这有助于模型提供更具情境相关性的回答。

以下是使用系统提示的一个例子：

系统消息：你是一位人工智能教授。
用户消息：请以教授的口吻，比较变分自编码器和生成对抗网络。

通过设置系统消息，我们可以引导模型在特定的框架内进行思考和回应。

小样本提示 📋

最后，让我们探讨小样本提示。这种提示通过提供少量示例来指导模型的回答格式和内容。

小样本提示向模型展示几个例子，帮助它理解我们期望的回答模式和上下文。

以下是小样本提示的一个例子：

示例1：
问题：什么是机器学习？
回答：机器学习是人工智能的一个分支，它使计算机能够从数据中学习并做出决策。

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/coursera-genai-llm/img/ee9559a1598f5a2c7e552334642e19d4_14.png)

示例2：
问题：什么是神经网络？
回答：神经网络是一种受人脑启发的计算模型，用于识别数据中的模式。

目标问题：
问题：什么是深度学习？

通过提供这些示例，模型能更好地理解如何构建对“深度学习”这个问题的回答。

总结 📝

本节课中，我们一起学习了提示工程的几种关键方法。我们了解到，通过尝试直接提示、系统提示和小样本提示，并对提示进行微小的调整，可以显著提升大语言模型的回答质量。掌握这些技巧，你将能更有效地与大语言模型互动，并获得更理想的结果。

生成式人工智能与大语言模型：P16：使用Hugging Face微调Transformer模型

在本节课中，我们将学习如何使用Hugging Face库来微调一个预训练的Transformer模型。微调能够让我们将通用模型适配到特定任务上，从而提升其性能。

环境设置

首先，我们需要设置环境并安装必要的库。

以下是安装所需库的命令：

pip install transformers datasets

加载预训练模型与分词器

上一节我们设置了环境，本节中我们来看看如何加载模型。我们将以BERT模型为例进行演示。

以下代码用于加载BERT模型及其对应的分词器：

from transformers import AutoModelForSequenceClassification, AutoTokenizer

model_name = "bert-base-uncased"
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
tokenizer = AutoTokenizer.from_pretrained(model_name)

准备数据集

模型加载完成后，下一步是准备用于训练的数据。我们将使用IMDB电影评论数据集作为示例。

以下代码加载IMDB数据集并进行分词处理：

from datasets import load_dataset

dataset = load_dataset("imdb")
def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True)

tokenized_datasets = dataset.map(tokenize_function, batched=True)

配置微调过程

数据准备就绪后，现在可以配置模型的微调过程了。我们将使用Hugging Face的Trainer API。

以下是配置训练参数并初始化Trainer的代码：

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=16,
    num_train_epochs=3,
    weight_decay=0.01,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets["train"].select(range(100)), # 小样本训练
    eval_dataset=tokenized_datasets["test"].select(range(100)),
    tokenizer=tokenizer,
)

测试微调后的模型

模型训练完成后，最后一步是测试其在新数据上的表现。

以下代码展示了如何使用微调后的模型进行预测：

test_sentences = ["This movie was fantastic!", "The plot was boring and predictable."]
inputs = tokenizer(test_sentences, padding=True, truncation=True, return_tensors="pt")
outputs = model(**inputs)
predictions = outputs.logits.argmax(-1)
print(predictions) # 输出预测的标签

总结

本节课中，我们一起学习了使用Hugging Face库微调Transformer模型的完整流程。我们首先设置了环境并加载了预训练的BERT模型，然后准备了IMDB数据集，接着配置并执行了模型的微调，最后测试了模型在新句子上的情感分析能力。通过微调，我们可以使强大的通用模型更好地服务于特定任务，有效提升其准确性和效率。

生成式人工智能与大语言模型：P17-03_01_02：检索知识嵌入与使用Faiss进行向量搜索 🔍

在本节课中，我们将学习如何利用嵌入向量和Faiss向量搜索技术，从文档集合中高效检索相关知识。我们将通过环境配置、生成嵌入、建立索引和查询匹配四个步骤，完整演示这一流程。

环境配置 🛠️

首先，我们需要设置编程环境。以下是配置所需库的步骤。

我们将安装faiss库和sentence-transformers库，并导入必要的工具来生成嵌入向量和执行向量搜索。

# 安装必要的库
!pip install faiss-cpu sentence-transformers -q

# 导入库
from sentence_transformers import SentenceTransformer
import faiss
import numpy as np

生成文档嵌入向量 📄

上一节我们配置好了环境，本节中我们来看看如何为文档生成向量嵌入。我们将使用sentence-transformers模型将文本转换为数值向量。

以下是生成嵌入向量的代码示例：

# 初始化嵌入模型
model = SentenceTransformer('all-MiniLM-L6-v2')

# 示例文档
documents = [
    "机器学习是人工智能的一个分支。",
    "深度学习利用神经网络进行学习。",
    "向量搜索用于高效检索相似信息。"
]

# 生成嵌入向量
document_embeddings = model.encode(documents)

使用Faiss建立向量索引 🗂️

生成了文档的嵌入向量后，下一步是使用Faiss为这些向量建立索引，以实现快速相似性搜索。

以下是建立Faiss索引的步骤：

# 获取嵌入向量的维度
dimension = document_embeddings.shape[1]

# 创建Faiss索引（这里使用内积进行相似度计算，等同于余弦相似度，因为向量已归一化）
index = faiss.IndexFlatIP(dimension)
faiss.normalize_L2(document_embeddings) # 归一化向量
index.add(document_embeddings) # 将向量添加到索引

执行查询与检索匹配结果 🔎

现在，我们已经有了一个包含文档向量的Faiss索引。本节中，我们将学习如何输入一个查询，并检索出最相关的文档。

以下是执行查询的代码：

# 定义查询
query = "什么是神经网络？"

# 将查询转换为嵌入向量
query_embedding = model.encode([query])
faiss.normalize_L2(query_embedding)

# 在索引中搜索最相似的k个文档
k = 2
distances, indices = index.search(query_embedding, k)

# 输出结果
print("最相关的文档索引:", indices[0])
print("相似度分数:", distances[0])
for idx in indices[0]:
    print(f"文档 {idx}: {documents[idx]}")

🎼 输出将显示与查询最匹配的文档及其相似度分数。

总结 📝

本节课中我们一起学习了利用嵌入向量和Faiss进行知识检索的完整流程。我们首先配置了环境并安装了必要的库。接着，我们使用sentence-transformers模型将文本文档转换为向量表示。然后，我们利用Faiss为这些向量建立了高效的搜索索引。最后，我们演示了如何输入一个查询，并快速检索出语义上最相关的文档。

这项强大的技术使我们能够在大型数据集中进行高效语义搜索，快速找到所需信息。

生成式人工智能与大语言模型：18：基于检索的生成：在LLM流程中融入检索机制 🧠

在本节课中，我们将学习如何通过为大语言模型流程添加检索机制，来实现基于检索的生成。这项技术能让模型通过整合外部真实世界的信息，生成更准确、更相关的回答。

上一节我们介绍了大语言模型的基本生成流程。本节中，我们来看看如何通过检索外部知识来增强模型的回答能力。

首先，我们需要设置运行环境。以下是需要安装的关键库：

# 安装必要的Python库
pip install transformers datasets faiss-cpu sentence-transformers

接下来，我们将使用句子转换器模型为一系列文档创建向量嵌入。向量嵌入是将文本转换为数值向量的过程，便于后续的相似度计算。

from sentence_transformers import SentenceTransformer

# 加载预训练的句子嵌入模型
embedder = SentenceTransformer('all-MiniLM-L6-v2')
# 假设documents是一个包含多个文本字符串的列表
document_embeddings = embedder.encode(documents)

现在，我们将使用Faiss库为这些嵌入向量建立索引，以实现高效检索。Faiss是一个专门用于快速相似性搜索和密集向量聚类的库。

import faiss

# 获取嵌入向量的维度
dimension = document_embeddings.shape[1]
# 创建一个索引（这里使用内积作为相似度度量，等同于余弦相似度，因为向量已归一化）
index = faiss.IndexFlatIP(dimension)
# 将文档向量添加到索引中
index.add(document_embeddings)

然后，我们处理用户查询。流程是：将查询转换为向量，检索最相关的文档，并构建一个增强的提示词。

以下是实现此流程的关键步骤：

嵌入查询：使用相同的句子转换器模型将用户查询转换为向量。
执行检索：在Faiss索引中搜索与查询向量最相似的K个文档向量。
构建上下文：将检索到的相关文档文本组合起来，作为额外的上下文信息。
组装提示：将原始查询与检索到的上下文信息结合，形成一个新的、信息更丰富的提示词，输入给大语言模型。

# 1. 嵌入查询
query_embedding = embedder.encode([user_query])

# 2. 执行检索，获取最相似的3个文档
k = 3
distances, indices = index.search(query_embedding, k)

# 3. 构建上下文
retrieved_docs = [documents[i] for i in indices[0]]
context = "\n\n".join(retrieved_docs)

# 4. 组装增强提示
enhanced_prompt = f"基于以下信息回答问题：\n{context}\n\n问题：{user_query}\n答案："

最后，我们将这个增强后的提示词输入给一个文本生成模型，让它基于检索到的真实信息生成最终的回答。

from transformers import pipeline

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/coursera-genai-llm/img/e0f9b3ae39b8c8d4de898f881362c5f0_1.png)

# 加载文本生成管道
generator = pipeline('text-generation', model='gpt2')
# 使用增强提示生成回答
response = generator(enhanced_prompt, max_length=200, do_sample=True)[0]['generated_text']

本节课中我们一起学习了如何将检索机制融入大语言模型流程。通过安装必要的库、为文档创建向量嵌入、建立高效索引、处理查询并构建增强提示，最终引导模型生成基于真实信息的回答。这项强大的技术能显著提升模型回答的准确性和相关性，是构建可靠AI应用的关键步骤之一。

019：提示大语言模型实现结构化输出与函数模拟 🧠

在本节课中，我们将学习如何通过特定的提示（Prompt）引导大语言模型，使其输出结构化的数据（如JSON、XML格式）并模拟执行函数任务。掌握这些技巧，可以让你更精确地控制模型的输出，提升交互的可靠性和实用性。

上一节我们了解了提示的基本概念，本节中我们来看看如何引导模型生成结构化输出。

首先，理解如何提示模型生成结构化输出（例如JSON格式）至关重要。以下代码展示了如何引导模型生成常规响应和结构化响应。

# 常规提示示例
prompt_regular = "请告诉我关于《霍比特人》这本书的信息。"
# 结构化提示示例
prompt_structured = "请以JSON格式提供《霍比特人》的信息，包含以下字段：title, author, year, genre。"

常规响应会提供关于《霍比特人》的故事和角色等详细信息。而结构化响应则会以JSON格式返回相同的信息，其结构如下：

{
  "title": "霍比特人",
  "author": "J.R.R. 托尔金",
  "year": 1937,
  "genre": "奇幻小说"
}

接下来，让我们学习如何创建专门用于请求特定格式（如JSON或XML）输出的结构化提示。

以下是请求JSON和XML格式输出的提示示例：

JSON格式请求：“请将以下数据以JSON格式返回：书名、作者、出版年份。”
XML格式请求：“请将用户信息组织成XML格式，包含<name>、<email>和<id>标签。”

在引导模型模拟函数时，我们可以让它扮演特定角色来执行任务。例如，让AI模拟一个计算器。

以下是一个模拟简单计算任务的提示：

prompt_calculator = "你是一个计算器。请计算：15乘以8加上20等于多少？只返回最终数字结果。"

为确保模型响应符合我们要求的格式，对响应进行验证是必不可少的一步。

以下代码演示了如何检查AI的响应是否为有效的JSON，并是否符合我们预期的精确格式：

import json

def validate_json_response(response):
    try:
        data = json.loads(response)
        # 检查是否包含预期的字段
        required_fields = {"title", "author", "year", "genre"}
        if all(field in data for field in required_fields):
            return True, data
        else:
            return False, "响应缺少必要字段。"
    except json.JSONDecodeError:
        return False, "响应不是有效的JSON格式。"

验证成功的输出表明请求的格式被正确遵循。

我们可以利用此方法模拟更复杂的任务，例如计算购物清单总额。

以下提示要求模型扮演购物计算器，并遵循特定的计算规则：

“你是一个购物计算器。我有一个购物清单：苹果3斤（单价5元），香蕉2把（单价4元），牛奶1盒（单价10元）。请计算总价，并考虑如果总价超过30元，打9折。最后返回一个JSON对象，包含items（列表）、subtotal（小计）、discount_applied（是否应用折扣）、total（总计）字段。”

最后，让我们创建一个结合了以上所有知识的智能助手。

以下代码展示了如何创建一个能执行任务并验证响应的智能助手：

def smart_assistant(task_prompt, expected_format="json"):
    # 1. 向大语言模型发送组合了格式要求的提示
    full_prompt = f"{task_prompt}\n\n请务必以{expected_format.upper()}格式返回结果。"
    # 2. 获取模型响应（此处为模拟）
    llm_response = get_llm_response(full_prompt)
    # 3. 根据预期格式验证响应
    if expected_format.lower() == "json":
        is_valid, result = validate_json_response(llm_response)
        if is_valid:
            return result
        else:
            return {"error": result}
    # 可以扩展其他格式（如XML）的验证
    # elif expected_format.lower() == "xml":
    #     ... 验证XML ...

本节课中我们一起学习了如何通过结构化提示引导大语言模型生成JSON等格式的输出，如何让其模拟计算器等函数角色，以及如何验证响应的正确性。通过使用结构化提示和函数模拟，你可以显著增强与大语言模型的交互效果，确保输出结果的准确性和可靠性，从而构建出更强大、更可控的AI应用。

生成式人工智能与大语言模型：P20-03-03-02：使用MLflow与Streamlit云部署大语言模型 🚀

在本节课中，我们将学习如何利用MLflow和Streamlit Cloud，将我们训练好的AI模型部署成一个可供他人使用的Web应用。整个过程就像为你的AI模型搭建一个网站，让用户可以通过简单的界面与之交互。

准备工作：认识我们的工具 🛠️

在开始构建之前，我们需要了解两个核心工具。

MLflow：这是一个用于管理机器学习生命周期的平台。它可以帮助我们以标准化的格式打包、记录和部署模型，确保模型在不同环境中的一致性。
Streamlit：这是一个用于快速创建数据科学Web应用的Python库。它允许我们用简单的Python脚本构建交互式界面，无需前端开发知识。

可以理解为，MLflow负责将我们的模型“打包”好，而Streamlit则负责为这个“包裹”设计一个漂亮的“展示窗口”和“操作面板”。

第一步：使用MLflow打包模型 📦

上一节我们介绍了部署所需的工具，本节中我们来看看如何具体准备模型。我们将使用Hugging Face Transformers库中的模型，并通过MLflow进行封装。

核心步骤是创建一个自定义的MLflow模型类，它定义了模型如何被加载和进行预测。

import mlflow
import transformers

# 定义一个自定义的MLflow Python模型类
class HuggingFaceModel(mlflow.pyfunc.PythonModel):
    def load_context(self, context):
        # 从保存的路径加载模型和分词器
        self.model = transformers.AutoModelForCausalLM.from_pretrained(context.artifacts["model_path"])
        self.tokenizer = transformers.AutoTokenizer.from_pretrained(context.artifacts["model_path"])

    def predict(self, context, model_input):
        # 定义生成文本的预测逻辑
        inputs = self.tokenizer(model_input["prompt"].tolist(), return_tensors="pt", padding=True)
        outputs = self.model.generate(**inputs, max_length=50)
        return self.tokenizer.batch_decode(outputs, skip_special_tokens=True)

接下来，我们需要将这个模型类与具体的模型文件（如从Hugging Face下载的模型）一起，保存为MLflow模型格式。

# 指定模型在Hugging Face上的名称或本地路径
model_name = "gpt2"

# 使用MLflow记录并保存模型
with mlflow.start_run():
    # 记录模型为PyFunc格式
    mlflow.pyfunc.log_model(
        artifact_path="model",
        python_model=HuggingFaceModel(),
        artifacts={"model_path": model_name},
        registered_model_name="MyChatGPT"
    )

执行以上代码后，模型会被打包并记录到MLflow的跟踪服务器中，为后续部署做好准备。

第二步：使用Streamlit构建Web界面 🖥️

模型打包完成后，我们需要为用户创建一个访问界面。Streamlit让这一步变得非常简单。

以下是构建一个简易聊天界面的核心代码。我们创建一个标题、一个文本输入框和一个触发生成的按钮。

import streamlit as st
import mlflow.pyfunc

# 设置页面标题
st.title("🤖 我的AI聊天助手")

# 创建一个文本输入框，供用户输入问题
prompt = st.text_input("请输入您的问题：", "你好，AI！")

# 创建一个按钮，当点击时生成回复
if st.button("生成回复"):
    # 加载之前用MLflow保存的模型
    model = mlflow.pyfunc.load_model('models:/MyChatGPT/Production')
    # 准备输入数据
    input_data = {"prompt": [prompt]}
    # 进行预测
    result = model.predict(input_data)
    # 显示结果
    st.write("AI回复：", result[0])

这段代码构建了一个最基础的交互流程：用户输入（st.text_input） -> 触发处理（st.button） -> 调用模型（model.predict） -> 显示结果（st.write）。

第三步：部署到Streamlit Cloud ☁️

应用构建好后，最后的步骤就是将其分享给全世界。我们需要将代码上传到GitHub仓库，然后在Streamlit Cloud上部署。

准备部署文件：确保你的项目包含以下两个核心文件：
- app.py：包含上述Streamlit应用代码的主文件。
- requirements.txt：列出所有依赖的Python包，例如 streamlit, mlflow, transformers。
执行部署命令：在Streamlit Cloud的界面中，连接你的GitHub仓库，并指定主文件路径（例如 app.py）。平台会自动安装依赖并启动应用。

完成部署后，Streamlit Cloud会提供一个公开的URL，任何人都可以通过这个链接访问你的AI聊天助手。

总结 📝

本节课中我们一起学习了将大语言模型从开发环境部署到云端的完整流程。

模型管理：我们使用MLflow将Hugging Face模型封装成标准化的、可服务的格式。
界面构建：我们利用Streamlit快速创建了一个包含输入、按钮和显示区域的Web应用界面。
云部署：最后，我们通过Streamlit Cloud将应用发布到互联网，实现了模型的共享与公开访问。

通过这三个步骤，你可以将任何AI项目转化为一个可交互的在线服务，极大地提升了模型的实际应用价值和可访问性。

021：使用OpenAI函数调用或工具仿真模拟AI代理 🧠🤖

在本节课中，我们将学习如何创建能够自主决策并使用工具的AI代理。我们将通过一个简单的模拟，为AI配备“工具箱”，并教会它如何理解问题、分解步骤并选择合适的工具来完成任务。

上一节我们介绍了AI代理的基本概念，本节中我们来看看如何具体实现一个能够使用工具的AI代理。首先，我们需要为AI助手设置好它可以使用的工具。

以下是创建AI代理工具的两个核心步骤：

创建计算器工具：我们为AI创建一个工具，使其能够执行数字相加的运算。
创建决策制定器工具：我们为AI创建另一个工具，使其能够根据条件选择要执行的动作。

这就像为我们的AI配备了一个包含多种专业工具的工具箱，让它有能力处理不同类型的问题。

接下来，我们需要教会AI如何理解它所拥有的工具。这个过程包括：

识别可用工具：让AI知晓“计算器”和“决策制定器”的存在及其功能。
分解问题步骤：指导AI将复杂问题拆解为一系列可执行的子任务。
选择合适工具：训练AI根据每个子任务的需求，从工具箱中选择最恰当的工具。

现在，让我们观察这个AI代理是如何工作的。其工作流程遵循一个清晰的逻辑链：

读取问题：AI首先接收并理解用户提出的问题。
选择工具：AI根据对问题的分析，决定使用哪个工具。
解决问题：AI调用选定的工具执行操作，并生成最终答案。

整个过程就像一个聪明的助手在严格遵循指令，逐步完成任务。

本节课中我们一起学习了如何创建能够使用工具并做出决策的AI代理。关键在于为AI提供清晰的指令和有用的工具。通过这种方式，AI代理能够帮助我们解决各种各样的问题。

022：为何扩散模型成为高质量图像生成的首选方法 🎨

在本节课中，我们将要学习扩散模型（Diffusion Models）为何能在图像生成领域脱颖而出，成为高质量图像生成的首选方法。我们将探讨其相较于传统方法的优势，以及它在不同行业中的应用。

想象一下，能够创造出与我们周围世界一样多样和复杂的、令人惊叹的真实感图像。这就是扩散模型的力量。它是一种图像生成领域的革命性方法，将传统的生成对抗网络（GANs）和变分自编码器（VAEs）等方法远远抛在身后。

那么，是什么让扩散模型如此突出？让我们来详细分析一下。

稳定性与精确性 ✨

扩散模型的魔力在于其稳定性和精确性。与生成对抗网络（GANs）不同，后者常常难以产生稳定的结果，而扩散模型提供了一个一致的框架。它确保生成的每一张图像都保持高保真度和真实感。

你是否曾使用过照片应用将自拍照转换成艺术作品？这背后就是扩散模型在默默工作。它为你提供更清晰、更生动的转换效果，避免了其他方法有时会出现的随机性问题。

可靠性与广泛应用 🌍

扩散模型的优势不仅在于生成一张好图像，更在于其在无数次渲染中的可靠性。在媒体和娱乐等行业，对逼真图形的需求是持续不断的，扩散模型正在重塑这些领域的格局。它们带来了前所未有的控制力和多样性，使其成为从超写实电影视觉效果到互动游戏环境等一切内容创作的理想选择。

上一节我们介绍了扩散模型的稳定性与可靠性，本节中我们来看看其影响范围。

扩散模型的影响不止于娱乐领域。以医疗保健为例，精确的成像技术可以挽救生命。扩散模型增强了医学成像技术，通过生成能更清晰揭示人体解剖结构和健康状况的高质量图像，潜在地改善了诊断水平。

为何需要关注扩散模型？ 🚀

那么，你为什么应该关注扩散模型？因为它们不仅仅是人工智能工具箱中的又一个工具。它们是一扇通往创新的大门。无论你是一位有抱负的艺术家、游戏开发者还是医疗保健专业人士，理解扩散模型都能为你所在的领域解锁新的潜力。在一个快速发展的世界中，站在技术前沿至关重要。

以下是拥抱扩散模型带来的核心益处：

掌握最新进展：它使你具备了解最新技术进步的知识。
赋能行业领导：它赋予你在自身行业中引领潮流的能力。

因此，请抓住这个机会来探索和掌握这项尖端技术。人工智能驱动的图像生成的未来是光明的，而掌握了扩散模型，你就已经走在了时代的前沿。

总结 📝

本节课中我们一起学习了扩散模型成为高质量图像生成首选方法的原因。我们了解到，其稳定、精确的生成框架克服了传统方法（如GANs）的不稳定性问题，确保了高保真度的输出。同时，其可靠的性能和广泛的应用潜力——从娱乐产业的视觉效果到医疗领域的诊断辅助——使其成为推动多行业创新的关键工具。理解并掌握扩散模型，意味着掌握了当前图像生成领域最前沿和强大的技术之一。

023：基于稳定扩散的文本到图像生成 🖼️

在本节课中，我们将学习如何使用稳定扩散模型，根据文本描述生成图像。这是一个强大的工具，能够将文字转化为视觉内容。

环境设置 ⚙️

首先，我们需要设置运行环境，安装稳定扩散模型所需的软件包。

以下是安装所需依赖的代码：

# 安装必要的Python包
!pip install diffusers transformers accelerate torch

从文本生成图像 ✍️➡️🖼️

上一节我们完成了环境设置，本节中我们来看看如何使用稳定扩散模型，根据文本提示生成图像。我们将通过调整几个关键参数来定制输出结果。

以下是生成图像的核心步骤：

导入模型与管道：从diffusers库中加载预训练的稳定扩散模型。
定义文本提示：输入一个描述你希望生成图像的文本。
设置生成参数：
- 推理步数：num_inference_steps，控制图像生成的精细度，步数越多，细节可能越丰富，但耗时也更长。
- 引导尺度：guidance_scale，控制生成图像与文本提示的贴合程度，值越高，图像越遵循提示。
- 随机种子：seed，用于控制生成过程的随机性，使用相同的种子可以复现相同的结果。
执行生成：调用模型管道，传入提示和参数，生成图像。

以下是生成图像的核心代码示例：

from diffusers import StableDiffusionPipeline
import torch

# 1. 加载预训练模型管道
pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16)
pipe = pipe.to("cuda") # 如果有GPU，将模型移至GPU以加速

# 2. 定义文本提示
prompt = "一只在太空中穿着宇航服的柴犬"

# 3. 设置参数并生成图像
image = pipe(
    prompt,
    num_inference_steps=50,   # 推理步数
    guidance_scale=7.5,       # 引导尺度
    generator=torch.Generator("cuda").manual_seed(42) # 随机种子
).images[0]

显示与保存结果 💾

图像生成完成后，我们需要将其显示出来并保存到本地，以便后续查看或使用。

以下是显示和保存图像的步骤：

显示图像：使用图像处理库（如PIL或matplotlib）在笔记本或界面中展示生成的图片。
保存图像：将图像对象保存为常见的图片文件格式，如PNG或JPG。

以下是相关代码：

from PIL import Image

# 显示图像
image.show()

# 保存图像到文件
image.save("generated_astronaut_dog.png")

总结 📝

本节课中我们一起学习了基于稳定扩散的文本到图像生成全流程。

我们首先设置了必要的软件环境，然后深入探讨了如何使用稳定扩散模型，通过调整推理步数、引导尺度和随机种子等关键参数，从文本提示生成定制化的图像。最后，我们掌握了如何显示并保存生成的结果。

通过掌握这些步骤，你已经能够利用文本提示创建出细节丰富且高度定制化的图像。

生成式人工智能与大语言模型：P24：探索扩散模型中的潜在空间

在本节课中，我们将学习如何探索扩散模型中的潜在空间。通过调整潜在变量，我们可以生成多样化的图像。我们将从环境设置开始，然后通过改变随机种子来探索不同的输出，最后学习如何通过微调潜在向量来优化生成的图像。

上一节我们介绍了扩散模型的基本概念，本节中我们来看看如何实际操作以探索其潜在空间。

首先，我们需要设置编程环境并加载必要的库和模型。

以下是设置步骤：

导入 torch 和 diffusers 库。
从 diffusers 库加载预训练的 StableDiffusionPipeline 模型。
将模型设置为使用 GPU 以加速计算（如果可用）。

import torch
from diffusers import StableDiffusionPipeline

# 加载预训练的Stable Diffusion模型
pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
pipe = pipe.to("cuda" if torch.cuda.is_available() else "cpu")

环境准备就绪后，接下来我们通过调整潜在变量来生成不同的图像。核心方法是使用不同的随机种子。

以下是操作步骤：

定义一个文本提示词，例如 "a scenic mountain landscape at sunset"。
使用 torch.manual_seed() 设置不同的随机种子。
调用管道并传入提示词以生成图像。

prompt = "a scenic mountain landscape at sunset"

# 使用种子 42 生成图像
torch.manual_seed(42)
image1 = pipe(prompt).images[0]

# 使用种子 123 生成另一张图像
torch.manual_seed(123)
image2 = pipe(prompt).images[0]

通过改变种子，我们得到了基础的变化。现在，我们学习如何对其中一张生成的图像进行更精细的调整，即通过扰动其潜在向量。

以下是微调步骤：

首先，使用一个固定种子生成初始图像并获取其对应的潜在向量。
然后，向这个潜在向量添加一个微小的随机噪声（扰动）。
最后，使用扰动后的潜在向量再次生成图像，观察变化。

# 生成初始潜在向量
torch.manual_seed(42)
latents = torch.randn((1, 4, 64, 64), device=pipe.device)

# 生成初始图像
image_initial = pipe(prompt, latents=latents).images[0]

# 扰动潜在向量
perturbation = 0.1 * torch.randn_like(latents)
latents_perturbed = latents + perturbation

# 使用扰动后的潜在向量生成图像
image_perturbed = pipe(prompt, latents=latents_perturbed).images[0]

本节课中我们一起学习了探索扩散模型潜在空间的完整流程。我们首先设置了必要的环境并加载了模型。接着，通过调整随机种子生成了不同的图像，直观感受了潜在空间的多样性。最后，我们通过向潜在向量添加微小扰动，实现了对生成图像的精细微调。掌握这些步骤后，你就能利用扩散模型创造出多样且可定制的视觉内容。

025：输出结果解析 🧠

在本节课中，我们将探索三种强大的生成式模型：变分自编码器、生成对抗网络和扩散模型。每种模型都有其独特的应用场景。我们将通过具体的代码示例和结果可视化，来理解它们的工作原理和输出特点。

变分自编码器 (VAEs) 🎨

变分自编码器擅长生成与训练集相似的新数据。我们将使用心电图数据来演示其应用。

首先，我们下载并配对ECG数据，对特征进行归一化处理，并分离标签。

接下来，定义VAE的架构。它包括一个用于压缩数据的编码器和一个用于重建数据的解码器。

# VAE架构示例
encoder = Encoder(input_dim, latent_dim)
decoder = Decoder(latent_dim, output_dim)

现在，我们使用ECG数据训练VAE模型。

训练完成后，在测试数据上评估模型的性能，观察其重建ECG信号的效果。该模型预测正确的比例约为59%。

尽管其ROC AUC分数高达0.95，但模型更擅长识别正常情况（精确率0.50），而对异常情况的识别精确率更高（0.90）。然而，它在找出所有异常情况方面存在困难（召回率0.33）。

最后，我们通过可视化原始和重建的ECG信号来理解模型的性能。

该图表显示，蓝色线条代表原始ECG信号，橙色线条代表重建的信号。两条线之间的巨大差异表明模型难以准确重建原始信号。

生成对抗网络 (GANs) 🖼️

上一节我们介绍了VAE，本节中我们来看看生成对抗网络。GANs用于生成与训练数据相似的新数据点。

我们将生成一个二维不平衡数据集来演示GAN的用例。该数据集包含105个少数类样本和895个多数类样本，这显示了两个类别之间样本数量的不平衡。

以下是定义GAN架构的步骤：

# GAN架构示例
generator = Generator(latent_dim, output_dim)
discriminator = Discriminator(input_dim)

现在，我们使用少数类数据训练生成器。

生成器训练完成后，生成合成的少数类观测数据。

最后，可视化包含合成少数类观测的增强数据集。

该图表显示了三个点群：蓝点代表多数类，橙点代表原始少数类，绿点代表GAN生成的合成少数类样本。绿点与橙点很好地混合在一起，表明GAN创建了与原始样本相似的新少数类样本，有助于平衡数据集。

扩散模型 ⏳

接下来，我们探索扩散模型，它用于模拟数据随时间的变化。

我们将模拟患者轨迹数据来演示扩散模型的用例。

首先，为扩散模型准备噪声调度。

然后，定义去噪扩散模型的架构。

# 扩散模型架构示例
model = DenoisingDiffusionModel(noise_schedule)

接着，向数据添加噪声并训练模型。

现在，使用反向扩散采样未来的患者结果。

最后，可视化并比较真实与生成的患者结果分布。

该图表显示了两组患者数据：蓝色代表真实数据，橙色代表生成数据。真实数据在中间形成了一个较大的隆起，而生成数据则是其下方一个较小的山丘。这表明模型正在生成新数据，但其多样性不如真实数据。

总结 📝

本节课中我们一起学习了变分自编码器、生成对抗网络和扩散模型。它们是用于生成和分析数据的强大工具。

通过理解这些模型的工作原理并可视化其输出，我们可以看到它们的优势和需要改进的领域。识别原始数据与生成数据之间的差异有助于改进这些模型以获得更好的性能。

生成式人工智能与大语言模型：26：从文本到万物：多模态革命

在本节课中，我们将要学习多模态人工智能的基本概念，了解它如何整合文本、图像和音频等多种数据形式，以创造更智能、更自然的交互系统。

你是否曾希望计算机不仅能理解文字，还能同时理解图片、声音等一切信息。欢迎来到多模态人工智能的世界，在这里，从文本到声音和图像的一切信息被结合起来，以创建对复杂数据的无缝理解。

多模态人工智能模型通过整合文本、图像和音频，正在改变我们处理信息的方式，它模仿了人类如何使用所有感官来感知世界。想象一个模型，它能同时看到一张狗在公园的图片、听到一声犬吠，并阅读一段关于它一天的故事。这种革命性的方法使人工智能能够获得更丰富的理解和上下文，从而改变搜索引擎、客户服务和辅助工具等领域的交互方式。

在现实世界中，多模态人工智能正掀起巨大波澜。以在线学习平台为例，这些模型可以分析学生的书面问题、解读图表，甚至聆听讲座，从而提供个性化的反馈和支持。电子商务是另一个前沿领域，得益于能够无缝处理视觉、文本和音频输入的能力，虚拟试衣间和智能购物助手现在变得比以往任何时候都更加直观。

然而，开发这些模型并非没有挑战。与专注于单一数据类型的传统单模态系统不同，多模态模型必须统一各种数据类型，这绝非易事。它需要复杂的数据表示对齐和创新的训练技术。但这一切努力是值得的。解决这些挑战能够创造出不仅更智能，而且交互起来更自然的系统。

随着我们站在这场多模态革命的前沿，可能性是无穷无尽的。从丰富虚拟体验到扩展我们对人工智能能力的理解，多模态技术正在开启一个充满机遇的新世界。让我们拥抱这一变革，探索这些强大的工具如何重塑我们与技术以及彼此互动的方式。

本节课中我们一起学习了多模态人工智能的核心思想，它通过融合多种感官数据，旨在构建更全面、更类人的智能系统。请继续探索，因为下一次创新就在眼前。

027：多模态模型如何整合文本、图像与音频 🧠

在本节课中，我们将学习多模态模型如何整合文本、图像与音频数据，以执行复杂的任务。我们将通过实际操作，了解如何设置环境、加载模型，并利用模型处理多模态输入。

上一节我们介绍了多模态模型的基本概念，本节中我们来看看如何具体设置环境并运行一个多模态模型。

首先，我们需要设置Python环境并安装必要的库。以下是需要安装的核心包：

!pip install torch transformers diffusers -q

-q 参数用于抑制不必要的安装输出，确保在协作环境中的兼容性。

环境设置完成后，我们将加载一个具体的多模态模型。这里我们使用 CLIP 模型及其对应的处理器。

from transformers import CLIPProcessor, CLIPModel

model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")

CLIP模型和处理器能够同时处理文本和图像输入。

现在，我们将结合文本和图像输入来执行一个多模态任务。以下是具体步骤：

准备输入：我们定义一段文本描述和一张对应的图像。
处理输入：使用CLIP处理器将文本和图像转换为模型可理解的格式。
模型推理：将处理后的输入传递给模型，获取文本与图像之间的相似度分数。

# 示例：文本和图像输入
text = ["a photo of a cat"]
image = Image.open("path_to_cat_image.jpg") # 请替换为实际图像路径

# 使用处理器处理输入
inputs = processor(text=text, images=image, return_tensors="pt", padding=True)

# 模型推理
outputs = model(**inputs)
logits_per_image = outputs.logits_per_image # 图像到文本的相似度
probs = logits_per_image.softmax(dim=1) # 转换为概率

相似度概率张量 probs 显示了一个值为 1.0，这表明模型确信该文本描述与图像内容完全匹配。

通过本节课的学习，我们了解到像CLIP这样的多模态模型，能够通过整合不同类型的数据（如文本和图像）来执行复杂任务。通过设置和使用这些模型，我们可以解锁AI在理解和解释周围世界方面的全新可能性。

总结：本节课我们一起学习了多模态模型的基本工作流程，包括环境设置、模型加载以及如何结合文本与图像输入进行推理，从而评估它们之间的关联性。

生成式人工智能与大语言模型：P28：使用BLIP为图像生成字幕

在本节课中，我们将学习如何使用BLIP模型为图像自动生成描述性文字，即图像字幕。我们将从环境配置开始，逐步完成加载模型、处理图像到最终生成字幕的全过程。

首先，我们需要准备好运行代码所需的环境。我们将安装几个关键的Python库。

以下是需要安装的库：

transformers：Hugging Face提供的库，用于加载和使用预训练模型。
diffusers：同样来自Hugging Face，专注于扩散模型，但安装它有助于确保环境兼容性。
pillow：Python图像处理库，用于加载和操作图像文件。

上一节我们配置好了环境，本节中我们来看看如何加载预训练的BLIP模型。我们将使用transformers库提供的便捷接口。

核心步骤是使用BlipProcessor和BlipForConditionalGeneration这两个类。BlipProcessor负责将图像和文本处理成模型能理解的格式，而BlipForConditionalGeneration则是用于生成字幕的模型本身。

现在我们已经加载了模型和处理器，接下来需要准备一张待处理的图像。我们将使用PIL（即pillow库）来加载图像，并用上一步初始化的处理器对其进行预处理。

这个过程会将图像转换为模型所需的张量格式，为生成字幕做好准备。

经过前面的步骤，图像已处理完毕，模型也已就绪。最后，我们使用BLIP模型来为图像生成描述性文字。

生成字幕的核心代码如下：

# 使用模型生成字幕
outputs = model.generate(**inputs)
# 使用处理器将生成的token解码为可读文本
caption = processor.decode(outputs[0]， skip_special_tokens=True)

模型接收处理后的图像输入，通过其内部机制生成一系列代表单词的标记（tokens），最后再将这些标记解码成我们能够理解的自然语言句子。

本节课中我们一起学习了使用BLIP模型为图像生成字幕的完整流程。我们首先配置环境并安装必要库，然后加载了预训练的BLIP处理器和模型，接着使用PIL库加载图像并用处理器进行预处理，最后调用模型生成并解码出最终的字幕。这个强大的工具能够轻松为视觉内容提供详细的描述，从而增强应用的易用性和自动化程度。😊

生成式人工智能与大语言模型：P29：基于CLIP的零样本图像分类

在本节课中，我们将学习如何使用CLIP模型进行零样本图像分类。CLIP是一个强大的多模态模型，能够同时理解文本和图像内容，从而无需针对特定任务进行训练即可完成分类。

环境设置

首先，我们需要设置运行环境。我们将安装必要的库，包括torch、transformers和pillow。为了确保在Colab等环境中的兼容性，我们会抑制不必要的输出。

!pip install torch transformers pillow -q

加载CLIP模型与处理器

上一节我们完成了环境设置，本节中我们来看看如何加载模型。我们将加载CLIP模型及其对应的处理器。这个处理器能够同时处理文本和图像输入，为零样本分类做好准备。

from transformers import CLIPProcessor, CLIPModel

model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")

准备图像与文本标签

现在我们已经加载了模型，接下来需要准备输入数据。我们将使用Pillow库加载一张待分类的图片，并定义一组文本标签作为候选的分类类别。

from PIL import Image

# 加载图像
image = Image.open("path_to_your_image.jpg")

# 定义分类标签
labels = ["a photo of a cat", "a photo of a dog", "a photo of a bird"]

执行零样本分类

数据准备就绪后，我们就可以执行分类了。以下是使用CLIP进行零样本图像分类的核心步骤。

首先，使用处理器同时编码图像和文本。

inputs = processor(text=labels, images=image, return_tensors="pt", padding=True)

接着，将编码后的输入传递给模型，获取图像与每段文本的相似度分数。

outputs = model(**inputs)
logits_per_image = outputs.logits_per_image

最后，选择相似度最高的文本标签作为预测结果。

probs = logits_per_image.softmax(dim=1)
predicted_label_idx = probs.argmax().item()
predicted_label = labels[predicted_label_idx]
print(f"Predicted label: {predicted_label}")

总结

本节课中我们一起学习了如何使用CLIP进行零样本图像分类。我们首先设置了环境并加载了模型，然后准备了图像和文本标签，最后通过计算图像与文本的相似度完成了分类。CLIP这种理解多模态信息的能力，使其在无需任务特定训练的情况下，也能灵活应用于广泛的场景。

生成式人工智能与大语言模型：P30-05_03_02：使用Whisper将语音转录为文本 🎤

在本节课中，我们将学习如何使用OpenAI的Whisper模型，将音频文件中的语音内容自动转录为准确的文本。这是一个强大的工具，可以轻松地将录音转换为文字稿。

想象一下，有一个模型能够毫不费力地将音频录音转换为精确的文本转录稿。Whisper正是这样一个模型，它能够准确地将音频转换为文本，非常适合转录和提升可访问性等任务。

上一节我们介绍了大语言模型的基本概念，本节中我们来看看如何利用Whisper模型处理音频数据。

首先，我们需要设置运行环境。以下是需要安装的必要库：

torch
transformers
librosa

安装时，我们可以选择抑制不必要的输出信息，保持界面整洁。

接下来，我们将加载预训练的Whisper模型及其对应的处理器。处理器将帮助我们准备音频数据，以便模型能够准确地进行转录。

加载音频文件后，我们需要对其进行预处理。我们将使用torchaudio库来读取音频，并使用Whisper处理器来提取和标准化音频特征。

现在，我们可以使用加载好的Whisper模型来生成转录文本了。生成完成后，我们将打印出转录出的文字内容。

最后，我们需要评估转录的输出结果。为了获得更好的效果，我们可以通过调整模型的参数来定制转录过程，例如设置语言或启用时间戳等。

本节课中，我们一起学习了如何使用Whisper将语音转录为文本。这个强大的模型能够准确地将音频转换为文本，使其成为转录工作和提升信息可访问性的理想工具。

031：利用文本转语音技术生成语音 🎤

在本节课中，我们将学习如何利用文本转语音技术，将文字内容转换为语音。我们将依次完成环境搭建、模型加载与配置、语音合成以及音频输出定制等步骤。

环境搭建

首先，我们需要为文本转语音任务安装必要的软件包。

以下是需要执行的安装命令：

pip install TTS

加载与配置TTS模型

上一节我们完成了环境搭建，本节中我们来看看如何加载和配置核心的TTS模型。

我们将加载两个关键模型：Spee T5声学模型和HiFi-GAN声码器。它们共同作用，以生成高质量的语音。

以下是加载模型的代码：

from TTS.api import TTS

# 初始化TTS模型
tts = TTS(model_name="tts_models/en/ljspeech/speedy-speech-wn", progress_bar=False, gpu=False)

合成语音

现在我们已经加载了模型，接下来就可以将一段给定的文本合成为语音。

我们将输入文本，并指定一个文件路径来保存生成的音频。

以下是合成并保存语音的代码：

# 要转换的文本
text = "Welcome back. Today we're going to explore how to generate speech from text."

# 合成语音并保存为WAV文件
tts.tts_to_file(text=text, file_path="output.wav")

定制音频输出

除了基础的语音合成，我们还可以通过调整生成参数来定制音频的输出效果。

以下是可调整的部分关键参数：

max_length：控制生成语音的最大长度。
num_beams：在束搜索中使用的束数量，影响生成质量。

我们可以通过修改这些参数来优化语音的流畅度和自然度。

在本节课中，我们一起学习了文本转语音的完整流程。我们从环境搭建开始，接着加载并配置了Spee T5和HiFi-GAN模型，然后将文本合成为语音并保存，最后还探讨了如何通过调整参数来定制音频输出。理解这些步骤后，你就能利用先进的TTS模型从文本生成高质量的语音了。

posted @ 2026-03-26 01:39 绝不原创的飞龙阅读(2) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

Coursera-生成式人工智能与大模型笔记-全-

Coursera 生成式人工智能与大模型笔记（全）

002：训练二维斑点上的判别模型逻辑回归 📊

概述

创建模拟数据 🎯

数据预处理与加载 🔄

构建逻辑回归模型 🧠

训练模型 🏋️

可视化决策边界 📈

总结

生成对抗网络：一场创造与识别的游戏 🎭

变分自编码器：学习压缩与重建 🧩

序列模型：预测下一个元素 📝

总结 📚

准备工作：连接LLM服务

任务一：文本摘要

任务二：代码解释与生成

任务三：语言翻译

任务四：分步问题解决

总结

010：Transformer为何至关重要？🤖

概述：Transformer的革命性影响

Transformer的核心机制：自注意力

Transformer的实际应用

Transformer的重要性

总结：拥抱Transformer的力量

011：循环神经网络的问题与Transformer的解决方案 🚀

从单车道到多车道高速公路 🛣️

Transformer的并行处理方案 🚗💨

位置编码：信息的GPS坐标 🗺️

构建完整的Transformer系统 🏗️

总结 📚

自注意力机制

准备关键矩阵

多头注意力机制

增强模型能力：前馈网络

构建Transformer块

总结

013：温度参数与Top-P采样

调整输出创造性：温度参数

精炼输出创造性：Top-P采样

总结

015：微调带来巨大成效 🎯

直接提示 ✍️

系统提示 🎭

小样本提示 📋

总结 📝

环境设置

加载预训练模型与分词器

准备数据集

配置微调过程

测试微调后的模型

总结

环境配置 🛠️

生成文档嵌入向量 📄

使用Faiss建立向量索引 🗂️

执行查询与检索匹配结果 🔎

总结 📝

019：提示大语言模型实现结构化输出与函数模拟 🧠

准备工作：认识我们的工具 🛠️

第一步：使用MLflow打包模型 📦

第二步：使用Streamlit构建Web界面 🖥️

第三步：部署到Streamlit Cloud ☁️

总结 📝

021：使用OpenAI函数调用或工具仿真模拟AI代理 🧠🤖

022：为何扩散模型成为高质量图像生成的首选方法 🎨

稳定性与精确性 ✨

可靠性与广泛应用 🌍

为何需要关注扩散模型？ 🚀

总结 📝

023：基于稳定扩散的文本到图像生成 🖼️

环境设置 ⚙️

从文本生成图像 ✍️➡️🖼️

显示与保存结果 💾

总结 📝

025：输出结果解析 🧠

变分自编码器 (VAEs) 🎨

生成对抗网络 (GANs) 🖼️