kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
3,787,676 | train_df["attempt_no"] = 1
train_df.attempt_no=train_df.attempt_no.astype('int8')
train_df["attempt_no"] = train_df[["user_id","content_id",'attempt_no']].groupby(["user_id","content_id"])["attempt_no"].cumsum()<data_type_conversions> | temp = copy.deepcopy(total_df[total_df.columns[total_df.columns != 'Age']])
temp.Title.replace(to_replace = ['Mr'] , value = 0 , inplace = True)
temp.Title.replace(to_replace = ['Mrs'] , value = 1 , inplace = True)
temp.Title.replace(to_replace = ['Miss'] , value = 2, inplace = True)
temp.Title.replace(to_replace =... | Titanic - Machine Learning from Disaster |
3,787,676 | explanation_agg = train_df.groupby('user_id')['prior_question_had_explanation'].agg(['sum', 'count'])
explanation_agg=explanation_agg.astype('int16')
<groupby> | total_df.Age = temp.groupby(['Pclass','Title'])['Age'].transform(lambda v: v.fillna(v.median()))
checking_missing(total_df ) | Titanic - Machine Learning from Disaster |
3,787,676 | user_agg = train_df.groupby('user_id')[target].agg(['sum', 'count'])
content_agg = train_df.groupby('content_id')[target].agg(['sum', 'count','var'])
task_container_agg = train_df.groupby('task_container_id')[target].agg(['sum', 'count','var'])
<data_type_conversions> | LE_columns = ['FamSize','Fare_Group','Sex','Age_Group','Missing_Age']
OHE_columns = ['Embarked','Title']
Other_columns = total_df.columns[~total_df.columns.isin(LE_columns)& ~total_df.columns.isin(OHE_columns)]
LE_data = total_df[LE_columns]
OHE_data = total_df[OHE_columns]
Other_data = total_df[Other_columns]
for col ... | Titanic - Machine Learning from Disaster |
3,787,676 | user_agg=user_agg.astype('int16')
content_agg=content_agg.astype('float32')
task_container_agg=task_container_agg.astype('float32' )<categorify> | train_df = train_df.drop(['PassengerId','Survived'],axis = 1)
test_df = test_df.drop(['PassengerId','Survived'], axis = 1)
ntrain = len(train_df)
ntest = len(test_df ) | Titanic - Machine Learning from Disaster |
3,787,676 | attempt_no_agg=train_df.groupby(["user_id","content_id"])["attempt_no"].agg(['sum'])
attempt_no_agg=attempt_no_agg.astype('int8')
<data_type_conversions> | xgbParams = {'max_depth':np.arange(3,11,2),'learning_rate':np.arange(0.01,0.2,0.05)
,'n_estimator':np.arange(100,1100,50),'gamma':np.arange(0.01,0.3,0.05)}
ABParams = {'n_estimators':np.arange(100,1100,50),'learning_rate':np.arange(0.01,0.2,0.05)}
RFParams = {'n_estimators':np.arange(100,1100,50),'max_depth':np.arange... | Titanic - Machine Learning from Disaster |
3,787,676 | train_df['content_count'] = train_df['content_id'].map(content_agg['count'] ).astype('int32')
train_df['content_sum'] = train_df['content_id'].map(content_agg['sum'] ).astype('int32')
train_df['content_correctness'] = train_df['content_id'].map(content_agg['sum'] / content_agg['count'])
train_df.content_correctness=... | xgb_best_Params,xgb_best_score = tuneParamsRandom(XGBClassifier() ,xgbParams,train_df,train_label)
print("XGB:",xgb_best_Params,xgb_best_score)
AB_best_Params,AB_best_score = tuneParamsRandom(AdaBoostClassifier() ,ABParams,train_df,train_label)
print("AdaBoost:",AB_best_Params,AB_best_score)
RF_best_Params,RF_best_... | Titanic - Machine Learning from Disaster |
3,787,676 | questions_df = pd.read_csv(
'.. /input/riiid-test-answer-prediction/questions.csv',
usecols=[0, 1,3,4],
dtype={'question_id': 'int16','bundle_id': 'int16', 'part': 'int8','tags': 'str'}
)
questions_df['part_bundle_id']=questions_df['part']*100000+questions_df['bundle_id']
questions_df.part_bundle_id=questions_df.par... | kf = KFold(n_splits = 5, random_state = 2019)
def fold_training(model, train_x, train_y, test_x):
oof_train = np.zeros(( ntrain))
oof_test = np.zeros(( ntest))
oof_kf_test = np.zeros(( 5,ntest))
for i,(train_idx,test_idx)in enumerate(kf.split(train_x)) :
kf_train_x = train_x.iloc[train_idx]
kf_train_y = train_y.iloc[t... | Titanic - Machine Learning from Disaster |
3,787,676 | questions_df.rename(columns={'question_id':'content_id'}, inplace=True )<data_type_conversions> | xgb_oof_train,xgb_oof_test = fold_training(XGBClassifier(**xgb_best_Params),train_df,train_label,test_df)
AB_oof_train,AB_oof_test = fold_training(AdaBoostClassifier(**AB_best_Params),train_df,train_label,test_df)
RF_oof_train,RF_oof_test = fold_training(RandomForestClassifier(**RF_best_Params),train_df,train_label,t... | Titanic - Machine Learning from Disaster |
3,787,676 | questions_df['content_correctness'] = questions_df['content_id'].map(content_agg['sum'] / content_agg['count'])
questions_df.content_correctness=questions_df.content_correctness.astype('float16')
questions_df['content_correctness_std'] = questions_df['content_id'].map(content_agg['var'])
questions_df.content_correct... | final_train_df = pd.DataFrame(np.concatenate(( xgb_oof_train,AB_oof_train,
RF_oof_train,ET_oof_train,gbc_oof_train,LGBMC_oof_train),axis=1))
final_test_df = pd.DataFrame(np.concatenate(( xgb_oof_test,AB_oof_test,
RF_oof_test,ET_oof_test,gbc_oof_test,LGBMC_oof_test),axis=1))
LRParams = {'penalty':['l1','l2'],'C':[0.01,0... | Titanic - Machine Learning from Disaster |
3,787,676 | part_agg = questions_df.groupby('part')['content_correctness'].agg(['mean', 'var'])
questions_df['part_correctness_mean'] = questions_df['part'].map(part_agg['mean'])
questions_df['part_correctness_std'] = questions_df['part'].map(part_agg['var'])
questions_df.part_correctness_mean=questions_df.part_correctness_mean... | LR = LogisticRegression(**LR_best_Params)
LR.fit(final_train_df,train_label)
prediction = LR.predict(final_test_df ) | Titanic - Machine Learning from Disaster |
3,787,676 | bundle_agg = questions_df.groupby('bundle_id')['content_correctness'].agg(['mean'])
questions_df['bundle_correctness'] = questions_df['bundle_id'].map(bundle_agg['mean'])
questions_df.bundle_correctness=questions_df.bundle_correctness.astype('float16' )<categorify> | submission = pd.DataFrame({'PassengerId':test_Ids,'Survived':prediction})
submission.to_csv('submission_v9.csv',index = False ) | Titanic - Machine Learning from Disaster |
9,163,665 | tags1_agg = questions_df.groupby('tags1')['content_correctness'].agg(['mean', 'var'])
questions_df['tags1_correctness_mean'] = questions_df['tags1'].map(tags1_agg['mean'])
questions_df['tags1_correctness_std'] = questions_df['tags1'].map(tags1_agg['var'])
questions_df.tags1_correctness_mean=questions_df.tags1_correc... | plt.style.use('seaborn-darkgrid')
warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
9,163,665 | questions_df.drop(columns=['content_correctness'], inplace=True )<merge> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
9,163,665 | questions_df = pd.merge(questions_df, content_explation_agg, on='content_id', how='left',right_index=True )<drop_column> | target = train_data['Survived']
train_data.drop(['Survived'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
9,163,665 | del bundle_agg
del part_agg
del tags1_agg
gc.collect()<train_model> | full_data = pd.concat([train_data, test_data], axis = 0 ) | Titanic - Machine Learning from Disaster |
9,163,665 | train_df['user_correctness'].fillna(1, inplace=True)
train_df['attempt_no'].fillna(1, inplace=True)
train_df.fillna(0, inplace=True )<categorify> | full_data.drop(['PassengerId', 'Ticket', 'Cabin', 'Fare'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
9,163,665 | MAX_SEQ = 160
skills = train_df["content_id"].unique()
n_skill = len(skills)
print("number skills", len(skills))
group = train_df[['user_id', 'content_id', 'answered_correctly']].groupby('user_id' ).apply(lambda r:(
r['content_id'].values,
r['answered_correctly'].values))
for user_id in group.index:
q, qa = group[use... | %pip install nameparser
full_data['Name_Title'] = full_data['Name'].apply(lambda x: HumanName(x ).title)
print(full_data.Name_Title.value_counts())
unique_title = list(full_data.Name_Title.value_counts().index ) | Titanic - Machine Learning from Disaster |
9,163,665 | features = [
'lagtime',
'lagtime_mean',
'user_lecture_cumsum',
'user_lecture_lv',
'prior_question_elapsed_time',
'delta_prior_question_elapsed_time',
'user_correctness',
'user_correct_cumcount',
'user_correct_cumsum',
'content_correctness',
'content_explation_false_mean',
'content_explation_true_mean',
'content_count',... | full_data.drop(['Name'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
9,163,665 | flag_lgbm=True
clfs = list()
params = {
'num_leaves': 350,
'max_bin':700,
'min_child_weight': 0.03454472573214212,
'feature_fraction': 0.58,
'bagging_fraction': 0.58,
'objective': 'binary',
'max_depth': -1,
'learning_rate': 0.05,
"boosting_type": "gbdt",
"bagging_seed": 11,
"metric": 'auc',
"verbosity": -1,
'reg_alpha'... | top_title = ['Mr.','Miss.','Mrs.','Master.'] | Titanic - Machine Learning from Disaster |
9,163,665 | del train_df_clf
del valid_df
gc.collect()<prepare_x_and_y> | full_data.replace({'Sex': {'male': 0, 'female': 1}}, inplace = True ) | Titanic - Machine Learning from Disaster |
9,163,665 | for i in range(0,num):
tr_data = lgb.Dataset(trains[i][features], label=trains[i][target])
va_data = lgb.Dataset(valids[i][features], label=valids[i][target])
del trains
del valids
gc.collect()
model = lgb.train(
params,
tr_data,
num_boost_round=5000,
valid_sets=[tr_data, va_data],
early_stopping_rounds=50,
feature_... | full_data.isnull().sum() [full_data.isnull().sum() > 0].sort_values(ascending = False ) | Titanic - Machine Learning from Disaster |
9,163,665 | user_sum_dict = user_agg['sum'].astype('int16' ).to_dict(defaultdict(int))
user_count_dict = user_agg['count'].astype('int16' ).to_dict(defaultdict(int))
content_sum_dict = content_agg['sum'].astype('int32' ).to_dict(defaultdict(int))
content_count_dict = content_agg['count'].astype('int32' ).to_dict(defaultdict(int))
... | guess_ages = np.zeros(( 2,3))
for i in range(0, 2):
for j in range(0, 3):
guess_df = full_data[(full_data['Sex'] == i)&(full_data['Pclass'] == j+1)]['Age'].dropna()
age_guess = guess_df.median()
guess_ages[i,j] = int(age_guess/0.5 + 0.5)* 0.5
for i in range(0, 2):
for j in range(0, 3):
full_data.loc[(full_data.Age.isnu... | Titanic - Machine Learning from Disaster |
9,163,665 | user_lecture_sum_dict = user_lecture_agg['sum'].astype('int16' ).to_dict(defaultdict(int))
user_lecture_count_dict = user_lecture_agg['count'].astype('int16' ).to_dict(defaultdict(int))
lagtime_mean_dict = lagtime_agg['mean'].astype('int32' ).to_dict(defaultdict(int))
del user_lecture_agg
del lagtime_agg
gc.collect()<c... | full_data['Embarked'].fillna(full_data['Embarked'].mode() [0], inplace = True ) | Titanic - Machine Learning from Disaster |
9,163,665 | attempt_no_agg=attempt_no_agg[attempt_no_agg['sum'] >1]
attempt_no_sum_dict = attempt_no_agg['sum'].to_dict(defaultdict(int))
del attempt_no_agg
gc.collect()<categorify> | full_data.isnull().sum() [full_data.isnull().sum() > 0].sort_values(ascending = False ) | Titanic - Machine Learning from Disaster |
9,163,665 | max_timestamp_u_dict=max_timestamp_u.set_index('user_id' ).to_dict()
user_prior_question_elapsed_time_dict=user_prior_question_elapsed_time.set_index('user_id' ).to_dict()
del max_timestamp_u
del user_prior_question_elapsed_time
gc.collect()<feature_engineering> | full_data['Family'] = full_data['SibSp'] + full_data['Parch'] + 1 | Titanic - Machine Learning from Disaster |
9,163,665 | def get_max_attempt(user_id,content_id):
k =(user_id,content_id)
if k in attempt_no_sum_dict.keys() :
attempt_no_sum_dict[k]+=1
return attempt_no_sum_dict[k]
attempt_no_sum_dict[k] = 1
return attempt_no_sum_dict[k]<choose_model_class> | full_data.loc[full_data['Family'] == 1, 'Family'] = 'Alone'
full_data.loc[full_data['Family'] == 2, 'Family'] = 'Partner'
full_data.loc[(full_data['Family'] != 'Alone')&(full_data['Family'] != 'Partner'), 'Family'] = 'More' | Titanic - Machine Learning from Disaster |
9,163,665 | class FFN(nn.Module):
def __init__(self, state_size=200):
super(FFN, self ).__init__()
self.state_size = state_size
self.lr1 = nn.Linear(state_size, state_size)
self.relu = nn.ReLU()
self.lr2 = nn.Linear(state_size, state_size)
self.dropout = nn.Dropout(0.2)
def forward(self, x):
x = self.lr1(x)
x = self.relu(x)
x... | Titanic - Machine Learning from Disaster | |
9,163,665 | iter_test = env.iter_test()
prior_test_df = None<data_type_conversions> | full_data.drop(['SibSp', 'Parch'], axis = 1, inplace = True)
print('Types of Passengers Travelling:',full_data.Family.value_counts())
full_data.head(10 ) | Titanic - Machine Learning from Disaster |
9,163,665 | %%time
for(test_df, sample_prediction_df)in iter_test:
if(prior_test_df is not None)&(psutil.virtual_memory().percent<90):
print(psutil.virtual_memory().percent)
prior_test_df[target] = eval(test_df['prior_group_answers_correct'].iloc[0])
prior_test_df = prior_test_df[prior_test_df[target] != -1].reset_index(drop=Tru... | full_data.loc[ full_data['Age'] <= 10, 'Age'] = 0
full_data.loc[(full_data['Age'] > 10)&(full_data['Age'] <= 20), 'Age'] = 1
full_data.loc[(full_data['Age'] > 20)&(full_data['Age'] <= 30), 'Age'] = 2
full_data.loc[(full_data['Age'] > 30)&(full_data['Age'] <= 40), 'Age'] = 3
full_data.loc[(full_data['Age'] > 40)&(full_d... | Titanic - Machine Learning from Disaster |
9,163,665 | !pip install efficientnet_pytorch >> /dev/null<set_options> | dummy_df = pd.get_dummies(full_data, columns = ['Pclass', 'Embarked', 'Name_Title', 'Family'], drop_first = True ) | Titanic - Machine Learning from Disaster |
9,163,665 | random.seed(a=42)
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
gpus = tf.config.experimental.list_physical_devices('GPU')
try:
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
except RuntimeError as e:
print(e)
CFG = dict(
batch_size = 32,
read_size = 256,
crop_size = 235,
net_size = 224,
LR = 1e-4... | train = dummy_df[:len(train_data)]
test = dummy_df[len(train_data):] | Titanic - Machine Learning from Disaster |
9,163,665 | def get_mat(rotation, shear, height_zoom, width_zoom, height_shift, width_shift):
rotation = math.pi * rotation / 180.
shear = math.pi * shear / 180.
def get_3x3_mat(lst):
return tf.reshape(tf.concat([lst],axis=0), [3,3])
c1 = tf.math.cos(rotation)
s1 = tf.math.sin(rotation)
one = tf.constant([1],dtype='float32')
... | rf_clf = RandomForestClassifier(n_estimators = 100)
rf_clf.fit(train, target)
rf_pred = rf_clf.predict(test)
print('Accuracy Score:',round(rf_clf.score(train, target)*100,2))
| Titanic - Machine Learning from Disaster |
9,163,665 | def get_model() :
model = EfficientNet.from_pretrained('efficientnet-b0', num_classes=1)
model.to(device)
return model
def get_opt_loss_fn(model):
optimizer = torch.optim.Adam(model.parameters() , lr=CFG["LR"])
loss_object = torch.nn.BCEWithLogitsLoss().to(device)
return optimizer, loss_object
def get_train_fn() :
... | svc_clf = SVC(C = 2, kernel = 'rbf')
svc_clf.fit(train, target)
svc_pred = svc_clf.predict(test)
print('Accuracy Score:',round(svc_clf.score(train, target)*100,2)) | Titanic - Machine Learning from Disaster |
9,163,665 | fold_cv_scores = []
submission_scores = []
folds = KFold(n_splits=5, shuffle = True, random_state = 42)
fold_num = 0
for tr_idx, va_idx in folds.split(files_train):
print(f"Starting fold: {fold_num}")
no_imp = 0
CFG['batch_size'] = 32
checkpoint_filepath = f"checkpoint_{fold_num}.h5"
files_train_tr = files_train[tr_i... | ada_clf = AdaBoostClassifier(n_estimators = 100)
ada_clf.fit(train, target)
ada_pred = ada_clf.predict(test)
print('Accuracy Score:',round(ada_clf.score(train, target)*100,2)) | Titanic - Machine Learning from Disaster |
9,163,665 | df_fold = pd.DataFrame(fold_cv_scores, columns=["Fold", "Filename", "Pred", "Label"])
df_sub = pd.DataFrame(submission_scores, columns=["Fold", "Filename", "Pred"] )<compute_test_metric> | lgbm_clf = LGBMClassifier(n_estimators = 400)
lgbm_clf.fit(train, target)
lgbm_pred = lgbm_clf.predict(test)
print('Accuracy Score:',round(lgbm_clf.score(train, target)*100,2)) | Titanic - Machine Learning from Disaster |
9,163,665 | df_fold = df_fold.groupby(["Filename"] ).mean().reset_index()
print("CV ROCAUC: ")
print(roc_auc_score(df_fold["Label"], df_fold["Pred"]))<save_to_csv> | xgb_clf = XGBClassifier(n_estimators = 200)
xgb_clf.fit(train, target)
xgb_pred = xgb_clf.predict(test)
print('Accuracy Score:',round(xgb_clf.score(train, target)*100,2)) | Titanic - Machine Learning from Disaster |
9,163,665 | df_sub = df_sub.groupby(["Filename"] ).mean().reset_index()
df_sub = df_sub[["Filename", "Pred"]]
df_sub.columns=["image_name", "target"]
df_sub.to_csv("submission.csv", index=False )<load_from_csv> | base_estimators = [('lgbm',lgbm_clf),
('rf',rf_clf)]
stc_clf = StackingClassifier(estimators = base_estimators, final_estimator = svc_clf)
stc_clf.fit(train, target)
stc_pred = stc_clf.predict(test)
print('Accuracy Score:',round(stc_clf.score(train, target)*100,2)) | Titanic - Machine Learning from Disaster |
9,163,665 | def MinMaxBestBaseStacking(input_folder, best_base, output_path):
sub_base = pd.read_csv(best_base)
all_files = os.listdir(input_folder)
outs = [pd.read_csv(os.path.join(input_folder, f), index_col=0)for f in all_files]
concat_sub = pd.concat(outs, axis=1)
cols = list(map(lambda x: "target" + str(x), range(len(conca... | estimators = [('rf',rf_clf),
('xgb',xgb_clf),
('lgbm',lgbm_clf)]
vot_clf = VotingClassifier(estimators = estimators, voting = 'soft')
vot_clf.fit(train, target)
vot_pred = vot_clf.predict(test)
print('Accuracy Score:',round(vot_clf.score(train, target)*100,2)) | Titanic - Machine Learning from Disaster |
9,163,665 | MinMaxBestBaseStacking('.. /input/cs0099/', '.. /input/cs0099/submission_mean.csv', 'submission.csv')
<import_modules> | submit_data = pd.read_csv('/kaggle/input/titanic/gender_submission.csv')
submit_data.head() | Titanic - Machine Learning from Disaster |
9,163,665 | import pandas as pd, numpy as np, os
from sklearn.metrics import roc_auc_score
import matplotlib.pyplot as plt<load_from_csv> | submit_data['Survived'] = rf_pred
submit_data.head() | Titanic - Machine Learning from Disaster |
9,163,665 | <prepare_x_and_y><EOS> | submit_data.to_csv('output.csv', index = False ) | Titanic - Machine Learning from Disaster |
11,487,740 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<compute_train_metric> | import os
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib as mpl
import matplotlib.pyplot as plt
from scipy import stats
from scipy.stats import norm, skew
from sklearn.preprocessing import LabelEncoder
from datetime import datetime | Titanic - Machine Learning from Disaster |
11,487,740 | all = []
for k in range(x.shape[1]):
auc = roc_auc_score(OOF_CSV[0].target,x[:,k])
all.append(auc)
print('Model %i has OOF AUC = %.4f'%(k,auc))
m = [np.argmax(all)]; w = []<find_best_params> | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
11,487,740 | old = np.max(all);
RES = 200;
PATIENCE = 10;
TOL = 0.0003
DUPLICATES = False
print('Ensemble AUC = %.4f by beginning with model %i'%(old,m[0]))
print()
for kk in range(len(OOF)) :
md = x[:,m[0]]
for i,k in enumerate(m[1:]):
md = w[i]*x[:,k] +(1-w[i])*md
mx = 0; mx_k = 0; mx_w = 0
print('Searching for best model to add.... | categorical = len(train.select_dtypes(include=['object'] ).columns)
numerical = len(train.select_dtypes(include=['int64','float64'] ).columns)
print('Total number of variables= ', categorical, 'Categorical', '+',
numerical, 'Numerical', '=>', categorical+numerical, 'variables')
train.head(10 ) | Titanic - Machine Learning from Disaster |
11,487,740 | print('We are using models',m)
print('with weights',w)
print('and achieve ensemble AUC = %.4f'%old )<save_to_csv> | comb = train.append(test)
comb.shape
comb.isnull().sum() /comb.isnull().count() *100 | Titanic - Machine Learning from Disaster |
11,487,740 | df = OOF_CSV[0].copy()
df.pred = md
df.to_csv('ensemble_oof.csv',index=False )<load_from_csv> | TicketType = []
for i in range(len(comb.Ticket)) :
ticket = comb.Ticket.iloc[i]
for c in string.punctuation:
ticket = ticket.replace(c,"")
splited_ticket = ticket.split(" ")
if len(splited_ticket)== 1:
TicketType.append('NO')
else:
TicketType.append(splited_ticket[0])
comb['TicketType'] = TicketType
comb['TicketTyp... | Titanic - Machine Learning from Disaster |
11,487,740 | SUB = np.sort([f for f in FILES if 'sub' in f])
SUB_CSV = [pd.read_csv(PATH+k)for k in SUB]
print('We have %i submission files...'%len(SUB))
print() ; print(SUB )<define_variables> | comb['TicketFreq'] = comb.groupby('Ticket')['Ticket'].transform('count' ) | Titanic - Machine Learning from Disaster |
11,487,740 | a = np.array([ int(x.split('_')[1].split('.')[0])for x in SUB ])
b = np.array([ int(x.split('_')[1].split('.')[0])for x in OOF ])
if len(a)!=len(b):
print('ERROR submission files dont match oof files')
else:
for k in range(len(a)) :
if a[k]!=b[k]: print('ERROR submission files dont match oof files' )<prepare_x_and_y... | comb.drop(['Ticket', 'Sex', 'Title', 'Name', 'Fare', 'Age', 'TicketType', 'LastName', 'Parch', 'SibSp', 'Crew',
'Cabin', 'Embarked', 'Group'], axis=1, inplace=True)
comb.head(5 ) | Titanic - Machine Learning from Disaster |
11,487,740 | y = np.zeros(( len(SUB_CSV[0]),len(SUB)))
for k in range(len(SUB)) :
y[:,k] = SUB_CSV[k].target.values<save_to_csv> | n=len(train)
train_df = comb.iloc[:n]
test_df = comb.iloc[n:]
y_train = train_df['Survived'].astype(int)
X_train = train_df.drop(['Survived', 'PassengerId'], axis=1)
X_test = test_df.drop(['Survived', 'PassengerId'], axis=1 ) | Titanic - Machine Learning from Disaster |
11,487,740 | df = SUB_CSV[0].copy()
df.target = md2
df.to_csv('ensemble_sub.csv',index=False )<install_modules> | def stats(models, X_train, y_train):
stats = {}
for name, inst in models.items() :
mscores = []
model_pipe = make_pipeline(StandardScaler() , inst)
model_pipe.fit(X_train, y_train)
acc=round(model_pipe.score(X_train, y_train)* 100, 2)
mscores.append(acc)
scores = cross_val_score(model_pipe, X_train, y_train, cv=10,... | Titanic - Machine Learning from Disaster |
11,487,740 | !pip install xgboost
<load_from_csv> | vote = VotingClassifier(estimators=[
('AdaBoostClassifier', AdaBoostClassifier()),
('GradientBoostingClassifier', GradientBoostingClassifier()),
('LogisticRegression', LogisticRegression()),
('SupportVectorMachines', SVC()),
('RandomForest', RandomForestClassifier()),
('KNN', KNeighborsClassifier())
],
voting='h... | Titanic - Machine Learning from Disaster |
11,487,740 | <data_type_conversions><EOS> | output= pd.DataFrame(pd.DataFrame({
"PassengerId": test_df["PassengerId"],
"Survived": prediction_vote}))
output.head()
output.to_csv('FinalSubmission.csv', index=False ) | Titanic - Machine Learning from Disaster |
8,787,138 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<data_type_conversions> | import numpy as np
import pandas as pd
import pandas_summary as ps
from category_encoders import WOEEncoder | Titanic - Machine Learning from Disaster |
8,787,138 | train['sex'] = train['sex'].astype("category" ).cat.codes +1
train['anatom_site_general_challenge'] = train['anatom_site_general_challenge'].astype("category" ).cat.codes +1
train.head()<data_type_conversions> | warnings.filterwarnings("ignore")
%matplotlib inline
| Titanic - Machine Learning from Disaster |
8,787,138 | test['sex'] = test['sex'].astype("category" ).cat.codes +1
test['anatom_site_general_challenge'] = test['anatom_site_general_challenge'].astype("category" ).cat.codes +1
test.head()<prepare_x_and_y> | folder = '.. /input/titanic/'
train_df = pd.read_csv(folder + 'train.csv')
test_df = pd.read_csv(folder + 'test.csv')
sub_df = pd.read_csv(folder + 'gender_submission.csv' ) | Titanic - Machine Learning from Disaster |
8,787,138 | x_train = train[['sex', 'age_approx','anatom_site_general_challenge']]
y_train = train['target']
x_test = test[['sex', 'age_approx','anatom_site_general_challenge']]
train_DMatrix = xgb.DMatrix(x_train, label= y_train)
test_DMatrix = xgb.DMatrix(x_test )<init_hyperparams> | train_df['Sex'] = train_df['Sex'].apply(lambda x: 1 if str(x)== 'male' else 0)
test_df['Sex'] = test_df['Sex'].apply(lambda x: 1 if str(x)== 'male' else 0 ) | Titanic - Machine Learning from Disaster |
8,787,138 | param = {
'booster':'gbtree',
'eta': 0.3,
'num_class': 2,
'max_depth': 8
}
epochs = 100<choose_model_class> | train_df.drop('PassengerId', axis=1, inplace=True)
test_df.drop('PassengerId', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
8,787,138 | clf = xgb.XGBClassifier(n_estimators=1000,
max_depth=8,
objective='multi:softprob',
seed=0,
nthread=-1,
learning_rate=0.015,
num_class = 2,
scale_pos_weight =(32542/584))<train_model> | y = train_df['Survived']
train_df.drop('Survived', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
8,787,138 | clf.fit(x_train, y_train)
<predict_on_test> | y.value_counts() | Titanic - Machine Learning from Disaster |
8,787,138 | pred_train = clf.predict(x_train )<compute_test_metric> | y.value_counts(normalize=True ) | Titanic - Machine Learning from Disaster |
8,787,138 | accuracy_score(pred_train, y_train )<predict_on_test> | for data in(train_df, test_df):
data['FamilySize'] = data['Parch'] + data['SibSp'] | Titanic - Machine Learning from Disaster |
8,787,138 | sub.target = clf.predict_proba(x_test)[:,1]
sub_tabular = sub.copy()<load_from_csv> | for data in(train_df, test_df):
data['Parch'] = data['Parch'] / data['FamilySize']
data['Parch'].fillna(-1, inplace=True)
data['SibSp'] = data['SibSp'] / data['FamilySize']
data['SibSp'].fillna(-1, inplace=True ) | Titanic - Machine Learning from Disaster |
8,787,138 | sub_public_merge = pd.read_csv('/kaggle/input/incredible-tpus-finetune-effnetb0-b6-at-once/submission_models_blended.csv' )<feature_engineering> | for data in(train_df, test_df):
data['Fare'].fillna(train_df.groupby(['Embarked', 'Pclass'])['Fare'].transform('median'), inplace=True)
for data in(train_df, test_df):
data['Embarked'].fillna(train_df['Embarked'].mode() , inplace=True ) | Titanic - Machine Learning from Disaster |
8,787,138 | sub.target = sub_public_merge.target *0.80 + sub_tabular.target *0.20<save_to_csv> | class AgeFeature(BaseEstimator, TransformerMixin):
def fit(self, X, y=None):
return self
def transform(self, X, y=None):
X['Initial'] = 0
for i in X:
X['Initial'] = X.Name.str.extract('([A-Za-z]+)\.')
X['Initial'].replace(
['Dona','Mlle','Mme','Ms','Dr','Major','Lady','Countess','Jonkheer','Col','Rev','Capt','Sir',... | Titanic - Machine Learning from Disaster |
8,787,138 | sub.to_csv('submission.csv', index = False )<set_options> | for data in(train_df, test_df):
data['Is_Married'] = 0
data['Is_Married'].loc[data['Initial'] == 'Mrs'] = 1 | Titanic - Machine Learning from Disaster |
8,787,138 | %matplotlib inline
warnings.filterwarnings(action='ignore', category=DeprecationWarning, module='sklearn')
warnings.simplefilter('ignore')
def seed_everything(SEED):
np.random.seed(SEED)
os.environ['PYTHONHASHSEED'] = str(SEED )<define_variables> | train_df['Cabin'] = train_df['Cabin'].apply(lambda x: str(x)[0] ).apply(lambda x: 'n' if x == 'T' else x)
test_df['Cabin'] = test_df['Cabin'].apply(lambda x: str(x)[0] ).apply(lambda x: 'n' if x == 'T' else x)
train_df['Cabin'].unique() , test_df['Cabin'].unique() | Titanic - Machine Learning from Disaster |
8,787,138 | FOLDS = 3
SEED = 123
Setup_Parameters = True
seed_everything(SEED)
file_add_list = [1,2,3,4,5]
pesudo_label = True
test_pipeline = True<load_from_csv> | woe_encoder = WOEEncoder(cols=['Cabin', 'Embarked', 'Initial'])
woe_encoder.fit(train_df, y)
train_df = woe_encoder.transform(train_df)
test_df = woe_encoder.transform(test_df ) | Titanic - Machine Learning from Disaster |
8,787,138 | BASE_PATH = '.. /input/siim-isic-melanoma-classification'
train_metadata = pd.read_csv(os.path.join(BASE_PATH, 'train.csv'))
test_metadata = pd.read_csv(os.path.join(BASE_PATH, 'test.csv'))
sample_submission = pd.read_csv(os.path.join(BASE_PATH, 'sample_submission.csv'))
tfrecord_number_df = pd.read_csv('.. /input/stac... | train_df.drop(['Name', 'Ticket'], axis=1, inplace=True)
test_df.drop(['Name', 'Ticket'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
8,787,138 | print('Unique values in column with frequency : ')
print('
sex : ', dict(train_metadata.sex.value_counts()))
print('
age_approx : ', dict(train_metadata.age_approx.value_counts()))
print('
anatom_site_general_challenge : ', dict(train_metadata.anatom_site_general_challenge.value_counts()))
print('
diagnosis : ', dict(... | train_df.columns.to_list() | Titanic - Machine Learning from Disaster |
8,787,138 | print('Unique values in column with frequency : ')
print('
sex : ', dict(test_metadata.sex.value_counts()))
print('
age_approx : ', dict(test_metadata.age_approx.value_counts()))
print('
anatom_site_general_challenge : ', dict(test_metadata.anatom_site_general_challenge.value_counts()))<categorify> | train_df.columns.to_list() | Titanic - Machine Learning from Disaster |
8,787,138 | train = train_metadata.copy()
train['age_approx'] = train['age_approx'].fillna(train.age_approx.mean())
sex_code = pd.get_dummies(train.sex, prefix='sex')
anatom_site_general_challenge_code = pd.get_dummies(train.anatom_site_general_challenge, prefix='anatom_site')
age_aprox_normalized =(train.age_approx-train.age_a... | dfs = ps.DataFrameSummary(train_df)
dfs.summary() | Titanic - Machine Learning from Disaster |
8,787,138 | def add_OOF_pred(train_coded,num):
for n in file_add_list:
df_ = pd.read_csv(f'.. /input/95-cv-oof-submission/oof_{n}.csv')
train_coded = pd.merge(train_coded, df_[['image_name','pred']], on="image_name",how='right')
train_coded.rename({'pred': f'pred_{n}'}, axis=1, inplace=True)
return train_coded
train_coded = pd.... | dfs = ps.DataFrameSummary(test_df)
dfs.summary() | Titanic - Machine Learning from Disaster |
8,787,138 | test = test_metadata.copy()
test['age_approx'] = test['age_approx'].fillna(test.age_approx.mean())
sex_code = pd.get_dummies(test.sex, prefix='sex')
anatom_site_general_challenge_code = pd.get_dummies(test.anatom_site_general_challenge, prefix='anatom_site')
age_aprox_normalized =(test.age_approx-test.age_approx.mea... | scaler = StandardScaler().fit(train_df)
scaled_train_df = scaler.transform(train_df)
scaled_test_df = scaler.transform(test_df ) | Titanic - Machine Learning from Disaster |
8,787,138 | def add_submission_pred(test_coded,num):
for n in file_add_list:
df_ = pd.read_csv(f'.. /input/95-cv-oof-submission/submission_{n}.csv')
test_coded = pd.merge(test_coded, df_[['image_name','target']], on="image_name",how='right')
test_coded.rename({'target': f'pred_{n}'}, axis=1, inplace=True)
return test_coded
test... | tsne = TSNE(perplexity=30)
train_tsne_transformed = tsne.fit_transform(scaled_train_df)
test_tsne_transformed = tsne.fit_transform(scaled_test_df ) | Titanic - Machine Learning from Disaster |
8,787,138 | def crossValidate(CLF,X=train_coded,X_test=test_coded,FOLDS = 5,SEED = 123,show_roc_curve = False,pesudo_label = False):
print(Fore.YELLOW)
print('
model_name = type(CLF ).__name__
print('
print('
CV_Score = []
Val_preds = []
Val_imagenames = []
val_targets = []
CV_Score_pesudo = []
Val_preds_pesudo = []
Val_imagename... | p = 0.9
k = 350
cat=[]
models = dict()
trains = []
preds = []
folds = []
valid_scores =dict()
skf = StratifiedKFold(n_splits=9, shuffle=True, random_state=7)
for num, spl in enumerate(skf.split(train_df, y)) :
train_index, val_index = spl[0], spl[1]
x_train_1, x_valid_1 = train_df.iloc[train_index, :], train_df.iloc[v... | Titanic - Machine Learning from Disaster |
8,787,138 | clf1 = lgb.LGBMClassifier(max_depth=5,
metric="auc",
n_estimators=100,
num_leaves=5,
boosting_type="gbdt",
learning_rate=0.1,
feature_fraction=0.05,
colsample_bytree=0.1,
bagging_fraction=0.8,
bagging_freq=2,
reg_lambda=0.2 )<choose_model_class> | model = LogisticRegression(penalty='l1', solver='saga')
model.fit(pd.DataFrame(np.array(trains)).T, y)
target = model.predict(pd.DataFrame(np.array(preds)).T ) | Titanic - Machine Learning from Disaster |
8,787,138 | clf2 = LogisticRegression(
C= 1.0,
class_weight=None,
dual= False,
fit_intercept= True,
intercept_scaling= 1,
l1_ratio= None,
max_iter= 100,
multi_class= 'auto',
n_jobs= None,
penalty= 'l2',
random_state= None,
solver= 'lbfgs',
tol= 0.0001,
verbose= 0,
warm_start= False )<choose_model_class> | sub_df['Survived'] = target | Titanic - Machine Learning from Disaster |
8,787,138 | clf3 = XGBRegressor(base_score=0.5,
booster=None,
colsample_bylevel=1,
colsample_bynode=1,
colsample_bytree=0.8,
gamma=1,
gpu_id=-1,
importance_type='gain',
interaction_constraints=None,
learning_rate=0.002,
max_delta_step=0,
max_depth=10,
min_child_weight=1,
missing=None,
monotone_constraints=None,
n_estimators=700,
n... | sub_df.to_csv("submission.csv", index=False ) | Titanic - Machine Learning from Disaster |
6,670,250 | clf4 = GaussianNB(
priors= None,
var_smoothing= 1e-09 )<choose_model_class> | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
6,670,250 | clf5 = RandomForestClassifier(
bootstrap= True,
ccp_alpha= 0.0,
class_weight= None,
criterion= 'gini',
max_depth= 5,
max_features= 'auto',
max_leaf_nodes= 30,
max_samples= None,
min_impurity_decrease= 0.0,
min_impurity_split= None,
min_samples_leaf= 2,
min_samples_split= 100,
min_weight_fraction_leaf= 0.0,
n_estimator... | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv')
| Titanic - Machine Learning from Disaster |
6,670,250 | clf9 = KNeighborsRegressor(algorithm= 'auto',
leaf_size= 30,
metric= 'minkowski',
metric_params= None,
n_jobs= None,
n_neighbors= 10,
p= 5,
weights= 'uniform' )<choose_model_class> | passengerId = test.PassengerId
titanic = train.append(test, ignore_index=True ) | Titanic - Machine Learning from Disaster |
6,670,250 | clf10 = DecisionTreeRegressor(ccp_alpha= 0.0,
criterion= 'mse',
max_depth= 5,
max_features= 'auto',
max_leaf_nodes= 30,
min_impurity_decrease= 0.0,
min_impurity_split= None,
min_samples_leaf= 2,
min_samples_split= 100,
min_weight_fraction_leaf= 0.0,
presort= 'deprecated',
random_state= SEED,
splitter= 'best' )<choose_m... | train_idx = len(train)
test_idx = len(titanic)- len(test ) | Titanic - Machine Learning from Disaster |
6,670,250 | clf11 = GradientBoostingRegressor()<choose_model_class> | titanic.drop('PassengerId', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
6,670,250 | SCF = StackingClassifier(classifiers=[clf1, clf5],
meta_classifier=clf2,
use_probas=True,
average_probas=True )<choose_model_class> | titanic['Title'] = titanic.Name.apply(lambda name: name.split(',')[1].split('.')[0].strip())
titanic.head() | Titanic - Machine Learning from Disaster |
6,670,250 | if test_pipeline:
pipelines = []
pipelines.append(( 'LGBMClassifier', Pipeline([('LGBMClassifier',clf1)])))
pipelines.append(( 'LogisticRegression', Pipeline([('LogisticRegression',clf2)])))
pipelines.append(( 'XGBRegressor', Pipeline([('XGBRegressor',clf3)])))
pipelines.append(( 'GaussianNB', Pipeline([('GaussianNB... | print("There are {} unique titles.".format(titanic.Title.nunique()))
print("
", titanic.Title.unique() ) | Titanic - Machine Learning from Disaster |
6,670,250 | select_classifier = clf2
select_classifier.get_params()<prepare_x_and_y> | normalized_titles = {
"Capt": "Officer",
"Col": "Officer",
"Major": "Officer",
"Jonkheer": "Royalty",
"Don": "Royalty",
"Sir" : "Royalty",
"Dr": "Officer",
"Rev": "Officer",
"the Countess":"Royalty",
"Dona": "Royalty",
"Mme": "Mrs",
"Mlle": "Miss",
"Ms": "Mrs",
"Mr" : "Mr",
"Mrs" : "Mrs",
"Miss" : "Miss",
"Master" : "M... | Titanic - Machine Learning from Disaster |
6,670,250 | if Setup_Parameters:
X_train = train_coded.drop('target',axis=1 ).iloc[:,1:]
y_train = train_coded['target']
params = dict(
C = [0.001, 0.01, 0.1, 1, 10],
max_iter = [100,150,50]
)
grid = GridSearchCV(estimator=select_classifier,
param_grid=params,
cv=FOLDS,
scoring='roc_auc',
refit='AUC',
n_jobs = -1)
grid.fit(X_t... | titanic.Title = titanic.Title.map(normalized_titles)
print(titanic.Title.value_counts() ) | Titanic - Machine Learning from Disaster |
6,670,250 | %matplotlib inline<define_variables> | titanic.Age = grouped.Age.apply(lambda x: x.fillna(x.median()))
titanic.info() | Titanic - Machine Learning from Disaster |
6,670,250 | np.random.seed(42)
random.seed(42 )<load_from_csv> | titanic.Cabin = titanic.Cabin.fillna('U' ) | Titanic - Machine Learning from Disaster |
6,670,250 | oof_01 = pd.read_csv('.. /input/melanoma-oof-and-sub/oof_0.csv')
test_01 = pd.read_csv('.. /input/melanoma-oof-and-sub/sub_0.csv')
oof_01 = oof_01.sort_values(by=['image_name'],
ascending=True ).reset_index(drop=True)
test_01 = test_01.sort_values(by=['image_name'],
ascending=True ).reset_index(drop=True)
oof_02 = ... | most_embarked = titanic.Embarked.value_counts().index[0]
titanic.Embarked = titanic.Embarked.fillna(most_embarked ) | Titanic - Machine Learning from Disaster |
6,670,250 | blend_train = []
blend_test = []
blend_train.append(oof_01.pred)
blend_train.append(oof_02.pred)
blend_train.append(oof_03.pred)
blend_train.append(oof_04.pred)
blend_train.append(oof_05.pred)
blend_train.append(oof_06.pred)
blend_train.append(oof_07.pred)
blend_train.append(oof_08.pred)
blend_train.append(oof_... | titanic.Survived.value_counts(normalize=True ) | Titanic - Machine Learning from Disaster |
6,670,250 | def roc_min_func(weights):
final_prediction = 0
for weight, prediction in zip(weights, blend_train):
final_prediction += weight * prediction
return roc_auc_score(np.array(oof_01.target), final_prediction)
print('
Finding Blending Weights...')
res_list = []
weights_list = []
for k in range(1000):
starting_values = np.... | group_by_sex = titanic.groupby('Sex')
group_by_sex.Survived.mean() | Titanic - Machine Learning from Disaster |
6,670,250 | print('
Ensemble Score: {best_score}'.format(best_score=bestSC))
print('
Best Weights: {weights}'.format(weights=bestWght))
train_prices = np.zeros(len(blend_train[0]))
test_prices = np.zeros(len(blend_test[0]))
print('
Your final model:')
for k in range(len(blend_test)) :
print(' %.6f * model-%d' %(weights[k],(k + 1)... | group_class_sex = titanic.groupby(['Pclass', 'Sex'])
group_class_sex.Survived.mean() | Titanic - Machine Learning from Disaster |
6,670,250 | test_01.target =(test_01.target.values*bestWght[0] +
test_02.target.values*bestWght[1] +
test_03.target.values*bestWght[2] +
test_04.target.values*bestWght[3] +
test_05.target.values*bestWght[4] +
test_06.target.values*bestWght[5] +
test_07.target.values*bestWght[6] +
test_08.target.values*bestWght[7] +
test_09.target.... | titanic['FamilySize'] = titanic.Parch + titanic.SibSp + 1 | Titanic - Machine Learning from Disaster |
6,670,250 | LABELS = ["target"]
all_files = glob.glob(".. /input/pseudolabelmodels/*.csv" )<load_from_csv> | titanic.Cabin = titanic.Cabin.map(lambda x: x[0])
titanic.Cabin.value_counts(normalize=True ) | Titanic - Machine Learning from Disaster |
6,670,250 | outs = [pd.read_csv(f, index_col=0)for f in all_files]
concat_sub = pd.concat(outs, axis=1)
cols = list(map(lambda x: "m" + str(x), range(len(concat_sub.columns))))
concat_sub.columns = cols
concat_sub.reset_index(inplace=True )<feature_engineering> | titanic.Sex = titanic.Sex.map({"male": 0, "female":1} ) | Titanic - Machine Learning from Disaster |
6,670,250 | warnings.filterwarnings("ignore")
rank = np.tril(concat_sub.iloc[:,1:].corr().values,-1)
m =(rank>0 ).sum()
m_gmean, s = 0, 0
for n in range(min(rank.shape[0],m)) :
mx = np.unravel_index(rank.argmin() , rank.shape)
w =(m-n)/(m+n/10)
m_gmean += w*(np.log(concat_sub.iloc[:,mx[0]+1])+np.log(concat_sub.iloc[:,mx[1]+1])... | pclass_dummies = pd.get_dummies(titanic.Pclass, prefix="Pclass")
title_dummies = pd.get_dummies(titanic.Title, prefix="Title")
cabin_dummies = pd.get_dummies(titanic.Cabin, prefix="Cabin")
embarked_dummies = pd.get_dummies(titanic.Embarked, prefix="Embarked" ) | Titanic - Machine Learning from Disaster |
6,670,250 | predict_list = []
predict_list.append(pd.read_csv('.. /input/pseudolabelmodels/submission-9350-pseudo-rohit.csv')[LABELS].values)
predict_list.append(pd.read_csv('.. /input/pseudolabelmodels/submission-9351-pseudo-rohit.csv')[LABELS].values)
predict_list.append(pd.read_csv('.. /input/pseudolabelmodels/submission-9373... | titanic_dummies = pd.concat([titanic, pclass_dummies, title_dummies, cabin_dummies, embarked_dummies], axis=1)
titanic_dummies.drop(['Pclass', 'Title', 'Cabin', 'Embarked', 'Name', 'Ticket'], axis=1, inplace=True)
titanic_dummies.head() | Titanic - Machine Learning from Disaster |
6,670,250 | warnings.filterwarnings("ignore")
print("Rank averaging on ", len(predict_list), " files")
predictions = np.zeros_like(predict_list[0])
for predict in predict_list:
for i in range(1):
predictions[:, i] = np.add(predictions[:, i], rankdata(predict[:, i])/predictions.shape[0])
predictions = predictions /len(predict_l... | train = titanic_dummies[ :train_idx]
test = titanic_dummies[test_idx: ]
train.Survived = train.Survived.astype(int ) | Titanic - Machine Learning from Disaster |
6,670,250 | warnings.filterwarnings("ignore")
print("Rank averaging on ", len(predict_list_2), " files")
predictions_2 = np.zeros_like(predict_list_2[0])
for predict_2 in predict_list_2:
for i in range(1):
predictions_2[:, i] = np.add(predictions_2[:, i], rankdata(predict_2[:, i])/predictions_2.shape[0])
predictions_2 = predic... | X = train.drop('Survived', axis=1 ).values
y = train.Survived.values | 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.