Récemment, j'ai été accro aux concours d'analyse de données tels que Kaggle et Signate, et j'étudie tous les jours tout en participant petit à petit à plusieurs concours. Avant chaque première confrontation aux données, j'ai un modèle LightGBM que je fais pour connaître la difficulté de la concurrence et la tendance des données, donc je vais le publier.
Faites-moi savoir si vous souhaitez faire plus comme ça!
Chargez les données et importez les bibliothèques requises. Si vous commencez sans vérifier attentivement les données d'entraînement, la quantité de données peut être étonnamment énorme, alors vérifiez la quantité de données.
from datetime import datetime
import numpy as np
import matplotlib.pyplot as plt
import os
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
#Lire les données
train_df = pd.read_csv("./train.csv")
test_df = pd.read_csv("./test.csv")
print(train_df.shape, test_df.shape)
(891, 12) (418, 11)
train_df
PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
0 1 0 3 Braund, Mr. Owen Harris male 22.0 1 0 A/5 21171 7.2500 NaN S
1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C
2 3 1 3 Heikkinen, Miss. Laina female 26.0 0 0 STON/O2. 3101282 7.9250 NaN S
3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 0 113803 53.1000 C123 S
4 5 0 3 Allen, Mr. William Henry male 35.0 0 0 373450 8.0500 NaN S
5 6 0 3 Moran, Mr. James male NaN 0 0 330877 8.4583 NaN Q
6 7 0 1 McCarthy, Mr. Timothy J male 54.0 0 0 17463 51.8625 E46 S
7 8 0 3 Palsson, Master. Gosta Leonard male 2.0 3 1 349909 21.0750 NaN S
8 9 1 3 Johnson, Mrs. Oscar W (Elisabeth Vilhelmina Berg) female 27.0 0 2 347742 11.1333 NaN S
9 10 1 2 Nasser, Mrs. Nicholas (Adele Achem) female 14.0 1 0 237736 30.0708 NaN C
10 11 1 3 Sandstrom, Miss. Marguerite Rut female 4.0 1 1 PP 9549 16.7000 G6 S
11 12 1 1 Bonnell, Miss. Elizabeth female 58.0 0 0 113783 26.5500 C103 S
12 13 0 3 Saundercock, Mr. William Henry male 20.0 0 0 A/5. 2151 8.0500 NaN S
13 14 0 3 Andersson, Mr. Anders Johan male 39.0 1 5 347082 31.2750 NaN S
14 15 0 3 Vestrom, Miss. Hulda Amanda Adolfina female 14.0 0
Il est important de voir les données dans n'importe quelle compétition.
Vérifiez les données minimales, telles que ne pas utiliser les variables objectives de cette période, Suvived, PassengerId et Name, car ce sont des quantités de caractéristiques uniques.
Divisez en variables explicatives et variables objectives.
train_x, train_y = train_df.drop("Survived", axis=1), train_df["Survived"]
Le traitement des fonctionnalités est également effectué, mais au minimum. Cela se fait uniquement à partir des trois points de vue suivants.
PassengerId et Name)def label_encording(data_col):
'''
Encodage des étiquettes
data_col :Une colonne du bloc de données cible
'''
le = LabelEncoder()
le = le.fit(data_col)
#Convertir l'étiquette en entier
data_col = le.transform(data_col)
return data_col
def preprocess(df):
'''
Effectuer un prétraitement
df : padnas.Dataframe
Trame de données cible
'''
df = df.drop("PassengerId", axis=1)
df = df.drop("Name", axis=1)
#Convertir des variables qualitatives en nombres
for column_name in df:
if df[column_name][0].dtypes == object: #Remplacez NULL par les valeurs manquantes
df[column_name] = df[column_name].fillna("NULL")
df[column_name] = label_encording(df[column_name])
elif df[column_name][0].dtypes == ( "int64" or "float64") : #Concernant les valeurs manquantes-Suppléant 999
df[column_name] = df[column_name].fillna(-999)
return df
Lors de l'exécution du codage d'étiquettes, il n'est pas bon que la correspondance entre les étiquettes dans les données d'apprentissage et les données de test soit rompue, de sorte que les données d'apprentissage et les données de test sont soumises à un traitement de quantité de caractéristiques en même temps.
all_x = pd.concat([train_x, test_df])
preprocessed_all_x = preprocess(all_x)
#Les données prétraitées sont subdivisées en données d'entraînement et données de test.
preprocessed_train_x, preprocessed_test_x = preprocessed_all_x[:train_x.shape[0]], preprocessed_all_x[train_x.shape[0]:]
print(preprocessed_train_x.head(5))
Créez une classe pour apprendre LightGBM. Voir le site officiel ci-dessous pour des explications détaillées sur les paramètres.
L '«objectif» et les «métriques» sont modifiés en fonction des données d'entraînement et de la compétition.
# LightGBM
import lightgbm as lgb
class lightGBM:
def __init__(self, params=None):
self.model = None
if params is not None:
self.params = params
else:
self.params = {'objective':'binary',
'seed': 0,
'verbose':10,
'boosting_type': 'gbdt',
'metrics':'auc',
'reg_alpha': 0.0,
'reg_lambda': 0.0,
'learning_rate':0.01,
'drop_rate':0.5
}
self.num_round = 20000
self.early_stopping_rounds = self.num_round/100
def fit(self, tr_x, tr_y, va_x, va_y):
self.target_columms = tr_x.columns
print(self.target_columms)
#Convertir l'ensemble de données
lgb_train = lgb.Dataset(tr_x, tr_y)
lgb_eval = lgb.Dataset(va_x, va_y)
self.model = lgb.train(self.params,
lgb_train,
num_boost_round=self.num_round,
early_stopping_rounds=self.early_stopping_rounds,
valid_names=['train', 'valid'],
valid_sets=[lgb_train, lgb_eval],
verbose_eval=self.num_round/100
)
return self.model
def predict(self, x):
data = lgb.Dataset(x)
pred = self.model.predict(x, num_iteration=self.model.best_iteration)
return pred
def get_feature_importance(self, target_columms=None):
'''
Sortie de fonction
'''
if target_columms is not None:
self.target_columms = target_columms
feature_imp = pd.DataFrame(sorted(zip(self.model.feature_importance(), self.target_columms)), columns=['Value','Feature'])
return feature_imp
Définition de l'apprenant
def model_learning(model, x, y):
'''
Former le modèle.
'''
tr_x, va_x, tr_y, va_y = train_test_split(x, train_y, test_size=0.2, random_state=0)
return model.fit(tr_x, tr_y, va_x, va_y)
En définissant le modèle dans une classe et en le transmettant à l'apprenant, il est possible de minimiser les modifications du code source lors de l'utilisation de différents modèles.
Par exemple, lorsque vous souhaitez utiliser XGBoost, vous pouvez remplacer le modèle à apprendre immédiatement en le réécrivant comme suit.
class XGBoost:
def __init__(self, params=None):
#Processus d'initialisation~~~
def fit(self, tr_x, tr_y, va_x, va_y):
#Processus d'apprentissage~~~
def predict(self, x):
#Traitement d'évaluation~~~
xgboost_model = XGBoost()
model_learning(xgboost_model, preprocessed_train_x, train_y)
lightgbm_model = lightGBM()
model_learning(lightgbm_model, preprocessed_train_x, train_y)
Index(['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Ticket', 'Fare', 'Cabin',
'Embarked'],
dtype='object')
Training until validation scores don't improve for 200.0 rounds
Early stopping, best iteration is:
[172] train's auc: 0.945026 valid's auc: 0.915613
L'apprentissage est terminé! C'était bientôt fini.
Avec LightGBM, vous pouvez vérifier les fonctionnalités apprises que vous avez utilisées le plus souvent. Cela vous donnera un aperçu de l'EDA pour la prochaine étape. D'une manière ou d'une autre, «Age», «Ticket» et «Fare» sont dans les rangs supérieurs, il semble donc que l'âge et la position du siège soient importants. ..
lightgbm_model.get_feature_importance()
Value Feature
0 32 Parch
1 58 SibSp
2 158 Embarked
3 165 Cabin
4 172 Sex
5 206 Pclass
6 1218 Fare
7 1261 Ticket
8 1398 Age
Évaluation du modèle. Le résultat de sortie est une probabilité, mais cette fois, il doit être "0 ou 1", donc formatez-le en conséquence.
#Évaluation du modèle pour les tests
proba_ = lightgbm_model.predict(preprocessed_test_x)
proba = list(map(lambda x: 0 if x < 0.5 else 1, proba_))
Formatez la valeur prévue en fonction des données soumises. C'est l'endroit le plus simple pour rester coincé ...
#Créer des données de test
submit_df = pd.DataFrame({"Survived": proba})
submit_df.index.name = "PassengerId"
submit_df.index = submit_df.index + len(train_df) + 1
Enregistrez le nom du fichier au format submit_ {% Y-% m-% d-% H% M% S}.
Ce faisant, vous pouvez éviter l'écrasement accidentel et vous n'avez pas à penser au nom du fichier à chaque fois, ce qui est pratique.
#sauvegarder
save_folder = "results"
if not os.path.exists(save_folder):
os.makedirs(save_folder)
submit_df.to_csv("{}/submit_{}.csv".format(save_folder, datetime.now().strftime("%Y-%m-%d-%H%M%S")),index=True)
Lorsque j'ai soumis ce résultat, le score public était de «0,77033», soit «6610e / 20114 personnes». (Au 25/08/2020) Je pense que ce n'est pas un mauvais modèle pour saisir la difficulté et le ressenti de la concurrence en la tournant pour le moment.
Je pense toujours que l'EDA est douce, donc je fais de l'EDA plus fermement à l'avenir.
Recommended Posts