kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,686,466 | print(bestP)
print('N estimators:', int(bestP['n_estimators']))
print('Learning rate:', bestP['learning_rate'])
print('Subsample:', bestP['subsample'])
print('Colsample bytree:', bestP['colsample_bytree'])
print('Max depth:', int(bestP['max_depth']))
print('Num leaves:', int(bestP['num_leaves']))
print('Min child w... | train = train.drop(columns=['Name','Cabin','Ticket'])
test = test.drop(columns=['Name','Cabin','Ticket'] ) | Titanic - Machine Learning from Disaster |
9,686,466 | %%time
model = lightgbm.LGBMRegressor(
n_estimators = int(bestP['n_estimators']),
learning_rate = bestP['learning_rate'],
subsample = bestP['subsample'],
colsample_bytree = bestP['colsample_bytree'],
max_depth = int(bestP['max_depth']),
num_leaves = int(bestP['num_leaves']),
min_child_weight = int(bestP['min_child_wei... | train['Embarked_S'] =(train['Embarked'] == 'S' ).astype(int)
train['Embarked_C'] =(train['Embarked'] == 'C' ).astype(int)
train['Embarked_Q'] =(train['Embarked'] == 'Q' ).astype(int)
train['Gender'] =(train['Sex'] == 'male' ).astype(int ) | Titanic - Machine Learning from Disaster |
9,686,466 | joblib.dump(model, filename)
del model, X_train, y_train, X_valid, y_valid
gc.collect()<feature_engineering> | test['Embarked_S'] =(test['Embarked'] == 'S' ).astype(int)
test['Embarked_C'] =(test['Embarked'] == 'C' ).astype(int)
test['Embarked_Q'] =(test['Embarked'] == 'Q' ).astype(int)
test['Gender'] =(test['Sex'] == 'male' ).astype(int ) | Titanic - Machine Learning from Disaster |
9,686,466 | %%time
validation = steval[['id']+['d_' + str(i)for i in range(1914,1942)]]
validation['id']=pd.read_csv('/kaggle/input/m5-forecasting-accuracy/sales_train_validation.csv' ).id
validation.columns=['id'] + ['F' + str(i + 1)for i in range(28)]
test['sold'] = eval_prediction
evaluation = test[['id','d','sold']]
evaluation... | train = train.drop(columns = ['Sex'])
test = test.drop(columns = ['Sex'])
train = train.drop(columns = ['Embarked'])
test = test.drop(columns = ['Embarked'] ) | Titanic - Machine Learning from Disaster |
9,686,466 | gc.collect()<concatenate> | train.fillna(0, inplace=True)
test.fillna(0, inplace=True ) | Titanic - Machine Learning from Disaster |
9,686,466 | submit = pd.concat([validation,evaluation] ).reset_index(drop=True)
submit.head()<save_to_csv> | X = train.drop(columns=['Survived'])
y = train['Survived'] | Titanic - Machine Learning from Disaster |
9,686,466 | print("Generating CSV file")
submit.to_csv('submission.csv',index=False)
print("Submission Successful" )<categorify> | X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42 ) | Titanic - Machine Learning from Disaster |
9,686,466 | 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_... | model = LGBMClassifier(learning_rate=0.01, n_estimators=1000 ) | Titanic - Machine Learning from Disaster |
9,686,466 | 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... | model.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
9,686,466 | 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... | model.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
9,686,466 | 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", ... | pred = model.predict(X_test ) | Titanic - Machine Learning from Disaster |
9,686,466 | 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)
... | print("R2-score: ",r2_score(pred, y_test))
print("Accuracy score: ",accuracy_score(pred, y_test))
print("F1-score: ",f1_score(pred, y_test)) | Titanic - Machine Learning from Disaster |
9,686,466 | 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... | actual_pred = model.predict(test ) | Titanic - Machine Learning from Disaster |
9,686,466 | 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"... | result = pd.DataFrame({'PassengerId':test['PassengerId'], 'Survived':actual_pred} ) | Titanic - Machine Learning from Disaster |
9,686,466 | <train_model><EOS> | result.to_csv("submission.csv", index=False ) | Titanic - Machine Learning from Disaster |
3,212,316 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
3,212,316 | 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... | def extract_title(name):
name = name.split()
for w in name:
if '.' in w:
return w
return None
all_titles = pd.concat([train, test], sort=False ).Name.apply(lambda name: extract_title(name))
all_titles.unique() | Titanic - Machine Learning from Disaster |
3,212,316 | 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])]
... | train['title'] = train.Name.apply(lambda name: extract_title(name))
test['title'] = test.Name.apply(lambda name: extract_title(name))
train.groupby('title' ).Survived.agg(['count', 'mean'] ) | Titanic - Machine Learning from Disaster |
3,212,316 | 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... | train.groupby('title' ).Survived.agg(['count', 'mean'] ) | Titanic - Machine Learning from Disaster |
3,212,316 | %matplotlib inline
warnings.filterwarnings('ignore' )<load_from_csv> | title_encoder = LabelEncoder().fit(train.title)
train.title = title_encoder.transform(train.title)
test.title = title_encoder.transform(test.title ) | Titanic - Machine Learning from Disaster |
3,212,316 | train = pd.read_json(".. /input/stanford-covid-vaccine/train.json",lines=True)
test = pd.read_json(".. /input/stanford-covid-vaccine/test.json",lines=True)
sub = pd.read_csv(".. /input/stanford-covid-vaccine/sample_submission.csv")
test_pub = test[test["seq_length"] == 107]
test_pri = test[test["seq_length"] == 130]... | sex_encoder = LabelEncoder().fit(train.Sex)
train.Sex = sex_encoder.transform(train.Sex)
test.Sex = sex_encoder.transform(test.Sex ) | Titanic - Machine Learning from Disaster |
3,212,316 | aug_df = pd.read_csv('.. /input/covid19-mrna-augmentation-data-and-features/aug_data1.csv')
aug_df = aug_df.drop_duplicates(subset=['id', 'structure'])
def aug_data(df):
target_df = df.copy()
new_df = aug_df[aug_df['id'].isin(target_df['id'])]
del target_df['structure']
del target_df['predicted_loop_type']
new_df = n... | age_translator = pd.concat([train, test], sort=False ).groupby('title' ).Age.median().to_dict()
train['completeAge'] = train.apply(lambda x: age_translator[x.title], axis=1)
train.loc[train.Age.notnull() , 'completeAge'] = train.loc[train.Age.notnull() , 'Age']
test['completeAge'] = test.apply(lambda x: age_translator... | Titanic - Machine Learning from Disaster |
3,212,316 | As = []
for id in tqdm(train["id"]):
a = np.load(f".. /input/stanford-covid-vaccine/bpps/{id}.npy" ).astype(np.float16)
As.append(a)
As = np.array(As)
As_pub = []
for id in tqdm(test_pub["id"]):
a = np.load(f".. /input/stanford-covid-vaccine/bpps/{id}.npy" ).astype(np.float16)
As_pub.append(a)
As_pub = np.array(As... | train['familysize'] = train.Parch + train.SibSp + 1
test['familysize'] = test.Parch + test.SibSp + 1
train.drop(['Parch', 'SibSp'], inplace=True, axis=1)
train['hasfamily'] = 0
train.loc[train.familysize == 1, 'hasfamily'] = 1
test['hasfamily'] = 0
test.loc[test.familysize == 1, 'hasfamily'] = 1 | Titanic - Machine Learning from Disaster |
3,212,316 | 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", ... | train['ticketno'] = train.Ticket.apply(lambda x: x.split() [-1])
train.ticketno.replace('LINE', "0", inplace=True)
train.ticketno = train['ticketno'].astype(np.int)
test['ticketno'] = test.Ticket.apply(lambda x: x.split() [-1])
test.ticketno = test['ticketno'].astype(np.int ) | Titanic - Machine Learning from Disaster |
3,212,316 | 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 = Ds / Ds.shape[1]
Ds = Ds[None, :,:]
Ds = np.repeat(Ds, len(As), axis = 0)
Dss = []
for i in [1]:
Dss.append(Ds ** i)
Ds = np.stack(Dss, axis = 3)
return Ds.a... | train['decklevel'] = train.Cabin.dropna().apply(lambda x: str(x)[0])
test['decklevel'] = test.Cabin.dropna().apply(lambda x: str(x)[0])
decklevel_encoder = LabelEncoder().fit(train.decklevel.dropna())
train.loc[train.decklevel.notna() , 'decklevel'] = decklevel_encoder.transform(train.decklevel.dropna())
test.loc[t... | Titanic - Machine Learning from Disaster |
3,212,316 | As = np.concatenate([As[:,:,:,None], As_cf[:,:,:,None], As_rs[:,:,:,None], Ss, Ds], axis = 3 ).astype(np.float16)
del Ss, Ds, As_cf, As_rs
As_pub = np.concatenate([As_pub[:,:,:,None], As_pub_cf[:,:,:,None], As_pub_rs[:,:,:,None], Ss_pub, Ds_pub], axis = 3 ).astype(np.float16)
del Ss_pub, Ds_pub, As_pub_cf, As_pub_rs
... | train.Embarked.fillna('S', inplace=True)
embarked_encoder = LabelEncoder().fit(train.Embarked)
train.Embarked = embarked_encoder.transform(train.Embarked)
test.Embarked = embarked_encoder.transform(test.Embarked ) | Titanic - Machine Learning from Disaster |
3,212,316 | f, ax = plt.subplots(1, 5, figsize=(15, 3))
for i in range(As.shape[-1]):
ax[i].imshow(As[0, :, :, i].astype(np.float32))
plt.show()<load_pretrained> | test.loc[test.Fare.isna() , 'Fare'] = train.Fare.median() | Titanic - Machine Learning from Disaster |
3,212,316 | arnie_train_features = pickle.load(open('.. /input/covid19-mrna-augmentation-data-and-features/arnie/arnie/train_features.p', 'rb'))
arnie_test_features = pickle.load(open('.. /input/covid19-mrna-augmentation-data-and-features/arnie/arnie/test_features.p', 'rb'))
capr_train_features = pickle.load(open('.. /input/covid1... | featurelist = ['Pclass', 'Fare', 'title', 'Sex', 'Embarked', 'rich_small_families', 'completeAge', 'hasfamily'] | Titanic - Machine Learning from Disaster |
3,212,316 | 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"... | parameters = {'n_estimators': [40, 50, 60, 70],
'max_depth': [7, 10, 13],
'max_features': range(3, len(featurelist)) ,
'min_samples_leaf': [1, 2, 3],
'min_samples_split': [7, 10, 12]}
model = RandomForestClassifier(random_state=42)
grid = GridSearchCV(model, param_grid=parameters, cv=5, n_jobs=-1, scoring='accuracy')
... | Titanic - Machine Learning from Disaster |
3,212,316 | del arnie_train_features, arnie_test_features, capr_train_features, capr_test_features<concatenate> | grid.best_params_ | Titanic - Machine Learning from Disaster |
3,212,316 | targets = ['reactivity', 'deg_Mg_pH10', 'deg_pH10', 'deg_Mg_50C', 'deg_50C']
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_... | grid.best_score_ | Titanic - Machine Learning from Disaster |
3,212,316 | N_NODE_FEATURES = X_node.shape[2]
N_EDGE_FEATURES = As.shape[3]<import_modules> | print(classification_report(grid.predict(train[featurelist]), train['Survived'])) | Titanic - Machine Learning from Disaster |
3,212,316 | import tensorflow as tf
from tensorflow.keras import layers as L
import tensorflow_addons as tfa
from tensorflow.keras import backend as K
from sklearn.utils import shuffle
from sklearn.model_selection import GroupKFold<define_search_space> | result = test
result.loc[:,'Survived'] = grid.predict(test[featurelist])
result.head() | Titanic - Machine Learning from Disaster |
3,212,316 | <compute_test_metric><EOS> | result[['PassengerId', 'Survived']].to_csv('submission.csv', header=True, index=False ) | Titanic - Machine Learning from Disaster |
1,503,290 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | init_notebook_mode() | Titanic - Machine Learning from Disaster |
1,503,290 | 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 ---")
X_node_shuff, As_shuff = shuffle(X_node, As)
ae_model.fit([X_node_shuff, As_shuff], [np.zeros(( len(X_node)))],
epochs = ae_epoch... | features1 = ["Age","SibSp","Parch", "Pclass", "is_male", "is_female", "f_size", "Single", "SmallF", "MedF", "LargeF", "Title", "Embarked"]
target = ["Survived"]
print("Total number of features is {}".format(len(features1)) ) | Titanic - Machine Learning from Disaster |
1,503,290 | del ae_model
gc.collect()<save_model> | test_csv = prepare_data('.. /input/test.csv', True)
test_data = test_csv[features1]
test_csv.head(5 ) | Titanic - Machine Learning from Disaster |
1,503,290 | np.save('X_node_pub.npy', X_node_pub)
np.save('X_node_pri.npy', X_node_pri)
np.save('As_pub.npy', As_pub)
np.save('As_pri.npy', As_pri)
del X_node_pub, X_node_pri, As_pub, As_pri, X_node_shuff, As_shuff, X_node_pub_shuff, As_pub_shuff, X_node_pri_shuff, As_pri_shuff<split> | train, valid = train_test_split(data, test_size=0.2)
print("The Train Set Size is {}
The Validation Set Size is {}".format(len(train), len(valid)))
print("Test Set Size is {}".format(len(test_data)) ) | Titanic - Machine Learning from Disaster |
1,503,290 | kfold = GroupKFold(5)
config = {}
scores = []
preds = np.zeros([len(X_node), X_node.shape[1], 5])
X_node, As, y, weights, groups_shuffled, SN_filter_mask = shuffle(X_node, As, y, train.signal_to_noise.values, train['id'],(train['SN_filter'] == 1 ).values)
del train
for i,(tr_idx, va_idx)in enumerate(kfold.split(X_no... | train_x , train_y = data[features1].as_matrix() , data[target].as_matrix()
clf = DecisionTreeClassifier()
clf.fit(train_x, train_y)
print(( np.array(clf.predict(valid[features1].as_matrix())== valid[target].as_matrix().flatten() , dtype=np.int ).sum() * 100.) / len(valid))
result = pd.DataFrame(data={'PassengerId': te... | Titanic - Machine Learning from Disaster |
1,503,290 | preds_df = []
for p_ix, _id in zip(range(preds.shape[0]), groups_shuffled):
for i in range(68):
preds_df.append([f'{_id}_{i}', preds[p_ix, i, 0], preds[p_ix, i, 1],
preds[p_ix, i, 3], y[p_ix, i, 0], y[p_ix, i, 1],
y[p_ix, i, 3], SN_filter_mask[p_ix]])
preds_df = pd.DataFrame(preds_df, columns=['id_seqpos', 'reactivity... | class TitanicLoader(Dataset):
def __init__(self,train,transforms=None):
self.X = train.as_matrix(columns=features1)
self.Y = train.as_matrix(columns=target ).flatten()
self.count = len(self.X)
self.transforms = transforms
def __getitem__(self, index):
nextItem = Variable(torch.tensor(self.X[index] ).type(torch.FloatT... | Titanic - Machine Learning from Disaster |
1,503,290 | del X_node, As<load_pretrained> | class DNN(nn.Module):
def __init__(self, input_size, first_hidden_size, second_hidden_size, num_classes):
super(DNN, self ).__init__()
self.z1 = nn.Linear(input_size, first_hidden_size)
self.relu = nn.ReLU()
self.z2 = nn.Linear(first_hidden_size, second_hidden_size)
self.z3 = nn.Linear(second_hidden_size, num_classes... | Titanic - Machine Learning from Disaster |
1,503,290 | X_node_pub = np.load('X_node_pub.npy')
X_node_pri = np.load('X_node_pri.npy')
As_pub = np.load('As_pub.npy')
As_pri = np.load('As_pri.npy' )<load_pretrained> | def train_dnn(net, trainL, validL):
count = 0
accuList = []
lossList = []
optimizer = torch.optim.Adam(net.parameters() ,lr=0.001)
for epc in range(1,epochs + 1):
print("Epoch
vcount = 0
total_loss = 0
net.train()
for data,target in trainL:
optimizer.zero_grad()
out = net(data)
loss = F.nll_loss(out, target, size_ave... | Titanic - Machine Learning from Disaster |
1,503,290 | p_pub = 0
p_pri = 0
for i in range(5):
config = {}
base = get_base(config)
if ae_epochs > 0:
print("****** load ae model ******")
base.load_weights("base_ae_lstm_lstm")
model = get_model(base, config)
model.load_weights(f"model{i}_lstm_lstm")
p_pub += model.predict([X_node_pub, As_pub])/ 5
p_pri += model.predict([... | epochs = 12 | Titanic - Machine Learning from Disaster |
1,503,290 | 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... | titanic_train_DS = TitanicLoader(train)
titanic_valid_DS = TitanicLoader(valid)
train_loader = torch.utils.data.DataLoader(titanic_train_DS,
batch_size=6, shuffle=False)
valid_loader = torch.utils.data.DataLoader(titanic_valid_DS,
batch_size=1, shuffle=False ) | Titanic - Machine Learning from Disaster |
1,503,290 | import numpy as np
import pandas as pd
import os
<import_modules> | myNet = DNN(len(features1), 23, 4, 2)
accuList, lossList = train_dnn(myNet, train_loader, valid_loader ) | Titanic - Machine Learning from Disaster |
1,503,290 | import json
import tensorflow as tf
from matplotlib import pyplot as plt<load_from_csv> | def get_preds(test, net):
net.eval()
preds = []
for data, target in test:
out = net(data)
pred = out.data.max(1, keepdim=True)[1]
preds.append(pred.item())
return preds | Titanic - Machine Learning from Disaster |
1,503,290 | train_data = pd.read_json('/kaggle/input/stanford-covid-vaccine/train.json', lines = True)
test_data = pd.read_json('/kaggle/input/stanford-covid-vaccine/test.json', lines = True)
submission_format = pd.read_csv('/kaggle/input/stanford-covid-vaccine/sample_submission.csv', encoding = 'utf-8-sig' )<groupby> | test_data['Survived'] = -1
titanic_test_DS = TitanicLoader(test_data)
test_loader = torch.utils.data.DataLoader(titanic_test_DS,
batch_size=1, shuffle=False)
result = pd.DataFrame(data={'PassengerId': test_csv['PassengerId'], 'Survived': get_preds(test_loader, myNet)})
result.to_csv(path_or_buf='neural_network_submi... | Titanic - Machine Learning from Disaster |
1,503,290 | train_data.groupby(['SN_filter'] ).size()<count_values> | neigh = KNeighborsClassifier(n_neighbors=5, weights='distance', p=1)
neigh.fit(train[features1].as_matrix() , train[target].as_matrix().flatten())
print_acc(( np.array(neigh.predict(valid[features1].as_matrix())== valid[target].as_matrix().flatten() , dtype=np.int ).sum() * 100.) / len(valid), "K-NN")
result = pd.Da... | Titanic - Machine Learning from Disaster |
1,503,290 | print('Training data:
',train_data['seq_scored'].value_counts())
print('Test data:
',test_data['seq_scored'].value_counts())
len(train_data['reactivity'].iloc[0] )<count_values> | gnb = GaussianNB()
y_pred = gnb.fit(train[features1].as_matrix() , train[target].as_matrix().flatten() ).predict(valid[features1].as_matrix())
print_acc(float(np.array(y_pred == valid[target].as_matrix().flatten() , dtype=np.int ).sum() * 100)/ len(valid), "Naive Bayes")
result = pd.DataFrame(data={'PassengerId': tes... | Titanic - Machine Learning from Disaster |
1,503,290 | flag = False
for i in range(0,len(train_data)) :
if(( [x<0 for x in train_data['reactivity_error'].iloc[i]].count(True)> 0)|
([x<0 for x in train_data['deg_error_Mg_pH10'].iloc[i]].count(True)> 0)|
([x<0 for x in train_data['deg_error_pH10'].iloc[i]].count(True)> 0)|
([x<0 for x in train_data['deg_error_Mg_50C'].ilo... | clf1 = LogisticRegression(random_state=1)
clf2 = RandomForestClassifier(n_estimators=25,random_state=1)
clf3 = GaussianNB(var_smoothing=True)
clf4 = LinearSVC(random_state=5)
gbm = xgb.XGBClassifier(max_depth=5, n_estimators=300, learning_rate=0.05)
eclf1 = VotingClassifier(estimators=[('lr', clf1),('rf', clf2),('... | Titanic - Machine Learning from Disaster |
1,503,290 | <feature_engineering><EOS> | gbm = xgb.XGBClassifier(max_depth=3, n_estimators=600, learning_rate=0.05)
y_pred = gbm.fit(train[features1].as_matrix() , train[target].as_matrix().flatten() ).predict(valid[features1].as_matrix())
print_acc(float(np.array(y_pred == valid[target].as_matrix().flatten() , dtype=np.int ).sum() * 100)/ len(valid), "XGB"... | Titanic - Machine Learning from Disaster |
434,514 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier | Titanic - Machine Learning from Disaster |
434,514 | token2int = {x:i for i, x in enumerate('().ACGUBEHIMSX')}
target_cols = ['reactivity', 'deg_Mg_pH10', 'deg_pH10', 'deg_Mg_50C', 'deg_50C']<load_pretrained> | train=pd.read_csv(".. /input/train.csv")
test=pd.read_csv(".. /input/test.csv")
def append_train_test(train,test):
train["IsTrain"]=1
test["IsTrain"]=0
df=train.append(test)
return df;
full=append_train_test(train,test)
train.info()
print("------------------------")
test.info()
print("------------------------")
f... | Titanic - Machine Learning from Disaster |
434,514 | def read_bpps_sum(df):
bpps_arr = []
for mol_id in df.id.to_list() :
bpps_arr.append(np.load(f".. /input/stanford-covid-vaccine/bpps/{mol_id}.npy" ).sum(axis=1))
return bpps_arr
def read_bpps_max(df):
bpps_arr = []
for mol_id in df.id.to_list() :
bpps_arr.append(np.load(f".. /input/stanford-covid-vaccine/bpps/{mol_id}.... | full.loc[(full["Title"].isin(["Rev","Dr","Col","Capt","Major"])) &(full["Sex"]!="male")] | Titanic - Machine Learning from Disaster |
434,514 | def get_bases(data):
bases = []
for j in range(len(data)) :
counts = dict(count(data.iloc[j]['sequence']))
bases.append((
counts['A'] / 107,
counts['G'] / 107,
counts['C'] / 107,
counts['U'] / 107
))
bases = pd.DataFrame(bases, columns=['A_percent', 'G_percent', 'C_percent', 'U_percent'])
return bases<create_datafram... | full.loc[(full["Title"].isin(["Rev","Capt","Major","Col","Jonkheer","Don","Sir","Dr"])) &(full["Sex"]=="male"),"Title"] = "Mr"
full.loc[(full["Title"].isin(["Countess","Lady","Dona","Mme"])) ,"Title"]="Mrs"
full.loc[(full["Title"].isin(["Mlle","Ms","Dr"])) &(full["Sex"]=="female"),"Title"]="Miss"
full["Title"].value_co... | Titanic - Machine Learning from Disaster |
434,514 | def get_pairs_rate(data):
pairs_rate = []
for j in range(len(data)) :
res = dict(count(data.iloc[j]['structure']))
pairs_rate.append(res['('] / 53.5)
pairs_rate = pd.DataFrame(pairs_rate, columns=['pairs_rate'])
return pairs_rate<define_variables> | full.isnull().sum() | Titanic - Machine Learning from Disaster |
434,514 | def get_pairs(data):
pairs = []
all_partners = []
for j in range(len(data)) :
partners = [-1 for i in range(130)]
pairs_dict = {}
queue = []
for i in range(0, len(data.iloc[j]['structure'])) :
if data.iloc[j]['structure'][i] == '(':
queue.append(i)
if data.iloc[j]['structure'][i] == ')':
first = queue.pop()
try:
pairs... | full[full.Fare.isnull() ] | Titanic - Machine Learning from Disaster |
434,514 | def get_loops(data):
loops = []
for j in range(len(data)) :
counts = dict(count(data.iloc[j]['predicted_loop_type']))
available = ['E', 'S', 'H', 'B', 'X', 'I', 'M']
row = []
for item in available:
try:
row.append(counts[item] / 107)
except:
row.append(0)
loops.append(row)
loops = pd.DataFrame(loops, columns=availab... | full.loc[(full.Fare.isnull()),"Fare"]=8.05 | Titanic - Machine Learning from Disaster |
434,514 | 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", ... | full[full.Embarked.isnull() ] | Titanic - Machine Learning from Disaster |
434,514 | As = []
data = train_data[train_data['signal_to_noise'] > 1].copy()
for id in tqdm(data['id']):
a = np.load(f"/kaggle/input/stanford-covid-vaccine/bpps/{id}.npy")
As.append(a)
As = np.array(As )<compute_test_metric> | full.loc[(full.Embarked.isnull()),"Embarked"]="C" | Titanic - Machine Learning from Disaster |
434,514 | 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)
... | ImpAge=pd.DataFrame({'median' : data.groupby([ "Title", "Pclass"] ).Age.median() } ).reset_index()
ImpAge.head(n=20 ) | Titanic - Machine Learning from Disaster |
434,514 | def preprocess_inputs(df, cols=['sequence', 'structure', 'predicted_loop_type'], seq_length = 107, flag = 'train'):
base_fea = np.transpose(
np.array(
df[cols]
.applymap(lambda seq: [token2int[x] for x in seq])
.values
.tolist()
),
(0, 2, 1)
)
bpps_sum_fea = np.array(df['bpps_sum'].to_list())[:,:,np.newaxis]
bpp... | def imputeAges(df):
classes=[1,2,3]
titles=["Mr","Mrs","Miss","Master"]
for title in titles:
for pclass in classes:
x=ImpAge[(( ImpAge.Title==title)&(ImpAge.Pclass==pclass)) ]["median"].values[0]
df.loc[(( df.Title==title)&(df.Pclass==pclass)&(df.Age.isnull())) ,"Age"]=x
return df
imputeAges(full)
full.isnull().sum() | Titanic - Machine Learning from Disaster |
434,514 | bases = get_bases(train_data)
pairs = get_pairs(train_data)
loops = get_loops(train_data)
pairs_rate = get_pairs_rate(train_data)
train_data = pd.concat([train_data, bases, pairs, loops, pairs_rate], axis=1)
bases = get_bases(test_data)
pairs = get_pairs(test_data)
loops = get_loops(test_data)
pairs_rate = get_... | features=["Age","Embarked","Fare","Parch","Pclass","Sex","SibSp","Title","FamilySize","FamilySizeBand"]
target="Survived"
full[features].head() | Titanic - Machine Learning from Disaster |
434,514 | train_inputs = preprocess_inputs(train_data.loc[train_data['signal_to_noise'] > 1], seq_length = 107, flag = 'train')
train_labels = np.array(train_data.loc[train_data['signal_to_noise'] > 1][target_cols].values.tolist() ).transpose(( 0, 2, 1))<compute_test_metric> | clf = RandomForestClassifier(n_jobs=2, random_state=0)
clf = clf.fit(train_features, train_target)
train_preds=clf.predict(train_features)
print(clf)
for i in range(0,10):
print(features[i]," ",clf.feature_importances_[i] ) | Titanic - Machine Learning from Disaster |
434,514 | def root_mean_squared_error(y_true, y_pred):
return tf.sqrt(mean_squared_error(y_true, y_pred))
def MCRMSE(y_true, y_pred):
colwise_mse = tf.reduce_mean(tf.square(y_true - y_pred), axis=1)
return tf.reduce_mean(tf.sqrt(colwise_mse), axis=1)
def lstm_layer(hidden_dim, dropout):
return tf.keras.layers.Bidirectional(
t... | pd.crosstab(train_target, train_preds, rownames=['Actual Outcome'], colnames=['Predicted Outcome'] ) | Titanic - Machine Learning from Disaster |
434,514 | public_df = test_data.query("seq_length == 107" ).copy()
private_df = test_data.query("seq_length == 130" ).copy()<load_pretrained> | test_preds=clf.predict(test_features ).astype(int)
test_ids=full[891:]["PassengerId"]
final = pd.DataFrame({
"PassengerId": test_ids,
"Survived": test_preds
})
final.info() | Titanic - Machine Learning from Disaster |
434,514 | <load_pretrained><EOS> | final.to_csv('submission2.csv', index=False ) | Titanic - Machine Learning from Disaster |
12,584,804 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_pretrained> | !pip install seaborn==0.11.0 | Titanic - Machine Learning from Disaster |
12,584,804 | model_LSTM_on_test_data_private = build_model(seq_len=130, pred_len=130, gru_flag = False)
model_LSTM_on_test_data_private.load_weights('.. /input/openvaccine-covid-model-weights/LSTM model.h5')
pred_test_data_private_LSTM = model_LSTM_on_test_data_private.predict(private_inputs)
model_GRU_on_test_data_private = bui... | titanic = pd.read_csv('/kaggle/input/titanic/train.csv' ) | Titanic - Machine Learning from Disaster |
12,584,804 | def format_predictions(public_preds, private_preds):
preds = []
for df, preds_ in [(public_df, public_preds),(private_df, private_preds)]:
for i, uid in enumerate(df.id):
single_pred = preds_[i]
single_df = pd.DataFrame(single_pred, columns=target_cols)
single_df['id_seqpos'] = [f'{uid}_{x}' for x in range(single_df.s... | titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
12,584,804 | lstm_preds = format_predictions(pred_test_data_public_LSTM, pred_test_data_private_LSTM)
gru_preds = format_predictions(pred_test_data_public_GRU, pred_test_data_private_GRU )<merge> | titanic = titanic.drop({'Name', 'Ticket', 'Cabin'}, axis=1 ) | Titanic - Machine Learning from Disaster |
12,584,804 | submission_LSTM = submission_format[['id_seqpos']].merge(lstm_preds, how = 'inner', on = 'id_seqpos')
submission_GRU = submission_format[['id_seqpos']].merge(gru_preds, how = 'inner', on = 'id_seqpos' )<merge> | titanic['Embarked']= titanic['Embarked'].fillna(titanic['Embarked'].value_counts().index[0] ) | Titanic - Machine Learning from Disaster |
12,584,804 | submission_lstm_gru_combined = submission_GRU.merge(submission_LSTM, how = 'inner', on = 'id_seqpos')
gru_weight = 0.5
lstm_weight = 0.5
for i in range(len(target_cols)) :
submission_lstm_gru_combined[target_cols[i]] = submission_lstm_gru_combined[target_cols[i]+'_x']*gru_weight + submission_lstm_gru_combined[target_c... | pd.pivot_table(titanic, values='Age', index=['Sex'], columns=['Pclass'], aggfunc=np.mean ) | Titanic - Machine Learning from Disaster |
12,584,804 | submission_lstm_gru_combined = submission_lstm_gru_combined[['id_seqpos'] + target_cols]<save_to_csv> | for Pclass in titanic.Pclass.unique() :
for Sex in titanic.Sex.unique() :
titanic[(titanic['Pclass'] == Pclass)&(titanic['Sex'] == Sex)] = \
titanic[(titanic['Pclass'] == Pclass)&(titanic['Sex'] == Sex)] \
.fillna(np.rint(titanic[(titanic['Pclass'] == Pclass)&(titanic['Sex'] == Sex)].Age.mean())) | Titanic - Machine Learning from Disaster |
12,584,804 | os.chdir("/kaggle/working/")
submission_LSTM.to_csv('submission_LSTM.csv', index = False)
submission_GRU.to_csv('submission_GRU.csv', index = False)
submission_lstm_gru_combined.to_csv('submission_lstm_gru_combined.csv', index = False )<define_variables> | titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
12,584,804 | copyfile(src = ".. /usr/lib/modellib/modellib.py", dst = ".. /working/ModelLib.py" )<import_modules> | titanic['Sex'] = pd.get_dummies(titanic['Sex'], drop_first=True)
titanic.rename({'Sex': 'Male'}, axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
12,584,804 | import numpy as np
import pandas as pd
import torch
from torch.utils.data import TensorDataset, Dataset, DataLoader
from torch.utils.data.sampler import SubsetRandomSampler
from sklearn.model_selection import KFold,StratifiedKFold
from tqdm.auto import tqdm
from ModelLib import Create_model,stratified_group_k_fold
impo... | titanic['Embarked_fz'] = pd.factorize(titanic['Embarked'], sort=True)[0] | Titanic - Machine Learning from Disaster |
12,584,804 | random.seed(831)
os.environ['PYTHONHASHSEED'] = str(721)
np.random.seed(1111)
torch.manual_seed(1117)
torch.cuda.manual_seed(1001)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
device = 'cuda'<load_pretrained> | X = titanic.drop({'PassengerId', 'Survived', 'SibSp', 'Parch', 'Embarked'}, axis=1)
y = titanic['Survived'] | Titanic - Machine Learning from Disaster |
12,584,804 | train_x = np.load('.. /input/covid19fe/train_aug_x.npy')
test_x = np.load('.. /input/covid19fe/test_aug_x.npy')
train_bpps = np.load('.. /input/covid19fe/train_bpps.npy')
test_bpps = np.load('.. /input/covid19fe/test_bpps.npy')
train_viennarna_bpps = np.load('.. /input/covid19extrafeatures/train_viennarna_bpps.npy'... | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42 ) | Titanic - Machine Learning from Disaster |
12,584,804 | train_bpps = np.concatenate([np.expand_dims(train_bpps,axis=1),np.expand_dims(train_viennarna_bpps,axis=1),np.expand_dims(train_mat,axis=1),np.expand_dims(train_aug_mat,axis=1)],axis=1)
test_bpps = np.concatenate([np.expand_dims(test_bpps,axis=1),np.expand_dims(test_viennarna_bpps,axis=1),np.expand_dims(test_mat,axis=... | clf = RandomForestClassifier() | Titanic - Machine Learning from Disaster |
12,584,804 | train = pd.read_json('.. /input/stanford-covid-vaccine/train.json',lines=True ).drop('index',axis=1)
test = pd.read_json('.. /input/stanford-covid-vaccine/test.json',lines=True ).drop('index',axis=1)
train_length = train.seq_length.values
test_length = test.seq_length.values
train_scored = train.seq_scored.values
tes... | parametrs = { 'n_estimators': range(10, 51, 10),
'max_depth': range(1,13, 2),
'min_samples_leaf': range(1,8),
'min_samples_split': range(2,10,2)} | Titanic - Machine Learning from Disaster |
12,584,804 |
<data_type_conversions> | grid = GridSearchCV(clf, parametrs, cv=5)
grid.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
12,584,804 | class Covid19Dataset(Dataset):
def __init__(self,X,bpps,mat,seq_length,scored_length,label=None,label_error=None,signal_to_noise=None,SN_filter_mask=None):
self.X = X.astype(np.int)
self.bpps = bpps.astype(np.float32)
if label is not None:
self.label = label.astype(np.float32)
self.signal_to_noise = signal_to_noise.... | grid.best_estimator_ | Titanic - Machine Learning from Disaster |
12,584,804 | nepochs = 300
n_fold = 5
kf = StratifiedKFold(n_fold,shuffle=True,random_state=831)
dataset = Covid19Dataset(train_x,train_bpps,train_mat,train_length,train_scored,label,label_error,signal_to_noise,SN_filter_mask)
cv_score = []
loss_weights = torch.Tensor([1.2,1.2,1.2,0.7,0.7] ).reshape(1,5 ).to(device)
oof = np.zer... | y_pred = grid.predict(X_test)
y_proba = grid.predict_proba(X_test)
y_proba = y_proba[:, 1] | Titanic - Machine Learning from Disaster |
12,584,804 | for i in range(n_fold):
print(f"fold {i+1} score:",cv_score[i])
print()
print("CV score:",np.mean(cv_score))
np.save('oof_{:5.5f}'.format(np.mean(cv_score)) ,oof )<create_dataframe> | confusion_matrix(y_test, y_pred ) | Titanic - Machine Learning from Disaster |
12,584,804 | dataset = Covid19Dataset(test_x,test_bpps,test_mat,test_length,test_scored)
args_loader = {'batch_size': 1, 'shuffle': False, 'num_workers': 0, 'pin_memory': True, 'drop_last': False}
test_loader = DataLoader(dataset, **args_loader)
test_predictions = np.zeros([len(test_x),130,5])
for j,col in enumerate(['reactivity... | precision_score(y_test, y_pred ) | Titanic - Machine Learning from Disaster |
12,584,804 | ss = pd.read_csv(".. /input/stanford-covid-vaccine/sample_submission.csv",index_col=0 )<feature_engineering> | recall_score(y_test, y_pred ) | Titanic - Machine Learning from Disaster |
12,584,804 | for n,row in tqdm(test.iterrows() ,total=len(test)) :
test_id = row['id']
seq_len = row['seq_length']
for i in range(seq_len):
for j,col in enumerate(['reactivity', 'deg_Mg_pH10', 'deg_Mg_50C']):
ss.loc[test_id+'_'+str(i),col] = test_predictions[n,i,j]<save_to_csv> | f1_score(y_test, y_pred ) | Titanic - Machine Learning from Disaster |
12,584,804 | ss.to_csv("submission_cnn_{:5.5f}.csv".format(np.mean(cv_score)) ,index=True )<install_modules> | titanic_test = pd.read_csv('/kaggle/input/titanic/test.csv')
titanic_test['Embarked']= titanic_test['Embarked'].fillna(titanic_test['Embarked'].value_counts().index[0])
for Pclass in titanic_test.Pclass.unique() :
for Sex in titanic_test.Sex.unique() :
titanic_test[(titanic_test['Pclass'] == Pclass)&(titanic_test['Se... | Titanic - Machine Learning from Disaster |
12,584,804 | <import_modules><EOS> | submission = pd.DataFrame({'PassengerId':PassengerId,'Survived':y_test2})
submission.to_csv('submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
1,007,734 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | train = pd.read_csv('.. /input/train.csv')
train.info() | Titanic - Machine Learning from Disaster |
1,007,734 | TARGETS = ['reactivity', 'deg_Mg_pH10', 'deg_pH10', 'deg_Mg_50C', 'deg_50C']
SCORED_TARGETS = [0, 1, 3]
NUM_TARGETS = len(TARGETS)
SEQ_SCORED_PUBLIC = 68
SEQ_SCORED_PRIVATE = 91
SEQ_LEN_PUBLIC = 107
SEQ_LEN_PRIVATE = 130<define_variables> | def prep_data(df):
to_be_dropped = ['Name', 'Cabin', 'Ticket']
df['Embarked'] = df['Embarked'].fillna('S')
df['Age'] = df['Age'].fillna(median_age)
df['Fare'] = df['Fare'].fillna(median_fare)
df['Companions'] = df['Parch'] + df['SibSp']
to_be_dropped.extend(['Parch', 'SibSp'])
df.loc[ df['Age'] <= 16, 'Age'] = 0
df... | Titanic - Machine Learning from Disaster |
1,007,734 | BASE_PATH = ".. /input/stanford-covid-vaccine/"
CP_PATH = ""
PRETRAINED_PATH = ".. /input/covid-pretrained/pretrained_model.pt"
DEVICE = torch.device('cuda')
TODAY = str(datetime.date.today() )<load_from_disk> | y = train['Survived']
X = train.drop('Survived', axis = 1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.35, random_state=7 ) | Titanic - Machine Learning from Disaster |
1,007,734 | train_df = pd.read_json(str(Path(BASE_PATH)/ 'train.json'), lines=True)
test_df = pd.read_json(str(Path(BASE_PATH)/ 'test.json'), lines=True)
public_df = test_df[test_df["seq_length"] == SEQ_LEN_PUBLIC].reset_index(drop=True)
private_df = test_df[test_df["seq_length"] == SEQ_LEN_PRIVATE].reset_index(drop=True )<defi... | warnings.filterwarnings("ignore", category=DeprecationWarning)
warnings.filterwarnings("ignore", category=UserWarning)
lgbm = lgb.LGBMClassifier(nthread = 4, boosting_type = 'dart')
param_grid = {'learning_rate': [0.08, 0.09, 0.1]}
grid_search = GridSearchCV(lgbm, param_grid, scoring='roc_auc', cv=10)
grid_result =... | Titanic - Machine Learning from Disaster |
1,007,734 | target_cols = ['reactivity', 'deg_Mg_pH10', 'deg_pH10', 'deg_Mg_50C', 'deg_50C']
input_cols = ['sequence', 'structure', 'predicted_loop_type']
error_cols = ['reactivity_error', 'deg_error_Mg_pH10', 'deg_error_Mg_50C', 'deg_error_pH10', 'deg_error_50C']
token_dicts = {
"sequence": {x: i for i, x in enumerate("ACGU")},
"... | accuracy = accuracy_score(y_test, lgbm.predict(X_test))
print("Accuracy: %.2f%%" %(accuracy * 100.0)) | Titanic - Machine Learning from Disaster |
1,007,734 | def set_seed(seed=42):
random.seed(seed)
np.random.seed(seed)
os.environ["PYTHONHASHSEED"] = str(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = True
SEED = 1234
set_seed(SEED )<categorify> | test = pd.read_csv('.. /input/test.csv')
test.info() | Titanic - Machine Learning from Disaster |
1,007,734 | <train_model><EOS> | predictions = lgbm.predict(test)
submission = pd.DataFrame({
"PassengerId": test.index,
"Survived": predictions
})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
2,249,093 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | print("Last updated:")
print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M")) | Titanic - Machine Learning from Disaster |
2,249,093 | aug_df = pd.read_csv('.. /input/covid-data/aug_data.csv' )<merge> | init_notebook_mode(connected=True)
| Titanic - Machine Learning from Disaster |
2,249,093 | def augment_data(df, concat=True):
df = df.copy()
target_df = df.copy()
new_df = aug_df[aug_df['id'].isin(target_df['id'])]
del target_df['structure']
del target_df['predicted_loop_type']
new_df = new_df.merge(target_df, on=['id','sequence'], how='left' ).sort_values('index')
df['cnt'] = df['id'].map(new_df[['id','cnt... | train_df=pd.read_csv(PATH+'train.csv')
test_df=pd.read_csv(PATH+'test.csv' ) | 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.