kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
1,289,226 | submission.to_csv('./submission.csv', index=False )<set_options> | opt_hyp['n_estimators'] = opt_hyp['n_estimators'].astype(np.int32)
opt_hyp.corr() ['score'] | Home Credit Default Risk |
1,289,226 | sns.set_style('whitegrid')
warnings.filterwarnings("ignore", category=DeprecationWarning)
%matplotlib inline
<load_from_csv> | hyp = hyp.drop(columns = ['metric', 'set', 'verbose'])
hyp['n_estimators'] = hyp['n_estimators'].astype(np.int32)
hyp['min_child_samples'] = hyp['min_child_samples'].astype(np.int32)
hyp['num_leaves'] = hyp['num_leaves'].astype(np.int32)
hyp['subsample_for_bin'] = hyp['subsample_for_bin'].astype(np.int32)
hyp = pd.get_dummies(hyp)
train_labels = hyp.pop('score')
train = np.array(hyp.copy() ) | Home Credit Default Risk |
1,289,226 | train = pd.read_csv('/kaggle/input/eval-lab-2-f464/train.csv')
train.drop('id',axis = 1,inplace = True)
print('Train rows:', train.shape[0] )<normalization> | lr = LinearRegression()
lr.fit(train, train_labels ) | Home Credit Default Risk |
1,289,226 | train = shuffle(train )<count_values> | import lightgbm as lgb | Home Credit Default Risk |
1,289,226 | train['class'].value_counts()<prepare_x_and_y> | train = pd.read_csv('.. /input/home-credit-simple-featuers/simple_features_train.csv')
print('Full Training Features Shape: ', train.shape)
test = pd.read_csv('.. /input/home-credit-simple-featuers/simple_features_test.csv')
print('Full Testing Features Shape: ', test.shape ) | Home Credit Default Risk |
1,289,226 | Y_class = train['class']
train = train.drop('class', axis=1 )<split> | train_labels = np.array(train['TARGET'].astype(np.int32)).reshape(( -1,))
train = train.drop(columns = ['SK_ID_CURR', 'TARGET'])
test_ids = list(test['SK_ID_CURR'])
test = test.drop(columns = ['SK_ID_CURR'] ) | Home Credit Default Risk |
1,289,226 | Y = Y_class.to_numpy()
X = train.to_numpy()
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.1,random_state=42)
print(X_train.shape,y_train.shape)
print(X_test.shape,y_test.shape )<train_on_grid> | random_best = ast.literal_eval(random.loc[0, 'hyperparameters'])
rmodel = lgb.LGBMClassifier(**random_best)
rmodel.fit(train, train_labels ) | Home Credit Default Risk |
1,289,226 | X_resampled, y_resampled = SMOTE().fit_resample(X, Y)
print(sorted(Counter(y_resampled ).items()))
<choose_model_class> | rpreds = rmodel.predict_proba(test)[:, 1]
rsub = pd.DataFrame({'SK_ID_CURR': test_ids, 'TARGET': rpreds})
rsub.to_csv('submission_random_search.csv', index = False ) | Home Credit Default Risk |
1,289,226 | RANDOM_SEED = 42
clf1 = KNeighborsClassifier()
clf2 = RandomForestClassifier(random_state=RANDOM_SEED)
clf3 = GaussianNB()
clf4 = ExtraTreesClassifier(random_state=RANDOM_SEED)
clf5 = XGBClassifier(random_state=RANDOM_SEED)
clf6 = LogisticRegression(random_state=RANDOM_SEED)
sclf = Classifier(classifiers=[clf2, clf3, clf4, clf5, clf6], use_probas=True,meta_classifier=clf1,random_state=RANDOM_SEED)
print('3-fold cross validation:
')
for clf, label in zip([clf1, clf2, clf3, clf4, clf5, clf6, sclf],
['KNN',
'Random Forest',
'GaussianNB',
'ExtraTreesClassifier',
'XGBClassifier',
'LogisticRegression',
'Classifier']):
scores = model_selection.cross_val_score(clf, X, Y,
cv=3, scoring='accuracy')
print("Accuracy: %0.2f(+/- %0.2f)[%s]"
%(scores.mean() , scores.std() , label))<train_model> | bayes_best = ast.literal_eval(opt.loc[0, 'hyperparameters'])
bmodel = lgb.LGBMClassifier(**bayes_best)
bmodel.fit(train, train_labels ) | Home Credit Default Risk |
1,289,226 | clf1.fit(X,Y)
clf2.fit(X,Y)
clf3.fit(X,Y)
clf4.fit(X,Y)
sclf.fit(X,Y)
clf5.fit(X,Y)
clf6.fit(X,Y )<load_from_csv> | bpreds = bmodel.predict_proba(test)[:, 1]
bsub = pd.DataFrame({'SK_ID_CURR': test_ids, 'TARGET': bpreds})
bsub.to_csv('submission_bayesian_optimization.csv', index = False ) | Home Credit Default Risk |
1,289,226 | test = pd.read_csv('/kaggle/input/eval-lab-2-f464/test.csv')
print('Data columns:', test.columns.drop(['id'] ).shape[0] )<drop_column> | random_fi = pd.DataFrame({'feature': features, 'importance': rmodel.feature_importances_})
bayes_fi = pd.DataFrame({'feature': features, 'importance': bmodel.feature_importances_} ) | Home Credit Default Risk |
1,289,226 | testId = test['id']
label = test.drop('id',axis=1)
<data_type_conversions> | random.loc[0, 'hyperparameters'] | Home Credit Default Risk |
1,319,042 | label = label.to_numpy()
label.shape<predict_on_test> | import matplotlib.pyplot as plt
import lightgbm as lgb
import gc
from sklearn.model_selection import KFold, cross_val_score
from sklearn.metrics import confusion_matrix,precision_recall_curve,auc,roc_auc_score,roc_curve,recall_score,classification_report
from sklearn.preprocessing import LabelEncoder | Home Credit Default Risk |
1,319,042 | preds1 = clf1.predict(label)
preds2 = clf2.predict(label)
preds3 = clf3.predict(label)
preds4 = clf4.predict(label)
preds5 = clf5.predict(label)
preds6 = clf6.predict(label)
predss = sclf.predict(label )<save_to_csv> | app_train = pd.read_csv('.. /input/application_train.csv')
print('Training data shape: ', app_train.shape)
app_train.head() | Home Credit Default Risk |
1,319,042 | submission1 = pd.DataFrame({'id': testId, 'class': preds1})
submission1.to_csv('KNN.csv', index=False)
submission2 = pd.DataFrame({'id': testId, 'class': preds2})
submission2.to_csv('Random.csv', index=False)
submission3 = pd.DataFrame({'id': testId, 'class': preds3})
submission3.to_csv('Gauss.csv', index=False)
submission4 = pd.DataFrame({'id': testId, 'class': preds4})
submission4.to_csv('Extra.csv', index=False)
submission5 = pd.DataFrame({'id': testId, 'class': preds5})
submission5.to_csv('XGB.csv', index=False)
submission6 = pd.DataFrame({'id': testId, 'class': preds6})
submission6.to_csv('Logistic.csv', index=False)
submissions = pd.DataFrame({'id': testId, 'class': predss})
submissions.to_csv('Classifier.csv', index=False )<load_from_csv> | app_test = pd.read_csv('.. /input/application_test.csv')
print('Testing data shape: ', app_test.shape)
app_test.head() | Home Credit Default Risk |
1,319,042 | df = pd.read_csv('/kaggle/input/eval-lab-2-f464/train.csv')
t = pd.read_csv('/kaggle/input/eval-lab-2-f464/test.csv' )<prepare_x_and_y> | app_train['TARGET'].value_counts()
print('The proportion of label 1 is %.2f' %(sum(app_train['TARGET']==1)/app_train.shape[0]*100), '%' ) | Home Credit Default Risk |
1,319,042 | y = df['class']
params = [ 'chem_1','chem_2', 'chem_4', 'chem_6', 'attribute']
x = df[params]
df
<import_modules> | def missing_values_table(df):
mis_val = df.isnull().sum()
mis_val_percent = df.isnull().sum() * 100 / df.shape[0]
mis_val_table = pd.concat([mis_val, mis_val_percent], axis = 1)
mis_val_table_rename_columns = mis_val_table.rename(columns = {0: 'Missing Values', 1: 'Percentage'})
mis_val_table_rename_columns = mis_val_table_rename_columns[
mis_val_table_rename_columns.iloc[:, 1]!=0].sort_values('Percentage', ascending=False ).round(1)
print('The total dataframe has ' + str(df.shape[1])+ ' columns')
print('There are ' + str(mis_val_table_rename_columns.shape[0])+ ' columns that have missing values.')
return mis_val_table_rename_columns | Home Credit Default Risk |
1,319,042 | import xgboost as xgb
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split<import_modules> | missing_values = missing_values_table(app_train)
missing_values.head(20 ) | Home Credit Default Risk |
1,319,042 | from sklearn.model_selection import GridSearchCV
from sklearn.metrics import make_scorer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
<train_model> | app_train.dtypes.value_counts() | Home Credit Default Risk |
1,319,042 | model = RandomForestClassifier(n_estimators = 1000)
model.fit(x,y )<save_to_csv> | app_train.select_dtypes('object' ).apply(pd.Series.nunique, axis=0 ) | Home Credit Default Risk |
1,319,042 | y_pred = model.predict(x_test[params])
y_pred = pd.DataFrame(data = y_pred)
answer = pd.concat([x_test['id'], y_pred], axis = 1)
answer.columns = ['id', 'class']
answer.to_csv('lab2_9.csv', index = False )<load_from_csv> | app_test.dtypes.value_counts() | Home Credit Default Risk |
1,319,042 | df_train = pd.read_csv('/kaggle/input/1056lab-diabetes-diagnosis/train.csv', index_col=0)
df_test = pd.read_csv('/kaggle/input/1056lab-diabetes-diagnosis/test.csv', index_col=0 )<set_options> | app_train = pd.get_dummies(app_train)
app_test = pd.get_dummies(app_test)
print('Training Features shape: ', app_train.shape)
print('Testing Features shape: ', app_test.shape ) | Home Credit Default Risk |
1,319,042 | %matplotlib inline
sns.countplot(x='Diabetes', data=df_train)
plt.show()<categorify> | train_labels = app_train['TARGET']
app_train, app_test = app_train.align(app_test, join = 'inner', axis = 1)
app_train['TARGET'] = train_labels
print('Training Features shape: ', app_train.shape)
print('Testing Features shape: ', app_test.shape ) | Home Credit Default Risk |
1,319,042 | df_train_dummies = pd.get_dummies(df_train, columns=['Gender'], drop_first=True)
df_train_dummies<categorify> | app_train['DAYS_EMPLOYED_ANOM'] = app_train['DAYS_EMPLOYED'] == 365243
app_train['DAYS_EMPLOYED'].replace({365243: np.nan}, inplace = True)
app_test['DAYS_EMPLOYED_ANOM'] = app_test['DAYS_EMPLOYED'] == 365243
app_test['DAYS_EMPLOYED'].replace({365243: np.nan}, inplace = True)
print('Training Features shape: ', app_train.shape)
print('Testing Features shape: ', app_test.shape ) | Home Credit Default Risk |
1,319,042 | df_test_dummies = pd.get_dummies(df_test, columns=['Gender'], drop_first=True)
df_test_dummies<train_model> | app_train_domain = app_train.copy()
app_test_domain = app_test.copy()
app_train_domain['CREDIT_INCOME_PERCENT'] = app_train_domain['AMT_CREDIT'] / app_train_domain['AMT_INCOME_TOTAL']
app_train_domain['ANNUITY_INCOME_PERCENT'] = app_train_domain['AMT_ANNUITY'] / app_train_domain['AMT_INCOME_TOTAL']
app_train_domain['CREDIT_TERM'] = app_train_domain['AMT_ANNUITY'] / app_train_domain['AMT_CREDIT']
app_train_domain['DAYS_EMPLOYED_PERCENT'] = app_train_domain['DAYS_EMPLOYED'] / app_train_domain['DAYS_BIRTH']
app_test_domain['CREDIT_INCOME_PERCENT'] = app_test_domain['AMT_CREDIT'] / app_test_domain['AMT_INCOME_TOTAL']
app_test_domain['ANNUITY_INCOME_PERCENT'] = app_test_domain['AMT_ANNUITY'] / app_test_domain['AMT_INCOME_TOTAL']
app_test_domain['CREDIT_TERM'] = app_test_domain['AMT_ANNUITY'] / app_test_domain['AMT_CREDIT']
app_test_domain['DAYS_EMPLOYED_PERCENT'] = app_test_domain['DAYS_EMPLOYED'] / app_test_domain['DAYS_BIRTH']
print('Domain Training Features shape: ', app_train_domain.shape)
print('Domain Testing Features shape: ', app_test_domain.shape ) | Home Credit Default Risk |
1,319,042 | X_train_dummies = df_train_dummies.drop(columns='Diabetes' ).values
y_train_dummies = df_train_dummies['Diabetes'].values
X_train, X_valid, y_train, y_valid = train_test_split(X_train_dummies, y_train_dummies, test_size=0.2, random_state=0)
dtc = RandomForestClassifier()
dtc.fit(X_train, y_train )<train_on_grid> | bureau = pd.read_csv('.. /input/bureau.csv')
bureau.head() | Home Credit Default Risk |
1,319,042 | clf = RandomForestClassifier()
params = {'criterion':('gini', 'entropy'), 'max_depth':[1, 2, 3, 4, 5], 'n_estimators':list(range(20,100,10)) }
gscv = GridSearchCV(clf, params, cv=5)
gscv.fit(X_train_dummies, y_train_dummies )<find_best_score> | previous_loan_counts = bureau.groupby('SK_ID_CURR', as_index=False)['SK_ID_BUREAU'].count().rename(columns = {'SK_ID_BUREAU': 'previous_loan_counts'})
previous_loan_counts.head()
| Home Credit Default Risk |
1,319,042 | print('%.3f %r' %(gscv.best_score_, gscv.best_params_))<train_model> | def agg_numeric(df, group_var, df_name):
for col in df:
if col != group_var and 'SK_ID' in col:
df = df.drop(columns = col)
group_ids = df[group_var]
numeric_df = df.select_dtypes('number')
numeric_df[group_var] = group_ids
agg = numeric_df.groupby(group_var ).agg(['count', 'mean', 'max', 'min', 'sum'] ).reset_index()
columns = [group_var]
for var in agg.columns.levels[0]:
if var != group_var:
for stat in agg.columns.levels[1][:-1]:
columns.append('%s_%s_%s' %(df_name, var, stat))
agg.columns = columns
return agg
bureau_agg = agg_numeric(bureau.drop(columns = ['SK_ID_BUREAU']), group_var = 'SK_ID_CURR', df_name = 'bureau')
bureau_agg.head() | Home Credit Default Risk |
1,319,042 | dtc = RandomForestClassifier(criterion='entropy', max_depth=5, n_estimators=60)
dtc.fit(X_train_dummies, y_train_dummies )<compute_train_metric> | def count_categorical(df, group_var, df_name):
categorical = pd.get_dummies(df.select_dtypes('object'))
categorical[group_var] = df[group_var]
categorical = categorical.groupby(group_var ).agg(['sum', 'mean'])
column_names = []
for var in categorical.columns.levels[0]:
for stat in ['count', 'count_norm']:
column_names.append('%s_%s_%s' %(df_name, var, stat))
categorical.columns = column_names
return categorical
bureau_counts = count_categorical(bureau, group_var = 'SK_ID_CURR', df_name = 'bureau')
bureau_counts.head() | Home Credit Default Risk |
1,319,042 | y_pred = dtc.predict_proba(X_valid)[:, 1]
fpr, tpr, thresholds = roc_curve(y_valid, y_pred)
auc(fpr, tpr )<predict_on_test> | train = app_train_domain.merge(previous_loan_counts, on = 'SK_ID_CURR', how = 'left')
train['previous_loan_counts'] = train['previous_loan_counts'].fillna(0)
test = app_test_domain.merge(previous_loan_counts, on = 'SK_ID_CURR', how = 'left')
test['previous_loan_counts'] = test['previous_loan_counts'].fillna(0 ) | Home Credit Default Risk |
1,319,042 | X_test = df_test_dummies.values
y_pred = dtc.predict_proba(X_test)[:, 1]<save_to_csv> | train = train.merge(bureau_agg, on = 'SK_ID_CURR', how = 'left')
test = test.merge(bureau_agg, on = 'SK_ID_CURR', how = 'left' ) | Home Credit Default Risk |
1,319,042 | submit = pd.read_csv('/kaggle/input/1056lab-diabetes-diagnosis/sampleSubmission.csv')
submit['Diabetes'] = y_pred
submit.to_csv('submission.csv', index=False )<load_from_csv> | train = train.merge(bureau_counts, on = 'SK_ID_CURR', how = 'left')
test = test.merge(bureau_counts, on = 'SK_ID_CURR', how = 'left' ) | Home Credit Default Risk |
1,319,042 | df_train = pd.read_csv('.. /input/1056lab-diabetes-diagnosis/train.csv',index_col=0)
df_test = pd.read_csv('.. /input/1056lab-diabetes-diagnosis/test.csv',index_col=0)
df_train<count_values> | print('Before align train.shape: ', train.shape)
print('Before align test.shape: ', test.shape)
train_labels = train['TARGET']
train, test = train.align(test, join = 'inner', axis = 1)
train['TARGET'] = train_labels
print('After align train.shape: ', train.shape)
print('After align test.shape: ', test.shape ) | Home Credit Default Risk |
1,319,042 | df_train['Diabetes'].value_counts()<categorify> | bureau_balance = pd.read_csv('.. /input/bureau_balance.csv')
bureau_balance.head() | Home Credit Default Risk |
1,319,042 | df_train_dummies = pd.get_dummies(df_train, columns=['Gender'], drop_first=True)
df_train_dummies<categorify> | bureau_balance_agg = agg_numeric(bureau_balance, group_var = 'SK_ID_BUREAU', df_name = 'bureau_balance')
bureau_balance_agg.head() | Home Credit Default Risk |
1,319,042 | df_test_dummies = pd.get_dummies(df_test, columns=['Gender'], drop_first=True)
df_test_dummies<set_options> | bureau_balance_counts = count_categorical(bureau_balance, group_var = 'SK_ID_BUREAU', df_name = 'bureau_balance')
bureau_balance_counts.head() | Home Credit Default Risk |
1,319,042 | %matplotlib inline
sns.pairplot(df_train_dummies, hue='Diabetes')
plt.show()<categorify> | bureau_by_loan = bureau_balance_agg.merge(bureau_balance_counts, right_index = True, left_on = 'SK_ID_BUREAU', how = 'outer' ) | Home Credit Default Risk |
1,319,042 | df_train_dummies2 = df_train_dummies[['HDL Chol', 'Chol/HDL ratio', 'Weight', 'Systolic BP', 'Diastolic BP','Waist','Hip','Diabetes']]
df_test_dummies2 = df_test_dummies[['HDL Chol', 'Chol/HDL ratio', 'Weight', 'Systolic BP', 'Diastolic BP','Waist','Hip']]<split> | bureau_by_loan = bureau_by_loan.merge(bureau[['SK_ID_BUREAU', 'SK_ID_CURR']], on = 'SK_ID_BUREAU', how = 'left' ) | Home Credit Default Risk |
1,319,042 | X_train_dummies = df_train_dummies2.drop('Diabetes', axis=1 ).values
y_train_dummies = df_train_dummies2['Diabetes'].values
X_train, X_valid, y_train, y_valid = train_test_split(X_train_dummies, y_train_dummies, test_size=0.2, random_state=0 )<train_on_grid> | bureau_balance_by_client = agg_numeric(bureau_by_loan.drop(columns = ['SK_ID_BUREAU']), group_var = 'SK_ID_CURR', df_name = 'client')
bureau_balance_by_client.head() | Home Credit Default Risk |
1,319,042 | clf = RandomForestClassifier()
params = {'criterion':('gini', 'entropy'),
'n_estimators':[240,260,280,300],
'max_depth':[1, 2, 3, 4, 5],
'random_state':[5]
}
gscv = GridSearchCV(clf, params, cv=5,scoring='roc_auc')
gscv.fit(X_train, y_train )<find_best_params> | train = train.merge(bureau_balance_by_client, on = 'SK_ID_CURR', how = 'left')
test = test.merge(bureau_balance_by_client, on = 'SK_ID_CURR', how = 'left' ) | Home Credit Default Risk |
1,319,042 | scores = gscv.cv_results_['mean_test_score']
params = gscv.cv_results_['params']
for score, param in zip(scores, params):
print('%.3f %r' %(score, param))<find_best_score> | print('Before align train.shape: ', train.shape)
print('Before align test.shape: ', test.shape)
train_labels = train['TARGET']
train, test = train.align(test, join = 'inner', axis = 1)
train['TARGET'] = train_labels
print('After align train.shape: ', train.shape)
print('After align test.shape: ', test.shape ) | Home Credit Default Risk |
1,319,042 | print('%.3f %r' %(gscv.best_score_, gscv.best_params_))<train_model> | gc.enable()
del app_train, app_test, app_train_domain, app_test_domain, bureau, bureau_balance, bureau_agg, bureau_counts, bureau_balance_agg, bureau_balance_counts, bureau_by_loan, bureau_balance_by_client
gc.collect() | Home Credit Default Risk |
1,319,042 | clf = RandomForestClassifier(criterion='entropy', max_depth= 4, n_estimators= 280,random_state= 5)
clf.fit(X_train_dummies,y_train_dummies )<predict_on_test> | missing_train = missing_values_table(train)
missing_train.head(10 ) | Home Credit Default Risk |
1,319,042 | X_test = df_test_dummies2.values
y_pred = clf.predict_proba(X_test)[:, 1]<save_to_csv> | missing_test = missing_values_table(test)
missing_test.head(10 ) | Home Credit Default Risk |
1,319,042 | submit = pd.read_csv('/kaggle/input/1056lab-diabetes-diagnosis/sampleSubmission.csv')
submit['Diabetes'] = y_pred
submit.to_csv('submission2.csv', index=False )<define_variables> | missing_train_vars = list(missing_train.index[missing_train['Percentage'] > 90])
print('There are', len(missing_train_vars), 'columns having missing percent larger than 90%% in the train')
missing_test_vars = list(missing_test.index[missing_test['Percentage'] > 90])
print('There are', len(missing_test_vars), 'columns having missing percent larger than 90%% in the test')
missing_columns = list(set(missing_test_vars + missing_train_vars))
print('There are %d columns with more than 90%% missing in either the training or testing data.' % len(missing_columns)) | Home Credit Default Risk |
1,319,042 | sys.path.insert(0,'.. /input/efficientnet/EfficientNet-b5')
<import_modules> | train = train.drop(columns = missing_columns)
test = test.drop(columns = missing_columns)
| Home Credit Default Risk |
1,319,042 | from __future__ import print_function, division
import argparse
import torch
import torch.nn as nn
import torch.optim as optim
from torch.autograd import Variable
from torchvision import datasets, models, transforms
import time
import os
import pandas as pd
from efficientnet.model import EfficientNet
import torch.nn.functional as F
import sys
from PIL import Image<init_hyperparams> | corrs = corrs.sort_values('TARGET', ascending = False)
pd.DataFrame(corrs['TARGET'].head(10)) | Home Credit Default Risk |
1,319,042 | use_gpu = torch.cuda.is_available()
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
data_dir = '.. /input/issm2020-ai-challenge'
batch_size = 4
lr = 0.1
momentum = 0.9
num_epochs = 100
input_size = 480
class_num = 10
num_workers = 4<compute_train_metric> | threshold = 0.8
above_threshold_vars = {}
for col in corrs:
above_threshold_vars[col] = list(corrs.index[corrs[col] > threshold] ) | Home Credit Default Risk |
1,319,042 | def linear_combination(x, y, epsilon):
return epsilon*x +(1-epsilon)*y
def reduce_loss(loss, reduction='mean'):
return loss.mean() if reduction=='mean'else loss.sum() if reduction=='sum' else loss
class LabelSmoothingCrossEntropy(nn.Module):
def __init__(self, epsilon:float=0.1, reduction='mean'):
super().__init__()
self.epsilon = epsilon
self.reduction = reduction
def forward(self, preds, target):
n = preds.size() [-1]
log_preds = F.log_softmax(preds, dim=-1)
loss = reduce_loss(-log_preds.sum(dim=-1), self.reduction)
nll = F.nll_loss(log_preds, target, reduction=self.reduction)
return linear_combination(loss/n, nll, self.epsilon )<choose_model_class> | cols_to_remove = []
cols_seen = []
cols_to_remove_pair = []
for key, value in above_threshold_vars.items() :
cols_seen.append(key)
for x in value:
if x == key:
next
else:
if x not in cols_seen:
cols_to_remove.append(x)
cols_to_remove_pair.append(key)
cols_to_remove = list(set(cols_to_remove))
print('Number of columns to remove: ', len(cols_to_remove)) | Home Credit Default Risk |
1,319,042 | def exp_lr_scheduler(optimizer, epoch, init_lr=0.01, lr_decay_epoch=10):
lr = init_lr *(0.8**(epoch // lr_decay_epoch))
print('LR is set to {}'.format(lr))
for param_group in optimizer.param_groups:
param_group['lr'] = lr
return optimizer<choose_model_class> | train_corrs_removed = train.drop(columns = cols_to_remove)
test_corrs_removed = test.drop(columns = cols_to_remove)
print('Training Corrs Removed Shape: ', train_corrs_removed.shape)
print('Testing Corrs Removed Shape: ', test_corrs_removed.shape)
| Home Credit Default Risk |
1,319,042 | def train_model(model_ft, criterion, optimizer, lr_scheduler, num_epochs=50):
train_loss = []
since = time.time()
best_model_wts = model_ft.state_dict()
best_acc = 0.0
best_train_acc = 0.0
for epoch in range(num_epochs):
model_ft.train(True)
dset_loaders, dset_sizes = loaddata(data_dir=data_dir, batch_size=batch_size, set_name='semTrain', shuffle=True)
print('Data Size', dset_sizes)
print('Epoch {}/{}'.format(epoch, num_epochs - 1))
print('-' * 10)
optimizer = lr_scheduler(optimizer, epoch)
running_loss = 0.0
running_corrects = 0
count = 0
for i,data in enumerate(dset_loaders['semTrain']):
inputs, labels = data
labels = torch.squeeze(labels.type(torch.LongTensor))
if use_gpu:
inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())
else:
inputs, labels = Variable(inputs), Variable(labels)
outputs = model_ft(inputs)
loss = criterion(outputs, labels)
_, preds = torch.max(outputs.data, 1)
optimizer.zero_grad()
loss.backward()
optimizer.step()
count += 1
if count % 30 == 0 or outputs.size() [0] < batch_size:
print('Epoch:{}: loss:{:.3f}'.format(epoch, loss.item()))
train_loss.append(loss.item())
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
epoch_loss = running_loss / dset_sizes
epoch_acc = running_corrects.double() / dset_sizes
print('Train Loss: {:.4f} Acc: {:.4f}'.format(
epoch_loss, epoch_acc))
if epoch_acc >= 0.9999:
best_acc = epoch_acc
best_model_wts = model_ft.state_dict()
print('update best weight at No.',epoch,' epoch' )<load_pretrained> | gc.enable()
del train, test
gc.collect() | Home Credit Default Risk |
1,319,042 | model_ft = EfficientNet.from_name('efficientnet-b2')
net_weight = '.. /input/efficientnet-pytorch-b0-b7/efficientnet-b2-8bb594d6.pth'
state_dict = torch.load(net_weight)
model_ft.load_state_dict(state_dict)
<feature_engineering> | def train_with_cv(train_data, test_data, n_folds, seed_varying):
train_ids = train_data['SK_ID_CURR']
test_ids = test_data['SK_ID_CURR']
train_labels = train_data['TARGET']
train_features = train_data.drop(columns = ['SK_ID_CURR', 'TARGET'])
test_features = test_data.drop(columns = ['SK_ID_CURR'])
feature_names = list(train_features.columns)
feature_importance_values = np.zeros(len(feature_names))
train_features = np.array(train_features)
test_features = np.array(test_features)
k_fold = KFold(n_splits = n_folds, shuffle = True, random_state = 50+seed_varying)
test_pred = np.zeros(test_features.shape[0])
out_of_fold = np.zeros(train_features.shape[0])
valid_scores = []
train_scores = []
for train_indices, valid_indices in k_fold.split(train_features):
x_train, y_train = train_features[train_indices], train_labels[train_indices]
x_valid, y_valid = train_features[valid_indices], train_labels[valid_indices]
model = lgb.LGBMClassifier(n_estimators=10000, objective = 'binary',
class_weight = 'balanced', learning_rate = 0.05,
reg_alpha = 0.1, reg_lambda = 0.1,
subsample = 0.8, n_jobs = -1, random_state = 50+seed_varying)
model.fit(x_train, y_train, eval_metric = 'auc',
eval_set = [(x_valid, y_valid),(x_train, y_train)],
eval_names = ['valid', 'train'], categorical_feature = 'auto',
early_stopping_rounds = 100, verbose = -1)
best_iteration = model.best_iteration_
feature_importance_values += model.feature_importances_ / k_fold.n_splits
test_pred += model.predict_proba(test_features, num_iteration = best_iteration)[:, 1] / k_fold.n_splits
out_of_fold[valid_indices] = model.predict_proba(x_valid, num_iteration = best_iteration)[:, 1]
valid_score = model.best_score_['valid']['auc']
train_score = model.best_score_['train']['auc']
valid_scores.append(valid_score)
train_scores.append(train_score)
gc.enable()
del model, x_train, y_train, x_valid, y_valid
gc.collect()
pred_score = pd.DataFrame({'SK_ID_CURR': test_ids, 'TARGET': test_pred})
feature_importances = pd.DataFrame({'feature': feature_names, 'importance': feature_importance_values})
valid_auc = roc_auc_score(train_labels, out_of_fold)
valid_scores.append(valid_auc)
train_scores.append(np.mean(train_scores))
fold_names = list(range(n_folds))
fold_names.append('overall')
metrics = pd.DataFrame({'fold': fold_names,
'train': train_scores,
'valid': valid_scores})
return pred_score, feature_importances, metrics | Home Credit Default Risk |
1,319,042 | num_ftrs = model_ft._fc.in_features
model_ft._fc = nn.Linear(num_ftrs, class_num)
criterion = LabelSmoothingCrossEntropy()<choose_model_class> | train_times = 5
n_folds = 5
i = 0
metrics_all = np.zeros(( train_times, 2))
for seed_varying in range(train_times):
print('
=======================================================')
print('The ', seed_varying, ' time of train')
print('
=======================================================')
sub, fi, metrics = train_with_cv(train_corrs_removed, test_corrs_removed, n_folds, seed_varying)
if i==0:
submission = sub
feat_
else:
submission['TARGET'] += sub['TARGET']
feat_import['importance'] += fi['importance']
metrics_all[i, :] = metrics.iloc[-1, 1:3]
i += 1
metrics_all_average = metrics_all.mean(axis = 0)
metrics_all = np.row_stack([metrics_all, metrics_all_average])
train_time_names = list(range(train_times))
train_time_names.append('Average')
metrics_final = pd.DataFrame({'train_time': train_time_names,
'train': metrics_all[:,0],
'valid': metrics_all[:,1]})
submission['TARGET'] = submission['TARGET'] / train_times
feat_import['importance'] = feat_import['importance'] / train_times
submission.to_csv('lightgbm_version_11.csv', index = False ) | Home Credit Default Risk |
1,316,372 | if use_gpu:
model_ft = model_ft.cuda()
criterion = criterion.cuda()
optimizer = optim.SGD(( model_ft.parameters()), lr=lr,
momentum=momentum, weight_decay=0.0004)
<train_model> | import matplotlib.pyplot as plt
import lightgbm as lgb
import gc
from sklearn.model_selection import KFold, cross_val_score
from sklearn.metrics import confusion_matrix,precision_recall_curve,auc,roc_auc_score,roc_curve,recall_score,classification_report
from sklearn.preprocessing import LabelEncoder | Home Credit Default Risk |
1,316,372 |
<find_best_params> | app_train = pd.read_csv('.. /input/application_train.csv')
print('Training data shape: ', app_train.shape)
app_train.head() | Home Credit Default Risk |
1,316,372 | model_ft_test = EfficientNet.from_name('efficientnet-b2')
num_ftrs = model_ft_test._fc.in_features
model_ft_test._fc = nn.Linear(num_ftrs, class_num)
net_weight = '.. /input/weight/best_val_efficientnet-b2.pth'
state_dict = torch.load(net_weight)
model_ft_test.load_state_dict(state_dict)
model_ft_test.cuda()
model_ft_test.eval()
data_transforms = transforms.Compose([
transforms.Resize(input_size),
transforms.CenterCrop(input_size),
transforms.ToTensor() ,
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])] )<features_selection> | app_test = pd.read_csv('.. /input/application_test.csv')
print('Testing data shape: ', app_test.shape)
app_test.head() | Home Credit Default Risk |
1,316,372 | res = []
hash1 = {}
for imagepath in os.listdir('.. /input/issm2020-ai-challenge/semTest/semTest'):
p = []
image = Image.open('.. /input/issm2020-ai-challenge/semTest/semTest/'+imagepath)
imgprob = data_transforms(image ).unsqueeze(0)
imgprob = Variable(imgprob ).cuda()
torch.no_grad()
logit = model_ft_test(imgprob)
p.append(F.softmax(logit, -1))
if 1:
logit = model_ft_test(torch.flip(imgprob, dims=(2,)).contiguous())
p.append(F.softmax(logit, -1))
logit = model_ft_test(torch.flip(imgprob, dims=(3,)).contiguous())
p.append(F.softmax(logit, -1))
logit = model_ft_test(torch.flip(imgprob, dims=(2,3)).contiguous())
p.append(F.softmax(logit, -1))
logit = model_ft_test(imgprob.permute(0,1,3,2 ).contiguous())
p.append(F.softmax(logit, -1))
p1 = torch.stack(p ).mean(0)
predict = p1.argmax(-1)
if imagepath.endswith('.jpg'):
hash1[int(imagepath.rstrip('.jpg')) ] =(int(predict.cpu().numpy()))
else:
hash1[int(imagepath.rstrip('.JPG')) ] =(int(predict.cpu().numpy()))<save_to_csv> | app_train['TARGET'].value_counts()
print('The proportion of label 1 is %.2f' %(sum(app_train['TARGET']==1)/app_train.shape[0]*100), '%' ) | Home Credit Default Risk |
1,316,372 | for i in sorted(hash1):
res.append(hash1[i]+1)
data = {'Id':list(range(1,351)) ,'LABEL':res}
df = pd.DataFrame(data)
df.to_csv('submission.csv',index=None )<import_modules> | def missing_values_table(df):
mis_val = df.isnull().sum()
mis_val_percent = df.isnull().sum() * 100 / df.shape[0]
mis_val_table = pd.concat([mis_val, mis_val_percent], axis = 1)
mis_val_table_rename_columns = mis_val_table.rename(columns = {0: 'Missing Values', 1: 'Percentage'})
mis_val_table_rename_columns = mis_val_table_rename_columns[
mis_val_table_rename_columns.iloc[:, 1]!=0].sort_values('Percentage', ascending=False ).round(1)
print('The total dataframe has ' + str(df.shape[1])+ ' columns')
print('There are ' + str(mis_val_table_rename_columns.shape[0])+ ' columns')
return mis_val_table_rename_columns | Home Credit Default Risk |
1,316,372 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import os<define_variables> | missing_values = missing_values_table(app_train)
missing_values.head(20 ) | Home Credit Default Risk |
1,316,372 | wd = "/kaggle/input/jamp-hackathon-drive-1/train_set/"<define_variables> | app_train.dtypes.value_counts() | Home Credit Default Risk |
1,316,372 | images_dir=os.listdir(wd )<feature_engineering> | app_train.select_dtypes('object' ).apply(pd.Series.nunique, axis=0 ) | Home Credit Default Risk |
1,316,372 | df=pd.DataFrame()
df['Images']=data
classes=df["Images"].str.split("/", n = 6, expand = True)[5]
df['Label']=classes
df = df.sample(frac=1 ).reset_index(drop=True )<count_values> | app_test.dtypes.value_counts() | Home Credit Default Risk |
1,316,372 | df['Label'].value_counts()<split> | app_train = pd.get_dummies(app_train)
app_test = pd.get_dummies(app_test)
print('Training Features shape: ', app_train.shape)
print('Testing Features shape: ', app_test.shape ) | Home Credit Default Risk |
1,316,372 | train, test = train_test_split(df, test_size=0.2,stratify=df['Label'] )<set_options> | train_labels = app_train['TARGET']
app_train, app_test = app_train.align(app_test, join = 'inner', axis = 1)
app_train['TARGET'] = train_labels
print('Training Features shape: ', app_train.shape)
print('Testing Features shape: ', app_test.shape ) | Home Credit Default Risk |
1,316,372 | get_ipython().magic('matplotlib inline')
<import_modules> | app_train['DAYS_EMPLOYED_ANOM'] = app_train['DAYS_EMPLOYED'] == 365243
app_train['DAYS_EMPLOYED'].replace({365243: np.nan}, inplace = True)
app_test['DAYS_EMPLOYED_ANOM'] = app_test['DAYS_EMPLOYED'] == 365243
app_test['DAYS_EMPLOYED'].replace({365243: np.nan}, inplace = True)
print('Training Features shape: ', app_train.shape)
print('Testing Features shape: ', app_test.shape ) | Home Credit Default Risk |
1,316,372 | from tqdm import tqdm
import pickle<categorify> | app_train_domain = app_train.copy()
app_test_domain = app_test.copy()
app_train_domain['CREDIT_INCOME_PERCENT'] = app_train_domain['AMT_CREDIT'] / app_train_domain['AMT_INCOME_TOTAL']
app_train_domain['ANNUITY_INCOME_PERCENT'] = app_train_domain['AMT_ANNUITY'] / app_train_domain['AMT_INCOME_TOTAL']
app_train_domain['CREDIT_TERM'] = app_train_domain['AMT_ANNUITY'] / app_train_domain['AMT_CREDIT']
app_train_domain['DAYS_EMPLOYED_PERCENT'] = app_train_domain['DAYS_EMPLOYED'] / app_train_domain['DAYS_BIRTH']
app_test_domain['CREDIT_INCOME_PERCENT'] = app_test_domain['AMT_CREDIT'] / app_test_domain['AMT_INCOME_TOTAL']
app_test_domain['ANNUITY_INCOME_PERCENT'] = app_test_domain['AMT_ANNUITY'] / app_test_domain['AMT_INCOME_TOTAL']
app_test_domain['CREDIT_TERM'] = app_test_domain['AMT_ANNUITY'] / app_test_domain['AMT_CREDIT']
app_test_domain['DAYS_EMPLOYED_PERCENT'] = app_test_domain['DAYS_EMPLOYED'] / app_test_domain['DAYS_BIRTH']
print('Domain Training Features shape: ', app_train_domain.shape)
print('Domain Testing Features shape: ', app_test_domain.shape ) | Home Credit Default Risk |
1,316,372 | train_img=[]
for i in tqdm(df['Images']):
temp_img=image.load_img(i,target_size=(224,224))
temp_img=image.img_to_array(temp_img)
train_img.append(temp_img)
train_img=np.array(train_img)
train_img=preprocess_input(train_img)
<feature_engineering> | bureau = pd.read_csv('.. /input/bureau.csv')
bureau.head() | Home Credit Default Risk |
1,316,372 | test_wd = "/kaggle/input/jamp-hackathon-drive-1/test_set/"
test_dir=os.listdir(test_wd)
test_data=[]
for i in test_dir:
test_data.append(os.path.join(test_wd,i))
test_df=pd.DataFrame()
test_df['Images']=test_data
test_df.head()<normalization> | previous_loan_counts = bureau.groupby('SK_ID_CURR', as_index=False)['SK_ID_BUREAU'].count().rename(columns = {'SK_ID_BUREAU': 'previous_loan_counts'})
previous_loan_counts.head()
| Home Credit Default Risk |
1,316,372 | test_img=[]
for i in tqdm(test_df['Images']):
temp_img=image.load_img(i,target_size=(224,224))
temp_img=image.img_to_array(temp_img)
test_img.append(temp_img)
test_img=np.array(test_img)
test_img=preprocess_input(test_img )<choose_model_class> | def agg_numeric(df, group_var, df_name):
for col in df:
if col != group_var and 'SK_ID' in col:
df = df.drop(columns = col)
group_ids = df[group_var]
numeric_df = df.select_dtypes('number')
numeric_df[group_var] = group_ids
agg = numeric_df.groupby(group_var ).agg(['count', 'mean', 'max', 'min', 'sum'] ).reset_index()
columns = [group_var]
for var in agg.columns.levels[0]:
if var != group_var:
for stat in agg.columns.levels[1][:-1]:
columns.append('%s_%s_%s' %(df_name, var, stat))
agg.columns = columns
return agg
bureau_agg = agg_numeric(bureau.drop(columns = ['SK_ID_BUREAU']), group_var = 'SK_ID_CURR', df_name = 'bureau')
bureau_agg.head() | Home Credit Default Risk |
1,316,372 | model = VGG16(weights='imagenet', include_top=False )<predict_on_test> | def count_categorical(df, group_var, df_name):
categorical = pd.get_dummies(df.select_dtypes('object'))
categorical[group_var] = df[group_var]
categorical = categorical.groupby(group_var ).agg(['sum', 'mean'])
column_names = []
for var in categorical.columns.levels[0]:
for stat in ['count', 'count_norm']:
column_names.append('%s_%s_%s' %(df_name, var, stat))
categorical.columns = column_names
return categorical
bureau_counts = count_categorical(bureau, group_var = 'SK_ID_CURR', df_name = 'bureau')
bureau_counts.head() | Home Credit Default Risk |
1,316,372 | features_train=model.predict(train_img )<predict_on_test> | train = app_train_domain.merge(previous_loan_counts, on = 'SK_ID_CURR', how = 'left')
train['previous_loan_counts'] = train['previous_loan_counts'].fillna(0)
test = app_test_domain.merge(previous_loan_counts, on = 'SK_ID_CURR', how = 'left')
test['previous_loan_counts'] = test['previous_loan_counts'].fillna(0 ) | Home Credit Default Risk |
1,316,372 | features_test=model.predict(test_img )<prepare_x_and_y> | train = train.merge(bureau_agg, on = 'SK_ID_CURR', how = 'left')
test = test.merge(bureau_agg, on = 'SK_ID_CURR', how = 'left' ) | Home Credit Default Risk |
1,316,372 | train_x=features_train.reshape(1027,-1 )<prepare_x_and_y> | train = train.merge(bureau_counts, on = 'SK_ID_CURR', how = 'left')
test = test.merge(bureau_counts, on = 'SK_ID_CURR', how = 'left' ) | Home Credit Default Risk |
1,316,372 | test_x=features_test.reshape(256,-1 )<split> | print('Before align train.shape: ', train.shape)
print('Before align test.shape: ', test.shape)
train_labels = train['TARGET']
train, test = train.align(test, join = 'inner', axis = 1)
train['TARGET'] = train_labels
print('After align train.shape: ', train.shape)
print('After align test.shape: ', test.shape ) | Home Credit Default Risk |
1,316,372 | train_y=np.asarray(df['Label'])
train_y=pd.get_dummies(train_y)
train_y=np.array(train_y)
X_train, X_valid, Y_train, Y_valid=train_test_split(train_x,train_y,test_size=0.3, random_state=42)
<categorify> | def train_with_cv(train_data, test_data, n_folds, seed_varying):
train_ids = train_data['SK_ID_CURR']
test_ids = test_data['SK_ID_CURR']
train_labels = train_data['TARGET']
train_features = train_data.drop(columns = ['SK_ID_CURR', 'TARGET'])
test_features = test_data.drop(columns = ['SK_ID_CURR'])
feature_names = list(train_features.columns)
feature_importance_values = np.zeros(len(feature_names))
train_features = np.array(train_features)
test_features = np.array(test_features)
k_fold = KFold(n_splits = n_folds, shuffle = True, random_state = 50+seed_varying)
test_pred = np.zeros(test_features.shape[0])
out_of_fold = np.zeros(train_features.shape[0])
valid_scores = []
train_scores = []
for train_indices, valid_indices in k_fold.split(train_features):
x_train, y_train = train_features[train_indices], train_labels[train_indices]
x_valid, y_valid = train_features[valid_indices], train_labels[valid_indices]
model = lgb.LGBMClassifier(n_estimators=10000, objective = 'binary',
class_weight = 'balanced', learning_rate = 0.05,
reg_alpha = 0.1, reg_lambda = 0.1,
subsample = 0.8, n_jobs = -1, random_state = 50+seed_varying)
model.fit(x_train, y_train, eval_metric = 'auc',
eval_set = [(x_valid, y_valid),(x_train, y_train)],
eval_names = ['valid', 'train'], categorical_feature = 'auto',
early_stopping_rounds = 100, verbose = -1)
best_iteration = model.best_iteration_
feature_importance_values += model.feature_importances_ / k_fold.n_splits
test_pred += model.predict_proba(test_features, num_iteration = best_iteration)[:, 1] / k_fold.n_splits
out_of_fold[valid_indices] = model.predict_proba(x_valid, num_iteration = best_iteration)[:, 1]
valid_score = model.best_score_['valid']['auc']
train_score = model.best_score_['train']['auc']
valid_scores.append(valid_score)
train_scores.append(train_score)
gc.enable()
del model, x_train, y_train, x_valid, y_valid
gc.collect()
pred_score = pd.DataFrame({'SK_ID_CURR': test_ids, 'TARGET': test_pred})
feature_importances = pd.DataFrame({'feature': feature_names, 'importance': feature_importance_values})
valid_auc = roc_auc_score(train_labels, out_of_fold)
valid_scores.append(valid_auc)
train_scores.append(np.mean(train_scores))
fold_names = list(range(n_folds))
fold_names.append('overall')
metrics = pd.DataFrame({'fold': fold_names,
'train': train_scores,
'valid': valid_scores})
return pred_score, feature_importances, metrics | Home Credit Default Risk |
1,316,372 | <choose_model_class><EOS> | train_times = 3
n_folds = 5
i = 0
metrics_all = np.zeros(( train_times, 2))
for seed_varying in range(train_times):
print('
=======================================================')
print('The ', seed_varying, ' time of train')
print('
=======================================================')
sub, fi, metrics = train_with_cv(train, test, n_folds, seed_varying)
if i==0:
submission = sub
feat_
else:
submission['TARGET'] += sub['TARGET']
feat_import['importance'] += fi['importance']
metrics_all[i, :] = metrics.iloc[-1, 1:3]
i += 1
metrics_all_average = metrics_all.mean(axis = 0)
metrics_all = np.row_stack([metrics_all, metrics_all_average])
train_time_names = list(range(train_times))
train_time_names.append('Average')
metrics_final = pd.DataFrame({'train_time': train_time_names,
'train': metrics_all[:,0],
'valid': metrics_all[:,1]})
submission['TARGET'] = submission['TARGET'] / train_times
feat_import['importance'] = feat_import['importance'] / train_times
submission.to_csv('lightgbm_version_9.csv', index = False ) | Home Credit Default Risk |
1,276,329 | <SOS> metric: AUC Kaggle data source: home-credit-default-risk<train_model> | init_notebook_mode(connected=True ) | Home Credit Default Risk |
1,276,329 | model.fit(X_train, Y_train, epochs=20, batch_size=128,validation_data=(X_valid,Y_valid))<predict_on_test> | print("Loading data files...")
start = time()
posc_bal = reduce_mem_usage(pd.read_csv(".. /input/POS_CASH_balance.csv"))
bureau_bal = reduce_mem_usage(pd.read_csv(".. /input/bureau_balance.csv"))
app_train = reduce_mem_usage(pd.read_csv(".. /input/application_train.csv"))
prev_app = reduce_mem_usage(pd.read_csv(".. /input/previous_application.csv"))
inst_pay = reduce_mem_usage(pd.read_csv(".. /input/installments_payments.csv"))
cc_bal = reduce_mem_usage(pd.read_csv(".. /input/credit_card_balance.csv"))
app_test = reduce_mem_usage(pd.read_csv(".. /input/application_test.csv"))
bureau = reduce_mem_usage(pd.read_csv(".. /input/bureau.csv"))
end = time()
print("Finished loading data files and running memory optimization in {} seconds.".format(int(round(end - start)))) | Home Credit Default Risk |
1,276,329 | model.predict(X_valid )<compute_test_metric> | eda = pd.DataFrame(
[
['Point of Sale Cash Balance', posc_bal.shape[0], posc_bal.shape[1] - 2, np.sum(posc_bal.dtypes=='category'),
np.sum(posc_bal.isnull().sum() > 0), posc_bal.isnull().sum().sum() ],
['Bureau Balance', bureau_bal.shape[0], bureau_bal.shape[1] - 1, np.sum(bureau_bal.dtypes=='category'),
np.sum(bureau_bal.isnull().sum() > 0), bureau_bal.isnull().sum().sum() ],
['Applications Train', app_train.shape[0], app_train.shape[1] - 2, np.sum(app_train.dtypes=='category'),
np.sum(app_train.isnull().sum() > 0), app_train.isnull().sum().sum() ],
['Previous Applications', prev_app.shape[0], prev_app.shape[1] - 2, np.sum(prev_app.dtypes=='category'),
np.sum(prev_app.isnull().sum() > 0), prev_app.isnull().sum().sum() ],
['Installment Payments', inst_pay.shape[0], inst_pay.shape[1] - 2, np.sum(inst_pay.dtypes=='category'),
np.sum(inst_pay.isnull().sum() > 0), inst_pay.isnull().sum().sum() ],
['Credit Card Balance', cc_bal.shape[0], cc_bal.shape[1] - 2, np.sum(cc_bal.dtypes=='category'),
np.sum(cc_bal.isnull().sum() > 0), cc_bal.isnull().sum().sum() ],
['Applications Test', app_test.shape[0], app_test.shape[1] - 1, np.sum(app_test.dtypes=='category'),
np.sum(app_test.isnull().sum() > 0), app_test.isnull().sum().sum() ],
['Bureau', bureau.shape[0], bureau.shape[1] - 2, np.sum(bureau.dtypes=='category'),
np.sum(bureau.isnull().sum() > 0), bureau.isnull().sum().sum() ],
],
columns=['Dataset', 'samples', 'number_features', 'number_categorical_features', 'number_features_missing_values',
'total_number_missing_values']
)
display(eda.head(8)) | Home Credit Default Risk |
1,276,329 | model.evaluate(X_valid,Y_valid )<compute_test_metric> | app_train['is_train'] = 1
app_train['is_test'] = 0
app_test['is_train'] = 0
app_test['is_test'] = 1
print("
Joining the training(app_train)and testing(app_test)dataset for pre-processing into pandas DataFrame 'data'.")
data = pd.concat([app_train, app_test], axis=0)
print("app_train has {0:,} samples and {1} features.".format(app_train.shape[0], app_train.shape[1]-4))
print("app_test has {0:,} samples and {1} features.".format(app_test.shape[0], app_test.shape[1]-3))
print("data has {0:,} samples and {1} features BEFORE one-hot encoding.".format(data.shape[0], data.shape[1]-4))
assert(data.shape[0] == app_train.shape[0] + app_test.shape[0])
assert(data.shape[1] >= max(app_train.shape[1], app_test.shape[1])) | Home Credit Default Risk |
1,276,329 | scores=model.evaluate(test_x,test_y )<compute_test_metric> | def _one_hot_encoding(data):
return pd.get_dummies(data)
print("
Performing one-hot encoding on {} dataset.".format('data'))
data = _one_hot_encoding(data)
print("app has {0:,} samples and {1} features AFTER one-hot encoding.".format(data.shape[0], data.shape[1]-4))
posc_bal = _one_hot_encoding(posc_bal)
prev_app = _one_hot_encoding(prev_app)
inst_pay = _one_hot_encoding(inst_pay)
cc_bal = _one_hot_encoding(cc_bal)
bureau = _one_hot_encoding(bureau ) | Home Credit Default Risk |
1,276,329 | print(f"Accuracy is {scores[1]*100} %" )<predict_on_test> | data_train_test = data.copy() | Home Credit Default Risk |
1,276,329 | output=np.argmax(model.predict(test_x),axis=1 )<create_dataframe> | print("Merge 'Point of Sale Cash Balance' dataset.")
posc_bal_count = posc_bal[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR' ).count()
posc_bal['POSC_BAL_COUNT'] = posc_bal['SK_ID_CURR'].map(posc_bal_count['SK_ID_PREV'])
posc_bal = posc_bal.drop(['SK_ID_PREV'], axis=1)
posc_bal_avg = posc_bal.groupby('SK_ID_CURR' ).mean()
posc_bal_avg.columns = ['pcb_' + col for col in posc_bal_avg.columns]
data = data.merge(right=posc_bal_avg.reset_index() , how='left', on='SK_ID_CURR' ) | Home Credit Default Risk |
1,276,329 | submission=pd.DataFrame()
submission['name']=test_df['Images'].str.split("/", n = 6, expand = True)[5].str.split(".", n = 3, expand = True)[0]
submission['class']=output<categorify> | Home Credit Default Risk | |
1,276,329 | submission['class'] = submission['class'].replace({0:1, 1:0} )<save_to_csv> | print("Merge 'Previous Applications' dataset.")
prev_app_count = prev_app[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR' ).count()
prev_app['PREV_COUNT'] = prev_app['SK_ID_CURR'].map(prev_app_count['SK_ID_PREV'])
prev_app = prev_app.drop(['SK_ID_PREV'], axis=1)
prev_app_avg = prev_app.groupby('SK_ID_CURR' ).mean()
prev_app_avg.columns = ['pa_' + col for col in prev_app_avg.columns]
data = data.merge(right=prev_app_avg.reset_index() , how='left', on='SK_ID_CURR' ) | Home Credit Default Risk |
1,276,329 | submission.to_csv("submission.csv", index=False )<save_to_csv> | print("Merge 'Installments Payments' dataset.")
inst_pay_count = inst_pay[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR' ).count()
inst_pay['INST_PAY_COUNT'] = inst_pay['SK_ID_CURR'].map(inst_pay_count['SK_ID_PREV'])
inst_pay = inst_pay.drop(['SK_ID_PREV'], axis=1)
inst_pay_avg = inst_pay.groupby('SK_ID_CURR' ).mean()
inst_pay_avg.columns = ['ip_' + col for col in inst_pay_avg.columns]
data = data.merge(right=inst_pay_avg.reset_index() , how='left', on='SK_ID_CURR' ) | Home Credit Default Risk |
1,276,329 | submission.to_csv("submission.csv", index=False )<install_modules> | print("Merge 'Credit Card Balance' dataset.")
cc_bal_count = cc_bal[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR' ).count()
cc_bal['CC_BAL_COUNT'] = cc_bal['SK_ID_CURR'].map(cc_bal_count['SK_ID_PREV'])
cc_bal = cc_bal.drop(['SK_ID_PREV'], axis=1)
cc_bal_avg = cc_bal.groupby('SK_ID_CURR' ).mean()
cc_bal_avg.columns = ['ccb_' + col for col in cc_bal_avg.columns]
data = data.merge(right=cc_bal_avg.reset_index() , how='left', on='SK_ID_CURR' ) | Home Credit Default Risk |
1,276,329 | !pip install torchsummary<set_options> | print("Merge 'Bureau' dataset.")
bureau_count = bureau[['SK_ID_CURR', 'SK_ID_BUREAU']].groupby('SK_ID_CURR' ).count()
bureau['BUREAU_COUNT'] = bureau['SK_ID_CURR'].map(bureau_count['SK_ID_BUREAU'])
bureau = bureau.drop(['SK_ID_BUREAU'], axis=1)
bureau_avg = bureau.groupby('SK_ID_CURR' ).mean()
bureau_avg.columns = ['b_' + col for col in bureau_avg.columns]
data = data.merge(right=bureau_avg.reset_index() , how='left', on='SK_ID_CURR' ) | Home Credit Default Risk |
1,276,329 | %matplotlib inline<set_options> | Home Credit Default Risk | |
1,276,329 | def seed_everything(seed=42):
os.environ['PYTHONHASHSEED'] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
def get_logger(
filename='log',
disable_stream_handler=False,
disable_file_handler=False
):
logger = getLogger(__name__)
logger.setLevel(INFO)
if not disable_stream_handler:
handler1 = StreamHandler()
handler1.setFormatter(Formatter("%(message)s"))
logger.addHandler(handler1)
if not disable_file_handler:
handler2 = FileHandler(filename=f"{filename}.log")
handler2.setFormatter(Formatter("%(message)s"))
logger.addHandler(handler2)
return logger<set_options> | scaler = MinMaxScaler()
numerical = ['DAYS_BIRTH', 'AMT_CREDIT', 'DAYS_ID_PUBLISH', 'DAYS_REGISTRATION', 'DAYS_EMPLOYED']
data[numerical] = scaler.fit_transform(data[numerical] ) | Home Credit Default Risk |
1,276,329 | logger = get_logger(
filename='running',
disable_stream_handler=False,
disable_file_handler=False,
)<define_variables> | data_to_use = 'ALL'
if data_to_use == 'data_train_test':
data = data_train_test.copy() | Home Credit Default Risk |
1,276,329 | INPUT_DIR = '.. /input/ailab-ml-training-1/'
ARTIFACT_DIR = '.. /input/v1-ailab1-cv/'
PATH = {
'train': os.path.join(INPUT_DIR, 'train.csv'),
'submission': os.path.join(INPUT_DIR, 'sample_submission.csv'),
'train_image_dir': os.path.join(INPUT_DIR, 'train_images/train_images'),
'test_image_dir': os.path.join(INPUT_DIR, 'test_images/test_images'),
'state_dict': os.path.join(ARTIFACT_DIR, 'best_state_dicts.pth'),
'oof': os.path.join(ARTIFACT_DIR, 'oof.npy'),
'predictions': os.path.join(ARTIFACT_DIR, 'predictions.npy'),
}
ID = 'fname'
TARGET = 'label'
SEED = 42
DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
seed_everything(SEED )<load_from_csv> | print("
Filling NaN values in the dataset using pandas.fillna() using the column mean() value.")
print("Number of NaN values in the dataset BEFORE running pandas.fillna() : {:,}".format(data.isnull().sum().sum()))
data = data.fillna(data.mean())
nan_after = data.isnull().sum().sum()
print("Number of NaN values in the dataset AFTER running pandas.fillna() : {:,}".format(nan_after))
assert(nan_after == 0 ) | Home Credit Default Risk |
1,276,329 | train_df = pd.read_csv(PATH['train'])
submission_df = pd.read_csv(PATH['submission'] )<feature_engineering> | del posc_bal, posc_bal_count, posc_bal_avg, bureau_bal, app_train, app_test
del prev_app, prev_app_count, prev_app_avg, inst_pay, inst_pay_count, inst_pay_avg, cc_bal, cc_bal_count, cc_bal_avg
del bureau, bureau_count, bureau_avg, data_train_test
gc.collect() | Home Credit Default Risk |
1,276,329 | train_df[ID] = train_df[ID].apply(lambda x: os.path.join(PATH['train_image_dir'], x))<prepare_output> | print("
Separating the training and testing dataset after completing pre-processing.")
train = data[data['is_train'] == 1]
target = train['TARGET']
train = train.drop(['TARGET', 'SK_ID_CURR', 'is_test', 'is_train'], axis=1)
test = data[data['is_test'] == 1]
test_id = test['SK_ID_CURR']
test = test.drop(['TARGET', 'SK_ID_CURR', 'is_test', 'is_train'], axis=1)
print("train has {:,} samples and {} features.".format(train.shape[0], train.shape[1]))
print("test has {:,} samples and {} features.".format(test.shape[0], test.shape[1])) | Home Credit Default Risk |
1,276,329 | def softmax(logits):
return np.exp(logits)/ np.sum(np.exp(logits), axis=1, keepdims=True )<feature_engineering> | print("
Splitting the training dataset into actual training and validation datasets")
X_train, X_val, y_train, y_val = train_test_split(train, target, test_size=0.2, random_state=42)
assert(train.shape[0] == X_train.shape[0] + X_val.shape[0])
assert(X_train.shape[1] == train.shape[1])
assert(X_val.shape[1] == train.shape[1])
assert(target.shape[0] == y_train.shape[0] + y_val.shape[0])
print("training dataset has {0:,} samples and {1} features.".format(X_train.shape[0], X_train.shape[1]))
print("validating dataset has {0:,} samples and {1} features.".format(X_val.shape[0], X_val.shape[1])) | Home Credit Default Risk |
1,276,329 | predictions = np.load(PATH['predictions'])
predictions = softmax(predictions)
predictions_label, predictions_proba = np.argmax(predictions, axis=1), np.max(predictions, axis=1)
pseudo_df = submission_df.copy()
pseudo_df[TARGET] = predictions_label
pseudo_df['proba'] = predictions_proba
pseudo_df = pseudo_df.loc[pseudo_df['proba'] > 0.999, :]
pseudo_df = pseudo_df.drop('proba', axis=1)
pseudo_df[ID] = pseudo_df[ID].apply(lambda x: os.path.join(PATH['test_image_dir'], x))<count_unique_values> | run_mode = 'LGBM_KFold' | Home Credit Default Risk |
1,276,329 |
<train_model> | if run_mode == 'grid_search_LGBM':
perc_samples = 0.15
print("
Preparing to run Hyperparameters tunning with GridSearchCV using {0:.2f}% of the training samples".format(perc_samples * 100))
X_train_small = X_train[:int(perc_samples * X_train.shape[0])]
y_train_small = y_train[:int(perc_samples * y_train.shape[0])]
X_val_small = X_val[:int(perc_samples * X_val.shape[0])]
y_val_small = y_val[:int(perc_samples * y_val.shape[0])]
estimator = lgb.LGBMClassifier(
objective='binary',
metric='auc',
num_iteration=5000,
verbose=1,
silent=False,
colsample_bytree=.8,
subsample=.9,
reg_alpha=.1,
reg_lambda=.1,
min_split_gain=.01,
min_child_weight=1,
)
parameters = {
'boosting_type': ['gbdt'],
'num_leaves': [35, 48, 80],
'min_data_in_leaf': [20],
'learning_rate': [0.005],
'max_depth': [7],
}
scorer = make_scorer(roc_auc_score)
grid_obj = GridSearchCV(estimator=estimator,
param_grid=parameters,
scoring=scorer)
start = time()
grid_fit = grid_obj.fit(X_train_small, y_train_small)
end = time()
grid_fit_time =(end - start)/ 60
print("
GridSearchCV estimator fit time: {0:.2f} minutes".format(( end - start)/ 60))
print("
Preparing to run Hyperparameters tunning with GridSearchCV using {0:.2f}% of the training samples".format(perc_samples * 100))
print("
Parameters used for tunning:
{}".format(parameters))
best_est = grid_obj.best_estimator_
print("
Best Estimator:
{}
".format(best_est))
best_score = grid_obj.best_score_
print("
Best Estimator Score: {}
".format(best_score))
best_params = grid_obj.best_params_
print("
Best Hyperparameters that yield the best score:
{}
".format(best_params))
Unoptimized Estimator prediction score on Validation set: \t{}".format(roc_auc_score(y_val_small, pred_val)))
best_pred_val = best_est.predict(X_val_small)
print("
Optimized Estimator prediction score on Validation set: \t{}".format(roc_auc_score(y_val_small, best_pred_val)))
| Home Credit Default Risk |
1,276,329 | class KmnistDataset(Dataset):
def __init__(
self,
paths,
labels,
transform=None,
with_memory_cache=False,
):
super().__init__()
self.paths = paths
self.labels = labels
self.transform = transform
self.with_memory_cache = with_memory_cache
if with_memory_cache:
self.images = [None,] * len(paths)
def load_image(self, path):
image = cv2.imread(path)
return image
def __len__(self):
return len(self.paths)
def __getitem__(self, idx):
if self.with_memory_cache:
image = self.images[idx]
if image is None:
path = self.paths[idx]
image = self.load_image(path)
self.images[idx] = image
else:
path = self.paths[idx]
image = self.load_image(path)
label = self.labels[idx]
if self.transform is not None:
image = self.transform(image=image)['image']
return image, label<create_dataframe> | if run_mode == 'grid_search_RFR':
perc_samples = 0.15
print("
Preparing to run Hyperparameters tunning with GridSearchCV using {0:.2f}% of the training samples".format(perc_samples * 100))
features_train_small = X_train[:int(perc_samples * X_train.shape[0])]
target_train_small = y_train[:int(perc_samples * y_train.shape[0])]
features_val_small = X_val[:int(perc_samples * X_val.shape[0])]
target_val_small = y_val[:int(perc_samples * y_val.shape[0])]
estimator = RandomForestRegressor(n_jobs=-1,
random_state=42,
verbose=0)
parameters = {
'n_estimators': [130, 135, 145],
'min_samples_leaf': [55, 62, 75],
'max_features': [0.2],
'min_samples_split': [2],
}
scorer = make_scorer(roc_auc_score)
grid_obj = GridSearchCV(estimator=estimator,
param_grid=parameters,
scoring=scorer)
start = time()
grid_fit = grid_obj.fit(features_train_small, target_train_small)
end = time()
grid_fit_time =(end - start)/ 60
print("
GridSearchCV estimator fit time: {0:.2f} minutes".format(( end - start)/ 60))
best_est = grid_obj.best_estimator_
print("
Best Estimator:
{}
".format(best_est))
best_score = grid_obj.best_score_
print("
Best Estimator Score: {}
".format(best_score))
best_params = grid_obj.best_params_
print("
Best Hyperparameters that yield the best score:
{}
".format(best_params))
pred_val =(estimator.fit(features_train_small, target_train_small)).predict(features_val_small)
print("
Unoptimized Estimator prediction score on Validation set: \t{}".format(roc_auc_score(target_val_small, pred_val)))
best_pred_val = best_est.predict(features_val_small)
print("
Optimized Estimator prediction score on Validation set: \t{}".format(roc_auc_score(target_val_small, best_pred_val)))
| Home Credit Default Risk |
1,276,329 | def get_dataloader(
X,
Y,
transform=None,
with_memory_cache=False,
batch_size=32,
shuffle=False,
num_workers=0,
pin_memory=True,
):
dataset = KmnistDataset(
X,
Y,
transform=transform,
with_memory_cache=with_memory_cache,
)
loader = DataLoader(
dataset=dataset,
batch_size=batch_size,
shuffle=shuffle,
num_workers=num_workers,
pin_memory=pin_memory,
)
return loader<groupby> | if run_mode == 'train_estimator_LGBM':
params = {
'boosting_type': 'dart',
'objective': 'binary',
'learning_rate': 0.1,
'min_data_in_leaf': 30,
'num_leaves': 31,
'max_depth': -1,
'feature_fraction': 0.5,
'scale_pos_weight': 2,
'drop_rate': 0.02,
'metric': 'auc',
'num_boost_round': 200,
}
data_split = 'kfold'
if data_split == 'train_test_split':
lgb_train = lgb.Dataset(data=X_train, label=y_train)
lgb_eval = lgb.Dataset(data=X_val, label=y_val)
start = time()
estimator = lgb.train(
params = params,
train_set = lgb_train,
valid_sets = lgb_eval,
early_stopping_rounds = 350,
verbose_eval = 200
)
end = time()
elif data_split == 'kfold':
lgb_train_cv = lgb.Dataset(data=train, label=target)
start = time()
cv_results = lgb.cv(
params = params,
train_set = lgb_train_cv,
nfold = 2,
early_stopping_rounds = 50,
stratified = True,
verbose_eval = 50
)
optimum_boost_rounds = np.argmax(cv_results['auc-mean'])
print('Optimum boost rounds = {}'.format(optimum_boost_rounds))
print('Best LGBM CV result = {}'.format(np.max(cv_results['auc-mean'])))
estimator = lgb.train(
params = params,
train_set = lgb_train_cv,
num_boost_round = optimum_boost_rounds,
verbose_eval = 50
)
end = time()
print("
Estimator fit time: {} seconds".format(int(round(end - start))))
lgb.plot_importance(estimator, figsize=(12, 12), max_num_features=30); | Home Credit Default Risk |
1,276,329 | num_samples = 20
sample = train_df.groupby(TARGET ).apply(lambda df: df.sample(num_samples))
fnames = sample[ID].to_list()
labels = sample[TARGET].to_list()<concatenate> | print(estimator ) | Home Credit Default Risk |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.