Même dans l'apprentissage automatique, il est difficile d'automatiser l'ensemble du processus d'apprentissage Il y a des moments où vous devez ajuster manuellement le modèle.
Les hyper paramètres font partie des paramètres d'un modèle d'apprentissage automatique. C'est un paramètre qu'une personne doit ajuster.
Les hyper paramètres varient en fonction de la méthode choisie, nous allons donc expliquer chaque modèle.
Le réglage des hyper paramètres est appelé réglage. Quant à la méthode d'ajustement, autre que la saisie directe de la valeur dans le modèle Il existe également un moyen de rechercher la meilleure valeur en spécifiant une plage de valeurs d'hyperparamètres.
Dans scikit-learn, en entrant une valeur dans le paramètre lors de la construction du modèle Les paramètres peuvent être réglés. Si vous n'entrez aucun paramètre Les valeurs initiales des paramètres définis pour chaque modèle sont spécifiées telles quelles.
Le code ressemble à ceci:
#Méthode de réglage utilisant un classificateur de modèle fictif comme exemple
model = Classifier(param1=1.0, param2=True, param3="linear")
Il existe un paramètre appelé C dans la régression logistique.
Dans ce C, la ligne de démarcation d'identification apprise par le modèle est contre une mauvaise classification des données des enseignants. C'est un indicateur de sa rigueur.
Plus la valeur de C est élevée, plus le modèle apprendra une ligne discriminante qui peut classer complètement les données de l'enseignant. Cependant, il tombe dans le surapprentissage en raison d'un apprentissage excessif des données des enseignants. Si vous faites des prédictions pour des données autres que des données d'entraînement, le taux de précision diminuera souvent.
Diminuer la valeur de C le rend plus tolérant aux erreurs de classification des données des enseignants. En permettant une classification erronée, la ligne de démarcation est moins susceptible d'être affectée par des données aberrantes. Il est plus facile d'obtenir des limites généralisées. Cependant, avec des données avec peu de valeurs aberrantes, les limites peuvent ne pas être bien identifiées. De plus, même si elle est extrêmement petite, la ligne de démarcation ne peut pas être bien identifiée.
La valeur initiale de C pour le modèle de régression logistique de scikit-learn est 1.0.
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
%matplotlib inline
#Génération de données
X, y = make_classification(
n_samples=1250, n_features=4, n_informative=2, n_redundant=2, random_state=42)
train_X, test_X, train_y, test_y = train_test_split(X, y, random_state=42)
#Définir la plage de valeurs C(Cette fois 1e-5,1e-4,1e-3,0.01,0.1,1,10,100,1000,10000)
C_list = [10 ** i for i in range(-5, 5)]
#Préparez une liste vide pour dessiner des graphiques
train_accuracy = []
test_accuracy = []
#Le code ci-dessous est important.
for C in C_list:
model = LogisticRegression(C=C, random_state=42) #J'apporte une liste de C.
model.fit(train_X, train_y)
train_accuracy.append(model.score(train_X, train_y))
test_accuracy.append(model.score(test_X, test_y))
#Préparation graphique
# semilogx()Modifie l'échelle de x à l'échelle de 10 à la puissance xe
plt.semilogx(C_list, train_accuracy, label="accuracy of train_data")
plt.semilogx(C_list, test_accuracy, label="accuracy of test_data")
plt.title("accuracy by changing C")
plt.xlabel("C")
plt.ylabel("accuracy")
plt.legend()
plt.show()
Alors que C était la tolérance pour les erreurs de classification
la pénalité représente une pénalité pour la complexité du modèle.
Il y a deux valeurs qui peuvent être entrées dans la pénalité, "L1" et "L2". En gros, vous pouvez sélectionner «L2», mais il existe des cas où vous pouvez obtenir les données souhaitées en sélectionnant «L1».
L1:C'est une pénalité pour généraliser la ligne de démarcation d'identification en réduisant la quantité de caractéristiques de données.
L2:C'est une pénalité pour généraliser la frontière d'identification en réduisant le poids de l'ensemble des données.
multi_class est un paramètre qui détermine le comportement du modèle lors de l'exécution d'une classification multi-classes.
La régression logistique fournit deux valeurs, "ovr" et "multinomial".
ovr: Convient aux problèmes qui répondent à une classe avec la valeur binaire "appartenir / ne pas appartenir".
multinomial: la probabilité d'être classé dans chaque classe est également prise en compte Convient pour les questions traitant de «combien peut appartenir» ainsi que «appartenance / non appartenance».
Le modèle traite les données dans un ordre aléatoire pendant l'entraînement.
random_l'état est un paramètre pour contrôler l'ordre.
Dans le cas du modèle de régression logistique, la ligne de démarcation peut changer de manière significative en fonction de l'ordre de traitement en fonction des données.
De plus, en fixant la valeur de cet random_state, le résultat de l'entraînement avec les mêmes données peut être enregistré.
Semblable à la régression logistique, SVM a également C, qui indique la tolérance des erreurs de classification. Défini comme paramètre. L'utilisation est similaire à la régression logistique.
Par rapport à la régression logistique, SVM a plus de fluctuations dans la valeur prédite de l'étiquette de données par C. Algorithmes SVM pour obtenir des limites plus généralisées par rapport à la régression logistique Si la tolérance d'erreur augmente ou diminue, le vecteur de support change et le taux de précision augmente ou diminue par rapport à la régression logistique.
La valeur initiale de C est 1,0 dans le modèle SVM linéaire.
Le module utilise LinearSVC.
from sklearn.svm import LinearSVC
#Construire un modèle de SVM linéaire
model = LinearSVC(C=C,random_state=2)
Comme la régression logistique, les SVM linéaires ont un paramètre de pénalité. Les valeurs qui peuvent être réglées sont également "L1" et "L2".
multi_class est un paramètre qui détermine le comportement du modèle lors de l'exécution d'une classification à plusieurs termes. SVM linéaire fournit deux valeurs, "ovr" et "crammer_singer". Fondamentalement, ovr est plus léger et donne de meilleurs résultats.
Random_state est utilisé pour fixer le résultat (fixer le nombre aléatoire), mais pour SVM, il est également impliqué dans la détermination du vecteur de support. Gardez à l'esprit que les limites d'apprentissage finales seront à peu près les mêmes, mais avec de légères différences.
Lorsque vous traitez des données qui ne sont pas linéairement séparables, utilisez un module appelé SVC de SVM. Le paramètre C existe en SVC ainsi qu'en régression logistique et SVM.
Pour les SVM non linéaires, ajustez C pour le pénaliser. Les pénalités contrôlent le nombre d'erreurs de classification tolérées pendant l'apprentissage.
Le paramètre noyau est un paramètre particulièrement important dans le SVM non linéaire. Un paramètre qui définit une fonction pour manipuler les données reçues afin de faciliter la classification.
Cinq valeurs peuvent être prises: linéaire, rbf, poly, sigmoïde et précalculée. La valeur par défaut est rbf.
linear
#C'est un SVM linéaire et est presque le même que le SVC linéaire. Utilisez LinearSVC sauf si vous avez une raison spécifique de le faire.
rbf
poly
#C'est comme une projection stéréoscopique.
#Comme rbf donne souvent un taux de précision relativement élevé par rapport aux autres, nous utilisons généralement le rbf par défaut.
precomputed
#Il est utilisé lorsque les données ont déjà été formatées par prétraitement.
sigmoid
#Effectue le même traitement que le modèle de régression logistique.
decision_function_shape est comme le paramètre multi_class dans SVC.
Deux valeurs sont disponibles, ovo et ovr.
ovo
Faites une paire de classes, faites une classification binaire avec cette paire et appartenez à la majorité
L'idée est de décider d'une classe.
La quantité de calcul est importante et l'opération peut devenir lourde en fonction de la quantité de données.
ovr
Classez une classe et l'autre et décidez de la classe à laquelle elle appartient par décision majoritaire.
random_state est un paramètre lié à l'ordre de traitement des données. Afin de reproduire le résultat de la prédiction, il est recommandé de le fixer au stade de l'apprentissage.
Lors de l'exécution de l'apprentissage automatique, il existe un moyen de spécifier un générateur pour générer des nombres aléatoires. Le code pour spécifier le générateur est le suivant.
import numpy as np
from sklearn.svm import SVC
#Construisez un générateur de nombres aléatoires
random_state = np.random.RandomState()
#Générateur aléatoire_Construire le modèle SVM spécifié dans l'état
model = SVC(random_state=random_state)