[Français] scikit-learn 0.18 Guide de l'utilisateur 1.4. Support Vector Machine

http://scikit-learn.org/0.18/modules/svm.html traduction google de l'apprentissage supervisé Contenu du guide de l'utilisateur [scikit-learn 0.18 Guide de l'utilisateur 1. Apprentissage supervisé](http://qiita.com/nazoking@github/items/267f2371757516f8c168#1-%E6%95%99%E5%B8%AB%E4%BB%98 À partir de% E3% 81% 8D% E5% AD% A6% E7% BF% 92)

1.4. Machine à vecteurs de soutien

** Support Vector Machine (SVM) ** est "[Category](# 141-% E5% 88% 86% E9% A1% 9E)", "[Return](# 142% E5% 9B% 9E% E5) % B8% B0) "et" [Détection des valeurs aberrantes](# 143-% E5% AF% 86% E5% BA% A6% E6% 8E% A8% E5% AE% 9A% E6% 96% B0% E8% A6% 8F% E6% 80% A7% E6% A4% 9C% E5% 87% BA) »est un ensemble de méthodes d'apprentissage supervisé.

Les avantages de la machine à vecteurs de support sont:

Les inconvénients de la machine à vecteurs de support sont:

Prise en charge de scikit-learn La machine vectorielle prend en charge des vecteurs d'échantillons haute densité (qui peuvent être convertis en ceux de numpy.ndarray et numpy.asarray) et clairsemés (tous les vecteurs scipy.sparse) en entrée. Cependant, afin d'utiliser SVM pour faire des prédictions de données rares, il doit être compatible avec ces données. Pour de meilleures performances, utilisez numpy.ndarray (dense) ou scipy.sparse.csr_matrix (sparse) avec dtype = float64.

1.4.1. Classification

SVC, NuSVC /modules/generated/sklearn.svm.NuSVC.html#sklearn.svm.NuSVC) et [LinearSVC](http://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html#sklearn .svm.LinearSVC) est une classe qui peut effectuer une classification multi-classes sur des ensembles de données.

SVC et NuSVC sont similaires, mais acceptent des ensembles de paramètres légèrement différents et ont des formulations mathématiques différentes (voir la section [Formulations mathématiques](# 147% E6% 95% B0% E5% AD% A6). % E7% 9A% 84% E5% 87% A6% E6% 96% B9)). D'autre part, LinearSVC est un autre classificateur de vecteur de support pour les noyaux linéaires. C'est une mise en œuvre. Notez que LinearSVC n'accepte pas le mot-clé kernel. Ceci est considéré comme linéaire. De plus, certains membres de SVC et NuSVC n'ont pas quelque chose comme support_. SVC, NuSVC et LinearSVC prennent deux tableaux de taille [n_samples, n_features] pour contenir les échantillons d'apprentissage, le tableau X d'étiquette de classe (chaîne ou entier) et la taille [n_samples] comme entrées. Je vais le prendre.

>>> from sklearn import svm
>>> X = [[0, 0], [1, 1]]
>>> y = [0, 1]
>>> clf = svm.SVC()
>>> clf.fit(X, y)  
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
    max_iter=-1, probability=False, random_state=None, shrinking=True,
    tol=0.001, verbose=False)

Après l'ajustement, vous pouvez utiliser le modèle pour prédire de nouvelles valeurs.

>>> clf.predict([[2., 2.]])
array([1])

La fonction de décision SVM repose sur plusieurs sous-ensembles de données d'apprentissage appelés vecteurs de support. Certaines propriétés de ces vecteurs de support se trouvent dans les membres support_vectors_, support_ et n_support.

>>> # get support vectors
>>> clf.support_vectors_
array([[ 0.,  0.],
       [ 1.,  1.]])
>>> # get indices of support vectors
>>> clf.support_ 
array([0, 1]...)
>>> # get number of support vectors for each class
>>> clf.n_support_ 
array([1, 1]...)

1.4.1.1. Classification multiclasse

SVC et NuSVC mettent en œuvre une approche «un contre un» pour la multiclassification (Knerr et al., 1990). Si n_class est le nombre de classes, un classificateur de n_class * (n_class -1) / 2 est construit, chaque donnée d'apprentissage provenant de deux classes. Pour fournir une interface cohérente avec d'autres classificateurs, l'option decision_function_shape agrège les résultats du classificateur" un contre un "en un déterminant de forme (n_samples, n_classes). rend le possible.

>>> X = [[0], [1], [2], [3]]
>>> Y = [0, 1, 2, 3]
>>> clf = svm.SVC(decision_function_shape='ovo')
>>> clf.fit(X, Y) 
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape='ovo', degree=3, gamma='auto', kernel='rbf',
    max_iter=-1, probability=False, random_state=None, shrinking=True,
    tol=0.001, verbose=False)
