Відстань Левенштейна в T-SQL


Відповіді:


100

Я реалізував стандартну функцію редагування відстані Левенштейна в TSQL з декількома оптимізаціями, що покращує швидкість порівняно з іншими версіями, про які я знаю. У випадках, коли обидва рядки мають спільні символи на початку (спільний префікс), спільні символи в їх кінці (спільний суфікс), а коли рядки великі та передбачена максимальна відстань редагування, поліпшення швидкості є значним. Наприклад, коли вхідними даними є дві дуже подібні 4000 символьних рядків і вказана максимальна відстань редагування 2, це майже на три порядки швидше, ніжedit_distance_withinфункція у прийнятій відповіді, повертаючи відповідь за 0,073 секунди (73 мілісекунди) проти 55 секунд. Це також ефективно для пам'яті, використовуючи простір, що дорівнює більшому з двох вхідних рядків плюс деякий постійний простір. Він використовує один "масив" nvarchar, що представляє стовпець, і виконує всі обчислення на місці, а також деякі допоміжні змінні int.

Оптимізації:

  • пропускає обробку спільного префіксу та / або суфікса
  • дострокове повернення, якщо більший рядок починається або закінчується цілим меншим рядком
  • дострокове повернення, якщо різниця в розмірах гарантує максимальну відстань
  • використовує лише один масив, що представляє стовпець у матриці (реалізований як nvarchar)
  • коли задано максимальну відстань, складність часу переходить від (len1 * len2) до (min (len1, len2)), тобто лінійно
  • коли вказана максимальна відстань, дострокове повернення, як тільки відомо, що обмежена максимальна відстань неможливо досягти

Ось код (оновлений 20.01.2014, щоб пришвидшити його ще трохи):

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

Як зазначалося в коментарях до цієї функції, чутливість до регістру порівнянь символів буде слідувати за чинним порівнянням. За замовчуванням порівняння SQL Server є таким, яке призведе до нечутливих порівнянь. Одним із способів змінити цю функцію, щоб завжди враховувати регістр, було б додати певне порівняння до двох місць порівняння рядків. Однак я не ретельно перевірив це, особливо щодо побічних ефектів, коли база даних використовує порівняння за замовчуванням. Ось як два рядки було б змінено, щоб змусити порівняння з урахуванням регістру:

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

і

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

1
Як ми можемо використовувати це для пошуку 5 найближчих рядків у таблиці? Я маю на увазі, скажімо, у мене є таблиця назв вулиць із 10-метровими рядками. Я ввожу пошук назви вулиці, але 1 символ написаний неправильно. Як я можу знайти найкращі 5 найближчих матчів з максимальною ефективністю?
MonsterMMORPG

1
Окрім грубої сили (порівняння всіх адрес), ви не можете. Левенштейн - це не те, чим можна легко скористатися індексами. Якщо ви можете звузити кандидатів до меншої підмножини за допомогою чогось, що можна проіндексувати, наприклад, поштового індексу для адреси або фонетичного коду для імен, наприклад, то прямий Левенштейн, подібний до цього у відповідях, можна доречно застосувати до підмножина. Щоб застосувати до великого набору, вам потрібно буде перейти до чогось типу Levenshtein Automata, але реалізація цього в SQL виходить далеко за рамки запитання SO, на яке дається відповідь.
топірець - зроблено SOverflow

@MonsterMMORPG теоретично ви могли б зробити зворотне і обчислити всі можливі перестановки для даної відстані Левенштейна. Або ви можете спробувати побачити, чи складають слова у ваших адресах список, настільки короткий, що може бути корисним (можливо, ігноруючи слова, які рідко з’являються).
TheConstructor

@MonsterMMORPG - це вже пізно, але я думав, що додам кращу відповідь. Якщо ви знаєте мінімальну кількість дозволених редагувань, ви можете скористатися методом симетричного видалення, як це було зроблено в проекті symspell на github. Ви можете зберегти невелику підмножину перестановок лише видалень, а потім шукати будь-яку з малого набору перестановок видалення рядка пошуку. На повернутому наборі (який був би малим, якщо ви дозволите лише 1 або 2 максимальні відстані редагування), ви потім зробите повний розрахунок левенштейна. Але це має бути набагато, набагато менше, ніж робити це на всіх струнах.
топірець - зроблено з SOverflow

1
@DaveCousineau - Як згадувалося в коментарях до функції, порівняння рядків використовують чутливість до регістру для діючого порівняння SQL Server. За замовчуванням це зазвичай означає відсутність регістру. Дивіться редагування мого допису, який я щойно додав. Реалізація Fribble в іншій відповіді поводиться аналогічно щодо зіставлення.
топірець - зроблено SOverflow

58

Арнольд Фріббл мав дві пропозиції на сайті sqlteam.com/forums

Це молодший з 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

1
@Alexander, здається, це працює, але я б змінив імена змінних на щось більш значуще. Крім того, я б позбувся @d, ви знаєте довжину двох рядків у вашому введенні.
Lieven Keersmaekers

2
@Lieven: Це не моя реалізація, автором є Арнольд Фріббл. Параметр @d - це максимально допустима різниця між рядками, після досягнення яких вони вважаються занадто різноманітними, а функція повертає -1. Це додано, оскільки алгоритм у T-SQL працює надто повільно.
Олександр Прокоф’єв

