Llama模型家族之Stanford NLP ReFT源代码探索 （二）Intervention Layers层

news2024/11/23 9:59:54

LlaMA 3 系列博客

基于 LlaMA 3 + LangGraph 在windows本地部署大模型 （一）

基于 LlaMA 3 + LangGraph 在windows本地部署大模型 （二）

基于 LlaMA 3 + LangGraph 在windows本地部署大模型 （三）

基于 LlaMA 3 + LangGraph 在windows本地部署大模型 （四）

基于 LlaMA 3 + LangGraph 在windows本地部署大模型 （五）

基于 LlaMA 3 + LangGraph 在windows本地部署大模型 （六）

基于 LlaMA 3 + LangGraph 在windows本地部署大模型 （七）

基于 LlaMA 3 + LangGraph 在windows本地部署大模型 （八）

基于 LlaMA 3 + LangGraph 在windows本地部署大模型 （九）

基于 LlaMA 3 + LangGraph 在windows本地部署大模型 （十）

构建安全的GenAI/LLMs核心技术解密之大模型对抗攻击（一）

构建安全的GenAI/LLMs核心技术解密之大模型对抗攻击（二）

构建安全的GenAI/LLMs核心技术解密之大模型对抗攻击（三）

构建安全的GenAI/LLMs核心技术解密之大模型对抗攻击（四）

构建安全的GenAI/LLMs核心技术解密之大模型对抗攻击（五）

你好 GPT-4o！

大模型标记器之Tokenizer可视化（GPT-4o）

大模型标记器 Tokenizer之Byte Pair Encoding (BPE) 算法详解与示例

大模型标记器 Tokenizer之Byte Pair Encoding (BPE)源码分析

大模型之自注意力机制Self-Attention（一）

大模型之自注意力机制Self-Attention（二）

大模型之自注意力机制Self-Attention（三）

基于 LlaMA 3 + LangGraph 在windows本地部署大模型 （十一）

Llama 3 模型家族构建安全可信赖企业级AI应用之 Code Llama （一）

Llama 3 模型家族构建安全可信赖企业级AI应用之 Code Llama （二）

Llama 3 模型家族构建安全可信赖企业级AI应用之 Code Llama （三）

Llama 3 模型家族构建安全可信赖企业级AI应用之 Code Llama （四）

Llama 3 模型家族构建安全可信赖企业级AI应用之 Code Llama （五）

Llama 3 模型家族构建安全可信赖企业级AI应用之使用 Llama Guard 保护大模型对话（一）

Llama 3 模型家族构建安全可信赖企业级AI应用之使用 Llama Guard 保护大模型对话（二）

Llama 3 模型家族构建安全可信赖企业级AI应用之使用 Llama Guard 保护大模型对话（三）

大模型之深入理解Transformer位置编码（Positional Embedding）

大模型之深入理解Transformer Layer Normalization（一）

大模型之深入理解Transformer Layer Normalization（二）

大模型之深入理解Transformer Layer Normalization（三）

大模型之一步一步使用PyTorch编写Meta的Llama 3代码（一）初学者的起点

大模型之一步一步使用PyTorch编写Meta的Llama 3代码（二）矩阵操作的演练

大模型之一步一步使用PyTorch编写Meta的Llama 3代码（三）初始化一个嵌入层

大模型之一步一步使用PyTorch编写Meta的Llama 3代码（四）预先计算 RoPE 频率

大模型之一步一步使用PyTorch编写Meta的Llama 3代码（五）预先计算因果掩码

大模型之一步一步使用PyTorch编写Meta的Llama 3代码（六）首次归一化：均方根归一化（RMSNorm）

大模型之一步一步使用PyTorch编写Meta的Llama 3代码（七） 初始化多查询注意力

大模型之一步一步使用PyTorch编写Meta的Llama 3代码（八）旋转位置嵌入

大模型之一步一步使用PyTorch编写Meta的Llama 3代码（九） 计算自注意力

大模型之一步一步使用PyTorch编写Meta的Llama 3代码（十） 残差连接及SwiGLU FFN

大模型之一步一步使用PyTorch编写Meta的Llama 3代码（十一）输出概率分布 及损失函数计算

大模型之使用PyTorch编写Meta的Llama 3实际功能代码（一）加载简化分词器及设置参数

大模型之使用PyTorch编写Meta的Llama 3实际功能代码（二）RoPE 及注意力机制

大模型之使用PyTorch编写Meta的Llama 3实际功能代码（三） FeedForward 及 Residual Layers

大模型之使用PyTorch编写Meta的Llama 3实际功能代码（四） 构建 Llama3 类模型本身

大模型之使用PyTorch编写Meta的Llama 3实际功能代码（五）训练并测试你自己的 minLlama3

