Méthode rapide pour trouver les meilleurs métaparamètres de SVM (c'est plus rapide que la recherche dans la grille)

J'utilise des modèles SVM pour faire des prévisions à court terme des polluants atmosphériques. Pour former un nouveau modèle, je dois trouver des métaparamètres appropriés pour un modèle SVM (je veux dire C, gamma, etc.).

La documentation de Libsvm (et de nombreux autres livres que j'ai lus) suggère d'utiliser la recherche de grille pour trouver ces paramètres - donc je forme essentiellement le modèle pour chaque combinaison de ces paramètres à partir d'un certain ensemble et choisis le meilleur modèle.

Y a-t-il une meilleure façon de trouver des métaparamètres optimaux (ou presque optimaux)? Pour moi, c'est principalement une question de temps de calcul - une recherche dans la grille de ce problème prend environ deux heures (après avoir fait quelques optimisations).

Avantages de la recherche sur la grille:

• Il peut être facilement parallélisé - si vous avez 20 processeurs, il fonctionnera 20 fois plus vite, la parallélisation d'autres méthodes est plus difficile
• Vous vérifiez de grandes parties de l'espace métaparamétrique, donc s'il existe une bonne solution, vous la trouverez.

L'inconvénient de la recherche dans la grille est que le temps d'exécution croît aussi vite que le produit du nombre d'options pour chaque paramètre.

Voici une entrée dans le blog d'Alex Smola liée à votre question

Voici une citation:

[...] choisissez, disons 1000 paires (x, x ') au hasard dans votre ensemble de données, calculez la distance de toutes ces paires et prenez la médiane, le 0,1 et le 0,9 quantile. Choisissez maintenant λ pour être l'inverse de l'un de ces trois nombres. Avec un peu de validation croisée, vous découvrirez lequel des trois est le meilleur. Dans la plupart des cas, vous n'aurez plus besoin de chercher.

Je n'ai pas essayé cela moi-même, mais cela semble plutôt prometteur.

Si vous faites l'hypothèse qu'il existe une fonction relativement fluide sous-jacente à la grille de paramètres, vous pouvez faire certaines choses. Par exemple, une heuristique simple consiste à commencer par une grille de paramètres très grossière, puis à utiliser une grille plus fine autour du meilleur des réglages de paramètres de la grille grossière.

Cela a tendance à bien fonctionner dans la pratique, avec des mises en garde bien sûr. Premièrement, l'espace n'est pas nécessairement lisse et il pourrait y avoir des optima locaux . La grille grossière peut complètement les manquer et vous pourriez vous retrouver avec une solution sous-optimale. Notez également que si vous avez relativement peu d'échantillons dans votre jeu d'exclusion, vous pouvez avoir beaucoup de réglages de paramètres qui donnent le même score (erreur ou métrique que vous utilisez). Cela peut être particulièrement problématique si vous effectuez un apprentissage en plusieurs classes (par exemple, en utilisant la méthode un pour tous ), et que vous n'avez que quelques exemples de chaque classe dans votre ensemble d'exposés. Cependant, sans recourir à des techniques d'optimisation non linéaire désagréables, cela sert probablement de bon point de départ.

Il y a un bel ensemble de références ici . Dans le passé, j'ai adopté l'approche selon laquelle vous pouvez raisonnablement estimer une bonne gamme d'hyperparamètres du noyau en inspectant le noyau (par exemple, dans le cas du noyau RBF, en veillant à ce que l'histogramme des valeurs du noyau donne une bonne répartition des valeurs, plutôt que d'être biaisé vers 0 ou 1 - et vous pouvez aussi le faire automatiquement sans trop de travail), ce qui signifie que vous pouvez réduire la plage avant de commencer. Vous pouvez ensuite concentrer votre recherche sur d'autres paramètres tels que le paramètre de régularisation / capacité. Cependant, bien sûr, cela ne fonctionne qu'avec des noyaux précalculés, bien que vous puissiez estimer cela sur un sous-ensemble aléatoire de points si vous ne souhaitez pas utiliser de noyaux précalculés, et je pense que cette approche conviendrait également.

J'utilise le recuit simulé pour rechercher des paramètres.

Le comportement est régi par quelques paramètres:

• k est la constante de Boltzmann.
• T_max est votre température de départ.
• T_min est votre seuil de fin.
• mu_T( μ) représente la baisse de la température ( T->T/μ)
• i est le nombre d'itérations à chaque température
• zest une taille de pas - vous déterminez ce que cela signifie exactement. Je me déplace au hasard à l'intérieur old*(1±z).

1. Prenez un point de départ (ensemble de valeurs de paramètres).
2. Obtenez une énergie pour cela (dans quelle mesure il s'adapte à vos données; j'utilise des valeurs chi carré).
3. Regardez dans une direction aléatoire ("faites un pas").
   • Si l'énergie est inférieure à votre point actuel, déplacez-vous là.
   • S'il est plus élevé, déplacez-vous avec une probabilité p = e^{-(E_{i+1} - E_i)/(kT)}.
4. Répétez l'opération, en abaissant occasionnellement T->T/μtoutes les iitérations jusqu'à ce que vous frappiez T_min.

Jouez un peu avec les paramètres et vous devriez pouvoir trouver un ensemble qui fonctionne bien et rapidement.

Et la bibliothèque scientifique GNU comprend un recuit simulé.

Si quelqu'un est intéressé, voici quelques-unes de mes réflexions sur le sujet:

• Comme l'a suggéré @tdc, je fais une recherche de grille grossière / fine. Cela introduit deux problèmes:
  • Dans la plupart des cas, je vais obtenir un ensemble de bons ensembles de métaparamètres qui ont des paramètres extrêmement différents --- je l'interprète de cette manière que ces paramètres sont des solutions optimales, mais pour être sûr, je devrais vérifier toutes les grilles fines près de tous ces bons paramètres ( cela prendrait beaucoup de temps), donc pour l'instant je ne vérifie que le voisinage des paris mis en métaparamètre.
  • Dans la plupart des cas, la recherche fine n'augmente pas les performances SVM (cela peut être dû au fait que je vérifie uniquement le voisinage du meilleur point de la grille grossière).
• J'ai observé un comportement selon lequel la plupart du temps de calcul est consacré à des ensembles de métaparamètres qui ne donneront pas de bons résultats, par exemple: la plupart des ensembles de métaparamètres calculent en moins de 15 secondes (et le meilleur d'entre eux ont un taux d'erreur de 15%), et certains prennent 15 minutes ( et la plupart d'entre eux ont des taux d'erreur supérieurs à 100%). Ainsi, lorsque je fais une recherche dans la grille, je tue des points qui prennent plus de 30 secondes à calculer et supposent qu'ils avaient une erreur infinie.
• J'utilise le multiprocessing (ce qui est assez simple)

Si le noyau est radial, vous pouvez utiliser cette heuristique pour obtenir une bonne$\sigma$ - L'optimisation C est alors beaucoup plus facile.