kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,356,808 | index = 'Occupancy'<compute_test_metric> | train_data = application_data[application_data.IS_TRAIN == 1.0] | Home Credit Default Risk |
9,356,808 | intervalo_valores(df_train[index] )<define_variables> | test_data = application_data[application_data.IS_TRAIN == 0.0] | Home Credit Default Risk |
9,356,808 | index = 'Metered Areas(Energy)'<data_type_conversions> | train_data.drop(columns='IS_TRAIN', inplace=True)
test_data.drop(columns='IS_TRAIN', inplace=True ) | Home Credit Default Risk |
9,356,808 | df_train[index] = df_train[index].astype('category' ).cat.codes
df_test[index] = df_test[index].astype('category' ).cat.codes<compute_test_metric> | del(application_data ) | Home Credit Default Risk |
9,356,808 | intervalo_valores(df_train[index] )<define_variables> | params = model.get_params() | Home Credit Default Risk |
9,356,808 | index = 'Metered Areas(Water)'<data_type_conversions> | params['objective'] = 'binary'
params['metric'] = 'auc' | Home Credit Default Risk |
9,356,808 | df_train[index] = df_train[index].astype('category' ).cat.codes
df_test[index] = df_test[index].astype('category' ).cat.codes<compute_test_metric> | skf = StratifiedKFold(n_splits=3, random_state=42, shuffle=True)
final_importance = np.zeros(len(train_data.columns))
for n_fold,(train_index, valid_index)in tqdm(enumerate(skf.split(train_data, train_target.TARGET))):
X_train = train_data.iloc[train_index]
y_train = train_target.iloc[train_index].TARGET
X_valid = train_data.iloc[valid_index]
y_valid = train_target.iloc[valid_index].TARGET
lgb_train = lgb.Dataset(data=X_train, label=y_train)
lgb_eval = lgb.Dataset(data=X_valid, label=y_valid)
model = lgb.train(params, lgb_train, valid_sets=lgb_eval, early_stopping_rounds=150, verbose_eval=100)
final_importance += model.feature_importance() | Home Credit Default Risk |
9,356,808 | intervalo_valores(df_train[index] )<define_variables> | fi = pd.DataFrame()
fi['FEAT'] = train_data.columns | Home Credit Default Risk |
9,356,808 | index = 'Site EUI(kBtu/ft²)'<compute_test_metric> | fi['importance'] = final_importance | Home Credit Default Risk |
9,356,808 | intervalo_valores(df_train[index] )<define_variables> | fi = fi.sort_values(by='importance', ascending=False ) | Home Credit Default Risk |
9,356,808 | index = 'Weather Normalized Site EUI(kBtu/ft²)'<feature_engineering> | fi = fi[fi.importance != 0] | Home Credit Default Risk |
9,356,808 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | cols = list(set(fi.FEAT.values ).union(set(['SK_ID_CURR'])) ) | Home Credit Default Risk |
9,356,808 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | train_data = train_data[cols] | Home Credit Default Risk |
9,356,808 | intervalo_valores(df_train[index] )<define_variables> | test_data = test_data[cols] | Home Credit Default Risk |
9,356,808 | index = 'Weather Normalized Site Electricity Intensity(kWh/ft²)'<feature_engineering> | def get_random_params() :
params = {
'boosting_type': 'gbdt',
'metric': 'auc',
'num_leaves': random.randint(10, 60),
'max_depth': random.randint(10, 30),
'learning_rate': random.choice([0.0001, 0.0005, 0.001, 0.005, 0.01]),
'n_estimators': random.randint(1000, 20000),
'objective': 'binary',
'reg_alpha': random.choice([0.001, 0.005, 0.01, 0.05, 0.1]),
'reg_lambda': random.choice([0.001, 0.005, 0.01, 0.05, 0.1]),
'colsample_bytree': random.choice([0.4, 0.5, 0.6, 0.7, 0.8, 0.9]),
'min_child_samples': random.randint(10, 100),
'subsample_for_bin': random.randint(50000, 300000)
}
return params | Home Credit Default Risk |
9,356,808 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | best_params = {'boosting_type': 'gbdt',
'metric': 'auc',
'num_leaves': 46,
'max_depth': 18,
'learning_rate': 0.01,
'n_estimators': 6289,
'objective': 'binary',
'reg_alpha': 0.05,
'reg_lambda': 0.05,
'colsample_bytree': 0.4,
'min_child_samples': 79,
'subsample_for_bin': 113092}
best_auc = 0.787228 | Home Credit Default Risk |
9,356,808 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | def get_best_params(hyper_rounds, n_folds, best_params=None, best_auc=0):
best_params = best_params
best_auc = best_auc
lgb_train = lgb.Dataset(data=train_data, label=train_target.TARGET)
for i in tqdm(range(hyper_rounds)) :
curr_params = get_random_params()
start = time.time()
print(curr_params)
eval_hist = lgb.cv(curr_params, lgb_train, early_stopping_rounds = 200, nfold = n_folds, seed = 42, verbose_eval = 100)
end = time.time()
print('TIME:', end-start)
curr_auc = eval_hist['auc-mean'][-1]
if curr_auc > best_auc:
best_params = curr_params
best_auc = curr_auc
return best_params, best_auc | Home Credit Default Risk |
9,356,808 | intervalo_valores(df_train[index] )<define_variables> | N_FOLDS = 10 | Home Credit Default Risk |
9,356,808 | index = 'Weather Normalized Site Natural Gas Intensity(therms/ft²)'<feature_engineering> | skf = StratifiedKFold(n_splits=N_FOLDS, random_state=42, shuffle=True)
sub_preds = np.zeros(len(test_data))
avg_valid_auc = 0
for n_fold,(train_index, valid_index)in tqdm(enumerate(skf.split(train_data, train_target.TARGET))):
print("FOLD N:", n_fold)
X_train = train_data.iloc[train_index]
y_train = train_target.iloc[train_index].TARGET
X_valid = train_data.iloc[valid_index]
y_valid = train_target.iloc[valid_index].TARGET
lgb_train = lgb.Dataset(data=X_train, label=y_train)
lgb_eval = lgb.Dataset(data=X_valid, label=y_valid)
model = lgb.train(best_params, lgb_train, valid_sets=lgb_eval, early_stopping_rounds=150, verbose_eval=100)
y_pred = model.predict(X_valid)
sub_preds += model.predict(test_data)/ skf.n_splits
avg_valid_auc += roc_auc_score(y_valid, y_pred)/ N_FOLDS | Home Credit Default Risk |
9,356,808 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | submit['TARGET'] = sub_preds | Home Credit Default Risk |
9,356,808 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | submit.to_csv('submission.csv', index = False ) | Home Credit Default Risk |
3,337,146 | intervalo_valores(df_train[index] )<define_variables> | file_path = ".. /input/" | Home Credit Default Risk |
3,337,146 | index = 'Weather Normalized Source EUI(kBtu/ft²)'<feature_engineering> | @contextmanager
def timer(title):
t0 = time.time()
yield
print("{} - done in {:.0f}s".format(title, time.time() - t0))
def one_hot_encoder(df, categorical_columns=None, nan_as_category=True):
original_columns = list(df.columns)
if not categorical_columns:
categorical_columns = [col for col in df.columns if df[col].dtype == 'object']
df = pd.get_dummies(df, columns=categorical_columns, dummy_na=nan_as_category)
categorical_columns = [c for c in df.columns if c not in original_columns]
return df, categorical_columns
def label_encoder(df, categorical_columns=None):
if not categorical_columns:
categorical_columns = [col for col in df.columns if df[col].dtype == 'object']
for col in categorical_columns:
df[col], uniques = pd.factorize(df[col])
return df, categorical_columns
rint('%d columns were label encoded.' % le_count)
def do_mean(df, group_cols, counted, agg_name):
gp = df[group_cols + [counted]].groupby(group_cols)[counted].mean().reset_index().rename(
columns={counted: agg_name})
df = df.merge(gp, on=group_cols, how='left')
del gp
gc.collect()
return df
def do_median(df, group_cols, counted, agg_name):
gp = df[group_cols + [counted]].groupby(group_cols)[counted].median().reset_index().rename(
columns={counted: agg_name})
df = df.merge(gp, on=group_cols, how='left')
del gp
gc.collect()
return df
def do_std(df, group_cols, counted, agg_name):
gp = df[group_cols + [counted]].groupby(group_cols)[counted].std().reset_index().rename(
columns={counted: agg_name})
df = df.merge(gp, on=group_cols, how='left')
del gp
gc.collect()
return df
def do_sum(df, group_cols, counted, agg_name):
gp = df[group_cols + [counted]].groupby(group_cols)[counted].sum().reset_index().rename(
columns={counted: agg_name})
df = df.merge(gp, on=group_cols, how='left')
del gp
gc.collect()
return df
def age_label(days_birth):
age_years = -days_birth / 365
if age_years < 27: return 1
elif age_years < 40: return 2
elif age_years < 50: return 3
elif age_years < 65: return 4
elif age_years < 99: return 5
else: return 0 | Home Credit Default Risk |
3,337,146 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | def application_train_test(file_path , nan_as_category = True,num_rows= None):
df_train = pd.read_csv(file_path + 'application_train.csv',nrows = num_rows)
df_test = pd.read_csv(file_path + 'application_test.csv',nrows = num_rows)
df = df_train.append(df_test ).reset_index()
del df_train, df_test
gc.collect()
df.drop(df[df['CODE_GENDER'] == 'XNA'].index, inplace = True)
df.drop(df[df['NAME_INCOME_TYPE'] == 'Maternity leave'].index, inplace = True)
df.drop(df[df['NAME_FAMILY_STATUS'] == 'Unknown'].index, inplace = True)
docs = [f for f in df.columns if 'FLAG_DOC' in f]
df['NEW_DOC_IND_AVG'] = df[docs].mean(axis=1)
df['NEW_DOC_IND_STD'] = df[docs].std(axis=1)
df['NEW_DOC_IND_KURT'] = df[docs].kurtosis(axis=1)
df['NEW_DOC_IND_SUM'] = df[docs].sum(axis=1)
drop_list = [ 'HOUR_APPR_PROCESS_START', 'REG_REGION_NOT_LIVE_REGION', 'REG_REGION_NOT_WORK_REGION',
'REG_CITY_NOT_WORK_CITY', 'OBS_30_CNT_SOCIAL_CIRCLE', 'OBS_60_CNT_SOCIAL_CIRCLE',
'AMT_REQ_CREDIT_BUREAU_DAY', 'AMT_REQ_CREDIT_BUREAU_MON', 'AMT_REQ_CREDIT_BUREAU_YEAR',
'COMMONAREA_MODE', 'NONLIVINGAREA_MODE', 'ELEVATORS_MODE', 'NONLIVINGAREA_AVG',
'FLOORSMIN_MEDI', 'LANDAREA_MODE', 'NONLIVINGAREA_MEDI', 'LIVINGAPARTMENTS_MODE',
'FLOORSMIN_AVG', 'LANDAREA_AVG', 'FLOORSMIN_MODE', 'LANDAREA_MEDI',
'COMMONAREA_MEDI', 'YEARS_BUILD_AVG', 'COMMONAREA_AVG', 'BASEMENTAREA_AVG',
'BASEMENTAREA_MODE', 'NONLIVINGAPARTMENTS_MEDI', 'BASEMENTAREA_MEDI',
'LIVINGAPARTMENTS_AVG', 'ELEVATORS_AVG', 'YEARS_BUILD_MEDI', 'ENTRANCES_MODE',
'NONLIVINGAPARTMENTS_MODE', 'LIVINGAREA_MODE', 'LIVINGAPARTMENTS_MEDI',
'YEARS_BUILD_MODE', 'YEARS_BEGINEXPLUATATION_AVG', 'ELEVATORS_MEDI', 'LIVINGAREA_MEDI',
'YEARS_BEGINEXPLUATATION_MODE', 'NONLIVINGAPARTMENTS_AVG',
'FONDKAPREMONT_MODE', 'EMERGENCYSTATE_MODE'
]
for doc_num in [2,4,5,7,9,10,11,12,13,14,15,16,17,19,20,21]:
drop_list.append('FLAG_DOCUMENT_{}'.format(doc_num))
df.drop(drop_list, axis=1, inplace=True)
df['DAYS_EMPLOYED'].replace(365243, np.nan, inplace = True)
df.loc[df['OWN_CAR_AGE'] > 80, 'OWN_CAR_AGE'] = np.nan
df.loc[df['REGION_RATING_CLIENT_W_CITY'] < 0, 'REGION_RATING_CLIENT_W_CITY'] = np.nan
df.loc[df['AMT_INCOME_TOTAL'] > 1e8, 'AMT_INCOME_TOTAL'] = np.nan
df.loc[df['AMT_REQ_CREDIT_BUREAU_QRT'] > 10, 'AMT_REQ_CREDIT_BUREAU_QRT'] = np.nan
df['AGE_RANGE'] = df['DAYS_BIRTH'].apply(lambda x: age_label(x))
df['DAYS_EMPLOYED'].replace(365243, np.nan, inplace= True)
df['EXT_SOURCE_1 / DAYS_BIRTH'] = df['EXT_SOURCE_1'] / df['DAYS_BIRTH']
df['EXT_SOURCE_2 / DAYS_BIRTH'] = df['EXT_SOURCE_2'] / df['DAYS_BIRTH']
df['EXT_SOURCE_3 / DAYS_BIRTH'] = df['EXT_SOURCE_3'] / df['DAYS_BIRTH']
df['EXT_SOURCES_WEIGHTED'] = df.EXT_SOURCE_1 * 2 + df.EXT_SOURCE_2 * 1 + df.EXT_SOURCE_3 * 3
df['EXT_SOURCES_MEAN'] = df[['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3']].mean(axis = 1)
df['EXT_SOURCE_STD'] = df[['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3']].std(axis = 1)
df['EXT_SOURCE_PROD'] = df['EXT_SOURCE_1'] * df['EXT_SOURCE_2'] * df['EXT_SOURCE_3']
df['EXT_SOURCE_2*EXT_SOURCE_3*DAYS_BIRTH']=df['EXT_SOURCE_1'] * df['EXT_SOURCE_2']*df['DAYS_BIRTH']
df['EXT_SOURCE_1 * EXT_SOURCE_2'] = df['EXT_SOURCE_1'] * df['EXT_SOURCE_2']
df['EXT_SOURCE_1 * EXT_SOURCE_3'] = df['EXT_SOURCE_1'] * df['EXT_SOURCE_3']
df['EXT_SOURCE_2 * EXT_SOURCE_3'] = df['EXT_SOURCE_2'] * df['EXT_SOURCE_3']
df['EXT_SOURCE_1 * DAYS_EMPLOYED'] = df['EXT_SOURCE_1'] * df['DAYS_EMPLOYED']
df['EXT_SOURCE_2 * DAYS_EMPLOYED'] = df['EXT_SOURCE_2'] * df['DAYS_EMPLOYED']
df['EXT_SOURCE_3 * DAYS_EMPLOYED'] = df['EXT_SOURCE_3'] * df['DAYS_EMPLOYED']
df['AMT_CREDIT - AMT_GOODS_PRICE'] = df['AMT_CREDIT'] - df['AMT_GOODS_PRICE']
df['AMT_CREDIT / AMT_INCOME_TOTAL'] = df['AMT_CREDIT'] / df['AMT_INCOME_TOTAL']
df['CREDIT_TO_ANNUITY_RATIO'] = df['AMT_CREDIT'] / df['AMT_ANNUITY']
df['CREDIT_TO_GOODS_RATIO'] = df['AMT_CREDIT'] / df['AMT_GOODS_PRICE']
df['app AMT_INCOME_TOTAL / 12 - AMT_ANNUITY'] = df['AMT_INCOME_TOTAL'] / 12.- df['AMT_ANNUITY']
df['app AMT_INCOME_TOTAL / AMT_ANNUITY'] = df['AMT_INCOME_TOTAL'] / df['AMT_ANNUITY']
df['app AMT_INCOME_TOTAL - AMT_GOODS_PRICE'] = df['AMT_INCOME_TOTAL'] - df['AMT_GOODS_PRICE']
df['app AMT_INCOME_TOTAL / CNT_FAM_MEMBERS'] = df['AMT_INCOME_TOTAL'] / df['CNT_FAM_MEMBERS']
df['app AMT_INCOME_TOTAL / CNT_CHILDREN'] = df['AMT_INCOME_TOTAL'] /(1 + df['CNT_CHILDREN'])
df['INCOME_PER_PERSON'] = df['AMT_INCOME_TOTAL'] / df['CNT_FAM_MEMBERS']
df['ANNUITY_INCOME_PERC'] = df['AMT_ANNUITY'] / df['AMT_INCOME_TOTAL']
df['app most popular AMT_GOODS_PRICE'] = df['AMT_GOODS_PRICE'] \
.isin([225000, 450000, 675000, 900000] ).map({True: 1, False: 0})
df['app popular AMT_GOODS_PRICE'] = df['AMT_GOODS_PRICE'] \
.isin([1125000, 1350000, 1575000, 1800000, 2250000] ).map({True: 1, False: 0})
df['app OWN_CAR_AGE / DAYS_BIRTH'] = df['OWN_CAR_AGE'] / df['DAYS_BIRTH']
df['app OWN_CAR_AGE / DAYS_EMPLOYED'] = df['OWN_CAR_AGE'] / df['DAYS_EMPLOYED']
df['app DAYS_LAST_PHONE_CHANGE / DAYS_BIRTH'] = df['DAYS_LAST_PHONE_CHANGE'] / df['DAYS_BIRTH']
df['app DAYS_LAST_PHONE_CHANGE / DAYS_EMPLOYED'] = df['DAYS_LAST_PHONE_CHANGE'] / df['DAYS_EMPLOYED']
df['app DAYS_EMPLOYED - DAYS_BIRTH'] = df['DAYS_EMPLOYED'] - df['DAYS_BIRTH']
df['app DAYS_EMPLOYED / DAYS_BIRTH'] = df['DAYS_EMPLOYED'] / df['DAYS_BIRTH']
df['app CNT_CHILDREN / CNT_FAM_MEMBERS'] = df['CNT_CHILDREN'] / df['CNT_FAM_MEMBERS']
group = ['ORGANIZATION_TYPE', 'NAME_EDUCATION_TYPE', 'OCCUPATION_TYPE', 'AGE_RANGE', 'CODE_GENDER']
df = do_median(df, group, 'EXT_SOURCES_MEAN', 'GROUP_EXT_SOURCES_MEDIAN')
df = do_std(df, group, 'EXT_SOURCES_MEAN', 'GROUP_EXT_SOURCES_STD')
df = do_mean(df, group, 'AMT_INCOME_TOTAL', 'GROUP_INCOME_MEAN')
df = do_std(df, group, 'AMT_INCOME_TOTAL', 'GROUP_INCOME_STD')
df = do_mean(df, group, 'CREDIT_TO_ANNUITY_RATIO', 'GROUP_CREDIT_TO_ANNUITY_MEAN')
df = do_std(df, group, 'CREDIT_TO_ANNUITY_RATIO', 'GROUP_CREDIT_TO_ANNUITY_STD')
df = do_mean(df, group, 'AMT_CREDIT', 'GROUP_CREDIT_MEAN')
df = do_mean(df, group, 'AMT_ANNUITY', 'GROUP_ANNUITY_MEAN')
df = do_std(df, group, 'AMT_ANNUITY', 'GROUP_ANNUITY_STD')
df, le_encoded_cols = label_encoder(df, None)
return reduce_mem_usage(df ) | Home Credit Default Risk |
3,337,146 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | def bureau_and_balance(file_path,num_rows = None, nan_as_category = True):
bureau = pd.read_csv(file_path+'bureau.csv', nrows = num_rows)
bb = pd.read_csv(file_path+'bureau_balance.csv', nrows = num_rows)
bb, bb_cat = one_hot_encoder(bb, nan_as_category=False)
bureau, bureau_cat = one_hot_encoder(bureau, nan_as_category=False)
bb_aggregations = {'MONTHS_BALANCE': ['min', 'max', 'size']}
for col in bb_cat:
bb_aggregations[col] = ['mean']
bb_agg = bb.groupby('SK_ID_BUREAU' ).agg(bb_aggregations)
bb_agg.columns = pd.Index([e[0] + "_" + e[1].upper() for e in bb_agg.columns.tolist() ])
bureau = bureau.join(bb_agg, how='left', on='SK_ID_BUREAU')
bureau.drop(['SK_ID_BUREAU'], axis=1, inplace= True)
del bb, bb_agg
gc.collect()
num_aggregations = {
'DAYS_CREDIT': [ 'mean', 'var'],
'DAYS_CREDIT_ENDDATE': [ 'mean'],
'DAYS_CREDIT_UPDATE': ['mean'],
'CREDIT_DAY_OVERDUE': ['mean'],
'AMT_CREDIT_MAX_OVERDUE': ['mean'],
'AMT_CREDIT_SUM': [ 'mean', 'sum'],
'AMT_CREDIT_SUM_DEBT': [ 'mean', 'sum'],
'AMT_CREDIT_SUM_OVERDUE': ['mean'],
'AMT_CREDIT_SUM_LIMIT': ['mean', 'sum'],
'AMT_ANNUITY': ['max', 'mean'],
'CNT_CREDIT_PROLONG': ['sum'],
'MONTHS_BALANCE_MIN': ['min'],
'MONTHS_BALANCE_MAX': ['max'],
'MONTHS_BALANCE_SIZE': ['mean', 'sum']
}
cat_aggregations = {}
for cat in bureau_cat: cat_aggregations[cat] = ['mean']
for cat in bb_cat: cat_aggregations[cat + "_MEAN"] = ['mean']
bureau_agg = bureau.groupby('SK_ID_CURR' ).agg({**num_aggregations, **cat_aggregations})
bureau_agg.columns = pd.Index(['BURO_' + e[0] + "_" + e[1].upper() for e in bureau_agg.columns.tolist() ])
active = bureau[bureau['CREDIT_ACTIVE_Active'] == 1]
active_agg = active.groupby('SK_ID_CURR' ).agg(num_aggregations)
active_agg.columns = pd.Index(['ACTIVE_' + e[0] + "_" + e[1].upper() for e in active_agg.columns.tolist() ])
bureau_agg = bureau_agg.join(active_agg, how='left', on='SK_ID_CURR')
del active, active_agg
gc.collect()
closed = bureau[bureau['CREDIT_ACTIVE_Closed'] == 1]
closed_agg = closed.groupby('SK_ID_CURR' ).agg(num_aggregations)
closed_agg.columns = pd.Index(['CLOSED_' + e[0] + "_" + e[1].upper() for e in closed_agg.columns.tolist() ])
bureau_agg = bureau_agg.join(closed_agg, how='left', on='SK_ID_CURR')
del closed, closed_agg
gc.collect()
for time_frame in [6, 12]:
prefix = "BUREAU_LAST{}M_".format(time_frame)
time_frame_df = bureau[bureau['DAYS_CREDIT'] >= -30*time_frame]
agg_bureau = group_and_merge(time_frame_df, agg_bureau, prefix, BUREAU_TIME_AGG)
del time_frame_df, bureau
gc.collect()
sort_bureau = bureau.sort_values(by=['DAYS_CREDIT'])
gr = sort_bureau.groupby('SK_ID_CURR')['AMT_CREDIT_MAX_OVERDUE'].last().reset_index()
gr.rename({'AMT_CREDIT_MAX_OVERDUE': 'BUREAU_LAST_LOAN_MAX_OVERDUE'}, inplace=True)
agg_bureau = agg_bureau.merge(gr, on='SK_ID_CURR', how='left')
return reduce_mem_usage(bureau_agg ) | Home Credit Default Risk |
3,337,146 | intervalo_valores(df_train[index] )<define_variables> | def previous_application(file_path ,num_rows = None, nan_as_category = True):
df_prev = pd.read_csv(file_path + 'previous_application.csv',nrows = num_rows)
df_prev.loc[df_prev['AMT_CREDIT'] > 6000000, 'AMT_CREDIT'] = np.nan
df_prev.loc[df_prev['SELLERPLACE_AREA'] > 3500000, 'SELLERPLACE_AREA'] = np.nan
df_prev[['DAYS_FIRST_DRAWING', 'DAYS_FIRST_DUE', 'DAYS_LAST_DUE_1ST_VERSION',
'DAYS_LAST_DUE', 'DAYS_TERMINATION']].replace(365243, np.nan, inplace = True)
df_prev['prev missing'] = df_prev.isnull().sum(axis = 1 ).values
df_prev['prev AMT_APPLICATION / AMT_CREDIT'] = df_prev['AMT_APPLICATION'] / df_prev['AMT_CREDIT']
df_prev['prev AMT_APPLICATION - AMT_CREDIT'] = df_prev['AMT_APPLICATION'] - df_prev['AMT_CREDIT']
df_prev['prev AMT_APPLICATION - AMT_GOODS_PRICE'] = df_prev['AMT_APPLICATION'] - df_prev['AMT_GOODS_PRICE']
df_prev['prev AMT_GOODS_PRICE - AMT_CREDIT'] = df_prev['AMT_GOODS_PRICE'] - df_prev['AMT_CREDIT']
df_prev['prev DAYS_FIRST_DRAWING - DAYS_FIRST_DUE'] = df_prev['DAYS_FIRST_DRAWING'] - df_prev['DAYS_FIRST_DUE']
df_prev['prev DAYS_TERMINATION less -500'] =(df_prev['DAYS_TERMINATION'] < -500 ).astype(int)
ohe_columns = [
'NAME_CONTRACT_STATUS', 'NAME_CONTRACT_TYPE', 'CHANNEL_TYPE',
'NAME_TYPE_SUITE', 'NAME_YIELD_GROUP', 'PRODUCT_COMBINATION',
'NAME_PRODUCT_TYPE', 'NAME_CLIENT_TYPE']
df_prev, categorical = one_hot_encoder(df_prev,ohe_columns, nan_as_category=False)
df_prev,categorical_label=label_encoder(df_prev)
aggregations = {}
for col in df_prev.columns:
aggregations[col] = ['mean'] if col in categorical else [ 'mean','min','max']
df_prev_agg = df_prev.groupby('SK_ID_CURR' ).agg(aggregations)
df_prev_agg.columns = pd.Index(['PREV_' + e[0] + "_" + e[1].upper() for e in df_prev_agg.columns.tolist() ])
approved_agg = df_prev[df_prev['NAME_CONTRACT_STATUS_Approved'] == 1].groupby('SK_ID_CURR' ).agg(aggregations)
approved_agg.columns = pd.Index(['APPROVED_' + e[0] + "_" + e[1].upper() for e in approved_agg.columns.tolist() ])
df_prev_agg = df_prev_agg.join(approved_agg, how = 'left')
del approved_agg
gc.collect()
refused_agg = df_prev[df_prev['NAME_CONTRACT_STATUS_Refused'] == 1].groupby('SK_ID_CURR' ).agg(aggregations)
refused_agg.columns = pd.Index(['REFUSED_' + e[0] + "_" + e[1].upper() for e in refused_agg.columns.tolist() ])
df_prev_agg = df_prev_agg.join(refused_agg, how = 'left')
del refused_agg, df_prev
gc.collect()
return reduce_mem_usage(df_prev_agg ) | Home Credit Default Risk |
3,337,146 | index = 'Fuel Oil<feature_engineering> | def pos_cash(file_path,num_rows = None, nan_as_category = True):
pos = pd.read_csv(file_path+'POS_CASH_balance.csv', nrows = num_rows)
pos, cat_cols = one_hot_encoder(pos, nan_as_category= False)
aggregations = {
'MONTHS_BALANCE': ['max', 'mean', 'size'],
'SK_DPD': ['max', 'mean'],
'SK_DPD_DEF': ['max', 'mean']
}
for cat in cat_cols:
aggregations[cat] = ['mean']
pos_agg = pos.groupby('SK_ID_CURR' ).agg(aggregations)
pos_agg.columns = pd.Index(['POS_' + e[0] + "_" + e[1].upper() for e in pos_agg.columns.tolist() ])
pos_agg['POS_COUNT'] = pos.groupby('SK_ID_CURR' ).size()
del pos
gc.collect()
return reduce_mem_usage(pos_agg)
def installments_payments(file_path,num_rows = None, nan_as_category = True):
ins = pd.read_csv(file_path+'installments_payments.csv', nrows = num_rows)
ins, cat_cols = one_hot_encoder(ins, nan_as_category= False)
ins['PAYMENT_PERC'] = ins['AMT_PAYMENT'] / ins['AMT_INSTALMENT']
ins['PAYMENT_DIFF'] = ins['AMT_INSTALMENT'] - ins['AMT_PAYMENT']
ins['DPD'] = ins['DAYS_ENTRY_PAYMENT'] - ins['DAYS_INSTALMENT']
ins['DBD'] = ins['DAYS_INSTALMENT'] - ins['DAYS_ENTRY_PAYMENT']
ins['DPD'] = ins['DPD'].apply(lambda x: x if x > 0 else 0)
ins['DBD'] = ins['DBD'].apply(lambda x: x if x > 0 else 0)
aggregations = {
'NUM_INSTALMENT_VERSION': ['nunique'],
'DPD': ['max', 'mean', 'sum'],
'DBD': ['max', 'mean', 'sum'],
'PAYMENT_PERC': [ 'mean', 'var'],
'PAYMENT_DIFF': [ 'mean', 'var'],
'AMT_INSTALMENT': ['max', 'mean', 'sum'],
'AMT_PAYMENT': ['min', 'max', 'mean', 'sum'],
'DAYS_ENTRY_PAYMENT': ['max', 'mean', 'sum']
}
for cat in cat_cols:
aggregations[cat] = ['mean']
ins_agg = ins.groupby('SK_ID_CURR' ).agg(aggregations)
ins_agg.columns = pd.Index(['INSTAL_' + e[0] + "_" + e[1].upper() for e in ins_agg.columns.tolist() ])
ins_agg['INSTAL_COUNT'] = ins.groupby('SK_ID_CURR' ).size()
del ins
gc.collect()
return reduce_mem_usage(ins_agg)
def credit_card_balance(file_path,num_rows = None, nan_as_category = True):
cc = pd.read_csv(file_path+'credit_card_balance.csv', nrows = num_rows)
cc, cat_cols = one_hot_encoder(cc, nan_as_category= False)
cc.drop(['SK_ID_PREV'], axis= 1, inplace = True)
cc_agg = cc.groupby('SK_ID_CURR' ).agg([ 'max', 'mean', 'sum', 'var'])
cc_agg.columns = pd.Index(['CC_' + e[0] + "_" + e[1].upper() for e in cc_agg.columns.tolist() ])
cc_agg['CC_COUNT'] = cc.groupby('SK_ID_CURR' ).size()
del cc
gc.collect()
return reduce_mem_usage(cc_agg ) | Home Credit Default Risk |
3,337,146 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | def bayes_parameter_opt_lgb(X, y, init_round=15, opt_round=25, n_folds=5, random_seed=6, n_estimators=10000, learning_rate=0.05, output_process=False):
train_data = lgb.Dataset(data=X, label=y, categorical_feature = categorical_feats, free_raw_data=False)
def lgb_eval(num_leaves, feature_fraction, bagging_fraction, max_depth, lambda_l1, lambda_l2, min_split_gain, min_child_weight):
params = {'application':'binary','num_iterations': n_estimators, 'learning_rate':learning_rate, 'early_stopping_round':100, 'metric':'auc'}
params["num_leaves"] = int(round(num_leaves))
params['feature_fraction'] = max(min(feature_fraction, 1), 0)
params['bagging_fraction'] = max(min(bagging_fraction, 1), 0)
params['max_depth'] = int(round(max_depth))
params['lambda_l1'] = max(lambda_l1, 0)
params['lambda_l2'] = max(lambda_l2, 0)
params['min_split_gain'] = min_split_gain
params['min_child_weight'] = min_child_weight
cv_result = lgb.cv(params, train_data, nfold=n_folds, seed=random_seed, stratified=True, verbose_eval =200, metrics=['auc'])
return max(cv_result['auc-mean'])
lgbBO = BayesianOptimization(lgb_eval, {'num_leaves':(30, 40),
'feature_fraction':(0.1, 0.9),
'bagging_fraction':(0.8, 1),
'max_depth':(7, 8.99),
'lambda_l1':(0, 5),
'lambda_l2':(0, 3),
'min_split_gain':(0.001, 0.1),
'min_child_weight':(39, 50)}, random_state=0)
lgbBO.maximize(init_points=init_round, n_iter=opt_round)
if output_process==True: lgbBO.points_to_csv("bayes_opt_result.csv")
return lgbBO.res['max']['max_params'] | Home Credit Default Risk |
3,337,146 | <compute_test_metric><EOS> | def main(debug = False):
num_rows = 30000 if debug else None
df = application_train_test(file_path,num_rows)
with timer("Process bureau and bureau_balance"):
bureau = bureau_and_balance(file_path,num_rows)
print("Bureau df shape:", bureau.shape)
df = df.join(bureau, how='left', on='SK_ID_CURR')
del bureau
gc.collect()
with timer("Process previous_applications"):
prev = previous_application(file_path,num_rows)
print("Previous applications df shape:", prev.shape)
df = df.join(prev, how='left', on='SK_ID_CURR')
del prev
gc.collect()
with timer("Process POS-CASH balance"):
pos = pos_cash(file_path,num_rows)
print("Pos-cash balance df shape:", pos.shape)
df = df.join(pos, how='left', on='SK_ID_CURR')
del pos
gc.collect()
with timer("Process installments payments"):
ins = installments_payments(file_path,num_rows)
print("Installments payments df shape:", ins.shape)
df = df.join(ins, how='left', on='SK_ID_CURR')
del ins
gc.collect()
with timer("Process credit card balance"):
cc = credit_card_balance(file_path,num_rows)
print("Credit card balance df shape:", cc.shape)
df = df.join(cc, how='left', on='SK_ID_CURR')
del cc
gc.collect()
with timer("bayesbian"):
X = df.drop('TARGET', axis=1)
y = df.TARGET
opt_params = bayes_parameter_opt_lgb(X, y, init_round=5, opt_round=10, n_folds=3, random_seed=6, n_estimators=100, learning_rate=0.05)
if __name__ == "__main__":
with timer("Full model run"):
main() | Home Credit Default Risk |
4,870,466 | <SOS> metric: AUC Kaggle data source: home-credit-default-risk<define_variables> | print(f"Pandas version: {pd.__version__}" ) | Home Credit Default Risk |
4,870,466 | index = 'Fuel Oil<feature_engineering> | INPUT_DIR = ".. /input/"
get_full_path = partial(os.path.join, INPUT_DIR)
PATH_APP_TRAIN = get_full_path("application_train.csv")
PATH_APP_TEST = get_full_path("application_test.csv")
PATH_PRE_APP = get_full_path("previous_application.csv")
PATH_INST_PAY = get_full_path("installments_payments.csv")
PATH_INST_PAY_PROCESSED = "installments_payments_preprocessed.csv"
PATH_POS_BALANCE = get_full_path("POS_CASH_balance")
PATH_CREDIT_BALANCE = get_full_path("credit_card_balance.csv")
PATH_BUREAU = get_full_path("bureau.csv")
PATH_BUREAU_BALANCE = get_full_path("bureau_balance.csv")
PERFORM_IMPUTATION = True
CROSS_VALIDATION_FOLD = 5
RANDOM_SEED = 0 | Home Credit Default Risk |
4,870,466 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | LoanType = CategoricalDtype(["Cash loans", "Revolving loans", "Consumer loans"], False)
HouseType = CategoricalDtype(["block of flats", "terraced house", "specific housing"])
WeekDayType = CategoricalDtype(['SUNDAY', 'MONDAY', 'TUESDAY', 'WEDNESDAY', 'THURSDAY', 'FRIDAY', 'SATURDAY'], True)
YesNoType = CategoricalDtype(["N", "Y"], True)
LoanStatusType = CategoricalDtype(['Approved', 'Refused', 'Canceled', 'Unused offer'], False)
EducationType = CategoricalDtype(["Incomplete higher", "Higher education", "Lower secondary",
"Secondary / secondary special", "Academic degree"], True)
FamilyType = CategoricalDtype(["Civil marriage", "Married", "Separated", "Single / not married", "Widow"], False)
HousingType = CategoricalDtype(["House / apartment", "Rented apartment", "With parents",
"Municipal apartment", "Office apartment", "Co-op apartment"], False)
IncomeType = CategoricalDtype(["Unemployed", "Student", "State servant", "Working", "Commercial associate",
"Businessman", "Maternity leave", "Pensioner"], False)
AccompanyType = CategoricalDtype(["Unaccompanied", "Spouse", "partner", "Family", "Children",
"Group of people", "Other_A", "Other_B"], False)
OccupationType = CategoricalDtype(["Accountants", "Cleaning staff", "Cooking staff", "Core staff",
"Drivers", "HR staff", "High skill tech staff", "IT staff", "Laborers",
"Low-skill Laborers", "Managers", "Medicine staff",
"Private service staff", "Realty agents", "Sales staff", "Secretaries",
"Security staff", "Waiters/barmen staff"], False)
CreditStatusType = CategoricalDtype(["Closed", "Active", "Sold", "Bad debt", "Signed"], True)
BureauBalanceStatusType = CategoricalDtype(["C", *map(str, range(6)) ], True ) | Home Credit Default Risk |
4,870,466 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | def load_app_data(train_only=False):
gender_type = CategoricalDtype(["M", "F"], False)
yes_no_type2 = CategoricalDtype(["No", "Yes"], True)
wall_material_type = CategoricalDtype(["Stone, brick", "Wooden", "Block", "Panel",
"Monolithic", "Mixed", "Others"], False)
fondkapremont_type = CategoricalDtype(["reg oper account", "org spec account",
"reg oper spec account", "not specified"], False)
col_types = {
"SK_ID_CURR": np.uint32, "TARGET": np.bool, "CODE_GENDER": gender_type, "NAME_CONTRACT_TYPE": LoanType,
"FLAG_OWN_CAR": YesNoType, "FLAG_OWN_REALTY": YesNoType, "CNT_CHILDREN": np.uint8,
"AMT_INCOME_TOTAL": np.float32, "AMT_CREDIT": np.float32,
"AMT_ANNUITY": np.float32, "AMT_GOODS_PRICE": np.float32,
"NAME_TYPE_SUITE": AccompanyType, "NAME_EDUCATION_TYPE": EducationType, "NAME_INCOME_TYPE": IncomeType,
"NAME_FAMILY_STATUS": FamilyType, "NAME_HOUSING_TYPE": HousingType,
"REGION_POPULATION_RELATIVE": np.float32,
"REGION_RATING_CLIENT": np.uint8, "REGION_RATING_CLIENT_W_CITY": np.uint8,
"WEEKDAY_APPR_PROCESS_START": WeekDayType, "HOUR_APPR_PROCESS_START": np.uint8,
"DAYS_EMPLOYED": np.float32, "DAYS_BIRTH": np.int32,
"DAYS_REGISTRATION": np.float32, "DAYS_ID_PUBLISH": np.float32,
"OWN_CAR_AGE": np.float16,
"EXT_SOURCE_1": np.float32, "EXT_SOURCE_2": np.float32, "EXT_SOURCE_3": np.float32,
"FLAG_MOBIL": np.bool, "FLAG_EMP_PHONE": np.bool, "FLAG_WORK_PHONE": np.bool,
"FLAG_CONT_MOBILE": np.bool, "FLAG_PHONE": np.bool, "FLAG_EMAIL": np.bool,
"OCCUPATION_TYPE": OccupationType, "CNT_FAM_MEMBERS": np.float16,
"REG_REGION_NOT_LIVE_REGION": np.bool, "REG_REGION_NOT_WORK_REGION": np.bool,
"LIVE_REGION_NOT_WORK_REGION": np.bool, "REG_CITY_NOT_LIVE_CITY": np.bool,
"REG_CITY_NOT_WORK_CITY": np.bool, "LIVE_CITY_NOT_WORK_CITY": np.bool,
"ORGANIZATION_TYPE": "category",
"OBS_30_CNT_SOCIAL_CIRCLE": np.float16, "DEF_30_CNT_SOCIAL_CIRCLE": np.float16,
"OBS_60_CNT_SOCIAL_CIRCLE": np.float16, "DEF_60_CNT_SOCIAL_CIRCLE": np.float16,
"DAYS_LAST_PHONE_CHANGE": np.float32,
"AMT_REQ_CREDIT_BUREAU_HOUR": np.float16, "AMT_REQ_CREDIT_BUREAU_DAY": np.float16,
"AMT_REQ_CREDIT_BUREAU_WEEK": np.float16, "AMT_REQ_CREDIT_BUREAU_MON": np.float16,
"AMT_REQ_CREDIT_BUREAU_QRT": np.float16, "AMT_REQ_CREDIT_BUREAU_YEAR": np.float16,
"HOUSETYPE_MODE": HouseType, "FONDKAPREMONT_MODE": fondkapremont_type,
"WALLSMATERIAL_MODE": wall_material_type, "EMERGENCYSTATE_MODE": yes_no_type2
}
float_housing_columns = [
"APARTMENTS_AVG", "BASEMENTAREA_AVG", "YEARS_BEGINEXPLUATATION_AVG",
"YEARS_BUILD_AVG", "COMMONAREA_AVG", "ELEVATORS_AVG", "ENTRANCES_AVG",
"FLOORSMAX_AVG", "FLOORSMIN_AVG", "LANDAREA_AVG",
"LIVINGAPARTMENTS_AVG", "LIVINGAREA_AVG", "NONLIVINGAPARTMENTS_AVG", "NONLIVINGAREA_AVG",
"APARTMENTS_MODE", "BASEMENTAREA_MODE", "YEARS_BEGINEXPLUATATION_MODE",
"YEARS_BUILD_MODE", "COMMONAREA_MODE", "ELEVATORS_MODE", "ENTRANCES_MODE",
"FLOORSMAX_MODE", "FLOORSMIN_MODE", "LANDAREA_MODE",
"LIVINGAPARTMENTS_MODE", "LIVINGAREA_MODE", "NONLIVINGAPARTMENTS_MODE",
"NONLIVINGAREA_MODE", "TOTALAREA_MODE",
"APARTMENTS_MEDI", "BASEMENTAREA_MEDI", "YEARS_BEGINEXPLUATATION_MEDI",
"YEARS_BUILD_MEDI", "COMMONAREA_MEDI", "ELEVATORS_MEDI", "ENTRANCES_MEDI",
"FLOORSMAX_MEDI", "FLOORSMIN_MEDI", "LANDAREA_MEDI", "LIVINGAPARTMENTS_MEDI",
"LIVINGAREA_MEDI", "NONLIVINGAPARTMENTS_MEDI", "NONLIVINGAREA_MEDI",
]
col_types.update(( "FLAG_DOCUMENT_" + str(v), np.bool)for v in range(2, 22))
col_types.update(( col, np.float16)for col in float_housing_columns)
replace_dict = {"DAYS_EMPLOYED": {365243: np.nan}, "DAYS_LAST_PHONE_CHANGE": {0: np.nan}}
na_values = ["XNA", "Unknown"]
df_app_train = pd.read_csv(PATH_APP_TRAIN, index_col=0, na_values=na_values, dtype=col_types)
df_app_train.replace(replace_dict, inplace=True)
assert df_app_train.shape ==(307511, 121)
if train_only:
return df_app_train
else:
df_app_test = pd.read_csv(PATH_APP_TEST, index_col=0, na_values=na_values, dtype=col_types)
df_app_test.replace(replace_dict, inplace=True)
assert df_app_test.shape ==(48744, 120)
return df_app_train, df_app_test
def load_prev_app_data() :
interest_types = CategoricalDtype(["low_action", "low_normal", "middle", "high"], True)
col_types = {
"SK_ID_PREV": np.uint32, "SK_ID_CURR": np.uint32, "NAME_CONTRACT_TYPE": LoanType,
"AMT_ANNUITY": np.float32, "AMT_APPLICATION": np.float32, "AMT_CREDIT": np.float32,
"AMT_DOWN_PAYMENT": np.float32, "AMT_GOODS_PRICE": np.float32,
"WEEKDAY_APPR_PROCESS_START": WeekDayType, "HOUR_APPR_PROCESS_START": np.uint8,
"FLAG_LAST_APPL_PER_CONTRACT": YesNoType, "NFLAG_LAST_APPL_IN_DAY": np.bool,
"RATE_DOWN_PAYMENT": np.float32, "RATE_INTEREST_PRIMARY": np.float32, "RATE_INTEREST_PRIVILEGED": np.float32,
"NAME_CASH_LOAN_PURPOSE": "category", "NAME_CONTRACT_STATUS": LoanStatusType,
"DAYS_DECISION": np.int16, "NAME_PAYMENT_TYPE": "category", "CODE_REJECT_REASON": "category",
"NAME_TYPE_SUITE": "category", "NAME_CLIENT_TYPE": "category", "NAME_GOODS_CATEGORY": "category",
"NAME_PORTFOLIO": "category", "NAME_PRODUCT_TYPE": "category", "CHANNEL_TYPE": "category",
"SELLERPLACE_AREA": np.float32, "NAME_SELLER_INDUSTRY": "category", "CNT_PAYMENT": np.float16,
"NAME_YIELD_GROUP": interest_types, "PRODUCT_COMBINATION": "category",
"DAYS_FIRST_DRAWING": np.float32, "DAYS_FIRST_DUE": np.float32,
"DAYS_LAST_DUE_1ST_VERSION": np.float32, "DAYS_LAST_DUE": np.float32, "DAYS_TERMINATION": np.float32,
"NFLAG_INSURED_ON_APPROVAL": np.float16
}
d = {365243: np.nan}
replace_dict = {"SELLERPLACE_AREA": {-1: np.nan},
"DAYS_FIRST_DRAWING": d, "DAYS_FIRST_DUE": d,
"DAYS_LAST_DUE_1ST_VERSION": d, "DAYS_LAST_DUE": d, "DAYS_TERMINATION": d}
df_prev_app = pd.read_csv(PATH_PRE_APP, na_values=["XNA", ""], index_col=0,
keep_default_na=False, dtype=col_types)
df_prev_app.replace(replace_dict, inplace=True)
assert df_prev_app.shape ==(1670214, 36), f"Incorrect shape for df_prev_app: {df_prev_app.shape}"
return df_prev_app
def load_install_payments(load_processed=True):
col_types = {
"SK_ID_PREV": np.uint32, "SK_ID_CURR": np.uint32,
"NUM_INSTALMENT_VERSION": np.uint8, "NUM_INSTALMENT_NUMBER": np.uint16,
"DAYS_INSTALMENT": np.int16, "DAYS_ENTRY_PAYMENT": np.float16,
"AMT_INSTALMENT": np.float32, "AMT_PAYMENT": np.float32,
"NUM_PAYMENTS": np.uint16, "AMT_OVERDUE": np.float32, "AMT_DPD30": np.float32
}
if load_processed:
return pd.read_csv(PATH_INST_PAY_PROCESSED, dtype=col_types)
else:
df = pd.read_csv(PATH_INST_PAY, dtype=col_types)
assert df.shape ==(13605401, 8)
return df
def load_pos_balance() :
col_types = {
"SK_ID_PREV": np.uint32, "SK_ID_CURR": np.uint32, "MONTHS_BALANCE": np.int16,
"CNT_INSTALMENT": np.float16, "CNT_INSTALMENT_FUTURE": np.float16,
"NAME_CONTRACT_STATUS": CreditStatusType,
"SK_DPD": np.uint16, "SK_DPD_DEF": np.uint16
}
df = pd.read_csv(PATH_POS_BALANCE, na_values=["XNA"], dtype=col_types)
assert df.shape ==(10001358, 8)
return df
def load_credit_balance_data() :
col_types = {
"SK_ID_PREV": np.uint32, "SK_ID_CURR": np.uint32, "MONTHS_BALANCE": np.int16,
"AMT_BALANCE": np.float32, "AMT_CREDIT_LIMIT_ACTUAL": np.float32,
"AMT_DRAWINGS_ATM_CURRENT": np.float32, "AMT_DRAWINGS_CURRENT": np.float32,
"AMT_DRAWINGS_OTHER_CURRENT": np.float32, "AMT_DRAWINGS_POS_CURRENT": np.float32,
"AMT_INST_MIN_REGULARITY": np.float32, "AMT_PAYMENT_CURRENT": np.float32,
"AMT_PAYMENT_TOTAL_CURRENT": np.float32, "AMT_RECEIVABLE_PRINCIPAL": np.float32,
"AMT_RECIVABLE": np.float32, "AMT_TOTAL_RECEIVABLE": np.float32,
"CNT_DRAWINGS_ATM_CURRENT": np.float16, "CNT_DRAWINGS_CURRENT": np.float16,
"CNT_DRAWINGS_OTHER_CURRENT": np.float16, "CNT_DRAWINGS_POS_CURRENT": np.float16,
"CNT_INSTALMENT_MATURE_CUM": np.float16, "NAME_CONTRACT_STATUS": "category",
"SK_DPD": np.uint16, "SK_DPD_DEF": np.uint16
}
df = pd.read_csv(PATH_CREDIT_BALANCE, dtype=col_types)
assert df.shape ==(3840312, 23)
return df
def load_bureau() :
currency_types = CategoricalDtype(["currency " + str(v)for v in range(1, 5)], False)
col_types = {
"SK_ID_BUREAU": np.uint32, "SK_ID_CURR": np.uint32, "CREDIT_ACTIVE": CreditStatusType,
"CREDIT_CURRENCY": currency_types, "DAYS_CREDIT": np.float16, "CREDIT_DAY_OVERDUE": np.uint16,
"DAYS_ENDDATE_FACT": np.float16, "DAYS_CREDIT_ENDDATE": np.float16,
"AMT_CREDIT_MAX_OVERDUE": np.float32, "CNT_CREDIT_PROLONG": np.uint8,
"AMT_CREDIT_SUM": np.float32, "AMT_CREDIT_SUM_DEBT": np.float32, "AMT_CREDIT_SUM_LIMIT": np.float32,
"AMT_CREDIT_SUM_OVERDUE": np.float32, "AMT_ANNUITY": np.float32,
"CREDIT_TYPE": "category"
}
df = pd.read_csv(PATH_BUREAU, index_col=1, dtype=col_types)
assert df.shape ==(1716428, 16)
return df
def load_bureau_balance() :
col_types = {
"SK_ID_BUREAU": np.uint32, "MONTHS_BALANCE": np.int16, "STATUS": BureauBalanceStatusType
}
df = pd.read_csv(PATH_BUREAU_BALANCE, na_values=["X"], dtype=col_types)
assert df.shape ==(27299925, 3)
return df | Home Credit Default Risk |
4,870,466 | intervalo_valores(df_train[index] )<define_variables> | def flatten_agg_df_columns(df_agg, prefix=None):
if prefix is None:
df_agg.columns = ['_'.join([c0, c1.upper() ])for c0, c1 in df_agg.columns]
else:
df_agg.columns = ['_'.join([prefix, c0, c1.upper() ])for c0, c1 in df_agg.columns]
return df_agg
def clean_inst_pay(df_inst_pay):
print("Cleaning installment payments data")
df_inst_pay["DAYS_ENTRY_PAYMENT"].fillna(0, inplace=True)
df_inst_pay["AMT_PAYMENT"].fillna(-1, inplace=True)
df_inst_pay_valid_filter =(df_inst_pay["AMT_PAYMENT"] > 0)|(df_inst_pay["AMT_INSTALMENT"] > 0)
print(f"Remove {(~df_inst_pay_valid_filter ).sum() :d} invalid records.")
df_inst_pay_group = df_inst_pay[df_inst_pay_valid_filter].groupby(["SK_ID_PREV", "NUM_INSTALMENT_NUMBER",
"DAYS_ENTRY_PAYMENT", "AMT_PAYMENT"])
del df_inst_pay_valid_filter
print("Aggregate multiple installments for one payment")
df_inst_pay_group_cnt = df_inst_pay_group.size()
df_inst_agg = flatten_agg_df_columns(df_inst_pay_group.agg({
"SK_ID_CURR": ["min", "max"],
"NUM_INSTALMENT_VERSION": ["max", "nunique"],
"DAYS_INSTALMENT": ["min", "max"],
"AMT_INSTALMENT": ["min", "max", "sum"]
}))
del df_inst_pay_group
print("Processing 1")
assert(df_inst_agg["SK_ID_CURR_MIN"] == df_inst_agg["SK_ID_CURR_MAX"] ).all(axis=None), "Inconsistent SK_ID_CURR"
df_inst_pay_processed = pd.DataFrame(index=df_inst_agg.index)
df_inst_pay_processed["SK_ID_CURR"] = df_inst_agg["SK_ID_CURR_MIN"]
df_inst_pay_group_cnt_distict = df_inst_agg["NUM_INSTALMENT_VERSION_NUNIQUE"]
df_inst_pay_group_check =(( df_inst_pay_group_cnt == 2)|
(df_inst_pay_group_cnt_distict == 1))
assert df_inst_pay_group_check.all(axis=None)
del df_inst_pay_group_cnt, df_inst_pay_group_check
df_inst_pay_processed["NUM_INSTALMENT_VERSION"] = df_inst_agg["NUM_INSTALMENT_VERSION_MAX"]
assert(df_inst_agg["DAYS_INSTALMENT_MIN"] == df_inst_agg["DAYS_INSTALMENT_MAX"] ).all(axis=None)
df_inst_pay_processed["DAYS_INSTALMENT"] = df_inst_agg["DAYS_INSTALMENT_MIN"]
df_agg_filter =(df_inst_pay_group_cnt_distict == 2)
assert(df_agg_filter |(df_inst_agg["AMT_INSTALMENT_MIN"] == df_inst_agg["AMT_INSTALMENT_MAX"])).all(axis=None)
df_inst_pay_processed["AMT_INSTALMENT"] = df_inst_agg["AMT_INSTALMENT_MIN"]
df_inst_pay_processed.loc[df_agg_filter, "AMT_INSTALMENT"] = df_inst_agg["AMT_INSTALMENT_SUM"]
print("%d payments aggregated" % df_agg_filter.sum())
del df_inst_pay_group_cnt_distict, df_agg_filter
df_inst_pay_processed.reset_index(inplace=True)
df_inst_pay_processed["DAYS_ENTRY_PAYMENT"] = df_inst_pay_processed["DAYS_ENTRY_PAYMENT"].astype(np.float16,
copy=False)
df_inst_pay_processed["AMT_PAYMENT"] = df_inst_pay_processed["AMT_PAYMENT"].astype(np.float32, copy=False)
df_inst_pay_processed["AMT_PAYMENT"].replace(-1, -np.inf, inplace=True)
assert(( df_inst_pay_processed["AMT_PAYMENT"] >= 0)|
(df_inst_pay_processed["DAYS_ENTRY_PAYMENT"] == 0)).all(axis=None)
df_diff_entry_offset = df_inst_pay_processed["DAYS_ENTRY_PAYMENT"] - df_inst_pay_processed["DAYS_INSTALMENT"]
df_inst_pay_processed["AMT_DUE_PAYMENT"] =(np.fmax(df_inst_pay_processed["AMT_PAYMENT"], 0)*
(df_diff_entry_offset <= 0))
df_inst_pay_processed["AMT_DUE30_PAYMENT"] =(np.fmax(df_inst_pay_processed["AMT_PAYMENT"], 0)*
(df_diff_entry_offset <= 30))
df_inst_pay_group = df_inst_pay_processed.groupby(["SK_ID_PREV", "NUM_INSTALMENT_NUMBER", "NUM_INSTALMENT_VERSION"])
del df_diff_entry_offset, df_inst_pay_processed, df_inst_agg
print("Aggregate multiple payments for one installment")
df_inst_pay_group_cnt = df_inst_pay_group.size()
df_inst_agg = flatten_agg_df_columns(df_inst_pay_group.agg({
"SK_ID_CURR": ["min", "max"],
"DAYS_INSTALMENT": ["min", "max"],
"DAYS_ENTRY_PAYMENT": ["min", "max"],
"AMT_INSTALMENT": ["min", "max", "sum"],
"AMT_PAYMENT": ["sum"],
"AMT_DUE_PAYMENT": ["sum"],
"AMT_DUE30_PAYMENT": ["sum"]
}, skipna=False))
del df_inst_pay_group
print("Finish aggregations")
gc.collect()
print("Processing 2")
assert(df_inst_agg["SK_ID_CURR_MIN"] == df_inst_agg["SK_ID_CURR_MAX"] ).all() , "Inconsistent SK_ID_CURR"
df_inst_pay_processed = pd.DataFrame(index=df_inst_agg.index)
df_inst_pay_processed["SK_ID_CURR"] = df_inst_agg["SK_ID_CURR_MIN"]
assert(df_inst_agg["DAYS_INSTALMENT_MIN"] ==
df_inst_agg["DAYS_INSTALMENT_MAX"] ).all(axis=None), "Inconsistent DAYS_INSTALMENT"
df_inst_pay_processed["DAYS_INSTALMENT"] = df_inst_agg["DAYS_INSTALMENT_MIN"]
df_inst_pay_processed["DAYS_FIRST_PAYMENT"] = df_inst_agg["DAYS_ENTRY_PAYMENT_MIN"].replace(0, np.nan)
df_inst_pay_processed["DAYS_LAST_PAYMENT"] = df_inst_agg["DAYS_ENTRY_PAYMENT_MAX"].replace(0, np.nan)
assert(df_inst_agg["AMT_INSTALMENT_MIN"] == df_inst_agg["AMT_INSTALMENT_MAX"] ).all(axis=None)
df_inst_pay_processed["AMT_INSTALMENT"] = df_inst_agg["AMT_INSTALMENT_MIN"]
df_inst_pay_invalid_filter =(df_inst_agg["AMT_PAYMENT_SUM"] < 0)
assert(( ~df_inst_pay_invalid_filter)|(df_inst_pay_group_cnt == 1)).all(axis=None)
df_inst_pay_processed["AMT_PAYMENT"] = df_inst_agg["AMT_PAYMENT_SUM"]
df_inst_pay_processed.loc[df_inst_pay_invalid_filter, "AMT_PAYMENT"] = np.nan
assert(df_inst_pay_processed["AMT_PAYMENT"] != 0 ).all(axis=None)
df_inst_pay_invalid_filter = df_inst_pay_processed["AMT_PAYMENT"].isnull()
df_inst_pay_processed["NUM_PAYMENTS"] = df_inst_pay_group_cnt.astype(np.uint16)
df_inst_pay_processed.loc[df_inst_pay_invalid_filter, "NUM_PAYMENTS"] = np.uint16(0)
print("%d installments aggregated" %(df_inst_pay_group_cnt > 1 ).sum())
del df_inst_pay_group_cnt, df_inst_pay_invalid_filter
df_inst_pay_processed["AMT_OVERDUE"] = np.fmax(df_inst_pay_processed["AMT_INSTALMENT"] -
df_inst_agg["AMT_DUE_PAYMENT_SUM"], 0)
df_inst_pay_processed["AMT_OVERDUE"] *=(df_inst_pay_processed["AMT_OVERDUE"] >= 0.01)
df_inst_pay_processed["AMT_DPD30"] = np.fmax(df_inst_pay_processed["AMT_INSTALMENT"] -
df_inst_agg["AMT_DUE30_PAYMENT_SUM"], 0)
df_inst_pay_processed["AMT_DPD30"] *=(df_inst_pay_processed["AMT_DPD30"] >= 0.01)
df_inst_pay_processed["AMT_UNPAID"] = np.fmax(df_inst_pay_processed["AMT_INSTALMENT"] -
df_inst_pay_processed["AMT_PAYMENT"].fillna(0), 0)
df_inst_pay_processed["AMT_UNPAID"] *=(df_inst_pay_processed["AMT_UNPAID"] >= 0.01)
df_inst_pay_processed.reset_index(inplace=True)
del df_inst_agg
print("Finish processing")
output_columns = ["SK_ID_PREV", "SK_ID_CURR", "NUM_INSTALMENT_VERSION", "NUM_INSTALMENT_NUMBER",
"DAYS_INSTALMENT", "DAYS_FIRST_PAYMENT", "DAYS_LAST_PAYMENT", "NUM_PAYMENTS",
"AMT_INSTALMENT", "AMT_PAYMENT", "AMT_OVERDUE", "AMT_DPD30", "AMT_UNPAID"]
df_inst_pay_processed.drop(df_inst_pay_processed.columns.drop(output_columns), axis=1, inplace=True)
print("Finish cleaning installment payment data")
return df_inst_pay_processed
def merge_payment_info() :
df_inst_pay = load_install_payments()
df_pos = load_pos_balance()
df_inst_pay["MONTHS_BALANCE"] = df_inst_pay["DAYS_INSTALMENT"] // 30
df_pos.set_index(["SK_ID_PREV", "MONTHS_BALANCE"], inplace=True, drop=True)
df_merged = df_inst_pay.join(df_pos, on=["SK_ID_PREV", "MONTHS_BALANCE"], how="outer", rsuffix="_POS")
t = df_merged[(df_merged.NAME_CONTRACT_STATUS != "Active")& df_merged.SK_ID_CURR.notnull() ]
return t | Home Credit Default Risk |
4,870,466 | index = 'Fuel Oil<feature_engineering> | def group_values(col_orig, new_col_values):
return pd.DataFrame({col: col_orig.isin(values)for col, values in new_col_values})
def get_preprocessed_bureau_data() :
df_bureau = load_bureau()
df_bureau_balance = load_bureau_balance()
df_bureau_balance["STATUS"] = df_bureau_balance["STATUS"].cat.codes - 1
df_bureau_balance["HAS_OVERDUE"] = df_bureau_balance["STATUS"] > 0
df_bureau_balance_agg = df_bureau_balance.groupby("SK_ID_BUREAU" ).agg({
"HAS_OVERDUE": ["sum"],
"STATUS": ["max"]
})
df_bureau_balance_agg.columns = ["CNT_OVERDUE", "MAX_OVERDUE_TIME"]
df_bureau = df_bureau.join(df_bureau_balance_agg)
df_bureau["CNT_OVERDUE"].where(df_bureau["CNT_OVERDUE"] > 0,
df_bureau["AMT_CREDIT_MAX_OVERDUE"].gt(0 ).astype(np.uint8, copy=False),
inplace=True)
df_bureau.loc[df_bureau["DAYS_ENDDATE_FACT"].isna() &(df_bureau["AMT_CREDIT_SUM_DEBT"] == 0)&
(df_bureau["DAYS_CREDIT_ENDDATE"] < 0), "DAYS_ENDDATE_FACT"] = df_bureau["DAYS_CREDIT_ENDDATE"]
df_bureau["DURATION"] = df_bureau["DAYS_ENDDATE_FACT"].fillna(0)- df_bureau["DAYS_CREDIT"]
df_bureau["CLOSE_DURATION_RATIO"] =(( df_bureau["DAYS_ENDDATE_FACT"] - df_bureau["DAYS_CREDIT"])/
(df_bureau["DAYS_CREDIT_ENDDATE"] - df_bureau["DAYS_CREDIT"]))
bureau_groups = df_bureau.groupby("SK_ID_CURR")
df_bureau_agg = flatten_agg_df_columns(bureau_groups.agg({
"CNT_OVERDUE": ["sum"],
"DURATION": ["sum"],
"AMT_CREDIT_MAX_OVERDUE": ["max"],
"AMT_CREDIT_SUM_OVERDUE": ["max", "sum"],
"DAYS_CREDIT": ["min", "max"],
"CREDIT_DAY_OVERDUE": ["max", "mean"],
"MAX_OVERDUE_TIME": ["max"],
"AMT_CREDIT_SUM": ["max", "mean", "sum"],
"AMT_CREDIT_SUM_DEBT": ["max", "mean", "sum"],
"CNT_CREDIT_PROLONG": ["max"],
"DURATION": ["sum"],
"DAYS_ENDDATE_FACT": ["max"],
"CLOSE_DURATION_RATIO": ["min", "max", "mean"]
}), "BUREAU")
df_bureau_agg["BUREAU_OVERDUE_FREQ"] = df_bureau_agg["BUREAU_CNT_OVERDUE_SUM"] / df_bureau_agg["BUREAU_DURATION_SUM"]
df_bureau_agg["BUREAU_LOAN_CNT"] = bureau_groups.size()
bureau_active_groups = df_bureau[df_bureau.CREDIT_ACTIVE == "Active"].groupby("SK_ID_CURR")
df_bureau_active_agg = flatten_agg_df_columns(bureau_active_groups.agg({
"DAYS_CREDIT_ENDDATE": ["max"],
"AMT_ANNUITY": ["sum"]
}), "BUREAU_ACTIVE")
df_bureau_agg = df_bureau_agg.join(df_bureau_active_agg, how="left")
df_bureau_agg.fillna({
"BUREAU_AMT_CREDIT_MAX_OVERDUE_MAX": 0,
"BUREAU_AMT_CREDIT_SUM_DEBT_SUM": 0,
"BUREAU_ACTIVE_AMT_CREDIT_SUM_DEBT_SUM": 0,
}, inplace=True)
del df_bureau, df_bureau_balance
return df_bureau_agg | Home Credit Default Risk |
4,870,466 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | def get_preprocessed_data(impute=True, random_seed=None):
print("Reading data")
df_app_train, df_app_test = load_app_data()
print("Finish reading data")
print("Preprocess training data")
df_bureau_agg = None
df_prev_app_agg = None
df_bureau_agg = get_preprocessed_bureau_data()
print("Finish preprocessing bureau data")
df_prev_app_agg = get_preprocessed_previous_app_data(True, True)
print("Finish preprocessing previous application data")
df_app_train = shuffle(df_app_train, random_state=random_seed)
transformers = dict()
X_train = preprocess_app(transformers, df_app_train, df_bureau_agg, df_prev_app_agg, impute=impute)
y_train = df_app_train["TARGET"]
print("Finish preprocessing application data")
print("Preprocess test data")
X_test = preprocess_app(transformers, df_app_test, df_bureau_agg, df_prev_app_agg, impute=impute)
print("Training data shape:", X_train.shape)
X_train.info(verbose=5)
return X_train, y_train, X_test
X_train, y_train, X_test = get_preprocessed_data(PERFORM_IMPUTATION, RANDOM_SEED ) | Home Credit Default Risk |
4,870,466 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | def build_model_and_classify(X_train, y_train, X_test=None, classifier="xgb", early_stopping=True,
cv=CROSS_VALIDATION_FOLD, tune_param=False, random_seed=None,
output_path="submission.csv"):
print("Initializing classifier")
if classifier == "xgb":
if tune_param:
clf = XGBClassifier(seed=random_seed, tree_method="gpu_hist")
else:
clf = XGBClassifier(n_estimators=2000, min_child_weight=32, max_depth=6,
min_split_loss=0.08, learning_rate=0.1,
reg_lambda=1, reg_alpha=0.6,
scale_pos_weight=3,
seed=random_seed, tree_method="gpu_hist")
elif classifier == "lgbm":
clf = LGBMClassifier(
boosting_type="goss", n_estimators=1000, learning_rate=0.00513,
num_leaves=54, max_depth=10, subsample_for_bin=240000,
reg_alpha=0.436193, reg_lambda=0.479169,
min_split_gain=0.025, colsample_bytree=0.52,
subsample=1,
silent=-1, verbose=-1
)
else:
raise ValueError("Unsupported classifier: " + classifier)
if early_stopping:
fit_orig = clf.fit
VALIDATION_SIZE = 0.1
def fit_wrapped(X, y, **kwargs):
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=VALIDATION_SIZE)
fit_orig(X_train, y_train, eval_set=[(X_val, y_val)],
early_stopping_rounds=50, eval_metric="auc")
clf.fit = fit_wrapped
if cv > 0:
if tune_param:
print("Tuning classifier parameters")
params = {
"n_estimators": [200, 400],
"max_depth": [6, 8],
"max_leaves": [64, 128],
"min_child_weight": [24, 32],
"min_split_loss": [0.02 *(1 << n)for n in range(6)],
"learning_rate": [0.06 + 0.02 *(1 << n)for n in range(1, 4)],
"reg_lambda": [0.2 * n for n in range(6)],
"reg_alpha": [0.2 * n for n in range(6)],
"scale_pos_weight": [1, 3, 5]
}
model_selection_task = RandomizedSearchCV(clf, params, n_iter=50, scoring="roc_auc",
cv=cv, n_jobs=5, verbose=5)
global results
results = model_selection_task.fit(X_train, y_train)
print(f"Best score: {results.best_score_}")
print(f"Best parameters: {results.best_params_}")
print(f"CV results: {results.cv_results_}")
clf = results.best_estimator_
else:
print(f"Perform {cv:d}-fold cross validation")
score_val = sum(cross_val_score(clf, X_train, y_train,
cv=cv, scoring="roc_auc", verbose=10, n_jobs=5)) / cv
print("Validation AUC: %.6f" % score_val)
else:
test_size = 0.1
print(f"Perform hold-out validation(Test size: {test_size:.0%})")
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=test_size, random_state=random_seed)
clf.fit(X_train, y_train)
prob_val = clf.predict_proba(X_val)[:, 1]
score_val = roc_auc_score(y_val, prob_val)
print("Validation AUC: %.6f" % score_val)
if X_test is None:
return
print("Training classifier")
clf.fit(X_train, y_train)
print("Classify training and test set")
test_prob_df = pd.DataFrame(clf.predict_proba(X_test)[:, 1], index=X_test.index, columns=["TARGET"])
test_prob_df.to_csv(output_path)
print("Finished classifying" ) | Home Credit Default Risk |
4,870,466 | intervalo_valores(df_train[index] )<define_variables> | build_model_and_classify(X_train, y_train, X_test, "lgbm", cv=CROSS_VALIDATION_FOLD, tune_param=True,
random_seed=RANDOM_SEED, output_path="submission_lgbm.csv" ) | Home Credit Default Risk |
4,870,466 | index = 'Fuel Oil<feature_engineering> | build_model_and_classify(X_train, y_train, X_test, tune_param=True, random_seed=RANDOM_SEED,
output_path="submission_xgb.csv" ) | Home Credit Default Risk |
4,870,466 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | df_result = pd.DataFrame.from_records(results.cv_results_["params"])
df_result["rank"] = results.cv_results_["rank_test_score"]
df_result["score"] = results.cv_results_["mean_test_score"]
df_result.sort_values(by="rank", inplace=True)
df_result | Home Credit Default Risk |
4,870,466 | <compute_test_metric><EOS> | for c in df_result.columns[:-2]:
print(df_result.groupby(c)["score"].mean().sort_values() ) | Home Credit Default Risk |
1,245,855 | <SOS> metric: AUC Kaggle data source: home-credit-default-risk<define_variables> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import gc
import xgboost as xgb
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split | Home Credit Default Risk |
1,245,855 | index = 'Diesel<feature_engineering> | def bureau_balance_preprocess() :
bureau = pd.read_csv(".. /input/bureau.csv")
balance = pd.read_csv(".. /input/bureau_balance.csv")
cat_cols = []
for i in balance.columns.values:
if balance[i].dtype == 'object':
cat_cols.append(i)
num_cols = [col for col in balance.columns if col not in cat_cols][1:]
balance = pd.get_dummies(balance, columns = ['STATUS'])
cat_cols = [c for c in balance.columns.tolist() if c not in [cat_cols, num_cols]][2:]
cat_aggs = {}
num_aggs = {}
for i in cat_cols:
cat_aggs[i] = ['mean']
for j in num_cols:
num_aggs[j] = ['size']
balance = balance.groupby('SK_ID_BUREAU' ).agg({**num_aggs, **cat_aggs})
balance.columns = [i[0] + "_" + i[1]for i in balance.columns.tolist() ]
balance.reset_index(inplace = True)
cat_cols = []
for i in bureau.columns.values:
if bureau[i].dtype == 'object':
cat_cols.append(i)
num_cols = [col for col in bureau.columns if col not in cat_cols]
bureau = pd.get_dummies(bureau, columns = cat_cols)
df = bureau.merge(balance, how='left', on='SK_ID_BUREAU')
df.drop(['SK_ID_BUREAU'], axis = 1, inplace = True)
aggregations = {}
for i in df.columns.tolist() [1:]:
aggregations[i] = ['min', 'max', 'mean', 'median', 'var', 'size']
df = df.groupby('SK_ID_CURR' ).agg(aggregations)
df.columns = [i[0] + "_" + i[1]for i in df.columns.tolist() ]
df = df.reset_index()
return df | Home Credit Default Risk |
1,245,855 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | def prev_application() :
df = pd.read_csv(".. /input/previous_application.csv")
df.loc[df['AMT_CREDIT'] > 6000000, 'AMT_CREDIT'] = np.nan
df.loc[df['SELLERPLACE_AREA'] > 3500000, 'SELLERPLACE_AREA'] = np.nan
df['DAYS_FIRST_DRAWING'].replace(365243, np.nan, inplace= True)
df['DAYS_FIRST_DUE'].replace(365243, np.nan, inplace= True)
df['DAYS_LAST_DUE_1ST_VERSION'].replace(365243, np.nan, inplace= True)
df['DAYS_LAST_DUE'].replace(365243, np.nan, inplace= True)
df['DAYS_TERMINATION'].replace(365243, np.nan, inplace= True)
df['prev missing'] = df.isnull().sum(axis = 1 ).values
df['prev AMT_APPLICATION / AMT_CREDIT'] = df['AMT_APPLICATION'] / df['AMT_CREDIT']
df['prev AMT_APPLICATION - AMT_CREDIT'] = df['AMT_APPLICATION'] - df['AMT_CREDIT']
df['prev AMT_APPLICATION - AMT_GOODS_PRICE'] = df['AMT_APPLICATION'] - df['AMT_GOODS_PRICE']
df['prev AMT_GOODS_PRICE - AMT_CREDIT'] = df['AMT_GOODS_PRICE'] - df['AMT_CREDIT']
df['prev DAYS_FIRST_DRAWING - DAYS_FIRST_DUE'] = df['DAYS_FIRST_DRAWING'] - df['DAYS_FIRST_DUE']
df['prev DAYS_TERMINATION less -500'] =(df['DAYS_TERMINATION'] < -500 ).astype(int)
df.rename(columns = lambda x : 'PREV_' + x if x not in ['SK_ID_PREV', 'SK_ID_CURR'] else x, inplace = True)
cat_cols = []
for i in df.columns.values:
if df[i].dtype == 'object':
cat_cols.append(i)
num_cols = [col for col in df.columns[2:] if col not in cat_cols]
df = pd.get_dummies(df, columns = cat_cols)
new_cat_cols = [c for c in df.columns.tolist() if c not in [cat_cols, num_cols]][2:]
cat_aggs = {}
num_aggs = {}
for i in new_cat_cols:
cat_aggs[i] = ['mean']
for j in num_cols:
num_aggs[j] = ['min', 'max', 'mean', 'median', 'var', 'size']
df.drop(['SK_ID_PREV'], axis = 1, inplace = True)
df = df.groupby('SK_ID_CURR' ).agg({**num_aggs, **cat_aggs})
df.columns = [i[0] + "_" + i[1]for i in df.columns.tolist() ]
return df.reset_index() | Home Credit Default Risk |
1,245,855 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | def posh_cash_balance() :
df = pd.read_csv(".. /input/POS_CASH_balance.csv")
df.loc[df['CNT_INSTALMENT_FUTURE'] > 60, 'CNT_INSTALMENT_FUTURE'] = np.nan
df.drop(['SK_ID_PREV'], axis = 1, inplace = True)
df['pos CNT_INSTALMENT more CNT_INSTALMENT_FUTURE'] = \
(df['CNT_INSTALMENT'] > df['CNT_INSTALMENT_FUTURE'] ).astype(int)
cat_cols = []
for i in df.columns.values:
if df[i].dtype == 'object':
cat_cols.append(i)
num_cols = [c for c in df.columns.tolist() if c not in cat_cols][1:]
df = pd.get_dummies(df, columns = ['NAME_CONTRACT_STATUS'])
cat_cols = [c for c in df.columns.tolist() if c not in [cat_cols, num_cols]][1:]
cat_aggs = {}
num_aggs = {}
for i in cat_cols:
cat_aggs[i] = ['mean']
for j in num_cols:
num_aggs[j] = ['min', 'max', 'mean', 'median', 'var', 'size']
df = df.groupby('SK_ID_CURR' ).agg({**num_aggs, **cat_aggs})
df.columns = [i[0] + "_" + i[1]for i in df.columns.tolist() ]
df.reset_index(inplace = True)
df['CNT_INSTALMENT_RATIO'] = df['CNT_INSTALMENT_mean'] / df['MONTHS_BALANCE_mean']
df['CNT_INSTALMENT_FUTURE_RATIO'] = df['CNT_INSTALMENT_FUTURE_mean'] / df['MONTHS_BALANCE_mean']
df['CNT_INSTALMENT_SUM_RATIO'] =(df['CNT_INSTALMENT_mean'] + df['CNT_INSTALMENT_FUTURE_mean'])/ df['MONTHS_BALANCE_mean']
return df | Home Credit Default Risk |
1,245,855 | intervalo_valores(df_train[index] )<define_variables> | def cc_balance() :
df = pd.read_csv(".. /input/credit_card_balance.csv")
df.loc[df['AMT_PAYMENT_CURRENT'] > 4000000, 'AMT_PAYMENT_CURRENT'] = np.nan
df.loc[df['AMT_CREDIT_LIMIT_ACTUAL'] > 1000000, 'AMT_CREDIT_LIMIT_ACTUAL'] = np.nan
df['card missing'] = df.isnull().sum(axis = 1 ).values
df['card SK_DPD - MONTHS_BALANCE'] = df['SK_DPD'] - df['MONTHS_BALANCE']
df['card SK_DPD_DEF - MONTHS_BALANCE'] = df['SK_DPD_DEF'] - df['MONTHS_BALANCE']
df['card SK_DPD - SK_DPD_DEF'] = df['SK_DPD'] - df['SK_DPD_DEF']
df['card AMT_TOTAL_RECEIVABLE - AMT_RECIVABLE'] = df['AMT_TOTAL_RECEIVABLE'] - df['AMT_RECIVABLE']
df['card AMT_TOTAL_RECEIVABLE - AMT_RECEIVABLE_PRINCIPAL'] = df['AMT_TOTAL_RECEIVABLE'] - df['AMT_RECEIVABLE_PRINCIPAL']
df['card AMT_RECIVABLE - AMT_RECEIVABLE_PRINCIPAL'] = df['AMT_RECIVABLE'] - df['AMT_RECEIVABLE_PRINCIPAL']
df['card AMT_BALANCE - AMT_RECIVABLE'] = df['AMT_BALANCE'] - df['AMT_RECIVABLE']
df['card AMT_BALANCE - AMT_RECEIVABLE_PRINCIPAL'] = df['AMT_BALANCE'] - df['AMT_RECEIVABLE_PRINCIPAL']
df['card AMT_BALANCE - AMT_TOTAL_RECEIVABLE'] = df['AMT_BALANCE'] - df['AMT_TOTAL_RECEIVABLE']
df['card AMT_DRAWINGS_CURRENT - AMT_DRAWINGS_ATM_CURRENT'] = df['AMT_DRAWINGS_CURRENT'] - df['AMT_DRAWINGS_ATM_CURRENT']
df['card AMT_DRAWINGS_CURRENT - AMT_DRAWINGS_OTHER_CURRENT'] = df['AMT_DRAWINGS_CURRENT'] - df['AMT_DRAWINGS_OTHER_CURRENT']
df['card AMT_DRAWINGS_CURRENT - AMT_DRAWINGS_POS_CURRENT'] = df['AMT_DRAWINGS_CURRENT'] - df['AMT_DRAWINGS_POS_CURRENT']
df.rename(columns = lambda x : 'PREV_' + x if x not in ['SK_ID_PREV', 'SK_ID_CURR'] else x, inplace = True)
cat_cols = []
for i in df.columns.values:
if df[i].dtype == 'object':
cat_cols.append(i)
num_cols = [col for col in df.columns[2:] if col not in cat_cols]
df = pd.get_dummies(df, columns = cat_cols)
new_cat_cols = [c for c in df.columns.tolist() if c not in [cat_cols, num_cols]][2:]
cat_aggs = {}
num_aggs = {}
for i in new_cat_cols:
cat_aggs[i] = ['mean']
for j in num_cols:
num_aggs[j] = ['min', 'max', 'mean', 'median', 'var', 'size']
df.drop(['SK_ID_PREV'], axis = 1, inplace = True)
df = df.groupby('SK_ID_CURR' ).agg({**num_aggs, **cat_aggs})
df.columns = [i[0] + "_" + i[1]for i in df.columns.tolist() ]
return df.reset_index() | Home Credit Default Risk |
1,245,855 | index = 'District Steam Use(kBtu)'<feature_engineering> | def installments() :
df = pd.read_csv(".. /input/installments_payments.csv")
df.loc[df['NUM_INSTALMENT_VERSION'] > 70, 'NUM_INSTALMENT_VERSION'] = np.nan
df.loc[df['DAYS_ENTRY_PAYMENT'] < -4000, 'DAYS_ENTRY_PAYMENT'] = np.nan
df['ins DAYS_ENTRY_PAYMENT - DAYS_INSTALMENT'] = df['DAYS_ENTRY_PAYMENT'] - df['DAYS_INSTALMENT']
df['ins NUM_INSTALMENT_NUMBER_100'] =(df['NUM_INSTALMENT_NUMBER'] == 100 ).astype(int)
df['ins DAYS_INSTALMENT more NUM_INSTALMENT_NUMBER'] =(df['DAYS_INSTALMENT'] > df['NUM_INSTALMENT_NUMBER'] * 50 / 3 - 11500 / 3 ).astype(int)
df['ins AMT_INSTALMENT - AMT_PAYMENT'] = df['AMT_INSTALMENT'] - df['AMT_PAYMENT']
df['ins AMT_PAYMENT / AMT_INSTALMENT'] = df['AMT_PAYMENT'] / df['AMT_INSTALMENT']
df.drop([])
df.rename(columns = lambda x : 'PREV_' + x if x not in ['SK_ID_PREV', 'SK_ID_CURR'] else x, inplace = True)
cat_cols = []
for i in df.columns.values:
if df[i].dtype == 'object':
cat_cols.append(i)
num_cols = [col for col in df.columns[2:] if col not in cat_cols]
df = pd.get_dummies(df, columns = cat_cols)
new_cat_cols = [c for c in df.columns.tolist() if c not in [cat_cols, num_cols]][2:]
cat_aggs = {}
num_aggs = {}
for i in new_cat_cols:
cat_aggs[i] = ['mean']
for j in num_cols:
num_aggs[j] = ['min', 'max', 'mean', 'median', 'var', 'size']
df.drop(['SK_ID_PREV'], axis = 1, inplace = True)
df = df.groupby('SK_ID_CURR' ).agg({**num_aggs, **cat_aggs})
df.columns = [i[0] + "_" + i[1]for i in df.columns.tolist() ]
return df.reset_index() | Home Credit Default Risk |
1,245,855 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | def get_beautiful_data() :
print('Getting train data...')
train = pd.read_csv(".. /input/application_train.csv")
print('Getting test data...')
test = pd.read_csv(".. /input/application_test.csv")
y = train.pop('TARGET')
index_end = y.shape[0]
test_index = test.pop('SK_ID_CURR')
cat_cols = []
for i in train.columns.values:
if train[i].dtype == 'object':
cat_cols.append(i)
num_cols = [col for col in train.columns if col not in cat_cols]
print('Merging train and tests data...')
df = pd.concat([train, test], axis = 0, ignore_index = True)
del train, test
gc.collect()
print('Merge complete.')
print('Fetching bureau and balance data...')
bureau = bureau_balance_preprocess()
print('Merging to main data frame...')
df = df.merge(bureau, how = 'left', on = 'SK_ID_CURR')
del bureau
gc.collect()
print('Merge complete.')
print('Fetching previous_application data...')
prev = prev_application()
print('Merging to main data frame...')
df = df.merge(prev, how = 'left', on = 'SK_ID_CURR')
del prev
gc.collect()
print('Merge complete.')
print('Fetching POS_CASH_balance data...')
pos = posh_cash_balance()
print('Merging to main data frame...')
df = df.merge(pos, how = 'left', on = 'SK_ID_CURR')
del pos
gc.collect()
print('Merge complete.')
print('Fetching credit_card_balance data...')
cc = cc_balance()
print('Merging to main data frame...')
df = df.merge(cc, how = 'left', on = 'SK_ID_CURR')
del cc
gc.collect()
print('Merge complete.')
print('Fetching installments_payments data...')
inst = installments()
print('Merging to main data frame...')
df = df.merge(inst, how = 'left', on = 'SK_ID_CURR')
del inst
gc.collect()
print('Merge complete')
docs = [_f for _f in df.columns if 'FLAG_DOC' in _f]
live = [_f for _f in df.columns if('FLAG_' in _f)&('FLAG_DOC' not in _f)&('_FLAG_' not in _f)]
print('Adding more features...')
df['DAYS_EMPLOYED'].replace(365243, np.nan, inplace= True)
df['NEW_CREDIT_TO_ANNUITY_RATIO'] = df['AMT_CREDIT'] / df['AMT_ANNUITY']
df['NEW_CREDIT_TO_GOODS_RATIO'] = df['AMT_CREDIT'] / df['AMT_GOODS_PRICE']
df['NEW_DOC_IND_KURT'] = df[docs].kurtosis(axis=1)
df['NEW_LIVE_IND_SUM'] = df[live].sum(axis=1)
df['NEW_INC_PER_CHLD'] = df['AMT_INCOME_TOTAL'] /(1 + df['CNT_CHILDREN'])
df['NEW_EMPLOY_TO_BIRTH_RATIO'] = df['DAYS_EMPLOYED'] / df['DAYS_BIRTH']
df['NEW_ANNUITY_TO_INCOME_RATIO'] = df['AMT_ANNUITY'] /(1 + df['AMT_INCOME_TOTAL'])
df['NEW_SOURCES_PROD'] = df['EXT_SOURCE_1'] * df['EXT_SOURCE_2'] * df['EXT_SOURCE_3']
df['NEW_EXT_SOURCES_MEAN'] = df[['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3']].mean(axis=1)
df['NEW_SCORES_STD'] = df[['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3']].std(axis=1)
df['NEW_SCORES_STD'] = df['NEW_SCORES_STD'].fillna(df['NEW_SCORES_STD'].mean())
df['NEW_CAR_TO_BIRTH_RATIO'] = df['OWN_CAR_AGE'] / df['DAYS_BIRTH']
df['NEW_CAR_TO_EMPLOY_RATIO'] = df['OWN_CAR_AGE'] / df['DAYS_EMPLOYED']
df['NEW_PHONE_TO_BIRTH_RATIO'] = df['DAYS_LAST_PHONE_CHANGE'] / df['DAYS_BIRTH']
df['NEW_PHONE_TO_BIRTH_RATIO'] = df['DAYS_LAST_PHONE_CHANGE'] / df['DAYS_EMPLOYED']
df['NEW_CREDIT_TO_INCOME_RATIO'] = df['AMT_CREDIT'] / df['AMT_INCOME_TOTAL']
df['DAYS_EMPLOYED_PERC'] = df['DAYS_EMPLOYED'] / df['DAYS_BIRTH']
df['INCOME_CREDIT_PERC'] = df['AMT_INCOME_TOTAL'] / df['AMT_CREDIT']
df['INCOME_PER_PERSON'] = df['AMT_INCOME_TOTAL'] / df['CNT_FAM_MEMBERS']
df['ANNUITY_INCOME_PERC'] = df['AMT_ANNUITY'] / df['AMT_INCOME_TOTAL']
df['PAYMENT_RATE'] = df['AMT_ANNUITY'] / df['AMT_CREDIT']
print('Done.')
df = pd.get_dummies(df, columns = cat_cols, dummy_na= True)
X = df.iloc[:index_end, 1:]
X_test = df.iloc[index_end:, 1:]
scale_pos_weight = y.value_counts() [0]/ y.value_counts() [1]
X, X_test = X.align(X_test, join = 'inner', axis = 1)
return X, X_test, y, scale_pos_weight, test_index | Home Credit Default Risk |
1,245,855 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | X, X_test, y, scale_pos_weight, test_index = get_beautiful_data() | Home Credit Default Risk |
1,245,855 | intervalo_valores(df_train[index] )<define_variables> | upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1 ).astype(np.bool))
upper.head() | Home Credit Default Risk |
1,245,855 | index = 'Natural Gas Use(kBtu)'<feature_engineering> | to_drop = [column for column in upper.columns if any(upper[column] > threshold)]
print('There are %d columns to remove.' %(len(to_drop)) ) | Home Credit Default Risk |
1,245,855 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | X = X.drop(columns = to_drop)
X_test = X_test.drop(columns = to_drop)
print('Training shape: ', X.shape)
print('Testing shape: ', X_test.shape ) | Home Credit Default Risk |
1,245,855 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | train_missing =(X.isnull().sum() / len(X)).sort_values(ascending = False)
train_missing.head() | Home Credit Default Risk |
1,245,855 | intervalo_valores(df_train[index] )<define_variables> | test_missing =(X_test.isnull().sum() / len(X_test)).sort_values(ascending = False)
test_missing.head() | Home Credit Default Risk |
1,245,855 | index = 'Weather Normalized Site Natural Gas Use(therms)'<feature_engineering> | train_missing = train_missing.index[train_missing > 0.75]
test_missing = test_missing.index[test_missing > 0.75]
all_missing = list(set(set(train_missing)| set(test_missing)))
print('There are %d columns with more than 75%% missing values' % len(all_missing)) | Home Credit Default Risk |
1,245,855 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | X = X.drop(columns = all_missing)
X_test = X_test.drop(columns = all_missing)
print('Training shape: ', X.shape)
print('Testing shape: ', X_test.shape ) | Home Credit Default Risk |
1,245,855 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | clf = xgb.XGBClassifier(learning_rate = 0.025,
n_estimators = 10000,
max_depth = 8,
min_child_weight = 1,
subsample = 0.8,
colsample_bytree = 0.7,
colsample_bylevel = 0.7,
objective = 'binary:logistic',
n_jobs = -1,
scale_pos_weight = scale_pos_weight,
silent = True ) | Home Credit Default Risk |
1,245,855 | intervalo_valores(df_train[index] )<define_variables> | X_train, X_val, y_train, y_val = train_test_split(X, y, test_size = 0.2, random_state = 42 ) | Home Credit Default Risk |
1,245,855 | index = 'Electricity Use - Grid Purchase(kBtu)'<feature_engineering> | clf.fit(X_train, y_train, eval_set = [(X_train, y_train),(X_val, y_val)], eval_metric= 'auc', verbose= 100, early_stopping_rounds= 400 ) | Home Credit Default Risk |
1,245,855 | <data_type_conversions><EOS> | result = clf.predict_proba(X_test)
submit = pd.DataFrame({'SK_ID_CURR': test_index, 'TARGET': result[:, 1]})
submit.to_csv('solution.csv', index = False ) | Home Credit Default Risk |
1,537,787 | <SOS> metric: AUC Kaggle data source: home-credit-default-risk<compute_test_metric> | %matplotlib inline
plt.style.use('ggplot')
seed =420
pd.options.display.max_rows = 100 | Home Credit Default Risk |
1,537,787 | intervalo_valores(df_train[index] )<define_variables> | nrows = 100000
path = '.. /input/'
app_train = pd.read_csv(path+'application_train.csv', nrows= nrows)
app_test = pd.read_csv(path+'application_test.csv', nrows= None)
bureau_balance = pd.read_csv(path+'bureau_balance.csv', nrows=nrows)
bureau = pd.read_csv(path+'bureau.csv', nrows=nrows)
installments_payments = pd.read_csv(path+ 'installments_payments.csv', nrows= nrows)
POS_CASH_balance = pd.read_csv(path+ 'POS_CASH_balance.csv', nrows= nrows)
credit_card_balance = pd.read_csv(path+'credit_card_balance.csv',nrows=nrows)
previous_application = pd.read_csv(path+ 'previous_application.csv', nrows= nrows)
gc.collect()
test_index = app_test['SK_ID_CURR'] | Home Credit Default Risk |
1,537,787 | index = 'Weather Normalized Site Electricity(kWh)'<feature_engineering> | def basic_details(df):
k = pd.DataFrame()
k['missing_value'] = df.isnull().sum()
k['%missing_value'] = round(df.isnull().sum() *100/df.shape[0],2)
k['dtypes'] = df.dtypes
k['N unique'] = df.nunique()
return k | Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | def missing_value_fill(df ,columns, mean_or_mode='mode'):
for i in columns:
if(df[i].isnull().sum() >0)and(mean_or_mode =='mode'):
df[i].fillna(df[i].mode() [0], inplace=True)
elif(df[i].isnull().sum() >0)and(mean_or_mode =='mean'):
df[i].fillna(df[i].mean() , inplace=True ) | Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | def replace_XNA_XAP(df):
"Replace XNA,XAP"
df.replace(to_replace = {'XNA':np.nan,'XAP':np.nan},inplace=True,value= None)
return df | Home Credit Default Risk |
1,537,787 | intervalo_valores(df_train[index] )<define_variables> | def one_hot_encoding(df,columns,nan_as_category = True):
print('*'*5,'One hot encoding of categorical variable','*'*5)
print('Original shape',df.shape)
original_columns = df.columns
df = pd.get_dummies(df, columns= columns,drop_first=True,dummy_na=nan_as_category)
new_columns = [i for i in df.columns if i not in original_columns]
print('After OHE',df.shape)
return df,new_columns | Home Credit Default Risk |
1,537,787 | index = 'Total GHG Emissions(Metric Tons CO2e)'<feature_engineering> | def descriptive_stat_feat(df,columns):
print('*'*5,'Descriptive statistics feature','*'*5)
print('Before',df.shape)
mean = df[columns].mean()
median = df[columns].median()
Q1 = np.percentile(df[columns], 25, axis=0)
Q3 = np.percentile(df[columns], 75, axis=0)
for i,j in enumerate(columns):
df['mean_'+j] =(df[j] < mean[i] ).astype('int8')
df['median_'+j] =(df[j] > median[i] ).astype('int8')
df['Q1'+j] =(df[j] < Q1[i] ).astype('int8')
df['Q3'+j] =(df[j] > Q3[i] ).astype('int8')
print('After ',df.shape ) | Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | def binary_encoding(df,columns):
print('*'*5,'Binary encoding','*'*5)
lb = LabelBinarizer()
print('Original shape:',df.shape)
original_col = df.columns
for i in columns:
if df[i].nunique() >2:
result = lb.fit_transform(df[i].fillna(df[i].mode() [0],axis=0))
col = ['BIN_'+ str(i)+'_'+str(c)for c in lb.classes_]
result1 = pd.DataFrame(result, columns=col)
df = df.join(result1)
print('After:',df.shape)
new_col = [c for c in df.columns if c not in original_col]
return df, new_col | Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | test_index = app_test['SK_ID_CURR']
app_train_col_drop = [] | Home Credit Default Risk |
1,537,787 | intervalo_valores(df_train[index] )<define_variables> | print('Count
',app_train['TARGET'].value_counts())
print('%
',app_train['TARGET'].value_counts() *100/app_train.shape[0] ) | Home Credit Default Risk |
1,537,787 | index = 'Direct GHG Emissions(Metric Tons CO2e)'<feature_engineering> | app_train[['NAME_CONTRACT_TYPE', 'CODE_GENDER','FLAG_OWN_CAR', 'FLAG_OWN_REALTY']] = app_train[
['NAME_CONTRACT_TYPE', 'CODE_GENDER','FLAG_OWN_CAR', 'FLAG_OWN_REALTY']].astype('object')
app_test[['NAME_CONTRACT_TYPE', 'CODE_GENDER','FLAG_OWN_CAR', 'FLAG_OWN_REALTY']] = app_test[
['NAME_CONTRACT_TYPE', 'CODE_GENDER','FLAG_OWN_CAR', 'FLAG_OWN_REALTY']].astype('object')
| Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | tmp = app_train['CNT_CHILDREN'].value_counts().to_frame()
tmp['%'] =(app_train['CNT_CHILDREN'].value_counts() *100 / app_train.shape[0])
tmp | Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | app_train['CNT_CHILDREN'] = app_train['CNT_CHILDREN'].astype('object')
app_test['CNT_CHILDREN'] = app_test['CNT_CHILDREN'].astype('object' ) | Home Credit Default Risk |
1,537,787 | intervalo_valores(df_train[index] )<define_variables> | print('Default',app_train[app_train['AMT_INCOME_TOTAL'] >0.2e8]['AMT_INCOME_TOTAL'])
app_train['AMT_INCOME_TOTAL'] = np.log(app_train['AMT_INCOME_TOTAL'])
app_test['AMT_INCOME_TOTAL'] = np.log(app_test['AMT_INCOME_TOTAL'] ) | Home Credit Default Risk |
1,537,787 | index = 'Indirect GHG Emissions(Metric Tons CO2e)'<feature_engineering> | app_train['AMT_CREDIT'] = np.sqrt(app_train['AMT_CREDIT'])
app_test['AMT_CREDIT'] = np.sqrt(app_test['AMT_CREDIT'] ) | Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | app_train['AMT_ANNUITY'] = np.log(app_train['AMT_ANNUITY'])
app_test['AMT_ANNUITY'] = np.log(app_test['AMT_ANNUITY'] ) | Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | app_train[['NAME_TYPE_SUITE', 'NAME_INCOME_TYPE', 'NAME_EDUCATION_TYPE', 'NAME_FAMILY_STATUS',
'NAME_HOUSING_TYPE']] = app_train[['NAME_TYPE_SUITE', 'NAME_INCOME_TYPE', 'NAME_EDUCATION_TYPE',
'NAME_FAMILY_STATUS', 'NAME_HOUSING_TYPE']].astype('object')
app_test[['NAME_TYPE_SUITE', 'NAME_INCOME_TYPE', 'NAME_EDUCATION_TYPE', 'NAME_FAMILY_STATUS',
'NAME_HOUSING_TYPE']] = app_test[['NAME_TYPE_SUITE', 'NAME_INCOME_TYPE', 'NAME_EDUCATION_TYPE',
'NAME_FAMILY_STATUS', 'NAME_HOUSING_TYPE']].astype('object' ) | Home Credit Default Risk |
1,537,787 | intervalo_valores(df_train[index] )<define_variables> | ((app_train['DAYS_EMPLOYED']/-365)[(app_train['DAYS_EMPLOYED']/-365)<0][:5],
app_train['DAYS_EMPLOYED'][app_train['DAYS_EMPLOYED']>0][:5],
app_test['DAYS_EMPLOYED'][app_test['DAYS_EMPLOYED']>0][:5] ) | Home Credit Default Risk |
1,537,787 | index = 'Property GFA - Self-Reported(ft²)'<compute_test_metric> | app_train['DAYS_EMPLOYED'].replace({365243:np.nan},inplace=True)
app_test['DAYS_EMPLOYED'].replace({365243:np.nan},inplace=True ) | Home Credit Default Risk |
1,537,787 | intervalo_valores(df_train[index] )<define_variables> | app_train['OWN_CAR_AGE'] = app_train['OWN_CAR_AGE'].astype('object')
app_test['OWN_CAR_AGE'] = app_test['OWN_CAR_AGE'].astype('object' ) | Home Credit Default Risk |
1,537,787 | index = 'Water Use(All Water Sources )(kgal)'<feature_engineering> | app_train_col_drop.append('FLAG_MOBIL')
app_train_col_drop.append('FLAG_CONT_MOBILE')
app_train_col_drop.append('FLAG_EMAIL')
app_train[['FLAG_EMP_PHONE','FLAG_WORK_PHONE','FLAG_PHONE']] = app_train[[
'FLAG_EMP_PHONE','FLAG_WORK_PHONE','FLAG_PHONE']].astype('object')
app_test[['FLAG_EMP_PHONE','FLAG_WORK_PHONE','FLAG_PHONE']] = app_test[[
'FLAG_EMP_PHONE','FLAG_WORK_PHONE','FLAG_PHONE']].astype('object' ) | Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | app_train['CNT_FAM_MEMBERS'] = app_train['CNT_FAM_MEMBERS'].astype('object')
app_test['CNT_FAM_MEMBERS'] = app_test['CNT_FAM_MEMBERS'].astype('object' ) | Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | app_train[['REGION_RATING_CLIENT','REGION_RATING_CLIENT_W_CITY']] = app_train[[
'REGION_RATING_CLIENT','REGION_RATING_CLIENT_W_CITY']].astype('object')
app_test[['REGION_RATING_CLIENT','REGION_RATING_CLIENT_W_CITY']] = app_test[[
'REGION_RATING_CLIENT','REGION_RATING_CLIENT_W_CITY']].astype('object' ) | Home Credit Default Risk |
1,537,787 | intervalo_valores(df_train[index] )<define_variables> | app_train['WEEKDAY_APPR_PROCESS_START'] = app_train['WEEKDAY_APPR_PROCESS_START'].astype('object')
app_test['WEEKDAY_APPR_PROCESS_START'] = app_test['WEEKDAY_APPR_PROCESS_START'].astype('object' ) | Home Credit Default Risk |
1,537,787 | index = 'Water Intensity(All Water Sources )(gal/ft²)'<feature_engineering> | app_train['HOUR_APPR_PROCESS_START'] = app_train['HOUR_APPR_PROCESS_START'].astype('object')
app_test['HOUR_APPR_PROCESS_START'] = app_test['HOUR_APPR_PROCESS_START'].astype('object' ) | Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].str.replace('Not Available', '0')
df_test[index] = df_test[index].str.replace('Not Available', '0' )<data_type_conversions> | app_train_col_drop.append('REG_REGION_NOT_LIVE_REGION')
app_train[['REG_REGION_NOT_WORK_REGION','LIVE_REGION_NOT_WORK_REGION', 'REG_CITY_NOT_LIVE_CITY',
'REG_CITY_NOT_WORK_CITY', 'LIVE_CITY_NOT_WORK_CITY']] = app_train[['REG_REGION_NOT_WORK_REGION','LIVE_REGION_NOT_WORK_REGION', 'REG_CITY_NOT_LIVE_CITY',
'REG_CITY_NOT_WORK_CITY', 'LIVE_CITY_NOT_WORK_CITY']].astype('object')
app_test[['REG_REGION_NOT_WORK_REGION','LIVE_REGION_NOT_WORK_REGION', 'REG_CITY_NOT_LIVE_CITY',
'REG_CITY_NOT_WORK_CITY', 'LIVE_CITY_NOT_WORK_CITY']] = app_test[['REG_REGION_NOT_WORK_REGION','LIVE_REGION_NOT_WORK_REGION', 'REG_CITY_NOT_LIVE_CITY',
'REG_CITY_NOT_WORK_CITY', 'LIVE_CITY_NOT_WORK_CITY']].astype('object' ) | Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].astype('float64')
df_test[index] = df_test[index].astype('float64' )<compute_test_metric> | app_train['ORGANIZATION_TYPE'].replace('XNA',np.nan,inplace=True)
app_test['ORGANIZATION_TYPE'].replace('XNA',np.nan,inplace=True)
app_train['ORGANIZATION_TYPE'] = app_train['ORGANIZATION_TYPE'].astype('object')
app_test['ORGANIZATION_TYPE'] = app_test['ORGANIZATION_TYPE'].astype('object' ) | Home Credit Default Risk |
1,537,787 | intervalo_valores(df_train[index] )<define_variables> | app_train[['FONDKAPREMONT_MODE', 'HOUSETYPE_MODE', 'WALLSMATERIAL_MODE', 'EMERGENCYSTATE_MODE']] = app_train[['FONDKAPREMONT_MODE', 'HOUSETYPE_MODE',
'WALLSMATERIAL_MODE', 'EMERGENCYSTATE_MODE']].astype('object')
app_test[['FONDKAPREMONT_MODE', 'HOUSETYPE_MODE', 'WALLSMATERIAL_MODE', 'EMERGENCYSTATE_MODE']] = app_test[['FONDKAPREMONT_MODE', 'HOUSETYPE_MODE',
'WALLSMATERIAL_MODE', 'EMERGENCYSTATE_MODE']].astype('object' ) | Home Credit Default Risk |
1,537,787 | index = 'Source EUI(kBtu/ft²)'<compute_test_metric> | app_train[['OBS_30_CNT_SOCIAL_CIRCLE', 'DEF_30_CNT_SOCIAL_CIRCLE',
'OBS_60_CNT_SOCIAL_CIRCLE', 'DEF_60_CNT_SOCIAL_CIRCLE',]] = app_train[['OBS_30_CNT_SOCIAL_CIRCLE', 'DEF_30_CNT_SOCIAL_CIRCLE',
'OBS_60_CNT_SOCIAL_CIRCLE', 'DEF_60_CNT_SOCIAL_CIRCLE',]].astype('object')
app_test[['OBS_30_CNT_SOCIAL_CIRCLE', 'DEF_30_CNT_SOCIAL_CIRCLE',
'OBS_60_CNT_SOCIAL_CIRCLE', 'DEF_60_CNT_SOCIAL_CIRCLE',]] = app_test[['OBS_30_CNT_SOCIAL_CIRCLE', 'DEF_30_CNT_SOCIAL_CIRCLE',
'OBS_60_CNT_SOCIAL_CIRCLE', 'DEF_60_CNT_SOCIAL_CIRCLE',]].astype('object' ) | Home Credit Default Risk |
1,537,787 | intervalo_valores(df_train[index] )<define_variables> | app_train[['FLAG_DOCUMENT_2', 'FLAG_DOCUMENT_3','FLAG_DOCUMENT_4', 'FLAG_DOCUMENT_5', 'FLAG_DOCUMENT_6',
'FLAG_DOCUMENT_7', 'FLAG_DOCUMENT_8', 'FLAG_DOCUMENT_9', 'FLAG_DOCUMENT_10', 'FLAG_DOCUMENT_11',
'FLAG_DOCUMENT_12','FLAG_DOCUMENT_13', 'FLAG_DOCUMENT_14', 'FLAG_DOCUMENT_15','FLAG_DOCUMENT_16',
'FLAG_DOCUMENT_17', 'FLAG_DOCUMENT_18','FLAG_DOCUMENT_19', 'FLAG_DOCUMENT_20', 'FLAG_DOCUMENT_21',]] = app_train[['FLAG_DOCUMENT_2', 'FLAG_DOCUMENT_3','FLAG_DOCUMENT_4', 'FLAG_DOCUMENT_5', 'FLAG_DOCUMENT_6',
'FLAG_DOCUMENT_7', 'FLAG_DOCUMENT_8', 'FLAG_DOCUMENT_9', 'FLAG_DOCUMENT_10', 'FLAG_DOCUMENT_11',
'FLAG_DOCUMENT_12','FLAG_DOCUMENT_13', 'FLAG_DOCUMENT_14', 'FLAG_DOCUMENT_15','FLAG_DOCUMENT_16',
'FLAG_DOCUMENT_17', 'FLAG_DOCUMENT_18','FLAG_DOCUMENT_19', 'FLAG_DOCUMENT_20', 'FLAG_DOCUMENT_21',]].astype('object')
app_test[['FLAG_DOCUMENT_2', 'FLAG_DOCUMENT_3','FLAG_DOCUMENT_4', 'FLAG_DOCUMENT_5', 'FLAG_DOCUMENT_6',
'FLAG_DOCUMENT_7', 'FLAG_DOCUMENT_8', 'FLAG_DOCUMENT_9', 'FLAG_DOCUMENT_10', 'FLAG_DOCUMENT_11',
'FLAG_DOCUMENT_12','FLAG_DOCUMENT_13', 'FLAG_DOCUMENT_14', 'FLAG_DOCUMENT_15','FLAG_DOCUMENT_16',
'FLAG_DOCUMENT_17', 'FLAG_DOCUMENT_18','FLAG_DOCUMENT_19', 'FLAG_DOCUMENT_20', 'FLAG_DOCUMENT_21',]] = app_test[['FLAG_DOCUMENT_2', 'FLAG_DOCUMENT_3','FLAG_DOCUMENT_4', 'FLAG_DOCUMENT_5', 'FLAG_DOCUMENT_6',
'FLAG_DOCUMENT_7', 'FLAG_DOCUMENT_8', 'FLAG_DOCUMENT_9', 'FLAG_DOCUMENT_10', 'FLAG_DOCUMENT_11',
'FLAG_DOCUMENT_12','FLAG_DOCUMENT_13', 'FLAG_DOCUMENT_14', 'FLAG_DOCUMENT_15','FLAG_DOCUMENT_16',
'FLAG_DOCUMENT_17', 'FLAG_DOCUMENT_18','FLAG_DOCUMENT_19', 'FLAG_DOCUMENT_20', 'FLAG_DOCUMENT_21',]].astype('object')
app_train_col_drop.extend(['FLAG_DOCUMENT_2', 'FLAG_DOCUMENT_4', 'FLAG_DOCUMENT_5', 'FLAG_DOCUMENT_7', 'FLAG_DOCUMENT_9',
'FLAG_DOCUMENT_10', 'FLAG_DOCUMENT_11', 'FLAG_DOCUMENT_12','FLAG_DOCUMENT_13', 'FLAG_DOCUMENT_14',
'FLAG_DOCUMENT_15', 'FLAG_DOCUMENT_16', 'FLAG_DOCUMENT_17', 'FLAG_DOCUMENT_18',
'FLAG_DOCUMENT_19', 'FLAG_DOCUMENT_20', 'FLAG_DOCUMENT_21'] ) | Home Credit Default Risk |
1,537,787 | index = 'Release Date'<drop_column> | app_train[['AMT_REQ_CREDIT_BUREAU_HOUR', 'AMT_REQ_CREDIT_BUREAU_DAY','AMT_REQ_CREDIT_BUREAU_WEEK',
'AMT_REQ_CREDIT_BUREAU_MON','AMT_REQ_CREDIT_BUREAU_QRT', 'AMT_REQ_CREDIT_BUREAU_YEAR',]] = app_train[['AMT_REQ_CREDIT_BUREAU_HOUR', 'AMT_REQ_CREDIT_BUREAU_DAY','AMT_REQ_CREDIT_BUREAU_WEEK',
'AMT_REQ_CREDIT_BUREAU_MON','AMT_REQ_CREDIT_BUREAU_QRT', 'AMT_REQ_CREDIT_BUREAU_YEAR',]].astype('object')
app_test[['AMT_REQ_CREDIT_BUREAU_HOUR', 'AMT_REQ_CREDIT_BUREAU_DAY','AMT_REQ_CREDIT_BUREAU_WEEK',
'AMT_REQ_CREDIT_BUREAU_MON','AMT_REQ_CREDIT_BUREAU_QRT', 'AMT_REQ_CREDIT_BUREAU_YEAR',]] = app_test[['AMT_REQ_CREDIT_BUREAU_HOUR', 'AMT_REQ_CREDIT_BUREAU_DAY','AMT_REQ_CREDIT_BUREAU_WEEK',
'AMT_REQ_CREDIT_BUREAU_MON','AMT_REQ_CREDIT_BUREAU_QRT', 'AMT_REQ_CREDIT_BUREAU_YEAR',]].astype('object')
| Home Credit Default Risk |
1,537,787 | del df_train[index]
del df_test[index]<define_variables> | gc.collect() | Home Credit Default Risk |
1,537,787 | index = 'Water Required?'<data_type_conversions> | train_test = train_test.drop(list(set(app_train_col_drop)) , axis=1)
categorical_col = train_test.select_dtypes('object' ).columns
numeric_col = train_test.select_dtypes('number' ).columns
numeric_col = numeric_col.drop('TARGET')
gc.collect() | Home Credit Default Risk |
1,537,787 | df_train[index] = df_train[index].astype('category' ).cat.codes
df_test[index] = df_test[index].astype('category' ).cat.codes<filter> | train_test = replace_XNA_XAP(train_test)
train_test,_ = binary_encoding(train_test, categorical_col)
train_test,_ = one_hot_encoding(train_test,categorical_col,nan_as_category=True)
descriptive_stat_feat(train_test,numeric_col)
del app_train,app_test
reduce_memory_usage(train_test)
gc.collect() | Home Credit Default Risk |
1,537,787 | df_train = df_train[df_train[index] > -1]<compute_test_metric> | bureau_balance = replace_XNA_XAP(bureau_balance)
bb_bin =[]
bureau_balance, bb_cat = one_hot_encoding(bureau_balance,['STATUS'],nan_as_category=False)
bb_aggregations = {'MONTHS_BALANCE':['min','max','mean']}
for col in bb_cat+bb_bin:
bb_aggregations[col] =['sum','mean']
bb_agg = bureau_balance.groupby('SK_ID_BUREAU' ).agg(bb_aggregations)
bb_agg.columns = [e[0]+ "_" +e[1].upper() for e in bb_agg.columns.tolist() ]
bb_agg.head(2 ) | Home Credit Default Risk |
1,537,787 | intervalo_valores(df_train[index] )<define_variables> | bureau[['CREDIT_TYPE','CNT_CREDIT_PROLONG']] = bureau[['CREDIT_TYPE','CNT_CREDIT_PROLONG']].astype('object')
| Home Credit Default Risk |
1,537,787 | index = 'DOF Benchmarking Submission Status'<drop_column> | bureau['AMT_CREDIT_SUM'] = bureau['AMT_CREDIT_SUM'].apply(np.log1p ) | Home Credit Default Risk |
1,537,787 | del df_train[index]
del df_test[index]<define_variables> | bureau['AMT_CREDIT_SUM_DEBT'] = np.log1p(bureau['AMT_CREDIT_SUM_DEBT'] ) | Home Credit Default Risk |
1,537,787 | index = 'Latitude'<drop_column> | bureau['AMT_ANNUITY'] = np.log1p(bureau['AMT_ANNUITY'] ) | Home Credit Default Risk |
1,537,787 | del df_train[index]
del df_test[index]<define_variables> | bureau = bureau.drop(bureau_drop_col, axis=1)
bureau = replace_XNA_XAP(bureau)
bureau_cat_col = bureau.select_dtypes('object' ).columns
bureau_numeric_col = bureau.select_dtypes('number' ).columns
bureau_numeric_col = bureau_numeric_col.drop(['SK_ID_CURR', 'SK_ID_BUREAU'])
bureau_bin =[]
bureau, bureau_bin = binary_encoding(bureau, bureau_cat_col)
bureau,bureau_cat = one_hot_encoding(bureau,bureau_cat_col,nan_as_category=False)
bureau = bureau.join(bb_agg,how='left',on ='SK_ID_BUREAU')
bureau.drop('SK_ID_BUREAU',axis = 1,inplace=True)
num_aggregators = {
'DAYS_CREDIT': ['min','max','var'],
'DAYS_CREDIT_ENDDATE': ['min','max','mean'],
'DAYS_ENDDATE_FACT': ['mean'],
'CREDIT_DAY_OVERDUE':['max','mean'],
'AMT_CREDIT_SUM':['mean','sum'],
'AMT_CREDIT_SUM_DEBT':['sum','max','mean'],
'AMT_CREDIT_SUM_LIMIT':['sum','mean'],
'AMT_CREDIT_SUM_OVERDUE':['mean'],
'AMT_ANNUITY':['mean','max'],
'MONTHS_BALANCE_MIN':['min'],
'MONTHS_BALANCE_MAX':['max'],
'MONTHS_BALANCE_MEAN':['mean']
}
cat_aggregates = {}
for col in bureau_cat+bureau_bin:
cat_aggregates[col] = ['sum','mean']
for col in bb_cat:
cat_aggregates[col+'_MEAN'] = ['mean']
cat_aggregates[col+'_SUM'] = ['sum']
bureau_agg = bureau.groupby('SK_ID_CURR' ).agg({**num_aggregators, **cat_aggregates})
bureau_agg.columns = pd.Index(['BUREAU_'+e[0]+'_'+e[1].upper() for e in bureau_agg.columns.tolist() ])
bureau_agg = bureau_agg.reset_index()
active = bureau[bureau['CREDIT_ACTIVE_Closed'] ==0]
active_agg = active.groupby('SK_ID_CURR' ).agg(num_aggregators)
active_agg.columns = pd.Index(['ACTIVE_'+ e[0]+'_'+e[1].upper() for e in active_agg.columns.tolist() ])
bureau_agg = bureau_agg.join(active_agg, on ='SK_ID_CURR', how='left')
del active, active_agg
closed = bureau[bureau['CREDIT_ACTIVE_Closed'] ==1]
closed_agg = bureau.groupby('SK_ID_CURR' ).agg(num_aggregators)
closed_agg.columns = pd.Index(['CLOSED_'+ e[0]+'_'+e[1].upper() for e in closed_agg.columns.tolist() ])
bureau_agg = bureau_agg.join(closed_agg, on = 'SK_ID_CURR', how='left')
del closed_agg, closed
del bureau,bureau_balance,bb_agg
gc.collect()
bureau_agg = bureau_agg.set_index('SK_ID_CURR')
bureau_agg.head() | Home Credit Default Risk |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.