大模型之使用PyTorch编写Meta的Llama 3实际功能代码（六）加载已经训练好的miniLlama3模型

Llama 3 模型家族构建安全可信赖企业级AI应用之使用 Llama Guard 保护大模型对话 （四）

Llama 3 模型家族构建安全可信赖企业级AI应用之使用 Llama Guard 保护大模型对话 （五）

Llama 3 模型家族构建安全可信赖企业级AI应用之使用 Llama Guard 保护大模型对话 （六）

Llama 3 模型家族构建安全可信赖企业级AI应用之使用 Llama Guard 保护大模型对话 （七）

Llama 3 模型家族构建安全可信赖企业级AI应用之使用 Llama Guard 保护大模型对话 （八）

Llama 3 模型家族构建安全可信赖企业级AI应用之 CyberSecEval 2：量化 LLM 安全和能力的基准（一）

Llama 3 模型家族构建安全可信赖企业级AI应用之 CyberSecEval 2：量化 LLM 安全和能力的基准（二）

Llama 3 模型家族构建安全可信赖企业级AI应用之 CyberSecEval 2：量化 LLM 安全和能力的基准（三）

Llama 3 模型家族构建安全可信赖企业级AI应用之 CyberSecEval 2：量化 LLM 安全和能力的基准（四）

Llama 3 模型家族构建安全可信赖企业级AI应用之code shield（一）Code Shield简介

Llama 3 模型家族构建安全可信赖企业级AI应用之code shield（二）防止 LLM 生成不安全代码

Llama 3 模型家族构建安全可信赖企业级AI应用之code shield（三）Code Shield代码示例

Llama模型家族之使用 Supervised Fine-Tuning（SFT）微调预训练Llama 3 语言模型（一） LLaMA-Factory简介

Llama模型家族之使用 Supervised Fine-Tuning（SFT）微调预训练Llama 3 语言模型（二） LLaMA-Factory训练方法及数据集

大模型之Ollama：在本地机器上释放大型语言模型的强大功能

Llama模型家族之使用 Supervised Fine-Tuning（SFT）微调预训练Llama 3 语言模型（三）通过Web UI微调

Llama模型家族之使用 Supervised Fine-Tuning（SFT）微调预训练Llama 3 语言模型（四）通过命令方式微调

Llama模型家族之使用 Supervised Fine-Tuning（SFT）微调预训练Llama 3 语言模型（五） 基于已训练好的模型进行推理

Llama模型家族之使用 Supervised Fine-Tuning（SFT）微调预训练Llama 3 语言模型（六）Llama 3 已训练的大模型合并LoRA权重参数

Llama模型家族之使用 Supervised Fine-Tuning（SFT）微调预训练Llama 3 语言模型（七） 使用 LoRA 微调 LLM 的实用技巧

Llama模型家族之使用 Supervised Fine-Tuning（SFT）微调预训练Llama 3 语言模型（八） 使用 LoRA 微调 LLM 的实用技巧

Llama模型家族之使用 Supervised Fine-Tuning（SFT）微调预训练Llama 3 语言模型（九） 使用 LoRA 微调常见问题答疑

Llama模型家族之使用 Supervised Fine-Tuning（SFT）微调预训练Llama 3 语言模型（十） 使用 LoRA 微调常见问题答疑

Llama模型家族训练奖励模型Reward Model技术及代码实战（一）简介

Llama模型家族训练奖励模型Reward Model技术及代码实战（二）从用户反馈构建比较数据集

Llama模型家族训练奖励模型Reward Model技术及代码实战（三） 使用 TRL 训练奖励模型

Llama模型家族之RLAIF 基于 AI 反馈的强化学习（一）RLHF简介

Llama模型家族之RLAIF 基于 AI 反馈的强化学习（二）RLHF 与RAIF比较

Llama模型家族之RLAIF 基于 AI 反馈的强化学习（三） RLAIF 的工作原理

Llama模型家族之RLAIF 基于 AI 反馈的强化学习（四）RLAIF 优势

Llama模型家族之RLAIF 基于 AI 反馈的强化学习（五）RLAIF 挑战

Llama模型家族之RLAIF 基于 AI 反馈的强化学习（六） RLAIF 代码实战

Llama模型家族之RLAIF 基于 AI 反馈的强化学习（七） RLAIF 代码实战

Llama模型家族之RLAIF 基于 AI 反馈的强化学习（八） RLAIF 代码实战

Llama模型家族之RLAIF 基于 AI 反馈的强化学习（九） RLAIF 代码实战

Llama模型家族之RLAIF 基于 AI 反馈的强化学习（十） RLAIF 代码实战

Llama模型家族之拒绝抽样(Rejection Sampling)（一）

Llama模型家族之拒绝抽样(Rejection Sampling)（二）均匀分布简介

