使用结构化表格数据对比深度学习和GBDT模型（上）

importosimportnumpyasnpimportpandasaspdimportwarningsimporttimefromdatetimeimportdatetimefromsklearn.model_selectionimporttrain_test_splitfromsklearn.preprocessingimportStandardScalerimporttorchfrompytorch_tabnet.pretrainingimportTabNetPretrainerfrompytorch_tabnet.tab_modelimportTabNetClassifierfromsklearn.metricsimportaccuracy_score, f1_score, confusion_matrix, roc_auc_scoreimportxgboostasxgbfromtensorflowimportkerasfromtensorflow.kerasimportlayersimportmatplotlib.pyplotaspltwarnings.filterwarnings("ignore")

deftimer(myFunction):
deffunctionTimer(*args, **kwargs):
start_time=time.time()
result=myFunction(*args, **kwargs)
end_time=time.time()
computation_time=round(end_time-start_time, 2)
print("{} is excuted".format(myFunction.__name__))
print('Computation took: {:.2f} seconds'.format(computation_time))
returnresultreturnfunctionTimer

@timerdefprepareInputs(df: "pd.dataFrame") ->"pd.dataFrame":
"""Prepare the input for trainingArgs:df (pd.DataFrame): raw dataProcess:1. Exclude missing values2. Clean the target variable3. Create dummy variables for categorical variables4. Create age features5. Impute missing valueReturn: pd.dataFrame"""#1.Excludemissingvaluesdf=df[df["POL_STATUS"].notnull()]
#2.Cleanthetargetvariabledf=df[df["POL_STATUS"] !="Unknown"]
df["lapse"] =np.where(df["POL_STATUS"] =="Lapsed", 1, 0)
#3.Createdummyvariablesforcategoricalvariablescategorical_cols= ["CLAIM3YEARS", "BUS_USE", "AD_BUILDINGS",
"APPR_ALARM", "CONTENTS_COVER", "P1_SEX",
"BUILDINGS_COVER", "P1_POLICY_REFUSED",
"APPR_LOCKS", "FLOODING",
"NEIGH_WATCH", "SAFE_INSTALLED", "SEC_DISC_REQ",
"SUBSIDENCE", "LEGAL_ADDON_POST_REN",
"HOME_EM_ADDON_PRE_REN","HOME_EM_ADDON_POST_REN",
"GARDEN_ADDON_PRE_REN", "GARDEN_ADDON_POST_REN",
"KEYCARE_ADDON_PRE_REN", "KEYCARE_ADDON_POST_REN",
"HP1_ADDON_PRE_REN", "HP1_ADDON_POST_REN",
"HP2_ADDON_PRE_REN", "HP2_ADDON_POST_REN",
"HP3_ADDON_PRE_REN", "HP3_ADDON_POST_REN",
"MTA_FLAG", "OCC_STATUS", "OWNERSHIP_TYPE",
"PROP_TYPE", "PAYMENT_METHOD", "P1_EMP_STATUS",
"P1_MAR_STATUS"                      ]
forcolincategorical_cols:
dummies=pd.get_dummies(df[col],
drop_first=True,
prefix=col                              )
df=pd.concat([df, dummies], 1)
#4.Createagefeaturesdf["age"] = (datetime.strptime("2013-01-01", "%Y-%m-%d") -pd.to_datetime(df["P1_DOB"])).dt.days// 365df["property_age"] =2013-df["YEARBUILT"]
df["cover_length"] =2013-pd.to_datetime(df["COVER_START"]).dt.year#5.Imputemissingvaluedf["RISK_RATED_AREA_B_imputed"] =df["RISK_RATED_AREA_B"].fillna(df["RISK_RATED_AREA_B"].mean())
df["RISK_RATED_AREA_C_imputed"] =df["RISK_RATED_AREA_C"].fillna(df["RISK_RATED_AREA_C"].mean())
df["MTA_FAP_imputed"] =df["MTA_FAP"].fillna(0)
df["MTA_APRP_imputed"] =df["MTA_APRP"].fillna(0)
returndf

