web-dev-qa-db-fra.com

Distance Levenshtein en T-SQL

Je suis intéressé par l'algorithme de calcul de la distance de Levenshtein par T-SQL.

70
Alexander Prokofyev

Arnold Fribble avait deux propositions sur sqlteam.com/forums

Voici le plus jeune de 2006:

SET QUOTED_IDENTIFIER ON 
GO
SET ANSI_NULLS ON 
GO

CREATE FUNCTION edit_distance_within(@s nvarchar(4000), @t nvarchar(4000), @d int)
RETURNS int
AS
BEGIN
  DECLARE @sl int, @tl int, @i int, @j int, @sc nchar, @c int, @c1 int,
    @cv0 nvarchar(4000), @cv1 nvarchar(4000), @cmin int
  SELECT @sl = LEN(@s), @tl = LEN(@t), @cv1 = '', @j = 1, @i = 1, @c = 0
  WHILE @j <= @tl
    SELECT @cv1 = @cv1 + NCHAR(@j), @j = @j + 1
  WHILE @i <= @sl
  BEGIN
    SELECT @sc = SUBSTRING(@s, @i, 1), @c1 = @i, @c = @i, @cv0 = '', @j = 1, @cmin = 4000
    WHILE @j <= @tl
    BEGIN
      SET @c = @c + 1
      SET @c1 = @c1 - CASE WHEN @sc = SUBSTRING(@t, @j, 1) THEN 1 ELSE 0 END
      IF @c > @c1 SET @c = @c1
      SET @c1 = UNICODE(SUBSTRING(@cv1, @j, 1)) + 1
      IF @c > @c1 SET @c = @c1
      IF @c < @cmin SET @cmin = @c
      SELECT @cv0 = @cv0 + NCHAR(@c), @j = @j + 1
    END
    IF @cmin > @d BREAK
    SELECT @cv1 = @cv0, @i = @i + 1
  END
  RETURN CASE WHEN @cmin <= @d AND @c <= @d THEN @c ELSE -1 END
END
GO
55
Alexander Prokofyev

J'ai implémenté la fonction de distance d'édition Levenshtein standard dans TSQL avec plusieurs optimisations qui améliorent la vitesse par rapport aux autres versions que je connais. Dans les cas où les deux chaînes ont des caractères en commun à leur début (préfixe partagé), des caractères en commun à leur fin (suffixe partagé), et lorsque les chaînes sont grandes et qu'une distance d'édition maximale est fournie, l'amélioration de la vitesse est significative. Par exemple, lorsque les entrées sont deux chaînes de 4 000 caractères très similaires et qu'une distance d'édition maximale de 2 est spécifiée, c'est presque trois ordres de grandeur plus rapide que le edit_distance_within fonction dans la réponse acceptée, renvoyant la réponse en 0,073 secondes (73 millisecondes) contre 55 secondes. Il est également efficace en mémoire, en utilisant un espace égal à la plus grande des deux chaînes d'entrée plus un espace constant. Il utilise un seul "tableau" nvarchar représentant une colonne, et effectue tous les calculs sur place, en plus de certaines variables d'aide.

Optimisations:

  • ignore le traitement du préfixe et/ou du suffixe partagé
  • retour anticipé si une chaîne plus grande commence ou se termine par une chaîne plus petite entière
  • retour anticipé si la différence de tailles garantit une distance maximale dépassée
  • utilise un seul tableau représentant une colonne dans la matrice (implémenté comme nvarchar)
  • lorsqu'une distance maximale est donnée, la complexité temporelle va de (len1 * len2) à (min (len1, len2)) c'est-à-dire linéaire
  • lorsqu'une distance maximale est donnée, retour anticipé dès que la distance maximale définie n'est pas réalisable

