Philben - Ms Access » Similarité

VBA : Exemple comparatif des indices de similarité

philben — Sat, 07 Sep 2013 17:38:26 +0000

Après avoir vu différents algorithmes de similarité dans des billets précédents, je vous propose un petit comparatif à travers un exemple qui consiste à trouver le doublon de restaurants par leur nom, adresse, téléphone et type de cusine.

Les données
Les données sont issues d’un exemple connu de recherche de doublons et sont présentées ici dans une seule colonne où nom, adresse, téléphone et type de cuisine sont fusionnés. Le fichier de données contient 224 lignes et chaque resto possède un et un seul doublon. Cet exemple reste donc plus simple qu’un cas général de recherche de doublons…
Extrait du fichier :

Katsu 1972 Hillhurst Ave. Los Feliz 213-665-1891 Japanese
Restaurant Katsu 1972 N. Hillhurst Ave. Los Angeles 213/665-1891 Asian
Les Celebrites 155 W. 58th St. New York City 212-484-5113 French (Classic)
Les Célébrités 160 Central Park S New York 212/484-5113 French

Une difficulté s’ajoute pour le dernier restaurant car les ‘é’ de Célébrités sont convertis en HTML (& eacute;)…

Le fichier source original est ici.

Principe
Le principe est donc de rechercher pour chaque ligne, le restaurant qui a la similarité la plus forte soit 49 952 mesures (224 x 223) après conversion des chaînes en majuscule.
Pour chaque restaurant, je considère que le bon doublon a été correctement trouvé s’il arrive avec le plus fort indice par rapport aux 222 autres restaurants.
J’ai comparé les 3 algorithmes Jaro-Winkler (JW), Damerau-Levenshtein (DL) et les 6 indices Cosinus/Dice/Jaccard/… (IS), en recherchant pour chacun la meilleure configuration.

Résultats
Concernant DL, pas de problème pour trouver la meilleure configuration car il suffit de passer les 2 chaînes en argument de la fonction.
Damerau-Levenshtein a permis de détecter 185 doublons sur 224 soit 82,6% de réussite.

Concernant Jaro-Winkler, on peut jouer sur la longueur du préfixe entre 0 et 4. Les résultats obtenus sont :

Longueur préfixe Doublons détectés
0 206
1 209
2 214
3 213
4 212

Dans cet exemple, la meilleure longueur de préfixe est 2 avec 214 doublons détectés soit un taux de réussite de 95,5%, la distance de Jaro seule (0) donne le moins bon résultat.

Enfin pour l’algorithme IS, le choix du paramétrage est plus complexe car on peut choisir entre 6 indices de similarités, la longueur des Grammes (0 = mot à 5), l’inversion ou non des grammes et une distance maximum de recherche des grammes communs.
Pour la distance maxi, j’ai laissé à -1 (pas de limite de distance) car elle fournit les meilleurs résultats dans cet exemple et la recherche de grammes inversés donne ici de moins bons résultats.

J’ai donc joué sur le reste des paramètres (type d’indice et longueur des grammes) et les résultats sont synthétisés ici :

Les unigrammes (1) ont les moins bon résultats, la variabilité des résultats entre les indices diminue avec la longueur des grammes, les trigrammes et Simpson ont en moyenne les meilleurs résultats.

Pourcentage de réussite des indices en fonction de la longueur des grammes :

Finalement, l’indice de Simpson avec des bigrammes donne ici le meilleur résultat : 219 doublons détectés soit 97,8% de réussite !

Le tableau suivant indique le nombre de doublons détectés par position des résultats hormis le Top 1. Par exemple, 18 nouvelles bonnes détections faites par DL dans les Top 2 des résultats et Simpson en détecte 4 soit 223 détections cumulées (Top 1 et Top 2) sur 224 !.

Après avoir vu rapidement la capacité des indices à détecter les vrais doublons, il faut vérifier leur capacité à être discriminant entre les restaurants et compter les éventuels ex aequo.
Imaginez un algo qui retourne un indice identique pour tous les restos : Ses résultats seraient parfaits mais pour chaque restaurant on aurait 223 restaurants détectés dans le Top 1 !

