update

app.py

@@ -2,65 +2,70 @@ import gradio as gr
 import torch
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 
-# 1) Load both model & tokenizer from your fine-tuned checkpoint
-MODEL_ID = "Mamadou2727/Feriji_model"
-tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
-model     = AutoModelForSeq2SeqLM.from_pretrained(MODEL_ID)
+# 1) Load the base M2M100 tokenizer (avoids the “non-consecutive added token” error)
+BASE_MODEL = "facebook/m2m100_418M"
+tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
 
-# 2) Move model to the right device
+# 2) Load your fine-tuned French⇄Zarma model
+FINETUNED_MODEL = "Mamadou2727/Feriji_model"
+model = AutoModelForSeq2SeqLM.from_pretrained(FINETUNED_MODEL)
+
+# 3) Ensure the model’s embedding matrix matches the tokenizer vocab size
+model.resize_token_embeddings(len(tokenizer))
+
+# 4) Move model to GPU if available
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 model.to(device)
 model.eval()
 
-# 3) Use ISO 639-3 for Zarma
+# 5) Correct ISO 639-3 code for Zarma (“dje”)
 LANG_CODES = {
     "French": "fr",
     "Zarma":  "yo"
 }
 
-def translate(text, num_return_sequences):
-    src = LANG_CODES["French"]
-    tgt = LANG_CODES["Zarma"]
-
-    # tell the tokenizer which languages we're using
-    tokenizer.src_lang = src
-    tokenizer.tgt_lang = tgt
+def translate(text: str, num_seqs: int):
+    # set source & target language codes
+    tokenizer.src_lang = LANG_CODES["French"]
+    tokenizer.tgt_lang = LANG_CODES["Zarma"]
 
-    # tokenize & move inputs to device
+    # tokenize & move to device
     inputs = tokenizer(text, return_tensors="pt", padding=True).to(device)
 
-    # generate
+    # generate translations
     with torch.no_grad():
         outputs = model.generate(
             **inputs,
-            forced_bos_token_id=tokenizer.lang_code_to_id[tgt],
-            num_beams=num_return_sequences,
-            num_return_sequences=num_return_sequences,
-            length_penalty=1.0,      # more standard for translation
+            forced_bos_token_id=tokenizer.lang_code_to_id[LANG_CODES["Zarma"]],
+            num_beams=num_seqs,
+            num_return_sequences=num_seqs,
+            length_penalty=1.0,
             early_stopping=True
         )
 
-    # decode & join
+    # decode & join multiple hypotheses
     translations = tokenizer.batch_decode(outputs, skip_special_tokens=True)
     return "\n\n".join(translations)
 
-
-# 4) Gradio interface
-markdown = r"""
-# FERIJI Translator: French ⇄ Zarma  
-*Beta version – academic & research use only.*
-"""
-
+# 6) Build Gradio app
 with gr.Blocks() as app:
-    gr.Markdown(markdown)
+    gr.Markdown(
+        """
+        # FERIJI Translator: French ⇄ Zarma  
+        *Beta version – academic & research use only.*
+        """
+    )
 
     with gr.Row():
         inp = gr.Textbox(lines=7, label="Français / French")
-        k   = gr.Slider(1, 5, value=1, step=1, label="Nombre de séquences retournées")
+        beams = gr.Slider(
+            label="Nombre de séquences retournées",
+            minimum=1, maximum=5, value=1, step=1
+        )
         out = gr.Textbox(lines=7, label="Zarma")
 
     btn = gr.Button("Traduire")
-    btn.click(translate, inputs=[inp, k], outputs=out, api_name="predict")
+    btn.click(fn=translate, inputs=[inp, beams], outputs=out, api_name="predict")
 
-# On HF Spaces you can just launch without share=True
+# On HF Spaces you don’t need share=True
 app.launch()