Llama模型家族之拒绝抽样(Rejection Sampling)（三）确定缩放常数以优化拒绝抽样方法

Llama模型家族之拒绝抽样(Rejection Sampling)（四） 蒙特卡罗方法在拒绝抽样中的应用：评估线与样本接受标准

Llama模型家族之拒绝抽样(Rejection Sampling)（五） 蒙特卡罗算法在拒绝抽样中：均匀分布与样本接受标准

Llama模型家族之拒绝抽样(Rejection Sampling)（六） 拒绝抽样中的蒙特卡罗算法：重复过程与接受标准

Llama模型家族之拒绝抽样(Rejection Sampling)（七） 优化拒绝抽样：选择高斯分布以减少样本拒绝

Llama模型家族之拒绝抽样(Rejection Sampling)（八） 代码实现

Llama模型家族之拒绝抽样(Rejection Sampling)（九） 强化学习之Rejection Sampling

Llama模型家族之使用 ReFT技术对 Llama-3 进行微调（一）ReFT简介

Llama模型家族之使用 ReFT技术对 Llama-3 进行微调（二） PyReFT简介

Llama模型家族之使用 ReFT技术对 Llama-3 进行微调（三）为 ReFT 微调准备模型及数据集

Llama模型家族之使用 ReFT技术对 Llama-3 进行微调（四） ReFT 微调训练及模型推理

Llama模型家族之Stanford NLP ReFT源代码探索 （一）数据预干预

Llama模型家族之Stanford NLP ReFT源代码探索 （二）

pyreft-main\pyreft\interventions.py

 import torch
from collections import OrderedDict

from pyvene import (
    ConstantSourceIntervention,
    SourcelessIntervention,
    TrainableIntervention,
    DistributedRepresentationIntervention,
)
from transformers.activations import ACT2FN


class LowRankRotateLayer(torch.nn.Module):
    """A linear transformation with orthogonal initialization."""

    def __init__(self, n, m, init_orth=True):
        super().__init__()
        # n > m
        self.weight = torch.nn.Parameter(torch.empty(n, m), requires_grad=True)
        if init_orth:
            torch.nn.init.orthogonal_(self.weight)

    def forward(self, x):
        return torch.matmul(x.to(self.weight.dtype), self.weight)


class LoreftIntervention(
    SourcelessIntervention,
    TrainableIntervention, 
    DistributedRepresentationIntervention
):
    """
    LoReFT(h) = h + R^T(Wh + b − Rh)
    """
    def __init__(self, **kwargs):
        super().__init__(**kwargs, keep_last_dim=True)
        rotate_layer = LowRankRotateLayer(self.embed_dim, kwargs["low_rank_dimension"], init_orth=True)
        self.rotate_layer = torch.nn.utils.parametrizations.orthogonal(rotate_layer, orthogonal_map='householder')
        self.learned_source = torch.nn.Linear(
            self.embed_dim, kwargs["low_rank_dimension"]).to(
            kwargs["dtype"] if "dtype" in kwargs else torch.bfloat16)
        self.dropout = torch.nn.Dropout(kwargs["dropout"] if "dropout" in kwargs else 0.0)
        self.act_fn = ACT2FN["linear"] if "act_fn" not in kwargs or kwargs["act_fn"] is None else ACT2FN[kwargs["act_fn"]]
        
    def forward(
        self, base, source=None, subspaces=None
    ):
        rotated_base = self.rotate_layer(base)
        output = base + torch.matmul(
            (self.act_fn(self.learned_source(base)) - rotated_base), self.rotate_layer.weight.T
        )
        return self.dropout(output.to(base.dtype))

    def state_dict(self, *args, **kwargs):
        """
        Overwrite for data-efficiency.
        """
        state_dict = OrderedDict()
        for k, v in self.learned_source.state_dict().items():
            state_dict[k] = v
        state_dict["rotate_layer"] = self.rotate_layer.weight.data
        return state_dict

    def load_state_dict(self, state_dict, *args, **kwargs):
        """
        Overwrite for data-efficiency.
        """
        self.learned_source.load_state_dict(state_dict, strict=False)
        overload_w = state_dict["rotate_layer"]
        overload_w_width = overload_w.shape[-1]
        self.rotate_layer.parametrizations.weight[0].base[:,:overload_w_width] = overload_w
        return


