投机采样 Speculative Decoding -- EAGLE

原创 于 2025-12-14 14:15:28 发布 · 751 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#人工智能 #深度学习 #自然语言处理 #语言模型 #transformer

文章目录

来源： 详细解释内容可参考 EAGLE投机采样

投机采样



import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 初始化模型和tokenizer
draft_model_name = "google/gemma-2b" # 选用一个轻量级模型
target_model_name = "meta-llama/Llama-2-7b-chat-hf" # 选用一个性能更好的模型

draft_model = AutoModelForCausalLM.from_pretrained(draft_model_name, device_map="auto")
target_model = AutoModelForCausalLM.from_pretrained(target_model_name, device_map="auto")

draft_tokenizer = AutoTokenizer.from_pretrained(draft_model_name)
target_tokenizer = AutoTokenizer.from_pretrained(target_model_name)

def speculative_decode(prompt, draft_model, target_model, draft_tokenizer, target_tokenizer, num_draft_tokens=5, acceptance_threshold=0.8):
    """
    简单的投机采样实现

    Args:
        prompt: 输入prompt (字符串)
        draft_model: Draft Model
        target_model: Target Model
        draft_tokenizer: Draft Model的tokenizer
        target_tokenizer: Target Model的tokenizer
        num_draft_tokens: Draft Model生成的token数量
        acceptance_threshold: 接受Draft token的概率阈值

    Returns:
        生成的文本 (字符串)
    """

    # 1. Draft 阶段
    draft_input = draft_tokenizer(prompt, return_tensors="pt").to(draft_model.device)
    draft_output = draft_model.generate(**draft_input, max_new_tokens=num_draft_tokens)
    draft_tokens = draft_output[:, draft_input['input_ids'].shape[-1]:]
    draft_text = draft_tokenizer.batch_decode(draft_tokens, skip_special_tokens=True)[0]

    # 2. Verify 阶段
    target_input = target_tokenizer(prompt, return_tensors="pt").to(target_model.device)
    target_logits = target_model(**target_input).logits
    initial_target_token = torch.argmax(target_logits[:, -1, :], dim=-1)  # 获取第一个token的预测

    accepted_tokens = [initial_target_token.item()]  # 存储接受的token, 初始化第一个token
    rejected_indices = []

    # 迭代验证Draft Model生成的token
    for i in range(num_draft_tokens):
        # 构建上下文，包含prompt和之前接受的token
        context_tokens = target_tokenizer(prompt, return_tensors="pt").to(target_model.device)['input_ids']
        context_tokens = torch.cat([context_tokens, torch.tensor([[accepted_tokens[j] for j in range(len(accepted_tokens))]])], dim=1)

        target_logits = target_model(**{"input_ids": context_tokens}).logits  # 注意使用context_tokens作为输入
        target_probs = torch.softmax(target_logits[:, -1, :], dim=-1)
        target_prob_for_draft_token = target_probs[0, draft_tokens[0, i]].item()

        if target_prob_for_draft_token >= acceptance_threshold:
            accepted_tokens.append(draft_tokens[0, i].item())
        else:
            rejected_indices.append(i)
            break # 一旦有token被拒绝，停止验证

    # 3. 生成剩余部分 (如果还有未验证的token)
    if rejected_indices:
        # 在被拒绝的token位置，使用Target Model生成新的token
        context_tokens = target_tokenizer(prompt, return_tensors="pt").to(target_model.device)['input_ids']
        context_tokens = torch.cat([context_tokens, torch.tensor([[accepted_tokens[j] for j in range(len(accepted_tokens))]])], dim=1)

        target_output = target_model.generate(**{"input_ids": context_tokens}, max_new_tokens=1)  # 生成一个新token
        new_token = target_output[:, context_tokens.shape[-1]:]
        accepted_tokens.append(new_token[0, 0].item()) # 将新生成的token添加到accepted_tokens

    # 将所有接受的token转换为文本
    generated_text = target_tokenizer.batch_decode([accepted_tokens], skip_special_tokens=True)[0]

    return generated_text

# 示例用法
prompt = "The capital of France is"
generated_text = speculative_decode(prompt, draft_model, target_model, draft_tokenizer, target_tokenizer)
print(f"Generated text: {generated_text}")

