Calcolo rapido della distanza Levenshtein

24

Dato un enorme database di parole consentite (in ordine alfabetico) e una parola, trova la parola dal database più vicina alla parola data in termini di distanza di Levenshtein.

L'approccio ingenuo è, ovviamente, semplicemente calcolare la distanza di levenshtein tra la parola data e tutte le parole del dizionario (possiamo fare una ricerca binaria nel database prima di calcolare effettivamente le distanze).

Mi chiedo se esiste una soluzione più efficiente a questo problema. Forse un po 'euristico che ci consente di ridurre il numero di parole da cercare, o ottimizzazioni dell'algoritmo di distanza Levenshtein.

Collegamenti a documenti sull'argomento benvenuto.

— Joshua Herman
fonte

16

Quello che ti stai chiedendo è il problema della ricerca del vicino vicino alla distanza di modifica. Non hai detto se sei interessato a risultati teorici o euristici, quindi risponderò al primo.

La distanza di modifica è piuttosto sgradevole da gestire per la costruzione di strutture di ricerca vicine. Il problema principale è che, come metrica, si comporta (in qualche modo) come altre metriche negative ben note come ai fini della riduzione e dell'approssimazione della dimensionalità. C'è un vasto lavoro da leggere su questo argomento, e la tua migliore fonte è il set di articoli di Alex Andoni : seguendo i puntatori all'indietro (ad esempio dal suo documento FOCS 2010) otterrai una buona serie di fonti. $\ell_1$

— Suresh Venkat
fonte

1

Tutto quello che so sugli spazi metrici proviene dalla semantica, quindi una domanda: ci sono incorporamenti decenti (per qualsiasi valore di decenti) della metrica di Levenshtein in un ultrametrico? A parte, ciò potrebbe dare origine all'algoritmo binary-tree-ish.

— Neel Krishnaswami,

Non ne sono del tutto sicuro. Sospetto che la risposta sia no in generale, ma non ho nulla da indicare.

— Suresh Venkat,

Il secondo documento su boytsov.info/pubs è una buona rassegna delle possibili soluzioni per la ricerca del vicino vicino sotto la distanza di modifica di Levenshtein e Damereau-Levenshtein.

— a3nm,

@NeelKrishnaswami Un incorporamento in un ultrametrico avrebbe una distorsione di almeno

dove

è la lunghezza della stringa. Ciò deriva da una distorsione inferiore al limite per l'incorporamento in

dovuta a Krauthgamer e Rabani , poiché l'ultrametria si incorpora isometricamente nello spazio euclideo, che si inserisce isometricamente in

.

Ω (\log d)

$\Omega(\log d)$

d

$d$

L_{1}

$L_1$

L_{1}

$L_1$

— Sasho Nikolov,

9

Automi di Levenshtein: http://en.wikipedia.org/wiki/Levenshtein_automaton

Alberi BK: http://en.wikipedia.org/wiki/BK-tree

— SCLV
fonte

2

Ho trovato soprattutto il terzo riferimento lì ( blog.notdot.net/2007/4/Damn-Cool-Algorithms-Part-1-BK-Trees ) per essere utile.

— Teun D,

5

Se hai un numero limitato di modifiche errate che intendi tollerare, puoi provare a utilizzare un albero di suffissi punteggiato . Disclaimer: ho scritto quel documento, ma risolve quello che vuoi: ha un alto costo dello spazio su disco, ma le query sono molto veloci.

In generale, è meglio guardarlo al contrario: hai un indice di tutte le parole nel dizionario. Ora, per una parola di input w, se si trova nel dizionario, fermarsi. Altrimenti, genera tutte le variazioni alla distanza 1 e cerca quelle. Se non ci sono, cerca le variazioni alla distanza 2 e così via ...

Ci sono molti miglioramenti a questa idea di base.

— luispedro
fonte

1

Avresti dovuto includere un link al tuo archivio di ricerca riproducibile per il documento .

— Dan D.

4

$O(m^{k+1} \cdot \sigma^{k})$ $m$ $\sigma$ $k$

— Jouni Sirén
fonte

4

Ho scritto una risposta a una domanda molto simile su cs.stackexchange.com ( /cs//a/2096/1490 ) e poi ho trovato questa domanda. La risposta è per la ricerca approssimata del vicino vicino nella distanza di modifica (cioè l'algoritmo genera una stringa che è approssimativamente più vicina alla stringa della query del vicino più vicino della stringa della query). Sto postando qui poiché non trovo nessuno dei riferimenti che ho dato lì nelle risposte fornite qui.

— Sasho Nikolov
fonte

3

Penso che quello che vuoi sia l'algoritmo di Wagner-Fischer: https://en.wikipedia.org/wiki/Wagner%E2%80%93Fischer_algorithm L'intuizione chiave è che, dal momento che il dizionario che stai attraversando è ordinato, due parole consecutive è molto probabile che condividano un prefisso lungo, quindi non è necessario aggiornare l'intera matrice per ogni calcolo della distanza.

— Björn Lindqvist
fonte

2

Puoi usare Intendevi?

E poi trova la distanza di Levenshtein tra la risposta restituita da "Intendevi" "e inserisci la stringa usando la Programmazione dinamica.

— Pratik Deoghare
fonte

Non capisco questa risposta. La domanda si pone come si possa trovare in modo efficiente una parola in un grande dizionario con una distanza Levenshtein vicina a un dato input, non su come calcolare la distanza Levenshtein o sul confronto con l'output di un controllo ortografico black box ...

— Huck Bennett

@Huck Bennett: pensavo che @Grigory Javadyan stesse costruendo Did you mean?funzionalità. Inoltre Did you mean?restituisce la parola che è molto vicina all'input dato e lo fa in modo abbastanza efficiente. :)

— Pratik Deoghare

Penso che le tue idee siano buone, ma sembra che Grigory stia chiedendo qualcosa di più profondo e più specifico.

— Huck Bennett,

@Huck Bennett: Sì, hai ragione! :)

