❄️ Documentation : Mini-Theya-Frozer

(Architecture FrozerYTB)

Mini-Theya-Frozer est un Small Language Model (SLM) ultra-compact conçu par Finisha. Basé sur l'architecture propriétaire FrozerYTB, ce modèle privilégie la densité de connaissance et la texture du langage sur un volume de paramètres minimaliste.

🛠 Spécifications Techniques

• Architecture : FrozerYTB (Transformer-based, optimisé pour la spécialisation) 🧬
• Taille : 11,2 Millions de paramètres 📏
• Dataset : Version condensée et ultra-sélective du dataset Theya (Propriétaire, 100% artisanal) ✍️
• Entraînement : Optimisé ⚡
• Philosophie : Anti-lissage. Recherche de la "syntaxe brute" et de l'originalité sémantique.

#. 🚀 Capacités & Usages

Malgré sa petite taille, l'architecture FrozerYTB permet des performances surprenantes en milieu contraint :

• Logique de niche : Excellent pour les tâches spécifiques où les modèles génériques (lisses) échouent par manque de "caractère".
• Edge Computing : Parfait pour être embarqué sur des supports mobiles ou des environnements sans ressources GPU massives.
• Laboratoire de texture : Idéal pour ceux qui cherchent à sortir du carcan des réponses formatées par les Big Tech.

⚠️ Notes de Finisha

"Ce modèle n'est pas là pour être poli ou conventionnel. Il est là pour être vrai. Si vous cherchez du texte pré-mâché, passez votre chemin. Ici, on travaille sur la structure pure."

⚡ Exemple d'inférence ❄️

import torch
from transformers import PreTrainedTokenizerFast, AutoConfig
from huggingface_hub import hf_hub_download

# 1. RÉIMPORTATION DE TES CLASSES (Obligatoire pour le chargement)
# Le code doit savoir ce qu'est un "FrozerYTBModel"
from transformers import PretrainedConfig, PreTrainedModel

class FrozerConfig(PretrainedConfig):
    model_type = "frozerytb"
    def __init__(self, vocab_size=30000, embed_dim=256, n_layers=6, n_heads=8, **kwargs):
        super().__init__(**kwargs)
        self.vocab_size = vocab_size
        self.embed_dim = embed_dim
        self.n_layers = n_layers
        self.n_heads = n_heads

class FrozerYTBModel(PreTrainedModel):
    config_class = FrozerConfig
    def __init__(self, config):
        super().__init__(config)
        self.embedding = torch.nn.Embedding(config.vocab_size, config.embed_dim)
        self.layers = torch.nn.ModuleList([
            torch.nn.TransformerEncoderLayer(d_model=config.embed_dim, nhead=config.n_heads, batch_first=True)
            for _ in range(config.n_layers)
        ])
        self.lm_head = torch.nn.Linear(config.embed_dim, config.vocab_size)

    @property
    def all_tied_weights_keys(self):
        # Return an empty dictionary if no weights are explicitly tied in this model
        # The transformers library expects an object with a .keys() method here.
        return {}

    def forward(self, input_ids, attention_mask=None, **kwargs):
        x = self.embedding(input_ids)
        for layer in self.layers:
            x = layer(x, src_key_padding_mask=(attention_mask == 0 if attention_mask is not None else None))
        return self.lm_head(x)

# 2. CHARGEMENT DEPUIS LE REPO CLEMYLIA/NACID-FROZER
repo_id = "Clemylia/Nacid-frozer"

print("Chargement du tokenizer...")
tokenizer = PreTrainedTokenizerFast.from_pretrained(repo_id)

print("Chargement du modèle...")
# On initialise le modèle avec la config du Hub, puis on charge les poids (pytorch_model.bin)
model = FrozerYTBModel.from_pretrained(repo_id)
model.eval() # Mode évaluation (désactive le dropout)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

# 3. FONCTION DE GÉNÉRATION (Inférence)
def generate_response(prompt, max_new_tokens=50, temperature=0.7):
    # Encodage de la question
    input_ids = tokenizer.encode(prompt, return_tensors="pt").to(device)

    # Création de la réponse mot par mot
    generated = input_ids

    with torch.no_grad():
        for _ in range(max_new_tokens):
            outputs = model(generated)
            # On prend le dernier token prédit (logits)
            next_token_logits = outputs[:, -1, :] / temperature

            # Convert logits to probabilities using softmax for sampling
            next_token_probs = torch.softmax(next_token_logits, dim=-1)

            # Sample the next token using multinomial distribution
            next_token = torch.multinomial(next_token_probs, num_samples=1)

            # On ajoute le mot à la séquence
            generated = torch.cat((generated, next_token), dim=1)

            # Si le modèle génère le token de fin, on arrête
            if next_token.item() == tokenizer.eos_token_id:
                break

    return tokenizer.decode(generated[0], skip_special_tokens=True)

# 4. TEST
prompt_test = "Quelle est ta fonction principale ?"
reponse = generate_response(prompt_test)

print("-" * 30)
print(f"Question : {prompt_test}")
print(f"Réponse  : {reponse}")
print("-" * 30)
print('fin')