Ich interessiere mich für Algorithmen in T-SQL zur Berechnung der Levenshtein-Entfernung.
Ich interessiere mich für Algorithmen in T-SQL zur Berechnung der Levenshtein-Entfernung.
Antworten:
Ich habe die Standard-Levenshtein-Bearbeitungsentfernungsfunktion 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 gemeinsame Zeichen haben (gemeinsames Präfix), am Ende gemeinsame Zeichen (gemeinsames Suffix) und wenn die Zeichenfolgen groß sind und ein maximaler Bearbeitungsabstand angegeben wird, ist die Verbesserung der Geschwindigkeit erheblich. Wenn die Eingaben beispielsweise zwei sehr ähnliche Zeichenfolgen mit 4000 Zeichen sind und ein maximaler Bearbeitungsabstand von 2 angegeben ist, ist dies fast drei Größenordnungen schneller als dieedit_distance_withinFunktion in der akzeptierten Antwort und gibt die Antwort in 0,073 Sekunden (73 Millisekunden) gegenüber 55 Sekunden zurück. Es ist auch speichereffizient und verwendet Speicherplatz, der dem größeren der beiden Eingabezeichenfolgen plus etwas konstantem Speicherplatz entspricht. Es verwendet ein einzelnes nvarchar-Array, das eine Spalte darstellt, und führt alle darin enthaltenen Berechnungen sowie einige Hilfs-Int-Variablen durch.
Optimierungen:
Hier ist der Code (aktualisiert am 20.01.2014, um ihn etwas zu beschleunigen):
-- =============================================
-- 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).
--
-- 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 gültigen Sortierung. Standardmäßig führt die SQL Server-Sortierung zu Vergleichen ohne Berücksichtigung der Groß- und Kleinschreibung. Eine Möglichkeit, diese Funktion so zu ändern, dass immer 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 Sortierung verwendet. Auf diese Weise 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
Arnold Fribble hatte zwei Vorschläge auf sqlteam.com/forums
Dies ist der 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
IIRC, mit SQL Server 2005 und höher können Sie gespeicherte Prozeduren in einer beliebigen .NET-Sprache schreiben: Verwenden der CLR-Integration in SQL Server 2005 . Damit sollte es nicht schwer sein, ein Verfahren zur Berechnung der Levenstein-Entfernung 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.
Sie können den Levenshtein-Distanzalgorithmus 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, @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
(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 in eine andere zu ändern, indem in einem Schritt ein anderes Zeichen ersetzt wird
Ich suchte auch nach einem Codebeispiel für den Levenshtein-Algorithmus und freute mich, es hier zu finden. Natürlich wollte ich verstehen, wie der Algorithmus funktioniert, und ich habe ein bisschen mit einem der obigen Beispiele herumgespielt, das ich von Veve gepostet habe . 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 Wörter.
Mit diesem EXCEL habe ich festgestellt, dass es Potenzial für zusätzliche Leistungsoptimierung gibt. 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, was den Abstand für jedes Zeichen um den Wert 1 erhöht.
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;
('jane', 'jeanne')einen Abstand von 3 zurück, wenn der Abstand 2 sein sollte. Um diesen zusätzlichen Code zu korrigieren, sollte dieser hinzugefügt werden, der tauscht @s1und @s2wenn er @s1eine kürzere Länge als hat @s2.
In TSQL sind SELECT-Anweisungen, die Tabellen in indizierten Spalten verbinden, der beste und schnellste Weg, um zwei Elemente zu vergleichen. Daher empfehle ich, die Bearbeitungsentfernung so zu implementieren, wenn Sie von den Vorteilen einer RDBMS-Engine profitieren 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 Joins für temporäre Tabellen implementiert, die nur für diesen Zweck entwickelt wurden. Es erfordert einige umfangreiche Vorverarbeitungsschritte - die Erstellung der temporären Tabellen - aber es funktioniert sehr gut mit einer großen Anzahl von Vergleichen.
Mit 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. Diese Tabelle wird durch Ausführen einer Reihe von Einfügeabfragen gefüllt, die jedes Wort in Buchstaben aufteilen (mithilfe von SELECT SUBSTRING), um so viele Zeilen zu erstellen, wie das Wort in der Quellliste Buchstaben enthält (ich weiß, das sind viele Zeilen, aber SQL Server kann Milliarden verarbeiten von Zeilen). 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 sie 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 Wortpaar, die dann zu einem einzelnen Levenstein-Abstand pro Wortpaar zusammengefasst 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 entworfen wurde, wie sie ist. Untersuchen Sie auch die Alternativen, da Sie mit dieser Methode eine Reihe zugrunde liegender Metriken erhalten, mit deren Hilfe viele Varianten der Bearbeitungsentfernung gleichzeitig berechnet werden können, wodurch Sie interessante Verbesserungen beim maschinellen Lernen erhalten.
Ein weiterer Punkt, der bereits in früheren Antworten auf dieser Seite erwähnt wurde: Versuchen Sie, so viel wie möglich vorzuverarbeiten, 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 der Bearbeitungsabstand aus der Länge der Zeichenfolgen ermittelt werden kann. Oder messen Sie nicht den Abstand zwischen zwei Kopien desselben Wortes, da er 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 mehrmals vorkommen. Wenn Sie also nur einmal die Entfernung messen, sparen Sie Verarbeitungszeit usw.