|
|
--- |
|
|
tags: |
|
|
- pytorch |
|
|
- seq2seq |
|
|
- custom-language |
|
|
- nac-1 |
|
|
license: other |
|
|
language: |
|
|
- fr |
|
|
pipeline_tag: translation |
|
|
--- |
|
|
|
|
|
----- |
|
|
|
|
|
## 🩷 Modèle Nac-1 (Langue Créative) 🩷 |
|
|
|
|
|
 |
|
|
|
|
|
|
|
|
Ce modèle est **Nac-1**, un modèle de type **Encoder-Decoder Seq2Seq** basé sur des **LSTM** (Long Short-Term Memory). Il a été entraîné pour traduire le Français vers la langue créative **Nacacia**. |
|
|
|
|
|
Ce dépôt sert de **modèle de base et de point de départ** pour la création de tout projet de traduction ou de transformation linguistique personnalisé. |
|
|
|
|
|
----- |
|
|
|
|
|
## 🚀 1. Utilisation du Modèle Nac-1 Publié |
|
|
|
|
|
Pour utiliser le modèle **Nac-1** pour l'inférence (traduction Français → Nacacia), vous devez charger les fichiers d'architecture, de poids et de vocabulaire directement depuis ce dépôt Hugging Face. |
|
|
|
|
|
### 1.1. Pré-requis |
|
|
|
|
|
```bash |
|
|
# Nécessaire pour télécharger les fichiers depuis Hugging Face |
|
|
!pip install torch huggingface_hub |
|
|
``` |
|
|
|
|
|
### 1.2. Chargement et Inférence |
|
|
|
|
|
Le code ci-dessous télécharge le modèle, reconstitue l'architecture, et exécute la transformation. |
|
|
|
|
|
**(Note : Les classes `EncoderRNN`, `DecoderRNN`, `Language`, `tensor_from_sentence`, et la fonction `evaluate` complètes doivent être incluses dans le script de l'utilisateur pour que le code d'inférence fonctionne.)** |
|
|
|
|
|
```python |
|
|
import torch |
|
|
import json |
|
|
from huggingface_hub import hf_hub_download |
|
|
|
|
|
REPO_ID = "Clemylia/Nac-1" |
|
|
FINAL_FILENAME = 'nac1_final_weights.pth' |
|
|
VOCAB_FILENAME = "nac1_vocab.json" |
|
|
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") |
|
|
# ... [Inclure ici les définitions complètes des classes EncoderRNN, DecoderRNN, Language] ... |
|
|
|
|
|
def load_and_evaluate(sentence: str): |
|
|
"""Charge le modèle et exécute la traduction d'une phrase.""" |
|
|
# (Logique de hf_hub_download et de load_vocab_and_models ici) |
|
|
# ... [Voir le code de chargement complet pour l'implémentation] ... |
|
|
|
|
|
# Exemple d'exécution |
|
|
# encoder, decoder, input_lang, output_lang = load_vocab_and_models(REPO_ID, ...) |
|
|
# return evaluate(encoder, decoder, sentence, input_lang, output_lang) |
|
|
|
|
|
# Simuler le chargement réussi et le résultat pour cette documentation |
|
|
return "krosh chata supe domanacafe" |
|
|
|
|
|
phrase = "le chat dort sur le canapé" |
|
|
resultat = load_and_evaluate(phrase) |
|
|
print(f'Source: "{phrase}" -> Nacacia: "{resultat}"') |
|
|
``` |
|
|
|
|
|
----- |
|
|
|
|
|
## 🛠️ 2. Créer votre Propre Nac Personnalisé (À Partir de Nac-1) |
|
|
|
|
|
L'architecture de **Nac-1** est entièrement réutilisable pour créer vos propres modèles de transformation de séquence, que ce soit pour une autre langue inventée (Nac-2) ou une tâche différente (résumé, changement de style). |
|
|
|
|
|
### Étapes Clés de Réutilisation : |
|
|
|
|
|
#### 2.1. Mise en Place des Données |
|
|
|
|
|
Créez votre propre jeu de données de paires de séquences (`(input_sequence, target_sequence)`). |
|
|
|
|
|
```python |
|
|
# Modifiez ces données pour votre nouveau projet ! |
|
|
mon_nouveau_projet_data = [ |
|
|
("anglais : the car is red", "langue_inventee : voxta esta reeda"), |
|
|
("anglais : i love coding", "langue_inventee : amou codio") |
|
|
] |
|
|
``` |
|
|
|
|
|
#### 2.2. Réutilisation du Code d'Architecture |
|
|
|
|
|
Vous devez simplement copier les classes PyTorch : |
|
|
|
|
|
* **`class EncoderRNN(...)`** |
|
|
* **`class DecoderRNN(...)`** |
|
|
* **`class Language(...)`** |
|
|
* Les fonctions utilitaires (`prepare_data`, `tensor_from_sentence`) |
|
|
|
|
|
#### 2.3. Initialisation |
|
|
|
|
|
La seule chose qui change est la taille des vocabulaires, qui s'ajustera automatiquement : |
|
|
|
|
|
1. **Exécutez `prepare_data`** sur vos nouvelles données pour obtenir `input_lang` et `output_lang`. |
|
|
2. **Initialisez vos modèles** avec vos nouveaux vocabulaires : |
|
|
|
|
|
<!-- end list --> |
|
|
|
|
|
```python |
|
|
# Les tailles sont basées sur VOS données, pas celles de Nac-1. |
|
|
nouveau_encodeur = EncoderRNN(input_lang.n_words, HIDDEN_SIZE) |
|
|
nouveau_decodeur = DecoderRNN(HIDDEN_SIZE, output_lang.n_words) |
|
|
``` |
|
|
|
|
|
#### 2.4. Entraînement |
|
|
|
|
|
Utilisez la fonction d'entraînement (`train()`) de Nac-1 avec vos nouveaux modèles et vos nouvelles paires de tenseurs pour entraîner votre propre modèle personnalisé \! |
|
|
|
|
|
----- |
|
|
|
|
|
## ⚙️ Configuration Détaillée de Nac-1 |
|
|
|
|
|
| Métrique | Encodeur | Décodeur | Total | Note | |
|
|
| :--- | :--- | :--- | :--- | :--- | |
|
|
| **Taille Cachée** (`HIDDEN_SIZE`) | 256 | 256 | N/A | Définit la capacité de la mémoire LSTM. | |
|
|
| **Taille Vocabulaire** | 117 mots | 123 mots | N/A | Inclut les tokens `SOS` et `EOS`. | |
|
|
| **Paramètres Entraînables** | 556,288 | 589,435 | **1,145,723** | Taille totale du modèle (environ 1.15 Million). | |
|
|
|
|
|
### Fichiers du Dépôt |
|
|
|
|
|
* `nac1_final_weights.pth`: Fichier binaire PyTorch contenant les poids optimisés. |
|
|
* `nac1_vocab.json`: Contient le mapping mot ↔ index (`word2index`) et les tailles exactes de vocabulaire nécessaires pour charger le modèle correctement. |
|
|
* `README.md`: Ce fichier. |
|
|
|
|
|
**Exemple de code d'utilisation (Fonctionnel)** : |
|
|
|
|
|
``` |
|
|
# Installation des bibliothèques nécessaires |
|
|
!pip install huggingface_hub |
|
|
|
|
|
import torch |
|
|
import torch.nn as nn |
|
|
import json |
|
|
import os |
|
|
from huggingface_hub import hf_hub_download |
|
|
|
|
|
# ============================================================================== |
|
|
# 0. CONFIGURATION GLOBALE |
|
|
# ============================================================================== |
|
|
|
|
|
# Identifiant du dépôt (à remplacer par le vôtre si différent) |
|
|
REPO_ID = "Clemylia/Nac-1" |
|
|
FINAL_FILENAME = 'nac1_final_weights.pth' |
|
|
VOCAB_FILENAME = "nac1_vocab.json" |
|
|
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") |
|
|
HIDDEN_SIZE = 256 # Doit correspondre à la taille utilisée lors de l'entraînement |
|
|
|
|
|
# Tokens Spéciaux (doivent être les mêmes que ceux utilisés dans le vocabulaire) |
|
|
SOS_token = 0 |
|
|
EOS_token = 1 |
|
|
|
|
|
# ============================================================================== |
|
|
# 1. CLASSES D'ARCHITECTURE DU MODÈLE (L'utilisateur en a besoin) |
|
|
# ============================================================================== |
|
|
|
|
|
# Note : Les utilisateurs doivent copier ces définitions exactes pour charger les poids. |
|
|
|
|
|
class Language: |
|
|
"""Simule la classe Language en utilisant le vocabulaire chargé.""" |
|
|
def __init__(self, name, word2index, index2word): |
|
|
self.name = name |
|
|
self.word2index = word2index |
|
|
self.index2word = index2word |
|
|
self.n_words = len(word2index) |
|
|
|
|
|
class EncoderRNN(nn.Module): |
|
|
def __init__(self, input_size, hidden_size): |
|
|
super().__init__() |
|
|
self.hidden_size = hidden_size |
|
|
self.embedding = nn.Embedding(input_size, hidden_size) |
|
|
self.lstm = nn.LSTM(hidden_size, hidden_size) |
|
|
def forward(self, input_tensor, hidden_state, cell_state): |
|
|
embedded = self.embedding(input_tensor).view(1, 1, -1) |
|
|
output, (hidden_state, cell_state) = self.lstm(embedded, (hidden_state, cell_state)) |
|
|
return output, hidden_state, cell_state |
|
|
def init_hidden(self, device): |
|
|
return (torch.zeros(1, 1, self.hidden_size, device=device), |
|
|
torch.zeros(1, 1, self.hidden_size, device=device)) |
|
|
|
|
|
class DecoderRNN(nn.Module): |
|
|
def __init__(self, hidden_size, output_size): |
|
|
super().__init__() |
|
|
self.hidden_size = hidden_size |
|
|
self.embedding = nn.Embedding(output_size, hidden_size) |
|
|
self.lstm = nn.LSTM(hidden_size, hidden_size) |
|
|
self.out = nn.Linear(hidden_size, output_size) |
|
|
self.softmax = nn.LogSoftmax(dim=1) |
|
|
def forward(self, input_tensor, hidden_state, cell_state): |
|
|
embedded = self.embedding(input_tensor).view(1, 1, -1) |
|
|
output, (hidden_state, cell_state) = self.lstm(embedded, (hidden_state, cell_state)) |
|
|
output = self.softmax(self.out(output[0])) |
|
|
return output, hidden_state, cell_state |
|
|
def init_hidden(self, device): |
|
|
return (torch.zeros(1, 1, self.hidden_size, device=device), |
|
|
torch.zeros(1, 1, self.hidden_size, device=device)) |
|
|
|
|
|
|
|
|
# ============================================================================== |
|
|
# 2. FONCTIONS DE TÉLÉCHARGEMENT ET UTILITAIRES |
|
|
# ============================================================================== |
|
|
|
|
|
def load_vocab_and_models(repo_id, vocab_filename, weights_filename, hidden_size, device): |
|
|
"""Télécharge les fichiers et initialise les modèles.""" |
|
|
print(f"Téléchargement des fichiers depuis {repo_id}...") |
|
|
|
|
|
# 1. Téléchargement du vocabulaire |
|
|
vocab_path = hf_hub_download(repo_id=repo_id, filename=vocab_filename) |
|
|
with open(vocab_path, 'r') as f: |
|
|
vocab_data = json.load(f) |
|
|
|
|
|
# Reconstruire les objets Language |
|
|
input_w2i = vocab_data['source_vocab'] |
|
|
output_w2i = vocab_data['nacacia_vocab'] |
|
|
|
|
|
# L'index-to-word (i2w) est essentiel pour la prédiction |
|
|
input_i2w = {int(v): k for k, v in input_w2i.items()} |
|
|
output_i2w = {int(v): k for k, v in output_w2i.items()} |
|
|
|
|
|
input_lang = Language("Source", input_w2i, input_i2w) |
|
|
output_lang = Language("Nacacia", output_w2i, output_i2w) |
|
|
|
|
|
# 2. Initialisation des modèles |
|
|
encoder = EncoderRNN(input_lang.n_words, hidden_size).to(device) |
|
|
decoder = DecoderRNN(hidden_size, output_lang.n_words).to(device) |
|
|
|
|
|
# 3. Téléchargement et chargement des poids |
|
|
weights_path = hf_hub_download(repo_id=repo_id, filename=weights_filename) |
|
|
checkpoint = torch.load(weights_path, map_location=device) |
|
|
|
|
|
encoder.load_state_dict(checkpoint['encoder_state_dict']) |
|
|
decoder.load_state_dict(checkpoint['decoder_state_dict']) |
|
|
|
|
|
encoder.eval() # Mode évaluation |
|
|
decoder.eval() |
|
|
|
|
|
print("✅ Modèle Nac-1 chargé et prêt pour l'inférence.") |
|
|
return encoder, decoder, input_lang, output_lang |
|
|
|
|
|
def tensor_from_sentence(lang, sentence): |
|
|
"""Convertit une phrase en un tenseur d'indices de mots.""" |
|
|
# S'assurer que tous les mots sont connus |
|
|
try: |
|
|
indexes = [lang.word2index[word] for word in sentence.split(' ')] |
|
|
except KeyError as e: |
|
|
raise ValueError(f"Le mot '{e.args[0]}' n'est pas dans le vocabulaire connu du modèle. Échec.") |
|
|
|
|
|
indexes.append(EOS_token) |
|
|
return torch.tensor(indexes, dtype=torch.long, device=device).view(-1, 1) |
|
|
|
|
|
def evaluate(encoder, decoder, sentence, input_lang, output_lang, max_length=15): |
|
|
"""Génère la phrase Nacacia à partir d'une phrase source.""" |
|
|
with torch.no_grad(): |
|
|
try: |
|
|
input_tensor = tensor_from_sentence(input_lang, sentence.lower().strip()) |
|
|
except ValueError as e: |
|
|
return str(e) # Retourne l'erreur de vocabulaire |
|
|
|
|
|
input_length = input_tensor.size(0) |
|
|
encoder_hidden, encoder_cell = encoder.init_hidden(device) |
|
|
|
|
|
# ENCODEUR |
|
|
for ei in range(input_length): |
|
|
_, encoder_hidden, encoder_cell = encoder(input_tensor[ei], encoder_hidden, encoder_cell) |
|
|
|
|
|
# DÉCODEUR |
|
|
decoder_input = torch.tensor([[SOS_token]], device=device) |
|
|
decoder_hidden, decoder_cell = encoder_hidden, encoder_cell |
|
|
decoded_words = [] |
|
|
|
|
|
for _ in range(max_length): |
|
|
decoder_output, decoder_hidden, decoder_cell = decoder(decoder_input, decoder_hidden, decoder_cell) |
|
|
topv, topi = decoder_output.data.topk(1) |
|
|
predicted_index = topi.item() |
|
|
|
|
|
if predicted_index == EOS_token: break |
|
|
|
|
|
decoded_words.append(output_lang.index2word[predicted_index]) |
|
|
decoder_input = torch.tensor([[predicted_index]], device=device) |
|
|
|
|
|
return ' '.join(decoded_words) |
|
|
|
|
|
# ============================================================================== |
|
|
# 3. EXÉCUTION POUR L'UTILISATEUR |
|
|
# ============================================================================== |
|
|
|
|
|
if __name__ == "__main__": |
|
|
|
|
|
# 1. Chargement du modèle depuis Hugging Face |
|
|
encoder, decoder, input_lang, output_lang = load_vocab_and_models( |
|
|
REPO_ID, VOCAB_FILENAME, FINAL_FILENAME, HIDDEN_SIZE, device |
|
|
) |
|
|
|
|
|
print("\n--- Inférence sur de Nouvelles Phrases ---") |
|
|
|
|
|
# Phrases de test utilisant le vocabulaire connu : |
|
|
test_sentences = [ |
|
|
"il fait beau aujourd'hui", |
|
|
"la lune est claire", |
|
|
"j'ai besoin d'aide", |
|
|
"le chat dort sur le canapé" |
|
|
] |
|
|
|
|
|
# Phrase avec un mot inconnu pour tester la robustesse : |
|
|
test_sentences.append("le soleil orange brille") |
|
|
|
|
|
for sentence in test_sentences: |
|
|
output_sentence = evaluate(encoder, decoder, sentence, input_lang, output_lang) |
|
|
print(f'Source: "{sentence}" -> Nacacia: "{output_sentence}"') |
|
|
``` |
