Upload 8 files

Dockerfile

@@ -0,0 +1,24 @@
+# Dockerfile pour Hugging Face Spaces (SDK: docker)
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Dépendances système minimales
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+# HF Spaces (Docker SDK) attend que le conteneur écoute sur le port 7860
+ENV PORT=7860
+EXPOSE 7860
+
+# Utilisateur non-root recommandé par HF Spaces
+RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
+USER appuser
+
+CMD ["python", "app.py"]

README.md

@@ -1,11 +1,155 @@
 ---
-title: Hilal Ai
-emoji: 🐨
-colorFrom: yellow
-colorTo: blue
+title: Hilal Ai Telegram Bot
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
 sdk: docker
+app_port: 7860
 pinned: false
-license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Hilal Ai — Bot Telegram hébergé sur Hugging Face Spaces (gratuit)
+
+Ce Space fait tourner en continu un bot Telegram propulsé par un modèle
+Transformer décodeur (style GPT) entraîné from scratch au niveau caractère.
+
+## ⚠️ Comprendre les limites du tier gratuit AVANT de déployer
+
+Le tier **CPU Basic** de HF Spaces est gratuit mais se met en veille après
+~48h sans "visite" sur la page web du Space. Un bot Telegram en polling n'a
+pas de visiteurs web naturellement, donc ce repo inclut :
+- un petit serveur Flask (`app.py`) qui répond sur `/` et `/ping`
+- des instructions ci-dessous pour qu'un service externe gratuit (UptimeRobot
+  ou GitHub Actions) ping cette URL régulièrement et empêche la mise en veille
+
+C'est une solution **bricolée mais fonctionnelle**. Elle n'est pas garantie à
+100% par Hugging Face (ce n'est pas un usage "officiellement prévu" du tier
+gratuit) — si tu veux une garantie de disponibilité totale, il faudra upgrader
+le hardware du Space (~9$/mois) qui élimine la mise en veille.
+
+## Fichiers du repo
+
+```
+.
+├── Dockerfile          # image Docker du Space (SDK: docker)
+├── app.py              # serveur web de ping + lance bot.py dans un thread
+├── bot.py              # logique du bot Telegram
+├── model.py            # architecture MiniGPT + tokenizer char-level
+├── requirements.txt
+├── .gitattributes      # config Git LFS pour model.pt
+├── model.pt            # TES poids entraînés (à uploader, voir ci-dessous)
+└── vocab.json          # TON vocabulaire char-level (voir ci-dessous)
+```
+
+## ⚠️ vocab.json est OBLIGATOIRE pour des réponses cohérentes
+
+Le tokenizer char-level a besoin du mapping exact caractère→indice utilisé
+pendant l'entraînement sur Colab. Sans lui, le modèle se chargera sans
+erreur mais générera des réponses incohérentes (les embeddings ne
+correspondront pas aux bons caractères).
+
+Si tu as encore accès à ton notebook Colab ou ton corpus d'entraînement :
+```python
+import json
+chars = sorted(list(set(text)))  # `text` = ton corpus d'entraînement original
+with open("vocab.json", "w", encoding="utf-8") as f:
+    json.dump({"chars": chars}, f, ensure_ascii=False)
+```
+
+## Étape 1 — Créer le Space sur Hugging Face
+
+1. Va sur https://huggingface.co/new-space (tu es déjà connecté à ton compte)
+2. Choisis un nom (ex: `hilal-ai-bot`)
+3. SDK : sélectionne **Docker** (pas Gradio)
+4. Visibilité : Public ou Private selon ta préférence
+5. Clique sur "Create Space"
+
+## Étape 2 — Ajouter le token Telegram comme secret
+
+Dans la page de ton Space : **Settings → Repository secrets → New secret**
+- Nom : `TELEGRAM_BOT_TOKEN`
+- Valeur : le token obtenu via @BotFather sur Telegram
+
+Ne mets jamais ce token directement dans le code ou dans un fichier commité.
+
+## Étape 3 — Pousser le code sur le Space
+
+Hugging Face Spaces fonctionne comme un repo Git classique.
+
+```bash
+# Installer git-lfs si pas déjà fait (pour model.pt)
+git lfs install
+
+# Cloner le repo vide de ton Space (remplace USERNAME et SPACE_NAME)
+git clone https://huggingface.co/spaces/USERNAME/SPACE_NAME
+cd SPACE_NAME
+
+# Copier tous les fichiers de ce dossier dedans :
+# Dockerfile, app.py, bot.py, model.py, requirements.txt, .gitattributes,
+# model.pt, vocab.json
+
+git lfs track "*.pt"
+git add .gitattributes
+git add .
+git commit -m "Déploiement initial Hilal Ai"
+git push
+```
+
+HF va automatiquement builder l'image Docker. Tu peux suivre les logs de
+build et d'exécution dans l'onglet **Logs** de ton Space.
+
+## Étape 4 — Vérifier que le bot tourne
+
+1. Va sur l'URL de ton Space : `https://huggingface.co/spaces/USERNAME/SPACE_NAME`
+2. L'app Flask doit répondre avec `{"bot_started": true, ...}` sur la page
+3. Sur Telegram, cherche ton bot et envoie `/start`
+
+## Étape 5 — Empêcher la mise en veille (keep-alive externe)
+
+L'URL publique de ton Space (format direct, sans iframe) est généralement :
+```
+https://USERNAME-SPACE_NAME.hf.space/ping
+```
+
+### Option A — UptimeRobot (recommandé, zéro code)
+1. Crée un compte gratuit sur https://uptimerobot.com
+2. Ajoute un nouveau monitor de type "HTTP(s)"
+3. URL : `https://USERNAME-SPACE_NAME.hf.space/ping`
+4. Intervalle : 30 minutes (largement suffisant pour rester sous 48h)
+
+### Option B — GitHub Actions (si tu préfères tout garder versionné)
+Crée `.github/workflows/keep-alive.yml` dans un repo GitHub que tu contrôles :
+
+```yaml
+name: Keep Hilal Ai Space Alive
+on:
+  schedule:
+    - cron: '0 */6 * * *'  # toutes les 6 heures
+  workflow_dispatch:
+jobs:
+  ping:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Ping Space
+        run: curl -f https://USERNAME-SPACE_NAME.hf.space/ping
+```
+
+## Variables d'environnement disponibles (Secrets ou Variables du Space)
+
+| Variable             | Défaut         | Description                                  |
+|----------------------|----------------|-----------------------------------------------|
+| TELEGRAM_BOT_TOKEN   | (obligatoire)  | Token du bot Telegram                         |
+| MODEL_PATH           | model.pt       | Chemin vers les poids                         |
+| VOCAB_PATH           | vocab.json     | Chemin vers le vocabulaire char-level         |
+| DEVICE               | cpu (auto)     | "cpu" (les Spaces gratuits n'ont pas de GPU)  |
+| MAX_NEW_TOKENS       | 200            | Nombre max de caractères générés par réponse  |
+| TEMPERATURE          | 0.7            | Température de sampling                       |
+| PORT                 | 7860           | Port du serveur Flask (imposé par HF Spaces)  |
+
+## Diagnostiquer un problème
+
+- **Le build Docker échoue** → onglet "Logs" du Space, section "Build logs"
+- **Le bot ne répond pas sur Telegram mais le Space tourne** → vérifie les
+  "Container logs" pour une erreur de chargement du modèle ou de token manquant
+- **Page d'accueil affiche `bot_started: false`** → le thread du bot a
+  crashé au démarrage (vérifie `model.pt`/`vocab.json` présents et valides)

app.py

@@ -0,0 +1,79 @@
+"""
+app.py
+Point d'entrée du Space Hugging Face (SDK Docker).
+
+Ce fichier fait deux choses en parallèle :
+1. Lance le bot Telegram (bot.py) dans un thread secondaire en polling.
+2. Démarre un serveur web Flask minimal sur le port attendu par HF Spaces
+   (variable d'env PORT, généralement 7860), qui sert uniquement à donner
+   à Hugging Face un "visiteur" actif quand on le ping depuis l'extérieur
+   (UptimeRobot, GitHub Actions, etc.), afin d'éviter la mise en veille
+   automatique après 48h d'inactivité du tier CPU Basic gratuit.
+
+Le serveur web ne sert à RIEN d'autre que ça : il n'expose aucune logique
+métier du bot, juste un endpoint de healthcheck.
+"""
+
+import logging
+import os
+import threading
+
+from flask import Flask, jsonify
+
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    level=logging.INFO,
+)
+logger = logging.getLogger("hilal_ai.app")
+
+app = Flask(__name__)
+
+# État partagé simple pour exposer si le bot a démarré sans erreur
+_bot_status = {"started": False, "error": None}
+
+
+@app.route("/")
+def index():
+    return jsonify(
+        {
+            "service": "Hilal Ai Telegram Bot",
+            "bot_started": _bot_status["started"],
+            "bot_error": _bot_status["error"],
+        }
+    )
+
+
+@app.route("/ping")
+def ping():
+    """Endpoint dédié au keep-alive externe (UptimeRobot, GitHub Actions...).
+    Doit répondre vite et toujours 200 si le process est vivant."""
+    return jsonify({"status": "ok"}), 200
+
+
+def _start_bot_thread():
+    """Lance bot.run_bot_blocking() dans un thread daemon séparé du
+    serveur Flask. Toute exception est capturée pour ne pas tuer le
+    thread silencieusement sans laisser de trace dans les logs HF."""
+    try:
+        import bot  # import différé pour que les logs Flask démarrent d'abord
+        _bot_status["started"] = True
+        bot.run_bot_blocking()
+    except Exception as e:
+        logger.exception("Le bot Telegram a crashé dans son thread.")
+        _bot_status["started"] = False
+        _bot_status["error"] = str(e)
+
+
+def main():
+    bot_thread = threading.Thread(target=_start_bot_thread, daemon=True, name="telegram-bot")
+    bot_thread.start()
+
+    port = int(os.environ.get("PORT", "7860"))
+    logger.info("Serveur web de ping démarré sur le port %d", port)
+    # debug=False et use_reloader=False sont obligatoires ici : le reloader
+    # de Flask relance le process et casserait le thread du bot.
+    app.run(host="0.0.0.0", port=port, debug=False, use_reloader=False)
+
+
+if __name__ == "__main__":
+    main()