>>> dec = clf.decision_function([[1]])
>>> dec.shape[1] # 4 classes: 4*3/2 = 6
6
>>> clf.decision_function_shape = "ovr"
>>> dec = clf.decision_function([[1]])
>>> dec.shape[1] # 4 classes
4

LinearSVC, quant à lui, implémente une stratégie multiclasse "one-vs-rest" et entraîne le modèle n_class. S'il n'y a que deux classes, un seul modèle sera formé.

>>>
>>> lin_clf = svm.LinearSVC()
>>> lin_clf.fit(X, Y) 
LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
     intercept_scaling=1, loss='squared_hinge', max_iter=1000,
     multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,
     verbose=0)
>>> dec = lin_clf.decision_function([[1]])
>>> dec.shape[1]
4

Voir [Formulation](# svm-mathématique-formulation) pour une description complète du déterminant. LinearSVC implémente également une stratégie multiclasse alternative, appelée SVM multiclasse, développée par Crammer et Singer en utilisant l'option multi_class = 'crammer_singer'. Cette méthode est cohérente. Cela ne s'applique pas à la classification «un contre repos». En pratique, les résultats sont à peu près les mêmes, mais le temps d'exécution est nettement inférieur, de sorte que la classification "un contre repos" est généralement préférée. Pour le LinearSVC "one-vs-rest", les attributs de coef_ et ʻintercept_ sont respectivement de la forme [n_class, n_features] ʻet [n_class]. Chaque ligne de coefficients correspond à l'un des nombreux classificateurs «one-vs-rest» «n_class», dans l'ordre de la classe «one», similaire à l'interception. Pour le SVC "one-vs-one", la disposition des attributs est un peu plus compliquée. Pour un noyau linéaire, la disposition de coef_ et de ʻintercept_ est celle décrite dans LinearSVC ci-dessus, sauf que la forme de coef_ est [n_class * (n_class -1) / 2, n_features] . Est le même que. De nombreux classificateurs binaires. L'ordre de la classe 0 à la classe n est "0 à 1", "0 à 2", ... "0 à n", "1 à 2", "1 à 3", "1 à n". .. .. "n-1 contre n". La forme de dual_coef_ est [n_class-1, n_SV], ce qui est une mise en page assez difficile. La colonne correspond à un vecteur de support contenu dans l'un des classificateurs "one-vs-one" "n_class * (n_class --1) / 2". Chaque vecteur de support est utilisé dans le classificateur n_class --1. L'entrée n_class -1sur chaque ligne correspond au double coefficient de ces classificateurs. Cela peut être plus clair dans l'exemple: Classe 0 avec 3 vecteurs de support $ v ^ {0} \ _ 0, v ^ {1} \ _ 0, v ^ {2} \ _ 0 $ et 2 vecteurs de support $ v ^ {0} \ _1, respectivement Considérons trois problèmes de classe, classe 1 et classe 2 avec v ^ {1} \ _1 $, $ v ^ {0} \ _2, v ^ {1} \ _2 $. Chaque vecteur de support $ v ^ {j} \ _i $ a deux coefficients doubles. Appelons le coefficient $ v ^ {j} \ _i $ du vecteur support dans le classificateur entre les classes $ i $ et $ k $ $ \ alpha ^ {j} \ _ {i, k} $. Alorsdual_coef_` devient:

$\alpha^{0}_{0,1}$ $\alpha^{0}_{0,2}$ Coefficients vectoriels de support de classe 0
$\alpha^{1}_{0,1}$ $\alpha^{1}_{0,2}$
$\alpha^{2}_{0,1} $ $\alpha^{2}_{0,2}$
$\alpha^{0}_{1,0}$ $\alpha^{0}_{1,2}$ Coefficients vectoriels de support de classe 1
$\alpha^{1}_{1,0}$ $\alpha^{1}_{1,2}$
$\alpha^{0}_{2,0}$ $\alpha^{0}_{2,1}$ Coefficients vectoriels de support de classe 2
$\alpha^{1}_{2,0}$ $\alpha^{1}_{2,1}$

1.4.1.2. Score et probabilité

La méthode SVC «decision_function» donne un score par classe pour chaque échantillon (ou un score par échantillon dans le cas binaire). Lorsque l'option du constructeur «probabilité» est définie sur «Vrai», l'estimation de la probabilité d'appartenance à une classe (à partir des méthodes de «predict_proba» et de «predict_log_proba») est valide. Pour le binaire, les probabilités sont calibrées à l'aide de la mise à l'échelle de Platt: régression logistique sur les scores SVM, ajustement par validation croisée supplémentaire sur les données d'entraînement. Pour les multiclasses, cela a été étendu comme dans Wu et al. (2004). Il va sans dire que la validation mutuelle impliquée dans la mise à l'échelle de Platt est une opération coûteuse pour les grands ensembles de données. En outre, l'estimation de la probabilité peut être incompatible avec le score dans le sens où «l'argmax» du score n'est pas l'argmax de la probabilité. (Par exemple, dans la classification binaire, un échantillon peut être étiqueté par "prédire" s'il appartient à une classe avec une probabilité de <½ selon "prédire_proba"). La méthode de Platt est également connue pour avoir des problèmes théoriques. Si vous avez besoin de scores de confiance, mais qu'il ne s'agit pas nécessairement de probabilités, c'est une bonne idée de définir probabilité = False et d'utiliser decision_function au lieu de predict_proba.

