Desert Ant Labs

Tongue : identification de langue sur l'appareil

Identification de langueDisponible

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.

0,933
FLORES-200, 3 mots
0,992
Tweets
84
Langues
2 MB
poids int8

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

iOS, macOS
Installation
// Swift Package Manager
.package(url: "https://github.com/Desert-Ant-Labs/tongue", from: "0.1.2")
Exemple - Swift
import Tongue

let tongue = try Tongue()
tongue.detect("kann ich das haben").language
// "de"
Android
Installation
// build.gradle.kts (Maven Central)
implementation("ai.desertant:tongue:0.1.2")
Exemple - Kotlin
import ai.desertant.tongue.Tongue

val tongue = Tongue.bundled(context)
tongue.detect("kann ich das haben").language
// "de"
Web, Node.js
Installation
npm i @desert-ant-labs/tongue
Exemple - TypeScript
import { Tongue } from "@desert-ant-labs/tongue";

const tongue = await Tongue.load();
tongue.detect("kann ich das haben").language;
// "de"
Ajoutez Tongue avec votre assistant de codage IA
Prompt
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.

Ressources