Metodo rapido per trovare i migliori metaparametri di SVM (che è più veloce della ricerca in griglia)

Sto usando modelli SVM per fare previsioni a breve termine di inquinanti atmosferici. Per addestrare un nuovo modello, devo trovare metaparametri appropriati per un modello SVM (intendo C, gamma e così via).

La documentazione di Libsvm (e molti altri libri che ho letto) suggerisce di usare la ricerca della griglia per trovare questi parametri, quindi fondamentalmente alleno il modello per ogni combinazione di questi parametri da un determinato set e scelgo il modello migliore.

Esiste un modo migliore per trovare metaparametri ottimali (o quasi ottimali)? Per me è principalmente una questione di tempo di calcolo - una ricerca in griglia di questo problema richiede circa due ore (dopo che ho fatto alcune ottimizzazioni).

Pro della ricerca della griglia:

• Può essere facilmente parallelizzato - se hai 20 CPU funzionerà 20 volte più velocemente, parallelizzare altri metodi è più difficile
• Controlli grandi parti dello spazio del metaparametro, quindi se c'è una buona soluzione la troverai.

Il rovescio della medaglia della ricerca della griglia è che il tempo di esecuzione cresce tanto rapidamente quanto il prodotto del numero di opzioni per ciascun parametro.

Ecco una voce nel blog di Alex Smola relativa alla tua domanda

Ecco una citazione:

[...] scegli, diciamo 1000 coppie (x, x ') a caso dal tuo set di dati, calcola la distanza di tutte queste coppie e prendi la mediana, lo 0,1 e lo 0,9 quantile. Ora scegli λ come inverso uno di questi tre numeri. Con un po 'di crossvalidation scoprirai quale dei tre è il migliore. Nella maggior parte dei casi non sarà necessario effettuare ulteriori ricerche.

Non ho provato questo, ma sembra promettente.

Se si presume che vi sia una funzione relativamente regolare alla base della griglia di parametri, ci sono alcune cose che è possibile fare. Ad esempio, una semplice euristica è iniziare con una griglia di parametri molto grossolana e quindi utilizzare una griglia più fine attorno alla migliore delle impostazioni dei parametri dalla griglia grossolana.

Questo tende a funzionare abbastanza bene in pratica, con avvertimenti ovviamente. Il primo è che lo spazio non è necessariamente liscio e potrebbero esserci optima locali . La griglia grossolana potrebbe mancare completamente questi e potresti finire con una soluzione non ottimale. Si noti inoltre che se si dispone di relativamente pochi campioni nel set di controllo, è possibile che siano presenti molte impostazioni dei parametri che danno lo stesso punteggio (errore o qualunque metrica si stia utilizzando). Questo può essere particolarmente problematico se stai facendo un apprendimento multi-classe (ad es. Usando il metodo uno contro tutti ), e hai solo alcuni esempi da ciascuna classe nel tuo set di controllo. Tuttavia, senza ricorrere a brutte tecniche di ottimizzazione non lineare, questo probabilmente serve come un buon punto di partenza.

C'è un bel set di riferimenti qui . In passato ho adottato l'approccio secondo cui è possibile stimare ragionevolmente una buona gamma di iperparametri del kernel mediante l'ispezione del kernel (ad esempio nel caso del kernel RBF, assicurando che l'istogramma dei valori del kernel fornisca una buona diffusione di valori, piuttosto che essere inclinato verso 0 o 1 - e puoi farlo automaticamente anche senza troppo lavoro), il che significa che puoi restringere l'intervallo prima di iniziare. È quindi possibile focalizzare la ricerca su altri parametri come il parametro regolarizzazione / capacità. Tuttavia, ovviamente, questo funziona solo con i kernel pre-calcolati, sebbene sia possibile stimarlo su un sottoinsieme casuale di punti se non si desidera utilizzare i kernel pre-calcolati e penso che anche l'approccio andrebbe bene.

Uso la ricottura simulata per la ricerca dei parametri.

Il comportamento è regolato da alcuni parametri:

• k è la costante di Boltzmann.
• T_max è la tua temperatura iniziale.
• T_min è la tua soglia finale.
• mu_T( μ) è quanto abbassi la temperatura ( T->T/μ)
• i è il numero di iterazioni per ciascuna temperatura
• zè una dimensione del passo: decidi cosa significa esattamente. Mi muovo casualmente all'interno old*(1±z).

1. Prendi un punto di partenza (set di valori dei parametri).
2. Ottieni energia per questo (quanto bene si adatta ai tuoi dati; io uso valori chi-quadrati).
3. Guarda in una direzione casuale ("fai un passo").
   • Se l'energia è inferiore al tuo punto attuale, spostati lì.
   • Se è più alto, spostati lì con una probabilità p = e^{-(E_{i+1} - E_i)/(kT)}.
4. Ripeti, abbassando T->T/μogni tanto ogni iiterazione fino a quando non colpisci T_min.

Gioca con i parametri un po 'e dovresti essere in grado di trovare un set che funzioni bene e velocemente.

E la GNU Scientific Library include ricottura simulata.

Se qualcuno è interessato qui sono alcuni dei miei pensieri sull'argomento:

• Come suggerito da @tdc, sto eseguendo una ricerca della griglia grossolana / fine. Questo introduce due problemi:
  • Nella maggior parte dei casi otterrò una serie di buoni set di metaparametro che hanno parametri selvaggiamente diversi --- lo sto interpretando in questo modo che questi parametri sono soluzioni ottimali, ma per essere sicuro dovrei controllare tutte le griglie fini vicino a tutti questi buoni parametri ( sarebbe un sacco di tempo), quindi per ora controllo solo il set di metaparametro del vicinato delle scommesse.
  • Nella maggior parte dei casi, la ricerca fine non aumenta le prestazioni SVM (ciò potrebbe essere dovuto al fatto che sto controllando solo il quartiere più vicino del punto migliore dalla griglia grossolana.
• Ho osservato il comportamento che la maggior parte del tempo di calcolo viene impiegato su set di metaparemeters che non produrrà buoni risultati, ad esempio: la maggior parte dei set di metaparametro calcolerà in meno di 15 secondi (e la maggior parte di essi ha un tasso di errore del 15%) e alcuni impiegano 15 minuti ( e la maggior parte di questi ha tassi di errore superiori al 100%). Quindi, quando eseguo la ricerca della griglia, uccido i punti che richiedono più di 30 secondi per calcolare e presumo che abbiano un errore infinito.
• Uso il multiprocessing (che è abbastanza semplice)

Se il kernel è radiale, puoi usare questa euristica per ottenere un valore corretto$\sigma$ - L'ottimizzazione C è quindi molto più semplice.