J'ai un iPhone depuis dix ans et je l'adore. Contrairement à certaines personnes, j'apprécie vraiment Siri et je l'utilise fréquemment. Mais après dix ans, Siri n'a pas compris que lorsqu'il retranscrit mes textes, il doit savoir que le nom de ma femme n'est pas Aaron, mais Erin. Je pardonne l'implémentation de la reconnaissance vocale, qui nécessite beaucoup de ressources, mais après avoir corrigé cette erreur une fois et envoyé un texte révisé, cette correction aurait dû être stockée dans un historique de corrections sur mon téléphone, un petit fichier utilisé par un modèle de transformation de post-traitement, avec d'autres indices, pour rendre cette erreur beaucoup moins probable. Je sais qu'appeler la fonctionnalité de reconnaissance vocale de l'iPhone Siri est une simplification excessive, mais c'est ainsi que mes enfants perçoivent « l'IA dans mon iPhone ».

Les systèmes de reconnaissance vocale rencontrent souvent des difficultés avec les homophones, c'est-à-dire des mots qui sonnent de la même manière mais dont l'orthographe et le sens sont différents. Ces erreurs peuvent être frustrantes, surtout lorsqu'elles concernent des noms de personnes ou des termes couramment utilisés. La solution à ce problème ne réside pas dans la refonte du moteur de reconnaissance vocale, mais dans une couche de traitement de texte post-transcription légère qui s'adapte aux corrections de l'utilisateur au fil du temps. Voici le code basé sur PyTorch que j'ai conçu pour résoudre ce problème.

Il est super compact et facile à déployer sur un téléphone après compilation pour mobile. Je sais que derrière Siri se trouve un ensemble très complexe de modèles enchaînés, donc ce code pourrait être utilisé simplement pour fournir une nouvelle fonctionnalité en entrée à ces modèles, un score qui aide à personnaliser la transcription lorsque des homophones particuliers apparaissent. Mais il serait plus simple de l'utiliser comme couche de post-traitement.

Il n'est pas nécessaire d'attendre la sortie d'un nouveau téléphone pour que cela soit possible. Cela me faciliterait la vie lors de la prochaine mise à jour qu'Apple publiera pour mon iPhone.

L'idée centrale

Cette approche se concentre sur trois éléments principaux :

• Historique des corrections : stocke les corrections précédentes de l'utilisateur, en donnant la priorité aux mots que l'utilisateur a explicitement corrigés auparavant.
• Contacts fréquents : suit les mots ou les noms fréquemment utilisés, en attribuant une probabilité plus élevée à ceux les plus couramment utilisés.
• Analyse contextuelle : utilise le traitement du langage naturel (TLN) pour analyser le texte environnant à la recherche d'indices qui aident à lever l'ambiguïté des homophones.

Le système calcule un score de vraisemblance pour chaque candidat homophone en fonction de ces trois facteurs et sélectionne la correction la plus probable. Vous trouverez ci-dessous l'implémentation Python divisée en sections avec des explications.

Chargement de la base de données des homophones

La première étape consiste à créer ou à charger une base de données d'homophones. Il s'agit de paires (ou de groupes) de mots susceptibles d'être confondus lors de la transcription.

 # Homophones database homophones_db = { "Aaron": ["Erin"], "bare": ["bear"], "phase": ["faze"], "affect": ["effect"], }

Il s'agit d'un dictionnaire simple où la clé est le mot mal transcrit et la valeur est une liste d'homophones alternatifs. Par exemple, "phase" peut être confondu avec "faze". Plus tard, cette base de données sera interrogée lorsqu'un mot ambigu sera rencontré.

Suivi de l'historique des corrections

Le code suit les corrections de l'utilisateur dans un dictionnaire où chaque clé est un tuple de (original_word, corrected_word) et la valeur est le nombre de fois où l'utilisateur a corrigé cette erreur.

Suivi de l'historique des corrections

 # Correction history tracker correction_history = { ("phase", "Faye's"): 3, ("bear", "bare"): 2, }

Si l'utilisateur corrige « phase » en « Faye » trois fois, le système donne la priorité à cette correction pour les transcriptions futures.

Contacts fréquents

Un autre facteur influençant la sélection des homophones est la fréquence d'utilisation d'un mot particulier. Il peut s'agir de noms personnels ou de termes fréquemment saisis par l'utilisateur.

 # Frequent contact tracker frequent_contacts = { "faye": 15, "phase": 5, "erin": 10, "aaron": 2, }

