<a id="Header1_HeaderTitle" class="headermaintitle HeaderMainTitle" href="https://www.cnblogs.com/apachecn">龙哥盟

·发布于 Towards Data Science ·21 分钟阅读·2024 年 7 月 23 日

作者提供的图像 — SDXL

Andrej Karpathy 是人工智能（AI）领域的领军人物之一。他是 OpenAI 的创始成员之一，曾领导 Tesla 的 AI 团队，并继续活跃在 AI 社区的前沿。他最近发布了一段精彩的4 小时视频，讲解如何从零开始构建一个高质量的大型语言模型（LLM）。

在那个视频中，我们逐一讲解了训练大型语言模型（LLM）的所有主要部分，从编写架构代码到加速训练时间，再到调整超参数以获得更好的结果。这里包含了大量的知识，因此我希望通过逐行解析 Karpathy 创建的代码，进一步展开讲解其工作原理。本文将是我系列文章的一部分，内容将涵盖 Karpathy 视频的每个部分。

在第一部分中，我们专注于实现 GPT-2 的架构。尽管 GPT-2 在 2018 年由 OpenAI 开源，但它是用 TensorFlow 编写的，这比 PyTorch 更难调试。因此，我们将使用更常用的工具重新构建 GPT-2。仅凭我们今天要创建的代码，你就能创建自己的大型语言模型（LLM）！

让我们开始吧！

高级词汇

在我们开始之前，先来统一一下术语。虽然可能与其他来源的命名有所冲突，但我会尽量在这些博客文章中保持一致。

块大小 — 告诉我们 Transformer 可以处理输入长度中多少个位置。一旦超过这个限制，性能会下降，因为你必须进行循环（你可以在我的《长 RoPE 博客》中了解如何在不从头训练新模型的情况下扩展这一点）。

词汇表大小 — 告诉我们模型能够理解和使用多少个独特的标记。通常，研究人员发现，较大的词汇表大小使模型能够更精确地使用语言，并捕捉到更多细微的回应。

层 — 我们神经网络中的隐藏层的一部分。具体来说，这里指的是我们在下面的灰色框中重复进行计算的次数：

我们模型中的一层来自《Attention is All You Need》

嵌入 — 我们传递给模型的数据的向量表示。

多头注意力 — 我们不是只运行一次注意力，而是运行 n 次，然后将所有结果连接起来，得到最终结果。

让我们进入代码吧！

GPT 类及其参数

@dataclass
class GPTConfig:
    block_size : int = 1024
    vocab_size : int = 50257
    n_layer : int = 12
    n_head : int = 12
    n_embd : int = 768

首先，我们在 GPTConfig 类中设置了 5 个超参数。block_size与n_layer和n_head一样，看起来有些随意。换句话说，这些值是根据研究人员所观察到的最佳性能经验选择的。此外，我们为n_embd选择了 786，这是 GPT-2 论文中选定的值，我们决定进行模拟。

然而，vocab_size是基于我们将使用的tiktoken GPT-2 分词器设置的。GPT-2 分词器是通过使用字节对编码算法创建的（在这里阅读更多）。它从初始的词汇表（在我们的案例中为 256）开始，然后遍历训练数据，根据新词汇在训练集中的出现频率创建新的词汇。它不断重复这一过程，直到达到限制（在我们的案例中为 50,000）。最后，我们为内部使用预留了词汇（在我们的案例中为结束标记字符）。将这些值相加，我们得到 50,257。

class GPT(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.config = config

    # ...

设置好我们的配置后，我们创建了一个 GPT 类，它是 torch nn.Module类的一个实例。这个类是所有 PyTorch 神经网络的基类，因此通过使用这个类，我们可以访问 PyTorch 为这些类型的模型提供的所有优化。每个nn.Module都有一个forward函数，定义了模型在前向传播过程中发生的事情（稍后会详细讲解）。

我们首先运行基类中的超构造函数，然后将transformer对象创建为ModuleDict。这样做是因为它允许我们像操作对象一样索引transformer，这在我们想从 HuggingFace 加载权重时以及调试并快速浏览模型时都会非常有用。

class GPT(nn.Module):
    def __init__(self, config):
        # ...

        self.transformer = nn.ModuleDict(dict(
            wte = nn.Embedding(config.vocab_size, config.n_embd),
            wpe = nn.Embedding(config.block_size, config.n_embd),
            h = nn.ModuleList([Block(config) for _ in range(config.n_layer)]),
            ln_f = nn.LayerNorm(config.n_embd)
        ))

我们的transformer在这里有四个主要部分要加载：标记嵌入的权重（wte）、位置编码的权重（wpe）、隐藏层（h）和层归一化（ln_f）。这个设置大致遵循了《Attention is All You Need》中 Transformer 架构的解码器部分（输出嵌入 ~ wte，位置编码 ~ wte，隐藏层 ~ h）。一个关键的区别是，我们的架构中在所有隐藏层完成后增加了一个额外的归一化层ln_f。

解码器架构部分，见《Attention is All You Need》

wte和wpe都是嵌入，因此我们自然使用nn.Embedding类来表示它们。我们的隐藏层是 Transformer 中大部分逻辑所在的地方，所以我稍后会详细讲解。现在只需注意，我们正在创建一个Block对象的循环，以便拥有n.layer个它们。最后，我们使用内建的nn.LayerNorm来处理ln_f，它将根据下面的公式对我们的输出进行归一化（其中 x 和 y 分别是输入和输出，E[x]是均值，γ和β是可学习的权重）。

PyTorch 中层归一化的公式

class GPT(nn.Module):
    def __init__(self, config):
        # ...
        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)

        # weight sharing scheme
        self.transformer.wte.weight = self.lm_head.weight

        # initalize weights
        self.apply(self._init_weights)

接下来，我们设置网络的最后一层线性层，用于生成模型的 logits。在这里，我们将从模型的嵌入维度（768）映射到模型的词汇表大小（50,257）。这里的想法是，我们将隐藏状态扩展到映射到我们的词汇表，以便我们的解码器头可以使用每个词汇上的值来确定下一个标记应该是什么。

最后，在我们的构造函数中，我们进行了一个有趣的优化，其中我们告诉模型将分词器的权重与线性层的权重设为相同。这样做的原因是，我们希望线性层和分词器对标记有相同的理解（如果两个标记在输入模型时相似，那么这两个标记在模型输出时也应该是相似的）。最后，我们初始化模型的权重，以便可以开始训练。

class GPT(nn.Module):
# ...
    def forward(self, idx, targets=None):
        B, T = idx.size() 
        assert T <= self.config.block_size, f"maximum sequence length breached"
        pos = torch.arange(0, T, dtype=torch.long, device=idx.device)
        pos_emb = self.transformer.wpe(pos)
        tok_emb = self.transformer.wte(idx)

        x = tok_emb + pos_emb # hidden broadcast

        for block in self.transformer.h:
            x = block(x)
        x = self.transformer.ln_f(x)
        logits = self.lm_head(x)
        loss = None
        if targets is not None:
            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
        return logits, loss

我们的前向函数是我们详细描述模型在前向传播过程中行为的地方。我们首先验证我们的序列长度是否不大于我们配置的最大值（block_size）。一旦这点成立，我们创建一个值为 0 到 T-1 的张量（例如，如果 T=4，我们将得到 tensor([0, 1, 2, 3]），并通过位置嵌入权重运行它们。完成之后，我们将输入张量通过标记嵌入权重。

我们将token和位置嵌入结合成x，需要广播操作来将它们合并。由于tok_emb比pos_emb大（在我们的示例中是 50257 对 1024），因此x的维度将与tok_emb相同。x现在是我们的隐藏状态，我们将在隐藏层中通过 for 循环传递它。我们小心地在每次通过 Block 后更新x。

接下来，我们通过 LayerNormalization ln_f对x进行归一化，然后进行线性投影以获取预测下一个 token 所需的 logits。如果我们正在训练模型（通过targets参数来指示），我们将计算我们刚刚生成的 logits 与存储在targets变量中的真实标签之间的交叉熵。我们通过cross_entropy损失函数来实现这一点。为了正确执行，我们需要通过.view()将logits和target转换为正确的形状。当我们通过-1 传递时，我们让 pytorch 推断出正确的大小。

这个类还有一个函数是初始化函数，不过我们稍后会讲到初始化逻辑。现在，让我们深入了解 Block 逻辑，它将帮助我们实现多头注意力和 MLP。

Block 类

class Block(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.ln_1 = nn.LayerNorm(config.n_embd)
        self.attn = CausalSelfAttention(config)
        self.ln_2 = nn.LayerNorm(config.n_embd)
        self.mlp = MLP(config)
# ...

Block 被实例化为nn.Module，因此我们还在开始时调用了父类构造函数进行优化。接下来，我们按照《Attention is All You Need》论文中的计算设置相同的操作——2 个层归一化、一个注意力计算和通过 MLPs 的前馈层。

《Attention is All You Need》中的一个隐藏层

class Block(nn.Module):
# ...
    def forward(self, x):
        x = x + self.attn(self.ln_1(x))
        x = x + self.mlp(self.ln_2(x))
        return x

然后我们定义了forward函数，PyTorch 将在每次模型前向传递时调用它。请注意，这里我们做了与《Attention is All You Need》不同的事情。我们设置了层归一化，分别发生在注意力和前馈层之前。这是 GPT-2 论文中的一个重要见解，您可以看到，像这样做一些小的改变，能够带来很大的不同。注意，原始张量的加法仍然保留在相应的位置。这两个加法将在我们设置权重初始化函数时变得非常重要。

这个类是一个很好的抽象，它允许我们替换注意力机制的实现或选择另一种类型的前馈函数，而不需要大规模重构代码。

CausalSelfAttention 类

class CausalSelfAttention(nn.Module):
    def __init__(self, config):
        super().__init__()
        assert config.n_embd % config.n_head == 0
        self.c_attn = nn.Linear(config.n_embd, 3*config.n_embd)
        self.c_proj = nn.Linear(config.n_embd, config.n_embd)
        self.c_proj.NANOGPT_SCALE_INIT = 1
        self.n_head = config.n_head
        self.n_embd = config.n_embd
        self.register_buffer('bias', torch.tril(torch.ones(config.block_size, config.block_size))
                                    .view(1,1, config.block_size, config.block_size))
# ...

注意力是我们模型的一个重要部分，因此这里自然有很多配置项。我们使用断言语句作为调试工具，确保我们传递的配置维度是兼容的。接着，我们创建了一些辅助函数，帮助我们在进行自注意力时使用。首先，我们有c_attn和c_proj，它们是线性投影，将我们的隐藏状态转换为注意力计算所需的新维度。c_proj.NANOGPT_SCALE_INIT是我们在这里和 MLP 中设置的一个标志，帮助我们稍后的权重初始化（事实上，这个名字可以取任何名字）。

最后，我们告诉 torch 创建一个在训练过程中不会更新的缓冲区，称为bias。偏置将是一个尺寸为block_size x block_size的下三角矩阵，接着我们将其转换为尺寸为 1 x 1 x block_size x block_size的 4D 张量。1 x 1 的维度是为了能够在单个通道中批量计算这些数据。这个缓冲区将用于在我们的多头注意力中应用掩码。

class CausalSelfAttention(nn.Module):
# ...
    def forward(self, x):
        B, T, C = x.size() # batch size, sequence length, channels
        qkv = self.c_attn(x)
        q, k, v = qkv.split(self.n_embd, dim=2)
        # transpose is done for efficiency optimization
        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)

        att = (q @ k.transpose(-2,-1)) * (1.0 / math.sqrt(k.size(-1)))
        att = att.masked_fill(self.bias[:, :, :T, :T] == 0, float("-inf"))
        att = F.softmax(att, dim=-1)
        y = att @ v
        y = y.transpose(1,2).contiguous().view(B, T, C)

        y = self.c_proj(y)
        return y

接下来是注意力的实现，重点是使其在 torch 中具有高性能。逐行分析，我们首先找到输入张量 x 中的批量大小、序列长度和通道数。接着我们会调用之前的c_attn，将隐藏状态投影到所需的维度。然后，我们将结果分割成 3 个形状为(B, T, C)的张量（具体来说，一个用于查询，一个用于键，一个用于值）。

然后，我们调整 q、k 和 v 的维度，以便能够高效地进行多头注意力。通过将维度从(B, T, C)更改为(B, T, self.n_head, C // self.n_head)，我们将数据划分开来，让每个头（head）获得自己的独特数据进行操作。我们转置视图，以便将 T 变为第三维，将self.n_head变为第二维，从而更方便地将头部拼接起来。

来自“Attention is All You Need”的注意力公式

现在我们有了值，可以开始计算了。我们对查询（query）和键（key）进行矩阵乘法（确保将键转置，使其处于正确的方向），然后除以 k 的大小的平方根。完成此计算后，我们再应用来自寄存器的偏置，以确保未来的标记（tokens）的注意力数据不会影响当前的标记（因此我们只对时间和通道维度中大于 T 的标记应用掩码）。完成后，我们应用 softmax，仅通过某些信息进行传递。

一旦掩码被应用，我们将值乘以 v，然后将我们的值转置回（B，T，self.n_head，C // self.n_head）的设置。我们调用.contiguous()以确保在内存中所有数据都按顺序排列，最后将张量转换回（B，T，C）维度，这样就完成了在此步骤中拼接注意力头的操作。

最后，我们使用线性投影c_proj将其转换回隐藏状态的原始维度。

MLP 类

class MLP(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.c_fc = nn.Linear(config.n_embd, 4 * config.n_embd)
        self.gelu = nn.GELU(approximate="tanh")
        self.c_proj = nn.Linear(4 * config.n_embd, config.n_embd)
        self.c_proj.NANOGPT_SCALE_INIT = 1
# ...

和之前所有的类一样，MLP 继承自nn.Module。我们首先设置一些辅助函数——特别是c_fc和c_proj线性投影层，分别将我们的嵌入扩展到原来的 4 倍大小，再缩回原来大小。接下来，我们使用 GELU。Karpathy 特别指出，近似参数这里只是为了与 GPT-2 论文中的结果尽可能接近。虽然当时，GELU 的近似是必要的，但现在我们不再需要近似——我们可以精确计算。

class MLP(nn.Module):
# ...
    def forward(self, x):
        x = self.c_fc(x)
        x = self.gelu(x)
        x = self.c_proj(x)
        return x

我们的前向传播过程相对简单。我们对输入张量调用每个函数并返回最终结果。

Hugging Face 连接代码

因为 GPT-2 是开源的，所以它可以在 Hugging Face 上找到。虽然我们的目标是训练自己的模型，但能够将我们的结果与 OpenAI 在训练中得到的结果进行对比是很有意义的。为了实现这一点，我们有以下函数来提取权重并将它们填充到我们的GPT类中。

这段代码还允许我们重用这些代码，从 Hugging Face 拉取基础模型并进行微调（经过一些修改，因为现在它仅对 gpt-2 进行了优化）。

class GPT(nn.Module):
# ...
    @classmethod
    def from_pretrained(cls, model_type):
        """Loads pretrained GPT-2 model weights from huggingface"""
        assert model_type in {'gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'}
        from transformers import GPT2LMHeadModel
        print("loading weights from pretrained gpt: %s" % model_type)

        # n_layer, n_head and n_embd are determined from model_type
        config_args = {
            'gpt2':         dict(n_layer=12, n_head=12, n_embd=768),  # 124M params
            'gpt2-medium':  dict(n_layer=24, n_head=16, n_embd=1024), # 350M params
            'gpt2-large':   dict(n_layer=36, n_head=20, n_embd=1280), # 774M params
            'gpt2-xl':      dict(n_layer=48, n_head=25, n_embd=1600), # 1558M params
        }[model_type]
        config_args['vocab_size'] = 50257 # always 50257 for GPT model checkpoints
        config_args['block_size'] = 1024 # always 1024 for GPT model checkpoints
        # create a from-scratch initialized minGPT model
        config = GPTConfig(**config_args)
        model = GPT(config)
        sd = model.state_dict()
        sd_keys = sd.keys()
        sd_keys = [k for k in sd_keys if not k.endswith('.attn.bias')] # discard this mask / buffer, not a param
# ...

从顶部开始，我们引入 HuggingFace 的transformers库，并设置在不同版本的 GPT-2 模型之间变化的超参数。由于vocab_size和block_size不变，您可以看到我们将它们硬编码了进去。然后，我们将这些变量传递给之前的GPTConfig类，然后实例化模型对象（GPT）。最后，我们从模型中删除所有以.attn.bias结尾的键，因为这些不是权重，而是我们之前为帮助注意力功能设置的寄存器。

class GPT(nn.Module):
# ...
    @classmethod
    def from_pretrained(cls, model_type):
# ...
        model_hf = GPT2LMHeadModel.from_pretrained(model_type)
        sd_hf = model_hf.state_dict()

        # copy while ensuring all of the parameters are aligned and match in names and shapes
        sd_keys_hf = sd_hf.keys()
        sd_keys_hf = [k for k in sd_keys_hf if not k.endswith('.attn.masked_bias')] # ignore these, just a buffer
        sd_keys_hf = [k for k in sd_keys_hf if not k.endswith('.attn.bias')] # same, just the mask (buffer)
        transposed = ['attn.c_attn.weight', 'attn.c_proj.weight', 'mlp.c_fc.weight', 'mlp.c_proj.weight']
        # basically the openai checkpoints use a "Conv1D" module, but we only want to use a vanilla Linear
        # this means that we have to transpose these weights when we import them
        assert len(sd_keys_hf) == len(sd_keys), f"mismatched keys: {len(sd_keys_hf)} != {len(sd_keys)}"

接下来，我们从 HuggingFace 类GPT2LMHeadModel加载模型。我们从这个模型中提取键，并同样忽略attn.masked_bias和attn.bias键。然后我们使用断言来确保 Hugging Face 模型中的键数量与我们模型中的键数量相同。

class GPT(nn.Module):
# ...
    @classmethod
    def from_pretrained(cls, model_type):
# ...
        for k in sd_keys_hf:
            if any(k.endswith(w) for w in transposed):
                # special treatment for the Conv1D weights we need to transpose
                assert sd_hf[k].shape[::-1] == sd[k].shape
                with torch.no_grad():
                    sd[k].copy_(sd_hf[k].t())
            else:
                # vanilla copy over the other parameters
                assert sd_hf[k].shape == sd[k].shape
                with torch.no_grad():
                    sd[k].copy_(sd_hf[k])

        return model

为了完善这个函数，我们遍历 Hugging Face 模型中的每个键，并将其权重添加到我们模型中对应的键上。有些键需要进行处理，以便适应我们正在使用的数据结构。我们使用函数.t()来转置 hugging face 矩阵，使其符合我们需要的维度。对于其余的键，我们直接复制过去。你会注意到我们使用了torch.no_grad()。这告诉 torch 它不需要缓存值用于模型的反向传播，这是另一个优化措施，使得运行速度更快。

生成我们的第一次预测（采样循环）

使用我们现在的类，我们可以运行模型并让它给出输出的 token（只需确保如果你是按顺序跟随的，记得注释掉 GPT 构造函数中的 _init_weights 调用）。下面的代码展示了我们如何做到这一点。

device = "cpu"
if torch.cuda.is_available():
    device = "cuda"
elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
    device = "mps"
print(f"device {device}")

torch.manual_seed(1337)

model = GPT(GPTConfig())
model.eval()
model.to(device)

我们首先确定可以访问的设备。Cuda 是 NVIDIA 的平台，可以进行非常快速的 GPU 计算，因此如果我们有访问使用 CUDA 的芯片，我们将使用它们。如果我们没有 CUDA 访问权限，但使用的是 Apple Silicon，那么我们将使用它。最后，如果两者都没有，我们就退回到 CPU（这将是最慢的，但每台计算机都有 CPU，所以我们知道仍然可以在上面训练）。

然后，我们使用默认配置实例化模型，并将模型置于'eval'模式——（这会做很多事情，比如禁用 dropout，但从宏观上看，它确保我们的模型在推理过程中更加一致）。设置完成后，我们将模型移到我们的设备上。注意，如果我们想使用 HuggingFace 的预训练权重而不是我们的训练权重，我们需要修改倒数第三行，使其变为：model = GPT.from_pretrained(‘gpt2’)

import tiktoken
enc = tiktoken.get_encoding('gpt2')
tokens = enc.encode("Hello, I'm a language model,")
tokens = torch.tensor(tokens, dtype=torch.long)
tokens = tokens.unsqueeze(0).repeat(num_return_sequences, 1)
x = tokens.to(device)

我们现在使用gpt2编码方式引入tiktoken并让它对我们的提示进行分词。我们将这些 token 放入一个 tensor 中，然后在下面一行中将其转换为批次。unsqueeze()会为 tensor 添加一个新的尺寸为 1 的第一维，repeat会在第一维重复整个 tensor num_return_sequences次，并在第二维重复一次。我们所做的是将数据格式化为模型预期的批处理结构。具体来说，我们现在匹配了(B, T)格式：num_return_sequences x 提示的编码长度。一旦我们将输入 tensor 传入模型的开始位置，我们的wte和wpe就会生成 C 维度。

while x.size(1) < max_length:
    with torch.no_grad():
        logits, _ = model(x)
        logits = logits[:, -1, :]
        probs = F.softmax(logits, dim=-1)
        topk_probs, topk_indices = torch.topk(probs, 50, dim=-1)
        ix = torch.multinomial(topk_probs, 1)
        xcol = torch.gather(topk_indices, -1, ix)
        x = torch.cat((x, xcol), dim=1)

现在它们已经准备好，我们将它们发送到设备上并开始我们的采样循环。这个循环将仅仅是前向传播，因此我们将其包装在torch.no_grad中，以防它为任何反向传播缓存值。我们的 logits 的形状为(batch_size, seq_len, vocab_size) — (B,T,C)，其中 C 是在模型前向传播后得到的。

我们只需要序列中的最后一个项来预测下一个 token，因此我们提取[:, -1, :]。然后我们将这些 logits 通过softmax处理，得到 token 的概率。取前 50 个概率最大的 token，我们随机选择一个索引，从中选出作为我们的预测 token。然后我们获取关于该 token 的信息并将其添加到我们的张量x中。通过将xcol拼接到x上，我们为根据刚刚预测的内容进入下一个 token 做好了准备。这就是我们实现自回归的方式。

for i in range(num_return_sequences):
    tokens = x[i, :max_length].tolist()
    decoded = enc.decode(tokens)
    print(f">> {decoded}")

采样循环完成后，我们可以遍历每个选定的 token 并对其进行解码，展示给用户响应。我们从批次中的第i个获取数据，并解码以得到下一个 token。

如果你在我们初始模型上运行采样循环，你会发现输出结果差强人意。这是因为我们还没有训练任何权重。接下来的几节将展示如何开始对模型进行初步训练。

DataLoaderLite

所有训练都需要高质量的数据。对于 Karpathy 的视频，他喜欢使用公共领域的莎士比亚文本（可以在这里找到）。

class DataLoaderLite:
    def __init__(self, B, T):
        self.B = B
        self.T = T

        with open('shakespeare.txt', "r") as f:
            text = f.read()

        enc = tiktoken.get_encoding('gpt2')
        tokens = enc.encode(text)
        self.tokens = torch.tensor(tokens)
        print(f"1 epoch = {len(self.tokens) // B * T} batches")

        self.current_position = 0

我们首先通过简单地打开文件并读取文本来开始。此数据源仅包含 ASCII 字符，因此我们不需要担心任何意外的二进制字符。我们使用tiktoken获取正文的编码，然后将这些 tokens 转换为张量。接着，我们创建一个名为current_position的变量，它将告诉我们当前正在从 token 张量的哪个位置进行训练（通常初始化为开始位置）。注意，这个类没有继承自nn.Module，主要是因为我们在这里不需要forward函数。就像在采样循环的提示部分一样，我们的 DataLoaderLite 类只需要生成形状为(B, T)的张量。

class DataLoaderLite:
# ...
    def next_batch(self):
        B, T = self.B, self.T
        buf = self.tokens[self.current_position: self.current_position+(B*T + 1)]
        x = (buf[:-1]).view(B, T)
        y = (buf[1:]).view(B,T)

        self.current_position += B * T
        if self.current_position + (B*T+1) > len(self.tokens):
            self.current_position = 0
        return x,y

在上面的代码中，我们定义了next_batch函数来帮助训练。为了加速程序运行，我们喜欢将计算分批执行。我们使用 B 和 T 字段来确定我们训练的批量大小（B）和序列长度（T）。使用这些变量，我们创建一个缓冲区来保存我们将用来训练的 tokens，将维度设置为 B 行 T 列。注意，我们从current_position读取到current_position + (B*T + 1)，其中+1 是为了确保我们有所有的真实值，适用于我们B*T的批次。

然后，我们设置我们的模型输入(x)和期望输出(y)。x是除了最后一个字符外的整个缓冲区，而y是除了第一个字符外的整个缓冲区。基本的想法是，给定 token 缓冲区中的第一个值，我们期望从模型中返回 token 缓冲区中的第二个 token。

最后，我们更新current_position并返回x和y。

权重初始化

由于我们处理的是概率，我们希望为权重选择初始值，以便更少的训练轮次就能得到正确的结果。我们的_init_weights函数帮助我们实现这一点，它通过用零或正态分布来初始化权重。

class GPT(nn.Module):
# ...
    def _init_weights(self, module):
        # layer norm is by default set to what we want, no need to adjust it
        if isinstance(module, nn.Linear):
            std = 0.02
            if hasattr(module, "NANOGPT_SCALE_INIT"):
                std *= (2 * self.config.n_layer) ** -0.5 # 2 * for 2 additions (attention & mlp)
            torch.nn.init.normal_(module.weight, mean=0.0, std=std)
            # reasonable values are set based off a certain equation
            if module.bias is not None:
                torch.nn.init.zeros_(module.bias)
        elif isinstance(module, nn.Embedding):
            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02 )

如果你之前记得，我们将GPT类的每个字段都传递给了_init_weights，所以我们正在处理nn.Module。我们使用 Xavier 方法初始化权重，这意味着我们将采样分布的标准差设置为1 / sqrt(hidden_layers)。你会注意到，在代码中，我们经常使用硬编码的 0.02 作为标准差。尽管这看起来是任意的，但从下面的表格可以看到，由于 GPT-2 使用的隐藏维度都大致为 0.02，这就是一个很好的近似值。

浏览代码时，我们首先检查我们操作的模块是nn.Module的哪种子类。

如果该模块是线性模块，我们会检查它是否是我们从MLP或CasualSelfAttention类中的投影之一（通过检查它是否设置了NANO_GPT_INIT标志）。如果是，那么我们 0.02 的近似值将不起作用，因为这些模块中的隐藏层数在增加（这是我们在Block类中添加张量的结果）。因此，GPT-2 论文使用了一个缩放函数来解决这个问题：1/sqrt(2 * self.config.n_layer)。2*的原因是我们的Block有两个地方在添加张量。

如果线性模块中有偏置，我们将首先将其初始化为零。

如果我们有一个Embedding模块（如 Token 或位置编码部分），我们将使用标准差为 0.02 的相同正态分布来初始化它。

如果你记得，我们的模型中还有另一种子类：nn.LayerNorm。这个类已经通过正态分布进行了初始化，因此我们决定不需要做任何更改。

训练循环

现在我们已经设置好了训练的基本要素，让我们快速组建一个训练循环来训练我们的模型。

device = "cpu"
if torch.cuda.is_available():
    device = "cuda"
elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
    device = "mps"
print(f"device {device}")

num_return_sequences = 5
max_length = 30

torch.manual_seed(1337)

train_loader = DataLoaderLite(B=4, T=32)

model = GPT(GPTConfig())
model.to(device)

你可以看到，我们重复进行设备计算以获得最佳性能。然后，我们设置数据加载器，使用批量大小为 4 和序列长度为 32（这个设置是任意的，尽管 2 的幂在内存效率上最佳）。

optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)
for i in range(50):
    x, y = train_loader.next_batch()
    x, y = x.to(device), y.to(device)
    optimizer.zero_grad() #have to start with a zero gradient
    logits, loss = model(x, y)
    loss.backward() #adds to the gradient (+=, which is why they must start as 0)
    optimizer.step()
    print(f"loss {loss.item()}, step {i}")

现在我们有了优化器，它将帮助我们训练模型。优化器是一个 PyTorch 类，它接受应训练的参数（在我们的情况下是从GPT类传入的参数），以及学习率，这是训练过程中的超参数，决定了我们调整参数的速度——较高的学习率意味着每次运行后权重的变化更为剧烈。我们根据 Karpathy 的推荐选择了我们的值。

然后我们使用 50 步训练来训练模型。我们首先获取训练批次并将其移到我们的设备上。我们将优化器的梯度设置为零（在 pytorch 中，梯度是累加的，所以如果不将其清零，我们将从上一批次携带信息）。我们计算模型的 logits 和损失，然后进行反向传播，以找出新的权重模型应该是什么。最后，我们运行optimizer.step()来更新所有模型参数。

合理性检查

若要查看上述所有代码的执行情况，您可以查看我的 Google Colab，其中我将所有内容结合并在 NVIDIA T4 GPU 上运行。运行我们的训练循环时，我们看到损失从大约~11 开始。为了验证这一点，我们预计在开始时预测正确的标记的概率为（1/vocab_size）。通过一个简化的损失函数-ln，我们得到大约 10.88，这正是我们开始的地方！

图片由作者提供

结束语

感谢你读到最后！

我尽力在这篇博客文章中包含了尽可能多的细节，但自然也有一些内容我不得不省略。如果你喜欢这篇博客文章或者发现有任何你认为应该修改/扩展的地方，请告诉我！

现在是构建的激动人心时刻！

[1] Karpathy, A.，《让我们重现 GPT-2（124M）》（2024），YouTube

[2] Radford, A. 等人，《语言模型是无监督多任务学习者》（2018），《带代码的论文》

[3] Vaswani, A. 等人，"Attention Is All You Need"（2017），arXiv

逐行分析，让我们重现 GPT-2：第二部分 — 硬件优化

原文：towardsdatascience.com/line-by-line-lets-reproduce-gpt-2-section-2-hardware-optimization-86e71c91d9bb?source=collection_archive---------15-----------------------#2024-07-31

本文将逐行分析 Andrej Karpathy 在《让我们重现 GPT-2（124M）》第二部分中的硬件优化内容。

·发布于 Towards Data Science ·阅读时间：11 分钟·2024 年 7 月 31 日

图片来源 — SDXL

快速回顾一下，在第一部分中，我们逐行分析了 Karpathy 编写的代码，目的是原始地训练 GPT-2。现在我们已经有了我们的设置，Karpathy 向我们展示了如何在我们的 NVIDIA GPU 上加速模型训练！虽然我们知道训练一个好的模型需要花费大量时间，但通过优化每次运行，我们可以节省数天甚至数周的训练时间。这自然为我们提供了更多的迭代次数来改善模型。在本文的最后，你将看到如何通过使用 Ampere 系列的 Nvidia GPU 来大幅加速训练（提高 10 倍）。

为了写这篇博客文章，我在 Google Colab 提供的免费 NVIDIA T4 GPU 和 Lambda Labs 的 NVIDIA A100 40GB SXM4 GPU 上进行了优化。Karpathy 提到的大多数优化方法专为 A100 或更强大的显卡设计，但在较弱的 GPU 上仍然可以获得一些性能提升。

让我们开始吧！

代码计时

首先，我们希望创建一种方式来查看我们的优化效果。为此，我们将在训练循环中添加以下代码：

for i in range(50):
    t0 = time.time() # start timer
    x, y = train_loader.next_batch()
    x, y = x.to(device), y.to(device)
    optimizer.zero_grad() 
    logits, loss = model(x, y)
    loss.backward() 
    optimizer.step()
    torch.cuda.synchronize() # synchronize with GPU
    t1 = time.time() # end timer
    dt = (t1-t0)*1000 # milliseconds difference
    print(f"loss {loss.item()}, step {i}, dt {dt:.2f}ms")

我们首先捕获循环开始时的时间，但在捕获结束时间之前，我们运行 torch.cuda.synchronize()。默认情况下，我们只关注 CPU 停止的时间。因为我们已经将大部分主要计算移至 GPU，所以我们需要确保定时器在此处考虑到 GPU 停止计算的时间。同步操作将使 CPU 等待，直到 GPU 完成其工作队列，从而为我们提供循环完成时的准确时间。一旦我们有了准确的时间，自然就能计算出开始时间和结束时间之间的差异。

批量大小

我们还希望确保每轮通过尽可能多的数据。我们实现这一目标的方式是设置批量大小。在我们的 DataLoaderLite 类中，我们可以调整 2 个参数（B 和 T），以便在不超出限制的情况下，使用 GPU 中尽可能多的内存。

使用 A100 GPU，你可以按照 Karpathy 的示例，其中我们将 T 设置为最大 block_size 的 1024，并将 B 设置为 16，因为它是一个“漂亮”的数字（容易被 2 的幂次方整除），并且是我们可以在内存中容纳的最大“漂亮”数字。

train_loader = DataLoaderLite(B=16, T=1024)

如果你尝试输入一个太大的值，你会在终端看到 CUDA 提示 OutOfMemoryError 错误。我发现对于 T4 GPU，最佳的值是 B = 4 和 T = 1024（当在 Google Colab 中尝试不同的 B 值时，请注意，你可能需要重启会话，以确保不会得到错误的 OutOfMemoryError）。

在 A100 和 T4 上运行时，我得到了以下图表，显示了开始训练的时间（平均大约在 T4 上是 1100ms，A100 上是 1040ms）

作者提供的图像 — A100 训练未进行优化

作者提供的图像 — T4 训练未进行优化

浮点优化

现在我们将重点关注在模型内部表示数据时所做的更改。

如果你查看我们在第一节代码中权重的 dtype，你会看到我们默认使用 32 位浮点数（fp32）。Fp32 表示我们使用 32 位表示数字，遵循下面的 IEEE 浮动点标准：

作者提供的图像 — IEEE 浮动点 32（FP32）表示

正如 Karpathy 在视频中所说，我们通过实验证明，fp32 并不是训练高质量模型所必需的——我们可以使用更少的数据来表示每个权重，并且仍然得到高质量的输出。加速计算的一种方法是使用 NVIDIA 的 TensorCore 指令。它将通过将操作数转换为下面所示的 Tensor Float 32（TF32）格式来处理矩阵乘法：

作者提供的图像 — Tensor Float 32（TF32）

作者提供的图像 — TF32 数据流通过 Tensor Core 经过优化

从代码角度来看，我们所有的变量（输入、输出）都是 FP32 格式，但 NVIDIA GPU 会将中间矩阵转换为 TF32 格式以加速。根据 NVIDIA 的说法，这能带来 8 倍的加速相对于 FFMA 指令。要在 PyTorch 中启用 TF32，我们只需要添加以下代码行（high = TF32, highest = FP32, medium = BF16（稍后会详细介绍））：

torch.set_float32_matmul_precision("high")

TensorCore 是 NVIDIA 独有的功能，您只能在 A100 GPU 或更高版本上运行 TF32，因此一些开发者使用浮点 16（FP16）作为训练方式。这种表示法的问题在于，FP16 能够表示的数据范围比 FP32 要小，导致无法表示训练所需的相同数据范围。虽然通过梯度扩展可以绕过这一点，但这会增加更多的计算，因此最终会陷入“前进一步，退两步”的困境。

作者提供的图片 — IEEE 浮点 16（FP16）表示法

但在他的演示视频中，Karpathy 使用的数据优化方法是脑浮点（BF16）。在这种表示法中，我们与 FP32 有相同数量的指数位，因此可以表示相同的范围，但尾数位较少。这意味着尽管我们有较少的位数，表示数字的精度较低。通过经验来看，这并没有导致性能大幅下降，所以这是一个我们愿意接受的折衷。要在 NVIDIA 芯片上使用此格式，您需要具备 A100。

作者提供的图片 — 脑浮点 16（BF16）

使用 PyTorch 时，我们不需要大幅修改代码就可以使用新的数据类型。文档建议我们只在模型的前向传递和损失计算过程中使用这些数据类型。由于我们的代码在 1 行中完成了这两个操作，我们可以按如下方式修改代码：

for i in range(50):
    t0 = time.time() 
    x, y = train_loader.next_batch()
    x, y = x.to(device), y.to(device)
    optimizer.zero_grad() 
    with torch.autocast(device_type=device, dtype=torch.bfloat16): # bf16 change
        logits, loss = model(x, y)
    loss.backward() 
    optimizer.step()
    torch.cuda.synchronize() 
    t1 = time.time()
    dt = (t1-t0)*1000 
    print(f"loss {loss.item()}, step {i}, dt {dt:.2f}ms")
    loss_arr.append(loss.item())

就这样，我们的代码现在已经开始使用 BF16 运行。

在我们的 A100 上运行时，现在平均每步大约需要 330 毫秒！我们已经将运行时间减少了大约 70%，而且我们才刚刚开始！

作者提供的图片 — 数据类型优化后的 A100 训练

Torch Compile

我们可以通过利用 PyTorch Compile 功能进一步改善训练时间。这样可以在不调整代码的情况下大幅提升性能。

从高层次来看，每个计算机程序都是以二进制执行的。因为大多数人觉得用二进制编程很困难，所以我们创建了更高层次的语言，让我们能以更容易理解的方式编写代码。当我们编译这些语言时，它们会被转换回我们实际运行的二进制代码。有时，在这种转换过程中，我们可以找到更快的方式来完成相同的计算——比如重用某个变量，甚至干脆跳过某些操作。

# ...
model = GPT(GPTConfig(vocab_size=50304))
model.to(device)
model = torch.compile(model) # new line here
# ...

这将我们带到了机器学习和 PyTorch。Python 是一种高级语言，但我们仍然在用它做计算密集型的计算。当我们运行torch compile时，我们花费更多时间在编译代码上，但由于我们为了找到这些优化所做的额外工作，我们最终看到我们的运行时间（在这里指的是训练）变得更快。

Karpathy 给出了一个 PyTorch 如何改善计算的示例。我们的 GELU 激活函数可以写成如下：

class TanhGELU(nn.Module):
    def forward(self, input):
        return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0/math.pi) * (input + 0.044715 * torch.pow(input, 3.0))))

对于你在上面的函数中看到的每个计算，我们都必须在 GPU 中调度一个内核。这意味着，当我们开始进行三次方计算时，我们从高带宽内存（HBM）中提取输入到 GPU 核心，并进行计算。然后，我们将结果写回 HBM，然后开始下一次计算，并重复整个过程。自然，这样的顺序导致我们在等待内存传输时浪费了大量时间。

PyTorch 编译让我们能够看到像这样的低效，并且更加小心地控制何时启动新的内核，从而实现显著的加速。这被称为内核融合。

在这个话题上，我想指出一个优秀的开源项目叫做 Luminal，它将这个思想进一步扩展了。Luminal 是一个独立的框架，你可以在其中编写训练/推理代码。通过使用这个框架，你可以访问它的编译器，该编译器通过只考虑有限数量的计算，能够为你找到更多优化。如果你喜欢通过编译快速 GPU 代码来提升运行时间的思路，可以看看这个项目。

当我们现在运行上面的代码时，我们会看到每一步大约需要 145 毫秒（比之前减少了 50%，比原始版本减少了约 86%）。我们为此付出了第一轮大约 40,000 毫秒的代价！由于大多数训练序列的步骤数远超过 50，这个权衡是我们愿意做出的。

作者提供的图片 — A100 训练在 Torch Compile 优化后的运行结果

Flash Attention

我们做的另一个优化是使用 Flash Attention（查看论文）。对于我们来说，代码本身的改动非常简单，但背后的思路值得深入探讨。

y = F.scaled_dot_product_attention(q, k, v, is_causal=True)

类似于我们如何将 TanhGELU 类压缩成尽可能少的内核，我们也将相同的思维方式应用于注意力机制。在他们的论文《“FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness”》中，作者展示了如何通过融合内核实现 7.6 倍的加速。虽然理论上 torch compile 应该能够找到类似的优化，但在实践中我们尚未看到它找到这一点。

图 1 来自《“FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness”》

这篇论文值得深入研究，但简要概述一下，FlashAttention 被设计为对 I/O 友好，从而避免了不必要（且耗时）的内存调用。通过减少这些调用，它们可以显著加速计算。

实施了这个优化后，我们发现现在每一步的平均时间约为 104 毫秒。

作者提供的图像 — Flash Attention 优化后的 A100 训练

词汇大小变化

最后，我们可以检查所有硬编码的数字，评估它们有多“合适”。当我们这样做时，我们发现词汇大小不能被许多 2 的幂整除，因此在 GPU 内存加载时会更加耗时。我们通过将词汇大小从 50,257 调整为下一个“合适”的数字 50,304 来解决这个问题。这个数字之所以“合适”，是因为它可以被 2、4、8、16、32、64 和 128 整除。

model = GPT(GPTConfig(vocab_size=50304))

你可能还记得上一篇博客中提到的，我们的词汇大小并不是一个任意的值 — 它是由我们使用的分词器决定的。因此，问题就来了，当我们任意地增加词汇大小时，会发生什么？在训练过程中，模型会发现这些新的词汇从未出现过，因此它会开始将这些词汇的概率推向 0 —— 所以我们的性能是安全的。不过，这并不意味着没有权衡。通过加载从未使用过的词汇到内存中，我们浪费了时间。然而，从经验上看，我们可以看到加载“合适”的数字能大大弥补这一成本。

通过最后的优化，我们现在每一步的平均时间大约是 100 毫秒。

作者提供的图像 — 词汇大小优化后的 A100 训练

通过这一最终优化，我们发现我们的训练从最初开始已经提高了约 10 倍！

哪些优化在 T4 GPU 上有效？

如果你一直在关注但仅能使用消费者级 T4 GPU，你可能会想知道哪些优化是可以使用的。回顾一下，我们不能使用 BF16 表示法，但可以使用词汇大小变化、Flash Attention 和 torch compile。要查看这段代码的实际应用，查看我为 T4 优化的 Google Colab 笔记本。

从下图中我们可以看到，尽管第一次运行 torch compile 确实需要很长时间，但接下来的几轮与未优化版本相比并没有显著提高（在 T4 上大约下降了 8%，而在 A100 上下降了 90%）。

作者提供的图像 — 在 T4 GPU 上优化运行

尽管如此，当 OpenAI 在训练 GPT-2 时，它运行的是比 T4 更先进的硬件。今天我们能够在 T4 上运行这个工作负载，表明硬件要求正在变得不那么苛刻，这有助于创造一个硬件不再成为机器学习工作障碍的未来。

结束语

通过优化我们的代码，我们看到了显著的速度提升，并且也了解了一些训练过程中主要的瓶颈。首先，数据类型对于速度至关重要，因为仅这一改变就大幅提升了速度。其次，我们发现硬件优化在加速计算中发挥着重要作用——因此，GPU 硬件真的是物有所值。最后，编译器优化在这里也起到了关键作用。

要查看我在 A100 上运行的代码，请查看这个 Gist。如果你有任何关于如何进一步优化硬件的建议，我很乐意在评论区看到它们！

现在是构建的激动人心的时刻！

[1] Karpathy, A., “让我们重现 GPT-2 (124M)” (2024), YouTube

[2] Dao, T. 等人 “FlashAttention: 快速且内存高效的精确注意力机制，具备 I/O 感知能力” (2022), arXiv

[3] Krashinsky, R. 等人 “NVIDIA 安培架构深度解析” (2020), NVIDIA 开发者

一行行地复现 GPT-2：第三部分 — 训练

原文：towardsdatascience.com/line-by-line-lets-reproduce-gpt-2-section-3-training-f2fef87880fc?source=collection_archive---------8-----------------------#2024-09-03

本文将逐行解析 Andrej Karpathy 的《一起来复现 GPT-2（124M）》第三部分中的代码。

·发布于 Towards Data Science ·17 分钟阅读·2024 年 9 月 3 日

图片来源 — SDXL

在第一篇博文中，我们编写了 Transformer 架构的代码。在第二篇博文中，我们优化了 NVIDIA 的交互。为了完成我们的系列教程，接下来我们将对 GPT-2 模型进行预训练。如果你还没有观看过，强烈推荐观看 Andrej Karpathy 的《让我们复现 GPT-2（124M）》视频，以及下面我们系列中的两篇前文。

## 一行行地复现 GPT-2：第一部分

本文将逐行解析 Andrej Karpathy 的《一起来复现 GPT-2（124M）》第一部分中的代码。

towardsdatascience.com ## 一行行地复现 GPT-2：第二部分 — 硬件优化

本文将逐行解析 Andrej Karpathy 的《一起来复现 GPT-2》第二部分中的硬件优化内容。

towardsdatascience.com

不再废话，让我们开始吧！

在我们开始预训练之前，我们需要对代码进行一些修改，以提高性能并在训练过程中提高可视性。请注意，我们将...

线性代数 5：线性无关

原文：towardsdatascience.com/linear-algebra-5-linear-independence-d350759debee?source=collection_archive---------4-----------------------#2024-03-21

Ax = 0 和证明一组向量线性无关

tenzin migmar (t9nz)

·发表于 Towards Data Science ·阅读时间 6 分钟·2024 年 3 月 21 日

序言

欢迎回到我关于线性代数基础的系列的第五篇文章，线性代数是机器学习背后的基础数学。在上一篇文章中，我讲解了矩阵方程 Ax = b。本篇文章将探讨线性无关这一重要概念，并讨论它与我们迄今为止学到的内容的关系。

本文最好与 David C. Lay、Steven R. Lay 和 Judi J. McDonald 合著的《线性代数及其应用》一书一起阅读。请将本系列视为一份辅助资源。

欢迎分享您的想法、问题和批评。

ℝⁿ 中的线性无关

之前，我们学习了矩阵乘法和形如 Ax = b 的矩阵方程。我们讲解了当 b 是矩阵 A 中一组向量（列）的线性组合时，Ax = b 有解 x。

在线性代数中，有一个特殊的矩阵方程 Ax = 0，我们称之为齐次线性系统。Ax = 0 总是至少有一个解，其中 x = 0，这个解称为平凡解，因为很容易证明任何矩阵 A 与 0 向量 x 相乘都会得到 0 向量。

我们真正关心的是学习矩阵方程Ax = 0是否仅有平凡解。如果Ax = 0只有平凡解x = 0，那么构成矩阵A列的向量集合是线性无关的。换句话说：v₁ + c₂v₂ + … + cₐvₐ = 0，其中 c₁, c₂, …, cₐ必须全为 0。另一种思考方式是，这个集合中的任何一个向量都不能表示为其他向量的线性组合。

另一方面，如果存在解使得x ≠ 0，那么该向量集合是线性相关的。由此可得，该集合中至少有一个向量可以表示为其他向量的线性组合：c₁v₁ + c₂v₂ + … + cₐvₐ = 0，其中不是所有的 c₁, c₂, …, cₐ都为 0。

一个简洁且直观的思考线性无关概念的方式是：你能否找到一组权重，将一组向量的线性组合压缩到原点？如果一组向量是线性无关的，那么唯一能应用到每个向量的权重是 0，才能使得线性组合等于零向量。如果这些向量是线性相关的，那么就存在至少一组非零权重，使得向量的线性组合等于零。

判断线性无关性

对于只有一个向量的集合，判断线性无关性是非常简单的。如果该向量是零向量，则它是线性相关的。这是因为任何非零权重乘以零向量都会得到零向量，因此对于*Ax = 0存在无数解。如果该向量不是零向量，则它是线性无关的，因为任何向量乘以零都会得到零向量。

如果一个集合包含两个向量，当且仅当其中一个向量是另一个向量的倍数时，向量集合是线性相关的。否则，它们是线性无关的。

对于包含超过两个向量的集合，需要进行更多的计算。令这些向量构成矩阵A的列，并对矩阵A进行行约简，得到简化行阶梯形矩阵。如果简化行阶梯形矩阵的每一列都有一个主元，则该向量集合是线性无关的。否则，该向量集合是线性相关的。为什么会这样呢？考虑将矩阵行约简为简化行阶梯形矩阵的过程。我们执行一系列基本的行变换，如将行乘以常数、交换行、将一行加到另一行，以便得到一个更简单形式的矩阵，从而使其基本属性变得清晰，同时解空间得以保持。

在线性独立的情况下，矩阵中每一列有主元，表明每个向量在至少一个部分的线性组合方程中起着主导作用。如果每个向量都独立地贡献于线性系统，那么没有任何一个向量可以表示为其他向量的线性组合，因此系统是线性独立的。相反，如果简化行阶梯形矩阵中有一列没有主元，意味着相应的变量（或向量）是依赖变量，可以通过其他向量来表示。换句话说，系统中存在冗余，表明向量之间存在线性依赖性。

总结这个概念的一种简洁方法是使用矩阵的秩。秩是矩阵中线性独立列的最大数目，因此可以推导出，秩等于简化行阶梯形矩阵中的主元个数。

如果矩阵的列数等于秩，那么矩阵是线性独立的。否则，矩阵是线性相关的。

使用 Numpy 进行线性独立性检测

尝试手工计算是更好理解线性独立性的有价值练习，但更实用的方法是利用 Numpy 库中内置的功能，既可以测试线性独立性，也可以推导给定矩阵的Ax = 0的解空间。

我们可以通过矩阵的秩来检查一个矩阵是否线性独立。如前所述，矩阵线性独立当且仅当矩阵的秩等于列数，因此我们的代码将围绕这个标准编写。

以下代码生成Ax = 0的向量解空间。

结论

线性独立性，虽然是线性代数的基础，但在机器学习应用中也起着基石作用。线性独立性在特征选择和降维技术中至关重要，例如主成分分析（PCA），它操作的是数据集中各特征之间的共线性或线性依赖性。

你将在机器学习中继续看到线性独立性的重要性！

摘要

如果一个线性方程组可以写成Ax = 0的形式，则称该方程组为齐次的。
线性独立的向量不能互相表示为线性组合（除非是所有系数都为零的平凡组合）。
线性相关的向量是指集合中的至少一个向量可以表示为其他向量的线性组合。
Numpy 是一个用于处理数组的 Python 库，提供了出色的支持，可以检查一个矩阵是否线性独立，并且还可以解给定矩阵的 Ax = 0。

注意事项

除非另有说明，否则所有图片均由作者创作。

线性注意力就是你所需要的一切

原文：towardsdatascience.com/linear-attention-is-all-you-need-5fa9c845c1b5?source=collection_archive---------2-----------------------#2024-06-02

自注意力能以更低的成本实现？

Sam Maddrell-Mander

·发布于 Towards Data Science ·9 分钟阅读·2024 年 6 月 2 日

图片由 Guillaume Jaillet 提供，来源于 Unsplash

“注意力在处理长序列时表现较差”

这是任何花费大量时间研究变换器和自注意力机制的人都听过一百次的内容。它绝对是正确的，我们都经历过，当你尝试增加模型的上下文大小时，一切突然停滞不前。但与此同时，似乎几乎每周都有一个新的前沿模型，创造了一个新的上下文长度纪录。（Gemini 的上下文长度达到了 2M 个标记！）

有很多复杂的方法，比如 RingAttention，它使得在大型分布式系统中训练极长的上下文长度成为可能，但今天我关注的是一个更简单的问题。

单靠线性注意力，我们能做到什么程度？

让我们来解析一下数学。

这将是一次快速浏览，但请耐心等待，我们将在深入分析结果之前，简要讨论一些关键点。

我们基本上可以用两个关键点总结传统的注意力机制：

首先，典型的 softmax 注意力表达式是将查询矩阵和键矩阵相乘，进行归一化以保持稳定性，然后按行进行 softmax 运算，从而得到序列中每个元素之间的注意力分数。
其次，时间复杂度主要由 N²的点积决定，而 softmax 内部的部分是限制因素。这就是我们计算注意力分数的地方。

传统形式可以表达为：

softmax 注意力机制的传统公式。

事实证明，如果我们请教一下数学家朋友，我们可以稍微换个角度思考这个问题。softmax 可以被看作是描述与其他 token 之间的概率分布的多种方式之一。我们可以使用任何我们喜欢的相似度度量（点积是最简单的之一），只要我们进行归一化，就没问题。

使用任何相似度函数的注意力的通用表达式。

说这就是注意力有点草率，因为实际上只有当相似度函数是查询和键的点积的指数（如下所示），并且我们在 softmax 中找到了这个时，它才是我们所知的注意力。但有趣的是，如果我们不使用这个表达式，而是尝试逼近它呢？

用两个特征图逼近自注意力中的相似度函数。

我们可以假设存在某个特征图“phi”，它能给出一个结果，几乎与取点积的指数相同。关键是，以这种方式写表达式允许我们改变矩阵乘法操作的顺序。

在论文中，他们提出了指数线性单元（ELU）作为特征图，因为它具有一些有用的属性：

对于大于 0 的值，ELU(x) 给出线性结果，尽管与指数不同，但仍然保留了分数之间的相对顺序。
对于小于或等于 0 的值，指数项保持了函数的连续性，并确保梯度不会消失。

我们在这里不会花太多时间讨论这个问题，但这已经通过经验得到了验证，作为 softmax 函数的一个合理逼近。

这使我们能够改变操作的顺序。我们可以首先取特征图 K 和 V 的乘积，形成一个 KV 块，然后与 Q 相乘。平方积变成了在模型维度上进行而非序列长度上进行。

将这一切组合到线性注意力的表达式中，我们得到：

使用特征图来逼近 softmax 相似度分数的线性注意力。

我们只需要每个查询行计算括号内的项一次。

(如果你想深入了解因果遮掩是如何融入其中以及梯度是如何计算的，可以查看论文，或者关注未来的博客。)

线性注意力到底快多少？

数学上的情况很有力，但就个人而言，在看到一些基准测试之前，我总是有些怀疑。

我们先从代码片段入手，描述这些术语。softmax 注意力看起来非常熟悉，这里我们没有做任何复杂的操作。

class TraditionalAttention(nn.Module):
    def __init__(self, d_k):
        super(TraditionalAttention, self).__init__()
        self.d_k = d_k

    def forward(self, Q, K, V):
        Z = torch.sqrt(torch.tensor(self.d_k, device=Q.device, dtype=torch.float32))
        scores = torch.matmul(Q, K.transpose(-2, -1)) / Z
        attention_weights = F.softmax(scores, dim=-1)
        output = torch.matmul(attention_weights, V)
        return output

接着，对于线性注意力，我们首先获取查询、键和值矩阵，然后对查询和键应用 ELU(x)特征映射。接着使用 einsum 符号进行乘法运算。

class LinearAttention(nn.Module):
    def __init__(self):
        super(LinearAttention, self).__init__()
        self.eps = 1e-6

    def elu_feature_map(self, x):
        return F.elu(x) + 1

    def forward(self, Q, K, V):
        Q = self.elu_feature_map(Q)
        K = self.elu_feature_map(K)
        KV = torch.einsum("nsd,nsd->ns", K, V)
        # Compute the normalizer
        Z = 1/(torch.einsum("nld,nd->nl", Q, K.sum(dim=1))+self.eps)
        # Finally compute and return the new values
        V = torch.einsum("nld,ns,nl->nd", Q, KV, Z)
        return V.contiguous()

在代码中看到这些是很好，但它在实验中实际上意味着什么呢？我们在这里谈论的性能提升到底有多大？从二次瓶颈到线性瓶颈的速度提升可能很难直接感受到，因此我进行了以下实验。

我们将采取一个单独的注意力层，固定的 d_k 模型维度为 64，并基准测试 32 批次序列的前向传播时间。唯一需要变化的变量是序列长度，范围从 128 到 6000（参考 GPT-3 的上下文长度为 2048）。每次运行进行 100 次，以获得平均值和标准差，实验使用的是 Nvidia T4 GPU。

对于如此简单的实验，结果相当惊人。

基准测试：测量传统（softmax）注意力和线性注意力下，单个序列每次迭代的时间。每个序列长度在 100 次迭代中取平均，标准差也会被绘制出来。使用的序列长度范围是从 128 到 6000。比率图也显示出来，便于更容易地衡量性能提升。

结果表明，即使是在一个极小的玩具示例中，我们也能获得最多 60 倍的加速。

讨论

这里有几个显而易见的收获：

线性注意力的优势巨大——无论是在速度上，较高的吞吐量总是件好事；还是在处理长序列时的内存需求上。在低内存环境中，这可能是一个很大的优势。
比例图显示了一个令人惊讶的弯曲——这让我们怀疑这里发生了一些额外的底层优化，这意味着预期的比例并没有完全实现。所以我们需要对这个结果保持一定的怀疑态度。

完整性考虑，别误解为说“线性注意力对于小模型来说是 60 倍快”。实际上，前馈层通常占据了 Transformer 中大部分的参数，而编码/解码也是一个限制性大小的组件。但在这个严格定义的问题中，结果相当令人印象深刻！

计算复杂度

如果我们考虑每种方法的实际时间复杂度，我们可以展示这个差异的来源。

让我们分解传统 softmax 注意力的时间复杂度，第一个项给出了 QK 乘法的复杂度，这是 n²个分数，每个都是长度为 d_k 的点积。第二项描述了对注意力分数进行 softmax 操作的复杂度，也是 n²。第三项则将 n²矩阵与值向量进行点积运算。

如果我们简化假设查询、键和值矩阵具有相同的维度，那么我们得到最终项，其中主导项是 n²项。（前提是模型维度远小于序列长度。）

普通自注意力的 softmax 操作受序列长度的 n²项主导，通常模型的维度 d_k 远小于 n。

线性注意力讲述了一个不同的故事。同样，如果我们查看下面的时间复杂度表达式，我们将分析每一项。

第一项是将特征映射应用于 Q 和 K 矩阵的成本，第二项是 Q 和 V 矩阵的乘积，结果是一个(d_k, d_v)矩阵，而 K(QV)乘法在第三项中的复杂度相同。然后，最终输出再次假设模型维度对于不同的矩阵相同，最终的复杂度是线性与序列长度相关，并且与模型维度二次方成正比。

线性自注意力改变了这种局面，其在 n 上是线性的，而在模型维度上是二次方的（如果 dk 和 dv 的隐藏维度与我在这里所做的相同，便于简化）。因此，在 n >> dk 的情况下，复杂度明显较低。

因此，只要模型的维度小于序列长度，我们就能得到一个显著更快的模型。剩下的唯一问题是，它的近似效果究竟有多好？

没有免费的午餐——我们真的能训练一个模型吗？

够了，足够的实验，希望我们都确信线性注意力比传统注意力要快得多，接下来进行真正的测试。我们能否真正训练模型，并且它们在两种不同注意力机制下的表现相似？

我们在这里使用的模型非常小（如果有兴趣深入探讨如何设置一个简单的训练框架，我们可以在未来再看看这个问题），而且数据也很简单。我们将使用 Penn Treebank 数据集（通过torchtext公开提供），它包含了一些简短的文本片段，可以用来建模/测试小型语言模型。

我们能训练一个真正的模型来进行真正的预测吗

如果我们诚实一点，实际预测可能有点过于夸张，考虑到我们训练所用的参数数量和时间，实际上我真正想观察的是训练动态是否相似。我们将查看在一个简单语言建模数据集上进行自回归训练的损失曲线，如果它们遵循相同的形状，我们至少可以有一些信心，认为不同的机制给出了相似的结果。

数据的性质意味着输出质量很少能达到高标准，但它提供了我们期望的所有正确训练过程的特征。

让我们来看一下训练曲线。左图展示了传统注意力方法和线性注意力方法在训练和验证中的损失。我们可以看到，在 10 个周期内，这两种方法基本上是无法区分的。同样地，如果我们查看右图，传统 softmax 和线性注意力的损失也表现得完全相同，显示了相同的训练动态。

（左）线性和传统注意力的每个周期的训练和验证损失，（右）线性和传统注意力机制的训练损失曲线。

结论

显然，这远远不够全面，我们这里并不打算与 GPT 竞争，但我们可以对减少注意力机制的复杂性并且不丧失建模能力保持乐观。

请关注第二部分，那里会有更详细的对比。

除非另有说明，否则所有图像均由作者创建，训练数据来自公开的PennTreebank数据集，通过PyTorch torchtext数据集获取。更多细节可以在此处找到。

如果你想了解更多关于线性注意力的实现细节，我强烈建议你深入阅读原始论文（arxiv.org/abs/2006.16236）。

如果你喜欢这篇内容，请关注此账号或在 Twitter上找到我。

线性判别分析（LDA）

原文：towardsdatascience.com/linear-discriminant-analysis-lda-598d8e90f8b9?source=collection_archive---------3-----------------------#2024-10-12

发现 LDA 如何帮助识别关键数据特征

Ingo Nowitzky

·发表于Towards Data Science ·阅读时间 12 分钟·2024 年 10 月 12 日

LDA 在人工智能和机器学习方法中的分类 | 作者提供的图片

**本文旨在探讨线性判别分析（LDA），重点介绍其核心思想、在代码中的数学实现以及来自制造业的实际例子。

希望你能参与进来。让我们开始吧！**

从事工业数据**工作的实践者会熟悉这种情况：数据集通常包含许多特征，而且通常不清楚哪些特征重要，哪些特征较不重要。在此上下文中，“重要”是一个相对的概念。通常，目标是区分数据集之间的差异，即对其进行分类。一个非常典型的任务是区分好的零件和坏的零件，并找出导致零件失败的原因（即特征）。

一种常用的方法是广为人知的主成分分析（PCA）。虽然 PCA 属于无监督方法，但较少使用的 LDA 是一种有监督的方法，因此它从标记数据中学习。因此，LDA 特别适用于解释来自大数据集的故障模式。

1. LDA 的目标和原理

LDA 的目标是线性地组合数据的特征，使得数据集的标签能够彼此最佳分离，并且新特征的数量被减少到预定义的数量。在人工智能术语中，这通常被称为投影到低维空间。

LDA 原理 | 图片修改自Raschka/Mirjalili, 2019

旁白：什么是维度，什么是维度降维？

维度与图形表示 | 图片由作者提供

维度指的是数据集中特征的数量。

仅凭一个测量（或特征），例如注塑机的工具温度，我们可以将其表示在数轴上。两个特征，比如温度和工具压力，仍然可以处理：我们可以轻松地在 x-y 图表上绘制数据。三个特征——温度、工具压力和注射压力——会变得更加复杂，但我们仍然可以在 3D x-y-z 图表上绘制数据。然而，当我们添加更多特征，例如粘度、电导率等时，复杂性会增加。

降维 | 图片由作者提供

在实际应用中，数据集通常包含数百甚至数千个特征。这带来了挑战，因为许多机器学习算法在数据集过大时表现较差。此外，所需的数据量随着维度的增加而指数增长，以达到统计显著性。这种现象被称为“维度灾难”。这些因素使得在数据科学过程中，提前确定哪些特征是相关的，并去除那些不重要的特征变得至关重要。

2. LDA 是如何工作的？

线性判别分析（LDA）的过程可以分为五个关键步骤。

步骤 1： 分别计算数据集中每个 k 类别的 d 维均值向量。

记住，LDA 是一种监督学习技术，这意味着我们可以利用已知的标签。在第一步中，我们计算所有属于特定类别 c 的样本的均值向量 mean_c。为此，我们按类别标签过滤特征矩阵，并计算每个 d 特征的均值。因此，我们得到 k 个均值向量（每个类别一个），每个均值向量的长度为 d（对应于 d 个特征）。

标签向量 Y 和特征矩阵 X | 图片由作者提供

类别 c 的均值向量

步骤 2： 计算散度矩阵（类间散度矩阵和类内散度矩阵）。

类内散度矩阵衡量的是同一类别样本之间的变异性。为了找到具有最佳可分性的子空间，我们旨在最小化此矩阵中的值。相比之下，类间散度矩阵衡量的是不同类别之间的变异性。为了获得最佳可分性，我们旨在最大化此矩阵中的值。

直观地讲，类内散度关注的是每个类别的紧凑度，而类间散度则考察不同类别之间的距离。

类内和类间散度矩阵 | 图片由作者提供

让我们从类内散布矩阵S_W开始。它是通过对每个类别的散布矩阵S_c求和得到的：

类内散布矩阵 S_W

类间散布矩阵S_B是通过类别均值mean_c与整个数据集的总体均值之间的差异得出的：

类间散布矩阵 S_B

其中mean指的是在所有样本上计算的均值向量，而不考虑它们的类别标签。

步骤 3： 计算S_W和S_B比率的特征向量和特征值。

如前所述，为了实现最佳的类分离性，我们的目标是最大化S_B并最小化S_W。我们可以通过最大化比率S_B/S_W来实现这一目标。从线性代数的角度看，这个比率对应于散布矩阵S_W⁻¹ S_B，该矩阵在由具有最大特征值的特征向量张成的子空间中最大化。特征向量定义了这个子空间的方向，而特征值表示了变形的幅度。我们将选择与最大特征值相关联的m个特征向量。

特征向量和特征值的计算公式

特征向量张成的子空间 | 图片来源：作者

步骤 4： 按照特征值从大到小的顺序排序特征向量，并选择具有最大特征值的m个特征向量来构建d × m-维度的变换矩阵W。

记住，我们的目标不仅是将数据投影到一个能增强类分离性的子空间中，还要进行降维。特征向量将定义我们新特征子空间的坐标轴。为了决定丢弃哪些特征向量以形成低维子空间，我们需要检查它们相应的特征值。简而言之，具有最小特征值的特征向量对类分离贡献最小，我们希望丢弃这些特征向量。通常的方法是按特征值从大到小排列，选择前m个特征向量。m是一个可以自由选择的参数，m越大，变换过程中丢失的信息就越少。

在按特征值从大到小排序特征对并选择前m对之后，下一步是构建d × m-维度的变换矩阵W。通过将m个选定的特征向量水平堆叠，得到矩阵W：

变换矩阵 W

W的第一列表示与最大特征值对应的特征向量，第二列表示与第二大特征值对应的特征向量，依此类推。

步骤 5： 使用W将样本投影到新的子空间。

在最后一步，我们使用d × m-维度的变换矩阵W，该矩阵由前m个选定的特征向量组成，将样本投影到新的子空间：

变换后的特征矩阵 Z

其中 X 是初始的 n × d 维特征矩阵，表示我们的样本，而 Z 是新子空间中经过转换后的 n × m 维特征矩阵。这意味着，所选的特征向量作为“配方”用于将原始特征转换为新特征（线性判别量）：具有最大特征值的特征向量提供了 LD1 的转换配方，具有第二大特征值的特征向量对应于 LD2，依此类推。

将 X 投影到线性判别量 LD 上

3. 从头开始实现线性判别分析（LDA）

为了展示理论和数学的实际应用，我们将从头开始使用 numpy 编写我们自己的 LDA。

import numpy as np

class LDA_fs:
    """
    Performs a Linear Discriminant Analysis (LDA)

    Methods
    =======
    fit_transform():
        Fits the model to the data X and Y, derives the transformation matrix W
    and projects the feature matrix X onto the m LDA axes
    """

    def __init__(self, m):
        """
        Parameters
        ==========
        m : int
            Number of LDA axes onto which the data will be projected

        Returns
        =======
        None
        """
        self.m = m

    def fit_transform(self, X, Y):
        """
        Parameters
        ==========
        X : array(n_samples, n_features)
            Feature matrix of the dataset
        Y = array(n_samples)
            Label vector of the dataset

        Returns
        =======
        X_transform : New feature matrix projected onto the m LDA axes

        """

        # Get number of features (columns)
        self.n_features = X.shape[1]
        # Get unique class labels
        class_labels = np.unique(Y)
        # Get the overall mean vector (independent of the class labels)
        mean_overall = np.mean(X, axis=0)  # Mean of each feature
        # Initialize both scatter matrices with zeros
        SW = np.zeros((self.n_features, self.n_features))  # Within scatter matrix
        SB = np.zeros((self.n_features, self.n_features))  # Between scatter matrix

        # Iterate over all classes and select the corresponding data
        for c in class_labels:
            # Filter X for class c
            X_c = X[Y == c]
            # Calculate the mean vector for class c
            mean_c = np.mean(X_c, axis=0)
            # Calculate within-class scatter for class c
            SW += (X_c - mean_c).T.dot((X_c - mean_c))
            # Number of samples in class c
            n_c = X_c.shape[0]
            # Difference between the overall mean and the mean of class c --> between-class scatter
            mean_diff = (mean_c - mean_overall).reshape(self.n_features, 1)
            SB += n_c * (mean_diff).dot(mean_diff.T)

        # Determine SW^-1 * SB
        A = np.linalg.inv(SW).dot(SB)
        # Get the eigenvalues and eigenvectors of (SW^-1 * SB)
        eigenvalues, eigenvectors = np.linalg.eig(A)
        # Keep only the real parts of eigenvalues and eigenvectors
        eigenvalues = np.real(eigenvalues)
        eigenvectors = np.real(eigenvectors.T)

        # Sort the eigenvalues descending (high to low)
        idxs = np.argsort(np.abs(eigenvalues))[::-1]
        self.eigenvalues = np.abs(eigenvalues[idxs])
        self.eigenvectors = eigenvectors[idxs]
        # Store the first m eigenvectors as transformation matrix W
        self.W = self.eigenvectors[0:self.m]

        # Transform the feature matrix X onto LD axes
        return np.dot(X, self.W.T)

4. 将 LDA 应用于工业数据集

为了看到 LDA 的实际应用，我们将其应用于生产环境中的典型任务。我们有来自一个简单制造流水线的数据，该流水线只有 7 个工作站。每个工作站发送一个数据点（是的，我知道，只有一个数据点是非常不现实的）。不幸的是，我们的生产线产生了大量的不良品，我们希望找出哪些工作站对这一现象负责。

首先，我们加载数据并初步查看。

import pandas as pd

# URL to Github repository
url = "https://raw.githubusercontent.com/IngoNowitzky/LDA_Medium/main/production_line_data.csv"

# Read csv to DataFrame
data = pd.read_csv(url)

# Print first 5 lines
data.head()

接下来，我们使用 Pandas 中的 .describe() 方法来研究数据的分布。

# Show average, min and max of numerical values
data.describe()

我们看到有 20,000 个数据点，测量范围从 -5 到 +150。由此，我们需要记住，稍后需要对数据集进行归一化：不同数值的量级，否则会对 LDA 产生负面影响。

我们有多少个良品和多少个不良品？

# Count the number of good and bad parts
label_counts = data['Label'].value_counts()

# Display the results
print("Number of Good and Bad Parts:")
print(label_counts)

我们有 19,031 个良品和 969 个不良品。数据集严重失衡是进一步分析的一个问题。因此，我们选择所有不良品和等数量的随机选择的良品进行后续处理。

# Select all bad parts
bad_parts = data[data['Label'] == 'Bad']

# Randomly select an equal number of good parts
good_parts = data[data['Label'] == 'Good'].sample(n=len(bad_parts), random_state=42)

# Combine both subsets to create a balanced dataset
balanced_data = pd.concat([bad_parts, good_parts])

# Shuffle the combined dataset
balanced_data = balanced_data.sample(frac=1, random_state=42).reset_index(drop=True)

# Display the number of good and bad parts in the balanced dataset
print("Number of Good and Bad Parts in the balanced dataset:")
print(balanced_data['Label'].value_counts())

现在，让我们将从头开始实现的 LDA 应用于平衡后的数据集。我们使用 sklearn 中的 StandardScaler 来对每个特征的测量值进行归一化，使其均值为 0，标准差为 1。我们选择一个线性判别轴 (m=1)，将数据投影到该轴上。这有助于我们清楚地看到哪些特征在区分良品和不良品方面最为相关，并通过直方图可视化投影后的数据。

import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler

# Separate features and labels
X = balanced_data.drop(columns=['Label'])
y = balanced_data['Label']

# Normalize the features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Perform LDA
lda = LDA_fs(m=1)  # Instanciate LDA object with 1 axis
X_lda = lda.fit_transform(X_scaled, y) # Fit the model and project the data

# Plot the LDA projection
plt.figure(figsize=(10, 6))
plt.hist(X_lda[y == 'Good'], bins=20, alpha=0.7, label='Good', color='green')
plt.hist(X_lda[y == 'Bad'], bins=20, alpha=0.7, label='Bad', color='red')
plt.title("LDA Projection of Good and Bad Parts")
plt.xlabel("LDA Component")
plt.ylabel("Frequency")
plt.legend()
plt.show()

# Examine feature contributions to the LDA component
feature_importance = pd.DataFrame({'Feature': X.columns, 'LDA Coefficient': lda.W[0]})
feature_importance = feature_importance.sort_values(by='LDA Coefficient', ascending=False)

# Display feature importance
print("Feature Contributions to LDA Component:")
print(feature_importance)

将特征矩阵投影到一个 LD（m=1）上

特征重要性 = 各站点在类分离中的贡献有多大？

直方图显示，我们能够很好地区分良品和不良品，只有少量重叠。这已经是一个积极的结果，表明我们的 LDA 成功了。

表格“LDA 组件的特征贡献”中的“LDA 系数”表示我们转换矩阵W的第一列（也是唯一一列，因为m=1）的特征向量。它们表示从各个工站的标准化测量值在 LDA 轴上的投影方向和大小。表中的数值按降序排列。我们需要同时从表格的顶部和底部读取，因为系数的绝对值表示每个工站在类别分离中的重要性，进而表示其对生产缺陷部件的贡献。符号表示较低或较高的测量值是否会增加缺陷部件的可能性。让我们仔细看看我们的例子：

最大的绝对值来自工站 4，其系数为-0.672。这意味着工站 4 对部件故障的影响最强。由于负号，较高的正测量值会投影到负的线性判别轴（LD）。直方图显示，负的 LD 与良好（绿色）部件相关。相反，在该工站的低值和负值会增加部件故障的可能性。

第二大绝对值来自工站 2，其系数为 0.557。因此，这个工站是导致部件故障的第二大贡献者。正号表示较高的正测量值会投影到正的 LD。从直方图中我们知道，较高的正 LD 值与较高的故障概率相关。换句话说，工站 2 的高测量值会导致部件故障。

第三高的系数来自工站 7，其值为-0.486。这使得工站 7 成为部件故障的第三大贡献者。负号再次表明，在该工站的较高正值会导致负 LD（这对应于良好的部件）。相反，在该工站的低值和负值会导致部件故障。

所有其他 LDA 系数的数量级都比上述三者小得多，因此，相关的工站对部件故障没有影响。

我们的 LDA 分析结果正确吗？正如你可能已经猜到的，生产数据集是合成生成的。我将所有部件标记为有缺陷，其中工站 2 的测量值大于 0.5，工站 4 的值小于-2.5，工站 7 的值小于 3。事实证明，LDA 完全准确地命中了目标！

# Determine if a sample is a good or bad part based on the conditions
data['Label'] = np.where(
    (data['Station_2'] > 0.5) & (data['Station_4'] < -2.5) & (data['Station_7'] < 3),
    'Bad',
    'Good'
)

5. 结论

线性判别分析（LDA）不仅可以减少数据集的复杂性，还能突出驱动类别分离的关键特征，因此在识别生产系统中的故障原因时非常有效。它是一种直接而强大的方法，具有实际应用，并且在像scikit-learn这样的库中容易获取。

为了实现最佳效果，平衡数据集（确保每个类别中样本数量相似）并进行归一化（均值为 0，标准差为 1）是至关重要的。

下次当你处理包含类别标签和多个特征的大型数据集时，为什么不尝试一下 LDA 呢？

产品分析中的线性优化

原文：towardsdatascience.com/linear-optimisations-in-product-analytics-ace19e925677?source=collection_archive---------2-----------------------#2024-12-18

解决背包问题

Mariya Mansurova

·发表于 Towards Data Science ·阅读时间 11 分钟·2024 年 12 月 18 日

由 DALL-E 3 生成的图像

这可能令人惊讶，但在本文中，我想谈谈背包问题，这个经典的优化问题已经被研究了一个多世纪。根据维基百科，该问题的定义如下：

给定一组物品，每个物品都有一个重量和一个价值，确定应该包括哪些物品，以便总重量小于或等于给定的限制，同时总价值尽可能大。

虽然产品分析师可能不会亲自打包背包，但其背后的数学模型与我们许多任务高度相关。背包问题在产品分析中有许多现实世界的应用。以下是一些例子：

营销活动： 营销团队在不同渠道和区域运营活动时，预算和能力有限。他们的目标是最大化某个 KPI，例如新用户数量或收入，同时遵守现有的约束条件。
零售空间优化： 一家零售商在店铺中有有限的物理空间，他们希望通过优化产品摆放来最大化收入。
产品发布优先级： 在发布新产品时，运营团队的能力可能有限，需要对特定市场进行优先排序。

这样的任务以及类似的任务非常常见，许多分析师会定期遇到它们。因此，在本文中，我将探讨解决此类问题的不同方法，涵盖从朴素的简单技巧到更先进的线性规划方法。

我选择这个话题的另一个原因是，线性规划是处方分析中最强大和最流行的工具之一——一种专注于为利益相关者提供可操作选项以做出明智决策的分析方法。因此，我认为这是任何分析师工具包中必备的技能。

案例

让我们直接进入将要探讨的案例。假设我们是一个营销团队的一部分，正在为下个月计划活动。我们的目标是最大化关键绩效指标（KPI），例如获取的用户数量和收入，同时在有限的营销预算内运营。

我们已估算了不同国家和渠道的各种营销活动的预期结果。以下是我们拥有的数据：

country — 我们可以进行一些促销活动的市场；
channel — 获取方式，例如社交网络或影响者活动；
users — 在促销活动一个月内预期获得的用户数量；
cs_contacts — 新用户产生的增量客户支持联系；
marketing_spending — 活动所需的投资；
revenue — 从已获取客户中产生的第一年 LTV（客户终身价值）。

请注意，数据集是合成的，随机生成的，因此不要尝试从中推断任何市场相关的见解。

首先，我计算了高级统计数据，以便查看这些数字。

让我们确定一组最佳的营销活动组合，在保持 3000 万美元营销预算的同时最大化收入。

暴力破解法

乍一看，这个问题可能显得简单：我们可以计算所有可能的营销活动组合并选择最佳的那一个。然而，这可能是一个具有挑战性的任务。

由于有 62 个数据段，每个数据段可以选择包含或排除，因此有 2⁶²种可能的组合。这大约是 4.6×10¹⁸种组合——一个天文数字。

为了更好地理解计算可行性，让我们考虑一个较小的 15 个数据段的子集，并估算一次迭代所需的时间。

import itertools
import pandas as pd
import tqdm

# reading data
df = pd.read_csv('marketing_campaign_estimations.csv', sep = '\t')
df['segment'] = df.country + ' - ' + df.channel

# calculating combinations
combinations = []
segments = list(df.segment.values)[:15]
print('number of segments: ', len(segments))

for num_items in range(len(segments) + 1):
  combinations.extend(
      itertools.combinations(segments, num_items)
  )
print('number of combinations: ', len(combinations))

tmp = []
for selected in tqdm.tqdm(combinations):
    tmp_df = df[df.segment.isin(selected)]
    tmp.append(
        {
        'selected_segments': ', '.join(selected),
        'users': tmp_df.users.sum(),
        'cs_contacts': tmp_df.cs_contacts.sum(),
        'marketing_spending': tmp_df.marketing_spending.sum(),
        'revenue': tmp_df.revenue.sum()
        }
    )

# number of segments:  15
# number of combinations:  32768

处理 15 个数据段大约花费了 4 秒钟，这使我们能够每秒处理约 7,000 次迭代。根据这个估算，让我们计算处理 62 个数据段所需的执行时间。

2**62 / 7000 / 3600 / 24 / 365
# 20 890 800.6

采用暴力破解法，回答我们问题大约需要 2090 万年——显然这不是一个可行的选项。

执行时间完全由数据段的数量决定。移除一个数据段可以将时间减少一半。考虑到这一点，让我们探讨合并数据段的可能方式。

像往常一样，较小的细分市场比大规模的更多，所以合并它们是一个合理的步骤。然而，值得注意的是，这种方法可能会降低准确性，因为多个细分市场被合并为一个。尽管如此，它仍然可以产生一个“足够好”的解决方案。

为了简化，我们将合并所有贡献少于 0.1%收入的细分市场。

df['share_of_revenue'] = df.revenue/df.revenue.sum() * 100
df['segment_group'] = list(map(
    lambda x, y: x if y >= 0.1 else 'other',
    df.segment,
    df.share_of_revenue
))

print(df[df.segment_group == 'other'].share_of_revenue.sum())
# 0.53
print(df.segment_group.nunique())
# 52

采用这种方法，我们将把十个细分市场合并为一个，占总收入的 0.53%（可能的误差范围）。剩余 52 个细分市场后，我们可以在仅 20.4 千年内获得解决方案。虽然这是一个显著的改进，但仍然不够充分。

你可以考虑其他针对特定任务量身定制的启发式方法。例如，如果你的约束是一个比率（例如，联系率 = 客户服务联系数 / 用户 ≤ 5%），你可以将所有符合约束的细分市场归为一组，因为最优解会包括所有这些细分市场。然而，在我们的案例中，我看不出有任何其他策略来减少细分市场的数量，因此暴力计算似乎不切实际。

也就是说，如果组合的数量相对较小，并且暴力计算可以在合理的时间内执行，那么它可以是一个理想的方法。它简单易开发，并且提供准确的结果。

天真方法：查看表现最好的细分市场

由于暴力计算不适合计算所有组合，我们考虑使用一种更简单的算法来解决这个问题。

一种可能的方法是专注于表现最好的细分市场。我们可以通过计算每花费一美元所获得的收入来评估细分市场的表现，然后根据这个比率对所有活动进行排序，选择符合营销预算的表现最佳的活动。让我们来实现这个方法。

df['revenue_per_spend'] = df.revenue / df.marketing_spending 
df = df.sort_values('revenue_per_spend', ascending = False)
df['spend_cumulative'] = df.marketing_spending.cumsum()
selected_df = df[df.spend_cumulative <= 30000000]
print(selected_df.shape[0])
# 48 
print(selected_df.revenue.sum()/1000000)
# 107.92

采用这种方法，我们选择了 48 个活动，并获得了 107.92 百万美元的收入。

不幸的是，尽管逻辑看起来合理，但它并不是最大化收入的最佳解决方案。让我们来看一个只有三个营销活动的简单例子。

使用选择最佳市场的方法，我们将选择法国，并获得 6800 万美元的收入。然而，如果选择另外两个市场，我们可以获得显著更好的结果——9750 万美元。关键点在于，我们的算法不仅优化了最大化收入，还优化了选择的细分市场数量。因此，这种方法将无法得到最佳结果，尤其是考虑到它无法应对多个约束条件。

线性规划

由于所有简单的方法都失败了，我们必须回到基础理论，探讨这个问题背后的理论。幸运的是，背包问题已经研究了许多年，我们可以应用优化技术，在几秒钟内解决它，而不是几年。

我们试图解决的问题是一个整数规划问题，实际上它是线性规划的一个子领域。

我们稍后会讨论这个方法，但首先，让我们对优化过程的关键概念达成一致。每个优化问题都由以下几个部分组成：

决策变量：模型中可以调整的参数，通常代表我们希望做出的杠杆或决策。
目标函数：我们旨在最大化或最小化的目标变量。无需多言，它必须依赖于决策变量。
约束条件：对决策变量施加的条件，定义了它们的可能值。例如，确保团队不能工作负数小时。

牢记这些基本概念，我们可以将线性规划定义为满足以下条件的场景：

目标函数是线性的。
所有约束都是线性的。
决策变量是实数值的。

整数规划与线性规划非常相似，唯一的区别是：一些或所有的决策变量必须是整数。虽然这看起来像是一个小的变化，但它显著影响了解决方法，需要比线性规划更复杂的方法。一种常见的技术是分支定界法。我们不会在这里深入探讨理论，但你总是可以在网上找到更详细的解释。

对于线性优化，我更喜欢广泛使用的 Python 包PuLP。不过，也有其他可用的选择，比如Python MIP或Pyomo。让我们通过 pip 安装 PuLP。

! pip install pulp

现在，是时候将我们的任务定义为一个数学优化问题了。具体步骤如下：

定义决策变量的集合（我们可以调整的杠杆）。
对齐目标函数（我们将优化的变量）。
制定约束条件（在优化过程中必须满足的条件）。

让我们逐步进行。但首先，我们需要创建问题对象并设置目标——在我们的案例中是最大化。

from pulp import *
problem = LpProblem("Marketing_campaign", LpMaximize)

下一步是定义决策变量——在优化过程中我们可以改变的参数。我们的主要决策是是否开展市场营销活动。因此，我们可以将其建模为每个细分市场的二元变量集（0 或 1）。让我们通过 PuLP 库来实现。

segments = range(df.shape[0])  
selected = LpVariable.dicts("Selected", segments, cat="Binary")

之后，是时候对目标函数进行对齐了。如前所述，我们希望最大化收入。总收入将是所有选定细分市场的收入之和（其中decision_variable = 1）。因此，我们可以将此公式定义为每个细分市场的预期收入乘以决策二元变量的总和。

problem += lpSum(
  selected[i] * list(df['revenue'].values)[i] 
  for i in segments
)

最后一步是添加约束。让我们从一个简单的约束开始：我们的市场营销支出必须低于 3000 万美元。

problem += lpSum(
    selected[i] * df['marketing_spending'].values[i]
    for i in segments
) <= 30 * 10**6

提示：你可以打印problem来仔细检查目标函数和约束条件。

现在我们已经定义了所有内容，可以运行优化并分析结果。

problem.solve()

运行优化只需不到一秒钟，与暴力破解需要数千年相比，效率显著提升。

Result - Optimal solution found

Objective value:                110162662.21000001
Enumerated nodes:               4
Total iterations:               76
Time (CPU seconds):             0.02
Time (Wallclock seconds):       0.02

让我们将模型执行的结果——表示每个区段是否被选择的决策变量——保存到我们的数据框中。

df['selected'] = list(map(lambda x: x.value(), selected.values()))
print(df[df.selected == 1].revenue.sum()/10**6)
# 110.16

它就像魔法一样快速提供解决方案。此外，请注意，相比我们的直觉方法，我们达到了更高的收入：1.1016 亿美元对比 1.0792 亿美元。

我们已经用一个简单的例子测试了整数规划，该例子仅涉及一个约束，但我们可以进一步扩展。例如，我们可以为 CS 联系方式添加额外的约束，以确保我们的运营团队能够以健康的方式处理需求：

额外的 CS 联系方式数量 ≤ 5000
联系率（CS 联系方式/用户）≤ 0.042

# define the problem
problem_v2 = LpProblem("Marketing_campaign_v2", LpMaximize)

# decision variables
segments = range(df.shape[0]) 
selected = LpVariable.dicts("Selected", segments, cat="Binary")

# objective function
problem_v2 += lpSum(
  selected[i] * list(df['revenue'].values)[i] 
  for i in segments
)

# Constraints
problem_v2 += lpSum(
    selected[i] * df['marketing_spending'].values[i]
    for i in segments
) <= 30 * 10**6

problem_v2 += lpSum(
    selected[i] * df['cs_contacts'].values[i]
    for i in segments
) <= 5000

problem_v2 += lpSum(
    selected[i] * df['cs_contacts'].values[i]
    for i in segments
) <= 0.042 * lpSum(
    selected[i] * df['users'].values[i]
    for i in segments
)

# run the optimisation
problem_v2.solve()

代码非常简单，唯一有点复杂的部分是将比例约束转换为更简单的线性形式。

另一个可能的约束条件是限制选定选项的数量，例如，限制为 10 个。这个约束在规范性分析中非常有用，比如当你需要选择最具影响力的前 N 个焦点区域时。

# define the problem
problem_v3 = LpProblem("Marketing_campaign_v2", LpMaximize)

# decision variables
segments = range(df.shape[0]) 
selected = LpVariable.dicts("Selected", segments, cat="Binary")

# objective function
problem_v3 += lpSum(
  selected[i] * list(df['revenue'].values)[i] 
  for i in segments
)

# constraints
problem_v3 += lpSum(
    selected[i] * df['marketing_spending'].values[i]
    for i in segments
) <= 30 * 10**6

problem_v3 += lpSum(
    selected[i] for i in segments
) <= 10

# run the optimisation
problem_v3.solve()
df['selected'] = list(map(lambda x: x.value(), selected.values()))
print(df.selected.sum())
# 10

另一个可以调整我们问题的选项是改变目标函数。我们一直在优化收入，但假设我们希望同时最大化收入和新增用户。为此，我们可以稍微修改目标函数。

让我们考虑最好的方法。我们可以计算收入和新增用户的总和并力图最大化它。然而，由于收入通常比新增用户高出 1000 倍，结果可能会倾向于最大化收入。为了使这些指标更具可比性，我们可以基于它们的总和来规范化收入和用户数。然后，我们可以将目标函数定义为这些比例的加权和。我会给这两个指标赋予相等的权重（0.5），但你可以调整权重，使其中一个指标的权重更大。

# define the problem
problem_v4 = LpProblem("Marketing_campaign_v2", LpMaximize)

# decision variables
segments = range(df.shape[0]) 
selected = LpVariable.dicts("Selected", segments, cat="Binary")

# objective Function
problem_v4 += (
    0.5 * lpSum(
        selected[i] * df['revenue'].values[i] / df['revenue'].sum()
        for i in segments
    )
    + 0.5 * lpSum(
        selected[i] * df['users'].values[i] / df['users'].sum()
        for i in segments
    )
)

# constraints
problem_v4 += lpSum(
    selected[i] * df['marketing_spending'].values[i]
    for i in segments
) <= 30 * 10**6

# run the optimisation
problem_v4.solve()
df['selected'] = list(map(lambda x: x.value(), selected.values()))

我们得到了最优目标函数值 0.6131，收入为 1.0436 亿美元，新增用户为 136,370 人。

就这样！我们学会了如何使用整数规划来解决各种优化问题。

你可以在GitHub上找到完整的代码。

总结

在本文中，我们探讨了解决背包问题及其在产品分析中的类比问题的不同方法。

我们从暴力破解方法开始，但很快意识到它会占用不合理的时间。
接下来，我们尝试通过直觉选取表现最好的区段，但这种方法得出的结果是错误的。
最后，我们转向了整数规划，学习了如何将我们的产品任务转化为优化模型并有效地解决它们。

有了这个，我希望你已经为你的工具包增添了另一项有价值的分析工具。

非常感谢你阅读本文。我希望这篇文章对你有所启发。如果你有任何后续问题或意见，请在评论区留言。

参考资料

除非另有说明，所有图片均由作者制作。

线性规划：带分支定界的整数线性规划

原文：towardsdatascience.com/linear-programming-integer-linear-programming-with-branch-and-bound-fe25a0f8ae55?source=collection_archive---------13-----------------------#2024-11-19

第四部分：将线性规划优化扩展到离散决策变量

·发布于Towards Data Science ·9 分钟阅读·2024 年 11 月 19 日

图片来自 Pexels.com，摄影：Min An

在本系列之前的内容中，我们讨论了严格的线性规划——其中目标函数、约束条件和决策变量都是线性且连续的。这种线性设置具有一些非常好的特性，但它的灵活性较差。本文将讨论如何使用一种名为整数线性规划（ILP）的工具，允许使用离散决策变量。

这是我写的关于线性规划系列文章的第四篇。其他文章（包括一个介绍部分——如果你不熟悉线性规划，可以查看）可以在这里找到：

线性规划

查看列表4 篇故事

本文将涵盖以下主题：

何时需要离散决策变量
分支定界算法如何解决整数线性规划问题
整数线性规划的优缺点…

线性规划优化：基础

原文：towardsdatascience.com/linear-programming-optimization-foundations-2f12770f66ca?source=collection_archive---------3-----------------------#2024-07-22

第一部分 - 基本概念与示例

·发布于数据科学前沿 ·11 分钟阅读·2024 年 7 月 22 日

线性规划是一种强大的优化技术，广泛应用于许多领域，以帮助改进决策过程。这是一个系列文章的第一部分，将涵盖与线性规划相关的重要主题。本文是最基础的部分，旨在介绍基本概念，之后将深入探讨更高级的线性规划话题。

在本文中，我们将：

讨论什么构成了一个线性规划问题
了解线性规划是如何工作的以及它为何如此强大
在 Python 中运行一个线性规划示例

我个人认为，例子是学习技术主题的非常有效的途径。出于这个原因，本文将通过一个简单的例子进行讲解。我将在下一节介绍这个例子。

在我们深入之前，如果你对优化的基本概念和术语不太熟悉，我写了一篇优化入门文章，建议你在继续阅读之前先查看一下（本文中有很多常见的优化术语，我没有在文中定义）。

线性规划优化：单纯形法

原文：towardsdatascience.com/linear-programming-optimization-the-simplex-method-b2f912e4c6fd?source=collection_archive---------7-----------------------#2024-09-10

第三部分：算法的幕后

·发表于Towards Data Science ·13 分钟阅读·2024 年 9 月 10 日

图片来自 Pexels.com 的 Daniel Cassey Pahati

到目前为止，本系列已涵盖了线性规划的基础知识。在这篇文章中，我们将从基本概念转向更深入的算法细节！这篇文章将介绍单纯形法，它是解决线性规划问题时常用的算法。虽然我们将通过手工计算一个简单的线性规划例子来应用单纯形法，但我们的重点将放在算法的直觉理解上，而非记住算法的步骤（这些步骤可以交给计算机来处理！）。

下面是我们将要讨论的内容：

为什么需要单纯形法
从图形解法到代数解法
演示单纯形法如何通过一个简单的例子来工作

这是包含我至今为止为此系列撰写的所有文章的列表链接：

线性规划

查看列表4 篇故事！

为什么需要单纯形法

线性规划：库存切割问题

原文：towardsdatascience.com/linear-programming-the-stock-cutting-problem-dc6ba3bf3de1?source=collection_archive---------4-----------------------#2024-08-22

第二部分 — 线性规划示例深入分析

来源：Yang, Songlin, et al. “Gated linear attention transformers with hardware-efficient training.” arXiv preprint arXiv:2312.06635(2023).

·发布于 Towards Data Science ·12 分钟阅读·2024 年 8 月 22 日

图片由 Mark Stebnicki 提供，来自 Pexels.com

这篇文章深入探讨了线性规划如何解决一个特定的问题——‘库存切割’问题。在开始深入讲解本系列中的线性规划细节之前，我想提供一个具体的例子。这篇文章将使用一些优化术语，这些术语没有在文中定义——我写了一篇优化基础的文章，涵盖了这些术语和其他基本概念。

在本文中，我们将讨论：

库存切割问题定义

2. 问题难度

3. 用 Python 解决问题

这里是该系列的第一篇文章和我提到的优化基础文章的链接：

## 线性规划优化：基础知识

第一部分 — 基本概念和例子

towardsdatascience.com

线性回归与因果结论

原文：towardsdatascience.com/linear-regressions-for-causal-conclusions-34c6317c5a11?source=collection_archive---------0-----------------------#2024-04-10

一个简单而强大的决策工具

Mariya Mansurova

·发布于 Towards Data Science ·阅读时间 21 分钟·2024 年 4 月 10 日

图片来自 DALL-E

我想我们大多数人都听过“相关性不等于因果性”这句话很多次。对于分析师来说，这常常是一个问题，因为我们通常只能看到相关性，但仍然想做出因果推论。

让我们通过几个例子更好地理解这种差异。我想从日常生活中的一个案例开始，而不是数字世界中的案例。

1975 年，丹麦开展了一项大型人口研究。这项研究被称为哥本哈根市心脏研究（CCHS）。研究人员收集了约 2 万名男女的资料，并对这些人进行了几十年的跟踪监测。该研究最初的目标是寻找预防心血管疾病和中风的方法。该研究的一个结论是，报告定期打网球的人预期寿命高出 9.7 年。

让我们思考一下如何解读这些信息。它是否意味着如果一个人今天开始每周打网球，他们的预期寿命会增加十年？不幸的是，答案并非完全如此。由于这是一个观察性研究，我们应该小心做出因果推论。可能存在一些其他的影响因素。例如，网球运动员可能更富裕，而我们知道较高的财富与更长的寿命相关。或者，也有可能是做运动的人更注重自己的健康，因此定期进行所有检查。所以，观察性研究可能会高估网球对寿命的影响，因为它没有控制其他因素。

让我们继续讨论一些与产品分析和我们日常工作更相关的例子。客户支持联系的次数可能与客户流失的概率正相关。如果客户不得不联系客户支持十次，他们可能会感到烦躁并停止使用我们的产品，而那些从未遇到问题并且对服务感到满意的客户可能永远不会有任何问题需要咨询。

这是否意味着，如果我们减少客户支持联系的次数，就能提高客户保持率？我敢打赌，如果我们隐藏联系信息并大幅减少客户支持联系的次数，我们并不能减少客户流失，因为流失的实际根本原因不是客户支持联系，而是客户对产品的不满，这导致了客户既联系了我们，又停止使用我们的产品。

我希望通过这些例子，你能够对相关性与因果关系的问题有一些直观的理解。

在本文中，我将分享一些从数据中得出因果结论的方法。令人惊讶的是，我们将能够使用最基础的工具——线性回归。

如果我们使用相同的线性回归进行因果推断，你可能会想，通常的方法和因果分析有什么区别？这是一个好问题。让我们通过理解两者之间的差异来开始我们的因果分析之旅。

预测分析与因果分析

预测分析有助于做出预测，并回答类似“如果没有任何变化，我们一年后会有多少客户？”或“这个客户在接下来的七天内购买的概率是多少？”的问题。

因果分析试图理解过程的根本原因。它可能帮助你回答类似“如果我们提高订阅费，客户流失的数量会是多少？”或者“如果我们没有推出这项情人节促销活动，会有多少客户签订我们的订阅？”这样的“假如”问题。

因果问题似乎比预测问题更复杂。然而，这两种方法往往使用相同的工具，例如线性回归或逻辑回归。尽管工具相同，但它们的目标完全不同：

对于预测分析，我们尽最大努力基于已知信息预测未来的某个值。因此，主要的关键绩效指标是预测的误差。
在建立因果分析的回归模型时，我们专注于目标值与其他因素之间的关系。模型的主要输出是系数，而不是预测值。

让我们看一个简单的例子。假设我们想要预测活跃客户的数量。

在预测方法中，我们讨论的是基准预测（假设情况保持基本不变）。我们可以使用ARIMA（自回归积分滑动平均）并以先前的数值为基础进行预测。ARIMA 对于预测很有效，但无法告诉你影响 KPI 的因素以及如何改善你的产品。
在因果分析中，我们的目标是寻找数据中的因果关系，因此我们将构建回归模型，识别可能影响我们关键绩效指标（KPI）的因素，如订阅费用、营销活动、季节性等。在这种情况下，我们不仅会得到常规（BAU，business as usual）预测，还能够估计未来的不同“假设情景”。

现在，到了深入因果理论并学习基本术语的时候了。

用例：A/B 测试

随机对照试验（RTC），通常称为 A/B 测试，是从数据中得出因果结论的强大工具。该方法假设我们是随机分配治疗，并且它帮助我们消除偏差（因为在没有治疗的情况下，组之间是相等的）。

为了练习解决此类任务，我们将查看一个基于合成数据的示例。假设我们构建了一个基于 LLM 的工具，帮助客服人员更快速地回答问题。为了衡量其效果，我们将该工具引入到一半的客服人员中，并且我们希望衡量我们的治疗（基于 LLM 的工具）如何影响结果（客服人员回答客户问题的时间）。

让我们快速查看一下我们拥有的数据。

以下是我们记录的参数描述：

case_id — 案例的唯一 ID。
agent_id — 代理的唯一 ID。
treatment 如果代理在实验组并有机会使用 LLM，则为 1，0 — 否则。
time_spent_mins — 回答客户问题所花费的分钟数。
cs_center — 客户支持中心。我们与多个客户支持中心合作。我们在其中一些中心启动了这个实验，因为在这些中心实施较为容易。这样的做法也帮助我们避免了污染（实验组和控制组的代理之间的互动可能会互相影响）。
complexity 等于 low、medium 或 high。该特征基于客户问题的类别，并定义代理处理此案件所需的时间。
tenure — 代理开始工作的月份数。
passed_training — 代理是否通过了 LLM 培训。该值仅对实验组为 True，因为控制组的代理没有接受此培训。
within_sla 等于 1，表示代理能够在 SLA（15 分钟）内回答问题。

如往常一样，让我们先从数据的高层次概述开始。我们有相当多的数据点，因此我们很可能能够获得统计上显著的结果。此外，我们可以看到实验组的平均响应时间明显较低，因此我们可以希望 LLM 工具确实有所帮助。

我通常还会查看实际的分布，因为平均统计数据可能具有误导性。在这种情况下，我们可以看到两个单峰分布，没有明显的离群值。

图片来自作者

经典统计方法

分析 A/B 测试的经典方法是使用统计公式。使用 scipy 包，我们可以计算两个均值之间差异的置信区间。

# defining samples
control_values = df[df.treatment == 0].time_spent_mins.values
exp_values = df[df.treatment == 1].time_spent_mins.values

# calculating p-values
from scipy.stats import ttest_ind

ttest_ind(exp_values, control_values)
# Output: TtestResult(statistic=-70.2769283935386, pvalue=0.0, df=89742.0)

我们得到的 p 值低于 1%。因此，我们可以拒绝零假设，得出结论：控制组和实验组在每个案件的平均处理时间上存在差异。为了了解效应大小，我们还可以计算置信区间。

from scipy import stats
import numpy as np

# Calculate sample statistics
mean1, mean2 = np.mean(exp_values), np.mean(control_values)
std1, std2 = np.std(exp_values, ddof=1), np.std(control_values, ddof=1)
n1, n2 = len(exp_values), len(control_values)
pooled_std = np.sqrt(((n1 - 1) * std1**2 + (n2 - 1) * std2**2) / (n1 + n2 - 2))
degrees_of_freedom = n1 + n2 - 2
confidence_level = 0.95

# Calculate margin of error
margin_of_error = stats.t.ppf((1 + confidence_level) / 2, degrees_of_freedom) * pooled_std * np.sqrt(1 / n1 + 1 / n2)

# Calculate confidence interval
mean_difference = mean1 - mean2
conf_interval = (mean_difference - margin_of_error, 
    mean_difference + margin_of_error)

print("Confidence Interval:", list(map(lambda x: round(x, 3), conf_interval)))
# Output: Confidence Interval: [-1.918, -1.814]

如预期的那样，由于 p 值低于 5%，我们的置信区间不包括 0。

传统方法是有效的。然而，我们可以通过线性回归得到相同的结果，这也将使我们能够进行更深入的分析。所以，让我们讨论这种方法。

线性回归基础

如我们之前讨论的那样，观察同一对象的两种潜在结果（有处理和无处理）是不可能的。由于我们无法单独估算每个对象的影响，因此我们需要一个模型。让我们假设常数处理效应。

然后，我们可以以以下方式写出结果（处理时间）和处理之间的关系，其中

baseline 是一个常数，表示结果的基本水平，
residual 代表我们现在不关心的其他潜在关系（例如，代理的成熟度或案件的复杂性）。

这是一条线性方程，我们可以使用线性回归来获得impact变量的估计值。我们将使用OLS（普通最小二乘法）函数，来自statsmodels包。

import statsmodels.formula.api as smf
model = smf.ols('time_spent_mins ~ treatment', data=df).fit()
model.summary().tables[1]

结果中，我们得到了所有需要的信息：效果估计（treatment变量的系数）、其 p 值和置信区间。

由于 p 值极小（明显低于 1%），我们可以认为效果显著，并且可以说我们的基于 LLM 的工具在 95%的置信区间内，帮助减少了 1.866 分钟的案件处理时间（1.814, 1.918）。你可以注意到，我们得到了与之前统计公式完全相同的结果。

添加更多变量

如承诺的那样，我们可以使用线性回归进行更复杂的分析，并考虑更多的因素，所以下来进行分析。在最初的方法中，我们只使用了一个回归变量——treatment标志。但是，我们可以添加更多的变量（例如，complexity）。

在这种情况下，impact将显示考虑了模型中所有其他变量的影响后的估计（在我们的例子中——任务复杂性）。让我们进行估计。将更多的变量添加到回归模型中非常简单——我们只需在方程中添加另一个组件。

import statsmodels.formula.api as smf
model = smf.ols('time_spent_mins ~ treatment + complexity', data=df).fit()
model.summary().tables[1]

现在，我们看到效果的估计值略有增加——1.91 分钟对比之前的 1.87 分钟。同时，误差减小了（0.015 对比 0.027），置信区间也变得更窄了。

你还可以注意到，由于复杂性是一个分类变量，它被自动转换成了一组虚拟变量。因此，我们得到了低复杂度任务为-9.8 分钟，中等复杂度任务为-4.7 分钟的估计值。

让我们试着理解为什么在添加复杂度后我们得到了更可信的结果。客户案件的处理时间显著依赖于任务的复杂性。因此，复杂性负责了我们变量方差的很大一部分。

图片由作者提供

正如我之前提到的，treatment的系数在考虑了方程中所有其他因素后，估算了影响。当我们将复杂度添加到我们的线性回归中时，它减少了残差的方差，这就是为什么我们得到了一个更窄的时间置信区间。

让我们再确认一下复杂性是否解释了方差的显著比例。我们可以看到一个显著的下降：时间花费的方差为 16.6，但当考虑复杂性时，它减少到了仅为 5.9。

time_model = smf.ols('time_spent_mins ~ complexity', data=df).fit()

print('Initial variance: %.2f' % (df.time_spent_mins.var()))
print('Residual variance after accounting for complexity: %.2f' \
  % (time_model.resid.var()))

# Output: 
# Initial variance: 16.63
# Residual variance after accounting for complexity: 5.94

所以，我们可以看到，向线性回归中添加一个可以预测结果变量的因素，可以改善你的效应估计。此外，值得注意的是，这个变量与治疗分配无关（每个复杂度的任务有相等的机会分配到控制组或实验组）。

传统上，因果图被用来显示变量之间的关系。让我们画出这样的图来表示我们当前的情况。

图片由作者提供

非线性关系

到目前为止，我们只看了线性关系，但有时候，仅仅线性模型并不足以描述我们的情况。

让我们来看看实验组代理人应当通过的 LLM 训练数据。只有一半的代理人通过了 LLM 训练并学会了如何有效地使用新工具。

我们可以看到，通过训练的处理组和未通过训练的代理人在平均时间上有显著差异。

图片由作者提供

所以，我们应该期待这两组在处理上的不同影响。我们可以使用非线性来表达这种关系，并在方程中加入treatment * passed_training项。

model = smf.ols('time_spent_mins ~ treatment * passed_training + complexity', 
    data=df).fit()
model.summary().tables[1]

treatment和passed_training因素也会自动添加到回归模型中。所以，我们将优化以下公式。

我们从线性回归中得到了以下结果。

与通过训练相关的影响没有统计学意义，因为 p 值超过了 5%，而其他系数则显著不同于零。

让我们列出所有不同的情景，并使用我们从线性回归中得到的系数来估计效果。

所以，我们得到了新的处理估计：通过训练的代理人每个案例平均提高 2.5 分钟，而未通过训练的代理人则是 1.3 分钟。

混杂因素

在得出结论之前，值得再检查一下我们所做的一些假设——例如，随机分配。我们已经讨论过，我们在一些计算机科学中心开展了实验。让我们检查不同中心的代理人是否相似，以确保我们的控制组和实验组没有偏差。

我们知道，代理人因经验不同，其表现可能会有显著差异。我们的日常直觉告诉我们，更有经验的代理人会在任务上花费更少的时间。从数据中我们可以看到，确实是这样。

图片由作者提供

让我们看看我们的实验组和对照组是否有相同水平的代理人经验。最简单的方法是查看分布。

图片由作者提供

显然，治疗组的代理比控制组的代理有更多的经验。总体来说，产品团队决定从经验更丰富的代理开始实验是有道理的。然而，这打破了我们关于随机分配的假设。由于控制组和测试组即便没有治疗也存在差异，我们高估了 LLM 工具对代理表现的影响。

让我们回到因果图。代理的经验同时影响治疗分配和输出变量（花费时间）。这类变量被称为混杂因素。

图片来自作者

别担心。我们可以轻松解决这个问题——只需要在我们的方程中包含混杂因素来进行控制。当我们将其添加到线性回归中时，我们开始在固定经验的前提下估计治疗效应，从而消除偏差。让我们试试看。

model = smf.ols('time_spent_mins ~ treatment * passed_training + complexity + tenure', data=df).fit()
model.summary().tables[1]

加入任期后，我们得到了以下结果：

单独考虑通过培训或治疗的影响并无统计学显著性，因为 p 值高于 5%。因此，我们可以得出结论，LLM 助手不会影响代理的表现，除非他们通过了培训。在之前的迭代中，我们看到过一个统计学显著的效果，但那是由于任期混杂偏差造成的。
唯一具有统计学显著性的效果是对于通过培训的治疗组。其结果为 1.07 分钟，95%的置信区间为（1.02，1.11）。
每个月的任期与任务上花费时间减少 0.05 分钟相关。

我们使用的是合成数据，因此可以轻松地将我们的估计与实际效果进行比较。如果代理通过了培训，LLM 工具可以将每个任务所花费的时间减少 1 分钟，因此我们的估计相当准确。

不良控制

机器学习任务通常很简单：你收集尽可能多的特征数据，尝试拟合一些模型，比较它们的表现，然后选择最佳模型。相反，因果推断需要一些技巧和对所处理过程的深刻理解。一个关键问题是，哪些特征值得纳入回归分析，哪些特征会破坏你的结果。

直到现在，我们添加到线性回归中的所有额外变量都在提高准确性。所以，你可能认为将所有特征都添加到回归分析中将是最佳策略。不幸的是，因果推断并不是那么简单。在本节中，我们将讨论几个额外变量反而降低估计准确性的情况。

例如，我们的数据中有一个客户服务中心。我们基于客户服务中心分配了治疗，因此将其纳入回归分析可能听起来合情合理。让我们试试看。

model = smf.ols('time_spent_mins ~ treatment + complexity + tenure + cs_center', 
    data=df[df.treatment == df.passed_training]).fit()
model.summary().tables[1]

为了简化，我已从数据集和方程中去除非线性因素，筛选出那些治疗组中的代理没有通过 LLM 培训的情况。

如果我们将 CS 中心包含在线性回归中，我们将得到一个荒谬的高估计效果（大约数十亿），但没有统计显著性。因此，这个变量比有帮助更有害。

让我们更新一个因果图，并尝试理解为什么它不起作用。CS 中心是我们治疗的预测因子，但与输出变量没有关系（因此它不是一个混杂变量）。增加一个治疗预测因子会导致多重共线性（就像在我们这个例子中）或减少治疗的方差（因为治疗变化不大，很难估计治疗对输出变量的影响）。因此，将这样的变量加入方程是不好的做法。

图片由作者提供

让我们来看另一个例子。我们有一个within_sla变量，表示代理是否在 15 分钟内完成任务。这个变量能否提高我们的效果估计质量？让我们看看。

model = smf.ols('time_spent_mins ~ treatment + complexity + tenure + within_sla', 
    data=df[df.treatment == df.passed_training]).fit()
model.summary().tables[1]

新的效果估计值大大降低：0.8 分钟对比 1.1 分钟。那么，这就提出了一个问题：哪一个更准确？我们在这个模型中增加了更多参数，因此它更复杂。难道它应该提供更精确的结果吗？不幸的是，情况并不总是这样。让我们深入探讨一下。

在这种情况下，within_sla标志表示代理是否在 15 分钟内解决了问题，或者问题花费了更多时间。因此，如果我们回到我们的因果图，within_sla标志是我们的输出变量（任务所花费的时间）的一个结果。

图片由作者提供

当我们将within_sla标志加入回归并加以控制时，我们开始估计治疗的效果，固定within_sla的值。因此，我们将有两种情况：within_sla = 1和within_sla = 0。让我们看看它们的偏差。

在这两种情况下，偏差不等于 0，这意味着我们的估计是有偏的。乍一看，这似乎有点违反直觉。让我稍微解释一下其中的逻辑。

在第一个方程中，我们比较了使用 LLM 工具和不使用 LLM 工具的代理在 15 分钟内完成任务的情况。之前的分析表明，LLM 工具（我们的治疗手段）通常能加速代理的工作。所以，如果我们比较没有治疗（即代理独立工作而没有 LLM 工具）时预期的任务完成时间，我们应该预期第二组的响应会更快。
类似地，对于第二个方程，我们正在比较没有在 15 分钟内完成任务的代理，即使在 LLM 的帮助下，以及那些独立完成任务的代理。我们应该预期第一组在没有治疗的情况下响应时间更长。

这是选择偏差的一个例子——当我们控制了从处理到输出变量或输出变量结果路径上的一个变量时，就会发生这种情况。在进行线性回归时控制这些变量也会导致偏差估计，所以不要这么做。

分组数据

在某些情况下，你可能没有详细的数据。在我们的例子中，我们可能不知道每个任务单独花费的时间，但知道平均时间。跟踪代理的汇总数据更容易。例如，“在两个小时内，一名代理完成了 15 个中等难度的任务”。我们可以将原始数据进行汇总，从而获得这些统计数据。

agents_df = df.groupby(['agent_id', 'treatment', 'complexity', 'tenure', 
  'passed_training'], as_index = False).aggregate(
    {'case_id': 'nunique', 'time_spent_mins': 'mean'}
)

对于线性回归来说，处理代理级别的数据并不是问题。我们只需要为每个代理指定权重（等于案例的数量）。

 model = smf.ols('time_spent_mins ~ treatment + complexity + tenure', 
    data = agents_df[agents_df.treatment == agents_df.passed_training],
    weights = agents_df[agents_df.treatment == agents_df.passed_training]['case_id'])\
    .fit()
model.summary().tables[1]

对于汇总数据，我们得到的治疗效果的结果大致相同。所以，如果你只有平均数据，也没有问题。

使用案例：观察性数据

我们已经详细查看了用于因果推断的 A/B 测试例子。然而，在许多情况下，我们不能进行适当的随机试验。以下是一些例子：

有些实验是不道德的。例如，你不能强迫学生饮酒或吸烟，看它如何影响他们在大学的表现。
在某些情况下，由于法律限制，你可能无法进行 A/B 测试。例如，你不能对同一产品收取不同的价格。
有时，这简直是不可能的。例如，如果你正在进行大规模的品牌重塑，你将不得不在某一天通过一个大的公关宣布全球推出。

在这种情况下，你必须仅凭观察数据得出结论。让我们看看在这种情况下我们的方法如何发挥作用。我们将使用学生表现数据集来自加州大学欧文分校的机器学习库。

让我们使用这个实际数据集来研究愿意接受高等教育的意愿如何影响数学课程的最终成绩。我们将从一个简单的模型和因果图开始。

图片由作者提供

df = pd.read_csv('student-mat.csv', sep = ';')
model = smf.ols('G3 ~ higher', data=df).fit()
model.summary().tables[1]

我们可以看到，继续教育的意愿在统计上显著地提高了课程的最终成绩，增加了 3.8 分。

然而，可能存在一些混杂因素，我们必须加以控制。例如，父母的教育水平可能同时影响治疗效果（如果父母受过教育，孩子更有可能计划接受高等教育）和结果（受过教育的父母更可能帮助孩子，因此孩子的成绩更高）。让我们将母亲和父亲的教育水平添加到模型中。

图片由作者提供

model = smf.ols('G3 ~ higher + Medu + Fedu', data=df).fit()
model.summary().tables[1]

我们可以看到母亲的教育水平对结果有统计学上的显著影响。我们可能提高了估计的准确性。

然而，我们应该对任何基于观察性数据得出的因果结论持谨慎态度。我们不能确定是否已经考虑了所有混杂变量，并且我们得到的估计是否完全无偏。

此外，解释关系的方向可能会有些棘手。我们确信继续教育的意愿与最终成绩之间存在相关性。然而，我们可以从多个角度来解释这一点：

希望继续接受教育的学生更有动力，因此他们的最终成绩较高。
成绩较高的学生受到学习成功的激励，这就是为什么他们想继续教育的原因。

在观察性数据中，我们只能凭借常识选择一种选项。我们无法仅通过数据推断出这个结论。

尽管存在一些局限性，我们仍然可以使用这个工具尽力得出一些关于世界的结论。正如我提到的，因果推断在很大程度上依赖于领域知识和常识，因此值得花时间在白板旁深思熟虑你所建模的过程。这将有助于你取得卓越的成果。

你可以在GitHub上找到这些示例的完整代码。

总结

我们讨论了一个相当广泛的因果推断主题，让我来总结一下我们所学到的内容：

预测分析的主要目标是获得准确的预测。因果推断侧重于理解变量之间的关系，因此我们更关心模型中的系数，而非实际的预测结果。
我们可以利用线性回归得出因果结论。
理解我们应该在线性回归中添加哪些特征是一门艺术，但这里有一些指导。

— 必须包括混杂变量（同时影响处理和结果的特征）。

— 添加一个能预测输出变量并解释其变化的特征，可以帮助你获得更有信心的估计。

— 避免添加仅影响处理或是输出变量结果的特征。
你可以将这种方法应用于 A/B 测试和观察性数据。然而，对于观察性数据，我们应当对因果结论持谨慎态度，因为我们无法确保已经考虑了所有混杂变量。

非常感谢你阅读这篇文章。如果你有任何后续问题或评论，请在评论区留言。

数据集

Cortez, Paulo. (2014). 学生表现。 UCI 机器学习库 (CC BY 4.0)。 doi.org/10.24432/C5TG7T

参考文献

除非另有说明，所有图片均由作者制作。

本文的灵感来源于《勇敢而真实的因果推断》一书，该书对因果推断的基础进行了精彩的概述。

线性化注意力

原文：towardsdatascience.com/linearizing-attention-204d3b86cc1e?source=collection_archive---------3-----------------------#2024-12-26

打破二次方限制：softmax 注意力的现代替代方案

Shitanshu Bhushan

·发布于 Towards Data Science ·阅读时间 8 分钟·2024 年 12 月 26 日

大型语言模型非常强大，但它们有一个小缺点，即使用 softmax 注意力，这可能会导致计算开销较大。在本文中，我们将探索是否有办法通过某种方式替换 softmax，从而实现线性时间复杂度。

作者提供的图片（使用 Miro Board 创建）

注意力机制基础

我假设你已经了解 ChatGPT、Claude 之类的内容，以及 Transformer 在这些模型中的工作原理。那么，注意力就是这些模型的核心。如果我们考虑普通的 RNN，我们会将所有过去的状态编码到一个隐藏状态中，然后使用这个隐藏状态与新的查询一起得到输出。一个明显的缺点是，你不能把所有信息都存储在一个小小的隐藏状态中。这就是注意力机制的作用，想象一下，对于每一个新的查询，你可以找到最相关的过去数据，并使用这些数据来做出预测。这就是注意力机制的本质。

Transformer 中的注意力机制（大多数当前语言模型背后的架构）涉及键、查询和值的嵌入。Transformer 中的注意力机制通过将查询与键进行匹配来检索相关值。对于每个查询（Q），模型计算与所有可用键（K）的相似度分数，然后利用这些分数创建相应值（Y）的加权组合。这个注意力计算可以表达为：

来源：作者提供的图片

这一机制使模型能够在做出预测时，有选择性地从整个上下文中提取和利用信息。我们在这里使用 softmax，因为它能有效地将原始相似度分数转换为标准化的概率，类似于 k 最近邻机制，其中更高的注意力权重会分配给更相关的键。

好的，现在让我们看一下 1 层注意力的计算成本，

来源：图片由作者提供

Softmax 缺点

从上面的内容可以看出，我们需要计算一个 NxN 矩阵的 softmax，因此，我们的计算成本随着序列长度的增加呈二次增长。对于较短的序列，这没问题，但对于长序列，N=100k+ 时，它变得极其低效。

这给了我们动机：我们能否减少计算成本？这就是线性注意力的作用所在。

线性注意力

由 Katharopoulos 等人提出，线性注意力使用了一种巧妙的技巧，将 softmax 指数表示为一个核函数，表现为特征映射 φ(x) 的点积。利用矩阵乘法的结合律，我们可以将注意力计算重写为线性。下图展示了这一转换：

来源：图片由作者提供

Katharopoulos 等人使用 elu(x) + 1 作为 φ(x)，但任何能够有效逼近指数相似度的核特征映射都可以使用。上述计算成本可以表示为：

来源：图片由作者提供

这样就不再需要计算完整的 N×N 注意力矩阵，并将复杂度降低到 O(Nd²)。其中 d 是嵌入维度，当 N >>> d 时，这实际上是线性复杂度，这通常适用于大规模语言模型。

好的，让我们来看一下线性注意力的递归视角，

来源：图片由作者提供

好的，为什么我们可以在线性注意力中做这个，而不能在 softmax 中做呢？嗯，softmax 不是可分离的，因此我们无法将其写成独立项的乘积。这里值得注意的是，在解码过程中，我们只需要跟踪 S_(n-1)，每生成一个 token 就能达到 O(d²) 的复杂度，因为 S 是一个 d × d 的矩阵。

然而，这种效率带来了一个重要的缺点。由于 S_(n-1) 只能存储 d² 信息（它是一个 d × d 的矩阵），我们面临着一个根本的限制。例如，如果原始上下文长度需要存储 20d² 的信息，你将实际上在压缩过程中丢失 19d² 的信息。这展示了线性注意力中的核心内存效率权衡：通过仅保持固定大小的状态矩阵，我们获得了计算效率，但这种固定大小限制了我们可以保留的上下文信息量，这也给我们提供了引入门控机制的动机。

门控线性注意力

好的，我们已经确定，在使用固定大小的状态矩阵优化效率时，我们不可避免地会遗忘信息。这引出了一个重要的问题：我们能否聪明地选择记住什么信息？这就是门控机制的作用——研究人员将其作为一种选择性地保留重要信息的机制，通过战略性地选择保留哪些信息来尽量减少记忆丧失的影响。门控并不是一个新概念，它在像 LSTM 这样的架构中已经得到广泛应用。

这里的基本变化在于我们如何公式化 Sn，

来源：作者提供的图片

有许多选择可以决定 G，这些选择会导致不同的模型，

这种架构的一个关键优势是，门控函数仅依赖于当前标记 x 和可学习的参数，而不是整个序列历史。由于每个标记的门控计算是独立的，这使得在训练过程中能够高效地进行并行处理——整个序列的所有门控计算可以同时执行。

状态空间模型

当我们想到处理像文本或时间序列这样的序列时，我们的大脑通常会跳到注意力机制或 RNN。但如果我们采取完全不同的方法呢？如果我们不把序列当作序列来处理，而是像 CNN 处理图像一样，通过卷积来处理它们呢？

状态空间模型（SSMs）通过离散线性时不变系统形式化了这种方法：

来源：作者提供的图片

好的，现在让我们看看这与卷积有什么关系，

来源：作者提供的图片

其中 F 是我们从参数（A, B, c）中学习到的滤波器，*表示卷积。

H3通过一种新颖的结构化架构实现了这种状态空间公式，该架构由两个互补的 SSM 层组成。

来源：Fu, Daniel Y., et al. “Hungry hungry hippos: Towards language modeling with state space models.” arXiv preprint arXiv:2212.14052 (2022).

在这里，我们将输入分解为 3 个通道，以模仿 K、Q 和 V。然后，我们使用 2 个 SSM 和 2 个门控来模仿线性注意力，事实证明，这种架构在实践中效果相当不错。

选择性状态空间模型

早些时候，我们看到门控线性注意力如何通过使信息保持过程数据依赖，改进了标准的线性注意力。状态空间模型中也存在类似的限制——控制状态转移和输出的参数 A、B 和 c 是固定的且与数据无关。这意味着每个输入都通过相同的静态系统进行处理，而不考虑其重要性或上下文。

我们可以通过引入时变动态系统，使 SSM（状态空间模型）成为数据依赖的，从而扩展 SSM：

来源：作者提供的图片

关键问题变成了如何将 c_t、b_t 和 A_t 参数化为输入的函数。不同的参数化方式可以导致接近线性或门控注意力机制的架构。

Mamba通过选择性 SSM 模块实现了这种时变状态空间的表达。

来源：Gu, Albert, and Tri Dao. “Mamba: Linear-time sequence modeling with selective state spaces.” arXiv preprint arXiv:2312.00752 (2023).

在这里，Mamba 使用了选择性 SSM 代替了 SSM，并通过输出门控和额外的卷积来提高性能。这是一个非常高层次的思想，解释了 Mamba 如何将这些组件组合成一个高效的序列建模架构。

结论

在本文中，我们探讨了高效序列建模架构的演变。从传统的 softmax 注意力开始，我们识别出其二次复杂度限制，这促使了线性注意力的发展。通过使用核函数重写注意力，线性注意力实现了 O(Nd²)的复杂度，但由于固定大小的状态矩阵，它面临着内存限制。

这种限制促使了门控线性注意力的提出，通过门控机制引入了选择性信息保持。我们接着从状态空间模型的角度进行了探讨，展示了它们如何通过类似卷积的操作来处理序列。从基础 SSM 到时变系统，再到选择性 SSM 的进展，与我们从线性到门控注意力的历程相似——在这两种情况下，使模型更加适应输入数据对于性能至关重要。

通过这些发展，我们看到了一个共同的主题：计算效率与内存容量之间的基本权衡。Softmax 注意力通过保持对整个序列的完全关注，擅长于上下文学习，但代价是二次复杂度。线性变体（包括 SSM）通过固定大小的状态表示实现了高效计算，但这种优化限制了它们保持过去上下文详细记忆的能力。这个权衡继续成为序列建模中的核心挑战，推动着对能够更好平衡这些竞争需求的架构的探索。

想要了解更多相关主题，我建议阅读以下论文：

线性注意力: Katharopoulos, Angelos 等. “Transformers are rnns: Fast autoregressive transformers with linear attention.” 国际机器学习会议. PMLR, 2020.

GLA: Yang, Songlin 等. “Gated linear attention transformers with hardware-efficient training.” arXiv 预印本 arXiv:2312.06635 (2023).

H3: Fu, Daniel Y. 等. “Hungry hungry hippos: Towards language modeling with state space models.” arXiv 预印本 arXiv:2212.14052 (2022).

Mamba: Gu, Albert 和 Tri Dao. “Mamba: Linear-time sequence modeling with selective state spaces.” arXiv 预印本 arXiv:2312.00752 (2023).

Waleffe, Roger 等. “An Empirical Study of Mamba-based Language Models.” arXiv 预印本 arXiv:2406.07887 (2024).

致谢

这篇博客文章的灵感来源于我在 2024 年秋季于密歇根大学研究生课程中的学习。尽管这些课程提供了探索这些主题的基础知识和动机，但本文中的任何错误或误解完全是我个人的责任。这代表了我对这些材料的个人理解和探索。

LingoNaut 语言助手

原文：towardsdatascience.com/lingonaut-language-assistant-6abe3e8b045c?source=collection_archive---------3-----------------------#2024-02-11

使用 Ollama-Python 对讲机进行多语言学习

Nate Cibik

·发表于 Towards Data Science ·阅读时长 11 分钟·2024 年 2 月 11 日

图像由作者使用 DALL-E 3 创建。

我们生活在一个世界真正触手可及的时代，只要我们知道该往哪里看。今天的开源大型语言模型（LLMs）足够强大和紧凑，可以将人类知识的完整集合放置在标准消费级硬件上，提供数小时无广告的深入讨论，涉及无数主题，且无需互联网连接。感谢开源社区的努力，像 Ollama 这样的工具使我们能够在本地提供今天顶级模型的高质量量化版本，并通过简化的 API 与之互动。

这种开发的便利性意味着我们可以减少花费在思考如何构建 LLM 应用上的时间，更多地关注我们想要构建的内容。就个人而言，我一直想学习多种语言，但由于我的生活经历中没有足够的多语言环境，且在旅游语言学习时，因缺乏亲密的朋友可供练习，这种学习往往会显得尴尬，因为我们不得不在陌生人身上进行试探。

这是一个有前景的机会，旨在利用基于大型语言模型（LLM）的聊天机器人开放式对话能力。由于如今在消费级硬件上本地化运行量化的开源 LLM 已经成为一个高效的流程，我们所需要做的唯一一件事就是将互动方式扩展为语音到语音的格式。同样，开源研究的成果为我们提供了便利。高质量的语音转文本和文本转语音模型已经准备就绪，并配有直观的 API 接口。

一个完美展示这些工具如何轻松地将激动人心的概念变为现实的示例就是 LingoNaut：一个多语言语言助手，它运行在一个仅包含 300 行代码的单一 Python 脚本中。通过结合 OpenAI 的 Whisper 语音转文本模型、本地 Ollama 服务器和 Coqui.ai 的 TTS 文本转语音库，我们可以构建一个用户友好的对讲机界面，并提供多种 LLM 选择。从这里开始，只需要进行系统提示工程（通过 ollama-python 容易完成），就可以从 LLM 中召唤出我们所需的行为，在这个案例中，创造一个有用的多语言语言导师。实际上，这意味着 LingoNaut 的代码可以轻松适应，通过调整使用的 LLM 和系统提示，就能创建各种各样的 AI 助手。

LingoNaut 应用演示。

运行 LingoNaut 的代码可以在 GitHub 仓库中找到，提供了简单的安装说明。LingoNaut 是一个开源项目，欢迎贡献。例如，未来的工作可能涉及将后端包装成更复杂的网页 UI，以支持远程托管对讲机 LLM 应用，从而支持移动设备。我希望 LingoNaut 能成为一个有趣且有用的资源，帮助其他人在他们的学习旅程中，同时也希望这段代码能作为一个轻量级的框架，供工程师们在沙盒中实验新的 LLM 或 LMM 基于的应用想法。

本文的其余部分概述了运行 LingoNaut 的 Python 代码，LingoNaut 是一个开源组件工具箱，使得像 LingoNaut 这样的工具能够轻松组合成型，并且为未来的工作提供了有前景的方向。通过一些巧妙的 Python 编程技巧、出色的语音转文本和文本转语音模型，以及在消费者机器上本地部署量化的 LLM（大语言模型），我们可以轻松构建一个语音对语音的管道，来解锁那些不太适合文本形式的应用场景，例如语言学习。研究界的聪明贡献汇聚在一起，为我们提供了这一系列非凡的可能性。让我们更详细地走一遍每一个步骤，理解它们在让 LingoNaut 应用成为现实过程中所扮演的角色。

LingoNaut 代码

图片由作者使用 DALL-E 3 制作。

对讲机界面

LingoNaut 中的代码创建了一个方便的基于终端的语音到语音应用，可以与 Ollama 一起使用，并且可以轻松适应新的使用场景。通过使用一个名为pynput的包，我们可以创建一个在后台线程中运行并响应用户按键的键盘监听器对象。这为运行在连续循环中的应用提供了广泛的选项，最重要的是在这种情况下提供一个控制，用于触发和终止用户音频录制，而无需图形用户界面和按钮。这样，互动式应用程序可以直接从终端运行，从而简化了许多工程问题。

在 LingoNaut 中，可以通过按不同的键来录制音频，从而部署不同的语音转文本模型。轻量级的 Whisper 模型在快速处理英语音频方面表现优异，而更大且较慢的模型则必须用于准确的多语言实时转录。因此，用户可以选择按住Ctrl键使用轻量级基础模型来提问英语问题，或者按住Shift键来用其他语言进行对话。

由键盘监听器启用的其他有用的 LingoNaut 功能包括，当你输入错误或对响应方向不满意时，可以通过按End键中断模型响应。这防止了因等待无关的文本和音频完成播放而被卡住，从而使用户能够保持更高的参与度。用户还可以通过按F2键锁定键盘输入，这样他们就可以在不担心意外触发音频录制的情况下，保持会话打开以供以后使用。

并发

尽管 LingoNaut 中使用的软件包为与创建语音到语音管道的三个模型接口提供了简化的 API，但单纯等待大型语言模型（LLM）生成文本、将其转录为音频，然后将音频串行播放给用户，将是一个非常慢的体验。LLM 文本块的流式传输、文本块转录成音频文件以及播放先前转录的音频文件都可以同时发生，因此 LingoNaut 为每个任务使用了独立的线程。通过使用ThreadPoolExecutor对象并将max_workers设置为 1，我们可以轻松地为任务提交打开新的线程，同时确保任务按顺序执行，从而使我们能够将工作从主线程外包，而不会出现重叠或顺序错乱的返回。以下是该安排的基本代码框架：

import ollama
from concurrent import ThreadPoolExecutor

def play_audio(file_path: str):
    # audio file playback code

def dump_to_audio(text: str, file_path: str):
    # transcribe text-to-speech and save audio file

def process_stream(chat_history: list):
    stream = ollama.chat(
        model='mistral:lingonaut',
        messages=chat_history,
        stream=True,
    )

    with ThreadPoolExecutor(max_workers=1) as play_pool:
        with ThreadPoolExecutor(max_workers=1) as tts_pool:
            def play_output(text, file_path):
                output_path = dump_to_audio(text, file_path)
                play_pool.submit(play_audio, output_path)
                return

            def process_section(text, file_path):
                tts_pool.submit(play_output, text, file_path)
                return current_string

            current_section = ""
            for i, chunk in enumerate(stream):
                current_path = f"{i}.wav"
                text_chunk = chunk['message']['content']
                current_section += text_chunk
                if len(current_section) > 50:
                    process_section(current_section, current_path)
                    current_section = ""

            tts_pool.shutdown(wait=True)
            play_pool.shutdown(wait=True)

模型定制

ollama-python 包提供了一个简单的工具，可以使用“Modelfiles”创建自定义标签的模型配置，以引导 LLM 的行为。在 LingoNaut 的情况下，Ollama 库中的 4 位量化 Mistral 7B 模型通过显式的系统提示进行了自定义，以引导其作为语言学习助手的预期行为。该提示可以在仓库中的 create_lingonaut_ollama.py 文件中找到，需要注意的是，这是唯一一个自定义模型选择和行为的文件，这意味着通过创建一个带有不同 Modelfile 的标签模型，您可以立即将这个仓库转换成任何其他的对讲机 LLM 应用程序。根据可用资源，所使用的 LLM 也可以轻松地替换为更大或更小的模型。

语音到语音工具箱

作者使用 DALL-E 3 制作的图像。

Whisper

Whisper 是由 OpenAI 提供的开源语音转文本模型。根据应用的复杂性和所需的准确性与效率的权衡，有五种不同大小的模型可供选择，包括英语专注和多语言版本。Whisper 是一个端到端的语音转文本框架，采用编码器-解码器变压器架构，处理输入音频，将其分割成 30 秒的块并转换为对数 Mel 频谱图。该网络在多个语音处理任务上进行了训练，包括多语言语音识别、语音翻译、口语语言识别和语音活动检测。

来自研究论文的 Whisper 架构图。

对于这个项目，用户可以使用两个对讲机按钮：一个将他们的普通英语问题通过更轻量、更快速的“基础”模型发送到机器人，另一个则部署更大的“中型”多语言模型，能够区分数十种语言并准确转录正确发音的语句。在语言学习的背景下，这促使用户更加专注于自己的发音，从而加速学习过程。下面是可用 Whisper 模型的图表：

来自 github.com/openai/whisper 的图表

Ollama

存在各种非常有用的开源语言模型接口，它们针对不同的使用场景提供不同复杂度的设置和使用方式。最广为人知的包括 oobabooga text-gen webui，它无疑提供了最多的灵活性和底层控制，llama.cpp，最初专注于在小型仅支持 CPU 的设备上优化量化模型的部署，但后来扩展到支持其他硬件类型，以及本项目所选的简化界面（基于 llama.cpp）：Ollama。

Ollama 侧重于简洁性和高效性，能够在后台运行，并能够同时在小型硬件上服务多个模型，根据需要快速将模型载入和移出内存以响应请求。Ollama 的重点不是低级工具，如微调，而是擅长简单安装、高效的运行时、丰富的现成可用模型，以及导入预训练模型权重的工具。对效率和简洁性的关注使得 Ollama 成为像 LingoNaut 这样的项目中 LLM 接口的自然选择，因为用户无需记得关闭会话以释放资源，因为 Ollama 会在应用程序不使用时自动在后台进行管理。此外，库中对高效、量化模型的便捷访问非常适合无摩擦地开发像 LingoNaut 这样的 LLM 应用。

尽管 Ollama 技术上并未专为 Windows 构建，但 Windows 用户可以轻松地通过 Windows 子系统（WSL）在 Windows 上安装它，并通过 Windows 应用程序与服务器进行通信。安装 WSL 后，打开 Linux 终端并输入一行 Ollama 安装命令。安装完成后，只需在 Linux 终端中运行“ollama serve”，然后就可以通过任何 Windows 机器上的 Python 脚本与 Ollama 服务器进行通信。

Coqui.ai 🐸 TTS

TTS 是一个功能齐全的文本转语音库，供非商业用途使用，同时也提供商业许可证。该库非常受欢迎，截至目前在 GitHub 上已有 3k 次分叉和 26.6k 个星标，这也不难理解：该库就像文本转语音领域的 Ollama，提供了一个统一的接口来访问各种高效的模型，涵盖了多种使用场景（例如：为本项目提供一个多说话人、多语言模型）、令人兴奋的功能，如声音克隆，以及对转录速度和情感语调的控制。

TTS 库提供了丰富的文本转语音模型选择，包括 Facebook 研究的“大规模多语言语音”（MMS）项目中的著名 Fairseq 模型。对于 LingoNaut，Coqui.ai 团队的XTTS模型最终被证明是正确的选择，因为它能够无缝地生成多语言的高质量语音。虽然该模型确实有一个“语言”输入参数，但我发现即便将其设置为“en”表示英语，并且仅传递其他语言的文本，依然能生成准确的多语言语音，且发音大多数情况下正确。

结论

图像由作者使用 DALL-E 3 生成。

在本文中，我介绍了一款新的语音到语音多语言语言学习助手——LingoNaut。该应用通过终端运行，使用轻量且易于适配的 Python 脚本，并配有对讲机键盘界面。这个完全免费的本地托管应用允许用户利用人工智能练习多种语言，在不需要在准备好之前与陌生人练习的情况下，增强对新语言的信心。代码已在GitHub上公开，并提供了快速设置说明，同时也容易扩展到新的应用场景。希望社区能在语言学习中从这款应用中受益，并且希望这段代码能作为未来概念验证的便捷轻量框架。LingoNaut 是开源的，欢迎贡献。

未来工作

本项目通过将大型语言模型（LLM）的基于文本的对话能力与输入和输出端分别独立的语音转文本和文本转语音模型相结合，构建了一个语音到语音的流程。这种设计比较笨重，容易产生级联错误，因此比使用真正的多模态语言模型更为逊色，后者能够从统一的表示空间中理解和生成音频与文本标记。当我们在将音频传递给模型之前将其编码为文本时，我们丧失了音频中的所有音调信息，包括发音和情感表达，这显著限制了我们的语言助手的先进性。通过使用在联合多模态表示空间上操作的 LLM，我们可以保留用户输入中的微妙音调信息。同样，在输出端进行文本转语音编码也是一个重要的信息瓶颈，导致交互不够自然。

NeXT-GPT的作者提供了一个有前景的框架，用于利用预训练的 LLM（大语言模型）创建大型的多模态模型（LMM），这些模型可以在统一的多模态表示空间中运行，这对于语音到语音的应用程序来说是一个有前景的方向。经过一些努力，发布的 NeXT-GPT 权重可能会被导入到 Ollama 中进行实验。他们的实验使用了一个大小相似的 Vicuna 7B LLM，证明了轻量级 LLM 可以在多模态空间中工作。虽然 Vicuna 模型并未宣传为多语言模型，但 LingoNaut 实验中使用的 Mistral 7B 模型也没有宣传为多语言模型，尽管它似乎在此目的下表现得相当不错。理想情况下，经过微调的多语言指令调优模型将是 LingoNaut 的最佳选择。为此，选择合适的数据集和低秩适配（LoRA）可能会导致成功。此外，LaVIN展示的轻量级适配器与参数高效的多模态对齐提供了使 NeXT-GPT 风格的 LMM 开发在有限资源下更具可达性的可能。第一步将是调查如何使用 LaVIN 的“廉价且快速”的模态混合适应（MMA）训练策略，将高质量音频编码器的表示与 LLM 对齐，从而缓解输入端的语音转文本瓶颈。接下来的步骤是调查如何使用 NeXT-GPT 风格的模态切换指令调优（MoSIT）来实现多模态输出。

最后，如引言中所提到的，构建一个可以与远程后端通信的 Web UI 前端，将大大扩展 LingoNaut 的乐趣，因为更大的模型可以部署在租用的云 GPU 上，并通过笔记本和移动设备的 https 请求进行通信。这将允许社区构建任何他们想象中的对讲机 LLM 应用程序，让朋友和家人在任何有网络连接的地方都能使用，从而将普遍可访问的语言学习助手的愿景变为现实。

通用语——基于实体感知的机器翻译方法，用于知识图谱上的问答

原文：towardsdatascience.com/lingua-franca-entity-aware-machine-translation-approach-for-question-answering-over-knowledge-e2c7e481c870?source=collection_archive---------12-----------------------#2024-01-29

朝着知识图谱问答系统的通用语发展

Aleksandr Perevalov

·发表于 Towards Data Science ·阅读时间 7 分钟·2024 年 1 月 29 日

TLDR

机器翻译（MT）可以增强现有的问答（QA）系统，这些系统的语言能力有限，通过使其支持多种语言来提高其功能。然而，机器翻译有一个主要缺点——它通常在翻译那些不能逐字翻译的命名实体时失败。例如，电影《教皇必须死》的德语片名是“Ein Papst zum Küssen”，其字面翻译是：“一个待吻的教皇”。由于命名实体的正确性对问答系统至关重要，因此必须妥善处理这一挑战。在本文中，我们提出了一种名为“Lingua Franca”的实体感知机器翻译方法。它利用知识图谱中的信息来确保命名实体翻译的准确性。没错，它能有效工作！

挑战

实现高质量的翻译在很大程度上依赖于准确翻译句子中的命名实体（NE）。已经提出了各种方法来增强命名实体的翻译，包括集成知识图谱（KG）来改善实体翻译的方法，这些方法承认实体在整体翻译质量中的关键作用，特别是在问答系统的上下文中。值得注意的是，命名实体翻译的质量并不是一个孤立的目标；它对涉及信息检索（IR）或基于知识图谱的问答（KGQA）等任务的系统有更广泛的影响。本文将深入讨论机器翻译（MT）和基于知识图谱的问答（KGQA）。

KGQA 系统的重要性在于它们能够基于结构化数据为用户提供事实性答案（见下图）。

Google 直接回答功能的截图（由作者提供）

KGQA 系统是现代搜索引擎的核心组件，使其能够为用户提供直接答案（Google 搜索，截图由作者提供）。

此外，多语言 KGQA 系统在解决 Web 上的“数字语言鸿沟”中发挥着至关重要的作用。例如，涉及德国的 Wikipedia 文章，特别是与城市或人物相关的文章，其中包含的信息在德语中的比例高于其他语言——这种信息不平衡可以通过多语言 KGQA 系统加以处理，顺便说一句，该系统是所有现代搜索引擎的核心。

使 KGQA 系统能够用不同语言回答问题的选项之一是使用机器翻译（MT）。然而，现成的 MT 在翻译命名实体（NEs）时面临显著挑战，因为许多实体无法直接翻译，需要背景知识才能准确解读。例如，考虑电影《教皇必须死》的德语片名，“Ein Papst zum Küssen”。字面翻译为“一个待吻的教皇”，这突显了超越简单翻译方法的上下文理解需求。

鉴于传统机器翻译方法在翻译实体时的局限性，将 KGQA 系统与机器翻译相结合通常会导致命名实体失真，显著降低准确回答问题的可能性。因此，需要一种增强的方法，将多语言背景知识整合到命名实体中。

我们的方法

本文介绍并实现了一种新的命名实体感知机器翻译（NEAMT）方法，旨在增强 KGQA 系统的多语言能力。NEAMT 的核心概念是通过结合知识图谱（例如 Wikidata 和 DBpedia）中的信息来提升机器翻译的质量。这是通过使用“实体替换”技术实现的。

作为评估数据，我们使用了 QALD-9-plus 和 QALD-10 数据集。然后，我们使用 NEAMT 框架中的多个组件，这些组件可在我们的仓库中获取。最后，该方法在两个 KGQA 系统上进行了评估：QAnswer 和 Qanary。该方法的详细描述请参见下图。

KGQA 过程中的 Lingua Franca 方法概述（图由作者提供）

从本质上讲，我们的方法在翻译过程中使用实体替换技术保留已知的命名实体。随后，这些实体会被从知识图谱中提取出的相应标签替换为目标翻译语言中的标签。这个细致的过程确保了问题在 KGQA 系统回答之前的精确翻译。

根据我们之前的文章的见解，我们将英语指定为共同的目标翻译语言，从而将我们的方法命名为“Lingua Franca”（灵感来自于“桥梁”或“联结”语言的含义）。需要特别指出的是，我们的框架具有多功能性，可以无缝地适应任何其他语言作为目标语言。重要的是，Lingua Franca 不仅限于 KGQA 的范畴，还可以应用于各种面向实体的搜索应用。

Lingua Franca 方法包括三个主要步骤：（1）命名实体识别（NER）和命名实体链接（NEL），（2）基于已识别命名实体应用实体替换技术，（3）利用机器翻译工具生成目标语言文本，同时考虑前述步骤中的信息。在这里，英语始终作为目标语言，与相关研究一致，认为这是问答（QA）质量的最优策略。然而，该方法不限于英语，如有需要，可以使用其他语言。

该方法作为开源框架实现，允许用户通过集成自定义的 NER、NEL 和 MT 组件来构建自己的命名实体感知机器翻译（NEAMT）管道（请参见我们的GitHub）。Lingua Franca 方法在所有设置下的详细信息在下面的示例中进行了说明，如下图所示。

Lingua Franca 方法在多个设置下的详细表示（作者提供的图示）

本研究的实验结果强烈支持 Lingua Franca 在与 KGQA 系统结合时优于标准机器翻译工具的观点。

实验结果

在评估每个实体替换设置时，计算了通过机器翻译工具处理后占位符或命名实体标签的损坏率。该比率作为该方法相关管道中实际命名实体翻译质量的指标。更新后的统计数据如下：

设置 1（类似字符串的占位符）：6.63%的占位符丢失或损坏。
设置 2（数值占位符）：2.89%的占位符丢失或损坏。
设置 3（在翻译前用英文标签替换命名实体）：6.16%的标签被损坏。

因此，通过我们的方法，我们可以自信地断言，在文本中识别的 NEs 中，最多有 97.11%（设置 2）被正确翻译。

我们分析了关于 QA 质量的结果，同时考虑了以下实验组件：一种方法管道或标准 MT 工具、源语言和 KGQA 基准。下图展示了方法与标准 MT 的对比——这些结果可以被解释为一种消融研究。

我们实验的宏观 F1 得分分组柱状图（按作者）

分组柱状图展示了关于每种语言和拆分的宏观 F1 得分（使用Gerbil-QA获得的）。在消融研究的背景下，每组包含两根柱状条：第一根柱条属于我们提出的最佳方法，而第二根柱条反映了标准 MT 工具（基准）的表现。

我们观察到，在大多数实验案例中（24 个中的 19 个），使用我们方法的 KGQA 系统的表现超过了使用标准 MT 工具的 KGQA 系统。为了验证上述结论，我们对相同数据进行了 Wilcoxon 符号秩检验。基于检验结果（p 值 = 0.0008，α = 0.01），我们拒绝了零假设，该假设表示 QA 质量结果没有差异，即将 KGQA 与标准 MT 结合与将 KGQA 与我们的方法结合没有区别。因此，我们得出结论，依赖我们 NEAMT 框架的方法显著提高了在回答多语言问题时的 QA 质量，相比标准 MT 工具。

实验的可重复性通过重复实验并计算所有 QA 质量指标之间的 Pearson 相关系数来确保。结果的系数为 0.794，表示强相关与非常强相关之间的边界值。因此，我们假设我们的实验是可重复的。

结论

本文介绍了一种名为Lingua Franca的 NEAMT 方法。Lingua Franca 旨在增强多语言能力，并与标准机器翻译工具相比提高问答质量，它专为 KGQA 系统设计，目的是扩大其潜在用户范围。Lingua Franca 的实现和评估采用了作者开发的模块化 NEAMT 框架，详细信息可参见“实验”部分。本文的主要贡献包括：（1）据我们所知，首次将 NEAMT 方法（即 Lingua Franca）与 KGQA 结合；（2）提出了一个开源模块化 NEAMT 框架，使研究社区能够构建自己的机器翻译管道；（3）进行了一项全面的评估和消融研究，展示了 Lingua Franca 方法的有效性。

在未来的工作中，我们计划扩展实验设置，涵盖更广泛的语言、基准和 KGQA 系统。为了处理实体替换过程中的损坏占位符，我们计划使用这些数据对机器翻译模型进行微调。此外，我们还将进行更详细的错误分析，重点分析错误传播。

请不要忘记查看我们的完整研究论文以及GitHub 仓库。

致谢

本研究得到了德国联邦教育与研究部（BMBF）资助，资助编号为 01IS17046 和 01QE2056C，同时也得到了德国北莱茵-威斯特法伦州文化与科学部（MKW NRW）资助，资助编号为 NW21–059D。本研究还在 QA4CB 研究项目内获得资助，该项目旨在开发用于扩展聊天机器人框架的问答组件。

链表 — 数据结构与算法（面向数据科学家）

原文：towardsdatascience.com/linked-lists-data-structures-algorithms-for-data-scientists-e559d08e0144?source=collection_archive---------4-----------------------#2024-10-21

链表和队列是如何在幕后工作的

Egor Howell

·发表于 Towards Data Science ·6 分钟阅读·2024 年 10 月 21 日

图片由 Luca Bravo 提供，来源于 Unsplash

在上一篇关于数组的文章之后，我想讨论链表数据结构及其一些操作。

## 数组 — 数据结构与算法（面向数据科学家）

动态和静态数组是如何在幕后工作的

towardsdatascience.com

作为数据科学家，尽管我们不一定需要了解数据结构和算法的每个细节，但这仍然是任何技术专业人员非常实用的技能集。

这就是为什么我会创建一系列文章，讨论核心数据结构以及它们如何在幕后工作。

什么是链表？

链表是一种数据结构，其中每个元素（称为节点）都按顺序存储/工作。然而，链表不像数组那样在内存中连续存储。

每个节点有两部分内容：

数据 — 该节点所包含的值
引用 — 节点包含对序列中下一个节点的引用。

lintsampler：一种快速从任何分布中获取随机样本的新方法

原文：towardsdatascience.com/lintsampler-a-new-way-to-quickly-get-random-samples-from-any-distribution-d07f73a70f5c?source=collection_archive---------8-----------------------#2024-10-14

Aneesh Naik

·发表于 Towards Data Science ·阅读时间 4 分钟·2024 年 10 月 14 日

lintsampler是一个纯 Python 包，可以轻松高效地从任何概率分布中生成随机样本。

完整披露：我是lintsampler的作者之一。

为什么你需要 lintsampler

我们经常遇到需要从给定概率分布（PDF）中抽取随机样本的情况。例如，我们可能想估算一些总结性统计量，或者为模拟创建一群粒子。

如果概率分布是标准分布，如均匀分布或高斯（正态）分布，那么numpy/scipy生态系统提供了一些简便的方法来从这些分布中抽取样本，方法是通过numpy.random或scipy.stats模块。

然而，在实际应用中，我们经常遇到非高斯的概率分布。有时，它们非常非高斯。例如：

一个非常非高斯的 PDF。等高线是密度相等的线，在对数空间中按相等间隔分隔。图片来源：作者。

我们如何从这个分布中抽取样本呢？

有几种广泛使用的技术可以从任意分布中抽取样本，比如拒绝采样或马尔可夫链蒙特卡罗（MCMC）。这些都是优秀且可靠的方法，并且有一些方便的 Python 实现。例如，emcee是一个在科学应用中广泛使用的 MCMC 采样器。

现有技术的问题在于它们需要相当多的设置和调试。使用拒绝采样时，必须选择一个提议分布，而不合适的选择会使得过程非常低效。使用 MCMC 时，必须担心样本是否已收敛，这通常需要进行一些后验测试来评估。

输入 lintsampler。操作简单如同：

from lintsampler import LintSampler
import numpy as np

x = np.linspace(xmin, xmax, ngrid)
y = np.linspace(ymin, ymax, ngrid)
sampler = LintSampler((x, y), pdf)
pts = sampler.sample(N=100000)

在这段代码中，我们沿着两个维度构造了 1D 数组，然后将它们与表示我们想从中抽取样本的概率分布的 pdf 函数一起传递给 LintSampler 对象（从 lintsampler 包中导入）。我们在这个片段中没有列出 pdf 函数，但在 docs 中有一些完全自包含的示例。

现在，pts 是一个包含来自 PDF 的 100000 个样本的数组。以下是它们的散点图：

从上面奇怪的 PDF 中采样的点的散点图（后者由轮廓线表示）。图片由作者提供。

本例的重点是演示如何轻松地设置和使用 lintsampler。在某些情况下，它也比 MCMC 和/或拒绝采样要快得多且高效。如果你有兴趣了解 lintsampler 背后的工作原理，请继续阅读。否则，可以访问 docs，那里有描述如何安装和使用 lintsampler 的说明，包括带有 1D、2D 和 3D 用例的示例笔记本，以及对一些 lintsampler 附加功能的描述：准蒙特卡洛采样（又称低差异序列）和在自适应树结构上的采样。此外，还有一篇发表于《开源软件杂志》(JOSS) 的论文，描述了 lintsampler。

`lintsampler` 的工作原理

lintsampler 背后是我们称之为 线性插值采样 的算法。文档的理论部分提供了一个更详细且更具数学性的算法描述，但这里简要说明一下。

下面的示例演示了当你将 PDF 和网格传递给 LintSampler 类时，lintsampler 背后发生了什么。我们将以 2D 高斯分布的简单示例为例，但这种方法适用于任意维度，并且适用于更不友好的 PDF。

首先，在网格上评估概率密度函数。在下面的示例中，网格的间距不均匀，仅供娱乐。

左：2D 高斯概率密度函数（PDF）。右：在（不均匀）网格上评估的概率密度函数。图片来自作者。

通过这种方式在网格上评估概率密度函数后，我们可以根据梯形法则估算每个网格单元的总概率（即，单元的体积乘以其角点密度的平均值）。
在每个网格单元内，我们可以通过双线性插值在单元角点之间近似概率密度函数：

使用（双）线性插值填充的网格化概率密度函数。图片来自作者。

这种对概率密度函数的线性近似可以非常高效地进行采样。绘制一个单一的样本是一个两步过程，如下图所示。首先，从按概率加权的单元列表中选择一个随机单元（左侧面板）。接下来，通过逆变换采样在单元内采样一个点（右侧面板）。

左：与前一图相同，随机选择的单元被高亮显示。右：高亮单元的放大图，显示采样点。图片来自作者。

值得理解的是，这里的关键步骤是线性近似：我们将在lintsampler文档中描述这一点，以及逆变换采样过程的更多细节。将概率密度函数近似为每个网格单元内的线性函数意味着它具有封闭的、解析的形式用于其分位数函数（即其逆累积分布函数），这意味着进行逆变换采样本质上归结为绘制均匀样本并对其应用代数函数。

用户需要关心的主要问题是获得合适的网格分辨率，以便线性近似足够准确。什么是合适的分辨率会因使用案例而异，正如在lintsampler文档中的一些示例笔记本所展示的那样。

祝你采样愉快！

使用 FFmpeg 增强数据讲述的实时图表

原文：towardsdatascience.com/live-graphs-with-ffmpeg-to-enhance-your-data-storytelling-61cc12529382?source=collection_archive---------4-----------------------#2024-04-15

使用这个 FFmpeg 教程来动画化你的数据可视化

Fouad Faraj

·发表于 Towards Data Science ·阅读时间 4 分钟·2024 年 4 月 15 日

2019–2024 年间 S&P 500 值的静态与动态图表对比。图片由作者提供

介绍

有大量开源的数据可视化库可用于创建图表，但大多数在创建动态移动图表方面功能有限。最常见的方法是生成多张图像，并通过在线转换器将它们合并成一个.mp4 或.gif 文件，这些转换器受到各种限制，只有付费才能避免这些限制。

以下是我为免费在线转换器发现的一些限制：

最大上传 200 MB
最大上传 100 张图片
分辨率最高为 800 像素
输出视频带水印

锁链图示，说明了免费在线转换器的功能限制。照片由Jose Fontano提供，来源于Unsplash

FFmpeg是一个开源软件工具，用于高效地处理音频和视频数据。FFmpeg 的全称是Fast Forward Moving Picture Experts Group，并被 VLC 和 YouTube 等大型公司在后台使用。尽管它在这些大应用程序中被广泛使用，但对于典型的数据科学家来说，它仍然是一个大多未被使用的工具。

Llama-2 与 Llama-3：模型间的井字游戏对决

原文：towardsdatascience.com/llama-2-vs-llama-3-a-tic-tac-toe-battle-between-models-7301962ca65d?source=collection_archive---------5-----------------------#2024-04-27

使用 Python 和 Llama-CPP 进行非科学性基准测试

Dmitrii Eliuseev

·发表于 Towards Data Science ·阅读时长 10 分钟·2024 年 4 月 27 日

图片来源：Solstice Hannan，来自 Unsplash

在撰写本文的前一周，Meta 发布了新的开源 Llama-3 模型，可以在此查看。Meta 宣称，这些是“目前 8B 和 70B 参数规模上最好的模型。”例如，依据HuggingFace 模型页面，Llama-3 8B 在 MMLU（大规模多任务语言理解基准）中的得分为 66.6，而 Llama-2 7B 为 45.7。Llama-3 还在常识问答数据集(CommonSense QA)中获得了 72.6 的得分，而 Llama-2 为 57.6。经过指令调优的 Llama-3 8B 模型在数学基准测试中获得了 30.0 的得分，而 Llama-2 仅为 3.8，这确实是一个令人印象深刻的改进。

学术基准很重要，但我们能看到真正的“实际差异”吗？显然，我们可以，而且这可能很有趣。让我们编写一个井字游戏，让两个模型对战，看看哪个会赢！在游戏过程中，我将测试所有的 7B、8B 和 70B 模型。同时，我还会收集一些关于模型性能和系统需求的数据。所有测试都可以在 Google Colab 中免费运行。

让我们开始吧！

加载模型

为了测试所有模型，我将使用Llama-cpp Python 库，因为它可以在 CPU 和 GPU 上运行。我们…

Llama 是开源的，但为什么？

原文：towardsdatascience.com/llama-is-open-source-but-why-3f87d290d0d5?source=collection_archive---------5-----------------------#2024-06-25

观点

Meta 开源大模型战略分析

Haifeng Jin

·发表于 Towards Data Science ·6 分钟阅读·2024 年 6 月 25 日

图片由作者使用 DALL-E 创建

训练一个大语言模型可能花费数百万美元。Meta 为什么会花这么多钱训练一个模型，并且让所有人免费使用？

本文分析了 Meta 的 GenAI 和大模型战略，旨在理解开源大模型的考虑因素。我们还讨论了这波开源模型如何与传统开源软件相似，又有何不同。

免责声明：Llama 模型是否真正开源超出了本文的讨论范围。所有信息均来自公开来源。

专有模型的幻象

如果 Meta 开源它的模型，难道人们不会选择自己构建服务，而不是付费使用 Meta 提供的服务（例如，基于 Llama 的 Meta AI 聊天机器人，API，或者帮助你微调模型并高效提供服务）吗？

通过将模型保持为专有，来阻止人们构建自己的解决方案，这不过是一个幻象。无论是否开源你的模型，其他公司，如 Mistral AI、阿里巴巴，甚至谷歌，都已开源了他们的模型。

目前，OpenAI、Anthropic 和谷歌并没有开源它们最大/最好的模型，因为它们仍然认为自己处于一个开源模型无法企及的领域，无论是能力还是质量。开源这些模型将对他们的业务造成损害。

除非你的模型比其他任何开源模型好几个数量级，否则是否开源你的模型不会影响用户在开源模型上构建应用程序的质量。

你唯一的选择是成为开源模型的首创者和领导者，或者成为一个追随者，在稍后发布你的模型。

为什么要成为开源模型的领导者？

成为开源模型的领导者有许多好处，但最重要的就是吸引人才。

GenAI 的战争是被计算能力瓶颈限制的人才竞争。你获得多少计算能力在很大程度上取决于你与 Nvidia 的现金流关系，除了谷歌。然而，拥有多少人才则是另一个问题。

根据埃隆·马斯克的说法，谷歌拥有三分之二的 AI 人才，为了对抗谷歌的力量，他们创办了 OpenAI。随后，一些最顶尖的人才离开了 OpenAI，创办了 Anthropic，专注于 AI 安全。因此，目前市场上这三家公司拥有最优秀、最多的 AI 专家。其他公司都急需更多的 AI 专家。

成为开源模型的领导者将帮助 Meta 弥合 AI 专家的差距。开源模型通过两种方式吸引人才。

首先，AI 专家们想为 Meta 工作。让全世界都使用你构建的模型是超级酷的。这会为你的工作带来大量曝光，扩大你的专业影响力，并且对你未来的职业生涯有好处。所以，许多有才华的人愿意为他们工作。

其次，社区中的 AI 专家们为 Meta 做了免费的工作。在 Llama 发布后不久，人们开始对其进行实验。他们帮助你开发新的服务技术以降低成本，微调模型以发现新应用，并仔细审查模型以发现漏洞，提升其安全性。例如，根据这篇文章，他们在 Llama 最初发布后一个月内进行了指令调优、量化、质量改进、人类评估、多模态和 RLHF。将这项工作交给社区，帮助 Meta 节省了大量的计算和人力资源。

与社区快速迭代。

使用开源模型，Meta 可以通过直接将其新开发的方法融入其中，迅速与社区一起进行迭代。

如果谷歌要采用社区的新方法，成本会有多高？这个过程分为两个阶段：实现和评估。首先，他们需要重新实现该方法以适配 Gemini。这涉及到用 JAX 重写代码，需要大量的工程资源。在评估阶段，他们需要对其进行一系列基准测试，这又需要大量的计算能力。最重要的是，这需要时间。当最新技术首次可用时，它们无法立即进行迭代。

相反，如果 Meta 想要采纳社区的一个新方法，对他们来说几乎没有成本。社区已经直接对 Llama 模型做了实验和基准测试，因此不需要进一步评估。代码是用 PyTorch 编写的，他们可以直接复制并粘贴到自己的系统中。

Llama 在 Meta 和社区之间建立了一个飞轮。Meta 从社区引入最新技术，并将其下一代模型推向社区。PyTorch 是他们共同使用的语言。

他们还能赚钱吗？

模型是开源的。人们不会直接建立自己的服务吗？为什么他们还要为一个建立在开源模型上的服务付费给 Meta 呢？当然会。即使是开源模型，构建服务依然很困难。

你如何微调和调整模型以适应你的特定应用？你如何平衡服务成本和模型质量？你是否了解所有技巧，能够充分利用你的 GPU？

知道这些问题答案的人很难找到，且招聘成本高。即使有足够的人力，想要获得足够的计算能力来微调和服务模型也很难。试想一下，如何从开源的 Llama 模型构建 Meta AI。我预计需要数百名员工和大量 GPU 参与其中。

所以，如果将来有任何类似的 Meta GenAI 服务，人们仍然可能会为其付费。

这就像开源软件，但又不完全是。

情况与传统的开源软件非常相似。"免费代码，付费服务" 这一框架依然适用。代码或模型是免费的，用来吸引更多用户加入生态系统。随着生态系统的扩大，拥有者能收获更多的利益。建立在免费代码之上的服务则是为了盈利。

然而，它也并不像开源软件。主要的区别可以总结为低用户留存率和一种新型的生态系统。

用户留存率低

开源模型的用户留存率较低。迁移到新模型比迁移到新软件要容易得多。

迁移软件很困难。PyTorch 和 HuggingFace 为深度学习框架和模型池建立了强大的生态系统。试想一下，如果你创建一个新的深度学习框架或模型池来与他们竞争，想要稍微改变他们的主导地位有多么困难。

一个很好的例子是 JAX。它对大规模分布式训练提供了更好的支持，但由于生态系统和社区较小，很难吸引用户使用 JAX。它缺乏一个能帮助用户解决问题的有力社区。而且，将整个基础设施迁移到新的框架的工程成本对大多数公司来说太高了。

开源模型没有这些问题。它们易于迁移，几乎不需要用户支持。因此，人们可以轻松转向最新和最好的模型。要在开源模型中保持领导地位，你必须不断发布位于排行榜顶部的新模型。这也是成为开源模型领导者的一大挑战或缺点。

一种新型的生态系统

开源模型创造了一种新型的生态系统。与开源软件创造贡献者和新软件生态系统不同，开源模型创造了微调和量化模型的生态系统，这些模型可以看作是原始模型的分支。

因此，一个开源基础模型不必在每个具体任务上都表现得非常优秀，因为用户可以通过领域特定的数据对其进行微调以适应他们的应用需求。基础模型最重要的特点是能够满足用户的部署要求，例如推理时的低延迟，或者足够小以适应终端设备。

这就是为什么 Llama 为每个版本提供多个尺寸的原因。例如，Llama-3 有三个版本：8B、70B 和 400B。他们希望确保涵盖所有的部署场景。

总结

即使 Meta 不开源他们的模型，其他公司也会开源。所以，Meta 提前开源并领导开源模型将是明智之举。然后，Meta 可以与社区快速迭代，改进其模型，赶上 OpenAI 和 Google。

在开源你的模型时，不必担心人们不使用你的服务，因为基础模型与构建良好的服务之间仍然存在巨大的差距。

开源模型类似于开源软件，它们都遵循“自由代码付费服务”框架，但在用户留存率和所创建的生态系统类型上有所不同。

未来，我预计会看到更多来自更多公司的开源模型。与已集中在 PyTorch 上的深度学习框架不同，开源模型将在很长一段时间内保持多样性和竞争力。

LLaVA：一个开源的 GPT-4V(ision)替代方案

原文：towardsdatascience.com/llava-an-open-source-alternative-to-gpt-4v-ision-b06f88ce8efa?source=collection_archive---------2-----------------------#2024-01-23

在 Web、本地和 Google Colab 上运行 LLaVA

Yann-Aël Le Borgne

·发布于 Towards Data Science ·7 分钟阅读·2024 年 1 月 23 日

好奇这张图片拍摄于哪里吗？问问 LLaVA 吧！(图片来自Guy Rey-Bellet，来自Pixabay)。

LLaVA（Large Language 和 Visual Assistant 的缩写）是一个有前途的开源生成型 AI 模型，它复制了 OpenAI GPT-4 在与图像对话方面的一些能力。用户可以将图片添加到 LLaVA 的聊天对话中，不仅能够讨论这些图片的内容，还可以利用它们以视觉方式描述想法、情境或场景。

LLaVA 最引人注目的特点是，它能够在使用更简单的模型架构和数量级更少的训练数据的情况下，超越其他开源解决方案。这些特点使得 LLaVA 不仅在训练上更快速且成本更低，而且更适合在消费级硬件上进行推理。

本文概述了 LLaVA，并更具体地旨在

展示如何通过网络界面进行实验，以及如何在您的计算机或笔记本电脑上安装它
解释它的主要技术特点
通过一个简单的聊天机器人应用示例，展示如何用它编程，该应用是基于 HuggingFace 库（Transformers 和 Gradio）在 Google Colab 上构建的。

使用 LLaVA 在线

如果你还没有尝试过，使用 LLaVA 的最简单方法是访问其作者提供的Web 界面。下面的截图展示了界面如何操作，其中用户根据冰箱内容的图片询问可以做哪些餐点的建议。用户可以通过左侧的控件上传图片，聊天界面允许提问并以文本形式获取答案。

LLaVA Web 界面

在这个例子中，LLaVA 正确识别出了冰箱中的食材，例如蓝莓、草莓、胡萝卜、酸奶或牛奶，并建议了相关的食谱创意，比如水果沙拉、果昔或蛋糕。

与 LLaVA 的其他对话示例可在项目网站上查看，这些示例说明了 LLaVA 不仅能够描述图像，还能够根据图像中的元素进行推理和推断（例如通过图片中的线索识别电影或人物、根据画图编码网站、解释幽默情况等）。

本地运行 LLaVA

LLaVA 还可以使用Ollama或 Mozilla 的‘llamafile’安装到本地计算机。这些工具可以在大多数仅配备 CPU 的消费级机器上运行，因为模型仅需要 8GB 内存和 4GB 的可用磁盘空间，甚至已经证明可以在 Raspberry PI 上成功运行。在围绕 Ollama 项目开发的工具和接口中，一个值得注意的项目是Ollama-WebUI（如下图所示），它复现了 OpenAI ChatGPT 用户界面的外观和操作体验。

Ollama Web 用户界面 — 受OpenAI ChatGPT的启发

LLaVA 主要特性简要概述

LLaVA 是由威斯康星大学麦迪逊分校、微软研究院和哥伦比亚大学的研究人员设计的，并且最近在 NeurIPS 2023 上展示。该项目的代码和技术规格可以通过Github 仓库访问，仓库还提供了与助手互动的各种接口。

正如作者在论文摘要中总结的：

[LLaVA] 在 11 个基准测试中达到了最先进的水平。我们的最终 13B 检查点仅使用了 1.2M 公开可用的数据，并且在单个 8-A100 节点上完成了大约 1 天的全训练。我们希望这能使最先进的大型多模态模型研究变得更加易于接触。代码和模型将公开发布。

论文中报告的基准结果，如下方的雷达图，展示了与其他最先进模型的对比改进。

LLaVA 基准结果的雷达图（图片来自论文）

内部工作机制

LLaVA 的数据处理工作流程在概念上非常简单。该模型本质上作为一个标准的因果语言模型工作，接受语言指令（用户文本提示）作为输入，并返回语言响应。语言模型处理图像的能力由一个独立的视觉编码器模型提供，该模型将图像转换为语言标记，这些标记被悄悄地添加到用户文本提示中（充当一种软提示）。LLaVA 的处理流程如下所示。

LLaVA 网络架构（图片来自论文）

LLaVA 的语言模型和视觉编码器分别依赖于两个参考模型，称为 Vicuna 和 CLIP。Vicuna是一个基于 LLaMA-2（由 Meta 设计）的预训练大语言模型，具有与中型 LLM 相媲美的竞争性能（参见 HuggingFace 上7B和13B版本的模型卡）。CLIP是由 OpenAI 设计的图像编码器，经过预训练，可以在相似的嵌入空间中对图像和文本进行编码，使用的是对比语言-图像预训练（因此称为‘CLIP’）。LLaVA 中使用的模型是视觉变换器变种 CLIP-ViT-L/14（查看其在 HuggingFace 上的模型卡）。

为了匹配视觉编码器的维度与语言模型的维度，一个投影模块（如上图中的W）被应用。它在原始的LLaVA中是一个简单的线性投影，在LLaVA 1.5中是一个两层感知机。

训练过程

LLaVA 的训练过程由两个相对简单的阶段组成。

第一阶段仅仅是为了调优投影模块W，而视觉编码器和 LLM 的权重保持冻结。训练使用来自CC3M 概念性字幕数据集的约 60 万对图像/字幕数据的子集进行，并且可以在 HuggingFace 的此仓库中找到。

在第二阶段，投影模块的权重W与 LLM 的权重一起进行微调（同时保持视觉编码器的权重冻结），使用包含 158K 语言-图像指令跟随数据的训练集。这些数据是通过 GPT-4 生成的，包含对话、详细描述和复杂推理的示例，并且可以在 HuggingFace 的此仓库中找到。

整个训练过程大约需要一天时间，使用八个 A100 GPU。

使用 LLaVA 进行编程：如何开始

代码可在 Colab 相关笔记本.

LLaVA 模型已集成在 Transformers 库中，可以通过标准的pipeline对象加载。7B 和 13B 版本的模型可以在LLaVA 😊 Hub 空间上找到，并可以以 4 位和 8 位加载，以节省 GPU 内存。下面我们展示如何使用代码加载并运行模型，代码可以在 Colab 上使用 T4 TPU（15GB 内存 GPU）执行。

以下是加载 4 位 LLaVA 1.5 7B 版本的代码片段：

from transformers import pipeline, BitsAndBytesConfig
import torch

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16
)

model_id = "llava-hf/llava-1.5-7b-hf"

pipe = pipeline("image-to-text", model=model_id, model_kwargs={"quantization_config": quantization_config})

然后让我们加载这张图片

我们使用标准的 PIL 库来加载这张图片：

import requests
from PIL import Image

image_url = "https://cdn.pixabay.com/photo/2018/01/29/14/13/italy-3116211_960_720.jpg"
image = Image.open(requests.get(image_url, stream=True).raw)
image

最后，我们使用图像查询 LLaVA 模型，并提供一个提示请求描述这张图片。

注意：提示的格式如下

“USER: \n\nASSISTANT:”

prompt = "USER: <image>\nDescribe this picture\nASSISTANT:"

outputs = pipe(image, prompt=prompt, generate_kwargs={"max_new_tokens": 200})
print(outputs[0]['generated_text'])

返回以下答案：

USER: 描述这张图片

ASSISTANT: 这张图片展示了一个大型、空旷的剧场，背景是壮丽的海洋景色。剧场四周被郁郁葱葱的绿色山坡环绕，远处可以看到一座雄伟的山脉。整个场景宁静而如画，阳光明媚地照耀在大地上。

LLaVA 聊天机器人

最后，让我们创建一个简单的聊天机器人，依赖于 LLaVA 模型。我们将使用Gradio 库，它提供了一种快速简便的方法来创建机器学习 Web 界面。

界面的核心是一个包含图像上传器（Gradio 图像对象）和聊天界面（Gradio ChatInterface对象）的行。

import gradio as gr

with gr.Blocks() as demo:

    with gr.Row():
      image = gr.Image(type='pil', interactive=True)

      gr.ChatInterface(
          update_conversation, additional_inputs=[image]
      )

聊天界面连接到一个update_conversation函数，该函数负责保持对话历史记录，并在用户发送消息时调用 LLaVA 模型生成响应。

def update_conversation(new_message, history, image):

    if image is None:
        return "Please upload an image first using the widget on the left"

    conversation_starting_from_image = [[user, assistant] for [user, assistant] in history if not assistant.startswith('Please')]

    prompt = "USER: <image>\n"

    for i in range(len(history)):
        prompt+=history[i][0]+'ASSISTANT: '+history[i][1]+"USER: "

    prompt = prompt+new_message+'ASSISTANT: '

    outputs = pipe(image, prompt=prompt, generate_kwargs={"max_new_tokens": 200, "do_sample" : True, "temperature" : 0.7})[0]['generated_text']

    return outputs[len(prompt)-6:]

界面是通过调用launch方法启动的。

demo.launch(debug=True)

几秒钟后，聊天机器人 Web 界面将出现：

恭喜，你的 LLaVA 聊天机器人已经启动并运行！

有用的链接

HuggingFace LLaVA 模型文档
Llava Hugging Face 组织
使用 AutoPrecessor 和 LLaVAForConditionalGeneration 加载和运行 LLaVA：Colab 笔记本
GPT-4V(ision)系统卡片
理解视觉指令微调

注意：除非另有说明，所有图片均由作者提供。

LLM 代理揭秘

原文：towardsdatascience.com/llm-agents-demystified-8e2a62c185fa?source=collection_archive---------1-----------------------#2024-07-14

使用 AdalFlow 库实现 ReAct 代理

Li Yin

·发表于Towards Data Science ·14 分钟阅读·2024 年 7 月 14 日

图片来源，感谢Growtika

AdalFlow 库：github.com/SylphAI-Inc/AdalFlow

Colab 笔记本

“自主代理是一个位于环境中的系统，能够感知该环境并在其中行动，随着时间推移，为了追求自己的目标，进而影响它所感知到的未来。”

— Franklin and Graesser (1997)

除了广为人知的 RAGs（检索增强生成模型），代理[1]是另一类受欢迎的 LLM 应用。使代理与众不同的是它们能够通过可访问的工具进行推理、规划和行动。在实现方面，AdalFlow 将其简化为一个生成器，能够使用工具，采取多步骤（顺序或并行）来完成用户查询。

什么是 ReAct 代理？

我们将首先介绍 ReAct[2]，这是构建代理的一种通用范式，包含一系列交替的思考、行动和观察步骤。

思考：采取行动的推理过程。
行动：从预定义的行动集合中采取的行动。特别地，这些是我们在工具部分介绍的工具/功能工具。
观察：最简单的场景是以字符串格式呈现的执行结果。为了更强的鲁棒性，可以通过任何提供足够执行信息的方式来定义，从而让 LLM 能够规划下一步。

提示和数据模型

DEFAULT_REACT_AGENT_SYSTEM_PROMPT是 React 代理 LLM 规划器的默认提示。我们可以将提示模板分为四个部分：

任务描述

这一部分是代理的整体角色设置和任务描述。

task_desc = r"""You are a helpful assistant.
Answer the user's query using the tools provided below with minimal steps and maximum accuracy.
Each step you will read the previous Thought, Action, and Observation(execution result of the action) and then provide the next Thought and Action."""

2. 工具、输出格式和示例

该模板部分与我们在工具中调用函数的方式完全相同。output_format_str是通过FunctionExpression和JsonOutputParser生成的。它包括实际的输出格式和FunctionExpression实例的示例列表。我们使用FunctionExpression的thought和action字段作为代理的回应。

tools = r"""{% if tools %}
<TOOLS>
{% for tool in tools %}
{{ loop.index }}.
{{tool}}
------------------------
{% endfor %}
</TOOLS>
{% endif %}
{{output_format_str}}"""

3. 任务规范，用于教会规划器如何“思考”。

我们提供更详细的指导，以确保代理始终以“finish”动作结束，以完成任务。此外，我们还教它如何处理简单查询和复杂查询。

对于简单查询，我们指示代理尽可能少的步骤来完成。
对于复杂查询，我们教代理采用“分而治之”的策略，逐步解决查询。

task_spec = r"""<TASK_SPEC>
- For simple queries: Directly call the ``finish`` action and provide the answer.
- For complex queries:
   - Step 1: Read the user query and potentially divide it into subqueries. And get started with the first subquery.
   - Call one available tool at a time to solve each subquery/subquestion. \
   - At step 'finish', join all subqueries answers and finish the task.
Remember:
- Action must call one of the above tools with name. It can not be empty.
- You will always end with 'finish' action to finish the task. The answer can be the final answer or failure message.
</TASK_SPEC>"""

我们将这三部分放在<SYS></SYS>标签内。

4. 代理步骤历史。

我们使用StepOutput来记录代理的步骤历史，包括：

action：这是代理预测的FunctionExpression实例。
observation：动作的执行结果。

特别地，我们将用户查询后的步骤历史格式化如下：

step_history = r"""User query:
{{ input_str }}
{# Step History #}
{% if step_history %}
<STEPS>
{% for history in step_history %}
Step {{ loop.index }}.
"Thought": "{{history.action.thought}}",
"Action": "{{history.action.action}}",
"Observation": "{{history.observation}}"
------------------------
{% endfor %}
</STEPS>
{% endif %}
You:"""

工具

除了用户提供的工具外，我们默认添加了一个名为finish的新工具，允许代理停止并返回最终答案。

def finish(answer: str) -> str:
   """Finish the task with answer."""
   return answer

简单地返回一个字符串可能无法满足所有场景，我们未来可能会考虑允许用户为更复杂的情况定义自己的 finish 函数。

此外，由于提供的工具不能总是解决用户查询，我们允许用户配置是否应该使用 LLM 模型来解决子查询，方法是通过add_llm_as_fallback参数进行配置。这个 LLM 将使用与代理规划器相同的模型客户端和模型参数。以下是我们指定回退 LLM 工具的代码：

_additional_llm_tool = (
   Generator(model_client=model_client, model_kwargs=model_kwargs)
   if self.add_llm_as_fallback
   else None
)

def llm_tool(input: str) -> str:
   """I answer any input query with llm's world knowledge. Use me as a fallback tool or when the query is simple."""
   # use the generator to answer the query
   try:
         output: GeneratorOutput = _additional_llm_tool(
            prompt_kwargs={"input_str": input}
         )
         response = output.data if output else None
         return response
   except Exception as e:
         log.error(f"Error using the generator: {e}")
         print(f"Error using the generator: {e}")
   return None

React Agent

我们定义了类ReActAgent来整合一切。它将协调两个组件：

planner：一个Generator，与JsonOutputParser配合使用，解析输出格式并提供FunctionExpression函数调用的示例。
ToolManager：管理给定的工具列表、finish 函数和 LLM 工具。它负责解析和执行这些函数。

此外，它还管理 step_history 作为 StepOutput 实例的列表，用于代理的内部状态。

提供输入查询并处理步骤以生成响应。

代理操作

我们将设置两组模型，Groq 提供的 llama3–70b-8192 和 OpenAI 提供的 gpt-3.5-turbo，来测试两个查询。为了对比，我们将这些与未使用代理的普通 LLM 响应进行比较。以下是代码片段：

from lightrag.components.agent import ReActAgent
from lightrag.core import Generator, ModelClientType, ModelClient
from lightrag.utils import setup_env

setup_env()

# Define tools
def multiply(a: int, b: int) -> int:
   """
   Multiply two numbers.
   """
   return a * b
def add(a: int, b: int) -> int:
   """
   Add two numbers.
   """
   return a + b
def divide(a: float, b: float) -> float:
   """
   Divide two numbers.
   """
   return float(a) / b
llama3_model_kwargs = {
   "model": "llama3-70b-8192",  # llama3 70b works better than 8b here.
   "temperature": 0.0,
}
gpt_model_kwargs = {
   "model": "gpt-3.5-turbo",
   "temperature": 0.0,
}

def test_react_agent(model_client: ModelClient, model_kwargs: dict):
   tools = [multiply, add, divide]
   queries = [
      "What is the capital of France? and what is 465 times 321 then add 95297 and then divide by 13.2?",
      "Give me 5 words rhyming with cool, and make a 4-sentence poem using them",
   ]
   # define a generator without tools for comparison
   generator = Generator(
      model_client=model_client,
      model_kwargs=model_kwargs,
   )
   react = ReActAgent(
      max_steps=6,
      add_llm_as_fallback=True,
      tools=tools,
      model_client=model_client,
      model_kwargs=model_kwargs,
   )
   # print(react)
   for query in queries:
      print(f"Query: {query}")
      agent_response = react.call(query)
      llm_response = generator.call(prompt_kwargs={"input_str": query})
      print(f"Agent response: {agent_response}")
      print(f"LLM response: {llm_response}")
      print("")

React 的结构，包括初始化参数和两个主要组件：tool_manager 和 planner，如下所示。

ReActAgent(
   max_steps=6, add_llm_as_fallback=True,
   (tool_manager): ToolManager(Tools: [FunctionTool(fn: , async: False, definition: FunctionDefinition(func_name='multiply', func_desc='multiply(a: int, b: int) -> int\n\n    Multiply two numbers.\n    ', func_parameters={'type': 'object', 'properties': {'a': {'type': 'int'}, 'b': {'type': 'int'}}, 'required': ['a', 'b']})), FunctionTool(fn: , async: False, definition: FunctionDefinition(func_name='add', func_desc='add(a: int, b: int) -> int\n\n    Add two numbers.\n    ', func_parameters={'type': 'object', 'properties': {'a': {'type': 'int'}, 'b': {'type': 'int'}}, 'required': ['a', 'b']})), FunctionTool(fn: , async: False, definition: FunctionDefinition(func_name='divide', func_desc='divide(a: float, b: float) -> float\n\n    Divide two numbers.\n    ', func_parameters={'type': 'object', 'properties': {'a': {'type': 'float'}, 'b': {'type': 'float'}}, 'required': ['a', 'b']})), FunctionTool(fn: .llm_tool at 0x11384b740>, async: False, definition: FunctionDefinition(func_name='llm_tool', func_desc="llm_tool(input: str) -> str\nI answer any input query with llm's world knowledge. Use me as a fallback tool or when the query is simple.", func_parameters={'type': 'object', 'properties': {'input': {'type': 'str'}}, 'required': ['input']})), FunctionTool(fn: .finish at 0x11382fa60>, async: False, definition: FunctionDefinition(func_name='finish', func_desc='finish(answer: str) -> str\nFinish the task with answer.', func_parameters={'type': 'object', 'properties': {'answer': {'type': 'str'}}, 'required': ['answer']}))], Additional Context: {})
   (planner): Generator(
      model_kwargs={'model': 'llama3-70b-8192', 'temperature': 0.0},
      (prompt): Prompt(
         template: 
         {# role/task description #}
         You are a helpful assistant.
         Answer the user's query using the tools provided below with minimal steps and maximum accuracy.
         {# REACT instructions #}
         Each step you will read the previous Thought, Action, and Observation(execution result of the action) and then provide the next Thought and Action.
         {# Tools #}
         {% if tools %}

         You available tools are:
         {# tools #}
         {% for tool in tools %}
         {{ loop.index }}.
         {{tool}}
         ------------------------
         {% endfor %}

         {% endif %}
         {# output format and examples #}

         {{output_format_str}}

         {# Task specification to teach the agent how to think using 'divide and conquer' strategy #}
         - For simple queries: Directly call the ``finish`` action and provide the answer.
         - For complex queries:
            - Step 1: Read the user query and potentially divide it into subqueries. And get started with the first subquery.
            - Call one available tool at a time to solve each subquery/subquestion. \
            - At step 'finish', join all subqueries answers and finish the task.
         Remember:
         - Action must call one of the above tools with name. It can not be empty.
         - You will always end with 'finish' action to finish the task. The answer can be the final answer or failure message.

         -----------------
         User query:
         {{ input_str }}
         {# Step History #}
         {% if step_history %}

         {% for history in step_history %}
         Step {{ loop.index }}.
         "Thought": "{{history.action.thought}}",
         "Action": "{{history.action.action}}",
         "Observation": "{{history.observation}}"
         ------------------------
         {% endfor %}

         {% endif %}
         You:, prompt_kwargs: {'tools': ['func_name: multiply\nfunc_desc: "multiply(a: int, b: int) -> int\\n\\n    Multiply two numbers.\\n    "\nfunc_parameters:\n  type: object\n  properties:\n    a:\n      type: int\n    b:\n      type: int\n  required:\n  - a\n  - b\n', 'func_name: add\nfunc_desc: "add(a: int, b: int) -> int\\n\\n    Add two numbers.\\n    "\nfunc_parameters:\n  type: object\n  properties:\n    a:\n      type: int\n    b:\n      type: int\n  required:\n  - a\n  - b\n', 'func_name: divide\nfunc_desc: "divide(a: float, b: float) -> float\\n\\n    Divide two numbers.\\n    "\nfunc_parameters:\n  type: object\n  properties:\n    a:\n      type: float\n    b:\n      type: float\n  required:\n  - a\n  - b\n', "func_name: llm_tool\nfunc_desc: 'llm_tool(input: str) -> str\n\n  I answer any input query with llm''s world knowledge. Use me as a fallback tool\n  or when the query is simple.'\nfunc_parameters:\n  type: object\n  properties:\n    input:\n      type: str\n  required:\n  - input\n", "func_name: finish\nfunc_desc: 'finish(answer: str) -> str\n\n  Finish the task with answer.'\nfunc_parameters:\n  type: object\n  properties:\n    answer:\n      type: str\n  required:\n  - answer\n"], 'output_format_str': 'Your output should be formatted as a standard JSON instance with the following schema:\n```\n{\n    "thought": "为什么该函数被调用（Optional[str]）（可选）",\n    "action": "FuncName() 有效的函数调用表达式。例如：\\"FuncName(a=1, b=2)\\" 遵循函数参数中指定的数据类型。例如，对于具有 x、y 属性的 Type 对象，使用 \\"ObjectType(x=1, y=2)（str）（必填）"\n}\n```py\nExamples:\n```\n{\n    "thought": "我已完成任务。",\n    "action": "finish(answer=\\"final answer: \'answer\'\\")"\n}\n________\n```py\n-Make sure to always enclose the JSON output in triple backticks (```)。请不要添加任何其他内容，除了有效的 JSON 输出！\n-使用双引号作为键和值的字符串标记。\n-不要将架构中的 "properties" 和 "type" 错误地理解为 JSON 输出中的实际字段。\n-遵循 JSON 格式规范。'}, prompt_variables: ['input_str', 'tools', 'step_history', 'output_format_str']

    )

    (model_client): GroqAPIClient()

    (output_processors): JsonOutputParser(

        data_class=FunctionExpression, examples=[FunctionExpression(thought='我已完成任务。', action='finish(answer="final answer: \'answer\'")')], exclude_fields=None, return_data_class=True

        (output_format_prompt): 提示(

        模板：你的输出应格式化为符合以下架构的标准 JSON 实例：

        ```py
         {{schema}}
         ```

        {% if example %}

        示例：

        ```py
         {{example}}
         ```

        {% endif %}

        -确保始终将 JSON 输出包裹在三个反引号内（```py). Please do not add anything other than valid JSON output!
         -Use double quotes for the keys and string values.
         -DO NOT mistaken the "properties" and "type" in the schema as the actual fields in the JSON output.
         -Follow the JSON formatting conventions., prompt_variables: ['example', 'schema']
         )
         (output_processors): JsonParser()
      )
   )
)

现在，让我们运行测试函数，看看代理的实际操作。

test_react_agent(ModelClientType.GROQ(), llama3_model_kwargs)
test_react_agent(ModelClientType.OPENAI(), gpt_model_kwargs)

我们的代理将通过有色打印输出展示开发者的核心步骤，包括输入查询、步骤和最终答案。以下是使用 llama3 的第一个查询打印输出（这里没有颜色）：

2024-07-10 16:48:47 - [react.py:287:call] - input_query: What is the capital of France? and what is 465 times 321 then add 95297 and then divide by 13.2

2024-07-10 16:48:48 - [react.py:266:_run_one_step] - Step 1:
StepOutput(step=1, action=FunctionExpression(thought="Let's break down the query into subqueries and start with the first one.", action='llm_tool(input="What is the capital of France?")'), function=Function(thought=None, name='llm_tool', args=[], kwargs={'input': 'What is the capital of France?'}), observation='The capital of France is Paris!')
_______
2024-07-10 16:48:49 - [react.py:266:_run_one_step] - Step 2:
StepOutput(step=2, action=FunctionExpression(thought="Now, let's move on to the second subquery.", action='multiply(a=465, b=321)'), function=Function(thought=None, name='multiply', args=[], kwargs={'a': 465, 'b': 321}), observation=149265)
_______
2024-07-10 16:48:49 - [react.py:266:_run_one_step] - Step 3:
StepOutput(step=3, action=FunctionExpression(thought="Now, let's add 95297 to the result.", action='add(a=149265, b=95297)'), function=Function(thought=None, name='add', args=[], kwargs={'a': 149265, 'b': 95297}), observation=244562)
_______
2024-07-10 16:48:50 - [react.py:266:_run_one_step] - Step 4:
StepOutput(step=4, action=FunctionExpression(thought="Now, let's divide the result by 13.2.", action='divide(a=244562, b=13.2)'), function=Function(thought=None, name='divide', args=[], kwargs={'a': 244562, 'b': 13.2}), observation=18527.424242424244)
_______
2024-07-10 16:48:50 - [react.py:266:_run_one_step] - Step 5:
StepOutput(step=5, action=FunctionExpression(thought="Now, let's combine the answers of both subqueries.", action='finish(answer="The capital of France is Paris! and the result of the mathematical operation is 18527.424242424244.")'), function=Function(thought=None, name='finish', args=[], kwargs={'answer': 'The capital of France is Paris! and the result of the mathematical operation is 18527.424242424244.'}), observation='The capital of France is Paris! and the result of the mathematical operation is 18527.424242424244.')
_______
2024-07-10 16:48:50 - [react.py:301:call] - answer:
The capital of France is Paris! and the result of the mathematical operation is 18527.424242424244.

对于第二个查询，打印输出：

2024-07-10 16:48:51 - [react.py:287:call] - input_query: Give me 5 words rhyming with cool, and make a 4-sentence poem using them
2024-07-10 16:48:52 - [react.py:266:_run_one_step] - Step 1:
StepOutput(step=1, action=FunctionExpression(thought="I need to find 5 words that rhyme with 'cool'.", action='llm_tool(input="What are 5 words that rhyme with \'cool\'?")'), function=Function(thought=None, name='llm_tool', args=[], kwargs={'input': "What are 5 words that rhyme with 'cool'?"}), observation='Here are 5 words that rhyme with "cool":\n\n1\. Rule\n2\. Tool\n3\. Fool\n4\. Pool\n5\. School')
_______
2024-07-10 16:49:00 - [react.py:266:_run_one_step] - Step 2:
StepOutput(step=2, action=FunctionExpression(thought='Now that I have the rhyming words, I need to create a 4-sentence poem using them.', action='llm_tool(input="Create a 4-sentence poem using the words \'rule\', \'tool\', \'fool\', \'pool\', and \'school\'.")'), function=Function(thought=None, name='llm_tool', args=[], kwargs={'input': "Create a 4-sentence poem using the words 'rule', 'tool', 'fool', 'pool', and 'school'."}), observation="Here is a 4-sentence poem using the words 'rule', 'tool', 'fool', 'pool', and 'school':\n\nIn the classroom, we learn to rule,\nWith a pencil as our trusty tool.\nBut if we're not careful, we can be a fool,\nAnd end up swimming in the school pool.")
_______
2024-07-10 16:49:12 - [react.py:266:_run_one_step] - Step 3:
StepOutput(step=3, action=FunctionExpression(thought='I have the poem, now I need to finish the task.', action='finish(answer="Here are 5 words that rhyme with \'cool\': rule, tool, fool, pool, school. Here is a 4-sentence poem using the words: In the classroom, we learn to rule, With a pencil as our trusty tool. But if we\'re not careful, we can be a fool, And end up swimming in the school pool.")'), function=Function(thought=None, name='finish', args=[], kwargs={'answer': "Here are 5 words that rhyme with 'cool': rule, tool, fool, pool, school. Here is a 4-sentence poem using the words: In the classroom, we learn to rule, With a pencil as our trusty tool. But if we're not careful, we can be a fool, And end up swimming in the school pool."}), observation="Here are 5 words that rhyme with 'cool': rule, tool, fool, pool, school. Here is a 4-sentence poem using the words: In the classroom, we learn to rule, With a pencil as our trusty tool. But if we're not careful, we can be a fool, And end up swimming in the school pool.")
_______
2024-07-10 16:49:12 - [react.py:301:call] - answer:
Here are 5 words that rhyme with 'cool': rule, tool, fool, pool, school. Here is a 4-sentence poem using the words: In the classroom, we learn to rule, With a pencil as our trusty tool. But if we're not careful, we can be a fool, And end up swimming in the school pool.

代理与普通 LLM 响应的比较如下所示：

Answer with agent: The capital of France is Paris! and the result of the mathematical operation is 18527.424242424244.
Answer without agent: GeneratorOutput(data="I'd be happy to help you with that!\n\nThe capital of France is Paris.\n\nNow, let's tackle the math problem:\n\n1\. 465 × 321 = 149,485\n2\. Add 95,297 to that result: 149,485 + 95,297 = 244,782\n3\. Divide the result by 13.2: 244,782 ÷ 13.2 = 18,544.09\n\nSo, the answer is 18,544.09!", error=None, usage=None, raw_response="I'd be happy to help you with that!\n\nThe capital of France is Paris.\n\nNow, let's tackle the math problem:\n\n1\. 465 × 321 = 149,485\n2\. Add 95,297 to that result: 149,485 + 95,297 = 244,782\n3\. Divide the result by 13.2: 244,782 ÷ 13.2 = 18,544.09\n\nSo, the answer is 18,544.09!", metadata=None)

对于第二个查询，比较结果如下所示：

Answer with agent: Here are 5 words that rhyme with 'cool': rule, tool, fool, pool, school. Here is a 4-sentence poem using the words: In the classroom, we learn to rule, With a pencil as our trusty tool. But if we're not careful, we can be a fool, And end up swimming in the school pool.
Answer without agent: GeneratorOutput(data='Here are 5 words that rhyme with "cool":\n\n1\. rule\n2\. tool\n3\. fool\n4\. pool\n5\. school\n\nAnd here\'s a 4-sentence poem using these words:\n\nIn the summer heat, I like to be cool,\nFollowing the rule, I take a dip in the pool.\nI\'m not a fool, I know just what to do,\nI grab my tool and head back to school.', error=None, usage=None, raw_response='Here are 5 words that rhyme with "cool":\n\n1\. rule\n2\. tool\n3\. fool\n4\. pool\n5\. school\n\nAnd here\'s a 4-sentence poem using these words:\n\nIn the summer heat, I like to be cool,\nFollowing the rule, I take a dip in the pool.\nI\'m not a fool, I know just what to do,\nI grab my tool and head back to school.', metadata=None)

ReAct 代理对于回答需要计算或更复杂推理和规划的查询特别有用。然而，在处理一般查询时使用它可能会过于复杂，因为它可能需要比必要的更多步骤来回答问题。

定制化

模板

首先你想要自定义的是模板本身。你可以通过将自己的模板传递给代理的构造函数来做到这一点。我们建议你修改我们的默认模板：[**DEFAULT_REACT_AGENT_SYSTEM_PROMPT**](https://lightrag.sylph.ai/apis/components/components.agent.react.html#components.agent.react.DEFAULT_REACT_AGENT_SYSTEM_PROMPT)。

更好的输出格式示例

其次，构造函数中的examples允许你提供更多示例以确保正确的输出格式。例如，如果我们想让它学习如何正确调用 multiply，我们可以传入一个包含正确格式的FunctionExpression实例的列表。classmethod from_function可以用来从一个函数及其参数创建一个FunctionExpression实例。

from lightrag.core.types import FunctionExpression

# generate an example of calling multiply with key-word arguments
example_using_multiply = FunctionExpression.from_function(
     func=multiply,
     thought="Now, let's multiply two numbers.",
     a=3,
     b=4,
 )
examples = [example_using_multiply]# pass it to the agent

我们可以通过以下方式可视化如何将其传递给规划器提示：

react.planner.print_prompt()

上述示例将格式化为：

<OUTPUT_FORMAT>
Your output should be formatted as a standard JSON instance with the following schema:

{

"thought": "为什么调用这个函数（Optional[str]）（可选）",

"action": "FuncName() 有效的函数调用表达式。例如："FuncName(a=1, b=2)" 请遵循函数参数中指定的数据类型。例如，对于具有 x、y 属性的类型对象，使用"ObjectType(x=1, y=2) (str) (required)"

}

Examples:

{

"thought": "现在，让我们乘以两个数字。",

"action": "multiply(a=3, b=4)"

}

{

"thought": "我已经完成了任务。",

"action": "finish(answer="final answer: 'answer'")"

}

-Make sure to always enclose the JSON output in triple backticks (```）。请不要添加任何有效 JSON 输出之外的内容！

-键和字符串值请使用双引号。

-不要将模式中的“properties”和“type”误认为是 JSON 输出中的实际字段。

遵循 JSON 格式规范。

</OUTPUT_FORMAT>

子类化 ReActAgent

如果你想进一步自定义代理，可以子类化[**ReActAgent**](https://lightrag.sylph.ai/apis/components/components.agent.react.html#components.agent.react.ReActAgent)并重写你想更改的方法。

参考文献

[1] 关于基于大语言模型的自主代理的调查：Paitesanshi/LLM-Agent-Survey

[2] ReAct: arxiv.org/abs/2210.03629

API 参考

[**components.agent.react.ReActAgent**](https://lightrag.sylph.ai/apis/components/components.agent.react.html#components.agent.react.ReActAgent)
[**core.types.StepOutput**](https://lightrag.sylph.ai/apis/core/core.types.html#core.types.StepOutput)
[**components.agent.react.DEFAULT_REACT_AGENT_SYSTEM_PROMPT**](https://lightrag.sylph.ai/apis/components/components.agent.react.html#components.agent.react.DEFAULT_REACT_AGENT_SYSTEM_PROMPT)

LLM 代理——直观且详尽地解释

原文：towardsdatascience.com/llm-agents-intuitively-and-exhaustively-explained-8905858e18e2?source=collection_archive---------2-----------------------#2024-01-05

语言建模 | 自主系统 | 人工智能

赋能语言模型进行推理与行动

Daniel Warfield

·发表于 Towards Data Science ·阅读时间 37 分钟·2024 年 1 月 5 日

“决策引导者”由丹尼尔·沃菲尔德（Daniel Warfield）使用 MidJourney 创作。所有图像均由作者提供，除非另有说明

本文聚焦于“代理”这一概念，它允许语言模型进行推理并与世界互动。首先，我们将讨论什么是代理以及为什么它们很重要；接着，我们将通过几种代理的形式来建立对其工作原理的直观理解；然后，我们将通过实现两种代理来探索代理在实际环境中的应用，一种使用 LangChain 实现，另一种用 Python 从零开始实现。

在本文结束时，您将理解代理如何赋能语言模型执行复杂任务，您也将了解如何自己构建一个代理。

这对谁有用？ 任何对构建前沿语言建模系统所需工具感兴趣的人。

这篇文章的难度如何？ 这篇文章在概念上简单，但包含了过去一年中的前沿研究，因此对各个经验层次的数据科学家都具有相关性。

前提条件： 无，尽管对语言模型（如 OpenAI 的 GPT）有一些基本了解可能会有所帮助。如果您对某些内容感到困惑，我在本文末尾附加了一些相关资料，供您参考……

LLM 代理、文本向量化、进阶 SQL 及其他我们最新作者的必读文章

原文：towardsdatascience.com/llm-agents-text-vectorization-advanced-sql-and-other-must-reads-by-our-newest-authors-3263a1bdd7eb?source=collection_archive---------6-----------------------#2024-08-22

TDS 编辑

·发布于Towards Data Science ·作为 Newsletter 发送 ·阅读时间：4 分钟·2024 年 8 月 22 日

如果你是《Variable》的常规读者，你可能已经注意到我们每周都会强调——TDS 始终欢迎新作者投稿。我们是认真的！你们中的一些人可能看到过这个信息，心想“太好了，我想写一篇文章！”但又开始思考，什么样的文章适合投稿，读者们对哪些话题感兴趣，以及哪些经历和技能是受欢迎的。

本周的《Variable》版块精选了我们最近的一些最佳文章，所以如果你不打算成为 TDS 的作者，那也完全没问题！我们希望你像往常一样享受阅读。我们这次只关注了我们最新一批作者的文章，旨在激励你们也尝试投稿。

正如你将看到的，TDS 的投稿者具有广泛的经验背景（从初学者到博士、行业老兵不等）、兴趣以及写作风格。将他们联系在一起的是他们卓越的叙事能力和将知识分享给更广泛社区的愿望。我们希望（并且相当确定）你会喜欢我们每周的内容。

大型语言模型“理解”什么？ “当我们将类人能力归因于 LLM 时，我们往往会陷入拟人化偏见，把它们的能力与我们自身的能力进行类比。但我们是否也在表现出一种人类中心主义偏见，忽视了 LLM 始终展现出来的能力？”在我们最近读过的一篇最具启发性的文章中，Tarik Dzekman从哲学和心理学的视角探讨了 LLM 理解语言的能力问题。
将 LLM 代理与 LangChain 整合到 VICA 中“我们的目标是告别聊天机器人中那种机械化和笨拙的表单式体验，迎接与人类助手进行个性化对话的新方式。”黄伟诚和Nicole Ren分享了他们在新加坡 GovTech 虚拟智能聊天助手（VICA）平台上广泛工作中的实际见解和经验教训。
文本向量化揭秘：将语言转化为数据 “对于我们这些了解机器学习流程的人来说，我们明白特征工程是从模型中生成良好结果的关键步骤。这个概念在自然语言处理（NLP）中同样适用。”Lakshmi Narayanan提供了关于文本向量化方法的全面概述，并权衡了它们各自的优缺点。

图片来源：Totte Annerbrink 来自Unsplash

利用 Gemini-1.5-Pro-Latest 实现更智能的饮食 “值得注意的是，随着人工智能领域的进步，数据科学家有责任逐步从传统的深度学习转向生成式人工智能技术，以革新他们的角色。”Mary Ara展示了一个端到端的项目演示，说明如何通过创建一个利用最先进的多模态模型的卡路里追踪应用来实现这一目标。
在技术行业成功的最有用的高级 SQL 技巧“尽管掌握基本和中级 SQL 相对容易，但要真正精通这项工具，并在各种场景中熟练运用，有时却具有挑战性。”Jiayan Yin旨在通过全面概述您应该添加到查询工具包中的更高级 SQL 技巧，帮助数据分析师和其他从业者弥补这一技能差距。
使用 Hugging Face Transformers 微调音频频谱变换器“这个过程将模型的能力调整到我们数据集的独特特征，比如类别和数据分布，从而确保结果的相关性。”在机器学习与音频数据的交集上，Marius Steger详细阐述了如何在任何音频分类数据集上微调音频频谱变换器（AST）的工作流程。
使用 MLflow 进行算法无关的模型构建“考虑这样一个场景：我们有一个当前在生产环境中部署的 sklearn 模型，用于特定的用例。后来，我们发现深度学习模型的表现更好。如果 sklearn 模型是以其原生格式部署的，转向深度学习模型可能会变得非常麻烦，因为这两个模型的工件差异很大。”Mena Wang, PhD解释了为什么有时使用算法无关的模型会非常有意义，并展示了如何在 MLflow 中开始使用它。
深度学习中非线性的新视角 “但我们为什么需要激活函数，特别是非线性激活函数？传统上有一种解释方式，同时也有一种新的视角。”Harys Dalvi剖析了在深度学习分类器输出中使用线性层的风险，以及通过多角度理解线性与非线性所能带来的价值。

感谢您支持我们作者的工作！正如我们前面提到的，我们喜欢发布新作者的文章，因此，如果您最近写了一篇有趣的项目教程、指南或关于我们核心主题的理论思考，请不要犹豫，与我们分享。

直到下一个变量，

TDS 团队

LLM 对齐：基于奖励的方法与无奖励的方法

原文：towardsdatascience.com/llm-alignment-reward-based-vs-reward-free-methods-ef0c0f6e8d88?source=collection_archive---------0-----------------------#2024-07-05

LLM 对齐的优化方法

Anish Dubey

·发表于 Towards Data Science ·阅读时长 10 分钟·2024 年 7 月 5 日

背景

语言模型在基于用户提供的提示生成各种引人注目的文本方面展现了显著的能力。然而，定义什么是“好”文本是具有挑战性的，因为它通常依赖于个人偏好和具体上下文。例如，在讲故事时，创造力是关键；在制作信息内容时，准确性和可靠性至关重要；在生成代码时，确保代码正确运行是必要的。因此，“LLM 对齐问题”，即确保大型语言模型（LLM）按照与人类价值观、意图和偏好一致的方式运作的挑战。

设计一个能够捕捉我们在文本中重视的多种特质（如创造力、准确性或可执行性）的损失函数是极其复杂的，且往往不切实际。像这些概念并不可微分，因此无法进行反向传播，也不能通过简单的下一词生成进行训练。

假设我们能够利用人类反馈来评估生成文本的质量，或者更好的是，使用这些反馈作为引导损失函数来提升模型的表现。这个概念是“人类反馈强化学习”（RLHF）的核心。通过应用强化学习技术，RLHF 使我们能够根据直接的人类反馈微调语言模型，使模型更加符合人类细微的价值观和期望。这种方法为训练不仅更加响应迅速，而且更符合人类偏好复杂性的语言模型开辟了新的可能性。

接下来，我们将通过基于奖励的方法，进一步了解 RLHF，并了解基于无奖励的方法。

什么是通过人类反馈的强化学习（RLHF）和基于奖励的系统？

让我们来了解通过人类反馈的强化学习（RLHF）。它由三个主要阶段组成：

监督微调
奖励建模阶段
RL 微调阶段

监督微调

RLHF 是一个预训练模型，已经在高质量数据集上进行了微调。它的目标很简单，即在给定输入（提示）时，产生一个输出。最终目标是进一步微调该模型，以根据人类的偏好产生输出。因此，让我们称之为基础模型以供参考。目前，这个模型是一个标准的基础模型，它对任何人类偏好一无所知。

奖励建模阶段

奖励模型创新：这是奖励模型如何被融入到 RLHF 中的新创新开始的地方。奖励模型的背后思想是，一个新的 LLM 模型（它可以与上述的基础模型相同）将能够生成人的偏好评分。之所以与大型语言模型相似，是因为该模型也需要理解语言语义，才能评估输出是否符合人类偏好。由于奖励是标量，我们在 LLM 上方添加一个线性层，以生成一个关于人类偏好的标量评分。

数据收集阶段：这个阶段是在监督微调阶段完成的，在该阶段中，基础模型会为给定的文本生成两个输出。示例：对于输入标记 x，基础模型生成两个输出标记 y1 和 y2。这些输出会展示给人工评分员进行评分，并记录每个输出的人工偏好。

训练阶段：一旦数据收集阶段采集到数据样本，奖励模型就会使用以下提示进行训练：“给定以下输入：，LLM 生成了输出。你能评估该输出的表现吗？” 模型将输出 r（奖励），我们已经知道从数据收集阶段得到的实际奖励值 r1。现在，可以通过损失函数进行反向传播，模型可以得到训练。以下是模型通过反向传播优化的目标损失函数：

该论文中的公式：arxiv.org/pdf/2305.18290

符号说明：

rΦ(x, y)：一个由Φ参数化的奖励模型，用于估计奖励。参数化意味着我们不知道实际的值，且需要根据上述方程进行优化。这就是奖励 LLM 模型本身。通常，LLM 的参数在这里被冻结，只有少数参数允许变化。最重要的层是顶部添加的线性层，它负责进行大部分的学习，以评估输出的评分。
Ɗ：一个三元组数据集（x, yw, yl），其中 x：输入，yw：赢家输出，yl：输家输出
σ：sigmoid 函数，它将奖励差异映射到一个概率值（0–1 之间）
∑(x, y,w yl) ~Ɗ 表示 x, yw, yl 都是从 Ɗ 中采样的。

示例场景： 假设你正在训练一个奖励模型来评估回答。你有一对针对给定提示的回答，并且人类反馈告诉你哪个回答更好。举个例子，x（“法国的首都是什么？”），你有 yw（“法国的首都巴黎。”）作为赢家，以及 yl（“法国的首都柏林。”）作为输家。当输入是“法国的首都是什么？”时，奖励模型最终应该学会给“法国的首都巴黎”更高的奖励，而不是“法国的首都柏林”。

RL 微调阶段

强化学习思路： 现在，基本模型和奖励模型都已经训练完成，思路是如何利用奖励模型的得分并更新基本模型参数，以反映人类偏好。由于奖励模型输出的是标量分数，并且不可微，我们无法使用简单的反向传播来更新基本模型参数。因此，我们需要其他技术来更新基本模型。这就是强化学习的作用，它通过奖励模型的得分帮助基本模型改变参数。这是通过 PPO（近端策略优化）完成的。理解 PPO 的核心架构并不是理解这个概念所必需的，因此我们不会在这里讲解，但从高层次来说，PPO 的思路是可以使用标量得分来更新基本模型参数。现在让我们了解基本模型和奖励模型如何结合起来，使得基本模型学习人类偏好。

RL 微调思路： 在强化学习中，我们有动作、空间和奖励。思路是提出一个策略，让任何动作代理都可以在该空间内采取，从而最大化奖励。这个过程比较复杂，但简化来看，π是我们的基本 LLM 模型。Πref表示基本模型，ΠӨ表示我们正在尝试生成的不同的 LLM 最优模型。我们需要找到 ΠӨ（即基本模型的神经网络权重将被微调），从而输出人类更喜欢的结果。问题是我们不知道ΠӨ，而目标是找到这个最优模型。

强化学习训练与反馈循环阶段：输入 x 被提供给两个策略模型，Πref（基准模型）和ΠӨ（我们试图生成的最优模型）。最初，两个模型是相同的。将输入 x 分别传入这两个模型会分别产生两个输出。ΠӨ模型的输出也会输入到奖励模型中（输入：x，输出：y；如上所述），并要求输出奖励分数，即 rΦ(x, y)。现在我们有三个内容：基准模型的输出、最优模型的输出和最优模型的奖励分数。这里有两个优化目标，一个是最大化奖励，因为最终我们希望模型与人类偏好尽可能接近，另一个是最小化与基准模型的差异。最大化奖励很容易，因为它本身就是一个标量值，但如何最小化基准模型和最优模型之间的差异呢？这里我们使用“Kullback–Leibler 散度”，它估计两个连续概率分布之间的差异。让我们更深入地了解目标损失函数。

来自本文的方程：arxiv.org/pdf/2305.18290

符号表示法：

rΦ(x, y)：表示输入 x 和输出 y 的标量值（来自最优模型）。为了明确起见，最优模型的输出会被输入到奖励模型中。
Dkl (ΠӨ (y | x) || Πref (y | x))：计算两个概率分布之间的Kullback–Leibler 散度。每个模型中的每个标记都是一个概率分布。KL 估计两个分布之间的差异程度。
β：超参数，用于确定最优模型与基准模型接近的重要性。

示例场景：假设你问：“法国的首都是什么？”，Πref（基准模型）回答：“法国的首都是柏林。”而ΠӨ（最优模型）回答：“法国有三个首都，巴黎、凡尔赛和里昂，但巴黎被视为官方首都。”现在 rΦ(“x: 法国的首都是什么…”, “y: 法国有三个首都…”)应该给出较低的分数，因为它不太符合人类的偏好，且 Kullback–Leibler 散度（ΠӨ (y | x) || Πref (y | x)）也应该较高，因为两个模型的输出概率分布空间存在差异。因此，这两个项的损失都会较高。我们不希望模型仅仅优化奖励，还希望它能够保持接近基准模型，因此这两个项都用于优化奖励。在接下来的学习迭代中，假设ΠӨ（最优模型）回答“法国的首都是德里”，在这种情况下，模型学习到保持接近Πref（基准模型）并输出更接近基准模型格式的内容，但奖励部分仍然较低。希望在第三次迭代中，ΠӨ（最优模型）能够学习并输出“法国的首都是巴黎”，并获得更高的奖励，同时模型输出与基准模型紧密对齐。

以下图示有助于说明逻辑。我还强烈推荐浏览RLHF 链接，该链接来自 Hugging Face。

作者提供的图片，灵感来自huggingface.co/blog/rlhf

什么是通过无奖励方法的基于人类反馈的强化学习（RLHF）？

在考虑使用基于奖励的方法的 RLHF 之后，我们来讨论无奖励方法。根据论文中的描述：“我们的关键见解是利用从奖励函数到最优策略的分析映射，这使我们能够将奖励函数上的损失函数转换为策略上的损失函数。这种变量变换方法避免了拟合显式的独立奖励模型，同时仍然在现有的人类偏好模型下进行优化。” 非常复杂，理解起来有难度，但我们将在下一部分尝试将其分解为简单的阶段。

无奖励方法的关键思想： 在 RLHF 中，训练一个单独的新的奖励模型既昂贵又难以维护。有没有什么机制可以避免训练新的奖励模型，而使用现有的基础模型来达到新的最优模型？这正是无奖励方法的做法，即它避免了训练新的奖励模型，并通过改变方程式，使得 DPO（直接偏好优化）的损失函数中不再包含奖励模型项。可以这样理解，我们需要从基础模型（Πref）到达最优模型策略（ΠӨ）。可以通过优化奖励函数空间来帮助建立代理模型，从而达到最优模型策略，或直接学习从奖励到策略的映射函数，并进而优化策略本身。这正是作者们通过移除损失函数中的奖励函数组件，并直接用模型策略参数替代它所尝试的做法。这就是作者们所说的“利用奖励函数到最优策略的分析映射...到损失函数上”的核心创新。

DPO 训练与反馈回路阶段： 使用Πref（基线模型），输入 x 并要求产生 2 个输出（y1 和 y2）。所有 x、y1 和 y2 都会被人工评分员用来决定胜出的 yw 和失败的 yl。离线数据集收集了三元组信息<x, yw 和 yl>。通过这些信息，我们知道胜出（人类偏好）和失败（人类不偏好）的答案是什么。现在，相同的输入 x 被传入 2 个模型（Πref 基线模型和ΠӨ最优模型）。最初，为了训练目的，两个模型保持相同。将输入 x 分别输入这两个模型，得到相应的两个输出。我们通过“Kullback-Leibler 散度”计算输出与参考模型和最优模型的胜出与失败答案之间的差距。让我们深入研究目标损失函数。

公式

来自 arxiv.org/pdf/2305.18290 的方程

ΠӨ (yw | x) -> 给定输入 x，模型的对应输出 youtput 与获胜输出 yw 之间的差距是多少。输出 youtput 和 yw 是概率分布，二者之间的差异将通过“Kullback–Leibler 散度”来计算。这将是一个标量值。此外，这也会针对不同组合的Πref (yw | x)、Πref (yl | x)、ΠӨ (yw | x)和ΠӨ (yl | x)进行计算。
β ：超参数，用于确定将最佳模型与基线模型接近的重要性。

图片来源于作者，灵感来自 huggingface.co/blog/rlhf

结论

自然地，问题变成了哪种方法更好，基于奖励的 RLHF 方法使用 PPO，还是无奖励的方法使用 DPO。这个问题没有确切的答案。最近一篇论文比较了“DPO 是否优于 PPO 用于大语言模型对齐”（论文链接）并得出结论，PPO 通常优于 DPO，而且 DPO 在处理超出分布的数据时更为困难。“超出分布”数据指的是人类偏好数据与基线训练数据不同。如果基础模型的训练是在某些数据集上进行，而偏好输出是在另一个数据集上进行，这种情况就可能发生。
总的来说，关于哪种方法更好，研究仍在进行中，但我们已经看到像 OpenAI、Anthropic、Meta 等公司将 RLHF 通过 PPO 和 DPO 两种工具用于大语言模型的对齐。

参考文献

直接偏好优化：你的语言模型实际上是一个奖励模型：arxiv.org/pdf/2305.18290
DPO 是否优于 PPO 用于大语言模型对齐？一项综合研究 arxiv.org/pdf/2404.10719
Hugging face RLHF 文章 huggingface.co/blog/rlhf

LLM 应用、关键数据技能、多代理 AI 系统及其他七月必读文章

原文：towardsdatascience.com/llm-apps-crucial-data-skills-multi-ai-agent-systems-and-other-july-must-reads-a660a846cda8?source=collection_archive---------6-----------------------#2024-07-04

TDS 编辑

·发表于Towards Data Science ·通过新闻通讯发送 ·阅读时间：4 分钟·2024 年 7 月 4 日

感觉受到了启发，想写下你的第一篇 TDS 文章吗？ 我们始终欢迎新作者的投稿。

如果你所在的地方已经是夏天，我们希望你能充分利用温暖的天气和（希望？也许？）更加放松的日常节奏。当然，学习永远不会停止——至少对数据科学家而言如此——所以如果你认为美好的时光是挑战新课题、探索前沿工具和工作流程，那么你将迎来一场盛宴。

我们七月的亮点由上个月在读者中引起最大反响的文章组成，涵盖了广泛的实用话题——其中许多文章旨在帮助你提高自身标准，拓展技能。让我们一起深入了解吧！

每月亮点

我在 Uber、Meta 和初创公司 10 年的经历教会了我数据分析的知识提供建议很容易；但根据 10 年的多元化数据领导经验，提出可操作的、经过时间验证的见解则需要付出更多努力——在Torsten Walbaum的文章中，这一努力绝对值得。
作为数据科学家，我如何使用 ChatGPT我们是否终于迎来了 LLM 工具能够显著简化数据专业人士核心任务的时刻？正如Egor Howell所解释的，如果你在如何以及在哪里将 ChatGPT 集成到工作流中做出聪明的选择，你的生产力可能已经开始显著受益。
330 周的数据可视化：我的历程与关键收获 在进行超过五年的每周数据可视化创作后，Yu Dong回顾了持续性的价值，并为现有和未来的数据科学家提供了有益的建议，帮助他们在制作图表、绘图和信息图时提升自己的技能。

照片由Emily Studer拍摄，发布于Unsplash

构建 LLM 应用程序：清晰的逐步指南许多机器学习从业者都有很棒的 AI 产品创意，但正如Almog Baku所指出的，“目前没有建立的最佳实践，很多先驱者在没有清晰路线图的情况下，要么需要重新发明轮子，要么会陷入困境。”幸运的是，随着 Almog 为导航复杂的 LLM 原生开发领域制定了蓝图，这种情况已经不再发生。
多 AI 代理系统 101在 LLM 成为主流后不久，产品工程师们开始发现它们所带来的各种痛点和瓶颈。Mariya Mansurova最近发布的指南介绍了应对这些挑战的最有前景的策略之一：多代理 AI 系统，在这种系统中，每个代理都拥有自己专门的“技能”，可以与其他代理协作。
2024 年你不能忽视的 5 项数据科学技能 在她的精彩职业导向总结中，Sara Nóbrega观察到：“虽然大学和正式教育提供了一些基本技能，但它们往往无法为学生提供进入公司所需的实际知识。”Sara 旨在填补这一空白，推荐数据科学家应该专注的五个领域，以便在当今的就业市场中茁壮成长。
17 种（高级）RAG 技术，将您的 LLM 应用原型转化为生产就绪解决方案 如果您需要随时调整、优化或升级您的检索增强生成系统，请务必收藏Dominik Polzer最近的贡献，他的内容远远超越了基础知识，涵盖了元数据、查询路由、句子窗口检索等更多内容。
微调小型变换器模型：文本分类 我们通过一篇出色的项目操作指南来完成本月的内容，由Ida Silfverskiöld呈现：它耐心地概述了微调小型变换器模型以处理 NLP 任务的过程，使用一个经过预训练的编码器模型，通过二分类来识别点击诱饵与事实类文章。

感谢您支持我们作者的工作！我们非常喜欢发布新作者的文章，如果你最近写了一篇有趣的项目 walkthrough、教程，或是关于我们核心主题的理论思考，别犹豫，与我们分享。

直到下一个变量，

TDS 团队

LLM 评估、AI 副项目、用户友好的数据表格及其他十月必读

原文：towardsdatascience.com/llm-evaluation-ai-side-projects-user-friendly-data-tables-and-other-october-must-reads-6be0066008e2?source=collection_archive---------8-----------------------#2024-10-31

TDS Editors

·发表于 Towards Data Science ·以新闻通讯形式发布 ·4 分钟阅读 ·2024 年 10 月 31 日

是否感到受到启发，想写你的第一篇 TDS 文章？我们始终欢迎新作者的投稿。

我们似乎正处于日历上一个理想的时段——介于夏季结束和节前最后的忙碌冲刺之间，换句话说，这是一个学习、琢磨和探索的完美时机。

我们十月最受欢迎的文章反映了这种专注能量的精神，涵盖了一系列动手实践的主题。从可操作的 AI 项目构思和数据科学收入来源，到关于时间序列分析和 LLMs（大语言模型）的易懂指南，这些文章很好地代表了我们作者的广博专业知识和他们（以及我们的读者）兴趣的多样性。如果你还没阅读它们，现在正是最佳时机！

月度亮点

5 个你可以在这个周末用 Python 构建的 AI 项目 如果你还没有准备好，别担心，马上就要动手了：我们十月最受欢迎的文章，来自Shaw Talebi，概述了几个非常有吸引力的项目构思，适合那些想将 AI 知识付诸实践的人。从简历整理工具到多模态搜索工具，这些项目为进入日益扩展的 AI 驱动产品开发世界提供了一个平滑的切入点。
谁真正拥有你预订的 Airbnb？——营销认知与数据分析的现实差异如果你想深入研究一个有趣的数据分析案例，Anna Gordun Peiro的最新文章正好符合你的需求。该文章基于公开数据，深入探讨了 Airbnb 的所有权模式，并向读者展示了如何在自己选择的城市进行类似的调查。
LLM 评估技能容易掌握（但实践成本高）创建 LLM 解决方案需要大量的时间和资源投入，因此产品经理和机器学习工程师必须清晰准确地了解其性能。Thuwarakesh Murallie为我们详细介绍了如何利用多种评估方法和工具，以实现这一常常难以捉摸的目标。

由Ahmad Ossayli拍摄，图片来自Unsplash

构建用户友好数据表的 5 个原则“我常常会想，‘这列是什么意思？’‘为什么表 A 和表 B 中有两列名称相同的列？我该用哪一列？’”Yu Dong介绍了五条实用的规则，确保你的数据表对团队成员和其他利益相关者具有可访问性、可用性，并且容易理解。
我如何在两周内学习 LLM：一份全面的学习路线图尽管你可能认为 LLM 在过去几年里已经无处不在，但许多从业者——无论是新手还是经验丰富的专家——才刚刚开始关注这一热门话题；如果你想要一个系统化的学习方法，从基础知识（及更多）开始，不妨直接参考Hesam Sheikh的广受欢迎的课程。
从零开始使用初中数学理解大型语言模型如果你希望通过更有指导性的方法从零开始学习大型语言模型，可以尝试Rohit Patel的首篇 TDS 贡献：这是一个全面的、40 分钟的讲解，讲解了这些模型的内部工作原理——并且不需要任何高级数学或机器学习知识。
掌握时间序列分析的 5 种必知技巧从数据拆分和交叉验证到特征工程，Sara Nóbrega最近的深入分析聚焦于你需要掌握的基本工作流，以便有效进行时间序列分析。
AI 代理：生成式 AI 中工具调用与推理的交集最近几个月，少有话题能像 AI 代理那样引发如此广泛的关注；如果你想深入了解它们的潜力（和局限性），不要错过Tula Masterman的清晰概述，该概述重点介绍了代理推理如何通过工具调用表现出来，探讨了代理在使用工具时面临的一些挑战，并涵盖了评估工具调用能力的常见方法。
作为数据科学家的 7 个收入来源大多数（所有？）数据专业人士都知道在科技巨头公司全职工作的福利，但将技能变现的选择远不止这些。Egor Howell提供了一个坦率的总结，回顾了他在过去几年中成为全职数据科学家后，所培养的各种收入来源。

我们最新一届的新作者

每个月，我们都非常高兴看到一批新的作者加入 TDS，他们每个人都在与我们的社区分享自己独特的声音、知识和经验。如果你正在寻找新的作者来探索和关注，只需浏览我们最新加入的作者作品，包括David Foutch、Robin von Malottki、Ruth Crasto、Stéphane Derosiaux、Rodrigo Nader、Tezan Sahu、Robson Tigre、Charles Ide、Aamir Mushir Khan、Aneesh Naik、Alex Held、caleb lee、Benjamin Bodner、Vignesh Baskaran、Ingo Nowitzky、Trupti Bavalatti、Sarah Lea、Felix Germaine、Marc Polizzi、Aymeric Floyrac、Bárbara A. Cancino、Hattie Biddlecombe、Carlo Peron、Minda Myers、Marc Linder、Akash Mukherjee、Jake Minns、Leandro Magga、Jack Vanlightly、Rohit Patel、Ben Hagag、Lucas See、Max Shap、Fhilipus Mahendra、Prakhar Ganesh，和Maxime Jabarian。

感谢您支持我们作者的工作！我们很喜欢发布新作者的文章，所以如果您最近写了一篇有趣的项目演示、教程或关于我们核心话题的理论反思，请毫不犹豫地与我们分享。

直到下一个变量，

TDS 团队

LLM 评估技能很容易掌握（但实践起来成本高昂）

原文：towardsdatascience.com/llm-evaluation-techniques-and-costs-3147840afc53?source=collection_archive---------1-----------------------#2024-10-09

这里是如何避免浪费预算在评估模型和系统上的方法

Thuwarakesh Murallie

·发表于Towards Data Science ·14 分钟阅读·2024 年 10 月 9 日

图片由作者使用 Flux1.1 Pro 制作。

你可以通过两种方式建造一座堡垒：一种是开始将砖块一个个堆叠起来，另一种是先画出你即将建造的堡垒的图纸并规划执行方案；然后，按照你的计划不断评估它。

我们都知道第二种方法是我们可能构建堡垒的唯一途径。

有时候，我是我自己建议的最差追随者。我说的是直接跳入笔记本去构建 LLM 应用程序。这是我们破坏项目的最糟糕做法。

在我们开始之前，我们需要一个机制来告诉我们是否朝着正确的方向前进——也就是要说明我们上一次尝试的结果是否比之前更好（或者相反）。

在软件工程中，这叫做测试驱动开发。而对于机器学习来说，这就是评估。

开发基于 LLM 的应用程序的第一步，也是最宝贵的技能，就是定义你将如何评估你的项目。

评估 LLM 应用程序与软件测试完全不同。我并不是否定软件测试中的挑战，但评估 LLM 并不像测试那样简单直接。

LLM 微调 — 常见问题解答

原文：towardsdatascience.com/llm-fine-tuning-faqs-200442827c99?source=collection_archive---------8-----------------------#2024-09-26

回答我作为 AI 顾问收到的最常见问题

Shaw Talebi

·发布于 Towards Data Science ·7 分钟阅读·2024 年 9 月 26 日

去年，我发布了一篇关于微调大型语言模型（LLMs）的文章。令我惊讶的是，这篇文章成为了我阅读量最高的博客之一，并且引发了与客户关于微调问题和 AI 项目的数十次对话。在这里，我将总结这些对话中最常见的问题以及我的回答。

图片来自 Canva。

什么是微调？

我喜欢将微调定义为采用一个现有的（预训练的）模型，并训练至少 1 个模型参数以将其适应特定的使用场景。

需要注意的是定义中“训练至少 1 个模型参数”这一部分。有些人会在定义中忽略这一细节（包括我自己有时也会忽略）。然而，这一细节将微调与诸如提示工程（prompt engineering）或前缀调优（prefix-tuning）等方法区分开来，因为后者是通过不修改模型内部操作的方式来调整模型行为。

## 微调大型语言模型（LLMs）

一个带有示例 Python 代码的概念概览

towardsdatascience.com

何时不应进行微调

LLM 驱动的半结构化和无结构文档解析与分析

原文：towardsdatascience.com/llm-powered-parsing-and-analysis-of-semi-structured-structured-documents-f03ac92f063e?source=collection_archive---------3-----------------------#2024-08-12

如何从文档中提取所需的信息

Umair Ali Khan

·发布于 Towards Data Science ·阅读时长 17 分钟·2024 年 8 月 12 日

如果你不是 Medium 会员，你可以通过 这个链接阅读完整文章。

文档解析是分析文档内容（无结构或半结构化）以提取特定信息或将内容转化为更结构化格式的过程。文档解析的目标是将文档分解成其组成部分，并对这些部分进行解释。文档解析对于处理大量各种格式数据的组织非常有用，因为这些数据需要自动化提取。文档解析在商业中有很多应用场景，例如发票处理、法律合同分析、来自多个来源的客户反馈分析和财务报表分析等等。

在大规模语言模型（LLM）出现之前，文档解析是通过使用预定义规则，如正则表达式（Regex）来完成的。然而，这些规则缺乏灵活性，并且仅限于预定义的结构。现实世界中的文档通常存在不一致性，并且没有固定的结构或格式。这正是 LLM 在从半结构化或无结构文档中提取特定信息并进行进一步分析方面，具有巨大潜力的地方。

在本文中，我将通过一个实际的例子，解释如何自动提取所需的信息……

LLM 路由 — 直观且详尽的解释

原文：towardsdatascience.com/llm-routing-intuitively-and-exhaustively-explained-5b0789fe27aa?source=collection_archive---------0-----------------------#2024-11-22

在每个查询上动态选择合适的语言模型

Daniel Warfield

·发表于 Towards Data Science ·阅读时间 49 分钟·2024 年 11 月 22 日

“和谐”，由 Daniel Warfield 使用 Midjourney 创作。除非另有说明，所有图片均由作者提供。本文最初发布于直观且详尽的解释。

在这篇文章中，我们将讨论“LLM 路由”，这是一种高级推理技术，可以自动从一组语言模型中选择最适合给定提示的语言模型；提高 LLM 驱动系统的性能、速度和成本效益。

我们将探索四种 LLM 路由方法：三种来自学术界，一种来自行业，以全面理解这一概念和技术。在此过程中，我们将探讨多种建模策略，这些策略在重要的 AI 应用场景中非常有用，比如自我评估、自治系统和在不确定性面前的决策制定。

这对谁有用？ 任何想要深入理解人工智能以及构建前沿 AI 驱动系统所需核心方法的人。

这篇文章有多高级？ 文章的前面部分适合各个层次的读者阅读。后面的部分则更倾向于有一定经验的数据科学家和开发者。

前提条件： 早期部分适合所有层次的读者，但后面的部分包含一些可能对经验较少的读者来说至关重要的支持内容。

LLM 对 LLM：Codenames 比赛

原文：towardsdatascience.com/llm-vs-llm-codenames-tournament-f8170dd1c8fb?source=collection_archive---------6-----------------------#2024-10-12

三个不同的 LLM 代理之间的迷你多代理竞赛

Yennie Jun

·发表于 Towards Data Science ·阅读时长：6 分钟·2024 年 10 月 12 日

由 ChatGPT 4o 生成。

本文最初发布于 Art Fish Intelligence.

介绍

大型语言模型（LLMs）擅长许多事情，其中之一就是玩游戏。人们已经利用 LLMs 玩过各种游戏，例如 Minecraft、国际象棋、谋杀之谜游戏、狼人杀和纽约时报连接谜题。（欲了解更全面的列表，您可以参考这篇调查。）

上面的大部分示例展示了 LLMs 在与自己或人类对战时玩游戏。但，LLMs 与其他LLMs 对战时，表现如何呢？

在这篇文章中，我展示了三种不同的 LLM 在流行桌游 Codenames 中的竞争结果，该游戏挑战玩家在看似无关的单词中寻找模式。

Codenames

对于不熟悉的人，Codenames 是一款由 Vladimír Chvátil 创建的桌游。游戏将两队（通常是红队和蓝队）对抗。

每个队伍有一个间谍头目，负责给出单词线索，指向 5x5 的单词板上的多个单词。队伍中的其他玩家必须猜测自己队伍的单词，同时避免猜到属于对方队伍的单词。只有…

LLMOps — 使用 BentoML 提供 Llama-3 模型服务

原文：towardsdatascience.com/llmops-serve-a-llama-3-model-with-bentoml-4d580a7a007f?source=collection_archive---------6-----------------------#2024-08-09

由Simon Wiedensohler拍摄，来源：Unsplash

快速设置 LLM API，使用 BentoML 和 Runpod

Marcello Politi

·发布于Towards Data Science ·6 分钟阅读·2024 年 8 月 9 日

引言

我经常看到数据科学家对 LLM 的模型架构、训练技术或数据收集产生兴趣。然而，我注意到，很多时候，在理论层面之外，许多人在将这些模型部署为可供用户使用时遇到困难。

在这个简短的教程中，我将以非常简单的方式展示如何使用BentoML提供 LLM 服务，特别是 llama-3 模型。

BentoML 是一个端到端的机器学习模型服务解决方案。它帮助数据科学团队开发生产就绪的模型服务端点，在每个阶段都实现 DevOps 最佳实践和性能优化。

我们需要 GPU

如你所知，在深度学习中，拥有合适的硬件至关重要。尤其对于像 LLM 这样的大型模型，这一点更加重要。不幸的是，我没有 GPU 😔

这就是为什么我依赖外部提供商，所以我租用他们的机器并在那里工作。为了这篇文章，我选择了Runpod，因为我了解他们的服务，并且我认为这个价格适合跟随本教程。但如果你有 GPU 或者想要…

LLMs、AI 代理、生成性 AI 的经济学以及其他八月必读文章

原文：towardsdatascience.com/llms-ai-agents-the-economics-of-generative-ai-and-other-august-must-reads-33f2112a5cdf?source=collection_archive---------6-----------------------#2024-08-29

TDS 编辑

·发表于Towards Data Science ·发送为新闻通讯 ·4 分钟阅读·2024 年 8 月 29 日

想要写你的第一篇 TDS 文章吗？我们始终欢迎新作者的投稿。

由于我们许多读者正准备告别夏天，重新进入正常的工作节奏，我们希望你们仍能为长期成长腾出一些时间——无论是开始一个副项目，探索前沿的机器学习研究，还是仅仅是刷新一下你的数据科学作品集。无论未来几个月带你走向何方，我们也希望 TDS 能继续成为你学习旅程的一部分。

从早期职业建议到 LLM 驱动的数据分析和编程技巧，我们上个月最受欢迎的文章涵盖了广泛的内容——这意味着，无论你当前的兴趣是什么，你都可能在这里找到能激发你好奇心的内容。

这里是我们八月的必读文章——祝你阅读愉快！

我给想成为数据科学家的人的诚恳建议如果你刚刚迈出数据科学职业生涯的第一步，并且对如何开始以及从哪里开始感到不确定，Egor Howell的真诚建议——从一个已经走得稍远的人的角度出发——或许正是你今天需要阅读的那篇文章。（它无疑与我们许多读者产生了共鸣！）
requirements.txt 已过时“尽管标准库功能强大，但现代 Python 应用程序通常需要更先进的功能，超出了标准库所包含的范围。” 聚焦、可操作且对广泛的数据专业人士具有相关性，Giorgos Myrianthous 提供了一份广受好评的指南，讲解如何使用 Poetry 管理 Python 项目的依赖关系和元数据。
ChatGPT vs. Claude vs. Gemini：数据分析对决（第一部分）随着基于大型语言模型（LLM）的工具在日常数据科学工作流中变得越来越普及，了解它们的表现以及不同模型之间的比较比以往任何时候都更加重要。Yu Dong 的热门系列正是为了实现这一目标，评估了三种流行工具在多种数据分析任务中的表现。

图片由 Annie Spratt 提供，来源于 Unsplash

AI 代理 — 从概念到 Python 中的实际实现“与其让一个单一的大型语言模型（LLM）处理复杂任务，我们可以结合多个 LLM 或 AI 代理，每个代理专注于某个特定领域。” Zoumana Keita 的易懂入门书籍清晰地解释了什么是 AI 代理，为什么在实际应用中应考虑使用它们，以及如何从零开始创建一个 AI 代理系统。
成功进入科技行业的最有用的高级 SQL 技巧如果你已经掌握了基础的 SQL 查询，并且觉得是时候提升你的技能水平，Jiayan Yin 的实用指南适合你：从窗口函数到子查询和公用表表达式（CTEs），它提供了具体的示例（和代码片段），鼓励你卷起袖子，将你的知识应用到自己的数据中。
关于 RAG 的那些事增强检索生成（RAG）可能不再是优化 LLM 输出最具话题性的技术，但从业者们仍在不断发现并更好地理解它的优势以及局限性。Ahmed Besbes的全面概述详细解答了后者：“让一个 RAG 系统准备投入生产不仅仅是将一些代码拼凑在一起。这关乎如何应对杂乱的数据、预料之外的用户查询以及始终存在的交付实际业务价值的压力。”
使用 Python 和 SQL 自动化 ETL 到 SFTP 服务器对于那些对数据工程和数据处理有兴趣的从业者（换句话说：你们中的大多数人！），Mary Ara的新教程耐心且清晰地讲解了一个基本工作流：跟随教程学习如何自动化数据在不同位置之间的转移，甚至可以包括 SFTP（安全文件传输协议）上传的额外步骤。
生成式 AI 的经济学“当我们回顾十年后的今天，我怀疑我们认为在生成式 AI 商业领域‘大赢家’的公司，是否是那些真正开发出底层技术的公司。”为了总结本月内容，我们邀请你退后一步，回顾Stephanie Kirmer对生成式 AI 工具商业案例的深刻分析，探索它推动的创新以及那些被抛在后头的创新。

我们最新一批的新作者

每个月，我们都很高兴看到一批新作者加入 TDS，他们每个人都将自己独特的声音、知识和经验与我们的社区分享。如果你在寻找新的作家来探索和关注，可以浏览我们最新加入的作者们的作品，包括Yury Kalbaska、Jose Parreño、Pablo Merchán-Rivera, Ph.D.、Conal Henderson、Mehdi Mohammadi、Mena Wang, PhD、Juan Hernanz、Dylan Anderson、Armin Catovic、Louis Wang、Diana Morales、Chris Lydick、Lakshmi Narayanan、Anindya Dey, PhD、Marius Steger、Muhammad Ardi、Stefan Pietrusky、Leonardo A. (🐼 panData)、Szymon Palucha、Nikolai Potapov、Mathew Wang、Arthur Cruiziat、Umair Ali Khan、Matt Fitzgerald、Samy Baladram、Saman (Sam) Rajaei、Phanuphat (Oad) Srisukhawasu、Rishabh Misra、Marcos Santiago、David Wells、Mary Ara、Tarik Dzekman、Ng Wei Cheng、James F. O'Brien、Jurgita Motus、Gary George、James Wilkins、Daniel Kharitonov、Ozgur Guler，以及Shrey Pareek, PhD等人。

感谢您支持我们作者的工作！我们喜欢发布新作者的文章，因此，如果您最近写了一篇有趣的项目教程、教程或关于我们核心主题的理论反思，欢迎不要犹豫，与我们分享。

直到下一个变量，

TDS 团队

从零开始学习 LLMs 和 Transformer：解码器

原文：towardsdatascience.com/llms-and-transformers-from-scratch-the-decoder-d533008629c5?source=collection_archive---------2-----------------------#2024-01-10

探索 Transformer 的解码器架构：掩蔽的多头注意力、编码器-解码器注意力以及实际实现

Luís Roque

·发表于 Towards Data Science ·13 分钟阅读·2024 年 1 月 10 日

本文由 Rafael Nardi 合著。

介绍

在本文中，我们深入探讨了 Transformer 架构中的解码器组件，重点分析它与编码器的异同。解码器的独特特点在于其类似循环的迭代特性，这与编码器的线性处理方式形成鲜明对比。解码器的核心是两种修改过的注意力机制：掩蔽的多头注意力和编码器-解码器多头注意力。

解码器中的掩蔽多头注意力确保了令牌的顺序处理，这种方法防止了每个生成的令牌受到后续令牌的影响。这种掩蔽对于保持生成数据的顺序性和连贯性至关重要。解码器输出（来自掩蔽注意力）与编码器输出之间的交互体现在编码器-解码器注意力中。最后一步将输入上下文引入解码器的处理过程中。

我们还将演示如何使用 Python 和 NumPy 实现这些概念。我们创建了一个简单的示例，用于将一句话从英语翻译成葡萄牙语。这种实用的方法将帮助阐明 Transformer 模型中解码器的内部工作原理……

大语言模型比家猫更笨

原文：towardsdatascience.com/llms-are-dumber-than-a-house-cat-81e7b3d63190?source=collection_archive---------9-----------------------#2024-01-09

它们真的能取代你吗？

Nabil Alouani

·发表于 Towards Data Science ·13 分钟阅读·2024 年 1 月 9 日

所有的图片均来自作者，通过 Midjourney 和 DALL-E 制作。

挫败感？困惑？也许“缺乏优雅”是一个更好的表达。这是你看到顶级科学家对他们已经理解的技术感到惊叹时的痛苦。

AI 影响者通过玩弄惊讶的把戏来吸引点击量，但对于科学家和工程师来说，情况是不同的。一旦揭示出其中的诀窍，魔力应该就会消失。

这就是为什么看到微软及其他地方的研究人员在 GPT-4 发布几个月后仍然用“不可思议”、“疯狂”和“惊人”等词汇来描述它时，感到刺痛。

并不是特别针对塞巴斯蒂安·布贝克，但如果一个强化版的自动补全能让他“震惊”，那就可以想象这对普通用户的影响。

开发者和数据从业者每天都在使用大语言模型（LLMs）来生成代码、合成数据和文档。他们也可能会被夸大的功能所误导。正是当人们过于信任他们的工具时，错误才会发生。

简而言之： 这是一个反对炒作的观点，你将了解大语言模型是如何工作的，为什么它们……

为什么 LLMs 不适合编程

原文：towardsdatascience.com/llms-coding-chatgpt-python-artificial-intelligence-4ea7a7bbdd93?source=collection_archive---------0-----------------------#2024-02-28

使用 LLMs 进行编码的挑战

Andrea Valenzuela

·发表于Towards Data Science ·阅读时长：7 分钟·2024 年 2 月 28 日

自制图像

在过去的一年里，得益于自然语言理解的进步，大型语言模型（LLMs）展示了惊人的能力。这些先进的模型不仅重新定义了自然语言处理的标准，还被广泛应用于各种应用程序和服务中。

使用 LLMs 进行编程的兴趣迅速增长，一些公司正在努力将自然语言处理转化为代码理解与生成。这一任务已经暴露出使用 LLMs 进行编码的多个挑战，尚未得到解决。尽管如此，这一趋势促使了 AI 代码生成产品的发展。

你曾经用过 ChatGPT 进行编程吗？

虽然在某些情况下它可能有所帮助，但它通常难以生成高效且高质量的代码。在本文中，我们将探讨三个原因，解释为什么大型语言模型（LLMs）在编程上无法做到“开箱即用”：分词器、应用于代码时上下文窗口的复杂性以及训练本身的性质。

识别需要改进的关键领域是将 LLMs 转变为更有效编程助手的关键！

#1 LLM 分词器

为什么 LLMs 不适合编码 — 第二部分

原文：towardsdatascience.com/llms-coding-software-development-artificial-intelligence-68f195bb2ad3?source=collection_archive---------1-----------------------#2024-05-20

用于编码任务的大型语言模型

Andrea Valenzuela

·发表于Towards Data Science ·6 分钟阅读·2024 年 5 月 20 日

自制图像。

在发布这篇系列文章的第一篇“为什么 LLMs 不适合编码”后，我在社交媒体上收到了几条评论，例如：

“我在用 ChatGPT 进行编码，它工作得非常好。”

“你错了。大型语言模型是有用的编码助手。”

我对这些反应感到惊讶，因为这篇文章系列的目的并不是劝阻任何人使用大型语言模型（LLMs）进行编码，而是识别需要改进的关键领域，以将 LLMs 转变为更有效的编码助手。

尽管像 ChatGPT 这样的 LLMs 在某些情况下可能有帮助，它们经常生成语法正确但不够优化甚至在功能上不正确的代码。

在上一篇文章中，我们讨论了标记器、在应用于代码时上下文窗口的复杂性以及训练本身的性质如何影响这些模型在编码任务中的表现。

在第二篇文章中，我们将更深入地探讨这些模型在进行编码任务时所接受的训练类型，以及LLMs 在“开箱即用”时天生不擅长编码的另一个原因：保持更新的挑战…

2024 年用于编程的 LLM：价格、性能与最佳之争

原文：towardsdatascience.com/llms-for-coding-in-2024-performance-pricing-and-the-battle-for-the-best-fba9a38597b6?source=collection_archive---------5-----------------------#2024-12-04

基于基准测试和实际世界的洞察，评估当前 LLM 的格局，帮助你做出明智的选择。

Ruben Broekx

·发布于 Towards Data Science ·11 分钟阅读·2024 年 12 月 4 日

图片由 Flux.1 - Schnell 生成

用于编程的大型语言模型（LLM）的竞争格局从未如此激烈。像阿里巴巴、Anthropic、谷歌、Meta、Mistral、OpenAI 和 xAI 等主要厂商都在提供自己的模型，开发者比以往任何时候都有更多的选择。

但你如何选择最适合你编程用例的 LLM 呢？

在这篇文章中，我将深入分析通过公共 API 提供的顶级 LLM。我将重点关注它们在编码任务中的表现，评估基准如 HumanEval，以及它们在实际应用中的表现，反映在各自的 Elo 分数上。

无论你是在做个人项目，还是将人工智能集成到你的开发工作流程中，了解这些模型的优缺点将帮助你做出更明智的决策。

免责声明：比较 LLM 时的挑战

比较大型语言模型（LLMs）是很困难的。模型经常接收到更新，这些更新对它们的表现有着显著影响——例如，OpenAI 从 GPT-4 到 GPT-4-turbo 再到 GPT-4o，再到 o1 模型的更新。然而，即使是小的更新也会产生影响——例如，GPT-4o 自 5 月 13 日发布以来，已经收到了 3 次更新！

此外，这些模型的随机性意味着它们的表现可能会在不同的运行中有所不同，从而导致研究中的结果不一致。最后，一些公司可能会定制基准和配置——例如特定的 Chain-of-Thought 技术——以展示其模型的最佳表现，这会扭曲比较结果并误导结论。

结论：比较 LLM 的表现是困难的。

本文代表了基于现有信息对各种编码任务模型的最佳努力比较。我欢迎任何反馈，以提高此分析的准确性！

评估 LLM：HumanEval 和 Elo 分数

如上文免责声明所示，为了正确理解 LLM 在编码任务中的表现，建议从多个角度进行评估。

通过 HumanEval 进行基准测试

最初，我尝试从多个基准中汇总结果，看看哪个模型表现最好。然而，这种方法的核心问题是：不同的模型使用不同的基准和配置。似乎只有一个基准是评估编码表现的默认标准：HumanEval。这是一个由人类编写的编码问题数据集，评估模型根据特定要求生成正确和功能性代码的能力。通过评估代码补全和解决问题的能力，HumanEval 成为评估 LLM 编码能力的标准。

通过 Elo 分数展现人们的声音

虽然基准测试能很好地反映模型的表现，但也应谨慎对待。考虑到 LLM 是在大量数据上训练的，某些基准内容（或非常相似的内容）可能已经包含在这些训练数据中。这就是为什么基于人类评判的模型表现也值得评估。像 Chatbot Arena（仅限编码） 这样的 Elo 排名正是这样做的。这些分数来自 LLM 在编码任务中的对抗性比较，由人类评审员进行评估。模型彼此对抗，根据胜负调整 Elo 分数。Elo 分数显示了模型相对于池中其他模型的表现，较高的分数意味着更好的表现。例如，100 Elo 分数的差距意味着排名较高的模型在与排名较低的模型对抗时，预计会有约 64% 的获胜概率。

当前模型表现状态

现在，让我们检查一下当我们将这些模型的 HumanEval 分数与它们的 Elo 排名进行比较时，它们的表现如何。以下图像展示了当前 LLM 的编码领域，其中模型按创建它们的公司进行了聚类。每个公司的最佳表现模型都有注释。

图 1：按 HumanEval 的 Elo 分数 — 按公司着色。X 轴和 Y 轴的刻度显示了每个公司发布的所有模型，最佳表现的模型用粗体标出。

OpenAI 的模型在两个指标上都位于最前端，展示了它们在解决编程任务中的优越能力。OpenAI 排名最高的模型在对比非 OpenAI 的最佳模型——Anthropic 的 Claude Sonnet 3.5 时，超出了 46 Elo 分，预计在对决中的胜率为 56.6%，在 HumanEval 中的差距为 3.9%。虽然这个差距并不惊人，但它显示了 OpenAI 仍然占有优势。有趣的是，表现最好的模型是 o1-mini，它比更大的 o1 高出 10 Elo 分和 2.5% 的 HumanEval 得分。

结论：OpenAI 继续占据主导地位，在基准测试表现和现实世界应用中位居榜首。值得注意的是，o1-mini 是表现最好的模型，超越了更大的对手 o1。

其他公司紧随其后，似乎都处于相同的“表现区间”内。为了更清晰地了解模型表现的差异，以下图表显示了每家公司最佳模型的胜率——由它们的 Elo 评分指示。

图 2：每家公司最佳（编码）模型的获胜概率 — 如 Elo 评分的对决胜率所示。

基准测试结果与现实世界表现的不匹配

从图 1 可以看出，一个显著的特点是 HumanEval（基准测试）与 Elo 评分（现实世界表现）之间的错配。一些模型——如 Mistral 的 Mistral Large——在 HumanEval 得分上显著优于它们的 Elo 评分。其他模型——如 Google 的 Gemini 1.5 Pro——在 Elo 评分上显著优于它们获得的 HumanEval 得分。

很难知道何时信任基准测试，因为基准数据可能已经包含在模型的训练数据集中。这可能导致（过拟合的）模型记住并重复回答编程问题，而不是理解并真正解决问题。

同样，考虑到 Elo 评分是通过众包努力获得的，因此将其作为事实依据也是有问题的。这样做会在评分中引入人为偏见，偏向那些以特定风格输出、采用特定方法的模型……而忽视其他模型，这并不总是与一个客观更好的模型相符。

结论：更好的基准测试结果并不总能反映更好的现实世界表现。建议分别查看两者。

以下图像显示了 HumanEval 和 Elo 评分之间的不一致。所有模型都根据各自的得分进行排序，为了简化，忽略了“一个模型相较另一个模型有多好”的因素。它直观地展示了哪些模型在基准测试中表现更好，但在现实中表现较差，反之亦然。

图 3：HumanEval 和 Elo 评分的错配 — 按公司颜色区分。为了简化，得分被转换为排名，从最差（左）到最好（右），分别显示在每个指标上。

图 4 通过进一步简化比较，进一步突出了基准测试和现实世界表现之间的差异。这里，图中显示了排名的相对差异，表明模型何时可能出现过拟合基准，或表现优于报告的结果。可以得出一些有趣的结论：

基准过拟合： 阿里巴巴和 Mistral 两家公司都在不断推出那些在基准测试中表现更好，但在现实中表现较差的模型。它们最近的模型，包括阿里巴巴的Qwen 2.5 Coder（–20.0%）和 Mistral 的Mistral Large（–11.5%），也遵循了这一模式。
优于报告结果： Google 凭借其生产的模型，在实际表现上显著优于报告结果，尤其是其最新的Gemini 1.5 Pro模型，表现出+31.5%的差异。Google 对“诚实训练与评估”的关注在其模型报告中得到了体现，并且他们选择开发自己的 Natural2Code 基准，而非使用 HumanEval。“Natural2Code 是一个涵盖 Python、Java、C++、JS、Go 等语言的代码生成基准。保留的数据集类似于 HumanEval，但未泄露在网络上。” ~ Google 在 Gimmini 1.5 发布中。
平衡良好： Meta 在平衡基准与现实世界表现方面做得非常有趣且特别好。由于图中显示的是排名而非得分，这种稳定性也取决于其他模型的表现。

图 4：从 HumanEval 到 Elo 分数的表现差异——按公司着色。负分表示 HumanEval 优于 Elo（基准过拟合），而正分表示 Elo 优于 HumanEval（表现优于报告）。

结论：阿里巴巴和 Mistral 倾向于创建在基准数据上过拟合的模型。

结论：Google 的模型在基准测试结果中被低估，原因在于其专注于公平的训练和评估。

平衡性能和价格：提供最佳性价比的模型

在选择 LLM 作为编程伴侣时，性能并不是唯一需要考虑的因素。另一个重要的维度是价格。本节重新评估了不同的 LLM，并比较了它们在性能（由其 Elo 评分表示）和价格方面的表现。

在开始比较之前，值得注意的是一个例外：Meta。Meta 的 Llama 模型是开源的，并非由 Meta 自己托管。然而，鉴于它们的受欢迎程度，我仍然将其纳入其中。这些模型的定价是大三云服务商（Google、Microsoft、Amazon）提供的最优按需定价——通常是 AWS 的价格。

图 5 对不同的模型进行了比较，并展示了帕累托前沿。使用 Elo 评分来代表模型表现，这被认为是最好的选择，因为 Elo 评分是由人类评估的，并且不包括过拟合偏差。接下来，使用按需付费的 API 价格，所显示的价格为生成一百万个 token 的输入和输出 token 费用的平均值。

图 5：按 API 价格分类的模型编码表现（Elo 评分）——按公司着色。组成帕累托前沿的模型已标注。

帕累托前沿仅由两家公司提供的模型构成：OpenAI 和谷歌。正如前面所提到的，OpenAI 的模型在性能上占据主导地位，并且它们的定价也相对合理。与此同时，谷歌似乎专注于较轻量——因此更便宜——但仍然表现良好的模型。这是有道理的，因为他们专注于适用于移动操作系统（Android）的设备端 LLM 应用场景，这对其战略具有重要价值。

结论：帕累托前沿由来自 OpenAI（高性能）或谷歌（高性价比）的模型组成。

下一个图表展示了在使用 HumanEval 而不是 Elo 评分来表示编码表现时的相似趋势。一些观察结果：

Anthropic 的Claude 3.5 Haiku是唯一的显著新增项，因为该模型目前还没有 Elo 评分。它有可能成为中端高性能模型的竞争者吗？
谷歌的Gemini 1.5 Pro和 Mistral 的Mistral Large之间的差异在前一节中已经解释过，该节将 HumanEval 评分与 Elo 评分进行了对比。
由于谷歌的Gemini 1.5 Flash 8B没有 HumanEval 评分，因此它被排除在这个图表之外。

图 6：按 API 价格分类的模型编码表现（HumanEval 评分）——按公司着色。组成帕累托前沿的模型已标注。

数据分析：额外的见解和趋势

总结一下，我将讨论一些在当前 LLM（编码）领域值得注意的额外见解。本节探讨了三个关键观察结果：模型随时间的稳定改进、专有模型的持续主导地位以及即便是微小的模型更新也能产生显著影响。所有这些观察结果都来源于图 5 所示的基于价格对比的 Elo 评分。

模型越来越好且越来越便宜

以下图表展示了新模型如何不断提高准确度，同时降低成本。值得注意的是，三个时间段——2023 年及之前、2024 年上半年和 2024 年下半年——每个都定义了自己独特的帕累托前沿，并几乎占据了完全不同的区段。期待看到这一趋势在 2025 年如何继续发展！

图 7：由三个不同时间段所指示的时间演变——2023 年及之前、2024 年上半年和 2024 年下半年。

结论：模型变得越来越好且越来越便宜，这是几乎所有新模型发布时都能观察到的趋势。

专有模型依然占据主导地位

以下图片显示了哪些分析过的模型是专有的，哪些是开源的。我们看到，专有模型仍然主导着 LLM 编程领域。帕累托前沿仍然由这些“闭源”模型主导，无论是在高性能端还是低成本端。

然而，开源模型正在缩小差距。有趣的是，对于每个开源模型，都有一个具有相同预测性能且显著更便宜的专有模型。这表明专有模型要么更加轻量化，要么经过了更好的优化，因此需要更少的计算能力——尽管这仅仅是个人的推测。

图 8：专有模型与开源模型的对比。

结论：专有模型继续保持性能-成本帕累托前沿。

即使是小的模型更新也会产生影响

以下这张图片展示了即使是相同模型的小更新也可能带来影响。通常，这些更新会带来性能提升，逐步改进模型，而无需进行重大发布。然而，偶尔某个模型在小更新后可能会在编程任务上表现下降，但这通常伴随着价格的降低。这可能是因为模型以某种方式进行了优化，比如通过量化或剪枝其网络的一部分。

图 9：小模型更新的性能和价格演变。

结论：小的模型更新几乎总是能提高性能或降低成本。

结论：LLMs 在编程中的关键要点

LLM 在编程领域的格局正在迅速发展，新模型不断推动帕累托前沿向更高性能和/或更便宜的选项迈进。开发者必须保持对最新模型的关注，以识别那些在预算内提供最佳功能的模型。认识到现实结果与基准测试之间的不一致性对于做出明智的决策至关重要。通过仔细衡量性能与成本，开发者可以选择最符合自己需求的工具，并在这个动态变化的领域中保持领先。

以下是本文所做的所有结论的快速概览：

比较 LLM 性能是很困难的。
OpenAI 继续主导市场，在基准性能和实际应用中位居前列。值得注意的是，o1-mini 是表现最好的模型，超越了更大的 o1 模型。
更好的基准结果并不总是意味着更好的现实世界表现。建议分别独立查看两者。
阿里巴巴和 Mistral 倾向于创建在基准数据上过拟合的模型。
谷歌的模型在基准测试结果中被低估，因为它们更注重公平训练和评估。
帕累托前沿由来自 OpenAI（高性能）或 Google（物有所值）的模型组成。
模型在不断系统性地提高性能并降低成本，这一趋势几乎出现在每一次新模型发布中。
专有模型仍然占据着性能-成本的帕累托前沿。
小幅的模型更新几乎总是能提高性能或降低成本。

觉得有用吗？欢迎在LinkedIn上关注我，查看我接下来的探索！

本文中展示的图像由我本人创作，除非另有说明。

LLMs 为每个人：在 Google Colab 上运行 HuggingFace 文本生成推理

原文：towardsdatascience.com/llms-for-everyone-running-the-huggingface-text-generation-inference-in-google-colab-5adb3218a137?source=collection_archive---------3-----------------------#2024-01-13

免费试验大语言模型（第三部分）

Dmitrii Eliuseev

·发布于 Towards Data Science ·阅读时长 7 分钟·2024 年 1 月 13 日

图片来源：Markus Spiske，Unsplash

在第一部分中，我们使用免费的 Google Colab 实例运行了 Mistral-7B 模型，并通过 FAISS（Facebook AI 相似度搜索）数据库提取信息。在第二部分中，我们使用了 LLaMA-13B 模型和 LangChain 库进行聊天，并实现了文本摘要及其他功能。在本部分中，我将展示如何使用 HuggingFace 🤗 文本生成推理（TGI）。TGI 是一个工具包，允许我们将大语言模型（LLM）作为服务运行。与之前的部分一样，我们将在 Google Colab 实例中测试它，完全免费。

文本生成推理

文本生成推理（TGI）是一个适用于大语言模型（LLMs）的生产级工具包，用于部署和提供服务。将 LLM 作为服务运行，允许我们在不同的客户端之间使用它，从 Python 笔记本到移动应用程序。测试 TGI 的功能非常有趣，但事实证明，它的系统要求相当高，并且并非一切都如预期般顺利：

免费的 Google Colab 实例仅提供 12.7 GB 的 RAM，这通常不足以一次性加载 13B 甚至 7B 模型……

每个人的 LLM：在 Google Colab 中运行 LLaMA-13B 模型和 LangChain

原文：towardsdatascience.com/llms-for-everyone-running-the-llama-13b-model-and-langchain-in-google-colab-68d88021cf0b?source=collection_archive---------4-----------------------#2024-01-05

免费实验大型语言模型（第二部分）

Dmitrii Eliuseev

·发表于Towards Data Science ·14 分钟阅读·2024 年 1 月 5 日

由 Glib Albovsky 拍摄，Unsplash

在故事的第一部分中，我们使用了一个免费的 Google Colab 实例来运行 Mistral-7B 模型，并使用 FAISS（Facebook AI 相似度搜索）数据库提取信息。在这一部分中，我们将进一步深入，我将展示如何运行 LLaMA 2 13B 模型；我们还将测试一些额外的 LangChain 功能，比如制作基于聊天的应用程序和使用代理。与第一部分相同，所有使用的组件都是基于开源项目，并且完全免费使用。

让我们开始吧！

LLaMA.cpp

LLaMA.CPP 是一个非常有趣的开源项目，最初设计用于在 MacBook 上运行 LLaMA 模型，但其功能远远超出了这一点。首先，它是用纯 C/C++ 编写的，没有外部依赖，能够在任何硬件上运行（支持 CUDA、OpenCL 和 Apple Silicon，甚至可以在 Raspberry Pi 上运行）。其次，LLaMA.CPP 可以与LangChain连接，这使我们能够在没有 OpenAI 密钥的情况下免费测试其许多功能。最后但同样重要的是，由于 LLaMA.CPP 可以在任何地方运行，它是一个非常适合在免费的 Google Colab 实例中运行的候选者。提醒一下，Google 提供免费...

LLMs 的陷阱

原文：towardsdatascience.com/llms-pitfalls-7a33de009638?source=collection_archive---------6-----------------------#2024-05-07

介绍一些围绕 LLMs 的关键组成部分，以生成生产级应用

Pier Paolo Ippolito

·发布于Towards Data Science ·阅读时间 9 分钟·2024 年 5 月 7 日

AI 生成（图像由作者提供）。

介绍

自从 ChatGPT 的崛起以来，大型语言模型（LLMs）变得越来越受欢迎，甚至非技术人员也开始关注它们。尽管 LLMs 本身尚无法提供一个完整的、可供广大受众使用的产品，但在本文中，我们将探讨一些用于使 LLMs 具备生产就绪能力的关键元素。

微调

数据集

像 LLAMA 这样的模型能够预测序列中的下一个标记，尽管这并不一定使它们适用于诸如问答等任务。因此，为了优化这些模型，可以使用不同类型的数据集：

原始完成：如果目标是预测下一个标记，我们提供一些输入文本，让模型逐步预测接下来的步骤。
填充中间目标：在这种情况下，我们有一些起始和结束文本，模型正在学习填补空白。这种方法在创建代码补全模型（如 Codex）时非常流行。
指令数据集：这里的目标是教模型如何回答问题。我们有问题（指令）作为……

LLMs.txt 解析

原文：towardsdatascience.com/llms-txt-414d5121bcb3?source=collection_archive---------1-----------------------#2024-11-28

您的网络新标准：LLM 友好内容指南

Derick Ruiz

·发表于Towards Data Science ·阅读时长 5 分钟·2024 年 11 月 28 日

最近，您可能已经看到一些开发工具将 LLMs.txt 支持添加到它们的文档中。这一提议的网络标准正在迅速获得广泛采用，但它到底是什么，又为什么重要呢？

虽然 robots.txt 和 sitemap.xml 是为搜索引擎设计的，但 LLMs.txt 则是为推理引擎优化的。它以 LLM 易于理解的格式，提供有关网站的信息。

那么，LLMs.txt 是如何在几乎一夜之间，从提议到成为行业趋势的呢？

LLMs.txt 解析（图片来源：Jørgen Larsen于Unsplash）

Mintlify 是如何推广 LLMs.txt 的

11 月 14 日，Mintlify 在其文档平台上添加了对 LLMs.txt 的支持。通过这一举措，他们使成千上万的开发工具文档对 LLM（大语言模型）更加友好，像是 Anthropic 和 Cursor 等工具。

Anthropic 和其他公司迅速在 X 平台上发布了关于其 LLMs.txt 支持的消息。更多由 Mintlify 托管的文档加入了这一行列，为这一提议的标准带来了广泛的关注。

这一势头激发了新的社区网站和工具的诞生。@ifox 创建了directory.llmstxt.cloud来索引 LLM 友好的技术文档。@screenfluent 随后也发布了llmstxt.directory。

制作 dotenvx 的 Mot，构建并分享了一个开源生成工具用于 dotenvx 文档站点。Firecrawl 的 Eric Ciarla 创建了一个工具，该工具会抓取您的网站并为您生成 LLMs.txt 文件。

Anthropic 的 Claude 关系负责人 Alex Albert 在 X 平台上宣布 LLMs.txt 的支持。

谁创建了 LLMs.txt，为什么？

Answer.AI 的联合创始人 Jeremy Howard 提出了 LLMs.txt，以解决特定的技术挑战。

AI 系统只能处理有限的上下文窗口，这使得它们很难理解大型文档网站。传统的 SEO 技术是为搜索爬虫而优化的，而不是为推理引擎优化，因此无法解决这一限制。

当 AI 系统尝试直接处理 HTML 页面时，它们会被导航元素、JavaScript、CSS 和其他不必要的信息拖慢，这减少了实际内容可以占用的空间。

LLMs.txt 通过以 AI 理解的格式提供确切的信息来解决这个问题。

Jeremy Howard 的 X 个人资料，他是 LLMs.txt 网页标准提案的创建者。

LLMs.txt 文件到底是什么？

LLMs.txt 是一个具有特定结构的 Markdown 文件。该规范定义了两个不同的文件：

/llms.txt：简化版文档导航视图，帮助 AI 系统快速理解你网站的结构。
/llms-full.txt：一个包含所有文档内容的综合文件。

`/llms.txt`

该文件必须以 H1 项目名称开始，接着是一个引用摘要。后续部分使用 H2 标题来组织文档链接。“可选”部分专门标记不那么关键的资源。

# Project Name
> Brief project summary

Additional context and important notes

## Core Documentation
- Quick Start: Description of the resource
- API Reference: API documentation details

## Optional
- Additional Resources: Supplementary information

例如，查看 llmtxt.org 的LLM.txt。如需更深入的多语言示例，请查看Anthropic 的。

`/llms-full.txt`

虽然/llms.txt提供了导航和结构，但/llms-full.txt包含完整的文档内容，采用 Markdown 格式。

# AI Review (Beta)

AI Review is a feature that allows you to review your recent changes in your codebase to catch any potential bugs.

<Frame>
  <img src="https://mintlify.s3-us-west-1.amazonaws.com/cursor/images/advanced/review.png" alt="AI Review" />
</Frame>

You can click into individual review items to see the full context in the editor, and chat with the AI to get more information.

### Custom Review Instructions

In order for AI Review to work in your favor, you can provide custom instructions for the AI to focus on. For example,
if you want the AI to focus on performance-related issues, you could put:

关注我的代码性能。


This way, AI Review will focus on the performance of your code when scanning through your changes.

### Review Options

Currently, you have a several options to choose from to review:

*   `Review Working State`
    *   This will review your uncommitted changes.
*   `Review Diff with Main Branch`
    *   This will review the diff between your current working state and the main branch.
*   `Review Last Commit`
    *   This will review the last commit you made.

上述代码片段来自 Cursor 的/llms-full.txt文件。查看Cursor 文档中的完整文件。

LLMs.txt 与 sitemap.xml 和 robots.txt 的区别

它的作用与现有的网页标准（如 sitemap.xml 和 robots.txt）截然不同。

/sitemap.xml列出了所有可索引的页面，但不帮助内容处理。AI 系统仍然需要解析复杂的 HTML，并处理额外的信息，这会占用上下文窗口。

/robots.txt建议搜索引擎爬虫访问，但也无法帮助理解内容。

/llms.txt解决了与 AI 相关的挑战。它有助于克服上下文窗口限制，去除不必要的标记和脚本，并以优化 AI 处理的结构呈现内容。

如何将 LLMs.txt 与 AI 系统一起使用

与主动爬行网络的搜索引擎不同，当前的 LLM 并不会自动发现和索引 LLMs.txt 文件。

你必须手动将文件内容提供给 AI 系统。这可以通过粘贴链接、直接将文件内容复制到提示中，或使用 AI 工具的文件上传功能来完成。

ChatGPT

首先，访问该文档或/llms-full.txt的 URL。将内容或 URL 复制到你的聊天中，提出你想要完成的具体问题。

使用 llms-full.txt 文件与 ChatGPT 结合的截图（图片来自作者）。

Claude

Claude 目前还无法浏览网页，因此请将该文档的/llms-full.txt文件内容复制到剪贴板。或者，你可以将其保存为.txt文件并上传。现在你可以放心地提问，确保它包含完整且最新的上下文。

使用 llms-full.txt 文件与 Claude 结合的截图（图片来自作者）。

Cursor

Cursor 允许你添加和索引第三方文档，并在聊天中作为上下文使用。你可以通过输入@Docs > Add new doc 来做到这一点。一个弹出框会出现，在这里你可以添加指向/llms-full.txt文件的链接。你将能够像使用其他文档一样将其作为上下文使用。

要了解更多关于此功能的信息，请参见 Cursor 的@Docs 功能。

输入 llms-full.txt 文件到 Cursor 中以用作上下文的截图（图片来自作者）。

如何生成 LLMs.txt 文件

有几种不同的工具可以用来创建你自己的文件：

Mintlify: 自动生成托管文档的/llms.txt 和/llms-full.txt 文件。
dotenv 的 llmstxt：由 dotenvx 的创始人 Mot 开发的工具，可以通过你网站的sitemap.xml生成llms.txt文件。
Firecrawl 的 llmstxt: 由 Firecrawl 的创始人 Eric Ciarla 开发的另一款工具，使用 Firecrawl 抓取你的网站并生成llms.txt文件。

LLMs.txt 的未来是什么？

LLMs.txt 代表了向 AI 优先文档转型的趋势。

正如 SEO 对于搜索引擎的可见性至关重要一样，拥有 AI 可读的内容将成为开发工具和文档的关键。

随着更多网站采用这个文件，我们可能会看到新的工具和最佳实践出现，使内容对人类和 AI 助手都能访问。

目前，LLMs.txt 提供了一种实际的解决方案，帮助 AI 系统更好地理解和利用网页内容，特别是针对技术文档和 API。

你的服务器在自托管 LLM 时能承受多少压力？

原文：towardsdatascience.com/load-testing-self-hosted-llms-29ca8a4cf43a?source=collection_archive---------4-----------------------#2024-10-19

你需要更多的 GPU 还是一块现代的 GPU？你如何做出基础设施的决策？

Thuwarakesh Murallie

·发表于Towards Data Science ·6 分钟阅读·2024 年 10 月 19 日

图像由作者使用 Dalle-E-2024 创建

当一群用户突然开始使用一个之前只有你和你的开发团队使用过的应用时，是什么感觉？

这就是从原型到生产阶段的百万美元问题。

就 LLM 而言，你可以进行几十次调整，以在预算和可接受的质量范围内运行你的应用。例如，你可以选择一个量化模型来降低内存使用。或者你可以微调一个小型模型，超越巨型 LLM 的性能。

## 我对 Tiny Llama 3.2 1B 进行了微调，以替代 GPT-4o

微调的努力是否比少量示例提示更值得？

towardsdatascience.com

你甚至可以调整你的基础设施，以获得更好的结果。例如，你可能想要将使用的 GPU 数量翻倍，或者选择最新一代的 GPU。

但你如何证明选项 A 比选项 B 和 C 表现更好呢？

这是我们在进入生产阶段时，最早期需要问自己的一个重要问题。所有这些选项都有它们的成本——…

Mac 上的本地 LLM 微调（M1 16GB）

原文：towardsdatascience.com/local-llm-fine-tuning-on-mac-m1-16gb-f59f4f598be7?source=collection_archive---------2-----------------------#2024-08-01

初学者友好的 Python 代码演示（特邀：MLX）

Shaw Talebi

·发表于Towards Data Science ·8 分钟阅读·2024 年 8 月 1 日

本文是关于使用大型语言模型（LLM）实践的系列文章的一部分。在上一篇文章中，我展示了如何在 Google Colab 上使用一块（免费的）GPU 微调 LLM。虽然那个例子（以及许多其他例子）可以在 Nvidia 硬件上轻松运行，但它们无法轻松适配 M 系列 Mac。在本文中，我将介绍如何在 Mac 上本地微调 LLM 的一种简单方法。

图片由Myron Mott提供，来源于Unsplash

随着开源大型语言模型（LLM）和高效微调方法的兴起，构建定制的机器学习解决方案变得前所未有的容易。现在，任何拥有一块 GPU 的人都可以在本地机器上微调 LLM。

然而，由于苹果的 M 系列芯片，Mac 用户在这一趋势中基本被排除在外。这些芯片采用了统一内存架构，这使得不再需要 GPU。因此，许多（以 GPU 为中心的）开源工具无法兼容（或无法充分利用）现代 Mac 的计算能力，用于运行和训练 LLM。

我差点放弃了在本地训练 LLM 的梦想，直到我发现了 MLX Python 库。

本地 RAG 从零开始

原文：towardsdatascience.com/local-rag-from-scratch-3afc6d3dea08?source=collection_archive---------0-----------------------#2024-05-11

开发并部署一个完全本地化的 RAG 系统

Joe Sasson

·发布于Towards Data Science ·18 分钟阅读·2024 年 5 月 11 日

图片由Kevin Ku提供，来源：Unsplash

引言

类似于llama-index和Langchain等库所提供的高级抽象，简化了检索增强生成（RAG）系统的开发。然而，要完全发挥这些库的潜力，深入理解其背后的机制仍然至关重要，尤其是对于任何机器学习工程师来说。在本文中，我将引导你从零开始开发一个 RAG 系统。我还将进一步带你走得更远，我们将创建一个容器化的 Flask API。我设计这篇教程时，注重实际应用：整个过程灵感来源于真实的使用案例，确保你获得的见解不仅是理论性的，而且是可以立即应用的。

用例概述 — 该实现设计用于处理各种文档类型。虽然当前示例使用了许多小型文档，每个文档描述了一个独立的产品，包含 SKU、名称、描述、价格和尺寸等细节，但这种方法具有高度的适应性。无论任务是涉及对多样化书籍库的索引，还是从大量合同中挖掘数据，亦或其他任何一类文档，该系统都可以根据这些不同情境的具体需求进行调整。这种灵活性使得不同类型的信息能够无缝集成和处理。

快速提示——此实现仅适用于文本数据。你可以按照类似的步骤，使用多模态模型如 CLIP 将图像转换为嵌入，然后进行索引和查询。

模块化框架

该实现有四个主要组件，可以互换。

文本数据
嵌入模型
大语言模型（LLM）
向量存储

将这些服务集成到你的项目中非常灵活，允许你根据特定需求进行定制。在这个示例实现中，我从一个初始数据为 JSON 格式的场景开始，它方便地将数据以字符串形式提供。然而，你可能会遇到其他格式的数据，如 PDF、电子邮件或 Excel 电子表格。在这种情况下，必须通过将数据转换为字符串格式来“规范化”这些数据。根据项目需求，你可以选择将数据转为内存中的字符串，或者将其保存到文本文件中，以便进一步细化或下游处理。

同样，嵌入模型、向量存储和大语言模型（LLM）的选择可以根据你的项目需求进行定制。无论你需要一个更小或更大的模型，还是可能需要一个外部模型，这种方法的灵活性使你能够轻松地替换合适的选项。这个即插即用的能力确保了你的项目可以在不对核心架构进行重大修改的情况下，适应各种需求。

简化的模块化框架。图片来自作者。

我将主要组件用灰色高亮显示。在这个实现中，我们的向量存储将仅仅是一个 JSON 文件。再一次，根据你的使用场景，如果你一次只处理一个文件，你可能只想使用内存中的向量存储（Python 字典）。如果你需要持久化这些数据，就像我们这个用例中那样，你可以将它们保存在本地 JSON 文件中。如果你需要存储数十万或数百万个向量，你需要一个外部的向量存储（如 Pinecone、Azure Cognitive Search 等）。

准备数据

如上所述，这个实现从 JSON 数据开始。我使用了 GPT-4 和 Claude 生成了这些数据。数据包含了不同家具产品的描述，每个描述都有其对应的 SKU。以下是一个示例：

{
    "MBR-2001": "Traditional sleigh bed crafted in rich walnut wood, featuring a curved headboard and footboard with intricate grain details. Queen size, includes a plush, supportive mattress. Produced by Heritage Bed Co. Dimensions: 65\"W x 85\"L x 50\"H.",
    "MBR-2002": "Art Deco-inspired vanity table in a polished ebony finish, featuring a tri-fold mirror and five drawers with crystal knobs. Includes a matching stool upholstered in silver velvet. Made by Luxe Interiors. Vanity dimensions: 48\"W x 20\"D x 30\"H, Stool dimensions: 22\"W x 16\"D x 18\"H.",
    "MBR-2003": "Set of sheer linen drapes in soft ivory, offering a delicate and airy touch to bedroom windows. Each panel measures 54\"W x 84\"L. Features hidden tabs for easy hanging. Manufactured by Tranquil Home Textiles.",

    "LVR-3001": "Convertible sofa bed upholstered in navy blue linen fabric, easily transitions from sofa to full-size sleeper. Perfect for guests or small living spaces. Features a sturdy wooden frame. Produced by SofaBed Solutions. Dimensions: 70\"W x 38\"D x 35\"H.",
    "LVR-3002": "Ornate Persian area rug in deep red and gold, hand-knotted from silk and wool. Adds a luxurious touch to any living room. Measures 8' x 10'. Manufactured by Ancient Weaves.",
    "LVR-3003": "Contemporary TV stand in matte black with tempered glass doors and chrome legs. Features integrated cable management and adjustable shelves. Accommodates up to 65-inch TVs. Made by Streamline Tech. Dimensions: 60\"W x 20\"D x 24\"H.",

    "OPT-4001": "Modular outdoor sofa set in espresso brown polyethylene wicker, includes three corner pieces and two armless chairs with water-resistant cushions in cream. Configurable to fit any patio space. Produced by Outdoor Living. Corner dimensions: 32\"W x 32\"D x 28\"H, Armless dimensions: 28\"W x 32\"D x 28\"H.",
    "OPT-4002": "Cantilever umbrella in sunflower yellow, featuring a 10-foot canopy and adjustable tilt for optimal shade. Constructed with a sturdy aluminum pole and fade-resistant fabric. Manufactured by Shade Masters. Dimensions: 120\"W x 120\"D x 96\"H.",
    "OPT-4003": "Rustic fire pit table made from faux stone, includes a natural gas hookup and a matching cover. Ideal for evening gatherings on the patio. Manufactured by Warmth Outdoor. Dimensions: 42\"W x 42\"D x 24\"H.",

    "ENT-5001": "Digital jukebox with touchscreen interface and built-in speakers, capable of streaming music and playing CDs. Retro design with modern technology, includes customizable LED lighting. Produced by RetroSound. Dimensions: 24\"W x 15\"D x 48\"H.",
    "ENT-5002": "Gaming console storage unit in sleek black, featuring designated compartments for systems, controllers, and games. Ventilated to prevent overheating. Manufactured by GameHub. Dimensions: 42\"W x 16\"D x 24\"H.",
    "ENT-5003": "Virtual reality gaming set by VR Innovations, includes headset, two motion controllers, and a charging station. Offers a comprehensive library of immersive games and experiences.",

    "KIT-6001": "Chef's rolling kitchen cart in stainless steel, features two shelves, a drawer, and towel bars. Portable and versatile, ideal for extra storage and workspace in the kitchen. Produced by KitchenAid. Dimensions: 30\"W x 18\"D x 36\"H.",
    "KIT-6002": "Contemporary pendant light cluster with three frosted glass shades, suspended from a polished nickel ceiling plate. Provides elegant, diffuse lighting over kitchen islands. Manufactured by Luminary Designs. Adjustable drop length up to 60\".",
    "KIT-6003": "Eight-piece ceramic dinnerware set in ocean blue, includes dinner plates, salad plates, bowls, and mugs. Dishwasher and microwave safe, adds a pop of color to any meal. Produced by Tabletop Trends.",

    "GBR-7001": "Twin-size daybed with trundle in brushed silver metal, ideal for guest rooms or small spaces. Includes two comfortable twin mattresses. Manufactured by Guestroom Gadgets. Bed dimensions: 79\"L x 42\"W x 34\"H.",
    "GBR-7002": "Wall art set featuring three abstract prints in blue and grey tones, framed in light wood. Each frame measures 24\"W x 36\"H. Adds a modern touch to guest bedrooms. Produced by Artistic Expressions.",
    "GBR-7003": "Set of two bedside lamps in brushed nickel with white fabric shades. Offers a soft, ambient light suitable for reading or relaxing in bed. Dimensions per lamp: 12\"W x 24\"H. Manufactured by Bright Nights.",

    "BMT-8001": "Industrial-style pool table with a slate top and black felt, includes cues, balls, and a rack. Perfect for entertaining and game nights in finished basements. Produced by Billiard Masters. Dimensions: 96\"L x 52\"W x 32\"H.",
    "BMT-8002": "Leather home theater recliner set in black, includes four connected seats with individual cup holders and storage compartments. Offers a luxurious movie-watching experience. Made by CinemaComfort. Dimensions per seat: 22\"W x 40\"D x 40\"H.",
    "BMT-8003": "Adjustable height pub table set with four stools, featuring a rustic wood finish and black metal frame. Ideal for casual dining or socializing in basements. Produced by Casual Home. Table dimensions: 36\"W x 36\"D x 42\"H, Stool dimensions: 15\"W x 15\"D x 30\"H."
}

在实际场景中，我们可以将其推断到数百万个 SKU 和描述，可能这些数据都存储在不同的地方。在这个场景中，聚合和组织这些数据看起来微不足道，但通常情况下，野外数据需要像这样组织成结构。

下一步是将每个 SKU 转换为单独的文本文件。总共有 105 个文本文件（SKUs）。注意——你可以在文章底部的我的 GitHub 中找到所有的数据/代码链接。

我使用这个提示生成数据，并多次发送：

Given different "categories" for furniture, I want you to generate a synthetic 'SKU' and product description.

Generate 3 for each category. Be extremely granular with your details and descriptions (colors, sizes, synthetic manufacturers, etc..).

Every response should follow this format and should be only JSON:
{<SKU>:<description>}.

- master bedroom
- living room
- outdoor patio
- entertainment 
- kitchen
- guest bedroom
- finished basement

为了继续前进，您应该有一个包含产品描述的文本文件的目录，其中 SKU 作为文件名。

分块、索引和检索

分块

给定一段文本，我们需要有效地将其分块，以便优化检索。我试图根据 llama-index 的SentenceSplitter类来建模这个过程。

import re
import os
import uuid
from transformers import AutoTokenizer, AutoModel

def document_chunker(directory_path,
                     model_name,
                     paragraph_separator='\n\n',
                     chunk_size=1024,
                     separator=' ',
                     secondary_chunking_regex=r'\S+?[\.,;!?]',
                     chunk_overlap=0):

    tokenizer = AutoTokenizer.from_pretrained(model_name)  # Load tokenizer for the specified model
    documents = {}  # Initialize dictionary to store results

    # Read each file in the specified directory
    for filename in os.listdir(directory_path):
        file_path = os.path.join(directory_path, filename)
        base = os.path.basename(file_path)
        sku = os.path.splitext(base)[0]
        if os.path.isfile(file_path):
            with open(file_path, 'r', encoding='utf-8') as file:
                text = file.read()

            # Generate a unique identifier for the document
            doc_id = str(uuid.uuid4())

            # Process each file using the existing chunking logic
            paragraphs = re.split(paragraph_separator, text)
            all_chunks = {}
            for paragraph in paragraphs:
                words = paragraph.split(separator)
                current_chunk = ""
                chunks = []

                for word in words:
                    new_chunk = current_chunk + (separator if current_chunk else '') + word
                    if len(tokenizer.tokenize(new_chunk)) <= chunk_size:
                        current_chunk = new_chunk
                    else:
                        if current_chunk:
                            chunks.append(current_chunk)
                        current_chunk = word

                if current_chunk:
                    chunks.append(current_chunk)

                refined_chunks = []
                for chunk in chunks:
                    if len(tokenizer.tokenize(chunk)) > chunk_size:
                        sub_chunks = re.split(secondary_chunking_regex, chunk)
                        sub_chunk_accum = ""
                        for sub_chunk in sub_chunks:
                            if sub_chunk_accum and len(tokenizer.tokenize(sub_chunk_accum + sub_chunk + ' ')) > chunk_size:
                                refined_chunks.append(sub_chunk_accum.strip())
                                sub_chunk_accum = sub_chunk
                            else:
                                sub_chunk_accum += (sub_chunk + ' ')
                        if sub_chunk_accum:
                            refined_chunks.append(sub_chunk_accum.strip())
                    else:
                        refined_chunks.append(chunk)

                final_chunks = []
                if chunk_overlap > 0 and len(refined_chunks) > 1:
                    for i in range(len(refined_chunks) - 1):
                        final_chunks.append(refined_chunks[i])
                        overlap_start = max(0, len(refined_chunks[i]) - chunk_overlap)
                        overlap_end = min(chunk_overlap, len(refined_chunks[i+1]))
                        overlap_chunk = refined_chunks[i][overlap_start:] + ' ' + refined_chunks[i+1][:overlap_end]
                        final_chunks.append(overlap_chunk)
                    final_chunks.append(refined_chunks[-1])
                else:
                    final_chunks = refined_chunks

                # Assign a UUID for each chunk and structure it with text and metadata
                for chunk in final_chunks:
                    chunk_id = str(uuid.uuid4())
                    all_chunks[chunk_id] = {"text": chunk, "metadata": {"file_name":sku}}  # Initialize metadata as dict

            # Map the document UUID to its chunk dictionary
            documents[doc_id] = all_chunks

    return documents

这里最重要的参数是“chunk_size”。如您所见，我们正在使用transformers库来计算给定字符串中的标记数量。因此，chunk_size 表示一个块中的标记数量。

以下是该函数内部操作的详细说明：

对指定目录中的每个文件 →

将文本分割成段落：
- 使用指定的分隔符将输入文本划分为段落。
将段落分块成单词：
- 对每个段落，将其拆分为单词。
- 创建这些单词的块，确保不超过指定的标记数量（chunk_size）。
优化块：
- 如果任何块超过了 chunk_size，则使用基于标点的正则表达式进一步拆分它。
- 如果需要，合并子块以优化块大小。
应用重叠：
- 对于包含多个块的序列，在它们之间创建重叠，以确保上下文的连贯性。
编译并返回块：
- 遍历每个最终的块，给它分配一个唯一的 ID，该 ID 映射到该块的文本和元数据，最后将该块字典分配给文档 ID。

在这个例子中，我们正在对大量较小的文档进行索引，分块过程相对简单。每个文档较为简短，因此只需少量分割。这与处理更大文本的场景形成鲜明对比，例如从冗长的合同中提取特定部分或对整本小说进行索引。为了适应不同大小和复杂度的文档，我开发了document_chunker函数。这使得您可以输入数据——无论其长度或格式如何——并应用相同高效的分块过程。无论是处理简洁的产品描述，还是广袤的文学作品，document_chunker都能确保您的数据经过适当分块，以实现最佳的索引和检索效果。

用法：

docs = document_chunker(directory_path='/Users/joesasson/Desktop/articles/rag-from-scratch/text_data',
                        model_name='BAAI/bge-small-en-v1.5',
                        chunk_size=256)

keys = list(docs.keys())
print(len(docs))
print(docs[keys[0]])

Out -->
105
{'61d6318e-644b-48cd-a635-9490a1d84711': {'text': 'Gaming console storage unit in sleek black, featuring designated compartments for systems, controllers, and games. Ventilated to prevent overheating. Manufactured by GameHub. Dimensions: 42"W x 16"D x 24"H.', 'metadata': {'file_name': 'ENT-5002'}}}

现在，我们有了一个映射，具有唯一的文档 ID，指向该文档中的所有块，每个块都有自己的唯一 ID，指向该块的文本和元数据。

元数据可以包含任意的键/值对。在这里，我将文件名（SKU）设置为元数据，以便我们可以将模型的结果追溯到原始产品。

索引

现在我们已经创建了文档存储，我们需要创建向量存储。

你可能已经注意到，我们使用的是BAAI/bge-small-en-v1.5作为我们的嵌入模型。在之前的函数中，我们仅用它进行分词，现在我们将用它来将文本向量化。

为了准备部署，让我们将分词器和模型保存到本地。

from transformers import AutoModel, AutoTokenizer

model_name = "BAAI/bge-small-en-v1.5"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)

tokenizer.save_pretrained("model/tokenizer")
model.save_pretrained("model/embedding")

def compute_embeddings(text):
    tokenizer = AutoTokenizer.from_pretrained("/model/tokenizer") 
    model = AutoModel.from_pretrained("/model/embedding")

    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True) 

    # Generate the embeddings 
    with torch.no_grad():    
        embeddings = model(**inputs).last_hidden_state.mean(dim=1).squeeze()

    return embeddings.tolist()

def create_vector_store(doc_store):
    vector_store = {}
    for doc_id, chunks in doc_store.items():
        doc_vectors = {}
        for chunk_id, chunk_dict in chunks.items():
            # Generate an embedding for each chunk of text
            doc_vectors[chunk_id] = compute_embeddings(chunk_dict.get("text"))
        # Store the document's chunk embeddings mapped by their chunk UUIDs
        vector_store[doc_id] = doc_vectors
    return vector_store

我们所做的只是简单地将文档库中的块转换为嵌入。你可以插入任何嵌入模型，以及任何向量存储。由于我们的向量存储只是一个字典，所以我们所需要做的就是将其保存为 JSON 文件以便持久化。

检索

现在让我们用一个查询来测试一下！

def compute_matches(vector_store, query_str, top_k):
    """
    This function takes in a vector store dictionary, a query string, and an int 'top_k'.
    It computes embeddings for the query string and then calculates the cosine similarity against every chunk embedding in the dictionary.
    The top_k matches are returned based on the highest similarity scores.
    """
    # Get the embedding for the query string
    query_str_embedding = np.array(compute_embeddings(query_str))
    scores = {}

    # Calculate the cosine similarity between the query embedding and each chunk's embedding
    for doc_id, chunks in vector_store.items():
        for chunk_id, chunk_embedding in chunks.items():
            chunk_embedding_array = np.array(chunk_embedding)
            # Normalize embeddings to unit vectors for cosine similarity calculation
            norm_query = np.linalg.norm(query_str_embedding)
            norm_chunk = np.linalg.norm(chunk_embedding_array)
            if norm_query == 0 or norm_chunk == 0:
                # Avoid division by zero
                score = 0
            else:
                score = np.dot(chunk_embedding_array, query_str_embedding) / (norm_query * norm_chunk)

            # Store the score along with a reference to both the document and the chunk
            scores[(doc_id, chunk_id)] = score

    # Sort scores and return the top_k results
    sorted_scores = sorted(scores.items(), key=lambda item: item[1], reverse=True)[:top_k]
    top_results = [(doc_id, chunk_id, score) for ((doc_id, chunk_id), score) in sorted_scores]

    return top_results

compute_matches函数旨在从存储的文本嵌入集合中识别与给定查询字符串最相似的前 k 个文本块。下面是详细说明：

嵌入查询字符串
计算余弦相似度。对于每个块，计算查询向量和块向量之间的余弦相似度。在这里，np.linalg.norm计算的是向量的欧几里得范数（L2 范数），这是计算余弦相似度所必需的。
处理规范化并计算点积。余弦相似度定义为：

A和B是向量，||A||和||B||是它们的范数。

对得分进行排序和选择。得分按降序排列，选取前 k 个结果。

用法：

matches = compute_matches(vector_store=vec_store,
                query_str="Wall-mounted electric fireplace with realistic LED flames",
                top_k=3)

# matches
[('d56bc8ca-9bbc-4edb-9f57-d1ea2b62362f',
  '3086bed2-65e7-46cc-8266-f9099085e981',
  0.8600385118142513),
 ('240c67ce-b469-4e0f-86f7-d41c630cead2',
  '49335ccf-f4fb-404c-a67a-19af027a9fc2',
  0.7067269230771228),
 ('53faba6d-cec8-46d2-8d7f-be68c3080091',
  'b88e4295-5eb1-497c-8536-59afd84d2210',
  0.6959163226146977)]

# plug the top match document ID keys into doc_store to access the retrieved content
docs['d56bc8ca-9bbc-4edb-9f57-d1ea2b62362f']['3086bed2-65e7-46cc-8266-f9099085e981']

# result
{'text': 'Wall-mounted electric fireplace with realistic LED flames and heat settings. Features a black glass frame and remote control for easy operation. Ideal for adding warmth and ambiance. Manufactured by Hearth & Home. Dimensions: 50"W x 6"D x 21"H.',
 'metadata': {'file_name': 'ENT-4001'}}

每个元组包含文档 ID，其后是块 ID，再后是得分。

太棒了，已经成功！接下来要做的就是连接 LLM 组件并运行完整的端到端测试，然后我们就可以部署了！

LLM 组件

为了通过使我们的 RAG 系统更加互动来增强用户体验，我们将使用llama-cpp-python库。我们的设置将使用带有 GGUF 3 位量化的 mistral-7B 参数模型，这一配置在计算效率和性能之间提供了良好的平衡。经过大量测试，这种模型大小已被证明在资源有限的机器上特别有效，例如我的 M2 8GB Mac。通过采用这种方法，我们确保我们的 RAG 系统不仅能提供精确和相关的响应，还能保持对话语气，使其更加引人入胜和易于接触，便于最终用户使用。

在 Mac 上本地设置 LLM 的快速说明——我更倾向于使用 anaconda 或 miniconda。确保你安装了 arm64 版本，并按照库中的‘metal’设置说明进行操作，这里。

现在，非常简单。我们需要做的就是定义一个函数，构建一个包含检索到的文档和用户查询的提示。LLM 的响应将返回给用户。

我定义了以下函数来流式传输 LLM 的文本响应并构建最终的提示。

from llama_cpp import Llama
import sys

def stream_and_buffer(base_prompt, llm, max_tokens=800, stop=["Q:", "\n"], echo=True, stream=True):

    # Formatting the base prompt
    formatted_prompt = f"Q: {base_prompt} A: "

    # Streaming the response from llm
    response = llm(formatted_prompt, max_tokens=max_tokens, stop=stop, echo=echo, stream=stream)

    buffer = ""

    for message in response:
        chunk = message['choices'][0]['text']
        buffer += chunk

        # Split at the last space to get words
        words = buffer.split(' ')
        for word in words[:-1]:  # Process all words except the last one (which might be incomplete)
            sys.stdout.write(word + ' ')  # Write the word followed by a space
            sys.stdout.flush()  # Ensure it gets displayed immediately

        # Keep the rest in the buffer
        buffer = words[-1]

    # Print any remaining content in the buffer
    if buffer:
        sys.stdout.write(buffer)
        sys.stdout.flush()

def construct_prompt(system_prompt, retrieved_docs, user_query):
    prompt = f"""{system_prompt}

    Here is the retrieved context:
    {retrieved_docs}

    Here is the users query:
    {user_query}
    """
    return prompt

# Usage
system_prompt = """
You are an intelligent search engine. You will be provided with some retrieved context, as well as the users query.

Your job is to understand the request, and answer based on the retrieved context.
"""

retrieved_docs = """
Wall-mounted electric fireplace with realistic LED flames and heat settings. Features a black glass frame and remote control for easy operation. Ideal for adding warmth and ambiance. Manufactured by Hearth & Home. Dimensions: 50"W x 6"D x 21"H.
"""

prompt = construct_prompt(system_prompt=system_prompt,
                          retrieved_docs=retrieved_docs,
                          user_query="I am looking for a wall-mounted electric fireplace with realistic LED flames")

llm = Llama(model_path="/Users/joesasson/Downloads/mistral-7b-instruct-v0.2.Q3_K_L.gguf", n_gpu_layers=1)

stream_and_buffer(prompt, llm)

返回给用户的最终输出：

“基于检索到的上下文和用户的查询，Hearth & Home 电壁炉配有逼真的 LED 火焰，符合描述。该型号宽 50 英寸，深 6 英寸，高 21 英寸，附带遥控器，便于操作。”

我们现在准备部署我们的 RAG 系统。请继续阅读下一部分，我们将把这段近乎“意大利面”的代码转换为可供用户使用的 API。

构建与部署 API

为了扩展我们系统的覆盖范围和可用性，我们将把它打包成一个容器化的 Flask 应用程序。此方法确保我们的模型被封装在一个 Docker 容器内，无论计算环境如何，都能提供稳定性和一致性。

你应该已经下载了上述的嵌入模型和分词器。将这些文件与应用代码、依赖项和 Dockerfile 放在同一目录下。你可以在此处下载 LLM。

你应该有以下的目录结构：

部署目录结构。图片由作者提供。

app.py

from flask import Flask, request, jsonify
import numpy as np
import json
from typing import Dict, List, Any
from llama_cpp import Llama
import torch
import logging
from transformers import AutoModel, AutoTokenizer

app = Flask(__name__)

# Set the logger level for Flask's logger
app.logger.setLevel(logging.INFO)

def compute_embeddings(text):
    tokenizer = AutoTokenizer.from_pretrained("/app/model/tokenizer") 
    model = AutoModel.from_pretrained("/app/model/embedding")

    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True) 

    # Generate the embeddings 
    with torch.no_grad():    
        embeddings = model(**inputs).last_hidden_state.mean(dim=1).squeeze()

    return embeddings.tolist()

def compute_matches(vector_store, query_str, top_k):
    """
    This function takes in a vector store dictionary, a query string, and an int 'top_k'.
    It computes embeddings for the query string and then calculates the cosine similarity against every chunk embedding in the dictionary.
    The top_k matches are returned based on the highest similarity scores.
    """
    # Get the embedding for the query string
    query_str_embedding = np.array(compute_embeddings(query_str))
    scores = {}

    # Calculate the cosine similarity between the query embedding and each chunk's embedding
    for doc_id, chunks in vector_store.items():
        for chunk_id, chunk_embedding in chunks.items():
            chunk_embedding_array = np.array(chunk_embedding)
            # Normalize embeddings to unit vectors for cosine similarity calculation
            norm_query = np.linalg.norm(query_str_embedding)
            norm_chunk = np.linalg.norm(chunk_embedding_array)
            if norm_query == 0 or norm_chunk == 0:
                # Avoid division by zero
                score = 0
            else:
                score = np.dot(chunk_embedding_array, query_str_embedding) / (norm_query * norm_chunk)

            # Store the score along with a reference to both the document and the chunk
            scores[(doc_id, chunk_id)] = score

    # Sort scores and return the top_k results
    sorted_scores = sorted(scores.items(), key=lambda item: item[1], reverse=True)[:top_k]
    top_results = [(doc_id, chunk_id, score) for ((doc_id, chunk_id), score) in sorted_scores]

    return top_results

def open_json(path):
    with open(path, 'r') as f:
        data = json.load(f)
    return data

def retrieve_docs(doc_store, matches):
    top_match = matches[0]
    doc_id = top_match[0]
    chunk_id = top_match[1]
    docs = doc_store[doc_id][chunk_id]
    return docs

def construct_prompt(system_prompt, retrieved_docs, user_query):
    prompt = f"""{system_prompt}

    Here is the retrieved context:
    {retrieved_docs}

    Here is the users query:
    {user_query}
    """
    return prompt

@app.route('/rag_endpoint', methods=['GET', 'POST'])
def main():
    app.logger.info('Processing HTTP request')

    # Process the request
    query_str = request.args.get('query') or (request.get_json() or {}).get('query')
    if not query_str:
        return jsonify({"error":"missing required parameter 'query'"})

    vec_store = open_json('/app/vector_store.json')
    doc_store = open_json('/app/doc_store.json')

    matches = compute_matches(vector_store=vec_store, query_str=query_str, top_k=3)
    retrieved_docs = retrieve_docs(doc_store, matches)

    system_prompt = """
    You are an intelligent search engine. You will be provided with some retrieved context, as well as the users query.

    Your job is to understand the request, and answer based on the retrieved context.
    """

    base_prompt = construct_prompt(system_prompt=system_prompt, retrieved_docs=retrieved_docs, user_query=query_str)

    app.logger.info(f'constructed prompt: {base_prompt}')

    # Formatting the base prompt
    formatted_prompt = f"Q: {base_prompt} A: "

    llm = Llama(model_path="/app/mistral-7b-instruct-v0.2.Q3_K_L.gguf")
    response = llm(formatted_prompt, max_tokens=800, stop=["Q:", "\n"], echo=False, stream=False)

    return jsonify({"response": response})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5001)

Dockerfile

# Use an official Python runtime as a parent image
FROM --platform=linux/arm64 python:3.11

# Set the working directory in the container to /app
WORKDIR /app

# Copy the requirements file
COPY requirements.txt .

# Update system packages, install gcc and Python dependencies
RUN apt-get update && \
    apt-get install -y gcc g++ make libtool && \
    apt-get upgrade -y && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/* && \
    pip install --no-cache-dir -r requirements.txt

# Copy the current directory contents into the container at /app
COPY . /app

# Expose port 5001 to the outside world
EXPOSE 5001

# Run script when the container launches
CMD ["python", "app.py"]

需要注意的一点是——我们在 Dockerfile 的第二行设置了工作目录为‘/app’。因此，任何本地路径（模型、向量或文档存储），应该在你的应用代码中以‘/app’为前缀。

此外，当你在容器中运行应用程序（在 Mac 上时），它将无法访问 GPU，参见这个讨论。我注意到使用 CPU 时，通常需要大约 20 分钟才能得到响应。

构建与运行：

docker build -t <image-name>:<tag> .

docker run -p 5001:5001 <image-name>:<tag>

运行容器会自动启动应用程序（见 Dockerfile 的最后一行）。你现在可以通过以下 URL 访问你的端点：

http://127.0.0.1:5001/rag_endpoint

调用 API：

import requests, json

def call_api(query):
    URL = "http://127.0.0.1:5001/rag_endpoint"

    # Headers for the request
    headers = {
        "Content-Type": "application/json"
    }

    # Body for the request.
    body = {"query": query}

    # Making the POST request
    response = requests.post(URL, headers=headers, data=json.dumps(body))

    # Check if the request was successful
    if response.status_code == 200:
        return response.json()
    else:
        return f"Error: {response.status_code}, Message: {response.text}"

# Test
query = "Wall-mounted electric fireplace with realistic LED flames"

result = call_api(query)
print(result)

# result
{'response': {'choices': [{'finish_reason': 'stop', 'index': 0, 'logprobs': None, 'text': ' Based on the retrieved context, the wall-mounted electric fireplace mentioned includes features such as realistic LED flames. Therefore, the answer to the user\'s query "Wall-mounted electric fireplace with realistic LED flames" is a match to the retrieved context. The specific model mentioned in the context is manufactured by Hearth & Home and comes with additional heat settings.'}], 'created': 1715307125, 'id': 'cmpl-dd6c41ee-7c89-440f-9b04-0c9da9662f26', 'model': '/app/mistral-7b-instruct-v0.2.Q3_K_L.gguf', 'object': 'text_completion', 'usage': {'completion_tokens': 78, 'prompt_tokens': 177, 'total_tokens': 255}}}

结论

我想回顾一下所有达到这一点所需的步骤，以及将其调整为适应任何数据/嵌入/LLM 的工作流程。

将你的文本文件目录传递给document_chunker函数，以创建文档存储。
选择你的嵌入模型。将其保存在本地。
将文档存储转换为向量存储。并将这两个文件保存在本地。
从 HF Hub 下载 LLM。
将文件移动到应用目录（嵌入模型、LLM、文档存储和向量存储 JSON 文件）。
构建并运行 Docker 容器。

本质上可以总结为这一点——使用build笔记本生成 doc_store 和 vector_store，并将这些文件放置到你的应用中。

GitHub 链接。感谢阅读！

Rust 中的 LOESS

原文：towardsdatascience.com/loess-in-rust-2e22f58c81d4?source=collection_archive---------7-----------------------#2024-08-12

是时候将 Python 中的 LOESS 代码移植到 Rust 了。

João Paulo Figueira

·发布于Towards Data Science ·阅读时长 5 分钟·2024 年 8 月 12 日

摄影：Matt Foxx 于Unsplash

五年前，从本文写作之时算起，我在 Medium 上发布了我最成功的文章。那篇文章源于一个需求：从车载远程信息处理数据流中过滤一个特别嘈杂的传感器数据。具体来说，它是连接到卡车传动轴的扭矩传感器，需要去除噪声。LOESS 是解决方案，因此写了那篇文章。

## LOESS

使用局部回归平滑数据

towardsdatascience.com

到那时，我已经深陷于 Python 的世界，并且该项目需要使用 Spark，因此在 Python 中实现算法是毫不犹豫的选择。然而，随着时间的推移，我现在更多使用 Rust，并决定尝试将旧代码移植过来。本文描述了移植过程以及我在重写代码时的选择。你应该阅读原始文章和参考材料，进一步了解算法。这里，我们将重点讨论在 Rust 中编写矩阵代码的细节，尽可能地替代之前的NumPy实现。

Rust 数值计算

作为一个坚定的反对重复造轮子的人，我寻找了推荐的 Rust 包来替代我在原始 Python 代码中使用的NumPy，很快就找到了nalgebra。

nalgebra 旨在成为一个通用的低维线性代数库，提供一套针对计算机图形学和物理学优化的工具集。

尽管我们不会做任何物理学或计算机图形学相关的工作，但我们符合低维度的要求，简直是量体裁衣。

差异

当将 Python 代码转换为 Rust 时，我遇到了一些困难，花了一些时间才理清楚。在 Python 中使用 NumPy 时，我们可以利用语言和库提供的所有特性来提高代码的表达性和可读性。Rust 比 Python 更冗长，而且在撰写本文时（版本 0.33.0），nalgebra crate 仍然缺少一些有助于提高表达性的特性。简洁性是一个挑战。

我的第一个障碍是使用其他数组对数组进行索引。使用 NumPy 时，我们可以用另一个整数或布尔值数组对数组进行索引。在第一种情况下，索引数组的每个元素都是源数组的索引，索引数组的维度可以等于或小于数据数组。在布尔索引的情况下，索引数组的大小必须与数据数组相同，每个元素必须表示是否包含对应的数据元素。在使用布尔表达式选择数据时，这个特性非常方便。

尽管如此，我在整个 Python 代码中都使用了这个特性：

# Python
xx = self.n_xx[min_range]

在这里，min_range 变量是一个整数数组，包含了从 self.n_xx 数组中检索的索引子集。

尽管我尽力而为，但我未能在 Rust crate 中找到模仿 NumPy 索引的方法，因此我不得不自己实现一个。在尝试和基准测试几次之后，我得到了最终的版本。这个解决方案直接而有效。

// Rust
fn select_indices(values: &DVector<f64>,
                  indices: &DVector<usize>) -> DVector<f64> {
    indices.map(|i| values[i])
}

map 表达式非常简单，但使用函数名更具表达性，因此我将上面的 Python 代码替换为相应的 Rust 代码：

// Rust
let xx = select_indices(&self.xx, min_range);

另外，也没有内置方法从整数范围创建向量。虽然使用 nalgebra 很容易做到，但代码会稍微长一些：

// Rust
range = DVector::<usize>::from_iterator(window, 0..window);

如果我们在编译期间固定了向量和数组的大小，可以避免很多这种繁琐的操作，但由于维度未知，这里我们无法做到。对应的 Python 代码要简洁得多：

# Python
np.arange(0, window)

这种简洁性也延伸到其他领域，例如按行填充矩阵。在 Python 中，我们可以这样做：

# Python
for i in range(1, degree + 1):
    xm[:, i] = np.power(self.n_xx[min_range], i)

在撰写本文时，我发现用 nalgebra 做同样的事情，没有比这个更好的方法了：

// Rust
for i in 1..=degree {
    for j in 0..window {
        xm[(j, i)] = self.xx[min_range[j]].powi(i as i32);
    }
}

也许包中隐藏着某些东西，等待被发现，从而帮助我们提高简洁性。

最后，我发现 nalgebra 的文档相对稀少。我们可以理解这一点，因为这是一个相对年轻的 Rust crate，未来充满了潜力。

优势

最精彩的部分在最后——原始性能。我邀请你尝试运行两种版本的相同代码（GitHub 仓库链接见下方），并比较它们的性能。在我的 2019 年款 2.6 GHz 6 核 Intel Core i7 MacBook Pro 上，Rust 代码的 release 版本运行时间不到 200 微秒，而 Python 代码的运行时间不到 5 毫秒。

结论

这个项目是我将旧代码从 Python 转移到 Rust 的另一个令人兴奋且富有教育意义的过程。尽管从著名的 Python 控制结构转换到 Rust 正变得越来越容易，但从 NumPy 转换到 nalgebra 的过程更加具有挑战性。Rust 包展现了很大的潜力，但仍需要更多的文档和在线支持。我热烈欢迎更为详细的用户指南。

Rust 比 Python 更加正式，但在适当使用时性能更好。在构建原型和发现阶段，我将继续使用 Python 进行日常工作，但在进入生产阶段时，我会转向 Rust 以获得更好的性能和内存安全性。我们甚至可以通过像PyO3这样的 crate 混合使用两者，所以这是一个双赢的局面。

Rust 真棒！

参考文献

joaofig/loess-rs: 一个在 Rust 中实现的 LOESS / LOWESS 算法

joaofig/pyloess: 使用 numpy 实现的简单 LOESS 算法

赞扬

我使用了Grammarly来审查写作，并接受了它的一些重写建议。

JetBrains 的 AI 助手帮助我编写了一部分代码，我也用它来学习 Rust。它已经成为我日常工作中处理 Rust 和 Python 的重要工具。不幸的是，对 nalgebra 的支持仍然不足。

João Paulo Figueira 是位于葡萄牙里斯本的 tb.lx by Daimler Truck 的数据科学家。

面包屑日志：仅显示导致错误的日志

原文：towardsdatascience.com/log-breadcrumbs-only-show-logs-leading-up-to-an-error-82b9f4c15520?source=collection_archive---------11-----------------------#2024-11-05

如何使用 Python 的内建日志包记录面包屑日志

Mike Huls

·发表于Towards Data Science ·阅读时间：5 分钟·2024 年 11 月 5 日

图片由Daniel Tseng提供 / Unsplash

在本文中，我们将探讨一种有效记录面包屑日志的方法，仅显示导致错误的日志。我们将仅使用 Python 的标准日志库创建一个高效的日志设置，仅在发生异常时捕获 debug 日志。这种方法提供了详细的步骤视图，展示问题发生之前的过程，同时减少杂乱并最小化 I/O。让我们开始编码吧！

为什么要记录面包屑日志？

当错误发生时，你希望尽可能多的信息来帮助你定位代码中的问题。在这方面，记录大量信息非常有用。

缺点是所有这些日志需要被处理。然后需要写入文件或通过 HTTP 发送到端点，这可能会影响应用程序或服务器的性能。此外，这可能会使日志杂乱无章，导致在错误发生时更难找到相关信息。

面包屑方法“忽略”例如所有debug日志，除非发生错误。这使你既可以记录大量的错误详细信息，并且保持性能和概览水平。

设置面包屑日志

为什么你的服务工程师需要一个聊天机器人：故障排除的未来

原文：towardsdatascience.com/logiq-service-engineer-chatbot-04e229beee5c?source=collection_archive---------4-----------------------#2024-09-29

图片：The New Yorker / Widows © Matt Chinworth | CC BY-NC-ND 4.0

作为 2024 年 Google AI Sprint 的一部分，我构建了一个多模态聊天机器人，结合了 Gemini 1.5，下面是它如何彻底改变家电支持的方式

Ashwin Raj

·发表于数据科学前沿 ·8 分钟阅读·2024 年 9 月 29 日

在各行各业中，故障排除对于维持平稳运营、确保客户满意度以及优化服务流程效率至关重要。然而，现场故障排除家电设备可能是一项具有挑战性的任务。由于有各种型号和无数潜在问题，服务工程师常常不得不翻阅手册或在线搜索解决方案，这种方法既令人沮丧，又费时费力。

这就是配备全面服务知识并能访问最新故障排除手册的聊天机器人能够改变体验的地方。虽然人们可能认为检索增强生成（RAG）是此类任务的理想解决方案，但在这种情况下，它往往力不从心。因为这些手册通常包含表格、图片和图表等元素，而这些元素难以提取，且总结可能会忽略其中的复杂细节，使得它不适合用于生产部署。

在本文中，我们将着手构建一个使用 Gemini 的聊天机器人，帮助现场服务工程师更快速、更直观地找到所需信息。我们还将探讨 Gemini 提供的高级功能，如上下文缓存和文件 API 集成，以支持多模态提示。最后，我们将把这个聊天机器人封装在 Streamlit 界面中，以便于交互。

在你开始之前

为了构建聊天机器人，我们将使用 Gemini、Python 3 和 Streamlit。首先，通过运行以下命令在你的本地机器上安装 Streamlit：

pip install streamlit

对于数据库，我们将依赖于 Python 预装的 SQLite。我们还需要一个 Gemini API 密钥，以便使用 Gemini 1.5 Flash 进行推理。如果你还没有 API 密钥，你可以通过这个链接免费创建一个。一旦你设置了密钥，运行以下命令安装 Google AI Python SDK：

pip install google-generativeai

你可以在我的 GitHub 仓库这里找到源代码和其他资源。

致谢： 本项目提供了 Google Cloud 的信用额度，作为#AISprint 2024 的一部分

架构

在实现之前，让我们详细检查系统架构。该过程从从数据库中提取所需的产品手册并传递给 Gemini 开始。这充当我们的聊天机器人的知识库，为所选电器提供必要的故障排除信息。

图片来自作者

一旦文档加载完成，我们利用 Gemini 的多模态文档处理能力，从产品手册中提取所需的信息。现在，当用户与聊天机器人互动时，模型将结合上传的服务手册数据、聊天历史和其他上下文信息，提供准确而深刻的回答，解答用户的查询。

为了提高性能，我们将实现上下文缓存，优化重复查询的响应时间。最后，我们将把这个架构封装在一个简单且直观的 Streamlit Web 应用程序中，允许服务工程师无缝地与聊天代理互动，并访问他们需要的信息。

将服务手册加载到数据库中

要开始构建聊天机器人，第一步是将故障排除指南加载到我们的数据库中以供参考。由于这些文件本身没有结构，我们无法直接将它们存储在数据库中。相反，我们存储它们的文件路径：

class ServiceGuides:
    def __init__(self, db_name="database/persistent/general.db"):
        self.conn = sqlite3.connect(db_name)
        self.create_table()

    def add_service_guide(self, model_number, guide_name, guide_file_url):
        cursor = self.conn.cursor()

        cursor.execute('''
            INSERT INTO service_guides (model, guide_name, guide_url)
            VALUES (?, ?, ?)
        ''', (model_number, guide_name, guide_file_url))

        self.conn.commit()

    def fetch_guides_by_model_number(self, model_number):
        cursor = self.conn.cursor()
        cursor.execute(
            """SELECT guide_url FROM service_guides WHERE model = ?""",
            (model_number,),
        )
        return cursor.fetchone()

在这个项目中，我们将在本地目录中存储手册，并将它们的文件路径保存在 SQLite 数据库中。然而，为了更好的可扩展性，建议使用对象存储服务，例如 Google Cloud Storage 来存储这些文件，并在像 Google Cloud SQL 这样的数据库服务中维护文件的 URL。

使用 Gemini 构建对话代理

一旦产品手册加载到数据库中，下一步是使用 1.5 Flash 构建代理。这个轻量级模型是 Gemini 家族的一部分，并通过一种称为“蒸馏”的过程进行了微调，其中来自更大模型的最重要的知识和技能被转移到一个更小、更高效的模型中，以支持各种高容量任务的规模。

来自The Keyword的图片，来源于 Google

为了提高速度和操作效率，1.5 Flash 模型在多模态推理方面非常高效，具有最多可达 100 万个令牌的上下文窗口，成为我们服务工程师使用场景的理想选择。

使用 1.5 Flash 进行多模态文档处理

要对我们的服务手册进行推理，首先需要将文件上传到 Gemini。Gemini API 支持将媒体文件与提示输入分开上传，使我们能够在多个请求中重复使用文件。File API 每个项目支持最多 20 GB 的文件，每个文件最大支持 2 GB：

class ServiceEngineerChatbot:
    def __init__(self):
        genai.configure(api_key=st.secrets["GEMINI_API_KEY"])

    def post_service_guide_to_gemini(self, title, path_to_service_guide):
        service_guide = genai.upload_file(
            path=path_to_service_guide,
            display_name=title,
        )

        while service_guide.state.name == 'PROCESSING':
            print('Waiting for file to be processed.')
            time.sleep(2)
            service_guide = genai.get_file(service_guide.name)

        return service_guide

要上传文件，我们使用 upload_file()方法，该方法的参数包括路径（要上传的文件路径）、名称（目标文件名，默认为系统生成的 ID）、mime_type（指定文档的 MIME 类型，如果未指定，将进行推断）和 display_name。

在继续之前，我们需要通过检查文件的元数据来验证 API 是否成功存储了上传的文件。如果文件的状态是 PROCESSING，则尚不能用于推理。一旦状态变为 ACTIVE，文件即可使用。如果状态为 FAILED，表示文件处理未成功。

对话式响应生成

上传服务手册后，下一步是利用 Gemini 1.5 的多模态文档处理能力来生成响应。API 的聊天功能允许我们收集多轮问题和答案，便于深入分析问题并逐步解决。

作者提供的图片

初始化模型时，提供具体的指导方针和上下文以塑造聊天机器人的行为至关重要。这是通过向模型提供系统指令来完成的。系统指令有助于维持上下文，指导互动风格，确保一致性，并为聊天机器人的响应设定边界，同时尽量避免幻觉现象。

class ServiceEngineerChatbot:
    def __init__(self):
        genai.configure(api_key=st.secrets["GEMINI_API_KEY"])

    def construct_flash_model(self, brand, sub_category, model_number):
        model_system_instruction = f"""
        Add your detailed system instructions here.
        These instructions should define the chatbot's behavior, tone, and 
        provide any necessary context. For example, you might include 
        guidelines about how to respond to queries, the structure of 
        responses, or information about what the chatbot should and should
        not do. Checkout my repo for this chatbot's system instructions.
        """

        model_generation_cofig = genai.types.GenerationConfig(
            candidate_count=1,
            max_output_tokens=1500,
            temperature=0.4,
        ),

        model = genai.GenerativeModel(
            model_name="gemini-1.5-flash",
            system_instruction=model_system_instruction,
            generation_config=model_generation_cofig,
        )
        return model

我们可以通过调整 GenerationConfig 类中的模型参数，进一步控制模型的响应生成。在我们的应用中，我们已将 max_output_tokens 设置为 1500，定义了每个响应的最大令牌限制，并将 temperature 设置为 0.4，以保持响应的确定性。

使用上下文缓存进行长上下文优化

在许多情况下，尤其是对于同一文档的重复查询，我们最终会将相同的输入令牌反复发送给模型。尽管这种方法可能有效，但对于大规模的生产级应用来说，它并不是最优选择。

这是 Gemini 的上下文缓存功能变得至关重要的地方，通过减少高 Token 工作负载的成本和延迟，提供更高效的解决方案。通过上下文缓存，我们可以在后续请求中引用缓存的 Token，而不是每次请求都发送相同的输入 Token。

图片由作者提供

在这个项目中，我们缓存了系统指令和服务手册文件。在大规模使用时，使用缓存的 Token 相比重复传输相同的数据显著降低了成本。默认情况下，这些缓存 Token 的生存时间（TTL）为 1 小时，但可以根据需要进行调整。一旦 TTL 到期，缓存的 Token 将自动从 Gemini 的上下文中移除。

class ServiceEngineerChatbot:
    def _generate_context_cache(
        self,
        brand,
        sub_category,
        model_number,
        service_guide_title,
        service_guide,
        ttl_mins=70,
    ):
        context_cache = caching.CachedContent.create(
            model='models/gemini-1.5-flash-001',
            display_name=f"{service_guide_title}_cache",
            system_instruction=model_system_instruction,
            contents=[
                service_guide
            ],
            ttl=datetime.timedelta(
                minutes=ttl_mins
            ),
        )

        return context_cache

需要注意的是，只有当输入 Token 数量达到 32,768 或更多时，上下文缓存才可用。如果 Token 数量低于此阈值，则需要依赖 Gemini 1.5 Flash 的标准多模态提示功能。

集成聊天机器人与 Streamlit

在我们的聊天机器人响应生成能力就位后，最后一步是将其包装成一个 Streamlit 应用，创建一个直观的用户界面供用户使用。

图片由作者提供

界面具有一个下拉菜单，用户可以选择他们正在使用的家电品牌和型号。选择后点击“配置聊天机器人”按钮，应用将把相应的服务手册传递给 Gemini，并展示聊天界面。从此，工程师可以输入他们的问题，聊天机器人将提供相关的回复。

未来展望

展望未来，有几个有前景的方向值得探索。聊天机器人的未来版本可以集成语音支持，允许工程师与聊天机器人进行更自然的交流，从而解决他们的问题。

此外，扩展系统以纳入预测性诊断功能，可以使工程师预先识别潜在问题，避免其导致设备故障。通过不断发展这个工具，目标是为服务工程师创建一个全面的支持系统，最终提升客户体验，从而改变故障排除的生态系统。

至此，我们已经结束了本文。如果您有任何问题或认为我有任何错误，请随时与我联系！您可以通过电子邮件或LinkedIn与我取得联系。直到那时，祝您学习愉快！

逻辑回归解析：带代码示例的可视化指南，适合初学者

原文：towardsdatascience.com/logistic-regression-explained-a-visual-guide-with-code-examples-for-beginners-81baf5871505?source=collection_archive---------0-----------------------#2024-09-10

分类算法

找到适合数据的最佳权重

·发表于Towards Data Science ·10 分钟阅读·2024 年 9 月 10 日

⛳️ 更多[分类算法](https://medium.com/@samybaladram/list/classification-algorithms-b3586f0a772c)解析：· 虚拟分类器 · K 近邻分类器 · 伯努利朴素贝叶斯 · 高斯朴素贝叶斯 · 决策树分类器 ▶ 逻辑回归 · 支持向量分类器 · 多层感知器

尽管一些基于概率的机器学习模型（如朴素贝叶斯）对特征独立性做出大胆假设，但逻辑回归采用了更为谨慎的方法。可以把它看作是绘制一条（或一平面）将两种结果分开的线，这样我们就可以以更大的灵活性预测概率。

所有视觉效果：作者使用 Canva Pro 创建。针对移动设备进行了优化；在桌面端可能会显得过大。

定义

逻辑回归是一种用于预测二元结果的统计方法。尽管名字中有“回归”，但它实际上用于分类而非回归。它估计实例属于某个特定类别的概率。如果估计的概率大于 50%，模型预测该实例属于该类别（反之亦然）。

📊 使用的数据集

在本文中，我们将使用这个人工高尔夫数据集（灵感来自[1]）作为示例。该数据集根据天气条件预测一个人是否会打高尔夫。

与 KNN 类似，逻辑回归也要求先对数据进行缩放。将类别列转换为 0 和 1，同时缩放数值特征，以避免某一特征主导距离度量。

列：‘Outlook’（天气状况）、‘Temperature’（温度）、‘Humidity’（湿度）、‘Wind’（风速）和‘Play’（目标特征）。类别列（Outlook 和 Windy）使用独热编码（one-hot encoding）进行编码，而数值列则使用标准缩放（z-标准化）进行缩放。

# Import required libraries
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import StandardScaler
import pandas as pd
import numpy as np

# Create dataset from dictionary
dataset_dict = {
    'Outlook': ['sunny', 'sunny', 'overcast', 'rainy', 'rainy', 'rainy', 'overcast', 'sunny', 'sunny', 'rainy', 'sunny', 'overcast', 'overcast', 'rainy', 'sunny', 'overcast', 'rainy', 'sunny', 'sunny', 'rainy', 'overcast', 'rainy', 'sunny', 'overcast', 'sunny', 'overcast', 'rainy', 'overcast'],
    'Temperature': [85.0, 80.0, 83.0, 70.0, 68.0, 65.0, 64.0, 72.0, 69.0, 75.0, 75.0, 72.0, 81.0, 71.0, 81.0, 74.0, 76.0, 78.0, 82.0, 67.0, 85.0, 73.0, 88.0, 77.0, 79.0, 80.0, 66.0, 84.0],
    'Humidity': [85.0, 90.0, 78.0, 96.0, 80.0, 70.0, 65.0, 95.0, 70.0, 80.0, 70.0, 90.0, 75.0, 80.0, 88.0, 92.0, 85.0, 75.0, 92.0, 90.0, 85.0, 88.0, 65.0, 70.0, 60.0, 95.0, 70.0, 78.0],
    'Wind': [False, True, False, False, False, True, True, False, False, False, True, True, False, True, True, False, False, True, False, True, True, False, True, False, False, True, False, False],
    'Play': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No', 'No', 'Yes', 'Yes', 'No', 'No', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No', 'Yes']
}
df = pd.DataFrame(dataset_dict)

# Prepare data: encode categorical variables
df = pd.get_dummies(df, columns=['Outlook'], prefix='', prefix_sep='', dtype=int)
df['Wind'] = df['Wind'].astype(int)
df['Play'] = (df['Play'] == 'Yes').astype(int)

# Rearrange columns
column_order = ['sunny', 'overcast', 'rainy', 'Temperature', 'Humidity', 'Wind', 'Play']
df = df[column_order]

# Split data into features and target
X, y = df.drop(columns='Play'), df['Play']

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.5, shuffle=False)

# Scale numerical features
scaler = StandardScaler()
X_train[['Temperature', 'Humidity']] = scaler.fit_transform(X_train[['Temperature', 'Humidity']])
X_test[['Temperature', 'Humidity']] = scaler.transform(X_test[['Temperature', 'Humidity']])

# Print results
print("Training set:")
print(pd.concat([X_train, y_train], axis=1), '\n')
print("Test set:")
print(pd.concat([X_test, y_test], axis=1))

主要机制

逻辑回归通过对输入特征的线性组合应用逻辑函数来工作。其操作过程如下：

计算输入特征的加权和（类似于线性回归）。
对这个和应用逻辑函数（也称为 Sigmoid 函数），它将任何实数映射到 0 和 1 之间的值。
将此值解释为属于正类的概率。
使用阈值（通常是 0.5）做出最终的分类决策。

对于我们的高尔夫数据集，逻辑回归可能会将天气因素合并为一个单一的分数，然后将此分数转换为打高尔夫的概率。

训练步骤

逻辑回归的训练过程涉及为输入特征找到最佳的权重。以下是一般的步骤概述：

初始化权重（通常为小的随机值）。

# Initialize weights (including bias) to 0.1
initial_weights = np.full(X_train_np.shape[1], 0.1)

# Create and display DataFrame for initial weights
print(f"Initial Weights: {initial_weights}")

2. 对于每个训练示例：

a. 使用当前的权重计算预测概率。

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def calculate_probabilities(X, weights):
    z = np.dot(X, weights)
    return sigmoid(z)

def calculate_log_loss(probabilities, y):
    return -y * np.log(probabilities) - (1 - y) * np.log(1 - probabilities)

def create_output_dataframe(X, y, weights):
    probabilities = calculate_probabilities(X, weights)
    log_losses = calculate_log_loss(probabilities, y)

    df = pd.DataFrame({
        'Probability': probabilities,
        'Label': y,
        'Log Loss': log_losses
    })

    return df

def calculate_average_log_loss(X, y, weights):
    probabilities = calculate_probabilities(X, weights)
    log_losses = calculate_log_loss(probabilities, y)
    return np.mean(log_losses)

# Convert X_train and y_train to numpy arrays for easier computation
X_train_np = X_train.to_numpy()
y_train_np = y_train.to_numpy()

# Add a column of 1s to X_train_np for the bias term
X_train_np = np.column_stack((np.ones(X_train_np.shape[0]), X_train_np))

# Create and display DataFrame for initial weights
initial_df = create_output_dataframe(X_train_np, y_train_np, initial_weights)
print(initial_df.to_string(index=False, float_format=lambda x: f"{x:.6f}"))
print(f"\nAverage Log Loss: {calculate_average_log_loss(X_train_np, y_train_np, initial_weights):.6f}")

b. 通过计算其对数损失，将该概率与实际类别标签进行比较。

3. 更新权重以最小化损失（通常使用一些优化算法，如梯度下降。这包括反复进行步骤 2，直到对数损失无法进一步减小）。

def gradient_descent_step(X, y, weights, learning_rate):
    m = len(y)
    probabilities = calculate_probabilities(X, weights)
    gradient = np.dot(X.T, (probabilities - y)) / m
    new_weights = weights - learning_rate * gradient  # Create new array for updated weights
    return new_weights

# Perform one step of gradient descent (one of the simplest optimization algorithm)
learning_rate = 0.1
updated_weights = gradient_descent_step(X_train_np, y_train_np, initial_weights, learning_rate)

# Print initial and updated weights
print("\nInitial weights:")
for feature, weight in zip(['Bias'] + list(X_train.columns), initial_weights):
    print(f"{feature:11}: {weight:.2f}")

print("\nUpdated weights after one iteration:")
for feature, weight in zip(['Bias'] + list(X_train.columns), updated_weights):
    print(f"{feature:11}: {weight:.2f}")

# With sklearn, you can get the final weights (coefficients)
# and final bias (intercepts) easily.
# The result is almost the same as doing it manually above.

from sklearn.linear_model import LogisticRegression

lr_clf = LogisticRegression(penalty=None, solver='saga')
lr_clf.fit(X_train, y_train)

coefficients = lr_clf.coef_
intercept = lr_clf.intercept_

y_train_prob = lr_clf.predict_proba(X_train)[:, 1]
loss = -np.mean(y_train * np.log(y_train_prob) + (1 - y_train) * np.log(1 - y_train_prob))

print(f"Weights & Bias Final: {coefficients[0].round(2)}, {round(intercept[0],2)}")
print("Loss Final:", loss.round(3))

分类步骤

一旦模型训练完成：

1. 对于新实例，使用最终权重（也称为系数）计算概率，就像训练步骤中一样。

2. 通过查看概率来解释输出：如果 p ≥ 0.5，预测为类别 1；否则，预测为类别 0

# Calculate prediction probability
predicted_probs = lr_clf.predict_proba(X_test)[:, 1]

z_values = np.log(predicted_probs / (1 - predicted_probs))

result_df = pd.DataFrame({
    'ID': X_test.index,
    'Z-Values': z_values.round(3),
    'Probabilities': predicted_probs.round(3)
}).set_index('ID')

print(result_df)

# Make predictions
y_pred = lr_clf.predict(X_test)
print(y_pred)

评估步骤

result_df = pd.DataFrame({
    'ID': X_test.index,
    'Label': y_test,
    'Probabilities': predicted_probs.round(2),
    'Prediction': y_pred,
}).set_index('ID')

print(result_df)

关键参数

逻辑回归有几个重要的参数来控制其行为：

1.惩罚项：使用的正则化类型（‘l1’，‘l2’，‘elasticnet’ 或 ‘none’）。逻辑回归中的正则化通过在模型的损失函数中加入惩罚项，防止过拟合，并鼓励简化模型。

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

regs = [None, 'l1', 'l2']
coeff_dict = {}

for reg in regs:
    lr_clf = LogisticRegression(penalty=reg, solver='saga')
    lr_clf.fit(X_train, y_train)
    coefficients = lr_clf.coef_
    intercept = lr_clf.intercept_
    predicted_probs = lr_clf.predict_proba(X_train)[:, 1]
    loss = -np.mean(y_train * np.log(predicted_probs) + (1 - y_train) * np.log(1 - predicted_probs))
    predictions = lr_clf.predict(X_test)
    accuracy = accuracy_score(y_test, predictions)

    coeff_dict[reg] = {
        'Coefficients': coefficients,
        'Intercept': intercept,
        'Loss': loss,
        'Accuracy': accuracy
    }

for reg, vals in coeff_dict.items():
    print(f"{reg}: Coeff: {vals['Coefficients'][0].round(2)}, Intercept: {vals['Intercept'].round(2)}, Loss: {vals['Loss'].round(3)}, Accuracy: {vals['Accuracy'].round(3)}")

2.正则化强度（C）：控制拟合训练数据与保持模型简洁之间的权衡。较小的 C 意味着更强的正则化。

# List of regularization strengths to try for L1
strengths = [0.001, 0.01, 0.1, 1, 10, 100]

coeff_dict = {}

for strength in strengths:
    lr_clf = LogisticRegression(penalty='l1', C=strength, solver='saga')
    lr_clf.fit(X_train, y_train)

    coefficients = lr_clf.coef_
    intercept = lr_clf.intercept_

    predicted_probs = lr_clf.predict_proba(X_train)[:, 1]
    loss = -np.mean(y_train * np.log(predicted_probs) + (1 - y_train) * np.log(1 - predicted_probs))
    predictions = lr_clf.predict(X_test)

    accuracy = accuracy_score(y_test, predictions)

    coeff_dict[f'L1_{strength}'] = {
        'Coefficients': coefficients[0].round(2),
        'Intercept': round(intercept[0],2),
        'Loss': round(loss,3),
        'Accuracy': round(accuracy*100,2)
    }

print(pd.DataFrame(coeff_dict).T)

# List of regularization strengths to try for L2
strengths = [0.001, 0.01, 0.1, 1, 10, 100]

coeff_dict = {}

for strength in strengths:
    lr_clf = LogisticRegression(penalty='l2', C=strength, solver='saga')
    lr_clf.fit(X_train, y_train)

    coefficients = lr_clf.coef_
    intercept = lr_clf.intercept_

    predicted_probs = lr_clf.predict_proba(X_train)[:, 1]
    loss = -np.mean(y_train * np.log(predicted_probs) + (1 - y_train) * np.log(1 - predicted_probs))
    predictions = lr_clf.predict(X_test)
    accuracy = accuracy_score(y_test, predictions)

    coeff_dict[f'L2_{strength}'] = {
        'Coefficients': coefficients[0].round(2),
        'Intercept': round(intercept[0],2),
        'Loss': round(loss,3),
        'Accuracy': round(accuracy*100,2)
    }

print(pd.DataFrame(coeff_dict).T)

3.求解器：用于优化的算法（‘liblinear’，‘newton-cg’，‘lbfgs’，‘sag’，‘saga’）。某些正则化可能需要特定的算法。

4.最大迭代次数：求解器收敛的最大迭代次数。

对于我们的高尔夫数据集，我们可能以‘l2’惩罚项、‘liblinear’求解器和 C=1.0 作为基准进行尝试。

优点与缺点

像机器学习中的任何算法一样，逻辑回归也有其优点和局限性。

优点：

简单性：易于实现和理解。
可解释性：权重直接显示每个特征的重要性。
效率：不需要过多的计算能力。
概率输出：提供概率而不仅仅是分类。

缺点：

线性假设：假设特征与结果的对数几率之间存在线性关系。
特征独立性：假设特征之间没有高度相关性。
有限的复杂性：在决策边界高度非线性的情况下，可能出现欠拟合。
需要更多数据：需要相对较大的样本量以获得稳定的结果。

在我们的高尔夫示例中，逻辑回归可能提供一个清晰、可解释的模型，说明每个天气因素如何影响打高尔夫的决策。然而，如果决策涉及天气条件之间的复杂交互，无法通过线性模型捕捉，那么它可能会遇到困难。

最后备注

逻辑回归作为一种强大而简洁的分类工具脱颖而出。它的优势在于能够处理复杂数据的同时保持易于解释。与一些其他基础模型不同，它提供平滑的概率估计，并且能很好地处理多个特征。在现实世界中，从预测客户行为到医学诊断，逻辑回归往往表现出惊人的效果。它不仅仅是一个过渡工具——它是一个可靠的模型，在许多情况下能与更复杂的模型匹敌。

🌟 逻辑回归代码总结

# Import required libraries
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score

# Load the dataset
dataset_dict = {
    'Outlook': ['sunny', 'sunny', 'overcast', 'rainy', 'rainy', 'rainy', 'overcast', 'sunny', 'sunny', 'rainy', 'sunny', 'overcast', 'overcast', 'rainy', 'sunny', 'overcast', 'rainy', 'sunny', 'sunny', 'rainy', 'overcast', 'rainy', 'sunny', 'overcast', 'sunny', 'overcast', 'rainy', 'overcast'],
    'Temperature': [85.0, 80.0, 83.0, 70.0, 68.0, 65.0, 64.0, 72.0, 69.0, 75.0, 75.0, 72.0, 81.0, 71.0, 81.0, 74.0, 76.0, 78.0, 82.0, 67.0, 85.0, 73.0, 88.0, 77.0, 79.0, 80.0, 66.0, 84.0],
    'Humidity': [85.0, 90.0, 78.0, 96.0, 80.0, 70.0, 65.0, 95.0, 70.0, 80.0, 70.0, 90.0, 75.0, 80.0, 88.0, 92.0, 85.0, 75.0, 92.0, 90.0, 85.0, 88.0, 65.0, 70.0, 60.0, 95.0, 70.0, 78.0],
    'Wind': [False, True, False, False, False, True, True, False, False, False, True, True, False, True, True, False, False, True, False, True, True, False, True, False, False, True, False, False],
    'Play': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No', 'No', 'Yes', 'Yes', 'No', 'No', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No', 'Yes']
}
df = pd.DataFrame(dataset_dict)

# Prepare data: encode categorical variables
df = pd.get_dummies(df, columns=['Outlook'],  prefix='', prefix_sep='', dtype=int)
df['Wind'] = df['Wind'].astype(int)
df['Play'] = (df['Play'] == 'Yes').astype(int)

# Split data into training and testing sets
X, y = df.drop(columns='Play'), df['Play']
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.5, shuffle=False)

# Scale numerical features
scaler = StandardScaler()
float_cols = X_train.select_dtypes(include=['float64']).columns
X_train[float_cols] = scaler.fit_transform(X_train[float_cols])
X_test[float_cols] = scaler.transform(X_test[float_cols])

# Train the model
lr_clf = LogisticRegression(penalty='l2', C=1, solver='saga')
lr_clf.fit(X_train, y_train)

# Make predictions
y_pred = lr_clf.predict(X_test)

# Evaluate the model
print(f"Accuracy: {accuracy_score(y_test, y_pred)}")

进一步阅读

关于逻辑回归及其在 scikit-learn 中的实现，读者可以参考官方文档[2]，该文档提供了关于其使用和参数的全面信息。

技术环境

本文使用 Python 3.7 和 scikit-learn 1.5 版本。虽然所讨论的概念一般适用，但具体的代码实现可能会因版本不同而略有差异。

关于插图

除非另有说明，所有图片均由作者创作，采用了来自 Canva Pro 的授权设计元素。

获取简洁的视觉总结，请查看Instagram 相关帖子。

参考文献

[1] T. M. Mitchell, 机器学习（1997），McGraw-Hill 科学/工程/数学，第 59 页

𝙎𝙚𝙚 𝙢𝙤𝙧𝙚 𝘾𝙡𝙖𝙨𝙨𝙞𝙛𝙞𝙘𝙖𝙩𝙞𝙤𝙣 𝘼𝙡𝙜𝙤𝙧𝙞𝙩𝙝𝙢𝙨 𝙝𝙚𝙧𝙚:

分类算法

查看列表8 个故事！

𝙔𝙤𝙪 𝙢𝙞𝙜𝙝𝙩 𝙖𝙡𝙨𝙤 𝙡𝙞𝙠𝙚:

回归算法

查看列表5 个故事！一个戴着粉色帽子的双马尾卡通娃娃。这个“假人”娃娃，通过其基本的设计和心形装饰的衬衫，直观地呈现了机器学习中“假回归器”的概念。就像这个玩具般的形象是一个简化、静态的人的代表一样，假回归器是作为基准的基本模型，用于更复杂的分析。

集成学习

查看列表4 个故事！

长格式视频表示学习（第一部分：视频作为图）

原文：towardsdatascience.com/long-form-video-representation-learning-part-1-video-as-graphs-c55b609d9100?source=collection_archive---------7-----------------------#2024-05-14

我们探索了具备长格式推理能力的新型视频表示方法。第一部分着重讨论视频作为图的表示，以及如何为多个下游应用学习轻量级的图神经网络。第二部分聚焦于稀疏视频-文本变换器。而第三部分则展示了我们最新最前沿的探索。

Subarna Tripathi

·发布于Towards Data Science ·10 分钟阅读·2024 年 5 月 14 日

现有的视频架构在处理视频内容的几秒钟后往往会遇到计算或内存瓶颈。那么，我们如何实现准确高效的长格式视觉理解呢？一个重要的第一步是拥有一个能在长视频上实际运行的模型。为此，我们探索了具备长格式推理能力的新型视频表示方法。

什么是长格式推理，为什么要进行长格式推理？

正如我们看到的，基于图像的理解任务随着深度学习模型（如卷积神经网络或变换器）取得了巨大成功，下一步自然就是超越静态图像，探索视频理解。开发视频理解模型需要两个同样重要的关注领域。首先是大规模的视频数据集，其次是用于高效提取视频特征的可学习骨干网络。即使设计者和标注者都有最好的意图，为动态信号（如视频）创建更细粒度且一致的注释也并非易事。自然，创建的大型视频数据集采用了相对更简单的方法，即在整个视频层面进行标注。至于第二个关注点，再次自然地将基于图像的模型（如 CNN 或变换器）扩展到视频理解中，因为视频被视为一系列视频帧的集合，每一帧的大小和形状都与图像相同。研究人员制作了使用采样帧作为输入的模型，而不是使用所有视频帧，这显然是为了节省内存。在具体应用中，当分析一个 5 分钟的视频片段，且视频帧率为 30 帧/秒时，我们需要处理 9,000 帧视频。若涉及到对每个视频帧提取 16x16 矩形块的密集计算，CNN 或变换器都无法处理 9,000 帧的序列。因此，大多数模型的操作方式是：它们将一个短视频片段作为输入，进行预测，然后进行时间平滑，而不是理想情况下我们希望模型能够完整地观看视频。

现在提出这个问题。如果我们需要知道一个视频是“游泳”类型还是“网球”类型，是否真的需要分析一分钟的内容？答案显然是否定的。换句话说，优化用于视频识别的模型，很可能学会了查看背景和其他空间上下文信息，而不是学习推理一个“长”视频中实际发生的事情。我们可以将这种现象称为学习空间捷径。这些模型在视频识别任务中表现良好。那么你能猜到这些模型在需要实际时间推理的其他任务（如动作预测、视频问答和最近提出的情节记忆任务）中如何表现吗？由于它们没有经过时间推理训练，因此它们在这些应用中的表现并不好。

所以我们理解到，数据集/注释使得大多数视频模型无法学习如何在时间和动作序列上进行推理。随着时间的推移，研究人员意识到了这个问题，并开始提出不同的基准来解决长时间推理问题。然而，仍然存在一个问题，主要是由内存限制引起的，即我们如何迈出第一步，让模型能够接受一段长视频作为输入，而不是将多个短片段依次处理。为了解决这个问题，我们提出了一种基于时空图学习（Spatio-Temporal Graphs Learning，简称 SPELL）的视频表示方法，以赋予模型长时间推理的能力。

视频作为时间图

设 G = (V, E)为一个图，其中 V 为节点集，E 为边集。对于社交网络、引用网络和分子结构等领域，V 和 E 是系统所提供的，我们称图作为输入提供给可学习的模型。现在，考虑视频中的最简单情况，其中每一帧视频被视为一个节点，形成 V。然而，目前尚不清楚节点 t1（时间=t1 时的帧）和节点 t2（时间=t2 时的帧）是如何连接的。因此，边集 E 没有提供。没有 E，图的拓扑结构就不完整，导致“真实值”图的不可用。一个重要的挑战依然是如何将视频转换为图。由于数据集中没有这样的标注（或“真实值”）图，所以该图可以被视为潜在图。

当视频被建模为时间图时，许多视频理解问题可以被表述为节点分类或图分类问题。我们利用 SPELL 框架来处理诸如动作边界检测、时间动作分割、视频摘要/高亮回放检测等任务。

视频摘要：表述为节点分类问题

在这里，我们提出了这样一个框架，称为 VideoSAGE，代表视频摘要与图表示学习。我们利用视频作为时间图的方法，通过该框架生成视频亮点集锦。首先，我们将输入的视频转换为图，其中每个节点对应视频的每一帧。然后，我们通过仅连接那些在指定时间距离内的节点对来对图施加稀疏性。接着，我们将视频摘要任务表述为一个二元节点分类问题，精确地对视频帧进行分类，判断它们是否应属于输出的摘要视频。以这种方式构建的图（如图 1 所示）旨在捕捉视频帧之间的长程交互，而稀疏性确保了模型在训练时不会遇到内存和计算瓶颈。对两个数据集（SumMe 和 TVSum）进行的实验表明，与现有的最先进的摘要方法相比，所提出的高效模型在计算时间和内存使用上提高了一个数量级的效率。

(图片来源：作者) 图 1：VideoSAGE 从输入视频构建图，每个节点编码一帧。我们将视频摘要问题表述为一个二元节点分类问题。

下表展示了我们方法（即 VideoSAGE）在性能和客观评分上的对比结果。这篇论文最近已被 CVPR 2024 工作坊接受。论文详细信息和更多结果请见此处。

(图片来源：作者) 表 1：（左）与 SOTA 方法在 SumMe 和 TVSum 数据集上的比较，（右）使用 A2Summ、PGL-SUM 和 VideoSAGE 进行推理分析。

动作分割：作为一个节点分类问题进行表述

同样地，我们也将动作分割问题作为在这种从输入视频构建的稀疏图中的节点分类问题。GNN 结构与上面类似，唯一的区别是最后一层 GNN 使用的是图注意力网络（GAT），而不是视频摘要中使用的 SageConv。我们在 50-Salads 数据集上进行了实验。我们利用 MSTCN 或 ASFormer 作为第一阶段的初始特征提取器。接下来，我们利用我们的稀疏双向 GNN 模型，该模型利用并行的时间“前向”和“后向”局部消息传递操作。GNN 模型进一步优化了我们系统的最终细粒度每帧动作预测。有关结果，请参阅表 2。

(图片来源：作者) 表 2：在 50-Salads 数据集上进行的动作分割结果，评估指标为 F1@0.1 和准确率。

视频作为“面向对象”的时空图

在这一部分，我们将描述如何采用类似的基于图的方式，其中节点表示“对象”而不是整个视频帧。我们将从一个具体的示例开始，来描述时空图方法。

(图由作者提供) 图 2：我们将视频从视听输入数据转换为标准图，其中每个节点对应于帧中的一个人，边表示节点之间的空间或时间交互。构建的图足够稠密，可以通过跨越时间上远离但相关的节点进行信息传递，来建模长期依赖关系，但又足够稀疏，可以在低内存和计算预算下处理。ASD 任务被设定为这个长范围时空图中的二元节点分类任务。

主动说话人检测：任务被表述为节点分类

图 2 展示了我们为主动说话人检测（ASD）任务设计的框架概览。通过将视听数据作为输入，我们构建了一个多模态图，并将 ASD 转化为一个图节点分类任务。图 3 展示了图的构建过程。首先，我们创建一个图，其中每个节点对应于每帧中的一个人，边表示它们之间的空间或时间关系。初始节点特征是通过简单且轻量级的二维卷积神经网络（CNN）构建的，而不是复杂的 3D CNN 或 Transformer。接下来，我们在这个图的每个节点上执行二分类节点分类，即活跃或非活跃说话人——通过学习一个轻量级的三层图神经网络（GNN）。图是专门为编码不同面部身份之间的空间和时间依赖关系而构建的。因此，GNN 可以利用这一图结构来建模语音中的时间连续性，以及长期的时空上下文，同时需要较低的内存和计算。

你可能会问，为什么图的构建方式是这样的？这就是领域知识的影响所在。之所以在同一时间距离内，具有相同面部 ID 的节点会相互连接，是为了模拟现实世界中的场景：如果一个人在 t=1 时在拍摄，而同一个人在 t=5 时在讲话，那么很有可能他在 t=2、t=3、t=4 时也在讲话。为什么我们要将不同的面部 ID 连接在一起，如果它们共享相同的时间戳？这是因为一般来说，如果一个人在讲话，其他人更可能在听。如果我们将所有节点彼此连接，使得图变得稠密，模型不仅需要巨大的内存和计算资源，而且还会变得嘈杂。

我们在 AVA-ActiveSpeaker 数据集上进行了广泛的实验。结果表明，SPELL 优于所有先前的最先进（SOTA）方法。得益于所构建图谱的稀疏性（约 95%），与当时领先的 SOTA 方法之一 ASDNet（48.6M #Params）相比，SPELL 在视觉特征编码时需要显著更少的硬件资源（11.2M #Params）。

(作者提供的图片) 图 3：（a）：我们图谱构建过程的示意图。上面的框架按时间顺序从左到右排列。蓝色、红色和黄色三种颜色表示框架中存在的三种身份。图中的每个节点对应框架中的每个面孔。SPELL 通过无向边连接同一框架中不同身份的面孔。SPELL 还通过前向/后向/无向边跨框架连接相同身份的面孔（由超参数τ控制）。在这个示例中，相同的身份通过前向边跨框架连接，前向边是有向的，仅朝时间前进的方向延伸。（b）：创建后向图和无向图的过程是相同的，唯一的不同是在前者的情况下，相同身份的边缘朝相反方向延伸，而在后者的情况下则没有有向边。每个节点还包含音频信息，但此处未显示。

时间上下文的长度是多少？

请参阅下方的图 4，展示了我们的方法在两个不同应用中的时间上下文。

SPELL 中的超参数τ（在我们的实验中为 0.9 秒）对跨时间距离较远的节点之间的直接连接施加了额外的约束。连续时间戳之间的面孔身份始终是相互连接的。以下是 SPELL 的有效时间上下文大小估算。AVA-ActiveSpeaker 数据集包含 365 万帧和 530 万标注面孔，导致每帧 1.45 个面孔。平均每帧 1.45 个面孔，一个按时间顺序排序的包含 500 到 2000 个面孔的图谱可以跨越 345 到 1379 帧，相当于 25 帧/秒视频中的 13 到 55 秒。换句话说，图中的节点可能存在大约 1 分钟的时间差，而 SPELL 能够在有限的内存和计算预算下有效地推理这一长期时间窗口。值得注意的是，MAAS中的时间窗口大小为 1.9 秒，TalkNet 使用最多 4 秒的长期序列级时间上下文。

关于用于活跃说话者检测的时空图的工作已在 ECCV 2022 上发表。手稿可以在这里找到。我们在之前的博客中提供了更多细节。

(作者提供的图像) 图 4：左图和右图分别展示了我们方法在活跃说话者检测和动作检测应用中的时间支持对比。

动作检测：任务形式为节点分类

Ava 活跃说话者数据集中的 ASD 问题设置可以访问标注的面孔和标注的面部轨迹，作为问题设置的输入。这在很大程度上简化了图的构建，特别是在节点和边的识别方面。对于其他问题，例如动作检测（Action Detection），由于没有提供地面真相的物体（人）位置和轨迹，我们使用预处理来检测物体和物体轨迹，然后利用 SPELL 来进行节点分类问题。类似于之前的情况，我们利用领域知识构建稀疏图。首先构建“面向物体”的图，始终保持底层应用的目标。

平均而言，我们实现了约 90% 的稀疏图；这一点与依赖于密集通用矩阵乘法（GEMM）操作的视觉 transformer 方法有显著区别。我们的稀疏 GNN 使我们能够 (1) 实现比 transformer 方法更好的性能；(2) 在与 transformer 方法相比的 10 倍更长的时间窗口（100 秒 vs 10 秒）中聚合时间上下文；以及 (3) 相比于 transformer 方法节省 2 到 5 倍的计算资源。

GraVi-T：开源软件库

我们已经开源了我们的软件库 GraVi-T。目前，GraVi-T 支持多种视频理解应用，包括活跃说话者检测、动作检测、时间分割、视频摘要等。请查看我们的开源软件库GraVi-T了解更多应用。

亮点

与 transformers 相比，我们的图方法可以在 10 倍更长的视频上聚合上下文，消耗约 10 倍更少的内存和 5 倍更低的 FLOPs。我们在这个主题（活跃说话者检测）上的首个主要工作已发表于 ECCV’22。请关注我们即将在即将召开的 CVPR 2024 上发布的关于视频摘要（即视频高亮集锦创建）的最新成果。

我们将视频建模为稀疏图的方法在多个应用中超越了复杂的 SOTA 方法，并在多个排行榜中名列前茅。包括 2022 年 ActivityNet，2022 年 ECCV 的 Ego4D 音频-视频分割挑战赛，2023 年 CVPR 等赛事。用于训练过去挑战赛获胜模型的源代码也包含在我们的开源软件库GraVi-T中。

我们对这个通用、轻量级且高效的框架充满期待，并正在朝着其他新应用方向努力。更多令人兴奋的消息即将发布！！！

长篇视频表示学习（第二部分：视频作为稀疏 Transformer）

原文：towardsdatascience.com/long-form-video-representation-learning-part-2-video-as-sparse-transformers-29fbd0ed9e71?source=collection_archive---------9-----------------------#2024-05-14

我们探索了具备长篇推理能力的新型视频表示方法。这是第二部分，重点介绍稀疏视频-文本 Transformer。请参见关于视频作为图的第一部分。而第三部分提供了我们最新研究成果的预览。

Subarna Tripathi

·发布于Towards Data Science ·6 分钟阅读·2024 年 5 月 14 日

本系列的第一篇博客介绍了用于“长篇”视频表示学习的显式稀疏图表示方法。这些方法是有效的；然而，它们不能进行端到端的训练。我们需要依赖其他基于 CNN 或 Transformer 的特征提取器来生成初始的节点嵌入。在本篇博客中，我们的重点是使用 Transformer 设计端到端的方法，但目标依然是实现“长篇”推理。

稀疏视频-文本 Transformer

作为一种端到端可学习的架构，我们开始探索 transformers。我们首先需要解答的问题是：视频-文本 transformer 是否能学习跨帧建模时序关系？我们观察到，尽管视频模型具有巨大的容量和丰富的多模态训练数据，最近的视频模型仍然表现出强烈的基于帧的空间表示倾向，而时序推理依然未得到有效解决。例如，如果我们打乱输入视频模型的帧顺序，输出几乎没有变化！

图片由作者提供

经过进一步调查，我们发现将多帧推理融入视频语言模型面临几个关键挑战。首先，有限的模型规模意味着空间和时间学习之间需要做出权衡（经典例子是视频 CNN 中的 2D/3D 卷积）。对于任何给定的数据集，最佳性能需要在二者之间找到微妙的平衡。其次，长时段视频模型通常具有更大的模型规模，并且更容易发生过拟合。因此，对于长视频模型，仔细分配参数和控制模型增长变得尤为重要。最后，即便扩展片段长度能改善结果，它也会面临收益递减的问题，因为视频片段所提供的信息量并不会随着采样率的增加而线性增长。如果不控制模型规模，计算量的增加可能无法抵消准确率提升带来的收益。这对基于 transformer 的架构尤为重要，因为自注意力机制的内存和时间成本是输入长度的二次方。

总之，模型复杂度应该根据输入视频自适应调整，以实现空间表示、时间表示、过拟合潜力和复杂性之间的最佳平衡。由于现有的视频-文本模型缺乏这种能力，它们要么在空间和时间建模之间达成次优平衡，要么根本没有学习到有意义的时间表示。

视频 transformers 中可以“稀疏化”的是什么？节点和边：

我们认为，视频-文本模型应学习将建模资源分配给视频数据。与其均匀地扩展模型至更长的片段，不如将这些资源分配到视频的相关时空位置，这对于从长片段中高效学习至关重要。对于 transformer 模型，这种资源分配通过修剪冗余的注意力连接自然而然地实现。我们通过探索 transformer 稀疏化技术来实现这些目标。这促使我们提出了受图模型启发的稀疏视频-文本 Transformer（SViTT）。如图 1 所示，SViTT 将视频标记视为图的顶点，自注意力模式视为连接它们的边。

我们设计了 SViTT，旨在实现节点和边缘的稀疏性：节点稀疏性通过识别信息丰富的标记（例如，表示前景中移动物体或人的标记）并剪枝背景特征嵌入来实现；边缘稀疏性则旨在减少注意力模块中的查询-键对，同时保持其全局推理能力。为了解决长输入片段的回报递减问题，我们提出通过时间稀疏扩展进行训练，采用课程学习策略，在每个训练阶段同步增加片段长度和模型稀疏性。

（作者提供的图片）图 2：（作者提供的图片）我们展示以下定性结果

结果：（1）左侧：一个训练样本包括描述（顶部的句子）和视频片段（视频的帧序列），（2）中间：视觉标记剪枝后的视频编码器的第 10 层；（3）右侧：多模态编码器在标记剪枝后的输出。

应用、评估与结果

SViTT 在多种视频-文本基准测试中进行了评估，从视频检索到问答任务，比较了先前的研究成果和我们自己的稠密模型基准。首先，我们进行了一系列消融研究，以了解稀疏建模在变换器中的优势。有趣的是，我们发现，在推理时，节点（标记）和边缘（注意力）可以大幅度剪枝，而对测试性能的影响很小。实际上，使用跨模态注意力进行的标记选择，在不重新训练的情况下，能使检索结果提高 1%。图 2 显示，SViTT 将信息丰富的区域从背景区域中分离出来，以促进高效的时间推理。

接下来，我们使用稀疏模型进行完整的预训练，并评估其下游性能。我们观察到，SViTT 在处理较长输入片段时表现良好，而稠密变换器在此时由于优化困难，准确率下降。在所有视频-文本基准测试中，SViTT 相较于稠密模型以更低的计算成本报告了可比或更好的性能，超过了包括那些使用额外图像-文本语料库训练的先前方法。

作者提供的图片

从上面的表格中，我们可以看到，通过稀疏化，立即的时间上下文聚合可以延长 2 倍（表 2）。还可以看到稀疏化如何维持最终任务的准确性（表 1），甚至有所提升。

作者提供的图片

在上述表格中，我们展示了我们提出的训练范式如何通过不同稀疏级别来帮助提高任务性能。在表 4 中，您可以看到在两个标准基准上进行的文本到视频检索任务的零-shot 性能。

作者提供的图片

最后，我们展示了在多模态检索和视频问答的不同基准上获得的结果。SViTT 超越了所有现有方法，甚至需要的预训练对数更少。

关于 SViTT 的更多细节可以在这里找到。总结来说，与原始的 transformers 相比，SViTT 的效率提高了 6 到 7 倍，能够实现 2 倍的上下文聚合。使用 SViTT 进行预训练，在 5 个基准任务（如检索、视频问答）上提高了准确性，超越了现有的最先进技术（SoTA）。

SViTT-Ego 用于以自我为中心的视频：

预训练以自我为中心的视觉-语言模型已成为提升下游自我中心视频-文本任务的关键。这些自我中心的基础模型通常使用 transformer 架构。这些模型在预训练期间的内存占用可能相当庞大。因此，我们预训练了我们自己的稀疏视频-文本 transformer 模型 SViTT-Ego，这是第一个集成边缘和节点稀疏化的稀疏自我中心视频-文本 transformer 模型。我们在EgoClip数据集上进行预训练，并引入了自我中心友好的目标 EgoNCE，而不是常用的 InfoNCE。最显著的是，SViTT-Ego 在 EgoMCQ（视频内）准确度上相比当前的最先进技术提高了 2.8%，且没有使用除标准图像增强外的额外数据增强技术，同时能够在内存有限的设备上进行预训练。以下展示了一个视觉示例。我们正在准备参加 CVPR 上的 EgoVis 研讨会，展示我们的 SViTT-Ego。

（图像由作者提供）图 3：来自 Huggingface 演示的 EgoMCQ 截图

（图像由作者提供）表 7：SViTT-Ego 在所有最先进的模型上表现优异

视频内准确度。考虑到仅在

3.8M 个样本没有叙述增强，SViTT-Ego 在

在视频间和视频内准确度上，所有模型均表现出色

（图像由作者提供）图 5：给定 qv = 0.7，我们展示了以下定性结果

使用视觉编码器的结果：第 1 行，显示 4 帧输入；第 2 行

图 2，显示视频编码器的第 4 层在视觉标记修剪后的情况；第 3 行，

显示视频编码器的第 7 层在视觉标记修剪后的情况；以及第 3 行

图 4，显示视频编码器的第 10 层在视觉标记修剪后的情况。我们

使用 SViTT 来修剪视觉标记

亮点：

我们提出了SViTT，一种视频-文本架构，统一了边缘和节点稀疏性；我们展示了它在视频语言任务中的时间建模效果。与原始的 transformer 相比，SViTT的效率提高了 6 到 7 倍，能够实现 2 倍的上下文聚合。使用 SViTT 进行预训练，在 5 个基准任务上（如检索、视频问答）提高了准确性，超越了当前的最先进技术（SoTA）。我们的稀疏视频-文本 transformer 工作首次发表于CVPR 2023。

接下来，我们展示了如何利用这种稀疏变换器进行自我中心视频理解应用。我们展示了SViTT-Ego（基于 SViTT 构建）在 EgoMCQ 任务中相较于密集变换器基准表现更好，并且由于固有的稀疏性，峰值内存和计算需求显著更低。这表明像SViTT-Ego这样的稀疏架构是一个潜在的基础模型选择，特别是在内存受限设备上的预训练。请关注即将发布的激动人心的消息！

长时视频表示学习（第三部分：长时自我中心视频表示学习）

原文：towardsdatascience.com/long-form-video-representation-learning-part-3-latest-and-greatest-in-long-form-video-1b6dee0f5f6e?source=collection_archive---------11-----------------------#2024-05-14

我们探索了具备长时推理能力的新型视频表示学习方法。这是第三部分，提供了我们关于“长时”自我中心视频表示学习的最新研究成果的预览。请参见第一部分，讲解视频作为图的内容，以及第二部分，介绍稀疏视频-文本转换器。

Subarna Tripathi

·发布于Towards Data Science ·8 分钟阅读·2024 年 5 月 14 日

本系列的前两篇博客描述了从图神经网络到稀疏转换器等不同架构模式如何应对“长时”视频表示学习的挑战。我们展示了显式基于图的方法如何聚合 5-10 倍更大的时间上下文，但它们是两阶段的方法。接下来，我们探索了如何基于转换器设计出既高效又能端到端学习的模型，并能聚合 2 倍以上更大的时间上下文。

在这篇博客中，我将带你走进我们最新最伟大的探索，特别是关于自我中心视频理解的部分。正如你所能想象的，自我中心视频或第一人称视频（通常通过头戴式相机拍摄）很可能来自于始终开启的相机，这意味着这些视频通常非常非常长，并且包含大量无关的视觉信息，尤其是在相机佩戴者移动头部时。而且，这种情况在头戴式相机中经常发生。对这类第一人称视频的适当分析可以帮助我们详细了解人类如何与环境互动，如何操作物体，以及最终，他们的目标和意图是什么。自我中心视觉系统的典型应用需要能够表示和处理视频的算法，这些视频的时间跨度通常在几分钟或几个小时之间。例如，行动预测、视频总结和情节记忆检索等应用。

自我中心行动场景图：

图 1：（图片由作者提供）自我中心行动场景图是时序动态图（G(t)），捕捉行动动词（蓝色节点）、直接或活跃物体（绿色节点）以及其他与相机佩戴者执行的活动相关的物体（黄色节点）。节点之间的边表示动词与物体之间的关系，或物体对之间的关系。该图随着时间发展，提供了自我中心视频的长时间段表示（虚线）。交互物体通过边界框进行定位

在与卡塔尼亚大学的联合研究中，我们提出了自我中心行动场景图（EASGs），这是一种用于长时间段理解自我中心视频的新表示方法。EASGs 通过提供一个基于图的时序描述，扩展了标准的手动注释自我中心视频表示，例如动词-名词行动标签，从而描述相机佩戴者执行的动作。该描述还包括交互的物体、它们之间的关系，以及动作如何随着时间展开。通过一种新的注释程序，我们扩展了 Ego4D 数据集，增加了手动标注的自我中心行动场景图，为长时间段的自我中心视频理解提供了丰富的注释集。

EASG 提供以动态图形式标注的视频片段。我们将 EASG 形式化为一个时间变化的有向图 G(t) = (V(t), E(t))，其中 V(t)是时间 t 时刻的节点集合，E(t)是这些节点之间的边的集合（见图 2）。图 G(t)的每一时刻表示一个跨越三帧的自我中心动作，这三帧定义如下[Ego4D]：前置条件（PRE）、不可回头点（PNR）和后置条件（POST）帧。因此，图 G(t)有效地与三帧关联：F(t) = {PREₜ, PNRₜ, POSTₜ}，如图 1 所示。

以自我为中心的场景图生成：

图 2 展示了一个详细的标注图示例。

作者提供的图片

我们通过利用来自 Ego4D 的现有标注，结合初始化和精炼过程，得到初始的 EASG。例如，我们从添加摄像机佩戴者节点、动词节点以及从摄像机佩戴者节点到动词节点的默认动作边开始。标注流程如图 3 所示。

作者提供的图片

接下来，我们通过三名标注者的输入对图进行精炼。验证阶段会汇总三名标注者收到的数据，并确保最终标注的质量，如下所示。

图 4（作者提供图片）：在验证阶段，针对标注者提出的问题示例（正确答案用红色标出），以解决标注中的歧义。

在标注阶段提供的标签。

如可以注意到的，EASG 数据集在其标签上具有独特性。下表展示了该新数据集与其他具有视觉关系的视频数据集在标签和大小方面的对比。

作者提供的图片：与现有的视频场景图数据集进行比较。我们的 Ego4D-EASG 数据集是唯一明确设计用于长格式自我中心视频理解的数据集，具有自我中心视频、动态图、平均序列长度为 3.1 分钟，以及每个序列平均 28.3 个图。*以对象-关系-对象三元组为单位测量。**不及物+及物动词谓词

上述视频直观地展示了一个标注用的 EASG 示例，它会随着视频内容的变化而动态变化。

在创建了这个独特的数据集之后，我们将描述在该数据集上评估的不同任务。第一组任务是生成动作场景图，源自图像场景图生成文献。换句话说，我们的目标是以监督方式学习 EASG 表示，并测量其在场景图文献中常用的标准 Recall 指标上的表现。我们设计了基准，并比较了不同基准在该数据集上的 EASG 生成表现。

（作者提供的图片）三项 EASG 生成任务（即 Edge Cls，SG Cls 和 EASG Cls）在 Recall@K 上的基准结果

使用 EASG 进行长篇理解任务：

我们展示了 EASG 表示在动作预测和活动摘要下游任务中的潜力。这两项任务都需要对以自我为中心的视频进行长篇推理，处理跨越不同时间步骤的长视频序列。根据最近的结果，展示了大型语言模型（LLMs）作为符号推理机器的灵活性，我们通过 OpenAI API 进行这些实验。实验旨在检查 EASG 表示的表达能力及其对下游应用的有用性。我们表明，EASG 提供了一种有效的方式来建模长篇活动，相比于广泛采用的金标准动词-名词动作编码，EASG 在自我中心视频社区中的表现更具优势。

使用 EASG 进行动作预测：

对于动作预测任务，我们使用 GPT3 的 text-davinci-003 模型。我们提示该模型从长度为 T ∈ {5，20}的序列中预测未来的动作。我们比较了两种表示——EASG 和动词-名词对序列。下表展示了此实验的结果。

作者提供的图片：动作预测任务的性能比较

即使是较短的 EASG 序列（T = 5）也往往超过较长的 V-N 序列（T = 20），这突显了 EASG 在与标准动词-名词表示相比时更强的表示能力。EASG 表示在长序列（T = 20）中取得了最佳结果。

使用 EASG 进行长篇活动摘要：

我们选择了 147 个 Ego4D-EASG 片段的子集，这些片段包含人类注释的摘要，描述了片段中执行的活动，并用 1 到 2 个句子总结。我们构建了三种类型的输入序列：图序列 S-EASG = [G(1)，G(2)，…，G(Tmax)]，动词-名词对序列 svn = [s-vn(1)，s-vn(2)，…，s-vn(Tmax)]，以及与 EASG 序列匹配的原始 Ego4D 叙述序列。最后一种输入用于参考，因为我们预计来自叙述的摘要将带来最佳的表现，考虑到语言模型对这种表示的自然偏好。

以下表格中报告的结果表明，相较于动词-名词序列输入，CIDEr 得分显著提高，表明处理 EASG 输入的模型能够捕捉详细的物体动作关系，从而生成更加具体、富有信息的句子，与参考描述高度契合。

作者提供的图片：使用 EASG 和动词-名词表示进行活动总结的结果

我们相信，这些贡献标志着在长篇自我中心视频理解方面迈出了重要的一步。

亮点：

我们提出了自我中心动作场景图（Egocentric Action Scene Graphs），这是一种用于长篇自我中心视频理解的新型表示方法；
我们通过一种新颖的注释程序，手动标注了 EASG 标签，并将其扩展到 Ego4D 数据集中；
我们提出了 EASG 生成基准，并提供了初步的基准结果；
我们展示了实验，突出了 EASG 表示在长篇自我中心视频理解中的有效性。我们将发布数据集和代码，以便复制数据注释过程；

实验；
我们将在下个月的CVPR 2024上展示这项工作。
论文：arxiv.org/abs/2312.03391 和代码：github.com/fpv-iplab/EASG

任务的时间定位：

近年来，自我中心视频-语言预训练（VLP）在学术界和工业界得到了广泛应用。一些研究工作，如EgoVLP、EgoVLPv2，从大规模视频-文本数据集中学习可转移的时空表示。最近，LaViLa证明了 VLP 可以受益于大型语言模型（LLMs）生成的密集叙述。然而，所有这些方法在处理视频序列时都会遇到内存和计算瓶颈，每个序列包含少量帧（例如 8 帧或 16 帧的模型），导致有限的时间上下文聚合能力。相反，我们的模型，称为LAVITI，具备长篇推理能力（1,000帧对比 16 帧），并且不受限于少量输入帧。

在这项正在进行的工作中，我们设计了一种新颖的方法，通过对比学习学习语言、视频和时间表示，用于长篇视频的处理。与现有方法不同，这种新方法旨在通过提取未剪辑视频中的有意义时刻，将语言、视频和时间特征对齐，并将其表述为一个直接的集合预测问题。LAVITI 在自我中心动作识别方面显著超过了现有的最先进方法，同时可以在内存和计算受限的系统上进行训练。我们的模型可以在 Ego4D 数据集上，仅用 8 个 NVIDIA RTX-3090 GPU，训练一天。

图片来自作者：在 CharadesEgo 上的表现。我们的方法在零-shot 和微调设置中均取得了显著的提升。ZS 和 FT 分别代表零-shot 和微调。

由于我们的模型能够进行具有显式时间对齐的长篇视频理解，Ego4D 自然语言查询（NLQ）任务与预训练目标非常契合。给定视频，我们可以直接预测与语言查询对齐的时间间隔；因此，LAVITI 可以

在零-shot 设置下执行 NLQ 任务（无需修改架构或重新训练 NLQ 注释）。

在不久的将来，我们计划评估其在学习改进的表征方面的潜力，尤其是在包括 NLQ 和 Moment Query (MQ) 在内的情节记忆任务中。总而言之，我们正在利用现有的基础模型（本质上是“短期”模型）来创建旨在进行 20 倍到 50 倍更大上下文聚合的“长篇”推理模块。

亮点：

我们设计了令人兴奋的新方法来进行自我中心的视频理解。我们的贡献是多方面的。

预训练目标通过提取未修剪视频中的有意义时刻，共同对齐语言、视频和时间特征；
将视频、语言和时间对齐问题表述为一个直接的集合预测问题；
以内存计算高效的方式，支持对视频中可能涉及的成千上万帧进行长篇推理；
通过其在 CharadesEgo 动作识别上的优越表现，展示了 LAVITI 的有效性；
支持零-shot 自然语言查询（NLQ）任务，而无需训练额外的子网络或 NLQ 注释。

关注这个新范式的“长篇”视频表示学习带来的更多激动人心的结果！

长短期记忆（LSTM）—— 改进 RNNs

原文：towardsdatascience.com/long-short-term-memory-lstm-improving-rnns-40323d1c05f8?source=collection_archive---------5-----------------------#2024-05-31

最先进的 RNNs 如何工作

Egor Howell

·发表于 Towards Data Science ·阅读时长 9 分钟 ·2024 年 5 月 31 日

"www.flaticon.com/free-icons/neural-network" 标题为“neural network icons”的图标由 Freepik 创建 — Flaticon。

在本文中，我们将介绍长短期记忆网络（LSTMs），它们是常规的 vanilla 循环神经网络（RNNs）的变种，在处理长期依赖问题上表现更好。

它们使用不同的“门”来记住或忘记它们认为对预测有用或不重要的信息。

LSTMs 是 RNNs 的最先进版本。它们在工业界被广泛使用，并构成了我们今天所见的所有大型语言模型（LLMs）的基础。

我们将首先回顾 RNNs，解释梯度消失和梯度爆炸问题，然后深入探讨 LSTMs 如何工作以及为何它们是更好的模型。

RNN 概述

循环神经网络（RNN）是常规前馈神经网络的变种，它们能够更好地处理自然语言和时间序列等序列数据。

它们通过拥有一个隐藏的循环神经元，将前一个输入和输出传递到下一层，从而实现这一点。下面是一个例子。

在你的苹果硅芯片 MacBook 上进行 LoRA 微调

原文：towardsdatascience.com/lora-fine-tuning-on-your-apple-silicon-macbook-432c7dab614a?source=collection_archive---------5-----------------------#2024-11-20

让我们一步步在你的 MacBook 上进行微调