kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
737,908 | threshold, score = get_f1(target, oof_pred)
print("F1 score after K fold at threshold {} is {}".format(threshold, score))
fake_test["pred"] =(fake_pred > threshold ).astype(int)
print("Fake test F1 score is {}".format(f1_score(fake_test["target"],
(fake_test["pred"] ).astype(int))))
test["prediction"] =(pred > thres... | full_set['Fare'] = full_set['Fare'].apply(fare_bin ).astype(int ) | Titanic - Machine Learning from Disaster |
737,908 | submission = test[["qid", "prediction"]]
submission.to_csv("submission.csv", index = False)
submission.head()<set_options> | full_set['Pclass'] = full_set['Pclass'].astype('str' ) | Titanic - Machine Learning from Disaster |
737,908 | def seed_everything(seed=1234):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
seed_everything(6017)
print('Seeding done...' )<feature_engineering> | full_w_dum = pd.get_dummies(full_set)
full_w_dum.head() | Titanic - Machine Learning from Disaster |
737,908 | print('Preproccesing texts.... ')
print('lower...')
df["question_text"] = df["question_text"].apply(lambda x: x.lower())
df_final["question_text"] = df_final["question_text"].apply(lambda x: x.lower())
contraction_mapping = {
"ain't": "is not",
"aren't": "are not",
"can't": "cannot",
"'cause": "because",
"could've"... | full_set = full_w_dum | Titanic - Machine Learning from Disaster |
737,908 | dim = 300
num_words = 95000
max_len = 100
print('Fiting tokenizer')
tokenizer = Tokenizer(num_words=num_words)
tokenizer.fit_on_texts(list(df['question_text'])+list(df_final['question_text']))
print('text to sequence')
x_train = tokenizer.texts_to_sequences(df['question_text'])
print('pad sequence')
x_train = pad_... | cols = list(set(full_set.columns)- set(['Survived']))
X_train, X_test = full_set[:train_set.shape[0]][cols], full_set[train_set.shape[0]:][cols]
y_train = full_set[:train_set.shape[0]]['Survived'] | Titanic - Machine Learning from Disaster |
737,908 | print('Glove...')
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open('.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'))
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_embs.std()
prin... | models = [ LogisticRegression, SVC, LinearSVC, RandomForestClassifier, KNeighborsClassifier, XGBClassifier ]
mscores = []
lscores = ['f1','accuracy','recall','roc_auc']
np.random.seed(42)
for elem in models:
mscores2 = []
model = elem()
for sc in lscores:
scores = cross_val_score(model, X_train, y_train, scoring=sc)
... | Titanic - Machine Learning from Disaster |
737,908 | print('Para...')
EMBEDDING_FILE = '.. /input/embeddings/paragram_300_sl999/paragram_300_sl999.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE, encoding="utf8", errors='ignore')if len(o)>100)
all_embs = np.stack... | order = np.argsort(np.mean(np.array(mscores), axis=1))
print(order ) | Titanic - Machine Learning from Disaster |
737,908 | class EarlyStopping:
def __init__(self, patience=7, verbose=False):
self.patience = patience
self.verbose = verbose
self.counter = 0
self.best_score = None
self.early_stop = False
self.val_loss_min = np.Inf
def __call__(self, val_loss, model):
score = -val_loss
if self.best_score is None:
self.best_score = score
se... | from sklearn.model_selection import StratifiedKFold, KFold | Titanic - Machine Learning from Disaster |
737,908 | class CyclicLR(object):
def __init__(self, optimizer, base_lr=1e-3, max_lr=6e-3,
step_size=2000, mode='triangular', gamma=1.,
scale_fn=None, scale_mode='cycle', last_batch_iteration=-1):
if not isinstance(optimizer, torch.optim.Optimizer):
raise TypeError('{} is not an Optimizer'.format(
type(optimizer ).__name__))
... | results_kfold = []
for K in [5,6,7,8,9,10]:
model = XGBClassifier()
kfold = KFold(n_splits=K, random_state=42)
res = cross_val_score(model, X_train, y_train, cv=kfold)
results_kfold.append(( K,res.mean() *100, res.std() *100)) | Titanic - Machine Learning from Disaster |
737,908 | print(os.listdir())
model = Sentiment(embedding_matrix_glov,embedding_matrix_para,batch_size=batch_size ).cuda()
model.load_state_dict(torch.load('checkpoint.pt'))<prepare_output> | list(map(lambda x: print('Iteration nº {:2}, with acc.{:.12} and std.dev.{:.12}'.format(*x)) ,results_kfold)) ; | Titanic - Machine Learning from Disaster |
737,908 | print('Threshold:',search_result['threshold'])
print(x_test.shape)
submission_dataset = torch.utils.data.TensorDataset(torch.tensor(x_test, dtype=torch.long ).cuda())
submission_loader = torch.utils.data.DataLoader(dataset=submission_dataset,batch_size=batch_size, shuffle=False)
pred = []
with torch.no_grad() :
for... | results_strat_kfold = []
for K in [5,6,7,8,9,10]:
model = XGBClassifier()
kfold = StratifiedKFold(n_splits=K, random_state=42)
res = cross_val_score(model, X_train, y_train, cv=kfold)
results_strat_kfold.append(( K,res.mean() *100, res.std() *100)) | Titanic - Machine Learning from Disaster |
737,908 | tqdm.pandas()
warnings.filterwarnings("ignore", message="F-score is ill-defined and being set to 0.0 due to no predicted samples.")
%matplotlib inline<load_from_csv> | list(map(lambda x: print('Iteration nº {:2}, with acc.{:.12} and std.dev.{:.12}'.format(*x)) ,results_strat_kfold)) ; | Titanic - Machine Learning from Disaster |
737,908 | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv")
print('Train data dimension: ', train_df.shape)
display(train_df.head())
print('Test data dimension: ', test_df.shape)
display(test_df.head() )<create_dataframe> | xg_scores = []
kfold = StratifiedKFold(n_splits=7, random_state=42)
for lamb in [.05,.1,.2,.3,.4,.5,.6 ]:
for eta in [.2,.19,.17,.15,.13,.11]:
model = XGBClassifier(learning_rate=eta, reg_lambda=lamb)
res = cross_val_score(model, X_train, y_train, cv=kfold)
xg_scores.append({'lamb':lamb, 'eta':eta, 'acc':res.mean() ... | Titanic - Machine Learning from Disaster |
737,908 | enable_local_test = True
if enable_local_test:
n_test = len(test_df)
train_df, local_test_df =(train_df.iloc[:-n_test].reset_index(drop=True),
train_df.iloc[-n_test:].reset_index(drop=True))
else:
local_test_df = pd.DataFrame([[None, None, 0], [None, None, 0]], columns=['qid', 'question_text', 'target'])
n_test = 2<s... | sorted(xg_scores,key=lambda x: x['acc'], reverse=True)[0] | Titanic - Machine Learning from Disaster |
737,908 | def seed_everything(seed=1234):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
seed_everything()<compute_test_metric> | model = XGBClassifier(learning_rate=.17, reg_lambda=.5)
model.fit(X_train, y_train)
predicted = model.predict(X_test ) | Titanic - Machine Learning from Disaster |
737,908 | <compute_test_metric><EOS> | test_set['Survived'] = predicted.astype(int)
test_set[['PassengerId','Survived']].to_csv('submission.csv', sep=',', index=False ) | Titanic - Machine Learning from Disaster |
11,400,975 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | !pip install pywaffle | Titanic - Machine Learning from Disaster |
11,400,975 | embed_size = 300
max_features = 95000
maxlen = 70<define_variables> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import pandas_profiling
import plotly.express as px
import plotly.graph_objects as go
import sklearn.metrics as metrics
import plotly.offline as py
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
f... | Titanic - Machine Learning from Disaster |
11,400,975 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | custom_colors = ["
customPalette = sns.set_palette(sns.color_palette(custom_colors)) | Titanic - Machine Learning from Disaster |
11,400,975 | for df in [train_df, test_df, local_test_df]:
df["question_text"] = df["question_text"].str.lower()
df["question_text"] = df["question_text"].apply(lambda x: clean_text(x))
df["question_text"].fillna("_
x_train = train_df["question_text"].values
x_test = test_df["question_text"].values
x_test_local = local_test_df["que... | sns.set_context("notebook", font_scale=1.5, rc={"lines.linewidth": 2.5} ) | Titanic - Machine Learning from Disaster |
11,400,975 | seed_everything()
glove_embeddings = load_glove(tokenizer.word_index, max_features)
paragram_embeddings = load_para(tokenizer.word_index, max_features)
embedding_matrix = np.mean([glove_embeddings, paragram_embeddings], axis=0)
np.shape(embedding_matrix )<split> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
11,400,975 | splits = list(StratifiedKFold(n_splits=4, shuffle=True, random_state=10 ).split(x_train, y_train))<normalization> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
11,400,975 | class Attention(nn.Module):
def __init__(self, feature_dim, step_dim, bias=True, **kwargs):
super(Attention, self ).__init__(**kwargs)
self.supports_masking = True
self.bias = bias
self.feature_dim = feature_dim
self.step_dim = step_dim
self.features_dim = 0
weight = torch.zeros(feature_dim, 1)
nn.init.xavier_uniform... | train_data.isna().sum() | Titanic - Machine Learning from Disaster |
11,400,975 | class NeuralNet(nn.Module):
def __init__(self):
super(NeuralNet, self ).__init__()
hidden_size = 60
self.embedding = nn.Embedding(max_features, embed_size)
self.embedding.weight = nn.Parameter(torch.tensor(embedding_matrix, dtype=torch.float32))
self.embedding.weight.requires_grad = False
self.embedding_dropout = Spat... | train_data.nunique() | Titanic - Machine Learning from Disaster |
11,400,975 | batch_size = 512
n_epochs = 5<choose_model_class> | train_data['Cabin'] = train_data['Cabin'].apply(lambda i: i[0] if pd.notnull(i)else 'Z')
test_data['Cabin'] = test_data['Cabin'].apply(lambda i: i[0] if pd.notnull(i)else 'Z' ) | Titanic - Machine Learning from Disaster |
11,400,975 | class CyclicLR(object):
def __init__(self, optimizer, base_lr=1e-3, max_lr=6e-3,
step_size=2000, factor=0.6, min_lr=1e-4, mode='triangular', gamma=1.,
scale_fn=None, scale_mode='cycle', last_batch_iteration=-1):
if not isinstance(optimizer, torch.optim.Optimizer):
raise TypeError('{} is not an Optimizer'.format(
type(... | train_data[train_data['Cabin']=='T'].index.values | Titanic - Machine Learning from Disaster |
11,400,975 | def train_model(model, x_train, y_train, x_val, y_val, validate=True):
optimizer = torch.optim.Adam(model.parameters())
step_size = 300
scheduler = CyclicLR(optimizer, base_lr=0.001, max_lr=0.003,
step_size=step_size, mode='exp_range',
gamma=0.99994)
train = torch.utils.data.TensorDataset(x_train, y_train)
valid = t... | test_data[test_data['Cabin']=='T'].index.values | Titanic - Machine Learning from Disaster |
11,400,975 | seed = 6017<load_pretrained> | train_data.iloc[339] | Titanic - Machine Learning from Disaster |
11,400,975 | x_test_cuda = torch.tensor(x_test, dtype=torch.long ).cuda()
test = torch.utils.data.TensorDataset(x_test_cuda)
test_loader = torch.utils.data.DataLoader(test, batch_size=batch_size, shuffle=False)
x_test_local_cuda = torch.tensor(x_test_local, dtype=torch.long ).cuda()
test_local = torch.utils.data.TensorDataset(x_t... | index = train_data[train_data['Cabin'] == 'T'].index
train_data.loc[index, 'Cabin'] = 'A' | Titanic - Machine Learning from Disaster |
11,400,975 | train_preds = np.zeros(len(train_df))
test_preds = np.zeros(( len(test_df), len(splits)))
test_preds_local = np.zeros(( n_test, len(splits)))
for i,(train_idx, valid_idx)in enumerate(splits):
x_train_fold = torch.tensor(x_train[train_idx], dtype=torch.long ).cuda()
y_train_fold = torch.tensor(y_train[train_idx, np.ne... | train_data['Cabin'] = train_data['Cabin'].replace(['A', 'B', 'C'], 'ABC')
train_data['Cabin'] = train_data['Cabin'].replace(['D', 'E'], 'DE')
train_data['Cabin'] = train_data['Cabin'].replace(['F', 'G'], 'FG')
test_data['Cabin'] = test_data['Cabin'].replace(['A', 'B', 'C'], 'ABC')
test_data['Cabin'] = test_data['Ca... | Titanic - Machine Learning from Disaster |
11,400,975 | search_result = threshold_search(y_train, train_preds)
search_result<compute_test_metric> | train_data.drop(["Ticket", "Name", "PassengerId"], axis=1, inplace=True)
test_data.drop(["Ticket", "Name", "PassengerId"], axis=1, inplace=True)
train_data["Age"].fillna(train_data["Age"].median(skipna=True), inplace=True)
test_data["Age"].fillna(test_data["Age"].median(skipna=True), inplace=True)
test_data["Fare"]... | Titanic - Machine Learning from Disaster |
11,400,975 | f1_score(y_test, test_preds_local.mean(axis=1)> search_result['threshold'] )<save_to_csv> | gender = {'male': 0, 'female': 1}
train_data.Sex = [gender[item] for item in train_data.Sex]
test_data.Sex = [gender[item] for item in test_data.Sex]
embarked = {'S': 0, 'C': 1, 'Q':2}
train_data.Embarked = [embarked[item] for item in train_data.Embarked]
test_data.Embarked = [embarked[item] for item in test_data.Embar... | Titanic - Machine Learning from Disaster |
11,400,975 | submission = test_df[['qid']].copy()
submission['prediction'] = test_preds.mean(axis=1)> search_result['threshold']
submission.to_csv('submission.csv', index=False )<define_variables> | td = pd.read_csv("/kaggle/input/titanic/train.csv")
td["Cabin"]=td.Cabin.str[0] | Titanic - Machine Learning from Disaster |
11,400,975 | test_scores = [0.6894145809793863, 0.6904706309470233, 0.6905915253597362, 0.6908101789878276, 0.6910334464526553, 0.6916507797390641, 0.6903868185698696, 0.6908830283890897]
train_scores = [0.669555770620476, 0.6708382008438574, 0.6700974173065081, 0.6701065866112219, 0.6704778141088164, 0.6708436318389969, 0.67053100... | expected_values = train_data["Survived"]
train_data.drop("Survived", axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
11,400,975 | eval_df = pd.DataFrame()
eval_df['cv_score'] = train_scores
eval_df['local_test_score'] = test_scores
eval_df['seed'] = seeds
eval_df.head()<filter> | train_data.drop("Cabin", axis=1, inplace=True)
test_data.drop("Cabin", axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
11,400,975 | eval_df.loc[[eval_df['local_test_score'].idxmax() ]]<import_modules> | X = train_data.values
y = expected_values.values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1, stratify=y ) | Titanic - Machine Learning from Disaster |
11,400,975 | tqdm.pandas(desc='Progress')
<define_variables> | model = RandomForestClassifier(criterion='gini',
n_estimators=1750,
max_depth=7,
min_samples_split=6,
min_samples_leaf=6,
max_features='auto',
oob_score=True,
random_state=42,
n_jobs=-1,
verbose=1 ) | Titanic - Machine Learning from Disaster |
11,400,975 | embed_size = 300
max_features = 120000
maxlen = 70
batch_size = 512
n_epochs = 5
n_splits = 5
SEED = 10
debug =0<choose_model_class> | model.fit(X_train, y_train)
y_pred_train = model.predict(X_train)
y_pred_test = model.predict(X_test ) | Titanic - Machine Learning from Disaster |
11,400,975 | loss_fn = torch.nn.BCEWithLogitsLoss(reduction='sum' )<set_options> | print("Training accuracy: ", accuracy_score(y_train, y_pred_train))
print("Testing accuracy: ", accuracy_score(y_test, y_pred_test)) | Titanic - Machine Learning from Disaster |
11,400,975 | def seed_everything(seed=10):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
seed_everything()<features_selection> | column_values = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']
X_train_df = pd.DataFrame(data = X_train,
columns = column_values)
X_test_df = pd.DataFrame(data = X_test,
columns = column_values ) | Titanic - Machine Learning from Disaster |
11,400,975 | def load_glove(word_index):
EMBEDDING_FILE = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')[:300]
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE))
all_embs = np.stack(embeddings_index.values())
emb_mean,e... | feature_importance(model ) | Titanic - Machine Learning from Disaster |
11,400,975 | def build_vocab(texts):
sentences = texts.apply(lambda x: x.split() ).values
vocab = {}
for sentence in sentences:
for word in sentence:
try:
vocab[word] += 1
except KeyError:
vocab[word] = 1
return vocab
def known_contractions(embed):
known = []
for contract in contraction_mapping:
if contract in embed:
known.append(c... | model.fit(train_data, expected_values)
print("%.4f" % model.oob_score_ ) | Titanic - Machine Learning from Disaster |
11,400,975 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | passenger_IDs = pd.read_csv("/kaggle/input/titanic/test.csv")[["PassengerId"]].values
preds = model.predict(test_data.values)
preds | Titanic - Machine Learning from Disaster |
11,400,975 | def parallelize_apply(df,func,colname,num_process,newcolnames):
pool =Pool(processes=num_process)
arraydata = pool.map(func,tqdm(df[colname].values))
pool.close()
newdf = pd.DataFrame(arraydata,columns = newcolnames)
df = pd.concat([df,newdf],axis=1)
return df
def parallelize_dataframe(df, func):
df_split = np.array... | df = {'PassengerId': passenger_IDs.ravel() , 'Survived': preds}
df_predictions = pd.DataFrame(df ).set_index(['PassengerId'])
df_predictions.head(10 ) | Titanic - Machine Learning from Disaster |
11,400,975 | <normalization><EOS> | df_predictions.to_csv('/kaggle/working/Predictions.csv' ) | Titanic - Machine Learning from Disaster |
5,515,762 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<choose_model_class> | df_train = pd.read_csv('/kaggle/input/titanic/train.csv')
df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
df_train.head() | Titanic - Machine Learning from Disaster |
5,515,762 | class CyclicLR(object):
def __init__(self, optimizer, base_lr=1e-3, max_lr=6e-3,
step_size=2000, mode='triangular', gamma=1.,
scale_fn=None, scale_mode='cycle', last_batch_iteration=-1):
if not isinstance(optimizer, Optimizer):
raise TypeError('{} is not an Optimizer'.format(
type(optimizer ).__name__))
self.optimizer... | df_missing = pd.DataFrame(df_train.isna().sum() + df_test.isna().sum() , columns=['Missing'])
df_missing = df_missing.drop('Survived')
df_missing = df_missing.sort_values(by='Missing', ascending=False)
df_missing = df_missing[df_missing.Missing > 0]
df_missing | Titanic - Machine Learning from Disaster |
5,515,762 | class MyDataset(Dataset):
def __init__(self,dataset):
self.dataset = dataset
def __getitem__(self,index):
data,target = self.dataset[index]
return data,target,index
def __len__(self):
return len(self.dataset )<compute_train_metric> | df_train, df_test = [x.drop('Cabin', axis=1)for x in [df_train, df_test]] | Titanic - Machine Learning from Disaster |
5,515,762 | def pytorch_model_run_cv(x_train,y_train,features,x_test, model_obj, feats = False,clip = True):
seed_everything()
avg_losses_f = []
avg_val_losses_f = []
train_preds = np.zeros(( len(x_train)))
test_preds = np.zeros(( len(x_test)))
splits = list(StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=SEED ).sp... | lb_encoder = LabelBinarizer(sparse_output=False)
age_bins = [0, 14, 25, 75, 120]
age_labels = ['Child', 'Teen', 'Adult', 'Elder']
for ds in [df_train, df_test]:
ds['Age'].fillna(ds['Age'].median() , inplace=True)
ds['AgeBin'] = pd.cut(ds['Age'], bins=age_bins, labels=age_labels, include_lowest=True)
g = sns.FacetGri... | Titanic - Machine Learning from Disaster |
5,515,762 | class Alex_NeuralNet_Meta(nn.Module):
def __init__(self,hidden_size,lin_size, embedding_matrix=embedding_matrix):
super(Alex_NeuralNet_Meta, self ).__init__()
self.hidden_size = hidden_size
drp = 0.1
self.embedding = nn.Embedding(max_features, embed_size)
self.embedding.weight = nn.Parameter(torch.tensor(embedding_mat... | df_train, df_test = [x.fillna('S')for x in [df_train, df_test]]
lb_encoder.fit(df_train['Embarked'])
df_train, df_test = [x.join(pd.DataFrame(lb_encoder.transform(x['Embarked']), columns=lb_encoder.classes_)) for x in [df_train, df_test]]
df_train, df_test = [x.drop('Embarked', axis=1)for x in [df_train, df_test]] | Titanic - Machine Learning from Disaster |
5,515,762 | def sigmoid(x):
return 1 /(1 + np.exp(-x))
seed_everything()
x_test_cuda = torch.tensor(x_test, dtype=torch.long ).cuda()
test = torch.utils.data.TensorDataset(x_test_cuda)
test_loader = torch.utils.data.DataLoader(test, batch_size=batch_size, shuffle=False )<compute_train_metric> | for ds in [df_train, df_test]:
ds['Title'] = [x.split(',')[1].split('.')[0].strip() for x in ds['Name']]
ds['Title'] = ds['Title'].replace(to_replace=['Mlle', 'Ms'], value='Miss')
ds['Title'] = ds['Title'].replace(to_replace='Mme', value='Mrs')
ds['Title'] = ds['Title'].apply(lambda i: i if i in ['Mr', 'Mrs', 'Miss',... | Titanic - Machine Learning from Disaster |
5,515,762 | train_preds , test_preds = pytorch_model_run_cv(x_train,y_train,features,x_test,Alex_NeuralNet_Meta(70,16, embedding_matrix=embedding_matrix), feats = True )<compute_test_metric> | pclass_cols = ['UpperClass', 'MiddleClass', 'LowerClass']
lb_encoder.fit(df_train['Pclass'])
df_test = df_test.join(pd.DataFrame(lb_encoder.transform(df_test['Pclass']), columns=pclass_cols))
df_train = df_train.join(pd.DataFrame(lb_encoder.transform(df_train['Pclass']), columns=pclass_cols))
df_test.drop('Pclass', ax... | Titanic - Machine Learning from Disaster |
5,515,762 | def bestThresshold(y_train,train_preds):
tmp = [0,0,0]
delta = 0
for tmp[0] in tqdm(np.arange(0.1, 0.501, 0.01)) :
tmp[1] = f1_score(y_train, np.array(train_preds)>tmp[0])
if tmp[1] > tmp[2]:
delta = tmp[0]
tmp[2] = tmp[1]
print('best threshold is {:.4f} with F1 score: {:.4f}'.format(delta, tmp[2]))
return delta , tmp... | for ds in [df_train, df_test]:
df_family =(ds['Parch'] + ds['SibSp'] + 1 ).astype(int)
ds.drop(['Parch', 'SibSp'], axis=1, inplace=True)
ds['IsAlone'] = df_family.map(lambda x: 1 if x == 1 else 0)
ds['SmallFamily'] = df_family.map(lambda x: 1 if 2 <= x <= 4 else 0)
ds['LargeFamily'] = df_family.map(lambda x: 1 if x... | Titanic - Machine Learning from Disaster |
5,515,762 | if debug:
df_test = pd.read_csv(".. /input/test.csv")[:20000]
else:
df_test = pd.read_csv(".. /input/test.csv")
submission = df_test[['qid']].copy()
submission['prediction'] =(test_preds > delta ).astype(int)
submission.to_csv('submission.csv', index=False )<set_options> | for ds in [df_train, df_test]:
ds['IsFemale'] =(ds['Sex'] == 'female' ).astype(int)
ds.drop('Sex', axis=1, inplace=True)
g = sns.FacetGrid(df_train, col="IsFemale" ).map(plt.hist, "Survived" ) | Titanic - Machine Learning from Disaster |
5,515,762 | def seed_torch(seed=1029):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
embed_size = 300
max_features = 95000
maxlen = 72
batch_size = 1536
train_epochs = 8
SEED = 1029
puncts = [',', '... | test_passenger_ids = np.array(df_test['PassengerId'])
df_test.drop(['PassengerId', 'Ticket'], axis=1, inplace=True)
df_train.drop(['PassengerId', 'Ticket'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
5,515,762 | class Attention(nn.Module):
def __init__(self, feature_dim, step_dim, bias=True, **kwargs):
super(Attention, self ).__init__(**kwargs)
self.supports_masking = True
self.bias = bias
self.feature_dim = feature_dim
self.step_dim = step_dim
self.features_dim = 0
weight = torch.zeros(feature_dim, 1)
nn.init.xavier_uniform... | X_train = df_train.loc[:, df_train.columns != 'Survived']
X_test = np.array(df_test)
y_train = np.array(df_train['Survived'])
print(f"Train features: {X_train.shape}
Train labels: {X_test.shape}
Testing features: {y_train.shape}" ) | Titanic - Machine Learning from Disaster |
5,515,762 | search_result = threshold_search(train_y, train_preds )<save_to_csv> | param_grid = {'n_estimators': [200, 300, 500, 600, 700, 800], 'random_state': [42]}
grid_search = GridSearchCV(estimator=RandomForestClassifier() , param_grid=param_grid, cv=4, n_jobs=-1, verbose=2)
grid_search.fit(X_train, y_train)
print(f"Best score: {round(grid_search.best_score_, 4)}
"
f"Mean score: {round(grid_s... | Titanic - Machine Learning from Disaster |
2,302,192 | sub = pd.read_csv('.. /input/sample_submission.csv')
sub.prediction = test_preds > search_result['threshold']
sub.to_csv("submission.csv", index=False )<import_modules> | pd.set_option("display.max_rows",200)
pd.set_option("display.max_columns",200)
%matplotlib inline
sns.set_style('whitegrid')
| Titanic - Machine Learning from Disaster |
2,302,192 | tqdm.pandas()
<load_from_csv> | df_train = pd.read_csv('.. /input/train.csv')
df_test = pd.read_csv('.. /input/test.csv')
print(len(df_train),len(df_test)) | Titanic - Machine Learning from Disaster |
2,302,192 | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
print(f"Train shape: {train.shape}")
print(f"Test shape: {test.shape}")
train.sample()<split> | df_test.head()
| Titanic - Machine Learning from Disaster |
2,302,192 | EMBEDDING_FILE = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
def get_coefs(word,*arr):
return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE))<feature_engineering> | len(df_train[df_train['Name'].str.contains('Dr.')] ) | Titanic - Machine Learning from Disaster |
2,302,192 | def check_coverage(vocab,embeddings_index):
a, oov, k, i = {}, {}, 0, 0
for word in vocab:
try:
a[word] = embeddings_index[word]
k += vocab[word]
except:
oov[word] = vocab[word]
i += vocab[word]
pass
print(f'Found embeddings for {(len(a)/ len(vocab)) :.2%} of vocab')
print(f'Found embeddings for {(k /(k + i)) :.2%} of... | len(df_train[df_train['Name'].str.contains('Sir.')] ) | Titanic - Machine Learning from Disaster |
2,302,192 | vocab = get_vocab(train["question_text"])
out_of_vocab = check_coverage(vocab, embeddings_index)
out_of_vocab[:10]<string_transform> | len(df_train[df_train['Cabin'].isnull() ])
| Titanic - Machine Learning from Disaster |
2,302,192 | punct = set('?!.,"
embed_punct = punct & set(embeddings_index.keys())
def clean_punctuation(txt):
for p in "/-":
txt = txt.replace(p, ' ')
for p in "'`‘":
txt = txt.replace(p, '')
for p in punct:
txt = txt.replace(p, f' {p} ' if p in embed_punct else ' _punct_ ')
return txt<feature_engineering> | df_train.drop(['Name','PassengerId','Ticket','Cabin'],axis=1,inplace=True)
df_train.head() | Titanic - Machine Learning from Disaster |
2,302,192 | train["question_text"] = train["question_text"].map(lambda x: clean_punctuation(x)).str.replace('\d+', '
test["question_text"] = test["question_text"].map(lambda x: clean_punctuation(x)).str.replace('\d+', '
vocab = get_vocab(train["question_text"])
out_of_vocab = check_coverage(vocab, embeddings_index )<string_transf... | df_train[df_train['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
2,302,192 | train, validation = train_test_split(train, test_size=0.08, random_state=20181224)
embed_size = 300
vocab_size = 95000
maxlen = 100
train_X = train["question_text"].fillna("_
val_X = validation["question_text"].fillna("_
test_X = test["question_text"].fillna("_
tokenizer = Tokenizer(num_words=vocab_size, filters='', l... | df_train['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
2,302,192 | all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_embs.std()
embed_size = all_embs.shape[1]<feature_engineering> | df_train['Embarked'].fillna('S',inplace=True)
df_train[df_train['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
2,302,192 | word_index = tokenizer.word_index
nb_words = min(vocab_size, len(word_index))
embedding_matrix = np.random.normal(emb_mean, emb_std,(nb_words, embed_size))
num_missed = 0
for word, i in word_index.items() :
if i >= vocab_size: continue
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None: embe... | df_train = pd.concat([df_train,pd.get_dummies(df_train['Embarked'],prefix='Embarked')],axis=1)
df_train.drop('Embarked',axis=1,inplace=True)
df_train.head() | Titanic - Machine Learning from Disaster |
2,302,192 | hidden_layer_size = 100
BATCH_SIZE = 64
tf.reset_default_graph()
X = tf.placeholder(tf.int32, [None, maxlen], name='X')
Y = tf.placeholder(tf.float32, [None], name='Y')
batch_size = tf.placeholder(tf.int64 )<define_variables> | df_train[df_train['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
2,302,192 | dataset = tf.data.Dataset.from_tensor_slices(( X, Y)).shuffle(buffer_size=1000 ).batch(batch_size ).repeat()
test_dataset = tf.data.Dataset.from_tensor_slices(( X, Y)).batch(batch_size)
iterator = tf.data.Iterator.from_structure(dataset.output_types,
dataset.output_shapes)
train_init_op = iterator.make_initializer(da... | avg_fare = pd.DataFrame([fare_notsurv.mean() ,fare_surv.mean() ])
std_fare = pd.DataFrame([fare_notsurv.std() ,fare_surv.std() ])
print("Mean fare for not survived is {} and survived is {}".format(fare_notsurv.mean() ,\
fare_surv.mean())) | Titanic - Machine Learning from Disaster |
2,302,192 | embeddings = tf.get_variable(name="embeddings", shape=embedding_matrix.shape,
initializer=tf.constant_initializer(np.array(embedding_matrix)) ,
trainable=False)
embed = tf.nn.embedding_lookup(embeddings, questions )<choose_model_class> | df_train[df_train['Age'].isnull() ] | Titanic - Machine Learning from Disaster |
2,302,192 | lstm_cell= tf.nn.rnn_cell.LSTMCell(hidden_layer_size)
_, final_state = tf.nn.dynamic_rnn(lstm_cell, embed, dtype=tf.float32)
last_layer = tf.layers.dense(final_state.h, 1)
prediction = tf.nn.sigmoid(last_layer)
prediction = tf.squeeze(prediction, [1] )<choose_model_class> | avg_age = pd.DataFrame([age_notsurv.mean() ,age_surv.mean() ])
std_age = pd.DataFrame([age_notsurv.std() ,age_surv.std() ])
print("Mean age for not survived is {} and survived is {}".format(age_notsurv.mean() ,\
age_surv.mean())) | Titanic - Machine Learning from Disaster |
2,302,192 | learning_rate=0.001
loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=tf.squeeze(last_layer), labels=labels)
loss = tf.reduce_mean(loss)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate ).minimize(loss )<compute_train_metric> | df_train['Family'] = df_train['Parch'] + df_train['SibSp']
df_train.drop(['Parch','SibSp'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
2,302,192 | with tf.name_scope('metrics'):
F1, f1_update = tf.contrib.metrics.f1_score(labels=labels, predictions=prediction, name='my_metric')
running_vars = tf.get_collection(tf.GraphKeys.LOCAL_VARIABLES, scope="my_metric")
reset_op = tf.variables_initializer(var_list=running_vars )<init_hyperparams> | df_train['Family'].loc[df_train['Family']>1]=1
df_train['Family'].loc[df_train['Family']==0]=0
df_train['Family'].value_counts() | Titanic - Machine Learning from Disaster |
2,302,192 | num_epochs = 10
seed = 3
sess = tf.Session()
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
costs, f1 = [], []<define_variables> | def get_person(passenger):
age,sex=passenger
return 'child' if age < 12 else sex
df_train['Person'] = df_train[['Age','Sex']].apply(get_person,axis=1)
df_train.drop('Sex',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
2,302,192 | start = time.time()
end = 0
max_time = 6600
sess.run(train_init_op, feed_dict={X:train_X, Y:train_y, batch_size:BATCH_SIZE})
num_iter = 1000
num_batches = int(train_X.shape[0] / BATCH_SIZE)
for epoch in range(1, num_epochs+1):
seed += seed
tf.set_random_seed(seed)
iter_cost = 0.
prev_iter = 0.
for i in range(num_b... | df_train = pd.concat([df_train,pd.get_dummies(df_train['Person'],prefix='Person')],axis=1)
df_train.drop(['Person'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
2,302,192 | sz = 90
tf.set_random_seed(2018)
sess.run(test_init_op, feed_dict={X: val_X, Y: val_y, batch_size: sz})
val_pred = np.concatenate([sess.run(prediction)for _ in range(int(val_X.shape[0]/sz)) ] )<compute_test_metric> | df_test.drop(['Name','Ticket','Cabin'],axis=1,inplace=True)
df_test['Embarked'].fillna('S',inplace=True)
df_test = pd.concat([df_test,pd.get_dummies(df_test['Embarked'],prefix='Embarked')],axis=1)
df_test.drop('Embarked',axis=1,inplace=True)
df_test['Fare'].fillna(df_test['Fare'].mean() ,inplace=True)
df_test['Age... | Titanic - Machine Learning from Disaster |
2,302,192 | thresh = thresholds[np.argmax(scores)]
print(f"Best Validation F1 Score is {max(scores):.4f} at threshold {thresh}" )<split> | features_train = df_train.drop(['Survived'],axis=1)
target_train= df_train['Survived']
features_test = df_test.drop(['PassengerId'],axis=1 ) | Titanic - Machine Learning from Disaster |
2,302,192 | sz=30
temp_y = val_y[:test_X.shape[0]]
sub = test[['qid']]
sess.run(test_init_op, feed_dict={X: test_X, Y: temp_y, batch_size:sz})
sub['prediction'] = np.concatenate([sess.run(prediction)for _ in range(int(test_X.shape[0]/sz)) ] )<save_to_csv> | train_x,test_x,train_y,test_y = train_test_split(features_train,target_train,test_size=0.2,random_state=42)
| Titanic - Machine Learning from Disaster |
2,302,192 | sub['prediction'] =(sub['prediction'] > thresh ).astype(np.int16)
sub.to_csv("submission.csv", index=False)
sub.sample()<define_variables> | clf_nb = GaussianNB()
clf_nb.fit(features_train,target_train)
target_test_nb = clf_nb.predict(features_test ) | Titanic - Machine Learning from Disaster |
2,302,192 | MAX_SEQUENCE_LENGTH = 60
MAX_WORDS = 45000
EMBEDDINGS_LOADED_DIMENSIONS = 300<load_from_csv> | df_test['Survived'] = target_test_nb
df_test[['PassengerId','Survived']].to_csv('gaussnb-kaggle.csv',index=False ) | Titanic - Machine Learning from Disaster |
2,302,192 | df_train = pd.read_csv(".. /input/train.csv")
df_test = pd.read_csv(".. /input/test.csv" )<define_variables> | clf_nb.fit(train_x,train_y)
pred_gnb_y = clf_nb.predict(test_x)
print('Accuracy score of Gaussian NB is {}'.format(metrics.accuracy_score(pred_gnb_y,test_y)) ) | Titanic - Machine Learning from Disaster |
2,302,192 | BATCH_SIZE = 512
Q_FRACTION = 1
questions = df_train.sample(frac=Q_FRACTION)
question_texts = questions["question_text"].values
question_targets = questions["target"].values
test_texts = df_test["question_text"].fillna("_na_" ).values
print(f"Working on {len(questions)} questions" )<load_pretrained> | svc = SVC(kernel='rbf',class_weight='balanced')
param_grid_svm = {'C': [1, 5, 10, 50,100],
'gamma': [0.0001, 0.0005, 0.001, 0.005,0.01]}
grid_svm = GridSearchCV(estimator=svc, param_grid=param_grid_svm)
grid_svm.fit(train_x,train_y)
grid_svm.best_params_ | Titanic - Machine Learning from Disaster |
2,302,192 | def load_embeddings(file):
embeddings = {}
with open(file)as f:
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings = dict(get_coefs(*line.split(" ")) for line in f)
print('Found %s word vectors.' % len(embeddings))
return embeddings
%time pretrained_embeddings = load_embeddings(".. /in... | clf_svm = grid_svm.best_estimator_
clf_svm.fit(features_train,target_train)
target_test_svm = clf_svm.predict(features_test ) | Titanic - Machine Learning from Disaster |
2,302,192 | tokenizer = Tokenizer(num_words=MAX_WORDS)
%time tokenizer.fit_on_texts(list(df_train["question_text"].values))<categorify> | df_test['Survived'] = target_test_svm
df_test[['PassengerId','Survived']].to_csv('svm-kaggle.csv',index=False ) | Titanic - Machine Learning from Disaster |
2,302,192 | def create_embedding_weights(tokenizer, embeddings, dimensions):
not_embedded = defaultdict(int)
word_index = tokenizer.word_index
words_count = min(len(word_index), MAX_WORDS)
embeddings_matrix = np.zeros(( words_count, dimensions))
for word, i in word_index.items() :
if i >= MAX_WORDS:
continue
embedding_vector = e... | clf_svm.fit(train_x,train_y)
pred_svm_y = clf_svm.predict(test_x)
print('Accuracy score of SVM is {}'.format(metrics.accuracy_score(pred_svm_y,test_y)) ) | Titanic - Machine Learning from Disaster |
2,302,192 | THRESHOLD = 0.35
class EpochMetricsCallback(keras.callbacks.Callback):
def on_train_begin(self, logs={}):
self.f1s = []
self.precisions = []
self.recalls = []
def on_epoch_end(self, epoch, logs={}):
predictions = self.model.predict(self.validation_data[0])
predictions =(predictions > THRESHOLD ).astype(int)
predictio... | rf = RandomForestClassifier(criterion='entropy')
param_grid_rf = {'n_estimators':[10,100,250,500,1000],
'max_features':['sqrt','log2'],'min_samples_split':[2,5,10,50,100]}
grid_rf = GridSearchCV(estimator=rf,param_grid=param_grid_rf)
grid_rf.fit(train_x,train_y)
grid_rf.best_params_ | Titanic - Machine Learning from Disaster |
2,302,192 | %time X = pad_sequences(tokenizer.texts_to_sequences(question_texts), maxlen=MAX_SEQUENCE_LENGTH)
%time Y = question_targets
%time test_word_tokens = pad_sequences(tokenizer.texts_to_sequences(test_texts), maxlen=MAX_SEQUENCE_LENGTH )<choose_model_class> | clf_rf = grid_rf.best_estimator_
clf_rf.fit(features_train,target_train)
target_test_rf = clf_rf.predict(features_test ) | Titanic - Machine Learning from Disaster |
2,302,192 | def make_model() :
tokenized_input = Input(shape=(MAX_SEQUENCE_LENGTH,), name="tokenized_input")
embedding = Embedding(MAX_WORDS, EMBEDDINGS_LOADED_DIMENSIONS,
weights=[pretrained_emb_weights],
trainable=False )(tokenized_input)
d0 = SpatialDropout1D(0.1 )(embedding)
lstm = Bidirectional(LSTM(128, return_sequences=T... | df_test['Survived'] = target_test_rf
df_test[['PassengerId','Survived']].to_csv('rf-kaggle.csv',index=False ) | Titanic - Machine Learning from Disaster |
2,302,192 | train_X, test_X, train_Y, test_Y = train_test_split(X, Y, test_size=0.01)
epoch_callback = EpochMetricsCallback()
model = make_model()
history = model.fit(x=train_X, y=train_Y, validation_split=0.015,
batch_size=BATCH_SIZE, epochs=4, verbose=2,
callbacks=[epoch_callback] )<save_to_csv> | clf_rf.fit(train_x,train_y)
pred_rf_y = clf_rf.predict(test_x)
print('Accuracy score of RF is {}'.format(metrics.accuracy_score(pred_rf_y,test_y)) ) | Titanic - Machine Learning from Disaster |
2,302,192 | test_word_tokens = pad_sequences(tokenizer.texts_to_sequences(test_texts), maxlen=MAX_SEQUENCE_LENGTH)
kaggle_predictions =(model.predict([test_word_tokens], batch_size=1024, verbose=2))
df_out = pd.DataFrame({"qid":df_test["qid"].values})
df_out['prediction'] =(kaggle_predictions > THRESHOLD ).astype(int)
df_out.to... | target_avg = 0.2 * target_test_nb + 0.3 * target_test_svm + 0.5 * target_test_rf
df_test['Survived'] = target_test_rf
df_test[['PassengerId','Survived']].to_csv('avg-kaggle.csv',index=False ) | Titanic - Machine Learning from Disaster |
2,213,168 | dim = 300
num_words = 50000
max_len = 100
print('Fiting tokenizer')
tokenizer = Tokenizer(num_words=num_words)
tokenizer.fit_on_texts(df['question_text'])
print('text to sequence')
x_train = tokenizer.texts_to_sequences(df['question_text'])
print('pad sequence')
x_train = pad_sequences(x_train,maxlen=max_len)
y_... | train_dataset = pd.read_csv('.. /input/train.csv')
test_dataset = pd.read_csv('.. /input/test.csv')
train_dataset.describe() | Titanic - Machine Learning from Disaster |
2,213,168 | print('Glove...')
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open('.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'))
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_embs.std()
prin... | y_train = train_dataset.iloc[:, 1].values
X_train = train_dataset.iloc[:, [0, 2, 4, 5, 6, 7, 11]].values
X_test = test_dataset.iloc[:, [0, 1, 3, 4, 5, 6, 10]].values
m = X_train.shape[0]
family_size_column = np.zeros(( m, 1))
X_train = np.append(X_train, family_size_column, axis=1)
X_train[:, 7] = 1 + X_train[:, 4] + ... | Titanic - Machine Learning from Disaster |
2,213,168 | print('Para...')
EMBEDDING_FILE = '.. /input/embeddings/paragram_300_sl999/paragram_300_sl999.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE, encoding="utf8", errors='ignore')if len(o)>100)
all_embs = np.stack... | nan_age_train = train_dataset[train_dataset['Age'].isnull() ]
nan_age_train.shape[0] | Titanic - Machine Learning from Disaster |
2,213,168 | matrixes = [embedding_matrix_glov,embedding_matrix_para]
matrix = np.mean(matrixes,axis=0)
del embedding_matrix_glov,embedding_matrix_para
gc.collect()<load_from_csv> | nan_age_test = test_dataset[test_dataset['Age'].isnull() ]
nan_age_test.shape[0] | Titanic - Machine Learning from Disaster |
2,213,168 | print('Loading test data...')
df_final = pd.read_csv('.. /input/test.csv')
df_final["question_text"].fillna("_
x_test=tokenizer.texts_to_sequences(df_final['question_text'])
x_test = pad_sequences(x_test,maxlen=max_len)
print('Test data loaded:',x_test.shape )<import_modules> | nan_embarked_train = train_dataset[train_dataset['Embarked'].isnull() ]
nan_embarked_train.shape[0] | Titanic - Machine Learning from Disaster |
2,213,168 | class CyclicLR(Callback):
def __init__(self, base_lr=0.001, max_lr=0.006, step_size=2000., mode='triangular',
gamma=1., scale_fn=None, scale_mode='cycle'):
super(CyclicLR, self ).__init__()
self.base_lr = base_lr
self.max_lr = max_lr
self.step_size = step_size
self.mode = mode
self.gamma = gamma
if scale_fn == None:
... | nan_embarked_test = test_dataset[test_dataset['Embarked'].isnull() ]
nan_embarked_test.shape[0] | Titanic - Machine Learning from Disaster |
2,213,168 | search_result = threshold_search(y_train, train_meta)
print(search_result)
df_subm = pd.DataFrame()
df_subm['qid'] = df_final.qid
df_subm['prediction'] = test_meta > search_result['threshold']
print(df_subm.head())
df_subm.to_csv('submission.csv', index=False )<import_modules> | imputer = SimpleImputer(missing_values = np.nan, strategy= 'mean')
imputer = imputer.fit(X_train[:, 3:4])
X_train[:, 3:4] = imputer.transform(X_train[:, 3:4])
imputer = imputer.fit(X_test[:, 3:4])
X_test[:, 3:4] = imputer.transform(X_test[:, 3:4])
X_train = np.delete(X_train, [4], 1)
X_test = np.delete(X_test, [4... | Titanic - Machine Learning from Disaster |
2,213,168 | import re
import time
import gc
import random
import os
import numpy as np
import pandas as pd
from tqdm import tqdm
from sklearn.model_selection import train_test_split
from sklearn import metrics
from sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklearn.metrics import f1_score, roc_auc_score
from... | ct = ColumnTransformer(
[('oh_enc', OneHotEncoder(sparse=False), [2]),],
remainder='passthrough'
)
X_train = ct.fit_transform(X_train)
X_test = ct.fit_transform(X_test)
labelencoder_y = LabelEncoder()
y_train = labelencoder_y.fit_transform(y_train ) | Titanic - Machine Learning from Disaster |
2,213,168 | def seed_torch(seed=1011):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True<define_variables> | X_train = np.delete(X_train, [1], 1)
print(X_train[0:5, :])
X_train.shape | 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.