模块分析

导入库
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
  • torch：PyTorch深度学习框架，用于张量计算和模型训练。
  • AutoModelForCausalLM：Hugging Face Transformers提供的自动加载因果语言模型的类。
  • AutoTokenizer：Hugging Face Transformers提供的自动加载tokenizer的类。

模型初始化

draft_model_name = "google/gemma-2b"
target_model_name = "meta-llama/Llama-2-7b-chat-hf"

draft_model = AutoModelForCausalLM.from_pretrained(draft_model_name, device_map="auto")
target_model = AutoModelForCausalLM.from_pretrained(target_model_name, device_map="auto")

draft_tokenizer = AutoTokenizer.from_pretrained(draft_model_name)
target_tokenizer = AutoTokenizer.from_pretrained(target_model_name)
  • draft_model_name和target_model_name：分别指定轻量级草稿模型和更强大的目标模型的Hugging Face模型名称。
  • AutoModelForCausalLM.from_pretrained：加载预训练的语言模型，device_map="auto"自动分配设备（GPU/CPU）。
  • AutoTokenizer.from_pretrained：加载与模型对应的tokenizer。

投机采样函数

def speculative_decode(prompt, draft_model, target_model, draft_tokenizer, target_tokenizer, num_draft_tokens=5, acceptance_threshold=0.8):
  • 参数说明：
    • prompt：输入的文本提示。
    • draft_model和target_model：草稿模型和目标模型。
    • draft_tokenizer和target_tokenizer：对应的tokenizer。
    • num_draft_tokens：草稿模型生成的token数量。
    • acceptance_threshold：接受草稿token的概率阈值。
Draft阶段
draft_input = draft_tokenizer(prompt, return_tensors="pt").to(draft_model.device)
draft_output = draft_model.generate(**draft_input, max_new_tokens=num_draft_tokens)
draft_tokens = draft_output[:, draft_input['input_ids'].shape[-1]:]
draft_text = draft_tokenizer.batch_decode(draft_tokens, skip_special_tokens=True)[0]
  • draft_tokenizer：将输入文本转换为模型输入的张量。
  • draft_model.generate：生成指定数量的token。
  • draft_tokens：提取生成的token（排除输入部分）。
  • draft_text：将生成的token解码为文本。
Verify阶段
target_input = target_tokenizer(prompt, return_tensors="pt").to(target_model.device)
target_logits = target_model(**target_input).logits
initial_target_token = torch.argmax(target_logits[:, -1, :], dim=-1)
accepted_tokens = [initial_target_token.item()]
rejected_indices = []
  • target_tokenizer：将输入文本转换为目标模型的输入张量。
  • target_model：获取目标模型的输出logits。
  • initial_target_token：获取目标模型预测的第一个token。
  • accepted_tokens：初始化接受的token列表。
  • rejected_indices：存储被拒绝的token索引。
验证草稿token
for i in range(num_draft_tokens):
    context_tokens = target_tokenizer(prompt, return_tensors="pt").to(target_model.device)['input_ids']
    context_tokens = torch.cat([context_tokens, torch.tensor([[accepted_tokens[j] for j in range(len(accepted_tokens))]])], dim=1)

    target_logits = target_model(**{"input_ids": context_tokens}).logits
    target_probs = torch.softmax(target_logits[:, -1, :], dim=-1)
    target_prob_for_draft_token = target_probs[0, draft_tokens[0, i]].item()

    if target_prob_for_draft_token >= acceptance_threshold:
        accepted_tokens.append(draft_tokens[0, i].item())
    else:
        rejected_indices.append(i)
        break
  • context_tokens：构建包含输入和已接受token的上下文。
  • target_model：计算目标模型对当前上下文的预测概率。
  • target_prob_for_draft_token：获取草稿token在目标模型中的概率。
  • 如果概率高于阈值，接受该token；否则拒绝并终止验证。
