Add files using upload-large-folder tool

math_evaluation/outputs/Qwen/Qwen2.5-Math-1.5B/math_eval/math_oai/test_llama-base-boxed_-1_seed0_t0.0_s0_e-1_llama-base-boxed_metrics.json

@@ -0,0 +1,13 @@
+{
+    "num_samples": 500,
+    "num_scores": 500,
+    "timeout_samples": 32,
+    "empty_samples": 1,
+    "acc": 59.6,
+    "all_acc": [
+        59.6
+    ],
+    "mean_acc": 59.6,
+    "time_use_in_second": 40.11754846572876,
+    "time_use_in_minite": "0:40"
+}

math_evaluation/outputs/public/home/lshi/yoAI/projects/Online_CL/train/model_sft_save/Qwen2.5-1.5B-Entropy-solution-1/checkpoint-2750/math_eval/aime24/test_llama-base-boxed_-1_seed0_t0.0_s0_e-1_llama-base-boxed_metrics.json

@@ -0,0 +1,13 @@
+{
+    "num_samples": 30,
+    "num_scores": 30,
+    "timeout_samples": 0,
+    "empty_samples": 0,
+    "acc": 6.7,
+    "all_acc": [
+        6.7
+    ],
+    "mean_acc": 6.7,
+    "time_use_in_second": 8.051186084747314,
+    "time_use_in_minite": "0:08"
+}

math_evaluation/outputs/public/home/lshi/yoAI/projects/Online_CL/train/model_sft_save/Qwen2.5-1.5B-Entropy-solution-1/checkpoint-2750/math_eval/math_oai/test_qwen-boxed_-1_seed0_t0.0_s0_e-1_qwen-boxed_metrics.json

@@ -0,0 +1,13 @@
+{
+    "num_samples": 500,
+    "num_scores": 500,
+    "timeout_samples": 54,
+    "empty_samples": 56,
+    "acc": 32.0,
+    "all_acc": [
+        32.0
+    ],
+    "mean_acc": 32.0,
+    "time_use_in_second": 62.29504370689392,
+    "time_use_in_minite": "1:02"
+}

math_evaluation/outputs/public/home/lshi/yoAI/projects/Online_CL/train/model_sft_save/Qwen2.5-Math-1.5B-Entropy-solution-1/checkpoint-2450/math_eval/math_oai/test_llama-base-boxed_-1_seed0_t0.0_s0_e-1_llama-base-boxed_metrics.json

@@ -0,0 +1,13 @@
+{
+    "num_samples": 500,
+    "num_scores": 500,
+    "timeout_samples": 0,
+    "empty_samples": 1,
+    "acc": 72.6,
+    "all_acc": [
+        72.6
+    ],
+    "mean_acc": 72.6,
+    "time_use_in_second": 18.515631198883057,
+    "time_use_in_minite": "0:18"
+}

math_evaluation/sh/eval_1.sh

@@ -0,0 +1,111 @@
+set -ex
+
+PROMPT_TYPE=$1
+MODEL_NAME_OR_PATH=$2
+OUTPUT_DIR=$3
+n_sampling=$4
+temperature=$5
+
+SPLIT="test"
+NUM_TEST_SAMPLE=-1
+
+# English open datasets
+DATA_NAME="math_oai,minerva_math,olympiadbench"
+# DATA_NAME="gsm8k,math,svamp,asdiv,mawps,carp_en,tabmwp,minerva_math,gaokao2023en,olympiadbench,college_math"
+TOKENIZERS_PARALLELISM=false \
+python3 -u math_eval.py \
+    --model_name_or_path ${MODEL_NAME_OR_PATH} \
+    --data_name ${DATA_NAME} \
+    --output_dir ${OUTPUT_DIR} \
+    --split ${SPLIT} \
+    --prompt_type ${PROMPT_TYPE} \
+    --num_test_sample ${NUM_TEST_SAMPLE} \
+    --seed 0 \
+    --temperature ${temperature} \
+    --n_sampling ${n_sampling} \
+    --top_p 1 \
+    --start 0 \
+    --end -1 \
+    --use_vllm
+
+# English multiple-choice datasets
+# DATA_NAME="aqua,sat_math,mmlu_stem"
+# TOKENIZERS_PARALLELISM=false \
+# python3 -u math_eval.py \
+#     --model_name_or_path ${MODEL_NAME_OR_PATH} \
+#     --data_name ${DATA_NAME} \
+#     --output_dir ${OUTPUT_DIR} \
+#     --split ${SPLIT} \
+#     --prompt_type ${PROMPT_TYPE} \
+#     --num_test_sample ${NUM_TEST_SAMPLE} \
+#     --seed 0 \
+#     --temperature 0 \
+#     --n_sampling 1 \
+#     --top_p 1 \
+#     --start 0 \
+#     --end -1 \
+#     --use_vllm \
+#     --save_outputs \
+#     --overwrite \
+#     --num_shots 5
+
+# Chinese gaokao collections
+# DATA_NAME="gaokao2024_I,gaokao2024_II,gaokao2024_mix,gaokao_math_cloze,gaokao_math_qa"
+# TOKENIZERS_PARALLELISM=false \
+# python3 -u math_eval.py \
+#     --model_name_or_path ${MODEL_NAME_OR_PATH} \
+#     --data_name ${DATA_NAME} \
+#     --output_dir ${OUTPUT_DIR} \
+#     --split ${SPLIT} \
+#     --prompt_type ${PROMPT_TYPE} \
+#     --num_test_sample ${NUM_TEST_SAMPLE} \
+#     --seed 0 \
+#     --temperature 0 \
+#     --n_sampling 1 \
+#     --top_p 1 \
+#     --start 0 \
+#     --end -1 \
+#     --use_vllm \
+#     --save_outputs \
+#     --overwrite \
+#     --adapt_few_shot
+
+# Chinese other datasets
+# DATA_NAME="cmath,cn_middle_school"
+# TOKENIZERS_PARALLELISM=false \
+# python3 -u math_eval.py \
+#     --model_name_or_path ${MODEL_NAME_OR_PATH} \
+#     --data_name ${DATA_NAME} \
+#     --output_dir ${OUTPUT_DIR} \
+#     --split ${SPLIT} \
+#     --prompt_type ${PROMPT_TYPE} \
+#     --num_test_sample ${NUM_TEST_SAMPLE} \
+#     --seed 0 \
+#     --temperature 0 \
+#     --n_sampling 1 \
+#     --top_p 1 \
+#     --start 0 \
+#     --end -1 \
+#     --use_vllm \
+#     --save_outputs \
+#     --overwrite \
+#     --adapt_few_shot
+
+
+# English competition datasets
+DATA_NAME="aime24,amc23"
+TOKENIZERS_PARALLELISM=false \
+python3 -u math_eval.py \
+    --model_name_or_path ${MODEL_NAME_OR_PATH} \
+    --data_name ${DATA_NAME} \
+    --output_dir ${OUTPUT_DIR} \
+    --split ${SPLIT} \
+    --prompt_type ${PROMPT_TYPE} \
+    --num_test_sample ${NUM_TEST_SAMPLE} \
+    --seed 0 \
+    --temperature ${temperature} \
+    --n_sampling ${n_sampling} \
+    --top_p 1 \
+    --start 0 \
+    --end -1 \
+    --use_vllm

train/ETrainer.py

