T-SQL'de Levenshtein mesafesi


Yanıtlar:


101

Bildiğim diğer sürümlere göre hızı artıran çeşitli optimizasyonlarla TSQL'de standart Levenshtein düzenleme mesafesi işlevini uyguladım. İki dizenin başlangıçta ortak karakterlere (paylaşılan önek), sonlarında ortak karakterlere (paylaşılan sonek) sahip olduğu ve dizeler büyük olduğunda ve maksimum düzenleme mesafesi sağlandığında, hızdaki gelişme önemlidir. Örneğin, girişler çok benzer iki 4000 karakterlik dizge olduğunda ve maks. Düzenleme mesafesi 2 belirlendiğinde, bu, neredeyse üç kat daha hızlıdır.edit_distance_withinkabul edilen yanıtta işlev, yanıtı 0,073 saniye (73 milisaniye) - 55 saniye içinde döndürür. Ayrıca, iki giriş dizisinden daha büyük olanına eşit alan artı bir miktar sabit alan kullanarak bellek açısından da verimli. Bir sütunu temsil eden tek bir nvarchar "dizisi" kullanır ve tüm hesaplamaları yerinde yapar, artı bazı yardımcı int değişkenleri.

Optimizasyonlar:

  • paylaşılan önek ve / veya son ekin işlenmesini atlar
  • Daha büyük dize, tüm küçük dizeyle başlar veya biterse erken dönüş
  • Boyutlardaki fark maksimum mesafenin aşılacağını garanti ediyorsa erken iade
  • matristeki bir sütunu temsil eden yalnızca tek bir dizi kullanır (nvarchar olarak uygulanır)
  • bir maksimum mesafe verildiğinde, zaman karmaşıklığı (len1 * len2) 'den (min (len1, len2))' ye, yani doğrusal
  • maksimum mesafe verildiğinde, maksimum mesafe sınırının elde edilemeyeceği bilindiğinde erken dönüş

İşte kod (biraz daha hızlandırmak için 20.01.2014 tarihinde güncellendi):

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

Bu işlevin yorumlarında belirtildiği gibi, karakter karşılaştırmalarının büyük / küçük harf duyarlılığı, yürürlükteki harmanlamayı takip edecektir. Varsayılan olarak, SQL Server'ın harmanlaması, büyük / küçük harfe duyarlı olmayan karşılaştırmalara neden olacak bir harmanlamadır. Bu işlevi her zaman büyük / küçük harfe duyarlı olacak şekilde değiştirmenin bir yolu, dizelerin karşılaştırıldığı iki yere belirli bir harmanlama eklemek olacaktır. Bununla birlikte, özellikle veritabanı varsayılan olmayan bir harmanlama kullandığında yan etkiler için bunu tam olarak test etmedim. Bunlar, büyük / küçük harfe duyarlı karşılaştırmaları zorlamak için iki satırın nasıl değiştirileceğidir:

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

ve

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

1
Bunu bir tablodaki en yakın 5 dizgeye bakmak için nasıl kullanabiliriz? Demek istediğim, 10m sıralı sokak isimleri tablom olduğunu varsayalım. Aramaya bir cadde adı giriyorum ancak 1 karakter yanlış yazılıyor. Maksimum performansla en yakın 5 eşleşmeye nasıl bakabilirim?
MonsterMMORPG

1
Kaba kuvvet dışında (tüm adresleri karşılaştırarak), yapamazsınız. Levenshtein, indekslerden kolayca yararlanabilecek bir şey değildir. Adayları daha küçük bir alt kümeye daraltabilirseniz, örneğin adres için bir posta kodu veya isimler için bir fonetik kod gibi dizine eklenebilen bir şey varsa, buradaki yanıtlarda olduğu gibi düz Levenshtein uygulanabilir bir şekilde alt küme. Büyük bir kümenin tamamına uygulamak için, Levenshtein Automata gibi bir şeye gitmeniz gerekir, ancak bunu SQL'de uygulamak, burada yanıtlanan SO sorusunun kapsamının çok ötesindedir.
hatchet - SOverflow ile bitti

@MonsterMMORPG teoride tersini yapabilir ve belirli bir Levenshtein mesafesi için tüm olası permütasyonları hesaplayabilirsiniz. Veya adreslerinizdeki kelimelerin yararlı olacak kadar kısa bir liste oluşturup oluşturmadığını deneyebilir ve deneyebilirsiniz (muhtemelen nadiren görünen kelimeleri görmezden geliyor).
TheConstructor

