Die Berechnung der ähnlichkeit zwischen zwei Listen

Ich würde gerne zur Berechnung der ähnlichkeit zwischen zwei Listen von verschiedenen Längen.

zB:

listA = ['apple', 'orange', 'apple', 'apple', 'banana', 'orange'] # (length = 6)
listB = ['apple', 'orange', 'grapefruit', 'apple'] # (length = 4)

wie Sie sehen können, ein einzelnes Objekt kann mehrere Male angezeigt in einer Liste, und die Längen sind in verschiedenen Größen.

Habe ich mir bereits gedacht vergleicht man die Frequenzen der einzelnen Elemente, aber das umfasst nicht die Größe der einzelnen Liste (eine Liste, die ist einfach zweimal, eine weitere Liste sollte ähnlich sein, aber nicht perfekt ähnlich)

eg2:

listA = ['apple', 'apple', 'orange', 'orange']
listB = ['apple', 'orange']
similarity(listA, listB) # should NOT equal 1

Also habe ich im Grunde wollen umfassen die Größe der Listen und die Verteilung der Elemente in der Liste.

Irgendwelche Ideen?

Das sind Listen, keine sets.
Durch similarity willst du damit erstellen Sie eine Dritte Liste enthält die Elemente, die in beiden listA und listB? so dass das Ergebnis in deinem Fall wäre ['apple', 'orange']?
durch die ähnlichkeit, die ich meine, einige Messen, wie ähnlich Sie sind. so ein Vergleich 2 identische Sätze (oder Liste) würde geben Ihnen einen score von 1 und 2 komplett unterschiedlichen sets geben würde, ist Sie null. diese Sätze sind allerdings von unterschiedlicher Größe, und enthalten sich wiederholende Elemente

InformationsquelleAutor kmace | 2013-02-06

17

Verwenden Sammlungen.Counter() vielleicht; diese sind in multi-sets, oder Taschen, in datatype-Sprachgebrauch:
```
from collections import Counter

counterA = Counter(listA)
counterB = Counter(listB)
```
Jetzt können Sie vergleichen diese, indem Sie Einträge oder Frequenzen:
```
>>> counterA
Counter({'apple': 3, 'orange': 2, 'banana': 1})
>>> counterB
Counter({'apple': 2, 'orange': 1, 'grapefruit': 1})
>>> counterA - counterB
Counter({'orange': 1, 'apple': 1, 'banana': 1})
>>> counterB - counterA
Counter({'grapefruit': 1})
```
Können Sie berechnen, Ihre Kosinus-ähnlichkeit mit:
```
import math

def counter_cosine_similarity(c1, c2):
    terms = set(c1).union(c2)
    dotprod = sum(c1.get(k, 0) * c2.get(k, 0) for k in terms)
    magA = math.sqrt(sum(c1.get(k, 0)**2 for k in terms))
    magB = math.sqrt(sum(c2.get(k, 0)**2 for k in terms))
    return dotprod / (magA * magB)
```
Gibt:
```
>>> counter_cosine_similarity(counterA, counterB)
0.8728715609439696
```
Je näher an 1, der Wert ist, desto ähnlicher sind die zwei Listen sind.

Die Kosinus-ähnlichkeit ist eine score berechnen zu können. Wenn Sie sich sorgen über die Länge der Liste, können Sie berechnen, andere; wenn Sie halten, dass die Punktzahl zwischen 0,0 und 1,0, wie gut Sie können, multiplizieren Sie die beiden Werte für eine final-score zwischen -1.0 und 1.0).

Zum Beispiel, um relative Längen in Konto, das Sie verwenden könnten:
```
def length_similarity(c1, c2):
    lenc1 = sum(c1.itervalues())
    lenc2 = sum(c2.itervalues())
    return min(lenc1, lenc2) / float(max(lenc1, lenc2))
```
und dann kombinieren Sie in einer Funktion, die Listen als Eingaben:
```
def similarity_score(l1, l2):
    c1, c2 = Counter(l1), Counter(l2)
    return length_similarity(c1, c2) * counter_cosine_similarity(c1, c2)  
```
Für deine beiden Beispiel zeigt, dass die Ergebnisse in:
```
>>> similarity_score(['apple', 'orange', 'apple', 'apple', 'banana', 'orange'], ['apple', 'orange', 'grapefruit', 'apple'])
0.5819143739626463
>>> similarity_score(['apple', 'apple', 'orange', 'orange'], ['apple', 'orange'])
0.4999999999999999
```
Können Sie mischen in anderen Metriken, wie gebraucht.
- diese Art der arbeiten, aber wenn wir uns an das Beispiel, wo die Liste c1 ist nur eine doppelte Zählung von c2, dann ist die ähnlichkeit noch 1. also nicht genau das, was ich Suche. vielen Dank für den code obwohl.
- Dies ist der Ausgangspunkt; wenn die cos ähnlichkeit ist 1, zu sehen, wenn man eine größere top-Zählung als der andere (.most_common(1) auf beiden) einstellen, etc.
- Wenn Sie nicht möchten, dass die Länge normalisierte score, der die Kosinus-Distanz bietet an, Sie berechnen die euklidische Distanz zwischen den beiden Listen
InformationsquelleAutor Martijn Pieters
1

Aus theoretischer Sicht : ich empfehle Ihnen, schauen bis Kosinus-ähnlichkeit
http://en.wikipedia.org/wiki/Cosine_similarity

Müssen Sie möglicherweise ändern, passen Sie Ihre Regelung, sondern die Idee der Kosinus-ähnlichkeit ist groß.

InformationsquelleAutor Vigneshwaren
0

Ich glaube was du suchst ist zum zählen der Anzahl der Inversionen in einem array
Die Frage hat Ihre Antwort: Zählen Inversionen in einem array
- Tut mir Leid, aber ich bin mir nicht sicher, ob ich das bekomme, was du meinst. Wie kann man zwei Sätze übersetzt werden, zählen die Anzahl der Inversionen in einer Implementierung von merge-sort?
InformationsquelleAutor Computernerd

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.