--Référence: Wu, Lin et Weng, "Estimation de probabilité de classification multiclasse par combinaison par paires", JMLR 5: 975 -1005, 2004.

1.4.1.3. Problème de déséquilibre

Vous pouvez utiliser les mots-clés «class_weight» et «sample_weight» dans les cas où vous souhaitez mettre davantage l'accent sur une classe particulière ou un échantillon individuel particulier. SVC (et non NuSVC) implémente le mot-clé class_weight dans la méthode fit. Ceci est un dictionnaire de la forme «{class_label: value}», où value est un nombre à virgule flottante> 0 qui définit le paramètre «C» de «class_label» sur «C * value».

SVC, NuSVC, SVR, NuSVR et OneClassSVM implémentent également des pondérations pour des échantillons individuels de la méthode «fit» à l'aide du mot-clé «sample_weight». Comme class_weight, ils définissent le paramètre C dans le i-ème exemple surC * sample_weight [i].

--Exemple:

1.4.2. Retour

La méthode de classification des vecteurs de support peut être étendue pour résoudre les problèmes de régression. Cette méthode est appelée régression vectorielle de support. Le modèle généré par la classification des vecteurs de support (comme décrit ci-dessus) ne dépend que d'un sous-ensemble des données d'apprentissage, car la fonction de coût de construction du modèle ne se soucie pas des points d'apprentissage au-delà de la marge. De même, le modèle généré par la régression vectorielle de support dépend uniquement d'un sous-ensemble des données d'apprentissage, car la fonction de coût qui construit le modèle ignore les données d'apprentissage proches de la prédiction du modèle. Il existe trois types d'implémentations de régression vectorielle de support: SVR, NuSVR et LinearSVR. LinearSVR offre une implémentation plus rapide que SVR, tandis que NuSVR implémente un format légèrement différent de SVR et LinearSVR, mais ne considère que le noyau linéaire. Pour plus d'informations, consultez Détails d'implémentation (# svm-implementation-details). Comme la classe de classification, la méthode fit est considérée comme les vecteurs d'arguments X, y. Dans ce cas, y devrait avoir une valeur à virgule flottante au lieu d'une valeur entière.

>>>
>>> from sklearn import svm
>>> X = [[0, 0], [2, 2]]
>>> y = [0.5, 2.5]
>>> clf = svm.SVR()
>>> clf.fit(X, y) 
SVR(C=1.0, cache_size=200, coef0=0.0, degree=3, epsilon=0.1, gamma='auto',
kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)
>>> clf.predict([[1, 1]])
array([ 1.5])

--Exemple:

1.4.3. Estimation de la densité, détection de nouveauté

