revert bitsandbytes: CUDA 13 runtime missing on Kaggle

bitsandbytes 4-bit quantization requires libnvJitLink.so.13 which
is not available in the Kaggle CUDA 11.8 environment.

Switching back to bfloat16-only training (no quantization):
- train_simple_nobnb.py: bfloat16 by default, 4-bit as opt-in flag
- notebook: use_4bit=False, no bitsandbytes pip install
- merge_simple.py: also uses bfloat16 for consistency

VRAM usage with bf16 LoRA on T4 should still be manageable with
batch_size=1 + gradient_accumulation=8

kaggle_train_stack29_v5.ipynb

@@ -8,17 +8,12 @@
     "\n",
     "Free GPU training on Kaggle using Qwen2.5-Coder-7B.\n",
     "\n",
-    "⏱️ **Runtime:** 2-4 hours  |  💾 **VRAM:** ~12GB (with 4-bit quantization)\n",
+    "⏱️ **Runtime:** 2-4 hours  |  💾 **VRAM:** ~14GB (bfloat16, no bitsandbytes)\n",
     "\n",
     "**Setup:**\n",
     "1. Settings → Accelerator → GPU **T4**\n",
     "2. Run all cells in order\n",
-    "3. Download merged model from Output tab when done\n",
-    "\n",
-    "**Key fixes in v5:**\n",
-    "- ✅ 4-bit NF4 quantization (saves ~10GB VRAM)\n",
-    "- ✅ bfloat16 training (instead of float16)\n",
-    "- ✅ bitsandbytes installed automatically"
+    "3. Download merged model from Output tab when done"
    ]
   },
   {
@@ -70,8 +65,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Install dependencies (including bitsandbytes for 4-bit quantization)\n",
-    "!pip install -q transformers==4.40.0 peft==0.10.0 accelerate==0.34.0 datasets==3.0.0 pyyaml tqdm scipy bitsandbytes\n",
+    "# Install other dependencies (NO bitsandbytes — bfloat16 only)\n",
+    "!pip install -q transformers==4.40.0 peft==0.10.0 accelerate==0.34.0 datasets==3.0.0 pyyaml tqdm scipy\n",
     "print('✅ Dependencies ready')"
    ]
   },
@@ -127,7 +122,7 @@
    "outputs": [],
    "source": [
     "# Generate training configuration\n",
-    "# Key changes: use_4bit=True, bf16=True, fp16=False\n",
+    "# Uses bfloat16 only (NO bitsandbytes — avoids CUDA 13 dependency issues)\n",
     "import yaml\n",
     "\n",
     "os.makedirs(OUTPUT_DIR, exist_ok=True)\n",
@@ -138,8 +133,8 @@
     "    'lora': {'r': 16, 'alpha': 32, 'dropout': 0.05, 'target_modules': ['q_proj', 'k_proj', 'v_proj', 'o_proj', 'gate_proj', 'up_proj', 'down_proj'], 'bias': 'none', 'task_type': 'CAUSAL_LM'},\n",
     "    'training': {'num_epochs': 1, 'batch_size': 1, 'gradient_accumulation': 8, 'learning_rate': 2e-4, 'warmup_steps': 50, 'weight_decay': 0.01, 'max_grad_norm': 1.0, 'logging_steps': 10, 'save_steps': 100, 'save_total_limit': 2, 'fp16': False, 'bf16': True, 'gradient_checkpointing': True},\n",
     "    'output': {'lora_dir': os.path.join(OUTPUT_DIR, 'lora'), 'logging_dir': os.path.join(OUTPUT_DIR, 'logs')},\n",
-    "    'quantization': {'enabled': True},\n",
-    "    'hardware': {'device': 'cuda', 'num_gpus': 1, 'use_4bit': True, 'use_8bit': False}\n",
+    "    'quantization': {'enabled': False},\n",
+    "    'hardware': {'device': 'cuda', 'num_gpus': 1, 'use_4bit': False, 'use_8bit': False}\n",
     "}\n",
     "\n",
     "config_path = os.path.join(OUTPUT_DIR, 'train_config.yaml')\n",
@@ -149,7 +144,6 @@
     "print(f'✅ Config: {config_path}')\n",
     "print(f\"   Model: {config['model']['name']}\")\n",
     "print(f\"   Data: {config['data']['input_path']}\")\n",
-    "print(f\"   Quantization: 4-bit={config['hardware']['use_4bit']}\")\n",
     "print(f\"   bf16={config['training']['bf16']}, fp16={config['training']['fp16']}\")"
    ]
   },
