Lecture et calcul de similiratité entre deux documents texte (débutant)

Bonjour tout le monde,

Je suis vraiment débutant donc désolé si j’utilise pas le bon vocabulaire et si certaines choses paraissent évidentes.

J’aimerai calculer la similarité entre deux textes avec les modules gensim et scikit-learn, j’ai trouvé un petit tuto qui a l’air pas mal sur ce site https://www.it-swarm.dev/fr/nlp/comment-calculer-la-similarite-entre-deux-documents-texte/942614709/. Le problème, c’est que je ne sais pas comment lire mes deux documents pour ensuite appliquer les modules, ni quel mode de lecture utiliser. Ce que je cherche à faire, c’est d’utiliser le calcul de similarité lignes par lignes : ligne 1 du document1.txt comparé à la ligne 1 du document2.txt, ligne2 du document1.txt comparé à la ligne 2 du document2.txt, etc etc.

Voilà, merci par avance !

Salut à toi !

Si tu es débutant en Python, tu te lances peut-être dans quelque chose d’un peu trop compliqué pour démarrer, mais à toi de voir.

Si je comprends bien, tu veux utiliser une bibliothèque pour comparer la similarité de chaînes de caractères deux à deux, une sur un fichier A et une sur un fichier B.

Si ton problème est la lecture de ces fichiers, c’est très simple avec Python:

with open('document1.txt') as f1, open('document2.txt') as f2:
    ligne_fichier1 = f1.readline()
    ligne_fichier2 = f2.readline()

    # Ici, tu feras la comparaison entre tes deux lignes

    # Il faut également que tu crées une boucle, pour pouvoir lire toutes les lignes de ton fichier.

Merci pour ta réponse ! Oui je sais mais bon je tente quand même haha, je préfère apprendre sur le tas avec un objectif précis que pratiquer dans le vent.. Du coup j’ai bricolé un truc mais je capte pas ce que je dois faire de la boucle ? C’est là où je suis censé mettre les deux dernières lignes de mon code ? Et aussi rien ne définit text_files…

from sklearn.feature_extraction.text import TfidfVectorizer

with open('orf.txt') as f1, open('gg.txt') as f2:
    lines_f1 = f1.readline()
    lines_f2 = f2.readline()

    for line in f1 :
    for line in f2 :

documents = [open(f) for f in text_files] # à supprimer ? je dois plutôt redéfinir documents pour que ça comprenne f1 et f2 non ? 

tfidf = TfidfVectorizer().fit_transform(documents)
pairwise_similarity = tfidf * tfidf.T

J’ai aussi oublié le mode d’ouverture non ? Je rajoute "r"?
with open('document1.txt', "r") as f1, open('document2.txt', "r") as f2:

Salut,

Oui je sais mais bon je tente quand même haha, je préfère apprendre sur le tas avec un objectif précis que pratiquer dans le vent.

Vue la teneur de tes questions, tu risques de bricoler dans le vent pas mal si tu n’apprends pas quelques bases avant de te lancer dans un projet un peu touffu. Vouloir utiliser des bibliothèques touffues sans même savoir lire un fichier et écrire une boucle for, c’est mettre la charrue avant les bœufs.

Oui oui je comprends tout à fait. Après le truc c’est que je ne suis pas sûr de vouloir apprendre la programmation (dans le vent) si je ne suis pas certain que mon programme est réalisable. Une fois que je le saurais, peut-être apprendrais-je plus profondément ou alors j’essaierai de monter un projet avec un programmeur pro mais c’est encore trop tôt pour être à ce stade. Et même si j’ai brassé beaucoup de vent depuis une semaine, je pense que j’ai quand même fait pas mal de progrès dans la compréhension des concepts

Après le truc c’est que je ne suis pas sûr de vouloir apprendre la programmation (dans le vent) si je ne suis pas certain que mon programme est réalisable. Une fois que je le saurais, peut-être apprendrais-je plus profondément ou alors j’essaierai de monter un projet avec un programmeur pro mais c’est encore trop tôt pour être à ce stade.

