kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,509,209 | def prep_data(start, end):
praq_train = pq.read_pandas('.. /input/train.parquet', columns=[str(i)for i in range(start, end)] ).to_pandas()
X = []
y = []
for id_measurement in tqdm(df_train.index.levels[0].unique() [int(start/3):int(end/3)]):
X_signal = []
for phase in [0,1,2]:
signal_id, target = df_train.loc[id_measur... | df = pd.read_csv("/kaggle/input/titanic/train.csv")
df | Titanic - Machine Learning from Disaster |
14,509,209 | X = []
y = []
def load_all() :
total_size = len(df_train)
for ini, end in [(0, int(total_size/2)) ,(int(total_size/2), total_size)]:
X_temp, y_temp = prep_data(ini, end)
X.append(X_temp)
y.append(y_temp)
load_all()
X = np.concatenate(X)
y = np.concatenate(y )<normalization> | test = pd.read_csv(".. /input/titanic/test.csv")
test | Titanic - Machine Learning from Disaster |
14,509,209 | def petrosian_fd(x):
n = len(x)
diff = np.ediff1d(x)
N_delta =(diff[1:-1] * diff[0:-2] < 0 ).sum()
return np.log10(n)/(np.log10(n)+ np.log10(n /(n + 0.4 * N_delta)))
def katz_fd(x):
x = np.array(x)
dists = np.abs(np.ediff1d(x))
ll = dists.sum()
ln = np.log10(np.divide(ll, dists.mean()))
aux_d = x - x[0]
d = np.... | for col in df.columns:
print(str(col)+ ":" + str(len(df[col].unique())) ) | Titanic - Machine Learning from Disaster |
14,509,209 | def _embed(x, order=3, delay=1):
N = len(x)
if order * delay > N:
raise ValueError("Error: order * delay should be lower than x.size")
if delay < 1:
raise ValueError("Delay has to be at least 1.")
if order < 2:
raise ValueError("Order has to be at least 2.")
Y = np.zeros(( order, N -(order - 1)* delay))
for i in ... | df["Age"].dropna() | Titanic - Machine Learning from Disaster |
14,509,209 | def entropy_and_fractal_dim(x):
return [perm_entropy(x), svd_entropy(x), app_entropy(x), sample_entropy(x), petrosian_fd(x), katz_fd(x), higuchi_fd(x)]<categorify> | dmean = df["Age"].dropna().mean()
dmean | Titanic - Machine Learning from Disaster |
14,509,209 | signals = X.reshape(( len(X), X.shape[1]*X.shape[2]))
features = []
for signal in signals:
features.append(entropy_and_fractal_dim(signal))<normalization> | df["Age"] = df["Age"].fillna(dmean ) | Titanic - Machine Learning from Disaster |
14,509,209 | features = np.array(features ).reshape(( len(features), 7))
scaler = MinMaxScaler(feature_range=(0, 1))
scaler.fit(features)
features = scaler.transform(features )<choose_model_class> | test["Age"] = test["Age"].fillna(dmean ) | Titanic - Machine Learning from Disaster |
14,509,209 | def model_lstm(input_shape, feat_shape):
inp = Input(shape=(input_shape[1], input_shape[2],))
feat = Input(shape=(feat_shape[1],))
bi_lstm = Bidirectional(CuDNNLSTM(128, return_sequences=True), merge_mode='concat' )(inp)
bi_gru = Bidirectional(CuDNNGRU(64, return_sequences=True), merge_mode='concat' )(bi_lstm)
attent... | from sklearn.preprocessing import LabelEncoder | Titanic - Machine Learning from Disaster |
14,509,209 | splits = list(StratifiedKFold(n_splits=N_SPLITS, shuffle=True, random_state=10 ).split(X, y))
preds_val = []
y_val = []
for idx,(train_idx, val_idx)in enumerate(splits):
K.clear_session()
print("Beginning fold {}".format(idx+1))
train_X, train_feat, train_y, val_X, val_feat, val_y = X[train_idx], features[train_idx], y... | le=LabelEncoder()
le.fit(df["Sex"])
df["Sex"] = le.transform(df["Sex"])
test["Sex"] = le.transform(test["Sex"] ) | Titanic - Machine Learning from Disaster |
14,509,209 | def threshold_search(y_true, y_proba):
best_threshold = 0
best_score = 0
for threshold in tqdm([i * 0.01 for i in range(100)]):
score = K.eval(matthews_correlation(
K.variable(y_true.astype("float64")) , K.variable(( y_proba > threshold ).astype("float64"))))
if score > best_score:
best_threshold = threshold
best_scor... | dfall = pd.concat([df,test],axis=0)
dfall | Titanic - Machine Learning from Disaster |
14,509,209 | optimal_values = threshold_search(y_val, preds_val)
best_threshold = optimal_values['threshold']
best_score = optimal_values['matthews_correlation']<compute_test_metric> | dfall2 = pd.get_dummies(dfall["Embarked"],dummy_na=True)
dfall2 | Titanic - Machine Learning from Disaster |
14,509,209 | print("Optimal Threshold : " + str(best_threshold))
print("Best Matthews Correlation : " + str(best_score))<load_from_csv> | dfall = pd.concat([dfall,dfall2],axis=1)
dfall | Titanic - Machine Learning from Disaster |
14,509,209 | %%time
meta_test = pd.read_csv('.. /input/metadata_test.csv' )<drop_column> | train = dfall.iloc[:len(df),:]
test = dfall.iloc[len(df):,:] | Titanic - Machine Learning from Disaster |
14,509,209 | meta_test = meta_test.set_index(['signal_id'])
meta_test.head()<define_variables> | from sklearn import preprocessing
from sklearn.metrics import accuracy_score
from sklearn.model_selection import StratifiedKFold | Titanic - Machine Learning from Disaster |
14,509,209 | %%time
first_sig = meta_test.index[0]
n_parts = 10
max_line = len(meta_test)
part_size = int(max_line / n_parts)
last_part = max_line % n_parts
print(first_sig, n_parts, max_line, part_size, last_part, n_parts * part_size + last_part)
start_end = [[x, x+part_size] for x in range(first_sig, max_line + first_sig, part... | folds = train.copy()
Fold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
for n,(train_index, val_index)in enumerate(Fold.split(folds, folds["Survived"])) :
folds.loc[val_index, 'fold'] = int(n)
folds['fold'] = folds['fold'].astype(int)
print(folds.groupby(['fold', "Survived"] ).size() ) | Titanic - Machine Learning from Disaster |
14,509,209 | X_test_input = np.asarray([np.concatenate([X_test[i][3],X_test[i+1][3], X_test[i+2][3]], axis=1)for i in range(0,len(X_test), 3)])
np.save("X_test.npy",X_test_input)
X_test_input.shape<normalization> | p_train = folds[folds["fold"] != 0]
p_val = folds[folds["fold"] == 0] | Titanic - Machine Learning from Disaster |
14,509,209 | signals = X_test_input.reshape(( len(X_test_input), X_test_input.shape[1]*X_test_input.shape[2]))
features_test = []
for signal in signals:
features_test.append(entropy_and_fractal_dim(signal))<normalization> | p_train = p_train.reset_index(drop=True)
p_val = p_val.reset_index(drop=True ) | Titanic - Machine Learning from Disaster |
14,509,209 | features_test = np.array(features_test ).reshape(( len(features_test), 7))
features_test = scaler.transform(features_test)
np.save("features_test.npy",features_test )<load_from_csv> | import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset | Titanic - Machine Learning from Disaster |
14,509,209 | submission = pd.read_csv('.. /input/sample_submission.csv')
print(len(submission))
submission.head()<predict_on_test> | FEATURES = ["Pclass","Sex","Age","SibSp","Parch","C","Q","S",np.nan]
TARGET = "Survived" | Titanic - Machine Learning from Disaster |
14,509,209 | preds_test = []
for i in range(N_SPLITS):
model.load_weights('weights_{}.h5'.format(i))
pred = model.predict([X_test_input, features_test], batch_size=300, verbose=1)
pred_3 = []
for pred_scalar in pred:
for i in range(3):
pred_3.append(pred_scalar)
preds_test.append(pred_3 )<data_type_conversions> | train_X = np.array(p_train[FEATURES])
train_Y = np.array(p_train[TARGET])
val_X = np.array(p_val[FEATURES])
val_Y = np.array(p_val[TARGET] ) | Titanic - Machine Learning from Disaster |
14,509,209 | preds_test =(np.squeeze(np.mean(preds_test, axis=0)) > best_threshold ).astype(np.int)
preds_test.shape<save_to_csv> | scaler = StandardScaler()
scaler.fit(train_X)
train_X = scaler.transform(train_X)
val_X = scaler.transform(val_X ) | Titanic - Machine Learning from Disaster |
14,509,209 | submission['target'] = preds_test
submission.to_csv('submission.csv', index=False)
submission.head()<import_modules> | train_X = torch.from_numpy(train_X ).float()
train_Y = torch.from_numpy(train_Y ).long()
val_X = torch.from_numpy(val_X ).float()
val_Y = torch.from_numpy(val_Y ).long() | Titanic - Machine Learning from Disaster |
14,509,209 | import pandas as pd
import pyarrow.parquet as pq
import os
import numpy as np
from joblib import Parallel, delayed
import tensorflow as tf
from tensorflow import set_random_seed
from keras.layers import *
from keras.models import Model
from tqdm import tqdm
from sklearn.model_selection import train_test_split
from skle... | train_dataset = TensorDataset(train_X,train_Y)
val_dataset = TensorDataset(val_X,val_Y ) | Titanic - Machine Learning from Disaster |
14,509,209 | N_SPLITS = 5
sample_size = 800000
MAX_THREADS = 2
RANDOM_SEED = 2019<define_variables> | train_dataloader = DataLoader(train_dataset,batch_size=128,shuffle = True)
val_dataloader = DataLoader(val_dataset,batch_size=32,shuffle = False ) | Titanic - Machine Learning from Disaster |
14,509,209 | np.random.seed(RANDOM_SEED)
set_random_seed(RANDOM_SEED )<normalization> | for a in train_dataloader:
print(a)
break | Titanic - Machine Learning from Disaster |
14,509,209 | class StatefullMCC(Layer):
def __init__(self, thresholds, **kwargs):
super(StatefullMCC, self ).__init__(**kwargs)
self.thresholds = thresholds
self.stateful = True
self.name='matthews_correlation'
def reset_states(self):
K.get_session().run(tf.variables_initializer(self.local_variable))
def metric_variable(self, shap... | class Net(nn.Module):
def __init__(self):
super(Net,self ).__init__()
self.fc1 = nn.Linear(len(FEATURES),512)
self.fc2 = nn.Linear(512,256)
self.fc3 = nn.Linear(256,2)
def forward(self,x):
x= F.relu(self.fc1(x))
x= F.relu(self.fc2(x))
x = self.fc3(x)
return x | Titanic - Machine Learning from Disaster |
14,509,209 | class Attention(Layer):
def __init__(self, step_dim,
W_regularizer=None, b_regularizer=None,
W_constraint=None, b_constraint=None,
bias=True, **kwargs):
self.supports_masking = True
self.init = initializers.glorot_uniform(RANDOM_SEED)
self.W_regularizer = regularizers.get(W_regularizer)
self.b_regularizer = regulariz... | model=Net()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters() , lr=0.01 ) | Titanic - Machine Learning from Disaster |
14,509,209 | df_train = pd.read_csv('.. /input/metadata_train.csv')
df_train = df_train.set_index(['id_measurement', 'phase'])
df_train.head()<load_from_csv> | total_loss = 0
model.train()
for train_x,train_y in train_dataloader:
print(train_x)
print(train_y)
train_x, train_y = Variable(train_x),Variable(train_y)
optimizer.zero_grad()
output = model(train_x)
loss = criterion(output,train_y)
loss.backward()
optimizer.step()
total_loss += loss.item()
break | Titanic - Machine Learning from Disaster |
14,509,209 | def get_features(dataset='train', split_parts=10):
if dataset == 'train':
cache_file = 'X.npy'
meta_file = '.. /input/metadata_train.csv'
elif dataset == 'test':
cache_file = 'X_test.npy'
meta_file = '.. /input/metadata_test.csv'
if os.path.isfile(cache_file):
X = np.load(cache_file)
y = None
if dataset == 'train':
y ... | def training(train_dataloader,model):
total_loss = 0
model.train()
for train_x,train_y in train_dataloader:
train_x, train_y = Variable(train_x),Variable(train_y)
optimizer.zero_grad()
output = model(train_x)
loss = criterion(output,train_y)
loss.backward()
optimizer.step()
total_loss += loss.item()
return model,tot... | Titanic - Machine Learning from Disaster |
14,509,209 | max_num = 127
min_num = -128<categorify> | total_valloss = 0
model.eval()
with torch.no_grad() :
for val_x,val_y in val_dataloader:
output = model(val_x)
valloss = criterion(output,val_y)
total_valloss += valloss.item() | Titanic - Machine Learning from Disaster |
14,509,209 | def min_max_transf(ts, min_data, max_data, range_needed=(-1,1)) :
if min_data < 0:
ts_std =(ts + abs(min_data)) /(max_data + abs(min_data))
else:
ts_std =(ts - min_data)/(max_data - min_data)
if range_needed[0] < 0:
return ts_std *(range_needed[1] + abs(range_needed[0])) + range_needed[0]
else:
return ts_std *(range_n... | def valeval(val_dataloader,model):
total_valloss = 0
model.eval()
with torch.no_grad() :
for val_x,val_y in val_dataloader:
output = model(val_x)
valloss = criterion(output,val_y)
total_valloss += valloss.item()
return total_valloss | Titanic - Machine Learning from Disaster |
14,509,209 | def transform_ts(ts, n_dim=160, min_max=(-1,1)) :
ts_std = min_max_transf(ts, min_data=min_num, max_data=max_num)
bucket_size = int(sample_size / n_dim)
new_ts = []
for i in range(0, sample_size, bucket_size):
ts_range = ts_std[i:i + bucket_size]
mean = ts_range.mean()
std = ts_range.std()
std_top = mean + std
std_bo... | all_trainloss = []
all_valloss = []
model=Net()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters() , lr=0.01)
for epoch in tqdm(range(1000)) :
model,trainloss = training(train_dataloader,model)
all_trainloss.append(trainloss)
valloss = valeval(val_dataloader,model)
all_valloss.append(v... | Titanic - Machine Learning from Disaster |
14,509,209 | def prep_data(signal_ids, dataset="train"):
signal_ids_all = np.concatenate(signal_ids)
if dataset == "train":
praq_data = pq.read_pandas('.. /input/train.parquet', columns=[str(i)for i in signal_ids_all] ).to_pandas()
elif dataset == "test":
praq_data = pq.read_pandas('.. /input/test.parquet', columns=[str(i)for i in... | train_preds = model(train_X)
train_preds[:3] | Titanic - Machine Learning from Disaster |
14,509,209 | X, y = get_features("train", split_parts=6 )<choose_model_class> | train_preds2 = torch.max(train_preds.data,1)[1]
train_preds2[:3] | Titanic - Machine Learning from Disaster |
14,509,209 | def model_lstm(input_shape):
inp = Input(shape=(input_shape[1], input_shape[2],))
init_glorot_uniform = initializers.glorot_uniform(seed=RANDOM_SEED)
init_orthogonal = initializers.orthogonal(seed=RANDOM_SEED)
x = Bidirectional(CuDNNLSTM(128, return_sequences=True, kernel_initializer=init_glorot_uniform, recurrent_in... | p_train["preds"] = train_preds2
p_train | Titanic - Machine Learning from Disaster |
14,509,209 | splits = list(StratifiedKFold(n_splits=N_SPLITS, shuffle=True, random_state=RANDOM_SEED ).split(X, y))
preds_val = []
y_val = []
for idx,(train_idx, val_idx)in enumerate(splits):
K.clear_session()
print("Beginning fold {}".format(idx+1))
train_X, train_y, val_X, val_y = X[train_idx], y[train_idx], X[val_idx], y[val_idx... | p_train["judge"] = p_train["Survived"] == p_train["preds"]
p_train | Titanic - Machine Learning from Disaster |
14,509,209 | def threshold_search(y_true, y_proba):
thresholds = np.linspace(0.0,1.0,101)
scores = [matthews_corrcoef(y_true,(y_proba > t ).astype(np.uint8)) for t in thresholds]
best_idx = np.argmax(scores)
return thresholds[best_idx], scores[best_idx]<compute_test_metric> | accuracy_score(train_Y,train_preds2 ) | Titanic - Machine Learning from Disaster |
14,509,209 | best_threshold, best_score = threshold_search(y_val, preds_val)
print(best_threshold, best_score )<load_from_csv> | def calc_accuracy(x,y,model):
preds = model(x)
preds2 = torch.max(preds.data,1)[1]
return accuracy_score(y,preds2)
| Titanic - Machine Learning from Disaster |
14,509,209 | %%time
meta_test = pd.read_csv('.. /input/metadata_test.csv' )<drop_column> | calc_accuracy(train_X,train_Y,model ) | Titanic - Machine Learning from Disaster |
14,509,209 | meta_test = meta_test.set_index(['signal_id'])
meta_test.head()<prepare_x_and_y> | calc_accuracy(val_X,val_Y,model ) | Titanic - Machine Learning from Disaster |
14,509,209 | %%time
X_test_input, _ = get_features("test" )<load_from_csv> | all_trainloss = []
all_valloss = []
all_trainscore = []
all_valscore = []
bestscore = None
model=Net()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters() , lr=0.01)
for epoch in tqdm(range(1000)) :
model,trainloss = training(train_dataloader,model)
all_trainloss.append(trainloss)
vallos... | Titanic - Machine Learning from Disaster |
14,509,209 | submission = pd.read_csv('.. /input/sample_submission.csv')
print(len(submission))
submission.head()<predict_on_test> | state = torch.load("./model1.pth" ) | Titanic - Machine Learning from Disaster |
14,509,209 | preds_test = []
for i in range(N_SPLITS):
model.load_weights('weights_{}.h5'.format(i))
pred = model.predict(X_test_input, batch_size=300, verbose=1)
pred_3 = []
for pred_scalar in pred:
for i in range(3):
pred_3.append(pred_scalar)
preds_test.append(pred_3)
<data_type_conversions> | model.load_state_dict(state["state_dict"] ) | Titanic - Machine Learning from Disaster |
14,509,209 | preds_test =(np.squeeze(np.mean(preds_test, axis=0)) > best_threshold ).astype(np.int)
preds_test.shape<save_to_csv> | submission = pd.read_csv(".. /input/titanic/gender_submission.csv")
submission | Titanic - Machine Learning from Disaster |
14,509,209 | submission['target'] = preds_test
submission.to_csv('submission.csv', index=False)
submission.head()<import_modules> | test_X = test[FEATURES]
test_X | Titanic - Machine Learning from Disaster |
14,509,209 | import pandas as pd
import pyarrow.parquet as pq
import os
import numpy as np
from keras.layers import *
from keras.models import Model
from tqdm import tqdm
from sklearn.model_selection import train_test_split
from keras import backend as K
from keras import optimizers
from sklearn.model_selection import GridSearchCV,... | test_X = np.array(test[FEATURES])
test_X = scaler.transform(test_X)
test_X = torch.from_numpy(test_X ).float() | Titanic - Machine Learning from Disaster |
14,509,209 | N_SPLITS = 5
sample_size = 800000<compute_test_metric> | preds = model(test_X ) | Titanic - Machine Learning from Disaster |
14,509,209 | def matthews_correlation(y_true, y_pred):
y_pred_pos = K.round(K.clip(y_pred, 0, 1))
y_pred_neg = 1 - y_pred_pos
y_pos = K.round(K.clip(y_true, 0, 1))
y_neg = 1 - y_pos
tp = K.sum(y_pos * y_pred_pos)
tn = K.sum(y_neg * y_pred_neg)
fp = K.sum(y_neg * y_pred_pos)
fn = K.sum(y_pos * y_pred_neg)
numerator =(tp * tn -... | preds2 = torch.max(preds.data,1)[1] | Titanic - Machine Learning from Disaster |
14,509,209 | class Attention(Layer):
def __init__(self, step_dim,
W_regularizer=None, b_regularizer=None,
W_constraint=None, b_constraint=None,
bias=True, **kwargs):
self.supports_masking = True
self.init = initializers.get('glorot_uniform')
self.W_regularizer = regularizers.get(W_regularizer)
self.b_regularizer = regularizers.ge... | submission["Survived"] = preds2 | Titanic - Machine Learning from Disaster |
14,509,209 | df_train = pd.read_csv('.. /input/metadata_train.csv')
df_train = df_train.set_index(['id_measurement', 'phase'])
df_train.head()<define_variables> | submission.to_csv("submission1.csv",index = False ) | Titanic - Machine Learning from Disaster |
14,509,209 | max_num = 127
min_num = -128<categorify> | bestscores = []
for fold in range(5):
trn_idx = folds[folds['fold'] != fold].index
val_idx = folds[folds['fold'] == fold].index
train_folds = folds.loc[trn_idx].reset_index(drop=True)
valid_folds = folds.loc[val_idx].reset_index(drop=True)
model=Net()
p_train = train_folds.copy()
p_val = valid_folds.copy()
criterion ... | Titanic - Machine Learning from Disaster |
14,509,209 | def min_max_transf(ts, min_data, max_data, range_needed=(-1,1)) :
if min_data < 0:
ts_std =(ts + abs(min_data)) /(max_data + abs(min_data))
else:
ts_std =(ts - min_data)/(max_data - min_data)
if range_needed[0] < 0:
return ts_std *(range_needed[1] + abs(range_needed[0])) + range_needed[0]
else:
return ts_std *(range_n... | states = [torch.load("model" + str(s)+ ".pth")for s in range(5)] | Titanic - Machine Learning from Disaster |
14,509,209 | def transform_ts(ts, n_dim=160, min_max=(-1,1)) :
ts_std = min_max_transf(ts, min_data=min_num, max_data=max_num)
bucket_size = int(sample_size / n_dim)
new_ts = []
for i in range(0, sample_size, bucket_size):
ts_range = ts_std[i:i + bucket_size]
mean = ts_range.mean()
std = ts_range.std()
std_top = mean + std
std_bo... | soft_values = []
for state in states:
model.load_state_dict(state["state_dict"])
model.eval()
with torch.no_grad() :
y_pred = model(test_X)
soft_values.append(y_pred.softmax(1 ).to("cpu" ).numpy())
soft_values2 = np.mean(soft_values,axis=0 ) | Titanic - Machine Learning from Disaster |
14,509,209 | def prep_data(start, end):
praq_train = pq.read_pandas('.. /input/train.parquet', columns=[str(i)for i in range(start, end)] ).to_pandas()
X = []
y = []
for id_measurement in tqdm(df_train.index.levels[0].unique() [int(start/3):int(end/3)]):
X_signal = []
for phase in [0,1,2]:
signal_id, target = df_train.loc[id_measur... | preds2 = [soft_values2[s].argmax() for s in range(len(soft_values2)) ] | Titanic - Machine Learning from Disaster |
14,509,209 | X = []
y = []
def load_all() :
total_size = len(df_train)
for ini, end in [(0, int(total_size/2)) ,(int(total_size/2), total_size)]:
X_temp, y_temp = prep_data(ini, end)
X.append(X_temp)
y.append(y_temp)
load_all()
X = np.concatenate(X)
y = np.concatenate(y )<choose_model_class> | submission["Survived"] = preds2 | Titanic - Machine Learning from Disaster |
14,509,209 | def model_lstm(input_shape):
inp = Input(shape=(input_shape[1], input_shape[2],))
x = Bidirectional(CuDNNLSTM(128, return_sequences=True))(inp)
x = Bidirectional(CuDNNLSTM(64, return_sequences=True))(x)
x = Attention(input_shape[1] )(x)
x = Dense(64, activation="relu" )(x)
x = Dense(1, activation="sigmoid" )(x)
mo... | submission.to_csv("submission2.csv",index=False ) | Titanic - Machine Learning from Disaster |
13,302,335 | splits = list(StratifiedKFold(n_splits=N_SPLITS, shuffle=True, random_state=2019 ).split(X, y))
preds_val = []
y_val = []
for idx,(train_idx, val_idx)in enumerate(splits):
K.clear_session()
print("Beginning fold {}".format(idx+1))
train_X, train_y, val_X, val_y = X[train_idx], y[train_idx], X[val_idx], y[val_idx]
model... | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
13,302,335 | def threshold_search(y_true, y_proba):
best_threshold = 0
best_score = 0
for threshold in tqdm([i * 0.01 for i in range(100)]):
score = K.eval(matthews_correlation(y_true.astype(np.float64),(y_proba > threshold ).astype(np.float64)))
if score > best_score:
best_threshold = threshold
best_score = score
search_result = ... | train_df = pd.read_csv('/kaggle/input/titanic/train.csv')
test_df = pd.read_csv('/kaggle/input/titanic/test.csv')
combine = [train_df, test_df]
| Titanic - Machine Learning from Disaster |
13,302,335 | best_threshold = threshold_search(y_val, preds_val)['threshold']<load_from_csv> | for dataset in combine:
dataset = dataset.drop(['Ticket', 'Cabin'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
13,302,335 | %%time
meta_test = pd.read_csv('.. /input/metadata_test.csv' )<drop_column> | for dataset in combine:
dataset['Title'] = dataset['Name'].str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
13,302,335 | meta_test = meta_test.set_index(['signal_id'])
meta_test.head()<define_variables> | for dataset in combine:
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col',\
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
dataset['Title'] = dataset['Ti... | Titanic - Machine Learning from Disaster |
13,302,335 | %%time
first_sig = meta_test.index[0]
n_parts = 10
max_line = len(meta_test)
part_size = int(max_line / n_parts)
last_part = max_line % n_parts
print(first_sig, n_parts, max_line, part_size, last_part, n_parts * part_size + last_part)
start_end = [[x, x+part_size] for x in range(first_sig, max_line + first_sig, part... | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in combine:
dataset['Title'] = dataset['Title'].map(title_mapping)
| Titanic - Machine Learning from Disaster |
13,302,335 | X_test_input = np.asarray([np.concatenate([X_test[i][3],X_test[i+1][3], X_test[i+2][3]], axis=1)for i in range(0,len(X_test), 3)])
np.save("X_test.npy",X_test_input)
X_test_input.shape<load_from_csv> | for dataset in combine:
dataset.drop(['Name'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
13,302,335 | submission = pd.read_csv('.. /input/sample_submission.csv')
print(len(submission))
submission.head()<predict_on_test> | train_df.drop(['PassengerId'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
13,302,335 | preds_test = []
for i in range(N_SPLITS):
model.load_weights('weights_{}.h5'.format(i))
pred = model.predict(X_test_input, batch_size=300, verbose=1)
pred_3 = []
for pred_scalar in pred:
for i in range(3):
pred_3.append(pred_scalar)
preds_test.append(pred_3)
<data_type_conversions> | for dataset in combine:
dataset['Sex'] = dataset['Sex'].map({'female': 1, 'male': 0} ).astype(int ) | Titanic - Machine Learning from Disaster |
13,302,335 | preds_test =(np.squeeze(np.mean(preds_test, axis=0)) > best_threshold ).astype(np.int)
preds_test.shape<save_to_csv> | for dataset in combine:
dataset['Embarked'] = dataset['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
13,302,335 | submission['target'] = preds_test
submission.to_csv('submission.csv', index=False)
submission.head()<load_from_csv> | train_df[['Embarked', 'Survived']].groupby('Embarked' ).mean() | Titanic - Machine Learning from Disaster |
13,302,335 | train_prepared = pd.read_csv('.. /input/agg-data-2/air_train_agg8000.csv')
test_prepared = pd.read_csv('.. /input/agg-data-3/air_test_14000.csv' )<categorify> | for dataset in combine:
dataset['Embarked'] = dataset['Embarked'].map({'S': 0, 'Q': 1, 'C': 2} ).astype(int ) | Titanic - Machine Learning from Disaster |
13,302,335 | lbl = preprocessing.LabelEncoder()
train_prepared['air_genre_name'] = lbl.fit_transform(train_prepared['air_genre_name'])
train_prepared['air_area_name'] = lbl.fit_transform(train_prepared['air_area_name'])
train_prepared['holiday_flg']= lbl.fit_transform(train_prepared['holiday_flg'])
train_prepared['day_of_week']=... | def mean_age_for_class(dataset):
mean_age_1class = dataset[dataset['Pclass'] == 1]['Age'].mean()
mean_age_2class = dataset[dataset['Pclass'] == 2]['Age'].mean()
mean_age_3class = dataset[dataset['Pclass'] == 3]['Age'].mean()
mean_age_list =(mean_age_1class, mean_age_2class, mean_age_3class)
return mean_age_list
for da... | Titanic - Machine Learning from Disaster |
13,302,335 | train_x = train_prepared.drop(['air_store_id', 'visit_date', 'visitors','total_air_reservations', 'total_hpg_reservations', 'total_reservations'], axis=1 )<prepare_x_and_y> | def fill_age_train(columns):
Age = columns[0]
Pclass = columns[1]
if pd.isnull(Age):
if(Pclass == 1):
return 38
elif(Pclass == 2):
return 30
elif(Pclass == 3):
return 25
else:
return Age
| Titanic - Machine Learning from Disaster |
13,302,335 | train_y = np.log1p(train_prepared['visitors'].values )<categorify> | train_df['Age'] = train_df[['Age', 'Pclass']].apply(fill_age_train, axis=1 ) | Titanic - Machine Learning from Disaster |
13,302,335 | test_prepared['air_genre_name'] = lbl.fit_transform(test_prepared['air_genre_name'])
test_prepared['air_area_name'] = lbl.fit_transform(test_prepared['air_area_name'])
test_prepared['holiday_flg']= lbl.fit_transform(test_prepared['holiday_flg'])
test_prepared['day_of_week']= lbl.fit_transform(test_prepared['day_of_w... | def fill_age_test(columns):
Age = columns[0]
Pclass = columns[1]
if pd.isnull(Age):
if(Pclass == 1):
return 41
elif(Pclass == 2):
return 29
elif(Pclass == 3):
return 24
else:
return Age | Titanic - Machine Learning from Disaster |
13,302,335 | test_prepared['id'] = test_prepared[['air_store_id', 'visit_date']].apply(lambda x: '_'.join(x.astype(str)) , axis=1 )<drop_column> | test_df['Age'] = test_df[['Age', 'Pclass']].apply(fill_age_test, axis=1 ) | Titanic - Machine Learning from Disaster |
13,302,335 | test_x = test_prepared.drop([ 'id','air_store_id', 'visit_date', 'visitors'], axis=1 )<data_type_conversions> | test_df['Fare'].fillna(test_df['Fare'].mean() , inplace=True ) | Titanic - Machine Learning from Disaster |
13,302,335 | train_x['hpg_store_id'] = pd.to_numeric(train_x['hpg_store_id'], errors='coerce')
train_x['hpg_genre_name'] = pd.to_numeric(train_x['hpg_genre_name'], errors='coerce')
train_x['hpg_area_name'] = pd.to_numeric(train_x['hpg_genre_name'], errors='coerce')
test_x['hpg_store_id'] = pd.to_numeric(test_x['hpg_store_id'], e... | for dataset in combine:
dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] | Titanic - Machine Learning from Disaster |
13,302,335 | train_x['var_max_lat'] = train_x['air_latitude'].max() - train_x['air_latitude']
train_x['var_max_long'] = train_x['air_longitude'].max() - train_x['air_longitude']
test_x['var_max_lat'] = test_x['air_latitude'].max() - test_x['air_latitude']
test_x['var_max_long'] = test_x['air_longitude'].max() - test_x['air_longitud... | for dataset in combine:
dataset['IsAlone'] = 0
dataset.loc[dataset['FamilySize'] == 0, 'IsAlone'] = 1 | Titanic - Machine Learning from Disaster |
13,302,335 | train_x = train_x.fillna(-1)
test_x = test_x.fillna(-1 )<prepare_x_and_y> | for dataset in combine:
dataset = dataset.drop(['Parch', 'SibSp'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
13,302,335 | validation = 0.1
mask = np.random.rand(len(train_x)) < validation
X_train = train_x[~mask]
y_train = train_y[~mask]
X_validation = train_x[mask]
y_validation = train_y[mask]<train_model> | train_df[['IsAlone', 'Survived']].groupby(['IsAlone'] ).mean() | Titanic - Machine Learning from Disaster |
13,302,335 | xgb0 = xgb.XGBRegressor()
xgb0.fit(X_train, y_train)
print('done' )<save_to_csv> | age_bin_labels = [1, 2, 3, 4]
fare_bin_labels = [1, 2, 3, 4, 5]
for dataset in combine:
dataset['Age'] = pd.qcut(dataset['Age'], q=4, labels=age_bin_labels ).astype(int)
dataset['Fare'] = pd.qcut(dataset['Fare'], q=5, labels=fare_bin_labels ).astype(int ) | Titanic - Machine Learning from Disaster |
13,302,335 | boost_params = {'eval_metric': 'rmse'}
xgb0 = xgb.XGBRegressor(max_depth=10,
learning_rate=0.01,
n_estimators=1000,
objective='reg:linear',
gamma=0,
min_child_weight=1,
subsample=0.8,
colsample_bytree=0.8,
scale_pos_weight=1,
seed=27,
**boost_params)
xgb0.fit(train_x, train_y)
predict_y = xgb0.predict(test_x)
test_p... | X = train_df.drop('Survived', axis=1)
Y = train_df['Survived']
X_test = test_df.drop('PassengerId', axis=1 ) | Titanic - Machine Learning from Disaster |
13,302,335 |
<load_from_csv> | X_train, X_val, y_train, y_val = train_test_split(X, Y, random_state=42 ) | Titanic - Machine Learning from Disaster |
13,302,335 | data = {
'tra': pd.read_csv('.. /input/air_visit_data.csv'),
'as': pd.read_csv('.. /input/air_store_info.csv'),
'hs': pd.read_csv('.. /input/hpg_store_info.csv'),
'ar': pd.read_csv('.. /input/air_reserve.csv'),
'hr': pd.read_csv('.. /input/hpg_reserve.csv'),
'id': pd.read_csv('.. /input/store_id_relation.csv'),
'tes': ... | parameters = {'n_estimators': [49, 50, 51],
'max_depth': [4, 5, 6],
'max_features': [3, 4, 5],
'min_samples_leaf': [9, 10,11, 12, 13]}
rf = GridSearchCV(RandomForestClassifier(random_state=1, n_jobs=-1), parameters)
rf.fit(X_train, y_train)
rf_predict = rf.predict(X_val)
rf.score(X_val, y_val ) | Titanic - Machine Learning from Disaster |
13,302,335 | def RMSLE(y, pred):
return metrics.mean_squared_error(y, pred)**0.5<define_variables> | rf.best_estimator_ | Titanic - Machine Learning from Disaster |
13,302,335 | value_col = ['holiday_flg','min_visitors','mean_visitors','median_visitors',
'count_observations',
'rs1_x','rv1_x','rs2_x','rv2_x','rs1_y','rv1_y','rs2_y','rv2_y','total_reserv_sum','total_reserv_mean',
'total_reserv_dt_diff_mean','date_int','var_max_lat','var_max_long','lon_plus_lat']
nn_col = value_col + ['dow', 'yea... | parameters = {'max_iter': [50, 100, 200, 300],
'alpha': [0.09, 0.1, 0.2, 0.3, 0.4]}
sgd = GridSearchCV(SGDClassifier(random_state=1, n_jobs=-1), parameters)
sgd.fit(X_train, y_train)
sgd_predict = sgd.predict(X_val)
sgd.score(X_val, y_val ) | Titanic - Machine Learning from Disaster |
13,302,335 | def get_nn_complete_model(train, hidden1_neurons=35, hidden2_neurons=15):
K.clear_session()
air_store_id = Input(shape=(1,), dtype='int32', name='air_store_id')
air_store_id_emb = Embedding(len(train['air_store_id2'].unique())+ 1, 15, input_shape=(1,),
name='air_store_id_emb' )(air_store_id)
air_store_id_emb = kera... | sgd.best_params_ | Titanic - Machine Learning from Disaster |
13,302,335 | model1 = ensemble.GradientBoostingRegressor(learning_rate=0.2, random_state=3,
n_estimators=200, subsample=0.8, max_depth =10)
model2 = neighbors.KNeighborsRegressor(n_jobs=-1, n_neighbors=4)
model3 = XGBRegressor(learning_rate=0.02, random_state=2, n_estimators=1000, subsample=0.8,
colsample_bytree=0.75, max_depth =... | parameters = {'max_iter': [25, 30, 35, 50, 100, 200, 300],
'C': [0.09, 0.1, 0.2, 0,5,0.9,1, 2, 3, 4]}
log_reg = GridSearchCV(LogisticRegression(random_state=1, n_jobs=-1), parameters)
log_reg.fit(X_train, y_train)
log_reg_predict = log_reg.predict(X_val)
log_reg.score(X_val, y_val ) | Titanic - Machine Learning from Disaster |
13,302,335 | dfs = { re.search('/([^/\.]*)\.csv', fn ).group(1):
pd.read_csv(fn)for fn in glob.glob('.. /input/*.csv')}
for k, v in dfs.items() : locals() [k] = v
wkend_holidays = date_info.apply(
(lambda x:(x.day_of_week=='Sunday' or x.day_of_week=='Saturday')and x.holiday_flg==1), axis=1)
date_info.loc[wkend_holidays, 'holiday_f... | log_reg.best_estimator_ | Titanic - Machine Learning from Disaster |
13,302,335 | def final_visitors(x, alt=False):
visitors_x, visitors_y = x['visitors_x'], x['visitors_y']
if x['visitors_y'] == -1:
return visitors_x
else:
return 0.7*visitors_x + 0.3*visitors_y* 1.1
sub_merge = pd.merge(sub1, sub2, on='id', how='inner')
sub_merge['visitors'] = sub_merge.apply(lambda x: final_visitors(x), axis=1)
... | rf_clf = RandomForestClassifier(max_depth=5, max_features=4, min_samples_leaf=11,
n_estimators=50, n_jobs=-1, random_state=1)
sgd_clf = SGDClassifier(alpha=0.1, max_iter=50, n_jobs=-1, random_state=0)
bagging_clf = BaggingClassifier(base_estimator=DecisionTreeClassifier() , max_features=5,
max_samples=40, n_estimator... | Titanic - Machine Learning from Disaster |
13,302,335 |
<set_options> | voiting_clf = VotingClassifier(estimators=([('rf', rf_clf),('bagg', bagging_clf),('lr', log_reg_clf),('ab', adaboost_clf)]))
voiting_clf.fit(X_train, y_train)
voiting_clf_predict = voiting_clf.predict(X_val)
voiting_clf.score(X_val, y_val ) | Titanic - Machine Learning from Disaster |
13,302,335 | %matplotlib inline<load_from_csv> | model = VotingClassifier(estimators=([('rf', rf_clf),('bagg', bagging_clf),('lr', log_reg_clf),('ab', adaboost_clf)]))
model.fit(X, Y)
predict = model.predict(X_test)
| Titanic - Machine Learning from Disaster |
13,302,335 | data = {
'tra': pd.read_csv('.. /input/air_visit_data.csv'),
'as': pd.read_csv('.. /input/air_store_info.csv'),
'hs': pd.read_csv('.. /input/hpg_store_info.csv'),
'ar': pd.read_csv('.. /input/air_reserve.csv'),
'hr': pd.read_csv('.. /input/hpg_reserve.csv'),
'id': pd.read_csv('.. /input/store_id_relation.csv'),
'tes': ... | output = pd.DataFrame({'PassengerId': test_df.PassengerId, 'Survived': predict})
output.to_csv('my_submission_11.csv', index=False ) | Titanic - Machine Learning from Disaster |
9,729,659 | def RMSLE(y, pred):
return metrics.mean_squared_error(y, pred)**0.5
def get_nn_complete_model(train, hidden1_neurons=35, hidden2_neurons=15):
K.clear_session()
air_store_id = Input(shape=(1,), dtype='int32', name='air_store_id')
air_store_id_emb = Embedding(len(train['air_store_id2'].unique())+ 1, 15, input_shape=(1,)... | %matplotlib inline
warnings.filterwarnings('ignore')
| Titanic - Machine Learning from Disaster |
9,729,659 | model1 = ensemble.GradientBoostingRegressor(learning_rate=0.2, random_state=3,
n_estimators=200, subsample=0.8, max_depth =10)
model2 = neighbors.KNeighborsRegressor(n_jobs=-1, n_neighbors=4)
model3 = XGBRegressor(learning_rate=0.2, random_state=3, n_estimators=200, subsample=0.8,
colsample_bytree=0.8, max_depth =10)... | train_df = pd.read_csv('/kaggle/input/titanic/train.csv')
test_df = pd.read_csv('/kaggle/input/titanic/test.csv')
combine = [train_df, test_df]
| Titanic - Machine Learning from Disaster |
9,729,659 | dfs = { re.search('/([^/\.]*)\.csv', fn ).group(1):
pd.read_csv(fn)for fn in glob.glob('.. /input/*.csv')}
for k, v in dfs.items() : locals() [k] = v
wkend_holidays = date_info.apply(
(lambda x:(x.day_of_week=='Sunday' or x.day_of_week=='Saturday')and x.holiday_flg==1), axis=1)
date_info.loc[wkend_holidays, 'holiday_f... | train_df.groupby('Pclass')['Survived'].mean() | Titanic - Machine Learning from Disaster |
9,729,659 | def final_visitors(x, alt=False):
visitors_x, visitors_y = x['visitors_x'], x['visitors_y']
if x['visitors_y'] == -1:
return visitors_x
else:
return 0.7*visitors_x + 0.3*visitors_y* 1.1
sub_merge = pd.merge(sub1, sub2, on='id', how='inner')
sub_merge['visitors'] = sub_merge.apply(lambda x: final_visitors(x), axis=1)
... | train_df.groupby('Embarked')['Survived'].mean() | Titanic - Machine Learning from Disaster |
9,729,659 | dfs = { re.search('/([^/\.]*)\.csv', fn ).group(1):pd.read_csv(fn)for fn in glob.glob('.. /input/*.csv')}
print('data frames read:{}'.format(list(dfs.keys())))
print('local variables with the same names are created.')
for k, v in dfs.items() : locals() [k] = v
print('holidays at weekends are not special, right?')
wk... | train_df.groupby('Sex')['Survived'].mean() | Titanic - Machine Learning from Disaster |
9,729,659 | print('weighted mean visitors for each(air_store_id, day_of_week, holiday_flag)or(air_store_id, day_of_week)')
visit_data = air_visit_data.merge(date_info, left_on='visit_date', right_on='calendar_date', how='left')
visit_data.drop('calendar_date', axis=1, inplace=True )<data_type_conversions> | train_df.groupby('SibSp')['Survived'].mean().sort_values(ascending=False ) | Titanic - Machine Learning from Disaster |
9,729,659 | visit_data['visit_date'] = pd.to_datetime(visit_data['visit_date'] )<split> | train_df.groupby('Parch')['Survived'].mean().sort_values(ascending=False ) | Titanic - Machine Learning from Disaster |
9,729,659 | test_data = visit_data[visit_data['visit_date']>='2017-04-01']<filter> | train_df.drop(columns=['Cabin', 'Ticket', 'PassengerId'], inplace=True)
test_df.drop(columns=['Cabin', 'Ticket'], inplace=True ) | Titanic - Machine Learning from Disaster |
9,729,659 | train_data = visit_data[visit_data['visit_date'] >='2017-03-01']<prepare_x_and_y> | for dataset in combine:
dataset['Title'] = dataset['Name'].str.extract('([A-Za-z]+)\.', expand=False)
pd.crosstab(train_df['Title'], train_df['Sex'] ) | 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.