@@ -0,0 +1,599 @@
+# Copyright 2020-2025 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Entropy-weighted Trainer (ETrainer) for knowledge distillation with dynamic loss weighting.
+Based on TRL's SFTTrainer with modifications for teacher-student entropy-based weighting.
+"""
+
+import torch
+import torch.nn as nn
+from typing import Any, Dict
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from trl import SFTTrainer
+from dataclasses import dataclass, field
+from trl import SFTConfig
+import transformers
+
+
+@dataclass
+class ETrainerConfig(SFTConfig):
+    """
+    Extended SFTConfig with teacher model parameters for entropy-weighted training.
+    
+    Args:
+        teacher_model_path (`str`, *optional*):
+            Path to the teacher model (e.g., "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B").
+            If None, no entropy weighting is applied.
+        entropy_weight_alpha (`float`, defaults to 2.0):
+            Alpha parameter controlling the sensitivity of entropy difference weighting.
+            Higher values make the weighting more sensitive to entropy differences.
+        entropy_weight_beta (`float`, defaults to 0.3):
+            Beta parameter controlling the zero-point offset for entropy difference.
+            Determines the threshold for significant entropy differences.
+        use_entropy_weighting (`bool`, defaults to True):
+            Whether to apply entropy-based loss weighting. Set to False to use standard loss.
+        teacher_dtype (`str`, defaults to "bfloat16"):
+            Data type for teacher model ("float16", "bfloat16", or "float32").
+        entropy_top_k (`int`, defaults to 64):
+            Number of top tokens to use for entropy approximation. Set to None or vocab_size
+            to compute exact entropy. Smaller values save memory significantly.
+    """
+    teacher_model_path: str | None = field(
+        default=None,
+        metadata={"help": "Path to teacher model for entropy weighting"}
+    )
+    entropy_weight_alpha: float = field(
+        default=2.0,
+        metadata={"help": "Alpha parameter for entropy weighting sensitivity"}
+    )
+    entropy_weight_beta: float = field(
+        default=0.3,
+        metadata={"help": "Beta parameter for entropy weighting offset"}
+    )
+    use_entropy_weighting: bool = field(
+        default=True,
+        metadata={"help": "Whether to apply entropy-based loss weighting"}
+    )
+    teacher_dtype: str = field(
+        default="bfloat16",
+        metadata={"help": "Teacher model dtype (float16/bfloat16/float32)"}
+    )
+    entropy_top_k: int = field(
+        default=64,
+        metadata={"help": "Top-K tokens for entropy approximation (reduces memory)"}
+    )
+    teacher_device_ids: str | None = field(
+        default=None,
+        metadata={
+            "help": "GPU device IDs for teacher model (e.g., '0', '0,1', 'cuda:2'). "
+                    "If None, uses same device as student. Separate GPUs enable parallel computation."
+        }
+    )
+
+
+class ETrainer(SFTTrainer):
+    """
+    Entropy-weighted Trainer for knowledge distillation.
+    
+    This trainer extends SFTTrainer by adding dynamic per-token loss weighting based on
+    teacher-student entropy differences. The weight formula is:
+    
+        w_j = exp(-H_t(j)) * sigmoid(α * (|H_s(j) - H_t(j)| - β))
+    
+    Where:
+        - H_t(j): Teacher's entropy at position j (lower = more confident)
+        - H_s(j): Student's entropy at position j
+        - α: Sensitivity parameter (default 2.0)
+        - β: Offset parameter (default 0.3)
+    
+    Key features:
+        - Higher weight when teacher is confident (low H_t)
+        - Higher weight when student differs significantly from teacher (large |ΔH|)
+        - Smooth weighting via sigmoid to avoid gradient explosion
+    """
+    
+    def __init__(self, *args, **kwargs):
+        # Extract ETrainer-specific arguments before passing to parent
+        args_obj = kwargs.get('args', None)
+        
+        # Initialize parent SFTTrainer
+        super().__init__(*args, **kwargs)
+        
+        # Load teacher model if specified
+        self.teacher_model = None
+        self.use_entropy_weighting = False
+        
+        # Initialize entropy-specific metrics
+        # Note: Only initialize metrics we actually populate to avoid ZeroDivisionError
+        if not hasattr(self, '_metrics'):
+            self._metrics = {'train': {}, 'eval': {}}
+        
+        # Add entropy-specific metric keys
+        for mode in ['train', 'eval']:
+            if mode not in self._metrics:
+                self._metrics[mode] = {}
+            # Only initialize avg_weight since we're not logging entropy to save memory
+            self._metrics[mode].setdefault('avg_weight', [])
+        
+        if args_obj and hasattr(args_obj, 'teacher_model_path') and args_obj.teacher_model_path:
+            self.use_entropy_weighting = args_obj.use_entropy_weighting
+            self.entropy_weight_alpha = args_obj.entropy_weight_alpha
+            self.entropy_weight_beta = args_obj.entropy_weight_beta
+            self.entropy_top_k = getattr(args_obj, 'entropy_top_k', 64)
+            
+            if self.use_entropy_weighting:
+                print(f"🎓 Loading teacher model: {args_obj.teacher_model_path}")
+                print(f"📊 Entropy weighting params: α={self.entropy_weight_alpha}, β={self.entropy_weight_beta}")
+                print(f"💾 Entropy computation: top-k={self.entropy_top_k} (memory-efficient mode)")
+                
+                # Load teacher model to specified device(s)
+                self.teacher_device = self._load_teacher_model(args_obj)
+                
+                print("✅ Teacher model loaded and frozen")
+                
+                # Freeze teacher model
+                for param in self.teacher_model.parameters():
+                    param.requires_grad = False
+                
+                print("✅ Teacher model loaded and frozen")
+                
+                # --- Fix teacher tokenizer/model vocab mismatch ---
+                print("\n🔍 Checking teacher tokenizer/model alignment...")
+                teacher_tokenizer = AutoTokenizer.from_pretrained(
+                    args_obj.teacher_model_path,
+                    trust_remote_code=True
+                )
+                
+                tokenizer_vocab = len(teacher_tokenizer)
+                model_vocab = self.teacher_model.config.vocab_size
+                
+                print(f"📌 Teacher tokenizer vocab: {tokenizer_vocab}")
+                print(f"📌 Teacher model vocab: {model_vocab}")
+                
+                if tokenizer_vocab != model_vocab:
+                    print("⚠️  Teacher tokenizer & model vocab mismatch! Resizing teacher embeddings...")
+                    self.teacher_model.resize_token_embeddings(tokenizer_vocab)
+                    self.teacher_model.config.vocab_size = tokenizer_vocab
+                    print(f"✅ Teacher embeddings resized to {tokenizer_vocab}")
+                else:
+                    print("✅ Teacher tokenizer and model vocab already match")
+                
+                # --- Now align student with teacher ---
+                print(f"\n📊 Student model vocab size: {self.model.config.vocab_size}")
+                print(f"📊 Teacher model vocab size (after alignment): {self.teacher_model.config.vocab_size}")
+                
+                # Handle vocab size mismatch by resizing student embeddings to match teacher
+                if self.teacher_model.config.vocab_size != self.model.config.vocab_size:
+                    print(f"\n⚠️  Student/Teacher vocab size mismatch detected!")
+                    print(f"   Teacher: {self.teacher_model.config.vocab_size}")
+                    print(f"   Student: {self.model.config.vocab_size}")
+                    print(f"🔧 Resizing student embeddings to match teacher...")
+                    
+                    # Resize student model embeddings (new tokens initialized with mean of existing)
+                    self.model.resize_token_embeddings(self.teacher_model.config.vocab_size)
+                    
+                    print(f"✅ Student embeddings resized to {self.teacher_model.config.vocab_size}")
+                    print(f"   New student vocab size: {self.model.config.vocab_size}")
+                else:
+                    print(f"✅ Student and teacher vocab sizes already match: {self.model.config.vocab_size}")
+                
+                print("\n" + "="*60)
+                print(f"🎯 Final Vocab Alignment Complete")
+                print(f"📊 Teacher vocab size: {self.teacher_model.config.vocab_size}")
+                print(f"📊 Student vocab size: {self.model.config.vocab_size}")
+                print("="*60)
+    
+    def _parse_teacher_devices(self, teacher_device_ids: str | None) -> str | list:
+        """
+        Parse teacher device IDs string into device specification.
+        
+        Args:
+            teacher_device_ids: Device string like "0", "0,1", "cuda:2", or None
+        
+        Returns:
+            Single device string (e.g., "cuda:0") or list of devices for multi-GPU
+        """
+        if teacher_device_ids is None:
+            # Default: use cuda:0 if available
+            return "cuda:0" if torch.cuda.is_available() else "cpu"
+        
+        # Clean up the input
+        teacher_device_ids = teacher_device_ids.strip()
+        
+        # Handle comma-separated multi-GPU case
+        if ',' in teacher_device_ids:
+            device_list = [f"cuda:{id.strip()}" if not id.strip().startswith('cuda:') 
+                          else id.strip() 
+                          for id in teacher_device_ids.split(',')]
+            return device_list
+        
+        # Single device case
+        if not teacher_device_ids.startswith('cuda:'):
+            return f"cuda:{teacher_device_ids}"
+        return teacher_device_ids
+    
+    def _load_teacher_model(self, args_obj):
+        """
+        Load teacher model to specified device(s).
+        
+        This method handles both single-GPU and multi-GPU teacher configurations.
+        """
+        # Parse device IDs: "1" / "0,1" / "cuda:3"
+        teacher_dev = getattr(args_obj, "teacher_device_ids", None)
+        teacher_dev = self._parse_teacher_devices(teacher_dev)
+        
+        # Determine teacher dtype
+        dtype_map = {
+            "float16": torch.float16,
+            "bfloat16": torch.bfloat16,
+            "float32": torch.float32,
+        }
+        teacher_dtype = dtype_map.get(args_obj.teacher_dtype, torch.bfloat16)
+        
+        print(f"🖥️  Teacher target device(s): {teacher_dev}")
+        
+        # Case A: multi-GPU teacher
+        if isinstance(teacher_dev, list):
+            print(f"📡 Using multi-GPU teacher (HF auto parallel): {teacher_dev}")
+            
+            # Let HuggingFace accelerate handle device distribution automatically
+            self.teacher_model = AutoModelForCausalLM.from_pretrained(
+                args_obj.teacher_model_path,
+                torch_dtype=teacher_dtype,
+                trust_remote_code=True,
+                device_map="auto",  # Let accelerate decide optimal sharding
+            )
+            
+        # Case B: single GPU teacher
+        else:
+            device_str = teacher_dev
+            print(f"📡 Loading teacher on single GPU: {device_str}")
+            
+            # Load to CPU first, then move to target GPU
+            self.teacher_model = AutoModelForCausalLM.from_pretrained(
+                args_obj.teacher_model_path,
+                torch_dtype=teacher_dtype,
+                trust_remote_code=True,
+            )
+            
+            # Move whole model to target GPU
+            self.teacher_model.to(device_str)
+        
+        # Freeze teacher model
+        self.teacher_model.eval()
+        for param in self.teacher_model.parameters():
+            param.requires_grad = False
+        
+        return teacher_dev
+    
+    def log(self, logs: dict[str, float], start_time: float | None = None) -> None:
+        mode = "train" if self.model.training else "eval"
+
+        # Only rank 0 logs
+        if torch.distributed.is_available() and torch.distributed.is_initialized():
+            if torch.distributed.get_rank() != 0:
+                return
+
+        # Add avg_weight if exists
+        if self.use_entropy_weighting:
+            if 'avg_weight' in self._metrics[mode] and len(self._metrics[mode]['avg_weight']) > 0:
+                logs["avg_weight"] = sum(self._metrics[mode]['avg_weight']) / len(self._metrics[mode]['avg_weight'])
+                self._metrics[mode]['avg_weight'] = []
+
+        # VERY IMPORTANT:
+        # Call HF Trainer.log instead of TRL SFTTrainer.log
+        transformers.Trainer.log(self, logs)
+        
+    def compute_entropy(self, logits: torch.Tensor, top_k: int = None) -> torch.Tensor:
+        """
+        Compute per-token entropy from logits (supports top-k approximation for memory efficiency).
+        
+        Args:
+            logits: Model logits of shape [batch_size, seq_len, vocab_size]
+            top_k: If not None and < vocab_size, compute entropy using only top-k tokens.
+                   This significantly reduces memory usage with minimal impact on weight quality.
+                   Default uses self.entropy_top_k (set to 64 by default).
+        
+        Returns:
+            entropy: Per-token entropy of shape [batch_size, seq_len]
+        """
+        # Use instance's top_k setting if not explicitly provided
+        if top_k is None:
+            top_k = getattr(self, 'entropy_top_k', 64)
+        
+        with torch.no_grad():
+            # Use float32 for numerical stability
+            logits = logits.float()
+            
+            vocab_size = logits.size(-1)
+            
+            if top_k is not None and top_k < vocab_size:
+                # Top-K approximation: only compute entropy on top-k tokens
+                # This reduces memory from O(vocab_size) to O(k)
+                # Memory: ~151665 -> ~64, ~2400x reduction!
+                top_values, _ = torch.topk(logits, k=top_k, dim=-1)  # [..., top_k]
+                
+                log_probs = torch.log_softmax(top_values, dim=-1)    # [..., top_k]
+                probs = torch.softmax(top_values, dim=-1)            # [..., top_k]
+                
+                entropy = -(probs * log_probs).sum(dim=-1)           # [batch_size, seq_len]
+            else:
+                # Exact entropy computation (uses full vocab)
+                log_probs = torch.log_softmax(logits, dim=-1)
+                probs = torch.softmax(logits, dim=-1)
+                entropy = -(probs * log_probs).sum(dim=-1)
+            
+            return entropy
+    
+    def compute_entropy_topk(self, logits_topk: torch.Tensor) -> torch.Tensor:
+        """
+        Compute entropy from pre-extracted top-k logits (ultra memory-efficient).
+        
+        Args:
+            logits_topk: Top-k logits of shape [batch_size, seq_len, k]
+        
+        Returns:
+            entropy: Per-token entropy of shape [batch_size, seq_len]
+        """
+        with torch.no_grad():
+            # logits_topk is already top-k, just compute softmax on it
+            logits_topk = logits_topk.float()
+            
+            log_probs = torch.log_softmax(logits_topk, dim=-1)
+            probs = torch.softmax(logits_topk, dim=-1)
+            
+            entropy = -(probs * log_probs).sum(dim=-1)
+            
+            return entropy
+    
+    def compute_entropy_weights_topk(
+        self,
+        student_logits_topk: torch.Tensor,
+        teacher_logits_topk: torch.Tensor,
+        labels: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Compute per-token weights using pre-extracted top-k logits (optimized version).
+        
+        Formula: w_j = exp(-H_t(j)) * sigmoid(α * (|H_s(j) - H_t(j)| - β))
+        
+        Args:
+            student_logits_topk: Student top-k logits [batch_size, seq_len, k]
+            teacher_logits_topk: Teacher top-k logits [batch_size, seq_len, k]
+            labels: Ground truth labels [batch_size, seq_len]
+        
+        Returns:
+            weights: Per-token weights [batch_size, seq_len]
+        """
+        # Compute entropies from top-k logits (no additional memory allocation)
+        H_s = self.compute_entropy_topk(student_logits_topk)  # [batch_size, seq_len]
+        H_t = self.compute_entropy_topk(teacher_logits_topk)  # [batch_size, seq_len]
+        
+        # Compute entropy difference
+        delta_H = torch.abs(H_s - H_t)  # [batch_size, seq_len]
+        
+        # Component 1: exp(-H_t) - emphasizes positions where teacher is confident
+        teacher_confidence = torch.exp(-H_t)
+        
+        # Component 2: sigmoid(α * (|ΔH| - β)) - smooth weighting based on disagreement
+        disagreement_weight = torch.nn.functional.softplus(
+            self.entropy_weight_alpha * (delta_H - self.entropy_weight_beta)
+        )
+        
+        # Combined weight
+        weights = teacher_confidence * disagreement_weight
+        
+        # Mask out positions where labels are -100 (padding or prompt tokens)
+        mask = (labels != -100).float()
+        weights = weights * mask
+        
+        return weights
+    
+    def compute_entropy_weights(
+        self,
+        student_logits: torch.Tensor,
+        teacher_logits: torch.Tensor,
+        labels: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Compute per-token weights based on teacher-student entropy differences.
+        
+        Formula: w_j = exp(-H_t(j)) * sigmoid(α * (|H_s(j) - H_t(j)| - β))
+        
+        Args:
+            student_logits: Student model logits [batch_size, seq_len, vocab_size]
+            teacher_logits: Teacher model logits [batch_size, seq_len, vocab_size]
+            labels: Ground truth labels [batch_size, seq_len]
+        
+        Returns:
+            weights: Per-token weights [batch_size, seq_len]
+        """
+        # Compute entropies
+        H_s = self.compute_entropy(student_logits)  # [batch_size, seq_len]
+        H_t = self.compute_entropy(teacher_logits)  # [batch_size, seq_len]
+        
+        # Compute entropy difference
+        delta_H = torch.abs(H_s - H_t)  # [batch_size, seq_len]
+        
+        # Component 1: exp(-H_t) - emphasizes positions where teacher is confident
+        teacher_confidence = torch.exp(-H_t)
+        
+        # Component 2: sigmoid(α * (|ΔH| - β)) - smooth weighting based on disagreement
+        disagreement_weight = torch.sigmoid(
+            self.entropy_weight_alpha * (delta_H - self.entropy_weight_beta)
+        )
+        
+        # Combined weight
+        weights = teacher_confidence * disagreement_weight
+        
+        # Mask out positions where labels are -100 (padding or prompt tokens)
+        mask = (labels != -100).float()
+        weights = weights * mask
+        
+        return weights
+    
+    def compute_loss(
+        self,
+        model: nn.Module,
+        inputs: Dict[str, torch.Tensor | Any],
+        return_outputs: bool = False,
+        num_items_in_batch: torch.Tensor | None = None,
+    ):
+        """
+        Compute weighted loss with teacher-student entropy weighting.
+        
+        This method:
+        1. Computes student model forward pass
+        2. If teacher available, computes teacher forward pass (no grad)
+        3. Calculates per-token weights based on entropy differences
+        4. Applies weights to the loss
+        """
+        # Standard loss computation from parent class (no entropy weighting)
+        if not self.use_entropy_weighting or self.teacher_model is None:
+            return super().compute_loss(model, inputs, return_outputs, num_items_in_batch)
+        
+        # Get labels - SFTTrainer should have already set this up
+        if "labels" not in inputs:
+            raise ValueError(
+                "Expected 'labels' in inputs but not found. This usually means your data collator "
+                "is not properly configured. Please ensure you're using the correct collator."
+            )
+        labels = inputs["labels"]
+        
+        # ===== Entropy-weighted loss computation =====
+        
+        # 1. Student forward pass (with gradient)
+        inputs["use_cache"] = False
+        outputs = model(**inputs)
+        student_logits = outputs.logits  # [batch_size, seq_len, vocab_size]
+        
+        # 2. Teacher forward pass (no gradient)
+        with torch.no_grad():
+            # Move inputs to teacher device for parallel computation
+            teacher_input_ids = inputs["input_ids"]
+            teacher_attention_mask = inputs.get("attention_mask", None)
+            
+            # Get teacher's primary device
+            if isinstance(self.teacher_device, list):
+                primary_teacher_device = self.teacher_device[0]
+            else:
+                primary_teacher_device = self.teacher_device
+            
+            # Move to teacher device if different from student
+            if str(primary_teacher_device) != str(teacher_input_ids.device):
+                teacher_input_ids = teacher_input_ids.to(primary_teacher_device)
+                if teacher_attention_mask is not None:
+                    teacher_attention_mask = teacher_attention_mask.to(primary_teacher_device)
+            
+            # Prepare teacher inputs - explicitly pass only what's needed
+            teacher_outputs = self.teacher_model(
+                input_ids=teacher_input_ids,
+                attention_mask=teacher_attention_mask,
+                use_cache=False,  # Explicitly disable cache for training
+            )
+            teacher_logits_full = teacher_outputs.logits  # [batch_size, seq_len, vocab_size] on teacher device
+            
+            # CRITICAL OPTIMIZATION: Shift FIRST, then top-k
+            # This saves 1/seq_len of memory compared to top-k then shift
+            shift_teacher_logits_full = teacher_logits_full[..., :-1, :].contiguous()
+            del teacher_logits_full  # Free full logits immediately
+            
+            # Now extract top-k from shifted teacher logits
+            # Reduces from [B, T-1, 151k] to [B, T-1, 64] - 2400x reduction!
+            top_k = getattr(self, 'entropy_top_k', 64)
+            shift_teacher_logits_topk, _ = torch.topk(
+                shift_teacher_logits_full, k=top_k, dim=-1
+            )  # [batch_size, seq_len-1, top_k] on teacher device
+            
+            del shift_teacher_logits_full  # Free shifted full logits
+            
+            # Move teacher logits back to student device for weight computation
+            if str(primary_teacher_device) != str(student_logits.device):
+                shift_teacher_logits_topk = shift_teacher_logits_topk.to(student_logits.device)
+        
+        # 3. Compute entropy-based weights
+        # Shift student logits and labels
+        shift_student_logits = student_logits[..., :-1, :].contiguous()  # Full vocab for CE loss
+        shift_labels = labels[..., 1:].contiguous()
+        
+        # OPTIMIZATION 2: Extract top-k from student logits for entropy computation only
+        # Student still needs full logits for CE loss, but we can use top-k for entropy
+        with torch.no_grad():
+            top_k = getattr(self, 'entropy_top_k', 64)
+            student_logits_topk, student_indices_topk = torch.topk(
+                shift_student_logits, k=top_k, dim=-1
+            )  # [batch_size, seq_len-1, top_k]
+        
+        # Calculate weights using top-k versions (massive memory savings)
+        weights = self.compute_entropy_weights_topk(
+            student_logits_topk,      # [B, T-1, k]
+            shift_teacher_logits_topk, # [B, T-1, k]
+            shift_labels,
+        )  # [batch_size, seq_len-1]
+        
+        # 4. Compute weighted cross-entropy loss
+        # Flatten for loss computation
+        shift_student_logits_flat = shift_student_logits.view(-1, shift_student_logits.size(-1))
+        shift_labels_flat = shift_labels.view(-1)
+        weights_flat = weights.view(-1)
+        
+        # Compute per-token cross-entropy (no reduction)
+        loss_fct = nn.CrossEntropyLoss(reduction='none')
+        per_token_loss = loss_fct(shift_student_logits_flat, shift_labels_flat)
+        
+        # Apply weights
+        weighted_loss = per_token_loss * weights_flat
+        
+        # Create proper mask considering both labels and attention_mask
+        if "attention_mask" in inputs:
+            # Shift attention mask to align with shifted labels
+            shift_attention_mask = inputs["attention_mask"][..., 1:].contiguous()
+            valid_mask = (shift_labels != -100) & (shift_attention_mask == 1)
+        else:
+            # Fallback if no attention mask (e.g., padding-free training)
+            valid_mask = (shift_labels != -100)
+        
+        valid_mask_flat = valid_mask.view(-1).float()
+        
+        # Compute final loss: normalize by sum of weights (not by token count)
+        # CRITICAL: Normalizing by weight_sum instead of token count ensures that
+        # the relative importance defined by weights is actually respected.
+        # If we normalized by token count, small-weight tokens would still contribute
+        # equally in the denominator, defeating the purpose of weighting.
+        weighted_loss_masked = weighted_loss * valid_mask_flat
+        weight_sum = (weights_flat * valid_mask_flat).sum()
+        
+        loss = weighted_loss_masked.sum() / weight_sum.clamp(min=1e-8)
+        
+        # 5. Handle auxiliary loss if present (e.g., MoE)
+        if self.aux_loss_enabled and hasattr(outputs, 'aux_loss'):
+            loss = loss + outputs.aux_loss
+        
+        # Log statistics (for monitoring) - simplified to avoid redundant entropy computation
+        if self.model.training:
+            with torch.no_grad():
+                # Only log weight statistics to avoid redundant entropy computation
+                # (entropy was already computed in compute_entropy_weights above)
+                weight_mean = weights[shift_labels != -100].mean().item()
+                self._metrics['train']['avg_weight'].append(weight_mean)
+                
+                # Optional: Can enable these if you need entropy logging
+                # but note this will recompute entropy and use extra memory
+                # H_s_mean = self.compute_entropy(shift_student_logits).mean().item()
+                # H_t_mean = self.compute_entropy(shift_teacher_logits).mean().item()
+                # self._metrics['train']['student_entropy'].append(H_s_mean)
+                # self._metrics['train']['teacher_entropy'].append(H_t_mean)
+        
+        return (loss, outputs) if return_outputs else loss

train/test_1.py

@@ -0,0 +1,662 @@
+# Copyright 2020-2025 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Entropy-weighted Trainer (ETrainer) for knowledge distillation with dynamic loss weighting.
+Based on TRL's SFTTrainer with modifications for teacher-student entropy-based weighting.
+"""
+
+import torch
+import torch.nn as nn
+from typing import Any, Dict
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from trl import SFTTrainer
+from dataclasses import dataclass, field
+from trl import SFTConfig
+import transformers
+
+
+@dataclass
+class ETrainerConfig(SFTConfig):
+    """
+    Extended SFTConfig with teacher model parameters for entropy-weighted training.
+    
+    Args:
+        teacher_model_path (`str`, *optional*):
+            Path to the teacher model (e.g., "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B").
+            If None, no entropy weighting is applied.
+        entropy_weight_alpha (`float`, defaults to 2.0):
+            Alpha parameter controlling the sensitivity of entropy difference weighting.
+            Higher values make the weighting more sensitive to entropy differences.
+        entropy_weight_beta (`float`, defaults to 0.3):
+            Beta parameter controlling the zero-point offset for entropy difference.
+            Determines the threshold for significant entropy differences.
+        use_entropy_weighting (`bool`, defaults to True):
+            Whether to apply entropy-based loss weighting. Set to False to use standard loss.
+        teacher_dtype (`str`, defaults to "bfloat16"):
+            Data type for teacher model ("float16", "bfloat16", or "float32").
+        entropy_top_k (`int`, defaults to 64):
+            Number of top tokens to use for entropy approximation. Set to None or vocab_size
+            to compute exact entropy. Smaller values save memory significantly.
+    """
+    teacher_model_path: str | None = field(
+        default=None,
+        metadata={"help": "Path to teacher model for entropy weighting"}
+    )
+    entropy_weight_alpha: float = field(
+        default=2.0,
+        metadata={"help": "Alpha parameter for entropy weighting sensitivity"}
+    )
+    entropy_weight_beta: float = field(
+        default=0.3,
+        metadata={"help": "Beta parameter for entropy weighting offset"}
+    )
+    use_entropy_weighting: bool = field(
+        default=True,
+        metadata={"help": "Whether to apply entropy-based loss weighting"}
+    )
+    teacher_dtype: str = field(
+        default="bfloat16",
+        metadata={"help": "Teacher model dtype (float16/bfloat16/float32)"}
+    )
+    entropy_top_k: int = field(
+        default=64,
+        metadata={"help": "Top-K tokens for entropy approximation (reduces memory)"}
+    )
+    teacher_device_ids: str | None = field(
+        default=None,
+        metadata={
+            "help": "GPU device IDs for teacher model (e.g., '0', '0,1', 'cuda:2'). "
+                    "If None, uses same device as student. Separate GPUs enable parallel computation."
+        }
+    )
+
+
+class ETrainer(SFTTrainer):
+    """
+    Entropy-weighted Trainer for knowledge distillation.
+    
+    This trainer extends SFTTrainer by adding dynamic per-token loss weighting based on
+    teacher-student entropy differences. The weight formula is:
+    
+        w_j = exp(-H_t(j)) * sigmoid(α * (|H_s(j) - H_t(j)| - β))
+    
+    Where:
+        - H_t(j): Teacher's entropy at position j (lower = more confident)
+        - H_s(j): Student's entropy at position j
+        - α: Sensitivity parameter (default 2.0)
+        - β: Offset parameter (default 0.3)
+    
+    Key features:
+        - Higher weight when teacher is confident (low H_t)
+        - Higher weight when student differs significantly from teacher (large |ΔH|)
+        - Smooth weighting via sigmoid to avoid gradient explosion
+    """
+    
+    def __init__(self, *args, **kwargs):
+        # Extract ETrainer-specific arguments before passing to parent
+        args_obj = kwargs.get('args', None)
+        
+        # Initialize parent SFTTrainer
+        super().__init__(*args, **kwargs)
+        
+        # Load teacher model if specified
+        self.teacher_model = None
+        self.use_entropy_weighting = False
+        
+        # Initialize entropy-specific metrics
+        # Note: Only initialize metrics we actually populate to avoid ZeroDivisionError
+        if not hasattr(self, '_metrics'):
+            self._metrics = {'train': {}, 'eval': {}}
+        
+        # Add entropy-specific metric keys
+        for mode in ['train', 'eval']:
+            if mode not in self._metrics:
+                self._metrics[mode] = {}
+            # Only initialize avg_weight since we're not logging entropy to save memory
+            self._metrics[mode].setdefault('avg_weight', [])
+        
+        if args_obj and hasattr(args_obj, 'teacher_model_path') and args_obj.teacher_model_path:
+            self.use_entropy_weighting = args_obj.use_entropy_weighting
+            self.entropy_weight_alpha = args_obj.entropy_weight_alpha
+            self.entropy_weight_beta = args_obj.entropy_weight_beta
+            self.entropy_top_k = getattr(args_obj, 'entropy_top_k', 64)
+            
+            if self.use_entropy_weighting:
+                # Check if we're in distributed training
+                is_main_process = True
+                if torch.distributed.is_available() and torch.distributed.is_initialized():
+                    is_main_process = torch.distributed.get_rank() == 0
+                
+                if is_main_process:
+                    print(f"🎓 Loading teacher model: {args_obj.teacher_model_path}")
+                    print(f"📊 Entropy weighting params: α={self.entropy_weight_alpha}, β={self.entropy_weight_beta}")
+                    print(f"💾 Entropy computation: top-k={self.entropy_top_k} (memory-efficient mode)")
+                
+                # Load teacher model to specified device(s)
+                self.teacher_device = self._load_teacher_model(args_obj)
+                
+                if is_main_process:
+                    print("✅ Teacher model loaded and frozen")
+                
+                # Freeze teacher model
+                for param in self.teacher_model.parameters():
+                    param.requires_grad = False
+                
+                if is_main_process:
+                    print("✅ Teacher model loaded and frozen")
+                    
+                    # --- Fix teacher tokenizer/model vocab mismatch ---
+                    print("\n🔍 Checking teacher tokenizer/model alignment...")
+                
+                teacher_tokenizer = AutoTokenizer.from_pretrained(
+                    args_obj.teacher_model_path,
+                    trust_remote_code=True
+                )
+                
+                tokenizer_vocab = len(teacher_tokenizer)
+                model_vocab = self.teacher_model.config.vocab_size
+                
+                if is_main_process:
+                    print(f"📌 Teacher tokenizer vocab: {tokenizer_vocab}")
+                    print(f"📌 Teacher model vocab: {model_vocab}")
+                
+                if tokenizer_vocab != model_vocab:
+                    if is_main_process:
+                        print("⚠️  Teacher tokenizer & model vocab mismatch! Resizing teacher embeddings...")
+                    self.teacher_model.resize_token_embeddings(tokenizer_vocab)
+                    self.teacher_model.config.vocab_size = tokenizer_vocab
+                    if is_main_process:
+                        print(f"✅ Teacher embeddings resized to {tokenizer_vocab}")
+                else:
+                    if is_main_process:
+                        print("✅ Teacher tokenizer and model vocab already match")
+                
+                # --- Now align student with teacher ---
+                if is_main_process:
+                    print(f"\n📊 Student model vocab size: {self.model.config.vocab_size}")
+                    print(f"📊 Teacher model vocab size (after alignment): {self.teacher_model.config.vocab_size}")
+                
+                # Handle vocab size mismatch by resizing student embeddings to match teacher
+                if self.teacher_model.config.vocab_size != self.model.config.vocab_size:
+                    if is_main_process:
+                        print(f"\n⚠️  Student/Teacher vocab size mismatch detected!")
+                        print(f"   Teacher: {self.teacher_model.config.vocab_size}")
+                        print(f"   Student: {self.model.config.vocab_size}")
+                        print(f"🔧 Resizing student embeddings to match teacher...")
+                    
+                    # Resize student model embeddings (new tokens initialized with mean of existing)
+                    self.model.resize_token_embeddings(self.teacher_model.config.vocab_size)
+                    
+                    if is_main_process:
+                        print(f"✅ Student embeddings resized to {self.teacher_model.config.vocab_size}")
+                        print(f"   New student vocab size: {self.model.config.vocab_size}")
+                else:
+                    if is_main_process:
+                        print(f"✅ Student and teacher vocab sizes already match: {self.model.config.vocab_size}")
+                
+                if is_main_process:
+                    print("\n" + "="*60)
+                    print(f"🎯 Final Vocab Alignment Complete")
+                    print(f"📊 Teacher vocab size: {self.teacher_model.config.vocab_size}")
+                    print(f"📊 Student vocab size: {self.model.config.vocab_size}")
+                    print("="*60)
+    
+    def _parse_teacher_devices(self, teacher_device_ids: str | None) -> str | list:
+        """
+        Parse teacher device IDs string into device specification.
+        
+        Args:
+            teacher_device_ids: Device string like "0", "0,1", "cuda:2", or None
+        
+        Returns:
+            Single device string (e.g., "cuda:0") or list of devices for multi-GPU
+        """
+        if teacher_device_ids is None:
+            # Default: use cuda:0 if available
+            return "cuda:0" if torch.cuda.is_available() else "cpu"
+        
+        # Clean up the input
+        teacher_device_ids = teacher_device_ids.strip()
+        
+        # Handle comma-separated multi-GPU case
+        if ',' in teacher_device_ids:
+            device_list = [f"cuda:{id.strip()}" if not id.strip().startswith('cuda:') 
+                          else id.strip() 
+                          for id in teacher_device_ids.split(',')]
+            return device_list
+        
+        # Single device case
+        if not teacher_device_ids.startswith('cuda:'):
+            return f"cuda:{teacher_device_ids}"
+        return teacher_device_ids
+    
+    def _load_teacher_model(self, args_obj):
+        """
+        Load teacher model to specified device(s).
+        
+        This method handles both single-GPU and multi-GPU teacher configurations.
+        """
+        # Check if we're in distributed training
+        is_main_process = True
+        if torch.distributed.is_available() and torch.distributed.is_initialized():
+            is_main_process = torch.distributed.get_rank() == 0
+        
+        # Parse device IDs: "1" / "0,1" / "cuda:3"
+        teacher_dev = getattr(args_obj, "teacher_device_ids", None)
+        teacher_dev = self._parse_teacher_devices(teacher_dev)
+        
+        # Determine teacher dtype
+        dtype_map = {
+            "float16": torch.float16,
+            "bfloat16": torch.bfloat16,
+            "float32": torch.float32,
+        }
+        teacher_dtype = dtype_map.get(args_obj.teacher_dtype, torch.bfloat16)
+        
+        if is_main_process:
+            print(f"🖥️  Teacher target device(s): {teacher_dev}")
+        
+        # Case A: multi-GPU teacher
+        if isinstance(teacher_dev, list):
+            if is_main_process:
+                print(f"📡 Using multi-GPU teacher (HF auto parallel): {teacher_dev}")
+            
+            # Let HuggingFace accelerate handle device distribution automatically
+            self.teacher_model = AutoModelForCausalLM.from_pretrained(
+                args_obj.teacher_model_path,
+                torch_dtype=teacher_dtype,
+                trust_remote_code=True,
+                device_map="auto",  # Let accelerate decide optimal sharding
+            )
+            
+        # Case B: single GPU teacher
+        else:
+            device_str = teacher_dev
+            if is_main_process:
+                print(f"📡 Loading teacher on single GPU: {device_str}")
+            
+            # Load to CPU first, then move to target GPU
+            self.teacher_model = AutoModelForCausalLM.from_pretrained(
+                args_obj.teacher_model_path,
+                torch_dtype=teacher_dtype,
+                trust_remote_code=True,
+            )
+            
+            # Move whole model to target GPU
+            self.teacher_model.to(device_str)
+        
+        # Freeze teacher model
+        self.teacher_model.eval()
+        for param in self.teacher_model.parameters():
+            param.requires_grad = False
+        
+        return teacher_dev
+    
+    def log(self, logs: dict[str, float], start_time: float | None = None) -> None:
+        mode = "train" if self.model.training else "eval"
+
+        # Only rank 0 logs
+        if torch.distributed.is_available() and torch.distributed.is_initialized():
+            if torch.distributed.get_rank() != 0:
+                return
+
+        # Add avg_weight if exists
+        if self.use_entropy_weighting:
+            if 'avg_weight' in self._metrics[mode] and len(self._metrics[mode]['avg_weight']) > 0:
+                logs["avg_weight"] = sum(self._metrics[mode]['avg_weight']) / len(self._metrics[mode]['avg_weight'])
+                self._metrics[mode]['avg_weight'] = []
+
+        # VERY IMPORTANT:
+        # Call HF Trainer.log instead of TRL SFTTrainer.log
+        transformers.Trainer.log(self, logs)
+        
+    def compute_entropy(self, logits: torch.Tensor, top_k: int = None) -> torch.Tensor:
+        """
+        Compute per-token entropy from logits (supports top-k approximation for memory efficiency).
+        
+        Args:
+            logits: Model logits of shape [batch_size, seq_len, vocab_size]
+            top_k: If not None and < vocab_size, compute entropy using only top-k tokens.
+                   This significantly reduces memory usage with minimal impact on weight quality.
+                   Default uses self.entropy_top_k (set to 64 by default).
+        
+        Returns:
+            entropy: Per-token entropy of shape [batch_size, seq_len]
+        """
+        # Use instance's top_k setting if not explicitly provided
+        if top_k is None:
+            top_k = getattr(self, 'entropy_top_k', 64)
+        
+        with torch.no_grad():
+            # Use float32 for numerical stability
+            logits = logits.float()
+            
+            vocab_size = logits.size(-1)
+            
+            if top_k is not None and top_k < vocab_size:
+                # Top-K approximation: only compute entropy on top-k tokens
+                # This reduces memory from O(vocab_size) to O(k)
+                # Memory: ~151665 -> ~64, ~2400x reduction!
+                top_values, _ = torch.topk(logits, k=top_k, dim=-1)  # [..., top_k]
+                
+                log_probs = torch.log_softmax(top_values, dim=-1)    # [..., top_k]
+                probs = torch.softmax(top_values, dim=-1)            # [..., top_k]
+                
+                entropy = -(probs * log_probs).sum(dim=-1)           # [batch_size, seq_len]
+            else:
+                # Exact entropy computation (uses full vocab)
+                log_probs = torch.log_softmax(logits, dim=-1)
+                probs = torch.softmax(logits, dim=-1)
+                entropy = -(probs * log_probs).sum(dim=-1)
+            
+            return entropy
+    
+    def compute_entropy_topk(self, logits_topk: torch.Tensor) -> torch.Tensor:
+        """
+        Compute entropy from pre-extracted top-k logits (ultra memory-efficient).
+        
+        Args:
+            logits_topk: Top-k logits of shape [batch_size, seq_len, k]
+        
+        Returns:
+            entropy: Per-token entropy of shape [batch_size, seq_len]
+        """
+        with torch.no_grad():
+            # logits_topk is already top-k, just compute softmax on it
+            logits_topk = logits_topk.float()
+            
+            log_probs = torch.log_softmax(logits_topk, dim=-1)
+            probs = torch.softmax(logits_topk, dim=-1)
+            
+            entropy = -(probs * log_probs).sum(dim=-1)
+            
+            return entropy
+    
+    def compute_entropy_weights_topk(
+        self,
+        student_logits_topk: torch.Tensor,
+        teacher_logits_topk: torch.Tensor,
+        labels: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Compute per-token weights using pre-extracted top-k logits (optimized version).
+        
+        Formula: w_j = exp(-H_t(j)) * sigmoid(α * (|H_s(j) - H_t(j)| - β))
+        
+        Args:
+            student_logits_topk: Student top-k logits [batch_size, seq_len, k]
+            teacher_logits_topk: Teacher top-k logits [batch_size, seq_len, k]
+            labels: Ground truth labels [batch_size, seq_len]
+        
+        Returns:
+            weights: Per-token weights [batch_size, seq_len]
+        """
+        # Compute entropies from top-k logits (no additional memory allocation)
+        H_s = self.compute_entropy_topk(student_logits_topk)  # [batch_size, seq_len]
+        H_t = self.compute_entropy_topk(teacher_logits_topk)  # [batch_size, seq_len]
+        
+        # Compute entropy difference
+        delta_H = torch.abs(H_s - H_t)  # [batch_size, seq_len]
+        
+        # Component 1: exp(-H_t) - emphasizes positions where teacher is confident
+        teacher_confidence = torch.exp(-H_t)
+        
+        # Component 2: sigmoid(α * (|ΔH| - β)) - smooth weighting based on disagreement
+        disagreement_weight = torch.nn.functional.softplus(
+            self.entropy_weight_alpha * (delta_H - self.entropy_weight_beta)
+        )
+        
+        # Combined weight
+        weights = teacher_confidence * disagreement_weight
+        
+        # Mask out positions where labels are -100 (padding or prompt tokens)
+        mask = (labels != -100).float()
+        weights = weights * mask
+        
+        return weights
+    
+    def compute_entropy_weights(
+        self,
+        student_logits: torch.Tensor,
+        teacher_logits: torch.Tensor,
+        labels: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Compute per-token weights based on teacher-student entropy differences.
+        
+        Formula: w_j = exp(-H_t(j)) * sigmoid(α * (|H_s(j) - H_t(j)| - β))
+        
+        Args:
+            student_logits: Student model logits [batch_size, seq_len, vocab_size]
+            teacher_logits: Teacher model logits [batch_size, seq_len, vocab_size]
+            labels: Ground truth labels [batch_size, seq_len]
+        
+        Returns:
+            weights: Per-token weights [batch_size, seq_len]
+        """
+        # Compute entropies
+        H_s = self.compute_entropy(student_logits)  # [batch_size, seq_len]
+        H_t = self.compute_entropy(teacher_logits)  # [batch_size, seq_len]
+        
+        # Compute entropy difference
+        delta_H = torch.abs(H_s - H_t)  # [batch_size, seq_len]
+        
+        # Component 1: exp(-H_t) - emphasizes positions where teacher is confident
+        teacher_confidence = torch.exp(-H_t)
+        
+        # Component 2: sigmoid(α * (|ΔH| - β)) - smooth weighting based on disagreement
+        disagreement_weight = torch.sigmoid(
+            self.entropy_weight_alpha * (delta_H - self.entropy_weight_beta)
+        )
+        
+        # Combined weight
+        weights = teacher_confidence * disagreement_weight
+        
+        # Mask out positions where labels are -100 (padding or prompt tokens)
+        mask = (labels != -100).float()
+        weights = weights * mask
+        
+        return weights
+    
+    def compute_loss(
+        self,
+        model: nn.Module,
+        inputs: Dict[str, torch.Tensor | Any],
+        return_outputs: bool = False,
+        num_items_in_batch: torch.Tensor | None = None,
+    ):
+        """
+        Compute weighted loss with teacher-student entropy weighting.
+        
+        This method:
+        1. Computes student model forward pass
+        2. If teacher available, computes teacher forward pass (no grad)
+        3. Calculates per-token weights based on entropy differences
+        4. Applies weights to the loss
+        """
+        # Standard loss computation from parent class (no entropy weighting)
+        if not self.use_entropy_weighting or self.teacher_model is None:
+            return super().compute_loss(model, inputs, return_outputs, num_items_in_batch)
+        
+        # Get labels - SFTTrainer should have already set this up
+        if "labels" not in inputs:
+            raise ValueError(
+                "Expected 'labels' in inputs but not found. This usually means your data collator "
+                "is not properly configured. Please ensure you're using the correct collator."
+            )
+        labels = inputs["labels"]
+        
+        # ===== Entropy-weighted loss computation with PARALLEL execution =====
+        
+        # Get teacher's primary device
+        if isinstance(self.teacher_device, list):
+            primary_teacher_device = self.teacher_device[0]
+        else:
+            primary_teacher_device = self.teacher_device
+        
+        # Prepare teacher inputs (move to teacher device early)
+        teacher_input_ids = inputs["input_ids"].to(primary_teacher_device, non_blocking=True)
+        teacher_attention_mask = inputs.get("attention_mask", None)
+        if teacher_attention_mask is not None:
+            teacher_attention_mask = teacher_attention_mask.to(primary_teacher_device, non_blocking=True)
+        
+        # Get student device
+        student_device = next(model.parameters()).device
+        
+        # Create CUDA streams for parallel execution
+        student_stream = torch.cuda.Stream(device=student_device)
+        teacher_stream = torch.cuda.Stream(device=primary_teacher_device)
+        
+        # Containers for outputs
+        student_outputs_container = [None]
+        teacher_logits_topk_container = [None]
+        
+        # ===== PARALLEL EXECUTION BLOCK =====
+        
+        # Containers for student top-k logits
+        student_logits_topk_container = [None]
+        shift_student_logits_container = [None]
+        
+        # 1. Student forward pass (with gradient) on student stream
+        with torch.cuda.stream(student_stream):
+            inputs["use_cache"] = False
+            student_outputs_container[0] = model(**inputs)
+            
+            # CRITICAL: Extract student logits and do shift + top-k in the same stream
+            # This avoids keeping full vocab logits in memory
+            student_logits_full = student_outputs_container[0].logits  # [B, T, V]
+            
+            # Shift student logits for loss computation (needs full vocab for CE)
+            shift_student_logits_container[0] = student_logits_full[..., :-1, :].contiguous()
+            
+            # Extract top-k from shifted student logits for entropy (memory efficient)
+            with torch.no_grad():
+                top_k = getattr(self, 'entropy_top_k', 64)
+                student_logits_topk_container[0], _ = torch.topk(
+                    shift_student_logits_container[0], k=top_k, dim=-1
+                )  # [B, T-1, k]
+        
+        # 2. Teacher forward pass (no gradient) on teacher stream - RUNS IN PARALLEL!
+        with torch.cuda.stream(teacher_stream):
+            with torch.no_grad():
+                # Prepare teacher inputs - explicitly pass only what's needed
+                teacher_outputs = self.teacher_model(
+                    input_ids=teacher_input_ids,
+                    attention_mask=teacher_attention_mask,
+                    use_cache=False,  # Explicitly disable cache for training
+                )
+                teacher_logits_full = teacher_outputs.logits  # [batch_size, seq_len, vocab_size] on teacher device
+                
+                # CRITICAL MEMORY OPTIMIZATION: Extract top-k BEFORE shift to save memory
+                # This avoids creating a full [B, T, V] contiguous tensor
+                top_k = getattr(self, 'entropy_top_k', 64)
+                
+                # Get top-k from full logits [B, T, V] -> [B, T, k]
+                teacher_logits_topk_full, _ = torch.topk(teacher_logits_full, k=top_k, dim=-1)
+                
+                # Immediately delete full logits (free 4+ GB!)
+                del teacher_logits_full
+                del teacher_outputs  # Also free the outputs object
+                
+                # Now shift the much smaller top-k tensor [B, T, k] -> [B, T-1, k]
+                shift_teacher_logits_topk = teacher_logits_topk_full[..., :-1, :].contiguous()
+                
+                # Free the unshifted top-k
+                del teacher_logits_topk_full
+                
+                # Move to student device (asynchronously)
+                teacher_logits_topk_container[0] = shift_teacher_logits_topk.to(
+                    student_device, non_blocking=True
+                )
+                
+                # Explicitly delete to free teacher device memory immediately
+                del shift_teacher_logits_topk
+        
+        # ===== SYNCHRONIZATION POINT =====
+        # Wait for both streams to complete before using their results
+        student_stream.synchronize()
+        teacher_stream.synchronize()
+        
+        # Extract results from containers
+        outputs = student_outputs_container[0]
+        shift_teacher_logits_topk = teacher_logits_topk_container[0]
+        shift_student_logits = shift_student_logits_container[0]
+        student_logits_topk = student_logits_topk_container[0]
+        
+        # 3. Compute entropy-based weights
+        # Shift labels
+        shift_labels = labels[..., 1:].contiguous()
+        
+        # Calculate weights using top-k versions (massive memory savings)
+        weights = self.compute_entropy_weights_topk(
+            student_logits_topk,      # [B, T-1, k]
+            shift_teacher_logits_topk, # [B, T-1, k]
+            shift_labels,
+        )  # [batch_size, seq_len-1]
+        
+        # 4. Compute weighted cross-entropy loss
+        # Flatten for loss computation
+        shift_student_logits_flat = shift_student_logits.view(-1, shift_student_logits.size(-1))
+        shift_labels_flat = shift_labels.view(-1)
+        weights_flat = weights.view(-1)
+        
+        # Compute per-token cross-entropy (no reduction)
+        loss_fct = nn.CrossEntropyLoss(reduction='none')
+        per_token_loss = loss_fct(shift_student_logits_flat, shift_labels_flat)
+        
+        # Apply weights
+        weighted_loss = per_token_loss * weights_flat
+        
+        # Create proper mask considering both labels and attention_mask
+        if "attention_mask" in inputs:
+            # Shift attention mask to align with shifted labels
+            shift_attention_mask = inputs["attention_mask"][..., 1:].contiguous()
+            valid_mask = (shift_labels != -100) & (shift_attention_mask == 1)
+        else:
+            # Fallback if no attention mask (e.g., padding-free training)
+            valid_mask = (shift_labels != -100)
+        
+        valid_mask_flat = valid_mask.view(-1).float()
+        
+        # Compute final loss: normalize by sum of weights (not by token count)
+        # CRITICAL: Normalizing by weight_sum instead of token count ensures that
+        # the relative importance defined by weights is actually respected.
+        # If we normalized by token count, small-weight tokens would still contribute
+        # equally in the denominator, defeating the purpose of weighting.
+        weighted_loss_masked = weighted_loss * valid_mask_flat
+        weight_sum = (weights_flat * valid_mask_flat).sum()
+        
+        loss = weighted_loss_masked.sum() / weight_sum.clamp(min=1e-8)
+        
+        # 5. Handle auxiliary loss if present (e.g., MoE)
+        if self.aux_loss_enabled and hasattr(outputs, 'aux_loss'):
+            loss = loss + outputs.aux_loss
+        
+        # Log statistics (for monitoring) - simplified to avoid redundant entropy computation
+        if self.model.training:
+            with torch.no_grad():
+                # Only log weight statistics to avoid redundant entropy computation
+                # (entropy was already computed in compute_entropy_weights above)
+                weight_mean = weights[shift_labels != -100].mean().item()
+                self._metrics['train']['avg_weight'].append(weight_mean)
+                
+                # Optional: Can enable these if you need entropy logging
+                # but note this will recompute entropy and use extra memory
+                # H_s_mean = self.compute_entropy(shift_student_logits).mean().item()
+                # H_t_mean = self.compute_entropy(shift_teacher_logits).mean().item()
+                # self._metrics['train']['student_entropy'].append(H_s_mean)
+                # self._metrics['train']['teacher_entropy'].append(H_t_mean)
+        
+        return (loss, outputs) if return_outputs else loss

train/test_on_math.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""
+vLLM evaluation with correct parameter name: max_model_length
+"""
+import os
+import shutil
+from datetime import timedelta
+
+from lighteval.logging.evaluation_tracker import EvaluationTracker
+from lighteval.models.vllm.vllm_model import VLLMModelConfig
+from lighteval.pipeline import ParallelismManager, Pipeline, PipelineParameters
+from lighteval.utils.imports import is_package_available
+
+if is_package_available("accelerate"):
+    from accelerate import Accelerator, InitProcessGroupKwargs
+    accelerator = Accelerator(
+        kwargs_handlers=[InitProcessGroupKwargs(timeout=timedelta(seconds=3000))]
+    )
+else:
+    accelerator = None
+
+
+def setup_environment():
+    cc = shutil.which("x86_64-conda-linux-gnu-cc") or shutil.which("gcc")
+    cxx = shutil.which("x86_64-conda-linux-gnu-c++") or shutil.which("g++")
+    if cc:
+        os.environ["CC"] = cc
+    if cxx:
+        os.environ["CXX"] = cxx
+    os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+    print("✓ Environment configured")
+
+
+def main():
+    setup_environment()
+    print("--- Starting vLLM evaluation ---")
+    
+    # Use max_model_length (not max_model_len!)
+    MAX_MODEL_LENGTH = 40960  # 40k tokens to handle 33658
+    
+    pipeline = Pipeline(
+        tasks="lighteval|math_500|0|1",
+        pipeline_parameters=PipelineParameters(
+            launcher_type=ParallelismManager.ACCELERATE if accelerator else ParallelismManager.NONE,
+            # max_samples=10,  # For testing
+        ),
+        evaluation_tracker=EvaluationTracker(
+            output_dir="./results",
+            save_details=True,
+        ),
+        model_config=VLLMModelConfig(
+            model_name="Qwen/Qwen2.5-Math-7B-Instruct",
+            dtype="bfloat16",
+            tensor_parallel_size=1,
+            gpu_memory_utilization=0.92,
+            trust_remote_code=True,
+            max_model_length=MAX_MODEL_LENGTH,  # ✅ Correct parameter name!
+        ),
+    )
+    
+    print(f"📊 Config: max_model_length={MAX_MODEL_LENGTH}")
+    
+    pipeline.evaluate()
+    pipeline.save_and_push_results()
+    pipeline.show_results()
+    
+    print("✅ Done!")
+
+
+if __name__ == "__main__":
+    main()

train/test_ood_python_lora_rope.py

@@ -0,0 +1,203 @@
+import lighteval
+from lighteval.logging.evaluation_tracker import EvaluationTracker
+from lighteval.models.vllm.vllm_model import VLLMModelConfig
+from lighteval.pipeline import ParallelismManager, Pipeline, PipelineParameters
+from lighteval.utils.imports import is_package_available
+from peft import PeftModel
+from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig
+import os
+import torch
+import json
+
+if is_package_available("accelerate"):
+    from datetime import timedelta
+    from accelerate import Accelerator, InitProcessGroupKwargs
+    accelerator = Accelerator(kwargs_handlers=[InitProcessGroupKwargs(timeout=timedelta(seconds=3000))])
+else:
+    accelerator = None
+
+def merge_lora_if_needed():
+    """Merge LoRA model and preserve RoPE scaling configuration"""
+    merged_path = "/public/home/lshi/yoAI/projects/Online_CL/train/model_sft_save/Qwen2.5-Math-1.5B-Lora-Merged"
+    
+    if os.path.exists(os.path.join(merged_path, "config.json")):
+        print(f"Merged model already exists at {merged_path}")
+        
+        # Verify RoPE scaling in existing merged model
+        config_path = os.path.join(merged_path, "config.json")
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+            if 'rope_scaling' in config:
+                print(f"✓ Existing merged model has RoPE scaling: {config['rope_scaling']}")
+                print(f"✓ Max position embeddings: {config.get('max_position_embeddings', 'N/A')}")
+            else:
+                print("⚠ Warning: Existing merged model does NOT have RoPE scaling config!")
+                print("  Deleting and re-creating with RoPE scaling...")
+                import shutil
+                shutil.rmtree(merged_path)
+                return merge_lora_if_needed()  # Recursive call to re-create
+        
+        return merged_path
+
+    print("="*100)
+    print("Merged model not found. Starting merge process...")
+    print("="*100)
+
+    lora_path = "/public/home/lshi/yoAI/projects/Online_CL/train/model_sft_save/Qwen2.5-Math-1.5B-Lora"
+    
+    # Step 1: Load base model
+    print("\n[1/5] Loading base model...")
+    base_model = AutoModelForCausalLM.from_pretrained(
+        "Qwen/Qwen2.5-Math-1.5B",
+        torch_dtype=torch.bfloat16,
+        trust_remote_code=True,
+        device_map="auto"
+    )
+    
+    # Step 2: Load LoRA adapter
+    print("\n[2/5] Loading LoRA adapter...")
+    model = PeftModel.from_pretrained(base_model, lora_path)
+    
+    # Step 3: Merge and unload
+    print("\n[3/5] Merging LoRA weights with base model...")
+    merged_model = model.merge_and_unload()
+    
+    # Step 4: Save merged model
+    print(f"\n[4/5] Saving merged model to {merged_path}...")
+    os.makedirs(merged_path, exist_ok=True)
+    merged_model.save_pretrained(merged_path, safe_serialization=True)
+    
+    # Step 5: Add RoPE scaling configuration
+    print("\n[5/5] Adding RoPE scaling configuration...")
+    merged_config_path = os.path.join(merged_path, "config.json")
+    with open(merged_config_path, 'r') as f:
+        merged_config = json.load(f)
+    
+    # ========== RoPE scaling: 4096 -> 8192, factor = 2.0 ==========
+    merged_config['rope_scaling'] = {
+        "type": "linear",
+        "factor": 2.0
+    }
+    
+    print(f"✓ Added RoPE scaling: {merged_config['rope_scaling']}")
+    
+    # 更新 max_position_embeddings 从 4096 到 8192
+    original_max_pos = merged_config.get('max_position_embeddings', 4096)
+    scaling_factor = merged_config['rope_scaling']['factor']
+    new_max_pos = int(original_max_pos * scaling_factor)
+    merged_config['max_position_embeddings'] = new_max_pos
+    print(f"✓ Updated max_position_embeddings: {original_max_pos} -> {new_max_pos}")
+    
+    # Save updated config
+    with open(merged_config_path, 'w') as f:
+        json.dump(merged_config, f, indent=2, ensure_ascii=False)
+    
+    # Save tokenizer
+    print("Saving tokenizer...")
+    tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Math-1.5B", trust_remote_code=True)
+    tokenizer.save_pretrained(merged_path)
+    
+    # Clean up memory
+    del base_model
+    del model
+    del merged_model
+    torch.cuda.empty_cache()
+    
+    print("\n" + "="*100)
+    print("✓ Merge completed successfully!")
+    print(f"✓ Merged model saved to: {merged_path}")
+    print(f"✓ RoPE scaling config: {merged_config['rope_scaling']}")
+    print(f"✓ Max position embeddings: {merged_config['max_position_embeddings']}")
+    print("="*100 + "\n")
+    
+    return merged_path
+
+def main():
+    # Set CUDA device FIRST before any CUDA operations
+    os.environ["CUDA_VISIBLE_DEVICES"] = "2"
+    os.environ["VLLM_ALLOW_LONG_MAX_MODEL_LEN"] = "1"
+    
+    print("Checking for merged model...")
+    merged_model_path = merge_lora_if_needed()
+    
+    # Detect number of GPUs
+    num_gpus = torch.cuda.device_count()
+    print(f"\n{'='*100}")
+    print(f"Detected {num_gpus} GPU(s)")
+    if num_gpus > 0:
+        for i in range(num_gpus):
+            print(f"  GPU {i}: {torch.cuda.get_device_name(i)}")
+    print(f"{'='*100}\n")
+    
+    # Read the merged model config to get max_model_length
+    config_path = os.path.join(merged_model_path, "config.json")
+    with open(config_path, 'r') as f:
+        model_config_dict = json.load(f)
+        max_position_embeddings = model_config_dict.get('max_position_embeddings', 4096)
+        rope_scaling = model_config_dict.get('rope_scaling', None)
+    
+    print(f"Model max_position_embeddings: {max_position_embeddings}")
+    print(f"Model RoPE scaling config: {rope_scaling}")
+    
+    # 使用 8192 作为 max_model_length（你训练时扩展后的长度）
+    max_model_length = 8192
+    print(f"Using max_model_length: {max_model_length}\n")
+    
+    print("Setting up evaluation pipeline...")
+    
+    evaluation_tracker = EvaluationTracker(
+        output_dir="./results",
+        save_details=True,
+        push_to_hub=False,
+    )
+
+    pipeline_params = PipelineParameters(
+        launcher_type=ParallelismManager.ACCELERATE,
+        custom_tasks_directory=None,
+        max_samples=500
+    )
+
+    model_config = VLLMModelConfig(
+        model_name=merged_model_path,
+        dtype="bfloat16",
+        max_model_length=max_model_length,  # 使用 8192
+        trust_remote_code=True,
+        tensor_parallel_size=num_gpus,
+    )
+
+    task = "lighteval|math_500|0"
+
+    print(f"Using {num_gpus} GPU(s) with tensor parallelism")
+    print(f"Task: {task}")
+    print(f"Max model length: {max_model_length}\n")
+
+    print("Creating pipeline...")
+    pipeline = Pipeline(
+        tasks=task,
+        pipeline_parameters=pipeline_params,
+        evaluation_tracker=evaluation_tracker,
+        model_config=model_config,
+    )
+
+    # Fix generation_size
+    print("Configuring generation parameters...")
+    for task_name, task_obj in pipeline.tasks_dict.items():
+        for doc in task_obj._docs:
+            doc.generation_size = 2048
+
+    print("\nStarting evaluation...")
+    print("="*100)
+    pipeline.evaluate()
+    
+    print("\nSaving results...")
+    pipeline.save_and_push_results()
+    
+    print("\nShowing results...")
+    pipeline.show_results()
+    
+    print("\n" + "="*100)
+    print("✓ Evaluation completed!")
+    print("="*100)
+
+if __name__ == "__main__":
+    main()

train/wandb/run-20251113_165350-n56lk6p0/logs/debug-internal.log

@@ -0,0 +1,6 @@
+{"time":"2025-11-13T16:53:50.599141389+08:00","level":"INFO","msg":"stream: starting","core version":"0.22.3"}
+{"time":"2025-11-13T16:53:51.898899791+08:00","level":"INFO","msg":"stream: created new stream","id":"n56lk6p0"}
+{"time":"2025-11-13T16:53:51.899200939+08:00","level":"INFO","msg":"handler: started","stream_id":"n56lk6p0"}
+{"time":"2025-11-13T16:53:51.900823773+08:00","level":"INFO","msg":"stream: started","id":"n56lk6p0"}
+{"time":"2025-11-13T16:53:51.90140837+08:00","level":"INFO","msg":"writer: started","stream_id":"n56lk6p0"}
+{"time":"2025-11-13T16:53:51.901489184+08:00","level":"INFO","msg":"sender: started","stream_id":"n56lk6p0"}

train/wandb/run-20251113_171624-kgxigylp/files/wandb-metadata.json

@@ -0,0 +1,117 @@
+{
+  "os":  "Linux-4.18.0-372.9.1.el8.x86_64-x86_64-with-glibc2.28",
+  "python":  "CPython 3.10.19",
+  "startedAt":  "2025-11-13T09:16:24.807116Z",
+  "args":  [
+    "--model_name",
+    "Qwen/Qwen2.5-Math-1.5B",
+    "--dataset_name",
+    "openr1",
+    "--output_dir",
+    "./model_sft_save/Qwen2.5-Math-1.5B-Full-solution",
+    "--batch_size",
+    "2",
+    "--grad_accum",
+    "4",
+    "--learning_rate",
+    "5e-6",
+    "--epochs",
+    "1",
+    "--use_rope_scaling",
+    "--use_deepspeed",
+    "--deepspeed_config",
+    "deepspeed/dp_stage2.json",
+    "--use_wandb",
+    "--wandb_project",
+    "qwen-math-sft",
+    "--wandb_run_name",
+    "qwen2.5-1.5b-46k-fft-solution"
+  ],
+  "program":  "/public/home/lshi/yoAI/projects/Online_CL/train/train_qwen_46k.py",
+  "codePath":  "train_qwen_46k.py",
+  "codePathLocal":  "train_qwen_46k.py",
+  "email":  "yaning1001@gmail.com",
+  "root":  "/public/home/lshi/yoAI/projects/Online_CL/train",
+  "host":  "gpu-h100-07",
+  "executable":  "/public/home/lshi/miniconda3/envs/sft_qwen/bin/python3.10",
+  "cpu_count":  96,
+  "cpu_count_logical":  96,
+  "gpu":  "NVIDIA H100 80GB HBM3",
+  "gpu_count":  8,
+  "disk":  {
+    "/":  {
+      "total":  "469407801344",
+      "used":  "289841229824"
+    }
+  },
+  "memory":  {
+    "total":  "2164142350336"
+  },
+  "gpu_nvidia":  [
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-d26f2d36-a358-5f8b-e928-f5ef4f73bc89"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-379104cc-3e15-4b2c-1b78-4ee1f142e16b"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-0d2164b6-b82a-6774-4914-58672f66b913"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-4f4398d2-2978-d7cb-7a33-2995e4efdbfd"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-0b6b2f40-df37-1563-f0cb-727bd3ac0fd9"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-8574e86d-a1bb-13dd-1843-407b718ebdf6"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-23628f74-fede-6431-ae15-2764fce29130"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-d18d570f-dd0f-0ff6-3401-561c9e799136"
+    }
+  ],
+  "cudaVersion":  "12.4",
+  "slurm":  {
+    "home":  "/opt/gridview/slurm",
+    "pmix_direct_conn":  "true",
+    "pmix_direct_conn_early":  "false",
+    "pmix_direct_conn_ucx":  "false",
+    "pmix_timeout":  "3000"
+  },
+  "writerId":  "tp3ukl31hffsi4h6hmw62zh3mmvd4ck1"
+}

train/wandb/run-20251114_040305-jb702f8e/files/wandb-summary.json

@@ -0,0 +1 @@
+{"_wandb":{"runtime":16984},"_runtime":16984}

train/wandb/run-20251114_083110-mocjk23v/files/wandb-summary.json

@@ -0,0 +1 @@
+{"_wandb":{"runtime":1157},"_runtime":1157}

train/wandb/run-20251114_085634-l1whc2fu/logs/debug-core.log

@@ -0,0 +1,14 @@
+{"time":"2025-11-14T08:56:34.99307817+08:00","level":"INFO","msg":"main: starting server","port-filename":"/tmp/tmps5yzjy9e/port-683755.txt","pid":683755,"log-level":0,"disable-analytics":false,"shutdown-on-parent-exit":false,"enable-dcgm-profiling":false}
+{"time":"2025-11-14T08:56:34.993470483+08:00","level":"INFO","msg":"server: accepting connections","addr":{"Name":"/tmp/wandb-683755-684391-740002659/socket","Net":"unix"}}
+{"time":"2025-11-14T08:56:34.993683243+08:00","level":"INFO","msg":"server: will exit if parent process dies","ppid":683755}
+{"time":"2025-11-14T08:56:35.174882292+08:00","level":"INFO","msg":"connection: ManageConnectionData: new connection created","id":"1(@)"}
+{"time":"2025-11-14T08:56:35.188631623+08:00","level":"INFO","msg":"handleInformInit: received","streamId":"l1whc2fu","id":"1(@)"}
+{"time":"2025-11-14T08:56:36.5336818+08:00","level":"INFO","msg":"handleInformInit: stream started","streamId":"l1whc2fu","id":"1(@)"}
+{"time":"2025-11-14T08:57:28.613569258+08:00","level":"INFO","msg":"handleInformTeardown: server teardown initiated","id":"1(@)"}
+{"time":"2025-11-14T08:57:28.613821906+08:00","level":"INFO","msg":"connection: closing","id":"1(@)"}
+{"time":"2025-11-14T08:57:28.613882852+08:00","level":"INFO","msg":"connection: closed successfully","id":"1(@)"}
+{"time":"2025-11-14T08:57:28.613904195+08:00","level":"INFO","msg":"server is shutting down"}
+{"time":"2025-11-14T08:57:28.613981514+08:00","level":"INFO","msg":"server: listener closed","addr":{"Name":"/tmp/wandb-683755-684391-740002659/socket","Net":"unix"}}
+{"time":"2025-11-14T08:57:31.434572086+08:00","level":"INFO","msg":"handleInformTeardown: server shutdown complete","id":"1(@)"}
+{"time":"2025-11-14T08:57:31.43461066+08:00","level":"INFO","msg":"connection: ManageConnectionData: connection closed","id":"1(@)"}
+{"time":"2025-11-14T08:57:31.43463779+08:00","level":"INFO","msg":"server is closed"}

train/wandb/run-20251114_093516-syhj5u87/files/config.yaml

@@ -0,0 +1,179 @@
+_wandb:
+    value:
+        cli_version: 0.22.3
+        e:
+            8wbmn2ipfnapymj9hqf701ll90rovymt:
+                args:
+                    - --model_name
+                    - Qwen/Qwen2.5-1.5B
+                    - --dataset_path
+                    - ./datasets/openr1/Openr1-Math-46k-8192.jsonl
+                    - --output_dir
+                    - ./model_sft_save/Qwen2.5-1.5B-Entropy-solution
+                    - --batch_size
+                    - "2"
+                    - --grad_accum
+                    - "4"
+                    - --learning_rate
+                    - "5e-6"
+                    - --epochs
+                    - "1"
+                    - --use_entropy_weighting
+                    - --teacher_model_path
+                    - deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
+                    - --entropy_weight_alpha
+                    - "2.0"
+                    - --entropy_weight_beta
+                    - "0.3"
+                    - --teacher_dtype
+                    - bfloat16
+                    - --use_deepspeed
+                    - --deepspeed_config
+                    - deepspeed/dp_stage2.json
+                    - --use_wandb
+                    - --wandb_project
+                    - qwen-math-entropy-sft
+                    - --wandb_run_name
+                    - qwen2.5-1.5b-46k-entropy-solution
+                codePath: train_qwen_46k_weight.py
+                codePathLocal: train_qwen_46k_weight.py
+                cpu_count: 96
+                cpu_count_logical: 96
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "469407801344"
+                        used: "288164167680"
+                email: yaning1001@gmail.com
+                executable: /public/home/lshi/miniconda3/envs/sft_qwen/bin/python3.10
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 6
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-d26f2d36-a358-5f8b-e928-f5ef4f73bc89
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-379104cc-3e15-4b2c-1b78-4ee1f142e16b
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-0d2164b6-b82a-6774-4914-58672f66b913
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-4f4398d2-2978-d7cb-7a33-2995e4efdbfd
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-0b6b2f40-df37-1563-f0cb-727bd3ac0fd9
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-8574e86d-a1bb-13dd-1843-407b718ebdf6
+                host: gpu-h100-07
+                memory:
+                    total: "2164142350336"
+                os: Linux-4.18.0-372.9.1.el8.x86_64-x86_64-with-glibc2.28
+                program: /public/home/lshi/yoAI/projects/Online_CL/train/train_qwen_46k_weight.py
+                python: CPython 3.10.19
+                root: /public/home/lshi/yoAI/projects/Online_CL/train
+                slurm:
+                    cluster_name: cluster_admin1
+                    conf: /opt/gridview/slurm/etc/slurm.conf
+                    cpu_bind: quiet,mask_cpu:0x000000000000000000000001
+                    cpu_bind_list: "0x000000000000000000000001"
+                    cpu_bind_type: 'mask_cpu:'
+                    cpu_bind_verbose: quiet
+                    cpus_on_node: "1"
+                    distribution: cyclic
+                    gtids: "0"
+                    home: /opt/gridview/slurm
+                    job_account: seu_qli
+                    job_cpus_per_node: "1"
+                    job_gid: "2026"
+                    job_id: "8428"
+                    job_name: bash
+                    job_nodelist: gpu-h100-07
+                    job_num_nodes: "1"
+                    job_partition: H100
+                    job_qos: normal
+                    job_uid: "2019"
+                    job_user: lshi
+                    jobid: "8428"
+                    launch_node_ipaddr: 172.16.254.194
+                    localid: "0"
+                    nnodes: "1"
+                    nodeid: "0"
+                    nodelist: gpu-h100-07
+                    nprocs: "1"
+                    ntasks: "1"
+                    pmix_direct_conn: "true"
+                    pmix_direct_conn_early: "false"
+                    pmix_direct_conn_ucx: "false"
+                    pmix_timeout: "3000"
+                    prio_process: "0"
+                    procid: "0"
+                    pty_port: "43139"
+                    pty_win_col: "146"
+                    pty_win_row: "21"
+                    srun_comm_host: 172.16.254.194
+                    srun_comm_port: "34989"
+                    step_gpus: 0,1,2,3,4,5
+                    step_id: "0"
+                    step_launcher_port: "34989"
+                    step_nodelist: gpu-h100-07
+                    step_num_nodes: "1"
+                    step_num_tasks: "1"
+                    step_tasks_per_node: "1"
+                    stepid: "0"
+                    submit_dir: /public/home/lshi/yoAI/projects
+                    submit_host: admin1
+                    task_pid: "649671"
+                    tasks_per_node: "1"
+                    topology_addr: gpu-h100-07
+                    topology_addr_pattern: node
+                    umask: "0022"
+                    working_cluster: cluster_admin1:172.16.254.194:6817:9216:101
+                startedAt: "2025-11-14T01:35:16.982120Z"
+                writerId: 8wbmn2ipfnapymj9hqf701ll90rovymt
+        m: []
+        python_version: 3.10.19
+        t:
+            "1":
+                - 1
+                - 11
+                - 41
+                - 49
+                - 51
+                - 71
+                - 84
+                - 98
+                - 105
+            "2":
+                - 1
+                - 11
+                - 41
+                - 49
+                - 51
+                - 71
+                - 84
+                - 98
+                - 105
+            "3":
+                - 13
+            "4": 3.10.19
+            "5": 0.22.3
+            "6": 4.57.1
+            "10":
+                - 20
+            "12": 0.22.3
+            "13": linux-x86_64

train/wandb/run-20251114_093516-syhj5u87/logs/debug-core.log

@@ -0,0 +1,12 @@
+{"time":"2025-11-14T09:35:17.03441142+08:00","level":"INFO","msg":"main: starting server","port-filename":"/tmp/tmpw3beozyg/port-732696.txt","pid":732696,"log-level":0,"disable-analytics":false,"shutdown-on-parent-exit":false,"enable-dcgm-profiling":false}
+{"time":"2025-11-14T09:35:17.034758287+08:00","level":"INFO","msg":"server: accepting connections","addr":{"Name":"/tmp/wandb-732696-733205-3319755749/socket","Net":"unix"}}
+{"time":"2025-11-14T09:35:17.034951673+08:00","level":"INFO","msg":"server: will exit if parent process dies","ppid":732696}
+{"time":"2025-11-14T09:35:17.211537499+08:00","level":"INFO","msg":"connection: ManageConnectionData: new connection created","id":"1(@)"}
+{"time":"2025-11-14T09:35:17.220353582+08:00","level":"INFO","msg":"handleInformInit: received","streamId":"syhj5u87","id":"1(@)"}
+{"time":"2025-11-14T09:35:18.22989479+08:00","level":"INFO","msg":"handleInformInit: stream started","streamId":"syhj5u87","id":"1(@)"}
+{"time":"2025-11-14T09:36:02.014981461+08:00","level":"INFO","msg":"handleInformTeardown: server teardown initiated","id":"1(@)"}
+{"time":"2025-11-14T09:36:02.015245162+08:00","level":"INFO","msg":"connection: closing","id":"1(@)"}
+{"time":"2025-11-14T09:36:02.015313878+08:00","level":"INFO","msg":"connection: closed successfully","id":"1(@)"}
+{"time":"2025-11-14T09:36:02.015339332+08:00","level":"INFO","msg":"server is shutting down"}
+{"time":"2025-11-14T09:36:02.015416344+08:00","level":"INFO","msg":"server: listener closed","addr":{"Name":"/tmp/wandb-732696-733205-3319755749/socket","Net":"unix"}}
+{"time":"2025-11-14T09:36:06.194928818+08:00","level":"INFO","msg":"server: parent process exited, terminating service process"}

train/wandb/run-20251114_103643-cvm4116u/files/config.yaml

@@ -0,0 +1,698 @@
+_name_or_path:
+    value: Qwen/Qwen2.5-1.5B
+_wandb:
+    value:
+        cli_version: 0.22.3
+        e:
+            7c7ug24k5x5ruwahnf33q520l30fph0h:
+                args:
+                    - --model_name
+                    - Qwen/Qwen2.5-1.5B
+                    - --dataset_path
+                    - ./datasets/openr1/Openr1-Math-46k-8192.jsonl
+                    - --output_dir
+                    - ./model_sft_save/Qwen2.5-1.5B-Entropy-solution
+                    - --batch_size
+                    - "2"
+                    - --grad_accum
+                    - "4"
+                    - --learning_rate
+                    - "5e-6"
+                    - --epochs
+                    - "1"
+                    - --use_entropy_weighting
+                    - --teacher_model_path
+                    - deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
+                    - --entropy_weight_alpha
+                    - "2.0"
+                    - --entropy_weight_beta
+                    - "0.3"
+                    - --teacher_dtype
+                    - bfloat16
+                    - --use_deepspeed
+                    - --deepspeed_config
+                    - deepspeed/dp_stage2.json
+                    - --use_wandb
+                    - --wandb_project
+                    - qwen-math-entropy-sft
+                    - --wandb_run_name
+                    - qwen2.5-1.5b-46k-entropy-solution
+                codePath: train_qwen_46k_weight.py
+                codePathLocal: train_qwen_46k_weight.py
+                cpu_count: 96
+                cpu_count_logical: 96
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "469407801344"
+                        used: "288221097984"
+                email: yaning1001@gmail.com
+                executable: /public/home/lshi/miniconda3/envs/sft_qwen/bin/python3.10
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 6
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-d26f2d36-a358-5f8b-e928-f5ef4f73bc89
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-379104cc-3e15-4b2c-1b78-4ee1f142e16b
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-0d2164b6-b82a-6774-4914-58672f66b913
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-4f4398d2-2978-d7cb-7a33-2995e4efdbfd
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-0b6b2f40-df37-1563-f0cb-727bd3ac0fd9
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-8574e86d-a1bb-13dd-1843-407b718ebdf6
+                host: gpu-h100-07
+                memory:
+                    total: "2164142350336"
+                os: Linux-4.18.0-372.9.1.el8.x86_64-x86_64-with-glibc2.28
+                program: /public/home/lshi/yoAI/projects/Online_CL/train/train_qwen_46k_weight.py
+                python: CPython 3.10.19
+                root: /public/home/lshi/yoAI/projects/Online_CL/train
+                slurm:
+                    cluster_name: cluster_admin1
+                    conf: /opt/gridview/slurm/etc/slurm.conf
+                    cpu_bind: quiet,mask_cpu:0x000000000000000000000001
+                    cpu_bind_list: "0x000000000000000000000001"
+                    cpu_bind_type: 'mask_cpu:'
+                    cpu_bind_verbose: quiet
+                    cpus_on_node: "1"
+                    distribution: cyclic
+                    gtids: "0"
+                    home: /opt/gridview/slurm
+                    job_account: seu_qli
+                    job_cpus_per_node: "1"
+                    job_gid: "2026"
+                    job_id: "8428"
+                    job_name: bash
+                    job_nodelist: gpu-h100-07
+                    job_num_nodes: "1"
+                    job_partition: H100
+                    job_qos: normal
+                    job_uid: "2019"
+                    job_user: lshi
+                    jobid: "8428"
+                    launch_node_ipaddr: 172.16.254.194
+                    localid: "0"
+                    nnodes: "1"
+                    nodeid: "0"
+                    nodelist: gpu-h100-07
+                    nprocs: "1"
+                    ntasks: "1"
+                    pmix_direct_conn: "true"
+                    pmix_direct_conn_early: "false"
+                    pmix_direct_conn_ucx: "false"
+                    pmix_timeout: "3000"
+                    prio_process: "0"
+                    procid: "0"
+                    pty_port: "43139"
+                    pty_win_col: "146"
+                    pty_win_row: "21"
+                    srun_comm_host: 172.16.254.194
+                    srun_comm_port: "34989"
+                    step_gpus: 0,1,2,3,4,5
+                    step_id: "0"
+                    step_launcher_port: "34989"
+                    step_nodelist: gpu-h100-07
+                    step_num_nodes: "1"
+                    step_num_tasks: "1"
+                    step_tasks_per_node: "1"
+                    stepid: "0"
+                    submit_dir: /public/home/lshi/yoAI/projects
+                    submit_host: admin1
+                    task_pid: "649671"
+                    tasks_per_node: "1"
+                    topology_addr: gpu-h100-07
+                    topology_addr_pattern: node
+                    umask: "0022"
+                    working_cluster: cluster_admin1:172.16.254.194:6817:9216:101
+                startedAt: "2025-11-14T02:36:43.740743Z"
+                writerId: 7c7ug24k5x5ruwahnf33q520l30fph0h
+        m:
+            - "1": train/global_step
+              "6":
+                - 3
+              "7": []
+            - "2": '*'
+              "5": 1
+              "6":
+                - 1
+              "7": []
+        python_version: 3.10.19
+        t:
+            "1":
+                - 1
+                - 11
+                - 41
+                - 49
+                - 51
+                - 71
+                - 84
+                - 98
+                - 105
+            "2":
+                - 1
+                - 11
+                - 41
+                - 49
+                - 51
+                - 71
+                - 84
+                - 98
+                - 105
+            "3":
+                - 7
+                - 13
+                - 19
+                - 66
+            "4": 3.10.19
+            "5": 0.22.3
+            "6": 4.57.1
+            "9":
+                "1": transformers_trainer
+            "10":
+                - 20
+            "12": 0.22.3
+            "13": linux-x86_64
+accelerator_config:
+    value:
+        dispatch_batches: null
+        even_batches: true
+        gradient_accumulation_kwargs: null
+        non_blocking: false
+        split_batches: false
+        use_seedable_sampler: true
+activation_offloading:
+    value: false
+adafactor:
+    value: false
+adam_beta1:
+    value: 0.9
+adam_beta2:
+    value: 0.999
+adam_epsilon:
+    value: 1e-08
+add_cross_attention:
+    value: false
+architectures:
+    value:
+        - Qwen2ForCausalLM
+assistant_only_loss:
+    value: false
+attention_dropout:
+    value: 0
+auto_find_batch_size:
+    value: false
+average_tokens_across_devices:
+    value: true
+bad_words_ids:
+    value: null
+batch_eval_metrics:
+    value: false
+begin_suppress_tokens:
+    value: null
+bf16:
+    value: true
+bf16_full_eval:
+    value: false
+bos_token_id:
+    value: null
+chat_template_path:
+    value: null
+chunk_size_feed_forward:
+    value: 0
+completion_only_loss:
+    value: null
+cross_attention_hidden_size:
+    value: null
+data_seed:
+    value: null
+dataloader_drop_last:
+    value: false
+dataloader_num_workers:
+    value: 0
+dataloader_persistent_workers:
+    value: false
+dataloader_pin_memory:
+    value: true
+dataloader_prefetch_factor:
+    value: null
+dataset_kwargs:
+    value: null
+dataset_num_proc:
+    value: null
+dataset_text_field:
+    value: null
+ddp_backend:
+    value: null
+ddp_broadcast_buffers:
+    value: null
+ddp_bucket_cap_mb:
+    value: null
+ddp_find_unused_parameters:
+    value: null
+ddp_timeout:
+    value: 1800
+debug:
+    value: []
+decoder_start_token_id:
+    value: null
+deepspeed:
+    value: deepspeed/dp_stage2.json
+disable_tqdm:
+    value: false
+diversity_penalty:
+    value: 0
+do_eval:
+    value: true
+do_predict:
+    value: false
+do_sample:
+    value: false
+do_train:
+    value: false
+dtype:
+    value: bfloat16
+early_stopping:
+    value: false
+encoder_no_repeat_ngram_size:
+    value: 0
+entropy_top_k:
+    value: 64
+entropy_weight_alpha:
+    value: 2
+entropy_weight_beta:
+    value: 0.3
+eos_token:
+    value: <EOS_TOKEN>
+eos_token_id:
+    value: 151643
+eval_accumulation_steps:
+    value: null
+eval_delay:
+    value: 0
+eval_do_concat_batches:
+    value: true
+eval_on_start:
+    value: false
+eval_packing:
+    value: null
+eval_steps:
+    value: 25
+eval_strategy:
+    value: steps
+eval_use_gather_object:
+    value: false
+exponential_decay_length_penalty:
+    value: null
+finetuning_task:
+    value: null
+forced_bos_token_id:
+    value: null
+forced_eos_token_id:
+    value: null
+fp16:
+    value: false
+fp16_backend:
+    value: auto
+fp16_full_eval:
+    value: false
+fp16_opt_level:
+    value: O1
+fsdp:
+    value: []
+fsdp_config:
+    value:
+        min_num_params: 0
+        xla: false
+        xla_fsdp_grad_ckpt: false
+        xla_fsdp_v2: false
+fsdp_min_num_params:
+    value: 0
+fsdp_transformer_layer_cls_to_wrap:
+    value: null
+full_determinism:
+    value: false
+gradient_accumulation_steps:
+    value: 4
+gradient_checkpointing:
+    value: true
+gradient_checkpointing_kwargs:
+    value:
+        use_reentrant: false
+greater_is_better:
+    value: false
+group_by_length:
+    value: false
+half_precision_backend:
+    value: auto
+hidden_act:
+    value: silu
+hidden_size:
+    value: 1536
+hub_always_push:
+    value: false
+hub_model_id:
+    value: null
+hub_private_repo:
+    value: null
+hub_revision:
+    value: null
+hub_strategy:
+    value: every_save
+hub_token:
+    value: <HUB_TOKEN>
+id2label:
+    value:
+        "0": LABEL_0
+        "1": LABEL_1
+ignore_data_skip:
+    value: false
+include_for_metrics:
+    value: []
+include_inputs_for_metrics:
+    value: false
+include_num_input_tokens_seen:
+    value: "no"
+include_tokens_per_second:
+    value: false
+initializer_range:
+    value: 0.02
+intermediate_size:
+    value: 8960
+is_decoder:
+    value: false
+is_encoder_decoder:
+    value: false
+jit_mode_eval:
+    value: false
+label_names:
+    value: null
+label_smoothing_factor:
+    value: 0
+label2id:
+    value:
+        LABEL_0: 0
+        LABEL_1: 1
+layer_types:
+    value:
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+learning_rate:
+    value: 5e-06
+length_column_name:
+    value: length
+length_penalty:
+    value: 1
+liger_kernel_config:
+    value: null
+load_best_model_at_end:
+    value: true
+local_rank:
+    value: 0
+log_level:
+    value: passive
+log_level_replica:
+    value: warning
+log_on_each_node:
+    value: true
+logging_dir:
+    value: ./model_sft_save/Qwen2.5-1.5B-Entropy-solution/runs/Nov14_10-36-48_gpu-h100-07
+logging_first_step:
+    value: false
+logging_nan_inf_filter:
+    value: true
+logging_steps:
+    value: 5
+logging_strategy:
+    value: steps
+loss_type:
+    value: nll
+lr_scheduler_type:
+    value: cosine
+max_grad_norm:
+    value: 1
+max_length:
+    value: 8192
+max_position_embeddings:
+    value: 131072
+max_steps:
+    value: -1
+max_window_layers:
+    value: 28
+metric_for_best_model:
+    value: eval_loss
+min_length:
+    value: 0
+model/num_parameters:
+    value: 1543298048
+model_init_kwargs:
+    value:
+        attn_implementation: sdpa
+        rope_scaling: null
+        torch_dtype: torch.bfloat16
+        trust_remote_code: true
+model_type:
+    value: qwen2
+mp_parameters:
+    value: ""
+neftune_noise_alpha:
+    value: null
+no_cuda:
+    value: false
+no_repeat_ngram_size:
+    value: 0
+num_attention_heads:
+    value: 12
+num_beam_groups:
+    value: 1
+num_beams:
+    value: 1
+num_hidden_layers:
+    value: 28
+num_key_value_heads:
+    value: 2
+num_return_sequences:
+    value: 1
+num_train_epochs:
+    value: 1
+optim:
+    value: adamw_torch
+optim_args:
+    value: null
+optim_target_modules:
+    value: null
+output_attentions:
+    value: false
+output_dir:
+    value: ./model_sft_save/Qwen2.5-1.5B-Entropy-solution
+output_hidden_states:
+    value: false
+output_scores:
+    value: false
+overwrite_output_dir:
+    value: false
+packing:
+    value: false
+packing_strategy:
+    value: bfd
+pad_to_multiple_of:
+    value: null
+pad_token:
+    value: <PAD_TOKEN>
+pad_token_id:
+    value: 151643
+padding_free:
+    value: false
+parallelism_config:
+    value: null
+past_index:
+    value: -1
+per_device_eval_batch_size:
+    value: 2
+per_device_train_batch_size:
+    value: 2
+per_gpu_eval_batch_size:
+    value: null
+per_gpu_train_batch_size:
+    value: null
+prediction_loss_only:
+    value: false
+prefix:
+    value: null
+problem_type:
+    value: null
+project:
+    value: huggingface
+push_to_hub:
+    value: false
+push_to_hub_model_id:
+    value: null
+push_to_hub_organization:
+    value: null
+push_to_hub_token:
+    value: <PUSH_TO_HUB_TOKEN>
+ray_scope:
+    value: last
+remove_invalid_values:
+    value: false
+remove_unused_columns:
+    value: true
+repetition_penalty:
+    value: 1
+report_to:
+    value:
+        - wandb
+restore_callback_states_from_checkpoint:
+    value: false
+resume_from_checkpoint:
+    value: null
+return_dict:
+    value: true
+return_dict_in_generate:
+    value: false
+rms_norm_eps:
+    value: 1e-06
+rope_scaling:
+    value: null
+rope_theta:
+    value: 1e+06
+run_name:
+    value: qwen2.5-1.5b-46k-entropy-solution
+save_on_each_node:
+    value: false
+save_only_model:
+    value: false
+save_safetensors:
+    value: true
+save_steps:
+    value: 50
+save_strategy:
+    value: steps
+save_total_limit:
+    value: 2
+seed:
+    value: 42
+sep_token_id:
+    value: null
+skip_memory_metrics:
+    value: true
+sliding_window:
+    value: null
+suppress_tokens:
+    value: null
+task_specific_params:
+    value: null
+teacher_dtype:
+    value: bfloat16
+teacher_model_path:
+    value: deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
+temperature:
+    value: 1
+tf_legacy_loss:
+    value: false
+tf32:
+    value: null
+tie_encoder_decoder:
+    value: false
+tie_word_embeddings:
+    value: true
+tokenizer_class:
+    value: null
+top_k:
+    value: 50
+top_p:
+    value: 1
+torch_compile:
+    value: false
+torch_compile_backend:
+    value: null
+torch_compile_mode:
+    value: null
+torch_empty_cache_steps:
+    value: null
+torchdynamo:
+    value: null
+torchscript:
+    value: false
+tpu_metrics_debug:
+    value: false
+tpu_num_cores:
+    value: null
+trackio_space_id:
+    value: trackio
+transformers_version:
+    value: 4.57.1
+typical_p:
+    value: 1
+use_bfloat16:
+    value: false
+use_cache:
+    value: true
+use_cpu:
+    value: false
+use_entropy_weighting:
+    value: true
+use_legacy_prediction_loop:
+    value: false
+use_liger_kernel:
+    value: false
+use_mps_device:
+    value: false
+use_mrope:
+    value: false
+use_sliding_window:
+    value: false
+vocab_size:
+    value: 151665
+warmup_ratio:
+    value: 0.03
+warmup_steps:
+    value: 0
+weight_decay:
+    value: 0.01

train/wandb/run-20251114_103643-cvm4116u/files/output.log

@@ -0,0 +1,262 @@
+📝 Loading tokenizer...
+📦 Loading local dataset from: ./datasets/openr1/Openr1-Math-46k-8192.jsonl
+📊 Train: 45334 | Eval: 458
+🔄 Formatting dataset...
+
+🔍 MASKED PART (prompt/question):
+<|im_start|>system
+Think step by step and solve the problem.<|im_end|>
+<|im_start|>user
+## Problem Statement
+
+Calculate the definite integral:
+
+$$
+\int_{\pi / 4}^{\arccos (1 / \sqrt{26})} \frac{d x}{(6-\operatorname{tg} x) \sin 2 x}
+$$<|im_end|>
+<|im_start|>assistant
+
+
+✅ TRAINED PART (solution):
+<think>
+Okay, so I need to compute the definite integral from π/4 to arccos(1/√26) of dx divided by (6 - tan x) times sin 2x. Hmm, let me start by recalling some integration techniques. The integral has tan x and sin 2x in the denominator. Maybe I can simplify the expression first or use substitution.
+
+First, I know that sin 2x is equal to 2 sin x cos x. So, maybe rewriting sin 2x as 2 sin x cos x could help. Let me try that:
+
+∫ [1 / ( (6 - tan x) * 2 sin x cos x ) ] dx
+
+Simplifying the denominator, that becomes:
+
+1 / [2 sin x cos x (6 - tan x)] dx
+
+But tan x is sin x / cos x, so substituting that in:
+
+Denominator: 2 sin x cos x (6 - sin x / cos x )
+
+Let me combine the terms in the parenthesis:
+
+6 - sin x / cos x = (6 cos x - sin x)/cos x
+
+Therefore, the denominator becomes:
+
+2 sin x cos x * (6 cos x - sin x)/cos x = 2 sin x (6 cos x - sin x)
+
+So now, the integral simplifies to:
+
+∫ [1 / (2 sin x (6 cos x - sin x)) ] dx
+
+So the integral is now 1/(2 sin x (6 cos x - sin x)) dx. Maybe this is easier to integrate. Let me factor out the 1/2:
+
+(1/2) �� [1 / (sin x (6 cos x - sin x)) ] dx
+
+Hmm, this seems a bit complicated. Maybe I can use substitution here. Let me think about substitution. Let's let u = 6 cos x - sin x. Then, du/dx = -6 sin x - cos x. Hmm, not sure if that helps. Let's check:
+
+If u = 6 cos x - sin x, then du = (-6 sin x - cos x) dx. Hmm, the integral has 1/(sin x u). So, maybe if I can express the integral in terms of du and u. But du has terms -6 sin x - cos x, which isn't directly present in the integral. Maybe this isn't the right substitution.
+
+Alternatively, maybe split the fraction into partial fractions. Let me see. The denominator is sin x (6 cos x - sin x). Let me denote t = cos x or t = sin x. Maybe substitution t = sin x or t = cos x.
+
+Alternatively, use substitution t = tan x. Let's try that. Let t = tan x. Then, dt/dx = sec²x = 1 + tan²x. So, dx = dt / (1 + t²). Also, sin 2x = 2 tan x / (1 + tan²x) = 2t / (1 + t²). Let me rewrite the integral in terms of t.
+
+Original integral:
+
+∫ [1 / ( (6 - t) * (2t / (1 + t²)) ) ] * [dt / (1 + t²)]
+
+Wait, let's check. If t = tan x, then when x goes from π/4 to arccos(1/√26), t will go from tan(π/4) = 1 to tan(arccos(1/√26)). Let me compute tan(arccos(1/√26)). Let �� = arccos(1/√26). So cos �� = 1/√26, so sin �� = sqrt(1 - 1/26) = sqrt(25/26) = 5/√26. Therefore, tan �� = sin �� / cos �� = 5. So the upper limit is 5. So substitution t = tan x changes the limits from 1 to 5.
+
+Now, let's rewrite the integral. The integrand is 1 / [ (6 - tan x) sin 2x ] dx.
+
+Expressing in terms of t:
+
+1 / [ (6 - t) * (2t / (1 + t²)) ] * (dt / (1 + t²))
+
+Let me compute that step by step. First, sin 2x is 2t / (1 + t²). So, the denominator becomes (6 - t) * 2t / (1 + t²). Then, dx is dt / (1 + t²). So, multiplying all together:
+
+Integral becomes �� [ (1 + t²) / (2t (6 - t)) ] * [ 1 / (1 + t²) ] dt from t=1 to t=5.
+
+Simplify: The (1 + t²) cancels out. So, we have �� [1 / (2t (6 - t)) ] dt from 1 to 5.
+
+So, the integral simplifies to (1/2) �� [1 / (t (6 - t)) ] dt from 1 to 5.
+
+That's a much simpler integral. Now, let's compute �� [1 / (t (6 - t)) ] dt. We can use partial fractions here.
+
+Express 1 / [ t (6 - t) ] as A/t + B/(6 - t). Let's find A and B.
+
+1 = A(6 - t) + B t
+
+Let t = 0: 1 = 6A => A = 1/6
+
+Let t = 6: 1 = 6B => B = 1/6
+
+Therefore, 1 / [ t (6 - t) ] = (1/6)/t + (1/6)/(6 - t)
+
+Therefore, the integral becomes:
+
+(1/2) �� [ (1/6)/t + (1/6)/(6 - t) ] dt from 1 to 5
+
+Factor out 1/6:
+
+(1/2)(1/6) �� [1/t + 1/(6 - t) ] dt = (1/12) �� [1/t + 1/(6 - t) ] dt
+
+Integrate term by term:
+
+∫1/t dt = ln |t| + C
+
+∫1/(6 - t) dt = -ln |6 - t| + C
+
+Therefore, the integral becomes:
+
+(1/12) [ ln |t| - ln |6 - t| ] evaluated from 1 to 5.
+
+So, evaluating from 1 to 5:
+
+(1/12) [ (ln 5 - ln (6 - 5)) - (ln 1 - ln (6 - 1)) ]
+
+Simplify:
+
+First, at upper limit 5: ln 5 - ln 1 = ln 5 (since 6 - 5 = 1, ln 1 = 0)
+
+At lower limit 1: ln 1 - ln 5 = 0 - ln 5 = -ln 5
+
+Therefore, the expression becomes:
+
+(1/12) [ (ln 5 - 0) - (0 - ln 5) ] = (1/12)(ln 5 + ln 5) = (1/12)(2 ln 5) = (1/6) ln 5
+
+Therefore, the value of the integral is (1/6) ln 5. Let me check the steps again to ensure I didn't make any mistakes.
+
+First substitution: t = tan x. That changed variables correctly. The limits from π/4 to arccos(1/√26) became 1 to 5. Then, substitution led to integral in terms of t, simplified to 1/(2t(6 - t)) dt. Partial fractions correctly done, coefficients A and B were both 1/6. Integrated to (1/12)(ln t - ln(6 - t)). Evaluated from 1 to 5, giving (1/12)[ln5 - 0 - (0 - ln5)] = (1/12)(2 ln5) = (1/6) ln5. Seems correct.
+
+Alternatively, let me check with another substitution. Suppose instead of t = tan x, maybe another substitution. Let me see.
+
+Original integral after simplifying sin2x:
+
+(1/2) �� [1/(sinx (6 cosx - sinx))] dx. Let me try substitution u = 6 cosx - sinx.
+
+Compute du/dx = -6 sinx - cosx. Hmm, not directly present in the integrand. But the integrand is 1/(sinx * u). Let me see:
+
+If I write the integrand as 1/(sinx * u). If I have du = (-6 sinx - cosx) dx. Let me rearrange terms:
+
+du = - sinx (6 + cotx) dx. Hmm, not sure. Alternatively, express the integrand in terms of u and du. Let me see:
+
+But this seems more complicated. The previous substitution t = tan x worked smoothly, leading to a standard partial fraction integral. So I think the answer is (1/6) ln5. Therefore, the definite integral is (ln5)/6.
+
+**Final Answer**
+\boxed{\dfrac{\ln 5}{6}}
+</think>
+
+To calculate the definite integral:
+
+$$
+\int_{\pi / 4}^{\arccos (1 / \sqrt{26})} \frac{d x}{(6 - \tan x) \sin 2 x}
+$$
+
+we start by rewriting \(\sin 2x\) as \(2 \sin x \cos x\). This transforms the integral into:
+
+$$
+\int_{\pi / 4}^{\arccos (1 / \sqrt{26})} \frac{1}{(6 - \tan x) \cdot 2 \sin x \cos x} \, dx
+$$
+
+Simplifying the denominator using \(\tan x = \frac{\sin x}{\cos x}\), we get:
+
+$$
+\frac{1}{2 \sin x \cos x \left(6 - \frac{\sin x}{\cos x}\right)} = \frac{1}{2 \sin x (6 \cos x - \sin x)}
+$$
+
+Next, we use the substitution \(t = \tan x\), which gives \(dt = \sec^2 x \, dx\) or \(dx = \frac{dt}{1 + t^2}\). The limits of integration change from \(x = \pi/4\) (where \(t = 1\)) to \(x = \arccos(1/\sqrt{26})\) (where \(t = 5\)). Rewriting \(\sin 2x\) as \(\frac{2t}{1 + t^2}\), the integral becomes:
+
+$$
+\int_{1}^{5} \frac{1}{(6 - t) \cdot \frac{2t}{1 + t^2}} \cdot \frac{dt}{1 + t^2}
+$$
+
+Simplifying, we get:
+
+$$
+\frac{1}{2} \int_{1}^{5} \frac{1}{t(6 - t)} \, dt
+$$
+
+Using partial fractions, we decompose \(\frac{1}{t(6 - t)}\) into \(\frac{1}{6t} + \frac{1}{6(6 - t)}\). The integral then becomes:
+
+$$
+\frac{1}{12} \int_{1}^{5} \left(\frac{1}{t} + \frac{1}{6 - t}\right) \, dt
+$$
+
+Integrating term by term, we get:
+
+$$
+\frac{1}{12} \left[ \ln |t| - \ln |6 - t| \right]_{1}^{5}
+$$
+
+Evaluating this from 1 to 5:
+
+$$
+\frac{1}{12} \left[ (\ln 5 - \ln 1) - (\ln 1 - \ln 5) \right] = \frac{1}{12} (2 \ln 5) = \frac{1}{6} \ln 5
+$$
+
+Thus, the value of the integral is:
+
+$$
+\boxed{\dfrac{\ln 5}{6}}
+```<|endoftext|>
+
+📊 Stats: 80 masked, 2671 trained
+[2025-11-14 10:36:48,937] [INFO] [real_accelerator.py:203:get_accelerator] Setting ds_accelerator to cuda (auto detect)
+ [WARNING]  async_io requires the dev libaio .so object and headers but these were not found.
+ [WARNING]  async_io: please install the libaio-devel package with yum
+ [WARNING]  If libaio is already installed (perhaps from source), try setting the CFLAGS and LDFLAGS environment variables to where it can be found.
+ [WARNING]  Please specify the CUTLASS repo directory as environment variable $CUTLASS_PATH
+ [WARNING]  sparse_attn requires a torch version >= 1.5 and < 2.0 but detected 2.3
+ [WARNING]  using untested triton version (2.3.0), only 1.0.0 is known to be compatible
+[2025-11-14 10:36:49,925] [INFO] [comm.py:637:init_distributed] cdb=None
+[2025-11-14 10:36:49,926] [INFO] [comm.py:668:init_distributed] Initializing TorchBackend in DeepSpeed with backend nccl
+
+============================================================
+🎓 ENTROPY WEIGHTING ENABLED
+============================================================
+Teacher Model: deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
+Alpha (α): 2.0
+Beta (β): 0.3
+Teacher dtype: bfloat16
+Formula: w_j = exp(-H_t(j)) * sigmoid(α * (|H_s(j) - H_t(j)| - β))
+============================================================
+`torch_dtype` is deprecated! Use `dtype` instead!
+Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.
+
+🎓 Loading teacher model: deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
+📊 Entropy weighting params: α=2.0, β=0.3
+💾 Entropy computation: top-k=64 (memory-efficient mode)
+`torch_dtype` is deprecated! Use `dtype` instead!
+Loading checkpoint shards: 100%|██████████| 2/2 [00:20<00:00, 10.15s/it]
+✅ Teacher model loaded and frozen
+
+🔍 Checking teacher tokenizer/model alignment...
+📌 Teacher tokenizer vocab: 151665
+📌 Teacher model vocab: 152064
+⚠️  Teacher tokenizer & model vocab mismatch! Resizing teacher embeddings...
+✅ Teacher embeddings resized to 151665
+
+📊 Student model vocab size: 151936
+📊 Teacher model vocab size (after alignment): 151665
+
+⚠️  Student/Teacher vocab size mismatch detected!
+   Teacher: 151665
+   Student: 151936
+🔧 Resizing student embeddings to match teacher...
+✅ Student embeddings resized to 151665
+   New student vocab size: 151665
+
+============================================================
+🎯 Final Vocab Alignment Complete
+📊 Teacher vocab size: 151665
+📊 Student vocab size: 151665
+============================================================
+
+🏋️ Starting training...
+📊 Total training steps: 5666
+The tokenizer has new PAD/BOS/EOS tokens that differ from the model config and generation config. The model config and generation config were aligned accordingly, being updated with the tokenizer's values. Updated tokens: {'bos_token_id': None, 'pad_token_id': 151643}.
+Gradient accumulation steps mismatch: GradientAccumulationPlugin has 1, DeepSpeed config has 4. Using DeepSpeed's value.
+  1%|          | 25/2834 [04:20<8:16:48, 10.61s/it]
+{'loss': 2.5676, 'grad_norm': 10.754595756530762, 'learning_rate': 2.3255813953488374e-07, 'avg_weight': 0.3920933440327644, 'epoch': 0.0}
+{'loss': 2.4953, 'grad_norm': 10.065147399902344, 'learning_rate': 5.232558139534884e-07, 'avg_weight': 0.389410637319088, 'epoch': 0.0}
+{'loss': 2.5079, 'grad_norm': 8.899886131286621, 'learning_rate': 8.139534883720931e-07, 'avg_weight': 0.38864233046770097, 'epoch': 0.01}
+{'loss': 2.4271, 'grad_norm': 8.81152629852295, 'learning_rate': 1.1046511627906977e-06, 'avg_weight': 0.38897048830986025, 'epoch': 0.01}
+{'loss': 2.4171, 'grad_norm': 7.3060808181762695, 'learning_rate': 1.3953488372093025e-06, 'avg_weight': 0.380949105322361, 'epoch': 0.01}
+ 33%|███▎      | 38/115 [01:04<02:29,  1.95s/it]

train/wandb/run-20251114_103644-c9m2ofd0/files/wandb-metadata.json

@@ -0,0 +1,162 @@
+{
+  "os":  "Linux-4.18.0-372.9.1.el8.x86_64-x86_64-with-glibc2.28",
+  "python":  "CPython 3.10.19",
+  "startedAt":  "2025-11-14T02:36:44.347486Z",
+  "args":  [
+    "--model_name",
+    "Qwen/Qwen2.5-1.5B",
+    "--dataset_path",
+    "./datasets/openr1/Openr1-Math-46k-8192.jsonl",
+    "--output_dir",
+    "./model_sft_save/Qwen2.5-1.5B-Entropy-solution",
+    "--batch_size",
+    "2",
+    "--grad_accum",
+    "4",
+    "--learning_rate",
+    "5e-6",
+    "--epochs",
+    "1",
+    "--use_entropy_weighting",
+    "--teacher_model_path",
+    "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
+    "--entropy_weight_alpha",
+    "2.0",
+    "--entropy_weight_beta",
+    "0.3",
+    "--teacher_dtype",
+    "bfloat16",
+    "--use_deepspeed",
+    "--deepspeed_config",
+    "deepspeed/dp_stage2.json",
+    "--use_wandb",
+    "--wandb_project",
+    "qwen-math-entropy-sft",
+    "--wandb_run_name",
+    "qwen2.5-1.5b-46k-entropy-solution"
+  ],
+  "program":  "/public/home/lshi/yoAI/projects/Online_CL/train/train_qwen_46k_weight.py",
+  "codePath":  "train_qwen_46k_weight.py",
+  "codePathLocal":  "train_qwen_46k_weight.py",
+  "email":  "yaning1001@gmail.com",
+  "root":  "/public/home/lshi/yoAI/projects/Online_CL/train",
+  "host":  "gpu-h100-07",
+  "executable":  "/public/home/lshi/miniconda3/envs/sft_qwen/bin/python3.10",
+  "cpu_count":  96,
+  "cpu_count_logical":  96,
+  "gpu":  "NVIDIA H100 80GB HBM3",
+  "gpu_count":  6,
+  "disk":  {
+    "/":  {
+      "total":  "469407801344",
+      "used":  "288221097984"
+    }
+  },
+  "memory":  {
+    "total":  "2164142350336"
+  },
+  "gpu_nvidia":  [
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-d26f2d36-a358-5f8b-e928-f5ef4f73bc89"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-379104cc-3e15-4b2c-1b78-4ee1f142e16b"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-0d2164b6-b82a-6774-4914-58672f66b913"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-4f4398d2-2978-d7cb-7a33-2995e4efdbfd"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-0b6b2f40-df37-1563-f0cb-727bd3ac0fd9"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-8574e86d-a1bb-13dd-1843-407b718ebdf6"
+    }
+  ],
+  "cudaVersion":  "12.4",
+  "slurm":  {
+    "cluster_name":  "cluster_admin1",
+    "conf":  "/opt/gridview/slurm/etc/slurm.conf",
+    "cpu_bind":  "quiet,mask_cpu:0x000000000000000000000001",
+    "cpu_bind_list":  "0x000000000000000000000001",
+    "cpu_bind_type":  "mask_cpu:",
+    "cpu_bind_verbose":  "quiet",
+    "cpus_on_node":  "1",
+    "distribution":  "cyclic",
+    "gtids":  "0",
+    "home":  "/opt/gridview/slurm",
+    "job_account":  "seu_qli",
+    "job_cpus_per_node":  "1",
+    "job_gid":  "2026",
+    "job_id":  "8428",
+    "job_name":  "bash",
+    "job_nodelist":  "gpu-h100-07",
+    "job_num_nodes":  "1",
+    "job_partition":  "H100",
+    "job_qos":  "normal",
+    "job_uid":  "2019",
+    "job_user":  "lshi",
+    "jobid":  "8428",
+    "launch_node_ipaddr":  "172.16.254.194",
+    "localid":  "0",
+    "nnodes":  "1",
+    "nodeid":  "0",
+    "nodelist":  "gpu-h100-07",
+    "nprocs":  "1",
+    "ntasks":  "1",
+    "pmix_direct_conn":  "true",
+    "pmix_direct_conn_early":  "false",
+    "pmix_direct_conn_ucx":  "false",
+    "pmix_timeout":  "3000",
+    "prio_process":  "0",
+    "procid":  "0",
+    "pty_port":  "43139",
+    "pty_win_col":  "146",
+    "pty_win_row":  "21",
+    "srun_comm_host":  "172.16.254.194",
+    "srun_comm_port":  "34989",
+    "step_gpus":  "0,1,2,3,4,5",
+    "step_id":  "0",
+    "step_launcher_port":  "34989",
+    "step_nodelist":  "gpu-h100-07",
+    "step_num_nodes":  "1",
+    "step_num_tasks":  "1",
+    "step_tasks_per_node":  "1",
+    "stepid":  "0",
+    "submit_dir":  "/public/home/lshi/yoAI/projects",
+    "submit_host":  "admin1",
+    "task_pid":  "649671",
+    "tasks_per_node":  "1",
+    "topology_addr":  "gpu-h100-07",
+    "topology_addr_pattern":  "node",
+    "umask":  "0022",
+    "working_cluster":  "cluster_admin1:172.16.254.194:6817:9216:101"
+  },
+  "writerId":  "by9i30haenoy72kbuz6wpiu3fbxqgmd9"
+}

train/wandb/run-20251114_103644-c9m2ofd0/files/wandb-summary.json

@@ -0,0 +1 @@
+{"_wandb":{"runtime":382},"_runtime":382}

train/wandb/run-20251114_145219-w9xre5r3/files/config.yaml

@@ -0,0 +1,659 @@
+_name_or_path:
+    value: Qwen/Qwen2.5-1.5B
+_wandb:
+    value:
+        cli_version: 0.22.3
+        e:
+            4ns8zmo5ar2v4v1bdwhe5waa6417g92a:
+                args:
+                    - --model_name
+                    - Qwen/Qwen2.5-1.5B
+                    - --dataset_path
+                    - ./datasets/openr1/Openr1-Math-46k-8192.jsonl
+                    - --output_dir
+                    - ./model_sft_save/Qwen2.5-1.5B-Entropy-solution
+                    - --batch_size
+                    - "2"
+                    - --grad_accum
+                    - "4"
+                    - --learning_rate
+                    - "5e-6"
+                    - --epochs
+                    - "1"
+                    - --use_entropy_weighting
+                    - --teacher_model_path
+                    - deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
+                    - --entropy_weight_alpha
+                    - "2.0"
+                    - --entropy_weight_beta
+                    - "0.3"
+                    - --teacher_dtype
+                    - bfloat16
+                    - --entropy_top_k
+                    - "48"
+                    - --teacher_device_ids
+                    - "2"
+                    - --use_deepspeed
+                    - --deepspeed_config
+                    - deepspeed/dp_stage2.json
+                    - --use_wandb
+                    - --wandb_project
+                    - qwen-math-entropy-sft
+                    - --wandb_run_name
+                    - qwen2.5-1.5b-46k-entropy-solution
+                codePath: train_qwen_46k_weight.py
+                codePathLocal: train_qwen_46k_weight.py
+                cpu_count: 96
+                cpu_count_logical: 96
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "469407801344"
+                        used: "288248733696"
+                email: yaning1001@gmail.com
+                executable: /public/home/lshi/miniconda3/envs/sft_qwen/bin/python3.10
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-d26f2d36-a358-5f8b-e928-f5ef4f73bc89
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-379104cc-3e15-4b2c-1b78-4ee1f142e16b
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-0d2164b6-b82a-6774-4914-58672f66b913
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-4f4398d2-2978-d7cb-7a33-2995e4efdbfd
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-0b6b2f40-df37-1563-f0cb-727bd3ac0fd9
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-8574e86d-a1bb-13dd-1843-407b718ebdf6
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-23628f74-fede-6431-ae15-2764fce29130
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-d18d570f-dd0f-0ff6-3401-561c9e799136
+                host: gpu-h100-07
+                memory:
+                    total: "2164142350336"
+                os: Linux-4.18.0-372.9.1.el8.x86_64-x86_64-with-glibc2.28
+                program: /public/home/lshi/yoAI/projects/Online_CL/train/train_qwen_46k_weight.py
+                python: CPython 3.10.19
+                root: /public/home/lshi/yoAI/projects/Online_CL/train
+                slurm:
+                    home: /opt/gridview/slurm
+                    pmix_direct_conn: "true"
+                    pmix_direct_conn_early: "false"
+                    pmix_direct_conn_ucx: "false"
+                    pmix_timeout: "3000"
+                startedAt: "2025-11-14T06:52:19.650156Z"
+                writerId: 4ns8zmo5ar2v4v1bdwhe5waa6417g92a
+        m:
+            - "1": train/global_step
+              "6":
+                - 3
+              "7": []
+            - "2": '*'
+              "5": 1
+              "6":
+                - 1
+              "7": []
+        python_version: 3.10.19
+        t:
+            "1":
+                - 1
+                - 11
+                - 41
+                - 49
+                - 51
+                - 71
+                - 84
+                - 98
+                - 105
+            "2":
+                - 1
+                - 11
+                - 41
+                - 49
+                - 51
+                - 71
+                - 84
+                - 98
+                - 105
+            "3":
+                - 7
+                - 13
+                - 19
+                - 66
+            "4": 3.10.19
+            "5": 0.22.3
+            "6": 4.57.1
+            "9":
+                "1": transformers_trainer
+            "10":
+                - 20
+            "12": 0.22.3
+            "13": linux-x86_64
+accelerator_config:
+    value:
+        dispatch_batches: null
+        even_batches: true
+        gradient_accumulation_kwargs: null
+        non_blocking: false
+        split_batches: false
+        use_seedable_sampler: true
+activation_offloading:
+    value: false
+adafactor:
+    value: false
+adam_beta1:
+    value: 0.9
+adam_beta2:
+    value: 0.999
+adam_epsilon:
+    value: 1e-08
+add_cross_attention:
+    value: false
+architectures:
+    value:
+        - Qwen2ForCausalLM
+assistant_only_loss:
+    value: false
+attention_dropout:
+    value: 0
+auto_find_batch_size:
+    value: false
+average_tokens_across_devices:
+    value: true
+bad_words_ids:
+    value: null
+batch_eval_metrics:
+    value: false
+begin_suppress_tokens:
+    value: null
+bf16:
+    value: true
+bf16_full_eval:
+    value: false
+bos_token_id:
+    value: null
+chat_template_path:
+    value: null
+chunk_size_feed_forward:
+    value: 0
+completion_only_loss:
+    value: null
+cross_attention_hidden_size:
+    value: null
+data_seed:
+    value: null
+dataloader_drop_last:
+    value: false
+dataloader_num_workers:
+    value: 0
+dataloader_persistent_workers:
+    value: false
+dataloader_pin_memory:
+    value: true
+dataloader_prefetch_factor:
+    value: null
+dataset_kwargs:
+    value: null
+dataset_num_proc:
+    value: null
+dataset_text_field:
+    value: null
+ddp_backend:
+    value: null
+ddp_broadcast_buffers:
+    value: null
+ddp_bucket_cap_mb:
+    value: null
+ddp_find_unused_parameters:
+    value: null
+ddp_timeout:
+    value: 1800
+debug:
+    value: []
+decoder_start_token_id:
+    value: null
+deepspeed:
+    value: deepspeed/dp_stage2.json
+disable_tqdm:
+    value: false
+diversity_penalty:
+    value: 0
+do_eval:
+    value: true
+do_predict:
+    value: false
+do_sample:
+    value: false
+do_train:
+    value: false
+dtype:
+    value: bfloat16
+early_stopping:
+    value: false
+encoder_no_repeat_ngram_size:
+    value: 0
+entropy_top_k:
+    value: 48
+entropy_weight_alpha:
+    value: 2
+entropy_weight_beta:
+    value: 0.3
+eos_token:
+    value: <EOS_TOKEN>
+eos_token_id:
+    value: 151643
+eval_accumulation_steps:
+    value: null
+eval_delay:
+    value: 0
+eval_do_concat_batches:
+    value: true
+eval_on_start:
+    value: false
+eval_packing:
+    value: null
+eval_steps:
+    value: 25
+eval_strategy:
+    value: steps
+eval_use_gather_object:
+    value: false
+exponential_decay_length_penalty:
+    value: null
+finetuning_task:
+    value: null
+forced_bos_token_id:
+    value: null
+forced_eos_token_id:
+    value: null
+fp16:
+    value: false
+fp16_backend:
+    value: auto
+fp16_full_eval:
+    value: false
+fp16_opt_level:
+    value: O1
+fsdp:
+    value: []
+fsdp_config:
+    value:
+        min_num_params: 0
+        xla: false
+        xla_fsdp_grad_ckpt: false
+        xla_fsdp_v2: false
+fsdp_min_num_params:
+    value: 0
+fsdp_transformer_layer_cls_to_wrap:
+    value: null
+full_determinism:
+    value: false
+gradient_accumulation_steps:
+    value: 4
+gradient_checkpointing:
+    value: true
+gradient_checkpointing_kwargs:
+    value:
+        use_reentrant: false
+greater_is_better:
+    value: false
+group_by_length:
+    value: false
+half_precision_backend:
+    value: auto
+hidden_act:
+    value: silu
+hidden_size:
+    value: 1536
+hub_always_push:
+    value: false
+hub_model_id:
+    value: null
+hub_private_repo:
+    value: null
+hub_revision:
+    value: null
+hub_strategy:
+    value: every_save
+hub_token:
+    value: <HUB_TOKEN>
+id2label:
+    value:
+        "0": LABEL_0
+        "1": LABEL_1
+ignore_data_skip:
+    value: false
+include_for_metrics:
+    value: []
+include_inputs_for_metrics:
+    value: false
+include_num_input_tokens_seen:
+    value: "no"
+include_tokens_per_second:
+    value: false
+initializer_range:
+    value: 0.02
+intermediate_size:
+    value: 8960
+is_decoder:
+    value: false
+is_encoder_decoder:
+    value: false
+jit_mode_eval:
+    value: false
+label_names:
+    value: null
+label_smoothing_factor:
+    value: 0
+label2id:
+    value:
+        LABEL_0: 0
+        LABEL_1: 1
+layer_types:
+    value:
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+        - full_attention
+learning_rate:
+    value: 5e-06
+length_column_name:
+    value: length
+length_penalty:
+    value: 1
+liger_kernel_config:
+    value: null
+load_best_model_at_end:
+    value: true
+local_rank:
+    value: 0
+log_level:
+    value: passive
+log_level_replica:
+    value: warning
+log_on_each_node:
+    value: true
+logging_dir:
+    value: ./model_sft_save/Qwen2.5-1.5B-Entropy-solution/runs/Nov14_14-52-26_gpu-h100-07
+logging_first_step:
+    value: false
+logging_nan_inf_filter:
+    value: true
+logging_steps:
+    value: 5
+logging_strategy:
+    value: steps
+loss_type:
+    value: nll
+lr_scheduler_type:
+    value: cosine
+max_grad_norm:
+    value: 1
+max_length:
+    value: 8192
+max_position_embeddings:
+    value: 131072
+max_steps:
+    value: -1
+max_window_layers:
+    value: 28
+metric_for_best_model:
+    value: eval_loss
+min_length:
+    value: 0
+model/num_parameters:
+    value: 1543298048
+model_init_kwargs:
+    value: null
+model_type:
+    value: qwen2
+mp_parameters:
+    value: ""
+neftune_noise_alpha:
+    value: null
+no_cuda:
+    value: false
+no_repeat_ngram_size:
+    value: 0
+num_attention_heads:
+    value: 12
+num_beam_groups:
+    value: 1
+num_beams:
+    value: 1
+num_hidden_layers:
+    value: 28
+num_key_value_heads:
+    value: 2
+num_return_sequences:
+    value: 1
+num_train_epochs:
+    value: 1
+optim:
+    value: adamw_torch
+optim_args:
+    value: null
+optim_target_modules:
+    value: null
+output_attentions:
+    value: false
+output_dir:
+    value: ./model_sft_save/Qwen2.5-1.5B-Entropy-solution
+output_hidden_states:
+    value: false
+output_scores:
+    value: false
+overwrite_output_dir:
+    value: false
+packing:
+    value: false
+packing_strategy:
+    value: bfd
+pad_to_multiple_of:
+    value: null
+pad_token:
+    value: <PAD_TOKEN>
+pad_token_id:
+    value: 151643
+padding_free:
+    value: false
+parallelism_config:
+    value: null
+past_index:
+    value: -1
+per_device_eval_batch_size:
+    value: 2
+per_device_train_batch_size:
+    value: 2
+per_gpu_eval_batch_size:
+    value: null
+per_gpu_train_batch_size:
+    value: null
+prediction_loss_only:
+    value: false
+prefix:
+    value: null
+problem_type:
+    value: null
+project:
+    value: huggingface
+push_to_hub:
+    value: false
+push_to_hub_model_id:
+    value: null
+push_to_hub_organization:
+    value: null
+push_to_hub_token:
+    value: <PUSH_TO_HUB_TOKEN>
+ray_scope:
+    value: last
+remove_invalid_values:
+    value: false
+remove_unused_columns:
+    value: true
+repetition_penalty:
+    value: 1
+report_to:
+    value:
+        - wandb
+restore_callback_states_from_checkpoint:
+    value: false
+resume_from_checkpoint:
+    value: null
+return_dict:
+    value: true
+return_dict_in_generate:
+    value: false
+rms_norm_eps:
+    value: 1e-06
+rope_scaling:
+    value: null
+rope_theta:
+    value: 1e+06
+run_name:
+    value: qwen2.5-1.5b-46k-entropy-solution
+save_on_each_node:
+    value: false
+save_only_model:
+    value: false
+save_safetensors:
+    value: true
+save_steps:
+    value: 50
+save_strategy:
+    value: steps
+save_total_limit:
+    value: 2
+seed:
+    value: 42
+sep_token_id:
+    value: null
+skip_memory_metrics:
+    value: true
+sliding_window:
+    value: null
+suppress_tokens:
+    value: null
+task_specific_params:
+    value: null
+teacher_device_ids:
+    value: "2"
+teacher_dtype:
+    value: bfloat16
+teacher_model_path:
+    value: deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
+temperature:
+    value: 1
+tf_legacy_loss:
+    value: false
+tf32:
+    value: null
+tie_encoder_decoder:
+    value: false
+tie_word_embeddings:
+    value: true
+tokenizer_class:
+    value: null
+top_k:
+    value: 50
+top_p:
+    value: 1
+torch_compile:
+    value: false
+torch_compile_backend:
+    value: null
+torch_compile_mode:
+    value: null
+torch_empty_cache_steps:
+    value: null
+torchdynamo:
+    value: null
+torchscript:
+    value: false
+tpu_metrics_debug:
+    value: false
+tpu_num_cores:
+    value: null
+trackio_space_id:
+    value: trackio
+transformers_version:
+    value: 4.57.1
+typical_p:
+    value: 1
+use_bfloat16:
+    value: false
+use_cache:
+    value: true
+use_cpu:
+    value: false
+use_entropy_weighting:
+    value: true
+use_legacy_prediction_loop:
+    value: false
+use_liger_kernel:
+    value: false
+use_mps_device:
+    value: false
+use_mrope:
+    value: false
+use_sliding_window:
+    value: false
+vocab_size:
+    value: 151665
+warmup_ratio:
+    value: 0.03
+warmup_steps:
+    value: 0
+weight_decay:
+    value: 0.01

train/wandb/run-20251114_145219-w9xre5r3/files/output.log

@@ -0,0 +1,336 @@
+📝 Loading tokenizer...
+📦 Loading local dataset from: ./datasets/openr1/Openr1-Math-46k-8192.jsonl
+📊 Train: 45334 | Eval: 458
+🔄 Formatting dataset...
+
+🔍 MASKED PART (prompt/question):
+<|im_start|>system
+Think step by step and solve the problem.<|im_end|>
+<|im_start|>user
+## Problem Statement
+
+Calculate the definite integral:
+
+$$
+\int_{\pi / 4}^{\arccos (1 / \sqrt{26})} \frac{d x}{(6-\operatorname{tg} x) \sin 2 x}
+$$<|im_end|>
+<|im_start|>assistant
+
+
+✅ TRAINED PART (solution):
+<think>
+Okay, so I need to compute the definite integral from π/4 to arccos(1/√26) of dx divided by (6 - tan x) times sin 2x. Hmm, let me start by recalling some integration techniques. The integral has tan x and sin 2x in the denominator. Maybe I can simplify the expression first or use substitution.
+
+First, I know that sin 2x is equal to 2 sin x cos x. So, maybe rewriting sin 2x as 2 sin x cos x could help. Let me try that:
+
+∫ [1 / ( (6 - tan x) * 2 sin x cos x ) ] dx
+
+Simplifying the denominator, that becomes:
+
+1 / [2 sin x cos x (6 - tan x)] dx
+
+But tan x is sin x / cos x, so substituting that in:
+
+Denominator: 2 sin x cos x (6 - sin x / cos x )
+
+Let me combine the terms in the parenthesis:
+
+6 - sin x / cos x = (6 cos x - sin x)/cos x
+
+Therefore, the denominator becomes:
+
+2 sin x cos x * (6 cos x - sin x)/cos x = 2 sin x (6 cos x - sin x)
+
+So now, the integral simplifies to:
+
+∫ [1 / (2 sin x (6 cos x - sin x)) ] dx
+
+So the integral is now 1/(2 sin x (6 cos x - sin x)) dx. Maybe this is easier to integrate. Let me factor out the 1/2:
+
+(1/2) �� [1 / (sin x (6 cos x - sin x)) ] dx
+
+Hmm, this seems a bit complicated. Maybe I can use substitution here. Let me think about substitution. Let's let u = 6 cos x - sin x. Then, du/dx = -6 sin x - cos x. Hmm, not sure if that helps. Let's check:
+
+If u = 6 cos x - sin x, then du = (-6 sin x - cos x) dx. Hmm, the integral has 1/(sin x u). So, maybe if I can express the integral in terms of du and u. But du has terms -6 sin x - cos x, which isn't directly present in the integral. Maybe this isn't the right substitution.
+
+Alternatively, maybe split the fraction into partial fractions. Let me see. The denominator is sin x (6 cos x - sin x). Let me denote t = cos x or t = sin x. Maybe substitution t = sin x or t = cos x.
+
+Alternatively, use substitution t = tan x. Let's try that. Let t = tan x. Then, dt/dx = sec²x = 1 + tan²x. So, dx = dt / (1 + t²). Also, sin 2x = 2 tan x / (1 + tan²x) = 2t / (1 + t²). Let me rewrite the integral in terms of t.
+
+Original integral:
+
+∫ [1 / ( (6 - t) * (2t / (1 + t²)) ) ] * [dt / (1 + t²)]
+
+Wait, let's check. If t = tan x, then when x goes from π/4 to arccos(1/√26), t will go from tan(π/4) = 1 to tan(arccos(1/√26)). Let me compute tan(arccos(1/√26)). Let �� = arccos(1/√26). So cos �� = 1/√26, so sin �� = sqrt(1 - 1/26) = sqrt(25/26) = 5/√26. Therefore, tan �� = sin �� / cos �� = 5. So the upper limit is 5. So substitution t = tan x changes the limits from 1 to 5.
+
+Now, let's rewrite the integral. The integrand is 1 / [ (6 - tan x) sin 2x ] dx.
+
+Expressing in terms of t:
+
+1 / [ (6 - t) * (2t / (1 + t²)) ] * (dt / (1 + t²))
+
+Let me compute that step by step. First, sin 2x is 2t / (1 + t²). So, the denominator becomes (6 - t) * 2t / (1 + t²). Then, dx is dt / (1 + t²). So, multiplying all together:
+
+Integral becomes �� [ (1 + t²) / (2t (6 - t)) ] * [ 1 / (1 + t²) ] dt from t=1 to t=5.
+
+Simplify: The (1 + t²) cancels out. So, we have �� [1 / (2t (6 - t)) ] dt from 1 to 5.
+
+So, the integral simplifies to (1/2) �� [1 / (t (6 - t)) ] dt from 1 to 5.
+
+That's a much simpler integral. Now, let's compute �� [1 / (t (6 - t)) ] dt. We can use partial fractions here.
+
+Express 1 / [ t (6 - t) ] as A/t + B/(6 - t). Let's find A and B.
+
+1 = A(6 - t) + B t
+
+Let t = 0: 1 = 6A => A = 1/6
+
+Let t = 6: 1 = 6B => B = 1/6
+
+Therefore, 1 / [ t (6 - t) ] = (1/6)/t + (1/6)/(6 - t)
+
+Therefore, the integral becomes:
+
+(1/2) �� [ (1/6)/t + (1/6)/(6 - t) ] dt from 1 to 5
+
+Factor out 1/6:
+
+(1/2)(1/6) �� [1/t + 1/(6 - t) ] dt = (1/12) �� [1/t + 1/(6 - t) ] dt
+
+Integrate term by term:
+
+∫1/t dt = ln |t| + C
+
+∫1/(6 - t) dt = -ln |6 - t| + C
+
+Therefore, the integral becomes:
+
+(1/12) [ ln |t| - ln |6 - t| ] evaluated from 1 to 5.
+
+So, evaluating from 1 to 5:
+
+(1/12) [ (ln 5 - ln (6 - 5)) - (ln 1 - ln (6 - 1)) ]
+
+Simplify:
+
+First, at upper limit 5: ln 5 - ln 1 = ln 5 (since 6 - 5 = 1, ln 1 = 0)
+
+At lower limit 1: ln 1 - ln 5 = 0 - ln 5 = -ln 5
+
+Therefore, the expression becomes:
+
+(1/12) [ (ln 5 - 0) - (0 - ln 5) ] = (1/12)(ln 5 + ln 5) = (1/12)(2 ln 5) = (1/6) ln 5
+
+Therefore, the value of the integral is (1/6) ln 5. Let me check the steps again to ensure I didn't make any mistakes.
+
+First substitution: t = tan x. That changed variables correctly. The limits from π/4 to arccos(1/√26) became 1 to 5. Then, substitution led to integral in terms of t, simplified to 1/(2t(6 - t)) dt. Partial fractions correctly done, coefficients A and B were both 1/6. Integrated to (1/12)(ln t - ln(6 - t)). Evaluated from 1 to 5, giving (1/12)[ln5 - 0 - (0 - ln5)] = (1/12)(2 ln5) = (1/6) ln5. Seems correct.
+
+Alternatively, let me check with another substitution. Suppose instead of t = tan x, maybe another substitution. Let me see.
+
+Original integral after simplifying sin2x:
+
+(1/2) �� [1/(sinx (6 cosx - sinx))] dx. Let me try substitution u = 6 cosx - sinx.
+
+Compute du/dx = -6 sinx - cosx. Hmm, not directly present in the integrand. But the integrand is 1/(sinx * u). Let me see:
+
+If I write the integrand as 1/(sinx * u). If I have du = (-6 sinx - cosx) dx. Let me rearrange terms:
+
+du = - sinx (6 + cotx) dx. Hmm, not sure. Alternatively, express the integrand in terms of u and du. Let me see:
+
+But this seems more complicated. The previous substitution t = tan x worked smoothly, leading to a standard partial fraction integral. So I think the answer is (1/6) ln5. Therefore, the definite integral is (ln5)/6.
+
+**Final Answer**
+\boxed{\dfrac{\ln 5}{6}}
+</think>
+
+To calculate the definite integral:
+
+$$
+\int_{\pi / 4}^{\arccos (1 / \sqrt{26})} \frac{d x}{(6 - \tan x) \sin 2 x}
+$$
+
+we start by rewriting \(\sin 2x\) as \(2 \sin x \cos x\). This transforms the integral into:
+
+$$
+\int_{\pi / 4}^{\arccos (1 / \sqrt{26})} \frac{1}{(6 - \tan x) \cdot 2 \sin x \cos x} \, dx
+$$
+
+Simplifying the denominator using \(\tan x = \frac{\sin x}{\cos x}\), we get:
+
+$$
+\frac{1}{2 \sin x \cos x \left(6 - \frac{\sin x}{\cos x}\right)} = \frac{1}{2 \sin x (6 \cos x - \sin x)}
+$$
+
+Next, we use the substitution \(t = \tan x\), which gives \(dt = \sec^2 x \, dx\) or \(dx = \frac{dt}{1 + t^2}\). The limits of integration change from \(x = \pi/4\) (where \(t = 1\)) to \(x = \arccos(1/\sqrt{26})\) (where \(t = 5\)). Rewriting \(\sin 2x\) as \(\frac{2t}{1 + t^2}\), the integral becomes:
+
+$$
+\int_{1}^{5} \frac{1}{(6 - t) \cdot \frac{2t}{1 + t^2}} \cdot \frac{dt}{1 + t^2}
+$$
+
+Simplifying, we get:
+
+$$
+\frac{1}{2} \int_{1}^{5} \frac{1}{t(6 - t)} \, dt
+$$
+
+Using partial fractions, we decompose \(\frac{1}{t(6 - t)}\) into \(\frac{1}{6t} + \frac{1}{6(6 - t)}\). The integral then becomes:
+
+$$
+\frac{1}{12} \int_{1}^{5} \left(\frac{1}{t} + \frac{1}{6 - t}\right) \, dt
+$$
+
+Integrating term by term, we get:
+
+$$
+\frac{1}{12} \left[ \ln |t| - \ln |6 - t| \right]_{1}^{5}
+$$
+
+Evaluating this from 1 to 5:
+
+$$
+\frac{1}{12} \left[ (\ln 5 - \ln 1) - (\ln 1 - \ln 5) \right] = \frac{1}{12} (2 \ln 5) = \frac{1}{6} \ln 5
+$$
+
+Thus, the value of the integral is:
+
+$$
+\boxed{\dfrac{\ln 5}{6}}
+```<|endoftext|>
+
+📊 Stats: 80 masked, 2671 trained
+
+📥 Loading student model: Qwen/Qwen2.5-1.5B
+`torch_dtype` is deprecated! Use `dtype` instead!
+✅ Student model loaded: 151936 vocab size
+[2025-11-14 14:52:27,291] [INFO] [real_accelerator.py:203:get_accelerator] Setting ds_accelerator to cuda (auto detect)
+ [WARNING]  async_io requires the dev libaio .so object and headers but these were not found.
+ [WARNING]  async_io: please install the libaio-devel package with yum
+ [WARNING]  If libaio is already installed (perhaps from source), try setting the CFLAGS and LDFLAGS environment variables to where it can be found.
+ [WARNING]  Please specify the CUTLASS repo directory as environment variable $CUTLASS_PATH
+ [WARNING]  sparse_attn requires a torch version >= 1.5 and < 2.0 but detected 2.3
+ [WARNING]  using untested triton version (2.3.0), only 1.0.0 is known to be compatible
+[2025-11-14 14:52:28,034] [INFO] [comm.py:637:init_distributed] cdb=None
+[2025-11-14 14:52:28,034] [INFO] [comm.py:668:init_distributed] Initializing TorchBackend in DeepSpeed with backend nccl
+
+============================================================
+🎓 ENTROPY WEIGHTING ENABLED
+============================================================
+Teacher Model: deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
+Teacher Device: 2
+Alpha (α): 2.0
+Beta (β): 0.3
+Top-K: 48
+Teacher dtype: bfloat16
+Formula: w_j = exp(-H_t(j)) * sigmoid(α * (|H_s(j) - H_t(j)| - β))
+============================================================
+Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.
+
+🎓 Loading teacher model: deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
+📊 Entropy weighting params: α=2.0, β=0.3
+💾 Entropy computation: top-k=48 (memory-efficient mode)
+🖥️  Teacher target device(s): cuda:2
+📡 Loading teacher on single GPU: cuda:2
+Loading checkpoint shards: 100%|██████████| 2/2 [00:00<00:00, 47.60it/s]
+✅ Teacher model loaded and frozen
+✅ Teacher model loaded and frozen
+
+🔍 Checking teacher tokenizer/model alignment...
+📌 Teacher tokenizer vocab: 151665
+📌 Teacher model vocab: 152064
+⚠️  Teacher tokenizer & model vocab mismatch! Resizing teacher embeddings...
+✅ Teacher embeddings resized to 151665
+
+📊 Student model vocab size: 151936
+📊 Teacher model vocab size (after alignment): 151665
+
+⚠️  Student/Teacher vocab size mismatch detected!
+   Teacher: 151665
+   Student: 151936
+🔧 Resizing student embeddings to match teacher...
+✅ Student embeddings resized to 151665
+   New student vocab size: 151665
+
+============================================================
+🎯 Final Vocab Alignment Complete
+📊 Teacher vocab size: 151665
+📊 Student vocab size: 151665
+============================================================
+
+🏋️ Starting training...
+📊 Total training steps: 5666
+The tokenizer has new PAD/BOS/EOS tokens that differ from the model config and generation config. The model config and generation config were aligned accordingly, being updated with the tokenizer's values. Updated tokens: {'bos_token_id': None, 'pad_token_id': 151643}.
+Gradient accumulation steps mismatch: GradientAccumulationPlugin has 1, DeepSpeed config has 4. Using DeepSpeed's value.
+                                                     
+{'loss': 2.5591, 'grad_norm': 10.723748207092285, 'learning_rate': 2.3255813953488374e-07, 'avg_weight': 0.3910901114344597, 'epoch': 0.0}
+{'loss': 2.4874, 'grad_norm': 10.057125091552734, 'learning_rate': 5.232558139534884e-07, 'avg_weight': 0.38843219727277756, 'epoch': 0.0}
+{'loss': 2.4994, 'grad_norm': 8.863786697387695, 'learning_rate': 8.139534883720931e-07, 'avg_weight': 0.38760635405778887, 'epoch': 0.01}
+{'loss': 2.4195, 'grad_norm': 8.823384284973145, 'learning_rate': 1.1046511627906977e-06, 'avg_weight': 0.3880971476435661, 'epoch': 0.01}
+{'loss': 2.4098, 'grad_norm': 7.296765327453613, 'learning_rate': 1.3953488372093025e-06, 'avg_weight': 0.3801196217536926, 'epoch': 0.01}
+                                                 
+{'eval_loss': 0.5676697492599487, 'eval_runtime': 177.1245, 'eval_samples_per_second': 2.586, 'eval_steps_per_second': 0.649, 'epoch': 0.01}
+{'loss': 2.2295, 'grad_norm': 5.418520450592041, 'learning_rate': 1.686046511627907e-06, 'avg_weight': 0.36370994746685026, 'epoch': 0.01}
+{'loss': 2.1721, 'grad_norm': 4.612456798553467, 'learning_rate': 1.976744186046512e-06, 'avg_weight': 0.35689852982759473, 'epoch': 0.01}
+{'loss': 2.0765, 'grad_norm': 4.605122089385986, 'learning_rate': 2.2674418604651163e-06, 'avg_weight': 0.36093987375497816, 'epoch': 0.01}
+{'loss': 2.0677, 'grad_norm': 4.118704795837402, 'learning_rate': 2.558139534883721e-06, 'avg_weight': 0.3577569782733917, 'epoch': 0.02}
+{'loss': 2.1147, 'grad_norm': 3.7384188175201416, 'learning_rate': 2.848837209302326e-06, 'avg_weight': 0.3483647421002388, 'epoch': 0.02}
+{'eval_loss': 0.48641934990882874, 'eval_runtime': 176.9466, 'eval_samples_per_second': 2.588, 'eval_steps_per_second': 0.65, 'epoch': 0.02}
+{'loss': 1.9462, 'grad_norm': 4.451317310333252, 'learning_rate': 3.1395348837209307e-06, 'avg_weight': 0.3532564118504524, 'epoch': 0.02}
+{'loss': 1.8641, 'grad_norm': 3.378995180130005, 'learning_rate': 3.430232558139535e-06, 'avg_weight': 0.3521373629570007, 'epoch': 0.02}
+{'loss': 1.878, 'grad_norm': 3.9663772583007812, 'learning_rate': 3.72093023255814e-06, 'avg_weight': 0.3486033886671066, 'epoch': 0.02}
+{'loss': 1.8243, 'grad_norm': 3.9792895317077637, 'learning_rate': 4.011627906976744e-06, 'avg_weight': 0.34984882175922394, 'epoch': 0.02}
+{'loss': 1.8915, 'grad_norm': 3.450552463531494, 'learning_rate': 4.302325581395349e-06, 'avg_weight': 0.34732189774513245, 'epoch': 0.03}
+{'eval_loss': 0.44193005561828613, 'eval_runtime': 176.9698, 'eval_samples_per_second': 2.588, 'eval_steps_per_second': 0.65, 'epoch': 0.03}
+{'loss': 1.6694, 'grad_norm': 3.710488796234131, 'learning_rate': 4.593023255813954e-06, 'avg_weight': 0.3485285028815269, 'epoch': 0.03}
+{'loss': 1.8175, 'grad_norm': 2.9457366466522217, 'learning_rate': 4.883720930232559e-06, 'avg_weight': 0.34327888786792754, 'epoch': 0.03}
+{'loss': 1.799, 'grad_norm': 3.038442611694336, 'learning_rate': 4.999985296579241e-06, 'avg_weight': 0.3441050469875336, 'epoch': 0.03}
+{'loss': 1.6772, 'grad_norm': 3.322579860687256, 'learning_rate': 4.999895442967599e-06, 'avg_weight': 0.34606429785490034, 'epoch': 0.03}
+{'loss': 1.7592, 'grad_norm': 3.061025381088257, 'learning_rate': 4.9997239072437415e-06, 'avg_weight': 0.3396225184202194, 'epoch': 0.04}
+{'eval_loss': 0.4209730625152588, 'eval_runtime': 176.9333, 'eval_samples_per_second': 2.589, 'eval_steps_per_second': 0.65, 'epoch': 0.04}
+{'loss': 1.663, 'grad_norm': 3.212209463119507, 'learning_rate': 4.999470695012462e-06, 'avg_weight': 0.3401555925607681, 'epoch': 0.04}
+{'loss': 1.6741, 'grad_norm': 2.88710880279541, 'learning_rate': 4.999135814547269e-06, 'avg_weight': 0.3444334402680397, 'epoch': 0.04}
+{'loss': 1.8002, 'grad_norm': 3.0338072776794434, 'learning_rate': 4.99871927679012e-06, 'avg_weight': 0.3414938300848007, 'epoch': 0.04}
+{'loss': 1.6332, 'grad_norm': 2.6287529468536377, 'learning_rate': 4.998221095351058e-06, 'avg_weight': 0.3433367222547531, 'epoch': 0.04}
+{'loss': 1.6309, 'grad_norm': 3.1718740463256836, 'learning_rate': 4.997641286507766e-06, 'avg_weight': 0.3451731190085411, 'epoch': 0.04}
+{'eval_loss': 0.4092359244823456, 'eval_runtime': 176.9574, 'eval_samples_per_second': 2.588, 'eval_steps_per_second': 0.65, 'epoch': 0.04}
+{'loss': 1.6804, 'grad_norm': 3.1825239658355713, 'learning_rate': 4.996979869205043e-06, 'avg_weight': 0.3412734940648079, 'epoch': 0.05}
+{'loss': 1.6437, 'grad_norm': 3.1620748043060303, 'learning_rate': 4.996236865054177e-06, 'avg_weight': 0.34043743312358854, 'epoch': 0.05}
+{'loss': 1.6659, 'grad_norm': 3.254448175430298, 'learning_rate': 4.995412298332243e-06, 'avg_weight': 0.3406913295388222, 'epoch': 0.05}
+{'loss': 1.6698, 'grad_norm': 3.2264506816864014, 'learning_rate': 4.994506195981309e-06, 'avg_weight': 0.34027899503707887, 'epoch': 0.05}
+{'loss': 1.5531, 'grad_norm': 3.0454981327056885, 'learning_rate': 4.9935185876075525e-06, 'avg_weight': 0.3385377749800682, 'epoch': 0.05}
+{'eval_loss': 0.4014018177986145, 'eval_runtime': 176.9922, 'eval_samples_per_second': 2.588, 'eval_steps_per_second': 0.65, 'epoch': 0.05}
+{'loss': 1.5782, 'grad_norm': 2.929764747619629, 'learning_rate': 4.992449505480301e-06, 'avg_weight': 0.34045338034629824, 'epoch': 0.05}
+{'loss': 1.5912, 'grad_norm': 3.0769646167755127, 'learning_rate': 4.991298984530968e-06, 'avg_weight': 0.34139142483472823, 'epoch': 0.06}
+{'loss': 1.6423, 'grad_norm': 2.820838689804077, 'learning_rate': 4.9900670623519185e-06, 'avg_weight': 0.3394546613097191, 'epoch': 0.06}
+{'loss': 1.6039, 'grad_norm': 2.8948822021484375, 'learning_rate': 4.98875377919524e-06, 'avg_weight': 0.33894784599542616, 'epoch': 0.06}
+{'loss': 1.5986, 'grad_norm': 2.98633074760437, 'learning_rate': 4.987359177971422e-06, 'avg_weight': 0.3411692440509796, 'epoch': 0.06}
+{'eval_loss': 0.39528319239616394, 'eval_runtime': 176.9244, 'eval_samples_per_second': 2.589, 'eval_steps_per_second': 0.65, 'epoch': 0.06}
+{'loss': 1.5965, 'grad_norm': 2.802412986755371, 'learning_rate': 4.985883304247961e-06, 'avg_weight': 0.3383798971772194, 'epoch': 0.06}
+{'loss': 1.5762, 'grad_norm': 3.027007818222046, 'learning_rate': 4.984326206247866e-06, 'avg_weight': 0.33840133994817734, 'epoch': 0.07}
+{'loss': 1.5978, 'grad_norm': 2.9903464317321777, 'learning_rate': 4.982687934848086e-06, 'avg_weight': 0.34024504870176314, 'epoch': 0.07}
+{'loss': 1.6444, 'grad_norm': 2.9462625980377197, 'learning_rate': 4.980968543577849e-06, 'avg_weight': 0.33813936412334444, 'epoch': 0.07}
+{'loss': 1.5458, 'grad_norm': 2.9322121143341064, 'learning_rate': 4.979168088616907e-06, 'avg_weight': 0.3389531776309013, 'epoch': 0.07}
+{'eval_loss': 0.39106011390686035, 'eval_runtime': 176.8862, 'eval_samples_per_second': 2.589, 'eval_steps_per_second': 0.65, 'epoch': 0.07}
+{'loss': 1.5588, 'grad_norm': 3.813068389892578, 'learning_rate': 4.977286628793707e-06, 'avg_weight': 0.3413571178913116, 'epoch': 0.07}
+{'loss': 1.7041, 'grad_norm': 3.0992965698242188, 'learning_rate': 4.975324225583465e-06, 'avg_weight': 0.3345016598701477, 'epoch': 0.07}
+{'loss': 1.5372, 'grad_norm': 2.912554979324341, 'learning_rate': 4.973280943106158e-06, 'avg_weight': 0.33904497176408765, 'epoch': 0.08}
+{'loss': 1.6412, 'grad_norm': 3.341759443283081, 'learning_rate': 4.971156848124429e-06, 'avg_weight': 0.33656598031520846, 'epoch': 0.08}
+{'loss': 1.6438, 'grad_norm': 2.90909481048584, 'learning_rate': 4.968952010041408e-06, 'avg_weight': 0.3322950556874275, 'epoch': 0.08}
+{'eval_loss': 0.38709789514541626, 'eval_runtime': 176.9433, 'eval_samples_per_second': 2.588, 'eval_steps_per_second': 0.65, 'epoch': 0.08}
+{'loss': 1.5637, 'grad_norm': 3.0614888668060303, 'learning_rate': 4.96666650089844e-06, 'avg_weight': 0.33701644390821456, 'epoch': 0.08}
+{'loss': 1.4937, 'grad_norm': 3.1825013160705566, 'learning_rate': 4.964300395372733e-06, 'avg_weight': 0.33940560817718507, 'epoch': 0.08}
+{'loss': 1.6914, 'grad_norm': 3.442878007888794, 'learning_rate': 4.961853770774921e-06, 'avg_weight': 0.33430094122886655, 'epoch': 0.08}
+{'loss': 1.5223, 'grad_norm': 3.1587722301483154, 'learning_rate': 4.959326707046532e-06, 'avg_weight': 0.33932786285877226, 'epoch': 0.09}
+{'loss': 1.5314, 'grad_norm': 3.011597156524658, 'learning_rate': 4.956719286757381e-06, 'avg_weight': 0.3337151423096657, 'epoch': 0.09}
+{'eval_loss': 0.38383862376213074, 'eval_runtime': 176.8929, 'eval_samples_per_second': 2.589, 'eval_steps_per_second': 0.65, 'epoch': 0.09}
+{'loss': 1.6525, 'grad_norm': 3.051734447479248, 'learning_rate': 4.9540315951028695e-06, 'avg_weight': 0.336119769513607, 'epoch': 0.09}
+{'loss': 1.6499, 'grad_norm': 3.2344253063201904, 'learning_rate': 4.951263719901203e-06, 'avg_weight': 0.33603269308805467, 'epoch': 0.09}
+{'loss': 1.6005, 'grad_norm': 2.8890116214752197, 'learning_rate': 4.948415751590521e-06, 'avg_weight': 0.3372333973646164, 'epoch': 0.09}
+{'loss': 1.5957, 'grad_norm': 3.270925998687744, 'learning_rate': 4.945487783225942e-06, 'avg_weight': 0.3381495177745819, 'epoch': 0.1}
+{'loss': 1.509, 'grad_norm': 3.0765645503997803, 'learning_rate': 4.9424799104765245e-06, 'avg_weight': 0.33853849917650225, 'epoch': 0.1}
+{'eval_loss': 0.3811159133911133, 'eval_runtime': 176.9156, 'eval_samples_per_second': 2.589, 'eval_steps_per_second': 0.65, 'epoch': 0.1}
+{'loss': 1.5422, 'grad_norm': 2.94732928276062, 'learning_rate': 4.939392231622136e-06, 'avg_weight': 0.3360708475112915, 'epoch': 0.1}
+{'loss': 1.6281, 'grad_norm': 3.1645963191986084, 'learning_rate': 4.9362248475502515e-06, 'avg_weight': 0.3375927582383156, 'epoch': 0.1}
+{'loss': 1.5221, 'grad_norm': 3.1172220706939697, 'learning_rate': 4.932977861752646e-06, 'avg_weight': 0.3341860607266426, 'epoch': 0.1}
+{'loss': 1.5929, 'grad_norm': 2.895547866821289, 'learning_rate': 4.929651380322019e-06, 'avg_weight': 0.3337728187441826, 'epoch': 0.1}
+{'loss': 1.5591, 'grad_norm': 3.267468214035034, 'learning_rate': 4.9262455119485295e-06, 'avg_weight': 0.3368815451860428, 'epoch': 0.11}
+{'eval_loss': 0.3784671425819397, 'eval_runtime': 176.9466, 'eval_samples_per_second': 2.588, 'eval_steps_per_second': 0.65, 'epoch': 0.11}

train/wandb/run-20251114_145219-w9xre5r3/files/requirements.txt

@@ -0,0 +1,150 @@
+mpmath==1.3.0
+typing_extensions==4.15.0
+Jinja2==3.1.6
+multidict==6.7.0
+dill==0.3.8
+charset-normalizer==3.4.4
+yarl==1.22.0
+aiosignal==1.4.0
+accelerate==1.11.0
+omegaconf==2.3.0
+msgpack==1.1.2
+codetiming==1.4.0
+click==8.2.1
+referencing==0.37.0
+opentelemetry-api==1.38.0
+opencensus==0.11.4
+sympy==1.14.0
+nvidia-cuda-runtime-cu12==12.1.105
+nvidia-cusparse-cu12==12.1.0.106
+torch==2.3.0+cu121
+PyYAML==6.0.3
+pyarrow-hotfix==0.7
+exceptiongroup==1.3.0
+multiprocess==0.70.16
+regex==2025.11.3
+markdown-it-py==4.0.0
+py-cpuinfo==9.0.0
+smmap==5.0.2
+sentry-sdk==2.43.0
+rpds-py==0.28.0
+tokenizers==0.22.1
+antlr4-python3-runtime==4.9.3
+pybind11==3.0.1
+Markdown==3.10
+cloudpickle==3.1.2
+pyasn1_modules==0.4.2
+wheel==0.45.1
+urllib3==2.5.0
+tzdata==2025.2
+pyarrow==22.0.0
+certifi==2025.10.5
+typer-slim==0.20.0
+huggingface-hub==0.36.0
+nvidia-ml-py==13.580.82
+pydantic==2.12.4
+deepspeed==0.14.4
+platformdirs==4.5.0
+sentencepiece==0.2.1
+trl==0.25.0
+tensorboard-data-server==0.7.2
+googleapis-common-protos==1.72.0
+hydra-core==1.3.2
+jsonschema-specifications==2025.9.1
+tensordict==0.10.0
+opentelemetry-semantic-conventions==0.59b0
+opentelemetry-exporter-prometheus==0.59b0
+nvidia-cublas-cu12==12.1.3.1
+frozenlist==1.8.0
+sniffio==1.3.1
+packaging==25.0
+h11==0.16.0
+async-timeout==5.0.1
+anyio==4.11.0
+pandas==2.3.3
+httpx==0.28.1
+aiohttp==3.13.2
+typeguard==4.4.4
+Pygments==2.19.2
+docstring_parser==0.17.0
+hjson==3.1.0
+pydantic_core==2.41.5
+ninja==1.13.0
+transformers==4.57.1
+datasets==4.4.1
+zipp==3.23.0
+wrapt==2.0.1
+Werkzeug==3.1.3
+pyvers==0.1.0
+prometheus_client==0.23.1
+grpcio==1.76.0
+cachetools==6.2.2
+smart_open==7.5.0
+rsa==4.9.1
+aiohttp-cors==0.8.1
+opentelemetry-sdk==1.38.0
+nvidia-curand-cu12==10.3.2.106
+fsspec==2024.5.0
+requests==2.32.5
+python-dateutil==2.9.0.post0
+py-spy==0.4.1
+safetensors==0.6.2
+distlib==0.4.0
+psutil==7.1.3
+colorful==0.5.8
+rich==14.2.0
+tyro==0.9.35
+protobuf==6.33.0
+wandb==0.22.3
+pyasn1==0.6.1
+opentelemetry-proto==1.38.0
+torchdata==0.11.0
+pip==25.2
+nvidia-cufft-cu12==11.0.2.54
+nvidia-cuda-nvrtc-cu12==12.1.105
+nvidia-cuda-cupti-cu12==12.1.105
+numpy==1.26.4
+nvidia-cudnn-cu12==8.9.2.26
+nvidia-cusolver-cu12==11.4.5.107
+torchvision==0.18.0+cu121
+torchaudio==2.3.0+cu121
+six==1.17.0
+aiohappyeyeballs==2.6.1
+httpcore==1.0.9
+gitdb==4.0.12
+virtualenv==20.35.4
+orjson==3.11.4
+tensorboard==2.20.0
+google-auth==2.43.0
+verl==0.6.0
+setuptools==80.9.0
+nvidia-nvjitlink-cu12==12.9.86
+nvidia-nccl-cu12==2.20.5
+networkx==3.3
+xxhash==3.6.0
+tqdm==4.67.1
+shellingham==1.5.4
+propcache==0.4.1
+idna==3.11
+hf-xet==1.2.0
+attrs==25.4.0
+shtab==1.7.2
+mdurl==0.1.2
+GitPython==3.1.45
+pylatexenc==2.10
+opencensus-context==0.1.3
+absl-py==2.3.1
+importlib_metadata==8.7.0
+jsonschema==4.25.1
+google-api-core==2.28.1
+ray==2.51.1
+pillow==11.3.0
+nvidia-nvtx-cu12==12.1.105
+MarkupSafe==2.1.5
+filelock==3.19.1
+triton==2.3.0
+pytz==2025.2
+peft==0.12.0
+typing-inspection==0.4.2
+annotated-types==0.7.0
+proto-plus==1.26.1

train/wandb/run-20251114_145219-w9xre5r3/files/wandb-metadata.json

@@ -0,0 +1,129 @@
+{
+  "os":  "Linux-4.18.0-372.9.1.el8.x86_64-x86_64-with-glibc2.28",
+  "python":  "CPython 3.10.19",
+  "startedAt":  "2025-11-14T06:52:19.650156Z",
+  "args":  [
+    "--model_name",
+    "Qwen/Qwen2.5-1.5B",
+    "--dataset_path",
+    "./datasets/openr1/Openr1-Math-46k-8192.jsonl",
+    "--output_dir",
+    "./model_sft_save/Qwen2.5-1.5B-Entropy-solution",
+    "--batch_size",
+    "2",
+    "--grad_accum",
+    "4",
+    "--learning_rate",
+    "5e-6",
+    "--epochs",
+    "1",
+    "--use_entropy_weighting",
+    "--teacher_model_path",
+    "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
+    "--entropy_weight_alpha",
+    "2.0",
+    "--entropy_weight_beta",
+    "0.3",
+    "--teacher_dtype",
+    "bfloat16",
+    "--entropy_top_k",
+    "48",
+    "--teacher_device_ids",
+    "2",
+    "--use_deepspeed",
+    "--deepspeed_config",
+    "deepspeed/dp_stage2.json",
+    "--use_wandb",
+    "--wandb_project",
+    "qwen-math-entropy-sft",
+    "--wandb_run_name",
+    "qwen2.5-1.5b-46k-entropy-solution"
+  ],
+  "program":  "/public/home/lshi/yoAI/projects/Online_CL/train/train_qwen_46k_weight.py",
+  "codePath":  "train_qwen_46k_weight.py",
+  "codePathLocal":  "train_qwen_46k_weight.py",
+  "email":  "yaning1001@gmail.com",
+  "root":  "/public/home/lshi/yoAI/projects/Online_CL/train",
+  "host":  "gpu-h100-07",
+  "executable":  "/public/home/lshi/miniconda3/envs/sft_qwen/bin/python3.10",
+  "cpu_count":  96,
+  "cpu_count_logical":  96,
+  "gpu":  "NVIDIA H100 80GB HBM3",
+  "gpu_count":  8,
+  "disk":  {
+    "/":  {
+      "total":  "469407801344",
+      "used":  "288248733696"
+    }
+  },
+  "memory":  {
+    "total":  "2164142350336"
+  },
+  "gpu_nvidia":  [
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-d26f2d36-a358-5f8b-e928-f5ef4f73bc89"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-379104cc-3e15-4b2c-1b78-4ee1f142e16b"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-0d2164b6-b82a-6774-4914-58672f66b913"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-4f4398d2-2978-d7cb-7a33-2995e4efdbfd"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-0b6b2f40-df37-1563-f0cb-727bd3ac0fd9"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-8574e86d-a1bb-13dd-1843-407b718ebdf6"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-23628f74-fede-6431-ae15-2764fce29130"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-d18d570f-dd0f-0ff6-3401-561c9e799136"
+    }
+  ],
+  "cudaVersion":  "12.4",
+  "slurm":  {
+    "home":  "/opt/gridview/slurm",
+    "pmix_direct_conn":  "true",
+    "pmix_direct_conn_early":  "false",
+    "pmix_direct_conn_ucx":  "false",
+    "pmix_timeout":  "3000"
+  },
+  "writerId":  "4ns8zmo5ar2v4v1bdwhe5waa6417g92a"
+}

train/wandb/run-20251114_145219-w9xre5r3/files/wandb-summary.json

@@ -0,0 +1 @@
+{"train/avg_weight":0.3368815451860428,"train/epoch":0.10587612493382742,"eval/samples_per_second":2.588,"eval/steps_per_second":0.65,"_wandb":{"runtime":5180},"train/global_step":300,"train/learning_rate":4.9262455119485295e-06,"train/grad_norm":3.267468214035034,"eval/runtime":176.9466,"_timestamp":1.7631082634970565e+09,"_step":71,"eval/loss":0.3784671425819397,"_runtime":5180,"train/loss":1.5591}

train/wandb/run-20251114_145219-w9xre5r3/logs/debug-internal.log

@@ -0,0 +1,9 @@
+{"time":"2025-11-14T14:52:19.890537747+08:00","level":"INFO","msg":"stream: starting","core version":"0.22.3"}
+{"time":"2025-11-14T14:52:22.294264931+08:00","level":"INFO","msg":"stream: created new stream","id":"w9xre5r3"}
+{"time":"2025-11-14T14:52:22.294429698+08:00","level":"INFO","msg":"handler: started","stream_id":"w9xre5r3"}
+{"time":"2025-11-14T14:52:22.295381437+08:00","level":"INFO","msg":"stream: started","id":"w9xre5r3"}
+{"time":"2025-11-14T14:52:22.295391392+08:00","level":"INFO","msg":"writer: started","stream_id":"w9xre5r3"}
+{"time":"2025-11-14T14:52:22.295405705+08:00","level":"INFO","msg":"sender: started","stream_id":"w9xre5r3"}
+{"time":"2025-11-14T15:49:09.252958086+08:00","level":"INFO","msg":"api: retrying error","error":"Post \"https://api.wandb.ai/files/yaning1001-dartmouth-college/qwen-math-entropy-sft/w9xre5r3/file_stream\": unexpected EOF"}
+{"time":"2025-11-14T16:12:36.32995217+08:00","level":"INFO","msg":"api: retrying error","error":"Post \"https://api.wandb.ai/files/yaning1001-dartmouth-college/qwen-math-entropy-sft/w9xre5r3/file_stream\": unexpected EOF"}
+{"time":"2025-11-14T16:18:43.711810258+08:00","level":"INFO","msg":"stream: closing","id":"w9xre5r3"}

train/wandb/run-20251114_145219-w9xre5r3/logs/debug.log

@@ -0,0 +1,26 @@
+2025-11-14 14:52:19,676 INFO    MainThread:1134562 [wandb_setup.py:_flush():81] Current SDK version is 0.22.3
+2025-11-14 14:52:19,676 INFO    MainThread:1134562 [wandb_setup.py:_flush():81] Configure stats pid to 1134562
+2025-11-14 14:52:19,676 INFO    MainThread:1134562 [wandb_setup.py:_flush():81] Loading settings from /public/home/lshi/.config/wandb/settings
+2025-11-14 14:52:19,676 INFO    MainThread:1134562 [wandb_setup.py:_flush():81] Loading settings from /public/home/lshi/yoAI/projects/Online_CL/train/wandb/settings
+2025-11-14 14:52:19,676 INFO    MainThread:1134562 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2025-11-14 14:52:19,676 INFO    MainThread:1134562 [wandb_init.py:setup_run_log_directory():706] Logging user logs to /public/home/lshi/yoAI/projects/Online_CL/train/wandb/run-20251114_145219-w9xre5r3/logs/debug.log
+2025-11-14 14:52:19,676 INFO    MainThread:1134562 [wandb_init.py:setup_run_log_directory():707] Logging internal logs to /public/home/lshi/yoAI/projects/Online_CL/train/wandb/run-20251114_145219-w9xre5r3/logs/debug-internal.log
+2025-11-14 14:52:19,676 INFO    MainThread:1134562 [wandb_init.py:init():833] calling init triggers
+2025-11-14 14:52:19,676 INFO    MainThread:1134562 [wandb_init.py:init():838] wandb.init called with sweep_config: {}
+config: {'_wandb': {}}
+2025-11-14 14:52:19,676 INFO    MainThread:1134562 [wandb_init.py:init():881] starting backend
+2025-11-14 14:52:19,882 INFO    MainThread:1134562 [wandb_init.py:init():884] sending inform_init request
+2025-11-14 14:52:19,886 INFO    MainThread:1134562 [wandb_init.py:init():892] backend started and connected
+2025-11-14 14:52:19,887 INFO    MainThread:1134562 [wandb_init.py:init():962] updated telemetry
+2025-11-14 14:52:19,888 INFO    MainThread:1134562 [wandb_init.py:init():986] communicating run to backend with 90.0 second timeout
+2025-11-14 14:52:22,838 INFO    MainThread:1134562 [wandb_init.py:init():1033] starting run threads in backend
+2025-11-14 14:52:22,926 INFO    MainThread:1134562 [wandb_run.py:_console_start():2506] atexit reg
+2025-11-14 14:52:22,927 INFO    MainThread:1134562 [wandb_run.py:_redirect():2354] redirect: wrap_raw
+2025-11-14 14:52:22,927 INFO    MainThread:1134562 [wandb_run.py:_redirect():2423] Wrapping output streams.
+2025-11-14 14:52:22,927 INFO    MainThread:1134562 [wandb_run.py:_redirect():2446] Redirects installed.
+2025-11-14 14:52:22,929 INFO    MainThread:1134562 [wandb_init.py:init():1073] run started, returning control to user process
+2025-11-14 14:53:10,780 INFO    MainThread:1134562 [wandb_run.py:_config_callback():1390] config_cb None None {'vocab_size': 151665, 'max_position_embeddings': 131072, 'hidden_size': 1536, 'intermediate_size': 8960, 'num_hidden_layers': 28, 'num_attention_heads': 12, 'use_sliding_window': False, 'sliding_window': None, 'max_window_layers': 28, 'num_key_value_heads': 2, 'hidden_act': 'silu', 'initializer_range': 0.02, 'rms_norm_eps': 1e-06, 'use_cache': True, 'rope_theta': 1000000.0, 'rope_scaling': None, 'attention_dropout': 0.0, 'layer_types': ['full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention', 'full_attention'], 'return_dict': True, 'output_hidden_states': False, 'torchscript': False, 'dtype': 'bfloat16', 'pruned_heads': {}, 'tie_word_embeddings': True, 'chunk_size_feed_forward': 0, 'is_encoder_decoder': False, 'is_decoder': False, 'cross_attention_hidden_size': None, 'add_cross_attention': False, 'tie_encoder_decoder': False, 'architectures': ['Qwen2ForCausalLM'], 'finetuning_task': None, 'id2label': {0: 'LABEL_0', 1: 'LABEL_1'}, 'label2id': {'LABEL_0': 0, 'LABEL_1': 1}, 'task_specific_params': None, 'problem_type': None, 'tokenizer_class': None, 'prefix': None, 'bos_token_id': None, 'pad_token_id': 151643, 'eos_token_id': 151643, 'sep_token_id': None, 'decoder_start_token_id': None, 'max_length': 8192, 'min_length': 0, 'do_sample': False, 'early_stopping': False, 'num_beams': 1, 'temperature': 1.0, 'top_k': 50, 'top_p': 1.0, 'typical_p': 1.0, 'repetition_penalty': 1.0, 'length_penalty': 1.0, 'no_repeat_ngram_size': 0, 'encoder_no_repeat_ngram_size': 0, 'bad_words_ids': None, 'num_return_sequences': 1, 'output_scores': False, 'return_dict_in_generate': False, 'forced_bos_token_id': None, 'forced_eos_token_id': None, 'remove_invalid_values': False, 'exponential_decay_length_penalty': None, 'suppress_tokens': None, 'begin_suppress_tokens': None, 'num_beam_groups': 1, 'diversity_penalty': 0.0, '_name_or_path': 'Qwen/Qwen2.5-1.5B', 'transformers_version': '4.57.1', 'model_type': 'qwen2', 'use_mrope': False, 'tf_legacy_loss': False, 'use_bfloat16': False, 'output_attentions': False, 'output_dir': './model_sft_save/Qwen2.5-1.5B-Entropy-solution', 'overwrite_output_dir': False, 'do_train': False, 'do_eval': True, 'do_predict': False, 'eval_strategy': 'steps', 'prediction_loss_only': False, 'per_device_train_batch_size': 2, 'per_device_eval_batch_size': 2, 'per_gpu_train_batch_size': None, 'per_gpu_eval_batch_size': None, 'gradient_accumulation_steps': 4, 'eval_accumulation_steps': None, 'eval_delay': 0, 'torch_empty_cache_steps': None, 'learning_rate': 5e-06, 'weight_decay': 0.01, 'adam_beta1': 0.9, 'adam_beta2': 0.999, 'adam_epsilon': 1e-08, 'max_grad_norm': 1.0, 'num_train_epochs': 1, 'max_steps': -1, 'lr_scheduler_type': 'cosine', 'lr_scheduler_kwargs': {}, 'warmup_ratio': 0.03, 'warmup_steps': 0, 'log_level': 'passive', 'log_level_replica': 'warning', 'log_on_each_node': True, 'logging_dir': './model_sft_save/Qwen2.5-1.5B-Entropy-solution/runs/Nov14_14-52-26_gpu-h100-07', 'logging_strategy': 'steps', 'logging_first_step': False, 'logging_steps': 5, 'logging_nan_inf_filter': True, 'save_strategy': 'steps', 'save_steps': 50, 'save_total_limit': 2, 'save_safetensors': True, 'save_on_each_node': False, 'save_only_model': False, 'restore_callback_states_from_checkpoint': False, 'no_cuda': False, 'use_cpu': False, 'use_mps_device': False, 'seed': 42, 'data_seed': None, 'jit_mode_eval': False, 'bf16': True, 'fp16': False, 'fp16_opt_level': 'O1', 'half_precision_backend': 'auto', 'bf16_full_eval': False, 'fp16_full_eval': False, 'tf32': None, 'local_rank': 0, 'ddp_backend': None, 'tpu_num_cores': None, 'tpu_metrics_debug': False, 'debug': [], 'dataloader_drop_last': False, 'eval_steps': 25, 'dataloader_num_workers': 0, 'dataloader_prefetch_factor': None, 'past_index': -1, 'run_name': 'qwen2.5-1.5b-46k-entropy-solution', 'disable_tqdm': False, 'remove_unused_columns': True, 'label_names': None, 'load_best_model_at_end': True, 'metric_for_best_model': 'eval_loss', 'greater_is_better': False, 'ignore_data_skip': False, 'fsdp': [], 'fsdp_min_num_params': 0, 'fsdp_config': {'min_num_params': 0, 'xla': False, 'xla_fsdp_v2': False, 'xla_fsdp_grad_ckpt': False}, 'fsdp_transformer_layer_cls_to_wrap': None, 'accelerator_config': {'split_batches': False, 'dispatch_batches': None, 'even_batches': True, 'use_seedable_sampler': True, 'non_blocking': False, 'gradient_accumulation_kwargs': None}, 'parallelism_config': None, 'deepspeed': 'deepspeed/dp_stage2.json', 'label_smoothing_factor': 0.0, 'optim': 'adamw_torch', 'optim_args': None, 'adafactor': False, 'group_by_length': False, 'length_column_name': 'length', 'report_to': ['wandb'], 'project': 'huggingface', 'trackio_space_id': 'trackio', 'ddp_find_unused_parameters': None, 'ddp_bucket_cap_mb': None, 'ddp_broadcast_buffers': None, 'dataloader_pin_memory': True, 'dataloader_persistent_workers': False, 'skip_memory_metrics': True, 'use_legacy_prediction_loop': False, 'push_to_hub': False, 'resume_from_checkpoint': None, 'hub_model_id': None, 'hub_strategy': 'every_save', 'hub_token': '<HUB_TOKEN>', 'hub_private_repo': None, 'hub_always_push': False, 'hub_revision': None, 'gradient_checkpointing': True, 'gradient_checkpointing_kwargs': {'use_reentrant': False}, 'include_inputs_for_metrics': False, 'include_for_metrics': [], 'eval_do_concat_batches': True, 'fp16_backend': 'auto', 'push_to_hub_model_id': None, 'push_to_hub_organization': None, 'push_to_hub_token': '<PUSH_TO_HUB_TOKEN>', 'mp_parameters': '', 'auto_find_batch_size': False, 'full_determinism': False, 'torchdynamo': None, 'ray_scope': 'last', 'ddp_timeout': 1800, 'torch_compile': False, 'torch_compile_backend': None, 'torch_compile_mode': None, 'include_tokens_per_second': False, 'include_num_input_tokens_seen': 'no', 'neftune_noise_alpha': None, 'optim_target_modules': None, 'batch_eval_metrics': False, 'eval_on_start': False, 'use_liger_kernel': False, 'liger_kernel_config': None, 'eval_use_gather_object': False, 'average_tokens_across_devices': True, 'model_init_kwargs': None, 'chat_template_path': None, 'dataset_text_field': None, 'dataset_kwargs': None, 'dataset_num_proc': None, 'eos_token': '<EOS_TOKEN>', 'pad_token': '<PAD_TOKEN>', 'packing': False, 'packing_strategy': 'bfd', 'padding_free': False, 'pad_to_multiple_of': None, 'eval_packing': None, 'completion_only_loss': None, 'assistant_only_loss': False, 'loss_type': 'nll', 'activation_offloading': False, 'teacher_model_path': 'deepseek-ai/DeepSeek-R1-Distill-Qwen-7B', 'entropy_weight_alpha': 2.0, 'entropy_weight_beta': 0.3, 'use_entropy_weighting': True, 'teacher_dtype': 'bfloat16', 'entropy_top_k': 48, 'teacher_device_ids': '2'}
+2025-11-14 14:53:10,783 INFO    MainThread:1134562 [wandb_config.py:__setitem__():154] [no run ID] config set model/num_parameters = 1543298048 - <bound method Run._config_callback of <wandb.sdk.wandb_run.Run object at 0x15291a429570>>
+2025-11-14 14:53:10,784 INFO    MainThread:1134562 [wandb_run.py:_config_callback():1390] config_cb model/num_parameters 1543298048 None
+2025-11-14 16:18:43,711 INFO    wandb-AsyncioManager-main:1134562 [service_client.py:_forward_responses():80] Reached EOF.
+2025-11-14 16:18:43,711 INFO    wandb-AsyncioManager-main:1134562 [mailbox.py:close():137] Closing mailbox, abandoning 1 handles.

train/wandb/run-20251114_145222-i8zbx8vz/files/config.yaml

@@ -0,0 +1,142 @@
+_wandb:
+    value:
+        cli_version: 0.22.3
+        e:
+            2utx15k5rol3shdkavsb8ec17gbbtrpd:
+                args:
+                    - --model_name
+                    - Qwen/Qwen2.5-1.5B
+                    - --dataset_path
+                    - ./datasets/openr1/Openr1-Math-46k-8192.jsonl
+                    - --output_dir
+                    - ./model_sft_save/Qwen2.5-1.5B-Entropy-solution
+                    - --batch_size
+                    - "2"
+                    - --grad_accum
+                    - "4"
+                    - --learning_rate
+                    - "5e-6"
+                    - --epochs
+                    - "1"
+                    - --use_entropy_weighting
+                    - --teacher_model_path
+                    - deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
+                    - --entropy_weight_alpha
+                    - "2.0"
+                    - --entropy_weight_beta
+                    - "0.3"
+                    - --teacher_dtype
+                    - bfloat16
+                    - --entropy_top_k
+                    - "48"
+                    - --teacher_device_ids
+                    - "2"
+                    - --use_deepspeed
+                    - --deepspeed_config
+                    - deepspeed/dp_stage2.json
+                    - --use_wandb
+                    - --wandb_project
+                    - qwen-math-entropy-sft
+                    - --wandb_run_name
+                    - qwen2.5-1.5b-46k-entropy-solution
+                codePath: train_qwen_46k_weight.py
+                codePathLocal: train_qwen_46k_weight.py
+                cpu_count: 96
+                cpu_count_logical: 96
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "469407801344"
+                        used: "288248737792"
+                email: yaning1001@gmail.com
+                executable: /public/home/lshi/miniconda3/envs/sft_qwen/bin/python3.10
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-d26f2d36-a358-5f8b-e928-f5ef4f73bc89
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-379104cc-3e15-4b2c-1b78-4ee1f142e16b
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-0d2164b6-b82a-6774-4914-58672f66b913
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-4f4398d2-2978-d7cb-7a33-2995e4efdbfd
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-0b6b2f40-df37-1563-f0cb-727bd3ac0fd9
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-8574e86d-a1bb-13dd-1843-407b718ebdf6
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-23628f74-fede-6431-ae15-2764fce29130
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-d18d570f-dd0f-0ff6-3401-561c9e799136
+                host: gpu-h100-07
+                memory:
+                    total: "2164142350336"
+                os: Linux-4.18.0-372.9.1.el8.x86_64-x86_64-with-glibc2.28
+                program: /public/home/lshi/yoAI/projects/Online_CL/train/train_qwen_46k_weight.py
+                python: CPython 3.10.19
+                root: /public/home/lshi/yoAI/projects/Online_CL/train
+                slurm:
+                    home: /opt/gridview/slurm
+                    pmix_direct_conn: "true"
+                    pmix_direct_conn_early: "false"
+                    pmix_direct_conn_ucx: "false"
+                    pmix_timeout: "3000"
+                startedAt: "2025-11-14T06:52:22.127959Z"
+                writerId: 2utx15k5rol3shdkavsb8ec17gbbtrpd
+        m: []
+        python_version: 3.10.19
+        t:
+            "1":
+                - 1
+                - 11
+                - 41
+                - 49
+                - 51
+                - 71
+                - 84
+                - 98
+                - 105
+            "2":
+                - 1
+                - 11
+                - 41
+                - 49
+                - 51
+                - 71
+                - 84
+                - 98
+                - 105
+            "3":
+                - 13
+            "4": 3.10.19
+            "5": 0.22.3
+            "6": 4.57.1
+            "10":
+                - 20
+            "12": 0.22.3
+            "13": linux-x86_64