kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
547,126 | def create_model() :
return SAKTModel(n_skill, max_seq=MAX_SEQ, embed_dim=EMBED_SIZE, forward_expansion=1, enc_layers=1, heads=8, dropout=0.1)
model = create_model()
model<train_model> | Titanic - Machine Learning from Disaster | |
547,126 | model(sample_batch[0], sample_batch[1])[0]<define_variables> | dataset_title=[i.split(",")[1].split('.')[0].strip() for i in dataset['Name']]
dataset['Title']=pd.Series(dataset_title)
dataset.head() | Titanic - Machine Learning from Disaster |
547,126 | LR = 2e-3
EPOCHS = 10
MODEL_PATH = '/kaggle/working/sakt.pth'<choose_model_class> | dataset['Title'] = dataset['Title'].replace(['Lady', 'the 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['Title'].replace('Mme',... | Titanic - Machine Learning from Disaster |
547,126 | def do_train() :
optimizer = torch.optim.Adam(model.parameters() , lr=LR)
criterion = nn.BCEWithLogitsLoss()
scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=LR,
steps_per_epoch=len(train_dataloader), epochs=EPOCHS)
model.to(device)
criterion.to(device)
best_auc = 0.0
for epoch in range(EPOCHS):
tr... | train_df[['Sex','Survived']].groupby(['Sex'],as_index=False ).mean().sort_values(by='Survived',ascending=False)
| Titanic - Machine Learning from Disaster |
547,126 | do_train()<train_model> | Ticket = []
for i in list(dataset.Ticket):
if not i.isdigit() :
Ticket.append(i.replace(".","" ).replace("/","" ).strip().split(' ')[0])
else:
Ticket.append("X")
dataset["Ticket"] = Ticket | Titanic - Machine Learning from Disaster |
547,126 | LR = LR/10.
EPOCHS = 3
do_train()<load_pretrained> | dataset["Cabin"] = pd.Series([i[0] if not pd.isnull(i)else 'X' for i in dataset['Cabin'] ])
| Titanic - Machine Learning from Disaster |
547,126 | model = create_model()
model.load_state_dict(torch.load(MODEL_PATH))
model.to(device )<split> | freq_port=train_df.Embarked.dropna().mode() [0]
freq_port
| Titanic - Machine Learning from Disaster |
547,126 | env = riiideducation.make_env()
iter_test = env.iter_test()<feature_engineering> | dataset['Embarked']=dataset['Embarked'].fillna(freq_port ) | Titanic - Machine Learning from Disaster |
547,126 | model.eval()
prev_test_df = None
for(test_df, sample_prediction_df)in tqdm(iter_test):
if(prev_test_df is not None)&(psutil.virtual_memory().percent<90):
print(psutil.virtual_memory().percent)
prev_test_df['answered_correctly'] = eval(test_df['prior_group_answers_correct'].iloc[0])
prev_test_df = prev_test_df[prev_te... | train_df[['Pclass','Survived']].groupby(['Pclass'],as_index=False ).mean().sort_values(by='Survived',ascending=False ) | Titanic - Machine Learning from Disaster |
547,126 | test_dataset = TestDataset(group, test_df, n_skill, max_seq=MAX_SEQ )<load_pretrained> | train_df[['SibSp','Survived']].groupby(['SibSp'],as_index=False ).mean().sort_values(by='Survived',ascending=False ) | Titanic - Machine Learning from Disaster |
547,126 | group.to_pickle('/kaggle/working/group.pkl' )<load_from_csv> | train_df[['Parch','Survived']].groupby(['Parch'],as_index=False ).mean().sort_values(by='Survived',ascending=False ) | Titanic - Machine Learning from Disaster |
547,126 | full_train = pd.read_pickle(".. /input/riiid-train-data-multiple-formats/riiid_train.pkl.gzip")
questions = pd.read_csv('/kaggle/input/riiid-test-answer-prediction/questions.csv')
lectures = pd.read_csv('/kaggle/input/riiid-test-answer-prediction/lectures.csv' )<drop_column> | dataset["Fsize"] = dataset["SibSp"] + dataset["Parch"] + 1
dataset['Single'] = dataset['Fsize'].map(lambda s: 1 if s == 1 else 0)
dataset['SmallF'] = dataset['Fsize'].map(lambda s: 1 if s == 2 else 0)
dataset['MedF'] = dataset['Fsize'].map(lambda s: 1 if 3 <= s <= 4 else 0)
dataset['LargeF'] = dataset['Fsize'].map(l... | Titanic - Machine Learning from Disaster |
547,126 | full_train = full_train[['row_id','user_id','content_id','content_type_id','answered_correctly']]
train = full_train.groupby('user_id' ).tail(400)
test = full_train.groupby('user_id' ).tail(4)
train = train.drop(test.index )<merge> | dataset["Fare"] = dataset["Fare"].map(lambda i: np.log(i)if i > 0 else 0 ) | Titanic - Machine Learning from Disaster |
547,126 | question_average = pd.DataFrame(full_train.loc[full_train['content_type_id'] == 0].groupby(['content_id'])['answered_correctly'].mean() ).rename(columns={'answered_correctly':'question_average'})
question_count = pd.DataFrame(full_train.loc[full_train['content_type_id'] == 0].groupby(['content_id'] ).size() ,columns=[... | dataset['Fare']=dataset['Fare'].fillna(dataset['Fare'].dropna().median())
| Titanic - Machine Learning from Disaster |
547,126 | train = train.join(question_df,on=['content_id'], rsuffix='_question' )<drop_column> | dataset.loc[dataset['Fare'] <=2.06,'Fare']=0
dataset.loc[(dataset['Fare'] <=2.67)&(dataset['Fare'] > 2.06),'Fare']=1
dataset.loc[(dataset['Fare'] <=3.44)&(dataset['Fare'] > 2.67),'Fare']=2
dataset.loc[(dataset['Fare'] <=6.2)&(dataset['Fare'] > 3.44),'Fare']=3
dataset.loc[dataset['Fare'] > 6.2 ,'Fare']=4
dataset['Fare']... | Titanic - Machine Learning from Disaster |
547,126 | del full_train
gc.collect()<data_type_conversions> | index_NaN_age = list(dataset["Age"][dataset["Age"].isnull() ].index)
for i in index_NaN_age:
age_med = dataset["Age"].median()
age_pred = dataset["Age"][(( dataset['SibSp'] == dataset.iloc[i]["SibSp"])&
(dataset['Parch'] == dataset.iloc[i]["Parch"])&
(dataset['Pclass'] == dataset.iloc[i]["Pclass"])) ].median()
if no... | Titanic - Machine Learning from Disaster |
547,126 | def reduce_memory_usage(train_data):
train_data['prior_question_had_explanation'] = train_data['prior_question_had_explanation'].fillna(False ).astype('bool')
return train_data<groupby> | dataset['AgeBand']=pd.cut(dataset['Age'],5)
| Titanic - Machine Learning from Disaster |
547,126 | mean_user = train.loc[train['content_type_id'] == False].groupby(['user_id'])['answered_correctly'].mean().mean()
mean_question = train.loc[train['content_type_id'] == False].groupby(['content_id'])['answered_correctly'].mean().mean()<groupby> | dataset[['AgeBand','Survived']].groupby(['AgeBand'],as_index=False ).mean() | Titanic - Machine Learning from Disaster |
547,126 | train['user_shift_question'] = train.loc[train['content_type_id'] == False].groupby(['user_id'])['question_average'].shift()<feature_engineering> | dataset.loc[dataset['Age'] <=16 , 'Age' ] = 0
dataset.loc[(dataset['Age'] > 16)&(dataset['Age'] <=32), 'Age' ] = 1
dataset.loc[(dataset['Age'] > 32)&(dataset['Age'] <=48), 'Age' ] = 2
dataset.loc[(dataset['Age'] > 48)&(dataset['Age'] <=64), 'Age' ] = 3
dataset.loc[(dataset['Age'] > 64), 'Age' ] = 4
dataset['Age']=datas... | Titanic - Machine Learning from Disaster |
547,126 | train['user_shift_question'] = train.loc[train['content_type_id'] == False].groupby(['user_id'])['question_average'].shift()
cumulated_question = train.loc[train['content_type_id'] == False].groupby(['user_id'])['user_shift_question'].agg(['cumsum','cumcount'])
train.loc[train['content_type_id'] == False,'average_past... | dataset=dataset.drop(['Name','Parch','PassengerId','SibSp','Fsize','FareBand','AgeBand'],axis=1 ) | Titanic - Machine Learning from Disaster |
547,126 | train['user_shift'] = train.loc[train['content_type_id'] == False].groupby(['user_id'])['answered_correctly'].shift()
cumulated = train.loc[train['content_type_id'] == False].groupby(['user_id'])['user_shift'].agg(['cumsum', 'cumcount'])
train.loc[train['content_type_id'] == False,'answered_correctly_user_average'] = ... | dataset=pd.get_dummies(dataset)
| Titanic - Machine Learning from Disaster |
547,126 | user_average = pd.DataFrame(train.loc[train['content_type_id'] == 0].groupby(['user_id'])['answered_correctly_user_average'].last() ).rename(columns={'answered_correctly_user_average':'user_average'})
user_count = pd.DataFrame(train.loc[train['content_type_id'] == 0].groupby(['user_id'] ).size() - 1,columns=['user_cou... | dataset=pd.get_dummies(dataset,prefix=['Pclass','Age','Fare'],columns=['Pclass','Age','Fare'] ) | Titanic - Machine Learning from Disaster |
547,126 | tmp = train.loc[train['content_type_id'] == False].groupby(['user_id'] ).mean()
train['performance_before'] = train['answered_correctly_user_average'] - train['average_past_questions']
user_performance = pd.DataFrame(train.loc[train['content_type_id'] == 0].groupby(['user_id'])['performance_before'].last() ).rename(col... | train = dataset[:train_len]
test = dataset[train_len:]
test.drop(labels=["Survived"],axis = 1,inplace=True ) | Titanic - Machine Learning from Disaster |
547,126 | gc.collect()<merge> | train["Survived"] = train["Survived"].astype(int)
X_train = train.drop(labels = ["Survived"],axis = 1)
Y_train = train["Survived"] | Titanic - Machine Learning from Disaster |
547,126 | user_df = user_performance.join(user_average ).join(user_count)
user_df['user_sum'] = user_df['user_average'] * user_df['user_count']<groupby> | X_test=test | Titanic - Machine Learning from Disaster |
547,126 | def question_average_sum_by_user(df,question_df):
my_dict = {}
group = df.groupby(['user_id'])
for user, val in group:
average_sum = 0.0
for row_index, row in val.iterrows() :
if(row['content_type_id'] == False):
question_id = row['content_id']
question_average = question_df.at[question_id,'question_average']
average_... | kfold= StratifiedKFold(n_splits=10 ) | Titanic - Machine Learning from Disaster |
547,126 | def add_answers_to_prior_df(current_df,prior_df):
prior_df_ = prior_df.copy()
if(prior_df.shape[0] > 0):
val = eval(current_df.iloc[0]['prior_group_answers_correct'])
if(len(val)== prior_df.shape[0]):
prior_df_['answered_correctly_response'] = val
return prior_df_<create_dataframe> | random_state=2
classifiers=[]
classifiers.append(SVC(random_state=random_state))
classifiers.append(DecisionTreeClassifier(random_state=random_state))
classifiers.append(RandomForestClassifier(random_state=random_state))
classifiers.append(KNeighborsClassifier())
classifiers.append(LogisticRegression(random_state=rand... | Titanic - Machine Learning from Disaster |
547,126 | def build_question_df(prior_df,question_df):
if(prior_df.shape[0] == 0):
return question_df
question_sum_prior = pd.DataFrame(prior_df.loc[prior_df['content_type_id'] == 0]\
.groupby(['content_id'])['answered_correctly_response'].sum())\
.rename(columns={'answered_correctly_response':'question_sum'})
question_count_... | svc_classifier=SVC(probability=True)
svc_param_grid = [{'C': [1], 'kernel': ['rbf'],
'gamma': [0.1],
'cache_size':[100],
'coef0':[0.1],
'degree':[1],
'tol':[0.001]}]
gs_SVC = GridSearchCV(estimator = svc_classifier,
param_grid = svc_param_grid,
scoring = 'accuracy',
cv = kfold,
n_jobs = -1)
gs_SVC = gs_SVC.fit(X_trai... | Titanic - Machine Learning from Disaster |
547,126 | def build_user_df(prior_df,user_df,question_df):
if(prior_df.shape[0] == 0):
return user_df
user_sum_prior = pd.DataFrame(prior_df.loc[prior_df['content_type_id'] == 0]\
.groupby(['user_id'])['answered_correctly_response'].sum())\
.rename(columns={'answered_correctly_response':'user_sum'})
user_count_prior = pd.Data... | dtc_classifier=DecisionTreeClassifier()
dtc_param_grid = [{'criterion': ['gini'],
"min_samples_split": [2],
"max_depth": [None],
"min_samples_leaf": [5],
"max_leaf_nodes": [10],
'splitter': ['best']}]
gs_DTC = GridSearchCV(estimator = dtc_classifier,
param_grid = dtc_param_grid,
scoring = 'accuracy',
cv = kfold,
n_jobs... | Titanic - Machine Learning from Disaster |
547,126 | prior_df = pd.DataFrame()
current_df = pd.DataFrame()
prior_df = add_answers_to_prior_df(current_df,prior_df)
question_df = build_question_df(prior_df,question_df)
user_df = build_user_df(prior_df,user_df,question_df )<define_variables> | rfc_classifier=RandomForestClassifier()
rfc_param_grid = [{'n_estimators':[1200] ,'criterion': ['entropy'],
'max_features':['auto'] ,'min_samples_split':[9],'min_samples_leaf':[2],
'bootstrap' : [True], 'n_jobs':[-1] ,'oob_score':[True]}]
gs_RFC = GridSearchCV(estimator = rfc_classifier,
param_grid = rfc_param_grid,
sc... | Titanic - Machine Learning from Disaster |
547,126 | TARGET_COL = ['answered_correctly']
FEATURE_COLS = ['row_id', 'performance', 'question_average']<merge> | knn_classifier=KNeighborsClassifier()
knn_param_grid = [{'n_neighbors':[10],'weights':['uniform'],'algorithm':['brute'],
}]
gs_KNN = GridSearchCV(estimator = knn_classifier,
param_grid = knn_param_grid,
scoring = 'accuracy',
cv = kfold,
n_jobs = -1)
gs_KNN = gs_KNN.fit(X_train, Y_train)
knn_best_params = gs_KNN.best_... | Titanic - Machine Learning from Disaster |
547,126 | def data_transform(df, is_training = True, is_validation = True):
df = df.join(question_df['question_average'],on=['content_id'],rsuffix='_question_average')
df = df.join(user_df[['performance','user_average', 'user_count']],on=['user_id'],rsuffix='_right')
df['is_beginning'] = df['user_count'] < 20
df = df.loc[df['c... | lr_classifier=LogisticRegression()
lr_param_grid = [{'penalty':['l1','l2'] , 'C':[1]}]
gs_LR = GridSearchCV(estimator = lr_classifier,
param_grid = lr_param_grid,
scoring = 'accuracy',
cv = kfold,
n_jobs = -1)
gs_LR = gs_LR.fit(X_train, Y_train)
lr_best_params = gs_LR.best_params_
lr_best_score = gs_LR.best_score_
lr... | Titanic - Machine Learning from Disaster |
547,126 | %%time
train = data_transform(train )<categorify> | adadtc_classifier=AdaBoostClassifier(dtc_best)
adadtc_param_grid = [{'n_estimators':[500],
"learning_rate": [0.1],
"algorithm" : ["SAMME"],
}]
gs_ADADTC = GridSearchCV(estimator = adadtc_classifier,
param_grid = adadtc_param_grid,
scoring = 'accuracy',
cv = kfold,
n_jobs = -1)
gs_ADADTC = gs_ADADTC.fit(X_train, Y_tra... | Titanic - Machine Learning from Disaster |
547,126 | test = data_transform(test,False )<prepare_x_and_y> | xt_classifier=ExtraTreesClassifier()
xt_param_grid = [{'n_estimators':[100],
'criterion':['entropy'],
'max_features':[None],
'max_depth':[None],
'min_samples_split':[2],
'min_samples_leaf':[10]
}]
gs_XT = GridSearchCV(estimator = xt_classifier,
param_grid = xt_param_grid,
scoring = 'accuracy',
cv = kfold,
n_jobs = -1)
... | Titanic - Machine Learning from Disaster |
547,126 | X_train = train[FEATURE_COLS]
y_train = train[TARGET_COL]
X_test = test[FEATURE_COLS]
y_test = test[TARGET_COL]<create_dataframe> | votingC = VotingClassifier(estimators=[('svc', svc_best),('dtc', dtc_best),
('rfc', rfc_best),('knn',knn_best),('lr',lr_best),('adadtc',adadtc_best),('xt',xt_best)], voting='soft', n_jobs=-1)
votingC = votingC.fit(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
547,126 | lgb_train = lgb.Dataset(X_train.iloc[:,1:],y_train)
lgb_val = lgb.Dataset(X_test.iloc[:,1:],y_test )<set_options> | test_Survived = pd.Series(votingC.predict(test), name="Survived")
results = pd.concat([IDtest,test_Survived],axis=1)
results.to_csv("ensemble_python_voting.csv",index=False ) | Titanic - Machine Learning from Disaster |
7,649,711 | del X_train,y_train
gc.collect()<choose_model_class> | print("Important libraries loaded successfully" ) | Titanic - Machine Learning from Disaster |
7,649,711 | def LGB_bayesian(
num_leaves,
seed,
):
num_leaves = int(num_leaves)
seed = int(seed)
param = {
'objective': 'binary',
'seed': seed,
'metric': 'auc',
'learning_rate': 0.05,
'max_bin': 1000,
'num_leaves': num_leaves,
'num_iterations' : 20
}
clf = lgb.train(param, lgb_train, num_boost_round=50, valid_sets = [lgb_train... | ds_train=pd.read_csv("/kaggle/input/titanic/train.csv")
ds_test=pd.read_csv("/kaggle/input/titanic/test.csv")
ds_result=pd.read_csv("/kaggle/input/titanic/gender_submission.csv")
print("Train and Test data sets are imported successfully" ) | Titanic - Machine Learning from Disaster |
7,649,711 | bounds_LGB = {
'num_leaves':(31, 500),
'seed':(0,1000)
}
LGB_BO = BayesianOptimization(LGB_bayesian, bounds_LGB, random_state=42)
init_points = 10
n_iter = 10
print('-' * 130)
warnings.filterwarnings("ignore")
with warnings.catch_warnings() :
warnings.filterwarnings('ignore')
LGB_BO.maximize(init_points=init_point... | ds_train=ds_train.drop(['Ticket','Cabin'],axis=1)
print("Columns Dropped Successfully")
ds_train.head() | Titanic - Machine Learning from Disaster |
7,649,711 | param_lgb = {
'objective': 'binary',
'seed': int(LGB_BO.max['params']['seed']),
'metric': 'auc',
'learning_rate': 0.05,
'max_bin': 1000,
'num_leaves': int(LGB_BO.max['params']['num_leaves']),
'num_iterations' : 20
}
model = lgb.train(
param_lgb,
lgb_train,
valid_sets=[lgb_train,lgb_val],
verbose_eval=1,
num_boost_roun... | print("Number of teenagers and child passengers in ship are {}".format(len(ds_train[ds_train['Age'] < 20 ])) ) | Titanic - Machine Learning from Disaster |
7,649,711 | %%time
predictions = pd.DataFrame(model.predict(X_test.iloc[:,1:]),index=X_test.index)
<compute_test_metric> | ds_train=ds_train.drop(['Embarked','Name'],axis=1)
print("Columns Dropped Successfully")
ds_train.head() | Titanic - Machine Learning from Disaster |
7,649,711 | roc_auc_score(y_test,predictions[0] )<predict_on_test> | ds_train['Family_Size'] = ds_train['SibSp'] + ds_train['Parch'] + 1
print("Family Size column created sucessfully")
ds_train.head() | Titanic - Machine Learning from Disaster |
7,649,711 | env = riiideducation.make_env()
iter_test = env.iter_test()
iter_nb = 0
for(current_df, sample_prediction_df)in iter_test:
if(iter_nb != 0):
prior_df = add_answers_to_prior_df(current_df,prior_df)
question_df = build_question_df(prior_df,question_df)
user_df = build_user_df(prior_df,user_df,question_df)
prior_df = c... | age_by_pclass_sex = ds_train.groupby(['Sex', 'Pclass'] ).median() ['Age']
for pclass in range(1, 4):
for sex in ['female', 'male']:
print('Median age of Pclass {} {}s: {}'.format(pclass, sex, age_by_pclass_sex[sex][pclass]))
print('Median age of all passengers: {}'.format(ds_train['Age'].median()))
ds_train['Age'] = ds... | Titanic - Machine Learning from Disaster |
7,649,711 | import pandas as pd
import numpy as np
import gc
from sklearn.metrics import roc_auc_score
from collections import defaultdict
from tqdm.notebook import tqdm
import lightgbm as lgb
import riiideducation
import matplotlib.pyplot as plt
import seaborn as sns
import random
import os<feature_engineering> | ds_train=ds_train.replace(to_replace='male',value=0)
ds_train=ds_train.replace(to_replace='female',value=1)
ds_train.head() | Titanic - Machine Learning from Disaster |
7,649,711 | SEED = 123
def seed_everything(seed):
random.seed(seed)
np.random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
seed_everything(SEED)
def add_features(df, answered_correctly_u_count, answered_correctly_u_sum, elapsed_time_u_sum, explanation_u_sum, timestamp_u, timestamp_u_incorrect, answered_correctly_q_count... | X_train=ds_train.drop(['Survived'],axis=1)
y_train=ds_train['Survived'].values
print('X_train shape: {}'.format(X_train.shape))
print('y_train shape: {}'.format(y_train.shape)) | Titanic - Machine Learning from Disaster |
7,649,711 | import gc
import random
from tqdm.notebook import tqdm
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split
import seaborn as sns
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.nn.utils.rnn as rnn_utils
from torch.autograd import Variable
from t... | classifier_rf=RandomForestClassifier(criterion='gini',
n_estimators=1100,
max_depth=5,
min_samples_split=4,
min_samples_leaf=5,
max_features='auto',
oob_score=True,
random_state=42,
n_jobs=-1,
verbose=1)
classifier_rf.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
7,649,711 | path = Path('/kaggle/input')
assert path.exists()<load_from_csv> | classifier_xgb=XGBClassifier(max_depth=3, n_estimators=300, learning_rate=0.05)
classifier_xgb.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
7,649,711 | %%time
data_types_dict = {
'content_type_id': 'bool',
'timestamp': 'int64',
'user_id': 'int32',
'content_id': 'int16',
'answered_correctly': 'int8',
'prior_question_elapsed_time': 'float32',
'prior_question_had_explanation': 'bool'
}
target = 'answered_correctly'
train_df = dt.fread(path/'riiid-test-answer-prediction/t... | age_by_pclass_sex = ds_test.groupby(['Sex', 'Pclass'] ).median() ['Age']
for pclass in range(1, 4):
for sex in ['female', 'male']:
print('Median age of Pclass {} {}s: {}'.format(pclass, sex, age_by_pclass_sex[sex][pclass]))
print('Median age of all passengers: {}'.format(ds_test['Age'].median()))
ds_test['Age'] = ds_te... | Titanic - Machine Learning from Disaster |
7,649,711 | %%time
train_df = train_df[train_df.content_type_id == False]
train_df = train_df.sort_values(['timestamp'], ascending=True ).reset_index(drop = True )<drop_column> | null_index=ds_test['Fare'].isnull().index
medianFare=ds_test['Fare'].median()
ds_test.at[null_index,'Fare'] = medianFare
print("Missing Fare updated as Median Fare :{}".format(medianFare)) | Titanic - Machine Learning from Disaster |
7,649,711 | del train_df['timestamp']
del train_df['content_type_id']<count_unique_values> | ds_test=ds_test.drop(['Ticket','Cabin','Embarked','Name'],axis=1)
print("Columns Dropped Successfully")
ds_test['Family_Size'] = ds_test['SibSp'] + ds_test['Parch'] + 1
print("Family Size column created sucessfully")
ds_test=ds_test.replace(to_replace='male',value=0)
ds_test=ds_test.replace(to_replace='female',valu... | Titanic - Machine Learning from Disaster |
7,649,711 | n_skill = train_df["content_id"].nunique()
print("number skills", n_skill )<groupby> | y_pred_rf=classifier_rf.predict(X_test)
y_pred_xgb=classifier_xgb.predict(X_test)
y_pred_rf=y_pred_rf.ravel()
y_pred_xgb=y_pred_xgb.ravel()
submission_df_rf = pd.DataFrame(columns=['PassengerId', 'Survived'])
submission_df_rf['PassengerId'] = X_test['PassengerId'].astype(int)
submission_df_rf['Survived'] = y_pred_r... | Titanic - Machine Learning from Disaster |
7,649,711 | %%time
group = train_df[['user_id', 'content_id', 'answered_correctly']].groupby('user_id' ).apply(lambda r:(r['content_id'].values, r['answered_correctly'].values))
del train_df<define_variables> | accuracies_rf = cross_val_score(estimator = classifier_rf, X = X_train, y = y_train, cv = 10)
accuracies_xgb = cross_val_score(estimator = classifier_xgb, X = X_train, y = y_train, cv = 10 ) | Titanic - Machine Learning from Disaster |
7,649,711 | MAX_SEQ = 180
ACCEPTED_USER_CONTENT_SIZE = 4
EMBED_SIZE = 128
BATCH_SIZE = 64
DROPOUT = 0.1<create_dataframe> | print("Accuracies for 10 Fold in Random Forest Model is {}".format(accuracies_rf))
print("Accuracies for 10 Fold in XG Boost Model is {}".format(accuracies_xgb)) | Titanic - Machine Learning from Disaster |
7,649,711 | class SAKTDataset(Dataset):
def __init__(self, group, n_skill, max_seq=100):
super(SAKTDataset, self ).__init__()
self.samples, self.n_skill, self.max_seq = {}, n_skill, max_seq
self.user_ids = []
for i, user_id in enumerate(group.index):
if(i % 10000 == 0):
print(f'Processed {i} users')
content_id, answered_correctly... | print("Mean Accuracy for Random Forest Model is {}".format(accuracies_rf.mean()))
print("Mean Accuracy for XG Boost Model is {}".format(accuracies_xgb.mean()))
print("Standard Deviation for Random Forest Model is {}".format(accuracies_rf.std()))
print("Standard Deviation for XG Boost Model is {}".format(accuracies_xgb.... | Titanic - Machine Learning from Disaster |
7,649,711 | TEST_SIZE = 0.1
train, val = train_test_split(group, test_size = TEST_SIZE )<create_dataframe> | param_grid = { 'bootstrap': [True],
'max_depth': [80, 90, 100, 110],
'max_features': [2, 3],
'min_samples_leaf': [3, 4, 5],
'min_samples_split': [8, 10, 12],
'n_estimators': [100, 300, 500, 1000] }
grid_search = GridSearchCV(estimator = classifier_rf, param_grid = param_grid,cv = 3, n_jobs = -1)
grid_search = grid_sea... | Titanic - Machine Learning from Disaster |
7,649,711 | train_dataset = SAKTDataset(train, n_skill, max_seq=MAX_SEQ)
train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=8)
del train<create_dataframe> | best_accuracy = grid_search.best_score_
best_parameters = grid_search.best_params_
print("Best Accuracy for Random Forest Classifier is {}".format(best_accuracy))
print("Best Parameters for Random Forest Classifier is {}".format(best_parameters)) | Titanic - Machine Learning from Disaster |
7,649,711 | val_dataset = SAKTDataset(val, n_skill, max_seq=MAX_SEQ)
val_dataloader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=8)
del val<choose_model_class> | classifier_rf_new = RandomForestClassifier(n_estimators = 719,
bootstrap=False,
max_depth=464,
max_features=0.3,
min_samples_leaf=1,
min_samples_split=2,
random_state=42)
classifier_rf_new.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
7,649,711 | <categorify><EOS> | print("Predicting Results from new Classifier and Converting into Submission file")
y_pred_rf_new=classifier_rf_new.predict(X_test)
y_pred_rf_new=y_pred_rf_new.ravel()
submission_df_rf_new = pd.DataFrame(columns=['PassengerId', 'Survived'])
submission_df_rf_new['PassengerId'] = X_test['PassengerId'].astype(int)
sub... | Titanic - Machine Learning from Disaster |
9,347,941 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<choose_model_class> | %matplotlib inline
warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
9,347,941 | class TransformerBlock(nn.Module):
def __init__(self, embed_dim, heads = 8, dropout = DROPOUT, forward_expansion = 1):
super(TransformerBlock, self ).__init__()
self.multi_att = nn.MultiheadAttention(embed_dim=embed_dim, num_heads=heads, dropout=dropout)
self.dropout = nn.Dropout(dropout)
self.layer_normal = nn.Layer... | train = pd.read_csv("/kaggle/input/titanic/train.csv")
df_test = pd.read_csv("/kaggle/input/titanic/test.csv")
test = df_test.copy()
gender_submission = pd.read_csv("/kaggle/input/titanic/gender_submission.csv" ) | Titanic - Machine Learning from Disaster |
9,347,941 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu" )<choose_model_class> | train.isnull().sum().sort_values(ascending = False ) | Titanic - Machine Learning from Disaster |
9,347,941 | def create_model() :
return SAKTModel(n_skill, max_seq=MAX_SEQ, embed_dim=EMBED_SIZE, forward_expansion=1, enc_layers=1, heads=8, dropout=0.1)
model = create_model()
model<train_model> | test.isnull().sum().sort_values(ascending = False ) | Titanic - Machine Learning from Disaster |
9,347,941 | model(sample_batch[0], sample_batch[1])[0]<define_variables> | train.Pclass.isnull().sum() | Titanic - Machine Learning from Disaster |
9,347,941 | LR = 2e-3
EPOCHS = 10
MODEL_PATH = '/kaggle/working/sakt.pth'<choose_model_class> | train.Name.value_counts() | Titanic - Machine Learning from Disaster |
9,347,941 | def do_train() :
optimizer = torch.optim.Adam(model.parameters() , lr=LR)
criterion = nn.BCEWithLogitsLoss()
scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=LR,
steps_per_epoch=len(train_dataloader), epochs=EPOCHS)
model.to(device)
criterion.to(device)
best_auc = 0.0
for epoch in range(EPOCHS):
tr... | train.drop(columns = ["Name","PassengerId"], axis = 1, inplace = True)
test.drop(columns = ["Name","PassengerId"], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
9,347,941 | do_train()<train_model> | train.Sex.isnull().sum() | Titanic - Machine Learning from Disaster |
9,347,941 | LR = 2e-4
EPOCHS = 3
do_train()<load_pretrained> | train.Age.isnull().sum() | Titanic - Machine Learning from Disaster |
9,347,941 | model = create_model()
model.load_state_dict(torch.load(MODEL_PATH))
model.to(device )<split> | train.Ticket.value_counts() | Titanic - Machine Learning from Disaster |
9,347,941 | env = riiideducation.make_env()
iter_test = env.iter_test()<feature_engineering> | print("There are {} unique Ticket values.".format(len(train.Ticket.unique())) ) | Titanic - Machine Learning from Disaster |
9,347,941 | model.eval()
prev_test_df = None
for(test_df, sample_prediction_df)in tqdm(iter_test):
if(prev_test_df is not None)&(psutil.virtual_memory().percent<90):
print(psutil.virtual_memory().percent)
prev_test_df['answered_correctly'] = eval(test_df['prior_group_answers_correct'].iloc[0])
prev_test_df = prev_test_df[prev_te... | train.drop("Ticket", axis = 1, inplace = True)
test.drop("Ticket", axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
9,347,941 | test_dataset = TestDataset(group, test_df, n_skill, max_seq=MAX_SEQ )<load_pretrained> | train.drop("Fare", axis = 1, inplace = True)
test.drop("Fare", axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
9,347,941 | group.to_pickle('/kaggle/working/group.pkl' )<install_modules> | train.Cabin.value_counts() | Titanic - Machine Learning from Disaster |
9,347,941 | !pip install.. /input/python-datatable/datatable-0.11.0-cp37-cp37m-manylinux2010_x86_64.whl > /dev/null 2>&1<set_options> | train.drop("Cabin", axis = 1, inplace = True)
test.drop("Cabin", axis =1, inplace = True ) | Titanic - Machine Learning from Disaster |
9,347,941 | _ = np.seterr(divide='ignore', invalid='ignore' )<define_variables> | train.Embarked.value_counts() | Titanic - Machine Learning from Disaster |
9,347,941 | data_types_dict = {
'timestamp': 'int64',
'user_id': 'int32',
'content_id': 'int16',
'content_type_id':'int8',
'task_container_id': 'int16',
'answered_correctly': 'int8',
'prior_question_elapsed_time': 'float32',
'prior_question_had_explanation': 'bool'
}
target = 'answered_correctly'<load_from_csv> | train["Embarked"].isnull().sum() | Titanic - Machine Learning from Disaster |
9,347,941 | train_df = dt.fread('.. /input/riiid-test-answer-prediction/train.csv', columns=set(data_types_dict.keys())).to_pandas()<load_from_csv> | print(len(train))
train = train.dropna(subset=['Embarked'])
print(len(train)) | Titanic - Machine Learning from Disaster |
9,347,941 | lectures_df = pd.read_csv('/kaggle/input/riiid-test-answer-prediction/lectures.csv' )<categorify> | train['Age'] = train.groupby("Pclass")['Age'].transform(lambda x: x.fillna(x.median()))
test['Age'] = test.groupby("Pclass")['Age'].transform(lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
9,347,941 | lectures_df['type_of'] = lectures_df['type_of'].replace('solving question', 'solving_question')
lectures_df = pd.get_dummies(lectures_df, columns=['part', 'type_of'])
part_lectures_columns = [column for column in lectures_df.columns if column.startswith('part')]
types_of_lectures_columns = [column for column in lectu... | print(train["Age"].isnull().sum())
print(test["Age"].isnull().sum() ) | Titanic - Machine Learning from Disaster |
9,347,941 | train_lectures = train_df[train_df.content_type_id == True].merge(lectures_df, left_on='content_id', right_on='lecture_id', how='left' )<groupby> | train = pd.get_dummies(data = train, columns = ["Sex", "Embarked", "Pclass"])
test = pd.get_dummies(data = test, columns = ["Sex", "Embarked", "Pclass"] ) | Titanic - Machine Learning from Disaster |
9,347,941 | user_lecture_stats_part = train_lectures.groupby('user_id',as_index = False)[part_lectures_columns + types_of_lectures_columns].sum()<data_type_conversions> | X_train = train.drop("Survived", axis = 1)
y_train = train["Survived"] | Titanic - Machine Learning from Disaster |
9,347,941 | lecturedata_types_dict = {
'user_id': 'int32',
'part_1': 'int8',
'part_2': 'int8',
'part_3': 'int8',
'part_4': 'int8',
'part_5': 'int8',
'part_6': 'int8',
'part_7': 'int8',
'type_of_concept': 'int8',
'type_of_intention': 'int8',
'type_of_solving_question': 'int8',
'type_of_starter': 'int8'
}
user_lecture_stats_part = u... | def fit_model(algo, X_train, y_train, cv):
model = algo.fit(X_train, y_train)
y_pred = algo.predict(X_train)
accuracy = round(accuracy_score(y_train, y_pred)* 100 , 2)
y_pred_cv = cross_val_predict(algo, X_train, y_train, cv = cv)
accuracy_cv = round(accuracy_score(y_train, y_pred_cv)* 100 , 2)
return y_pred_cv, a... | Titanic - Machine Learning from Disaster |
9,347,941 | for column in user_lecture_stats_part.columns:
if(column !='user_id'):
user_lecture_stats_part[column] =(user_lecture_stats_part[column] > 0 ).astype('int8' )<filter> | y_pred_cv_lr, accuracy_lr, accuracy_cv_lr = fit_model(LogisticRegression(random_state = 3),
X_train, y_train, 10)
print("Accuracy : ",accuracy_lr)
print("Accuracy CV :",accuracy_cv_lr ) | Titanic - Machine Learning from Disaster |
9,347,941 | train_lectures[train_lectures.user_id==5382]<filter> | rf = RandomForestClassifier(n_estimators = 100, random_state = 3)
rf.fit(X_train, y_train)
y_train_pred = rf.predict(X_train)
print('Confusion Matrix : ','
', confusion_matrix(y_train, y_train_pred))
print()
print("Accuracy : ", round(accuracy_score(y_train, y_train_pred)* 100, 2)) | Titanic - Machine Learning from Disaster |
9,347,941 | user_lecture_stats_part[user_lecture_stats_part.user_id==5382]<drop_column> | rfc = RandomForestClassifier(random_state=3)
params = {'n_estimators' : sp_randint(50,200),
'max_depth' : sp_randint(2,100),
'max_depth' : sp_randint(2,100),
'min_samples_split' : sp_randint(2,100),
'min_samples_leaf' : sp_randint(1,200),
'criterion' : ['gini', 'entropy']}
rsearch_rfc = RandomizedSearchCV(rfc, param_d... | Titanic - Machine Learning from Disaster |
9,347,941 | del(train_lectures )<data_type_conversions> | rsearch_rfc.best_params_ | Titanic - Machine Learning from Disaster |
9,347,941 | cum = train_df.groupby('user_id')['content_type_id'].agg(['cumsum', 'cumcount'])
train_df['user_lecture_cumsum'] = cum['cumsum']
train_df['user_lecture_lv'] = cum['cumsum'] / cum['cumcount']
train_df.user_lecture_lv=train_df.user_lecture_lv.astype('float16')
train_df.user_lecture_cumsum=train_df.user_lecture_cumsum.a... | rfc = RandomForestClassifier(**rsearch_rfc.best_params_, random_state = 3)
rfc.fit(X_train, y_train)
y_train_pred = rfc.predict(X_train)
print('Confusion Matrix : ','
', confusion_matrix(y_train, y_train_pred))
print()
print("Accuracy : ", round(accuracy_score(y_train, y_train_pred)* 100, 2)) | Titanic - Machine Learning from Disaster |
9,347,941 | train_df['prior_question_had_explanation'].fillna(False, inplace=True)
train_df = train_df.astype(data_types_dict)
train_df = train_df[train_df[target] != -1].reset_index(drop=True)
content_explation_agg=train_df[["content_id","prior_question_had_explanation",target]].groupby(["content_id","prior_question_had_explan... | imp = pd.DataFrame(rfc.feature_importances_, index = X_train.columns, columns = ['imp'])
imp = imp.sort_values(by ='imp', ascending = False)
imp | Titanic - Machine Learning from Disaster |
9,347,941 | max_timestamp_u = train_df[['user_id','timestamp']].groupby(['user_id'] ).agg(['max'] ).reset_index()
max_timestamp_u.columns = ['user_id', 'max_time_stamp']<data_type_conversions> | y_test_pred = rfc.predict(test ) | Titanic - Machine Learning from Disaster |
9,347,941 | train_df['lagtime'] = train_df.groupby('user_id')['timestamp'].shift()
train_df['lagtime']=train_df['timestamp']-train_df['lagtime']
lagtime_mean=train_df['lagtime'].mean()
train_df['lagtime'].fillna(lagtime_mean, inplace=True)
train_df.lagtime=train_df.lagtime.astype('int32')
<categorify> | submission = pd.DataFrame()
submission['PassengerId'] = df_test['PassengerId']
submission['Survived'] = y_test_pred
submission.head() | Titanic - Machine Learning from Disaster |
9,347,941 | lagtime_agg = train_df.groupby('user_id')['lagtime'].agg(['mean'])
train_df['lagtime_mean'] = train_df['user_id'].map(lagtime_agg['mean'])
train_df.lagtime_mean=train_df.lagtime_mean.astype('int32' )<groupby> | submission.to_csv('rf_submission.csv', index=False)
print('Submission CSV is ready!' ) | Titanic - Machine Learning from Disaster |
9,347,941 | train_df[['user_id','prior_question_elapsed_time']].groupby(['user_id'] ).head()<groupby> | submissions_check = pd.read_csv("rf_submission.csv")
submissions_check.head() | Titanic - Machine Learning from Disaster |
3,787,676 | user_prior_question_elapsed_time = train_df[['user_id','prior_question_elapsed_time']].groupby(['user_id'] ).tail(1)
user_prior_question_elapsed_time.columns = ['user_id', 'prior_question_elapsed_time']<feature_engineering> | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
3,787,676 | train_df['delta_prior_question_elapsed_time'] = train_df.groupby('user_id')['prior_question_elapsed_time'].shift()
train_df['delta_prior_question_elapsed_time']=train_df['prior_question_elapsed_time']-train_df['delta_prior_question_elapsed_time']
train_df['delta_prior_question_elapsed_time'].fillna(0, inplace=True)
<da... | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv')
print(train_df.shape)
print(test_df.shape)
train_label = train_df.Survived
test_Ids = test_df.PassengerId | Titanic - Machine Learning from Disaster |
3,787,676 | train_df.delta_prior_question_elapsed_time=train_df.delta_prior_question_elapsed_time.astype('int32' )<data_type_conversions> | def checking_missing(data):
for col in data.columns:
print(f' Count of NAs in {col} : {np.sum(data[col].isnull())} ')
print("NAs in train dataset: ")
checking_missing(train_df)
print("NAs in test dataset: ")
checking_missing(test_df ) | Titanic - Machine Learning from Disaster |
3,787,676 | train_df['timestamp']=train_df['timestamp']/(1000*3600)
train_df.timestamp=train_df.timestamp.astype('int16')
<groupby> | print(total_df.SibSp.value_counts())
print('-'*10)
print(total_df.Parch.value_counts() ) | Titanic - Machine Learning from Disaster |
3,787,676 | train_df['lag'] = train_df.groupby('user_id')[target].shift()<data_type_conversions> | total_df['FamSize'] = total_df.SibSp + total_df.Parch + 1
print(total_df.FamSize.value_counts())
total_df.FamSize.replace(to_replace = [1], value = 'single', inplace = True)
total_df.FamSize.replace(to_replace = [2,3,4,5], value = 'median', inplace = True)
total_df.FamSize.replace(to_replace = [6,7,8,11], value = 'l... | Titanic - Machine Learning from Disaster |
3,787,676 | cum = train_df.groupby('user_id')['lag'].agg(['cumsum', 'cumcount'])
train_df['user_correctness'] = cum['cumsum'] / cum['cumcount']
train_df['user_correct_cumsum'] = cum['cumsum']
train_df['user_correct_cumcount'] = cum['cumcount']
train_df.drop(columns=['lag'], inplace=True)
train_df['user_correct_cumsum'].fillna(0,... | total_df.Fare = total_df.Fare.fillna(total_df.Fare.median())
cuttingArr = np.array([0,50,100,total_df.Fare.max() ])
total_df['Fare_Group'] = pd.cut(total_df.Fare,cuttingArr,include_lowest = True)
print(total_df.Fare_Group.value_counts())
Fare_intervals = total_df.Fare_Group.unique()
total_df.Fare_Group.replace(to_r... | Titanic - Machine Learning from Disaster |
3,787,676 | train_df.prior_question_had_explanation=train_df.prior_question_had_explanation.astype('int8')
train_df['lag'] = train_df.groupby('user_id')['prior_question_had_explanation'].shift()<data_type_conversions> | total_df.Cabin = total_df.Cabin.fillna('X')
total_df.Cabin = total_df.Cabin.apply(lambda x: x[0])
total_df.Cabin = total_df.Cabin == 'X'
total_df.Cabin = total_df.Cabin.apply(lambda x: 0 if x == False else 1)
print(total_df.Cabin.value_counts() ) | Titanic - Machine Learning from Disaster |
3,787,676 | cum = train_df.groupby('user_id')['lag'].agg(['cumsum', 'cumcount'])
train_df['explanation_mean'] = cum['cumsum'] / cum['cumcount']
train_df['explanation_cumsum'] = cum['cumsum']
train_df.drop(columns=['lag'], inplace=True)
train_df['explanation_mean'].fillna(0, inplace=True)
train_df['explanation_cumsum'].fillna(0,... | total_df.Embarked = total_df.Embarked.fillna(total_df.Embarked.mode() [0])
total_df.Embarked.value_counts() | Titanic - Machine Learning from Disaster |
3,787,676 | del cum
gc.collect()<data_type_conversions> | total_df = total_df.drop(['Ticket'], axis = 1 ) | 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.