Une classe de SVM est utilisée pour la détection de nouveauté. Autrement dit, étant donné un ensemble d'échantillons, il détecte les limites souples de l'ensemble afin de classer le nouvel ensemble comme appartenant à cet ensemble. La classe qui implémente ceci est OneClassSVM. Dans ce cas, la méthode fit n'a pas d'étiquette de classe et prend le tableau X comme entrée car c'est un type d'apprentissage non supervisé. Pour plus d'informations sur cette utilisation, consultez la section "[Détection des nouveautés et des valeurs aberrantes](http://qiita.com/nazoking@github/items/e3c4d203abafb8accbab#271-%E6%96%B0%E8%A6%8F%" E6% 80% A7% E3% 81% AE% E6% A4% 9C% E5% 87% BA) ".

--Exemple:

1.4.4. Complexe

Les machines vectorielles de support sont un outil puissant, mais à mesure que le nombre de vecteurs d'entraînement augmente, leurs besoins en informatique et en stockage augmentent rapidement. Au cœur de SVM se trouve un problème de planification secondaire (QP) qui sépare le vecteur de support du reste du vecteur de formation. Le solveur QP utilisé dans cette implémentation basée sur libsvm dépend de l'efficacité du cache libsvm, $ O (n \ _ {features} \ times n \ _ {samples} ^ 2) $ et $ O (n \ _ {features} \ times n \ _ {samples} ^ 3) $ En fait utilisé (en fonction de l'ensemble de données). Si les données sont très rares, remplacez $ n_ {features} $ par le nombre moyen d'entités non nulles dans l'exemple de vecteur. Aussi, pour linéaire, les algorithmes utilisés dans l'implémentation liblinear de LinearSVC sont beaucoup plus efficaces que le compilateur SVC basé sur libsvm. Il peut être mis à l'échelle presque linéairement à des millions d'échantillons et de fonctionnalités.

1.4.5. Conseils pratiques

1.4.6. Fonction du noyau

La fonction du noyau peut être l'une des suivantes:

--Linéaire: $ \ langle x, x '\ rangle $. --Polygon: $ (\ gamma \ langle x, x '\ rangle + r) ^ d $. $ D $ spécifie le mot-clé degree et $ r $ avec coef0.

Différents noyaux sont spécifiés lors de l'initialisation par le mot-clé kernel:

>>> linear_svc = svm.SVC(kernel='linear')
>>> linear_svc.kernel
'linear'
>>> rbf_svc = svm.SVC(kernel='rbf')
>>> rbf_svc.kernel
'rbf'

1.4.6.1. Noyau personnalisé

Vous pouvez définir votre propre noyau en donnant les fonctions Python du noyau ou en pré-calculant la matrice Gram. Un classificateur avec un noyau personnalisé se comporte comme n'importe quel autre classificateur, à l'exception de ce qui suit:

1.4.6.1.1. Utiliser les fonctions Python comme noyau

Vous pouvez également utiliser votre propre noyau prédéfini en passant une fonction au mot-clé du constructeur kernel. Le noyau doit prendre deux matrices de forme (n_samples_1, n_features), (n_samples_2, n_features) comme arguments et renvoyer une matrice de noyau de forme(n_samples_1, n_samples_2). Le code suivant définit un noyau linéaire et crée une instance de classificateur qui utilise ce noyau.

>>> import numpy as np
>>> from sklearn import svm
>>> def my_kernel(X, Y):
...     return np.dot(X, Y.T)
...
>>> clf = svm.SVC(kernel=my_kernel)

--Exemple:

1.4.6.1.2. Utilisation de la matrice gramme

Définissez kernel = 'precalculé' et passez la matrice de gramme au lieu de X dans la méthode d'ajustement. À ce stade, les valeurs du noyau entre tous les vecteurs d'entraînement et de test doivent être fournies.

>>> import numpy as np
>>> from sklearn import svm
>>> X = np.array([[0, 0], [1, 1]])
>>> y = [0, 1]
>>> clf = svm.SVC(kernel='precomputed')
>>> # linear kernel computation
>>> gram = np.dot(X, X.T)
>>> clf.fit(gram, y) 
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape=None, degree=3, gamma='auto',
    kernel='precomputed', max_iter=-1, probability=False,
    random_state=None, shrinking=True, tol=0.001, verbose=False)
>>> # predict on training examples
>>> clf.predict(gram)
array([0, 1])

1.4.6.1.3. Paramètres du noyau RBF

