project-llm-trainer 0.5.16__py3-none-any.whl → 0.6.0__py3-none-any.whl

llm_trainer/dpo_trainer.py

@@ -35,28 +35,28 @@ class DPOTrainer(Trainer):
             eval_image_tags=eval_image_tags
         )
 
-        self.reference_model = self._init_reference_model()
+        self.ref_model = self._init_ref_model()
 
-    def _init_reference_model(self):
-        reference_model = self._new_model(self.train_config)
+    def _init_ref_model(self):
+        ref_model = self._new_model(self.train_config)
 
-        reference_model, _ = TrainerTools().parallel.process(
-            model=reference_model,
+        ref_model, _ = TrainerTools().parallel.process(
+            model=ref_model,
             optimizer=None,
-            kwargs=self._init_reference_args(),
+            kwargs=self._init_ref_model_args(),
             save_instance=False
         )
 
-        reference_model.eval()
-        for param in reference_model.parameters():
+        ref_model.eval()
+        for param in ref_model.parameters():
             param.requires_grad = False
 
         sync_model_params(
             _from=self.train_model,
-            _to=reference_model
+            _to=ref_model
         )
 
-        return reference_model
+        return ref_model
 
     def _init_loss(self):
         criterion = DPOLoss(
@@ -203,17 +203,18 @@ class DPOTrainer(Trainer):
 
                         with self.ctx:
                             policy_outputs = self.train_model(concat_inputs, attention_mask=concat_mask)
-                            with torch.inference_mode():
-                                ref_outputs = self.reference_model(concat_inputs, attention_mask=concat_mask)
-
                             policy_probs = self._logprobs(policy_outputs['logits'], concat_labels, concat_mask)
-                            ref_probs = self._logprobs(ref_outputs['logits'], concat_labels, concat_mask)
+                            aux_loss = policy_outputs.get('aux_loss')
+
+                            with torch.no_grad():
+                                ref_outputs = self.ref_model(concat_inputs, attention_mask=concat_mask)
+                                ref_probs = self._logprobs(ref_outputs['logits'], concat_labels, concat_mask)
 
                             # calc loss
                             loss = self.criterion(policy_probs, ref_probs)
 
-                            if aux_loss_coef and policy_outputs['aux_loss']:
-                                loss += aux_loss_coef * policy_outputs['aux_loss']
+                            if aux_loss_coef and aux_loss:
+                                loss += aux_loss_coef * aux_loss
 
                         if gradient_accumulation_steps > 1:
                             loss = loss / gradient_accumulation_steps

llm_trainer/grpo_trainer.py

@@ -42,32 +42,36 @@ class GRPOTrainer(Trainer):
         )
 
         self.reward_func = reward_func
-        self.reference_model = self._init_reference_model()
+        self.ref_model = self._init_ref_model()
 
         # 默认使用torch提供的pad_sequence
         # 如果pad_sequence不支持padding_side参数，则将改参数置为False，使用反转的方式
         self._use_origin_pad_sequence = True
 
-    def _init_reference_model(self):
-        reference_model = self._new_model(self.train_config)
+    def _init_ref_model(self):
+        ref_model = self._new_model(self.train_config)
 
-        reference_model, _ = TrainerTools().parallel.process(
-            model=reference_model,
+        ref_model, _ = TrainerTools().parallel.process(
+            model=ref_model,
             optimizer=None,
-            kwargs=self._init_reference_args(),
+            kwargs=self._init_ref_model_args(),
             save_instance=False
         )
 
-        reference_model.eval()
-        for param in reference_model.parameters():
+        ref_model.eval()
+        for param in ref_model.parameters():
             param.requires_grad = False
 
-        return reference_model
+        return ref_model
 
     def _init_loss(self):
         criterion = GRPOLoss(
-            clip_eps=self.train_config.grpo_config.clip_eps,
-            kl_weight=self.train_config.grpo_config.kl_weight
+            beta=self.train_config.grpo_config.loss_beta,
+            clip_eps=self.train_config.grpo_config.loss_clip_eps,
+            delta=self.train_config.grpo_config.loss_delta,
+            importance_sampling_level=self.train_config.grpo_config.loss_importance_sampling_level,
+            loss_type=self.train_config.grpo_config.loss_type,
+            gen_max_new_tokens=self.train_config.grpo_config.gen_max_new_tokens
         )
 
         return criterion, None
@@ -225,7 +229,7 @@ class GRPOTrainer(Trainer):
             old_log_probs, _ = self._compute_log_probabilities(generate_model, input_ids, attention_mask, logits_to_keep)
 
             # Compute ref_log_probs from the reference model, which remains static.
-            ref_log_probs, _ = self._compute_log_probabilities(self.reference_model, input_ids, attention_mask, logits_to_keep)
+            ref_log_probs, _ = self._compute_log_probabilities(self.ref_model, input_ids, attention_mask, logits_to_keep)
 
         repeated_prompts = [p for p in prompts for _ in range(group_size)]
         repeated_answers = [a for a in answers for _ in range(group_size)]
@@ -290,7 +294,7 @@ class GRPOTrainer(Trainer):
         for epoch in range(self.train_config.n_epochs):
             sync_model_params(
                 _from=self.train_model,
-                _to=self.reference_model,
+                _to=self.ref_model,
                 mixup_alpha=self.train_config.grpo_config.mixup_alpha
             )
 

llm_trainer/loss.py

@@ -2,6 +2,7 @@ from typing import List, Optional
 import torch
 from torch import nn
 import torch.nn.functional as F
+from .tools import TrainerTools
 
 
 class LMLoss(nn.Module):
@@ -115,6 +116,7 @@ class DPOLoss(nn.Module):
             )
 
         loss = losses.mean()
+
         # chosen_rewards = self.beta * (policy_chosen_probs - ref_chosen_probs).detach()
         # rejected_rewards = self.beta * (policy_reject_probs - ref_reject_probs).detach()
 
@@ -124,12 +126,21 @@ class DPOLoss(nn.Module):
 class GRPOLoss(nn.Module):
     def __init__(
             self,
+            beta: float,
             clip_eps: float,
-            kl_weight: float
+            delta: Optional[float] = None,
+            importance_sampling_level: str = 'token',
+            loss_type: str = 'grpo',
+            gen_max_new_tokens: Optional[float] = None
     ):
         super().__init__()
+
+        self.beta = beta
         self.clip_eps = clip_eps
-        self.kl_weight = kl_weight
+        self.delta = delta
+        self.importance_sampling_level = importance_sampling_level
+        self.loss_type = loss_type
+        self.gen_max_new_tokens = gen_max_new_tokens
 
     def forward(
             self,
@@ -139,33 +150,41 @@ class GRPOLoss(nn.Module):
             completion_mask: torch.Tensor,
             advantages: torch.Tensor
     ) -> torch.Tensor:
-        # Compute policy ratio
-        ratio = torch.exp(log_probs - old_log_probs)
 
-        # Compute surrogate loss with clipping
-        surrogate1 = ratio * advantages
-        surrogate2 = torch.clamp(ratio, 1 - self.clip_eps, 1 + self.clip_eps) * advantages
-        surrogate_loss = torch.min(surrogate1, surrogate2)
+        if self.beta != 0.0:
+            per_token_kl = torch.exp(ref_log_probs - log_probs) - (ref_log_probs - log_probs) - 1
+        else:
+            per_token_kl = None
+
+        log_ratio = log_probs - old_log_probs
+        if self.importance_sampling_level == "seq":
+            # GSPO
+            log_importance_weights = (log_ratio * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0)
+            log_importance_weights = log_importance_weights.unsqueeze(-1)
+        else:
+            # GRPO
+            log_importance_weights = log_ratio
 
-        # Compute KL divergence penalty
-        kl_div = torch.exp(ref_log_probs - log_probs) - (ref_log_probs - log_probs) - 1
+        coef_1 = torch.exp(log_importance_weights)
+        coef_2 = torch.clamp(coef_1, 1 - self.clip_eps, 1 + self.clip_eps)
 
-        # Combine losses
-        per_token_loss = surrogate_loss - self.kl_weight * kl_div
-        loss = -((per_token_loss * completion_mask).sum(dim=1) / completion_mask.sum(dim=1)).mean()
+        # Two-sided clipping
+        if self.delta is not None:
+            coef_1 = torch.clamp(coef_1, max=self.delta)
 
-        return loss
+        per_token_loss1 = coef_1 * advantages
+        per_token_loss2 = coef_2 * advantages
+        per_token_loss = -torch.min(per_token_loss1, per_token_loss2)
+
+        if self.beta != 0.0:
+            per_token_loss = per_token_loss + self.beta * per_token_kl
 
-        # kl = self._approx_kl_divergence(
-        #     log_probs=log_probs,
-        #     ref_log_probs=ref_log_probs,
-        #     mask=mask,
-        # )
-        #
-        # ratio = (log_probs - old_log_probs).exp()
-        # surr1 = ratio * advantages
-        # surr2 = ratio.clamp(1 - self.clip_eps, 1 + self.clip_eps) * advantages
-        # loss = -torch.min(surr1, surr2) + self.kl_weight * kl
-        #
-        # loss = self._masked_mean(loss, mask, dim=-1).mean()
-        # return loss, kl.mean()
+        if self.loss_type == "bnpo":
+            loss = (per_token_loss * completion_mask).sum() / completion_mask.sum().clamp(min=1.0)
+        elif self.loss_type == "dr_grpo":
+            assert self.gen_max_new_tokens is not None
+            loss = (per_token_loss * completion_mask).sum() / (per_token_loss.size(0) * self.gen_max_new_tokens)
+        else:
+            loss = ((per_token_loss * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0)).mean()
+
+        return loss

llm_trainer/parallel.py

@@ -140,7 +140,7 @@ class Parallel(ABC):
         return 1
 
     def wait(self, msg=None):
-        msg = f' for {msg}' if msg else None
+        msg = f' for {msg}' if msg else ''
         log(f'wait at {self.device}{msg}')
         dist.barrier()
         log(f'continue at {self.device}{msg}')

llm_trainer/partition_utils.py

@@ -4,6 +4,7 @@ import itertools
 from packaging import version
 from torch import nn
 from torch.nn.parallel import DistributedDataParallel as DDP
+import torch.distributed as dist
 
 from .tools import TrainerTools
 from .parallel_ds import DsParallel
@@ -45,12 +46,40 @@ def unwrap_model_for_generation(model: nn.Module):
 
 
 def sync_model_params(_from: nn.Module, _to: Optional[nn.Module], mixup_alpha: float = 1.0):
+    """
+        必须在所有rank上调用，非rank0, _to 可以设置为None.
+        当前函数不适用于_to是一个zero3模型
+    """
     if isinstance(TrainerTools().parallel, DsParallel):
-        _sync_ds_model_params(_from, _to, mixup_alpha)
-    elif isinstance(TrainerTools().parallel, DdpParallel):
-        _sync_ddp_model_params(_from, _to, mixup_alpha)
+        state_dict = _get_ds_model_params(_from, only_rank0=_to is None)
+    elif isinstance(_from, DDP):
+        state_dict = _from.module.state_dict()
+    else:
+        state_dict = _from.state_dict()
+
+    if not _to or not state_dict:
+        return
+
+    unwrap_to_model = unwrap_model(_to)
+    if mixup_alpha == 1.0:
+        # 直接覆盖
+        unwrap_to_model.load_state_dict(state_dict)
     else:
-        _copy_params(_from, _to, mixup_alpha)
+        # 混合参数
+        for param_name, target_param in unwrap_to_model.named_parameters():
+            if param_name in state_dict:
+                from_param_tensor = state_dict[param_name]
+                target_param.data.mul_(1.0 - mixup_alpha).add_(
+                    from_param_tensor.data.to(target_param.device),
+                    alpha=mixup_alpha
+                )
+
+    # if isinstance(TrainerTools().parallel, DsParallel):
+    #     _sync_ds_model_params(_from, _to, mixup_alpha)
+    # elif isinstance(TrainerTools().parallel, DdpParallel):
+    #     _sync_ddp_model_params(_from, _to, mixup_alpha)
+    # else:
+    #     _copy_params(_from, _to, mixup_alpha)
 
 
 def unwrap_model(model) -> nn.Module:
@@ -66,6 +95,57 @@ def unwrap_model(model) -> nn.Module:
     return model
 
 
+def _get_ds_full_state_dict_on_rank0(model: nn.Module) -> Optional[dict]:
+    """
+        需要在所有rank上调用，然后只有rank0有值
+    """
+    import deepspeed
+    assert isinstance(model, deepspeed.DeepSpeedEngine)
+
+    if model.zero_optimization_stage() != 3:
+        if TrainerTools().parallel.is_main_process:
+            return {k: v.cpu().clone() for k, v in model.module.state_dict().items()}
+        return None
+
+    # --- ZeRO-3 ---
+    # 只调用一次 GatheredParameters，传入所有参数
+    with deepspeed.zero.GatheredParameters(model.parameters(), modifier_rank=0):
+        if TrainerTools().parallel.is_main_process:
+            # 在这个 'with' 代码块内，rank 0 上的 model.module 拥有完整的参数
+            # 所以我们可以像操作普通模型一样直接调用 state_dict()
+            full_state_dict = model.module.state_dict()
+
+            # 将其克隆到 CPU 并返回
+            return {k: v.cpu().clone() for k, v in full_state_dict.items()}
+
+    # 其他 rank 执行到这里时，上下文结束，直接返回 None
+    return None
+
+
+def _get_ds_model_params(model: nn.Module, only_rank0=False):
+    """
+        从一个正在运行的 DeepSpeedEngine 中高效地提取完整的 FP32 state_dict，
+        兼容 ZeRO Stages 0, 1, 2, 3。
+        包含了对 ZeRO-3 中分片参数的正确处理。
+    """
+
+    import deepspeed
+    assert isinstance(model, deepspeed.DeepSpeedEngine)
+    state_dict = _get_ds_full_state_dict_on_rank0(model)
+
+    # 现在，只有 rank 0 上的 state_dict 是一个有效的字典，其他 rank 上是 None。
+    # 我们需要将其广播给所有进程。
+    if not only_rank0 and TrainerTools().parallel.world_size > 1:
+        # 准备一个列表，rank 0 有数据，其他 rank 是占位符
+        object_list = [state_dict] if TrainerTools().parallel.is_main_process else [None]
+        # 执行广播，这个操作是阻塞的，会同步所有进程
+        dist.broadcast_object_list(object_list, src=0)
+        # 所有进程从列表中获取广播后的 state_dict 副本
+        state_dict = object_list[0]
+
+    return state_dict
+
+
 def _copy_params(model, target_model, mixup_alpha):
     for target_param, copy_param in zip(target_model.parameters(), model.parameters()):
         target_param.data.mul_(1.0 - mixup_alpha).add_(copy_param.data, alpha=mixup_alpha)
@@ -79,6 +159,7 @@ def _sync_ds_model_params(_from: nn.Module, _to: Optional[nn.Module], mixup_alph
 
     if _from.zero_optimization_stage() == 3:
         with deepspeed.zero.GatheredParameters(list(origin_from.parameters()) + list(_to.parameters()), modifier_rank=0):
+            # why only rank 0?
             if TrainerTools().parallel.is_main_process:
                 _copy_params(origin_from, _to, mixup_alpha)
     else:

llm_trainer/train_configs.py

@@ -136,10 +136,13 @@ class DPOConfig:
 @dataclass(kw_only=True)
 class GRPOConfig:
     grpo_steps: int = 1
-    clip_eps: float = 0.1
-    kl_weight: float = 0.04
     group_size: int = 12
     mixup_alpha: float = 1.0
+    loss_beta: float = 0.04
+    loss_clip_eps: float = 0.1
+    loss_delta: Optional[float] = None
+    loss_importance_sampling_level: str = 'token' # token or seq
+    loss_type: str = 'grpo' # grpo or bnpo or dr_grpo
     gen_max_new_tokens: Optional[int] = None
     gen_temperature: Optional[float] = None
     gen_k: Optional[int] = None

llm_trainer/trainer.py

@@ -1,6 +1,6 @@
-import time
 from contextlib import nullcontext
 from typing import Optional, Tuple, List, Dict, Any
+import copy
 
 import torch
 import torch.distributed as dist
@@ -65,6 +65,7 @@ class Trainer:
             assert len(self.eval_prompts) == len(self.eval_image_tags)
 
         parallel_kwargs, data_loader_kwargs, sampler_kwargs, use_ds_optim = self._convert_train_args()
+        self.parallel_kwargs = parallel_kwargs
         self.data_loader_kwargs: dict[str, Any] = data_loader_kwargs
         self.sampler_kwargs: dict[str, Any] = sampler_kwargs
 
@@ -323,8 +324,8 @@ class Trainer:
 
         return parallel_kwargs, data_loader_kwargs, sampler_kwargs, use_ds_optim
 
-    def _init_reference_args(self) -> dict:
-        parallel_kwargs, _, _, _ = self._convert_train_args()
+    def _init_ref_model_args(self) -> dict:
+        parallel_kwargs = copy.deepcopy(self.parallel_kwargs)
 
         if parallel_kwargs and isinstance(TrainerTools().parallel, DsParallel):
             # reference to https://github.com/huggingface/trl/blob/main/trl/models/utils.py:prepare_deepspeed
@@ -346,8 +347,13 @@ class Trainer:
             #             }
             #         )
 
-            if parallel_kwargs['zero_optimization']['stage'] != 3:
-                parallel_kwargs['zero_optimization']['stage'] = 0
+            parallel_kwargs.pop('activation_checkpointing', None)
+            parallel_kwargs.pop('gradient_clipping', None)
+
+            # ref_model暂时先使用stage 0, 解决训练卡住问题
+            parallel_kwargs["zero_optimization"] = {"stage": 0}
+            # if parallel_kwargs.get("zero_optimization", {}).get("stage", 0) != 3:
+            #     parallel_kwargs["zero_optimization"] = {"stage": 0}
 
         return parallel_kwargs
 

{project_llm_trainer-0.5.16.dist-info → project_llm_trainer-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: project_llm_trainer
-Version: 0.5.16
+Version: 0.6.0
 Summary: LLM and VLM trainer
 Author: qibin
 Author-email: qibin0506@gmail.com

project_llm_trainer-0.6.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+llm_trainer/__init__.py,sha256=HWgtTEVeQSnZmEyYQm2K6eFEG4X2QAoigMlB5Z2tcXE,260
+llm_trainer/checkpoint.py,sha256=gz31pZbbQvRTYrBhxV-MFaBAIFeqpe7rM6nFsjwT9lY,4328
+llm_trainer/dataset.py,sha256=4QlOo0SFB5816BUYegQjgobUqTUMQvdmZMM_OEAMSjE,4347
+llm_trainer/dpo_trainer.py,sha256=mETXpU1ZSasg1UM72wnh9NaoTuXBibuNuodfuW7u8Iw,12269
+llm_trainer/ds_checkpoint.py,sha256=Wzy7PvVVWR794-BW4uragWFTAkkgDvjvkF-qMdyB4fc,2141
+llm_trainer/eval.py,sha256=ZyUfSo2Q8P-lrCdPEnGkoo5pGubd0AabREK5eMISRII,1109
+llm_trainer/generate_utils.py,sha256=wrZoG2g7CsOyG4sb3px9vURHQFV6_9j5kQmpFc5A8yg,15335
+llm_trainer/grpo_trainer.py,sha256=-wbozslll_bcGUMqrbS0a73jhosyjc3oC3PHLSev6lw,16344
+llm_trainer/log.py,sha256=LxqTGRNZUGMTSQCePRpk-rYyxSnSIbT4kOdP8Fbzr0M,462
+llm_trainer/loss.py,sha256=eYvOlCoguKnLvdGuqvQpGUoLVSADQ5coaU3DWYbJEdM,6811
+llm_trainer/parallel.py,sha256=G9X0FddIJwd9j-5XOknB4AlBe4G2W6fUCaQH6ycC2Fo,4490
+llm_trainer/parallel_ddp.py,sha256=Pob9vUlBZnkL4oP1Re11kFob7nufMSE96pn7m7fuOEM,1345
+llm_trainer/parallel_ds.py,sha256=oy8RRxHud3rACWubFlJqqd0pjPEQhKeAPGPQUSdJX2c,1145
+llm_trainer/parallel_none.py,sha256=TG6Pm829Dg-yQu-97O-EHV3FCARBlNcP47KkGFAs16E,676
+llm_trainer/partition_utils.py,sha256=eEYNhfEIF4hGzZ3OLa6sEBIECz261drptEz_n7fZYtk,8396
+llm_trainer/scheduler.py,sha256=LAI_0VxClsIQkix0bRoduRD4vPfVuIZDhZgTAT_KK8k,4901
+llm_trainer/sft_trainer.py,sha256=gxQA7T1o1QGUsHp2CX1Qb_fO5LppBJuNbc0H4ixCYUA,1783
+llm_trainer/tokenizer.py,sha256=SSpgXtb0e1NtQqRW0gCq09TTZi47umggy-Fh5EMHKJg,6708
+llm_trainer/tools.py,sha256=yF17lp6oOfLe2XJeKDQ1juZcbv-6vFamJSLwEeArduA,2975
+llm_trainer/train_configs.py,sha256=U4hwXWKI6svDqiDOu6RPTitCzpxEYyjZUN6gwh_co8c,7510
+llm_trainer/trainer.py,sha256=Q821nlLDKRZVpaRoiZ7DiJplpAJRRLtvR_33FbClGA0,26729
+llm_trainer/utils.py,sha256=LWNhyQ0NDEZ9mZtk2Ryvh6EulvHIaUGIflugSpqmeFI,6791
+project_llm_trainer-0.6.0.data/scripts/calc_intermediate_size,sha256=AggpgNHokJiJMbEtVdOnolqr_4bH3i1UYuZNEAzC2Gc,460
+project_llm_trainer-0.6.0.data/scripts/ddp_train,sha256=x81AasaN2-9TwARFFF1l7iV1LmfMQ0bLw0i_CGbOwSw,299
+project_llm_trainer-0.6.0.data/scripts/ds_train,sha256=qL3qc3TcedBCw98UZUjW07ONcErRawLE1HymW2AmscA,265
+project_llm_trainer-0.6.0.data/scripts/plot_loss,sha256=MzFcdJESlVr1srj4Td6-AxPGUKkfB_QEcJwm0Bd-5fU,910
+project_llm_trainer-0.6.0.data/scripts/plot_lr,sha256=w_7XR_x3KYYyboeOVAeu_I4fveLFI-C0wBmRrNlmWUI,894
+project_llm_trainer-0.6.0.data/scripts/py_train,sha256=tOp9TquORQeU8XN5H7OVIk5O0Ypwi34p_GENxTwgwdk,265
+project_llm_trainer-0.6.0.data/scripts/smart_train,sha256=Pmt4Q0to4Hoz82iB9uFPZuz7uahNUbfE7FR1940EBy8,716
+project_llm_trainer-0.6.0.dist-info/METADATA,sha256=_F0QQHrdQNGXG8eDGRDsgEvdX6fYWXSDg5Ad089CXHk,195
+project_llm_trainer-0.6.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+project_llm_trainer-0.6.0.dist-info/top_level.txt,sha256=LtRFg28i0QIG7iBCD2t095oSco99LCtkijibS9cMGik,12
+project_llm_trainer-0.6.0.dist-info/RECORD,,

project_llm_trainer-0.5.16.dist-info/RECORD

@@ -1,33 +0,0 @@
-llm_trainer/__init__.py,sha256=HWgtTEVeQSnZmEyYQm2K6eFEG4X2QAoigMlB5Z2tcXE,260
-llm_trainer/checkpoint.py,sha256=gz31pZbbQvRTYrBhxV-MFaBAIFeqpe7rM6nFsjwT9lY,4328
-llm_trainer/dataset.py,sha256=4QlOo0SFB5816BUYegQjgobUqTUMQvdmZMM_OEAMSjE,4347
-llm_trainer/dpo_trainer.py,sha256=--ItH-rkkq24Da3M_Kf0VxpQ3t-k0fpZrzFGqkYsjks,12304
-llm_trainer/ds_checkpoint.py,sha256=Wzy7PvVVWR794-BW4uragWFTAkkgDvjvkF-qMdyB4fc,2141
-llm_trainer/eval.py,sha256=ZyUfSo2Q8P-lrCdPEnGkoo5pGubd0AabREK5eMISRII,1109
-llm_trainer/generate_utils.py,sha256=wrZoG2g7CsOyG4sb3px9vURHQFV6_9j5kQmpFc5A8yg,15335
-llm_trainer/grpo_trainer.py,sha256=g_ivzQop2SkvhlKAEWb0zUnIvNuHTfsOoIG6y29oTCw,16106
-llm_trainer/log.py,sha256=LxqTGRNZUGMTSQCePRpk-rYyxSnSIbT4kOdP8Fbzr0M,462
-llm_trainer/loss.py,sha256=NZCQeUXnLSj__mmDflE8g89KgE0emAJXIab0IERCLno,6023
-llm_trainer/parallel.py,sha256=j1L4n-JmDkDZblURrNKpEAWEqqGIAXAN9PT_fSS_OnE,4492
-llm_trainer/parallel_ddp.py,sha256=Pob9vUlBZnkL4oP1Re11kFob7nufMSE96pn7m7fuOEM,1345
-llm_trainer/parallel_ds.py,sha256=oy8RRxHud3rACWubFlJqqd0pjPEQhKeAPGPQUSdJX2c,1145
-llm_trainer/parallel_none.py,sha256=TG6Pm829Dg-yQu-97O-EHV3FCARBlNcP47KkGFAs16E,676
-llm_trainer/partition_utils.py,sha256=xzv8kwlbKp3dai2pBwX89gN5ymeHk1bGbTkGru5H-UM,5167
-llm_trainer/scheduler.py,sha256=LAI_0VxClsIQkix0bRoduRD4vPfVuIZDhZgTAT_KK8k,4901
-llm_trainer/sft_trainer.py,sha256=gxQA7T1o1QGUsHp2CX1Qb_fO5LppBJuNbc0H4ixCYUA,1783
-llm_trainer/tokenizer.py,sha256=SSpgXtb0e1NtQqRW0gCq09TTZi47umggy-Fh5EMHKJg,6708
-llm_trainer/tools.py,sha256=yF17lp6oOfLe2XJeKDQ1juZcbv-6vFamJSLwEeArduA,2975
-llm_trainer/train_configs.py,sha256=992wy0YhBG2WvxwdLEPL4_-JUl4NkwMPT-jj_BIHo6A,7347
-llm_trainer/trainer.py,sha256=YqWhD9jXbrUdm3KEjEHLyg_qHiXCy5R7PK-arCXxJ6M,26399
-llm_trainer/utils.py,sha256=LWNhyQ0NDEZ9mZtk2Ryvh6EulvHIaUGIflugSpqmeFI,6791
-project_llm_trainer-0.5.16.data/scripts/calc_intermediate_size,sha256=AggpgNHokJiJMbEtVdOnolqr_4bH3i1UYuZNEAzC2Gc,460
-project_llm_trainer-0.5.16.data/scripts/ddp_train,sha256=x81AasaN2-9TwARFFF1l7iV1LmfMQ0bLw0i_CGbOwSw,299
-project_llm_trainer-0.5.16.data/scripts/ds_train,sha256=qL3qc3TcedBCw98UZUjW07ONcErRawLE1HymW2AmscA,265
-project_llm_trainer-0.5.16.data/scripts/plot_loss,sha256=MzFcdJESlVr1srj4Td6-AxPGUKkfB_QEcJwm0Bd-5fU,910
-project_llm_trainer-0.5.16.data/scripts/plot_lr,sha256=w_7XR_x3KYYyboeOVAeu_I4fveLFI-C0wBmRrNlmWUI,894
-project_llm_trainer-0.5.16.data/scripts/py_train,sha256=tOp9TquORQeU8XN5H7OVIk5O0Ypwi34p_GENxTwgwdk,265
-project_llm_trainer-0.5.16.data/scripts/smart_train,sha256=Pmt4Q0to4Hoz82iB9uFPZuz7uahNUbfE7FR1940EBy8,716
-project_llm_trainer-0.5.16.dist-info/METADATA,sha256=h0TMNrZMUU875tVasbuqt69EuPPMbo_nv6tHQLKeNbQ,196
-project_llm_trainer-0.5.16.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-project_llm_trainer-0.5.16.dist-info/top_level.txt,sha256=LtRFg28i0QIG7iBCD2t095oSco99LCtkijibS9cMGik,12
-project_llm_trainer-0.5.16.dist-info/RECORD,,