生成剩余部分
if rejected_indices:
    context_tokens = target_tokenizer(prompt, return_tensors="pt").to(target_model.device)['input_ids']
    context_tokens = torch.cat([context_tokens, torch.tensor([[accepted_tokens[j] for j in range(len(accepted_tokens))]])], dim=1)

    target_output = target_model.generate(**{"input_ids": context_tokens}, max_new_tokens=1)
    new_token = target_output[:, context_tokens.shape[-1]:]
    accepted_tokens.append(new_token[0, 0].item())
  • 如果存在被拒绝的token，使用目标模型生成一个新的token。
  • target_model.generate：生成一个新token。
  • new_token：提取生成的token并添加到接受列表。
输出结果
generated_text = target_tokenizer.batch_decode([accepted_tokens], skip_special_tokens=True)[0]
return generated_text
  • batch_decode：将接受的token解码为文本。
  • 返回生成的文本。

示例用法

prompt = "The capital of France is"
generated_text = speculative_decode(prompt, draft_model, target_model, draft_tokenizer, target_tokenizer)
print(f"Generated text: {generated_text}")
  • 输入提示文本，调用投机采样函数生成文本并打印结果。

EAGLE


import torch
import torch.nn as nn
import torch.optim as optim
from transformers import AutoModelForCausalLM, AutoTokenizer
import numpy as np

# 假设我们使用困惑度作为特征，并简化特征预测模型

class FeaturePredictor(nn.Module):
    def __init__(self, hidden_size):
        super(FeaturePredictor, self).__init__()
        self.linear = nn.Linear(hidden_size, 1) # 预测困惑度

    def forward(self, hidden_states):
        # hidden_states: (batch_size, sequence_length, hidden_size)
        perplexity = self.linear(hidden_states).squeeze(-1) # (batch_size, sequence_length)
        return perplexity

def train_feature_predictor(target_model, tokenizer, feature_predictor, num_epochs=3, learning_rate=1e-4):
    """
    训练特征预测器，使用Target Model的hidden states和困惑度作为训练数据

    Args:
        target_model: Target Model
        tokenizer: Target Model的tokenizer
        feature_predictor: 特征预测模型
        num_epochs: 训练轮数
        learning_rate: 学习率
    """
    optimizer = optim.Adam(feature_predictor.parameters(), lr=learning_rate)
    criterion = nn.MSELoss()

    # 生成一些训练数据
    texts = ["The quick brown fox jumps over the lazy dog.",
             "The capital of France is Paris.",
             "Machine learning is a fascinating field.",
             "Coding is fun and challenging."]

    for epoch in range(num_epochs):
        for text in texts:
            inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True).to(target_model.device)
            with torch.no_grad():
                outputs = target_model(**inputs, output_hidden_states=True)
                hidden_states = outputs.hidden_states[-1] # 使用最后一层的hidden states

                # 计算困惑度 (作为ground truth)
                logits = outputs.logits
                shift_logits = logits[:, :-1, :].contiguous()
                shift_labels = inputs['input_ids'][:, 1:].contiguous()
                loss_fct = nn.CrossEntropyLoss()
                loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
                perplexity = torch.exp(loss)

            # 使用hidden states预测困惑度
            predicted_perplexity = feature_predictor(hidden_states[:, :-1, :]) # 预测除了第一个token之外的perplexity

            # 计算损失并更新模型
            loss = criterion(predicted_perplexity, torch.full_like(predicted_perplexity, perplexity.item()))
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

        print(f"Epoch {epoch+1}, Loss: {loss.item()}")

