La communication interlangues est devenue cruciale dans un monde globalisé. Les solutions de traduction traditionnelles présentent souvent des limites en termes de latence, de coût et de compréhension contextuelle, notamment pour les applications interactives nécessitant une réponse immédiate.

La série de modèles de traduction open source HY-MT1.5, développée par l'équipe Tencent Hunyuan, offre une alternative performante. Cette série inclut deux versions principales :

• HY-MT1.5-1.8B (1,8 milliard de paramètres) : optimisé pour le déploiement sur des appareils périphériques, offrant une latence réduite.
• HY-MT1.5-7B (7 milliards de paramètres) : conçu pour une traduction de haute précision dans le cloud.

Malgré sa taille réduite, le modèle 1.8B atteint environ 78% sur l'évaluation FLORES-200, avec un temps de réponse moyen de 0,18 seconde par requête.

Caractéristiques techniques du modèle

Le modèle supporte la traduction entre 33 langues majeures, incluant des langues peu courantes comme le tchèque, l'estonian ou l'islandais, ainsi que certaines langues régionales comme le tibétain ou le ouïghour. Ses fonctionnalités clés comprennent :

• Gestion de la terminologie : possibilité de définir des correspondances lexicales personnalisées pour garantir la précision des termes techniques.
• Traduction contextuelle : prise en charge d'une fenêtre contextuelle multiple pour réduire les ambiguïtés.
• Conservation du format : préservation de la structure HTML, Markdown ou numérotée du texte source.

Déploiement via conteneur Docker

Le modèle est distribué sous forme d'image Docker préconfigurée. Les prérequis matériels sont :

• Un GPU NVIDIA avec au moins 24 Go de mémoire (comme un RTX 4090D).
• L'environnement d'exécution vLLM intégré.

Pour lancer le service, exécutez la commande suivante :

docker run -d --gpus all -p 8080:80 --name hy-mt15 registry.tencent.com/hunyuan/hy-mt1.5-1.8b:v1.0

L'initialisation automatique du modèle prend généralement 2 à 3 minutes. Une interface web accessible via un navigateur permet de tester les traductions, de sélectionner les langues et de charger des glossaires au format CSV.

Intégration programmatique via API REST

Le service expose plusieurs endpoints HTTP :

Exemple de corps de requête JSON pour une traduction :

{
  "source_lang": "fr",
  "target_lang": "de",
  "text": "Bonjour, ceci est un exemple.",
  "context": ["Texte précédent"],
  "preserve_format": true
}

Voici une implémentation Python pour interagir avec l'API :

import requests

class TranslationService:
    def __init__(self, endpoint="http://localhost:8080"):
        self.url = endpoint

    def configure_glossary(self, mapping):
        response = requests.post(f"{self.url}/set_terms", json={"terms": mapping})
        return response.status_code == 200

    def single_translation(self, text, source="fr", target="de", context_list=None):
        payload = {
            "source_lang": source,
            "target_lang": target,
            "text": text,
            "context": context_list or [],
            "preserve_format": True
        }
        response = requests.post(f"{self.url}/translate", json=payload)
        data = response.json()
        return data.get("translated_text", "")

    def batch_translation(self, texts_list, source="fr", target="de"):
        payload = {"source_lang": source, "target_lang": target, "texts": texts_list}
        response = requests.post(f"{self.url}/translate_batch", json=payload)
        return response.json().get("results", [])

# Utilisation
service = TranslationService()
service.configure_glossary({"intelligence artificielle": "künstliche Intelligenz"})
traduction = service.single_translation("L'intelligence artificielle évolue rapidement.", "fr", "de")
print(traduction)

textes = ["Première phrase.", "Deuxième phrase.", "Troisième phrase."]
resultats = service.batch_translation(textes, "fr", "de")
for res in resultats:
    print(res)

Mesures de performence et optimisation

Sur un GPU RTX 4090D, avec une taille de lot de 8, les métriques observées sont :

• Temps de réponse moyen : 0,18 seconde
• Débit : 45 requêtes par seconde
• Mémoire GPU utilisée : 18,3 Go
• Connexions simultanées gérées : jusqu'à 100

Pour améliorer les performances dans des environnements de production :

• Pour les langues avec peu de ressources, ajouter un préfixe explicite comme « Traduire en islandais : » avant le texte.
• Utiliser un cache (comme Redis) pour les phrases fréquentes afin de réduire la charge.
• Implémenter une file d'attente asynchrone (Celery, RabbitMQ) pour découpler la réception des requêtes de leur traitement.
• Envisager une quantification du modèle en INT8 via TensorRT-LLM pour réduire l'empreinte mémoire et accélérer l'inférence.

Considérations pour un déploiement en milieu professionnel

Afin de garantir la sécurité et la stabilité, il est recommandé d'intégrer :

• Un mécanisme d'authentification (comme JWT).
• Un contrôle du débit des requêtes (par exemple, 100 requêtes par minute par adresse IP).
• Un module de filtrage des contenus sensibles.

L'adaptation sur des plateformes de calcul nationales (comme les NPU de type MXMACA) permet également d'obtenir une solution entièrement maîtrisée.

Le modèle HY-MT1.5-1.8B équilibre efficacement qualité de traduction et rapidité d'exécution. Sa légèreté en fait un candidat idéal pour les systèmes de traduction en temps réel intégrés dans des applications web, des services de messagerie ou des plateformes de support client multilingue.