Lors de la formation des SVM avec le noyau de la fonction de base radiale (RBF), il y a deux paramètres à prendre en compte: «C» et «gamma». Le paramètre «C», qui est commun à tous les noyaux SVM, élimine les erreurs de classification des exemples d'apprentissage pour la simplicité de la table de décision. Un C bas vise à lisser la table de décision et un «C» élevé vise à classer correctement tous les exemples d'entraînement. gamma définit l'impact qu'aura un exemple de formation. Plus le «gamma» est grand, plus les autres exemples sont affectés. Une bonne sélection de «C» et «gamma» est importante pour les performances SVM. On utilise sklearn.model_selection.GridSearchCV avec C et `gamma Il est recommandé d'utiliser ʻexponentiellement loin.

--Exemple:

1.4.7. Prescription mathématique

Les machines vectorielles de soutien construisent des superplans ou des ensembles de superplans dans un espace dimensionnel supérieur ou infini utilisé pour la classification, la régression ou d'autres tâches. Intuitivement, en général, plus la marge est grande, plus l'erreur de généralisation du classificateur est faible, de sorte qu'une bonne séparation est obtenue par le superplan avec la plus grande distance au point de données d'apprentissage le plus proche (ce que l'on appelle la marge de fonction) de quelle classe. Atteint.

1.4.7.1. SVC

Étant donné le vecteur y des vecteurs d'apprentissage $ x_i \ in \ mathbb {R} ^ p $, $ i = 1 ... n $ et $ y \ in \ mathbb {R} ^ n $ $ \ varepsilon $ pour les deux classes Le SVC était un problème:

\min_ {w, b, \zeta} \frac{1}{2} w^T w + C \sum_{i=1}^{n} \zeta_i

\begin{align}
\textrm {subject to } & y_i (w^T \phi (x_i) + b) \geq 1 - \zeta_i,\\
 & \zeta_i \geq 0, i=1, ..., n
\end{align}

Ce double

\min_{\alpha} \frac{1}{2} \alpha^T Q \alpha - e^T \alpha

\begin{align}
\textrm {subject to } & y^T \alpha = 0\\
& 0 \leq \alpha_i \leq C, i=1, ..., n
\end{align}

Où $ e $ est le vecteur de tous les 1, $ C> 0 $ est la borne supérieure, $ Q $ est la matrice de valeurs fixes semi-positives n × n positives, $ Q_ {ij} \ equiv y_i y_j K (x_i, x_j) $. Où $ K (x_i, x_j) = \ phi (x_i) ^ T \ phi (x_j) $ est le noyau. Ici, le vecteur d'apprentissage est implicitement mappé à un espace supérieur (éventuellement infini) par la fonction $ \ phi $. Le déterminant est:

\operatorname{sgn}(\sum_{i=1}^n y_i \alpha_i K(x_i, x) + \rho)

** Remarque **: Les modèles SVM dérivés de libsvm et liblinear utilisent C comme paramètre de régularisation, mais la plupart des autres estimateurs utilisent alpha. La relation entre les deux est $ C = \ frac {n \ samples} {alpha}. $. Ce paramètre est accessible via le membre dual_coef_, qui contient le produit $ y_i \ alpha_i $, support_vectors_, qui contient les vecteurs de support, et ʻintercept`, qui contient le terme indépendant $ \ rho $.

--Référence:

1.4.7.2. NuSVC

Présentation d'un nouveau paramètre, $ \ nu $, qui contrôle le nombre de vecteurs de support et les erreurs d'entraînement. Paramètres $ \ nu \ in (0, 1] $ est la limite supérieure du taux d'erreur d'entraînement et la limite inférieure du taux de vecteur de support. Il s'avère que la formulation $ \ nu $ -SVC est une reparamétrie de C-SVC et est donc mathématiquement équivalente.

1.4.7.3. SVR

Étant donné le vecteur d'apprentissage $ x_i \ mathbb {R} ^ p $, i = 1, ..., n et le vecteur $ \ mathbb {R} ^ n \ varepsilon $ -SVR résout les problèmes suivants Faire.

    \min_ {w, b, \zeta, \zeta^*} \frac{1}{2} w^T w + C \sum_{i=1}^{n} (\zeta_i + \zeta_i^*)

\begin{align}
    \textrm {subject to } & y_i - w^T \phi (x_i) - b \leq \varepsilon + \zeta_i,\\
                          & w^T \phi (x_i) + b - y_i \leq \varepsilon + \zeta_i^*,\\
                          & \zeta_i, \zeta_i^* \geq 0, i=1, ..., n