Вам слід перевірити алгоритм коду psuedo за адресою: en.wikipedia.org/wiki/Levenshtein_distance, він не набагато покращений.
Norman H

13

IIRC, з SQL Server 2005 та пізніших версій, ви можете писати збережені процедури будь-якою мовою .NET: Використання інтеграції CLR у SQL Server 2005 . З огляду на це не повинно бути важко написати процедуру розрахунку відстані Левенштейна .

Простий Привіт, Світе! витягнуто з довідки:

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

Потім у своєму SQL Server запустіть наступне:

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

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

І тепер ви можете тестово запустити його:

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

Сподіваюся, це допомагає.


7

Для порівняння рядків можна використовувати алгоритм відстані Левенштейна

Тут ви можете знайти приклад T-SQL за адресою 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

(Функція розроблена Джозефом Гамою)

Використання:

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

Алгоритм просто повертає кількість stpe для зміни одного рядка на інший, замінюючи іншим символом на одному кроці


На жаль, це не стосується випадку, коли рядок порожній
Кодеман

2

Я також шукав приклад коду для алгоритму Левенштейна, і був радий знайти його тут. Звичайно, я хотів зрозуміти, як працює алгоритм, і я трохи погрався з одним із наведених вище прикладів, я трохи пограв, який опублікував Veve . Для кращого розуміння коду я створив EXCEL із матрицею.

відстань для FUZZY порівняно з FUZY

Зображення говорять більше 1000 слів.

За допомогою цього EXCEL я виявив, що існує потенціал для додаткової оптимізації продуктивності. Всі значення у верхній правій червоній області не потрібно обчислювати. Значення кожної червоної клітини призводить до значення лівої клітини плюс 1. Це тому, що другий рядок завжди буде довшим у цій області, ніж перший, що збільшує відстань на значення 1 для кожного символу.

Ви можете це відобразити, використовуючи твердження IF @j <= @i і збільшуючи значення @i До цього твердження.

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')повернуть відстань 3, коли відстань має бути 2. Для виправлення цього додаткового коду слід додати, що обміняється @s1і @s2якщо @s1має меншу довжину, ніж @s2.
топірець - зроблено SOverflow

2

У TSQL найкращим і найшвидшим способом порівняння двох елементів є оператори SELECT, які об’єднують таблиці в індексованих стовпцях. Тому я пропоную застосувати відстань редагування, якщо ви хочете скористатися перевагами механізму RDBMS. Цикли TSQL також працюватимуть, але обчислення відстані Левенштейна будуть швидшими в інших мовах, ніж у TSQL для порівняння великих обсягів.

Я застосував відстань редагування в декількох системах, використовуючи серії об’єднань проти тимчасових таблиць, призначених лише для цієї мети. Це вимагає деяких важких етапів попередньої обробки - підготовка тимчасових таблиць - але це дуже добре працює з великою кількістю порівнянь.

Кілька слів: попередня обробка складається зі створення, заповнення та індексації тимчасових таблиць. Перший містить довідкові ідентифікатори, однобуквенний стовпець та стовпець charindex. Ця таблиця заповнюється запуском серії запитів вставки, які розділяють кожне слово на літери (за допомогою SELECT SUBSTRING), щоб створити стільки рядків, скільки у слові у вихідному списку є літер (я знаю, це багато рядків, але SQL-сервер може обробляти мільярди рядків). Потім складіть другу таблицю із 2-літерним стовпцем, іншу таблицю із 3-літерним стовпчиком тощо. Кінцевий результат - це серія таблиць, що містять посилальні ідентифікатори та підрядки кожного слова, а також посилання на їх положення в слові.

Як тільки це буде зроблено, уся гра полягає в продублюванні цих таблиць та об’єднанні їх з їх дублікатами в запиті GROUP BY select, який підраховує кількість збігів. Це створює серію заходів для кожної можливої ​​пари слів, які потім об'єднуються в єдину відстань Левенштейна на пару слів.

Технічно це сильно відрізняється від більшості інших реалізацій відстані Левенштейна (або її варіантів), тому вам потрібно глибоко зрозуміти, як працює відстань Левенштейна і чому вона була розроблена такою, якою вона є. Дослідіть також альтернативи, оскільки за допомогою цього методу ви отримаєте низку базових метрик, які можуть допомогти одночасно обчислити багато варіантів відстані редагування, надаючи вам цікаві вдосконалення щодо машинного навчання.

Ще один момент, про який вже згадували попередні відповіді на цій сторінці: спробуйте заздалегідь обробити якомога більше, щоб усунути пари, які не потребують вимірювання відстані. Наприклад, пару двох слів, які не мають жодної спільної літери, слід виключити, оскільки відстань редагування можна отримати з довжини рядків. Або не вимірюйте відстань між двома копіями одного і того ж слова, оскільки воно від природи дорівнює 0. Або видаліть дублікати перед тим, як проводити вимірювання, якщо ваш список слів походить із довгого тексту, цілком ймовірно, що одні й ті ж слова з’являться більше одного разу, тому вимірювання відстані лише один раз заощадить час обробки тощо

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.