Via une requête, j’ai donc calculé la position absolue du vrai doublon pour chaque algorithme et chaque ligne. Des ex aequo sont présents si la position absolue est supérieure au classement.

Indice Classement Position absolue
---------------------------------------
JW 28 29
---------------------------------------
IS 1 2
---------------------------------------
DL 2 3
DL 2 4
DL 3 6
DL 4 6
DL 4 5
DL 5 9
DL 5 6
DL 6 7
DL 7 12
DL 9 11
DL 12 20
DL 17 21
DL 24 66

JW n’est affecté qu’une fois par un ex aequo et ceci pour un classement du vrai doublon en 28ème position.
IS en a obtenu un seul sur un Top 1 et DL a eu 13 fois un ou plusieurs ex aequo.

Conclusion
Dans cet exemple, l’indice de Simpson a détecté le plus de doublons dans le Top 1 (219 sur 224) et 223 dans le Top 2 des résultats.
Si vous le souhaitez, vous pouvez ajouter vos propres résultats de vos algorithmes en commentaire du billet.

Philippe

VBA : Distance de Jaro-Winkler

philben — Sat, 31 Aug 2013 03:01:16 +0000

Cet algorithme mesure la similarité entre deux chaînes de caractères pour la recherche de doublons par exemple. Tout comme les algorithmes de Damerau-Levenshtein et les indices de similarité Cosinus, Dice, Jaccard…, la distance est normalisée entre 0 et 1. Plus la similarité est forte plus la distance tend vers 1.

La fonction VBA

Public Function JaroWinkler(ByVal s1 As String, ByVal s2 As String, _
Optional ByVal LongueurPrefixe As Byte = 3, _
Optional ByVal TypeComparaison As VbCompareMethod = vbBinaryCompare) As Single
'La distance de jaro_Winkler mesure la similarité entre deux chaines de caractères (s1 et s2)
'La distance est normalisée entre 0 et 1 (1 = similarité maximale)
'si LongueurPrefixe [0,4] = 0 => Distance de Jaro
'Référence : http://fr.wikipedia.org/wiki/Distance_de_Jaro-Winkler et références
'Remarques : Préparation parfois nécessaire des chaînes : ucase(),trim(),diacritiques
' Quelques libertés prises pour le calcul de la fenêtre (dMax) / Wikipédia
'Auteur : Philben v1.0 - Free to use
Const cMaxLongueurPrefixe As Byte = 4, cCoeffPrefixe As Single = 0.1
Dim l1 As Long, l2 As Long, dMax As Long, i As Long, j As Long, k As Long
Dim jMin As Long, jMax As Long, m As Long, t As Long, p As Long, lam1 As Long
Dim c1 As String, r As Single, aUsed() As Boolean, ac2() As String, am1() As Long

l1 = Len(s1): l2 = Len(s2)
If l1 > 0 And l2 > 0 Then
ReDim aUsed(1 To l2): ReDim ac2(1 To l2)
For i = 1 To l2: ac2(i) = Mid$(s2, i, 1): Next i

If l1 >= l2 Then
'dMax (1/2 fenêtre) calculée avec la + courte chaîne et non la + longue ! (voir blog)
dMax = (l2 + 1) \ 2 - 1 'arrondi sup. de dMax (l=1 => 0, l=2 => 0, l=3 => 1)
Else
dMax = (l1 + 1) \ 2 - 1
End If
If LongueurPrefixe > cMaxLongueurPrefixe Then LongueurPrefixe = cMaxLongueurPrefixe

jMin = 1
If dMax < l2 Then jMax = dMax Else: jMax = l2
For i = 1 To l1
c1 = Mid$(s1, i, 1)

If i > dMax + 1 Then jMin = jMin + 1
If jMax < l2 Then jMax = jMax + 1
If jMin > jMax Then Exit For 'définitivement hors fenêtre => Fin

