Tongue : identification de langue sur l'appareil
Une identification de langue sur l'appareil qui lit un court fragment de texte et nomme sa langue, parmi 84 langues, en quelques dizaines de microsecondes.
Tongue lit un mot, une expression ou une phrase et renvoie la langue dans laquelle elle est écrite, de "kann ich das haben" en allemand à "안녕하세요" en coréen. Il est réglé pour le texte court, champs de recherche, messages de chat, saisie au clavier : le cas le plus difficile et le plus utile de la détection de langue sur un appareil.
Deux étapes font le travail. Un routeur d'écritures sans aucun paramètre tranche le texte dont l'écriture n'appartient qu'à une seule langue : le hangul, le grec, le thaï et 22 autres sont décidés d'emblée, sans modèle. Pour les écritures partagées, des n-grammes de caractères hachés alimentent un modèle int8 de 2 MB. Pas de tokenizer, pas de fichier de vocabulaire, pas de runtime d'inférence ; et quand une saisie courte est réellement ambiguë, Tongue dit qu'il n'est pas sûr au lieu de deviner.
Démo
Performances
Avec 2 MB, il tient tête à des détecteurs jusqu'à 130 fois plus gros.
Mesuré sur les poids int8 livrés, sur trois benchmarks publics, les autres détecteurs étant exécutés sur les mêmes lignes et sous-ensembles de langues. Tableaux complets et modes d'échec sur la fiche du modèle.
Cas d'usage
Router le texte par langue
Choisir le bon modèle de traduction, l'analyseur ou la file de support dès les premiers mots saisis, entièrement sur l'appareil.
Claviers et saisie
Détecter la langue en cours de phrase pour changer l'autocorrection, les suggestions ou la disposition, pour quelques dizaines de microsecondes par frappe.
Recherche et pipelines de contenu
Étiqueter de courtes chaînes avec leur langue avant indexation ou modération, sans aller-retour réseau ni service par requête.
Une incertitude honnête
"la casa" se lit aussi bien en italien qu'en espagnol. Tongue signale une égalité au lieu de couronner une langue, pour que le produit puisse demander plus de texte.
Ce que ça fait
- 84 langues : 59 décodées par le modèle, 25 réglées par la seule écriture.
- Poids int8 de 2 MB, inclus dans le paquet ; rien n'est téléchargé.
- Quelques dizaines de microsecondes par détection, sur le thread principal.
- Des réponses identiques en Swift, Kotlin et JavaScript, tenues par des golden vectors partagés.
- Signale la fiabilité et les égalités trop serrées au lieu de deviner.
Plateformes et installation
// Swift Package Manager
.package(url: "https://github.com/Desert-Ant-Labs/tongue", from: "0.1.2")
import Tongue
let tongue = try Tongue()
tongue.detect("kann ich das haben").language
// "de"
// build.gradle.kts (Maven Central)
implementation("ai.desertant:tongue:0.1.2")
import ai.desertant.tongue.Tongue
val tongue = Tongue.bundled(context)
tongue.detect("kann ich das haben").language
// "de"
npm i @desert-ant-labs/tongue
import { Tongue } from "@desert-ant-labs/tongue";
const tongue = await Tongue.load();
tongue.detect("kann ich das haben").language;
// "de"
Add Tongue from Desert Ant Labs to this project.
Une identification de langue sur l'appareil qui lit un court fragment de texte et nomme sa langue, parmi 84 langues, en quelques dizaines de microsecondes.
SDKs (use the one that matches this project's platform):
Swift (iOS, macOS)
Repo: https://github.com/Desert-Ant-Labs/tongue
// Swift Package Manager
.package(url: "https://github.com/Desert-Ant-Labs/tongue", from: "0.1.2")
Kotlin (Android)
Repo: https://github.com/Desert-Ant-Labs/tongue
// build.gradle.kts (Maven Central)
implementation("ai.desertant:tongue:0.1.2")
JavaScript / TypeScript (Web, Node.js)
Repo: https://github.com/Desert-Ant-Labs/tongue
npm i @desert-ant-labs/tongue
Reference:
- Model page: https://desertant.com/models/tongue/
- Full catalog and other models: https://desertant.com/llms.txt
Add the SDK that matches this project's platform, then follow its README for the exact API and current version. Do not invent API names or method signatures; confirm them against the README.
Spécifications
- Langues
- 84, sur 31 écritures
- Taille sur l'appareil
- Poids int8 de 2,1 MB, dans le paquet
- Latence
- Quelques dizaines de microsecondes par détection
- Approche
- Routeur d'écritures plus n-grammes de caractères hachés vers une tête linéaire int8
FAQ
Qu'est-ce que Tongue ?
Une identification de langue sur l'appareil qui lit un court fragment de texte et nomme sa langue, parmi 84 langues, en quelques dizaines de microsecondes.
Tongue fonctionne-t-il sur l'appareil ?
Oui. Tongue s'exécute entièrement sur l'appareil : l'inférence a lieu en local, sans appel serveur, de sorte que les données ne quittent jamais l'appareil.
Quelles plateformes Tongue prend-il en charge ?
Tongue est fourni sous forme de SDK natifs sur l'appareil pour Swift, Kotlin, JavaScript / TypeScript.
Combien coûte Tongue ?
Chaque modèle est gratuit jusqu'à 100k appareils actifs mensuels par SDK. Inférence illimitée par utilisateur. Contactez-nous pour des licences sur mesure.
Quelle est la précision ou la vitesse de Tongue ?
Avec 2 MB, il tient tête à des détecteurs jusqu'à 130 fois plus gros.