Après avoir appris la programmation de base en python, travaillons sur kaggle! A ce moment-là, parlons du noyau! Je pense qu'il y a beaucoup d'articles et de livres, et en fait, je pense que c'est un moyen de devenir incroyablement puissant.
Cependant, du point de vue d'un vrai débutant, j'ai pensé ** "C'est trop difficile de lire le noyau et je ne comprends pas le sens ..." ** "Non, ce n'est pas une technologie aussi avancée, mais un apprentissage automatique de base pour le moment. Je voulais juste faire un modèle ... "**, et j'ai eu du mal à être moi-même.
Ainsi, dans cet article, dans quelle mesure la précision de divers modèles d'apprentissage automatique changera-t-elle en augmentant progressivement le niveau, comme ** «méthode super-basique» et «méthode légèrement conçue» **? Je souhaite vérifier **. Ce faisant, ** "Je vois, comment créer un modèle d'apprentissage automatique super basique?" "Comment puis-je augmenter un peu plus le niveau?" Que faire ** est le but de cet article.
Dans mon article sur qiita, j'utilise le jeu de données Kickstarter Projects de kaggle, que je vois souvent. https://www.kaggle.com/kemical/kickstarter-projects
J'ai essayé de collectionner des objets orthodoxes.
・ Retour logistique ・ SVM · Arbre de décision ・ Forêt aléatoire ・ Adaboost
A: aucun ajustement (par défaut) B: (Uniquement les modèles nécessaires) Régularisation C: (Uniquement les modèles requis) Standardisation D: réglage des hyper paramètres E: sélection des fonctionnalités
Voici un résumé de (2) et (3) et les résultats de précision de tous les modèles qui seront vérifiés ultérieurement.
Du point de vue, le modèle 1 est la version par défaut de la régression logistique avec une précision de 0,52958, le modèle 2 est la version avec seulement la régression logistique avec une précision de 0,59815, et le modèle 3 est la version avec régularisation et standardisation avec régression logistique. Et la précision est de 0,66181 ...
Fondamentalement, on suppose que la précision augmentera au fur et à mesure que le motif progresse dans chaque modèle, mais cette fois, la sélection de la quantité de caractéristiques de E utilise la méthode intégrée. → Veuillez noter que la méthode intégrée est basée sur un modèle linéaire, donc la précision n'augmente pas nécessairement (en fait, il y avait des modèles où il valait mieux ne pas faire E avec des modèles multiples).
Je pense que c'est une bonne idée de regarder d'abord la version A de chaque modèle, puis d'avancer progressivement le modèle pour chaque modèle.
| modèle | modèle | précision | |
|---|---|---|---|
| modèle 1 | Retour logistique | A | 0.52958 |
| Motif 2 | Retour logistique | B | 0.59815 |
| Modèle 3 | Retour logistique | B+C | 0.66181 |
| Modèle 4 | Retour logistique | B+C+D | 0.66181 |
| Modèle 5 | Retour logistique | B+C+D+E | 0.66185 |
| Modèle 6 | SVM | A | 0.61935 |
| Modèle 7 | SVM | C | 0.64871 |
| Modèle 8 | SVM | C+D | 0.65393 |
| Modèle 9 | SVM | C+D+E | 0.65066 |
| Modèle 10 | Arbre de décision | A | 0.63727 |
| Modèle 11 | Arbre de décision | D | 0.66376 |
| Modèle 12 | Arbre de décision | D+E | 0.65732 |
| Modèle 13 | Forêt aléatoire | A | 0.64522 |
| Modèle 14 | Forêt aléatoire | D | 0.67762 |
| Modèle 15 | Forêt aléatoire | D+E | 0.66308 |
| Modèle 16 | Adaboost | A | 0.63947 |
| Modèle 17 | Adaboost | D | 0.67426 |
| Modèle 18 | Adaboost | D+E | 0.659367 |
Pour chaque modèle d'apprentissage automatique, nous ne le mettrons en œuvre que cette fois, mais nous avons publié une série d'articles qui comprennent le contexte des mathématiques, nous espérons donc que vous pourrez également vous y référer.
[[Machine learning] Comprendre la régression logistique à partir de scikit-learn et des mathématiques] (https://qiita.com/Hawaii/items/ee2a0687ca451fe213be) [[Machine learning] Comprendre SVM à la fois à partir de scikit-learn et des mathématiques] (https://qiita.com/Hawaii/items/4688a50cffb2140f297d) [Apprentissage automatique] Comprendre les arbres de décision de scikit-learn et de mathématiques [[Machine learning] Comprendre la forêt aléatoire] (https://qiita.com/Hawaii/items/5831e667723b66b46fba)
Je vais faire le traitement commun à tous les modèles ici.
Importons tout cela en même temps. Imaginez faire ce processus commun au début de chaque modèle, puis écrire le code pour chaque modèle successivement.
#numpy,Importer des pandas
import numpy as np
import pandas as pd
#Importer pour effectuer certains traitements sur les données de date
import datetime
#Importation des données d'entraînement et fractionnement des données de test
from sklearn.model_selection import train_test_split
#Importer pour la normalisation
from sklearn.preprocessing import StandardScaler
#Importer pour la vérification de l'exactitude
from sklearn.model_selection import cross_val_score
#Importer pour le réglage des hyper paramètres
from sklearn.model_selection import train_test_split, GridSearchCV
#Importer pour la sélection des fonctionnalités
from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LassoCV
#Importer pour la régression logistique
from sklearn.linear_model import SGDClassifier
from sklearn.metrics import log_loss, accuracy_score, confusion_matrix
#Importer pour SVM
from sklearn.svm import SVC
#Importer pour l'arbre de décision
from sklearn.tree import DecisionTreeClassifier, export_graphviz
#Importer pour Random Forest
from sklearn.ensemble import RandomForestClassifier
#Importer pour Adaboost
from sklearn.ensemble import AdaBoostClassifier
df = pd.read_csv(r"C:~~\ks-projects-201801.csv")
De ce qui suit, vous pouvez voir qu'il s'agit de l'ensemble de données de (378661, 15). Étant donné que la quantité de données est assez importante, les modèles qui prennent beaucoup de temps à traiter sont entraînés à l'aide de certaines de ces données.
df.shape
Jetons également un coup d'œil aux données dans .head.
df.head()
Je vais omettre les détails, mais puisque l'heure de début du recrutement et l'heure de fin du financement cloud sont dans les données, nous allons convertir cela en "jours de recrutement".
df['deadline'] = pd.to_datetime(df["deadline"])
df["launched"] = pd.to_datetime(df["launched"])
df["days"] = (df["deadline"] - df["launched"]).dt.days
Je vais également omettre les détails ici, mais il y a des catégories autres que succès ("réussi") et échec ("échec") pour la variable objective "état", mais cette fois je n'utiliserai les données que pour le succès et l'échec.
df = df[(df["state"] == "successful") | (df["state"] == "failed")]
Remplacez ensuite le succès par 1 et l'échec par 0.
df["state"] = df["state"].replace("failed",0)
df["state"] = df["state"].replace("successful",1)
Avant de créer le modèle, supprimez l'identifiant et le nom dont vous pensez ne pas avoir besoin (cela devrait être conservé, mais cette fois, nous le supprimerons), et les variables que vous ne connaissez qu'après le financement du cloud. ..
df = df.drop(["ID","name","deadline","launched","backers","pledged","usd pledged","usd_pledged_real","usd_goal_real"], axis=1)
Effectuez le traitement des variables catégorielles avec pd.get_dummies.
df = pd.get_dummies(df,drop_first = True)
Je souhaite mettre en place une régression logistique sans aucun ajustement.
Commencez par le diviser en données d'entraînement et données de test.
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
Ensuite, créez un modèle pour la forêt aléatoire. La raison pour laquelle je mets un argument dans SGDClassifier en disant que je ne fais rien est que je ne peux pas faire un modèle de régression logistique à moins que la perte ne soit log, et après cela je vérifierai l'exactitude quand il y aura régularisation, donc La pénalité est fixée à aucune ici.
clf = SGDClassifier(loss = "log", penalty = "none",random_state=1234)
clf.fit(X_train,y_train)
Enfin, vérifions l'exactitude avec les données de test.
clf.score(X_test, y_test)
Ensuite, la précision est devenue ** 0,52958 **.
Je vais omettre ce qu'est la régularisation ici, mais je vérifierai avec la régularisation L1 et la régularisation L2 si la précision s'améliorera si seule la régularisation est effectuée.
Commencez par le diviser en données d'entraînement et données de test.
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
◆ Régularisation L1 Réglez la pénalité sur l1 et vérifiez la précision.
clf_L1 = SGDClassifier(loss = "log", penalty = "l1", random_state=1234)
clf_L1.fit(X_train,y_train)
clf_L1.score(X_test, y_test)
Ensuite, la précision était de ** 0,52958 **, ce qui était le même qu'auparavant.
◆ Régularisation L2 De même, réglez la pénalité sur l2 et vérifiez la précision.
clf_L2 = SGDClassifier(loss = "log", penalty = "l2", random_state=1234)
clf_L2.fit(X_train,y_train)
clf_L2.score(X_test, y_test)
Ensuite, la précision était de ** 0,59815 **, ce qui était supérieur à celui du motif 1. La régularisation L2 peut être plus appropriée pour ces données.
Vérifions quel type de précision sera obtenu en ajoutant un traitement de standardisation à la régularisation ci-dessus. Après avoir effectué le processus de standardisation, nous ajouterons la régularisation L1 et la régularisation L2.
Commencez par le diviser en données d'entraînement et données de test.
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
Ensuite, standardisez. Étant donné que le nombre d'entités est faible cette fois, seuls les objectifs et les jours qui devraient être normalisés sont normalisés, et les colonnes qui ont été traitées avec des variables catégorielles par get_dumiies ne sont pas normalisées. Cependant, il semble qu'il n'y ait pas de problème même si toutes les données sont standardisées (j'ai demandé au professeur du cours d'apprentissage automatique que je suis).
stdsc = StandardScaler()
df["goal"] = stdsc.fit_transform(df[["goal"]].values)
df["days"] = stdsc.fit_transform(df[["days"]].values)
Après cela, le traitement de régularisation L1, le traitement de régularisation L2 et la vérification de l'exactitude sont effectués.
#Régularisation et précision L1
clf_L1 = SGDClassifier(loss = "log", penalty = "l1", random_state=1234)
clf_L1.fit(X_train,y_train)
clf_L1.score(X_test, y_test)
#Régularisation et précision L2
clf_L2 = SGDClassifier(loss = "log", penalty = "l2", random_state=1234)
clf_L2.fit(X_train,y_train)
clf_L2.score(X_test, y_test)
La précision de la régularisation L1 est de ** 0,66181 ** et la précision de la régularisation L2 est de ** 0,65750 **, améliorant la précision immédiatement. Après la normalisation, la régularisation L1 semble être un meilleur match. Ici, je garderai un enregistrement de ** 0,66181 ** de régularisation L1, qui avait une bonne précision.
Effectuons un réglage supplémentaire des hyper paramètres sur le modèle 3. Le réglage des hyper-paramètres fait référence à l'exploration et au choix des valeurs numériques que nous devons décider nous-mêmes pour créer un modèle d'apprentissage automatique.
Ici, nous utiliserons Gridsearch.
Ce serait bien si tous les paramètres pouvaient être recherchés dans chaque plage, mais cela prendrait trop de temps, donc cette fois nous ajusterons la pénalité et l'alpha qui semblent être importants dans le classificateur SGD.
Le premier est le traitement de normalisation + la division des données de formation et des données de test.
#Standardisation
stdsc = StandardScaler()
df["goal"] = stdsc.fit_transform(df[["goal"]].values)
df["days"] = stdsc.fit_transform(df[["days"]].values)
#Répartition des données
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
parameters = {'penalty':['l1', 'l2'], 'alpha':[0.0001,0.001, 0.01, 0.1, 1, 10, 100],'loss':['log']} #Modifier ici
model = SGDClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3)
clf.fit(X_train, y_train)
print(clf.best_params_)
Cette fois, je voulais comparer la précision de chaque motif indiqué dans le tableau au début, j'ai donc pris soin de ** utiliser GridSearch en incluant la valeur par défaut **. En effet, si la valeur par défaut n'est pas incluse, la comparaison de précision ne sera pas possible.
La pénalité est l1 ou l2, et alpha contient la valeur par défaut de 0,0001, ce qui est assez large. Comme précédemment, si vous ne spécifiez pas la perte dans le journal, ce ne sera pas une régression logistique en premier lieu, spécifiez-le donc dans le journal.
Ensuite, {'alpha': 0.0001, 'loss': 'log', 'penalty': 'l1'} a été affiché, et il a recherché le meilleur paramètre.
Notez que l'alpha de ce meilleur paramètre est en fait exactement la même valeur que la valeur par défaut lorsque vous regardez le site de sklearn **. De plus, dans la régularisation L1 du motif 3, la perte est définie sur log et la pénalité est définie sur l1, donc en théorie, même si une recherche d'hyper paramètre est effectuée, ** les mêmes paramètres que la régularisation L1 du motif 3 sont utilisés. **.
En d'autres termes, continuons en pensant que la précision devrait être de 0,66181, ce qui équivaut à la régularisation L1 du motif 3.
Maintenant, reconstruisons le modèle en utilisant ce meilleur paramètre. Ce qui suit signifie utiliser "** clf.best_paramas_" pour entraîner le classificateur SGD avec les meilleurs paramètres que j'ai mentionnés précédemment.
clf_2 = SGDClassifier(**clf.best_params_,random_state=1234)
clf_2.fit(X_train,y_train)
Enfin, vérifiez la précision avec les données de test.
clf_2.score(X_test, y_test)
Il est devenu ** 0,66181 **, et il est devenu le même système que le modèle 3 comme supposé.
Jusqu'au modèle 4, j'ai créé un modèle avec la quantité de fonctionnalités que j'ai choisie arbitrairement, mais ici, je vais essayer de sélectionner la quantité de fonctionnalités en utilisant la méthode appelée méthode intégrée.
Premièrement, standardisez et divisez les données.
#Standardisation
stdsc = StandardScaler()
df["goal"] = stdsc.fit_transform(df[["goal"]].values)
df["days"] = stdsc.fit_transform(df[["days"]].values)
#Répartition des données
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
Ensuite, nous sélectionnerons le montant de la fonctionnalité par la méthode intégrée.
estimator = LassoCV(normalize = True, cv = 10, random_state = 1234)
sfm = SelectFromModel(estimator, threshold = 1e-5)
sfm.fit(X_train,y_train)
Les fonctionnalités sélectionnées seront écrasées et mises à jour avec les données d'entraînement et les données de test.
X_train_selected = sfm.transform(X_train)
X_test_selected = sfm.transform(X_test)
Vérifiez la précision du classificateur SGD avec les données d'entraînement écrasées (à ce stade, le réglage des hyperparamètres n'a pas encore été effectué).
classifier = SGDClassifier(random_state=1234)
classifier.fit(X_train_selected, y_train)
À partir de là, effectuez le réglage des hyper paramètres. La méthode est fondamentalement la même qu'avant, mais les données d'entraînement (X_train_selected) qui écrasent le contenu de .fit sont utilisées.
parameters = {'penalty':['l1', 'l2'], 'alpha':[0.0001,0.001, 0.01, 0.1, 1, 10, 100],'loss':['log']}
model = SGDClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3)
clf.fit(X_train_selected, y_train)
print(clf.best_params_)
Entraînez à nouveau le classificateur SGD avec les meilleurs paramètres que vous avez donnés.
clf_2 = SGDClassifier(**clf.best_params_,random_state=1234)
clf_2.fit(X_train_selected,y_train)
Enfin, vérifiez la précision.
clf_2.score(X_test_selected, y_test)
Avec ** 0,66185 **, nous avons pu obtenir la meilleure précision jamais atteinte.
C'est la fin de la régression logistique. Résumons l'exactitude une fois.
| modèle | modèle | précision | |
|---|---|---|---|
| modèle 1 | Retour logistique | A | 0.52958 |
| Motif 2 | Retour logistique | B | 0.59815 |
| Modèle 3 | Retour logistique | B+C | 0.66181 |
| Motif 4 | Retour logistique | B+C+D | 0.66181 |
| Modèle 5 | Retour logistique | B+C+D+E | 0.66185 |
| Modèle 6 | SVM | A | |
| Modèle 7 | SVM | C | |
| Modèle 8 | SVM | C+D | |
| Modèle 9 | SVM | C+D+E | |
| Modèle 10 | Arbre de décision | A | |
| Modèle 11 | Arbre de décision | D | |
| Modèle 12 | Arbre de décision | D+E | |
| Modèle 13 | Forêt aléatoire | A | |
| Modèle 14 | Forêt aléatoire | D | |
| Modèle 15 | Forêt aléatoire | D+E | |
| Modèle 16 | Adaboost | A | |
| Modèle 17 | Adaboost | D | |
| Modèle 18 | Adaboost | D+E |
Passons maintenant à SVM.
J'ai également essayé SVM et j'ai réalisé qu'il était gâché, mais cela prend beaucoup de temps à traiter. Donc, comme la régression logistique, si je construisais un modèle et réglais des hyperparamètres en utilisant toutes les données d'entraînement, je n'aurais pas assez de temps, donc j'ai pris soin de réduire les données.
J'ai entraîné toutes les données du premier coup et j'ai constaté à plusieurs reprises que cela ne se terminait pas même si cela prenait des heures, alors j'ai d'abord essayé avec un très petit nombre de données (et de paramètres), et le temps que cela a pris Faire une note du. Donc, je pense qu'il est préférable de démarrer le processus après avoir défini une ligne directrice sur le temps qu'il faudra, car ce montant est environ plusieurs fois plus élevé.
J'implémenterai SVM sans aucun ajustement. Commencez par le diviser en données d'entraînement et données de test.
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
Voici les principaux changements que j'ai apportés au traitement des SVM avec d'autres modèles, mais il faut beaucoup de temps pour former les SVM avec toutes les données d'entraînement comme la régression logistique.
Par conséquent, traitons les données d'entraînement qui étaient autrefois divisées en 70% du total, puis traitons 1,5% (= 10,5% de toutes les données) comme des données d'entraînement.
Même avec 1,5%, il a fallu plus de 3 heures pour terminer le processus. ..
#1 à partir des données d'entraînement.Échantillon 50%
X_train_sample = pd.DataFrame(X_train).sample(frac = 0.15, random_state=1234)
y_train_sample = pd.DataFrame(y_train).sample(frac = 0.15, random_state=1234)
#Construction de modèles
clf = SVC(random_state=1234)
clf.fit(X_train_sample, y_train_sample)
Maintenant que nous avons un modèle, vérifions la précision avec les données de test. Il est important de noter que les données de test ne sont pas réduites de 30% du total, mais la précision est confirmée en utilisant toutes les données de test. C'est parce que je pensais que si le nombre de données de test était réduit uniquement pour SVM, il ne serait pas possible de comparer la précision avec d'autres modèles.
clf.score(X_test,y_test)
La précision était de ** 0,61935 **.
Puisque SVM ne nécessite pas de régularisation en soi, il commence par la mise en œuvre de la normalisation.
Tout d'abord, normalisons et divisons les données. Après cela, c'est la même chose que le modèle 6.
#Standardisation
stdsc = StandardScaler()
df["goal"] = stdsc.fit_transform(df[["goal"]].values)
df["days"] = stdsc.fit_transform(df[["days"]].values)
#Répartition des données
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
#1 à partir des données d'entraînement.Échantillon 50%
X_train_sample = pd.DataFrame(X_train).sample(frac = 0.15, random_state=1234)
y_train_sample = pd.DataFrame(y_train).sample(frac = 0.15, random_state=1234)
#Construction de modèles
clf = SVC(random_state=1234)
clf.fit(X_train_sample, y_train_sample)
#Évaluation de la précision
clf.score(X_test, y_test)
La précision est de ** 0,64871 **, ce qui est meilleur que le modèle 6.
Ensuite, implémentons la normalisation + le réglage des hyper paramètres.
Le premier est la normalisation et la division des données.
stdsc = StandardScaler()
df["goal"] = stdsc.fit_transform(df[["goal"]].values)
df["days"] = stdsc.fit_transform(df[["days"]].values)
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
Ensuite, effectuez le réglage des hyper paramètres. Encore une fois, la recherche en utilisant toutes les données d'entraînement prend beaucoup de temps, donc 3% (= 2,1% du total) des 70% des données d'entraînement sont utilisées pour le réglage des hyper paramètres.
A l'origine, j'aimerais utiliser plus de données pour ajuster les paramètres, mais comme le traitement n'est pas vraiment terminé, j'ai choisi cette valeur.
#Données d'entraînement 3%Échantillonnage
X_train_grid = pd.DataFrame(X_train).sample(frac = 0.03,random_state=1234)
y_train_grid = pd.DataFrame(y_train).sample(frac = 0.03,random_state=1234)
Ensuite, effectuez le réglage des hyper paramètres.
parameters = {'kernel':['linear', 'rbf'], 'C':[0.001, 0.01,0.1,1,10]} #Modifier ici
model = SVC(random_state=1234)
clf = GridSearchCV(model, parameters, cv=2,return_train_score=False)
clf.fit(X_train_grid, y_train_grid)
print(clf.best_params_, clf.best_score_)
Le point qui diffère de la régression logistique est que l'argument cv de GridSearch est défini sur 2 + return_train_score est défini sur False. À l'origine, cv était défini sur 3 et return_train_score n'était pas défini en particulier, mais comme le processus ne se termine pas éternellement, je l'ai vérifié sur le site et l'ai défini.
Jusqu'à présent, nous avons recherché les "paramètres optimaux"! Nous nous entraînerons en utilisant les données d'entraînement avec ce paramètre optimal et en vérifierons l'exactitude avec les données de test.
#1 à partir des données d'entraînement.Échantillon 50%
X_train_sample = pd.DataFrame(X_train).sample(frac = 0.15, random_state=1234)
y_train_sample = pd.DataFrame(y_train).sample(frac = 0.15, random_state=1234)
#Formation modèle
clf = SVC(**clf.best_params_,random_state=1234)
clf.fit(X_train_sample, y_train_sample)
#Confirmer l'exactitude avec les données de test
clf.score(X_test, y_test)
La précision était de ** 0,65393 **.
Enfin, ajoutez une sélection de fonctionnalités.
Encore une fois, les données d'apprentissage sont divisées en motif 8 pour la sélection des fonctionnalités, veillez donc à ne pas confondre les données d'apprentissage que vous utilisez pour quoi.
#Standardisation
stdsc = StandardScaler()
df["goal"] = stdsc.fit_transform(df[["goal"]].values)
df["days"] = stdsc.fit_transform(df[["days"]].values)
#Répartition des données
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
#Sélection de fonctionnalité
estimator = LassoCV(normalize = True, cv = 10, random_state = 1234)
sfm = SelectFromModel(estimator, threshold = 1e-5)
sfm.fit(X_train,y_train)
#Écraser les données d'entraînement avec les fonctionnalités sélectionnées
X_train_selected = sfm.transform(X_train)
X_test_selected = sfm.transform(X_test)
C'est la sélection des fonctionnalités. Ensuite, un réglage d'hyper paramètre est effectué sur la base de la quantité de caractéristiques sélectionnée.
#3 des données d'entraînement écrasées par les fonctionnalités sélectionnées pour le réglage des hyperparamètres%Échantillonnage
X_train_grid = pd.DataFrame(X_train_selected).sample(frac = 0.03,random_state=1234)
y_train_grid = pd.DataFrame(y_train).sample(frac = 0.03,random_state=1234)
#Réglage des hyper paramètres
parameters = {'kernel':['linear', 'rbf'], 'C':[0.001, 0.01,0.1,1,10]} #Modifier ici
model = SVC(random_state=1234)
clf = GridSearchCV(model, parameters, cv=2,return_train_score=False)
clf.fit(X_train_grid, y_train_grid)
print(clf.best_params_, clf.best_score_)
À ce stade, le réglage des hyper-paramètres à l'aide des fonctionnalités sélectionnées par la méthode intégrée est terminé et les meilleurs paramètres ont été déterminés.
Entraînons le modèle SVM avec les données d'entraînement (X_train_selected) écrasées avec cette quantité de fonctionnalité sélectionnée et les meilleurs paramètres avec 1,5% des données d'entraînement de 70% du total.
#Échantillon de 30% des données d'entraînement écrasées
X_train_sample = pd.DataFrame(X_train_selected).sample(frac = 0.15, random_state=1234)
y_train_sample = pd.DataFrame(y_train).sample(frac = 0.15, random_state=1234)
#Construction du modèle avec 30% supplémentaires de données d'échantillon provenant de 70% des données d'entraînement
clf = SVC(**clf.best_params_,random_state=1234)
clf.fit(X_train_sample, y_train_sample)
#Évaluation de la précision avec les données de test
clf.score(X_test_selected, y_test)
La précision est de ** 0,65066 **.
Ici, résumons à nouveau la précision.
| modèle | modèle | précision | |
|---|---|---|---|
| modèle 1 | Retour logistique | A | 0.52958 |
| Motif 2 | Retour logistique | B | 0.59815 |
| Modèle 3 | Retour logistique | B+C | 0.66181 |
| Motif 4 | Retour logistique | B+C+D | 0.66181 |
| Modèle 5 | Retour logistique | B+C+D+E | 0.66185 |
| Modèle 6 | SVM | A | 0.61935 |
| Modèle 7 | SVM | C | 0.64871 |
| Modèle 8 | SVM | C+D | 0.65393 |
| Modèle 9 | SVM | C+D+E | 0.65066 |
| Modèle 10 | Arbre de décision | A | |
| Modèle 11 | Arbre de décision | D | |
| Modèle 12 | Arbre de décision | D+E | |
| Modèle 13 | Forêt aléatoire | A | |
| Modèle 14 | Forêt aléatoire | D | |
| Modèle 15 | Forêt aléatoire | D+E | |
| Modèle 16 | Adaboost | A | |
| Modèle 17 | Adaboost | D | |
| Modèle 18 | Adaboost | D+E |
Vient ensuite l'arbre de décision.
Divisez les données.
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
Construisez un modèle de l'arbre de décision et vérifiez l'exactitude.
clf = DecisionTreeClassifier(random_state=1234)
clf = clf.fit(X_train, y_train)
clf.score(X_test, y_test)
La précision est maintenant de ** 0,63727 **.
L'arbre de décision ne nécessite ni régularisation ni standardisation, nous commençons donc par le réglage des hyperparamètres.
Le premier est la division des données.
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
Ensuite, effectuez une recherche de grille pour le réglage des hyper paramètres. Après cela, nous allons construire le modèle avec les meilleurs paramètres et vérifier l'exactitude des données de test.
#GridSearch
parameters = {'criterion':['gini', 'entropy'], 'max_depth':[i for i in range(1, 11)],'max_features':['auto','sqrt','log2'], 'min_samples_leaf':[i for i in range(1, 11)],'random_state':[1234]} #Modifier ici
model = DecisionTreeClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3)
clf.fit(X_train, y_train)
print(clf.best_params_, clf.best_score_)
#Construisez un modèle avec les meilleurs paramètres
clf = DecisionTreeClassifier(**clf.best_params_,random_state=1234)
clf.fit(X_train, y_train)
#Vérification de l'exactitude
clf.score(X_test,y_test)
La précision était de ** 0,66376 **.
Comme toujours, commencez par le partitionnement des données.
#Répartition des données
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
#Sélection de fonctionnalité
estimator = LassoCV(normalize = True, cv = 10, random_state = 1234)
sfm = SelectFromModel(estimator, threshold = 1e-5)
sfm.fit(X_train,y_train)
#Écraser les données d'entraînement avec les fonctionnalités sélectionnées
X_train_selected = sfm.transform(X_train)
X_test_selected = sfm.transform(X_test)
#Réglage des hyper paramètres
parameters = {'criterion':['gini', 'entropy'], 'max_depth':[i for i in range(1, 11)],'max_features':['auto','sqrt','log2'], 'min_samples_leaf':[i for i in range(1, 11)],'random_state':[1234]}
model = DecisionTreeClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3)
clf.fit(X_train_selected, y_train)
print(clf.best_params_, clf.best_score_)
#Former les apprenants avec des paramètres optimaux
clf_2 = DecisionTreeClassifier(**clf.best_params_,random_state=1234)
clf_2.fit(X_train_selected,y_train)
#Confirmer l'exactitude avec les données de test
clf_2.score(X_test_selected, y_test)
La précision est de ** 0,65732 **.
| modèle | modèle | précision | |
|---|---|---|---|
| modèle 1 | Retour logistique | A | 0.52958 |
| Motif 2 | Retour logistique | B | 0.59815 |
| Modèle 3 | Retour logistique | B+C | 0.66181 |
| Modèle 4 | Retour logistique | B+C+D | 0.66181 |
| Modèle 5 | Retour logistique | B+C+D+E | 0.66185 |
| Modèle 6 | SVM | A | 0.61935 |
| Modèle 7 | SVM | C | 0.64871 |
| Modèle 8 | SVM | C+D | 0.65393 |
| Modèle 9 | SVM | C+D+E | 0.65066 |
| Modèle 10 | Arbre de décision | A | 0.63727 |
| Modèle 11 | Arbre de décision | D | 0.66376 |
| Modèle 12 | Arbre de décision | D+E | 0.65732 |
| Modèle 13 | Forêt aléatoire | A | |
| Modèle 14 | Forêt aléatoire | D | |
| Modèle 15 | Forêt aléatoire | D+E | |
| Modèle 16 | Adaboost | A | |
| Modèle 17 | Adaboost | D | |
| Modèle 18 | Adaboost | D+E |
Divisez les données.
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
La construction du modèle de forêt aléatoire est effectuée et la vérification de l'exactitude est effectuée.
clf = RandomForestClassifier(random_state=1234)
clf.fit(X_train, y_train)
clf.score(X_test, y_test)
La précision est maintenant de ** 0,64522 **.
Tout comme l'arbre de décision, les forêts aléatoires ne nécessitent ni régularisation ni standardisation.
Comme précédemment, le réglage des hyper paramètres est effectué après la division des données. La différence avec les modèles précédents est que la plage de recherche est légèrement réduite (chaque index est recherché dans une plage de 1 à 5). Cela seul a pris environ 35 minutes, donc j'ai senti qu'il serait difficile de partitionner le processus en tenant compte de mon propre temps si j'étendais davantage la gamme, alors j'ai réduit la gamme.
#Répartition des données
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
#Réglage des hyper paramètres
parameters = {'max_depth':[2,4,6,None], 'min_samples_leaf':[1,3,5],'min_samples_split':[2,4,6]}
model = RandomForestClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3,)
clf.fit(X_train, y_train)
print(clf.best_params_, clf.best_score_)
#Former les apprenants avec des paramètres optimaux
clf = RandomForestClassifier(**clf.best_params_,random_state=1234)
clf.fit(X_train, y_train)
#Confirmer l'exactitude avec les données de test
clf.score(X_test, y_test)
Comme il a fallu beaucoup de temps pour affiner les valeurs numériques dans la recherche d'hyper paramètre, nous sommes passés à la recherche uniquement de nombres pairs ou impairs en supposant que les valeurs par défaut sont incluses. La précision était de ** 0,67762 **.
#Répartition des données
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
#Sélection de fonctionnalité
estimator = LassoCV(normalize = True, cv = 10, random_state = 1234)
sfm = SelectFromModel(estimator, threshold = 1e-5)
sfm.fit(X_train,y_train)
#Écraser les données d'entraînement avec les fonctionnalités sélectionnées
X_train_selected = sfm.transform(X_train)
X_test_selected = sfm.transform(X_test)
#Réglage des hyper paramètres
parameters = {'max_depth':[2,4,6,None], 'min_samples_leaf':[1,3,5],'min_samples_split':[2,4,6]}
model = RandomForestClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3,)
clf.fit(X_train_selected, y_train)
print(clf.best_params_, clf.best_score_)
#Former les apprenants avec des paramètres optimaux
clf = RandomForestClassifier(**clf.best_params_,random_state=1234)
clf.fit(X_train_selected, y_train)
#Confirmer l'exactitude avec les données de test
clf.score(X_test_selected, y_test)
La précision est maintenant de ** 0,66308 **.
Vérifions à nouveau l'exactitude.
| modèle | modèle | précision | |
|---|---|---|---|
| modèle 1 | Retour logistique | A | 0.52958 |
| Motif 2 | Retour logistique | B | 0.59815 |
| Modèle 3 | Retour logistique | B+C | 0.66181 |
| Modèle 4 | Retour logistique | B+C+D | 0.66181 |
| Modèle 5 | Retour logistique | B+C+D+E | 0.66185 |
| Modèle 6 | SVM | A | 0.61935 |
| Modèle 7 | SVM | C | 0.64871 |
| Modèle 8 | SVM | C+D | 0.65393 |
| Modèle 9 | SVM | C+D+E | 0.65066 |
| Modèle 10 | Arbre de décision | A | 0.63727 |
| Modèle 11 | Arbre de décision | D | 0.66376 |
| Modèle 12 | Arbre de décision | D+E | 0.65732 |
| Modèle 13 | Forêt aléatoire | A | 0.64522 |
| Modèle 14 | Forêt aléatoire | D | 0.67762 |
| Modèle 15 | Forêt aléatoire | D+E | 0.66308 |
| Modèle 16 | Adaboost | A | |
| Modèle 17 | Adaboost | D | |
| Modèle 18 | Adaboost | D+E |
Divisez les données.
#Répartition des données
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
Nous construisons un modèle d'Adaboost et vérifions son exactitude.
clf = AdaBoostClassifier(DecisionTreeClassifier(random_state=1234))
clf.fit(X_train, y_train)
clf.score(X_test, y_test)
La précision est maintenant de ** 0,63947 **.
#Répartition des données
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
#Réglage des hyper paramètres
parameters = {'learning_rate':[0.1,0.5,1.0]}
model = AdaBoostClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3,)
clf.fit(X_train, y_train)
print(clf.best_params_, clf.best_score_)
#Former les apprenants avec des paramètres optimaux
clf = AdaBoostClassifier(**clf.best_params_,random_state=1234)
clf.fit(X_train, y_train)
#Confirmer l'exactitude avec les données de test
clf.score(X_test, y_test)
La précision était de ** 0,67426 **.
#Répartition des données
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)
#Sélection de fonctionnalité
estimator = LassoCV(normalize = True, cv = 10, random_state = 1234)
sfm = SelectFromModel(estimator, threshold = 1e-5)
sfm.fit(X_train,y_train)
#Écraser les données d'entraînement avec les fonctionnalités sélectionnées
X_train_selected = sfm.transform(X_train)
X_test_selected = sfm.transform(X_test)
#Réglage des hyper paramètres
parameters = {'learning_rate':[0.1,0.5,1.0]}
model = AdaBoostClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3)
clf.fit(X_train_selected, y_train)
print(clf.best_params_, clf.best_score_)
#Former les apprenants avec des paramètres optimaux
clf = AdaBoostClassifier(**clf.best_params_,random_state=1234)
clf.fit(X_train_selected, y_train)
#Confirmer l'exactitude avec les données de test
clf.score(X_test_selected, y_test)
La précision était de ** 0,659367 **.
| modèle | modèle | précision | |
|---|---|---|---|
| modèle 1 | Retour logistique | A | 0.52958 |
| Motif 2 | Retour logistique | B | 0.59815 |
| Modèle 3 | Retour logistique | B+C | 0.66181 |
| Modèle 4 | Retour logistique | B+C+D | 0.66181 |
| Modèle 5 | Retour logistique | B+C+D+E | 0.66185 |
| Modèle 6 | SVM | A | 0.61935 |
| Modèle 7 | SVM | C | 0.64871 |
| Modèle 8 | SVM | C+D | 0.65393 |
| Modèle 9 | SVM | C+D+E | 0.65066 |
| Modèle 10 | Arbre de décision | A | 0.63727 |
| Modèle 11 | Arbre de décision | D | 0.66376 |
| Modèle 12 | Arbre de décision | D+E | 0.65732 |
| Modèle 13 | Forêt aléatoire | A | 0.64522 |
| Modèle 14 | Forêt aléatoire | D | 0.67762 |
| Modèle 15 | Forêt aléatoire | D+E | 0.66308 |
| Modèle 16 | Adaboost | A | 0.63947 |
| Modèle 17 | Adaboost | D | 0.67426 |
| Modèle 18 | Adaboost | D+E | 0.659367 |
Qu'as-tu pensé.
Étonnamment, je pense qu'il y a peu de sites qui introduisent des méthodes de création de modèles super basiques, et je pense toujours: "Je ne veux pas connaître des choses aussi avancées, je veux juste créer un modèle une fois!" J'ai fait.
Cet article se concentre sur mes propres problèmes, j'espère donc qu'il aidera à approfondir ma compréhension.