For j = jMin To jMax
If Not aUsed(j) Then
If StrComp(c1, ac2(j), TypeComparaison) = 0 Then
m = m + 1 'Match
If i = j And i <= LongueurPrefixe And p = i - 1 Then
p = p + 1 'Préfixe commun
Else
lam1 = lam1 + 1: ReDim Preserve am1(1 To lam1): am1(lam1) = i
End If
aUsed(j) = True
Exit For
End If
End If
Next j
Next i

'Compte les tranpositions
k = p + 1
For i = 1 To lam1
For j = k To l2
If aUsed(j) Then Exit For
Next j
If StrComp(Mid$(s1, am1(i), 1), ac2(j), TypeComparaison) <> 0 Then t = t + 1
k = j + 1
Next i
t = t \ 2

If m > 0 Then
r = (m / l1 + m / l2 + (m - t) / m) / 3 'Distance de Jaro
r = r + (p * cCoeffPrefixe * (1 - r)) 'Extension de Winkler
End If
End If

JaroWinkler = r
End Function

Paramètres de la fonction
‘S1′ et ‘S2′ correspondent aux deux chaînes de caractères à étudier.
‘LongueurPrefixe’ permet de choisir la longueur du préfixe commun entre les deux chaînes. Cette longueur permet de calculer l’apport de Winkler à l’algorithme de Jaro. Cette longueur est comprise entre 0 et 4 (3 par défaut). La distance de Jaro est retournée lorsque ce paramètre est égal à 0.
‘TypeComparaison’ permet de choisir le type de comparaison entre les deux chaînes : Soit une comparaison binaire (par défaut) soit une comparaison textuelle (moins restrictive car ne tient pas compte de la casse des caractères mais généralement moins performante).
Il sera souvent nécessaire de prétraiter les chaînes par UCase()/LCase() (casse uniforme des caractères), Trim() (suppression des espaces en début et fin de chaîne) et remplacer les caractères diacritiques pour ne pas ‘parasiter’ l’algorithme (voir ici).

Tests
J’ai récolté dans une publication de W. E. Winkler (voir référence plus bas) et sur le Web des exemples pour tester les résultats de mon code. La longueur du préfixe est fixée à 4.

Public Function testJW()
Dim i As Integer, r As Single, v() As Variant

v = Array("SHACKLEFORD", "SHACKELFORD", 0.982, "DUNNINGHAM", "CUNNIGHAM", 0.896, "NICHLESON", "NICHULSON", 0.956, _
"JONES", "JOHNSON", 0.832, "MASSEY", "MASSIE", 0.933, "ABROMS", "ABRAMS", 0.922, "HARDIN", "MARTINEZ", 0#, _
"ITMAN", "SMITH", 0#, "JERALDINE", "GERALDINE", 0.926, "MARHTA", "MARTHA", 0.961, "MICHELLE", "MICHAEL", 0.921, _
"JULIES", "JULIUS", 0.933, "TANYA", "TONYA", 0.88, "DWAYNE", "DUANE", 0.84, "SEAN", "SUSAN", 0.805, _
"JON", "JOHN", 0.933, "JON", "JAN", 0#, "DIXON", "DICKSONX", 0.813, "VOYAGE", "AGENDA", 0.444, _
"TRAVEL", "TRAIN", 0.9, "ABCVWXYZ", "CABVWXYZ", 0.958)

Debug.Print "Chaîne 1", "Chaîne 2", "Attendue", "Obtenue"
Debug.Print "--------", "--------", "---------", "-------"
For i = LBound(v) To UBound(v) Step 3
r = JaroWinkler(v(i), v(i + 1), 4) 'Longueur Prefixe = 4
Debug.Print v(i), v(i + 1), v(i + 2), Round(r, 3), IIf(Abs(r - v(i + 2)) > 0.001, "*** Ecart ***", "")
Next i
End Function

Résultats et commentaires

