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

2024-06-09 11:20

本文主要是介绍Llama模型家族之Stanford NLP ReFT源代码探索 (一)数据预干预,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

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源代码探索 (一)数据预干预

pyreft/config.py

import pyvene as pv
import jsonclass ReftConfig(pv.IntervenableConfig):"""Reft config for Reft methods."""def __init__(self, **kwargs,):super().__init__(**kwargs)

pyreft/dataset.py

IGNORE_INDEX = -100no_header_prompt_template = """\
### Instruction:
%s### Response:
"""prompt_input = """Below is an instruction that \
describes a task, paired with an input that provides \
further context. Write a response that appropriately \
completes the request.### Instruction:
%s### Input:
%s### Response:
"""prompt_no_input = """Below is an instruction that \
describes a task. Write a response that appropriately \
completes the request.### Instruction:
%s### Response:
"""import os
import abc
import copy
import logging
from tqdm import tqdm
from dataclasses import dataclass, field
from typing import Dict, Optional, Sequence, Union, List, Anyimport torch
import random
import transformers
from torch.utils.data import Dataset
import datasets
from datasets import load_dataset
from collections import defaultdictfrom transformers import DataCollatordef parse_positions(positions: str):# parse positionfirst_n, last_n = 0, 0if "+" in positions:first_n = int(positions.split("+")[0].strip("f"))last_n = int(positions.split("+")[1].strip("l"))else:if "f" in positions:first_n = int(positions.strip("f"))elif "l" in positions:last_n = int(positions.strip("l"))return first_n, last_ndef get_intervention_locations(**kwargs):"""This function generates the intervention locations.For your customized dataset, you want to create your own function."""# parse kwargsshare_weights = kwargs["share_weights"] if "share_weights" in kwargs else Falselast_position = kwargs["last_position"]if "positions" in kwargs:_first_n, _last_n = parse_positions(kwargs["positions"])else:_first_n, _last_n = kwargs["first_n"], kwargs["last_n"]num_interventions = kwargs["num_interventions"]pad_mode = kwargs["pad_mode"] if "pad_mode" in kwargs else "first"first_n = min(last_position // 2, _first_n)last_n = min(last_position // 2, _last_n)pad_amount = (_first_n - first_n) + (_last_n - last_n)pad_position = -1 if pad_mode == "first" else last_positionif share_weights or (first_n == 0 or last_n == 0):position_list = [i for i in range(first_n)] + \[i for i in range(last_position - last_n, last_position)] + \[pad_position for _ in range(pad_amount)]intervention_locations = [position_list]*num_interventionselse:left_pad_amount = (_first_n - first_n)right_pad_amount = (_last_n - last_n)left_intervention_locations = [i for i in range(first_n)] + [pad_position for _ in range(left_pad_amount)]right_intervention_locations = [i for i in range(last_position - last_n, last_position)] + \[pad_position for _ in range(right_pad_amount)]# after padding, there could be still length diff, we need to do another checkleft_len = len(left_intervention_locations)right_len = len(right_intervention_locations)if left_len > right_len:right_intervention_locations += [pad_position for _ in range(left_len-right_len)]else:left_intervention_locations += [pad_position for _ in range(right_len-left_len)]intervention_locations = [left_intervention_locations]*(num_interventions//2) + \[right_intervention_locations]*(num_interventions//2)return intervention_locations@dataclass
class ReftDataCollator(object):"""Collate examples for ReFT."""data_collator: DataCollatordef __call__(self, instances: Sequence[Dict]) -> Dict[str, torch.Tensor]:batch_inputs = self.data_collator(instances)max_seq_length = batch_inputs["input_ids"].shape[-1]batch_inputs["intervention_locations"] = batch_inputs["intervention_locations"][..., :max_seq_length]return batch_inputsclass ReftDataset(Dataset):__metaclass__ = abc.ABCMetadef __init__(self, task: str, data_path: str,tokenizer: transformers.PreTrainedTokenizer,data_split="train", dataset=None, seed=42, max_n_example=None,**kwargs,):super(ReftDataset, self).__init__()result = defaultdict(list)# setupself.tokenizer = tokenizerself.first_n, self.last_n = parse_positions(kwargs["position"])self.task = taskself.data_path = data_pathself.data_split = data_splitself.dataset = datasetself.seed = seedself.max_n_example = max_n_exampleself.pad_mode = "first"self.fields_to_pad = ["input_ids", "labels"]self.fields_to_mask = ["input_ids"]# load the datasetself.preprocess(kwargs)self.task_dataset = self.load_dataset()# kwargs settingsself.postprocess(kwargs)# tokenize and interveneself.result = []for i, data_item in enumerate(tqdm(self.task_dataset)):tokenized, last_position = self.tokenize(data_item)tokenized = self.compute_intervention_and_subspaces(i, data_item, tokenized, last_position, **kwargs)self.result.append(tokenized)@abc.abstractmethoddef tokenize(self, data_item, **kwargs):"""How to tokenize a single data item. Override this function!"""returndef preprocess(self, kwargs):"""Preprocessing."""returndef postprocess(self, kwargs):"""Postprocessing."""returndef __len__(self):return len(self.result)def __getitem__(self, i) -> Dict[str, torch.Tensor]:return copy.deepcopy(self.result[i])def load_dataset(self):"""Load the dataset (or a portion of it) from HF or a local file."""# load the datasetif self.dataset is None:print("loading data for dataset: ", self.data_path)if self.data_path is None:task_dataset = load_dataset(self.task, split=self.data_split)elif self.data_path.endswith(".json"):task_dataset = load_dataset("json", data_files=self.data_path, split="train")else:task_dataset = load_dataset(self.task, self.data_path, split=self.data_split)else:task_dataset = self.dataset# select n random examples if specificedif self.max_n_example is not None:task_dataset = task_dataset.shuffle(seed=self.seed)task_dataset = task_dataset.select(range(self.max_n_example))# save raw_dataset pointer for access raw stringsself.raw_dataset = task_dataset if self.data_split != "train" else Nonereturn task_datasetdef get_intervention_locations(self, **kwargs):return get_intervention_locations(**kwargs)def compute_intervention_and_subspaces(self, id: int, data_item, result: dict, last_position: int, **kwargs):# compute intervention locsintervention_locations = self.get_intervention_locations(last_position=last_position, first_n=self.first_n, last_n=self.last_n, pad_mode=self.pad_mode, **kwargs)result["intervention_locations"] = intervention_locationsresult["id"] = id# add a single padding token BEFORE input_ids and fix everythingif self.pad_mode == "first":for field in self.fields_to_pad:if field not in result:continueif field == "labels":result[field] = torch.cat((torch.tensor([IGNORE_INDEX,]), result[field]))else:result[field] = torch.cat((torch.tensor([self.tokenizer.pad_token_id,]), result[field]))result["intervention_locations"] = (torch.IntTensor(result["intervention_locations"]) + 1).tolist()elif self.pad_mode == "last":for field in self.fields_to_pad:if field not in result:continueif field == "labels":result[field] = torch.cat((result[field], torch.tensor([IGNORE_INDEX,])))else:result[field] = torch.cat((result[field], torch.tensor([self.tokenizer.pad_token_id,])))# attention masksif len(self.fields_to_mask) == 1:result["attention_mask"] = (result[self.fields_to_mask[0]] != self.tokenizer.pad_token_id).int()else:for field in self.fields_to_mask:result[f"{field}_mask"] = (result[field] != self.tokenizer.pad_token_id).int()# subspacesif "subspaces" in data_item:num_interventions = kwargs["num_interventions"]share_weights = kwargs["share_weights"] if "share_weights" in kwargs else Falseif share_weights:num_interventions = num_interventions // 2# we now assume each task has a constant subspaces_subspaces = [data_item["subspaces"]] * num_interventionsresult["subspaces"] = _subspacesreturn resultclass ReftRawDataset(Dataset):def __init__(self, task: str, data_path: str,tokenizer: transformers.PreTrainedTokenizer,data_split="train", dataset=None, seed=42, max_n_example=None, **kwargs,):super(ReftRawDataset, self).__init__()result = defaultdict(list)if dataset is None:print("loading data for dataset: ", data_path)if data_path.endswith(".json"):task_dataset = load_dataset("json", data_files=data_path)[data_split]else:task_dataset = load_dataset(data_path)[data_split]else:task_dataset = datasetif max_n_example is not None:task_dataset = task_dataset.shuffle(seed=seed)task_dataset = task_dataset.select(range(max_n_example))# save raw_dataset pointer for access raw stringsself.raw_dataset = task_dataset if data_split != "train" else Nonefirst_n, last_n = parse_positions(kwargs["position"])# tokenize and intervenefor i, data_item in enumerate(tqdm(task_dataset)):base_prompt = data_item["instruction"]base_input = base_prompt + data_item["output"] + tokenizer.eos_token# tokenizebase_prompt_ids = tokenizer(base_prompt, max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]base_prompt_length = len(base_prompt_ids)if data_split == "train":base_input_ids = tokenizer(base_input, max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]output_ids = copy.deepcopy(base_input_ids)output_ids[:base_prompt_length] = IGNORE_INDEXresult["input_ids"].append(base_input_ids)result["labels"].append(output_ids)else:# print("Assuming test split for now")result["input_ids"].append(base_prompt_ids)last_position = base_prompt_length# get intervention locationsintervention_locations = self.get_intervention_locations(last_position=last_position, first_n=first_n, last_n=last_n,pad_mode="first",**kwargs)result["intervention_locations"].append(intervention_locations)result["id"].append(i)# add a single padding token BEFORE input_ids and fix everythingresult["input_ids"][-1] = torch.cat((torch.tensor([tokenizer.pad_token_id,]), result["input_ids"][-1]))if data_split == "train":result["labels"][-1] = torch.cat((torch.tensor([IGNORE_INDEX]), result["labels"][-1]))result["intervention_locations"][-1] = (torch.IntTensor(result["intervention_locations"][-1]) + 1).tolist()result["attention_mask"].append((result["input_ids"][-1] != tokenizer.pad_token_id).int())if "subspaces" in data_item:num_interventions = kwargs["num_interventions"]share_weights = kwargs["share_weights"] if "share_weights" in kwargs else Falseif share_weights:num_interventions = num_interventions // 2# we now assume each task has a constant subspaces_subspaces = [data_item["subspaces"]] * num_interventionsresult["subspaces"].append(_subspaces)self.input_ids = result["input_ids"]self.attention_mask = result["attention_mask"]self.intervention_locations = result["intervention_locations"]self.labels = result["labels"] if "labels" in result else Noneself.subspaces = result["subspaces"] if "subspaces" in result else Noneself.id = result["id"]def get_intervention_locations(self, **kwargs):return get_intervention_locations(**kwargs)def __len__(self):return len(self.input_ids)def __getitem__(self, i) -> Dict[str, torch.Tensor]:return_dict = dict(input_ids=self.input_ids[i],attention_mask=self.attention_mask[i],intervention_locations=self.intervention_locations[i],id=self.id[i],)if self.labels is not None:return_dict["labels"] = self.labels[i]if self.subspaces is not None:return_dict["subspaces"] = self.subspaces[i]return return_dictclass ReftClassificationDataset(ReftDataset):"""A ReftClassificationDataset only contains a single text fieldthat we tokenize, intervene on a prefix + suffix of, andcompute subspace settings for. This is intended for classificationtasks.Remember to pass in the input_field and label_field as kwargs."""def preprocess(self, kwargs):self.input_field = kwargs["input_field"]self.label_field = kwargs["label_field"]def tokenize(self, data_item):result = {}# inputinput_ids = self.tokenizer(data_item[self.input_field], max_length=self.tokenizer.model_max_length,truncation=True, return_tensors="pt")["input_ids"][0]base_prompt_length = len(input_ids)last_position = base_prompt_length - 1result["input_ids"] = input_ids# labelsif self.label_field == self.input_field:result["labels"] = input_ids.clone()elif self.label_field is not None:labels = self.tokenizer(data_item[self.label_field], max_length=self.tokenizer.model_max_length,truncation=True, return_tensors="pt")["input_ids"][0]result["labels"] = labelsreturn result, last_positionclass ReftGenerationDataset(ReftDataset):"""A ReftGenerationDataset contains an instruction and a completion for each data item. We intervene on a prefix + suffixof *only the instruction*. This is suitable for generation taskswhere you don't want inference overhead during decoding.Remember to pass in the prompt_field and completion_field as kwargs."""def preprocess(self, kwargs):self.prompt_field = kwargs["prompt_field"]self.completion_field = kwargs["completion_field"]def tokenize(self, data_item):result = {}# promptprompt_ids = self.tokenizer(data_item[self.prompt_field], max_length=self.tokenizer.model_max_length,truncation=True, return_tensors="pt")["input_ids"][0]base_prompt_length = len(prompt_ids)last_position = base_prompt_length - 1# inputfull_input = data_item[self.prompt_field] + data_item[self.completion_field] + self.tokenizer.eos_tokeninput_ids = self.tokenizer(full_input, max_length=self.tokenizer.model_max_length,truncation=True, return_tensors="pt")["input_ids"][0]result["input_ids"] = input_ids# labelsoutput_ids = copy.deepcopy(input_ids)output_ids[:base_prompt_length] = IGNORE_INDEXresult["labels"] = output_idsreturn result, last_positionclass ReftSupervisedDataset(ReftDataset):"""Alpaca-style supervised dataset. We intervene on a prefix + suffixof the input. This is suitable for supervised fine-tuning tasks.Remember to pass in the input_field, output_field, and instruction_field as kwargs."""def preprocess(self, kwargs):self.input_field = kwargs["input_field"]self.output_field = kwargs["output_field"]self.instruction_field = kwargs["instruction_field"]def tokenize(self, data_item):result = {}# promptif self.input_field not in data_item or data_item[self.input_field] == "":base_prompt = prompt_no_input % (data_item[self.instruction_field])else:base_prompt = prompt_input % (data_item[self.instruction_field], data_item[self.input_field])prompt_ids = self.tokenizer(base_prompt, max_length=self.tokenizer.model_max_length,truncation=True, return_tensors="pt")["input_ids"][0]base_prompt_length = len(prompt_ids)last_position = base_prompt_length - 1# inputbase_input = base_prompt + data_item[self.output_field] + self.tokenizer.eos_tokeninput_ids = self.tokenizer(base_input, max_length=self.tokenizer.model_max_length,truncation=True, return_tensors="pt")["input_ids"][0]result["input_ids"] = input_ids# labelsoutput_ids = copy.deepcopy(input_ids)output_ids[:base_prompt_length] = IGNORE_INDEXresult["labels"] = output_idsreturn result, last_positiondef make_last_position_supervised_chat_data_module(tokenizer: transformers.PreTrainedTokenizer, model, inputs, outputs, num_interventions=1, nonstop=False
) -> Dict:"""Make dataset and collator for supervised fine-tuning."""all_base_input_ids, all_intervention_locations, all_output_ids = [], [], []for i in range(len(inputs)):_input = inputs[i]_output = outputs[i]base_prompt = _inputbase_input = base_prompt + _outputif not nonstop:base_input += tokenizer.eos_token# tokenizebase_prompt_ids = tokenizer(base_prompt, max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]base_prompt_length = len(base_prompt_ids)base_input_ids = tokenizer(base_input, max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]output_ids = copy.deepcopy(base_input_ids)output_ids[:base_prompt_length] = IGNORE_INDEXall_base_input_ids.append(base_input_ids)all_intervention_locations.append([[base_prompt_length - 1]]*num_interventions)all_output_ids.append(output_ids)train_dataset = datasets.Dataset.from_dict({"input_ids": all_base_input_ids,"intervention_locations": all_intervention_locations,"labels": all_output_ids,})data_collator_fn = transformers.DataCollatorForSeq2Seq(tokenizer=tokenizer,model=model,label_pad_token_id=-100,padding="longest")data_collator = ReftDataCollator(data_collator=data_collator_fn)return dict(train_dataset=train_dataset, eval_dataset=None, data_collator=data_collator)def make_last_position_supervised_data_module(tokenizer: transformers.PreTrainedTokenizer, model, inputs, outputs, num_interventions=1, nonstop=False
) -> Dict:"""Make dataset and collator for supervised fine-tuning."""all_base_input_ids, all_intervention_locations, all_output_ids = [], [], []for i in range(len(inputs)):_input = inputs[i]_output = outputs[i]base_prompt = _inputbase_input = base_prompt + _outputif not nonstop:base_input += tokenizer.eos_token# tokenizebase_prompt_ids = tokenizer(base_prompt, max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]base_prompt_length = len(base_prompt_ids)base_input_ids = tokenizer(base_input, max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]output_ids = copy.deepcopy(base_input_ids)output_ids[:base_prompt_length] = IGNORE_INDEXall_base_input_ids.append(base_input_ids)all_intervention_locations.append([[base_prompt_length - 1]]*num_interventions)all_output_ids.append(output_ids)train_dataset = datasets.Dataset.from_dict({"input_ids": all_base_input_ids,"intervention_locations": all_intervention_locations,"labels": all_output_ids,})data_collator_fn = transformers.DataCollatorForSeq2Seq(tokenizer=tokenizer,model=model,label_pad_token_id=-100,padding="longest")data_collator = ReftDataCollator(data_collator=data_collator_fn)return dict(train_dataset=train_dataset, eval_dataset=None, data_collator=data_collator)def make_multiple_position_supervised_data_module(tokenizer: transformers.PreTrainedTokenizer, model, inputs, outputs, positions="f1+l1", num_interventions=1, nonstop=False, share_weights=False
) -> Dict:"""Make dataset and collator for supervised fine-tuning."""first_n, last_n = parse_positions(positions)all_base_input_ids, all_intervention_locations, all_output_ids = [], [], []for i in range(len(inputs)):_input = inputs[i]_output = outputs[i]base_prompt = _inputbase_input = base_prompt + _outputif not nonstop:base_input += tokenizer.eos_token# tokenizebase_prompt_ids = tokenizer(base_prompt, max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]base_prompt_length = len(base_prompt_ids)base_input_ids = tokenizer(base_input, max_length=tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]output_ids = copy.deepcopy(base_input_ids)output_ids[:base_prompt_length] = IGNORE_INDEXintervention_locations = get_intervention_locations(last_position=base_prompt_length, first_n=first_n, last_n=last_n,pad_mode="last",num_interventions=num_interventions,share_weights=share_weights,)all_base_input_ids.append(base_input_ids)all_intervention_locations.append(intervention_locations)all_output_ids.append(output_ids)train_dataset = datasets.Dataset.from_dict({"input_ids": all_base_input_ids,"intervention_locations": all_intervention_locations,"labels": all_output_ids,})data_collator_fn = transformers.DataCollatorForSeq2Seq(tokenizer=tokenizer,model=model,label_pad_token_id=-100,padding="longest")data_collator = ReftDataCollator(data_collator=data_collator_fn)return dict(train_dataset=train_dataset, eval_dataset=None, data_collator=data_collator)class ReftPreferenceDataset(ReftDataset):"""Different from ReftSupervisedDataset where we have(x, y)ReftPreferenceDataset contains (x, y1, y2) where y1 and y2are constrastive pairs.ReFT training objective is to generate y2, given (x, y1) andthe intervention."""def preprocess(self, kwargs):self.input_field = kwargs["input_field"]self.instruction_field = kwargs["instruction_field"]self.chosen_output_field = kwargs["chosen_output_field"]self.rejected_output_field = kwargs["rejected_output_field"]def tokenize(self, data_item):result = {}if self.input_field not in data_item or data_item[self.input_field] == "":base_prompt = prompt_no_input % (data_item[self.instruction_field])else:base_prompt = prompt_input % (data_item[self.instruction_field], data_item[self.input_field])# base input takes rejected output to steer away from.base_input = base_prompt + data_item[self.rejected_output_field] + self.tokenizer.eos_token# tokenizebase_prompt_ids = self.tokenizer(base_prompt, max_length=self.tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]base_prompt_length = len(base_prompt_ids)if self.data_split == "train":base_input_ids = self.tokenizer(base_input, max_length=self.tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]# base output takes chosen output to steer towards to.base_output = base_prompt + data_item[self.chosen_output_field] + self.tokenizer.eos_tokenbase_output_ids = self.tokenizer(base_output, max_length=self.tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]output_ids = base_output_idsoutput_ids[:base_prompt_length] = IGNORE_INDEX# padding! needs to be cautious here. let's unpack:# pad inputs with pad_token_id so that attention masks can ignore these tokens.# pad outputs with IGNORE_INDEX so that loss calculation can ignore these tokens.# and the goal is to have input and output have the same length.max_length = max(base_input_ids.size(0), output_ids.size(0))input_pad_length = max_length - base_input_ids.size(0)output_pad_length = max_length - output_ids.size(0)input_pad_tensor = torch.full((input_pad_length,), self.tokenizer.pad_token_id, dtype=torch.long)output_pad_tensor = torch.full((output_pad_length,), IGNORE_INDEX, dtype=torch.long)base_input_ids_padded = torch.cat((base_input_ids, input_pad_tensor), dim=0)output_ids_padded = torch.cat((output_ids, output_pad_tensor), dim=0)result["input_ids"] = base_input_ids_paddedresult["labels"] = output_ids_paddedelse:# print("Assuming test split for now")result["input_ids"] = base_prompt_idslast_position = base_prompt_lengthreturn result, last_positionclass ReftRewardDataset(ReftDataset):def preprocess(self, kwargs):self.conv_A_field = kwargs["conv_A_field"]self.conv_B_field = kwargs["conv_B_field"]self.prompt_field = kwargs["prompt_field"] if "prompt_field" in kwargs else Noneself.conv_A_reward_field = kwargs["conv_A_reward_field"] if "conv_A_reward_field" in kwargs else Noneself.conv_B_reward_field = kwargs["conv_B_reward_field"] if "conv_B_reward_field" in kwargs else Noneself.fields_to_pad = ["chosen_output", "rejected_output"] # pad both chosen and rejected with dummy tokself.fields_to_mask = ["chosen_output", "rejected_output"] # -> chosen_output_mask, rejected_output_maskdef tokenize(self, data_item):result = {}# generate prompt formatif self.prompt_field is not None:data_item[self.conv_A_field] = [{"role": "user", "content": data_item[self.prompt_field]},{"role": "assistant", "content": data_item[self.conv_A_field]}]data_item[self.conv_B_field] = [{"role": "user", "content": data_item[self.prompt_field]},{"role": "assistant", "content": data_item[self.conv_B_field]}]chosen_output = self.tokenizer.apply_chat_template(data_item[self.conv_A_field], tokenize=False, add_generation_prompt=False).replace(self.tokenizer.bos_token, "")rejected_output = self.tokenizer.apply_chat_template(data_item[self.conv_B_field], tokenize=False, add_generation_prompt=False).replace(self.tokenizer.bos_token, "")# rewardif self.conv_A_reward_field is not None:result["chosen_reward"] = data_item[self.conv_A_reward_field]result["rejected_reward"] = data_item[self.conv_B_reward_field]# swap so that chosen is betterif result["chosen_reward"] < result["rejected_reward"]:chosen_output, rejected_output = rejected_output, chosen_outputresult["chosen_reward"], result["rejected_reward"] = result["rejected_reward"], result["chosen_reward"]# tokenizechosen_ids = self.tokenizer(chosen_output, max_length=self.tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]rejected_ids = self.tokenizer(rejected_output, max_length=self.tokenizer.model_max_length, truncation=True, return_tensors="pt")["input_ids"][0]base_prompt_length = 0for i in range(min(len(chosen_ids), len(rejected_ids))):base_prompt_length += 1if chosen_ids[i] != rejected_ids[i]:breaklast_position = base_prompt_length - 1result["chosen_output"] = chosen_idsresult["rejected_output"] = rejected_idsreturn result, last_position@dataclass
class ReftRewardCollator:tokenizer: transformers.PreTrainedTokenizerpadding: Union[bool, str] = Truemax_length: Optional[int] = Nonepad_to_multiple_of: Optional[int] = Nonereturn_tensors: str = "pt"def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, Any]:merged_features = []for feature in features:merged_features.append({"input_ids": feature["chosen_output"],"attention_mask": feature["chosen_output_mask"],"reward": feature["chosen_reward"] if "chosen_reward" in feature else 1.0,"intervention_locations": feature["intervention_locations"],})merged_features.append({"input_ids": feature["rejected_output"],"attention_mask": feature["rejected_output_mask"],"reward": feature["rejected_reward"] if "rejected_reward" in feature else 0.0,"intervention_locations": feature["intervention_locations"],})batch = self.tokenizer.pad(merged_features,padding=self.padding,max_length=self.max_length,pad_to_multiple_of=self.pad_to_multiple_of,return_tensors=self.return_tensors,)batch = {"input_ids": batch["input_ids"],"attention_mask": batch["attention_mask"],"reward": batch["reward"],"intervention_locations": batch["intervention_locations"],}max_seq_length = batch["input_ids"].shape[-1]batch["intervention_locations"] = batch["intervention_locations"][..., :max_seq_length]return batch
  1. 数据集类定义 (ReftDataset, ReftRawDataset, ReftClassificationDataset, ReftGenerationDataset, ReftSupervisedDataset, ReftPreferenceDataset, ReftRewardDataset): 这些类继承自Dataset类,用于创建不同的数据集,它们处理文本数据的加载、分词(tokenization)、干预位置的计算以及数据的格式化。

  2. 干预位置计算 (get_intervention_locations): 这个函数用于确定文本中干预的位置,这些位置将用于模型训练时的特定干预策略。

  3. 数据整理 (ReftDataCollator): 这个类继承自DataCollator,用于在批处理数据时整理干预位置和其它相关数据。

  4. 数据集加载和预处理 (load_dataset, preprocess, postprocess): 这些方法用于加载数据集文件,进行预处理,如选择特定数量的样本或应用特定的数据集设置。

  5. 分词和干预 (tokenize, compute_intervention_and_subspaces): 这些方法用于将文本数据分词,并根据干预位置进行处理,以便模型可以学习在特定位置进行干预。

  6. 数据集项的获取 (__getitem__): 这些方法用于从数据集中获取单个数据项,通常返回一个包含input_ids, attention_mask, intervention_locations等字段的字典。

  7. 数据集长度 (__len__): 这些方法返回数据集的长度。

  8. 数据模块生成函数 (make_last_position_supervised_chat_data_module, make_last_position_supervised_data_module, make_multiple_position_supervised_data_module): 这些函数用于生成用于监督式微调的数据模块,包括数据集和数据整理器。

  9. 奖励数据整理 (ReftRewardCollator): 这个类用于整理奖励数据集,它将正例和负例的输入、注意力掩码、奖励和干预位置合并为一个批次。

  10. 特殊标记 (IGNORE_INDEX): 这个常量用于在标签中指示模型忽略某些标记,通常用于处理序列填充。

