Les mécanismes d'autocorrections

Dans le livre il indicts les une voie vers les mécanismes d'autocorrections (plus de 100 fois)  

 

Ces algorithmes offrent différentes approches pour l'autocorrection :

La distance de Levenshtein permet de mesurer la similarité entre deux mots en comptant le nombre minimal de modifications nécessaires pour passer de l'un à l'autre. C'est particulièrement utile pour les erreurs de frappe simples.

L'algorithme Soundex transforme les mots en codes phonétiques, ce qui permet de trouver des mots qui sonnent de manière similaire même s'ils sont orthographiés différemment. Par exemple, "Philippe" et "Filip" auront le même code Soundex.

La méthode des n-grammes découpe les mots en sous-séquences de n caractères et compare leur similarité. Cette approche est efficace pour détecter des similarités partielles entre les mots.

def levenshtein_distance(str1, str2):

    """Calcule la distance de Levenshtein entre deux chaînes."""

    if len(str1) < len(str2):

        return levenshtein_distance(str2, str1)

    if len(str2) == 0:

        return len(str1)

    previous_row = range(len(str2) + 1)

    for i, c1 in enumerate(str1):

        current_row = [i + 1]

        for j, c2 in enumerate(str2):

            insertions = previous_row[j + 1] + 1

            deletions = current_row[j] + 1

            substitutions = previous_row[j] + (c1 != c2)

            current_row.append(min(insertions, deletions, substitutions))

        previous_row = current_row

    return previous_row[-1]

def suggestion_mot(mot_errone, dictionnaire, seuil=2):

    """Trouve les suggestions pour un mot erroné basé sur la distance de Levenshtein."""

    suggestions = []

    for mot in dictionnaire:

        distance = levenshtein_distance(mot_errone, mot)

        if distance <= seuil:

            suggestions.append((mot, distance))

    

    return sorted(suggestions, key=lambda x: x[1])

# Exemple d'utilisation de l'algorithme phonétique Soundex

def soundex(mot):

    """Implémentation de l'algorithme Soundex."""

    # Table de conversion

    conv_table = {

        'b': '1', 'f': '1', 'p': '1', 'v': '1',

        'c': '2', 'g': '2', 'j': '2', 'k': '2', 'q': '2', 's': '2', 'x': '2', 'z': '2',

        'd': '3', 't': '3',

        'l': '4',

        'm': '5', 'n': '5',

        'r': '6'

    }

    

    if not mot:

        return ''

        

    # Garde la première lettre

    code = mot[0].upper()

    

    # Convertit le reste des lettres

    for char in mot[1:].lower():

        if char in conv_table:

            if conv_table[char] != code[-1]:  # Évite les répétitions

                code += conv_table[char]

    

    # Pad avec des zéros et tronque à 4 caractères

    code = code + '0' * 4

    return code[:4]

def n_grammes(mot, n=2):

    """Génère les n-grammes d'un mot."""

    return [mot[i:i+n] for i in range(len(mot)-n+1)]

def similarite_n_grammes(mot1, mot2, n=2):

    """Calcule la similarité entre deux mots basée sur leurs n-grammes."""

    ngrams1 = set(n_grammes(mot1, n))

    ngrams2 = set(n_grammes(mot2, n))

    

    intersection = len(ngrams1.intersection(ngrams2))

    union = len(ngrams1.union(ngrams2))

    

    return intersection / union if union > 0 else 0

Pour améliorer ces mécanismes, on peut également :

Utiliser des dictionnaires de fréquence pour privilégier les mots les plus courants

Tenir compte du contexte (mots précédents et suivants)

Implémenter des règles spécifiques à la langue (par exemple pour le français : accents, cédilles, etc.)

Utiliser des techniques d'apprentissage automatique pour affiner les suggestions... Et bien plus, je suppose que l'IA Freysa devait être avec des mécanismes de ce type.

L'IA Freysa trompée 

https://vitalik.eth.limo/general/2024/01/30/cryptoai.html

Maintenant que les blockchains et les IA deviennent de plus en plus puissantes, il existe un nombre croissant de cas d’utilisation à l’intersection des deux domaines. Cependant, certains de ces cas d’utilisation ont beaucoup plus de sens et sont beaucoup plus robustes que d’autres. En général, les cas d’utilisation où le mécanisme sous-jacent continue d’être conçu grossièrement comme avant, mais où les acteurs individuels deviennent des IA, permettant au mécanisme de fonctionner efficacement à une échelle beaucoup plus micro, sont les plus prometteurs et les plus faciles à réaliser.

Les applications les plus difficiles à mettre en œuvre sont celles qui tentent d’utiliser des blockchains et des techniques cryptographiques pour créer un « singleton » : une IA de confiance décentralisée unique sur laquelle une application s’appuierait à une certaine fin. Ces applications sont prometteuses, à la fois pour la fonctionnalité et pour l’amélioration de la sécurité de l’IA d’une manière qui évite les risques de centralisation associés à des approches plus courantes de ce problème. Mais il y a aussi de nombreuses façons dont les hypothèses sous-jacentes pourraient échouer ; Par conséquent, il vaut la peine d’être prudent, en particulier lors du déploiement de ces applications dans des contextes à forte valeur et à haut risque.

J’ai hâte de voir d’autres tentatives de cas d’utilisation constructifs de l’IA dans tous ces domaines, afin que nous puissions voir lesquels d’entre eux sont vraiment viables à grande échelle.

https://github.com/0xfreysa/agent

--- 

 Pierre Erol GIRAUDY 

http://about.me/giraudyerol