Small-ever

import torch
from transformers import AutoModelForCausalLM, AutoConfig
# Pour ce modèle minimal, nous devons recréer le tokenizer personnalisé en mémoire
# car il n'est pas standard ({"Clem": 0, "Creatrice": 1, ...})

# 1. Configuration des IDs
MODEL_NAME = "Clemylia/the-smallest-llm-real-words" 
REAL_TOKENS = ["Clem", "Creatrice"] 
INPUT_TEXT = "Clem"
INPUT_ID = 0  # L'ID que le modèle a appris pour "Clem"
EXPECTED_OUTPUT = "Creatrice"
IDS_TO_TOKENS = {0: "Clem", 1: "Creatrice", 2: "<pad>", 3: "<unk>"}

# 2. Chargement du Modèle
try:
    model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
    model.eval() 
except Exception as e:
    print(f"Erreur de chargement : {e}")
    exit()

# 3. Préparation de l'Input (Tenseur de l'ID 0)
input_ids = torch.tensor([[INPUT_ID]], dtype=torch.long)

# 4. Forward Pass pour obtenir les logits
with torch.no_grad():
    outputs = model(input_ids)
    
# 5. Détermination de la Prédiction
next_token_logits = outputs.logits[0, -1, :] 
predicted_id = torch.argmax(next_token_logits).item()
predicted_token = IDS_TO_TOKENS.get(predicted_id, "TOKEN INCONNU")

print(f"Input: {INPUT_TEXT} ({INPUT_ID})")
print(f"Prédiction: {predicted_token} ({predicted_id})")
# Résultat attendu : Creatrice (ID 1)

import torch
from transformers import AutoModelForCausalLM, AutoConfig
import json
import os
import torch.nn.functional as F

# ==============================================================================
# 0. CONFIGURATION
# ==============================================================================
MODEL_NAME = "Clemylia/Small-ever" 
REAL_TOKENS = ["Clem", "Creatrice"] 
INPUT_TEXT = "Clem"                  
INPUT_ID = 0                          
EXPECTED_OUTPUT = "Creatrice"
# 🎯 NOUVEAU PARAMÈTRE : La Température (ajuste-la entre 0.1 et 1.0)
TEMPERATURE = 0.5 
# ==============================================================================


print(f"🚀 Démarrage de l'inférence avec Température ({TEMPERATURE}) pour : {MODEL_NAME}")
print("-" * 50)


# ==============================================================================
# 1. RECRÉATION DU TOKENIZER MINIMALISTE
# ==============================================================================
class MinimalTokenizer:
    """Recrée le tokenizer pour l'inférence."""
    def __init__(self, messages):
        self.vocab = {messages[0]: 0, messages[1]: 1, "<pad>": 2, "<unk>": 3}
        self.ids_to_tokens = {v: k for k, v in self.vocab.items()}
        self.pad_token_id = self.vocab["<pad>"]

    def encode(self, text, return_tensors='pt'):
        if text in self.vocab:
            input_ids = [self.vocab[text]]
        else:
            input_ids = [self.vocab["<unk>"]]
            
        if return_tensors == 'pt':
            return torch.tensor([input_ids], dtype=torch.long)
        return input_ids

    def decode(self, token_id, skip_special_tokens=True):
        return self.ids_to_tokens.get(token_id, "TOKEN INCONNU")

minimal_tokenizer = MinimalTokenizer(REAL_TOKENS)
IDS_TO_TOKENS = minimal_tokenizer.ids_to_tokens
print("✅ Tokenizer minimal recréé en mémoire.")


# ==============================================================================
# 2. CHARGEMENT DU MODÈLE SEUL
# ==============================================================================
try:
    model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
    model.eval() 
    print("✅ Modèle chargé avec succès depuis Hugging Face.")
except Exception as e:
    print(f"❌ Échec critique du chargement du modèle. Erreur : {e}")
    exit()

print("-" * 50)


# ==============================================================================
# 3. INFÉRENCE AVEC TEMPÉRATURE ET SOFTMAX
# ==============================================================================

# 3.1 Préparation de l'entrée 
input_ids = minimal_tokenizer.encode(INPUT_TEXT, return_tensors="pt")
print(f"Input '{INPUT_TEXT}' (ID {input_ids.tolist()[0][0]}) prêt.")

# 3.2 Exécution du forward pass
with torch.no_grad():
    outputs = model(input_ids)

# 3.3 Application de la température et Softmax
next_token_logits = outputs.logits[0, -1, :] 

# 🎯 Calcul de la probabilité avec température !
# 1. Divise les logits par la température
# 2. Applique Softmax pour obtenir les probabilités
logits_with_temp = next_token_logits / TEMPERATURE
probs = F.softmax(logits_with_temp, dim=-1)

# 3.4 Détermination de la prédiction (Choix du token le plus probable après Softmax)
predicted_id = torch.argmax(probs).item()
predicted_token = minimal_tokenizer.decode(predicted_id).strip()

# ==============================================================================
# 4. CONCLUSION
# ==============================================================================
print(f"Probabilités des Tokens (après Softmax/Température) :")
# Affichage formaté des probabilités pour les IDs 0, 1, 2, 3
for i in range(len(probs)):
    print(f"  ID {i} ({IDS_TO_TOKENS.get(i)}): {probs[i].item():.4f}")

print(f"\nID prédit (Max Probabilité) : {predicted_id}")
print(f"Prédiction finale : **{predicted_token}**")
print("-" * 50)

if predicted_token == EXPECTED_OUTPUT:
    print(f"🎉 TEST RÉUSSI : Le modèle a correctement prédit '{EXPECTED_OUTPUT}' !")
else:
    print(f"⚠️ TEST ÉCHOUÉ : Attendu '{EXPECTED_OUTPUT}', reçu '{predicted_token}'. (Essaie d'augmenter les époques à 100 et/ou de baisser la température.)")