def eagle_speculative_decode(prompt, draft_model, target_model, draft_tokenizer, target_tokenizer, feature_predictor, num_draft_tokens=5, acceptance_threshold=0.8, alpha=0.5):
    """
    EAGLE投机采样实现

    Args:
        prompt: 输入prompt (字符串)
        draft_model: Draft Model
        target_model: Target Model
        draft_tokenizer: Draft Model的tokenizer
        target_tokenizer: Target Model的tokenizer
        feature_predictor: 特征预测模型
        num_draft_tokens: Draft Model生成的token数量
        acceptance_threshold: 接受Draft token的概率阈值
        alpha: 权重系数，用于平衡Draft Model和特征预测

    Returns:
        生成的文本 (字符串)
    """

    # 1. Draft 阶段
    draft_input = draft_tokenizer(prompt, return_tensors="pt").to(draft_model.device)
    draft_output = draft_model.generate(**draft_input, max_new_tokens=num_draft_tokens, output_hidden_states=True, return_dict_in_generate=True)
    draft_tokens = draft_output.sequences[:, draft_input['input_ids'].shape[-1]:]
    draft_text = draft_tokenizer.batch_decode(draft_tokens, skip_special_tokens=True)[0]
    draft_hidden_states = draft_output.hidden_states[-1] # 获取Draft Model的hidden states

    # 2. 特征预测 (困惑度)
    predicted_perplexities = feature_predictor(draft_hidden_states[:, draft_input['input_ids'].shape[-1]:, :]).detach().cpu().numpy()  # 预测每个token的困惑度

    # 3. Verify 阶段
    target_input = target_tokenizer(prompt, return_tensors="pt").to(target_model.device)
    target_logits = target_model(**target_input).logits
    initial_target_token = torch.argmax(target_logits[:, -1, :], dim=-1)  # 获取第一个token的预测

    accepted_tokens = [initial_target_token.item()]  # 存储接受的token, 初始化第一个token
    rejected_indices = []

    # 迭代验证Draft Model生成的token
    for i in range(num_draft_tokens):
        # 构建上下文，包含prompt和之前接受的token
        context_tokens = target_tokenizer(prompt, return_tensors="pt").to(target_model.device)['input_ids']
        context_tokens = torch.cat([context_tokens, torch.tensor([[accepted_tokens[j] for j in range(len(accepted_tokens))]])], dim=1)

        target_logits = target_model(**{"input_ids": context_tokens}).logits  # 注意使用context_tokens作为输入
        target_probs = torch.softmax(target_logits[:, -1, :], dim=-1)
        target_prob_for_draft_token = target_probs[0, draft_tokens[0, i]].item()

        # 4. 调整采样概率 (这里简化为直接使用困惑度作为调整)
        # 假设Target Model期望的困惑度较低，因此困惑度越低，越容易接受
        feature_prob = 1.0 - np.clip(predicted_perplexities[0, i] / 10.0, 0.0, 1.0)  # 将困惑度映射到0-1之间的概率

        # 加权平均采样概率
        adjusted_prob = alpha * target_prob_for_draft_token + (1 - alpha) * feature_prob

        if adjusted_prob >= acceptance_threshold:
            accepted_tokens.append(draft_tokens[0, i].item())
        else:
            rejected_indices.append(i)
            break # 一旦有token被拒绝，停止验证

    # 5. 生成剩余部分 (如果还有未验证的token)
    if rejected_indices:
        # 在被拒绝的token位置，使用Target Model生成新的token
        context_tokens = target_tokenizer(prompt, return_tensors="pt").to(target_model.device)['input_ids']
        context_tokens = torch.cat([context_tokens, torch.tensor([[accepted_tokens[j] for j in range(len(accepted_tokens))]])], dim=1)

        target_output = target_model.generate(**{"input_ids": context_tokens}, max_new_tokens=1)  # 生成一个新token
        new_token = target_output[:, context_tokens.shape[-1]:]
        accepted_tokens.append(new_token[0, 0].item()) # 将新生成的token添加到accepted_tokens

    # 将所有接受的token转换为文本
    generated_text = target_tokenizer.batch_decode([accepted_tokens], skip_special_tokens=True)[0]

    return generated_text

# 初始化模型和tokenizer (这里简化为使用同一个模型)
model_name = "google/gemma-2b"
draft_model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")
target_model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")
draft_tokenizer = AutoTokenizer.from_pretrained(model_name)
target_tokenizer = AutoTokenizer.from_pretrained(model_name)

# 初始化特征预测模型
hidden_size = draft_model.config.hidden_size
feature_predictor = FeaturePredictor(hidden_size).to(draft_model.device)

# 训练特征预测模型
train_feature_predictor(target_model, target_tokenizer, feature_predictor)

