J'ai une colonne qui comprend des mots similaires dans un dataframe pandas:

My_Column
thereisacat
there-is_cat
mummy
mommy
mammy
Daniel-1
Daniel 
Bob

Je voudrais créer une colonne dans laquelle j'inclus pour chaque ligne les mots les plus similaires, par exemple:

My_Column        Similar_to
thereisacat     [there-is_cat]
there-is_cat    [thereisacat]
mummy           [mommy, mammy]
mommy           [mummy, mammy]
mammy           [mummy, mommy]
Daniel-1        [Daniel]
Daniel          [Daniel-1]
Bob             []

Pour calculer la similitude, je considère ce qui suit:

(1)

import nltk
nltk.edit_distance()

(2)

 import difflib
        seq = difflib.SequenceMatcher()

(3)

 import jellyfish
    jellyfish.levenshtein_distance() # or jellyfish.jaro_distance()

Je voudrais savoir comment je pourrais appliquer l'un de ces trois algorithmes pour créer une colonne qui répertorie les mots les plus similaires à ceux de My_Column.

Si j'ai raison (peut-être pas mon code), ce que je devrais faire est de créer une matrice qui inclut toutes les lignes de My_Column sous forme de colonnes afin d'attribuer une valeur de similitude puis d'extraire la plus similaire. Quelque chose comme ça:

def sim_metric(col1, col2): # actually should be more
    return SequenceMatcher(None, df[col1], df[col2]).ratio()

df['Similar_to'] = df.apply(sim_metric,
                          axis=1)
1
user14430348 5 nov. 2020 à 05:23

2 réponses

Meilleure réponse

Tout d'abord, créez une matrice de similarité, puis filtrez la matrice en utilisant un certain seuil et ajoutez les résultats.

import pandas as pd
import numpy as np
import nltk

similarity = {}
similiar_words = []
thresh = 3

df = pd.read_clipboard()

for word in df.My_Column:
    scores = {}
    for match in df.My_Column:
        score = nltk.edit_distance(word, match)
        scores[match] = score
    similarity[word] = scores

matrix_df = pd.DataFrame(similarity) 

for value in matrix_df.to_dict('dict').values():
    similiar_words.append([key for key, val in value.items() if 0 < val < thresh])

df['Similar_to'] = similiar_words

df

Out[1]: 
      My_Column      Similar_to
0   thereisacat  [there-is_cat]
1  there-is_cat   [thereisacat]
2         mummy  [mommy, mammy]
3         mommy  [mummy, mammy]
4         mammy  [mummy, mommy]
5      Daniel-1        [Daniel]
6        Daniel      [Daniel-1]
7           Bob              []
0
Michael Gardner 5 nov. 2020 à 05:06

Cela devrait aider:

from itertools import product

unique_words = set(df['My_column'])

similarity_matrix = {key: distance_algo(key[0], key[1]) for key in list(product(list(unique_words),repeat = 2))}

similar_to_map = {}
for word in unique_words:
  wlist = [(sword, similarity_matrix[(word, sword)]) for sword in unique_words if sword is not word]
  wlist = wlist.sort(key=lambda x: x[1])
  similar_to_map[word] = wlist[0][0]

df['Similar_to'] = df['My_column'].apply(lambda x: similar_to_map[x], axis=0)
0
Michael Gardner 5 nov. 2020 à 03:30