class NoreftIntervention(
    SourcelessIntervention,
    TrainableIntervention, 
    DistributedRepresentationIntervention
):
    """
    NoReFT(h) = h + W2^T(W1h + b − W2h)
    """
    def __init__(self, **kwargs):
        super().__init__(**kwargs, keep_last_dim=True)
        self.proj_layer = torch.nn.Linear(
            self.embed_dim, kwargs["low_rank_dimension"], bias=kwargs["add_bias"]).to(
            kwargs["dtype"] if "dtype" in kwargs else torch.bfloat16)
        self.learned_source = torch.nn.Linear(
            self.embed_dim, kwargs["low_rank_dimension"]).to(
            kwargs["dtype"] if "dtype" in kwargs else torch.bfloat16)
        self.dropout = torch.nn.Dropout(kwargs["dropout"] if "dropout" in kwargs else 0.0)
        self.act_fn = ACT2FN["linear"] if "act_fn" not in kwargs or kwargs["act_fn"] is None else ACT2FN[kwargs["act_fn"]]
        
    def forward(
        self, base, source=None, subspaces=None
    ):
        proj_base = self.proj_layer(base)
        output = base + torch.matmul(
            (self.act_fn(self.learned_source(base)) - proj_base), self.proj_layer.weight
        )
        return self.dropout(output.to(base.dtype))


class ConsreftIntervention(
    SourcelessIntervention,
    TrainableIntervention, 
    DistributedRepresentationIntervention
):
    """
    ConsReFT(h) = h + R^T(b − Rh)
    """
    def __init__(self, **kwargs):
        super().__init__(**kwargs, keep_last_dim=True)
        rotate_layer = LowRankRotateLayer(self.embed_dim, kwargs["low_rank_dimension"], init_orth=True)
        self.rotate_layer = torch.nn.utils.parametrizations.orthogonal(rotate_layer, orthogonal_map='householder')
        self.learned_source = torch.nn.Parameter(
            torch.rand(kwargs["low_rank_dimension"]), requires_grad=True)
        
    def forward(
        self, base, source=None, subspaces=None
    ):
        rotated_base = self.rotate_layer(base)
        output = base + torch.matmul(
            (self.learned_source - rotated_base), self.rotate_layer.weight.T
        )
        return output.to(base.dtype)


class LobireftIntervention(
    SourcelessIntervention,
    TrainableIntervention, 
    DistributedRepresentationIntervention
):
    """
    LobiReFT(h) = h + R^T(b)
    """
    def __init__(self, **kwargs):
        super().__init__(**kwargs, keep_last_dim=True)
        rotate_layer = LowRankRotateLayer(self.embed_dim, kwargs["low_rank_dimension"], init_orth=True)
        self.rotate_layer = torch.nn.utils.parametrizations.orthogonal(rotate_layer, orthogonal_map='householder')
        self.learned_source = torch.nn.Parameter(
            torch.rand(kwargs["low_rank_dimension"]), requires_grad=True)
        self.dropout = torch.nn.Dropout(kwargs["dropout"] if "dropout" in kwargs else 0.0)
        
    def forward(
        self, base, source=None, subspaces=None
    ):
        output = base + torch.matmul(
            self.learned_source, self.rotate_layer.weight.T
        )
        return self.dropout(output.to(base.dtype))


class DireftIntervention(
    SourcelessIntervention,
    TrainableIntervention, 
    DistributedRepresentationIntervention
):
    """
    DiReFT(h) = h + R^T(Wh + b)
    """
    def __init__(self, **kwargs):
        super().__init__(**kwargs, keep_last_dim=True)
        rotate_layer = LowRankRotateLayer(self.embed_dim, kwargs["low_rank_dimension"], init_orth=True)
        self.rotate_layer = torch.nn.utils.parametrizations.orthogonal(rotate_layer, orthogonal_map='householder')
        self.learned_source = torch.nn.Linear(
            self.embed_dim, kwargs["low_rank_dimension"]).to(
            kwargs["dtype"] if "dtype" in kwargs else torch.bfloat16)
        self.dropout = torch.nn.Dropout(kwargs["dropout"] if "dropout" in kwargs else 0.0)
        self.act_fn = ACT2FN["linear"] if "act_fn" not in kwargs or kwargs["act_fn"] is None else ACT2FN[kwargs["act_fn"]]
        
    def forward(
        self, base, source=None, subspaces=None
    ):
        cast_base = base.to(self.learned_source.weight.dtype)
        output = base + torch.matmul(
            (self.act_fn(self.learned_source(cast_base))).to(self.rotate_layer.weight.dtype), self.rotate_layer.weight.T
        )
        return self.dropout(output.to(base.dtype))