Autant être clair, si tu n’as pas toi même des bases solides en programmation, tu seras très probablement incapable d’estimer avec une certitude raisonnable si un programme est réalisable ou non (et surtout, avec quels moyens). Pour que l’on puisse t’aider, tu devrais soit exposer ton idée ici, soit en parler de vive voix avec un professionnel. Si tu as peur qu’on te pique ton idée (c’est une crainte classique…) sache que :

• ça arrive rarement parce que les très bonnes idées qu’on peut sentir comme telles à l’avance, c’est rare ;
• tu n’as très probablement pas la primeur de ton idée ;
• tu n’as aucun droit d’exclusivité sur une idée, seule la réalisation compte.

Je comprends les idées que tu exposes et je les avait déjà en tête avant de poster sur ce forum. Après, sur le plan conceptuel, je pense pouvoir être à même de savoir si l’idée que j’ai en tête est réalisable ou non, donc comme tu l’as dis c’est la question des moyens, d’où ma venue sur ce forum. Et comme tu l’as dis, j’ai effectivement peur que l’on me pique mon idée, je passe presque 10h par jours depuis une semaine, ça me ferait un peu chier. Donc non je ne vais pas expliquer dans les moindres détails ce que je veux faire, d’autant plus que j’ai une demande assez spécifique, je vois pas pourquoi je devrais plus expliciter mon projet. Pour répondre à tes points :

• j’ai effectivement l’impression que c’est une bonne car elle n’existe pas (à ma connaissance). pourquoi je pense que c’est une (très) bonne idée ? Parce que déjà, et c’est déjà beaucoup, je crois en la possibilité que ça me soit très utile personnellement, et par voie de conséquence, si ça marche, ça sera utile à beaucoup de gens, à la fois en terme pratique, mais aussi en terme financier puisqu’à priori elle ne coûtera pas grand chose (juste ce qu’il faut pour que les programmeurs et moi-même puissions bouffer et éventuellement boire un coup), ce qui n’est pas le cas des programmes qui sont similaires à ce que je veux faire. Je sais aussi que je m’embarque dans un truc casse gueule et qu’il est fort probable qu’elle ne soit finalement pas réalisable (notamment en terme de nombre de bugs).
• Je ne prétends pas avoir la primeur de l’idée, en aucune façon. Je me suis d’ailleurs demandé pourquoi elle n’avait d’ailleurs pas déjà été créée, et j’en ai conclu que c’était pour tout un tas de raisons (techniques, juridiques, et financières), et probablement que des dizaines de personnes y ont pensé avant moi.
• Concernant le dernier point, je ne suis pas tout à fait d’accord. Je ne prétends pas non plus avoir une quelconque forme de droit à l’exclusivité, mais quand même, je trouve que ça reste important. Dire que seule la réalisation compte c’est un peu réducteur. Ce sont les faces d’une même pièce. Et si jamais ça marche, je penserais bien sûr à faire quelque chose pour ceux qui m’ont aidé, même ne serait-ce que sur un petit bout de code. D’ailleurs en passant, je suis infographiste à la base (illustrator, indesign, photoshop), donc si je peux faire un retour de services et aider quelqu’un sur un projet c’est avec plaisir. Ensuite, il me semble que les forums (et internet de façon plus générale) sont justement des espaces où l’on peut essayer d’apprendre de façon pédagogique et vulgarisée (et donc pour les gens comme moi qui partent de 0), notamment grâce aux tutos. Mais si je demande c’est que je n’ai pas trouvé sur des tutos. J’ai toujours détesté cette façon d’enseigner les choses, où tu dois engloutir tout un tas de connaissances qui n’ont ni queue ni tête parce qu’elles ne sont pas pratiques pour toi. C’est lassant, c’est toujours la même modèle, de l’école à l’université. Ou alors tu dois faire une école privée. Nique les écoles privées. Alors oui, clairement, pour celui qui enseigne, c’est plus chiant, ça demande plus de temps, ça demande de vulgariser des trucs qui paraissent élémentaires à n’importe qui qui détient des compétences, même minimes. Mais je ne crois pas manquer de respect à quiconque en postant mon message, si tu n’as pas envie de m’aider, ne le fais pas, et je n’y vois d’ailleurs pas de problèmes, et je ne vais pas harceler les gens pour qu’ils m’aident ou parce qu’ils ne m’ont pas donné toutes les clés en main, s’il manque un truc dans le code j’essaie aussi de trouver la solution, même si c’est sûr que ma propension à brasser du vent est assez élevée. Enfin bref, je ne crois/espère pas être au mauvais endroit pour demander ce que je demande. Bon je crois que j’ai dis ce que j’avais à dire haha à bon entendeur.se