Chaîne 1 Chaîne 2 Attendue Obtenue
-------- -------- --------- -------
SHACKLEFORD SHACKELFORD 0,982 0,982
DUNNINGHAM CUNNIGHAM 0,896 0,896
NICHLESON NICHULSON 0,956 0,956
JONES JOHNSON 0,832 0,832
MASSEY MASSIE 0,933 0,933
ABROMS ABRAMS 0,922 0,922
HARDIN MARTINEZ 0 0,722 *** Ecart ***
ITMAN SMITH 0 0,622 *** Ecart ***
JERALDINE GERALDINE 0,926 0,926
MARHTA MARTHA 0,961 0,961
MICHELLE MICHAEL 0,921 0,921
JULIES JULIUS 0,933 0,933
TANYA TONYA 0,88 0,88
DWAYNE DUANE 0,84 0,84
SEAN SUSAN 0,805 0,805
JON JOHN 0,933 0,933
JON JAN 0 0,8 *** Ecart ***
DIXON DICKSONX 0,813 0,813
VOYAGE AGENDA 0,444 0,444
TRAVEL TRAIN 0,9 0,79 *** Ecart ***
ABCVWXYZ CABVWXYZ 0,958 0,958

Les distances obtenues sont parfois différentes des distances attendues (4 écarts constatés).
Concernant les couples HARDIN/MARTINEZ, ITMAN/SMITH, JON/JAN, ils sont fournis par W. E. Winkler qui devait utiliser un algo un peu différent de celui décrit dans Wikipédia (en effet, sa fonction strcomp.c est plus complexe…)

Concernant le couple TRAVEL/TRAIN et la distance attendue de 0,9, je pense qu’il s’agit d’une coquille de l’auteur car la distance de Jaro dans la même publication était seulement de 0,7.

De plus, l’applet java de ce site donne des résultats proches ou identiques aux miens.

Remarque
L’éloignement maximal (variable dMax dans mon code) devrait être calculé à l’aide de la plus grande longueur de chaîne. J’ai préféré utiliser la plus courte pour éviter des résultats ‘étonnants’ avec certaines chaînes de caractères.
Par exemple, en allongeant la seconde chaîne ‘cba’ et en utilisant la plus grande longueur des deux chaînes de caractères, on obtient :

?JaroWinkler("abc","cba") '0,556
?JaroWinkler("abc","cbau") '0,528
?JaroWinkler("abc","cbauu") '0,756
?JaroWinkler("abc","cbauuu") '0,722

La similarité diminue avec 4 caractères (0,528) puis augmente paradoxalement avec 5 caractères (‘cbauu’ donne 0,756)!
Pourquoi ?
Dans le 1er exemple, l’éloignement maximal (variable dMax dans le code) est égal à 1 et on obtient une seule concordance (lettre ‘b’) entre les 2 chaînes.
Dans le 2ème exemple, la similarité chute légèrement car la longueur de la chaîne n°2 est de 4 au lieu de 3 et celle-ci intervient en tant que dénominateur dans le calcul de la distance de Jaro. L’éloignement maximal reste égal à 1.
Dans le 3ème exemple, l’éloignement maximal est égal à 2 car la longueur de la chaîne n°2 est de 5 caractères (arrondi supérieur de 5/2 – 1 = 2). Cet éloignement permet d’obtenir 3 correspondances (‘a’, ‘b’, ‘c’) et une transposition (‘a’ et ‘c’). Ces 3 correspondances au lieu d’une seule augmentent la similarité malgré la transposition et la longueur de la chaîne n°2.

Pour éviter ce problème, une solution consiste donc à utiliser la plus petite longueur des deux chaînes :

?JaroWinkler("abc","cba") '0,556
?JaroWinkler("abc","cbau") '0,528
?JaroWinkler("abc","cbauu") '0,511
?JaroWinkler("abc","cbauuu") '0,5

Conclusion
Algorithme rapide et efficace sur des chaînes relativement courtes.

Références
Wikipédia: Distance de Jaro-Winkler
Publication de W. E. Winkler.

Philippe

Indices de similarité entre deux chaînes de caractères

philben — Mon, 24 Sep 2012 00:32:03 +0000

Après l’algorithme de Damerau-Levenshtein qui mesure la distance minimale d’édition entre deux textes, je présente un algorithme plus simple et donc plus rapide qui calcule différents indices de similarité (Cosinus, Dice, Jaccard, Kulczynski,…) à partir de n-grammes (n-grams/q-grams en anglais) ou sous-séquences continues de caractères.