class NodireftIntervention(
    SourcelessIntervention,
    TrainableIntervention, 
    DistributedRepresentationIntervention
):
    """
    NodiReFT(h) = h + W2^T(W1h + b)
    """
    def __init__(self, **kwargs):
        super().__init__(**kwargs, keep_last_dim=True)
        self.proj_layer = torch.nn.Linear(
            self.embed_dim, kwargs["low_rank_dimension"], bias=kwargs["add_bias"]).to(
            kwargs["dtype"] if "dtype" in kwargs else torch.bfloat16)
        self.learned_source = torch.nn.Linear(
            self.embed_dim, kwargs["low_rank_dimension"]).to(
            kwargs["dtype"] if "dtype" in kwargs else torch.bfloat16)
        self.dropout = torch.nn.Dropout(kwargs["dropout"] if "dropout" in kwargs else 0.0)
        self.act_fn = ACT2FN["linear"] if "act_fn" not in kwargs or kwargs["act_fn"] is None else ACT2FN[kwargs["act_fn"]]
        
    def forward(
        self, base, source=None, subspaces=None
    ):
        output = base + torch.matmul(
            self.act_fn(self.learned_source(base)), self.proj_layer.weight
        )
        return self.dropout(output.to(base.dtype))

这段代码定义了一系列基于PyTorch框架的神经网络干预层（Intervention Layers），用于对嵌入向量进行变换 ：

1. 导入模块

  • torch：PyTorch库，用于构建和操作张量以及构建神经网络。
  • OrderedDict：有序字典，用于保存状态字典时保持键的顺序。
  • pyvene：提供了不同类型的干预层基类。
  • ACT2FN：一个映射，将激活函数的名称映射到其对应的函数实现。
    在这里插入图片描述

2. LowRankRotateLayer 类

  • 这个类实现了一个线性变换层，其权重矩阵通过正交初始化来保证数值稳定性。
    • __init__：构造函数，接受输入维度n和输出维度m（要求n > m），并可选择是否进行正交初始化。
    • forward：前向传播函数，使用矩阵乘法对输入x进行变换。

3. LoreftIntervention 类

  • 继承自SourcelessIntervention、TrainableIntervention和DistributedRepresentationIntervention，实现了LoReFT干预层。
    • __init__：构造函数，初始化一个低秩旋转层、一个可学习的源向量层、dropout层和激活函数。
    • forward：实现了LoReFT变换，通过旋转层和可学习的源向量层对基础嵌入base进行变换。
    • state_dict和load_state_dict：重写这两个方法以优化数据效率，确保在保存和加载模型状态时只保存必要的参数。
      在这里插入图片描述
  • 公式 ( h + R^T(Wh + b - Rh) ) 描述了一种向量变换

  1. ( h )：这是原始的输入向量，是嵌入表示向量。

  2. ( R )：这是一个低秩矩阵，用于在变换中引入低维结构。"低秩"意味着矩阵 ( R ) 的列向量或行向量是线性相关的，这有助于减少模型的参数数量并提高计算效率。

  3. ( W )：这是一个权重矩阵，用于对输入向量 ( h ) 进行线性变换。在神经网络中，( W ) 通常是可学习的参数。

  4. ( b )：这是一个偏置项，用于为变换添加一个常数。

  5. ( R^T )：这是矩阵 ( R ) 的转置。在矩阵乘法中，转置操作会影响结果向量的方向。

  6. ( Wh )：表示权重矩阵 ( W ) 与输入向量 ( h ) 的乘积，这是对输入向量的一个线性变换。

  7. ( - Rh )：表示矩阵 ( R ) 与输入向量 ( h ) 的乘积，然后取负号。这表示从 ( Wh ) 中减去 ( Rh ) 的影响，是为了减少某些类型的偏差或进行正则化。

  8. ( R^T(Wh + b - Rh) )：这部分是整个变换的核心。首先，对 ( h ) 进行线性变换 ( Wh )，然后加上偏置 ( b )，再减去 ( Rh )。 将整个结果乘以 ( R ) 的转置，得到一个新的向量。

  9. ( h + R^T(Wh + b - Rh) )：最终，原始向量 ( h ) 与通过 ( R^T ) 变换后的结果相加，得到最终的输出向量。这种结构允许模型在保留原始信息的同时，对嵌入表示进行调整，以更好地适应特定的任务或数据集。

4. NoreftIntervention 类

  • 类似于LoreftIntervention，但使用的是正交投影层而不是旋转层，实现了NoReFT干预层。

5. ConsreftIntervention 类

  • 使用常数源向量和旋转层实现ConsReFT 干预层。

6. LobirefIntervention 类

  • 使用单个参数化的源向量和旋转层的转置实现LobiReFT 干预层。

7. DireftIntervention 类

  • 类似于LoreftIntervention，但源向量是通过线性层得到的，并且使用了激活函数，实现DiReFT 干预层。

8. NodireftIntervention 类

  • 类似于NoreftIntervention，但源向量是通过线性层得到的，并且使用了激活函数，实现NodiReFT 干预层。

大模型技术分享

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

《企业级生成式人工智能LLM大模型技术、算法及案例实战》线上高级研修讲座

