Génération de fautes de frappe basée sur la physique — Comment fonctionne LikelyTypo

Vos tests d’autocorrection ne valent que ce que valent vos données de test. Si vos « fautes de frappe » ressemblent à du bruit aléatoire plutôt qu’à des erreurs humaines, vos tests vous mentent.

Pensez à la dernière fois que vous avez mal saisi un mot sur votre téléphone. Vous avez probablement appuyé sur la touche juste à côté de celle visée. Peut-être avez-vous doublé une lettre, inversé deux caractères ou manqué la barre d’espace. Ce que vous n’avez presque certainement pas fait, c’est remplacer un « e » par un « z » ou substituer une voyelle par un signe de ponctuation. Pourtant, c’est exactement ce que produisent la plupart des approches de génération de fautes de frappe : des absurdités statistiquement improbables qu’aucune main humaine ne produirait jamais.

LikelyTypo est un simulateur d’erreurs clavier en ligne qui génère des erreurs de saisie réalistes en modélisant l’acte physique d’appuyer sur des touches sur de vrais appareils. Au lieu de lancer des dés sur l’ensemble du jeu de caractères, il simule ce qui se passe réellement quand les doigts rencontrent des claviers, des écrans tactiles et des tablettes. Vous pouvez l’essayer dès maintenant dans la démo interactive—sans installation, sans inscription, tapez simplement et regardez des fautes de frappe basées sur la physique apparaître en temps réel.

Le problème des fausses fautes de frappe

La plupart des approches pour générer des fautes de frappe de test suivent le même schéma : choisir une position aléatoire dans une chaîne, puis choisir un caractère aléatoire de l’alphabet pour substituer, insérer ou supprimer. La logique est simple, et le résultat est inutile pour tout test sérieux.

Considérons le mot « keyboard. » Une approche par mutation aléatoire pourrait le transformer en « keybxard », « keyb*ard » ou « keyboapd. » Aucune de ces versions ne ressemble à ce qu’une vraie personne taperait. Une vraie personne taperait « keybiard » (touche adjacente), « keybard » (lettre omise) ou « keybaord » (paire inversée). La différence compte parce que les algorithmes d’autocorrection, les correcteurs orthographiques et les moteurs de recherche flous sont spécifiquement calibrés pour traiter les types d’erreurs que les humains commettent réellement. Quand vos données de test contiennent des erreurs qui ne se produisent jamais dans la réalité, votre suite de tests vous donne une fausse confiance.

Le manque d’outils est évident. D’un côté, il y a des méthodes triviales de mutation aléatoire qui produisent du bruit irréaliste. De l’autre, il y a des articles académiques décrivant des modèles d’erreurs sophistiqués que personne n’a rendus accessibles. Les personnes qui ont besoin de fautes de frappe réalistes pour les tests, la génération de données d’entraînement ou les démonstrations d’interface ont dû construire leurs propres solutions à partir de zéro. LikelyTypo comble ce vide avec un outil interactif que n’importe qui peut utiliser immédiatement.

Comment les fautes de frappe se produisent réellement : la physique du clavier

Comprendre les vraies fautes de frappe commence par comprendre les vrais claviers. Chaque erreur de saisie a une cause physique enracinée dans la géométrie du périphérique d’entrée, la biomécanique des doigts humains et la vitesse de frappe. LikelyTypo modélise ces causes directement.

Touches adjacentes, pas caractères aléatoires

L’erreur de frappe la plus courante est d’appuyer sur une touche voisine au lieu de celle visée. Sur un clavier QWERTY, si vous visez le « r » et que vous le manquez, vous toucherez « e », « t », « f », « d » ou « g »—jamais « m » ou « p. » Ce n’est pas une tendance statistique. C’est une contrainte physique. Votre doigt ne peut dériver que jusqu’à un certain point de sa cible avant que l’erreur ne devienne un type de faute complètement différent.

LikelyTypo maintient une carte complète d’adjacence pour chaque disposition de clavier prise en charge. Quand le moteur introduit une erreur de substitution de touche, il sélectionne exclusivement parmi les touches physiquement adjacentes, pondérées par distance. Les touches directement à gauche et à droite sont des cibles plus probables que les voisines diagonales, car la dérive horizontale est plus fréquente que la dérive verticale lors de la frappe rapide.

Pour voir cela en action, ouvrez la démo interactive et tapez le mot « the. » Vous pourriez le voir devenir « thr » ou « rhe »—parce que « e » et « r » sont adjacents sur QWERTY, et « t » et « r » sont côte à côte. Vous ne verrez jamais « the » devenir « thz » car « z » n’est proche de « e » sur aucune disposition de clavier standard.

