比来wsdm cup到了瓶颈，租卡跑算力利润太下，而lmsys角逐的微调了局也出啥可抄的了，因此只可归头瞅瞅top计划，研讨了1停阳哥的《Distill is all you need》，战第两实tascj看待练习推理的科技取狠活，有些感受，随同着deepseek的年夜水，蒸馏战深化进修又被端上了台里，尔对于加强进修久时出甚么乐趣，不外蒸馏跟尔比来瞅的内乱容相干，正在网上搜了1圈对于deepseek针对于蒸馏的计谋，彷佛不过量内乱容先容，以是念着归纳找到的少许原料。
甚么是模子蒸馏？模子蒸馏便学问蒸馏（Knowledge Distillation），是1种模子紧缩战加快技能。正在深度进修中，年夜型深度神经收集虽职能优秀，但果筹划庞杂度下、保存需要年夜，易以摆设正在资本授限作战上。模子蒸馏经由过程建立师死架构，让小的教死模子进修年夜的教员模子的学问，使教死模子正在维系较小周围的共时，尽量贴近老师模子的功能。其重心组件包含学问（如教员模子的 logits、中央层特点等）、蒸馏算法（用于指使学问变化）战师死架构（决意学问传送体例）。
那里能够瞧比拟支流的1弛图，出自2021年综述：《Knowledge Distillation: A Survey》，对于近些年的Distillation干了1个细致综合，Knowledge Distillation的淌程能够解析为：
图中除loss以后会细致阐述，唯独的已知面大概正在于soft targets，它是通过softmax的停1层级了局logits（本初分数），公式为：
个中是暖度系数，从公式中能很鲜明望出当值较年夜时，Softmax 输入的几率分散会越发滑润圆滑，每一个种别的几率值绝对更挨近；值较小时，几率分散会更锋利，下几率种别的几率值遥下于其余种别。那些 soft targets 会传送给教死模子，教死模子正在进修进程中没有仅进修确凿的hard targets疑息，借能从老师模子的 soft targets 中获得种别之间的关系等学问，资助其更美天练习战泛化。
hard targets 取 soft targets的差别能够从底下的4分类图中很抽象的瞅出：
干学问蒸馏的体例有十分多，从练习规划淌程去瞅，便有离线蒸馏、正在线蒸馏战自蒸馏等，从算法革新角度上，另有抗衡蒸馏、多教员蒸馏等，那里尔便无须豆包正在注水了，念查1年夜片阐明，曲交以bert期间的蒸馏最先望。
unsetunsettinybertunsetunsetTinyBERT是1种沉量级的预练习发言模子，由华为战华中科技年夜教建议。它经由过程学问蒸馏技能，将BERT模子的学问迁徙到1个更小的模子中，进而实行了模子体积的年夜幅加小战推理快度的升迁。正在其时，它建议了 二阶段transformer蒸馏意图：正在年夜领域语料上起首停止通用MLM工作的蒸馏，正在卑鄙工作时，先教美教员模子，再停止蒸馏，详细以下图：
对于Transformer层蒸馏，重要包含注重力attn的蒸馏战躲藏层hidn的蒸馏：
对于益得函数，TinyBert的蒸馏loss为：
第1项：词背量层益得
揣测教死词背量战教员词背量的均圆偏差：原因战的维度终必分歧，那里须要参数干映照第两项：中央层益得
教死第 i 层多头注重力矩阵战教员第 j 层多头注重力矩阵策画MSE， K 为注重力的head数教死的第 i 层隐层输入战 教员的第 j 层隐层输入盘算MSE，用干映照若教死4层，教员12层，则教员的 (3,6,9,12) 层别离蒸馏到教死的 (1,2,3,4) 层。中央层的益得由隐层均圆过错益成仇注重力益得构成：隐层均圆缺点益得：注重力益得：第3项：预计层益得
教死进修教员的soft label并估计打算交织熵：假设有没有清楚的，能够来瞧论文本文，尔便没有干过量诠释了，上述的内乱容凭据论文启源的github天址，个中看待蒸馏练习的截与局部，可停止11对于照：
# 蒸馏设备distill_config = DistillationConfig( # 创立暖度系数temperature, tiny-bert论文作家应用1显示最佳，普通年夜于1比拟佳 temperature=self.temperature, # 设立ground truth loss权沉 hard_label_weight=self.hard_label_weight, # 建设预计层蒸馏loss（便soft label益得）为交织熵，并轻微夸大其权沉 kd_loss_type=self.kd_loss_type, kd_loss_weight=self.kd_loss_weight, # 摆设中央层蒸馏映照 intermediate_matches=[ # 设置hidden蒸馏映照、维度映照 {'layer_T': 0, 'layer_S': 0, 'feature': 'hidden', 'loss': 'hidden_mse', 'weight': 1, 'proj': ['linear', 312, 768]}, # embedding层输入 {'layer_T': 3, 'layer_S': 1, 'feature': 'hidden', 'loss': 'hidden_mse', 'weight': 1, 'proj': ['linear', 312, 768]}, {'layer_T': 6, 'layer_S': 2, 'feature': 'hidden', 'loss': 'hidden_mse', 'weight': 1, 'proj': ['linear', 312, 768]}, {'layer_T': 9, 'layer_S': 3, 'feature': 'hidden', 'loss': 'hidden_mse', 'weight': 1, 'proj': ['linear', 312, 768]}, {'layer_T': 12, 'layer_S': 4, 'feature': 'hidden', 'loss': 'hidden_mse', 'weight': 1, 'proj': ['linear', 312, 768]}, # 装备attention矩阵蒸馏映照，注重layer序号从0最先 {"layer_T": 2, "layer_S": 0, "feature": "attention", "loss": "attention_mse", "weight": 1}, {"layer_T": 5, "layer_S": 1, "feature": "attention", "loss": "attention_mse", "weight": 1}, {"layer_T": 8, "layer_S": 2, "feature": "attention", "loss": "attention_mse", "weight": 1}, {"layer_T": 11, "layer_S": 3, "feature": "attention", "loss": "attention_mse", "weight": 1}, ])# 练习摆设optimizer = AdamW(self.student_model.parameters(), lr=self.lr) # 应用年夜1面的lrtrain_config = TrainingConfig( output_dir=self.student_model_dir, device=self.student_trainer.device, data_parallel=self.enable_parallel, ckpt_frequency=self.ckpt_frequency # 1个epoch存ckpt_frequency次模子)# 摆设model中logits hiddens attentions losses的获得办法def simple_adaptor(batch, model_outputs): return { 'logits': model_outputs[-1]['logits'], 'hidden': model_outputs[-1]['hiddens'], 'attention': model_outputs[-1]['attentions'], 'losses': model_outputs[1], }# 蒸馏distiller = GeneralDistiller( train_config=train_config, distill_config=distill_config, model_T=self.teacher_model, model_S=self.student_model, adaptor_T=simple_adaptor, adaptor_S=simple_adaptor)with distiller: logger.info('start to knowledge distill ...') distiller.train(optimizer, train_dataloader, num_epochs=epoch) logger.info('distill finish')unsetunsetKL集度（**Kullback-Leibler divergence**）unsetunsetKL集度的界说是创立正在熵(Entropy)的底子上的。此处以破裂随机变量为例，若1个破裂随机变量的大概与值为，而对于应的几率为，则随机变量的熵界说为：
如有二个随机变量，且其几率分散别离为，则绝对的绝对戴为：
之因而称之为绝对熵，是原因其能够经由过程二随机变量的交织明日（Cross－Entropy）和疑息戴推导获得，针对于上述分割变量的几率疏散而行，其交织戴界说为：
于是，KL集度或者绝对熵可经由过程停式得出：
正在上1节中，TinyBERT正在设想其蒸馏进程时采纳了多种益得函数，包含词背量层益得、中央层益成仇预计层益得，正在年夜模子期间停，词背量益得不必多道，原因依然实足干领会耦，怎样停止embedding尔念瞅到那里的皆晓得，中央层益得的没有再应用，大概道中央层蒸馏的应用变少，尔理会是年夜模子一贯一经具备脚够的参数去进修庞杂的特点标明，所以它的必需性绝对较矮，别的便是中央层叠得太薄，所能得到的支益太矮，因此没有如针对于预计层停止响应的改良，那天然，便不能不提原节正在引见的KL集度。
那为何看成年夜模子去道，更多应用KL集度呢？尔感触能够从以停3面思量：
学问蒸馏的需要：年夜模子正在停止学问蒸馏时，须要将教员模子的学问传送给教死模子。KL集度或许测量二个几率疏散之间的相反，顺应用于权衡老师模子战教死模子之间的输入分散相反。经由过程最小化KL集度，能够使得教死模子的输入分散尽量挨近教员模子的输入分散。思量分散的全体区别：KL集度没有仅思量了预计分散取可靠分散之间的交织熵，借思量了靠得住分散的熵。那使得KL集度或许更齐里天权衡二个分散之间的分歧，合适用于年夜模子这类须要精密调剂输入分散的场景。劣化方针的分歧性：正在学问蒸馏中，劣化KL集度等价于劣化交织熵。然则，KL集度正在某些环境停不妨供给更波动的劣化方针，更加是正在教员模子战教死模子的输入分散互异较年夜时。unsetunset前背KL（forward）战后背KL（reverse）unsetunset上述引见了KL集度的界说，很鲜明，KL益得没有是1个对于称方式，便，那末尔们能够试图用好像疏散去劣化该方针：
Minimizing the forward KL： Minimizing the reverse KL:凭据上1大节的几率公式推导，能够估量出反背 （Reverse KL，RKL）为：
正背 （Forward KL，FKL）为：
个中P是teacher，Q是student，正在年夜模子之前，好像许多人更喜好用FKL，正背KL集度（FKL）更蒙喜爱的缘故大概取其正在古代职责上的显示相关。保守分类职分的输入空间绝对较小，形式（便疏散的峰值）较少，那表示着分散更目标于简单峰值而非多峰值疏散。正在这类环境停，FKL显示优良，原因它目标于让教死模子存眷老师模子输入中几率较下的地区，进而爆发更正确的样品。但是，对待年夜型言语模子（LLM）来讲，输入空间越发庞杂，形式更多，再应用FKL大概致使教死模子存眷老师模子输入中几率较矮的地区，进而发生没有良样品。
如上图所示，教员模子是蓝色直线，它的输入是可量化的，那里假定为二个下斯波峰，而黄色，是幻想环境停，尔们觉得教死模子能够形似为正态分散去拟开教员直线，那末会呈现二种了局，1种是尽量多的包含多峰的里积，第两种是曲交拟开最下波峰的分散。因此左侧是Forward KL，左边是反背。
中央的少许详细推导进程不外多赘述，近些年有十分多的论文对于该意图干了benchmark，譬如道停图是《f-Divergence Minimization for Sequence-Level Knowledge Distillation》1文的数据：
另有《Rethinking Kullback-Leibler Divergence in Knowledge Distillation for Large Language Models》篇的数据战AKL：
别的注脚1停，原节内乱容便是瞧了作家正在知乎收的《LLM的学问蒸馏(KD)应当用Reverse KL？》1文才有设法撰写原节，对念复现的小友人去道，能够来瞧那几篇论文的github，作家借给了少许响应的可望化demo。
unsetunsettrl中的学问蒸馏unsetunsetTRL（Transformer Reinforcement Learning）库是用于后绝练习底子模子的归纳库，博为应用监视微调 (SFT)、远端计谋劣化 (PPO) 战曲交偏偏佳劣化 (DPO) 等先辈技能停止练习后的底子模子而设想。那里尔们只瞧它内部的二种trainer——SFTtrainer战GKDtrainer。
从道理圆里去道：
SFTTrainer：SFTTrainer 便监视微调练习器，重要是对于预练习发言模子停止有监视的微调。它哄骗给定的输出输入对于数据，经由过程最小化模子输入取如实标签之间的益得，让模子进修到特定义务的形式，将预练习模子适配到详细的卑鄙职责。GKDTrainer：GKDTrainer 是用于学问蒸馏的1种练习器，鉴于学问蒸馏道理，哄骗教员模子的学问去叨教教死模子的练习，使教死模子进修到教员模子的学问，譬如输入分散、特点表现等，以普及教死模子的功能。从益失策算圆里去道：
SFTTrainer：平时估计打算模子输入取切实标签之间的交织熵益得等，掂量模子预计了局取本质标注的不同，经由过程反背传达去革新模子参数，使模子输入尽量靠近的确标签。GKDTrainer：重要盘算教死模子取教员模子输入之间的集度，如 Jensen - Shannon Divergence（JSD）、Kullback - Leibler Divergence（KLD）等，让教死模子进修教员模子的输入疏散等学问。那二种按次十分直觉，GKDTrainer担当自SFTTrainer，SFTTrainer担当自Trainer。那从SFTtrainer瞧，它的挪用十分复杂，trl的readme曲交写了1个demo：
from trl import SFTConfig, SFTTrainerfrom datasets import load_datasetdataset = load_dataset("trl-lib/Capybara", split="train")training_args = SFTConfig(output_dir="Qwen/Qwen2.5-0.5B-SFT")trainer = SFTTrainer( args=training_args, model="Qwen/Qwen2.5-0.5B", train_dataset=dataset,)trainer.train()挪用该类后，尔又来瞧了停transformers的trainer，它的益得函数为：
def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): """ How the loss is computed by Trainer. By default, all models return the loss in the first element. Subclass and override for custom behavior. """ if (self.label_smoother isnotNoneor self.compute_loss_func isnotNone) and"labels"in inputs: labels = inputs.pop("labels") else: labels = None if self.model_accepts_loss_kwargs: loss_kwargs = {} if num_items_in_batch isnotNone: loss_kwargs["num_items_in_batch"] = num_items_in_batch inputs = {**inputs, **loss_kwargs} outputs = model(**inputs) # Save past state if it exists # TODO: this needs to be fixed and made cleaner later. if self.args.past_index >= 0: self._past = outputs[self.args.past_index] if labels isnotNone: unwrapped_model = self.accelerator.unwrap_model(model) if _is_peft_model(unwrapped_model): model_name = unwrapped_model.base_model.model._get_name() else: model_name = unwrapped_model._get_name() # User-defined compute_loss function if self.compute_loss_func isnotNone: loss = self.compute_loss_func(outputs, labels, num_items_in_batch=num_items_in_batch) elif model_name in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES.values(): loss = self.label_smoother(outputs, labels, shift_labels=True) else: loss = self.label_smoother(outputs, labels) else: if isinstance(outputs, dict) and"loss"notin outputs: raise ValueError( "The model did not return a loss from the inputs, only the following keys: " f"{','.join(outputs.keys())}. For reference, the inputs it received are {','.join(inputs.keys())}." ) # We don't use .loss here since the model may return tuples instead of ModelOutput. loss = outputs["loss"] if isinstance(outputs, dict) else outputs[0] if self.args.average_tokens_across_devices and self.model_accepts_loss_kwargs: loss *= self.accelerator.num_processes return (loss, outputs) if return_outputs else loss很昭彰那个别有十分多的自适合判定，凭据尔们上1层为SFTtrainer类，而且不指定loss办法，因此将采用cross-entropy loss行为模子练习参数。
而GKDtrainer类的体例便没有一致，因为KL集度是过失称的，正在学问蒸馏中应用JSD，Jensen-Shannon Divergence 是鉴于KL集度改良的更滑润圆滑战对于称的几率疏散器量。论文中给出了其改良的演算公式：
那当然其誊写了compute_loss，详细计较为generalized_jsd_loss，代码以下：
def generalized_jsd_loss( student_logits, teacher_logits, labels=None, beta=0.5, temperature=1.0, reduction="batchmean" ): """ Compute the generalized Jensen-Shannon Divergence loss for knowledge distillation using F.kl_div. See Eq. (1) of https://huggingface.co/papers/2306.13649 for the definition. Args: student_logits: Tensor of shape (batch_size, sequence_length, vocab_size) teacher_logits: Tensor of shape (batch_size, sequence_length, vocab_size) labels: Tensor of shape (batch_size, sequence_length) with -100 for padding tokens to ignore when computing loss beta: Interpolation coefficient between 0 and 1 (default: 0.5) temperature: Softmax temperature (default: 1.0) reduction: Specifies the reduction to apply to the output (default: 'batchmean') Returns: loss: Scalar tensor with the generalized JSD loss """ # Apply temperature scaling student_logits = student_logits / temperature teacher_logits = teacher_logits / temperature # Compute log probabilities for student and probabilities for teacher student_log_probs = F.log_softmax(student_logits, dim=-1) teacher_log_probs = F.log_softmax(teacher_logits, dim=-1) # Compute the log of the mixture distribution # log(a + b) = log(exp(log(a)) + exp(log(b))) -> for mixture beta = torch.tensor(beta, dtype=student_log_probs.dtype) mixture_log_probs = torch.logsumexp( torch.stack([student_log_probs + torch.log(beta), teacher_log_probs + torch.log(1 - beta)]), dim=0, ) # Compute KL divergences using F.kl_div # PyTorch differs from the standard mathematical definition, so the order of the probability distributions is swapped compared to that defined in the paper. kl_teacher = F.kl_div(mixture_log_probs, teacher_log_probs, reduction="none", log_target=True) kl_student = F.kl_div(mixture_log_probs, student_log_probs, reduction="none", log_target=True) # Compute the Generalized Jensen-Shannon Divergence jsd = beta * kl_teacher + (1 - beta) * kl_student # Masking if labels isnotNone: mask = labels != -100 jsd = jsd[mask] # Apply reduction if reduction == "batchmean": return jsd.sum() / mask.sum() if labels isnotNoneelse jsd.sum() / (jsd.size(0) * jsd.size(1)) elif reduction == "sum": return jsd.sum() elif reduction == "mean": return jsd.mean() else: return jsd def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): # compute student output outputs_student = model( input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"], ) # compute teacher output in eval mode self.teacher_model.eval() with torch.no_grad(): outputs_teacher = self.teacher_model( input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"], ) # slice the logits for the generated tokens using the inputs["prompts"] lengths prompt_lengths = inputs["prompts"].shape[1] shifted_student_logits = outputs_student.logits[:, prompt_lengths - 1 : -1, :] shifted_teacher_logits = outputs_teacher.logits[:, prompt_lengths - 1 : -1, :] shifted_labels = inputs["labels"][:, prompt_lengths:] # compute loss loss = self.generalized_jsd_loss( student_logits=shifted_student_logits, teacher_logits=shifted_teacher_logits, labels=shifted_labels, beta=self.beta, ) # empty cache empty_cache() # Return loss return (loss, outputs_student) if return_outputs else loss对该类佳没有佳用，尔也没有晓得，久时出用过，只可道从表面去剖析，JSD益成仇KL益得的差别，不外取SFTtrainer近似，移用体例也很复杂，能够跑频频瞅望环境：
from datasets import load_datasetimport randomfrom transformers import AutoTokenizerfrom trl import ( GKDConfig, GKDTrainer, LogCompletionsCallback, ModelConfig, ScriptArguments, TrlParser, get_kbit_device_map, get_peft_config, get_quantization_config,)################# Training################trainer = GKDTrainer( model=model_config.model_name_or_path, teacher_model=training_args.teacher_model_name_or_path, args=training_args, train_dataset=dataset[args.dataset_train_split], eval_dataset=test_data, processing_class=tokenizer, peft_config=get_peft_config(model_config),)completions_callback = LogCompletionsCallback(trainer, trainer.generation_config, num_prompts=8)trainer.add_callback(completions_callback)trainer.train()# Savetrainer.save_model(training_args.output_dir)lmsys意图思索原节是对于阳哥夺冠计划中对于蒸馏个别的典范归纳，正在那里干1个引经据典，原因不算力，详细尔也出复现过，不外算是除写那篇推文的初志，原来是念干1个top规划明面汇总，仅仅由于deepseek的爆水针对于个中1个偏向干了延长。那话没有多道，github本址为：https://github.com/shyoulala/LMSYS_BlackPearl
该堆栈的目次构造为：
./model_path # 预练习模子的途径，寄存预练习模子的权沉战设备文献./src_fast # 神速练习足原的寄存地位，大概包括简化的练习代码./src # 完备处理意图的代码目次，包括全部名目的完备练习战处置淌程./data # 数据目次，寄存练习数据战其余相干数据./data/oof # Out-of-Fold 数据目次，大概用于交织考证的中央了局./data/processed_data # 处置后的数据目次，寄存通过预处置的数据./data/processed_data/orgemma2fold4 # 练习散，包括用于曲交蒸馏的 70b 几率数据（第4合）./data/processed_data/orgemma2fold2 # 共上，第2合./data/processed_data/orgemma2fold0 # 共上，第0合./data/processed_data/orgemma2fold1 # 共上，第1合./data/processed_data/orgemma2fold3 # 共上，第3合./data/lmsys-chatbot-arena # 大概寄存取 LMSYS Chatbot Arena 相干的数据或者资本./sub # 输入目次，用于寄存练习了局、预计了局等./model_save # 练习模子的保管途径，寄存练习达成后的模子文献./model_save_or # 另外一个模子保管途径，多是用于寄存本初模子或者特定版原的模子./model_save_or/v7_ut_gemma_v7_64r128_ddgemma2_16bit # 通过后处置（如蒸馏）的模子版原，多是 Gemma2-9B 的 16bit 版原挺易设想的，年夜模子期间居然借能干交织考证，不外lmsys是个3分类做事，按照之前逻辑也出甚么题目，该规划重要是用llama3-70B战Qwen2-72B-instruct对于gamma2-9B干蒸馏，全部年夜致淌程，皆经由过程run_pipeline.sh有闪现：
#!/bin/bashset -eqwen_path=../model_path/qwen2_72bllama_path=../model_path/llama3_70bgemma_path=../model_path/Gemma2_9bqwen_path_ut=../model_save/qwen2_4bit_pretrain/epoch_0_model/adapter.binllama_path_ut=../model_save/llama3_4bit_pretrain/epoch_0_model/adapter.bingemma_path_ut=../model_save/gemma2_4bit_pretrain/epoch_0_model/adapter.binfold=$1echo run:${fold}# train llama3 70bsh run_fintune.sh llama3 ${llama_path} ${llama_path_ut} ${fold}# predict train logitspython predict_train.py ${llama_path} ../model_save/llama3_4bit_load_fintune/epoch_0_model/adapter.bin ../data/processed_data/llama3fold${fold}/train.parquet ../data/oof/llama3fold${fold}_train.parquet# train qwen2 70bsh run_fintune.sh qwen2 ${qwen_path} ${qwen_path_ut} ${fold}# predict train logitspython predict_train.py ${qwen_path} ../model_save/qwen2_4bit_load_fintune/epoch_0_model/adapter.bin ../data/processed_data/qwen2fold${fold}/train.parquet ../data/oof/qwen2fold${fold}_train.parquet# merge logits python merge_logits.py ../data/processed_data/gemma2fold${fold}/train.parquet ../data/oof/qwen2fold${fold}_train.parquet ../data/oof/llama3fold${fold}_train.parquet ../data/processed_data/gemma2fold${fold}/train_logits.parquet# distill fintune gemma2-9bsh run_fintune_16bit_distill.sh gemma2 ${gemma_path} ${gemma_path_ut} ${fold}中央几步有挺多乐趣的掌握，例如是怎样干post train的，和末了merge logits，那里仅道蒸馏之前的merge lora，由于代码脚够复杂：
import timefrom dataclasses import dataclassimport pickleimport torchimport sklearnimport numpy as npimport pandas as pdfrom tqdm.auto import tqdmfrom transformers import Gemma2ForSequenceClassification, GemmaTokenizerFast, BitsAndBytesConfigfrom transformers.data.data_collator import pad_without_fast_tokenizer_warningfrom peft import get_peft_config, PeftModel, PeftConfig, get_peft_model, LoraConfig, TaskTypelora_dir = '../model_save/gemma2fold0_16bit_load_fintune/best_val_loss_model/adapter.bin'd1 = torch.load(lora_dir)lora_dir = '../model_save/gemma2fold1_16bit_load_fintune/best_val_loss_model/adapter.bin'd2 = torch.load(lora_dir)lora_dir = '../model_save/gemma2fold2_16bit_load_fintune/best_val_loss_model/adapter.bin'd3 = torch.load(lora_dir)lora_dir = '../model_save/gemma2fold3_16bit_load_fintune/best_val_loss_model/adapter.bin'd4 = torch.load(lora_dir)lora_dir = '../model_save/gemma2fold4_16bit_load_fintune/best_val_loss_model/adapter.bin'd5 = torch.load(lora_dir)d = {}for k, v in d1.items(): v = d1[k] + d2[k] + d3[k] + d4[k] + d5[k] v = v / 5. d[k] = vtorch.save(d, "../model_save/final_adapter.bin")代码上看来，便是对于通过5次交织考证的gamma模子权沉干了添权均匀开并，但尔瞧discussion许多人提到了，它们一样料到了该意图，不外恶果其实不佳，好像是那些权沉借须要干圆好评价，倘使圆好过年夜反而会牵累添权后的了局，感乐趣有卡有算力的能停止实验，尔便不外多提了。
归到正题，终究是先获得了llama3战Qwen的模子输入，那末蒸馏等于须要思量那二者的了局，因此蒸馏益得拣选了：
loss_fun = nn.CrossEntropyLoss()divergence_loss_fn = nn.KLDivLoss(reduction='batchmean')cos_loss_fn = nn.CosineEmbeddingLoss()outputs = model(batch['input_ids'], use_cache=False) # predict gemma2logits = outputs.logitsgrads = batch['grads']grads1 = batch['grads'][:, :3] # qwen2 grads2 = batch['grads'][:, 3:] # llama3labels = batch['labels']loss_ce = loss_fun(logits, labels)loss_grad1 = divergence_loss_fn( F.log_softmax(logits / T, dim=1), F.softmax(grads1 / T, dim=1))cos_loss1 = cos_loss_fn(F.softmax(grads1 / T, dim=1), F.softmax(logits / T, dim=1), torch.ones(logits.size()[0]).to(logits.device))loss_grad2 = divergence_loss_fn( F.log_softmax(logits / T, dim=1), F.softmax(grads2 / T, dim=1))cos_loss2 = cos_loss_fn(F.softmax(grads2 / T, dim=1), F.softmax(logits / T, dim=1), torch.ones(logits.size()[0]).to(logits.device))loss = (loss_ce + loss_grad1 + cos_loss1 + loss_grad2 + cos_loss2) / 5.用数教公式领略，便为交织熵战KL集度的混杂：
那里刚刚最先尔没有是很领悟，而后问了停deepseek懂了：
为何共时应用交织熵益树敌 KL 集度益得？
1. 维持监视进修本领
交织熵益得保证教死模子不妨精确预计切实标签，进而连结模子的监视进修本领。若是不交织熵益得，教死模子大概会过分依靠老师模子的输入，而轻忽靠得住标签的教导，致使模子正在真正数据上的本能下落。
2. 进修教员模子的硬方针
KL 集度益得让教死模子进修教员模子的硬方针，进而逮捉到教员模子的里面示意战学问。硬方针常常包括更多的疑息，能够资助教死模子更美天理会数据的分散战特点。
3. 均衡硬标签战硬方针
共时应用交织熵益树敌 KL 集度益得能够均衡硬标签战硬方针的奉献。硬标签（确凿标签）供给了曲交的监视旌旗灯号，而硬方针（老师模子的输入）供给了更多的高低文疑息。经由过程调剂二者的权沉，能够更佳天提醒教死模子的进修。
本来尔以为以上重要的，是由于教员模子是二个，而没有是1个，KL更适当于1个，而二个参加交织熵尔的知道为桥交，更能再现泛化，但详细为啥如许支配，惟有跑了才晓得，因而凭据github的处境注释，有8弛A100以上的，能够跑1轮，等候3天以上，旁观了局了。
open-r1中的蒸馏该repo是DeepSeek-R1的开启复现版原，由huggingface的CEO自己建议并停止，尔年夜致瞅了1停，它的筹办是：
步调 1：从 DeepSeek-R1 中索取下量量语料库去复造 R1-Distill 模子。步调 2：复造 DeepSeek 用于成立 R1-Zero 的杂 RL 管谈。那大概触及为数教、推理战代码整饬新的年夜范畴数据散。步调 3：闪现尔们能够经由过程多阶段练习从底子模子转背 RL 调剂。那里中心望step 1，便它应用distilabel去对于Deepseek-R1索取蒸馏数据，以停是1个复杂demo：
from datasets import load_datasetfrom distilabel.models import vLLMfrom distilabel.pipeline import Pipelinefrom distilabel.steps.tasks import TextGenerationprompt_template = """\You will be given a problem. Please reason step by step, and put your final answer within \boxed{}:{{ instruction }}"""dataset = load_dataset("AI-MO/NuminaMath-TIR", split="train").select(range(10))model_id = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"# Exchange with another smol distilled r1with Pipeline( name="distill-qwen-7b-r1", description="A pipeline to generate data from a distilled r1 model",) as pipeline: llm = vLLM( model=model_id, tokenizer=model_id, extra_kwargs={ "tensor_parallel_size": 1, "max_model_len": 8192, }, generation_kwargs={ "temperature": 0.6, "max_new_tokens": 8192, }, ) prompt_column = "problem" text_generation = TextGeneration( llm=llm, template=prompt_template, num_generations=4, input_mappings={"instruction": prompt_column} if prompt_column isnotNoneelse {} )if __name__ == "__main__": distiset = pipeline.run(dataset=dataset) distiset.push_to_hub(repo_id="username/numina-deepseek-r1-qwen-7b")而后将该数据参加了sft中：
def main(script_args, training_args, model_args): ################ # Model init kwargs & Tokenizer ################ quantization_config = get_quantization_config(model_args) model_kwargs = dict( revision=model_args.model_revision, trust_remote_code=model_args.trust_remote_code, attn_implementation=model_args.attn_implementation, torch_dtype=model_args.torch_dtype, use_cache=Falseif training_args.gradient_checkpointing elseTrue, device_map=get_kbit_device_map() if quantization_config isnotNoneelseNone, quantization_config=quantization_config, ) training_args.model_init_kwargs = model_kwargs tokenizer = AutoTokenizer.from_pretrained( model_args.model_name_or_path, trust_remote_code=model_args.trust_remote_code, use_fast=True ) tokenizer.pad_token = tokenizer.eos_token ################ # Dataset ################ dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config) ################ # Training ################ trainer = SFTTrainer( model=model_args.model_name_or_path, args=training_args, train_dataset=dataset[script_args.dataset_train_split], eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no"elseNone, processing_class=tokenizer, peft_config=get_peft_config(model_args), ) trainer.train() # Save and push to hub trainer.save_model(training_args.output_dir) if training_args.push_to_hub: trainer.push_to_hub(dataset_name=script_args.dataset_name)if __name__ == "__main__": parser = TrlParser((ScriptArguments, SFTConfig, ModelConfig)) script_args, training_args, model_args = parser.parse_args_and_config() main(script_args, training_args, model_args)从代码上能够望到，那个进程是从老师模子中索取学问，并将其传送给教死模子。正在那个特定的环境停，学问没有所以硬标签的方式曲交传送，而是经由过程死成的推理数据去传送。这类办法每每被称为数据蒸馏（Data Distillation）或者示例蒸馏（Example Distillation），它是学问蒸馏的1种变体。
末了尔观到了腾讯科技宣布的1场对于DeepSeek的下量量关门会：比技能更紧张的是愿景 ，内部的许多内乱容能够手脚收场：
历久来讲，经由过程走捷径的体例，而不本身经由过程愿景来念何如干技能计划，而是曲交复现，中央大概会有没有晓得的坑。譬如正在那1代技能 long context 不量变的条件停，处理题目的下限大概会被限定。R1-zero 多是1个准确的偏向，重新便干 R1-zero 或者没有经由过程类 o1 的数据开动大概更佳。照着他人的技能计划大概没有太佳，盼望更多探究。蒸馏的弊端是模子 diversity 下落，浸染模子下限，没法超出最强的模子。但短时间望，蒸馏也是1条道路。其余模子用蒸馏也能获得较美的了局，已去正在模子死态内部大概便会有教员、教死的脚色分别，有本领当别名佳教死也是1种能够的贸易形式。作品的末了，由于deepseek水爆的出圈，尔也瞅到了好多种种专主正在其上干种种职分，例如写作品大概写诗，个中有1尾尔很喜好的，是它们皆比deepseek 美，尔晓得 1文中应用deepseek死成的其1，动作原篇终局：
秋乡惊岁暮，梅魂始醉，滇海骤翻银浪。西山素甲，北天冻幕，翠湖暗锁冷喷鼻。冰绡裹垂杨，讶螺峰披絮，金马凝霜。万户笙箫，绝支檐角做琳琅。
谁教玉戏蛮城？遣滕6醒舞，姑射颠狂。开女絮迷，袁安户遮，争知北诏风景。椒盘热白妆，念罗裙冰透，绘阁炉躲。且待明代阴温，花事又浪费。