#Splittrainandtest@timerdefsplitData(df: "pd.DataFrame", FEATS: "list"):
"""Split the dataframe into train and testArgs:df: preprocessed dataframeFEATS: feature listReturns:X_train, y_train, X_test, y_test"""train, test=train_test_split(df, test_size= .3, random_state=42)
train, test=prepareInputs(train), prepareInputs(test)
returntrain[FEATS], train["lapse"], test[FEATS], test["lapse"]

#Standardisethedatasets@timerdefstandardiseNumericalFeats(X_train, X_test):
"""Standardise the numerical featuresReturns:Standardised X_train and X_test"""numerical_cols= [
"age", "property_age", "cover_length", "RISK_RATED_AREA_B_imputed",
"RISK_RATED_AREA_C_imputed", "MTA_FAP_imputed", "MTA_APRP_imputed",
"SUM_INSURED_BUILDINGS", "NCD_GRANTED_YEARS_B", "SUM_INSURED_CONTENTS",
"NCD_GRANTED_YEARS_C", "SPEC_SUM_INSURED", "SPEC_ITEM_PREM",
"UNSPEC_HRP_PREM", "BEDROOMS", "MAX_DAYS_UNOCC", "LAST_ANN_PREM_GROSS"  ]
forcolinnumerical_cols:
scaler=StandardScaler()
X_train[col] =scaler.fit_transform(X_train[[col]])
X_test[col] =scaler.transform(X_test[[col]])
returnX_train, X_test

XGBoost@timerdeftrainXgbModel(X_train, y_train, X_test, y_test, FEATS, ROUNDS) ->"XGBoost model obj":
"""Train XGBoost modelArg:ROUNDS: Number of training roundsReturn:Model object"""params= {
'eta': 0.02,
'max_depth': 10,
'min_child_weight': 7,
'subsample': 0.6,
'objective': 'binary:logistic',
'eval_metric': 'error',
'grow_policy': 'lossguide'          }
dtrain, dtest=xgb.DMatrix(X_train, y_train, feature_names=FEATS), xgb.DMatrix(X_test, y_test, feature_names=FEATS)
EVAL_LIST= [(dtrain, "train"),(dtest, "test")]
xgb_model=xgb.train(params,dtrain,ROUNDS,EVAL_LIST)
returnxgb_modelMLP (1D-CNN)
@timerdeftrainD1CnnModel(X_train, y_train):
"""Train D1-CNN modelReturn:keras model obj"""d1_cnn_model=keras.Sequential([
layers.Dense(4096, activation='relu'),
layers.Reshape((256, 16)),
layers.BatchNormalization(),
layers.Dropout(0.2),
layers.Conv1D(filters=16, kernel_size=5, strides=1, activation='relu'),
layers.MaxPooling1D(pool_size=2),
layers.Flatten(),
layers.Dense(16, activation='relu'),
layers.Dense(1, activation='sigmoid'),
  ])
d1_cnn_model.compile(
optimizer=keras.optimizers.Adam(learning_rate=3e-3),
loss='binary_crossentropy',
metrics=[keras.metrics.BinaryCrossentropy()]
  )
early_stopping=keras.callbacks.EarlyStopping(
patience=25,
min_delta=0.001,
restore_best_weights=True,
  )
d1_cnn_model.fit(
X_train, y_train,
batch_size=10000,
epochs=5000,
callbacks=[early_stopping],
validation_data=(X_test, y_test),
  )
returnd1_cnn_modelTabNet@timerdeftrainTabNetModel(X_train, y_train, pretrainer):
"""Train TabNet modelArgs:pretrainer: pretrained model. If not using this, use NoneReturn:TabNet model obj"""tabNet_model=TabNetClassifier(
n_d=16,
n_a=16,
n_steps=4,
gamma=1.9,
n_independent=4,
n_shared=5,
seed=42,
optimizer_fn=torch.optim.Adam,
scheduler_params= {"milestones": [150,250,300,350,400,450],'gamma':0.2},
scheduler_fn=torch.optim.lr_scheduler.MultiStepLR                                )
tabNet_model.fit(
X_train=X_train.to_numpy(),
y_train=y_train.to_numpy(),
eval_set=[(X_train.to_numpy(), y_train.to_numpy()),
                (X_test.to_numpy(), y_test.to_numpy())],
max_epochs=100,
batch_size=256,
patience=10,
from_unsupervised=pretrainer      )
returntabNet_model