Les fonctions
Placer l’ensemble du code suivant dans un module standard.

L’énumération pour faciliter le choix du coefficient de similarité :

Public Enum eIndiceSimilarite
eCosinus = 1
eDice = 2
eJaccard = 3
eKulczynski = 4
eBraunBlanquet = 5
eSimpson = 6
End Enum

La fonction Ngram appelée par la fonction principale pour créer les grammes de la chaîne :

Private Function Ngram(ByRef qgs() As String, ByVal s As String, ByVal Q As Integer, ByVal InversionGram As Boolean) As Integer
Dim i As Integer, n As Integer, Fin As String
If Q > 0 Then
If Q > 1 Then
If InversionGram Then Fin = vbVerticalTab Else: Fin = vbFormFeed
s = String(Q - 1, vbVerticalTab) & s & String(Q - 1, Fin)
End If
n = Len(s) - Q: ReDim qgs(0 To n)
For i = 0 To n: qgs(i) = Mid$(s, i + 1, Q): Next i
Ngram = n + 1
Else
qgs = Split(s, " ", , vbBinaryCompare)
Ngram = UBound(qgs) + 1
End If
End Function

La fonction principale :

Public Function IndiceSimilarite(ByVal s1 As String, ByVal s2 As String, _
Optional ByVal Indice As eIndiceSimilarite = eIndiceSimilarite.eDice, _
Optional ByVal TypeNgram As Integer = 1, _
Optional ByVal InversionGram As Boolean = False, _
Optional ByVal MaxDistance As Integer = -1, _
Optional ByVal TypeComparaison As VbCompareMethod = vbBinaryCompare) As Single
'Retourne un indice de similarité [0 à 1] entre deux phrases
'Options : Indice : Choix de l'indice calculé (Cosinus, Dice, Jaccard, Kulczynski, BraunBlanquet)
' : TypeNgram : longueur des sous-séquences (0 : mot, 1 = caractère,...,5)
' : InversionGram : Recherche une inversion du gram :'ch' -> 'hc' (sauf pour TypeNgram = 1 !)
' : MaxDistance : distance maximum (en gram) de recherche (-1 = pas de limite)
' : TypeComparaison : binaire ou textuelle
'Remarque: parfois nécessaire de prétraiter les chaînes (ucase(),trim(),sans diacritique,...)
'Auteur : Philben - v1.0 - Free to use

Const cMaxLen As Long = 256&, cMinNgram As Integer = 0, cMaxNgram As Integer = 5
Dim l1 As Long, l2 As Long, i As Integer, j As Integer, jMin As Integer, jMax As Integer
Dim c As Integer, n As Integer, n1 As Integer, n2 As Integer
Dim aq1() As String, aq2() As String, q1 As String, q1Inv As String, Idx As Single, Res As Boolean

l1 = Len(s1): l2 = Len(s2)
If l1 >= 1 And l2 >= 1 And l1 <= cMaxLen And l2 <= cMaxLen And TypeNgram >= cMinNgram And TypeNgram <= cMaxNgram Then
If TypeNgram = 1 And InversionGram Then InversionGram = False

n1 = Ngram(aq1, s1, TypeNgram, InversionGram)
n2 = Ngram(aq2, s2, TypeNgram, InversionGram)
n = n2 - 1

For i = 0 To n1 - 1
q1 = aq1(i)

If InversionGram Then q1Inv = StrReverse(q1)
jMin = 0: jMax = n
If MaxDistance > -1 Then
If i > MaxDistance Then jMin = i - MaxDistance
If jMax > i + MaxDistance Then jMax = i + MaxDistance
End If

For j = jMin To jMax
If aq2(j) <> vbNullString Then
Res = (StrComp(q1, aq2(j), TypeComparaison) = 0)
If Not Res And InversionGram Then Res = (StrComp(q1Inv, aq2(j), TypeComparaison) = 0)
If Res Then
c = c + 1
aq2(j) = vbNullString
Exit For
End If
End If
Next j
Next i