Le système donne plus de poids aux mots fréquemment utilisés pour désambiguïser les homophones. Par exemple, si « faye » apparaît 15 fois mais que « phase » n'apparaît que 5 fois, « faye » sera préféré.

Analyse contextuelle

Les indices contextuels sont extraits de la phrase environnante pour affiner davantage la sélection. Par exemple, si la phrase contient le pronom « elle », le système peut privilégier « Erin » par rapport à « Aaron ».

Charger un modèle PNL pour l'analyse du contexte

 from transformers import pipeline # Load an NLP model for context analysis context_analyzer = pipeline("fill-mask", model="bert-base-uncased") def detect_context(sentence): """Detect context-specific clues in the sentence.""" pronouns = ["he", "she", "his", "her", "their"] tokens = sentence.lower().split() return [word for word in tokens if word in pronouns]

Cette fonction analyse la phrase à la recherche de pronoms spécifiques au genre ou d'autres indices qui pourraient indiquer le sens voulu du mot.

Calcul des scores de vraisemblance

À chaque candidat homophone est attribué un score de vraisemblance basé sur :

1. Corrections passées : Poids plus élevé (par exemple, 3x).
2. Utilisation fréquente : Poids moyen (par exemple, 2x).
3. Correspondance de contexte : Poids inférieur (par exemple, 1x).

 def calculate_likelihood(word, candidate, sentence): """Calculate a likelihood score for a homophone candidate.""" correction_score = correction_history.get((word, candidate), 0) * 3 frequency_score = frequent_contacts.get(candidate, 0) * 2 context = detect_context(sentence) context_clues = homophones_db.get(candidate, []) context_score = sum(1 for clue in context if clue in context_clues) return correction_score + frequency_score + context_score

Ce score combine les trois facteurs pour déterminer l’homophone le plus probable.

Désambiguïsation des homophones

Une fois les scores de vraisemblance calculés, le système sélectionne l’homophone avec le score le plus élevé.

 def prioritize_homophones(word, candidates, sentence): """Prioritize homophones based on their likelihood scores.""" likelihoods = { candidate: calculate_likelihood(word, candidate, sentence) for candidate in candidates } return max(likelihoods, key=likelihoods.get) def disambiguate_homophone(word, sentence): """Disambiguate homophones using likelihood scores.""" candidates = homophones_db.get(word, []) if not candidates: return word return prioritize_homophones(word, candidates, sentence)

Ce processus garantit que le mot le plus approprié est choisi en fonction de l’historique, de la fréquence et du contexte.

Traitement des transcriptions complètes

Le système traite une phrase entière, en appliquant la logique de désambiguïsation à chaque mot.

 def process_transcription(transcription): """Process the transcription to correct homophones.""" words = transcription.split() corrected_words = [disambiguate_homophone(word, transcription) for word in words] return " ".join(corrected_words)

Exemple complet de flux de travail

 # Example transcription and correction raw_transcription = "This is phase one plan." corrected_transcription = process_transcription(raw_transcription) print("Original Transcription:", raw_transcription) print("Corrected Transcription:", corrected_transcription) # Simulate user feedback update_correction_history("phase", "faye") print("Updated Correction History:", correction_history) print("Updated Frequent Contacts:", frequent_contacts)

Mise à jour des commentaires

Lorsque l'utilisateur corrige une erreur, l'historique des corrections et les contacts fréquents sont mis à jour pour améliorer les prévisions futures.

 def update_correction_history(original, corrected): """Update correction history and frequent contacts.""" correction_history[(original, corrected)] = correction_history.get((original, corrected), 0) + 1 frequent_contacts[corrected] = frequent_contacts.get(corrected, 0) + 1 frequent_contacts[original] = max(0, frequent_contacts.get(original, 0) - 1)

Exemple de transcription et de correction

 Original Transcription: This is phase one plan. Corrected Transcription: This is Faye's one plan. Updated Correction History: {('phase', 'Faye's'): 4} Updated Frequent Contacts: {'Faye's': 16, 'phase': 4}

Conclusion

Cette couche de traitement de texte légère améliore la précision des applications de conversion de la parole en texte en apprenant des corrections de l'utilisateur, en tirant parti de l'utilisation fréquente et en analysant le contexte. Elle est suffisamment compacte pour fonctionner sur des appareils mobiles et s'adapte aux besoins individuels des utilisateurs, offrant une alternative plus intelligente aux modèles statiques traditionnels. Avec un minimum d'efforts, Apple (ou toute autre entreprise) pourrait intégrer cette fonctionnalité pour rendre les assistants virtuels comme Siri plus réactifs et personnalisés.