ist es möglich zu tun, fuzzy-match-merge mit python pandas?

Habe ich zwei DataFrames, die ich Zusammenführen möchten, basierend auf einer Spalte. Jedoch, aufgrund von alternativen Schreibweisen, unterschiedliche Anzahl von Leerzeichen, die Abwesenheit/Anwesenheit von diakritischen Zeichen, ich möchte in der Lage sein zu verschmelzen, solange Sie einander ähnlich.

Jedem ähnlichkeits-Algorithmus (soundex, Levenshtein, difflib).

Sagen ein DataFrame hat die folgenden Daten:

df1 = DataFrame([[1],[2],[3],[4],[5]], index=['one','two','three','four','five'], columns=['number'])

       number
one         1
two         2
three       3
four        4
five        5

df2 = DataFrame([['a'],['b'],['c'],['d'],['e']], index=['one','too','three','fours','five'], columns=['letter'])

      letter
one        a
too        b
three      c
fours      d
five       e

Dann möchte ich, um die daraus resultierenden DataFrame

       number letter
one         1      a
two         2      b
three       3      c
four        4      d
five        5      e

Ich habe gerade fusioniert ein paar hundert DataFrames gestern mit .rename, in der Regel ist dies eine ganz schnelle Lösung (obwohl ich denke, es hängt davon ab, wie viele Rechtschreibfehler vorhanden sind...) - und ich mag, um zu Steuern, welche Spalte die Namen sind wirklich ähnlich.
Vielleicht sollte ich etwas klarer (Bearbeiten Frage jetzt). Ich Zusammenführen möchten, auf ähnliche Werte zwischen den beiden DataFrames
Ja, mit d6tjoin MergeTop1 notebook

InformationsquelleAutor pocketfullofcheese | 2012-11-29

pandas python

Ähnlich wie @locojay Vorschlag, den Sie anwenden können, difflib's get_close_matches zu df2's index und dann eine join:

In [23]: import difflib 

In [24]: difflib.get_close_matches
Out[24]: <function difflib.get_close_matches>

In [25]: df2.index = df2.index.map(lambda x: difflib.get_close_matches(x, df1.index)[0])

In [26]: df2
Out[26]: 
      letter
one        a
two        b
three      c
four       d
five       e

In [31]: df1.join(df2)
Out[31]: 
       number letter
one         1      a
two         2      b
three       3      c
four        4      d
five        5      e

Wenn diese Spalten wurden, in der gleichen Vene, die Sie anwenden könnten, um die Spalte dann merge:

df1 = DataFrame([[1,'one'],[2,'two'],[3,'three'],[4,'four'],[5,'five']], columns=['number', 'name'])
df2 = DataFrame([['a','one'],['b','too'],['c','three'],['d','fours'],['e','five']], columns=['letter', 'name'])

df2['name'] = df2['name'].apply(lambda x: difflib.get_close_matches(x, df1['name'])[0])
df1.merge(df2)

Das ist toll. Während locojay, sofern die grundlegende Idee (und schneller) deine Beispiel-Implementierung wird die Antwort akzeptiert. Macht es einfacher zu testen. Upvote für die Bereitstellung von index-und Spalten-basierte Antworten!
Weiß jemand, ob es einen Weg gibt, dies zu tun, zwischen den Zeilen der einen Spalte? Ich bin versucht, Duplikate zu finden, die möglicherweise Tippfehler
Sie können verwenden Sie n=1 beschränken, die Ergebnisse zu 1. docs.python.org/3/library/...
Funktioniert nicht wenn es mehrere Spiele.
Wie gehen Sie vor, wenn die beiden dataframes unterschiedliche Längen haben?

InformationsquelleAutor Andy Hayden

10

Habe ich geschrieben, ein Python-Paket, welches darauf abzielt, dieses problem zu lösen:

pip install fuzzymatcher

Finden Sie die repo - hier und docs hier.

Grundlegende Verwendung:

Gegeben zwei dataframes df_left und df_right, die Sie wollen, um fuzzy-Verknüpfung, können Sie die folgenden schreiben:
```
from fuzzymatcher import link_table, fuzzy_left_join

# Columns to match on from df_left
left_on = ["fname", "mname", "lname",  "dob"]

# Columns to match on from df_right
right_on = ["name", "middlename", "surname", "date"]

# The link table potentially contains several matches for each record
fuzzymatcher.link_table(df_left, df_right, left_on, right_on)
```
Oder wenn Sie wollen einfach nur auf den link am ähnlichsten ist:
```
fuzzymatcher.fuzzy_left_join(df_left, df_right, left_on, right_on)
```
Wäre schon genial, wenn es nicht hatte so viele Abhängigkeiten, ehrlich gesagt, zuerst hatte ich zum installieren von visual studio build-tool, jetzt bekomme ich die Fehlermeldung: no such module: fts4

InformationsquelleAutor RobinL

Ich würde Jaro-Winkler, denn es ist eines der am meisten robust und präzise Ungefähre string-matching-algorithmen, die derzeit verfügbar [Cohen, et al.], [Winkler].

Dies ist, wie ich es tun würde, mit Jaro-Winkler von der Quallen Paket:

def get_closest_match(x, list_strings):

  best_match = None
  highest_jw = 0

  for current_string in list_strings:
    current_score = jellyfish.jaro_winkler(x, current_string)

    if(current_score > highest_jw):
      highest_jw = current_score
      best_match = current_string

  return best_match

df1 = pandas.DataFrame([[1],[2],[3],[4],[5]], index=['one','two','three','four','five'], columns=['number'])
df2 = pandas.DataFrame([['a'],['b'],['c'],['d'],['e']], index=['one','too','three','fours','five'], columns=['letter'])