Select Case Indice
Case eCosinus 'Ochiai, Otsuka
Idx = c / Sqr(CLng(n1) * n2) 'Cast pour éviter un overflow
Case eDice 'Pirlot's index, Sorensen, Tversky (alpha=beta=0.5), ~Czekanowski
Idx = 2 * c / (n1 + n2)
Case eJaccard 'Tversky (alpha=beta=1), ~Tanimoto
Idx = c / (n1 + n2 - c)
Case eKulczynski '2nd coeff
Idx = 0.5 * (c / n1 + c / n2)
Case eBraunBlanquet 'c/max(n1,n2)
If n1 >= n2 Then Idx = c / n1 Else Idx = c / n2
Case eSimpson 'c/min(n1,n2)
If n1 <= n2 Then Idx = c / n1 Else Idx = c / n2
End Select
Else
Idx = -1
End If
IndiceSimilarite = Idx
End Function

Définition
Un gramme (ou gram en anglais) est une sous-séquences continues de caractères de la chaîne.

Explications
Cette fonction ne mesure pas une distance entre les deux chaînes, elle compte seulement les grammes communs entre les deux chaînes S1 et S2. Ce compte est ensuite divisé par un coefficient qui distingue les indices entre eux : Ce dénominateur peut être la moyenne géométrique du nombre de n-grams (n1 et n2), la moyenne arithmétique, le nombre maxi, mini…
Le choix des indices est :

Cosinus (équivalence : coefficients de Ochiai et de Otsuka)
Dice (équivalence : Pirlot’s index, Sorensen, Tversky (alpha=beta=0.5), ~Czekanowski)
Jaccard (équivalence : Tversky (alpha=beta=1), ~Tanimoto)
Kulczynski (son second coefficient)
Braun-Blanquet (dénominateur : max(n1,n2))
Simpson (dénominateur : min(n1,n2))

Si le nombre de n-grams est identique entre les deux chaînes, les indices retournent la même valeur mis à part l’index de Jaccard. Par défaut le coefficient de Dice est utilisé.

La longueur des sous-séquences (paramètre TypeNgram) peut varier entre 0 et 5. Zéro indique qu’un n-gramme correspond à un mot, 1-gramme ou unigramme correspond à chaque caractère de la chaîne, 2-gramme ou bigramme est composé de deux caractères, jusqu’à 5-grammes. Au-dessus de 5-grammes la Prévention Informatique ne conseille pas de prendre le clavier !
Par exemple, les bigrammes de ‘abc’ seront ‘%a’, ‘ab’, ‘bc’ et ‘c#’ avec % et # des caractères non utilisés.

Le paramètre suivant (InversionGram) autorise ou non de compter un gramme inversé. Par exemple, ‘ab’ et ‘ba’ seront communs si InversionGram = True.

Le paramètre MaxDistance définit ou non une distance maximale (en valeur absolue) entre deux grammes communs. Si deux grammes communs sont trop éloignés, ils ne seront pas comptabilisés. Par exemple, la similarité calculée est égale à 0 si les chaînes sont ‘ab’ et ‘ba’ avec n-gram=1 et une distance maxi de zéro. Aucune limite de distance n’est définie si MaxDistance = -1.

Enfin, le dernier paramètre définit le type de comparaison entre les deux chaînes (binaire ou textuelle).

Ces indices et celui de Damerau-Levenshtein n’ont pas une réelle corrélation car ils ne mesurent pas la même chose.

Exemples
Des anagrammes qui retournent un indice de similarité parfait (1) :

?IndiceSimilarite("la crise economique","le scenario comique")
?IndiceSimilarite("mammifere","mari femme",eIndiceSimilarite.eSimpson)
?IndiceSimilarite("pascal obispo","pablo picasso")
?IndiceSimilarite("stromae","maestro")

Dans le deuxième exemple, on utilise l’indice de Simpson car il divise le nombre de grammes communs par le plus petit nombre de n-grams entre n1 et n2 ce qui permet d’obtenir un indice égal à 1.

Via une requête SQL, une recherche d’anagrammes sur des mots de 12 lettres dans une table a donné (après suppression des accents) :

