Ci sono miglioramenti nell'algoritmo di Dana Angluin per l'apprendimento di serie regolari

Nel suo seminario del 1987 Dana Angluin presenta un algoritmo temporale polinomiale per l'apprendimento di un DFA da domande di appartenenza e domande di teoria (controesempi a un DFA proposto).

Mostra che se stai cercando di imparare un DFA minimo con stati, e il tuo più grande esempio di countex è di lunghezza , allora devi fare domande di appartenenza e al massimo domande di teoria. $n$ $m$ $O(mn^2)$ $n - 1$

Sono stati apportati miglioramenti significativi al numero di query necessarie per apprendere una serie regolare?

Riferimenti e domande correlate

Dana Angluin (1987) "Apprendimento di insiemi regolari da query e controesempi", Infortmation and Computation 75: 87-106
Limiti inferiori per l'apprendimento nella query di appartenenza e nel modello di controesempio

algorithms learning-theory machine-learning

— Artem Kaznatcheev
fonte

Speriamo che @DominikFreydenberger passi ad un certo punto in futuro. Lo saprà.

— Raffaello

Sospetto che anche @LevReyzin conoscesse la risposta ... ed era per questo che inizialmente avevo pensato di chiedere su cstheory, ma credo che dovrei aiutare a far crescere questo nuovo sito.

— Artem Kaznatcheev,

Non è una risposta alla domanda, ma può ancora essere utile: [ citeulike.org/user/erelsegal-halevi/article/9275508 Un kernel universale per l'apprendimento delle lingue regolari]

— Erel Segal-Halevi

grazie per il link @Erel, ma non capisco come si collega. Il kernel universale di Kontorovich non è calcolabile in modo efficiente e il modello di apprendimento non ha controesempi.

— Artem Kaznatcheev,

Risposte:

$O(n^2 + n\log m)$

Schizzo del miglioramento

$(S,E,T)$ $(S,E,T)$ $s_1, s_2 \in S$ $s_1 \neq s_2$ $row(s_1) \neq row(s_2)$ $|S| \leq n$

$z$ $z$ $S$ $e$ $E$ $e$ $(S,E,T)$ $S$ $e$

\exists s, s^{'} \in S, a \in Σ s.t r o w (s) = r o w (s^{'} a) and o (δ (q_{0}, s e)) \neq o (δ (q_{0}, s^{'} a e))

$\exists s, s' \in S, a \in \Sigma \quad \text{s.t} \quad row(s) = row(s'a) \; \text{and} \; o(\delta(q_0,se)) \neq o(\delta(q_0,s'ae))$

$o$ $q_0$ $\delta$ $e$ $s$ $s'a$

$e$ $z$ $r_i$ $z = p_ir_i$ $0 \leq |p_i| = i < |z|$ $s_i$ $p_i$ $\log m$ $k$ $o(\delta(q_0,s_kr_k)) \neq o(\delta(q_0,s_{k+1}r_{k+1})$ $r_{k+1}$ $e$ $E$

— Artem Kaznatcheev
fonte

Non so se la mia risposta è ancora pertinente. Recentemente è stata descritta l'implementazione di un nuovo algoritmo chiamato Observation Pack o in alcune circostanze Discrimination Tree di Falk Howar. Questo algoritmo è come L * ma usa Rivest-Shapire o un altro metodo (vedi Steffen e Isberner) per gestire la decomposizione del controesempio; e utilizza una struttura di dati, un albero di discriminazione (un albero binario) per rendere efficacemente un "setaccio", vale a dire l'inserimento di una transizione A (dove A è ogni simbolo dell'alfabeto) di un nuovo stato trovato fino a quando non c'è chiusura . Questo algoritmo esiste in due versioni: OneGlobally e OneLocally a seconda che il suffisso fondato nella decomposizione venga aggiunto o meno a ciascun componente (il rapporto dietro l'algoritmo è che tutti i prefissi in un componente sono equivalenti a un prefisso breve e rappresentano lo stesso stato nella destinazione in base ai suffissi trovati in questo momento. Più tardi con un nuovo controesempio viene trovato un nuovo suffisso che discrimina almeno 2 prefissi di uno stesso componente, causando una divisione di quel componente in due componenti). Con OneLocally ci sono molte meno richieste di appartenenza, ma il numero di query di equivalenza può aumentare drasticamente con DFA target di grandi dimensioni. Piuttosto OneGlobally ha un numero di query di appartenenza sempre inferiore a L * (ma maggiore di OneLocally) e un numero simile di query di equivalenza rispetto a L * Successivamente con un nuovo controesempio viene trovato un nuovo suffisso che discrimina almeno 2 prefissi di uno stesso componente. Ciò causa una divisione di quel componente in due componenti). Con OneLocally ci sono molte meno richieste di appartenenza, ma il numero di query di equivalenza può aumentare drasticamente con DFA target di grandi dimensioni. Piuttosto OneGlobally ha un numero di query di appartenenza sempre inferiore a L * (ma maggiore di OneLocally) e un numero simile di query di equivalenza rispetto a L * Successivamente con un nuovo controesempio viene trovato un nuovo suffisso che discrimina almeno 2 prefissi di uno stesso componente. Ciò causa una divisione di quel componente in due componenti). Con OneLocally ci sono molte meno richieste di appartenenza, ma il numero di query di equivalenza può aumentare drasticamente con DFA target di grandi dimensioni. Piuttosto OneGlobally ha un numero di query di appartenenza sempre inferiore a L * (ma maggiore di OneLocally) e un numero simile di query di equivalenza rispetto a L *

So che esiste anche un altro algoritmo: l'algoritmo TTT che è migliore anche di Observation Pack ma non ne ho una buona conoscenza. L'algoritmo TT dovrebbe essere lo stato dell'arte

— Umbert
fonte

Grazie per questa risposta! Hai un riferimento cartaceo per l'algoritmo Howar e per TTT?

— Artem Kaznatcheev,

Questo per il link del pacchetto di osservazione Howar e questo per il link dell'algoritmo di TTT TTT Puoi trovare l'implementazione in LearLib (il pacchetto di osservazione è chiamato lì Discrimination Tree)

— Umbert