Cette seule décision de conception—limiter la substitution aux touches adjacentes—transforme la sortie d’un non-sens évident en texte qui semble avoir été tapé par une vraie personne pressée.

Le facteur de forme de l’appareil change tout

Un clavier physique, un écran tactile de téléphone, un geste de balayage et une tablette produisent des modèles d’erreur fondamentalement différents. Sur un clavier complet, les erreurs d’inversion dominent car les doigts sur les touches voisines se déclenchent dans le mauvais ordre. Sur une interface tactile de téléphone, les substitutions de touches adjacentes augmentent fortement car les cibles tactiles sont petites et les pouces imprécis. La saisie par balayage introduit des erreurs entièrement uniques : des déviations de trajectoire en milieu de mot qui produisent des mots plausibles mais incorrects. La saisie sur tablette se situe quelque part entre le clavier et le téléphone, avec des cibles tactiles plus grandes mais moins de retour tactile que les touches physiques.

LikelyTypo prend en charge plusieurs modèles d’appareils—clavier, toucher de téléphone, balayage de téléphone et tablette—chacun avec sa propre distribution de probabilité d’erreur. Le même texte d’entrée produit des modèles d’erreur différents selon l’appareil sélectionné, car les causes physiques de ces erreurs sont différentes. Dans la démo interactive, vous pouvez basculer entre les appareils d’un simple clic et voir immédiatement comment les fautes de frappe générées changent de caractère. Essayez de taper une phrase, puis passez du clavier au toucher de téléphone et regénérez. Les erreurs passent des inversions aux substitutions de touches adjacentes sous vos yeux.

Catégories d’erreurs au-delà de la substitution de touches

La substitution de touches n’est qu’un des nombreux types d’erreurs que LikelyTypo modélise. La saisie réelle implique une gamme bien plus large d’erreurs :

• Inversion : Deux caractères adjacents échangent leur ordre (« teh » au lieu de « the »)
• Omission : Un caractère est complètement sauté (« typng » au lieu de « typing »)
• Insertion : Un caractère supplémentaire apparaît, généralement un voisin de la touche visée
• Doublement : Une touche s’enregistre deux fois (« keyboaard »)
• Espace manqué : Deux mots se collent (« thequick »)
• Espace en trop : Un espace apparaît au milieu d’un mot (« key board »)
• Erreurs de casse : Des problèmes de synchronisation de la touche Maj produisent une capitalisation incorrecte
• Substitution homophone : Des touches au son similaire sont confondues

Chaque type d’erreur a son propre poids de probabilité qui varie selon l’appareil et le profil. Un dactylographe soigneux sur un clavier complet double rarement les touches mais inverse occasionnellement. Un dactylographe rapide sur téléphone omet des caractères et manque des espaces fréquemment. Ces distributions ne sont pas arbitraires—elles reflètent des modèles observés dans des données de saisie réelles. Quand vous générez des fautes de frappe dans la démo, le panneau de détails des erreurs vous montre exactement quel type d’erreur a été appliqué à chaque position, pour que vous puissiez voir la ventilation complète de ce qui s’est passé et pourquoi.

Présentation de LikelyTypo

LikelyTypo est un outil web gratuit conçu pour quiconque a besoin de fautes de frappe réalistes—que ce soit pour tester l’autocorrection, entraîner des modèles d’apprentissage automatique, peupler des interfaces de démonstration ou simplement comprendre comment fonctionnent les erreurs de saisie humaines. La démo interactive sur likelytypo.com vous permet de générer des fautes de frappe basées sur la physique instantanément sans aucune configuration.

Principes fondamentaux de conception

Trois principes guident la conception de l’outil :

1. La physique plutôt que le hasard. Chaque type d’erreur est ancré dans une cause physique. Le moteur n’introduit jamais une erreur qui ne peut pas être expliquée par la biomécanique humaine et la géométrie de l’appareil.
2. Déterministe quand vous en avez besoin. Fournir une graine produit une sortie identique pour une entrée identique, à chaque fois. Cela rend les résultats reproductibles, partageables et vérifiables.
3. Configurable sans complexité. Les profils regroupent des valeurs par défaut judicieuses pour les scénarios courants. Vous pouvez générer des fautes de frappe réalistes d’un simple clic, ou affiner chaque poids d’erreur individuellement via le panneau de paramètres avancés.

Essayez par vous-même

