kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
4,881,309 | model.fit(train_X, train_y, batch_size=512, epochs=2, validation_data=(val_X, val_y))<predict_on_test> | def get_team_id(dataset,name_list):
return dataset[(dataset.Surname.isin(name_list)) |(dataset.Maiden.isin(name_list)) ]["PassengerId"].values | Titanic - Machine Learning from Disaster |
4,881,309 | pred_fasttext_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_fasttext_val_y>thresh ).astype(int))))<predict_on_test> | team_id =get_team_id(have_family,["Olsen"])
have_family.loc[have_family.PassengerId.isin(team_id),"Group_size"] = have_family[have_family.PassengerId.isin(team_id)].shape[0]
have_family.loc[have_family.PassengerId.isin(team_id),"Ave_Survival"] = have_family[have_family.PassengerId.isin(team_id)]["Survived"].mean() | Titanic - Machine Learning from Disaster |
4,881,309 | pred_fasttext_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | team_id = get_team_id(have_family,["Crosby","Halstead"])
have_family.loc[have_family.PassengerId.isin(team_id),"Group_size"] = have_family[have_family.PassengerId.isin(team_id)].shape[0]
have_family.loc[have_family.PassengerId.isin(team_id),"Ave_Survival"] = have_family[have_family.PassengerId.isin(team_id)]["Survived... | Titanic - Machine Learning from Disaster |
4,881,309 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<statistical_test> | def full_gs_and_as(dataset,id_list,ticket_kind,check_list,with_friend,count_maiden):
for i in id_list:
surname = set(dataset[dataset.PassengerId.isin([i])]["Surname"].values)
ticket_list = set(dataset[dataset.PassengerId.isin([i])][ticket_kind].values)
if count_maiden ==True:
maiden = set(dataset[dataset.PassengerId.... | Titanic - Machine Learning from Disaster |
4,881,309 | EMBEDDING_FILE = '.. /input/embeddings/paragram_300_sl999/paragram_300_sl999.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE, encoding="utf8", errors='ignore')if len(o)>100)
all_embs = np.stack(embeddings_index.... | full_gs_and_as(dataset = have_family,id_list=ship_team_2,ticket_kind = "Ticket",check_list = [],with_friend=[],count_maiden = True ) | Titanic - Machine Learning from Disaster |
4,881,309 | model.fit(train_X, train_y, batch_size=512, epochs=2, validation_data=(val_X, val_y))<predict_on_test> | def fillfull_p2(dataset,check_list,check_more):
for i in check_list:
pclass = dataset[dataset.PassengerId.isin(i)].Pclass.describe() ["mean"]
if pclass != 2:
check_more = check_more+[i]
else:
dataset.loc[dataset.PassengerId.isin(i),"Group_size"] = len(i)
dataset.loc[dataset.PassengerId.isin(i),"Ave_Survival"] = datase... | Titanic - Machine Learning from Disaster |
4,881,309 | pred_paragram_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_paragram_val_y>thresh ).astype(int))))<predict_on_test> | check_list = [[26, 183, 234, 262, 1046, 1066, 1271], [28, 89, 342, 439, 945, 961], [44, 609, 686, 1188], [59, 451, 473, 1142],
[94, 789, 924, 1246], [119, 300, 1076], [246, 413, 1303], [280, 747, 1284], [298, 306, 499, 1198], [671, 685, 1067],
[818, 828, 1253]]
fillfull_p2(dataset = have_family,check_list = check_list,... | Titanic - Machine Learning from Disaster |
4,881,309 | pred_paragram_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | def check_ave_survival(dataset,passid):
return dataset[dataset.PassengerId.isin(passid)][["Pclass_Gender","Survived"]]
def fullfill_ave_survival(dataset,check_list,check_more):
for i in check_list:
ave_survival = dataset[dataset.PassengerId.isin(i)].Survived.mean()
empty_gender = list(dataset[(dataset.PassengerId.isin(... | Titanic - Machine Learning from Disaster |
4,881,309 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<compute_test_metric> | check_ave_survival(have_family,[298, 306, 499, 1198] ) | Titanic - Machine Learning from Disaster |
4,881,309 | pred_val_y = 0.33*pred_glove_val_y + 0.33*pred_fasttext_val_y + 0.34*pred_paragram_val_y
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_val_y>thresh ).astype(int))))<save_to_csv> | have_family.loc[(have_family.PassengerId.isin([298, 306, 499, 1198])) ,"Ave_Survival"] = 0.33 | Titanic - Machine Learning from Disaster |
4,881,309 | pred_test_y = 0.33*pred_glove_test_y + 0.33*pred_fasttext_test_y + 0.34*pred_paragram_test_y
pred_test_y =(pred_test_y>0.35 ).astype(int)
out_df = pd.DataFrame({"qid":test_df["qid"].values})
out_df['prediction'] = pred_test_y
out_df.to_csv("submission.csv", index=False )<categorify> | situation_2 = ship_team_1+ship_team_2_tic2
full_gs_and_as(dataset = have_family,id_list=situation_2,ticket_kind = "Ticket2",check_list = [],with_friend=[],count_maiden = True ) | Titanic - Machine Learning from Disaster |
4,881,309 | pretrain_dir = None
one_fold = False
run_test = False
denoise = True
ae_epochs = 20
ae_epochs_each = 5
ae_batch_size = 32
epochs_list = [30, 10, 3, 3, 5, 5]
batch_size_list = [8, 16, 32, 64, 128, 256]
if pretrain_dir is not None:
for d in glob.glob(pretrain_dir + "*"):
shutil.copy(d, ".")
%matplotlib inline<load_from_... | check_list = [[70, 185, 1057, 1268, 1286], [408, 438, 530, 775, 832, 944], [438, 530, 775, 944], [477, 727, 923, 1211],
[672, 821, 984, 1200], [727, 923, 1211], [821, 984, 1200]]
fillfull_p2(have_family,check_list,check_more = [] ) | Titanic - Machine Learning from Disaster |
4,881,309 | train = pd.read_json("/kaggle/input/stanford-covid-vaccine/train.json",lines=True)
if denoise:
train = train[train.signal_to_noise > 1].reset_index(drop = True)
test = pd.read_json("/kaggle/input/stanford-covid-vaccine/test.json",lines=True)
test_pub = test[test["seq_length"] == 107]
test_pri = test[test["seq_length... | check_list = [[70, 185, 1057, 1268, 1286], [672, 821, 984, 1200], [821, 984, 1200]]
fullfill_ave_survival(have_family,check_list,check_more=[] ) | Titanic - Machine Learning from Disaster |
4,881,309 | targets = list(sub.columns[1:])
print(targets)
y_train = []
seq_len = train["seq_length"].iloc[0]
seq_len_target = train["seq_scored"].iloc[0]
ignore = -10000
ignore_length = seq_len - seq_len_target
for target in targets:
y = np.vstack(train[target])
dummy = np.zeros([y.shape[0], ignore_length])+ ignore
y = np.hsta... | remain_second_family = list(have_family[(have_family.PassengerId.isin(have_secondary_family1+have_secondary_family2))
&(have_family.Group_size.isna())]["PassengerId"].values)
print(len(remain_second_family)) | Titanic - Machine Learning from Disaster |
4,881,309 | def get_structure_adj(train):
Ss = []
for i in tqdm(range(len(train))):
seq_length = train["seq_length"].iloc[i]
structure = train["structure"].iloc[i]
sequence = train["sequence"].iloc[i]
cue = []
a_structures = {
("A", "U"): np.zeros([seq_length, seq_length]),
("C", "G"): np.zeros([seq_length, seq_length]),
("U", ... | second_family = have_secondary_family1+have_secondary_family2
for i in remain_second_family:
second_family.remove(i)
print(second_family ) | Titanic - Machine Learning from Disaster |
4,881,309 | def get_distance_matrix(As):
idx = np.arange(As.shape[1])
Ds = []
for i in range(len(idx)) :
d = np.abs(idx[i] - idx)
Ds.append(d)
Ds = np.array(Ds)+ 1
Ds = 1/Ds
Ds = Ds[None, :,:]
Ds = np.repeat(Ds, len(As), axis = 0)
Dss = []
for i in [1, 2, 4]:
Dss.append(Ds ** i)
Ds = np.stack(Dss, axis = 3)
print(Ds.shape)
... | have_family[have_family.PassengerId.isin([70, 185, 1057, 1268, 1286])][["Pclass_Gender","Survived","Ave_Survival"]] | Titanic - Machine Learning from Disaster |
4,881,309 | As = np.concatenate([As[:,:,:,None], Ss, Ds], axis = 3 ).astype(np.float32)
As_pub = np.concatenate([As_pub[:,:,:,None], Ss_pub, Ds_pub], axis = 3 ).astype(np.float32)
As_pri = np.concatenate([As_pri[:,:,:,None], Ss_pri, Ds_pri], axis = 3 ).astype(np.float32)
del Ss, Ds, Ss_pub, Ds_pub, Ss_pri, Ds_pri
As.shape, As_p... | next_check_2 = []
have_grouped = []
for i,j in have_family[have_family.PassengerId.isin(next_check)].groupby(["Surname"]):
if(len(j)) >=2:
family_size = j.Family_size.mean()
j_size = j.shape[0]
j_passid = list(j.PassengerId.values)
if j_size == family_size:
have_grouped = have_grouped+[j_passid]
have_family.loc[(have_... | Titanic - Machine Learning from Disaster |
4,881,309 | def return_ohe(n, i):
tmp = [0] * n
tmp[i] = 1
return tmp
def get_input(train):
mapping = {}
vocab = ["A", "G", "C", "U"]
for i, s in enumerate(vocab):
mapping[s] = return_ohe(len(vocab), i)
X_node = np.stack(train["sequence"].apply(lambda x : list(map(lambda y : mapping[y], list(x)))))
mapping = {}
vocab = ["S", "M"... | need_more_check = [41,193,69,1106,581,1133,1296,248,756,722,313,1041,443,893]
can_groupby_ticket2 = []
maybe_wrong = []
for i,j in have_family[have_family.PassengerId.isin(need_more_check)].groupby(["Embarked","Ticket2","Pclass"]):
if len(j)>=2:
can_groupby_ticket2 = can_groupby_ticket2+[i[1]]
else:
maybe_wrong = maybe... | Titanic - Machine Learning from Disaster |
4,881,309 | def mcrmse(t, p, seq_len_target = seq_len_target):
score = np.mean(np.sqrt(np.mean(( p - y_va)** 2, axis = 2)) [:, :seq_len_target])
return score
def mcrmse_loss(t, y, seq_len_target = seq_len_target):
t = t[:, :seq_len_target]
y = y[:, :seq_len_target]
loss = tf.reduce_mean(tf.sqrt(tf.reduce_mean(( t - y)** 2, axis =... | def get_from_id_tic2(dataset,passid,tic2):
return dataset[(dataset.PassengerId.isin(passid))
&(dataset.Ticket2.isin(tic2)) ][['Age', 'Embarked', 'Parch', 'SibSp','Ticket','Surname', 'Maiden','Family_size',
'Pclass_Gender','Cabin_Title',"Survived","Ave_Survival"]] | Titanic - Machine Learning from Disaster |
4,881,309 | config = {}
if ae_epochs > 0:
base = get_base(config)
ae_model = get_ae_model(base, config)
for i in range(ae_epochs//ae_epochs_each):
print(f"------ {i} ------")
print("--- train ---")
ae_model.fit([X_node, As], [X_node[:,0]],
epochs = ae_epochs_each,
batch_size = ae_batch_size)
print("--- public ---")
ae_model.... | get_from_id_tic2(have_family,need_more_check,["2377xx"] ) | Titanic - Machine Learning from Disaster |
4,881,309 | kfold = KFold(5, shuffle = True, random_state = 42)
scores = []
preds = np.zeros([len(X_node), X_node.shape[1], 5])
for i,(tr_idx, va_idx)in enumerate(kfold.split(X_node, As)) :
print(f"------ fold {i} start -----")
print(f"------ fold {i} start -----")
print(f"------ fold {i} start -----")
X_node_tr = X_node[tr_i... | have_family.loc[(have_family.PassengerId.isin([581,1133])) ,["Group_size","Ave_Survival"]] = [2,1] | Titanic - Machine Learning from Disaster |
4,881,309 | p_pub = 0
p_pri = 0
for i in range(5):
model.load_weights(f"./model{i}")
p_pub += model.predict([X_node_pub, As_pub])/ 5
p_pri += model.predict([X_node_pri, As_pri])/ 5
if one_fold:
p_pub *= 5
p_pri *= 5
break
for i, target in enumerate(targets):
test_pub[target] = [list(p_pub[k, :, i])for k in range(p_pub.shape[0])]
... | get_from_id_tic2(have_family,need_more_check,['2506xx'] ) | Titanic - Machine Learning from Disaster |
4,881,309 | preds_ls = []
for df, preds in [(test_pub, p_pub),(test_pri, p_pri)]:
for i, uid in enumerate(df.id):
single_pred = preds[i]
single_df = pd.DataFrame(single_pred, columns=targets)
single_df['id_seqpos'] = [f'{uid}_{x}' for x in range(single_df.shape[0])]
preds_ls.append(single_df)
preds_df = pd.concat(preds_ls)
pred... | have_family.loc[(have_family.PassengerId.isin([248,313,756,1041])) ,["Group_size","Ave_Survival"]] = [3,0.5] | Titanic - Machine Learning from Disaster |
4,881,309 | warnings.filterwarnings('ignore' )<import_modules> | get_from_id_tic2(have_family,need_more_check,['3470xx'] ) | Titanic - Machine Learning from Disaster |
4,881,309 | import xgboost as xgb<categorify> | get_from_id_tic2(have_family,need_more_check,['3500xx'] ) | Titanic - Machine Learning from Disaster |
4,881,309 | def seed_everything(seed=0):
random.seed(seed)
np.random.seed(seed)
def df_parallelize_run(func, t_split):
num_cores = np.min([N_CORES,len(t_split)])
pool = Pool(num_cores)
df = pd.concat(pool.map(func, t_split), axis=1)
pool.close()
pool.join()
return df
def get_data_by_store(store):
df = pd.concat([pd.read_pickl... | have_family.loc[(have_family.PassengerId.isin([193,722])) ,["Group_size","Ave_Survival"]] = [2,0.5] | Titanic - Machine Learning from Disaster |
4,881,309 | VER = 1
SEED = 42
seed_everything(SEED)
xgb_params['seed'] = SEED
N_CORES = psutil.cpu_count()
TARGET = 'sales'
START_TRAIN = 0
END_TRAIN = 1913
P_HORIZON = 28
USE_AUX = True
remove_features = ['id','state_id','store_id',
'date','wm_yr_wk','d',TARGET]
mean_features = ['enc_cat_id_mean','enc_cat_id_std',
'enc_dept_id_m... | have_family.loc[have_family.PassengerId==443,["Group_size",'Ave_Survival']] = [2,0]
have_family.loc[have_family.PassengerId==1106,["Group_size",'Ave_Survival']] = [7,0] | Titanic - Machine Learning from Disaster |
4,881,309 |
<drop_column> | get_from_id_tic2(have_family,need_more_check,maybe_wrong ) | Titanic - Machine Learning from Disaster |
4,881,309 | grid_df, features_columns = get_data_by_store('CA_1')
del grid_df
MODEL_FEATURES = features_columns<categorify> | have_family.loc[have_family.PassengerId.isin([41,893,1296]),["SibSp","Family_size"]] = [0,1]
combine.loc[combine.PassengerId.isin([41,893,1296]),["SibSp","Family_size"]] = [0,1]
have_family.loc[have_family.PassengerId.isin([69,1106]),["Group_size",'Ave_Survival']] = [7,0.125] | Titanic - Machine Learning from Disaster |
4,881,309 | def get_base_test() :
base_test = pd.DataFrame()
for store_id in STORES_IDS:
temp_df = pd.read_pickle(AUX_MODELS + 'test_'+store_id+'.pkl')
temp_df['store_id'] = store_id
base_test = pd.concat([base_test, temp_df] ).reset_index(drop=True)
return base_test<create_dataframe> | have_family = have_family[have_family.Family_size!=1]
passid_list = list(have_family.PassengerId.values)
group_size_list = list(have_family.Group_size.values)
ave_survival = list(have_family.Ave_Survival.values)
combine.loc[combine.PassengerId.isin(passid_list),"Group_size"] = group_size_list
combine.loc[combine.Pas... | Titanic - Machine Learning from Disaster |
4,881,309 | all_preds = pd.DataFrame()
base_test = get_base_test()
main_time = time.time()
for PREDICT_DAY in range(1,29):
print('Predict | Day:', PREDICT_DAY)
start_time = time.time()
grid_df = base_test.copy()
grid_df = pd.concat([grid_df, df_parallelize_run(make_lag_roll, ROLS_SPLIT)], axis=1)
for store_id in STORES_IDS:
mode... | all_passenger = []
for i,j in combine[(combine.Surname_Counts>=2)].groupby(["Ticket2","Surname"]):
if len(j)>=2:
j_passid = list(j.PassengerId.values)
all_passenger = all_passenger+j_passid
same_surname = list(combine[(combine.PassengerId.isin(all_passenger)) &(combine.Group_size.isna())]["PassengerId"].values)
print... | Titanic - Machine Learning from Disaster |
4,881,309 | submission = pd.read_csv(ORIGINAL+'sample_submission.csv')[['id']]
submission = submission.merge(all_preds, on=['id'], how='left' ).fillna(0)
submission.to_csv('submission_v'+str(VER)+'.csv', index=False )<set_options> | all_passenger = []
for i,j in combine[(combine.Maiden_Counts>=2)].groupby(["Ticket2","Maiden"]):
if len(j)>=2:
j_passid = list(j.PassengerId.values)
all_passenger = all_passenger+j_passid
same_maiden = list(combine[(combine.PassengerId.isin(all_passenger)) &(combine.Group_size.isna())]["PassengerId"].values)
print(sa... | Titanic - Machine Learning from Disaster |
4,881,309 | %pylab inline
<import_modules> | combine[combine.Ticket=="31352"][['Age', 'Embarked', 'Parch', 'SibSp','Ticket','Surname', 'Maiden','Family_size','Pclass_Gender',
'Cabin_Title',"Surname_Counts","Group_size","Survived"]] | Titanic - Machine Learning from Disaster |
4,881,309 | from sklearn.preprocessing import StandardScaler
from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import LabelEncoder<import_modules> | team = combine[(combine.Ticket=="31352")|(( combine.Surname=="Ware")&(combine.Family_size!=1)) ]
combine.loc[(combine.PassengerId.isin([1170,1254])) ,"Group_size"] = 2
combine.loc[(combine.PassengerId.isin([1170,1254])) ,"Ave_Survival"] = team.Survived.mean() | Titanic - Machine Learning from Disaster |
4,881,309 | from keras.models import Sequential
from keras.layers import Dense,Dropout,Activation
from keras.utils.np_utils import to_categorical
from keras.callbacks import EarlyStopping<load_from_csv> | same_surname.remove(1254)
full_gs_and_as(dataset = combine,id_list=same_surname,ticket_kind = "Ticket2",check_list = [],with_friend=[],count_maiden = False ) | Titanic - Machine Learning from Disaster |
4,881,309 | data = pd.read_csv('.. /input/train.csv')
parent_data = data.copy()
ID = data.pop('id' )<categorify> | combine[(combine.PassengerId.isin([115, 245, 303, 598, 693, 827])) ][["Pclass_Gender","Survived","Ticket"]] | Titanic - Machine Learning from Disaster |
4,881,309 | y = data.pop('species')
y = LabelEncoder().fit(y ).transform(y)
print(y.shape )<normalization> | combine.loc[(combine.Ticket.isin(["2627","2694"])) ,"Group_size"] = combine[(combine.Ticket.isin(["2627","2694"])) ].shape[0]
combine.loc[(combine.Ticket.isin(["2627","2694"])) ,"Ave_Survival"] = combine[(combine.Ticket.isin(["2627","2694"])) ]["Survived"].mean()
combine.loc[(combine.Ticket.isin(["LINE"])) ,"Group_size... | Titanic - Machine Learning from Disaster |
4,881,309 | X = StandardScaler().fit(data ).transform(data)
print(X.shape )<categorify> | surname_list = list(combine.Surname.values)
common_name = []
for maiden in combine.Maiden.values:
if maiden in surname_list:
common_name = common_name+[maiden]
print(len(common_name))
print(common_name[:5] ) | Titanic - Machine Learning from Disaster |
4,881,309 | y_cat = to_categorical(y)
print(y_cat.shape )<choose_model_class> | possible_cousin = combine[(( combine.Surname.isin(common_name)) |(combine.Maiden.isin(common_name)))
&(combine.Family_size==1)&(combine.Group_size.isna())]
possible_cousin_id = []
for i,j in possible_cousin.groupby(["Ticket2"]):
if len(j)>=2:
j_passid = list(j.PassengerId.values)
possible_cousin_id = possible_cousin_... | Titanic - Machine Learning from Disaster |
4,881,309 | 2
model = Sequential()
model.add(Dense(600,input_dim=192, init='uniform', activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(300, activation='sigmoid'))
model.add(Dropout(0.3))
model.add(Dense(99, activation='softmax'))<choose_model_class> | combine[(combine.PassengerId.isin([41, 104, 714, 877])) ][["Surname","Maiden"]] | Titanic - Machine Learning from Disaster |
4,881,309 | model.compile(loss='categorical_crossentropy',optimizer='rmsprop', metrics = ["accuracy"] )<train_model> | combine[(combine.PassengerId.isin([41, 714])) ][['Age',"Cabin_Title", 'Embarked','Pclass_Gender',"Surname",'Maiden','Ticket',"Survived"]] | Titanic - Machine Learning from Disaster |
4,881,309 | early_stopping = EarlyStopping(monitor='val_loss', patience=280)
history = model.fit(X,y_cat,batch_size=192,
nb_epoch=800 ,verbose=0, validation_split=0.1, callbacks=[early_stopping] )<train_model> | combine.loc[combine.PassengerId.isin([41, 714]),["Group_size",'Ave_Survival']] = [2,0] | Titanic - Machine Learning from Disaster |
4,881,309 | print('val_acc: ',max(history.history['val_acc']))
print('val_loss: ',min(history.history['val_loss']))
print('train_acc: ',max(history.history['acc']))
print('train_loss: ',min(history.history['loss']))
print()
print("train/val loss ratio: ", min(history.history['loss'])/min(history.history['val_loss']))<load_from_csv... | check_list = [[146, 550, 1068, 1222], [270, 326, 374, 1206], [280, 747, 1065, 1284], [291, 742, 988], [298, 306, 499, 709, 1033, 1198],
[308, 506, 1306], [381, 558, 701, 717, 1094], [538, 545, 1131]]
fillfull_p2(combine,check_list,check_more = [] ) | Titanic - Machine Learning from Disaster |
4,881,309 | test = pd.read_csv('.. /input/test.csv')
index = test.pop('id')
test = StandardScaler().fit(test ).transform(test)
yPred = model.predict_proba(test )<create_dataframe> | survival = combine[(combine.Pclass_Gender=="P3-Man")&(combine.Ave_Survival==0.5)]["Survived"].mean()
shape = combine[(combine.Pclass_Gender=="P3-Man")&(combine.Ave_Survival==0.5)&(combine.Survived.notna())].shape[0]
print(survival)
print(shape ) | Titanic - Machine Learning from Disaster |
4,881,309 | yPred = pd.DataFrame(yPred,index=index,columns=sort(parent_data.species.unique()))<save_to_csv> | survival = combine[(combine.Pclass_Gender=="P1-Man")&(combine.Ave_Survival==0.5)]["Survived"].mean()
shape = combine[(combine.Pclass_Gender=="P1-Man")&(combine.Ave_Survival==0.5)&(combine.Survived.notna())].shape[0]
print(survival)
print(shape ) | Titanic - Machine Learning from Disaster |
4,881,309 | fp = open('submission_nn_kernel.csv','w')
fp.write(yPred.to_csv() )<set_options> | survival =combine[(combine.Pclass_Gender=="P3-Boy")&(combine.Ave_Survival==0.5)]["Survived"].mean()
shape = combine[(combine.Pclass_Gender=="P3-Boy")&(combine.Ave_Survival==0.5)&(combine.Survived.notna())].shape[0]
print(survival)
print(shape ) | Titanic - Machine Learning from Disaster |
4,881,309 | %reload_ext autoreload
%autoreload 2
%matplotlib inline
%matplotlib inline
<load_pretrained> | combine[(combine.Pclass_Gender=="P3-Boy")&(combine.Ave_Survival==0.5)
&(combine.Survived.isna())][["PassengerId","Ticket","Ticket_Counts"]] | Titanic - Machine Learning from Disaster |
4,881,309 | md_ef = EfficientNet.from_pretrained('efficientnet-b5', num_classes=1 )<load_from_csv> | combine[combine.Ticket=="2673"][["PassengerId","Age","Pclass_Gender","Survived","Ave_Survival"]] | Titanic - Machine Learning from Disaster |
4,881,309 | def get_df() :
base_image_dir = os.path.join('.. ', 'input/aptos2019-blindness-detection/')
train_dir = os.path.join(base_image_dir,'train_images/')
df = pd.read_csv(os.path.join(base_image_dir, 'train.csv'))
df['path'] = df['id_code'].map(lambda x: os.path.join(train_dir,'{}.png'.format(x)))
df = df.drop(columns=['... | combine.loc[(combine.Pclass_Gender.isin(["P3-Woman"])) &(combine.Ave_Survival>=0.5),"If_Survived"] = 1
combine.loc[(combine.Pclass_Gender.isin(["P3-Woman"])) &(combine.Ave_Survival<0.5),"If_Survived"] = 0
combine.loc[(combine.Pclass_Gender.isin(["P1-Man","P3-Man"])&(combine.Ave_Survival>0.5)) ,"If_Survived"] = 1
combin... | Titanic - Machine Learning from Disaster |
4,881,309 | bs = 64
sz = 224
tfms = get_transforms(do_flip=True,flip_vert=True )<compute_test_metric> | combine[(combine.Pclass_Gender.isin(["P1-Man","P3-Man"]))
&(combine.Survived.isna())&(combine.If_Survived==1)][["Pclass_Gender","Group_size","Ave_Survival","Ticket"]] | Titanic - Machine Learning from Disaster |
4,881,309 | def qk(y_pred, y):
return torch.tensor(cohen_kappa_score(torch.round(y_pred), y, weights='quadratic'), device='cuda:0' )<load_pretrained> | combine.loc[(combine.If_Survived==0),"Predict"] = 0
combine.loc[(combine.If_Survived==1),"Predict"] = 1
combine.loc[(combine.PassengerId.isin([1036,1047,1210])) ,"Predict"] = 0 | Titanic - Machine Learning from Disaster |
4,881,309 | learn = Learner(data,
md_ef,
metrics = [qk],
model_dir="models" ).to_fp16()
learn.data.add_test(ImageList.from_df(test_df,
'.. /input/aptos2019-blindness-detection',
folder='test_images',
suffix='.png'))
<load_pretrained> | combine = combine[["PassengerId","Age","Embarked","Survived","Pclass_Gender","Fare_PP","Cabin_Title","Predict"]] | Titanic - Machine Learning from Disaster |
4,881,309 | learn.load('abcdef');<compute_train_metric> | remain_train = combine[(combine.Predict.isna())&(combine.Survived.notna())]
remain_test = combine[(combine.Predict.isna())&(combine.Survived.isna())] | Titanic - Machine Learning from Disaster |
4,881,309 | class OptimizedRounder(object):
def __init__(self):
self.coef_ = 0
def _kappa_loss(self, coef, X, y):
X_p = np.copy(X)
for i, pred in enumerate(X_p):
if pred < coef[0]:
X_p[i] = 0
elif pred >= coef[0] and pred < coef[1]:
X_p[i] = 1
elif pred >= coef[1] and pred < coef[2]:
X_p[i] = 2
elif pred >= coef[2] and pred < coe... | print("Pclass_Gender distribution in train data:",remain_train.Pclass_Gender.value_counts())
print("-"*50)
print("Pclass_Gender distribution in test data:",remain_test.Pclass_Gender.value_counts() ) | Titanic - Machine Learning from Disaster |
4,881,309 | def run_subm(learn=learn, coefficients=[0.5, 1.5, 2.5, 3.5]):
opt = OptimizedRounder()
preds,y = learn.get_preds(DatasetType.Test)
tst_pred = opt.predict(preds, coefficients)
test_df.diagnosis = tst_pred.astype(int)
test_df.to_csv('submission.csv',index=False)
print('done' )<install_modules> | survival_in_remain = remain_train[(remain_train.Pclass_Gender=="P1-Man")]["Survived"].mean()
survival_in_all = combine[(combine.Pclass_Gender=="P1-Man")]["Survived"].mean()
print(round(survival_in_all,2),round(survival_in_remain,2)) | Titanic - Machine Learning from Disaster |
4,881,309 | !pip install -U '.. /input/install/efficientnet-0.0.3-py2.py3-none-any.whl'<load_from_csv> | survival_in_remain = remain_train[(remain_train.Pclass_Gender=="P3-Man")]["Survived"].mean()
survival_in_all = combine[(combine.Pclass_Gender=="P3-Man")]["Survived"].mean()
print(round(survival_in_all,2),round(survival_in_remain,2)) | Titanic - Machine Learning from Disaster |
4,881,309 | df_train = pd.read_csv('.. /input/aptos2019-blindness-detection/train.csv')
df_test = pd.read_csv('.. /input/aptos2019-blindness-detection/test.csv' )<split> | combine.loc[(combine.Predict.isna())&(combine.Survived.isna())&(combine.Pclass_Gender=="P3-Woman"),"Predict"] = 1
combine.loc[(combine.Predict.isna())&(combine.Survived.isna()),"Predict"]=0 | Titanic - Machine Learning from Disaster |
4,881,309 | y = to_categorical(y, num_classes=NUM_CLASSES)
train_x, valid_x, train_y, valid_y = train_test_split(x, y, test_size=0.15,
stratify=y, random_state=8)
print(train_x.shape)
print(train_y.shape)
print(valid_x.shape)
print(valid_y.shape )<define_variables> | final_submit = pd.DataFrame({"PassengerId":combine[combine.Survived.isna() ].PassengerId.values,
"Survived":combine[combine.Survived.isna() ].Predict.values})
final_submit["Survived"] = final_submit.Survived.astype("int64")
final_submit.tail(2 ) | Titanic - Machine Learning from Disaster |
4,881,309 | <load_pretrained><EOS> | final_submit.to_csv("Titanic.csv",index = False ) | Titanic - Machine Learning from Disaster |
4,191,551 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<choose_model_class> | sns.set(style="whitegrid")
%matplotlib inline
warnings.simplefilter(action='ignore')
training_data = pd.read_csv('.. /input/train.csv')
testing_data = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
4,191,551 | attn_layer = Conv2D(64, kernel_size =(1,1), padding = 'same', activation = 'relu' )(Dropout(0.5 )(bn_features))
attn_layer = Conv2D(16, kernel_size =(1,1), padding = 'same', activation = 'relu' )(attn_layer)
attn_layer = Conv2D(8, kernel_size =(1,1), padding = 'same', activation = 'relu' )(attn_layer)
attn_layer = Co... | sex_dict = {'male':0, 'female':1} | Titanic - Machine Learning from Disaster |
4,191,551 | EarlyStopping, ReduceLROnPlateau,CSVLogger)
epochs = 30; batch_size = 16
checkpoint = ModelCheckpoint('.. /working/model_.h5', monitor='val_loss', verbose=1,
save_best_only=True, mode='min', save_weights_only = True)
reduceLROnPlat = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=4,
verbose=1, mode='auto'... | training_data['Sex'] = training_data['Sex'].map(sex_dict)
training_data.head() | Titanic - Machine Learning from Disaster |
4,191,551 | def kappa_loss(y_true, y_pred, y_pow=2, eps=1e-12, N=5, bsize=32, name='kappa'):
with tf.name_scope(name):
y_true = tf.to_float(y_true)
repeat_op = tf.to_float(tf.tile(tf.reshape(tf.range(0, N), [N, 1]), [1, N]))
repeat_op_sq = tf.square(( repeat_op - tf.transpose(repeat_op)))
weights = repeat_op_sq / tf.to_float(( N... | testing_data['Sex'] = testing_data['Sex'].map(sex_dict)
testing_data.head() | Titanic - Machine Learning from Disaster |
4,191,551 | class QWKEvaluation(Callback):
def __init__(self, validation_data=() , batch_size=64, interval=1):
super(Callback, self ).__init__()
self.interval = interval
self.batch_size = batch_size
self.valid_generator, self.y_val = validation_data
self.history = []
def on_epoch_end(self, epoch, logs={}):
if epoch % self.interval... | imp = Imputer(missing_values = 'NaN', strategy = 'mean', axis = 0)
training_data[["Age"]] = imp.fit_transform(training_data[["Age"]] ).ravel()
testing_data[["Age"]] = imp.fit_transform(testing_data[["Age"]] ).ravel()
testing_data[["Fare"]] = imp.fit_transform(testing_data[["Fare"]] ).ravel()
training_data[["Embarked"]... | Titanic - Machine Learning from Disaster |
4,191,551 | for layer in retina_model.layers:
layer.trainable = False
for i in range(-3,0):
retina_model.layers[i].trainable = True
retina_model.compile(
loss='categorical_crossentropy',
optimizer=Adam(1e-3))
retina_model.fit_generator(
train_generator,
steps_per_epoch=np.ceil(float(len(train_y)) / float(128)) ,
epochs=2,
worker... | training_data.isnull().sum(axis=0 ) | Titanic - Machine Learning from Disaster |
4,191,551 | for layer in retina_model.layers:
layer.trainable = True
callbacks_list = [checkpoint, csv_logger, reduceLROnPlat, early, qwk]
retina_model.compile(
loss=kappa_loss,
optimizer=Adam(lr=1e-4))
retina_model.fit_generator(
train_mixup,
steps_per_epoch=np.ceil(float(len(train_x)) / float(batch_size)) ,
validation_data=val... | testing_data.isnull().sum(axis=0 ) | Titanic - Machine Learning from Disaster |
4,191,551 | layer_names = []
for layer in outputs:
layer_names.append(layer.name.split("/")[0])
print("Layers going to be used for visualization: ")
print(layer_names )<define_variables> | le = LabelEncoder()
training_data[["Ticket"]] = le.fit_transform(training_data[["Ticket"]] ).ravel()
training_data[["Embarked"]] = le.fit_transform(training_data[["Embarked"]] ).ravel()
testing_data[["Ticket"]] = le.fit_transform(testing_data[["Ticket"]])
testing_data[["Embarked"]] = le.fit_transform(testing_data[["Em... | Titanic - Machine Learning from Disaster |
4,191,551 | def show_random_sample(idx):
img_id = df_train.iloc[idx]['id_code']
img_path = '.. /input/aptos2019-blindness-detection/train_images/'+str(img_id)+'.png'
sample_image = cv2.imread(img_path)
sample_image = cv2.cvtColor(sample_image, cv2.COLOR_BGR2RGB)
sample_image = cv2.resize(sample_image,(256, 256))
sample_label =... | train_data = training_data.drop(['PassengerId','Name','Cabin','Survived'],axis = 1)
survived = training_data['Survived']
test_data = testing_data.drop(['PassengerId','Name','Cabin'], axis = 1 ) | Titanic - Machine Learning from Disaster |
4,191,551 | submit = pd.read_csv('.. /input/aptos2019-blindness-detection/sample_submission.csv')
retina_model.load_weights('.. /working/model_bestqwk.h5')
predicted = []<predict_on_test> | X_train, X_test, y_train, y_test = train_test_split(train_data, survived, test_size=0.2, random_state=42 ) | Titanic - Machine Learning from Disaster |
4,191,551 | for i, name in tqdm(enumerate(submit['id_code'])) :
path = os.path.join('.. /input/aptos2019-blindness-detection/test_images/', name+'.png')
image = cv2.imread(path)
image = cv2.resize(image,(SIZE, SIZE))
score_predict = retina_model.predict(( image[np.newaxis])/255)
label_predict = np.argmax(score_predict)
predict... | lgbm = lgb.LGBMClassifier(max_depth = 8,
num_leaves=90,
lambda_l1 = 0.1,
lambda_l2 = 0.01,
learning_rate = 0.01,
max_bin= 350,
n_estimators = 600,
reg_alpha = 1.6,
colsample_bytree = 0.9,
subsample = 0.9,
n_jobs = 6)
lgbm.fit(X_train,y_train)
pred = lgbm.predict(test_data ) | Titanic - Machine Learning from Disaster |
4,191,551 | <define_variables><EOS> | submission = pd.DataFrame({"PassengerId": testing_data["PassengerId"],"Survived": pred})
submission.to_csv('submission.csv',index= False ) | Titanic - Machine Learning from Disaster |
1,897,265 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | %matplotlib inline
py.init_notebook_mode(connected=True)
warnings.filterwarnings('ignore')
print("Python version: {}".format(sys.version))
print("pandas version: {}".format(pd.__version__))
print("matplotlib version: {}".format(matplotlib.__version__))
print("NumPy version: {}".format(np.__version__))
print("SciPy ve... | Titanic - Machine Learning from Disaster |
1,897,265 | train = pd.read_csv(DATA_PATH + "train.csv")
test = pd.read_csv(DATA_PATH + "test.csv")
train["id_code"] = train["id_code"].apply(lambda x: x + ".png")
test["id_code"] = test["id_code"].apply(lambda x: x + ".png")
train['diagnosis'] = train['diagnosis'].astype('str')
train.head(10 )<define_variables> | train = pd.read_csv('.. /input/train.csv', header = 0, dtype={'Age': np.float64})
test = pd.read_csv('.. /input/test.csv' , header = 0, dtype={'Age': np.float64})
full_data = [train, test]
print(train.info() ) | Titanic - Machine Learning from Disaster |
1,897,265 | batch_size_train = 32
batch_size_test = 1
train_datagen = ImageDataGenerator(rescale=1./255, validation_split=0.1,
horizontal_flip=True,
vertical_flip=True,
rotation_range=20,
zoom_range= 0.2,
featurewise_center=True,
featurewise_std_normalization=True,
zca_whitening=True,
width_shift_range=0.2,
height_shift_range=0.2,... | train['Name_length'] = train['Name'].apply(len)
test['Name_length'] = test['Name'].apply(len)
train['Has_Cabin'] = train["Cabin"].apply(lambda x: 0 if type(x)== float else 1)
test['Has_Cabin'] = test["Cabin"].apply(lambda x: 0 if type(x)== float else 1)
for dataset in full_data:
dataset['FamilySize'] = dataset['Sib... | Titanic - Machine Learning from Disaster |
1,897,265 | def custom_loss(y_true, y_pred):
custom_cce = math.add(math.multiply(y_true, -1*math.log(0.001+ y_pred*0.999)) ,
math.multiply(1-y_true, -1*math.log(1-y_pred*0.999)))
custom_cce = math.reduce_sum(custom_cce, 1)
weights = cast(1 + math.square(math.abs(math.argmax(y_pred, axis=1)-math.argmax(y_true, axis=1)))/100, fl... | PassengerId = test['PassengerId']
feature_columns = ['Sex','Pclass', 'Embarked', 'Title','SibSp', 'Parch', 'Age', 'Fare', 'FamilySize', 'IsAlone', 'Age*Class']
train = train[feature_columns + ['Survived']]
test = test[feature_columns]
train.head() | Titanic - Machine Learning from Disaster |
1,897,265 | print('Creating model...', end=' ')
input_tensor = Input(shape=(IMAGE_SIZE,IMAGE_SIZE,3))
conv_base = ResNet50(include_top=False, weights=None, input_tensor=input_tensor)
conv_base.load_weights('.. /input/resnet50/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5')
a_map = layers.Conv2D(516, 1, strides=(1, 1), pa... | classifiers = []
ntrain = train.shape[0]
ntest = test.shape[0]
kfold = StratifiedKFold(n_splits=10)
y_train = train['Survived'].ravel()
x_train = train.drop(['Survived'], axis=1 ).values
x_train_columns = train.drop(['Survived'], axis=1 ).columns
x_test = test.values
def classifier_name(clf):
if 'ABCMeta' == clf.__cla... | Titanic - Machine Learning from Disaster |
1,897,265 | train_steps = train_gen.n//train_gen.batch_size
val_steps = valid_gen.n//valid_gen.batch_size
for layer in model.layers:
layer.trainable = False
for i in range(-9, 0):
model.layers[i].trainable = True
optimizer = Adam(lr=1e-4)
model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy'])
h... | rf_params = {
'n_jobs': -1,
'n_estimators': 500,
'warm_start': False,
'min_samples_leaf': 2,
'max_features' : 'sqrt',
'verbose': 0,
'random_state': RANDOM_SEED
}
rf = RandomForestClassifier(**rf_params)
classifiers.append(rf ) | Titanic - Machine Learning from Disaster |
1,897,265 | for layer in model.layers:
layer.trainable = True
earlystopper = EarlyStopping(monitor='val_loss', patience=7, verbose=1, restore_best_weights=True)
reducel = ReduceLROnPlateau(monitor='val_loss', patience=2, verbose=1, factor=0.3, min_lr=1e-6)
optimizer = Adam(1e-4)
model.compile(loss='categorical_crossentropy',
op... | svm_params = {'probability': True,
'random_state': RANDOM_SEED}
svm = SVC(**svm_params)
classifiers.append(svm ) | Titanic - Machine Learning from Disaster |
1,897,265 | def show_image_mask(path):
im = imread(path)
exctraction_model = Model(input_tensor, res)
im = np.array([im])
w = exctraction_model.predict(im)
im_res = np.squeeze(im)[:,:,0]
im_w = np.power(resize(np.mean(w[0], axis=2),(224, 224)) ,4)
imshow(np.multiply(im_w, im_res), cmap = 'gray' )<define_variables> | lr_params = {
'solver': 'liblinear',
'random_state': RANDOM_SEED
}
lr = LogisticRegression(**lr_params)
classifiers.append(lr ) | Titanic - Machine Learning from Disaster |
1,897,265 | final_valid_datagen = ImageDataGenerator(rescale=1./255)
final_valid_gen = train_datagen.flow_from_directory(directory= train_dest,
batch_size= 1,
class_mode= 'categorical',
target_size=(IMAGE_SIZE, IMAGE_SIZE),
shuffle=False)
STEP_SIZE_TEST = final_valid_gen.n//final_valid_gen.batch_size
print('Start predictions...'... | kn_params = {'n_neighbors': 3}
kn = KNeighborsClassifier(**kn_params)
classifiers.append(kn ) | Titanic - Machine Learning from Disaster |
1,897,265 | test_gen.reset()
STEP_SIZE_TEST = test_gen.n//test_gen.batch_size
print("Predictions begins...")
preds = model.predict_generator(test_gen, steps=STEP_SIZE_TEST)
print("Predictions done !")
predictions = [np.argmax(pred)for pred in preds]
filenames = test_gen.filenames
results = pd.DataFrame({'id_code':filenames, 'di... | gb_params = {'random_state':RANDOM_SEED}
gb = GradientBoostingClassifier(**gb_params)
classifiers.append(gb ) | Titanic - Machine Learning from Disaster |
1,897,265 | df = pd.read_csv("submission.csv")
print(df["diagnosis"].value_counts())
print(preds )<load_pretrained> | dt_params = {'random_state':RANDOM_SEED}
dt = DecisionTreeClassifier(**dt_params)
classifiers.append(dt ) | Titanic - Machine Learning from Disaster |
1,897,265 | if os.path.exists('valid/'):
shutil.rmtree('valid/')
if os.path.exists(train_dest):
shutil.rmtree(train_dest)
if os.path.exists(test_dest):
shutil.rmtree(test_dest )<load_from_csv> | ab_params = {'random_state':RANDOM_SEED}
ab = AdaBoostClassifier(**ab_params)
classifiers.append(ab ) | Titanic - Machine Learning from Disaster |
1,897,265 | test_df = pd.read_csv('.. /input/aptos2019-blindness-detection/test.csv')
print(test_df.shape )<choose_model_class> | gnb_params = {}
gnb = GaussianNB(**gnb_params)
classifiers.append(gnb ) | Titanic - Machine Learning from Disaster |
1,897,265 | densenet = DenseNet121(
weights='.. /input/densenet-keras/DenseNet-BC-121-32-no-top.h5',
include_top=False,
input_shape=(im_size,im_size,3)
)
def build_model() :
model = Sequential()
model.add(densenet)
model.add(layers.GlobalAveragePooling2D())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(5, activation='s... | ld_params = {}
ld = LinearDiscriminantAnalysis(**ld_params)
classifiers.append(ld ) | Titanic - Machine Learning from Disaster |
1,897,265 | y_test = model.predict(x_test)> 0.5
y_test = y_test.astype(int ).sum(axis=1)- 1
test_df['diagnosis'] = y_test
test_df.to_csv('submission.csv',index=False)
print(test_df.head() )<import_modules> | qd_params = {}
qd = QuadraticDiscriminantAnalysis(**qd_params)
classifiers.append(qd ) | Titanic - Machine Learning from Disaster |
1,897,265 | from fastai import *
from fastai.vision import *
import pandas as pd
import matplotlib.pyplot as plt
import pandas as pd
import os
import numpy as np
import pandas as pd
import glob
import matplotlib.pyplot as plt
import imagehash
import psutil
from PIL import Image
from joblib import Parallel, delayed
import matplotli... | xgb_params = {'random_state':RANDOM_SEED}
xgb = XGBClassifier(**xgb_params)
classifiers.append(xgb ) | Titanic - Machine Learning from Disaster |
1,897,265 | base_image_dir = os.path.join('.. ', 'input/aptos2019-blindness-detection/')
train_dir = os.path.join(base_image_dir,'train_images/')
df = pd.read_csv(os.path.join(base_image_dir, 'train.csv'))
df['path'] = df['id_code'].map(lambda x: os.path.join(train_dir,'{}.png'.format(x)))
df = df.drop(columns=['id_code'])
df ... | _, NUMBER_OF_FEATURES = x_train.shape
def create_network() :
network = Sequential()
network.add(Dense(units = 9, kernel_initializer = 'uniform', activation = 'relu', input_shape=(NUMBER_OF_FEATURES,)))
network.add(Dense(units = 9, kernel_initializer = 'uniform', activation = 'relu'))
network.add(Dense(units = 5, kerne... | Titanic - Machine Learning from Disaster |
1,897,265 | bs = 32
sz=245<compute_test_metric> | def evaluate_with_cross_validation(classifiers, test_size, split_num, X, y):
ret_results = {}
cv_results = []
for classifier in tqdm(classifiers):
clf_name = classifier_name(classifier)
print('cross validate with {0}'.format(clf_name))
n_jobs = None if clf_name in ['KerasClassifier'] else -1
cv_results.append(cross_va... | Titanic - Machine Learning from Disaster |
1,897,265 | def quadratic_kappa(y_hat, y):
return torch.tensor(cohen_kappa_score(torch.argmax(y_hat,1), y, weights='quadratic'),device='cuda:0' )<choose_model_class> | DTC = DecisionTreeClassifier()
adaDTC = AdaBoostClassifier(DTC, random_state=7)
ada_param_grid = {"base_estimator__criterion" : ["gini", "entropy"],
"base_estimator__splitter" : ["best", "random"],
"algorithm" : ["SAMME","SAMME.R"],
"n_estimators" :[1,2],
"learning_rate": [0.0001, 0.001, 0.01, 0.1, 0.2, 0.3,1.5]}
gsad... | Titanic - Machine Learning from Disaster |
1,897,265 | learn= cnn_learner(data, base_arch=models.vgg19_bn, metrics = [accuracy,quadratic_kappa] )<train_model> | ExtC = ExtraTreesClassifier()
ex_param_grid = {"max_depth": [None],
"max_features": [1, 3, 10],
"min_samples_split": [2, 3, 10],
"min_samples_leaf": [1, 3, 10],
"bootstrap": [False],
"n_estimators" :[100,300],
"criterion": ["gini"]}
gsExtC = GridSearchCV(ExtC,param_grid = ex_param_grid, cv=kfold, scoring="accuracy", n_... | Titanic - Machine Learning from Disaster |
1,897,265 | learn.fit_one_cycle(4, max_lr=1e-2)
learn.recorder.plot_losses()<load_from_csv> | RFC = RandomForestClassifier()
rf_param_grid = {"max_depth": [None],
"max_features": [1, 3, 10],
"min_samples_split": [2, 3, 10],
"min_samples_leaf": [1, 3, 10],
"bootstrap": [False],
"n_estimators" :[100,300],
"criterion": ["gini"]}
gsRFC = GridSearchCV(RFC,param_grid = rf_param_grid, cv=kfold, scoring="accuracy", n_j... | Titanic - Machine Learning from Disaster |
1,897,265 | sample_df = pd.read_csv('.. /input/aptos2019-blindness-detection/sample_submission.csv')
learn.data.add_test(ImageList.from_df(sample_df,'.. /input/aptos2019-blindness-detection/',folder='test_images',suffix='.png'))
preds,y = learn.get_preds(DatasetType.Test )<save_to_csv> | GBC = GradientBoostingClassifier()
gb_param_grid = {'loss' : ["deviance"],
'n_estimators' : [100,200,300],
'learning_rate': [0.1, 0.05, 0.01],
'max_depth': [4, 8],
'min_samples_leaf': [100,150],
'max_features': [0.3, 0.1]
}
gsGBC = GridSearchCV(GBC,param_grid = gb_param_grid, cv=kfold, scoring="accuracy", n_jobs=-1, ve... | Titanic - Machine Learning from Disaster |
1,897,265 | sample_df.diagnosis = preds.argmax(1)
sample_df.head()
sample_df.to_csv('submission.csv',index=False )<set_options> | SVMC = SVC(probability=True)
svc_param_grid = {'kernel': ['rbf'],
'gamma': [ 0.001, 0.01, 0.1, 1],
'C': [1, 10, 50, 100,200,300, 1000]}
gsSVMC = GridSearchCV(SVMC,param_grid = svc_param_grid, cv=kfold, scoring="accuracy", n_jobs=-1, verbose = 1)
gsSVMC.fit(x_train,y_train)
SVMC_best = gsSVMC.best_estimator_
gsSVMC_a... | Titanic - Machine Learning from Disaster |
1,897,265 | %reload_ext autoreload
%autoreload 2
%matplotlib inline<import_modules> | enable_classifiers_num = 5
enable_classifiers = sorted(classifier_results.items() , key=lambda kv: kv[1][0], reverse=True)[:enable_classifiers_num]
print('Top {0:,} classifiers'.format(enable_classifiers_num ).upper())
for clf_name, tup in enable_classifiers:
print('\t{0:30s}: {1:.5f}'.format(clf_name, tup[0])) | Titanic - Machine Learning from Disaster |
1,897,265 | from fastai import *
from fastai.vision import *
import pandas as pd
import matplotlib.pyplot as plt<set_options> | estimators = [(n, tup[1])for n, tup in enable_classifiers]
vc_params = {
'estimators': estimators,
'voting': 'soft',
'n_jobs': -1,
'flatten_transform': True
}
voting_classifier = VotingClassifier(**vc_params)
voting_classifier = voting_classifier.fit(x_train, y_train)
cv_result = cross_val_score(voting_classifier, x_... | Titanic - Machine Learning from Disaster |
1,897,265 | <feature_engineering><EOS> | best_classifier = voting_classifier
best_classifier.fit(x_train, y_train)
predictions = best_classifier.predict(x_test)
submission_file = pd.DataFrame({ 'PassengerId': PassengerId,
'Survived': predictions })
ts = datetime.now().strftime("%Y%m%d%H%M")
filename = 'submission_file_{0}.csv'.format(ts)
submission_file.... | Titanic - Machine Learning from Disaster |
1,067,710 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | %matplotlib inline
sns.set_style('whitegrid')
sns.set_context('talk')
params = {'legend.fontsize': 'x-large',
'figure.figsize':(30, 10),
'axes.labelsize': 'x-large',
'axes.titlesize':'x-large',
'xtick.labelsize':'x-large',
'ytick.labelsize':'x-large'}
plt.rcParams.update(params)
| Titanic - Machine Learning from Disaster |
1,067,710 | folds = pd.read_csv('.. /input/atposfolds/folds.csv' )<define_variables> | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv')
print(train_df.shape)
print(test_df.shape ) | Titanic - Machine Learning from Disaster |
1,067,710 | fold_num = 1
val_idxs = folds[folds['folds'] == fold_num].index.values<define_variables> | test_df['Survived'] = 0
full = pd.concat([train_df, test_df],
axis=0,
ignore_index=True,
sort=False ) | 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.