@MonsterMMORPG - geç oldu ama daha iyi bir cevap ekleyeceğimi düşündüm. İzin vereceğiniz minimum düzenleme sayısını biliyorsanız, simetrik Silme yöntemini github'daki symspell projesinde olduğu gibi kullanabilirsiniz. Yalnızca silmelerin küçük bir permütasyon alt kümesini depolayabilir ve ardından arama dizesinin küçük silme permütasyonları kümesinde herhangi birini arayabilirsiniz. Döndürülen sette (sadece 1 veya 2 maksimum düzenleme mesafesine izin verirseniz küçük olacaktır), daha sonra tam düz hesaplama yaparsınız. Ancak bu, tüm dizelerde yapmaktan çok, çok daha az olmalıdır.
hatchet - SOverflow ile

1
@DaveCousineau - İşlev yorumlarında belirtildiği gibi, dize karşılaştırmaları, geçerli SQL Server harmanlaması için büyük / küçük harf duyarlılığını kullanır. Varsayılan olarak, bu genellikle büyük / küçük harfe duyarlı değildir. Yeni eklediğim gönderimin düzenlemesine bakın. Başka bir cevaptaki Fribble uygulaması, harmanlama konusunda benzer şekilde davranır.
hatchet - SOverflow ile bitti

58

Arnold fribble iki öneri vardı sqlteam.com/forums

Bu 2006'dan daha genç olanı:

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

1
@Alexander, işe yarıyor gibi görünüyor ama değişken isimlerini daha anlamlı bir şeye değiştirirdim. Ayrıca, @d'den kurtulurum, girişinizdeki iki dizenin uzunluğunu bilirsiniz.
Lieven Keersmaekers

2
@Lieven: Benim uygulamam değil, yazar Arnold Fribble. @d parametresi, çok çeşitli oldukları düşünülen ve işlev -1 döndüren dizeler arasında izin verilen maksimum bir farktır. T-SQL'deki algoritma çok yavaş çalıştığı için eklendi.
Alexander Prokofyev

Algoritma psuedo kodunu şu adresten kontrol etmelisiniz: en.wikipedia.org/wiki/Levenshtein_distance , pek geliştirilmedi.
Norman H

13

IIRC, SQL Server 2005 ve sonraki sürümleri ile herhangi bir .NET dilinde saklı yordamları yazabilirsiniz: SQL Server 2005'te CLR Entegrasyonunu kullanarak . Bununla birlikte, Levenstein mesafesini hesaplamak için bir prosedür yazmak zor olmamalı .

Basit bir Merhaba, Dünya! yardımdan alınmıştır:

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

Ardından SQL Server'ınızda aşağıdakileri çalıştırın:

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

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

Ve şimdi çalıştırmayı test edebilirsiniz:

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

Bu yardımcı olur umarım.


7

Dizeleri karşılaştırmak için Levenshtein Mesafe Algoritmasını kullanabilirsiniz

Burada, http://www.kodyaz.com/articles/fuzzy-string-matching-using-levenshtein-distance-sql-server.aspx adresinde bir T-SQL örneği bulabilirsiniz.

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

(Joseph Gama tarafından geliştirilen işlev)

Kullanım:

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

Algoritma, bir adımda farklı bir karakteri değiştirerek bir dizeyi diğerine değiştirmek için basitçe stpe sayısını döndürür.


Bu maalesef bir dizenin boş olduğu durumu
kapsamıyor

2

Levenshtein algoritması için de bir kod örneği arıyordum ve burada bulduğum için mutluydum. Elbette algoritmanın nasıl çalıştığını anlamak istedim ve biraz da Veve tarafından yayınlanan yukarıdaki örneklerden biriyle biraz oynuyordum . Kodu daha iyi anlamak için Matrix ile bir EXCEL oluşturdum.

BULANIK ile karşılaştırıldığında FUZZY mesafesi

Görüntüler 1000'den fazla kelime söylüyor.

Bu EXCEL ile ek performans optimizasyonu potansiyeli olduğunu buldum. Sağ üst kırmızı alandaki tüm değerlerin hesaplanması gerekmez. Her kırmızı hücrenin değeri, sol hücrenin değeri artı 1 ile sonuçlanır. Bunun nedeni, ikinci dizenin o alanda her zaman birinciden daha uzun olacağıdır, bu da mesafeyi her karakter için 1 değerini artırır.

