Upload 2 files

finetune.py

@@ -0,0 +1,143 @@
+import os
+import time
+import math
+import torch
+from model import GPTConfig, GPT
+
+import numpy as np
+
+# -----------------------------------------------------------------------------
+# KONFIGURATION FÜR SMALLMPRO FINETUNING
+out_dir = '/media/leo/Data/checkpoints/350m_Apex_1.5_Final_NEW_More_Anti_Forgetting'
+init_from = '/media/leo/Data/checkpoints/350m_fineweb' # Pfad zum Pretraining-Ordner
+dataset = 'alpaca_cleaned_mixed_NEW'
+
+# Sanfte Hyperparameter gegen Catastrophic Forgetting
+batch_size = 4
+gradient_accumulation_steps = 32
+block_size = 1024
+learning_rate = 2e-5
+max_iters = 3000
+weight_decay = 0.1
+dropout = 0.1
+warmup_iters = 100
+min_lr = 3e-6
+beta1, beta2 = 0.9, 0.95
+device = 'cuda'
+dtype = 'bfloat16'
+compile = True
+save_interval = 500
+# -----------------------------------------------------------------------------
+
+os.makedirs(out_dir, exist_ok=True)
+torch.manual_seed(1337)
+device_type = 'cuda' if 'cuda' in device else 'cpu'
+ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[dtype]
+ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype)
+
+# Daten-Loader (Alpaca Binärdatei)
+data_dir = os.path.join('data', dataset)
+train_data = np.memmap(os.path.join(data_dir, 'train.bin'), dtype=np.uint16, mode='r')
+train_mask = np.memmap(os.path.join(data_dir, 'train_mask.bin'), dtype=np.uint8, mode='r')
+
+def get_batch():
+    ix = torch.randint(len(train_data) - block_size, (batch_size,))
+    x = torch.stack([torch.from_numpy((train_data[i:i+block_size]).astype(np.int64)) for i in ix])
+    y = torch.stack([torch.from_numpy((train_data[i+1:i+1+block_size]).astype(np.int64)) for i in ix])
+    # Maske laden (entspricht y, also um 1 verschoben)
+    m = torch.stack([torch.from_numpy((train_mask[i+1:i+1+block_size]).astype(np.int64)) for i in ix])
+    
+    # WICHTIG: Ersetze in y alle Stellen, wo m == 0 ist, durch -100
+    # PyTorch CrossEntropyLoss ignoriert -100 automatisch
+    y[m == 0] = -100
+    
+    x, y = x.to(device), y.to(device)
+    return x, y
+
+# Modell laden
+print(f"📥 Lade Pretraining-Checkpoint aus {init_from}...")
+#ckpt_files = sorted([f for f in os.listdir(init_from) if f.endswith('.pt')])
+#if not ckpt_files:
+#    raise FileNotFoundError("Kein Checkpoint im init_from Verzeichnis gefunden!")
+
+#ckpt_path = os.path.join(init_from, ckpt_files[-1])
+ckpt_path = os.path.join(init_from, 'base_model_best_42k.pt')
+checkpoint = torch.load(ckpt_path, map_location=device)
+gptconf = GPTConfig(**checkpoint['model_args'])
+model = GPT(gptconf)
+state_dict = checkpoint['model']
+
+# Fix für potenzielle 'orig_mod' Prefixe
+unwanted_prefix = '_orig_mod.'
+for k,v in list(state_dict.items()):
+    if k.startswith(unwanted_prefix):
+        state_dict[k[len(unwanted_prefix):]] = state_dict.pop(k)
+
+model.load_state_dict(state_dict)
+model.to(device)
+
+if compile:
+    print("🚀 Kompiliere Modell...")
+    model = torch.compile(model)
+
+optimizer = model.configure_optimizers(weight_decay, learning_rate, (beta1, beta2), device_type)
+scaler = torch.cuda.amp.GradScaler(enabled=(dtype == 'float16'))
+
+# LR Scheduler
+def get_lr(it):
+    if it < warmup_iters: return learning_rate * it / warmup_iters
+    if it > max_iters: return min_lr
+    decay_ratio = (it - warmup_iters) / (max_iters - warmup_iters)
+    coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio))
+    return min_lr + coeff * (learning_rate - min_lr)
+
+# Trainings-Schleife
+print(f"🛠️ Starte Finetuning: Apex 1.5 lernt Chatten...")
+model.train()
+t0 = time.time()
+
+for iter_num in range(max_iters + 1):
+    lr = get_lr(iter_num)
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = lr
+
+    for micro_step in range(gradient_accumulation_steps):
+        X, Y = get_batch()
+        with ctx:
+            logits, loss = model(X, Y)
+            loss = loss / gradient_accumulation_steps
+        scaler.scale(loss).backward()
+
+    scaler.unscale_(optimizer)
+    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+    scaler.step(optimizer)
+    scaler.update()
+    optimizer.zero_grad(set_to_none=True)
+
+    if iter_num % 10 == 0:
+        dt = time.time() - t0
+        print(f"Iter {iter_num}: Loss {loss.item()*gradient_accumulation_steps:.4f}, Zeit {dt*1000:.2f}ms, LR {lr:.2e}")
+        t0 = time.time()
+
+    if iter_num > 0 and iter_num % save_interval == 0:
+        checkpoint_name = f'Apex_1.5_iter_{iter_num}.pt'
+        save_path = os.path.join(out_dir, checkpoint_name)
+        print(f"💾 Speichere Zwischen-Checkpoint: {checkpoint_name}")
+        raw_model = model._orig_mod if compile else model
+        checkpoint_data = {
+            'model': raw_model.state_dict(),
+            'model_args': checkpoint['model_args'],
+            'iter_num': iter_num,
+            'lr': lr,
+        }
+        torch.save(checkpoint_data, save_path)
+
+# Finales Speichern
+print(f"💾 Finetuning beendet. Speichere Apex 1.5...")
+final_checkpoint = {
+    'model': model.state_dict() if not compile else model._orig_mod.state_dict(),
+    'model_args': checkpoint['model_args'],
+    'config': checkpoint.get('config', {}),
+}
+torch.save(final_checkpoint, os.path.join(out_dir, 'Apex_1.5_Final.pt'))
+print("✅ Apex 1.5 wurde erfolgreich gespeichert!")