je pense pouvoir être à même de savoir si l’idée que j’ai en tête est réalisable ou non, donc comme tu l’as dis c’est la question des moyens, d’où ma venue sur ce forum

Non. En ayant aucune compétence en programmation, tu ne peux pas te rendre compte de qui est faisable ou non en programmation. Par contre, tu peux avoir l’impression d’être capable de le faire. Par ailleurs, par "moyens", j’entendais le nombre de développeurs, le temps, l’argent qu’il faudrait y mettre. Pas savoir quelle bibliothèque utiliser et comment faire une boucle for en Python.

Le reste a déjà été discuté en long en large et en travers un peu partout sur les forums. C’est pas vraiment le sujet.

Tu viens ici pour demander de l’aide sur l’utilisation d’une bibliothèque assez riche et pointue, mon conseil, et ce que j’estime être la meilleure façon de t’aider, c’est que tu devrais apprendre les bases de Python avant d’apprendre à te servir de cette bibliothèque. Tu me réponds qu’en fait, ton vrai but c’est d’évaluer la faisabilité d’un projet (le bon vieux problème XY), ce à quoi ma réponse est que tu as aussi besoin d’apprendre les bases de la programmation pour ça (et même plus, ou bien parler de ton idée à une personne qualifiée). Maintenant, tu as deux options, te dire que si ce conseil est revenu deux fois, c’est qu’il y a une raison que peut être tu n’as pas assez de recul pour bien comprendre ; ou bien t’entêter dans la direction que tu as prise. Dans le fond c’est ton choix, mais je ne vois pas trop l’intérêt de demander de l’aide sur un forum si c’est pour ne pas écouter.

Après il pose la question sur une question précise, je ne vois pas de mal à apprendre en suivant un tutoriel précis. Puis on a tous était débutant un jour, on a fait des mauvais choix, on s’est planté … c’est comme ça qu’on apprend ! Jamais d’échec, toujours une leçon. Je ne connaissais pas cette méthode, merci pour le partage @didierfa !

Voici la partie manquante du code :

from sklearn.feature_extraction.text import TfidfVectorizer

docs = []
with open('a.txt', 'r') as f: docs.append(f.read())
with open('b.txt', 'r') as f: docs.append(f.read())

tfidf = TfidfVectorizer().fit_transform(docs)
pairwise_similarity = tfidf * tfidf.T
print(pairwise_similarity)

La définition de documents présenté n’est pas très claire, ni propre. Avec with open() tu t’assures de pouvoir retirer le locker du fichier une fois la lecture terminée.

