adds gpt-oss support

README.md

@@ -10,7 +10,7 @@
 
 # 🤏🏻🏭SmolFactory
 
-SmolFactory helps you train , monitor and deploy your Smollm3 finetune , and more !
+SmolFactory helps you train, monitor and deploy your SmolLM3 and GPT-OSS fine-tunes, and more!
 
 <table>
   <tr>
@@ -35,7 +35,7 @@ Train and deploy your model with one simple command !
 - **Trackio Monitoring Space**: Real-time training metrics, loss curves, and resource utilization
 - **Demo Spaces**: Instant web interfaces for model testing and demonstration
 - **Real-time Metrics**: Live training loss, learning rate, gradient norms, and GPU utilization
-- **Custom Dashboards**: Tailored visualizations for SmolLM3 fine-tuning
+- **Custom Dashboards**: Tailored visualizations for SmolLM3 and GPT-OSS fine-tuning
 - **Artifact Logging**: Model checkpoints, configuration files, and training logs
 - **Experiment Comparison**: Side-by-side analysis of different training runs
 - **Alert System**: Notifications for training issues or completion
@@ -44,6 +44,7 @@ Train and deploy your model with one simple command !
 - **Reproducibility**: Complete experiment history with configuration snapshots
 - **Collaboration**: Easy sharing of training results and model comparisons
 - **Version Control**: Track dataset changes and model performance over time
+- **GPT-OSS Support**: Specialized configurations for OpenAI's GPT-OSS-20B model with LoRA and multilingual reasoning
 
 ## 🚀 Quick Start
 
@@ -57,7 +58,7 @@ The easiest way to get started is using the interactive pipeline:
 
 This script will:
 1. **Authenticate** with Hugging Face (write + read tokens)
-2. **Configure** training parameters interactively
+2. **Configure** training parameters interactively (SmolLM3 or GPT-OSS)
 3. **Deploy** Trackio Space for monitoring
 4. **Setup** HF Dataset for experiment tracking
 5. **Execute** training with your chosen configuration

config/train_gpt_oss_basic.py