df2.index = df2.index.map(lambda x: get_closest_match(x, df1.index))

df1.join(df2)

Ausgabe:

    number  letter
one     1   a
two     2   b
three   3   c
four    4   d
five    5   e

wie wäre def get_closest_match(x, list_strings): return sortiert(list_strings, key=lambda y: Quallen.jaro_winkler(x, y), reverse=True)[0]
Gibt es eine Möglichkeit, um diese Fahrt? Dieser code nicht gut zu skalieren.

InformationsquelleAutor lostsoul29

5

http://pandas.pydata.org/pandas-docs/dev/merging.html nicht über eine hook-Funktion zu tun, diese on-the-fly. Wäre schön, wenn...

Würde ich nur tun, in einem separaten Schritt, und verwenden Sie difflib getclosest_matches zum erstellen einer neuen Spalte in einer der 2 dataframes und der merge/join auf die fuzzy-abgestimmt Spalte

Könnten Sie erklären, wie man difflib.get_closest_matches zu schaffen, wie eine Spalte und dann Zusammenführen?

InformationsquelleAutor locojay
2

Als ein heads-up, das im Grunde funktioniert, außer wenn keine übereinstimmung gefunden wird, oder wenn Sie haben NaNs entweder Spalte. Anstatt direkt anwenden get_close_matches fand ich es einfacher in der Anwendung die folgende Funktion. Die Wahl von NaN Ersatz hängt viel von Ihrem dataset.
```
def fuzzy_match(a, b):
    left = '1' if pd.isnull(a) else a
    right = b.fillna('2')
    out = difflib.get_close_matches(left, right)
    return out[0] if out else np.NaN
```
InformationsquelleAutor Luke
1

Können Sie d6tjoin für das
```
import d6tjoin.top1
d6tjoin.top1.MergeTop1(df1.reset_index(),df2.reset_index(),
       fuzzy_left_on=['index'],fuzzy_right_on=['index']).merge()['merged']
```
index number index_right letter 0 one 1 one a 1 two 2 too b 2 three 3 three c 3 four 4 fours d 4 five 5 five e

Es hat eine Vielzahl von zusätzlichen Funktionen wie:
- check-join-quality, pre-und post-join
- anpassen ähnlichkeit der Funktion, z.B. edit-Distanz vs hamming-Distanz
- angeben, max Abstand
- multi-core-compute -
Details siehe
- MergeTop1 Beispiele - Besten-match-join-Beispiele notebook
- PreJoin Beispiele - Beispiele für die Diagnose von join-Problemen
Das ist eigentlich wirklich nützlich, danke!
Gerade getestet, es gibt mir seltsame Ergebnisse zurück, beispielsweise die abgestimmten government mit business, gibt es eine Möglichkeit, konfigurieren Sie den Schwellenwert für die matching-Punktzahl?
Ja, siehe Referenz-docs, die Sie übergeben können top_limit - und vielleicht wollen Sie auch zu ändern fun_diff zu fun_diff=[affinegap.affineGapDistance] die dazu neigt, zu geben, besser entspricht.

InformationsquelleAutor citynorman

Mit `fuzzywuzzy`

Da gibt es keine Beispiele mit der fuzzywuzzy Paket, hier ist eine Funktion, die ich schrieb, wird wieder alle Spiele basierend auf einem Schwellenwert können Sie festlegen, wie ein Benutzer:

Beispiel datframe

df1 = pd.DataFrame({'Key':['Apple', 'Banana', 'Orange', 'Strawberry']})
df2 = pd.DataFrame({'Key':['Aple', 'Mango', 'Orag', 'Straw', 'Bannanna', 'Berry']})

# df1
          Key
0       Apple
1      Banana
2      Orange
3  Strawberry

# df2
        Key
0      Aple
1     Mango
2      Orag
3     Straw
4  Bannanna
5     Berry

- Funktion für das fuzzy-matching -

def fuzzy_merge(df_1, df_2, key1, key2, threshold=90, limit=2):
    '''
    df_1 is the left table to join
    df_2 is the right table to join
    key1 is the key column of the left table
    key2 is the key column of the right table
    threshold is how close the matches should be to return a match
    limit is the amount of matches will get returned, these are sorted high to low
    '''
    s = df_2[key2].tolist()

    m = df_1[key1].apply(lambda x: process.extract(x, s, limit=limit))    
    df_1['matches'] = m

    m2 = df_1['matches'].apply(lambda x: ', '.join([i[0] for i in x if i[1] >= threshold]))
    df_1['matches'] = m2

    return df_1

Mit unserer Funktion auf der dataframes: #1

from fuzzywuzzy import fuzz
from fuzzywuzzy import process

fuzzy_merge(df1, df2, 'Key', 'Key', threshold=80)

          Key       matches
0       Apple          Aple
1      Banana      Bannanna
2      Orange          Orag
3  Strawberry  Straw, Berry

Mit unserer Funktion auf der dataframes: #2

df1 = pd.DataFrame({'Col1':['Microsoft', 'Google', 'Amazon', 'IBM']})
df2 = pd.DataFrame({'Col2':['Mcrsoft', 'gogle', 'Amason', 'BIM']})

fuzzy_merge(df1, df2, 'Col1', 'Col2', 80)

        Col1  matches
0  Microsoft  Mcrsoft
1     Google    gogle
2     Amazon   Amason
3        IBM

Installation:

Pip

pip install fuzzywuzzy

Anaconda

conda install -c conda-forge fuzzywuzzy

InformationsquelleAutor Erfan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Mit fuzzywuzzy

Installation:

Mit `fuzzywuzzy`