Bunu, IF @j <= @i ifadesini kullanarak ve @i değerini artırarak yansıtabilirsiniz . Bu ifadeden önce.

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;

Yazıldığı gibi, bu her zaman doğru sonuçları vermeyecektir. Örneğin, veriler ('jane', 'jeanne')uzaktan bu ek kod swap ilave edilmelidir gidermek için 2 olması gerekirken, 3 mesafe döner @s1ve @s2eğer @s1daha kısa bir uzunluğa sahiptir @s2.
hatchet - SOverflow ile bitti

2

TSQL'de iki öğeyi karşılaştırmanın en iyi ve en hızlı yolu, tabloları dizine alınmış sütunlar üzerinde birleştiren SELECT deyimleridir. Bu nedenle, bir RDBMS motorunun avantajlarından yararlanmak istiyorsanız, düzenleme mesafesini bu şekilde uygulamanızı öneririm. TSQL Döngüleri de işe yarayacaktır, ancak Levenstein mesafe hesaplamaları büyük hacimli karşılaştırmalar için diğer dillerde TSQL'den daha hızlı olacaktır.

Düzenleme mesafesini çeşitli sistemlerde, yalnızca bu amaç için tasarlanmış geçici tablolara karşı Birleştirme serileri kullanarak uyguladım. Bazı ağır ön işleme adımları gerektirir - geçici tabloların hazırlanması - ancak çok sayıda karşılaştırmada çok iyi çalışır.

Birkaç kelimeyle: ön işleme, geçici tabloların oluşturulması, doldurulması ve indekslenmesinden oluşur. İlki, referans kimlikleri, tek harfli bir sütun ve bir charindex sütunu içerir. Bu tablo, her kelimeyi harflere bölen (SELECT SUBSTRING kullanarak) bir dizi ekleme sorgusu çalıştırarak doldurulur ve kaynak listesindeki kelimelerin harfleri olduğu kadar satır oluşturur (biliyorum, bu çok fazla satırdır, ancak SQL sunucusu milyarlarcayı işleyebilir satır sayısı). Daha sonra 2 harfli bir sütun içeren ikinci bir tablo, 3 harfli bir sütuna sahip başka bir tablo vb. Yapın. Son sonuçlar, her bir sözcüğün referans kimliklerini ve alt dizelerini ve konumlarının referansını içeren bir dizi tablodur. kelimede.

Bu yapıldıktan sonra, tüm oyun bu tabloları çoğaltmak ve eşleşmelerin sayısını sayan bir GROUP BY seçme sorgusunda kopyalarına karşı birleştirmekle ilgilidir. Bu, olası her kelime çifti için bir dizi ölçü oluşturur ve bunlar daha sonra kelime çifti başına tek bir Levenstein mesafesi olarak yeniden toplanır.

Teknik olarak bu, Levenstein mesafesinin (veya varyantlarının) diğer birçok uygulamasından çok farklıdır, bu nedenle Levenstein mesafesinin nasıl çalıştığını ve neden olduğu gibi tasarlandığını derinlemesine anlamanız gerekir. Alternatifleri de araştırın, çünkü bu yöntemle, aynı anda düzenleme mesafesinin birçok varyantını hesaplamaya yardımcı olabilecek ve size ilginç makine öğrenimi potansiyel iyileştirmeleri sağlayan bir dizi temel metrik elde edersiniz.

Bu sayfada daha önce verilen yanıtlarda daha önce bahsedilen bir başka nokta: Mesafe ölçümü gerektirmeyen çiftleri elemek için mümkün olduğunca ön işlem yapmaya çalışın. Örneğin, ortak bir harfe sahip olmayan bir çift kelime hariç tutulmalıdır, çünkü düzenleme mesafesi dizelerin uzunluğundan elde edilebilir. Veya aynı kelimenin iki kopyası arasındaki mesafeyi ölçmeyin, çünkü doğası gereği 0'dır. Veya ölçümü yapmadan önce kopyaları kaldırın, kelime listeniz uzun bir metinden geliyorsa, aynı kelimelerin birden fazla görünmesi muhtemeldir, bu nedenle mesafeyi yalnızca bir kez ölçmek işlem süresinden tasarruf sağlar, vb.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.