模块一：Generative AI 原理本质、技术内核及工程实践周期详解
模块二：工业级 Prompting 技术内幕及端到端的基于LLM 的会议助理实战
模块三：三大 Llama 2 模型详解及实战构建安全可靠的智能对话系统
模块四：生产环境下 GenAI/LLMs 的五大核心问题及构建健壮的应用实战
模块五：大模型应用开发技术：Agentic-based 应用技术及案例实战
模块六：LLM 大模型微调及模型 Quantization 技术及案例实战
模块七：大模型高效微调 PEFT 算法、技术、流程及代码实战进阶
模块八：LLM 模型对齐技术、流程及进行文本Toxicity 分析实战
模块九：构建安全的 GenAI/LLMs 核心技术Red Teaming 解密实战
模块十：构建可信赖的企业私有安全大模型Responsible AI 实战

Llama3关键技术深度解析与构建Responsible AI、算法及开发落地实战

1、Llama开源模型家族大模型技术、工具和多模态详解：学员将深入了解Meta Llama 3的创新之处，比如其在语言模型技术上的突破，并学习到如何在Llama 3中构建trust and safety AI。他们将详细了解Llama 3的五大技术分支及工具，以及如何在AWS上实战Llama指令微调的案例。
2、解密Llama 3 Foundation Model模型结构特色技术及代码实现：深入了解Llama 3中的各种技术，比如Tiktokenizer、KV Cache、Grouped Multi-Query Attention等。通过项目二逐行剖析Llama 3的源码，加深对技术的理解。
3、解密Llama 3 Foundation Model模型结构核心技术及代码实现：SwiGLU Activation Function、FeedForward Block、Encoder Block等。通过项目三学习Llama 3的推理及Inferencing代码，加强对技术的实践理解。
4、基于LangGraph on Llama 3构建Responsible AI实战体验：通过项目四在Llama 3上实战基于LangGraph的Responsible AI项目。他们将了解到LangGraph的三大核心组件、运行机制和流程步骤，从而加强对Responsible AI的实践能力。
5、Llama模型家族构建技术构建安全可信赖企业级AI应用内幕详解：深入了解构建安全可靠的企业级AI应用所需的关键技术，比如Code Llama、Llama Guard等。项目五实战构建安全可靠的对话智能项目升级版，加强对安全性的实践理解。
6、Llama模型家族Fine-tuning技术与算法实战：学员将学习Fine-tuning技术与算法，比如Supervised Fine-Tuning(SFT)、Reward Model技术、PPO算法、DPO算法等。项目六动手实现PPO及DPO算法，加强对算法的理解和应用能力。
7、Llama模型家族基于AI反馈的强化学习技术解密：深入学习Llama模型家族基于AI反馈的强化学习技术，比如RLAIF和RLHF。项目七实战基于RLAIF的Constitutional AI。
8、Llama 3中的DPO原理、算法、组件及具体实现及算法进阶：学习Llama 3中结合使用PPO和DPO算法，剖析DPO的原理和工作机制，详细解析DPO中的关键算法组件，并通过综合项目八从零开始动手实现和测试DPO算法，同时课程将解密DPO进阶技术Iterative DPO及IPO算法。
9、Llama模型家族Safety设计与实现：在这个模块中，学员将学习Llama模型家族的Safety设计与实现，比如Safety in Pretraining、Safety Fine-Tuning等。构建安全可靠的GenAI/LLMs项目开发。
10、Llama 3构建可信赖的企业私有安全大模型Responsible AI系统：构建可信赖的企业私有安全大模型Responsible AI系统，掌握Llama 3的Constitutional AI、Red Teaming。

解码Sora架构、技术及应用

一、为何Sora通往AGI道路的里程碑？
1，探索从大规模语言模型(LLM)到大规模视觉模型(LVM)的关键转变，揭示其在实现通用人工智能(AGI)中的作用。
2，展示Visual Data和Text Data结合的成功案例，解析Sora在此过程中扮演的关键角色。
3，详细介绍Sora如何依据文本指令生成具有三维一致性(3D consistency)的视频内容。 4，解析Sora如何根据图像或视频生成高保真内容的技术路径。
5，探讨Sora在不同应用场景中的实践价值及其面临的挑战和局限性。