Tactiquement Acquittement
Conversation Conservation
Premierement Empierrement
Horticulture Horticulteur
Resurrection Reconstruire
Ternissement Ressentiment
Egalisatrice Eclairagiste
Photogravure Photograveur

Si on reprend l’exemple de ‘pascal obispo’ mais avec des bigrammes, l’indice tombe à 0,36 et remonte à 0,43 si on autorise les inversions car ‘… o…’ est commun à ‘…o …’ de ‘Pablo Picasso’. L’indice chute à 0,2 avec des trigrammes.

?IndiceSimilarite("pascal obispo","pablo picasso",,2)
?IndiceSimilarite("pascal obispo","pablo picasso",,2,True)
?IndiceSimilarite("pascal obispo","pablo picasso",,3,True)

On peut aussi jouer sur la distance maxi pour modifier sensiblement le résultat :

?IndiceSimilarite("rehcehcre","recherche") '1
?IndiceSimilarite("rehcehcre","recherche",,,,2) '1
?IndiceSimilarite("rehcehcre","recherche",,,,1) '0,78
?IndiceSimilarite("rehcehcre","recherche",,,,0) '0,56
?IndiceSimilarite("rehcehcre","recherche",,2,True) '1
?IndiceSimilarite("rehcehcre","recherche",,2,False) '0,3
?IndiceSimilarite("rehcehcre","recherche",,2,True,2) '0,8
?IndiceSimilarite("rehcehcre","recherche",,2,True,0) '0,4
?IndiceSimilarite("rehcehcre","recherche",,3,True,0) '0,36

Performance
Cette fonction semble être 5 à 6 fois plus rapide que la fonction de Damerau-Levenshtein. Le principe mis en jeu est différent et les différentes possibilités de réglages permettent d’adapter l’algorithme à de nombreux cas de figures.

Voir aussi le billet sur la distance de Jaro-Winkler.

Philippe

Similarité entre deux chaînes de caractères

philben — Fri, 31 Aug 2012 16:06:49 +0000

Pour tenter de réduire l’imperfection des ITCC, IPCC, ITPCC voire ITPCCC et plus généralement ICC(*), de nombreux algorithmes sont proposés (Soundex, Jaro-Winkler, …) et l’algorithme de Damerau-Levenshtein que j’ai implémenté ici en VBA.
Voir aussi le billet sur les indices de similarité et le billet sur la distance de Jaro-Winkler.

Le code source

Public Function DamerauLevenshteinSimilarite(ByVal s1 As String, ByVal s2 As String) As Single
'Calcul la similarité (de [0 à 1]) entre deux chaines d'après l'algorithme de Damerau-Levenshtein
'références : http://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance
' http://mwh.geek.nz/2009/04/26/python-damerau-levenshtein-distance/
' http://www-igm.univ-mlv.fr/~lecroq/seqcomp/node2.html
'Remarques : Préparer les chaines car les comparaisons sont binaires : UCase(), Trim(),...
'Philben v1.0 - Free to Use
Const cFacteur As Long = &H100&, cMaxLen As Long = 256& 'Longueur maxi autorisée des chaines analysées
Dim l1 As Long, l2 As Long, c1 As Long, c2 As Long
Dim r() As Integer, rp() As Integer, rpp() As Integer, i As Integer, j As Integer
Dim c As Integer, x As Integer, y As Integer, z As Integer, f1 As Integer, f2 As Integer
Dim dls As Single, ac1() As Byte, ac2() As Byte

l1 = Len(s1): l2 = Len(s2)
If l1 > 0 And l1 <= cMaxLen And l2 > 0 And l2 <= cMaxLen Then
ac1 = s1: ac2 = s2 'conversion des chaines en tableaux de bytes

'Initialise la ligne précédente (rp) de la matrice
ReDim rp(0 To l2)
For i = 0 To l2: rp(i) = i: Next i

For i = 1 To l1
'Initialise la ligne courante de la matrice
ReDim r(0 To l2): r(0) = i

'Calcul le CharCode du caractère courant de la chaine
f1 = (i - 1) * 2: c1 = ac1(f1 + 1) * cFacteur + ac1(f1)

