kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
2,249,093 | PUBLIC_IDS = public_df['id'].values
def is_public(id_seqpos):
id_ = '_'.join(id_seqpos.split('_')[:2])
return id_ in PUBLIC_IDS<define_variables> | print("Train: rows:{} cols:{}".format(train_df.shape[0], train_df.shape[1]))
print("Test: rows:{} cols:{}".format(test_df.shape[0], test_df.shape[1])) | Titanic - Machine Learning from Disaster |
2,249,093 | PL_PATH = ".. /input/covid-pl/"<load_pretrained> | def missing_data(data):
total = data.isnull().sum().sort_values(ascending = False)
percent =(data.isnull().sum() /data.isnull().count() *100 ).sort_values(ascending = False)
return pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
missing_data(train_df ) | Titanic - Machine Learning from Disaster |
2,249,093 | PL_PUBLIC = np.load(PL_PATH + 'pl_public.npy')
PL_PRIVATE = np.load(PL_PATH + 'pl_private.npy' )<categorify> | missing_data(test_df ) | Titanic - Machine Learning from Disaster |
2,249,093 | for t, target in enumerate(TARGETS):
tgt = []
for i in range(len(public_df)) :
tgt.append(list(PL_PUBLIC[i, :SEQ_SCORED_PUBLIC, t]))
public_df[target] = tgt
tgt = []
for i in range(len(private_df)) :
tgt.append(list(PL_PRIVATE[i, :SEQ_SCORED_PRIVATE, t]))
private_df[target] = tgt
public_df['signal_to_noise'] = 1
privat... | def get_categories(data, val):
tmp = data[val].value_counts()
return pd.DataFrame(data={'Number': tmp.values}, index=tmp.index ).reset_index() | Titanic - Machine Learning from Disaster |
2,249,093 | def save_model_weights(model, filename, verbose=1, cp_folder=""):
if verbose:
print(f"
-> Saving weights to {os.path.join(cp_folder, filename)}
")
torch.save(model.state_dict() , os.path.join(cp_folder, filename))
def load_model_weights(model, filename, verbose=1, cp_folder=""):
if verbose:
print(f"
-> Loading wei... | def get_survived_categories(data, val):
tmp = data.groupby('Survived')[val].value_counts()
return pd.DataFrame(data={'Number': tmp.values}, index=tmp.index ).reset_index() | Titanic - Machine Learning from Disaster |
2,249,093 | def preprocess_inputs(df, cols):
return np.concatenate([preprocess_feature_col(df, col)for col in cols], axis=2)
def preprocess_feature_col(df, col):
dic = token_dicts[col]
dic_len = len(dic)
seq_length = len(df[col][0])
ident = np.identity(dic_len)
arr = np.array(
df[[col]].applymap(lambda seq: [ident[dic[x]] for... | train_df['Ticket'].value_counts().head(10 ) | Titanic - Machine Learning from Disaster |
2,249,093 | def create_loader(df, batch_size=64, is_test=False, shuffle=True):
if is_test:
shuffle = False
features, labels = preprocess(df, is_test)
features_tensor = torch.from_numpy(features)
if labels is not None:
labels_tensor = torch.from_numpy(labels)
dataset = VacDataset(features_tensor, df, labels_tensor)
loader = tor... | train_df['Cabin'].value_counts().head(10 ) | Titanic - Machine Learning from Disaster |
2,249,093 | USE_FT = True
CNN_DROP = 0.1
ENC_DROP = 0.1
RNN_DROP = 0.3
LOGIT_DROP = 0.25
D = 256<concatenate> | tmp = train_df.groupby(['SibSp', 'Parch'])['Survived'].value_counts()
df = pd.DataFrame(data={'Passengers': tmp.values}, index=tmp.index ).reset_index()
hover_text = []
for index, row in df.iterrows() :
hover_text.append(( 'Sibilings: {}
'+
'Parents/Children: {}
'+
'Survived: {}
'+
'Passengers: {}' ).format(row['SibSp'... | Titanic - Machine Learning from Disaster |
2,249,093 | class Conv1dStack(nn.Module):
def __init__(self, in_dim, out_dim, kernel_size=3, padding=1, dilation=1):
super(Conv1dStack, self ).__init__()
self.conv = nn.Sequential(
nn.Conv1d(in_dim, out_dim, kernel_size=kernel_size, padding=padding, dilation=dilation, bias=False),
nn.BatchNorm1d(out_dim),
nn.Dropout(CNN_DROP),
nn... | test_df['Survived'] = None
all_df = pd.concat([train_df, test_df], axis=0 ) | Titanic - Machine Learning from Disaster |
2,249,093 | PRETRAIN = False<create_dataframe> | def encrypt_single_column(data):
le = LabelEncoder()
le.fit(data.astype(str))
return le.transform(data.astype(str)) | Titanic - Machine Learning from Disaster |
2,249,093 | features, _ = preprocess(train_df, True)
features_tensor = torch.from_numpy(features)
dataset0 = VacDataset(features_tensor, train_df, None)
features, _ = preprocess(public_df, True)
features_tensor = torch.from_numpy(features)
dataset1 = VacDataset(features_tensor, public_df, None)
features, _ = preprocess(priva... | features = ['Pclass','Sex','Embarked','SibSp','Parch']
for feature in features:
all_df[feature] = encrypt_single_column(all_df[feature] ) | Titanic - Machine Learning from Disaster |
2,249,093 | BATCH_SIZE = 64
loader0 = torch.utils.data.DataLoader(dataset0, BATCH_SIZE, shuffle=True)
loader1 = torch.utils.data.DataLoader(dataset1, BATCH_SIZE, shuffle=True)
loader2 = torch.utils.data.DataLoader(dataset2, BATCH_SIZE, shuffle=True )<find_best_model_class> | X = all_df.loc[~(all_df.Fare.isna())]
y = X['Fare'].values
X = X[features]
X_test = all_df.loc[all_df.Fare.isna() ]
X_test = X_test[features]
print(f'X: {X.shape} y: {y.shape}, X_text: {X_test.shape}' ) | Titanic - Machine Learning from Disaster |
2,249,093 | def learn_from_batch_ae(model, data):
seq = data["sequence"].clone()
seq[:, :, :14] = F.dropout2d(seq[:, :, :14], p=0.3)
target = data["sequence"][:, :, :14]
out = model(seq.to(DEVICE), data["bpp"].to(DEVICE))
loss = F.binary_cross_entropy(out, target.to(DEVICE))
return loss
def train_ae(model, train_data, optimizer, ... | clf = DecisionTreeRegressor()
clf.fit(X, y)
y_test = clf.predict(X_test ) | Titanic - Machine Learning from Disaster |
2,249,093 | set_seed(SEED )<categorify> | print(f'Fare: {y_test}' ) | Titanic - Machine Learning from Disaster |
2,249,093 | if PRETRAIN:
model = AEModel()
model = model.to(DEVICE)
optimizer = torch.optim.Adam(model.parameters() , lr=1e-3)
lr_scheduler = None
res = dict(end_epoch=0, it=0, min_loss_epoch=0)
epochs = [5, 5, 5, 5]
for e in epochs:
print(' -> Training with train data')
res = train_ae(model, loader0, optimizer, lr_scheduler, ... | all_df.loc[all_df.Fare.isna() , 'Fare'] = y_test | Titanic - Machine Learning from Disaster |
2,249,093 | CLASS_WEIGHT_5 = torch.from_numpy(np.array([1, 1, 1, 1, 1])).unsqueeze(0 ).cuda()
CLASS_WEIGHT_3 = torch.from_numpy(np.array([1, 1, 0, 1, 0])).unsqueeze(0 ).cuda()<compute_test_metric> | all_df.loc[all_df.Fare.isna() ].shape | Titanic - Machine Learning from Disaster |
2,249,093 | def mcrmse(truth, pred, verbose=0, scored_targets=[0, 1, 3], filtered=None, reduce=True):
error =(truth - pred)** 2
error = error[:, :, scored_targets]
if filtered is not None:
error = np.array([error[i] for i, kept in enumerate(filtered)if kept])
rmse = np.sqrt(error.mean(1))
if verbose:
for t, score in zip(scored_... | all_df = [train_df, test_df] | Titanic - Machine Learning from Disaster |
2,249,093 | def learn_from_batch(model, data, optimizer, lr_scheduler, class_weight, pred_len=68):
optimizer.zero_grad()
out = model(
data["sequence"].to(DEVICE),
data["bpp"].to(DEVICE),
pred_len=pred_len,
)
signal_to_noise = data["signal_to_noise"] * data["score"]
loss = sn_mcrmse_loss(
out,
data["label"].to(DEVICE),
signal_t... | for dataset in all_df:
dataset['Title'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
2,249,093 | def predict(model, loader, pred_len=68):
model.eval()
preds = np.empty(( 0, pred_len, NUM_TARGETS))
with torch.no_grad() :
for batch in loader:
y_pred = model(
batch["sequence"].cuda() ,
batch["bpp"].cuda() ,
pred_len=pred_len,
).detach()
preds = np.concatenate([preds, y_pred.cpu().numpy() ])
return preds<train_mod... | for dataset in all_df:
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
dataset['Title'] = dataset['Title'].replace('Mme', 'Mrs' ) | Titanic - Machine Learning from Disaster |
2,249,093 | def train(model, train_data, valid_data, optimizer, lr_scheduler, epochs=10, swa_first_epoch=40, class_weight=None, pred_len=68):
it = 0
for epoch in range(epochs):
t0 = time.time()
print(f"Epoch {epoch+1}/{epochs}", end='\t')
model.train()
losses = []
for i, data in enumerate(train_data):
_, loss = learn_from_batch(m... | train_df[(train_df['Title'] == 'Dr')&(train_df['Sex'] == 'female')] | Titanic - Machine Learning from Disaster |
2,249,093 | EPOCHS_1 = 30
EPOCHS_2 = 10
EPOCHS_3 = 10
EPOCHS_4 = 5
SWA_FIRST_EPOCH = 0
WARMUP_PROP = 0.05
K = 5
BATCH_SIZE = 32
LR = 5e-4
LOAD = True<drop_column> | train_df[train_df['Cabin']=='D17'] | Titanic - Machine Learning from Disaster |
2,249,093 | samples = train_df.copy().drop('score', axis=1)
ids = samples.reset_index() ["id"]
set_seed(SEED )<split> | train_df.loc[train_df.PassengerId == 797, 'Title'] = 'Mrs' | Titanic - Machine Learning from Disaster |
2,249,093 | gkf = GroupKFold(n_splits=K)
splits = list(gkf.split(X=samples, groups=groups))<categorify> | train_df[train_df['Cabin']=='D17'] | Titanic - Machine Learning from Disaster |
2,249,093 | scores = []
pred_oof = np.zeros(( len(samples), 68, NUM_TARGETS))
for fold,(train_index, test_index)in enumerate(splits):
print(f"
------------- Fold {fold + 1}/{K} -------------
")
set_seed(SEED)
df_train = samples.loc[train_index].reset_index()
df_train = augment_data(df_train)
df_val = samples.loc[test_index].res... | for dataset in all_df:
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col',\
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare' ) | Titanic - Machine Learning from Disaster |
2,249,093 | BATCH_SIZE = 64
TTA = True<load_pretrained> | train_df[['Title', 'Sex', 'Survived']].groupby(['Title', 'Sex'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
2,249,093 | 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)
pub_loader = create_loader(public_df, BATCH_SIZE, is_test=True)
pri_loader =... | for dataset in all_df:
dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1 | Titanic - Machine Learning from Disaster |
2,249,093 | pred_df_list = []
pred_public = np.zeros(( len(public_df), 107, NUM_TARGETS))
pred_private = np.zeros(( len(private_df), SEQ_LEN_PRIVATE, NUM_TARGETS))
for fold in range(K):
print(f"
------------- Fold {fold + 1}/{K} -------------
")
model_load_path = CP_PATH + f"model_{fold}.pt"
print(f' -> Loading weights from {mode... | train_df[['FamilySize', 'Survived']].groupby(['FamilySize'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
2,249,093 | def pred_to_sub(df_test, pred_public, pred_private):
sub_public = df_test[df_test['seq_scored'] == SEQ_SCORED_PUBLIC][['id']].reset_index(drop=True)
sub_private = df_test[df_test['seq_scored'] == SEQ_SCORED_PRIVATE][['id']].reset_index(drop=True)
test_preds = []
for sub, pred in [(sub_public, pred_public),(sub_privat... | for dataset in all_df:
dataset['Surname'] = dataset.Name.str.extract('([A-Za-z]+)\,', expand=False ) | Titanic - Machine Learning from Disaster |
2,249,093 | sub = pred_to_sub(test_df, pred_public, pred_private )<compute_test_metric> | tmp = train_df.groupby(['Surname'])['Survived'].value_counts()
df = pd.DataFrame(data={'Size of group with same Surname': tmp.values}, index=tmp.index ).reset_index().sort_values(['Size of group with same Surname', 'Surname'], ascending=False ) | Titanic - Machine Learning from Disaster |
2,249,093 | score = np.mean(scores)
score<save_to_csv> | tmp = df.groupby(['Size of group with same Surname'])['Survived'].value_counts()
df = pd.DataFrame(data={'Number': tmp.values}, index=tmp.index ).reset_index().sort_values(['Size of group with same Surname', 'Survived'], ascending=False)
df | Titanic - Machine Learning from Disaster |
2,249,093 | print(f'Saving submission to "{TODAY}_{score:.4f}_pl.csv"')
sub.to_csv(f"{TODAY}_{score:.4f}_pl.csv", index=False)
np.save(f"oof_{TODAY}_{score:.4f}_pl.npy", pred_oof)
sub.head()<import_modules> | for dataset in all_df:
dataset['Deck'] = dataset.Cabin.str.extract('^([A-Za-z]+)', expand=False ) | Titanic - Machine Learning from Disaster |
2,249,093 | import numpy as np
import pandas as pd
import os<load_from_csv> | train_df[['Deck', 'Survived']].groupby(['Deck'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
2,249,093 | weight_aepgc = 0.27625
sub1 = pd.read_csv('.. /input/24551-ae-gcn/submission(3 ).csv')
sub2 = pd.read_csv('.. /input/hawkey-ae-pretrained-gcn-3ensemble/submission(4 ).csv' )<load_from_csv> | for dataset in all_df:
dataset['Sex'] = dataset['Sex'].map({'female': 1, 'male': 0} ).astype(int ) | Titanic - Machine Learning from Disaster |
2,249,093 | weight_nprg = 0.27625
sub3 = pd.read_csv('.. /input/gru-5fold-2seeds-knncv-68c7e1/submission.csv')
sub4 = pd.read_csv('.. /input/fork-of-lstm-gru-5fold-2seeds-knncv-0a37d7/submission.csv')
sub5 = pd.read_csv('.. /input/lstm-5fold-2seeds-knncv-775f37/submission.csv')
sub6 = pd.read_csv('.. /input/hawkey-gcn-only-2530... | age_aprox = np.zeros(( 2,3))
for dataset in all_df:
for i in range(0, 2):
for j in range(0, 3):
aprox_age = dataset[(dataset['Sex'] == i)& \
(dataset['Pclass'] == j+1)]['Age'].dropna()
age_aprox[i,j] = aprox_age.median()
for i in range(0, 2):
for j in range(0, 3):
dataset.loc[(dataset.Age.isnull())&(dataset.Sex == i)&... | Titanic - Machine Learning from Disaster |
2,249,093 | weight_aug = 0.0975
sub9 = pd.read_csv('.. /input/aug-data-local-training-gru-lstm/aug_data_training_local.csv' )<load_from_csv> | tmp = train_df.groupby(['Title', 'Pclass'])['Survived'].value_counts()
df = pd.DataFrame(data={'Passengers': tmp.values}, index=tmp.index ).reset_index()
df | Titanic - Machine Learning from Disaster |
2,249,093 | weight_pt = 0.35
sub10 = pd.read_csv('.. /input/open-vaccine-pytorch-pretrain/submission.csv')
sub11 = pd.read_csv('.. /input/4-ae-pretrained-sin/submission_4_ae.csv' )<load_from_csv> | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in all_df:
dataset['Title'] = dataset['Title'].map(title_mapping ) | Titanic - Machine Learning from Disaster |
2,249,093 | sub12 = pd.read_csv('.. /input/blend-of-public/blend_of_public.csv' )<load_from_csv> | for dataset in all_df:
dataset.loc[ dataset['Fare'] <= 7.91, 'Fare'] = 0
dataset.loc[(dataset['Fare'] > 7.91)&(dataset['Fare'] <= 14.454), 'Fare'] = 1
dataset.loc[(dataset['Fare'] > 14.454)&(dataset['Fare'] <= 31), 'Fare'] = 2
dataset.loc[ dataset['Fare'] > 31, 'Fare'] = 3 | Titanic - Machine Learning from Disaster |
2,249,093 | final = pd.read_csv('.. /input/stanford-covid-vaccine/sample_submission.csv' ).set_index('id_seqpos')
sample_sub = pd.read_csv('.. /input/stanford-covid-vaccine/sample_submission.csv' )<filter> | for dataset in all_df:
dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0
dataset.loc[(dataset['Age'] > 16)&(dataset['Age'] <= 32), 'Age'] = 1
dataset.loc[(dataset['Age'] > 32)&(dataset['Age'] <= 48), 'Age'] = 2
dataset.loc[(dataset['Age'] > 48)&(dataset['Age'] <= 64), 'Age'] = 3
dataset.loc[ dataset['Age'] > 64, 'Age'] = 4 | Titanic - Machine Learning from Disaster |
2,249,093 | sub1 = sub1[sample_sub.columns].set_index('id_seqpos' ).loc[final.index]
sub2 = sub2[sample_sub.columns].set_index('id_seqpos' ).loc[final.index]
sub3 = sub3[sample_sub.columns].set_index('id_seqpos' ).loc[final.index]
sub4 = sub4[sample_sub.columns].set_index('id_seqpos' ).loc[final.index]
sub5 = sub5[sample_sub.colum... | for dataset in all_df:
dataset.loc[ dataset['FamilySize'] <= 1, 'FamilySize'] = 0
dataset.loc[(dataset['FamilySize'] > 1)&(dataset['FamilySize'] <= 4), 'FamilySize'] = 1
dataset.loc[ dataset['FamilySize'] > 4, 'FamilySize'] = 2 | Titanic - Machine Learning from Disaster |
2,249,093 | final =(( sub1 + sub2)/ 2 * weight_aepgc +(( sub3 + sub4 + sub5 + sub6 + sub7)/ 5 * 0.85 + sub8 * 0.15)* weight_nprg + sub9 * weight_aug +(sub10 * 0.7 + sub11 * 0.3)* weight_pt)*.93 + sub12 *.07<save_to_csv> | for dataset in all_df:
dataset['Class*Age'] = dataset['Pclass'] * dataset['Age'] | Titanic - Machine Learning from Disaster |
2,249,093 | final.to_csv('final_sub_nopp.csv' )<define_variables> | VALID_SIZE = 0.2
RANDOM_STATE = 2018
train, valid = train_test_split(train_df, test_size=VALID_SIZE, random_state=RANDOM_STATE, shuffle=True ) | Titanic - Machine Learning from Disaster |
2,249,093 | 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")},
"... | predictors = ['Sex', 'Age']
target = 'Survived' | Titanic - Machine Learning from Disaster |
2,249,093 | BASE_PATH = "/kaggle/input/stanford-covid-vaccine"
MODEL_SAVE_PATH = "/kaggle/model"
def preprocess_inputs(df, cols):
return np.concatenate([preprocess_feature_col(df, col)for col in cols], axis=2)
def preprocess_feature_col(df, col):
dic = token_dicts[col]
dic_len = len(dic)
seq_length = len(df[col][0])
ident = np.... | train_X = train[predictors]
train_Y = train[target].values
valid_X = valid[predictors]
valid_Y = valid[target].values | Titanic - Machine Learning from Disaster |
2,249,093 | class Conv1dStack(nn.Module):
def __init__(self, in_dim, out_dim, kernel_size=3, padding=1, dilation=1):
super(Conv1dStack, self ).__init__()
self.conv = nn.Sequential(
nn.Conv1d(in_dim, out_dim, kernel_size=kernel_size, padding=padding, dilation=dilation, bias=False),
nn.BatchNorm1d(out_dim),
nn.Dropout(0.1),
nn.Leak... | RFC_METRIC = 'gini'
NUM_ESTIMATORS = 100
NO_JOBS = 4 | Titanic - Machine Learning from Disaster |
2,249,093 | base_train_data = pd.read_json(str(Path(BASE_PATH)/ 'train.json'), lines=True)
base_train_data.head()
device = torch.device('cuda')
BATCH_SIZE = 64
base_train_data = pd.read_json(str(Path(BASE_PATH)/ 'train.json'), lines=True)
base_test_data = pd.read_json(str(Path(BASE_PATH)/ 'test.json'), lines=True)
public_df = ... | clf = RandomForestClassifier(n_jobs=NO_JOBS,
random_state=RANDOM_STATE,
criterion=RFC_METRIC,
n_estimators=NUM_ESTIMATORS,
verbose=False ) | Titanic - Machine Learning from Disaster |
2,249,093 | def learn_from_batch_ae(model, data, device):
seq = data["sequence"].clone()
seq[:, :, :14] = F.dropout2d(seq[:, :, :14], p=0.3)
target = data["sequence"][:, :, :14]
out = model(seq.to(device), data["bpp"].to(device))
loss = F.binary_cross_entropy(out, target.to(device))
return loss
def train_ae(model, train_data, opt... | clf.fit(train_X, train_Y ) | Titanic - Machine Learning from Disaster |
2,249,093 | set_seed(123)
shutil.rmtree("./model", True)
shutil.rmtree("./logs", True)
save_path = Path("./model_prediction")
if not save_path.exists() :
save_path.mkdir(parents=True)
lr_scheduler = None
device = "cuda" if torch.cuda.is_available() else "cpu"
model = AEModel()
model = model.to(device)
optimizer = torch.optim... | preds = clf.predict(valid_X ) | Titanic - Machine Learning from Disaster |
2,249,093 | def MCRMSE(y_true, y_pred):
colwise_mse = torch.mean(torch.square(y_true - y_pred), dim=1)
return torch.mean(torch.sqrt(colwise_mse), dim=1)
def sn_mcrmse_loss(predict, target, signal_to_noise):
loss = MCRMSE(target, predict)
weight = 0.5 * torch.log(signal_to_noise + 1.01)
loss =(loss * weight ).mean()
return loss... | clf.score(train_X, train_Y)
acc = round(clf.score(train_X, train_Y)* 100, 2)
print("RandomForest accuracy(train set):", acc ) | Titanic - Machine Learning from Disaster |
2,249,093 | device = torch.device('cuda')
BATCH_SIZE = 64
base_train_data = pd.read_json(str(Path(BASE_PATH)/ 'train.json'), lines=True)
samples = base_train_data
save_path = Path("./model_prediction")
if not save_path.exists() :
save_path.mkdir(parents=True)
shutil.rmtree("./model", True)
shutil.rmtree("./logs", True)
split... | clf.score(valid_X, valid_Y)
acc = round(clf.score(valid_X, valid_Y)* 100, 2)
print("RandomForest accuracy(validation set):", acc ) | Titanic - Machine Learning from Disaster |
2,249,093 | def predict_batch(model, data, device):
with torch.no_grad() :
pred = model(data["sequence"].to(device), data["bpp"].to(device))
pred = pred.detach().cpu().numpy()
return_values = []
ids = data["ids"]
for idx, p in enumerate(pred):
id_ = ids[idx]
assert p.shape ==(model.pred_len, len(target_cols))
for seqpos, val in en... | print(metrics.classification_report(valid_Y, preds, target_names=['Not Survived', 'Survived'])) | Titanic - Machine Learning from Disaster |
2,249,093 | device = torch.device('cuda')if torch.cuda.is_available() else "cpu"
BATCH_SIZE = 1
base_test_data = pd.read_json(str(Path(BASE_PATH)/ 'test.json'), lines=True)
public_df = base_test_data.query("seq_length == 107" ).copy()
private_df = base_test_data.query("seq_length == 130" ).copy()
print(f"public_df: {public_df.sha... | predictors = ['Sex', 'Age', 'Pclass', 'Fare']
target = 'Survived' | Titanic - Machine Learning from Disaster |
2,249,093 | import numpy as np
import pandas as pd
import os<define_variables> | train_X = train[predictors]
train_Y = train[target].values
valid_X = valid[predictors]
valid_Y = valid[target].values | Titanic - Machine Learning from Disaster |
2,249,093 | 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")},
"... | clf.fit(train_X, train_Y ) | Titanic - Machine Learning from Disaster |
2,249,093 | BASE_PATH = "/kaggle/input/stanford-covid-vaccine"
MODEL_SAVE_PATH = "/kaggle/model"
def preprocess_inputs(df, cols):
return np.concatenate([preprocess_feature_col(df, col)for col in cols], axis=2)
def preprocess_feature_col(df, col):
dic = token_dicts[col]
dic_len = len(dic)
seq_length = len(df[col][0])
ident = np.... | preds = clf.predict(valid_X ) | Titanic - Machine Learning from Disaster |
2,249,093 | class Conv1dStack(nn.Module):
def __init__(self, in_dim, out_dim, kernel_size=3, padding=1, dilation=1):
super(Conv1dStack, self ).__init__()
self.conv = nn.Sequential(
nn.Conv1d(in_dim, out_dim, kernel_size=kernel_size, padding=padding, dilation=dilation, bias=False),
nn.BatchNorm1d(out_dim),
nn.Dropout(0.1),
nn.Leak... | clf.score(train_X, train_Y)
acc = round(clf.score(train_X, train_Y)* 100, 2)
print("RandomForest accuracy(train set):", acc ) | Titanic - Machine Learning from Disaster |
2,249,093 | base_train_data = pd.read_json(str(Path(BASE_PATH)/ 'train.json'), lines=True)
base_train_data.head()
device = torch.device('cuda')
BATCH_SIZE = 64
base_train_data = pd.read_json(str(Path(BASE_PATH)/ 'train.json'), lines=True)
base_test_data = pd.read_json(str(Path(BASE_PATH)/ 'test.json'), lines=True)
public_df = ... | clf.score(valid_X, valid_Y)
acc = round(clf.score(valid_X, valid_Y)* 100, 2)
print("RandomForest accuracy(validation set):", acc ) | Titanic - Machine Learning from Disaster |
2,249,093 | def learn_from_batch_ae(model, data, device):
seq = data["sequence"].clone()
seq[:, :, :14] = F.dropout2d(seq[:, :, :14], p=0.3)
target = data["sequence"][:, :, :14]
out = model(seq.to(device), data["bpp"].to(device))
loss = F.binary_cross_entropy(out, target.to(device))
return loss
def train_ae(model, train_data, opt... | print(metrics.classification_report(valid_Y, preds, target_names=['Not Survived', 'Survived'])) | Titanic - Machine Learning from Disaster |
2,249,093 | set_seed(123)
shutil.rmtree("./model", True)
shutil.rmtree("./logs", True)
save_path = Path("./model_prediction")
if not save_path.exists() :
save_path.mkdir(parents=True)
lr_scheduler = None
device = "cuda" if torch.cuda.is_available() else "cpu"
model = AEModel()
model = model.to(device)
optimizer = torch.optim... | predictors = ['Sex', 'Age', 'Pclass', 'Fare', 'Parch', 'SibSp']
target = 'Survived' | Titanic - Machine Learning from Disaster |
2,249,093 | def MCRMSE(y_true, y_pred):
colwise_mse = torch.mean(torch.square(y_true - y_pred), dim=1)
return torch.mean(torch.sqrt(colwise_mse), dim=1)
def sn_mcrmse_loss(predict, target, signal_to_noise):
loss = MCRMSE(target, predict)
weight = 0.5 * torch.log(signal_to_noise + 1.01)
loss =(loss * weight ).mean()
return loss... | train_X = train[predictors]
train_Y = train[target].values
valid_X = valid[predictors]
valid_Y = valid[target].values | Titanic - Machine Learning from Disaster |
2,249,093 | device = torch.device('cuda')
BATCH_SIZE = 64
base_train_data = pd.read_json(str(Path(BASE_PATH)/ 'train.json'), lines=True)
samples = base_train_data
save_path = Path("./model_prediction")
if not save_path.exists() :
save_path.mkdir(parents=True)
shutil.rmtree("./model", True)
shutil.rmtree("./logs", True)
split... | clf.fit(train_X, train_Y ) | Titanic - Machine Learning from Disaster |
2,249,093 | def predict_batch(model, data, device):
with torch.no_grad() :
pred = model(data["sequence"].to(device), data["bpp"].to(device))
pred = pred.detach().cpu().numpy()
return_values = []
ids = data["ids"]
for idx, p in enumerate(pred):
id_ = ids[idx]
assert p.shape ==(model.pred_len, len(target_cols))
for seqpos, val in en... | preds = clf.predict(valid_X ) | Titanic - Machine Learning from Disaster |
2,249,093 | device = torch.device('cuda')if torch.cuda.is_available() else "cpu"
BATCH_SIZE = 1
base_test_data = pd.read_json(str(Path(BASE_PATH)/ 'test.json'), lines=True)
public_df = base_test_data.query("seq_length == 107" ).copy()
private_df = base_test_data.query("seq_length == 130" ).copy()
print(f"public_df: {public_df.sha... | clf.score(train_X, train_Y)
acc = round(clf.score(train_X, train_Y)* 100, 2)
print("RandomForest accuracy(train set):", acc ) | Titanic - Machine Learning from Disaster |
2,249,093 | pretrain_dir = None
one_fold = False
run_test = False
denoise = True
ae_epochs = 25
ae_epochs_each = 5
ae_batch_size = 32
epochs_list = [40, 15, 5, 5, 5, 8]
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_... | clf.score(valid_X, valid_Y)
acc = round(clf.score(valid_X, valid_Y)* 100, 2)
print("RandomForest accuracy(validation set):", acc ) | Titanic - Machine Learning from Disaster |
2,249,093 | 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... | print(metrics.classification_report(valid_Y, preds, target_names=['Not Survived', 'Survived'])) | Titanic - Machine Learning from Disaster |
2,249,093 | 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... | predictors = ['Sex', 'Age', 'Pclass', 'Fare', 'Parch', 'SibSp', 'FamilySize', 'Title']
target = 'Survived' | Titanic - Machine Learning from Disaster |
2,249,093 | 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_X = train[predictors]
train_Y = train[target].values
valid_X = valid[predictors]
valid_Y = valid[target].values | Titanic - Machine Learning from Disaster |
2,249,093 | 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... | clf.fit(train_X, train_Y ) | Titanic - Machine Learning from Disaster |
2,249,093 | 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"... | preds = clf.predict(valid_X ) | Titanic - Machine Learning from Disaster |
2,249,093 | 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 =... | clf.score(train_X, train_Y)
acc = round(clf.score(train_X, train_Y)* 100, 2)
print("RandomForest accuracy(train set):", acc ) | Titanic - Machine Learning from Disaster |
2,249,093 | 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.... | clf.score(valid_X, valid_Y)
acc = round(clf.score(valid_X, valid_Y)* 100, 2)
print("RandomForest accuracy(validation set):", acc ) | Titanic - Machine Learning from Disaster |
2,249,093 | 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... | print(metrics.classification_report(valid_Y, preds, target_names=['Not Survived', 'Survived'])) | Titanic - Machine Learning from Disaster |
2,249,093 | 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])]
... | predictors = ['FamilySize', 'Title', 'Class*Age']
target = 'Survived' | Titanic - Machine Learning from Disaster |
2,249,093 | 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_X = train[predictors]
train_Y = train[target].values
valid_X = valid[predictors]
valid_Y = valid[target].values | Titanic - Machine Learning from Disaster |
2,249,093 | os.environ['CUDA_VISIBLE_DEVICES'] = '0'
def allocate_gpu_memory(gpu_number=0):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if physical_devices:
try:
print("Found {} GPU(s)".format(len(physical_devices)))
tf.config.set_visible_devices(physical_devices[gpu_number], 'GPU')
tf.config.experime... | rf_clf = clf.fit(train_X, train_Y ) | Titanic - Machine Learning from Disaster |
2,249,093 | token2int = {x:i for i, x in enumerate('().ACGUBEHIMSX')}
pred_cols = ['reactivity', 'deg_Mg_pH10', 'deg_pH10', 'deg_Mg_50C', 'deg_50C']
def rmse(y_actual, y_pred):
mse = tf.keras.losses.mean_squared_error(y_actual, y_pred)
return K.sqrt(mse)
def mcrmse(y_actual, y_pred, num_scored=len(pred_cols)) :
score = 0
for i i... | preds = clf.predict(valid_X ) | Titanic - Machine Learning from Disaster |
2,249,093 | def gru_layer(hidden_dim, dropout):
return L.Bidirectional(L.GRU(hidden_dim, dropout=dropout, return_sequences=True, kernel_initializer = 'orthogonal'))
def lstm_layer(hidden_dim, dropout):
return L.Bidirectional(L.LSTM(hidden_dim, dropout=dropout, return_sequences=True, kernel_initializer = 'orthogonal'))
def build_mo... | clf.score(train_X, train_Y)
acc = round(clf.score(train_X, train_Y)* 100, 2)
print("RandomForest accuracy(train set):", acc ) | Titanic - Machine Learning from Disaster |
2,249,093 | device = torch.device('cuda:%s'%0 if torch.cuda.is_available() else 'cpu')
def Init_params(shape,w=None,b=None):
if w is None:
w = torch.nn.Parameter(torch.empty(*shape))
nn.init.xavier_uniform_(w)
else:
w = torch.nn.Parameter(w)
if b is None:
b = torch.nn.Parameter(torch.zeros(shape[1]))
else:
b = torch.nn.Paramete... | clf.score(valid_X, valid_Y)
acc = round(clf.score(valid_X, valid_Y)* 100, 2)
print("RandomForest accuracy(validation set):", acc ) | Titanic - Machine Learning from Disaster |
2,249,093 | x = preprocess_inputs(train[:1])
cate_x = torch.LongTensor(x[:,:,:3] ).to(device)
cont_x = torch.Tensor(x[:,:,3:] ).to(device)
y = np.array(train[:1][pred_cols].values.tolist() ).transpose(( 0, 2, 1))<predict_on_test> | print(metrics.classification_report(valid_Y, preds, target_names=['Not Survived', 'Survived'])) | Titanic - Machine Learning from Disaster |
2,249,093 | keras_y = keras_model.predict(x)
keras_y<predict_on_test> | test_X = test_df[predictors]
pred_Y = clf.predict(test_X ) | Titanic - Machine Learning from Disaster |
2,249,093 | pytorch_model.eval()
pytorch_y = pytorch_model(cate_x,cont_x ).detach().cpu().numpy()
pytorch_y<compute_test_metric> | submission = pd.DataFrame({"PassengerId": test_df["PassengerId"],"Survived": pred_Y})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
2,249,093 | np.mean(np.abs(keras_y-pytorch_y[:,:68,:]))<load_pretrained> | rf_clf = clf.fit(train_X, train_Y ) | Titanic - Machine Learning from Disaster |
2,249,093 | gkf = GroupKFold(n_splits=5)
keras_predict = []
pytorch_predict = []
targets = []
for fold,(train_index, valid_index)in enumerate(gkf.split(train, train['reactivity'], train['cluster_id'])) :
keras_model.load_weights('.. /input/gru-lstm-with-feature-engineering-and-augmentation/modelGRU_LSTM1_cv%s.h5'%fold)
t_valid =... | parameters = {
'n_estimators':(50, 75,100),
'max_features':('auto', 'sqrt'),
'max_depth':(3,4,5),
'min_samples_split':(2,5,10),
'min_samples_leaf':(1,2,3)
} | Titanic - Machine Learning from Disaster |
2,249,093 | for i in range(5):
print('fold %s output difference between Keras and Pytorch:'%i,np.mean(np.abs(keras_predict[i]-pytorch_predict[i])) )<compute_test_metric> | %%time
gs_clf = GridSearchCV(rf_clf, parameters, n_jobs=-1, cv = 5, verbose = 5)
gs_clf = gs_clf.fit(train_X, train_Y ) | Titanic - Machine Learning from Disaster |
2,249,093 | def Metric(target,pred):
metric = 0
for i in range(target.shape[-1]):
metric +=(np.sqrt(np.mean(( target[:,:,i]-pred[:,:,i])**2)) /target.shape[-1])
return metric<compute_test_metric> | print('Best scores:',gs_clf.best_score_)
print('Best params:',gs_clf.best_params_ ) | Titanic - Machine Learning from Disaster |
2,249,093 | for i in range(5):
print('fold %s'%i,'|','metric of keras outputs:%.6f'%Metric(targets[i],keras_predict[i]),'|','metric of pytorch outputs:%.6f'%Metric(targets[i],pytorch_predict[i]))<compute_test_metric> | preds = gs_clf.predict(valid_X ) | Titanic - Machine Learning from Disaster |
2,249,093 | def rmse(y_actual, y_pred):
mse = tf.keras.losses.mean_squared_error(y_actual, y_pred)
return K.sqrt(mse)
def mcrmse(y_actual, y_pred, num_scored=5):
score = 0
for i in range(num_scored):
score += rmse(y_actual[:, :, i], y_pred[:, :, i])/ num_scored
return score
for i in range(5):
print('fold %s'%i,mcrmse(targets[i],... | clf.score(valid_X, valid_Y)
acc = round(clf.score(valid_X, valid_Y)* 100, 2)
print("RandomForest accuracy(validation set):", acc ) | Titanic - Machine Learning from Disaster |
2,249,093 | for i in range(5):
print('fold %s'%i,K.mean(mcrmse(targets[i],keras_predict[i])) )<create_dataframe> | print(metrics.classification_report(valid_Y, preds, target_names=['Not Survived', 'Survived'])) | Titanic - Machine Learning from Disaster |
2,249,093 | def Pred(df):
test_x = preprocess_inputs(df)
test_cate_x = torch.LongTensor(test_x[:,:,:3])
test_cont_x = torch.Tensor(test_x[:,:,3:])
test_data = TensorDataset(test_cate_x,test_cont_x)
test_data_loader = DataLoader(dataset=test_data,shuffle=False,batch_size=64,num_workers=1)
all_id = []
for i,row in df.iterrows()... | test_X = test_df[predictors]
pred_Y = gs_clf.predict(test_X ) | Titanic - Machine Learning from Disaster |
2,249,093 | pytorch_sub = pytorch_sub.sort_values(by=['id_seqpos'] ).reset_index(drop=True )<load_from_csv> | submission = pd.DataFrame({"PassengerId": test_df["PassengerId"],"Survived": pred_Y})
submission.to_csv('submission_hyperparam_optimization.csv', index=False ) | Titanic - Machine Learning from Disaster |
2,249,093 | keras_sub = pd.read_csv('.. /input/gru-lstm-with-feature-engineering-and-augmentation/submission.csv' )<sort_values> | NUMBER_KFOLDS = 5
kf = KFold(n_splits = NUMBER_KFOLDS, random_state = RANDOM_STATE, shuffle = True ) | Titanic - Machine Learning from Disaster |
2,249,093 | keras_sub = keras_sub.sort_values(by=['id_seqpos'] ).reset_index(drop=True )<compute_test_metric> | class SklearnBasicClassifier(object):
def __init__(self, clf, seed=2018, params=None):
params['random_state'] = seed
self.clf = clf(**params)
def train(self, x_train, y_train):
self.clf.fit(x_train, y_train)
def predict(self, x):
return self.clf.predict(x)
def fit(self,x,y):
return self.clf.fit(x,y)
def feature_imp... | Titanic - Machine Learning from Disaster |
2,249,093 | np.mean(np.abs(keras_sub[pred_cols].values-pytorch_sub[pred_cols].values))<save_to_csv> | ntrain = train_df.shape[0]
ntest = test_df.shape[0]
def get_oof_predictions(clf, x_train, y_train, x_test):
oof_train = np.zeros(( ntrain,))
oof_test = np.zeros(( ntest,))
oof_test_skf = np.empty(( NUMBER_KFOLDS, ntest))
for i,(train_idx, valid_idx)in enumerate(kf.split(train_df)) :
clf.train(x_train[train_idx], y_trai... | Titanic - Machine Learning from Disaster |
2,249,093 | pytorch_sub.to_csv('./submission.csv',index=False )<set_options> | ada_params = {
'n_estimators': 200,
'learning_rate' : 0.75
}
cat_params = {
'iterations': 150,
'learning_rate': 0.02,
'depth': 12,
'bagging_temperature':0.2,
'od_type':'Iter',
'metric_period':400,
}
ext_params = {
'n_jobs': -1,
'n_estimators':100,
'max_depth': 8,
'min_samples_leaf': 3,
'verbose': 0
}
gbm_params = {
'n_... | Titanic - Machine Learning from Disaster |
2,249,093 | os.environ['CUDA_VISIBLE_DEVICES'] = '0'
def allocate_gpu_memory(gpu_number=0):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if physical_devices:
try:
print("Found {} GPU(s)".format(len(physical_devices)))
tf.config.set_visible_devices(physical_devices[gpu_number], 'GPU')
tf.config.experime... | ada = SklearnBasicClassifier(clf=AdaBoostClassifier, seed=RANDOM_STATE, params=ada_params)
cat = SklearnBasicClassifier(clf=CatBoostClassifier, seed=RANDOM_STATE, params=cat_params)
ext = SklearnBasicClassifier(clf=ExtraTreesClassifier, seed=RANDOM_STATE, params=ext_params)
gbm = SklearnBasicClassifier(clf=GradientB... | Titanic - Machine Learning from Disaster |
2,249,093 | def gru_layer(hidden_dim, dropout):
return L.Bidirectional(L.GRU(hidden_dim, dropout=dropout, return_sequences=True, kernel_initializer = 'orthogonal'))
def lstm_layer(hidden_dim, dropout):
return L.Bidirectional(L.LSTM(hidden_dim, dropout=dropout, return_sequences=True, kernel_initializer = 'orthogonal'))
def build_mo... | predictors = ['FamilySize', 'Title', 'Class*Age']
target = 'Survived' | Titanic - Machine Learning from Disaster |
2,249,093 | token2int = {x:i for i, x in enumerate('().ACGUBEHIMSX')}
pred_cols = ['reactivity', 'deg_Mg_pH10', 'deg_pH10', 'deg_Mg_50C', 'deg_50C']
def preprocess_inputs(df, cols=['sequence', 'structure', 'predicted_loop_type']):
base_fea = np.transpose(
np.array(
df[cols]
.applymap(lambda seq: [token2int[x] for x in seq])
.va... | y_train = train_df['Survived'].values
train = train_df[predictors]
test = test_df[predictors]
x_train = train.values
x_test = test.values | Titanic - Machine Learning from Disaster |
2,249,093 | train = pd.read_json('.. /input/stanford-covid-vaccine/train.json', lines=True)
test = pd.read_json('.. /input/stanford-covid-vaccine/test.json', lines=True )<load_pretrained> | print("Start training")
ada_oof_train, ada_oof_test = get_oof_predictions(ada, x_train, y_train, x_test)
print("End AdaBoost")
cat_oof_train, cat_oof_test = get_oof_predictions(cat, x_train, y_train, x_test)
print("End CatBoost")
ext_oof_train, ext_oof_test = get_oof_predictions(ext, x_train, y_train, x_test)
pri... | Titanic - Machine Learning from Disaster |
2,249,093 | 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" ).max(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}.... | ada_feature_importance = ada.get_feature_importances(x_train,y_train)
cat_feature_importance = cat.get_feature_importances(x_train,y_train)
ext_feature_importance = ext.get_feature_importances(x_train,y_train)
gbm_feature_importance = gbm.get_feature_importances(x_train,y_train)
rfo_feature_importance = rfo.get_fea... | Titanic - Machine Learning from Disaster |
2,249,093 | kmeans_model = KMeans(n_clusters=200, random_state=110 ).fit(preprocess_inputs(train)[:,:,0])
train['cluster_id'] = kmeans_model.labels_<load_from_csv> | base_predictions_train = pd.DataFrame({
'AdaBoost': ada_oof_train.ravel() ,
'CatBoost': cat_oof_train.ravel() ,
'ExtraTrees': ext_oof_train.ravel() ,
'GradientBoost': gbm_oof_train.ravel() ,
'RandomForest': rfo_oof_train.ravel() ,
'SVM': svc_oof_train.ravel()
})
base_predictions_train.head(10 ) | Titanic - Machine Learning from Disaster |
2,249,093 | aug_df = pd.read_csv(aug_data)
display(aug_df.head() )<merge> | x_train = np.concatenate(( ada_oof_train, cat_oof_train, ext_oof_train, gbm_oof_train, rfo_oof_train, svc_oof_train), axis=1)
x_test = np.concatenate(( ada_oof_test, cat_oof_test, ext_oof_test, gbm_oof_test, rfo_oof_test, svc_oof_test), axis=1 ) | Titanic - Machine Learning from Disaster |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.