@@ -0,0 +1,176 @@
+"""
+GPT-OSS Basic Training Configuration
+Based on OpenAI's GPT-OSS fine-tuning tutorial
+Optimized for standard fine-tuning scenarios
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+@dataclass
+class GPTOSSBasicConfig:
+    """Basic configuration for GPT-OSS fine-tuning"""
+    
+    # Trainer type selection
+    trainer_type: str = "sft"  # "sft" or "dpo"
+    
+    # Model configuration - GPT-OSS specific
+    model_name: str = "openai/gpt-oss-20b"
+    max_seq_length: int = 2048  # GPT-OSS default
+    use_flash_attention: bool = True
+    use_gradient_checkpointing: bool = True
+    
+    # Training configuration - optimized for GPT-OSS
+    batch_size: int = 4  # Conservative for 20B model
+    gradient_accumulation_steps: int = 4
+    learning_rate: float = 2e-4  # Higher LR as per tutorial
+    weight_decay: float = 0.01
+    warmup_steps: int = 100
+    max_iters: int = 1000
+    eval_interval: int = 100
+    log_interval: int = 10
+    save_interval: int = 500
+    
+    # Optimizer configuration
+    optimizer: str = "adamw_torch"
+    beta1: float = 0.9
+    beta2: float = 0.95
+    eps: float = 1e-8
+    
+    # Scheduler configuration
+    scheduler: str = "cosine_with_min_lr"
+    min_lr: float = 2e-5  # Higher min LR as per tutorial
+    lr_scheduler_kwargs: dict = None
+    
+    # Mixed precision - GPT-OSS optimized
+    fp16: bool = False  # Use bf16 for GPT-OSS
+    bf16: bool = True
+    
+    # DDP configuration
+    ddp_backend: str = "nccl"
+    ddp_find_unused_parameters: bool = False
+    
+    # Logging and saving
+    save_steps: int = 500
+    eval_steps: int = 100
+    logging_steps: int = 10
+    save_total_limit: Optional[int] = 3
+    
+    # Evaluation
+    eval_strategy: str = "steps"
+    metric_for_best_model: str = "eval_loss"
+    greater_is_better: bool = False
+    load_best_model_at_end: bool = True
+    
+    # Data configuration
+    dataset_name: str = "HuggingFaceH4/Multilingual-Thinking"
+    dataset_split: str = "train"
+    input_field: str = "messages"  # GPT-OSS uses messages format
+    target_field: str = None  # Not used for messages format
+    filter_bad_entries: bool = False
+    bad_entry_field: str = "bad_entry"
+    
+    # Chat template configuration - GPT-OSS specific
+    use_chat_template: bool = True
+    chat_template_kwargs: dict = None
+    
+    # Trackio monitoring configuration
+    enable_tracking: bool = True
+    trackio_url: Optional[str] = None
+    trackio_token: Optional[str] = None
+    log_artifacts: bool = True
+    log_metrics: bool = True
+    log_config: bool = True
+    experiment_name: Optional[str] = None
+    
+    # HF Datasets configuration
+    hf_token: Optional[str] = None
+    dataset_repo: Optional[str] = None
+    
+    # GPT-OSS specific configurations
+    # LoRA configuration for GPT-OSS
+    use_lora: bool = True
+    lora_config: dict = None
+    
+    # Quantization for GPT-OSS (MXFP4)
+    use_quantization: bool = True
+    quantization_config: dict = None
+    
+    # GPT-OSS specific model kwargs
+    model_kwargs: dict = None
+    
+    def __post_init__(self):
+        if self.chat_template_kwargs is None:
+            self.chat_template_kwargs = {
+                "add_generation_prompt": True,
+                "tokenize": False  # GPT-OSS specific
+            }
+        
+        if self.lr_scheduler_kwargs is None:
+            self.lr_scheduler_kwargs = {
+                "min_lr_rate": 0.1
+            }
+        
+        if self.lora_config is None:
+            self.lora_config = {
+                "r": 8,
+                "lora_alpha": 16,
+                "target_modules": "all-linear",
+                "target_parameters": [
+                    "7.mlp.experts.gate_up_proj",
+                    "7.mlp.experts.down_proj",
+                    "15.mlp.experts.gate_up_proj",
+                    "15.mlp.experts.down_proj",
+                    "23.mlp.experts.gate_up_proj",
+                    "23.mlp.experts.down_proj",
+                ]
+            }
+        
+        if self.quantization_config is None:
+            self.quantization_config = {
+                "dequantize": True
+            }
+        
+        if self.model_kwargs is None:
+            self.model_kwargs = {
+                "attn_implementation": "eager",
+                "torch_dtype": "auto",
+                "use_cache": False,
+                "device_map": "auto"
+            }
+        
+        # Validate configuration
+        if self.fp16 and self.bf16:
+            raise ValueError("Cannot use both fp16 and bf16")
+        
+        if self.max_seq_length > 131072:  # 128k limit
+            raise ValueError("max_seq_length cannot exceed 131072")
+        
+        # Set default experiment name if not provided
+        if self.experiment_name is None:
+            self.experiment_name = "gpt_oss_basic"
+
+def get_config(config_path: str) -> GPTOSSBasicConfig:
+    """Load configuration from file or return default"""
+    if os.path.exists(config_path):
+        # Load from file if it exists
+        import importlib.util
+        spec = importlib.util.spec_from_file_location("config_module", config_path)
+        config_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(config_module)
+        
+        if hasattr(config_module, 'config'):
+            return config_module.config
+        else:
+            # Try to find a config class
+            for attr_name in dir(config_module):
+                attr = getattr(config_module, attr_name)
+                if isinstance(attr, GPTOSSBasicConfig):
+                    return attr
+    
+    # Return default configuration
+    return GPTOSSBasicConfig()
+
+# Default configuration instance
+config = GPTOSSBasicConfig() 

config/train_gpt_oss_h100_optimized.py

@@ -0,0 +1,203 @@
+"""
+GPT-OSS H100 Optimized Training Configuration
+Based on OpenAI's GPT-OSS fine-tuning tutorial
+Optimized for H100 GPU with maximum performance
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+@dataclass
+class GPTOSSH100OptimizedConfig:
+    """H100-optimized configuration for GPT-OSS fine-tuning"""
+    
+    # Trainer type selection
+    trainer_type: str = "sft"  # "sft" or "dpo"
+    
+    # Model configuration - GPT-OSS specific with H100 optimizations
+    model_name: str = "openai/gpt-oss-20b"
+    max_seq_length: int = 4096  # Increased for H100
+    use_flash_attention: bool = True
+    use_gradient_checkpointing: bool = True
+    
+    # Training configuration - H100 optimized
+    batch_size: int = 8  # Larger batch size for H100
+    gradient_accumulation_steps: int = 2  # Reduced for faster updates
+    learning_rate: float = 3e-4  # Higher LR for H100
+    weight_decay: float = 0.01
+    warmup_steps: int = 50  # Reduced warmup for rapid training
+    max_iters: int = 2000  # More iterations for H100
+    eval_interval: int = 50  # More frequent evaluation
+    log_interval: int = 5  # More frequent logging
+    save_interval: int = 200  # More frequent saving
+    
+    # Optimizer configuration - H100 optimized
+    optimizer: str = "adamw_torch"
+    beta1: float = 0.9
+    beta2: float = 0.95
+    eps: float = 1e-8
+    
+    # Scheduler configuration - faster learning
+    scheduler: str = "cosine_with_min_lr"
+    min_lr: float = 3e-5  # Higher min LR for H100
+    lr_scheduler_kwargs: dict = None
+    
+    # Mixed precision - H100 optimized
+    fp16: bool = False  # Use bf16 for H100
+    bf16: bool = True
+    
+    # DDP configuration
+    ddp_backend: str = "nccl"
+    ddp_find_unused_parameters: bool = False
+    
+    # Logging and saving - optimized for rapid training
+    save_steps: int = 200
+    eval_steps: int = 50
+    logging_steps: int = 5
+    save_total_limit: Optional[int] = 2  # Keep fewer checkpoints
+    
+    # Evaluation
+    eval_strategy: str = "steps"
+    metric_for_best_model: str = "eval_loss"
+    greater_is_better: bool = False
+    load_best_model_at_end: bool = True
+    
+    # Data configuration
+    dataset_name: str = "HuggingFaceH4/Multilingual-Thinking"
+    dataset_split: str = "train"
+    input_field: str = "messages"  # GPT-OSS uses messages format
+    target_field: str = None  # Not used for messages format
+    filter_bad_entries: bool = False
+    bad_entry_field: str = "bad_entry"
+    
+    # Chat template configuration - GPT-OSS specific
+    use_chat_template: bool = True
+    chat_template_kwargs: dict = None
+    
+    # Trackio monitoring configuration
+    enable_tracking: bool = True
+    trackio_url: Optional[str] = None
+    trackio_token: Optional[str] = None
+    log_artifacts: bool = True
+    log_metrics: bool = True
+    log_config: bool = True
+    experiment_name: Optional[str] = None
+    
+    # HF Datasets configuration
+    hf_token: Optional[str] = None
+    dataset_repo: Optional[str] = None
+    
+    # GPT-OSS specific configurations
+    # LoRA configuration for GPT-OSS - H100 optimized
+    use_lora: bool = True
+    lora_config: dict = None
+    
+    # Quantization for GPT-OSS (MXFP4) - H100 optimized
+    use_quantization: bool = True
+    quantization_config: dict = None
+    
+    # GPT-OSS specific model kwargs - H100 optimized
+    model_kwargs: dict = None
+    
+    # H100-specific optimizations
+    dataloader_num_workers: int = 8  # More workers for H100
+    dataloader_pin_memory: bool = True
+    dataloader_prefetch_factor: int = 4  # Increased prefetch
+    
+    # Memory optimizations for H100
+    max_grad_norm: float = 1.0
+    group_by_length: bool = True  # Group similar length sequences
+    
+    def __post_init__(self):
+        if self.chat_template_kwargs is None:
+            self.chat_template_kwargs = {
+                "add_generation_prompt": True,
+                "tokenize": False  # GPT-OSS specific
+            }
+        
+        if self.lr_scheduler_kwargs is None:
+            self.lr_scheduler_kwargs = {
+                "min_lr_rate": 0.1
+            }
+        
+        if self.lora_config is None:
+            self.lora_config = {
+                "r": 16,  # Increased for H100
+                "lora_alpha": 32,  # Increased for H100
+                "target_modules": "all-linear",
+                "target_parameters": [
+                    "7.mlp.experts.gate_up_proj",
+                    "7.mlp.experts.down_proj",
+                    "15.mlp.experts.gate_up_proj",
+                    "15.mlp.experts.down_proj",
+                    "23.mlp.experts.gate_up_proj",
+                    "23.mlp.experts.down_proj",
+                ]
+            }
+        
+        if self.quantization_config is None:
+            self.quantization_config = {
+                "dequantize": True
+            }
+        
+        if self.model_kwargs is None:
+            self.model_kwargs = {
+                "attn_implementation": "eager",
+                "torch_dtype": "auto",
+                "use_cache": False,
+                "device_map": "auto"
+            }
+        
+        # Validate configuration
+        if self.fp16 and self.bf16:
+            raise ValueError("Cannot use both fp16 and bf16")
+        
+        if self.max_seq_length > 131072:  # 128k limit
+            raise ValueError("max_seq_length cannot exceed 131072")
+        
+        # Calculate training statistics for H100
+        effective_batch_size = self.batch_size * self.gradient_accumulation_steps
+        steps_per_epoch = 1000 // effective_batch_size  # Approximate for Multilingual-Thinking
+        epochs_for_max_iters = self.max_iters / steps_per_epoch
+        
+        print(f"=== GPT-OSS H100 Optimized Configuration ===")
+        print(f"Effective batch size: {effective_batch_size}")
+        print(f"Steps per epoch: ~{steps_per_epoch}")
+        print(f"Training for ~{epochs_for_max_iters:.1f} epochs")
+        print(f"Total training steps: {self.max_iters}")
+        print(f"Learning rate: {self.learning_rate}")
+        print(f"Mixed precision: {'bf16' if self.bf16 else 'fp16'}")
+        print(f"Max sequence length: {self.max_seq_length}")
+        print(f"Gradient checkpointing: {self.use_gradient_checkpointing}")
+        print(f"LoRA rank: {self.lora_config['r']}")
+        print(f"Data loader workers: {self.dataloader_num_workers}")
+        print("=" * 50)
+        
+        # Set default experiment name if not provided
+        if self.experiment_name is None:
+            self.experiment_name = "gpt_oss_h100_optimized"
+
+def get_config(config_path: str) -> GPTOSSH100OptimizedConfig:
+    """Load configuration from file or return default"""
+    if os.path.exists(config_path):
+        # Load from file if it exists
+        import importlib.util
+        spec = importlib.util.spec_from_file_location("config_module", config_path)
+        config_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(config_module)
+        
+        if hasattr(config_module, 'config'):
+            return config_module.config
+        else:
+            # Try to find a config class
+            for attr_name in dir(config_module):
+                attr = getattr(config_module, attr_name)
+                if isinstance(attr, GPTOSSH100OptimizedConfig):
+                    return attr
+    
+    # Return default configuration
+    return GPTOSSH100OptimizedConfig()
+
+# Default configuration instance
+config = GPTOSSH100OptimizedConfig() 