这段代码是一个复杂的NLP处理流程,涵盖了数据加载、预处理、分词、干预计算、数据整理和批次生成等多个方面。

在这里插入图片描述
在这里插入图片描述

大模型技术分享

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

《企业级生成式人工智能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语言模型架构、数学原理及内幕机制-简介

这篇关于Llama模型家族之Stanford NLP ReFT源代码探索 (一)数据预干预的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1045037

相关文章

大模型研发全揭秘:客服工单数据标注的完整攻略

在人工智能(AI)领域,数据标注是模型训练过程中至关重要的一步。无论你是新手还是有经验的从业者,掌握数据标注的技术细节和常见问题的解决方案都能为你的AI项目增添不少价值。在电信运营商的客服系统中,工单数据是客户问题和解决方案的重要记录。通过对这些工单数据进行有效标注,不仅能够帮助提升客服自动化系统的智能化水平,还能优化客户服务流程,提高客户满意度。本文将详细介绍如何在电信运营商客服工单的背景下进行

基于MySQL Binlog的Elasticsearch数据同步实践

一、为什么要做 随着马蜂窝的逐渐发展,我们的业务数据越来越多,单纯使用 MySQL 已经不能满足我们的数据查询需求,例如对于商品、订单等数据的多维度检索。 使用 Elasticsearch 存储业务数据可以很好的解决我们业务中的搜索需求。而数据进行异构存储后,随之而来的就是数据同步的问题。 二、现有方法及问题 对于数据同步,我们目前的解决方案是建立数据中间表。把需要检索的业务数据,统一放到一张M

