it-swarm.com.de

Levenshtein Entfernung in T-SQL

Ich interessiere mich für einen Algorithmus zur T-SQL-Berechnung der Levenshtein-Distanz.

70

Arnold Fribble hatte zwei Vorschläge zu sqlteam.com/forums

Dies ist die jüngere aus dem Jahr 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

Ich habe die standardmäßige Levenshtein-Distanzbearbeitungsfunktion in TSQL mit mehreren Optimierungen implementiert, die die Geschwindigkeit gegenüber den anderen mir bekannten Versionen verbessern. In Fällen, in denen die beiden Zeichenfolgen am Anfang Zeichen gemeinsam haben (gemeinsames Präfix) und am Ende Zeichen gemeinsam haben (gemeinsames Suffix) und in denen die Zeichenfolgen groß sind und ein maximaler Bearbeitungsabstand angegeben ist, ist die Geschwindigkeitsverbesserung erheblich. Wenn es sich bei den Eingaben beispielsweise um zwei sehr ähnliche 4000-Zeichenfolgen handelt und ein maximaler Bearbeitungsabstand von 2 angegeben ist, ist dies fast drei Größenordnungen schneller als der Wert von edit_distance_within funktioniert in der akzeptierten Antwort und gibt die Antwort in 0,073 Sekunden (73 Millisekunden) im Vergleich zu 55 Sekunden zurück. Es ist auch speichereffizient, da der Platz gleich dem größeren der beiden Eingabe-Strings plus etwas konstantem Platz ist. Es verwendet ein einzelnes nvarchar "Array", das eine Spalte darstellt, und führt alle darin enthaltenen Berechnungen sowie einige Helfer-Int-Variablen aus.

Optimierungen:

  • überspringt die Verarbeitung von gemeinsamen Präfixen und/oder Suffixen
  • vorzeitige Rückkehr, wenn eine größere Zeichenfolge mit einer ganzen kleineren Zeichenfolge beginnt oder endet
  • vorzeitige Rückgabe, wenn der Größenunterschied garantiert, dass der maximale Abstand überschritten wird
  • verwendet nur ein einzelnes Array, das eine Spalte in der Matrix darstellt (implementiert als nvarchar)
  • wenn ein maximaler Abstand gegeben ist, geht die Zeitkomplexität von (len1 · len2) zu (min (len1, len2)), d. h. linear
  • wenn eine maximale Entfernung angegeben ist, ist eine frühe Rückkehr, sobald bekannt ist, dass die maximale Entfernung nicht erreichbar ist, nicht möglich

Die Optimierungen werden in meinem Blogpost zu Levenshtein in TSQL und einem Link zu einem anderen Post mit einer ähnlichen Damerau-Levenshtein-Implementierung ausführlicher beschrieben. Aber hier ist der Code (aktualisiert am 20.01.2014, um ihn ein bisschen schneller zu machen):

-- =============================================
-- 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

Wie in den Kommentaren dieser Funktion erwähnt, folgt die Groß- und Kleinschreibung der Zeichenvergleiche der Sortierung, die wirksam ist. Standardmäßig wird bei der Sortierung von SQL Server die Groß- und Kleinschreibung nicht beachtet. Eine Möglichkeit, diese Funktion so zu ändern, dass zwischen Groß- und Kleinschreibung unterschieden wird, besteht darin, den beiden Stellen, an denen Zeichenfolgen verglichen werden, eine bestimmte Sortierung hinzuzufügen. Ich habe dies jedoch nicht gründlich getestet, insbesondere auf Nebenwirkungen, wenn die Datenbank eine nicht standardmäßige Kollatierung verwendet. So würden die beiden Zeilen geändert, um Vergleiche zwischen Groß- und Kleinschreibung zu erzwingen:

    -- 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) 

und

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

In IIRC können Sie mit SQL Server 2005 und höher gespeicherte Prozeduren in einer beliebigen .NET-Sprache schreiben: Verwenden der CLR-Integration in SQL Server 2005 . Damit sollte es nicht schwierig sein, eine Prozedur zur Berechnung von Levenstein-Distanz zu schreiben.

Ein einfaches Hallo, Welt! Aus der Hilfe extrahiert:

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!";
    }
}

Führen Sie dann in Ihrem SQL Server Folgendes aus:

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

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

Und jetzt können Sie es testen:

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

Hoffe das hilft.

12
Leandro López

Sie können den Levenshtein-Entfernungsalgorithmus zum Vergleichen von Zeichenfolgen verwenden

Hier finden Sie ein T-SQL-Beispiel unter 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, @[email protected], 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, @[email protected]+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

(Funktion von Joseph Gama entwickelt)

Verwendung :

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')

Der Algorithmus gibt einfach die Anzahl der Zeichen zurück, um eine Zeichenfolge durch Ersetzen eines anderen Zeichens in einem Schritt in eine andere Zeichenfolge zu ändern

7
Eralper