Le moyen le plus rapide de comprendre LikelyTypo est de l’utiliser. Rendez-vous sur la démo interactive, collez n’importe quelle phrase dans le champ de saisie et cliquez sur le bouton générer. En une fraction de seconde, vous verrez votre texte transformé avec des erreurs de saisie réalistes. La vue des différences met en évidence chaque changement en couleur, rendant immédiatement évident où les erreurs ont été introduites et de quel type elles sont.

Essayez de coller « The quick brown fox jumps over the lazy dog » et de générer avec les paramètres par défaut. Vous pourriez voir quelque chose comme « The quikc brown fox jumsp over the lazy dog »—deux inversions qui ressemblent exactement au type d’erreurs qu’un dactylographe rapide commet. Maintenant, passez à l’appareil toucher de téléphone et regénérez. Les erreurs changent : au lieu d’inversions, vous voyez des touches adjacentes, peut-être « The quick brown foz jumps over the lazy dog » où « x » est devenu « z » parce que ces touches sont voisines sur un clavier de téléphone. Chaque combinaison de paramètres produit un résultat différent mais toujours plausible.

Le panneau de détails des erreurs sous la sortie montre une ventilation structurée de chaque modification : le type d’erreur, la position dans la chaîne, le caractère original et le remplacement. Cette transparence vous permet de comprendre non seulement ce qui a changé, mais pourquoi le moteur a choisi cette erreur particulière à cet endroit particulier.

Profils de saisie : du subtil au furieux

Tous les dactylographes ne se valent pas. Un rédacteur méticuleux composant une lettre de motivation fait des erreurs très différentes de quelqu’un qui tape rageusement une réponse à 2 heures du matin. LikelyTypo capture ce spectre à travers des profils de saisie, qui sont des préréglages nommés contrôlant le taux d’erreur global et la probabilité relative de chaque type d’erreur.

Profils intégrés

L’outil est livré avec plusieurs profils intégrés :

• Subtle — Taux d’erreur faible, principalement des inversions et des omissions de caractère unique. Modélise un dactylographe soigneux qui dérape occasionnellement.
• Typing-fast — Taux d’erreur modéré avec une gamme plus large de types d’erreurs. Les inversions et substitutions de touches adjacentes dominent. C’est le profil par défaut.
• Angry-typing — Taux d’erreur élevé, beaucoup d’espaces manqués, de caractères doublés et d’erreurs de casse. Modélise quelqu’un qui tape avec force et vitesse, sacrifiant la précision au profit du débit émotionnel.
• Very-drunk — Taux d’erreur très élevé dans toutes les catégories d’erreurs. Dérive significative vers les touches adjacentes, omissions fréquentes et espacement erratique. Modélise un contrôle moteur sévèrement altéré.

Pour voir la différence que font les profils, essayez la phrase « Meeting tomorrow at nine in the conference room » avec chaque profil sélectionné dans la démo. Le résultat subtle pourrait changer un seul caractère—peut-être « Meetign » avec une inversion. Le résultat typing-fast introduit quelques erreurs de plus : une inversion ici, une touche adjacente là, peut-être un espace manqué. Le résultat angry-typing est nettement dégradé, avec des caractères doublés, une capitalisation incorrecte et des mots collés. Le résultat very-drunk va encore plus loin, dispersant des erreurs sur presque chaque mot tout en restant reconnaissable comme la phrase originale. Toutes les sorties sont de la frappe humaine plausible—elles diffèrent en degré, pas en nature.

Modèles d’erreur adaptés à l’appareil

Les profils et les appareils interagissent pour produire des signatures d’erreur distinctes. Le même profil sur différents appareils produit des résultats différents parce que les contraintes physiques changent. Un dactylographe typing-fast sur un clavier physique inverse fréquemment les caractères parce que ses doigts dépassent sa coordination. Le même profil en toucher de téléphone produit plus de substitutions de touches adjacentes parce que les cibles tactiles sont plus petites et la précision du pouce diminue avec la vitesse.

Vous pouvez combiner n’importe quel profil avec n’importe quel appareil dans la démo. Essayez de sélectionner angry-typing avec l’appareil balayage de téléphone, puis passez au clavier et regénérez avec la même graine. Le nombre total d’erreurs peut être similaire, mais leur caractère change complètement. Les erreurs de balayage de téléphone tendent à produire des mots plausibles mais incorrects par déviation de trajectoire, tandis que les erreurs de clavier penchent vers les inversions et les touches doublées dues à des frappes mal synchronisées. Cette diversité est exactement ce qui rend l’outil utile pour des tests complèts : vous pouvez vérifier que votre application gère l’ensemble du spectre des entrées réelles.