# 示例用法
prompt = "The capital of France is"
generated_text = eagle_speculative_decode(prompt, draft_model, target_model, draft_tokenizer, target_tokenizer, feature_predictor)
print(f"Generated text (EAGLE): {generated_text}")
vLLM专题（十六）-推测性解码（Speculative Decoding）
02-25 545
请注意，vLLM 中的推测性解码尚未优化，并且通常不会对所有提示数据集或采样参数带来令牌间延迟的减少。优化工作正在进行中，相关进展可以通过此链接跟踪：问题 #4630。目前，vLLM 中的推测性解码与管道并行性不兼容。本文档展示了如何在 vLLM 中使用推测性解码。推测性解码是一种提高内存受限的 LLM 推理中令牌间延迟的技术。
加速未来：EAGLE-3如何让大语言模型飞起来
步子哥的博客
03-04 1476
这与当前LLM领域的主流趋势相悖——LLaMA系列模型从LLaMA 1的1万亿词训练数据，到LLaMA 3的15万亿词，在保持模型架构和推理成本基本不变的情况下，性能获得了显著提升。EAGLE-3融合了目标模型的低层、中层和高层特征，捕获了不同层次的语义信息。更重要的是，EAGLE-3揭示了推理加速的新缩放定律：在正确的架构设计下，增加训练数据量可以带来推理加速效果的线性提升。随着草稿模型自身输入的增加，EAGLE的接受率显著下降，而EAGLE-3的接受率几乎保持不变，这充分证明了训练时测试技术的有效性。
对比：投机采样（Speculative Decoding）和 Lookahead Decoding
jerwey的博客
07-10 873
投机采样（Speculative Decoding）和Lookahead Decoding是两种用于加速大语言模型（LLM）推理的技术，虽然目标相似（减少自回归解码的延迟），但核心思想、实现方式和适用场景存在显著差异。
投机采样EAGLE-1详解精读
星辰火之梦
01-06 3312
自回归解码是指模型逐个生成词语（token），每个词语的生成都依赖于之前生成的所有词语。当使用KV Cache加速技术后，解码阶段的每次矩阵-矩阵乘法运算被简化矩阵-向量乘法。矩阵-向量乘法相对矩阵-矩阵乘法，计算访存比更低，这导致整个运算过程的性能瓶颈卡在数据传输上面。因此，自回归解码这种串行的生成方式是 LLM 推理速度慢的主要瓶颈。
【LLM】大模型投机采样Speculative Sampling推理加速
发现问题，并解决问题，批判性思维
08-09 2371
当前的主流 LLM 基本都是 Decoder Only 的 Transformer 模型，其推理过程可以分为两个阶段： （1）Prefill：根据输入 Tokens（Recite, the, first, law, of, robotics） 生成第一个输出 Token（A），通过一次 Forward 就可以完成，在 Forward 中，输入 Tokens 间可以并行执行（类似 Bert 这些 Encoder 模型），因此执行效率很高。 （2）Decoding：从生成第一个 Token（A） 之后开始，
Speculative decoding投机解码原理思考与解决
点滴的岁月
04-19 2114
投机解码的核心动机是：在生成任务中，总有简单和复杂的子任务，对于一些较为简单的任务，解码过程存在可以节约资源的环节，使用大模型进行每轮一个token的自回归解码存在资源上的浪费；换句话说，简单的子任务只需要用参数量较小的模型来生成也能取得与使用大模型生成相当的效果，亦或是用大模型在每轮迭代进行多个token的并行解码也依然能保持生成质量。基于此，投机解码采用一种draft-then-verify（起草+验证）的机制来实现这一过程。
超大模型推理加速2.18倍！SGLang联合美团技术团队开源投机采样训练框架
数据派THU
08-12 180
同时，将 SGLang 的speculative-eagle-topk固定为8，将speculative-num-draft-tokens固定为10，这样可以使用 tree attention达到更高的接受率。目前开源社区中，尚无能够支持超大尺寸模型训练且与SGLang深度结合的框架，而这些工具层面的不足，直接导致此类模型的部署面临巨大挑战。这些模型具有强劲的性能，但受制于模型尺寸导致推理效率较低。它通过训练一个专门的轻量级草稿模型来准确预测较大目标模型的token分布，从而实现高接受率和显著的性能提升。
推理加速：投机采样经典方法
星辰火之梦
01-02 1670
SpecInfer 投机采样利用多个小型模型（SSM）快速生成“草稿”（Draft），然后由大型模型（LLM）验证并选择，从而加速文本生成。SSM1matSSM1核心思路为：通过一系列小模型 SSM（Small Speculative Model）联合预测 LLM 输出，并将这些小模型的预测输出组织为 Token 树，树中每个分支表示一个候选 Token 序列。
Speculative Decoding 推测解码方案详解
cr7258的博客
06-23 1564
本文系统介绍了从早期草稿模型方法、Prompt Lookup 到 Jacobi Decoding、Lookahead、Medusa，再到当前速度领先的 EAGLE 等多种方案。
Eagle论文解析
点滴的岁月
08-22 1157
EAGLE-1：Speculative Decoding 加速框架摘要Algorithm是一个用于加速大语言模型自回归推理的无损推理加速机制，它通过预测特征（而非直接预测 token）来提升推理效率。arXiv工作机制利用模型倒数第二层的特征向量作为输入，让一个轻量级插件预测下一个时刻的特征。使用原模型冻结好的分类头从 predicted feature 输出 token。在不修改模型和输出分布的前提下，实现推理速度显著提升（如 Vicuna 13B 上速度提升约 2.7–3.5 倍）
Unlocking efficiency in large language model inference: A survey of speculative decoding
qq_52024723的博客
11-30 1012
在SpecDec之后，Google和DeepMind也进行这方面的工作，也就是Fast inference from transformers via speculative decoding[202305,ICML2023]和Accelerating large language model decoding with speculative sampling[202302],对应于上面的投机解码和投机采样那两篇文章。此外，这种方法提出了一种创新策略，放宽了严格的验证标准，从而提高了起草令牌的接受率。
深度学习下载包时可能会遇到的问题及解决方案
m0_50481455的博客
12-09 495
若确实下载安装了CUDA ，但是此时输出的CUDA是否可用为否，应该是torch的版本为cpu版本导致，刚刚的下载包的语句如果总是下载的是cpu版本，我们考虑直接去网站下指定包，再进行安装。CUDA Version表示的是驱动支持的最高 CUDA 版本，去官网下载 CUDA ，我这里是12.2，表示下载的版本最大只能是12.2。然后下载包时，比如本地环境是Python3.9，找包下载时候，3.9要下对应cp39的包。下载好后，执行语句安装。
精品数据分享 | 锂电池数据集（七）同济大学电池数据集
12-11 806
本期继续分享一篇Nature communicationTop论文公开锂离子电池数据，划重点-数据集开源，代码开源！！！
vLLM推理引擎教程4-离线推理功能
benben044的专栏
12-12 557
本文介绍了使用vLLM框架优化推理性能的多种方法。主要内容包括：1）基础文本生成、对话式推理、文本分类和嵌入提取四种任务的基本实现；2）自动前缀缓存功能，通过共享KV缓存加速长上下文处理；3）使用YARN方法扩展模型上下文长度；4）多模态任务处理示例（Whisper语音识别）；5）底层LLMEngine API的使用。文章通过具体代码示例展示了如何设置参数实现各类推理优化，包括温度调节、top-p采样、缓存复用等技巧，适用于文本生成、分类、嵌入等多种NLP任务场景。
观成科技:Zloader木马家族加密流量分析
GCKJ_0824的博客
12-12 519
摘要：Zloader木马最初作为银行木马Zeus的下载器，现被广泛用于勒索软件投递。其采用多种加密通信技术规避检测：1）DGA技术生成随机域名；2）DNS隧道隐藏数据；3）HTTPS加密通信；4）Websocket掩码加密。最新版本通过会话密钥强化DNS隧道加密。观成科技利用AI模型结合TLS指纹检测HTTPS加密流量，持续通过行为分析和机器学习应对加密威胁。研究表明，恶意软件正不断升级流量对抗技术，凸显加密流量检测的重要性。（149字）
宝马，如何建设一座AI汽车工厂？｜产业AI案例
chanyejiawang的博客
12-08 1517
AI汽车时代来袭
Syslog / Flow / Telemetry 的 AI 聚合与异常检测实战（可观测性）
最新发布
oQianYuan的博客
12-12 904
网络设备每天在后台发出巨量的可观测性数据，它们大多数被丢弃、被忽略、被埋没在日志平台里。Syslog、Flow、Telemetry 是三类最常用的基础信号，但它们一直没有在企业里发挥出该有的价值——所谓“看起来都有，出了问题却找不到原因”。过去几年里，我几乎把所有大型网络的事故复盘都做过一遍，最后得出的共同结论是：事故不是因为没有可观测性，而是因为信号太分散、太原始，而人类根本处理不过来。这篇文章的目标很直接：把 Syslog、Flow、Telemetry 三种信号，做成可输入 AI 的高质量特征，进而构建
大模型的监督微调基础详解
AggressiveYu的博客
12-10 1041
在预训练完毕之后，我们的模型已经成为了一个学习完所有知识的学生，但是他缺乏用适当的方式表达知识的能力，还是停留在续写文本的阶段，无法直接回答我们的问题，所以监督微调这个时候就出来了，这个指令微调的作用，就是让模型在预训练的基础上，通过特定的数据和训练，让模型能够更好的回答用户的问题。 预训练一般包括三大要素，网络结构，损失函数，训练数据。指令微调和预训练的方式几乎没有区别，只是训练数据的不同。
创始人IP与AI融合：重构信任与引领变革
ckjrxdn的博客
12-08 310
通过个人品牌的塑造，企业能够增强与用户之间的情感连接，提升认同感。举办此次峰会，是希望帮助更多中小企业家认识到技术趋势与品牌建设的重要性，从而更好地把握未来发展机遇。另一方面，人工智能能够全面提升企业在内容创作、客户转化等环节的效率，助力构建可持续的商业系统。活动汇聚了来自全球的创始人、行业专家及媒体代表，共同探讨在人工智能与个人品牌价值并重的时代背景下，企业如何应对挑战、实现持续发展。本次峰会还设置了多场主题分享与圆桌对话，聚焦人工智能的应用前景与未来商业趋势，为参会者提供了交流与合作的平台。
in-house 的投机采样
10-24
投机采样（Speculative Sampling）是一种加速大语言模型推理的技术。以下是关于in - house（内部、自有）的投机采样的相关介绍： ### 基本概念 投机采样的核心思想是利用一个较小、速度更快的“草稿模型”（Draft Model）来生成可能的输出候选，然后让较大、更准确的“目标模型”（Target Model）对这些候选进行验证。在in - house场景下，企业或组织可以根据自身需求训练和使用适合的草稿模型和目标模型。 ### 工作流程 1. **草稿模型生成**：草稿模型基于输入生成一系列可能的输出标记（Tokens）。由于草稿模型规模较小，生成速度快。 2. **目标模型验证**：目标模型对草稿模型生成的标记进行验证。它会从草稿模型生成的序列开始处理，检查这些标记是否与自己的预测一致。 3. **接受或拒绝**：如果目标模型验证通过草稿模型生成的部分或全部标记，那么这些标记就被接受并作为最终输出的一部分；如果验证不通过，目标模型会重新生成正确的标记。 ### in - house应用优势 1. **定制化**：企业可以根据自身数据和业务需求，训练专门的草稿模型和目标模型，以更好地适应特定任务。 2. **数据安全**：在in - house环境中处理数据，避免了将敏感数据发送到外部，确保数据安全和隐私。 3. **成本控制**：通过优化模型架构和训练过程，可以降低推理成本，特别是在大规模使用的情况下。 ### 潜在挑战 1. **模型训练**：训练合适的草稿模型和目标模型需要大量的计算资源和专业知识。 2. **性能调优**：需要对草稿模型和目标模型的性能进行调优，以达到最佳的加速效果和输出质量。 ### 示例代码（伪代码） ```python # 输入 input_text = "Some input text" # 草稿模型生成 draft_model = load_draft_model() draft_output = draft_model.generate(input_text) # 目标模型验证 target_model = load_target_model() validated_output = target_model.validate(draft_output, input_text) # 最终输出 final_output = validated_output ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值