Pour ton premier argument sur l’effet Dunning-Kruger, je ne me sens pas particulièrement concerné, je suis quelqu’un qui à la base n’a pas tellement confiance en soi, et si j’ai laissé paraître un excès de confiance c’est loin d’être le cas, je vois tout à fait l’immense océan que j’ai en face de moi. ça fait plusieurs jours que j’oscille entre "mais non c’est débile t’as pas du tout les connaissances" et "putain en vrai c’est une bonne idée parce que c’est simple" (quand je dis ça, je veux dire que la résolution de mon conflit est une opération pas compliquée. Sur la possibilité de le faire, je ne viens pas ici en ayant rien lu, ni demander la faisabilité de certains trucs à des programmeurs pro (c’est bien sûr difficile quand tu cherches à cacher un peu ton idée), qui m’ont dit que c’était faisable. Là où j’ai vraiment de gros doutes c’est sur la capacité du programme à résoudre les opérations assez vite pour que ça n’impacte pas l’utilisateur, et en soit, après la résolution du conflit, (c’est là où j’avoue je suis clairement dans l’expectative), ça ne devrait pas trop puiser dans la mémoire vive. Et je sais très bien que là, je suis à l’étape la plus compliquée de mon programme. Sur la question des "moyens", là aussi j’avoue que je suis clairement dans le flou mais il est trop tôt pour que j’en parle à quelqu’un, d’autant plus que je veux avoir une confiance absolue dans la personne et je ne veux pas prendre le risque. Sur le fameux problème xy, je vois l’idée, je suis d’accord, mais c’est un raisonnement un peu simpliste car mon idée est détaillée en de multiples étapes, et si en soit je veux effectivement chercher à résoudre y par x, en fait je me suis déjà attelé à résoudre u, v, w. Pour revenir à mon problème de départ (le calcul d’indice de similarité entre deux documents texte), j’avoue que là encore j’ai un gros doute, notamment sur la possibilité et la manière de me servir des valeurs que je vais obtenir et ce que je vais pouvoir leur faire faire. Là j’avoue que c’est chaud. Et clairement je suis pas dans un refus d’apprendre les bases, mais je veux juste qu’elles soient utiles à ce que je veux faire. Et sur tous les trucs où je vais ce n’est pas le cas. Je réfléchis sérieusement à reprendre une formation dans la programmation mais c’est clair que ça serait nettement plus stimulant si je sais que mon programme est faisable, et puis je suis plus tout jeune je vais pas passer ma vie à faire des études. Et je suis d’accord c’est primordial, mais de ce que je comprends si je dois passer un an, voir deux, pour me rendre compte que finalement c’est pas faisable, c’est un peu relou. Je prends note de ton conseil, mais je suis un peu (beaucoup) têtu. ça m’a pas valut que des bonnes choses haha mais j’essaie de vivre avec

Merci beaucoup Yarflam ça fonctionne et merci aussi pour les encouragements, je vais tchecker ça plus en détail demain à tête reposée

Salut,

• Apprendre les bases de la programmation c’est pas non plus une histoire de deux ans. Apprendre les bases de Python, ce sera l’histoire de quelques semaines. Donc suivre un tutoriel sur Python, même pendant que tu essaies de mener à bien ton projet, ne pourra t’être que profitable.
• Comment tu détermines les bases qui sont utiles à ce que tu veux faire ? Généralement si on ne connaît pas un sujet, on n’a pas les connaissances pour savoir ce qui nous sera utile ou pas. En particulier, vu qu’on ne connaît pas le sujet, on a tendance à faire certaines choses de manière compliquée parce qu’on ne connaît pas les possibilités pour le faire.
• Avoir des bases qui ne sont pas immédiatement utiles pour ton projet c’est quand même une bonne chose vu que ça te donne d’autres points de vue, d’autres idées, d’autres manières de faire, etc. Un peu comme le scientifique spécialisé dans un domaine qui s’inspire et va piocher dans d’autres domaines.
• Quand tu dis « Le problème, c’est que je ne sais pas comment lire mes deux documents pour ensuite appliquer les modules, ni quel mode de lecture utiliser », ça montre qu’il te faut regarder comment on ouvre un fichier en Python. De même, la boucle for fait partie des outils de base de Python, et te sera présentée assez tôt dans un tutoriel Python.
• Quand tu dis que tu n’as pas trouvé de tutoriel sur ce point en particulier, c’est parce qu’en ayant les bases nécessaires et en lisant quelques bouts de code présentés dans la doc et certains tutoriels, on est censé pouvoir adapter le code donné à son utilisation, pas juste copier le code. Et ça rejoint la suite de mon message.

La programmation ce n’est (malheureusement ?) pas juste mettre des lignes de code les unes à la suite des autres en espérant que ça marche. Et on voit trop de débutants qui procèdent de la sorte, essayent de rajouter, supprimer ou modifier des lignes un peu au hasard en espérant obtenir le résultat voulu. Et ça donne des programmes qui tombent en marche. On sait pas trop pourquoi, on sait pas si ça marche tout le temps, on sait pas si c’est bugué ou pas (donc on va supposer que oui), etc.

À propos de la faisabilité de projet, je pense pas que la confiance en soi joue un grand rôle. Ce sont plutôt les a priori qu’on a, nos connaissances dans le domaine, et les programmes que l’on connaît. Par exemple, entre une IA à la Jarvis et un programme qui prend un programme $P$ et une entrée $x$ et te dit si $P$ se termine sur $x$, c’est très facile de penser que le second est beaucoup plus facile à faire que le premier.

Finalement, je ne te dirais pas d’arrêter ou de continuer ton projet, (même si je pense honnêtement qu’il n’a pas beaucoup de chance d’aboutir en continuant comme ça), mais je te conseille de suivre un tutoriel en parallèle de ce que tu essaies de faire pour ton projet. Ça te sera profitable, tu découvriras d’autre chose et surtout, les bases apprises te seront peut-être (sûrement même) utiles pour la suite de ton projet. En tout cas, bonne chance pour ton projet.

Salut tout le monde, j’espère que vous allez bien

Bon je vais peut-être pas répondre point par point j’ai déjà dit l’essentiel de ce que je voulais dire.

Encore une fois je suis pas contre apprendre les bases loin de là. Mais comme tu le dis, et c’est ce qui est chiant quand t’apprends les bases, la programmation ce n’est pas juste prendre des bouts de code qu’on met à la suite les uns des autres en modifiant un peu au hasard les lignes, et je l’ai bien compris, et c’est pour ça que j’ai aussi du mal avec cette méthode, et on en revient à ce que j’avais dit sur les savoirs surplombants qu’on nous enseigne (et c’est normal puisque dans la logique il ne sert à rien d’enseigner quelque chose de très particulier à un débutant). Bon je vois que vous insistez sur ce point, donc je vous poserais cette question : à partir de combien de temps pensez-vous que je peux être à même d’adapter du code en fonction de ce dont j’ai besoin ? D’ailleurs, j’ai vu qu’ils proposaient des formations en alternance sur openclassrooms, vous avez des retours de gens qui sont passés par là ?

On revient à mes moutons ça vous dit ? Bon bah après plus de lectures, je me dis que l’outil que je souhaite utiliser n’est peut-être pas le bon, je m’étais un peu enflammé avec le beau graphique du site que j’avais mis dans mon premier message. Je vous explique un peu plus en détail ce que je cherche à faire. Je me sers aussi de ce site qui me permet de voir les résultats de similarité en fonction de différentes méthodes (indice de jaccard, distance de levenshtein…). Je vous donne un petit exemple de mes documents :

1. Salut l’ami.
2. Salut l’ami ?
3. C’est nul.
4. Peut-être que je devrais vous donner un nom.

1. Salut, mon ami.
2. Mon ami ?
3. C’est nul.
4. Je devrais te donner un nom.

Bon, du coup, l’idée c’est que pour chaque ligne, il puisse avoir une comparaison. J’ai l’impression que l’outil que je voulais utiliser, le calcul de similarité en cosinus, sert habituellement à comprendre le sens des phrases, souvent pour des utilisations commerciales. Ex : “Qu’est-il arrivé à ma livraison” et “Ma commande n’a pas encore été livrée.” Les phrases ont donc le même sens. Or, moi, je m’en fou un peu du sens. Je veux juste savoir si mes phrases sont à peu près pareil. J’ai vu qu’il y avait pas mal d’outils différents en Traitement Automatique du Langage et c’est vrai que je m’y perds un peu, entre la lemmatisation, le stemming… J’ai l’impression que tous ces outils peuvent m’être utiles mais je ne sais pas lequel est le plus pertinent et le plus simple, sachant que de ce que je comprends, j’ai l’impression qu’ils sont à la base utilisés pour de faibles quantités de données, alors que je travaille sur une grosse base de données. En fait, des fois, j’ai mes données qui sont mal alignées :

5. Je vais vous demander de partir.

5. A tel point que je me suis posé des questions.

Je cherche donc à capter quand les phrases ne sont pas pareil, pour les remettre dans l’ordre. Voilà voilà, vous savez tout

Je me trompe peut-être, mais j’ai l’impression que tu cherches à créer un modèle conversationnel ? Si c’est le cas, je m’étais intéressé à Dialogflow, outil racheté par Google, qui te permet justement de gérer les complexités liées au traitement, et de te concentrer sur ce que tu veux faire avec.

Hm non. Je pense que l’exemple que j’ai pris t’a induit en erreur. Prenons un autre exemple. A la base mes textes sont plus ou moins comme ça :

texte1. Chronique. On sait que l’âge joue un rôle aggravant dans l’exposition à l’épidémie de Covid-19. Mais dans quelle mesure les conditions de vie et d’emploi en jouent-elles un ?

texte2. Chronique. L’âge joue un rôle important dans l’exposition à l’épidémie de Covid-19. Notamment les personnes âgées. Comment les conditions de vie et d’emploi en jouent-elles un ?

J’ai déjà fait en sorte que sur chaque ligne se trouve une phrase, de telle sorte que j’ai dans le texte 1 :

1. Chronique.
2. On sait que l’âge joue un rôle aggravant dans l’exposition à l’épidémie de Covid-19.
3. Mais dans quelle mesure les conditions de vie et d’emploi en jouent-elles un ?

En gros je bosse sur la traduction. Je veux voir si elles sont à peu près bonnes, sauf que des fois ça fait de la merde, et ça capte mal, ça ajoute des mots et donc des phrases (ici la ligne 3). Exemple sur mon fichier traduit :

1. Chronique.
2. L’âge joue un rôle important dans l’exposition à l’épidémie de Covid-19.
3. Notamment les personnes âgées.
4. Comment les conditions de vie et d’emploi en jouent-elles un ?

Analysons lignes par lignes.

1. Le mot est le même, c’est donc ok pour moi.
2. "On sait que" a été supprimé. Et "aggravant" a été remplacé par "important", mais la plupart des mots sont là, le sens ne change pas (j’avoue que j’ai du mal à savoir si je dois donner de l’importance au sens, mais bref)
3. Là, on a carrément une nouvelle phrase. J’aimerai en gros que mon programme comprenne que cette phrase est complètement différente de la ligne 3 du texte1. Quand c’est le cas, suppression de la phrase.
4. Notre Ligne 3 est donc supprimée. Cette ligne, la 4, devient donc la ligne 3. -> nouvelle analyse : comme la ligne 2, "Mais dans quelle mesure" a été remplacé par "comment", mais le sens est pareil, beaucoup de mots sont présents dans les deux phrases, du coup ok-> analyse des lignes suivantes.

C’est plus clair ?

Là,

Il te faut chercher un algo qui te donne des résultats convaincants. Vu ce que tu dis, tu peux commencer par un modèle très simple qui regarde par exemple le nombre de mots identiques dans les deux phrases et regarde également si les deux phrases ont à peu près la même taille.

phrases_1 = découper teste 1 en phrase
phrases_2 = découper texte 2 en phrase
Pour chaque (phrase_1, phrase2) dans (phrases1, phrases_2)
   mots_1 = découper phrase_1 en mots
   mots_2 = découper phrase_2 en mots
   nb_mots = nombre de mots dans mots_1 qui sont aussi dans mots_2
   max_mot = max(taille(mots_1), taille(mots_2))
   Si nb_mots/max_mot > SEUIL et que les deux mots n'ont pas des tailles trop différente
      C'est OK pour ces deux lignes.
   Fin Si
Fin Pour

On se rend compte qu’il y a plus dans ce que tu veux faire. Dans ton exemple, vu que la ligne 3 du deuxième fichier ne correspondait pas à la ligne 3 du premier fichier, tu l’as supprimé et ensuite tu as comparé la ligne 4 du deuxième fichier avec la ligne 1 du premier fichier. Est-ce que c’est toujours ce qu’il faudra faire ? Pourquoi c’est la ligne du deuxième fichier qui a été supprimé ? Comment sait-on que ce n’est pas dans le fichier 1 qu’il y a une ligne en trop (ou qu’il y a une ligne manquante dans le second fichier) ?

à partir de combien de temps pensez-vous que je peux être à même d’adapter du code en fonction de ce dont j’ai besoin ?

Au bout de deux ou trois semaines de travail régulier, tu devrais déjà être un peu autonome, et tu peux même aller plus vite. Pas la peine de prendre une formation compliquée. Tu suis un tutoriel sur les bases de Python et c’est bon. On a pleins de contenus sur Python qui pourront t’aider dont un sur les bases vu que tu as l’air d’être parti du côté de Python.

Mais celui qui est le plus conseillé pour débuter en Python est le cours de Gérard Swinnen. En gros, c’est un cours de plus de 400 pages avec plein d’exercices et qui aborde plusieurs aspects de Python (interface graphique, réseaux, BDD, etc.). Finalement, tu as moins de la moitié du livre (peut-être une petite centaine de pages) qui concerne les bases qui semblent t’intéresser (les chapitres de 1 à 10 sans le 8).

En particulier, le cours de Swinnen est conseillé parce qu’il ne s’agit pas d’un cours pour apprendre Python, il s’agit plus d’un cours pour apprendre à programmer, et pour ça on s’appuie sur Python. Donc avec lui, tu verras comment utiliser Python (sa syntaxe et tout), mais tu apprendras aussi à programmer (utiliser la syntaxe de Python pour obtenir ce que tu veux).

Pour améliorer l’algorithme de Karnaj, tu peux aller plus loin en utilisant des espaces sémantiques. Ton idée de départ, il me semble. Qui consiste à vectoriser les mots puis à les comparer dans un espace multidimensionnel.

Cet après-midi, je me suis amusé à coder un petit prototype :

#!/usr/bin/python3
# By Yarflam
from unicodedata import normalize, category
import math
import re

# Semantic space
class Semantic:
    def __init__(self):
        self._features = []
        self._maxLen = 0
    # Load some documents
    def loadDocs(self, docs):
        for i in range(0, len(docs)):
            docs[i] = self.cleanDoc(docs[i])
            for j in range(0, len(docs[i])):
                docs[i][j] = self.embedding(docs[i][j])
        return docs
    # Clean a document
    def cleanDoc(self, doc):
        doc = doc.lower()
        doc = ''.join((c for c in normalize('NFD', doc) if category(c) != 'Mn'))
        doc = re.sub(r'((^|\n) +| +(\n|$))', r'\3', re.sub('([^a-z0-9\n -]| +)', ' ', doc))
        return list(filter(None, doc.split('\n')))
    # Transform words to vector
    def embedding(self, words):
        vector = SmtcVector(self)
        words = words.split(' ')
        # For each word
        for i in range(0, len(words)):
            if not len(words[i]): continue
            # Add new feature
            if words[i] not in self._features:
                self._features.append(words[i])
            # Add the word
            vector.add(words[i])
            # Max Len (optional)
            self._maxLen = max(self._maxLen, len(words[i]))
        return vector
    # Calculate the distance between two vectors
    def dist(self, a, b):
        a, b = a.getValue(), b.getValue()
        fit = (len(list(filter(lambda x: x > 0, a)))
            + len(list(filter(lambda x: x > 0, b)))) / 2
        # Pythagorean theorem
        sum = 0
        for i in range(0, self._maxLen):
            sum += (b[i]-a[i]) * (b[i]-a[i])
        return math.sqrt(sum) / fit
    # Return the current features
    def getFeatures(self):
        self._features.sort()
        self._features.sort(key=len)
        return self._features
    # Return the maximum length
    def getMaxLen(self):
        return self._maxLen

# Semantic vector
class SmtcVector:
    def __init__(self, semantic):
        self._semantic = semantic
        self._value = []
    # Add a new word
    def add(self, word):
        self._value.append(word)
    # Return the value
    def getValue(self):
        ft = self._semantic.getFeatures()
        maxFt = 1/len(ft)
        vect = list((ft.index(x) + 1) * maxFt for x in self._value)
        vect += [0.] * (self._semantic.getMaxLen() - len(vect))
        return vect
    # Return the words (not transformed)
    def getWords(self):
        return ' '.join(self._value)
    # Show the vector
    def __str__(self):
        return '<'+', '.join(str(x) for x in self.getValue())+'>'

# Example
def main ():
    # Load the documents
    docs = []
    with open('a.txt', 'r') as f: docs.append(f.read())
    with open('b.txt', 'r') as f: docs.append(f.read())

    # Create a new semantic space
    app = Semantic()
    embeds = app.loadDocs(docs)
    print('Features:\n%s\n' % (', '.join(app.getFeatures())))

    # Evaluate the lines
    tolerance = 0.06
    for i in range(0, len(embeds[0])):
        for j in range(0, len(embeds[1])):
            d1, d2 = embeds[0][i], embeds[1][j]
            dist = app.dist(d1, d2)
            if dist < tolerance:
                print('L%s -> L%s' % ((i+1), (j+1)))
                print('D1: %s' % d1.getWords())
                print('D2: %s' % d2.getWords())
                print('V1: %s' % d1)
                print('V2: %s' % d2)
                print('Dist: %s' % dist)
                print(' ')

main()

Avec ces deux fichiers :

a.txt

Serpent d'argent    
Dragon des landes
Ange des landes
Mélomancien du ciel d'azur
Arachnide des ombres

b.txt

Serpent d'albâte
Dragon des landes
Mélomancien des ombres
Ange des landes
Goule de la nuit

J’obtiens en sortie :

Features:
d, de, du, la, des, ange, azur, ciel, nuit, goule, albate, argent, dragon, landes, ombres, serpent, arachnide, melomancien

L1 -> L1
D1: serpent d argent
D2: serpent d albate
V1: <0.8888888888888888, 0.05555555555555555, 0.6666666666666666, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0>
V2: <0.8888888888888888, 0.05555555555555555, 0.611111111111111, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0>
Dist: 0.018518518518518528
 
L2 -> L2
D1: dragon des landes
D2: dragon des landes
V1: <0.7222222222222222, 0.2777777777777778, 0.7777777777777777, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0>
V2: <0.7222222222222222, 0.2777777777777778, 0.7777777777777777, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0>
Dist: 0.0
 
L3 -> L4
D1: ange des landes
D2: ange des landes
V1: <0.3333333333333333, 0.2777777777777778, 0.7777777777777777, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0>
V2: <0.3333333333333333, 0.2777777777777778, 0.7777777777777777, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0>
Dist: 0.0
 
L5 -> L3
D1: arachnide des ombres
D2: melomancien des ombres
V1: <0.9444444444444444, 0.2777777777777778, 0.8333333333333333, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0>
V2: <1.0, 0.2777777777777778, 0.8333333333333333, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0>
Dist: 0.018518518518518528

Dans le debug, tu as l’association de chaque ligne puis successivement les valeurs et les vecteurs obtenus. Puis la distance correspondante qui avec un paramètre de tolérance, indiquera avec une plus ou moins grande précision leur relation.

J’ai essayé avec ton exemple, il a du mal avec le cas n°4 ; ça mériterait certainement des améliorations. Je sais qu’il existe les modèles Word2vec en association avec Tensorflow (voir ici), ce sera certainement plus performant. Après il faut que t’apprenne Python.

Wouah… Franchement je sais pas quoi dire ! Je trouve vraiment l’univers de la programmation fascinant. Quand je serais grand (j’ai 28ans) j’aimerais être programmeur haha. Autant il est passionnant de comprendre comment fonctionnent certains univers tels que l’économie, le droit, ou les médias, autant, il est vrai, l’informatique et la programmation a une place particulière. Karnaj et Yarflam.. Merci. Bon Yarflam clairement je sais pas combien de temps il t’a fallut pour maîtriser ce genre de trucs mais je trouve ces histoires d’espaces dimensionnels ouf ! Et Karnaj merci beaucoup c’est parfaitement ce dont j’avais besoin pour apprendre, je vais essayer de bien bosser tout seul et j’essaierai de revenir avec le "vrai" code. Et pour répondre à tes questions, je pense qu’il me sera plus facile d’y répondre une fois que j’aurai fait cette partie de code car j’ai le cerveau en surchauffe et ça sera mieux quand l’algo fera un peu le taff à ma place, je tiens pas en place j’arrive plus à réfléchir. En fait j’avais justement pensé à ça - comparer le nombre de mots de deux phrases, j’avais fait des stats manuellement et il y a une fréquence non négligeable intéressante à exploiter ; et j’avais aussi pensé au deuxième truc - au départ j’étais partis sur un dictionnaire et puis je me suis dit mais ça sert à rien autant prendre les mots de mes données ça facilite tellement la tâche. Et de savoir qu’il serait éventuellement possible de combiner les deux algorithmes, franchement c’est génial. Mille merci ! J’essaie de revenir vers vous le plus tôt possible avec du code que j’aurai bossé dans mon coin en suivant les tutos. Il me faut aussi plus de cas où j’ai des exceptions ça sera mieux pour travailler l’efficacité de l’algo car là j’en ai vraiment pas beaucoup. Bonne soirée à vous !