kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,261,262 | 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_df.Embarked.value_counts() | Titanic - Machine Learning from Disaster |
14,261,262 | x_train, x_val, x_test, y_train, y_val, train_features, val_features, test_features, word_index = load_and_prec()
<save_model> | train_df.Embarked.isnull().sum() | Titanic - Machine Learning from Disaster |
14,261,262 | np.save("x_train",x_train)
np.save("x_val",x_val)
np.save("x_test",x_test)
np.save("y_train",y_train)
np.save("y_val",y_val)
np.save("train_features",train_features)
np.save("val_features",val_features)
np.save("test_features",test_features)
np.save("word_index.npy",word_index )<normalization> | test_df.Embarked.isnull().sum() | Titanic - Machine Learning from Disaster |
14,261,262 | 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... | train_df.Name.str.split('.' ).str[0].str.split(',' ).str[1].value_counts() | Titanic - Machine Learning from Disaster |
14,261,262 | splits = list(StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=SEED ).split(x_train, y_train))
splits[:3]<choose_model_class> | test_df.Name.str.split('.' ).str[0].str.split(',' ).str[1].value_counts() | Titanic - Machine Learning from Disaster |
14,261,262 | 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... | title_dict = {
'Mr': 'Mr',
'Miss': 'Miss',
'Mrs': 'Mrs',
'Master': 'Master',
'Dr': 'Officer',
'Rev': 'Officer',
'Major': 'Officer',
'Col': 'Officer',
'Mlle': 'Miss',
'the Countess': 'Royalty',
'Don': 'Royalty',
'Mme': 'Mrs',
'Jonkheer': 'Royalty',
'Sir': 'Royalty',
'Ms': 'Mrs',
'Lady': 'Royalty',
'Capt': 'Officer',
'Do... | Titanic - Machine Learning from Disaster |
14,261,262 | 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... | train_df.Title.value_counts() | Titanic - Machine Learning from Disaster |
14,261,262 | 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_df['NameLen'] = train_df.Name.str.split().str.len()
test_df['NameLen'] = test_df.Name.str.split().str.len() | Titanic - Machine Learning from Disaster |
14,261,262 | 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> | train_df.Age.isnull().sum() | Titanic - Machine Learning from Disaster |
14,261,262 | 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... | age_pclass_title_map = train_df.groupby(['Pclass', 'Title', 'Sex'] ).median().reset_index() [['Pclass', 'Title', 'Sex', 'Age']]
age_pclass_title_map | Titanic - Machine Learning from Disaster |
14,261,262 | def sigmoid(x):
return 1 /(1 + np.exp(-x))
train_preds = np.zeros(( len(x_train)))
val_preds = np.zeros(( len(x_val)))
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.da... | def get_age(row):
return age_pclass_title_map[(age_pclass_title_map['Pclass']==row['Pclass'])&
(age_pclass_title_map['Title']==row['Title'])&
(age_pclass_title_map['Sex']==row['Sex'])]['Age'].values[0]
for df in dataset:
df.Age = df.apply(lambda row: get_age(row)if np.isnan(row['Age'])else row['Age'], axis=1 ) | Titanic - Machine Learning from Disaster |
14,261,262 | for i,(train_idx, valid_idx)in enumerate(splits):
x_train = np.array(x_train)
y_train = np.array(y_train)
train_features = np.array(train_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... | test_df.Age.isna().sum() | Titanic - Machine Learning from Disaster |
14,261,262 | 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... | def age_type(row):
if row['Age'] < 14:
return 'Child'
elif row['Age'] < 24:
return 'Youth'
elif row['Age'] <= 40:
return 'Adult'
elif row['Age'] <= 60:
return 'MiddleAged'
else:
return 'Senior'
for df in dataset:
df['AgeType'] = df.apply(lambda row: age_type(row), axis=1 ) | Titanic - Machine Learning from Disaster |
14,261,262 | submission = df_test[['qid']].copy()
submission['prediction'] =(test_preds > delta ).astype(int)
submission.to_csv('submission.csv', index=False )<feature_engineering> | train_df.AgeType.isna().sum() | Titanic - Machine Learning from Disaster |
14,261,262 | 3500/len(x_test )<set_options> | test_df[test_df.Fare.isna() ] | Titanic - Machine Learning from Disaster |
14,261,262 | 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> | train_df[(train_df.Pclass==3)&(train_df.AgeType=='Senior')&(train_df.Embarked=='S')&(train_df.Title=='Mr')]['Fare'].mean() | Titanic - Machine Learning from Disaster |
14,261,262 | 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"... | test_df.Fare.fillna(7.00625, inplace=True ) | Titanic - Machine Learning from Disaster |
14,261,262 | dim = 300
num_words = 75966
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_... | dataset[1][dataset[1].Fare.isna() ] | Titanic - Machine Learning from Disaster |
14,261,262 | 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... | test_df[test_df.Fare.isna() ] | Titanic - Machine Learning from Disaster |
14,261,262 | 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... | def getFareType(row):
if -0.512 < row['Fare'] <= 102.466:
return '1'
elif 102.466 < row['Fare'] <= 204.932:
return '2'
elif 204.932 < row['Fare'] <= 307.398:
return '3'
elif 409.863 < row['Fare'] <= 512.329:
return '5'
else :
return '4'
test_df['FareType'] = test_df.apply(lambda row: getFareType(row), axis=1)
test_df.... | Titanic - Machine Learning from Disaster |
14,261,262 | matrixes = [embedding_matrix_glov,embedding_matrix_para]
matrix = np.mean(matrixes,axis=0)
del embedding_matrix_glov,embedding_matrix_para
gc.collect()<train_model> | test_df.FareType.value_counts() | Titanic - Machine Learning from Disaster |
14,261,262 | 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... | for df in dataset:
df['FamilySize'] = df.Parch + df.SibSp + 1
train_df.FamilySize.value_counts() | Titanic - Machine Learning from Disaster |
14,261,262 | def threshold_search(y_true, y_proba):
best_threshold = 0
best_score = 0
for threshold in [i * 0.01 for i in range(100)]:
with warnings.catch_warnings() :
warnings.simplefilter("ignore")
score = f1_score(y_true=y_true, y_pred=y_proba > threshold)
if score > best_score:
best_threshold = threshold
best_score = score
be... | for df in dataset:
df['Single'] = df.FamilySize.map(lambda size: 1 if size==1 else 0)
df['Medium'] = df.FamilySize.map(lambda size: 1 if 2<=size<=4 else 0)
df['Large'] = df.FamilySize.map(lambda size: 1 if size>4 else 0 ) | Titanic - Machine Learning from Disaster |
14,261,262 | 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'] ).astype(int)
print(df_subm.head())
df_subm.to_csv('submission.csv', index=False )<import_modules> | for df in dataset:
df.drop(['PassengerId', 'Name', 'SibSp', 'Parch', 'Ticket', 'Cabin', 'FamilySize', 'Age', 'Fare'], inplace=True, axis=1 ) | Titanic - Machine Learning from Disaster |
14,261,262 | tqdm.pandas(desc='Progress')
<define_variables> | train_df.isnull().any() | Titanic - Machine Learning from Disaster |
14,261,262 | embed_size = 300
max_features = 120000
maxlen = 70
batch_size = 512
n_epochs = 7
n_splits = 4
SEED = random.randint(0,10000 )<set_options> | test_df.isnull().any() | Titanic - Machine Learning from Disaster |
14,261,262 | 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> | oh_cols = ['Pclass', 'Embarked', 'Title', 'AgeType', 'FareType']
train_df = pd.get_dummies(train_df, columns=oh_cols, prefix=oh_cols)
test_df = pd.get_dummies(test_df, columns=oh_cols, prefix=oh_cols)
train_df.head() | Titanic - Machine Learning from Disaster |
14,261,262 | 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_df.drop(['FareType_5'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,261,262 | 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> | test_df2 = pd.read_csv('/kaggle/input/titanic/test.csv' ) | 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
vocab = build_vocab(df['question_text'] )<define_variables> | X, y = train_df.drop(['Survived'], axis=1),train_df['Survived'] | 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> | def compute_score(clf, X, y, cv, scoring='accuracy'):
xval = cross_val_score(clf, X, y, cv = cv, scoring=scoring)
return np.mean(xval ) | 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... | cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=1)
model_lgbm = LGBMClassifier(
boosting='dart',
objective='binary',
metric='binary_logloss,auc',
bagging_freq=5, bagging_fraction=0.75
)
score_lgbm = compute_score(model_lgbm, X=X, y=y, cv=cv)
model_lgbm.fit(X, y)
predictions_lgbm = model_lgbm.predict(... | Titanic - Machine Learning from Disaster |
14,261,262 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=1)
model_xgbc = XGBClassifier(learning_rate=0.01,
n_estimators=1800,
max_depth=7,
objective= 'binary:logistic', subsample=0.5,
min_split_loss=1)
score_xgbc = compute_score(model_xgbc, X=X, y=y, cv=cv)
model_xgbc.fit(X, y)
predictions_xgbc = model_xgbc.pre... | Titanic - Machine Learning from Disaster |
14,261,262 | <train_model><EOS> | cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=1)
model_rf = RandomForestClassifier(n_estimators=1000, max_features='sqrt', max_depth=4)
score_rf = compute_score(model_rf, X=X, y=y, cv=cv)
model_rf.fit(X, y)
predictions_rf = model_rf.predict(test_df)
output_rf = pd.DataFrame({'PassengerId': test_df2[... | Titanic - Machine Learning from Disaster |
14,269,685 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_model> | data = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
14,269,685 | 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> | data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,269,685 | 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> | data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,269,685 | seed_everything()
glove_embeddings = load_glove(word_index)
paragram_embeddings = load_para(word_index)
embedding_matrix = np.mean([glove_embeddings, paragram_embeddings], axis=0)
del glove_embeddings, paragram_embeddings
gc.collect()
np.shape(embedding_matrix )<split> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
14,269,685 | splits = list(StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=SEED ).split(x_train, y_train))
splits[:3]<choose_model_class> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
14,269,685 | 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... | mean_age = data.groupby(['Sex','Pclass'])['Age'].mean()
mean_age.reset_index(name = 'm_Age' ) | Titanic - Machine Learning from Disaster |
14,269,685 | 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 fill_Ages(row):
if pd.isnull(row['Age']):
return mean_age[row['Sex'],row['Pclass']]
else:
return row['Age']
data['Age'] =data.apply(fill_Ages, axis=1 ) | Titanic - Machine Learning from Disaster |
14,269,685 | 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... | mean_age = test.groupby(['Sex','Pclass'])['Age'].mean()
mean_age.reset_index(name = 'm_Age')
test['Age'] =test.apply(fill_Ages, axis=1)
test.Fare.fillna(test.Fare.mean() ,inplace=True ) | Titanic - Machine Learning from Disaster |
14,269,685 | 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 )<define_variables> | data.Embarked.value_counts() | Titanic - Machine Learning from Disaster |
14,269,685 | def sigmoid(x):
return 1 /(1 + np.exp(-x))
train_preds = []
for i in range(n_epochs):
train_preds.append([])
train_preds[i] = np.zeros(( len(x_train)))
test_preds = []
for i in range(n_epochs):
test_preds.append([])
test_preds[i] = np.zeros(( len(x_test)))
seed_everything()
x_test_cuda = torch.tensor(x_test, dtype=... | data.Embarked.fillna('S', inplace=True ) | Titanic - Machine Learning from Disaster |
14,269,685 | global_test_saver = []
for i in range(n_epochs):
global_test_saver.append([])
for split_idx,(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_... | data['Title'] = data.Name.str.extract(r',\s*([^\.]*)\s*\.',expand=False)
test['Title'] = test.Name.str.extract(r',\s*([^\.]*)\s*\.',expand=False)
data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
14,269,685 | import matplotlib.pyplot as plt<feature_engineering> | def Fare_group(fare):
a = 0
if(fare <= 50):
a = 1
elif(fare <= 100):
a = 2
elif(fare <=150):
a = 3
else:
a = 4
return a
data['Fare Group'] = data.Fare.map(Fare_group)
test['Fare Group'] = test.Fare.map(Fare_group)
| Titanic - Machine Learning from Disaster |
14,269,685 | def cal_diff(global_test_saver,delta):
diff = np.zeros([n_splits,n_splits])
for ii in range(n_splits):
for jj in range(ii,n_splits):
diff[ii,jj] = int(np.sum(np.abs(global_test_saver[ii] - global_test_saver[jj])))
diff_sum = np.sum(diff)
a = diff_sum /(n_splits)/(n_splits - 1)* 2 /len(global_test_saver[0])
for ii i... | def Age_group(age):
a = 0
if(age <= 10):
a = 1
elif(age <= 20):
a = 2
elif(age <=40):
a = 3
else:
a = 4
return a
data['Age Group'] = data.Age.map(Age_group)
test['Age Group'] = test.Age.map(Age_group)
| Titanic - Machine Learning from Disaster |
14,269,685 | diff_1s = []
diff_2s = []
cv_scores = []
test_scores = []
for epoch in range(n_epochs):
delta,score = bestThresshold(y_train,train_preds[epoch])
diff_1,diff_2,diff_3 = cal_diff(global_test_saver[epoch],delta)
diff_1s.append(diff_1)
diff_2s.append(diff_2)
cv_scores.append(score)
test_score = f1_score(y_test, np.arr... | data['Sex'] = data.Sex.apply(lambda x:1 if x=='female' else 2)
test['Sex'] = test.Sex.apply(lambda x:1 if x=='female' else 2 ) | Titanic - Machine Learning from Disaster |
14,269,685 | %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> | data['Embarked'] = data.Embarked.apply(lambda x:1 if x=='S' else(2 if x=='C' else 3))
test['Embarked'] = test.Embarked.apply(lambda x:1 if x=='S' else(2 if x=='C' else 3)) | Titanic - Machine Learning from Disaster |
14,269,685 | 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> | data['No_fam_mem'] = data['SibSp'] + data['Parch']
data.drop(['SibSp','Parch', 'Ticket'], axis=1, inplace=True)
test['No_fam_mem'] = test['SibSp'] + test['Parch']
test.drop(['SibSp','Parch', 'Ticket'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,269,685 | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
sub = pd.read_csv('.. /input/sample_submission.csv' )<count_values> | data.No_fam_mem.value_counts() | Titanic - Machine Learning from Disaster |
14,269,685 | train["target"].value_counts()<split> | def fam_type(fam_size):
a = 0
if(fam_size==0):
a = 1
elif(fam_size<= 5):
a = 2
else:
a = 3
return a
data['Fam size'] = data.No_fam_mem.map(fam_type)
data.drop('No_fam_mem', axis=1, inplace=True)
data = data[['PassengerId', 'Pclass', 'Title', 'Sex', 'Age', 'Age Group', 'Fam size', 'Fare', 'Fare Group', 'Embarked', 'Ca... | Titanic - Machine Learning from Disaster |
14,269,685 | 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> | data.Cabin.value_counts() | Titanic - Machine Learning from Disaster |
14,269,685 | 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> | data.Cabin = data.Cabin.map(lambda x: x[0])
test.Cabin = test.Cabin.map(lambda x: x[0])
data.Cabin.value_counts() | Titanic - Machine Learning from Disaster |
14,269,685 | 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)))) )<define_variables> | deck_map = {'U':1, 'A':2, 'B':3, 'C':4, 'D':5, 'E':6, 'F':7, 'G':8, 'T':9}
data['Deck'] = data['Cabin']
data.Deck = data.Deck.map(deck_map)
data.drop('Cabin', axis=1, inplace=True)
test['Deck'] = test['Cabin']
test.Deck = test.Deck.map(deck_map)
test.drop('Cabin', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,269,685 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,269,685 | 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> | data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,269,685 | train_tokenized = tk.texts_to_sequences(train['question_text'].fillna('missing'))
test_tokenized = tk.texts_to_sequences(test['question_text'].fillna('missing'))<categorify> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
14,269,685 | 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> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
14,269,685 | y_train = train['target'].values<compute_test_metric> | data['class_age'] = data['Pclass']*data['Age']
data['class_title'] = data['Pclass']*data['Title']
data['class_gen'] = data['Pclass']*data['Sex']
data['fam_fare'] = data['Fam size']*data['Fare']
data['em_fare'] = data['Embarked']*data['Fare']
data['title_age'] = data['Title']*data['Age']
test['class_age'] = test['Pclass... | Titanic - Machine Learning from Disaster |
14,269,685 | def sigmoid(x):
return 1 /(1 + np.exp(-x))<split> | data.drop(['Age', 'Fare'], axis=1, inplace=True)
test.drop(['Age', 'Fare'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,269,685 | splits = list(StratifiedKFold(n_splits=4, shuffle=True, random_state=10 ).split(X_train, y_train))<statistical_test> | scaler = MinMaxScaler()
col_lst = [ 'Pclass', 'Title', 'Age Group', 'Fam size', 'Fare Group', 'Embarked',
'Deck', 'class_age', 'class_title', 'class_gen', 'fam_fare', 'em_fare', 'title_age']
data[col_lst] = scaler.fit_transform(data[col_lst])
test[col_lst] = scaler.fit_transform(test[col_lst] ) | Titanic - Machine Learning from Disaster |
14,269,685 | 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... | data = data[['Pclass', 'Title', 'Sex', 'Age Group', 'Fam size', 'Fare Group', 'Embarked', 'Deck', 'class_age',
'class_title', 'class_gen', 'fam_fare', 'em_fare', 'title_age', 'Survived']]
test = test[['PassengerId', 'Pclass', 'Title', 'Sex', 'Age Group', 'Fam size', 'Fare Group', 'Embarked', 'Deck', 'class_age',
'class... | Titanic - Machine Learning from Disaster |
14,269,685 | 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... | kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=1)
test_2 = test.drop('PassengerId', axis=1 ).copy()
target = data['Survived']
train = data.drop('Survived', axis=1 ) | Titanic - Machine Learning from Disaster |
14,269,685 | embedding_matrix = np.mean([embedding_matrix, embedding_matrix1], axis=0)
del embedding_matrix1
<normalization> | X_train, X_test, y_train, y_test = train_test_split(train, target, test_size=0.3, random_state=1)
X_train.shape, X_test.shape, y_train.shape, y_test.shape | Titanic - Machine Learning from Disaster |
14,269,685 | 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... | from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier | Titanic - Machine Learning from Disaster |
14,269,685 | m = NeuralNet()<train_model> | def model_score(model, X_train=X_train, X_test=X_test, y_train=y_train, y_test=y_test):
model.fit(X_train, y_train)
model_score = model.score(X_test, y_test)*100
return model_score | Titanic - Machine Learning from Disaster |
14,269,685 | 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)
... | def cv_score(model):
cv_score = cross_val_score(model, train, target, cv=kf, scoring='accuracy')
return cv_score.mean() *100 | Titanic - Machine Learning from Disaster |
14,269,685 | 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> | print('Cross val score for LR : ', cv_score(LogisticRegression()))
print('LR Score : ', model_score(LogisticRegression()),'
')
print('Cross val score for RF : ', cv_score(RandomForestClassifier(n_estimators=100, max_depth=7, min_samples_split=2,
min_samples_leaf=6, max_features='auto', random_state=1)))
print('RF Sco... | Titanic - Machine Learning from Disaster |
14,269,685 | 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... | xgbc = XGBClassifier(max_depth=15, min_child_weight=1, n_estimators=500, random_state=42, learning_rate=0.01,
eval_metric=["error", "logloss"])
xgbc.fit(X_train,y_train, early_stopping_rounds=15, eval_set=[(X_train, y_train),(X_test, y_test)], verbose=True)
| Titanic - Machine Learning from Disaster |
14,269,685 | 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... | y_pred_xgbc = xgbc.predict(X_test ) | Titanic - Machine Learning from Disaster |
14,269,685 | 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> | xgbc_score_train = xgbc.score(X_train, y_train)
print("Train Prediction Score",xgbc_score_train*100)
xgbc_score_test = accuracy_score(y_test,y_pred_xgbc)
print("Test Prediction Score",xgbc_score_test*100 ) | Titanic - Machine Learning from Disaster |
14,269,685 | tqdm.pandas(desc='Progress')
<define_variables> | xgbc.fit(train, target)
prediction_xgbc = xgbc.predict(test_2 ) | Titanic - Machine Learning from Disaster |
14,269,685 | embed_size = 300
max_features = 120000
maxlen = 70
batch_size = 512
n_epochs = 5
n_splits = 5
SEED = 1029<set_options> | model=RandomForestClassifier(n_estimators=100, max_depth=7, min_samples_split=2,min_samples_leaf=6, max_features='auto', random_state=1)
model.fit(train, target)
pred_dt = model.predict(test_2 ) | Titanic - Machine Learning from Disaster |
14,269,685 | 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 = SVC(C=20)
model.fit(train, target)
pred_svc = model.predict(test_2 ) | Titanic - Machine Learning from Disaster |
14,269,685 | 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... | sub = pd.DataFrame({'PassengerId': test['PassengerId'], 'Survived':pred_svc})
sub.to_csv('sample_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,287,016 | 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 )<define_variables> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv')
y = train_data.Survived
X = train_data.drop(['Survived'], axis = 1)
X.info() | Titanic - Machine Learning from Disaster |
14,287,016 | 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("<define_variables> | X_train_full, X_valid_full, y_train, y_valid = train_test_split(X,y, test_size = 0.2, random_state = 0 ) | Titanic - Machine Learning from Disaster |
14,287,016 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | categorical_cols = [cname for cname in X_train_full.columns if X_train_full[cname].nunique() < 10 and
X_train_full[cname].dtype == "object"]
numerical_cols = [cname for cname in X_train_full.columns if X_train_full[cname].dtype in ['int64', 'float64']]
my_cols = categorical_cols + numerical_cols
X_train = X_train_full[... | Titanic - Machine Learning from Disaster |
14,287,016 | 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... | numerical_transformer = SimpleImputer(strategy='mean')
categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='most_frequent')) ,
('onehot', OneHotEncoder(handle_unknown='ignore'))
])
preprocessor = ColumnTransformer(
transformers=[
('num', numerical_transformer, numerical_cols),
('cat', c... | Titanic - Machine Learning from Disaster |
14,287,016 | %%time
x_train, x_test, y_train, features, test_features, word_index = load_and_prec()<save_model> | X_train = preprocessor.fit_transform(X_train)
X_valid = preprocessor.transform(X_valid ) | Titanic - Machine Learning from Disaster |
14,287,016 | 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> | from xgboost import XGBClassifier | Titanic - Machine Learning from Disaster |
14,287,016 | 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> | model = XGBClassifier(n_estimators=200, learning_rate=0.01)
model.fit(X_train, y_train, early_stopping_rounds=5,
eval_set=[(X_valid, y_valid)],
verbose=False ) | Titanic - Machine Learning from Disaster |
14,287,016 | 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... | predictions = model.predict(X_valid ) | Titanic - Machine Learning from Disaster |
14,287,016 | np.save("embedding_matrix",embedding_matrix )<load_pretrained> | accuracy_score(y_valid, predictions ) | Titanic - Machine Learning from Disaster |
14,287,016 | embedding_matrix = np.load("embedding_matrix.npy" )<split> | PassengerId = test_data.PassengerId,
test_data = preprocessor.transform(test_data)
final_predictions = model.predict(test_data ) | Titanic - Machine Learning from Disaster |
14,287,016 | <choose_model_class><EOS> | output = pd.DataFrame({'PassengerId': PassengerId[0],
'Survived': final_predictions})
output.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,602,777 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<choose_model_class> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
14,602,777 | embedding_dim = 300
embedding_path = '.. /save/embedding_matrix.npy'
use_pretrained_embedding = True
hidden_size = 64
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... | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
all_data = [train,test] | Titanic - Machine Learning from Disaster |
14,602,777 | 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... | print(train[['Sex', 'Survived']].groupby(['Sex'], as_index=False ).mean())
| Titanic - Machine Learning from Disaster |
14,602,777 | class NeuralNet(nn.Module):
def __init__(self):
super(NeuralNet, self ).__init__()
fc_layer = 16
fc_layer1 = 16
nbr_filers_1cnn = 5
nbr_filers_2cnn = 10
self.embedding = nn.Embedding(max_features, embed_size)
self.embedding.weight = nn.Parameter(torch.tensor(embedding_matrix, dtype=torch.float32))
self.embedding.weigh... | print(train[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean())
| Titanic - Machine Learning from Disaster |
14,602,777 | 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 )<define_variables> | for dataset in all_data:
dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1
print(train[['FamilySize', 'Survived']].groupby(['FamilySize'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
14,602,777 | 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 = train.drop(['Parch', 'SibSp'], axis=1)
test = test.drop(['Parch', 'SibSp'], axis=1)
all_data = [train, test]
train.head()
| Titanic - Machine Learning from Disaster |
14,602,777 | seed_everything()
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... | for dataset in all_data:
dataset['Sex'] = dataset['Sex'].map({'female': 0, 'male': 1} ).astype(int)
train.head() | Titanic - Machine Learning from Disaster |
14,602,777 | 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
delta... | guess_ages = np.zeros(( 2,3))
guess_ages
| Titanic - Machine Learning from Disaster |
14,602,777 | submission = df_test[['qid']].copy()
submission['prediction'] =(test_preds > delta ).astype(int)
submission.to_csv('submission.csv', index=False )<load_from_csv> | for dataset in all_data:
for i in range(0, 2):
for j in range(0, 3):
guess_data = dataset[(dataset['Sex'] == i)& \
(dataset['Pclass'] == j+1)]['Age'].dropna()
age_guess = guess_data.median()
guess_ages[i,j] = int(age_guess/0.5 + 0.5)* 0.5
for i in range(0, 2):
for j in range(0, 3):
dataset.loc[(dataset.Age.isnull())&(... | Titanic - Machine Learning from Disaster |
14,602,777 | text = torchtext.data.Field(lower=True, batch_first=True, tokenize=word_tokenize, fix_length=100)
qid = torchtext.data.Field()
target = torchtext.data.Field(sequential=False, use_vocab=False, is_target=True)
train_dataset = torchtext.data.TabularDataset(path='.. /input/train.csv', format='csv',
fields={'question_text... | train['Age_group'] = pd.cut(train['Age'], 5)
train[['Age_group', 'Survived']].groupby(['Age_group'], as_index=False ).mean().sort_values(by='Age_group', ascending=True)
| Titanic - Machine Learning from Disaster |
14,602,777 | glove = torchtext.vocab.Vectors('.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt')
text.vocab.set_vectors(glove.stoi, glove.vectors, dim=300 )<train_model> | for dataset in all_data:
dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0
dataset.loc[(dataset['Age'] > 16)&(dataset['Age'] <= 32), 'Age'] = 1
dataset.loc[(dataset['Age'] > 32)&(dataset['Age'] <= 48), 'Age'] = 2
dataset.loc[(dataset['Age'] > 48)&(dataset['Age'] <= 64), 'Age'] = 3
dataset.loc[ dataset['Age'] > 64, 'Age']
t... | Titanic - Machine Learning from Disaster |
14,602,777 | 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
if... | train = train.drop(['Age_group'], axis=1)
all_data = [train, test]
train.head()
| Titanic - Machine Learning from Disaster |
14,602,777 | torch.cuda.init()
torch.cuda.empty_cache()
print('CUDA MEM:',torch.cuda.memory_allocated())
print('cuda:', torch.cuda.is_available())
print('cude index:',torch.cuda.current_device())
batch_size = 512
print('batch_size:',batch_size)
print('---')
train_loader = torchtext.data.BucketIterator(dataset=train,
batch_size... | for dataset in all_data:
dataset['Embarked'] = dataset['Embarked'].fillna('S')
print(train[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False ).mean())
| 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.