@@ -159,9 +153,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Train (using standalone train_simple_nobnb.py - now with 4-bit support)\n",
+    "# Train (using standalone train_simple_nobnb.py - bfloat16, no quantization)\n",
     "print('='*60)\n",
-    "print('STARTING TRAINING (4-bit NF4 quantized)')\n",
+    "print('STARTING TRAINING (bfloat16, no quantization)')\n",
     "print('='*60)\n",
     "\n",
     "!cd {REPO_DIR} && python train_simple_nobnb.py --config {config_path}\n",

train_simple_nobnb.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
 Simple standalone training script for Stack 2.9.
-Uses 4-bit quantization when use_4bit=True, otherwise bfloat16.
+Uses bfloat16 with optional 4-bit quantization via bitsandbytes.
 """
 
 import argparse
@@ -16,7 +16,6 @@ from transformers import (
     TrainingArguments,
     Trainer,
     DataCollatorForLanguageModeling,
-    BitsAndBytesConfig,
 )
 from peft import LoraConfig, get_peft_model, TaskType
 import torch
@@ -32,11 +31,13 @@ def load_model_and_tokenizer(
     trust_remote_code: bool = True,
     use_4bit: bool = False,
 ):
-    """Load base model with optional 4-bit quantization."""
+    """Load base model in bfloat16, with optional 4-bit quantization."""
     tokenizer = AutoTokenizer.from_pretrained(
         model_name, trust_remote_code=trust_remote_code
     )
+
     if use_4bit:
+        from transformers import BitsAndBytesConfig
         bnb_config = BitsAndBytesConfig(
             load_in_4bit=True,
             bnb_4bit_quant_type="nf4",
@@ -56,6 +57,7 @@ def load_model_and_tokenizer(
             trust_remote_code=trust_remote_code,
             device_map={"": torch.device("cuda")},
         )
+
     return model, tokenizer
 
 
@@ -103,17 +105,13 @@ def load_data(
     # Handle train_split logic
     total_samples = len(tokenized_dataset)
     if train_split >= 1.0:
-        # Absolute number of training samples
         n_train = int(train_split)
         if n_train >= total_samples:
-            # Use all data for training, no eval set
             return tokenized_dataset, None
         else:
-            # Split with exact number
             split = tokenized_dataset.train_test_split(train_size=n_train)
             return split["train"], split["test"]
     else:
-        # Fractional split
         split = tokenized_dataset.train_test_split(train_size=train_split)
         return split["train"], split["test"]
 
@@ -126,9 +124,8 @@ def train(config: dict):
     training_config = config["training"]
     output_config = config["output"]
     hardware_config = config.get("hardware", {})
-    quantization_config = config.get("quantization", {})
 
-    use_4bit = hardware_config.get("use_4bit", False) or quantization_config.get("enabled", False)
+    use_4bit = hardware_config.get("use_4bit", False)
 
     # Load model and tokenizer
     print(f"Loading model: {model_config['name']} (4bit={use_4bit})")
@@ -164,8 +161,7 @@ def train(config: dict):
     model = get_peft_model(model, peft_config)
     model.print_trainable_parameters()
 
-    # Enable gradient checkpointing with explicit use_reentrant=False
-    # (required for PyTorch 2.9+ compatibility)
+    # Enable gradient checkpointing with use_reentrant=False (required for PyTorch 2.9+)
     if training_config.get("gradient_checkpointing", True):
         model.gradient_checkpointing_enable(
             gradient_checkpointing_kwargs={"use_reentrant": False}
@@ -177,7 +173,7 @@ def train(config: dict):
                 gradient_checkpointing_kwargs={"use_reentrant": False}
             )
 
-    # Training arguments
+    # Training arguments — bf16 is safe for both full and quantized models
     output_dir = output_config["lora_dir"]
     os.makedirs(output_dir, exist_ok=True)
 
@@ -193,7 +189,7 @@ def train(config: dict):
         logging_steps=training_config.get("logging_steps", 10),
         save_steps=training_config.get("save_steps", 100),
         save_total_limit=training_config.get("save_total_limit", 2),
-        bf16=True,  # always use bf16 (works for both full and quantized)
+        bf16=True,
         fp16=False,
         gradient_checkpointing=training_config.get("gradient_checkpointing", True),
         evaluation_strategy="steps" if eval_dataset else "no",