prepare.py

@@ -0,0 +1,144 @@
+import os
+import numpy as np
+import tiktoken
+from datasets import load_dataset
+from tqdm import tqdm
+
+# --- KONFIGURATION ---
+OUTPUT_DIR = "data/alpaca_cleaned_mixed_NEW"
+# Wichtig: Das muss exakt der Tokenizer sein, den dein Modell verwendet (meist GPT-2)
+TOKENIZER_NAME = "gpt2" 
+SEED = 1337
+
+# Balance: Wie viel Alpaca vs. FineWeb?
+# Zu viel FineWeb = Modell antwortet nicht im Chat-Stil
+# Zu wenig FineWeb = Modell wird dumm (vergisst Weltwissen)
+FINEWEB_SAMPLES = 520000
+
+enc = tiktoken.get_encoding(TOKENIZER_NAME)
+EOS_TOKEN = "<|endoftext|>" # End of Sequence Token
+
+def format_prompt_with_mask(instruction, input_text, output):
+    """
+    Formatiert den Prompt und erstellt die Loss-Maske.
+    Format:
+    Instruction: ...
+    Input: ... (optional)
+    Response: ... <|endoftext|>
+    """
+    # 1. Den "Prompt"-Teil bauen (Frage) -> Wird NICHT trainiert (Maske 0)
+    if input_text and input_text.strip():
+        prompt_text = f"Instruction:\n{instruction}\n\nInput:\n{input_text}\n\nResponse:\n"
+    else:
+        prompt_text = f"Instruction:\n{instruction}\n\nResponse:\n"
+    
+    # 2. Den "Completion"-Teil bauen (Antwort) -> Wird TRAINIERT (Maske 1)
+    completion_text = f"{output}{EOS_TOKEN}"
+    
+    # 3. Tokenisieren
+    # encode_plain verhindert, dass special tokens im normalen Text interpretiert werden
+    prompt_ids = enc.encode(prompt_text, allowed_special={'<|endoftext|>'})
+    completion_ids = enc.encode(completion_text, allowed_special={'<|endoftext|>'})
+    
+    # 4. Zusammenfügen
+    full_ids = prompt_ids + completion_ids
+    
+    # 5. Maske erstellen
+    # 0 = Ignorieren (Loss wird hier nicht berechnet)
+    # 1 = Trainieren (Modell soll lernen, das vorherzusagen)
+    mask = [0] * len(prompt_ids) + [1] * len(completion_ids)
+    
+    return full_ids, mask
+
+def main():
+    np.random.seed(SEED)
+    print(f"🚀 Starte Prepare-Script für SmaLLMPro (350M SFT)...")
+    print(f"📚 Tokenizer: {TOKENIZER_NAME}")
+    
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # --- 1. DATENSÄTZE LADEN ---
+    print("📥 Lade 'yahma/alpaca-cleaned' (Chat-Instruktionen)...")
+    alpaca = load_dataset("yahma/alpaca-cleaned", split='train')
+    
+    print(f"📥 Lade 'HuggingFaceFW/fineweb-edu' (Sample-10BT) für {FINEWEB_SAMPLES} Samples...")
+    fineweb = load_dataset("HuggingFaceFW/fineweb-edu", name="sample-10BT", split='train', streaming=True)
+    
+    all_tokens = []
+    all_masks = []
+    
+    # --- 2. ALPACA VERARBEITEN (Masking aktiv) ---
+    print("⚙️  Verarbeite Alpaca...")
+    for ex in tqdm(alpaca, desc="Alpaca"):
+        ids, mask = format_prompt_with_mask(ex['instruction'], ex['input'], ex['output'])
+        all_tokens.extend(ids)
+        all_masks.extend(mask)
+        
+    alpaca_len = len(all_tokens)
+    print(f"   -> Alpaca Tokens: {alpaca_len:,}")
+
+    # --- 3. FINEWEB VERARBEITEN (Wissenserhalt) ---
+    # Hier setzen wir die Maske auf 1 für den GANZEN Text.
+    # Warum? Das Modell soll das Weltwissen aktiv auffrischen, nicht nur als Prompt sehen.
+    print("⚙️  Verarbeite FineWeb (Anti-Forgetting)...")
+    fw_iter = iter(fineweb)
+    fw_count = 0
+    fw_tokens_count = 0
+    
+    for _ in tqdm(range(FINEWEB_SAMPLES), desc="FineWeb"):
+        try:
+            ex = next(fw_iter)
+            text = ex['text'] + EOS_TOKEN
+            ids = enc.encode(text, allowed_special={EOS_TOKEN})
+            
+            all_tokens.extend(ids)
+            # Alles lernen!
+            all_masks.extend([1] * len(ids)) 
+            
+            fw_tokens_count += len(ids)
+            fw_count += 1
+        except StopIteration:
+            break
+            
+    print(f"   -> FineWeb Tokens: {fw_tokens_count:,} (aus {fw_count} Dokumenten)")
+
+    # --- 4. SPEICHERN ---
+    total_tokens = len(all_tokens)
+    print(f"\n💾 Speichere {total_tokens:,} Tokens in '{OUTPUT_DIR}'...")
+    
+    # Tokens als uint16 (spart Platz, reicht für GPT-2 Vocab ~50k)
+    token_arr = np.array(all_tokens, dtype=np.uint16)
+    token_arr.tofile(os.path.join(OUTPUT_DIR, "train.bin"))
+    
+    # Maske als uint8 (braucht nur 0 oder 1)
+    mask_arr = np.array(all_masks, dtype=np.uint8)
+    mask_arr.tofile(os.path.join(OUTPUT_DIR, "train_mask.bin"))
+    
+    # --- 5. SANITY CHECK (Ganz wichtig!) ---
+    print("\n🔍 --- SANITY CHECK ---")
+    print("Ich dekodiere die ersten 50 Tokens des ersten Beispiels, um zu prüfen, ob alles stimmt.")
+    print("Grün (TRAIN) = Was das Modell lernt. Grau (IGNORE) = Was das Modell nur liest.")
+    
+    check_len = 100
+    sample_ids = all_tokens[:check_len]
+    sample_mask = all_masks[:check_len]
+    
+    # Wir rekonstruieren den Text und zeigen, was maskiert ist
+    decoded_parts = []
+    for t_id, m_val in zip(sample_ids, sample_mask):
+        token_str = enc.decode([t_id])
+        if m_val == 1:
+            decoded_parts.append(f"\033[92m{token_str}\033[0m") # Grün für Training
+        else:
+            decoded_parts.append(f"\033[90m{token_str}\033[0m") # Grau für Prompt
+            
+    print("".join(decoded_parts))
+    print("\n(Legende: \033[90mGrau=Prompt/Ignoriert\033[0m, \033[92mGrün=Response/Gelernt\033[0m)")
+    
+    if len(token_arr) != len(mask_arr):
+        print("\n❌ ACHTUNG: Token und Mask Array sind unterschiedlich lang! Irgendwas stimmt nicht!")
+    else:
+        print("\n✅ Alles perfekt. Arrays sind synchron. Du kannst trainieren.")
+
+if __name__ == "__main__":
+    main()