kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,420,831 | tqdm.pandas(desc='Progress')
<define_variables> | tuned_LR = LogisticRegression(C= 11.288378916846883, max_iter= 100, penalty= 'l1', random_state= 42, solver= 'liblinear')
get_model_accuracy(tuned_LR ) | Titanic - Machine Learning from Disaster |
13,420,831 | embed_size = 300
max_features = 120000
maxlen = 70
batch_size = 512
n_epochs = 5
n_splits = 5
SEED = 1029<set_options> | param_grid = {
'random_state': [42],
'C': [.1,.3, 1, 3],
'kernel': ['rbf'],
'gamma': [.03,.1,.3, 1]
}
clf_SVC = GridSearchCV(SVC, param_grid=param_grid, cv=5, verbose=True, n_jobs=-1)
best_clf_SVC = clf_SVC.fit(X_train_scaled, y_train)
clf_performance(best_clf_SVC ) | Titanic - Machine Learning from Disaster |
13,420,831 | def seed_everything(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
seed_everything()<features_selection> | print_valid_params("'C': 3, 'gamma': 0.03, 'kernel': 'rbf', 'random_state': 42" ) | Titanic - Machine Learning from Disaster |
13,420,831 | 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... | tuned_SVC = svm.SVC(C= 3, gamma= 0.03, kernel= 'rbf', random_state= 42, probability=True)
get_model_accuracy(tuned_SVC ) | Titanic - Machine Learning from Disaster |
13,420,831 | df_train = pd.read_csv(".. /input/train.csv")
df_test = pd.read_csv(".. /input/test.csv")
df = pd.concat([df_train ,df_test],sort=True )<feature_engineering> | param_grid = {
'n_neighbors': [3, 5, 7, 9],
'weights': ['uniform', 'distance'],
'algorithm': ['auto', 'ball_tree', 'kd_tree'],
'p': [1, 2]
}
clf_KNN = GridSearchCV(KNN, param_grid=param_grid, cv=5, verbose=True, n_jobs=-1)
best_clf_KNN = clf_KNN.fit(X_train_scaled, y_train)
clf_performance(best_clf_KNN ) | Titanic - Machine Learning from Disaster |
13,420,831 | 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
vocab = build_vocab(df['question_text'] )<define_variables> | print_valid_params("'algorithm': 'auto', 'n_neighbors': 7, 'p': 2, 'weights': 'uniform'" ) | Titanic - Machine Learning from Disaster |
13,420,831 | sin = len(df_train[df_train["target"]==0])
insin = len(df_train[df_train["target"]==1])
persin =(sin/(sin+insin)) *100
perinsin =(insin/(sin+insin)) *100
print("
print("<feature_engineering> | tuned_KNN = KNeighborsClassifier(algorithm= 'auto', n_neighbors= 7, p= 2, weights= 'uniform')
get_model_accuracy(tuned_KNN ) | Titanic - Machine Learning from Disaster |
13,420,831 | 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... | param_grid = {
'random_state': [42],
'n_estimators': [10, 30, 100, 300, 1000],
'bootstrap': [True, False],
'max_depth': [1, 3, 10, 30, 100, None],
'max_features': ['auto', 'sqrt'],
'min_samples_leaf': [1, 3, 10, 30],
'min_samples_split': [2, 4, 7, 10]
}
clf_RFC = RandomizedSearchCV(RFC, param_distributions=param_grid, ... | Titanic - Machine Learning from Disaster |
13,420,831 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | print_valid_params("'random_state': 42, 'n_estimators': 30, 'min_samples_split': 7, 'min_samples_leaf': 1, 'max_features': 'sqrt', 'max_depth': None, 'bootstrap': False" ) | Titanic - Machine Learning from Disaster |
13,420,831 | def add_features(df):
df['question_text'] = df['question_text'].progress_apply(lambda x:str(x))
df['total_length'] = df['question_text'].progress_apply(len)
df['capitals'] = df['question_text'].progress_apply(lambda comment: sum(1 for c in comment if c.isupper()))
df['caps_vs_length'] = df.progress_apply(lambda row: f... | tuned_RFC = RandomForestClassifier(random_state= 42, n_estimators= 30, min_samples_split= 7, min_samples_leaf= 1, max_features= 'sqrt', max_depth= None, bootstrap= False)
get_model_accuracy(tuned_RFC ) | Titanic - Machine Learning from Disaster |
13,420,831 | x_train, x_test, y_train, features, test_features, word_index = load_and_prec()
<save_model> | param_grid = {
'random_state': [42],
'n_estimators': [100, 300],
'learning_rate': [.1,.3, 1],
'max_depth': [1, 2, 3, 10],
'min_samples_split': [.1,.3, 1, 3, 10],
'min_samples_leaf': [.1,.3, 1, 3]
}
clf_GB = GridSearchCV(GB, param_grid=param_grid, cv=5, verbose=True, n_jobs=-1)
best_clf_GB = clf_GB.fit(X_train_scaled, ... | Titanic - Machine Learning from Disaster |
13,420,831 | np.save("x_train",x_train)
np.save("x_test",x_test)
np.save("y_train",y_train)
np.save("features",features)
np.save("test_features",test_features)
np.save("word_index.npy",word_index )<load_pretrained> | print_valid_params("'learning_rate': 0.1, 'max_depth': 3, 'min_samples_leaf': 3, 'min_samples_split': 0.1, 'n_estimators': 300, 'random_state': 42" ) | Titanic - Machine Learning from Disaster |
13,420,831 | x_train = np.load("x_train.npy")
x_test = np.load("x_test.npy")
y_train = np.load("y_train.npy")
features = np.load("features.npy")
test_features = np.load("test_features.npy")
word_index = np.load("word_index.npy" ).item()<normalization> | tuned_GB = GradientBoostingClassifier(learning_rate= 0.1, max_depth= 3, min_samples_leaf= 3, min_samples_split= 0.1, n_estimators= 300, random_state= 42)
get_model_accuracy(tuned_GB ) | Titanic - Machine Learning from Disaster |
13,420,831 | seed_everything()
glove_embeddings = load_glove(word_index)
paragram_embeddings = load_para(word_index)
fasttext_embeddings = load_fasttext(word_index)
embedding_matrix = np.mean([glove_embeddings, paragram_embeddings, fasttext_embeddings], axis=0)
del glove_embeddings, paragram_embeddings, fasttext_embeddings
gc.c... | params = {
'weights': [[1, 1, 1], [1, 1, 2], [1, 2, 1], [2, 1, 1], [1, 2, 2], [2, 1, 2], [2, 2, 1]]
}
vote_weight = GridSearchCV(voting_clf_best_3, param_grid=params, cv=5, verbose=True, n_jobs=-1)
best_clf_weight = vote_weight.fit(X_train_scaled, y_train)
clf_performance(best_clf_weight ) | Titanic - Machine Learning from Disaster |
13,420,831 | splits = list(StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=SEED ).split(x_train, y_train))
splits[:3]<choose_model_class> | print_valid_params("'weights': [1, 1, 2]" ) | Titanic - Machine Learning from Disaster |
13,420,831 | 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... | weighted_voting_clf_best_3 = VotingClassifier(
estimators=[('SVC', SVC),('RFC', RFC),('KNN', KNN)],
voting='soft',
weights= [1, 1, 2]
)
get_model_accuracy(weighted_voting_clf_best_3 ) | Titanic - Machine Learning from Disaster |
13,420,831 | embedding_dim = 300
embedding_path = '.. /save/embedding_matrix.npy'
use_pretrained_embedding = True
hidden_size = 60
gru_len = hidden_size
Routings = 4
Num_capsule = 5
Dim_capsule = 5
dropout_p = 0.25
rate_drop_dense = 0.28
LR = 0.001
T_epsilon = 1e-7
num_classes = 30
class Embed_Layer(nn.Module):
def __init__(self, e... | def submission_to_csv(y_preds, filename='submission.csv'):
submission = {'PassengerId': test_data.PassengerId, 'survived': y_preds}
submission_df = pd.DataFrame(data=submission)
submission_csv = submission_df.to_csv(filename, index=False)
return(submission_csv ) | Titanic - Machine Learning from Disaster |
13,420,831 | 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... | tuned_RFC.fit(X_train_scaled, y_train)
tuned_RFC_preds = tuned_RFC.predict(X_test_scaled)
submission_to_csv(tuned_RFC_preds, 'RFC_submission.csv' ) | Titanic - Machine Learning from Disaster |
13,420,831 | 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> | tuned_GB.fit(X_train_scaled, y_train)
tuned_GB_preds = tuned_GB.predict(X_test_scaled)
submission_to_csv(tuned_GB_preds, 'GB_clf_submission.csv' ) | Titanic - Machine Learning from Disaster |
13,420,831 | class FocalLoss(nn.Module):
def __init__(self, alpha=1, gamma=2, logits=True, reduction='elementwise_mean'):
super(FocalLoss, self ).__init__()
self.alpha = alpha
self.gamma = gamma
self.logits = logits
self.reduction = reduction
def forward(self, inputs, targets):
if self.logits:
BCE_loss = F.binary_cross_entropy_with... | weighted_voting_clf_best_3.fit(X_train_scaled, y_train)
weighted_voting_clf_best_3_preds = weighted_voting_clf_best_3.predict(X_test_scaled)
submission_to_csv(weighted_voting_clf_best_3_preds, 'soft_voting_clf_submission.csv' ) | Titanic - Machine Learning from Disaster |
14,344,676 | def sigmoid(x):
return 1 /(1 + np.exp(-x))
train_preds = np.zeros(( len(x_train)))
test_preds = np.zeros(( len(df_test)))
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_... | train = pd.read_csv("/kaggle/input/titanic/train.csv")
test = pd.read_csv("/kaggle/input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
14,344,676 | for i,(train_idx, valid_idx)in enumerate(splits):
x_train = np.array(x_train)
y_train = np.array(y_train)
features = np.array(features)
x_train_fold = torch.tensor(x_train[train_idx.astype(int)], dtype=torch.long ).cuda()
y_train_fold = torch.tensor(y_train[train_idx.astype(int), np.newaxis], dtype=torch.float32 ).c... | train.groupby('Pclass' ).mean() ['Survived']*100 | Titanic - Machine Learning from Disaster |
14,344,676 | def bestThresshold(y_train,train_preds):
tmp = [0,0,0]
delta = 0
for tmp[0] in tqdm(np.arange(0.3, 0.601, 0.001)) :
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
delt... | train.isna().sum() | Titanic - Machine Learning from Disaster |
14,344,676 | submission = df_test[['qid']].copy()
submission['prediction'] =(test_preds > delta ).astype(int)
submission.to_csv('submission.csv', index=False )<import_modules> | print(train.isna().sum() ,'
', test.isna().sum())
| Titanic - Machine Learning from Disaster |
14,344,676 | import os
import time
import numpy as np
import pandas as pd
from tqdm import tqdm
import math
from sklearn.model_selection import train_test_split
from sklearn import metrics
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from keras.layers import Dense, Input, LST... | train[train['Embarked'].isna() == True] | Titanic - Machine Learning from Disaster |
14,344,676 | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv")
print("Train shape : ",train_df.shape)
print("Test shape : ",test_df.shape )<split> | train['Embarked'] = train['Embarked'].fillna(value='S' ) | Titanic - Machine Learning from Disaster |
14,344,676 | train_df, val_df = train_test_split(train_df, test_size=0.1, random_state=2018)
embed_size = 300
max_features = 50000
maxlen = 100
train_X = train_df["question_text"].fillna("_na_" ).values
val_X = val_df["question_text"].fillna("_na_" ).values
test_X = test_df["question_text"].fillna("_na_" ).values
tokenizer = Token... | train = pd.get_dummies(train, columns=['Embarked'], drop_first=True)
train = pd.get_dummies(train, columns=['Sex'], drop_first=True)
test = pd.get_dummies(test, columns=['Embarked'], drop_first=True)
test = pd.get_dummies(test, columns=['Sex'], drop_first=True)
| Titanic - Machine Learning from Disaster |
14,344,676 | 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))
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_em... | train.drop(['Name','Ticket'],axis=1,inplace=True)
test.drop(['Name','Ticket'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
14,344,676 | model.fit(train_X, train_y, batch_size=512, epochs=2, validation_data=(val_X, val_y))<predict_on_test> | train.Cabin.isna().sum() /len(train.Cabin)*100 | Titanic - Machine Learning from Disaster |
14,344,676 | pred_glove_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_glove_val_y>thresh ).astype(int))))<predict_on_test> | train = train.drop('Cabin',axis=1)
test = test.drop('Cabin',axis=1 ) | Titanic - Machine Learning from Disaster |
14,344,676 | pred_glove_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | def imputeAge(cols):
Age = cols[0]
Pclass = cols[1]
if(pd.isnull(Age)) :
if(Pclass==1):
return 37
if Pclass==2:
return 29
else:
return 24
else:
return Age | Titanic - Machine Learning from Disaster |
14,344,676 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<statistical_test> | train['Age']= train[['Age','Pclass']].apply(imputeAge,axis=1)
test['Age']= test[['Age','Pclass']].apply(imputeAge,axis=1 ) | Titanic - Machine Learning from Disaster |
14,344,676 | EMBEDDING_FILE = '.. /input/embeddings/wiki-news-300d-1M/wiki-news-300d-1M.vec'
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)if len(o)>100)
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_em... | test['Fare'] = test['Fare'].fillna(( test.Fare.mean()))
train['Fare'] = train['Fare'].fillna(( train.Fare.mean())) | Titanic - Machine Learning from Disaster |
14,344,676 | model.fit(train_X, train_y, batch_size=512, epochs=2, validation_data=(val_X, val_y))<predict_on_test> | Titanic - Machine Learning from Disaster | |
14,344,676 | pred_fasttext_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_fasttext_val_y>thresh ).astype(int))))<predict_on_test> | y = train['Survived']
features = ['PassengerId','Pclass','Age','SibSp','Sex_male','Parch','Embarked_Q','Embarked_S','Fare']
X = train[features]
X_test = test[features]
model = RandomForestClassifier(n_estimators=100,max_depth=5,random_state=1)
model.fit(X,y)
| Titanic - Machine Learning from Disaster |
14,344,676 | pred_fasttext_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | predictions = model.predict(X_test ) | Titanic - Machine Learning from Disaster |
14,344,676 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<statistical_test> | output = pd.DataFrame({'PassengerId': X_test.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
14,646,784 | EMBEDDING_FILE = '.. /input/embeddings/paragram_300_sl999/paragram_300_sl999.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE, encoding="utf8", errors='ignore')if len(o)>100)
all_embs = np.stack(embeddings_index.... | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
14,646,784 | model.fit(train_X, train_y, batch_size=512, epochs=2, validation_data=(val_X, val_y))<predict_on_test> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
14,646,784 | pred_paragram_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_paragram_val_y>thresh ).astype(int))))<predict_on_test> | train_data.groupby('Sex' ).Survived.mean() | Titanic - Machine Learning from Disaster |
14,646,784 | pred_paragram_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | train_data.groupby('Pclass' ).Survived.mean() | Titanic - Machine Learning from Disaster |
14,646,784 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<compute_test_metric> | train_data.isnull() | Titanic - Machine Learning from Disaster |
14,646,784 | pred_val_y = 0.30*pred_glove_val_y + 0.35*pred_fasttext_val_y + 0.35*pred_paragram_val_y
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_val_y>thresh ).astype(int))))<save_to_csv> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,646,784 | pred_test_y = 0.30*pred_glove_test_y + 0.35*pred_fasttext_test_y + 0.35*pred_paragram_test_y
pred_test_y =(pred_test_y>0.36 ).astype(int)
out_df = pd.DataFrame({"qid":test_df["qid"].values})
out_df['prediction'] = pred_test_y
out_df.to_csv("submission.csv", index=False )<import_modules> | train_data.drop(["Name","Cabin"], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,646,784 | tqdm.pandas(desc='Progress')
<define_variables> | train_data['Age'].fillna(value=train_data['Age'].mean() , inplace=True ) | Titanic - Machine Learning from Disaster |
14,646,784 | embed_size = 300
max_features = 120000
maxlen = 70
batch_size = 512
n_epochs = 5
n_splits = 5
SEED = 1029<set_options> | train_data['Embarked'] = train_data['Embarked'].fillna(value=train_data['Embarked'].mode() [0] ) | Titanic - Machine Learning from Disaster |
14,646,784 | def seed_everything(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
seed_everything()<features_selection> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,646,784 | 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... | train_data['Sex'] = train_data['Sex'].replace(['male', 'female'],[1,0])
train_data.rename(columns = {'Sex' : 'gender'}, inplace = True ) | Titanic - Machine Learning from Disaster |
14,646,784 | df_train = pd.read_csv(".. /input/train.csv")
df_test = pd.read_csv(".. /input/test.csv")
df = pd.concat([df_train ,df_test],sort=True )<feature_engineering> | train_data['Embarked'] = train_data['Embarked'].replace(['S','C','Q'],[0,1,2])
train_data.rename(columns = {'Embarked' : 'port'}, inplace = True ) | Titanic - Machine Learning from Disaster |
14,646,784 | 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
vocab = build_vocab(df['question_text'] )<define_variables> | train_data.rename(columns = {'Pclass' : 'passenger_cls'} ) | Titanic - Machine Learning from Disaster |
14,646,784 | sin = len(df_train[df_train["target"]==0])
insin = len(df_train[df_train["target"]==1])
persin =(sin/(sin+insin)) *100
perinsin =(insin/(sin+insin)) *100
print("
print("<feature_engineering> | train_data['family_members'] = train_data['SibSp'] + train_data['Parch']
train_data.drop(['SibSp', 'Parch'], axis = 1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,646,784 | 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... | train_data.loc[ train_data['Age'] <= 21, 'Age'] = 0
train_data.loc[(train_data['Age'] > 21)&(train_data['Age'] <= 34), 'Age'] = 1
train_data.loc[(train_data['Age'] > 34)&(train_data['Age'] <= 54), 'Age'] = 2
train_data.loc[(train_data['Age'] > 60)&(train_data['Age'] <= 75), 'Age'] = 3
train_data.loc[ train_data['Age'] ... | Titanic - Machine Learning from Disaster |
14,646,784 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | train_data.loc[ train_data['Fare'] <= 7.5, 'Fare'] = 0
train_data.loc[(train_data['Fare'] > 15)&(train_data['Fare'] <= 21.5), 'Fare'] = 1
train_data.loc[(train_data['Fare'] > 21.5)&(train_data['Age'] <= 29), 'Fare'] = 2
train_data.loc[(train_data['Fare'] > 29)&(train_data['Fare'] <= 36.5), 'Fare'] = 3
train_data.loc[ t... | Titanic - Machine Learning from Disaster |
14,646,784 | def add_features(df):
df['question_text'] = df['question_text'].progress_apply(lambda x:str(x))
df['total_length'] = df['question_text'].progress_apply(len)
df['capitals'] = df['question_text'].progress_apply(lambda comment: sum(1 for c in comment if c.isupper()))
df['caps_vs_length'] = df.progress_apply(lambda row: f... | train_data.drop(['Ticket'], axis = 1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,646,784 | x_train, x_test, y_train, features, test_features, word_index = load_and_prec()
<save_model> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,646,784 | np.save("x_train",x_train)
np.save("x_test",x_test)
np.save("y_train",y_train)
np.save("features",features)
np.save("test_features",test_features)
np.save("word_index.npy",word_index )<load_pretrained> | test_data.drop(['Name', 'Ticket','Cabin'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
14,646,784 | x_train = np.load("x_train.npy")
x_test = np.load("x_test.npy")
y_train = np.load("y_train.npy")
features = np.load("features.npy")
test_features = np.load("test_features.npy")
word_index = np.load("word_index.npy" ).item()<normalization> | test_data['Age'].fillna(value=test_data['Age'].mean() , inplace=True ) | Titanic - Machine Learning from Disaster |
14,646,784 | seed_everything()
glove_embeddings = load_glove(word_index)
paragram_embeddings = load_para(word_index)
fasttext_embeddings = load_fasttext(word_index)
embedding_matrix = np.mean([glove_embeddings, paragram_embeddings, fasttext_embeddings], axis=0)
del glove_embeddings, paragram_embeddings, fasttext_embeddings
gc.c... | test_data['Fare'].fillna(value=test_data['Fare'].mean() , inplace=True ) | Titanic - Machine Learning from Disaster |
14,646,784 | splits = list(StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=SEED ).split(x_train, y_train))
splits[:3]<choose_model_class> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,646,784 | 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... | test_data['Sex'] = test_data['Sex'].replace(['male', 'female'],[1,0])
test_data.rename(columns = {'Sex' : 'gender'}, inplace = True ) | Titanic - Machine Learning from Disaster |
14,646,784 | embedding_dim = 300
embedding_path = '.. /save/embedding_matrix.npy'
use_pretrained_embedding = True
hidden_size = 60
gru_len = hidden_size
Routings = 4
Num_capsule = 5
Dim_capsule = 5
dropout_p = 0.25
rate_drop_dense = 0.28
LR = 0.001
T_epsilon = 1e-7
num_classes = 30
class Embed_Layer(nn.Module):
def __init__(self, e... | test_data['Embarked'] = test_data['Embarked'].replace(['S','C','Q'],[0,1,2])
test_data.rename(columns = {'Embarked' : 'port'}, inplace = True ) | Titanic - Machine Learning from Disaster |
14,646,784 | 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... | test_data.rename(columns = {'Pclass' : 'passenger cls'} ) | Titanic - Machine Learning from Disaster |
14,646,784 | 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> | test_data['family_members'] = test_data['SibSp'] + test_data['Parch']
test_data.drop(['SibSp', 'Parch'], axis = 1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,646,784 | class FocalLoss(nn.Module):
def __init__(self, alpha=1, gamma=2, logits=True, reduction='elementwise_mean'):
super(FocalLoss, self ).__init__()
self.alpha = alpha
self.gamma = gamma
self.logits = logits
self.reduction = reduction
def forward(self, inputs, targets):
if self.logits:
BCE_loss = F.binary_cross_entropy_with... | test_data.loc[ test_data['Age'] <= 21, 'Age'] = 0
test_data.loc[(test_data['Age'] > 21)&(test_data['Age'] <= 34), 'Age'] = 1
test_data.loc[(test_data['Age'] > 34)&(test_data['Age'] <= 54), 'Age'] = 2
test_data.loc[(test_data['Age'] > 60)&(test_data['Age'] <= 75), 'Age'] = 3
test_data.loc[ test_data['Age'] > 75, 'Age'] ... | Titanic - Machine Learning from Disaster |
14,646,784 | def sigmoid(x):
return 1 /(1 + np.exp(-x))
train_preds = np.zeros(( len(x_train)))
test_preds = np.zeros(( len(df_test)))
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_... | test_data.loc[ test_data['Fare'] <= 7.5, 'Fare'] = 0
test_data.loc[(test_data['Fare'] > 15)&(test_data['Fare'] <= 21.5), 'Fare'] = 1
test_data.loc[(test_data['Fare'] > 21.5)&(test_data['Age'] <= 29), 'Fare'] = 2
test_data.loc[(test_data['Fare'] > 29)&(test_data['Fare'] <= 36.5), 'Fare'] = 3
test_data.loc[ test_data['Fa... | Titanic - Machine Learning from Disaster |
14,646,784 | for i,(train_idx, valid_idx)in enumerate(splits):
x_train = np.array(x_train)
y_train = np.array(y_train)
features = np.array(features)
x_train_fold = torch.tensor(x_train[train_idx.astype(int)], dtype=torch.long ).cuda()
y_train_fold = torch.tensor(y_train[train_idx.astype(int), np.newaxis], dtype=torch.float32 ).c... | x = train_data.drop("Survived", axis = 1 ) | Titanic - Machine Learning from Disaster |
14,646,784 | def bestThresshold(y_train,train_preds):
tmp = [0,0,0]
delta = 0
for tmp[0] in tqdm(np.arange(0.3, 0.601, 0.001)) :
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
delt... | y = train_data["Survived"] | Titanic - Machine Learning from Disaster |
14,646,784 | submission = df_test[['qid']].copy()
submission['prediction'] =(test_preds > delta ).astype(int)
submission.to_csv('submission.csv', index=False )<set_options> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
14,646,784 | %matplotlib inline
pd.set_option('max_colwidth',400)
warnings.filterwarnings("ignore", message="F-score is ill-defined and being set to 0.0 due to no predicted samples.")
<set_options> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
14,646,784 | 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<load_from_csv> | x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.4, random_state = 12 ) | Titanic - Machine Learning from Disaster |
14,646,784 | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
sub = pd.read_csv('.. /input/sample_submission.csv' )<count_values> | dtree = DecisionTreeClassifier()
dtree.fit(x_train, y_train)
y_pred = dtree.predict(x_test)
dtree_accuracy = round(accuracy_score(y_pred, y_test)* 100, 2)
print(dtree_accuracy ) | Titanic - Machine Learning from Disaster |
14,646,784 | train["target"].value_counts()<split> | randomforest = RandomForestClassifier(n_estimators=30, max_depth = 4)
randomforest.fit(x_train, y_train)
y_pred = randomforest.predict(x_test)
acc_randomforest = round(accuracy_score(y_pred, y_test)* 100, 2)
print(acc_randomforest ) | Titanic - Machine Learning from Disaster |
14,646,784 | print('Average word length of questions in train is {0:.0f}.'.format(np.mean(train['question_text'].apply(lambda x: len(x.split())))))
print('Average word length of questions in test is {0:.0f}.'.format(np.mean(test['question_text'].apply(lambda x: len(x.split())))) )<string_transform> | logreg = LogisticRegression(solver='liblinear', dual = False)
logreg.fit(x_train, y_train)
y_pred = logreg.predict(x_test)
acc_log = round(logreg.score(x_train, y_train)* 100, 2)
acc_log
accuracy_score(y_test, y_pred ) | Titanic - Machine Learning from Disaster |
14,646,784 | print('Max word length of questions in train is {0:.0f}.'.format(np.max(train['question_text'].apply(lambda x: len(x.split())))))
print('Max word length of questions in test is {0:.0f}.'.format(np.max(test['question_text'].apply(lambda x: len(x.split())))) )<compute_test_metric> | dt = RandomForestClassifier(n_estimators=30, max_depth = 4 ) | Titanic - Machine Learning from Disaster |
14,646,784 | print('Average character length of questions in train is {0:.0f}.'.format(np.mean(train['question_text'].apply(lambda x: len(x)))))
print('Average character length of questions in test is {0:.0f}.'.format(np.mean(test['question_text'].apply(lambda x: len(x)))) )<train_model> | dt.fit(x_train, y_train ) | Titanic - Machine Learning from Disaster |
14,646,784 | max_features = 120000
tk = Tokenizer(lower = True, filters='', num_words=max_features)
full_text = list(train['question_text'].values)+ list(test['question_text'].values)
tk.fit_on_texts(full_text )<string_transform> | y_test_predict = dt.predict(x_test ) | Titanic - Machine Learning from Disaster |
14,646,784 | train_tokenized = tk.texts_to_sequences(train['question_text'].fillna('missing'))
test_tokenized = tk.texts_to_sequences(test['question_text'].fillna('missing'))<categorify> | print(classification_report(y_test, y_test_predict)) | Titanic - Machine Learning from Disaster |
14,646,784 | max_len = 72
maxlen = 72
X_train = pad_sequences(train_tokenized, maxlen = max_len)
X_test = pad_sequences(test_tokenized, maxlen = max_len )<prepare_x_and_y> | x_test = test_data | Titanic - Machine Learning from Disaster |
14,646,784 | y_train = train['target'].values<compute_test_metric> | y_test_predict = dt.predict(test_data ) | Titanic - Machine Learning from Disaster |
14,646,784 | <split><EOS> | output_data = pd.DataFrame({'PassengerId' : test_data.PassengerId, 'Survived' : y_test_predict})
output_data.to_csv('Titanic_Survival_Decision_Tree', index = False)
print("Submission is successfully" ) | Titanic - Machine Learning from Disaster |
14,395,164 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<statistical_test> | import pandas as pd
from sklearn.tree import DecisionTreeClassifier | Titanic - Machine Learning from Disaster |
14,395,164 | embed_size = 300
embedding_path = ".. /input/embeddings/glove.840B.300d/glove.840B.300d.txt"
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embedding_index = dict(get_coefs(*o.split(" ")) for o in open(embedding_path, encoding='utf-8', errors='ignore'))
emb_mean,emb_std = -0.005838499, 0.48782... | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
14,395,164 | embedding_path = ".. /input/embeddings/paragram_300_sl999/paragram_300_sl999.txt"
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embedding_index = dict(get_coefs(*o.split(" ")) for o in open(embedding_path, encoding='utf-8', errors='ignore')if len(o)>100)
emb_mean,emb_std = -0.0053247833, 0.4... | train = train.drop(["Name", "Ticket", "Cabin"], axis=1)
test = test.drop(["Name", "Ticket", "Cabin"], axis=1 ) | Titanic - Machine Learning from Disaster |
14,395,164 | embedding_matrix = np.mean([embedding_matrix, embedding_matrix1], axis=0)
del embedding_matrix1<normalization> | new_data_train = pd.get_dummies(train)
new_data_test = pd.get_dummies(test ) | Titanic - Machine Learning from Disaster |
14,395,164 | 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... | new_data_train.isnull().sum().sort_values(ascending=False ).head(10 ) | Titanic - Machine Learning from Disaster |
14,395,164 | m = NeuralNet()<train_model> | new_data_train["Age"].fillna(new_data_train["Age"].mean() , inplace=True)
new_data_test["Age"].fillna(new_data_test["Age"].mean() , inplace=True ) | Titanic - Machine Learning from Disaster |
14,395,164 | def train_model(model, x_train, y_train, x_val, y_val, validate=True):
optimizer = torch.optim.Adam(model.parameters())
train = torch.utils.data.TensorDataset(x_train, y_train)
valid = torch.utils.data.TensorDataset(x_val, y_val)
train_loader = torch.utils.data.DataLoader(train, batch_size=batch_size, shuffle=True)
... | new_data_test.isnull().sum().sort_values(ascending=False ).head(10 ) | Titanic - Machine Learning from Disaster |
14,395,164 | x_test_cuda = torch.tensor(X_test, dtype=torch.long ).cuda()
test = torch.utils.data.TensorDataset(x_test_cuda)
batch_size = 512
test_loader = torch.utils.data.DataLoader(test, batch_size=batch_size, shuffle=False )<compute_train_metric> | new_data_test["Fare"].fillna(new_data_test["Fare"].mean() , inplace=True ) | Titanic - Machine Learning from Disaster |
14,395,164 | seed=1029
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)], disable=True):
score = f1_score(y_true=y_true, y_pred=y_proba > threshold)
if score > best_score:
best_threshold = threshold
best_score = score
search_result = {'threshold': best_thr... | X = new_data_train.drop("Survived", axis=1)
y = new_data_train["Survived"] | Titanic - Machine Learning from Disaster |
14,395,164 | train_preds = np.zeros(len(train))
test_preds = np.zeros(( len(test), len(splits)))
n_epochs = 5
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.newaxis], dtype=torch.float32 ).cuda()
x_val_fol... | tree = DecisionTreeClassifier(max_depth = 10, random_state = 0)
tree.fit(X, y ) | Titanic - Machine Learning from Disaster |
14,395,164 | search_result = threshold_search(y_train, train_preds)
sub['prediction'] = test_preds.mean(1)> search_result['threshold']
sub.to_csv("submission.csv", index=False )<import_modules> | tree.score(X, y)
| Titanic - Machine Learning from Disaster |
14,395,164 | tqdm.pandas(desc='Progress')
<define_variables> | from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
14,395,164 | embed_size = 300
max_features = 120000
maxlen = 70
batch_size = 512
n_epochs = 5
n_splits = 5
SEED = 1029<set_options> | Xtrain, Xvalidation, Ytrain, Yvalidation = train_test_split(X, y, test_size=0.2, random_state=True ) | Titanic - Machine Learning from Disaster |
14,395,164 | def seed_everything(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
seed_everything()<features_selection> | model = RandomForestClassifier(n_estimators=100,
max_leaf_nodes=12,
max_depth=12,
random_state=0)
model.fit(Xtrain, Ytrain ) | Titanic - Machine Learning from Disaster |
14,395,164 | 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... | model.score(Xtrain, Ytrain ) | Titanic - Machine Learning from Disaster |
14,395,164 | df_train = pd.read_csv(".. /input/train.csv")
df_test = pd.read_csv(".. /input/test.csv")
df = pd.concat([df_train ,df_test],sort=True )<feature_engineering> | Yprediction = model.predict(Xvalidation)
accuracy_score(Yvalidation, Yprediction ) | Titanic - Machine Learning from Disaster |
14,395,164 | 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
vocab = build_vocab(df['question_text'] )<define_variables> | submission = pd.DataFrame()
submission["PassengerId"] = Xtest["PassengerId"]
submission["Survived"] = model.predict(Xtest)
submission.to_csv("submission.csv", index=False ) | Titanic - Machine Learning from Disaster |
14,261,262 | sin = len(df_train[df_train["target"]==0])
insin = len(df_train[df_train["target"]==1])
persin =(sin/(sin+insin)) *100
perinsin =(insin/(sin+insin)) *100
print("
print("<feature_engineering> | import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt | Titanic - Machine Learning from Disaster |
14,261,262 | 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... | train_df = pd.read_csv('/kaggle/input/titanic/train.csv')
test_df = pd.read_csv('/kaggle/input/titanic/test.csv')
dataset = [train_df, test_df]
dataset[0].head() | Titanic - Machine Learning from Disaster |
14,261,262 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | for df in dataset:
df.Sex = df.Sex.map({'male':0, 'female': 1})
train_df.Sex.unique() | 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.