bot.py

@@ -0,0 +1,283 @@
+"""
+bot.py
+Bot Telegram pour "Hilal Ai", un LLM Transformer Décodeur entraîné from
+scratch au niveau caractère par LabZero / Suayki.
+
+Prérequis :
+    pip install python-telegram-bot==21.* torch
+
+Fichiers attendus dans le même dossier :
+    - model.pt      (poids entraînés, obligatoire)
+    - vocab.json     (vocabulaire char-level, fortement recommandé)
+    - model.py        (architecture, fourni séparément)
+
+Variables d'environnement (NE JAMAIS mettre le token en clair dans le code) :
+    TELEGRAM_BOT_TOKEN   -> token du bot obtenu via @BotFather
+    MODEL_PATH           -> chemin vers model.pt (défaut: "model.pt")
+    VOCAB_PATH           -> chemin vers vocab.json (défaut: "vocab.json")
+    DEVICE                -> "cpu" ou "cuda" (défaut: auto-détection)
+    MAX_NEW_TOKENS        -> nombre max de caractères générés (défaut: 200)
+    TEMPERATURE           -> température de sampling (défaut: 0.7)
+
+Lancement :
+    export TELEGRAM_BOT_TOKEN="xxxx:yyyy"
+    python bot.py
+"""
+
+import asyncio
+import datetime
+import logging
+import os
+import re
+import sys
+
+import torch
+from telegram import Update
+from telegram.constants import ChatAction
+from telegram.ext import (
+    Application,
+    CommandHandler,
+    ContextTypes,
+    MessageHandler,
+    filters,
+)
+
+from model import BLOCK_SIZE, load_model
+
+# ----------------------------------------------------------------------------
+# Configuration / logging
+# ----------------------------------------------------------------------------
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    level=logging.INFO,
+)
+logger = logging.getLogger("hilal_ai.bot")
+
+TELEGRAM_BOT_TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN")
+if not TELEGRAM_BOT_TOKEN:
+    logger.critical(
+        "TELEGRAM_BOT_TOKEN n'est pas défini. "
+        "Sur HF Spaces : Settings -> Repository secrets -> ajoute TELEGRAM_BOT_TOKEN. "
+        "En local : export TELEGRAM_BOT_TOKEN='ton_token' avant de démarrer."
+    )
+    raise RuntimeError("TELEGRAM_BOT_TOKEN manquant")
+
+MODEL_PATH = os.environ.get("MODEL_PATH", "model.pt")
+VOCAB_PATH = os.environ.get("VOCAB_PATH", "vocab.json")
+DEVICE = os.environ.get("DEVICE") or ("cuda" if torch.cuda.is_available() else "cpu")
+MAX_NEW_TOKENS = int(os.environ.get("MAX_NEW_TOKENS", "200"))
+TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))
+
+# Identité du bot (specs fournies)
+BOT_NAME = "Hilal Ai"
+BOT_SKILLS = "Discuter, Résumer, Traduire, Rédiger"
+DEV_NAME = "LabZero"
+DEV_LINK = "https://t.me"          # à remplacer par le lien réel du canal/contact
+DEV_CHAT_ID = "-1004489211751"
+PROGRAMMER_NAME = "Suayki"
+PROGRAMMER_LINK = "https://t.me"   # à remplacer par le lien réel
+PROGRAMMER_USER_ID = "6074566712"
+
+IDENTITY_TEXT = (
+    f"🤖 *{BOT_NAME}*\n\n"
+    f"Compétences : {BOT_SKILLS}.\n\n"
+    f"Développeur : [{DEV_NAME}]({DEV_LINK})\n"
+    f"Programmeur : [{PROGRAMMER_NAME}]({PROGRAMMER_LINK})"
+)
+
+# Mots-clés déclenchant l'injection de la date/heure serveur dans le prompt
+DATETIME_TRIGGERS = re.compile(
+    r"\b(quelle heure|quelle date|date du jour|heure actuelle|"
+    r"on est quel jour|quel jour sommes[- ]nous|date et heure)\b",
+    re.IGNORECASE,
+)
+
+# Mots-clés déclenchant la réponse d'identité statique plutôt que la génération
+IDENTITY_TRIGGERS = re.compile(
+    r"\b(qui es[- ]tu|qui t'a (créé|developpé|développé|fait)|"
+    r"ton (créateur|développeur|programmeur)|c'est qui ton (créateur|développeur))\b",
+    re.IGNORECASE,
+)
+
+# ----------------------------------------------------------------------------
+# Chargement du modèle (une seule fois, au démarrage du process)
+# ----------------------------------------------------------------------------
+logger.info("Chargement du modèle depuis %s sur %s ...", MODEL_PATH, DEVICE)
+try:
+    model, tokenizer = load_model(MODEL_PATH, VOCAB_PATH, device=DEVICE)
+    logger.info("Modèle chargé avec succès. vocab_size=%d", tokenizer.vocab_size)
+except FileNotFoundError:
+    logger.critical(
+        "Fichier de poids introuvable : %s. Place model.pt à la racine du repo Space "
+        "ou définis la variable MODEL_PATH dans les Secrets/Variables du Space.",
+        MODEL_PATH,
+    )
+    # Pas de sys.exit() ici : sur HF Spaces, ce module tourne dans un thread
+    # secondaire lancé par app.py. Si on tue le process, le serveur web de
+    # ping meurt aussi et HF considère tout le Space comme crashé en boucle.
+    # On préfère garder le serveur de ping vivant pour diagnostiquer via
+    # l'endpoint "/" et les logs du Space.
+    raise
+except Exception:
+    logger.critical("Échec du chargement du modèle.", exc_info=True)
+    raise
+logger.info("Bot prêt à démarrer.")
+
+# Verrou pour éviter les accès concurrents au modèle (un seul forward pass
+# CPU/GPU à la fois, simple et sûr pour un usage VPS mono-instance).
+_generation_lock = asyncio.Lock()
+
+
+# ----------------------------------------------------------------------------
+# Génération de texte
+# ----------------------------------------------------------------------------
+def _build_prompt(user_text: str) -> str:
+    """
+    Construit le prompt final envoyé au modèle. Injecte la date/heure serveur
+    si l'utilisateur la demande explicitement.
+    """
+    if DATETIME_TRIGGERS.search(user_text):
+        now = datetime.datetime.now().strftime("%d/%m/%Y %H:%M")
+        user_text = f"[Date et heure actuelles : {now}]\n{user_text}"
+    return user_text
+
+
+def _safe_generate(prompt: str, max_new_tokens: int, temperature: float) -> str:
+    """
+    Génère une réponse de façon synchrone et sécurisée :
+    - tronque le prompt pour ne garder que les BLOCK_SIZE derniers caractères
+      (le modèle ne peut de toute façon pas voir plus loin que son contexte)
+    - encode/décode avec le tokenizer char-level
+    - retourne uniquement le texte nouvellement généré (sans répéter le prompt)
+    """
+    prompt = prompt[-BLOCK_SIZE:]  # le contexte ne peut pas dépasser BLOCK_SIZE de toute façon
+    encoded = tokenizer.encode(prompt)
+    if not encoded:
+        encoded = tokenizer.encode(" ")
+
+    idx = torch.tensor([encoded], dtype=torch.long, device=DEVICE)
+
+    with torch.no_grad():
+        out = model.generate(
+            idx,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+        )
+
+    generated_ids = out[0].tolist()[len(encoded):]
+    text = tokenizer.decode(generated_ids)
+    return text.strip()
+
+
+async def generate_reply(user_text: str) -> str:
+    """Wrapper async : exécute la génération (bloquante, CPU/GPU-bound) dans
+    un thread séparé pour ne pas bloquer la boucle d'événements du bot, et
+    sérialise les accès au modèle via un verrou."""
+    prompt = _build_prompt(user_text)
+    async with _generation_lock:
+        try:
+            reply = await asyncio.to_thread(
+                _safe_generate, prompt, MAX_NEW_TOKENS, TEMPERATURE
+            )
+        except Exception:
+            logger.exception("Erreur pendant la génération de texte.")
+            return "Désolé, une erreur interne est survenue pendant la génération. Réessaie."
+
+    if not reply:
+        reply = "Je n'ai pas pu générer de réponse claire, peux-tu reformuler ?"
+    return reply
+
+
+# ----------------------------------------------------------------------------
+# Handlers Telegram
+# ----------------------------------------------------------------------------
+async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    await update.message.reply_text(
+        f"Salut ! Je suis {BOT_NAME} 🤖\n"
+        f"Je peux discuter, résumer, traduire et rédiger.\n"
+        f"Envoie-moi simplement un message, ou tape /about pour en savoir plus sur moi."
+    )
+
+
+async def cmd_about(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    await update.message.reply_text(
+        IDENTITY_TEXT,
+        parse_mode="Markdown",
+        disable_web_page_preview=True,
+    )
+
+
+async def cmd_reset(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Optionnel : si tu ajoutes un historique de conversation par utilisateur,
+    cette commande permet de le réinitialiser. Le modèle char-level de base
+    n'a pas de mémoire de conversation par défaut (pas de chat template)."""
+    context.user_data.clear()
+    await update.message.reply_text("Contexte de conversation réinitialisé. ✅")
+
+
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    user_text = update.message.text or ""
+    user_text = user_text.strip()
+
+    if not user_text:
+        return
+
+    if IDENTITY_TRIGGERS.search(user_text):
+        await update.message.reply_text(
+            IDENTITY_TEXT,
+            parse_mode="Markdown",
+            disable_web_page_preview=True,
+        )
+        return
+
+    await context.bot.send_chat_action(
+        chat_id=update.effective_chat.id, action=ChatAction.TYPING
+    )
+
+    reply = await generate_reply(user_text)
+    await update.message.reply_text(reply)
+
+
+async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
+    logger.error("Exception non gérée :", exc_info=context.error)
+    if isinstance(update, Update) and update.effective_message:
+        try:
+            await update.effective_message.reply_text(
+                "Une erreur est survenue, désolé. Réessaie dans un instant."
+            )
+        except Exception:
+            pass
+
+
+# ----------------------------------------------------------------------------
+# Lancement de l'application
+# ----------------------------------------------------------------------------
+def main() -> None:
+    app = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
+
+    app.add_handler(CommandHandler("start", cmd_start))
+    app.add_handler(CommandHandler("about", cmd_about))
+    app.add_handler(CommandHandler("reset", cmd_reset))
+    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
+    app.add_error_handler(error_handler)
+
+    logger.info("Hilal Ai démarre (polling)...")
+    # stop_signals=None : nécessaire car sur HF Spaces ce bot tourne dans un
+    # thread secondaire (le thread principal sert le serveur web de ping),
+    # et les gestionnaires de signaux ne peuvent être enregistrés que dans
+    # le thread principal en Python.
+    app.run_polling(
+        allowed_updates=Update.ALL_TYPES,
+        drop_pending_updates=True,
+        stop_signals=None,
+    )
+
+
+def run_bot_blocking() -> None:
+    """Point d'entrée appelé depuis un thread secondaire par app.py
+    (le serveur web de ping reste dans le thread principal sur HF Spaces)."""
+    main()
+
+
+if __name__ == "__main__":
+    main()

model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:786fc2fadbc913fb374b92811bcc33d4d9266ff64ad94c902a1876b813e74f84
+size 8928571

model.py

@@ -0,0 +1,253 @@
+"""
+model.py
+Architecture du modèle "Hilal Ai" : Transformer Décodeur (style GPT) entraîné
+from scratch au niveau caractère.
+
+Cette architecture DOIT correspondre exactement à celle utilisée pendant
+l'entraînement sur Colab pour que model.load_state_dict(...) fonctionne.
+Si tu as modifié l'architecture sur Colab (dropout, bias, etc.), répercute
+les mêmes changements ici.
+"""
+
+import json
+import logging
+import os
+
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+
+logger = logging.getLogger("hilal_ai.model")
+
+# ----------------------------------------------------------------------------
+# Hyperparamètres (doivent matcher l'entraînement Colab)
+# ----------------------------------------------------------------------------
+BLOCK_SIZE = 128
+N_EMBD = 192
+N_HEAD = 6
+N_LAYER = 4
+DROPOUT = 0.1  # identique à l'entraînement Colab. Sans effet en model.eval()
+               # (le dropout est désactivé automatiquement en inference),
+               # mais gardé identique pour la cohérence de l'architecture.
+
+
+# ----------------------------------------------------------------------------
+# Architecture
+# ----------------------------------------------------------------------------
+class Head(nn.Module):
+    """Une tête d'auto-attention causale."""
+
+    def __init__(self, head_size):
+        super().__init__()
+        self.key = nn.Linear(N_EMBD, head_size, bias=False)
+        self.query = nn.Linear(N_EMBD, head_size, bias=False)
+        self.value = nn.Linear(N_EMBD, head_size, bias=False)
+        self.register_buffer("tril", torch.tril(torch.ones(BLOCK_SIZE, BLOCK_SIZE)))
+        self.dropout = nn.Dropout(DROPOUT)
+
+    def forward(self, x):
+        B, T, C = x.shape
+        k = self.key(x)
+        q = self.query(x)
+        wei = q @ k.transpose(-2, -1) * (k.shape[-1] ** -0.5)
+        wei = wei.masked_fill(self.tril[:T, :T] == 0, float("-inf"))
+        wei = F.softmax(wei, dim=-1)
+        wei = self.dropout(wei)
+        v = self.value(x)
+        out = wei @ v
+        return out
+
+
+class MultiHeadAttention(nn.Module):
+    """Plusieurs têtes d'attention en parallèle."""
+
+    def __init__(self, num_heads, head_size):
+        super().__init__()
+        self.heads = nn.ModuleList([Head(head_size) for _ in range(num_heads)])
+        self.proj = nn.Linear(N_EMBD, N_EMBD)
+        self.dropout = nn.Dropout(DROPOUT)
+
+    def forward(self, x):
+        out = torch.cat([h(x) for h in self.heads], dim=-1)
+        out = self.dropout(self.proj(out))
+        return out
+
+
+class FeedForward(nn.Module):
+    """Simple couche feed-forward (MLP) avec activation GELU."""
+
+    def __init__(self, n_embd):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(n_embd, 4 * n_embd),
+            nn.GELU(),
+            nn.Linear(4 * n_embd, n_embd),
+            nn.Dropout(DROPOUT),
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+class Block(nn.Module):
+    """Bloc Transformer : communication (attention) puis calcul (FFN)."""
+
+    def __init__(self, n_embd, n_head):
+        super().__init__()
+        head_size = n_embd // n_head
+        self.sa = MultiHeadAttention(n_head, head_size)
+        self.ffwd = FeedForward(n_embd)
+        self.ln1 = nn.LayerNorm(n_embd)
+        self.ln2 = nn.LayerNorm(n_embd)
+
+    def forward(self, x):
+        x = x + self.sa(self.ln1(x))
+        x = x + self.ffwd(self.ln2(x))
+        return x
+
+
+class MiniGPT(nn.Module):
+    """Modèle de langage Transformer Décodeur, niveau caractère."""
+
+    def __init__(self, vocab_size):
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.token_embedding = nn.Embedding(vocab_size, N_EMBD)
+        self.position_embedding = nn.Embedding(BLOCK_SIZE, N_EMBD)
+        self.blocks = nn.Sequential(*[Block(N_EMBD, N_HEAD) for _ in range(N_LAYER)])
+        self.ln_f = nn.LayerNorm(N_EMBD)
+        self.lm_head = nn.Linear(N_EMBD, vocab_size)
+
+    def forward(self, idx, targets=None):
+        B, T = idx.shape
+        tok_emb = self.token_embedding(idx)
+        pos_emb = self.position_embedding(
+            torch.arange(T, device=idx.device)
+        )
+        x = tok_emb + pos_emb
+        x = self.blocks(x)
+        x = self.ln_f(x)
+        logits = self.lm_head(x)
+
+        loss = None
+        if targets is not None:
+            B, T, C = logits.shape
+            logits_flat = logits.view(B * T, C)
+            targets_flat = targets.view(B * T)
+            loss = F.cross_entropy(logits_flat, targets_flat)
+
+        return logits, loss
+
+    @torch.no_grad()
+    def generate(self, idx, max_new_tokens, temperature=0.7, top_k=None):
+        """
+        Génère max_new_tokens nouveaux caractères à partir du contexte idx.
+        idx : tensor (B, T) d'indices déjà encodés.
+        Le contexte est tronqué à BLOCK_SIZE à chaque étape (fenêtre glissante).
+        """
+        self.eval()
+        for _ in range(max_new_tokens):
+            idx_cond = idx[:, -BLOCK_SIZE:]
+            logits, _ = self(idx_cond)
+            logits = logits[:, -1, :] / max(temperature, 1e-6)
+
+            if top_k is not None:
+                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
+                logits[logits < v[:, [-1]]] = float("-inf")
+
+            probs = F.softmax(logits, dim=-1)
+            idx_next = torch.multinomial(probs, num_samples=1)
+            idx = torch.cat((idx, idx_next), dim=1)
+        return idx
+
+
+# ----------------------------------------------------------------------------
+# Tokenizer niveau caractère
+# ----------------------------------------------------------------------------
+class CharTokenizer:
+    """
+    Tokenizer char-level. Le mapping stoi/itos DOIT être identique à celui
+    utilisé pendant l'entraînement sur Colab, sinon le modèle produira du
+    charabia (les poids des embeddings ne correspondront pas aux bons
+    caractères).
+
+    Stratégie recommandée :
+    1. Pendant l'entraînement sur Colab, sauvegarde ton vocabulaire :
+           import json
+           with open("vocab.json", "w", encoding="utf-8") as f:
+               json.dump({"chars": sorted(list(set(text)))}, f, ensure_ascii=False)
+       puis télécharge vocab.json à côté de model.pt.
+    2. Place vocab.json dans le même dossier que ce script.
+
+    Si vocab.json est absent, un jeu de caractères par défaut est utilisé
+    en secours (lettres FR/EN, chiffres, ponctuation courante). Dans ce cas,
+    la cohérence avec les poids entraînés n'est PAS garantie.
+    """
+
+    DEFAULT_CHARS = (
+        "\n !\"#$%&'()*+,-./0123456789:;<=>?@"
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`"
+        "abcdefghijklmnopqrstuvwxyz{|}~"
+        "àâäéèêëïîôöùûüçÀÂÄÉÈÊËÏÎÔÖÙÛÜÇœŒ«»…–—’"
+    )
+
+    def __init__(self, vocab_path="vocab.json"):
+        chars = None
+        if vocab_path and os.path.exists(vocab_path):
+            try:
+                with open(vocab_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                chars = data["chars"]
+                logger.info("Vocabulaire chargé depuis %s (%d caractères).", vocab_path, len(chars))
+            except Exception as e:
+                logger.warning("Impossible de lire %s (%s). Utilisation du vocabulaire par défaut.", vocab_path, e)
+
+        if chars is None:
+            chars = sorted(set(self.DEFAULT_CHARS))
+            logger.warning(
+                "AUCUN vocab.json trouvé : utilisation d'un vocabulaire par défaut (%d caractères). "
+                "Ceci ne correspondra probablement PAS exactement aux poids entraînés sur Colab.",
+                len(chars),
+            )
+
+        self.chars = chars
+        self.vocab_size = len(chars)
+        self.stoi = {ch: i for i, ch in enumerate(chars)}
+        self.itos = {i: ch for i, ch in enumerate(chars)}
+        # Caractère de remplacement pour tout caractère inconnu en entrée
+        self.unk_char = chars[0]
+
+    def encode(self, s: str):
+        return [self.stoi.get(c, self.stoi.get(self.unk_char, 0)) for c in s]
+
+    def decode(self, indices) -> str:
+        return "".join(self.itos.get(int(i), "") for i in indices)
+
+
+# ----------------------------------------------------------------------------
+# Chargement du modèle complet
+# ----------------------------------------------------------------------------
+def load_model(model_path: str, vocab_path: str = "vocab.json", device: str = "cpu"):
+    """
+    Instancie le tokenizer + le modèle, charge les poids depuis model_path,
+    et renvoie (model, tokenizer) prêts pour l'inférence.
+    """
+    tokenizer = CharTokenizer(vocab_path)
+    model = MiniGPT(vocab_size=tokenizer.vocab_size)
+
+    state_dict = torch.load(model_path, map_location=device)
+
+    # Selon comment le modèle a été sauvegardé sur Colab (state_dict pur,
+    # ou checkpoint dict contenant 'model_state_dict'), on gère les deux cas.
+    if isinstance(state_dict, dict) and "model_state_dict" in state_dict:
+        state_dict = state_dict["model_state_dict"]
+
+    missing, unexpected = model.load_state_dict(state_dict, strict=False)
+    if missing:
+        logger.warning("Clés manquantes lors du chargement des poids : %s", missing)
+    if unexpected:
+        logger.warning("Clés inattendues lors du chargement des poids : %s", unexpected)
+
+    model.to(device)
+    model.eval()
+    return model, tokenizer

requirements.txt

@@ -0,0 +1,3 @@
+python-telegram-bot==21.4
+torch>=2.0
+flask>=3.0

vocab.json

@@ -0,0 +1 @@
+{"chars": ["\n", " ", "!", "'", "(", ")", ",", "-", ".", "/", "0", "1", "2", "4", "5", "6", "7", "8", "9", ":", "?", "A", "B", "C", "D", "H", "I", "J", "L", "N", "O", "P", "Q", "R", "S", "T", "U", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "x", "y", "z", "à", "ç", "è", "é"]}