Les optimisations sont décrites un peu plus en détail dans mon article de blog sur Levenshtein dans TSQL et un lien là-bas vers un autre article avec une implémentation Damerau-Levenshtein similaire. Mais voici le code (mis à jour le 20/01/2014 pour l'accélérer un peu plus):

-- =============================================
-- Computes and returns the Levenshtein edit distance between two strings, i.e. the
-- number of insertion, deletion, and sustitution edits required to transform one
-- string to the other, or NULL if @max is exceeded. Comparisons use the case-
-- sensitivity configured in SQL Server (case-insensitive by default).
-- http://blog.softwx.net/2014/12/optimizing-levenshtein-algorithm-in-tsql.html
-- 
-- Based on Sten Hjelmqvist's "Fast, memory efficient" algorithm, described
-- at http://www.codeproject.com/Articles/13525/Fast-memory-efficient-Levenshtein-algorithm,
-- with some additional optimizations.
-- =============================================
CREATE FUNCTION [dbo].[Levenshtein](
    @s nvarchar(4000)
  , @t nvarchar(4000)
  , @max int
)
RETURNS int
WITH SCHEMABINDING
AS
BEGIN
    DECLARE @distance int = 0 -- return variable
          , @v0 nvarchar(4000)-- running scratchpad for storing computed distances
          , @start int = 1      -- index (1 based) of first non-matching character between the two string
          , @i int, @j int      -- loop counters: i for s string and j for t string
          , @diag int          -- distance in cell diagonally above and left if we were using an m by n matrix
          , @left int          -- distance in cell to the left if we were using an m by n matrix
          , @sChar nchar      -- character at index i from s string
          , @thisJ int          -- temporary storage of @j to allow SELECT combining
          , @jOffset int      -- offset used to calculate starting value for j loop
          , @jEnd int          -- ending value for j loop (stopping point for processing a column)
          -- get input string lengths including any trailing spaces (which SQL Server would otherwise ignore)
          , @sLen int = datalength(@s) / datalength(left(left(@s, 1) + '.', 1))    -- length of smaller string
          , @tLen int = datalength(@t) / datalength(left(left(@t, 1) + '.', 1))    -- length of larger string
          , @lenDiff int      -- difference in length between the two strings
    -- if strings of different lengths, ensure shorter string is in s. This can result in a little
    -- faster speed by spending more time spinning just the inner loop during the main processing.
    IF (@sLen > @tLen) BEGIN
        SELECT @v0 = @s, @i = @sLen -- temporarily use v0 for swap
        SELECT @s = @t, @sLen = @tLen
        SELECT @t = @v0, @tLen = @i
    END
    SELECT @max = ISNULL(@max, @tLen)
         , @lenDiff = @tLen - @sLen
    IF @lenDiff > @max RETURN NULL

    -- suffix common to both strings can be ignored
    WHILE(@sLen > 0 AND SUBSTRING(@s, @sLen, 1) = SUBSTRING(@t, @tLen, 1))
        SELECT @sLen = @sLen - 1, @tLen = @tLen - 1

    IF (@sLen = 0) RETURN @tLen

    -- prefix common to both strings can be ignored
    WHILE (@start < @sLen AND SUBSTRING(@s, @start, 1) = SUBSTRING(@t, @start, 1)) 
        SELECT @start = @start + 1
    IF (@start > 1) BEGIN
        SELECT @sLen = @sLen - (@start - 1)
             , @tLen = @tLen - (@start - 1)

        -- if all of shorter string matches prefix and/or suffix of longer string, then
        -- edit distance is just the delete of additional characters present in longer string
        IF (@sLen <= 0) RETURN @tLen

        SELECT @s = SUBSTRING(@s, @start, @sLen)
             , @t = SUBSTRING(@t, @start, @tLen)
    END

    -- initialize v0 array of distances
    SELECT @v0 = '', @j = 1
    WHILE (@j <= @tLen) BEGIN
        SELECT @v0 = @v0 + NCHAR(CASE WHEN @j > @max THEN @max ELSE @j END)
        SELECT @j = @j + 1
    END

    SELECT @jOffset = @max - @lenDiff
         , @i = 1
    WHILE (@i <= @sLen) BEGIN
        SELECT @distance = @i
             , @diag = @i - 1
             , @sChar = SUBSTRING(@s, @i, 1)
             -- no need to look beyond window of upper left diagonal (@i) + @max cells
             -- and the lower right diagonal (@i - @lenDiff) - @max cells
             , @j = CASE WHEN @i <= @jOffset THEN 1 ELSE @i - @jOffset END
             , @jEnd = CASE WHEN @i + @max >= @tLen THEN @tLen ELSE @i + @max END
        WHILE (@j <= @jEnd) BEGIN
            -- at this point, @distance holds the previous value (the cell above if we were using an m by n matrix)
            SELECT @left = UNICODE(SUBSTRING(@v0, @j, 1))
                 , @thisJ = @j
            SELECT @distance = 
                CASE WHEN (@sChar = SUBSTRING(@t, @j, 1)) THEN @diag                    --match, no change
                     ELSE 1 + CASE WHEN @diag < @left AND @diag < @distance THEN @diag    --substitution
                                   WHEN @left < @distance THEN @left                    -- insertion
                                   ELSE @distance                                        -- deletion
                                END    END
            SELECT @v0 = STUFF(@v0, @thisJ, 1, NCHAR(@distance))
                 , @diag = @left
                 , @j = case when (@distance > @max) AND (@thisJ = @i + @lenDiff) then @jEnd + 2 else @thisJ + 1 end
        END
        SELECT @i = CASE WHEN @j > @jEnd + 1 THEN @sLen + 1 ELSE @i + 1 END
    END
    RETURN CASE WHEN @distance <= @max THEN @distance ELSE NULL END
END

Comme mentionné dans les commentaires de cette fonction, la sensibilité à la casse des comparaisons de caractères suivra le classement en vigueur. Par défaut, le classement de SQL Server est celui qui entraînera des comparaisons insensibles à la casse. Une façon de modifier cette fonction pour qu'elle soit toujours sensible à la casse serait d'ajouter un classement spécifique aux deux endroits où les chaînes sont comparées. Cependant, je n'ai pas testé cela en profondeur, en particulier pour les effets secondaires lorsque la base de données utilise un classement non par défaut. Voici comment les deux lignes seraient modifiées pour forcer les comparaisons sensibles à la casse:

    -- prefix common to both strings can be ignored
    WHILE (@start < @sLen AND SUBSTRING(@s, @start, 1) = SUBSTRING(@t, @start, 1) COLLATE SQL_Latin1_General_Cp1_CS_AS) 

et

            SELECT @distance = 
                CASE WHEN (@sChar = SUBSTRING(@t, @j, 1) COLLATE SQL_Latin1_General_Cp1_CS_AS) THEN @diag                    --match, no change
79
hatchet

IIRC, avec SQL Server 2005 et versions ultérieures, vous pouvez écrire des procédures stockées dans n'importe quel langage .NET: tilisation de l'intégration CLR dans SQL Server 2005 . Avec cela, il ne devrait pas être difficile d'écrire une procédure pour calculer distance de Levenstein .

Un simple Bonjour tout le monde! extrait de l'aide:

using System;
using System.Data;
using Microsoft.SqlServer.Server;
using System.Data.SqlTypes;

public class HelloWorldProc
{
    [Microsoft.SqlServer.Server.SqlProcedure]
    public static void HelloWorld(out string text)
    {
        SqlContext.Pipe.Send("Hello world!" + Environment.NewLine);
        text = "Hello world!";
    }
}

Ensuite, dans votre serveur SQL, exécutez ce qui suit:

CREATE Assembly helloworld from 'c:\helloworld.dll' WITH PERMISSION_SET = SAFE

CREATE PROCEDURE hello
@i nchar(25) OUTPUT
AS
EXTERNAL NAME helloworld.HelloWorldProc.HelloWorld

Et maintenant, vous pouvez le tester:

DECLARE @J nchar(25)
EXEC hello @J out
PRINT @J

J'espère que cela t'aides.

12
Leandro López

Vous pouvez utiliser l'algorithme de distance de Levenshtein pour comparer des chaînes

Ici vous pouvez trouver un exemple T-SQL sur http://www.kodyaz.com/articles/fuzzy-string-matching-using-levenshtein-distance-sql-server.aspx

CREATE FUNCTION edit_distance(@s1 nvarchar(3999), @s2 nvarchar(3999))
RETURNS int
AS
BEGIN
 DECLARE @s1_len int, @s2_len int
 DECLARE @i int, @j int, @s1_char nchar, @c int, @c_temp int
 DECLARE @cv0 varbinary(8000), @cv1 varbinary(8000)

 SELECT
  @s1_len = LEN(@s1),
  @s2_len = LEN(@s2),
  @cv1 = 0x0000,
  @j = 1, @i = 1, @c = 0

 WHILE @j <= @s2_len
  SELECT @cv1 = @cv1 + CAST(@j AS binary(2)), @j = @j + 1

 WHILE @i <= @s1_len
 BEGIN
  SELECT
   @s1_char = SUBSTRING(@s1, @i, 1),
   @c = @i,
   @cv0 = CAST(@i AS binary(2)),
   @j = 1

  WHILE @j <= @s2_len
  BEGIN
   SET @c = @c + 1
   SET @c_temp = CAST(SUBSTRING(@cv1, @j+@j-1, 2) AS int) +
    CASE WHEN @s1_char = SUBSTRING(@s2, @j, 1) THEN 0 ELSE 1 END
   IF @c > @c_temp SET @c = @c_temp
   SET @c_temp = CAST(SUBSTRING(@cv1, @j+@j+1, 2) AS int)+1
   IF @c > @c_temp SET @c = @c_temp
   SELECT @cv0 = @cv0 + CAST(@c AS binary(2)), @j = @j + 1
 END

 SELECT @cv1 = @cv0, @i = @i + 1
 END

 RETURN @c
END

(Fonction développée par Joseph Gama)

Utilisation:

select
 dbo.edit_distance('Fuzzy String Match','fuzzy string match'),
 dbo.edit_distance('fuzzy','fuzy'),
 dbo.edit_distance('Fuzzy String Match','fuzy string match'),
 dbo.edit_distance('levenshtein distance sql','levenshtein sql server'),
 dbo.edit_distance('distance','server')

L'algorithme renvoie simplement le nombre de stpe pour changer une chaîne en une autre en remplaçant un caractère différent à une étape

7
Eralper

Je cherchais également un exemple de code pour l'algorithme Levenshtein, et j'étais heureux de le trouver ici. Bien sûr, je voulais comprendre comment l'algorithme fonctionne et je jouais un peu avec l'un des exemples ci-dessus que je jouais un peu, publié par Veve . Afin de mieux comprendre le code, j'ai créé un Excel avec la matrice.

distance pour FUZZY par rapport à FUZY

Les images disent plus de 1000 mots.

Avec cet Excel, j'ai découvert qu'il y avait un potentiel d'optimisation supplémentaire des performances. Il n'est pas nécessaire de calculer toutes les valeurs dans la zone rouge supérieure droite. La valeur de chaque cellule rouge donne la valeur de la cellule de gauche plus 1. En effet, la deuxième chaîne sera toujours plus longue dans cette zone que la première, ce qui augmente la distance de la valeur 1 pour chaque caractère.

Vous pouvez le refléter en utilisant l'instruction IF @j <= @i et en augmentant la valeur de @ i Avant cette déclaration.

CREATE FUNCTION [dbo].[f_LevenshteinDistance](@s1 nvarchar(3999), @s2 nvarchar(3999))
    RETURNS int
    AS
    BEGIN
       DECLARE @s1_len  int;
       DECLARE @s2_len  int;
       DECLARE @i       int;
       DECLARE @j       int;
       DECLARE @s1_char nchar;
       DECLARE @c       int;
       DECLARE @c_temp  int;
       DECLARE @cv0     varbinary(8000);
       DECLARE @cv1     varbinary(8000);

       SELECT
          @s1_len = LEN(@s1),
          @s2_len = LEN(@s2),
          @cv1    = 0x0000  ,
          @j      = 1       , 
          @i      = 1       , 
          @c      = 0

       WHILE @j <= @s2_len
          SELECT @cv1 = @cv1 + CAST(@j AS binary(2)), @j = @j + 1;

          WHILE @i <= @s1_len
             BEGIN
                SELECT
                   @s1_char = SUBSTRING(@s1, @i, 1),
                   @c       = @i                   ,
                   @cv0     = CAST(@i AS binary(2)),
                   @j       = 1;

                SET @i = @i + 1;

                WHILE @j <= @s2_len
                   BEGIN
                      SET @c = @c + 1;

                      IF @j <= @i 
                         BEGIN
                            SET @c_temp = CAST(SUBSTRING(@cv1, @j + @j - 1, 2) AS int) + CASE WHEN @s1_char = SUBSTRING(@s2, @j, 1) THEN 0 ELSE 1 END;
                            IF @c > @c_temp SET @c = @c_temp
                            SET @c_temp = CAST(SUBSTRING(@cv1, @j + @j + 1, 2) AS int) + 1;
                            IF @c > @c_temp SET @c = @c_temp;
                         END;
                      SELECT @cv0 = @cv0 + CAST(@c AS binary(2)), @j = @j + 1;
                   END;
                SET @cv1 = @cv0;
          END;
       RETURN @c;
    END;
2
Marcus Belz

Dans TSQL, le meilleur et le plus rapide moyen de comparer deux éléments sont les instructions SELECT qui joignent des tables sur des colonnes indexées. C'est ainsi que je vous propose d'implémenter la distance d'édition si vous souhaitez bénéficier des avantages d'un moteur RDBMS. Les boucles TSQL fonctionneront également, mais les calculs de distance de Levenstein seront plus rapides dans d'autres langues que dans TSQL pour les comparaisons de gros volumes.

J'ai implémenté la distance d'édition dans plusieurs systèmes en utilisant des séries de jointures contre des tables temporaires conçues à cet effet uniquement. Cela nécessite de lourdes étapes de prétraitement - la préparation des tables temporaires - mais cela fonctionne très bien avec un grand nombre de comparaisons.

En quelques mots: le prétraitement consiste à créer, remplir et indexer des tables temporaires. Le premier contient des identifiants de référence, une colonne d'une lettre et une colonne charindex. Ce tableau est rempli en exécutant une série de requêtes d'insertion qui divisent chaque mot en lettres (en utilisant SELECT SUBSTRING) pour créer autant de lignes que Word dans la liste source a des lettres (je sais, c'est beaucoup de lignes mais SQL Server peut gérer des milliards de lignes). Faites ensuite un deuxième tableau avec une colonne de 2 lettres, un autre tableau avec une colonne de 3 lettres, etc. Le résultat final est une série de tableaux qui contiennent des identifiants de référence et des sous-chaînes de chacun des mots, ainsi qu'une référence de leur position dans le mot.

Une fois cela fait, tout le jeu consiste à dupliquer ces tables et à les joindre contre leur doublon dans une requête de sélection GROUP BY qui compte le nombre de correspondances. Cela crée une série de mesures pour chaque paire de mots possible, qui sont ensuite ré-agrégées en une seule distance de Levenstein par paire de mots.

Techniquement, cela est très différent de la plupart des autres implémentations de la distance de Levenstein (ou de ses variantes), vous devez donc comprendre en profondeur comment fonctionne la distance de Levenstein et pourquoi elle a été conçue telle quelle. Examinez également les alternatives car avec cette méthode, vous vous retrouvez avec une série de mesures sous-jacentes qui peuvent aider à calculer de nombreuses variantes de la distance d'édition en même temps, vous offrant ainsi des améliorations potentielles intéressantes de l'apprentissage automatique.

Autre point déjà évoqué par les réponses précédentes sur cette page: essayez de prétraiter au maximum pour éliminer les paires qui ne nécessitent pas de mesure de distance. Par exemple, une paire de deux mots qui n'ont pas une seule lettre en commun doit être exclue, car la distance d'édition peut être obtenue à partir de la longueur des chaînes. Ou ne mesurez pas la distance entre deux copies d'un même mot, car il s'agit de 0 par nature. Ou supprimez les doublons avant de faire la mesure, si votre liste de mots provient d'un long texte, il est probable que les mêmes mots apparaîtront plus d'une fois, donc mesurer la distance une seule fois économisera du temps de traitement, etc.

1
JeromeE