关于数据埋点,你需要了解这些基本知识

产品汪每天都在和数据打交道,你知道数据来自哪里吗? 移动app端内的用户行为数据大多来自埋点,了解一些埋点知识,能和数据分析师、技术侃大山,参与到前期的数据采集,更重要是让最终的埋点数据能为我所用,否则可怜巴巴等上几个月是常有的事。   埋点类型 根据埋点方式,可以区分为: 手动埋点半自动埋点全自动埋点 秉承“任何事物都有两面性”的道理:自动程度高的,能解决通用统计,便于统一化管理,但个性化定

使用SecondaryNameNode恢复NameNode的数据

1)需求: NameNode进程挂了并且存储的数据也丢失了,如何恢复NameNode 此种方式恢复的数据可能存在小部分数据的丢失。 2)故障模拟 (1)kill -9 NameNode进程 [lytfly@hadoop102 current]$ kill -9 19886 (2)删除NameNode存储的数据(/opt/module/hadoop-3.1.4/data/tmp/dfs/na

异构存储(冷热数据分离)

异构存储主要解决不同的数据,存储在不同类型的硬盘中,达到最佳性能的问题。 异构存储Shell操作 (1)查看当前有哪些存储策略可以用 [lytfly@hadoop102 hadoop-3.1.4]$ hdfs storagepolicies -listPolicies (2)为指定路径(数据存储目录)设置指定的存储策略 hdfs storagepolicies -setStoragePo

Hadoop集群数据均衡之磁盘间数据均衡

生产环境,由于硬盘空间不足,往往需要增加一块硬盘。刚加载的硬盘没有数据时,可以执行磁盘数据均衡命令。(Hadoop3.x新特性) plan后面带的节点的名字必须是已经存在的,并且是需要均衡的节点。 如果节点不存在,会报如下错误: 如果节点只有一个硬盘的话,不会创建均衡计划: (1)生成均衡计划 hdfs diskbalancer -plan hadoop102 (2)执行均衡计划 hd

深入探索协同过滤:从原理到推荐模块案例

文章目录 前言一、协同过滤1. 基于用户的协同过滤(UserCF)2. 基于物品的协同过滤(ItemCF)3. 相似度计算方法 二、相似度计算方法1. 欧氏距离2. 皮尔逊相关系数3. 杰卡德相似系数4. 余弦相似度 三、推荐模块案例1.基于文章的协同过滤推荐功能2.基于用户的协同过滤推荐功能 前言     在信息过载的时代,推荐系统成为连接用户与内容的桥梁。本文聚焦于

Andrej Karpathy最新采访:认知核心模型10亿参数就够了,AI会打破教育不公的僵局

夕小瑶科技说 原创  作者 | 海野 AI圈子的红人,AI大神Andrej Karpathy,曾是OpenAI联合创始人之一,特斯拉AI总监。上一次的动态是官宣创办一家名为 Eureka Labs 的人工智能+教育公司 ,宣布将长期致力于AI原生教育。 近日,Andrej Karpathy接受了No Priors(投资博客)的采访,与硅谷知名投资人 Sara Guo 和 Elad G

【Prometheus】PromQL向量匹配实现不同标签的向量数据进行运算

✨✨ 欢迎大家来到景天科技苑✨✨ 🎈🎈 养成好习惯,先赞后看哦~🎈🎈 🏆 作者简介:景天科技苑 🏆《头衔》:大厂架构师,华为云开发者社区专家博主,阿里云开发者社区专家博主,CSDN全栈领域优质创作者,掘金优秀博主,51CTO博客专家等。 🏆《博客》:Python全栈,前后端开发,小程序开发,人工智能,js逆向,App逆向,网络系统安全,数据分析,Django,fastapi

Retrieval-based-Voice-Conversion-WebUI模型构建指南

一、模型介绍 Retrieval-based-Voice-Conversion-WebUI(简称 RVC)模型是一个基于 VITS(Variational Inference with adversarial learning for end-to-end Text-to-Speech)的简单易用的语音转换框架。 具有以下特点 简单易用:RVC 模型通过简单易用的网页界面,使得用户无需深入了