LikelyTypo prend également en charge plusieurs dispositions de clavier—notamment QWERTY, AZERTY et QWERTZ—car les cartes d’adjacence des touches diffèrent entre les dispositions. Un « q » sur un clavier QWERTY est adjacent à « w » et « a. » Sur un clavier AZERTY, cette même touche physique est « a » et ses voisines sont complètement différentes. Si votre application dessert des utilisateurs dans plusieurs régions, générer des fautes de frappe avec la bonne disposition garantit que vos données de test correspondent à la réalité. Changez de disposition dans le menu déroulant de la démo et observez comment les erreurs basées sur l’adjacence se déplacent en conséquence.

Sortie déterministe avec des graines

L’aléatoire est utile pour l’exploration mais destructeur pour les tests. Si une faute de frappe générée diffère à chaque fois, un test réussi aujourd’hui pourrait échouer demain—non pas parce que votre logique a changé, mais parce que le générateur de nombres aléatoires a produit une séquence différente. LikelyTypo résout ce problème avec l’ensaîmencement déterministe.

Quand vous entrez une valeur de graine dans la démo, la sortie est garantie d’être identique pour une entrée identique. Tapez le même texte, utilisez le même profil, appareil, disposition et graine, et vous obtiendrez exactement les mêmes fautes de frappe à chaque fois. Cette propriété rend les résultats entièrement reproductibles et partageables. Vous pouvez envoyer à un collègue le texte, les paramètres et la graine, et il verra la même sortie sur son écran.

Quand vous laissez le champ de graine vide, le moteur en génère une automatiquement et l’affiche à côté du résultat. Si une faute de frappe générée aléatoirement révèle quelque chose d’intéressant—un modèle d’erreur particulièrement délicat, une combinaison qui fait planter votre correcteur orthographique—vous pouvez noter la graine et revenir à ce résultat exact quand vous en avez besoin. Ce flux de travail transforme l’exploration libre en une référence répétable sans aucun effort.

Le mécanisme de graines dans le panneau de paramètres avancés facilite également la démonstration de comportements spécifiques. Si vous rédigez un article de blog sur les cas limites de l’autocorrection, que vous présentez une démo à des parties prenantes ou que vous soumettez un rapport de bogue, vous pouvez inclure la graine pour rendre votre exemple durablement reproductible plutôt que de dépendre d’une capture d’écran d’un résultat transitoire.

Et ensuite

LikelyTypo est conçu pour être exploré et étendu. Les profils intégrés couvrent les scénarios les plus courants, mais le moteur sous-jacent accepte des configurations de poids entièrement personnalisées via le panneau de paramètres avancés. Vous pouvez définir votre propre distribution d’erreurs en ajustant les probabilités de chaque type d’erreur, régler le taux d’erreur global avec précision et combiner des poids personnalisés avec n’importe quelle combinaison d’appareil et de disposition.

L’architecture supporte l’ajout de nouveaux modèles d’appareils, de nouvelles dispositions de clavier et de nouveaux types d’erreurs au fil du temps. Les cartes d’adjacence sont pilotées par les données, ce qui signifie que les nouvelles dispositions sont une question de définition de positions de touches plutôt que de reconception du moteur. Au fur et à mesure que l’outil évolue, attendez-vous à voir des dispositions supplémentaires pour les claviers régionaux et de nouveaux profils d’appareils reflétant les méthodes de saisie émergentes.

La démo interactive vous permet d’expérimenter avec chaque paramètre en temps réel. Tapez ou collez n’importe quel texte, sélectionnez un profil et un appareil, définissez optionnellement une graine et regardez LikelyTypo transformer votre saisie en fautes de frappe réalistes. La vue des différences met en évidence chaque changement, et le panneau de détails des erreurs montre exactement quel type d’erreur a été appliqué à chaque position. C’est le moyen le plus rapide de développer une intuition sur la façon dont la génération de fautes de frappe basée sur la physique diffère de la mutation aléatoire de caractères.

Si vous développez de l’autocorrection, de la vérification orthographique, de la recherche floue ou toute fonctionnalité qui traite du texte saisi par les utilisateurs, LikelyTypo vous fournit des données de test qui ressemblent réellement à ce que produisent les vrais utilisateurs. Plus de bruit aléatoire. Plus de fausse confiance. Juste des fautes de frappe réalistes, basées sur la physique et déterministes—disponibles instantanément dans votre navigateur.