二、解码Sora架构原理
1，DiT (Diffusion Transformer)架构详解
2，DiT是如何帮助Sora实现Consistent、Realistic、Imaginative视频内容的？
3，探讨为何选用Transformer作为Diffusion的核心网络，而非技术如U-Net。
4，DiT的Patchification原理及流程，揭示其在处理视频和图像数据中的重要性。
5，Conditional Diffusion过程详解，及其在内容生成过程中的作用。
三、解码Sora关键技术解密
1，Sora如何利用Transformer和Diffusion技术理解物体间的互动，及其对模拟复杂互动场景的重要性。
2，为何说Space-time patches是Sora技术的核心，及其对视频生成能力的提升作用。
3，Spacetime latent patches详解，探讨其在视频压缩和生成中的关键角色。
4，Sora Simulator如何利用Space-time patches构建digital和physical世界，及其对模拟真实世界变化的能力。
5，Sora如何实现faithfully按照用户输入文本而生成内容，探讨背后的技术与创新。
6，Sora为何依据abstract concept而不是依据具体的pixels进行内容生成，及其对模型生成质量与多样性的影响。

GPT 自回归语言模型架构、数学原理及内幕-简介

GPT 自回归语言模型架构、数学原理及内幕-简介

基于 Transformer 的 Rasa Internals 解密之 Retrieval Model 剖析-简介

基于 Transformer 的 Rasa Internals 解密之 Retrieval Model 剖析-简介

Transformer语言模型架构、数学原理及内幕机制-简介

Transformer语言模型架构、数学原理及内幕机制-简介

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1807475.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

CentOS安装Node.js以及JSDOM跳坑记

CentOS安装Node.js以及JSDOM跳坑记

笔者在一台 CentOS 7.9 的服务器上使用常规的安装命令：sudo yum install node 来安装 Node.js，到最后系统提示： Error: Package: 2:nodejs-20.14.0-1nodesource.x86_64 (nodesource-nodejs) Requires: libstdc.so.6(GLIBCXX_3.4.20)(64bit) …
阅读更多...
RabbitMQ-工作模式（Topics模式RPC模式Publisher Confirms模式）

RabbitMQ-工作模式（Topics模式RPC模式Publisher Confirms模式）

文章目录 Topics模式topic代码示例 RPC模式客户端界面回调队列关联ID总结RPC代码示例 Publisher Confirms模式概述在通道上启用发布者确认单独发布消息批量发布消息异步处理发布者确认总结总体代码示例 更多相关内容可查看 Topics模式 在Topics中，发送的消息不能具…
阅读更多...
C#异步编程是怎么回事

C#异步编程是怎么回事

首先以一个例子开始 我说明一下这个例子。 这是一个演示异步编程的例子。 输入job [name]，在一个同步的Main方法中，以一发即忘的方式调用异步方法StartJob()。输入time，调用同步方法PrintCurrentTime()输出时间。输出都带上线程ID，便于观察。 可以看到，主线程不会阻塞。主…
阅读更多...
SmartEDA VS Multisim/Proteus：电子设计江湖，谁主沉浮？

SmartEDA VS Multisim/Proteus：电子设计江湖，谁主沉浮？

在电子设计的江湖里，SmartEDA、Multisim和Proteus无疑是几大门派，各自拥有独特的武功秘籍和门派特色。今天，我们就来一场巅峰对决，看看这些电子设计软件究竟谁能笑傲江湖，成为电子设计界的霸主！ 一、门派起…
阅读更多...
【虚拟现实】一、AR与VR的基本原理

【虚拟现实】一、AR与VR的基本原理

人不走空 🌈个人主页：人不走空 💖系列专栏：算法专题 ⏰诗词歌赋：斯是陋室，惟吾德馨 增强现实（AR）和虚拟现实（VR）技术已经从科幻小说走入现实&#xf…
阅读更多...
atomic特质的局限性

atomic特质的局限性

为什么在实际的 Objective-C 开发中, 几乎所有的属性都声明为 nonatomic ? 声明为 atomic 的属性我是真的没见过 在实际的 Objective-C 开发中，大多数属性通常声明为 nonatomic，主要原因包括性能考虑和常见的设计模式。具体原因如下： 性能问…
阅读更多...
Leetcode刷题笔记8

Leetcode刷题笔记8

162. 寻找峰值 162. 寻找峰值 - 力扣（LeetCode） 对于所有有效的 i 都有 nums[i] ! nums[i 1] 解法一：暴力解法 从第一个位置一直向后走，然后分情况即可1. 第二个元素就往下降，那么第一个元素就是峰顶 2. 一直遍历…
阅读更多...
Linux -- 正则表达式基础

Linux -- 正则表达式基础

提示：制作不易，可以点个关注和收藏哦。 前言 虽然我们这一节的标题是正则表达式，但实际这一节实验只是介绍grep，sed，awk这三个命令，而正则表达式作为这三个命令的一种使用方式（命令输出中可以包…
阅读更多...
【C++】函数模板和类模版

【C++】函数模板和类模版

目录 前言 模板参数 类型模板参数 非类型模板参数 模板的特化 函数模板的特化 类模板的特化 全特化 偏特化 模板的分离编译 模板总结 前言 函数模板和类模板是C模板编程中的两个核心概念，它们允许程序员编写泛型代码，这些代码可以在多种数据…
阅读更多...
嵌入式单片机中项目在线仿真工具分享