Ich suchte auch nach einem Codebeispiel für den Levenshtein-Algorithmus und war froh, es hier zu finden. Natürlich wollte ich verstehen, wie der Algorithmus funktioniert und spielte ein bisschen mit einem der obigen Beispiele herum, die von Veve gepostet wurden. Um den Code besser zu verstehen, habe ich mit der Matrix ein Excel erstellt.

Abstand für FUZZY im Vergleich zu FUZY

Bilder sagen mehr als 1000 Worte.

Mit diesem Excel stellte ich fest, dass Potenzial für eine zusätzliche Leistungsoptimierung besteht. Alle Werte im oberen rechten roten Bereich müssen nicht berechnet werden. Der Wert jeder roten Zelle ergibt den Wert der linken Zelle plus 1. Dies liegt daran, dass die zweite Zeichenfolge in diesem Bereich immer länger ist als die erste, wodurch der Abstand für jedes Zeichen um den Wert 1 erhöht wird.

Sie können dies widerspiegeln, indem Sie die Anweisung IF @j <= @i verwenden und den Wert von @ i vor dieser Anweisung erhöhen.

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

In TSQL sind SELECT-Anweisungen, die Tabellen in indizierten Spalten verknüpfen, die beste und schnellste Möglichkeit, zwei Elemente zu vergleichen. Daher schlage ich vor, den Bearbeitungsabstand so zu implementieren, wenn Sie die Vorteile einer RDBMS-Engine nutzen möchten. TSQL-Schleifen funktionieren auch, aber Levenstein-Entfernungsberechnungen sind in anderen Sprachen schneller als in TSQL für Vergleiche großer Volumina.

Ich habe die Bearbeitungsentfernung in mehreren Systemen mithilfe von Joinserien für temporäre Tabellen implementiert, die nur für diesen Zweck vorgesehen sind. Es erfordert einige schwere Vorverarbeitungsschritte - das Vorbereiten der temporären Tabellen - aber es funktioniert sehr gut mit einer großen Anzahl von Vergleichen.

In wenigen Worten: Die Vorverarbeitung besteht aus dem Erstellen, Auffüllen und Indizieren von temporären Tabellen. Die erste enthält Referenz-IDs, eine Ein-Buchstaben-Spalte und eine Zeichenindex-Spalte. In dieser Tabelle werden eine Reihe von Einfügeabfragen ausgeführt, die jedes Wort in Buchstaben aufteilen (mithilfe von SELECT SUBSTRING), um so viele Zeilen zu erstellen, wie Word in der Quellliste Buchstaben enthält (ich weiß, das sind viele Zeilen, aber SQL Server kann Milliarden verarbeiten) Reihen). Erstellen Sie dann eine zweite Tabelle mit einer 2-Buchstaben-Spalte, eine weitere Tabelle mit einer 3-Buchstaben-Spalte usw. Das Endergebnis ist eine Reihe von Tabellen, die Referenz-IDs und Teilzeichenfolgen der einzelnen Wörter sowie die Referenz ihrer Position enthalten in dem Wort.

Sobald dies erledigt ist, geht es im gesamten Spiel darum, diese Tabellen zu duplizieren und mit ihrem Duplikat in einer GROUP BY-Auswahlabfrage zu verbinden, die die Anzahl der Übereinstimmungen zählt. Dies erzeugt eine Reihe von Maßen für jedes mögliche Paar von Wörtern, die dann zu einer einzelnen Levenstein-Distanz pro Paar von Wörtern neu aggregiert werden.

Technisch gesehen unterscheidet sich dies stark von den meisten anderen Implementierungen der Levenstein-Distanz (oder ihrer Varianten). Sie müssen daher genau verstehen, wie die Levenstein-Distanz funktioniert und warum sie so konzipiert wurde, wie sie ist. Untersuchen Sie auch die Alternativen, denn mit dieser Methode erhalten Sie eine Reihe von zugrunde liegenden Metriken, mit denen Sie viele Varianten der Bearbeitungsentfernung gleichzeitig berechnen und interessante Verbesserungsmöglichkeiten für das maschinelle Lernen erhalten können.

Ein weiterer Punkt, der bereits in früheren Antworten auf dieser Seite erwähnt wurde: Versuchen Sie, so weit wie möglich vorzubereiten, um die Paare zu eliminieren, für die keine Entfernungsmessung erforderlich ist. Beispielsweise sollte ein Paar von zwei Wörtern ausgeschlossen werden, die keinen einzigen Buchstaben gemeinsam haben, da sich der Bearbeitungsabstand aus der Länge der Zeichenfolgen ergibt. Oder messen Sie nicht den Abstand zwischen zwei Kopien desselben Wortes, da es von Natur aus 0 ist. Oder entfernen Sie Duplikate, bevor Sie die Messung durchführen. Wenn Ihre Wortliste aus einem langen Text stammt, werden dieselben Wörter wahrscheinlich mehr als einmal vorkommen. So können Sie Verarbeitungszeit sparen, wenn Sie den Abstand nur einmal messen.

1
JeromeE