config/train_gpt_oss_multilingual_reasoning.py

@@ -0,0 +1,217 @@
+"""
+GPT-OSS Multilingual Reasoning Training Configuration
+Based on OpenAI's GPT-OSS fine-tuning tutorial
+Specialized for multilingual reasoning tasks
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+@dataclass
+class GPTOSSMultilingualReasoningConfig:
+    """Multilingual reasoning configuration for GPT-OSS fine-tuning"""
+    
+    # Trainer type selection
+    trainer_type: str = "sft"  # "sft" or "dpo"
+    
+    # Model configuration - GPT-OSS specific for multilingual reasoning
+    model_name: str = "openai/gpt-oss-20b"
+    max_seq_length: int = 2048  # Standard for reasoning tasks
+    use_flash_attention: bool = True
+    use_gradient_checkpointing: bool = True
+    
+    # Training configuration - optimized for multilingual reasoning
+    batch_size: int = 4  # Conservative for reasoning tasks
+    gradient_accumulation_steps: int = 4
+    learning_rate: float = 2e-4  # As per tutorial
+    weight_decay: float = 0.01
+    warmup_steps: int = 100
+    max_iters: int = 1000  # 1 epoch on Multilingual-Thinking
+    eval_interval: int = 100
+    log_interval: int = 10
+    save_interval: int = 500
+    
+    # Optimizer configuration
+    optimizer: str = "adamw_torch"
+    beta1: float = 0.9
+    beta2: float = 0.95
+    eps: float = 1e-8
+    
+    # Scheduler configuration - as per tutorial
+    scheduler: str = "cosine_with_min_lr"
+    min_lr: float = 2e-5  # As per tutorial
+    lr_scheduler_kwargs: dict = None
+    
+    # Mixed precision - GPT-OSS optimized
+    fp16: bool = False  # Use bf16 for GPT-OSS
+    bf16: bool = True
+    
+    # DDP configuration
+    ddp_backend: str = "nccl"
+    ddp_find_unused_parameters: bool = False
+    
+    # Logging and saving
+    save_steps: int = 500
+    eval_steps: int = 100
+    logging_steps: int = 10
+    save_total_limit: Optional[int] = 3
+    
+    # Evaluation
+    eval_strategy: str = "steps"
+    metric_for_best_model: str = "eval_loss"
+    greater_is_better: bool = False
+    load_best_model_at_end: bool = True
+    
+    # Data configuration - Multilingual-Thinking specific
+    dataset_name: str = "HuggingFaceH4/Multilingual-Thinking"
+    dataset_split: str = "train"
+    input_field: str = "messages"  # GPT-OSS uses messages format
+    target_field: str = None  # Not used for messages format
+    filter_bad_entries: bool = False
+    bad_entry_field: str = "bad_entry"
+    
+    # Chat template configuration - GPT-OSS specific
+    use_chat_template: bool = True
+    chat_template_kwargs: dict = None
+    
+    # Trackio monitoring configuration
+    enable_tracking: bool = True
+    trackio_url: Optional[str] = None
+    trackio_token: Optional[str] = None
+    log_artifacts: bool = True
+    log_metrics: bool = True
+    log_config: bool = True
+    experiment_name: Optional[str] = None
+    
+    # HF Datasets configuration
+    hf_token: Optional[str] = None
+    dataset_repo: Optional[str] = None
+    
+    # GPT-OSS specific configurations
+    # LoRA configuration for GPT-OSS - as per tutorial
+    use_lora: bool = True
+    lora_config: dict = None
+    
+    # Quantization for GPT-OSS (MXFP4) - as per tutorial
+    use_quantization: bool = True
+    quantization_config: dict = None
+    
+    # GPT-OSS specific model kwargs - as per tutorial
+    model_kwargs: dict = None
+    
+    # Multilingual reasoning specific configurations
+    # Generation parameters for multilingual reasoning
+    generation_config: dict = None
+    
+    # Multilingual reasoning evaluation languages
+    reasoning_languages: list = None
+    
+    def __post_init__(self):
+        if self.chat_template_kwargs is None:
+            self.chat_template_kwargs = {
+                "add_generation_prompt": True,
+                "tokenize": False  # GPT-OSS specific
+            }
+        
+        if self.lr_scheduler_kwargs is None:
+            self.lr_scheduler_kwargs = {
+                "min_lr_rate": 0.1
+            }
+        
+        if self.lora_config is None:
+            self.lora_config = {
+                "r": 8,
+                "lora_alpha": 16,
+                "target_modules": "all-linear",
+                "target_parameters": [
+                    "7.mlp.experts.gate_up_proj",
+                    "7.mlp.experts.down_proj",
+                    "15.mlp.experts.gate_up_proj",
+                    "15.mlp.experts.down_proj",
+                    "23.mlp.experts.gate_up_proj",
+                    "23.mlp.experts.down_proj",
+                ]
+            }
+        
+        if self.quantization_config is None:
+            self.quantization_config = {
+                "dequantize": True
+            }
+        
+        if self.model_kwargs is None:
+            self.model_kwargs = {
+                "attn_implementation": "eager",
+                "torch_dtype": "auto",
+                "use_cache": False,
+                "device_map": "auto"
+            }
+        
+        if self.generation_config is None:
+            self.generation_config = {
+                "max_new_tokens": 512,
+                "do_sample": True,
+                "temperature": 0.6,
+                "top_p": None,
+                "top_k": None
+            }
+        
+        if self.reasoning_languages is None:
+            self.reasoning_languages = [
+                "English", "Spanish", "French", "Italian", "German",
+                "Chinese", "Hindi", "Japanese", "Korean", "Arabic"
+            ]
+        
+        # Validate configuration
+        if self.fp16 and self.bf16:
+            raise ValueError("Cannot use both fp16 and bf16")
+        
+        if self.max_seq_length > 131072:  # 128k limit
+            raise ValueError("max_seq_length cannot exceed 131072")
+        
+        # Calculate training statistics for Multilingual-Thinking
+        effective_batch_size = self.batch_size * self.gradient_accumulation_steps
+        steps_per_epoch = 1000 // effective_batch_size  # Multilingual-Thinking has 1000 examples
+        epochs_for_max_iters = self.max_iters / steps_per_epoch
+        
+        print(f"=== GPT-OSS Multilingual Reasoning Configuration ===")
+        print(f"Dataset: {self.dataset_name}")
+        print(f"Effective batch size: {effective_batch_size}")
+        print(f"Steps per epoch: ~{steps_per_epoch}")
+        print(f"Training for ~{epochs_for_max_iters:.1f} epochs")
+        print(f"Total training steps: {self.max_iters}")
+        print(f"Learning rate: {self.learning_rate}")
+        print(f"Mixed precision: {'bf16' if self.bf16 else 'fp16'}")
+        print(f"Max sequence length: {self.max_seq_length}")
+        print(f"Gradient checkpointing: {self.use_gradient_checkpointing}")
+        print(f"LoRA rank: {self.lora_config['r']}")
+        print(f"Supported reasoning languages: {len(self.reasoning_languages)}")
+        print("=" * 50)
+        
+        # Set default experiment name if not provided
+        if self.experiment_name is None:
+            self.experiment_name = "gpt_oss_multilingual_reasoning"
+
+def get_config(config_path: str) -> GPTOSSMultilingualReasoningConfig:
+    """Load configuration from file or return default"""
+    if os.path.exists(config_path):
+        # Load from file if it exists
+        import importlib.util
+        spec = importlib.util.spec_from_file_location("config_module", config_path)
+        config_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(config_module)
+        
+        if hasattr(config_module, 'config'):
+            return config_module.config
+        else:
+            # Try to find a config class
+            for attr_name in dir(config_module):
+                attr = getattr(config_module, attr_name)
+                if isinstance(attr, GPTOSSMultilingualReasoningConfig):
+                    return attr
+    
+    # Return default configuration
+    return GPTOSSMultilingualReasoningConfig()
+
+# Default configuration instance
+config = GPTOSSMultilingualReasoningConfig() 

launch.sh

@@ -164,6 +164,7 @@ show_training_configs() {
     print_header "Available Training Configurations"
     echo "======================================"
     echo ""
+    echo "=== SmolLM3 Configurations ==="
     echo "1. Basic Training (Default)"
     echo "   - Model: SmolLM3-3B"
     echo "   - Dataset: SmolTalk"
@@ -196,7 +197,35 @@ show_training_configs() {
     echo "   - Learning Rate: 3e-6"
     echo "   - Sequence Length: 8192"
     echo ""
-    echo "5. Custom Configuration"
+    echo "=== GPT-OSS Configurations ==="
+    echo "5. GPT-OSS Basic Training"
+    echo "   - Model: openai/gpt-oss-20b"
+    echo "   - Dataset: Multilingual-Thinking"
+    echo "   - Epochs: 1"
+    echo "   - Batch Size: 4"
+    echo "   - Learning Rate: 2e-4"
+    echo "   - LoRA + MXFP4 Quantization"
+    echo "   - Optimized for multilingual reasoning"
+    echo ""
+    echo "6. GPT-OSS H100 Optimized"
+    echo "   - Model: openai/gpt-oss-20b"
+    echo "   - Dataset: Multilingual-Thinking"
+    echo "   - Epochs: 2"
+    echo "   - Batch Size: 8"
+    echo "   - Learning Rate: 3e-4"
+    echo "   - Enhanced LoRA (rank 16)"
+    echo "   - Optimized for H100 performance"
+    echo ""
+    echo "7. GPT-OSS Multilingual Reasoning"
+    echo "   - Model: openai/gpt-oss-20b"
+    echo "   - Dataset: Multilingual-Thinking"
+    echo "   - Epochs: 1"
+    echo "   - Batch Size: 4"
+    echo "   - Learning Rate: 2e-4"
+    echo "   - Specialized for reasoning tasks"
+    echo "   - Supports 10+ languages"
+    echo ""
+    echo "8. Custom Configuration"
     echo "   - User-defined parameters"
     echo ""
 }
@@ -247,6 +276,36 @@ get_training_config() {
             MAX_SEQ_LENGTH=8192
             CONFIG_FILE="config/train_smollm3_openhermes_fr_a100_multiple_passes.py"
             ;;
+        "GPT-OSS Basic Training")
+            MODEL_NAME="openai/gpt-oss-20b"
+            DATASET_NAME="HuggingFaceH4/Multilingual-Thinking"
+            MAX_EPOCHS=1
+            BATCH_SIZE=4
+            GRADIENT_ACCUMULATION_STEPS=4
+            LEARNING_RATE=2e-4
+            MAX_SEQ_LENGTH=2048
+            CONFIG_FILE="config/train_gpt_oss_basic.py"
+            ;;
+        "GPT-OSS H100 Optimized")
+            MODEL_NAME="openai/gpt-oss-20b"
+            DATASET_NAME="HuggingFaceH4/Multilingual-Thinking"
+            MAX_EPOCHS=2
+            BATCH_SIZE=8
+            GRADIENT_ACCUMULATION_STEPS=2
+            LEARNING_RATE=3e-4
+            MAX_SEQ_LENGTH=4096
+            CONFIG_FILE="config/train_gpt_oss_h100_optimized.py"
+            ;;
+        "GPT-OSS Multilingual Reasoning")
+            MODEL_NAME="openai/gpt-oss-20b"
+            DATASET_NAME="HuggingFaceH4/Multilingual-Thinking"
+            MAX_EPOCHS=1
+            BATCH_SIZE=4
+            GRADIENT_ACCUMULATION_STEPS=4
+            LEARNING_RATE=2e-4
+            MAX_SEQ_LENGTH=2048
+            CONFIG_FILE="config/train_gpt_oss_multilingual_reasoning.py"
+            ;;
         "Custom Configuration")
             get_custom_config
             ;;
@@ -419,7 +478,7 @@ print_step "Step 2: Training Configuration"
 echo "=================================="
 
 show_training_configs
-select_option "Select training configuration:" "Basic Training" "H100 Lightweight (Rapid)" "A100 Large Scale" "Multiple Passes" "Custom Configuration" TRAINING_CONFIG_TYPE
+select_option "Select training configuration:" "Basic Training" "H100 Lightweight (Rapid)" "A100 Large Scale" "Multiple Passes" "GPT-OSS Basic Training" "GPT-OSS H100 Optimized" "GPT-OSS Multilingual Reasoning" "Custom Configuration" TRAINING_CONFIG_TYPE
 
 get_training_config "$TRAINING_CONFIG_TYPE"
 
@@ -783,13 +842,24 @@ export HUGGING_FACE_HUB_TOKEN="$HF_TOKEN"
 export HF_USERNAME="$HF_USERNAME"
 export TRACKIO_DATASET_REPO="$TRACKIO_DATASET_REPO"
 
-# Run the simpler training script
-python scripts/training/train.py \
-    --config "$CONFIG_FILE" \
-    --experiment-name "$EXPERIMENT_NAME" \
-    --output-dir /output-checkpoint \
-    --trackio-url "$TRACKIO_URL" \
-    --trainer-type "$TRAINER_TYPE_LOWER"
+# Run the appropriate training script based on model type
+if [[ "$MODEL_NAME" == *"gpt-oss"* ]]; then
+    print_info "Using GPT-OSS specialized training script..."
+    python scripts/training/train_gpt_oss.py \
+        --config "$CONFIG_FILE" \
+        --experiment-name "$EXPERIMENT_NAME" \
+        --output-dir /output-checkpoint \
+        --trackio-url "$TRACKIO_URL" \
+        --trainer-type "$TRAINER_TYPE_LOWER"
+else
+    print_info "Using standard SmolLM3 training script..."
+    python scripts/training/train.py \
+        --config "$CONFIG_FILE" \
+        --experiment-name "$EXPERIMENT_NAME" \
+        --output-dir /output-checkpoint \
+        --trackio-url "$TRACKIO_URL" \
+        --trainer-type "$TRAINER_TYPE_LOWER"
+fi
 
 # Step 16: Push model to Hugging Face Hub
 print_step "Step 16: Pushing Model to HF Hub"
@@ -806,14 +876,26 @@ export HUGGING_FACE_HUB_TOKEN="$HF_TOKEN"
 export HF_USERNAME="$HF_USERNAME"
 export TRACKIO_DATASET_REPO="$TRACKIO_DATASET_REPO"
 
-# Run the push script
-python scripts/model_tonic/push_to_huggingface.py /output-checkpoint "$REPO_NAME" \
-    --token "$HF_TOKEN" \
-    --trackio-url "$TRACKIO_URL" \
-    --experiment-name "$EXPERIMENT_NAME" \
-    --dataset-repo "$TRACKIO_DATASET_REPO" \
-    --author-name "$AUTHOR_NAME" \
-    --model-description "$MODEL_DESCRIPTION"
+# Run the appropriate push script based on model type
+if [[ "$MODEL_NAME" == *"gpt-oss"* ]]; then
+    print_info "Using GPT-OSS specialized push script..."
+    python scripts/model_tonic/push_gpt_oss_to_huggingface.py /output-checkpoint "$REPO_NAME" \
+        --token "$HF_TOKEN" \
+        --trackio-url "$TRACKIO_URL" \
+        --experiment-name "$EXPERIMENT_NAME" \
+        --dataset-repo "$TRACKIO_DATASET_REPO" \
+        --author-name "$AUTHOR_NAME" \
+        --model-description "$MODEL_DESCRIPTION"
+else
+    print_info "Using standard SmolLM3 push script..."
+    python scripts/model_tonic/push_to_huggingface.py /output-checkpoint "$REPO_NAME" \
+        --token "$HF_TOKEN" \
+        --trackio-url "$TRACKIO_URL" \
+        --experiment-name "$EXPERIMENT_NAME" \
+        --dataset-repo "$TRACKIO_DATASET_REPO" \
+        --author-name "$AUTHOR_NAME" \
+        --model-description "$MODEL_DESCRIPTION"
+fi
 
 # Step 16.5: Switch Trackio Space to Read Token (Security)
 print_step "Step 16.5: Switching to Read Token for Security"

requirements/requirements_core.txt

@@ -1,10 +1,10 @@
-# Core dependencies for SmolLM3 fine-tuning
+# Core dependencies for SmolLM3 and GPT-OSS fine-tuning
 torch>=2.0.0
-transformers>=4.53.0
+transformers>=4.55.0  # Updated for GPT-OSS compatibility
 datasets>=2.14.0
 accelerate>=0.20.0
-peft>=0.4.0
-trl>=0.7.0
+peft>=0.17.0  # Updated for GPT-OSS LoRA support
+trl>=0.20.0  # Updated for GPT-OSS compatibility
 
 # Hugging Face Hub for model and space management
 huggingface_hub>=0.19.0
@@ -16,4 +16,8 @@ pandas>=2.0.0
 plotly>=5.0.0
 trackio>=0.1.0
 psutil>=5.9.0 
-pynvml>=12.0.0
+pynvml>=12.0.0
+
+# GPT-OSS specific dependencies
+# Note: GPT-OSS requires specific versions for optimal performance
+# These are compatible with the tutorial requirements

scripts/model_tonic/push_gpt_oss_to_huggingface.py

@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+"""
+GPT-OSS Model Push Script
+Specialized script for pushing GPT-OSS models to Hugging Face Hub
+Handles LoRA weight merging and model card generation
+"""
+
+import os
+import sys
+import argparse
+import json
+from datetime import datetime
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+import torch
+
+def merge_lora_weights(checkpoint_path, base_model_name, output_path):
+    """Merge LoRA weights with base model for inference"""
+    
+    print(f"Loading base model: {base_model_name}")
+    
+    # Load base model
+    model_kwargs = {
+        "attn_implementation": "eager", 
+        "torch_dtype": "auto", 
+        "use_cache": True, 
+        "device_map": "auto"
+    }
+    base_model = AutoModelForCausalLM.from_pretrained(base_model_name, **model_kwargs).cuda()
+    
+    print(f"Loading LoRA weights from: {checkpoint_path}")
+    
+    # Load and merge LoRA weights
+    model = PeftModel.from_pretrained(base_model, checkpoint_path)
+    model = model.merge_and_unload()
+    
+    print(f"Saving merged model to: {output_path}")
+    model.save_pretrained(output_path)
+    
+    # Save tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(base_model_name)
+    tokenizer.save_pretrained(output_path)
+    
+    return model, tokenizer
+
+def create_gpt_oss_model_card(model_name, experiment_name, trackio_url, dataset_repo, author_name, model_description):
+    """Create a comprehensive model card for GPT-OSS models"""
+    
+    card_content = f"""---
+language:
+- en
+- es
+- fr
+- it
+- de
+- zh
+- hi
+- ja
+- ko
+- ar
+license: mit
+tags:
+- gpt-oss
+- multilingual
+- reasoning
+- chain-of-thought
+- fine-tuned
+---
+
+# {model_name}
+
+## Model Description
+
+{model_description}
+
+This model is a fine-tuned version of OpenAI's GPT-OSS-20B model, optimized for multilingual reasoning tasks. It has been trained on the Multilingual-Thinking dataset to generate chain-of-thought reasoning in multiple languages.
+
+## Training Details
+
+- **Base Model**: openai/gpt-oss-20b
+- **Training Dataset**: HuggingFaceH4/Multilingual-Thinking
+- **Training Method**: LoRA (Low-Rank Adaptation)
+- **Quantization**: MXFP4
+- **Experiment**: {experiment_name}
+- **Monitoring**: {trackio_url}
+
+## Usage
+
+### Basic Usage
+
+```python
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+# Load model and tokenizer
+tokenizer = AutoTokenizer.from_pretrained("{model_name}")
+model = AutoModelForCausalLM.from_pretrained("{model_name}")
+
+# Example: Reasoning in Spanish
+messages = [
+    {{"role": "system", "content": "reasoning language: Spanish"}},
+    {{"role": "user", "content": "What is the capital of Australia?"}}
+]
+
+input_ids = tokenizer.apply_chat_template(
+    messages,
+    add_generation_prompt=True,
+    return_tensors="pt"
+).to(model.device)
+
+output_ids = model.generate(input_ids, max_new_tokens=512)
+response = tokenizer.batch_decode(output_ids)[0]
+print(response)
+```
+
+### Multilingual Reasoning
+
+The model supports reasoning in multiple languages:
+
+- English
+- Spanish (Español)
+- French (Français)
+- Italian (Italiano)
+- German (Deutsch)
+- Chinese (中文)
+- Hindi (हिन्दी)
+- Japanese (日本語)
+- Korean (한국어)
+- Arabic (العربية)
+
+### System Prompt Format
+
+To control the reasoning language, use the system prompt:
+
+```
+reasoning language: [LANGUAGE]
+```
+
+Example:
+```
+reasoning language: German
+```
+
+## Training Configuration
+
+- **LoRA Rank**: 8
+- **LoRA Alpha**: 16
+- **Target Modules**: all-linear
+- **Learning Rate**: 2e-4
+- **Batch Size**: 4
+- **Sequence Length**: 2048
+- **Mixed Precision**: bf16
+
+## Dataset Information
+
+The model was trained on the Multilingual-Thinking dataset, which contains 1,000 examples of chain-of-thought reasoning translated into multiple languages.
+
+## Limitations
+
+- The model is designed for reasoning tasks and may not perform optimally on other tasks
+- Reasoning quality may vary across languages
+- The model inherits limitations from the base GPT-OSS-20B model
+
+## Citation
+
+If you use this model in your research, please cite:
+
+```bibtex
+@misc{{{model_name.replace("/", "_").replace("-", "_")},
+  author = {{{author_name}}},
+  title = {{{model_name}}},
+  year = {{{datetime.now().year}}},
+  publisher = {Hugging Face},
+  journal = {Hugging Face repository},
+  howpublished = {{\\url{{https://huggingface.co/{model_name}}}}}
+  }}
+```
+
+## License
+
+This model is licensed under the MIT License.
+
+## Training Resources
+
+- **Training Dataset**: https://huggingface.co/datasets/{dataset_repo}
+- **Training Monitoring**: {trackio_url}
+- **Base Model**: https://huggingface.co/openai/gpt-oss-20b
+
+## Model Information
+
+- **Architecture**: GPT-OSS-20B with LoRA adapters
+- **Parameters**: 20B base + LoRA adapters
+- **Context Length**: 2048 tokens
+- **Languages**: 10+ languages supported
+- **Task**: Multilingual reasoning and chain-of-thought generation
+"""
+    
+    return card_content
+
+def push_gpt_oss_model(checkpoint_path, repo_name, hf_token, trackio_url, experiment_name, dataset_repo, author_name, model_description):
+    """Push GPT-OSS model to Hugging Face Hub"""
+    
+    print("=== GPT-OSS Model Push Pipeline ===")
+    print(f"Checkpoint: {checkpoint_path}")
+    print(f"Repository: {repo_name}")
+    print(f"Experiment: {experiment_name}")
+    print(f"Author: {author_name}")
+    
+    # Validate checkpoint path
+    if not os.path.exists(checkpoint_path):
+        raise FileNotFoundError(f"Checkpoint path not found: {checkpoint_path}")
+    
+    # Create temporary directory for merged model
+    temp_output = f"/tmp/gpt_oss_merged_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+    os.makedirs(temp_output, exist_ok=True)
+    
+    try:
+        # Merge LoRA weights with base model
+        print("Merging LoRA weights with base model...")
+        model, tokenizer = merge_lora_weights(
+            checkpoint_path=checkpoint_path,
+            base_model_name="openai/gpt-oss-20b",
+            output_path=temp_output
+        )
+        
+        # Create model card
+        print("Creating model card...")
+        model_card_content = create_gpt_oss_model_card(
+            model_name=repo_name,
+            experiment_name=experiment_name,
+            trackio_url=trackio_url,
+            dataset_repo=dataset_repo,
+            author_name=author_name,
+            model_description=model_description
+        )
+        
+        # Save model card
+        model_card_path = os.path.join(temp_output, "README.md")
+        with open(model_card_path, "w", encoding="utf-8") as f:
+            f.write(model_card_content)
+        
+        # Push to Hugging Face Hub
+        print(f"Pushing model to: {repo_name}")
+        
+        # Set HF token
+        os.environ["HUGGING_FACE_HUB_TOKEN"] = hf_token
+        
+        # Push using transformers
+        from huggingface_hub import HfApi
+        api = HfApi()
+        
+        # Create repository if it doesn't exist
+        try:
+            api.create_repo(repo_name, private=False, exist_ok=True)
+        except Exception as e:
+            print(f"Warning: Could not create repository: {e}")
+        
+        # Upload files
+        print("Uploading model files...")
+        api.upload_folder(
+            folder_path=temp_output,
+            repo_id=repo_name,
+            repo_type="model"
+        )
+        
+        print("✅ GPT-OSS model pushed successfully!")
+        print(f"Model URL: https://huggingface.co/{repo_name}")
+        
+        # Clean up
+        import shutil
+        shutil.rmtree(temp_output)
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error pushing GPT-OSS model: {e}")
+        
+        # Clean up on error
+        if os.path.exists(temp_output):
+            import shutil
+            shutil.rmtree(temp_output)
+        
+        return False
+
+def main():
+    parser = argparse.ArgumentParser(description="Push GPT-OSS model to Hugging Face Hub")
+    parser.add_argument("checkpoint_path", help="Path to model checkpoint")
+    parser.add_argument("repo_name", help="Hugging Face repository name")
+    parser.add_argument("--token", required=True, help="Hugging Face token")
+    parser.add_argument("--trackio-url", help="Trackio URL for model card")
+    parser.add_argument("--experiment-name", help="Experiment name")
+    parser.add_argument("--dataset-repo", help="Dataset repository")
+    parser.add_argument("--author-name", help="Author name")
+    parser.add_argument("--model-description", help="Model description")
+    
+    args = parser.parse_args()
+    
+    # Set defaults
+    experiment_name = args.experiment_name or "gpt_oss_finetune"
+    dataset_repo = args.dataset_repo or "HuggingFaceH4/Multilingual-Thinking"
+    author_name = args.author_name or "GPT-OSS Fine-tuner"
+    model_description = args.model_description or "A fine-tuned version of OpenAI's GPT-OSS-20B model for multilingual reasoning tasks."
+    
+    success = push_gpt_oss_model(
+        checkpoint_path=args.checkpoint_path,
+        repo_name=args.repo_name,
+        hf_token=args.token,
+        trackio_url=args.trackio_url,
+        experiment_name=experiment_name,
+        dataset_repo=dataset_repo,
+        author_name=author_name,
+        model_description=model_description
+    )
+    
+    sys.exit(0 if success else 1)
+
+if __name__ == "__main__":
+    main() 

scripts/training/train_gpt_oss.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""
+GPT-OSS Training Script
+Specialized training script for OpenAI's GPT-OSS models
+Based on the GPT-OSS fine-tuning tutorial
+"""
+
+import os
+import sys
+import argparse
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import LoraConfig, get_peft_model
+from trl import SFTTrainer, SFTConfig
+import trackio
+from datasets import load_dataset
+
+def load_gpt_oss_model_and_tokenizer(config):
+    """Load GPT-OSS model and tokenizer with proper configuration"""
+    
+    print("Loading GPT-OSS tokenizer...")
+    tokenizer = AutoTokenizer.from_pretrained(config.model_name)
+    
+    print("Loading GPT-OSS model with quantization...")
+    
+    # Import quantization config
+    from transformers import Mxfp4Config
+    
+    # Set up quantization config
+    quantization_config = Mxfp4Config(dequantize=True)
+    
+    # Model kwargs as per tutorial
+    model_kwargs = {
+        "attn_implementation": "eager",
+        "torch_dtype": torch.bfloat16,
+        "quantization_config": quantization_config,
+        "use_cache": False,
+        "device_map": "auto",
+    }
+    
+    model = AutoModelForCausalLM.from_pretrained(config.model_name, **model_kwargs)
+    
+    return model, tokenizer
+
+def setup_lora_for_gpt_oss(model, config):
+    """Setup LoRA for GPT-OSS model"""
+    
+    print("Setting up LoRA for GPT-OSS...")
+    
+    # LoRA configuration as per tutorial
+    lora_config = LoraConfig(
+        r=config.lora_config.get("r", 8),
+        lora_alpha=config.lora_config.get("lora_alpha", 16),
+        target_modules=config.lora_config.get("target_modules", "all-linear"),
+        target_parameters=config.lora_config.get("target_parameters", [
+            "7.mlp.experts.gate_up_proj",
+            "7.mlp.experts.down_proj",
+            "15.mlp.experts.gate_up_proj",
+            "15.mlp.experts.down_proj",
+            "23.mlp.experts.gate_up_proj",
+            "23.mlp.experts.down_proj",
+        ]),
+    )
+    
+    peft_model = get_peft_model(model, lora_config)
+    peft_model.print_trainable_parameters()
+    
+    return peft_model
+
+def load_multilingual_thinking_dataset():
+    """Load the Multilingual-Thinking dataset"""
+    
+    print("Loading Multilingual-Thinking dataset...")
+    dataset = load_dataset("HuggingFaceH4/Multilingual-Thinking", split="train")
+    print(f"Dataset loaded: {len(dataset)} examples")
+    
+    return dataset
+
+def setup_trackio_tracking(config):
+    """Setup Trackio tracking if enabled"""
+    
+    if not config.enable_tracking or not config.trackio_url:
+        print("Trackio tracking disabled or URL not provided")
+        return None
+    
+    print(f"Setting up Trackio tracking: {config.trackio_url}")
+    
+    # Initialize Trackio client
+    trackio_client = trackio.Client(
+        api_url=config.trackio_url,
+        token=config.trackio_token
+    )
+    
+    return trackio_client
+
+def create_sft_config(config):
+    """Create SFTConfig for GPT-OSS training"""
+    
+    print("Creating SFT configuration...")
+    
+    sft_config = SFTConfig(
+        learning_rate=config.learning_rate,
+        gradient_checkpointing=True,
+        num_train_epochs=1,  # Single epoch as per tutorial
+        logging_steps=config.logging_steps,
+        per_device_train_batch_size=config.batch_size,
+        gradient_accumulation_steps=config.gradient_accumulation_steps,
+        max_length=config.max_seq_length,
+        warmup_ratio=0.03,
+        lr_scheduler_type="cosine_with_min_lr",
+        lr_scheduler_kwargs={"min_lr_rate": 0.1},
+        output_dir="gpt-oss-20b-multilingual-reasoner",
+        report_to="trackio" if config.enable_tracking else None,
+        push_to_hub=True,
+    )
+    
+    return sft_config
+
+def train_gpt_oss(config_path, experiment_name, output_dir, trackio_url, trainer_type="sft"):
+    """Main training function for GPT-OSS"""
+    
+    print("=== GPT-OSS Training Pipeline ===")
+    print(f"Config: {config_path}")
+    print(f"Experiment: {experiment_name}")
+    print(f"Output: {output_dir}")
+    print(f"Trackio: {trackio_url}")
+    print(f"Trainer: {trainer_type}")
+    
+    # Load configuration
+    if os.path.exists(config_path):
+        import importlib.util
+        spec = importlib.util.spec_from_file_location("config_module", config_path)
+        config_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(config_module)
+        
+        if hasattr(config_module, 'config'):
+            config = config_module.config
+        else:
+            # Try to find a config class
+            for attr_name in dir(config_module):
+                attr = getattr(config_module, attr_name)
+                if hasattr(attr, 'model_name') and 'gpt_oss' in attr.model_name.lower():
+                    config = attr
+                    break
+            else:
+                raise ValueError(f"No GPT-OSS configuration found in {config_path}")
+    else:
+        raise FileNotFoundError(f"Configuration file not found: {config_path}")
+    
+    # Update config with runtime parameters
+    config.experiment_name = experiment_name
+    config.trackio_url = trackio_url
+    config.trainer_type = trainer_type
+    
+    # Load model and tokenizer
+    model, tokenizer = load_gpt_oss_model_and_tokenizer(config)
+    
+    # Setup LoRA
+    peft_model = setup_lora_for_gpt_oss(model, config)
+    
+    # Load dataset
+    dataset = load_multilingual_thinking_dataset()
+    
+    # Setup Trackio tracking
+    trackio_client = setup_trackio_tracking(config)
+    
+    # Create SFT configuration
+    sft_config = create_sft_config(config)
+    
+    # Create trainer
+    print("Creating SFT trainer...")
+    trainer = SFTTrainer(
+        model=peft_model,
+        args=sft_config,
+        train_dataset=dataset,
+        processing_class=tokenizer,
+    )
+    
+    # Start training
+    print("Starting GPT-OSS training...")
+    trainer.train()
+    
+    # Save model
+    print("Saving trained model...")
+    trainer.save_model(output_dir)
+    
+    # Push to hub if enabled
+    if sft_config.push_to_hub:
+        print("Pushing model to Hugging Face Hub...")
+        trainer.push_to_hub(dataset_name="HuggingFaceH4/Multilingual-Thinking")
+    
+    print("GPT-OSS training completed successfully!")
+    
+    return trainer
+
+def main():
+    parser = argparse.ArgumentParser(description="GPT-OSS Training Script")
+    parser.add_argument("--config", required=True, help="Path to configuration file")
+    parser.add_argument("--experiment-name", required=True, help="Experiment name")
+    parser.add_argument("--output-dir", required=True, help="Output directory for checkpoints")
+    parser.add_argument("--trackio-url", help="Trackio URL for monitoring")
+    parser.add_argument("--trainer-type", default="sft", choices=["sft", "dpo"], help="Trainer type")
+    
+    args = parser.parse_args()
+    
+    # Validate arguments
+    if not os.path.exists(args.config):
+        print(f"Error: Configuration file not found: {args.config}")
+        sys.exit(1)
+    
+    # Create output directory
+    os.makedirs(args.output_dir, exist_ok=True)
+    
+    try:
+        train_gpt_oss(
+            config_path=args.config,
+            experiment_name=args.experiment_name,
+            output_dir=args.output_dir,
+            trackio_url=args.trackio_url,
+            trainer_type=args.trainer_type
+        )
+    except Exception as e:
+        print(f"Error during training: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()