— Pratik Deoghare

-1

Un modo è addestrare un modello di apprendimento automatico per mappare le parole ai vettori e mappare la distanza di levenshtein alla distanza euclidea. Quindi è possibile creare un KDTree dai vettori per il dizionario che si desidera utilizzare. Ho creato un notebook jupyter che fa questo qui: https://gist.github.com/MichaelSnowden/9b8b1e662c98c514d571f4d5c20c3a03

Secondo i commenti di DW:

procedura di allenamento = discesa gradiente stocastica con gradienti adattativi
funzione di perdita = errore quadratico medio tra la distanza di modifica reale e la distanza euclidea
dati di allenamento = stringhe casuali comprese tra 1 e 32 caratteri (potrebbero essere migliorate con dati che corrispondono a una distribuzione effettiva di errori di battitura comuni)
risultati quantitativi: dopo l'allenamento per circa 150 epoche con una dimensione del lotto di 2048 (tempo di parete = circa un minuto), usando incorporamenti di parole di 512 dimensioni, con un livello nascosto, l'errore assoluto medio tra la distanza di modifica reale e la distanza di modifica prevista si trova a circa 0,75, il che significa che la distanza di modifica prevista è di circa un carattere

Riepilogo della struttura del modello:

Crea un incorporamento appreso per ogni carattere, incluso il carattere null (utilizzato in seguito per il pad del testo destro sotto il limite di caratteri)
Riempi il lato destro del testo con il carattere null fino a raggiungere il limite di caratteri (32)
Concatena questi matrimoni
Esegui gli incorporamenti attraverso una rete neurale feed-forward per produrre un incorporamento di parole di dimensione inferiore (512-dimensionale)
Fallo per entrambe le parole
Trova la distanza euclidea tra i vettori
Imposta la perdita come errore quadratico medio tra la distanza reale di Levenshtein e la distanza euclidea

I miei dati di allenamento sono solo stringhe casuali, ma penso che i risultati potrebbero davvero migliorare se i dati di allenamento fossero (errori di battitura / parola corretta). Ho finito per usare solo /usr/share/dict/wordsperché è comunemente disponibile.

— michaelsnowden
fonte

2

Come si allena un modello ML in modo che le parole che si trovano nelle vicinanze della distanza Levenshtein mappino a vettori simili? Quale procedura di allenamento e funzione di perdita usi per questo? Puoi riassumere il metodo nella tua risposta, in modo che la risposta sia ancora utile anche se il collegamento smette di funzionare e in modo che non dobbiamo scavare attraverso il tuo taccuino per capire il metodo che stai utilizzando? Inoltre, puoi valutare quanto funziona in modo quantitativo? È meglio delle alternative?

— DW

Allo stato attuale, questa è (penso) una scelta inadeguata per CSTheory. Cioè, nessuna idea di ciò che è specificamente suggerito e nessuna giustificazione teorica per questo.

— Clemente C.

@DW Siamo spiacenti, ho apportato una modifica piuttosto sostanziale che dovrebbe essere completa in caso di interruzione del collegamento (o nel caso in cui non si desideri scorrere il blocco note). Sebbene questa non sia in realtà una teoria CS perché non è una ricerca, penso che sia un approccio pratico perché è veloce e facile sia per la formazione che per l'inferenza.

— michaelsnowden,

1

Ti stai allenando su stringhe casuali. La distanza prevista di Levenshtein tra due di queste stringhe sarà approssimativamente la lunghezza della corda più lunga. Pertanto, è molto facile stimare questa distanza su stringhe casuali, ma non è utile per gestire i dati del mondo reale. Sospetto che i tuoi incorporamenti potrebbero semplicemente codificare la lunghezza della stringa, e quindi potresti aver creato un modo elegante per fare qualcosa di banale e inutile. Questo è un problema con l'utilizzo di ML; è molto sensibile alla funzione di perdita che usi.

— DW,

@DW Se si osservano i risultati nel notebook, il recupero ha restituito risultati decenti, non solo stringhe della stessa lunghezza. Ti incoraggio davvero a scremarlo. Non lo definirei banale e inutile.

— michaelsnowden,