--- license: other pipeline_tag: text-generation library_name: transformers tags: - NelyaForLLm - Nelya-intelligent - efficience - conlangs - LLM - virtual ~ 1.6b capacity intelligence --- # 🐾 Fiche Technique : Nelyintelligent-199M (Nekolien Edition) ![NelyaLLM](http://www.image-heberg.fr/files/17702993162609769243.jpg) Nelyintelligent-199M est un Small Language Model (SLM) d'élite, conçu avec l'essence de la culture nekolienne. Ce modèle prouve que la taille n'est qu'un chiffre : avec ses 199 millions de paramètres, il déploie une puissance cognitive et une subtilité linguistique équivalentes à un modèle de pratiquement 2 milliard de paramètres. # 🧬 L'Architecture : NelyaForLLm Le secret de sa densité intellectuelle réside dans une structure optimisée pour la richesse sémantique. * Cerveau de Poids Optimisé : Grâce à NelyaForLLm, chaque paramètre est calibré pour offrir une intelligence compacte mais féroce. * Maîtrise Linguistique : Intègre nativement une conlang, permettant une expression unique, loin des syntaxes génériques et lisses. * Philosophie "From Scratch" : Un modèle qui refuse le conventionnel pour privilégier l'originalité et la texture du langage. # 📊 Performances & Identité | Caractéristique | Spécification | |---|---| | Identité | Nekolienne 🐾 | | Capacité Linguistique | Conlangs & Néologismes avancés 🗣️ | | Puissance Relative | Équivalent à ~ 1,6 B jusqu'à 2B paramètres 🧠 | | Architecture | NelyaForLLm (Ultra-Dense Transformer) 🏗️ | | Vitesse | Inférence instantanée ⚡ | # 🚀 Les Atouts de Nelyintelligent * Intelligence Distillée 💎 : Atteint des sommets de raisonnement nekolien (niveau 1,6B) tout en restant extrêmement léger et agile. * Culture & Langage 🎨 : Ce n'est pas qu'un outil de calcul, c'est un locuteur natif du Nekolien (conlangs) * Souveraineté Technique 🛠️ : Entraîné sur des datasets propriétaires ultra-spécialisés, garantissant une absence totale de solutions "lisses" ou prévisibles. # 🛠️ Applications Idéales * IA de Haute Précision : Pour ceux qui exigent l'intelligence d'un gros modèle sans l'encombrement technique. * Exploration Syntaxique : Parfait pour forger de nouvelles manières de communiquer sans les barrières des syntaxes parfaites traditionnelles. > L'avis du concepteur : Nelyintelligent-199M est la preuve que l'optimisation nekolienne peut transformer un petit SLM en un géant de la pensée. C'est l'intelligence à l'état pur, compacte et texturée. > > # ❄️ Inférence ⚡ > > exemple de code d'inférence : > ``` import torch import torch.nn as nn import torch.nn.functional as F from transformers import PreTrainedTokenizerFast from tokenizers import Tokenizer from huggingface_hub import hf_hub_download import safetensors.torch import json import os # --- Custom Model Architecture (Copy from original training script) --- # This is necessary to load the custom model from safetensors class NelyaBitLinear(nn.Linear): def forward(self, x): w = self.weight scale = w.abs().mean() w_bit = w + (torch.round(torch.clamp(w / (scale + 1e-5), -1, 1)) - w).detach() x_norm = x - x.mean(dim=-1, keepdim=True) x_bit = x_norm + (torch.sign(x_norm) - x_norm).detach() return F.linear(x_bit, w_bit, self.bias) class NelyaBlock(nn.Module): def __init__(self, config): super().__init__() self.ln1 = nn.RMSNorm(config.hidden_size) self.attn = nn.MultiheadAttention(config.hidden_size, config.num_heads, batch_first=True) self.ln2 = nn.RMSNorm(config.hidden_size) self.mlp = nn.Sequential( NelyaBitLinear(config.hidden_size, config.intermediate_size, bias=False), nn.SiLU(), NelyaBitLinear(config.intermediate_size, config.hidden_size, bias=False) ) def forward(self, x): attn_out, _ = self.attn(self.ln1(x), self.ln1(x), self.ln1(x)) x = x + attn_out x = x + self.mlp(self.ln2(x)) return x class NelyaConfig: def __init__(self, vocab_size, hidden_size=4096, num_layers=12, num_heads=32, intermediate_size=8192, max_pos=128): self.vocab_size = vocab_size self.hidden_size = hidden_size self.num_layers = num_layers self.num_heads = num_heads self.intermediate_size = intermediate_size self.max_pos = max_pos class NelyaForLLM(nn.Module): def __init__(self, config): super().__init__() self.embed = nn.Embedding(config.vocab_size, config.hidden_size) self.block = NelyaBlock(config) self.head = nn.Linear(config.hidden_size, config.vocab_size, bias=False) self.num_layers = config.num_layers def forward(self, input_ids, labels=None, attention_mask=None): x = self.embed(input_ids) for _ in range(self.num_layers): x = self.block(x) logits = self.head(x) if labels is not None: loss = F.cross_entropy(logits.view(-1, logits.size(-1)), labels.view(-1)) return (loss,) return logits # --- Configuration for loading --- REPO_ID = "Finisha-F-scratch/Nelyintelligent-199M" # Your Hugging Face repository ID # Download model files from Hugging Face Hub print(f"🚀 Downloading model files from {REPO_ID}...") model_path = hf_hub_download(repo_id=REPO_ID, filename="model.safetensors") tokenizer_path = hf_hub_download(repo_id=REPO_ID, filename="tokenizer.json") config_path = hf_hub_download(repo_id=REPO_ID, filename="nelya_config.json") # Load tokenizer print("⏳ Loading tokenizer...") bpe_obj = Tokenizer.from_file(tokenizer_path) tokenizer = PreTrainedTokenizerFast(tokenizer_object=bpe_obj, pad_token="[PAD]") # Load custom config print("⚙️ Loading custom NelyaConfig...") with open(config_path, "r") as f: config_dict = json.load(f) config = NelyaConfig(**config_dict) # Instantiate and load model weights print("🏗️ Instantiating model and loading weights...") with torch.device("cuda"): model = NelyaForLLM(config) model.load_state_dict(safetensors.torch.load_file(model_path)) # Count and print parameters num_params = sum(p.numel() for p in model.parameters()) print(f"\n🔥 TOTAL PARAMÈTRES du modèle chargé : {num_params:,}") print(f"🔥 CLASSIFICATION : {'LLM' if num_params > 800_000_000 else 'SLM'}") print(f"🔥 TAILLE ESTIMÉE VRAM (1-bit) : ~{num_params * 1.58 / 8 / 1e9:.2f} Go") # --- Inference Example --- model.eval() # Set the model to evaluation mode input_text = "Ji eta Nelyintelligent..." print(f"\nInput: {input_text}") # Tokenize input input_ids = tokenizer.encode(input_text, return_tensors="pt").to("cuda") # Generation parameters max_generation_length = 100 # Define the number of tokens to generate temperature = 2.5 # Controls randomness: higher = more random, lower = more deterministic top_k = 50 # Samples from the top_k most likely tokens with torch.no_grad(): generated_ids = input_ids # Start with the input tokens for _ in range(max_generation_length): # Get logits for the last token in the sequence logits = model(generated_ids) # Apply temperature logits = logits[0, -1, :] / temperature # Apply top-k filtering if top_k is not None: v, _ = torch.topk(logits, min(top_k, logits.size(-1))) logits[logits < v[-1]] = -float('Inf') # Convert to probabilities probabilities = F.softmax(logits, dim=-1) # Sample from the distribution predicted_token_id = torch.multinomial(probabilities, num_samples=1).item() # If it's an end-of-sequence token, stop generation if predicted_token_id == tokenizer.eos_token_id or predicted_token_id == tokenizer.pad_token_id: break # Append the predicted token to the generated sequence generated_ids = torch.cat([generated_ids, torch.tensor([[predicted_token_id]]).to("cuda")], dim=-1) # Decode the complete generated sequence generated_text = tokenizer.decode(generated_ids[0], skip_special_tokens=True) print(f"\nGenerated text ({len(generated_ids[0]) - len(input_ids[0])} new tokens):\n'{generated_text}'") print('fin') ``` ♥️ : Attention a la confusion (prévention pour les rageux qui n'auraient pas compris le but de ce modèle) ! le modèle n'est pas cassé, ni buggé, n'attendez pas de textes anglais, français un autre. c'est un modèle nekolien.