\end{align}

Ce double

   \min_{\alpha, \alpha^*} \frac{1}{2} (\alpha - \alpha^*)^T Q (\alpha - \alpha^*) + \varepsilon e^T (\alpha + \alpha^*) - y^T (\alpha - \alpha^*)

\begin{align}
   \textrm {subject to } & e^T (\alpha - \alpha^*) = 0\\
   & 0 \leq \alpha_i, \alpha_i^* \leq C, i=1, ..., n
\end{align}

Où $ e $ est le vecteur de tous les 1, $ C> 0 $ est la borne supérieure, $ Q $ est la matrice de valeur semi-fixe $ n $ par $ n $ positive, $ Q_ {ij} \ equiv K (x_i`` x_j) = \ phi (x_i) ^ T \ phi (x_j) $ est le noyau. Ici, le vecteur d'apprentissage est implicitement mappé à un espace supérieur (éventuellement infini) par la fonction $ \ phi $. Le déterminant est:

 \sum_{i=1}^n (\alpha_i - \alpha_i^*) K(x_i, x) + \rho

Ces paramètres sont accessibles via le membre dual_coef_, qui contient la différence $ \ alpha_i- \ alpha_i ^ * $, support_vectors_, qui contient les vecteurs de support, et ʻintercept_`, qui contient le terme indépendant $ \ ρ $.

--Référence:

1.4.8. Détails de mise en œuvre

En interne, libsvm et [liblinear](http: //www.csie.) Pour gérer tous les calculs. Utilisez ntu.edu.tw / ~ cjlin / liblinear /). Ces bibliothèques sont encapsulées à l'aide de C et Cython.

--Référence: Pour la mise en œuvre et les détails de l'algorithme utilisé, voir:

[scikit-learn 0.18 Guide de l'utilisateur 1. Apprentissage supervisé](http://qiita.com/nazoking@github/items/267f2371757516f8c168#1-%E6%95%99%E5%B8%AB%E4%BB%98 À partir de% E3% 81% 8D% E5% AD% A6% E7% BF% 92)

© 2010 --2016, développeurs scikit-learn (licence BSD).

Recommended Posts

[Français] scikit-learn 0.18 Guide de l'utilisateur 1.4. Support Vector Machine
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.5. Projection aléatoire
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.11. Méthode Ensemble
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.15. Régression isotonique
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.2 Extraction de fonctionnalités
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.16. Étalonnage des probabilités
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.13 Sélection des fonctionnalités
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.4. Persistance du modèle
[Français] scikit-learn 0.18 Guide de l'utilisateur 2.8. Estimation de la densité
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.3. Prétraitement des données
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.4. Réduction de dimension non supervisée
[Français] scikit-learn 0.18 Guide de l'utilisateur Table des matières
Machine de vecteur de support d'apprentissage automatique
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.12. Algorithme multi-classes et algorithme multi-étiquettes
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.2. Réglage des hyper paramètres de l'estimateur
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.8. Convertir la cible de prédiction (y)
Machine Learning: Supervisé - Support Vector Machine
Algorithme d'apprentissage automatique (machine vectorielle de support)
[Français] scikit-learn 0.18 Guide de l'utilisateur 2.7. Détection des nouveautés et des valeurs aberrantes
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.1. Validation croisée: évaluer les performances de l'estimateur
Algorithme d'apprentissage automatique (prise en charge de l'application de machine vectorielle)
Apprentissage automatique ① Résumé SVM (Support Vector Machine)
<Course> Machine Learning Chapitre 7: Support Vector Machine
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.3. Évaluation du modèle: quantifier la qualité de la prédiction
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.1. Union des pipelines et des fonctionnalités: combinaison d'estimateurs
Support Vector Machine (pour les débutants) -Code Edition-
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.5. Courbe de vérification: tracez le score pour évaluer le modèle
[Français] scikit-learn 0.18 Guide de l'utilisateur 2.5. Décomposer les signaux en composants (problème de décomposition de la matrice)
[Français] scikit-learn 0.18 Introduction de l'apprentissage automatique par le didacticiel scikit-learn
Calcul de la machine à vecteurs de support (SVM) (en utilisant cvxopt)
Guide de l'utilisateur Pandas "Multi-Index / Advanced Index" (Document officiel traduction japonaise)
Guide de l'utilisateur Pandas "Manipulation des données manquantes" (Document officiel de traduction en japonais)