嵌入式单片机中项目在线仿真工具分享

前段时间，无意间发现了一个不错的在线仿真工具（Wokwi），支持多种平台，支持市面上主流的开发板，比如：STM32、ESP32、Arduino、树莓派等。 还支持常见的传感器、显示器件（LCD、LED屏幕）等，还可以播放音乐、联网、逻辑分析仪等，关键还提供了很多实际项目的案例。 这款工…
阅读更多...
对称加密系统解析

对称加密系统解析

目录​​​​​​​ 1.概述 2. 对称密码类型 3. 对称加密优缺点 4. 对称加密算法 4.1 DES 4.2 3DES 4.3 AES ​​​​​​4.4 SM1 4.5 SM4 1.概述 对称加密，是指在加密和解密时使用同一秘钥的方式。秘钥的传送和保存的保护非常重要，务必不要让秘…
阅读更多...
【React】json-server

【React】json-server

1.安装到开发环境 npm install json-server -D2.在根目录下下，新建db.json文件 {"list": [{"rpid": 3,"user": {"uid": "13258165","avatar": "http://toutiao.itheima.net/resources/images/9…
阅读更多...
显示子系统，显示子前后端，linuxfb，wayland

显示子系统，显示子前后端，linuxfb，wayland

显示前端 显示前端通常指的是在图形系统中负责生成图形数据的部分或组件。它负责接收来自应用程序或图形引擎的图形数据，并将其转换成适合显示的格式，以便发送到显示后端进行处理和输出。 显示前端的功能通常包括以下几个方面： 图形数据生…
阅读更多...
自定义类型：枚举（enum）+联合体（union）

自定义类型：枚举（enum）+联合体（union）

枚举联合体 一.枚举1.枚举类型的声明2.枚举类型的优点3.枚举类型的使用 二.联合体1.联合体类型的声明2.联合体的特点3.相同成员的结构体和联合体对比4.联合体大小的计算5.联合体的练习（判断大小端）6.联合体节省空间例题 一.枚举 1.枚举类型的声明 枚举…
阅读更多...
《软件定义安全》之四：什么是软件定义安全

《软件定义安全》之四：什么是软件定义安全

第4章 什么是软件定义安全 1.软件定义安全的含义 1.1 软件定义安全的提出 虚拟化、云计算、软件定义架构的出现，对安全体系提出了新的挑战。如果要跟上网络演进的步伐和业务快速创新的速度，安全体系应该朝以下方向演变。 𝟭 安全机制软件…
阅读更多...
springcloud gateway扩展支持多版本灰度

springcloud gateway扩展支持多版本灰度

改造要求 需要在原有的调度策略中通过客户端header中的version进行1个服务多实例下进行二次分组，让指定的version在指定的版本实例下进行轮训调度。 需要改造的点 1.业务服务在发布到naocs中的元数据需要指定版本号 2.网关的调度策略中需要增加版本的区分 3.无…
阅读更多...
LeetCode | 1.两数之和

LeetCode | 1.两数之和

这道题，很容易想到的是暴力解，直接一个双重循环，对于数组中的每一个数，都去遍历其他数字，看能不能找到数字等于target-nums[i]的数字，时间复杂度为 O ( n 2 ) O(n^2) O(n2) 但是通过其他题目，我…
阅读更多...
【算法专题--链表】环形链表--高频面试题（图文详解，小白一看就会！！）

【算法专题--链表】环形链表--高频面试题（图文详解，小白一看就会！！）

目录 一、前言 二、什么是环形链表？ 🥝 环形链表的概念详解 🍇 环形链表的特点 🍍环形链表的延申问题 三、高频面试题 ✨环形链表 ✨环形链表II ✨环形链表的环长 四、总结 五、共勉 一、前言 环形链表，可以说是…
阅读更多...
VSCode超过390万下载的请求插件

VSCode超过390万下载的请求插件

Thunder Client 是一款在 VSCode（Visual Studio Code）中非常受欢迎的 REST API 客户端插件，由Ranga Vadhineni开发，现在已经有超过390万的下载量。它允许开发者直接在编辑器内发送 HTTP 请求，查看响应。Thunder Client…
阅读更多...
力扣hot100：739. 每日温度/54. 螺旋矩阵

力扣hot100：739. 每日温度/54. 螺旋矩阵

文章目录 一、 739. 每日温度二、54. 螺旋矩阵1、模拟螺旋矩阵的路径2、按层模拟 一、 739. 每日温度 LeetCode：739. 每日温度 经典单调栈问题，求下一个更大的数。 使用单调递减栈，一个元素A出栈，当且仅当它第一次出现比它更大…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023