Spaceship Titanic——简单的预处理+LightGBM

Kaggle上的spaceship titanic比赛，做了一些简单的预处理，之后用LightGMB建模，在原作者的基础上稍微调了下参数，最终结果有了一点点提升;)

数据特征描述：

    PassengerId- 每位乘客的唯一 ID。 每个 Id 采用以下形式 gggg_pp表示，其中 gggg表示乘客所在的group，其中 pp是他们在组内的号码。 同一个group中的人通常是家庭成员，但并非总是如此。
    HomePlanet- 乘客离开的星球，通常是他们的永久居住星球。
    CryoSleep- 指示乘客是否选择在航程期间进入假死状态。 处于低温睡眠状态的乘客被限制在他们的客舱内。
    Cabin- 乘客入住的客舱号码。 采取形式 deck/num/side， 其中 side取值可以是 P或者S，分别对应左舷"P"或右舷"S"。
    Destination- 乘客将要去的星球。
    Age- 乘客的年龄。
    VIP- 旅客在航程中是否支付了VIP服务费用。
    RoomService, FoodCourt, ShoppingMall, Spa, VRDeck-均为在泰坦尼克号宇宙飞船的众多豪华设施中所支付的金额

   Name- 乘客的名字和姓氏。
  Transported- 乘客是否被运送到另一个维度。 这是要预测的列。

具体代码如下：

import numpy as np
import pandas as pd
import seaborn as sns

# data loading
train = pd.read_csv('./data/train.csv')
test = pd.read_csv('./data/test.csv')

# EDA

# 获取每一组(group)的中的人数

# method 1
groups_train = {}
# dataframe特定的列经过.str之后，就可以使用各种python常用的字符处理方法了
for value in train['PassengerId'].str.split('_').str[0]:
    # dict.get(key, default=None)  
    # 参数: key：需要查找的键; default：如果查找的键不存在的话，返回default的值。
    groups_train[value] = groups_train.get(value, 0) + 1

# # method 2
# groups_train = train['PassengerId'].str.split('_').str[0].value_counts(sort=False).to_dict()

groups_test = {}
for value in test['PassengerId'].str.split('_').str[0]:
    groups_test[value] = groups_test.get(value, 0) + 1

# 每个gropu内的样本量
train_number = []
test_number = []
for index, value in train['PassengerId'].items():
    train_number.append(groups_train[value.split('_')[0]])
for index, value in test['PassengerId'].items():
    test_number.append(groups_test[value.split('_')[0]])
train['GroupSize'] = train_number
test['GroupSize'] = test_number

# 将cabin拆分为'Deck', 'Num','Side'
train[['Deck', 'Num','Side']] = train['Cabin'].str.split('/', expand=True)
test[['Deck', 'Num','Side']] = test['Cabin'].str.split('/', expand=True)
train.drop(['PassengerId', 'Cabin', 'Name'], axis=1, inplace=True)
test.drop(['PassengerId', 'Cabin', 'Name'], axis=1, inplace=True)


# 分别对数值型和类别型变量中的缺失值进行填充
(由于lightgbm可以自动处理缺失值，处理方式与xgboost一致，
即在建树过程中，会尝试把当前特征中有缺失值的所有样本分别分到左子树或右子树，
然后看两种不同的分法中的哪以种可以让损失函数减少地更多，模型会记录下这种分法。
但是模型并不会对缺失值进行填充)
cat_cols = ['HomePlanet', 'CryoSleep', 'Destination', 'VIP']
num_cols = ['Age', 'RoomService', 'FoodCourt', 'ShoppingMall', 'Spa', 'VRDeck']
for col in num_cols:     
    train[col].fillna(train[col].mean(), inplace=True)
    test[col].fillna(test[col].mean(), inplace=True)
for col in cat_cols:
    train[col].fillna(train[col].mode()[0], inplace=True)
    test[col].fillna(test[col].mode()[0], inplace=True)

d = {'A':0, 'B':1, 'C':2, 'D':3, 'E':4, 'F':5, 'G':6, 'T':7}
train['Deck'].replace(d, inplace=True)
test['Deck'].replace(d, inplace=True)
train['Num'] = train['Num'].astype(float)
test['Num'] = test['Num'].astype(float)
train=pd.get_dummies(train,prefix_sep='_')
test=pd.get_dummies(test,prefix_sep='_')

# Modeling
y = train['Transported']
X = train.drop(['Transported'], axis=1)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_val, X_test, y_val, y_test = train_test_split(X_test, y_test, test_size=0.1, random_state=42)

# training
from lightgbm import LGBMClassifier
from lightgbm import log_evaluation, early_stopping

clf = LGBMClassifier(objective='binary',
                     learning_rate=0.005,
                     n_estimators=200,
                     num_iterations=700,
                     bagging_fraction= 0.8,
                     max_depth=-1,
                     )
callbacks = [log_evaluation(period=50), early_stopping(stopping_rounds=50)]
clf.fit(X_train, y_train, 
        eval_set=[(X_train, y_train), (X_val, y_val)], 
        eval_names=['train','val'],
        eval_metric='auc',
        callbacks=callbacks
        )

# testing
from sklearn.metrics import accuracy_score

test_pred = clf.predict(X_test) 
print('accuracy:', accuracy_score(y_test, test_pred))

# submit
sample = pd.read_csv('./data/sample_submission.csv')
sample['Transported'] = clf.predict(test).astype(bool)
sample.to_csv('submission.csv', index=False)

最终的结果(预测准确率)：0.80313，还不错