kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
1,020,569 | train = pd.read_csv('/kaggle/input/seriestemporales-diplomado/train.txt', sep = ';', index_col=0)
test = pd.read_csv('/kaggle/input/seriestemporales-diplomado/test.txt', sep = ';', index_col=0 )<rename_columns> | def GP(data):
return(GPI(data)+GPII(data)+GPIII(data)) /3.
| Home Credit Default Risk |
1,020,569 | train = train.set_index('Fecha_Hora' )<feature_engineering> | from sklearn.metrics import roc_auc_score | Home Credit Default Risk |
1,020,569 | test['Fecha_Hora'] = test['Fecha'] + ' ' + test['Hora']<drop_column> | roc_auc_score(train.TARGET,GPI(train)) | Home Credit Default Risk |
1,020,569 | test = test.drop('Fecha', axis = 1)
test = test.drop('Hora', axis = 1)
test.head()<drop_column> | roc_auc_score(train.TARGET,GPII(train)) | Home Credit Default Risk |
1,020,569 | test = test[['Fecha_Hora','Poder_Reactivo_Global', 'Voltaje', 'Intensidad_Global', 'Medida_1',
'Medida_2', 'Medida_3']]<drop_column> | roc_auc_score(train.TARGET,GPIII(train)) | Home Credit Default Risk |
1,020,569 | test = test.set_index('Fecha_Hora' )<concatenate> | roc_auc_score(train.TARGET,GP(train)) | Home Credit Default Risk |
1,020,569 | <define_variables><EOS> | Submission = pd.DataFrame({ 'SK_ID_CURR': ID,'TARGET': GP(test ).values })
Submission.to_csv("sample_submission.csv", index=False ) | Home Credit Default Risk |
1,013,173 | <SOS> metric: AUC Kaggle data source: home-credit-default-risk<import_modules> | sns.set(style="whitegrid", color_codes=True)
np.random.seed(sum(map(ord, "categorical")))
print(os.listdir(".. /input"))
application_train = pd.read_csv(".. /input/application_train.csv")
application_test = pd.read_csv(".. /input/application_test.csv")
bureau = pd.read_csv(".. /input/bureau.csv")
bureau_balance = ... | Home Credit Default Risk |
1,013,173 | import seaborn as sns<count_missing_values> | sns.set(rc={'figure.figsize':(14.7,8.27)} ) | Home Credit Default Risk |
1,013,173 | dataset.isnull().sum()<define_variables> | bureau_cat = [f_ for f_ in bureau.columns if bureau[f_].dtype == 'object']
dummy_bureau = pd.get_dummies(bureau, columns=bureau_cat)
dummy_bureau.head() | Home Credit Default Risk |
1,013,173 | set_test = dataset.iloc[-8760:,:]<define_variables> | bureau_balance_cat = [f_ for f_ in bureau_balance.columns if bureau_balance[f_].dtype == 'object']
dummy_bureau_balance = pd.get_dummies(bureau_balance, columns=bureau_balance_cat)
dummy_bureau_balance.head() | Home Credit Default Risk |
1,013,173 | set_train = dataset.iloc[:-8760,:]<set_options> | avg_bureau_balance = dummy_bureau_balance.groupby('SK_ID_BUREAU' ).mean()
avg_bureau_balance.head() | Home Credit Default Risk |
1,013,173 | set_train<set_options> | bureau_all = dummy_bureau.merge(right=avg_bureau_balance.reset_index() , how='left', on='SK_ID_BUREAU', suffixes=('', '_balance_'))
bureau_all.head() | Home Credit Default Risk |
1,013,173 | set_test<count_missing_values> | bureau_per_curr = bureau_all[['SK_ID_CURR', 'SK_ID_BUREAU']].groupby('SK_ID_CURR' ).count()
bureau_per_curr.head(10)
bureau_all['SK_ID_BUREAU'] = bureau_all['SK_ID_CURR'].map(bureau_per_curr['SK_ID_BUREAU'] ) | Home Credit Default Risk |
1,013,173 | droping_list_all=[]
for j in range(0,7):
if not dataset.iloc[:, j].notnull().all() :
droping_list_all.append(j)
droping_list_all<data_type_conversions> | avg_bureau = bureau_all.groupby('SK_ID_CURR' ).mean()
avg_bureau.head(10 ) | Home Credit Default Risk |
1,013,173 | set_train = set_train.apply(pd.to_numeric )<data_type_conversions> | del avg_bureau_balance, dummy_bureau, dummy_bureau_balance, bureau_all | Home Credit Default Risk |
1,013,173 | set_train.iloc[:,0]=set_train.iloc[:,0].fillna(set_train.iloc[:,0].mean() )<data_type_conversions> | credit_card_balance_cat = [f_ for f_ in credit_card_balance.columns if credit_card_balance[f_].dtype == 'object']
dummy_credit_card_balance = pd.get_dummies(credit_card_balance, columns=credit_card_balance_cat)
dummy_credit_card_balance.head() | Home Credit Default Risk |
1,013,173 | set_train.iloc[:,1]=set_train.iloc[:,1].fillna(set_train.iloc[:,1].mean() )<count_missing_values> | credit_card_per_curr = dummy_credit_card_balance[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR' ).count()
dummy_credit_card_balance['SK_ID_PREV'] = dummy_credit_card_balance['SK_ID_CURR'].map(credit_card_per_curr['SK_ID_PREV'])
avg_credit_card = dummy_credit_card_balance.groupby('SK_ID_CURR' ).mean()
avg_credit_ca... | Home Credit Default Risk |
1,013,173 | set_train.isnull().sum()<drop_column> | del dummy_credit_card_balance | Home Credit Default Risk |
1,013,173 | set_train = set_train[['Intensidad_Global', 'Medida_1', 'Medida_2', 'Medida_3', 'Poder_Reactivo_Global', 'Voltaje',
'Poder_Activo_Global']]
set_train<drop_column> | installments_payments_cat = [f_ for f_ in installments_payments.columns if installments_payments[f_].dtype == 'object']
dummy_installments_payments = pd.get_dummies(installments_payments, columns=installments_payments_cat)
dummy_installments_payments.head() | Home Credit Default Risk |
1,013,173 | set_test = set_test[['Intensidad_Global', 'Medida_1', 'Medida_2', 'Medida_3', 'Poder_Reactivo_Global', 'Voltaje',
'Poder_Activo_Global']]
set_test<normalization> | installments_per_curr = dummy_installments_payments[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR' ).count()
dummy_installments_payments['SK_ID_PREV'] = dummy_installments_payments['SK_ID_CURR'].map(installments_per_curr['SK_ID_PREV'])
avg_installments = dummy_installments_payments.groupby('SK_ID_CURR' ).mean()
av... | Home Credit Default Risk |
1,013,173 | values = set_train.values
scaler = MinMaxScaler(feature_range=(0, 1))
scaled = scaler.fit_transform(values )<prepare_x_and_y> | del dummy_installments_payments | Home Credit Default Risk |
1,013,173 | values = scaled
n_train_time_start = 1920000
n_train_time = 2000000
train = values[n_train_time_start:n_train_time, :]
test = values[n_train_time:, :]
train_X, train_y = train[:, :-1], train[:, -1]
test_X, test_y = test[:, :-1], test[:, -1]
train_X = train_X.reshape(( train_X.shape[0], 1, train_X.shape[1]))
test_X = te... | pos_cash_balance_cat = [f_ for f_ in POS_CASH_balance.columns if POS_CASH_balance[f_].dtype == 'object']
dummy_POS_CASH_balance = pd.get_dummies(POS_CASH_balance, columns=pos_cash_balance_cat)
dummy_POS_CASH_balance.head() | Home Credit Default Risk |
1,013,173 | def root_mean_squared_error(y_true, y_pred):
return K.sqrt(K.mean(K.square(y_pred - y_true)) )<import_modules> | pos_per_curr = dummy_POS_CASH_balance[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR' ).count()
dummy_POS_CASH_balance['SK_ID_PREV'] = dummy_POS_CASH_balance['SK_ID_CURR'].map(pos_per_curr['SK_ID_PREV'])
avg_pos = dummy_POS_CASH_balance.groupby('SK_ID_CURR' ).mean()
avg_pos.head()
| Home Credit Default Risk |
1,013,173 |
<compute_train_metric> | del dummy_POS_CASH_balance | Home Credit Default Risk |
1,013,173 | yhat = model.predict(test_X)
test_X = test_X.reshape(( test_X.shape[0], 6))
inv_yhat = np.concatenate(( yhat, test_X[:, -6:]), axis=1)
inv_yhat = scaler.inverse_transform(inv_yhat)
inv_yhat = inv_yhat[:,0]
test_y = test_y.reshape(( len(test_y), 1))
inv_y = np.concatenate(( test_y, test_X[:, -6:]), axis=1)
inv_y = s... | previous_application_cat = [f_ for f_ in previous_application.columns if previous_application[f_].dtype == 'object']
dummy_previous_application = pd.get_dummies(previous_application, columns=previous_application_cat)
dummy_previous_application.head() | Home Credit Default Risk |
1,013,173 | set_test = set_test.apply(pd.to_numeric )<count_missing_values> | previous_per_curr = dummy_previous_application[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR' ).count()
dummy_previous_application['SK_ID_PREV'] = dummy_previous_application['SK_ID_CURR'].map(previous_per_curr['SK_ID_PREV'])
dummy_previous_application.head(10 ) | Home Credit Default Risk |
1,013,173 | set_test.isnull().sum()<predict_on_test> | avg_previous = dummy_previous_application.groupby('SK_ID_CURR' ).mean()
avg_previous.head() | Home Credit Default Risk |
1,013,173 | set_test_to_predict = set_test[['Intensidad_Global', 'Medida_1', 'Medida_2', 'Medida_3', 'Poder_Reactivo_Global', 'Voltaje']]<set_options> | del dummy_previous_application | Home Credit Default Risk |
1,013,173 | set_test_to_predict<normalization> | del previous_application | Home Credit Default Risk |
1,013,173 | values = set_test_to_predict.values
scaler_test = MinMaxScaler(feature_range=(0, 1))
scaled_test = scaler_test.fit_transform(values )<train_model> | y = application_train['TARGET']
del application_train['TARGET'] | Home Credit Default Risk |
1,013,173 | to_predict = scaled_test
to_predict = to_predict.reshape(( to_predict.shape[0], 1, to_predict.shape[1]))<predict_on_test> | cat = [f for f in application_train.columns if application_train[f].dtype == 'object']
for f_ in cat:
application_train[f_], indexer = pd.factorize(application_train[f_])
application_test[f_] = indexer.get_indexer(application_test[f_])
for f_ in cat:
print('{}: {}'.format(f_, application_train[f_].unique()))
applicat... | Home Credit Default Risk |
1,013,173 | ypredict = model.predict(to_predict )<concatenate> | application_train.isnull().sum().sort_values(ascending=False ) | Home Credit Default Risk |
1,013,173 | to_predict = to_predict.reshape(( to_predict.shape[0], 6))
inv_ypredict = np.concatenate(( to_predict[:, :], ypredict), axis=1 )<normalization> | application_train = application_train.merge(right=avg_bureau.reset_index() , how='left', on='SK_ID_CURR')
application_test = application_test.merge(right=avg_bureau.reset_index() , how='left', on='SK_ID_CURR')
| Home Credit Default Risk |
1,013,173 | inv_ypredict = scaler.inverse_transform(inv_ypredict)
ypredict_final = inv_ypredict[:,-1]<create_dataframe> | application_train = application_train.merge(right=avg_previous.reset_index() , how='left', on='SK_ID_CURR')
application_test = application_test.merge(right=avg_previous.reset_index() , how='left', on='SK_ID_CURR')
| Home Credit Default Risk |
1,013,173 | prediction = pd.DataFrame(ypredict_final )<prepare_output> | application_train = application_train.merge(right=avg_pos.reset_index() , how='left', on='SK_ID_CURR')
application_test = application_test.merge(right=avg_pos.reset_index() , how='left', on='SK_ID_CURR' ) | Home Credit Default Risk |
1,013,173 | set_test['Poder_Activo_Global'] = ypredict_final<set_options> | application_train = application_train.merge(right=avg_installments.reset_index() , how='left', on='SK_ID_CURR')
application_test = application_test.merge(right=avg_installments.reset_index() , how='left', on='SK_ID_CURR' ) | Home Credit Default Risk |
1,013,173 | set_test<define_variables> | application_train = application_train.merge(right=avg_credit_card.reset_index() , how='left', on='SK_ID_CURR')
application_test = application_test.merge(right=avg_credit_card.reset_index() , how='left', on='SK_ID_CURR' ) | Home Credit Default Risk |
1,013,173 | enviar = set_test[['Poder_Activo_Global']]<feature_engineering> | X = application_train
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 42 ) | Home Credit Default Risk |
1,013,173 | enviar['Fecha_Hora'] = enviar.index<drop_column> | train_data=lgb.Dataset(x_train,label=y_train)
test_data=lgb.Dataset(x_test,label=y_test ) | Home Credit Default Risk |
1,013,173 | enviar = enviar.reset_index(drop=True)
enviar = enviar[['Fecha_Hora', 'Poder_Activo_Global']]
enviar<save_to_csv> | params = {
'boosting_type': 'gbdt',
'objective': 'binary',
'metric': {'binary_logloss', 'auc'},
'metric_freq': 1,
'is_training_metric': True,
'max_bin': 255,
'learning_rate': 0.1,
'num_leaves': 63,
'tree_learner': 'serial',
'feature_fraction': 0.8,
'bagging_fraction': 0.8,
'bagging_freq': 5,
'min_data_in_leaf': 50,
'mi... | Home Credit Default Risk |
1,013,173 | enviar.to_csv('Output.csv',index=False )<load_from_csv> | clf = lgb.train(params, train_data, 2000, valid_sets=test_data, early_stopping_rounds= 40, verbose_eval= 10 ) | Home Credit Default Risk |
1,013,173 | df_train_with_no_id = pd.read_csv('.. /input/train.csv')
df_train_with_no_id=df_train_with_no_id.drop(['id'],1)
X = np.array(df_train_with_no_id.drop(['diagnosis'],1))
y = np.array(df_train_with_no_id['diagnosis'])
X.shape
model = linear_model.LogisticRegression()
model.fit(X,y)
predictions = model.predict(X)
mode... | y_prediction=clf.predict(application_train)
| Home Credit Default Risk |
1,013,173 | datos_submit = pd.read_csv('.. /input/dataForSubmission.csv')
ids=datos_submit['id']
datos_submit=datos_submit.drop(['id'],1)
predictions=model.predict(datos_submit)
predictions
resultados=DataFrame({'Id': ids, 'Predicted': predictions})
resultados
resultados.to_csv('resultados_1.csv', index = False )<categorify> | score = roc_auc_score(y, y_prediction)
print("Overall AUC: {:.3f}".format(score)) | Home Credit Default Risk |
1,013,173 | class VowelConsonantDataset(Dataset):
def __init__(self, file_path,train=True,transform=None):
self.transform = transform
self.file_path=file_path
self.train=train
self.file_names=[file for _,_,files in os.walk(self.file_path)for file in files]
self.len = len(self.file_names)
if self.train:
self.classes_mapping=self.g... | submit = clf.predict(application_test ) | Home Credit Default Risk |
1,013,173 | train_on_gpu = torch.cuda.is_available()<set_options> | application_test['TARGET'] = submit
application_test[['SK_ID_CURR', 'TARGET']].to_csv('submission.csv', index=False, float_format='%.8f' ) | Home Credit Default Risk |
1,483,510 | device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
device<load_pretrained> | application_train=pd.read_csv(r".. /input/application_train.csv")
application_test=pd.read_csv(r".. /input/application_test.csv")
bureau_balance=pd.read_csv(r".. /input/bureau_balance.csv")
bureau=pd.read_csv(r".. /input/bureau.csv")
credit_card_balance=pd.read_csv(r".. /input/credit_card_balance.csv")
POS_cash=pd... | Home Credit Default Risk |
1,483,510 | os.mkdir('.. /Inputs')
with zipfile.ZipFile(".. /input/padhai-hindi-vowel-consonant-classification/train.zip","r")as z:
z.extractall(".. /Inputs/")
with zipfile.ZipFile(".. /input/padhai-hindi-vowel-consonant-classification/test.zip","r")as z:
z.extractall(".. /Inputs/" )<set_options> | total_null=application_train.isnull().sum().sort_values(ascending=False)
percentage=(application_train.isnull().sum() /application_train.isnull().count() *100 ).sort_values(ascending=False)
missing_train_data=pd.concat([total_null,percentage],axis=1,keys=["Total_null","Percentage"] ) | Home Credit Default Risk |
1,483,510 | transform = transforms.Compose([
transforms.ColorJitter() ,
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor() , ] )<split> | total_null=POS_cash.isnull().sum().sort_values(ascending=False)
percentage=(POS_cash.isnull().sum() /POS_cash.isnull().count() *100 ).sort_values(ascending=False)
missing_POS_data=pd.concat([total_null,percentage],axis=1,keys=["Total_null","Percentage"] ) | Home Credit Default Risk |
1,483,510 | batch_size = 60
full_data=VowelConsonantDataset(".. /Inputs/train",train=True,transform=transform)
train_size = int(0.9 * len(full_data))
test_size = len(full_data)- train_size
train_data, validation_data = random_split(full_data, [train_size, test_size])
train_loader = torch.utils.data.DataLoader(train_data, batch_s... | total_null=bureau.isnull().sum().sort_values(ascending=False)
percentage=(bureau.isnull().sum() /bureau.isnull().count() *100 ).sort_values(ascending=False)
missing_bureau_data=pd.concat([total_null,percentage],axis=1,keys=["Total_null","Percentage"])
missing_bureau_data.head(15 ) | Home Credit Default Risk |
1,483,510 | from torchvision import models<choose_model_class> | total_null=bureau_balance.isnull().sum().sort_values(ascending=False)
percentage=(bureau_balance.isnull().sum() /bureau_balance.isnull().count() *100 ).sort_values(ascending=False)
missing_bureau_balance=pd.concat([total_null,percentage],axis=1,keys=["Total_null","Percentage"])
missing_bureau_balance.head(15 ) | Home Credit Default Risk |
1,483,510 | class MyModel(nn.Module):
def __init__(self, num_classes1, num_classes2):
super(MyModel, self ).__init__()
self.model_snet = models.mobilenet_v2(pretrained=True)
final_in_features = self.model_snet.classifier[1].in_features
mod_classifier = list(self.model_snet.classifier.children())[:-1]
self.model_snet.classifier = ... | total_null=previous_application.isnull().sum().sort_values(ascending=False)
percentage=(previous_application.isnull().sum() /previous_application.isnull().count() *100 ).sort_values(ascending=False)
missing_previous_application=pd.concat([total_null,percentage],axis=1,keys=["Total_null","Percentage"])
missing_previo... | Home Credit Default Risk |
1,483,510 | net = MyModel(10,10 )<data_type_conversions> | total_null=install_payment.isnull().sum().sort_values(ascending=False)
percentage=(install_payment.isnull().sum() /install_payment.isnull().count() *100 ).sort_values(ascending=False)
missing_installment=pd.concat([total_null,percentage],axis=1,keys=["Total_null","Percentage"])
missing_installment.head() | Home Credit Default Risk |
1,483,510 | net = net.to(device )<categorify> | total_null=application_test.isnull().sum().sort_values(ascending=False)
percentage=(application_test.isnull().sum() /application_test.isnull().count() *100 ).sort_values(ascending=False)
missing_app_test=pd.concat([total_null,percentage],axis=1,keys=["Total_null","Percentage"])
missing_app_test.head(15 ) | Home Credit Default Risk |
1,483,510 | def evaluation(dataloader):
total, correct = 0, 0
for data in dataloader:
inputs, labels = data
inputs, labels = inputs.to(device), labels.to(device)
_, actual_v = torch.max(labels[:,0,:].data, 1)
_, actual_c = torch.max(labels[:,1,:].data, 1)
outputs_v,outputs_c = net(inputs)
_, pred_v = torch.max(outputs_v.data, ... | application_train.select_dtypes("object" ).nunique() | Home Credit Default Risk |
1,483,510 | loss_fn = nn.CrossEntropyLoss()
plist = [
{'params': net.fc1.parameters() , 'lr': 5e-3},
{'params': net.fc2.parameters() , 'lr': 5e-3}
]
lr=0.01
opt = optim.SGD(net.parameters() ,lr=0.01,momentum=0.9,nesterov=True )<init_hyperparams> | lbl=LabelEncoder()
lbl_count=0
for i in application_train:
if application_train[i].dtype=='object':
if len(list(application_train[i].unique())) <= 2:
lbl.fit(application_train[i])
application_train[i]=lbl.transform(application_train[i])
application_test[i]=lbl.transform(application_test[i])
lbl_count +=1
print('%d c... | Home Credit Default Risk |
1,483,510 | %%time
loss_arr = []
loss_epoch_arr = []
max_epochs = 10
min_loss = 1000
best_model = None
for epoch in range(max_epochs):
for i, data in enumerate(train_loader, 0):
inputs, labels = data
inputs, labels = inputs.to(device), labels.to(device)
labels_v = labels[:,0,:]
labels_c = labels[:,1,:]
_, actual_v = torch.max(lab... | application_train.select_dtypes("object" ).nunique() | Home Credit Default Risk |
1,483,510 | net.eval()
plist=[]
fn_list=[]
for inputs_test, fn in test_loader:
inputs_test=inputs_test.to(device)
out1,out2=net.forward(inputs_test)
_,pred1=torch.max(out1,1)
pred1=pred1.tolist()
_,pred2=torch.max(out2,1)
pred2=pred2.tolist()
for x,y,z in zip(pred1,pred2,fn):
p="V"+str(x)+"_"+"C"+str(y)
plist.append(p)
fn_li... | application_train=pd.get_dummies(application_train)
application_test=pd.get_dummies(application_test)
print("application_train feature shape:",application_train.shape)
print("application_test feature shape:",application_test.shape ) | Home Credit Default Risk |
1,483,510 | submission = pd.DataFrame({"ImageId":fn_list, "Class":plist})
submission.head()<save_to_csv> | train_target=application_train['TARGET']
application_train,application_test=application_train.align(application_test,axis=1,join='inner' ) | Home Credit Default Risk |
1,483,510 | submission.to_csv('submission.csv', index=False )<save_to_csv> | application_train['TARGET']=train_target | Home Credit Default Risk |
1,483,510 | submission.to_csv('submission.csv', index=False )<import_modules> | application_train.isnull().sum() | Home Credit Default Risk |
1,483,510 | import numpy as np
import pandas as pd
from sklearn.neighbors import KNeighborsClassifier<load_from_csv> | application_train.isnull().sum() | Home Credit Default Risk |
1,483,510 | traindf = pd.read_csv(".. /input/train.csv" )<drop_column> | prev_category = pd.get_dummies(previous_application)
bureau_category = pd.get_dummies(bureau)
pos_category = pd.get_dummies(POS_cash)
credit_category= pd.get_dummies(credit_card_balance)
| Home Credit Default Risk |
1,483,510 | traindf.drop(['Gender'], axis=1, inplace=True )<create_dataframe> | application_train=application_train.fillna(0)
application_test=application_test.fillna(0 ) | Home Credit Default Risk |
1,483,510 | traindata = traindf.values<define_search_space> | application_test['is_test'] = 1
application_test['is_train'] = 0
application_train['is_test'] = 0
application_train['is_train'] = 1
Y = application_train['TARGET']
train_X = application_train.drop(['TARGET'], axis = 1)
test_id = application_train['SK_ID_CURR']
test_X = application_test
data = pd.concat([train_X, test_... | Home Credit Default Risk |
1,483,510 | descriptores,clases = traindata[:,0:-1],traindata[:,-1]<define_variables> | prev_apps = previous_application[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR' ).count()
previous_application['SK_ID_PREV'] = previous_application['SK_ID_CURR'].map(prev_apps['SK_ID_PREV'])
prev_apps_avg = previous_application.groupby('SK_ID_CURR' ).mean()
prev_apps_avg.columns = ['p_' + col for col in prev_apps_... | Home Credit Default Risk |
1,483,510 | clases = [1 if clase==True else 0 for clase in clases]<choose_model_class> | bureau_avg = bureau.groupby('SK_ID_CURR' ).mean()
bureau_avg['buro_count'] = bureau[['SK_ID_BUREAU','SK_ID_CURR']].groupby('SK_ID_CURR' ).count() ['SK_ID_BUREAU']
bureau_avg.columns = ['b_' + f_ for f_ in bureau_avg.columns]
data = data.merge(right=bureau_avg.reset_index() , how='left', on='SK_ID_CURR' ) | Home Credit Default Risk |
1,483,510 | knn = KNeighborsClassifier(n_neighbors=1 )<train_model> | install_pay= install_payment[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR' ).count()
install_payment['SK_ID_PREV'] = install_payment['SK_ID_CURR'].map(install_pay['SK_ID_PREV'])
avg_inst = install_payment.groupby('SK_ID_CURR' ).mean()
avg_inst.columns = ['i_' + f_ for f_ in avg_inst.columns]
data = data.merge(rig... | Home Credit Default Risk |
1,483,510 | knn.fit(descriptores,clases )<load_from_csv> | pos_cash = POS_cash[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR' ).count()
POS_cash['SK_ID_PREV'] = POS_cash['SK_ID_CURR'].map(pos_cash['SK_ID_PREV'])
POS_avg = POS_cash.groupby('SK_ID_CURR' ).mean()
data = data.merge(right=POS_avg.reset_index() , how='left', on='SK_ID_CURR' ) | Home Credit Default Risk |
1,483,510 | testdf = pd.read_csv(".. /input/test.csv")
testdf.drop(['Gender'], axis=1, inplace=True)
testdata = testdf.values<predict_on_test> | credit_balns= credit_card_balance[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR' ).count()
credit_card_balance['SK_ID_PREV'] = credit_card_balance['SK_ID_CURR'].map(credit_balns['SK_ID_PREV'])
avg_credit_bal = credit_card_balance.groupby('SK_ID_CURR' ).mean()
avg_credit_bal.columns = ['credit_bal_' + f_ for f_ in ... | Home Credit Default Risk |
1,483,510 | predicciones = knn.predict(testdata )<define_variables> | ignore_features = ['SK_ID_CURR', 'is_train', 'is_test']
relevant_features = [col for col in data.columns if col not in ignore_features]
trainX = data[data['is_train'] == 1][relevant_features]
testX = data[data['is_test'] == 1][relevant_features] | Home Credit Default Risk |
1,483,510 | predicciones = [True if prediccion==1 else False for prediccion in predicciones]<create_dataframe> | x_train, x_val, y_train, y_val = train_test_split(trainX, Y, test_size=0.2, random_state=18)
lgb_train = lgb.Dataset(data=x_train, label=y_train)
lgb_eval = lgb.Dataset(data=x_val, label=y_val ) | Home Credit Default Risk |
1,483,510 | soldf = pd.DataFrame(list(enumerate(predicciones)) )<rename_columns> | params = {'task': 'train', 'boosting_type': 'gbdt', 'objective': 'binary', 'metric': 'auc',
'learning_rate': 0.01, 'num_leaves': 48, 'num_iteration': 5000, 'verbose': 0 ,
'colsample_bytree':.8, 'subsample':.9, 'max_depth':7, 'reg_alpha':.1, 'reg_lambda':.1,
'min_split_gain':.01, 'min_child_weight':1}
model = lgb.train(... | Home Credit Default Risk |
1,483,510 | soldf.columns = ['Id','Prediction']<save_to_csv> | preds = model.predict(testX)
sub = application_test[['SK_ID_CURR']].copy()
sub['TARGET'] = preds
sub.to_csv('sub.csv', index= False)
sub.head(10 ) | Home Credit Default Risk |
1,432,477 | soldf.to_csv("submission.csv",sep=',',index=False )<set_options> | M1 = pd.read_csv('.. /input/diversity/LGBM.798.csv')
M2 = pd.read_csv('.. /input/ingredients/WEIGHT_AVERAGE_RANK2.csv')
M3 = pd.read_csv('.. /input/neural/sub_nn.csv')
M4 = pd.read_csv('.. /input/genetic/pure_submission.csv')
M5 = pd.read_csv('.. /input/diversity/xgb.796.csv' ) | Home Credit Default Risk |
1,432,477 | %matplotlib inline
mpl.style.use('ggplot')
sns.set_style('white' )<load_from_csv> | def merge_dataframes(dfs, merge_keys):
dfs_merged = reduce(lambda left,right: pd.merge(left, right, on=merge_keys), dfs)
return dfs_merged | Home Credit Default Risk |
1,432,477 | sample = pd.read_csv('/kaggle/input/mlbio1/sample_submission.csv')
test = pd.read_csv('/kaggle/input/mlbio1/test.csv')
train = pd.read_csv('/kaggle/input/mlbio1/train.csv')
<sort_values> | dfs = [M1,M2,M3,M4,M5]
merge_keys=['SK_ID_CURR']
df = merge_dataframes(dfs, merge_keys=merge_keys ) | Home Credit Default Risk |
1,432,477 | total = train.isnull().sum().sort_values(ascending=False)
percent =(train.isnull().sum() /train.isnull().count() ).sort_values(ascending=False)
missing_data = pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
missing_data.head(20 )<drop_column> | df.columns = ['SK_ID_CURR','T1','T2','T3','T4','T5']
df.head() | Home Credit Default Risk |
1,432,477 | train = train.drop('smoking_status', 1)
test = test.drop('smoking_status', 1 )<feature_engineering> | pred_prob = 0.5 * df['T2'] + 0.5 * df['T1']
pred_prob.head() | Home Credit Default Risk |
1,432,477 | median_bmi = train['bmi'].median()
train['bmi'] = train['bmi'].fillna(median_bmi)
test['bmi'] = test['bmi'].fillna(median_bmi )<train_on_grid> | sub = pd.DataFrame()
sub['SK_ID_CURR'] = df['SK_ID_CURR']
sub['target']= pred_prob | Home Credit Default Risk |
1,432,477 | def cross_validation_for_roc_auc(clf, X, y ,cv=5):
X = np.array(X.copy())
y = np.array(y.copy())
kf = KFold(n_splits=cv)
kf.get_n_splits(X)
scores = []
for train_index, test_index in kf.split(X):
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
clf.fit(X_train, y_train... | sub.to_csv('ldit.csv', index=False ) | Home Credit Default Risk |
1,432,477 | def calc_smooth_mean(train, test, by, on, m):
mean = train[on].mean()
agg = train.groupby(by)[on].agg(['count', 'mean'])
counts = agg['count']
means = agg['mean']
smooth =(counts * means + m * mean)/(counts + m)
return train[by].map(smooth), test[by].map(smooth )<compute_train_metric> | B_prob = 0.6 * df['T1'] + 0.2 * df['T3'] + 0.2 * df['T4'] | Home Credit Default Risk |
1,432,477 | for const in range(0, 21, 5):
lgb = LGBMClassifier(n_estimators=50, max_depth=3)
sgd = SGDClassifier(loss='log', penalty = 'elasticnet')
train['gender_target_enc'],test['gender_target_enc'] = \
calc_smooth_mean(train, test, by='gender',on='stroke', m=const)
print(const, np.mean(cross_validation_for_roc_auc(lgb, trai... | SUB = pd.DataFrame()
SUB['SK_ID_CURR'] = df['SK_ID_CURR']
SUB['TARGET'] = B_prob
SUB.to_csv('Blendss.csv', index=False ) | Home Credit Default Risk |
1,432,477 | train = train.drop('gender_target_enc', 1)
test = test.drop('gender_target_enc', 1)
train = train.drop('gender', 1)
test = test.drop('gender', 1 )<compute_train_metric> | corr_pred = 0.6 * df['T2'] + 0.05 * df['T3'] + 0.05 * df['T4'] + 0.1 * df['T5'] + 0.2 * df['T1']
corr_pred.head() | Home Credit Default Risk |
1,432,477 | <feature_engineering><EOS> | SuB = pd.DataFrame()
SuB['SK_ID_CURR'] = df['SK_ID_CURR']
SuB['TARGET'] = corr_pred
SuB.to_csv('corr_blend.csv', index=False ) | Home Credit Default Risk |
1,224,566 | <SOS> metric: AUC Kaggle data source: home-credit-default-risk<categorify> | deb=time.time()
path=".. /input"
listfiles={"application_train":("SK_ID_CURR",["SK_ID_CURR"]),"application_test":("SK_ID_CURR",["SK_ID_CURR"]),"bureau":("SK_ID_CURR",["SK_ID_CURR","SK_ID_BUREAU"]),
"bureau_balance":("SK_ID_BUREAU",["SK_ID_BUREAU"]),"POS_CASH_balance":("SK_ID_PREV",["SK_ID_CURR","SK_ID_PREV"]),"previous... | Home Credit Default Risk |
1,224,566 | <define_variables><EOS> | sub=pd.Series(clf.predict_proba(X_test)[:,1],name="TARGET")
sub.loc[sub<0]=0
sub.loc[sub>1]=1
sub.index=indtest.index
submission=pd.concat([indtest,sub],axis=1)
submission.to_csv('submission.csv', index=False ) | Home Credit Default Risk |
1,396,051 | <choose_model_class><EOS> | warnings.simplefilter(action='ignore', category=FutureWarning)
@contextmanager
def timer(title):
t0 = time.time()
yield
print("{} - done in {:.0f}s".format(title, time.time() - t0))
def one_hot_encoder(df, nan_as_category = True):
original_columns = list(df.columns)
categorical_columns = [col for col in df.columns if... | Home Credit Default Risk |
21,768,463 | results.to_csv('submission.csv',index=False )<load_from_csv> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
21,768,463 | X_train = np.loadtxt("/kaggle/input/roxie2/roxie_train_features.csv", delimiter=",")[:,1:]
X_test = np.loadtxt("/kaggle/input/roxie2/roxie_test_features.csv", delimiter=",")
ids_test = X_test[:,(0,)]
X_test = X_test[:,1:]
y_train = np.loadtxt("/kaggle/input/roxie2/roxie_train_values.csv", delimiter=",", ndmin=2)[:,(1,... | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
21,768,463 | output = np.concatenate(( ids_test, y_pred), axis=1)
np.savetxt("submission_knn.csv", output, delimiter=",", fmt='%i,%1.4f', header='ID,intensity' )<load_from_csv> | women = train_data.loc[train_data.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
print("% of women who survived:", rate_women ) | Titanic - Machine Learning from Disaster |
21,768,463 | X_full = np.loadtxt("/kaggle/input/roxie2/roxie_full_features.csv", delimiter=",")
y_pred = mdl.predict(X_full)
plt.figure(figsize=(10,15))
plt.imshow(y_pred.reshape(( 650,430,3)) /255 )<set_options> | men = train_data.loc[train_data.Sex == 'male']["Survived"]
rate_men = sum(men)/len(men)
print("% of men who survived:", rate_men ) | Titanic - Machine Learning from Disaster |
21,768,463 | %config InlineBackend.figure_format = 'retina'
%matplotlib inline<load_from_csv> | y = train_data["Survived"]
features = ["Pclass", "Sex", "SibSp", "Parch"]
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=1)
model.fit(X, y)
predictions = model.predict(X_test)
output = pd.DataFrame({'P... | Titanic - Machine Learning from Disaster |
21,768,463 | print(os.listdir(".. /input"))
local = 0
if(local):
train = pd.read_csv("input/train.csv")
test = pd.read_csv("input/test.csv")
else:
train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
<drop_column> | print("Before", train_data.shape, test_data.shape)
train_data = train_data.drop(['Ticket', 'Cabin'], axis=1)
test_data = test_data.drop(['Ticket', 'Cabin'], axis=1)
combine = [train_data, test_data]
"After", train_data.shape, test_data.shape | Titanic - Machine Learning from Disaster |
21,768,463 | train_clean = train.drop(['ID','price'],1)
test_clean = test.drop('ID',1)
test_clean.head()
train_clean.shape<concatenate> | combine = [train_data, test_data] | Titanic - Machine Learning from Disaster |
21,768,463 | all_data = pd.concat(( train_clean[:],test_clean[:]))
all_data["caret_sqroot"] = np.sqrt(all_data["carat"])
all_data["caret_cubtroot"] = all_data.carat **(1/3)
all_data.shape
<feature_engineering> | for dataset in combine:
dataset['Title'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False)
pd.crosstab(train_data['Title'], train_data['Sex'] ) | Titanic - Machine Learning from Disaster |
21,768,463 | train["logprice"] = np.log1p(train["price"])
numeric_feats = all_data.dtypes[all_data.dtypes != "object"].index
print(numeric_feats )<feature_engineering> | for dataset in combine:
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col',\
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
dataset['Title'] = dataset['T... | Titanic - Machine Learning from Disaster |
21,768,463 |
<categorify> | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in combine:
dataset['Title'] = dataset['Title'].map(title_mapping)
dataset['Title'] = dataset['Title'].fillna(0)
train_data.head() | Titanic - Machine Learning from Disaster |
21,768,463 | all_data = pd.get_dummies(all_data)
all_data.head()<data_type_conversions> | train_data = train_data.drop(['Name', 'PassengerId'], axis=1)
test_data = test_data.drop(['Name'], axis=1)
combine = [train_data, test_data]
train_data.shape, test_data.shape | Titanic - Machine Learning from Disaster |
21,768,463 | all_data = all_data.fillna(all_data.mean() )<prepare_x_and_y> | for dataset in combine:
dataset['Sex'] = dataset['Sex'].map({'female': 1, 'male': 0} ).astype(int)
train_data.head() | Titanic - Machine Learning from Disaster |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.