For j = 1 To l2
f2 = (j - 1) * 2: c2 = ac2(f2 + 1) * cFacteur + ac2(f2)
c = -(c1 <> c2) 'Cout : True = -1 => c = 1

'suppression, insertion, substitution
x = rp(j) + 1: y = r(j - 1) + 1: z = rp(j - 1) + c
If x < y Then
If x < z Then r(j) = x Else r(j) = z
Else
If y < z Then r(j) = y Else r(j) = z
End If

'transposition
If i > 1 And j > 1 And c = 1 Then
If c1 = ac2(f2 - 1) * cFacteur + ac2(f2 - 2) And c2 = ac1(f1 - 1) * cFacteur + ac1(f1 - 2) Then
If r(j) > rpp(j - 2) + c Then r(j) = rpp(j - 2) + c
End If
End If
Next j
'Reculer d'un niveau la ligne précédente (rp) et courante (r)
rpp = rp: rp = r
Next i
'Calcul la similarité via la distance entre les chaines r(l2)
If l1 >= l2 Then dls = 1 - r(l2) / l1 Else dls = 1 - r(l2) / l2
ElseIf l1 > cMaxLen Or l2 > cMaxLen Then
dls = -1 'indique un dépassement de longueur de chaine
ElseIf l1 = 0 And l2 = 0 Then
dls = 1 'cas particulier
End If

DamerauLevenshteinSimilarite = dls
End Function

Explications
L’algorithme de Levenshtein mesure la distance entre deux chaînes de caractères qui est basée sur le nombre minimal de suppressions/insertions/substitutions de caractères pour passer d’une chaîne à l’autre.
L’algorithme de Damerau-Levenshtein ajoute en plus la transposition bien connue des dyslexiques du clavier (‘rehcerhce’ au lieu de ‘recherche’)…

Mon implémentation ne retourne pas une distance mais un indice de similarité allant de 0 à 1. La valeur 1 indique une similarité maximale entre deux chaînes. De plus, elle réalise une comparaison binaire des caractères, d’où parfois la nécessité de prétraiter les chaînes (UCase(), Trim(), sans accent,…)

La complexité de l’algorithme est O(m*n) avec m et n la longueur des chaînes ce qui limite son usage à des chaînes relativement courtes, des mots.

Exemples
On peut utiliser cette fonction dans une requête SQL pour rechercher des doublons sur une petite(!) base de données en se basant sur une ou des colonnes (nom/prénom/adresse/…) ou afficher les données les plus similaires à une chaîne de recherche.

Par exemple, mon doigt a rippé par deux fois sur mon clavier AZERTY et j’ai enchaîné un redressement un peu tardif qui a eu pour résultat : ‘tbalrette’

La recherche de similarité dans une table de synonymes (+ de 36 000 entrées) a affiché :

barette (0,78)
tablette (0,78)
turlurette (0,70)
targette (0,67)
…

Je voulais écrire ‘tablette’.

Comme d’habitude, vous pouvez tester la fonction dans la fenêtre Exécution du VBE :

?DamerauLevenshteinSimilarite("tbalrette","tablette") '=>0,7777778
?DamerauLevenshteinSimilarite("apple","appel") '=>0,8
?DamerauLevenshteinSimilarite("chrizantème","chrysanthème") '=>0,75
?DamerauLevenshteinSimilarite("rehcerche","recherche") '=>0,8888889
?DamerauLevenshteinSimilarite("dnas","dans") '=>0,75
?DamerauLevenshteinSimilarite("machine","appareil") '=>0,125
?DamerauLevenshteinSimilarite("le jour se lève","le jour se couche") '=>0,7058824

(*)

ICC : Interface Chaise-Clavier
ITCC : Interface Téléphone-Chaise-Clavier
IPCC : Interface Papier-Chaise-Clavier
ITPCC : Interface Téléphone-Papier-Chaise-Clavier
ITPCCC : Interface Téléphone-Papier-Collègue-Chaise-Clavier

Pour en savoir plus sur le thème errare humanum est…

Philippe