Faire des SVM courir plus vite en python

À l'aide de la code ci-dessous pour les svm en python:

from sklearn import datasets
from sklearn.multiclass import OneVsRestClassifier
from sklearn.svm import SVC
iris = datasets.load_iris()
X, y = iris.data, iris.target
clf = OneVsRestClassifier(SVC(kernel='linear', probability=True, class_weight='auto'))
clf.fit(X, y)
proba = clf.predict_proba(X)

Mais il prend une énorme quantité de temps.

Données Réelles Dimensions:

train-set (1422392,29)
test-set (233081,29)

Comment puis-je accélérer(parallèle ou d'une autre façon)? S'il vous plaît aider.
J'ai déjà essayé de l'APC et de sous-échantillonnage.

J'ai 6 classes.
Edit:
Trouvé http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDClassifier.html
mais je souhaite que les estimations de probabilité, et il ne semble pas tellement pour les svm.

Edit:

from sklearn import datasets
from sklearn.multiclass import OneVsRestClassifier
from sklearn.svm import SVC,LinearSVC
from sklearn.linear_model import SGDClassifier
import joblib
import numpy as np
from sklearn import grid_search
import multiprocessing
import numpy as np
import math

def new_func(a):                              #converts array(x) elements to (1/(1 + e(-x)))
    a=1/(1 + math.exp(-a))
    return a

if __name__ == '__main__':
    iris = datasets.load_iris()
    cores=multiprocessing.cpu_count()-2
    X, y = iris.data, iris.target                       #loading dataset

    C_range = 10.0 ** np.arange(-4, 4);                  #c value range 
    param_grid = dict(estimator__C=C_range.tolist())              

    svr = OneVsRestClassifier(LinearSVC(class_weight='auto'),n_jobs=cores) ################LinearSVC Code faster        
    #svr = OneVsRestClassifier(SVC(kernel='linear', probability=True,  ##################SVC code slow
    #   class_weight='auto'),n_jobs=cores)

    clf = grid_search.GridSearchCV(svr, param_grid,n_jobs=cores,verbose=2)  #grid search
    clf.fit(X, y)                                                   #training svm model                                     

    decisions=clf.decision_function(X)                             #outputs decision functions
    #prob=clf.predict_proba(X)                                     #only for SVC outputs probablilites
    print decisions[:5,:]
    vecfunc = np.vectorize(new_func)
    prob=vecfunc(decisions)                                        #converts deicision to (1/(1 + e(-x)))
    print prob[:5,:]

Edit 2:
La réponse par user3914041 donne de très mauvaises estimations de probabilité.

  • Quantifier "quantité énorme de temps." Qu'avez-vous utilisé pour le profil de votre code?
  • Merci pour les commentaires. Je suis indiquant à peu près par hasard s'exécute du code. Je suis à peu près de mesure par la sortie vérifie dans le code, ce qui est une mauvaise façon de le faire. Ne fait que répondre à votre question?
  • Avez-vous besoin de tous les 1,4 million d'exemples de formation? Selon le docs L'ajustement du temps de la complexité est plus quadratique dans le nombre d'exemples de formation. En outre, vous avez besoin de l'estimation des probabilités? Qui requiert une course de cross-validation de la générer.
  • Merci pour l'info! Comme mentionné, je peux sous-échantillonner mais il n'est pas préférable. Oui, j'ai besoin d'estimations de probabilité délimitée par certains format de la compétition.
  • Le OneVsRestClassifier livré avec une option pour le parallélisme, mais être averti qu'il peut manger beaucoup de vos ressources, car il faudra beaucoup de temps pour s'adapter à chacun des modèles. Essayez de définir le n_jobs paramètre selon les docs ici.
  • Essayez MKL Optimisations de Continuum, voir magasin.continuum.io/cshop/mkl-optimisations. Ils offrent un essai gratuit de 30 jours et le coût est de $99. Je ne suis pas un représentant des ventes, mais je utiliser leurs Anaconda Python distribution et, comme il a été recommandé à l'Étincelle du Sommet de la formation. D'ailleurs Étincelle prend en charge SVM et qu'il tourne sur même une petite Étincelle cluster améliorer considérablement les performances, voir spark.apache.org/docs/1.1.0/....
  • Allumage ne fonctionne pas car il ne prend pas en charge les estimations de probabilité de SVM
  • Merci pour les connaissances utiles! J'ai un cluster HPC avec moi. Mais si ne pas offrir des estimations de probabilité, alors il ne serait pas d'une grande utilité.
  • Je n'ai pas regardé beaucoup en elle, mais je pense que IPython Parallèle / Starcluster pourrait être utile de vérifier ainsi. Voici un résumé de l'information avec le code de démonstration à partir de l'une des sklearn des collaborateurs de tutoriels. Mais pour se développer à partir de Tris commentaire, vous allez vouloir essayer de passer sur un cluster à un certain point. Et si sklearn ne fonctionne pas facilement sur un cluster, vous pouvez envisager d'écrire votre propre code sur le dessus de ces autres bibliothèques qui vous donne les estimations de probabilité dont vous avez besoin.
  • Merci pour la réponse, encore une fois! J'ai essayé d'utiliser OneVsRestClassifier en parallèle. J'ai été alloué 14 noyaux, mais il semblait seulement 6 d'entre eux (qui est égal au nombre de classes). Une raison à cela, vous le savez, je suis pas certain de savoir comment parallèle dégradé travaille. Si je ne peux pas courir plus vite que le nombre de classes, je ne pense pas que l'aide de cluster serait de l'aide.(Aussi, j'ai déjà plus qu'assez de RAM ~48 GB sur le bureau. Donc, il n'y a pas de problème de mémoire.)
  • Oui SVM prend beaucoup de temps et de manière lente dans les Processeurs. Vous aurez besoin de blanchir de l'APC de données, pour le rendre plus rapide ou essayer de trouver une bibliothèque qui s'exécute dans le GPU.
  • Merci pour la réponse! Je fais blanchir les données. Je ne peux pas trouver une telle bibliothèque. Pouvez-vous mentionner les raisons pour lesquelles l'aide de GPU pourrait l'aider.
  • Ce n'est pas vraiment parallèle gradient d'autant qu'il est approprié l'6 OneVsRest modèles en parallèle, il est donc logique qu'il ne sera pas paralléliser plus que cela. Si vous avez l'intention de rester avec Python et sklearn.SVC en raison des estimations de probabilité, alors il me semble que votre meilleur pari serait de sous-échantillonner, de l'APC, et l'utilisation OneVsRest avec 6 emplois.
  • Merci pour l'info! Moi je préfère Matlab sur python, mais comme la plupart des autres code en python. En outre, le temps ne permet pas le changement.
  • En cours d'exécution sur GPU est 20X, et en plus, si vous exécutez natif c/c++ code, il ajoute à la vitesse. Python toujours lente (au moins pour moi!). Jetez un oeil ici: devtalk.nvidia.com/default/topic/485456/...
  • Le sous-échantillonnage et de l'APC de ne pas donner de bons résultats. Si vous vous connaissez de toute autre possibilité s'il vous plaît laissez-moi savoir. Probablement à l'aide de LinearSVC à rendre les estimations de probabilité.
  • Si cela ne fonctionne pas pour vous, alors je suis d'accord. LinearSVC avec calibré estimations de probabilité est alors une autre bonne option. J'imagine que vous pouvez également essayer de régulariser la Régression Logistique à nouveau avec des paramètres appropriés, même si il a donné de précision inférieure comme vous le mentionnez ci-dessous. Il est très difficile d'évaluer ce qui fonctionne le mieux pour vous, sans rien savoir d'autre sur les données. :/
  • Salut, merci pour l'info! J'ai essayé un peu de code pour LinearSVC avec calibré estimations de probabilité, veuillez vérifier(Édition en Question). L'aide maximale likelohood convient sans doute mieux de ce que j'ai pu trouver. 1/1+exp(Ax+B), où A et B sont des paramètres appris par ML estimation. Pouvez-vous aider à la façon de la mettre en œuvre. Je n'arrive pas à trouver un point de départ.