kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
8,512,706 | best_model2.load(net, optimizer )<train_model> | from fastai.tabular import * | Titanic - Machine Learning from Disaster |
8,512,706 | train_network(net, optimizer,criterion,train_loader,val_loader,10, 3,best_model)
best_model.load(net, optimizer )<load_pretrained> | procs = [FillMissing, Categorify, Normalize]
dep_var = 'Survived'
cat_names = ['Sex', 'Cabin', 'Embarked']
cont_names = ['PassengerId', 'Pclass', 'Age', 'SibSp', 'Parch', 'SibSp']
X=train[cont_names]
X=train[cat_names] | Titanic - Machine Learning from Disaster |
8,512,706 | best_model.load(net, optimizer )<predict_on_test> | data =(TabularList.from_df(train, procs=procs, cont_names=cont_names, cat_names=cat_names)
.split_by_idx(valid_idx=range(int(len(train)*0.9),len(train)))
.label_from_df(cols=dep_var)
.add_test(TabularList.from_df(X_test, cat_names=cat_names, cont_names=cont_names, procs=procs))
.databunch())
print(data.train_ds.cont_... | Titanic - Machine Learning from Disaster |
8,512,706 | def predict_loader(network, loader):
network.eval()
all_predictions = []
with torch.no_grad() :
for X,_ in tqdm_notebook(loader, total=len(loader)) :
X = X.cuda()
out = network(X ).view(-1)
out = torch.sigmoid(out)
all_predictions.extend(out.tolist())
return np.array(all_predictions )<predict_on_test> | learn = tabular_learner(data, layers=[1000,500], metrics=accuracy, wd=0.1 ) | Titanic - Machine Learning from Disaster |
8,512,706 | network_pred = predict_loader(net, val_loader )<set_options> | learn.fit_one_cycle(5, 2.5e-2 ) | Titanic - Machine Learning from Disaster |
8,512,706 | print(net.embedding.weight.requires_grad )<find_best_params> | learn.fit_one_cycle(5, 2.6e-9 ) | Titanic - Machine Learning from Disaster |
8,512,706 | prc = metrics.precision_recall_curve(val_labels.values, network_pred, pos_label=1 )<import_modules> | learn.save('stage-1' ) | Titanic - Machine Learning from Disaster |
8,512,706 | import matplotlib.pyplot as plt<compute_test_metric> | preds, _ = learn.get_preds(ds_type=DatasetType.Test)
pred_prob, pred_class = preds.max(1 ) | Titanic - Machine Learning from Disaster |
8,512,706 | exact_predictions = np.round(network_pred)
print(metrics.classification_report(val_labels.values, exact_predictions))<compute_test_metric> | submission = pd.DataFrame({'PassengerId': X_test.PassengerId, 'Survived':pred_class} ) | Titanic - Machine Learning from Disaster |
8,512,706 | <statistical_test><EOS> | submission.to_csv('my_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
5,523,792 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<find_best_params> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn import preprocessing
from keras.models import Sequential
from keras.layers import Dense, Dropout | Titanic - Machine Learning from Disaster |
5,523,792 | max_f1_index = np.argmax(f1_scores)
best_threshold = thresholds[max_f1_index]
print(best_threshold)
print(f1_scores[max_f1_index] )<data_type_conversions> | train_data = pd.read_csv('.. /input/titanic/train.csv')
test_data = pd.read_csv('.. /input/titanic/test.csv')
train_data_copy = train_data.copy()
test_data_copy = test_data.copy() | Titanic - Machine Learning from Disaster |
5,523,792 | def thresholded_predictions(probs, threshold):
return(probs > threshold ).astype(np.int8 )<compute_train_metric> | test_data['Test'] = 1
train_data['Test'] = 0
data = train_data.append(test_data, sort = False)
drop_cols = list()
one_hot_encoding_cols = list()
normalization_cols = list() | Titanic - Machine Learning from Disaster |
5,523,792 | exact_predictions = thresholded_predictions(network_pred, best_threshold)
print(metrics.classification_report(val_labels.values, exact_predictions))<compute_test_metric> | data.drop('PassengerId', axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
5,523,792 | print(metrics.confusion_matrix(val_labels.values, exact_predictions))<find_best_params> | data['Pclass'].value_counts(dropna = False)
normalization_cols.append('Pclass' ) | Titanic - Machine Learning from Disaster |
5,523,792 | def test_weights(network):
network.eval()
with torch.no_grad() :
xx, yy = next(iter(val_loader))
xx, yy = xx.cuda() , yy.cuda()
print(xx[10], [vocab.itos[w] for w in xx[10]])
weights = network.get_attention_weights(xx)
print(weights.size())
return weights.cpu()
<normalization> | data['Title'] = data['Name'].str.extract('([A-Za-z]+)\.', expand=True)
data.drop('Name', axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
5,523,792 | attn = test_weights(net)
show_attention(15,attn,val_tokens[:256] )<define_variables> | data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
5,523,792 | def print_examples(questions, labels, y_pred):
assert len(questions)== len(labels)== len(y_pred)
sample = np.random.choice(len(questions),size=1000, replace=False)
questions, labels, y_pred = questions[sample], labels[sample], y_pred[sample]
positive_pred = y_pred == 1
negative_pred = ~positive_pred
positives = label... | mapping = {'Col': 'Army', 'Mlle' : 'Miss', 'Major' : 'Army', 'Sir': 'Royal',
'Mme': 'Mrs', 'Capt' : 'Army', 'Don' : 'Royal', 'Jonkheer' : 'Royal',
'Ms' : 'Miss', 'Countess' : 'Royal', 'Lady': 'Royal'}
data.replace({'Title': mapping}, inplace=True ) | Titanic - Machine Learning from Disaster |
5,523,792 | val_questions = quora_data.iloc[list(val_labels.index)].question_text.values<compute_test_metric> | data['Sex'].value_counts(dropna = False ) | Titanic - Machine Learning from Disaster |
5,523,792 | print_examples(val_questions, val_labels.values, exact_predictions )<find_best_params> | label_encoder = preprocessing.LabelEncoder()
data['Sex'] = label_encoder.fit_transform(data['Sex'])
data.head() | Titanic - Machine Learning from Disaster |
5,523,792 | print(net.embedding.weight.data )<data_type_conversions> | data[data['Test'] == 0].groupby(['Title', 'Sex'] ).Age.mean() | Titanic - Machine Learning from Disaster |
5,523,792 | tuned_embeddings = net.embedding.weight.data.cpu().numpy()<import_modules> | data.loc[(data.Age.isna())&(data.Sex == 1)&(data.Title == 'Army'), 'Age'] = 56.60
data.loc[(data.Age.isna())&(data.Sex == 1)&(data.Title == 'Dr'), 'Age'] = 49.00
data.loc[(data.Age.isna())&(data.Sex == 0)&(data.Title == 'Dr'), 'Age'] = 40.60
data.loc[(data.Age.isna())&(data.Sex == 1)&(data.Title == 'Master'), 'Age'] = ... | Titanic - Machine Learning from Disaster |
5,523,792 | from sklearn import decomposition<normalization> | data['SibSp'].value_counts()
normalization_cols.append('SibSp' ) | Titanic - Machine Learning from Disaster |
5,523,792 | def get_trajectory(batch):
X = batch.cuda()
with torch.no_grad() :
states = net.get_hidden(X)
probs = F.sigmoid(net(X)).view(-1 ).cpu().numpy()
print(states.shape)
pca = decomposition.PCA(2)
timesteps = states.shape[0]
batch_size = states.shape[1]
states = torch.transpose(states,0,1)
pca_points = pca.fit_transform(... | data['Parch'].value_counts()
normalization_cols.append('Parch')
data.head() | Titanic - Machine Learning from Disaster |
5,523,792 | batch, _ = next(iter(val_loader))
pca, probs = get_trajectory(batch)
toks = val_tokens[:len(batch)]
<import_modules> | data.drop('Ticket', axis =1, inplace = True ) | Titanic - Machine Learning from Disaster |
5,523,792 | import matplotlib.colors<define_variables> | normalization_cols.append('Fare')
| Titanic - Machine Learning from Disaster |
5,523,792 | cdict = {'red':(( 0.0, 0.0, 0.0),
(1/6., 0.0, 0.0),
(1/2., 0.8, 1.0),
(5/6., 1.0, 1.0),
(1.0, 0.4, 1.0)) ,
'green':(( 0.0, 0.0, 0.4),
(1/6., 1.0, 1.0),
(1/2., 1.0, 0.8),
(5/6., 0.0, 0.0),
(1.0, 0.0, 0.0)) ,
'blue':(( 0.0, 0.0, 0.0),
(1/6., 0.0, 0.0),
(1/2., 0.9, 0.9),
(5/6., 0.0, 0.0),
(1.0, 0.0, 0.0))
}
cm... | data['HasCabin'] = data['Cabin'].isnull() == False
data['HasCabin'].replace(False, 0, inplace = True)
data['HasCabin'].replace(True, 1, inplace = True)
data.drop('Cabin', axis =1, inplace = True ) | Titanic - Machine Learning from Disaster |
5,523,792 | sel_word = 'iq'
nearest_neighbors(vocab, np_vectors, sel_word, 10, True)
print('
after_training
')
nearest_neighbors(vocab, tuned_embeddings, sel_word, 10, False )<compute_train_metric> | one_hot_encoding_cols.append('Embarked' ) | Titanic - Machine Learning from Disaster |
5,523,792 | def ngram_neighbors(conv_layer, vocab, vectors, idx):
ngram = conv_layer.weight.data[idx].cpu().numpy()
ngram = ngram.T
sims = pairwise.cosine_similarity(ngram, vectors)
ranking = np.argsort(sims,axis=1)[:,::-1]
for i, row in enumerate(ranking):
print(i)
for j in range(10):
word_index = ranking[i,j]
sim = sims[i, wor... | data = pd.get_dummies(data = data, columns = one_hot_encoding_cols ) | Titanic - Machine Learning from Disaster |
5,523,792 | test_dataset = TokenToIdDataset(test_tokens,np.broadcast_to(np.zeros(1),shape=(len(test_tokens,))),vocab,min_size=25, precompute=True )<load_pretrained> | std = data[data['Test'] == 0][normalization_cols].std(axis = 0)
mean = data[data['Test'] == 0][normalization_cols].mean(axis = 0)
data[normalization_cols] =(data[normalization_cols] - mean)/ std | Titanic - Machine Learning from Disaster |
5,523,792 | test_loader = torch.utils.data.DataLoader(test_dataset,batch_size=256,collate_fn=test_dataset.collate )<predict_on_test> | train_data = data[data['Test'] == 0].drop(columns = ['Test'])
test_data = data[data['Test'] == 1].drop(columns = ['Survived', 'Test'] ) | Titanic - Machine Learning from Disaster |
5,523,792 | network_test_pred = predict_loader(net, test_loader )<predict_on_test> | X = train_data.iloc[: , 1:].to_numpy()
y = train_data.iloc[:, 0].to_numpy()
print(str(X.shape))
print(str(y.shape)) | Titanic - Machine Learning from Disaster |
5,523,792 | exact_test_predictions = thresholded_predictions(network_test_pred, best_threshold )<create_dataframe> | def create_model() :
model = Sequential()
model.add(Dense(14, input_dim = 19, activation = 'relu'))
model.add(Dropout(0.3))
model.add(Dense(8, activation = 'relu'))
model.add(Dense(1, activation = 'sigmoid'))
model.compile(loss='binary_crossentropy', optimizer = 'adam', metrics = ['accuracy'])
return model | Titanic - Machine Learning from Disaster |
5,523,792 | submission = pd.DataFrame({'qid': quora_test_data.qid, 'prediction': exact_test_predictions} )<save_to_csv> | epochs = 20
model = create_model()
history = model.fit(X, y, epochs=epochs, validation_split = 0.3, batch_size=10 ) | Titanic - Machine Learning from Disaster |
5,523,792 | submission.to_csv('submission.csv', index=False )<save_to_csv> | epochs = 20
model = create_model()
history = model.fit(X, y, epochs=epochs, batch_size=10, verbose = 0 ) | Titanic - Machine Learning from Disaster |
5,523,792 | submission.to_csv('submission.csv', index=False )<save_to_csv> | X_test = test_data.to_numpy() | Titanic - Machine Learning from Disaster |
5,523,792 | with open('submission.csv')as f:
for line in itertools.islice(f,0,5):
print(line )<save_to_csv> | prediction = model.predict(X_test ) | Titanic - Machine Learning from Disaster |
5,523,792 | exact_test_predictions = thresholded_predictions(network_test_pred, 0.5)
submission = pd.DataFrame({'qid': quora_test_data.qid, 'prediction': exact_test_predictions})
submission.to_csv('submission_05.csv', index=False )<import_modules> | submission = pd.DataFrame(test_data_copy[['PassengerId']])
submission['Survived'] = prediction
submission['Survived'] = submission['Survived'].apply(lambda x: 0 if x < 0.5 else 1 ) | Titanic - Machine Learning from Disaster |
5,523,792 | <load_from_csv><EOS> | submission.to_csv('submission.csv', index = False ) | Titanic - Machine Learning from Disaster |
11,372,153 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | %matplotlib inline | Titanic - Machine Learning from Disaster |
11,372,153 | 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 check_coverage(vocab, embeddings_index):
known_words = {}
unknown_words = {}
nb_known_words = 0
nb_unknown_word... | X_full = pd.read_csv('.. /input/titanic/train.csv')
X_test_full = pd.read_csv('.. /input/titanic/test.csv')
X_full.dropna(axis=0, subset=['Survived'], inplace=True)
y = X_full.Survived
X_full.drop(['PassengerId'], axis=1, inplace=True)
X_train_full, X_valid_full, y_train, y_valid = train_test_split(X_full, y,
train... | Titanic - Machine Learning from Disaster |
11,372,153 | vocab = build_vocab(df['question_text'])
del df<split> | categorical_cols = ['Sex', 'Embarked']
numerical_cols = ['Pclass', 'SibSp', 'Parch']
age_col = ['Age']
fare_col = ['Fare']
complex_cols = ['Name','Ticket','Cabin']
my_cols = categorical_cols + numerical_cols + age_col + fare_col + complex_cols
X_train = X_train_full[my_cols].copy()
X_valid = X_valid_full[my_cols].copy(... | Titanic - Machine Learning from Disaster |
11,372,153 | def load_embed(file):
def get_coefs(word,*arr):
return word, np.asarray(arr, dtype='float32')
if file == '.. /input/embeddings/wiki-news-300d-1M/wiki-news-300d-1M.vec':
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(file)if len(o)>100)
else:
embeddings_index = dict(get_coefs(*o.split(" ")) for o in op... | avg_survival_chance = X_full['Survived'].mean()
avg_survival_chance_male = X_full[X_full['Sex']=='male']['Survived'].mean()
avg_survival_chance_female = X_full[X_full['Sex']=='female']['Survived'].mean()
print('all: {}, male {}, female {}'.format(avg_survival_chance, avg_survival_chance_male, avg_survival_chance_female... | Titanic - Machine Learning from Disaster |
11,372,153 | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" )<load_from_csv> | ticket_survival = X_full[['Ticket','Survived']].copy()
ticket_survival['TicketCode'] = ticket_survival['Ticket'].map(lambda c : c.split() [0])
ticket_survival['TicketCode'] = ticket_survival['TicketCode'].map(lambda c : 'NUM' if c.isdigit() else c)
ticket_survival = ticket_survival.groupby('TicketCode' ).mean().sort_... | Titanic - Machine Learning from Disaster |
11,372,153 | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" )<feature_engineering> | code_dict = {}
def split_ticket_codes(surv):
if surv < 0.05:
return 1
elif surv < 0.15:
return 2
elif surv < 0.3:
return 3
elif surv < 0.4:
return 4
elif surv < 0.48:
return 5
elif surv < 0.6:
return 6
elif surv < 0.8:
return 7
return 8
for i in ticket_survival.index:
code_dict[i] = split_ticket_codes(ticket_survival[i... | Titanic - Machine Learning from Disaster |
11,372,153 | def preprocess(df):
df["question_text"] = df["question_text"].progress_apply(lambda x: x.lower())
df["question_text"] = df["question_text"].progress_apply(lambda x: clean_contractions(x, contraction_mapping))
df["question_text"] = df["question_text"].progress_apply(lambda x: clean_special_chars(x, punct, punct_mapping... | cabin_survival = X_full[['Cabin','Survived']].copy()
cabin_survival['Code'] = cabin_survival['Cabin'].map(lambda c : str(c)[0])
cabin_survival = cabin_survival.groupby('Code' ).mean().sort_values(by='Survived')
cabin_survival | Titanic - Machine Learning from Disaster |
11,372,153 | preprocess(train )<split> | cabin_dict = {'T':1, 'n':2, 'A': 3, 'G':4, 'C':5, 'F':6, 'B':7, 'E':8, 'D':9} | Titanic - Machine Learning from Disaster |
11,372,153 | train_df, val_df = train_test_split(train, test_size=0.1, random_state=2018)
embed_size = 300
max_features = 100000
maxlen = 80
train_X = train_df["question_text"].fillna("_na_" ).values
val_X = val_df["question_text"].fillna("_na_" ).values
test_X = test["question_text"].fillna("_na_" ).values
tokenizer = Tokenizer(n... | title_dict = {'Capt':0, 'Don':1, 'Jonkheer':2, 'Rev':3,
'Mr':4,
'Dr':7,
'Col':8, 'Major':9, 'Master':10,
'Miss':11,
'Mrs':15,
'Mme':16, 'Sir':17, 'Ms':18, 'Lady':19, 'Mlle':20, 'the Countess':21,
'Don':5, 'Jonkheer':6,
'Dona':12, 'Lady':13} | Titanic - Machine Learning from Disaster |
11,372,153 | train_reserved = train
del train, train_df, val_df<load_pretrained> | train_age = X_train[['Age','Name']].append(X_test[['Age','Name']] ) | Titanic - Machine Learning from Disaster |
11,372,153 | glove = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
print("Extracting GloVe embedding")
embed_glove = load_embed(glove )<feature_engineering> | def get_title(name):
return name.split(',')[1].split('.')[0].strip()
def get_title_id(title):
return title_dict[title] if title in title_dict else 9
def get_age_per_title(x):
x['Title'] = x.Name.map(lambda x : get_title(x))
return x.groupby('Title' ).Age.mean()
avg_age_per_title = get_age_per_title(train_age ) | Titanic - Machine Learning from Disaster |
11,372,153 | add_lower(embed_glove, vocab )<compute_train_metric> | train_fare = X_train[['Fare','Pclass']].append(X_test[['Fare','Pclass']] ) | Titanic - Machine Learning from Disaster |
11,372,153 | vocab_temp = build_vocab(train_reserved['question_text'])
oov = check_coverage(vocab_temp, embed_glove)
print(oov[:20])
del oov, vocab_temp
time.sleep(5 )<feature_engineering> | def get_fare_per_pclass(x):
avg_fare = []
for i in range(1,4):
avg_fare.append(x[x['Pclass']==i]['Fare'].mean())
print('avg_fare: {}'.format(avg_fare))
return avg_fare
avg_fare = get_fare_per_pclass(train_fare ) | Titanic - Machine Learning from Disaster |
11,372,153 | embeddings_index = embed_glove
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_embs.std()
embed_size = all_embs.shape[1]
word_index = tokenizer.word_index
nb_words = min(max_features, len(word_index))
embedding_matrix = np.random.normal(emb_mean, emb_std,(nb_words, embed_size))
... | class NameAgeFeaturesTransformer(BaseEstimator, TransformerMixin):
def __init__(self):
return
def fit(self, x, y=None):
return self
def omit_garbage(self, name):
name = name.replace('(', '(')
name = name.replace(')', ')')
parts = name.split()
idx_start = -1
idx_end = -1
has_nick = 0
for p in parts:
i = p.find('(')
j... | Titanic - Machine Learning from Disaster |
11,372,153 | 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> | class CabinFeaturesTransformer(BaseEstimator, TransformerMixin):
def __init__(self):
return
def fit(self, x, y=None):
return self
def transform(self, x):
x.Cabin.fillna('n0', inplace=True)
x['CabinCode'] = x['Cabin'].map(lambda c : str(c)[0])
x['CabinCode'] = x['CabinCode'].map(lambda c : int(cabin_dict[c]))
x.drop('... | Titanic - Machine Learning from Disaster |
11,372,153 | pred_glove_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<drop_column> | class FareFeaturesTransformer(BaseEstimator, TransformerMixin):
def __init__(self):
return
def fit(self, x, y=None):
return self
def fillEmpty(self, fare, pclass):
if pd.isnull(fare):
return avg_fare[int(pclass)-1]
return fare
def transform(self, x):
x['Fare'] = x.apply(lambda c : self.fillEmpty(c['Fare'], c['Pclass'])... | Titanic - Machine Learning from Disaster |
11,372,153 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x, embed_glove
time.sleep(10 )<load_pretrained> | class TicketFeaturesTransformer(BaseEstimator, TransformerMixin):
def __init__(self):
return
def fit(self, x, y=None):
return self
def transform(self, x):
x.Ticket.fillna('NUM 0', inplace=True)
x['TicketCode'] = x['Ticket'].map(lambda c : c.split() [0])
x['TicketCode'] = x['TicketCode'].map(lambda c : c if not(c.isdi... | Titanic - Machine Learning from Disaster |
11,372,153 | wiki_news = '.. /input/embeddings/wiki-news-300d-1M/wiki-news-300d-1M.vec'
print("Extracting FastText embedding")
embed_fasttext = load_embed(wiki_news )<feature_engineering> | categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='most_frequent')) ,
('onehot', OneHotEncoder(handle_unknown='ignore'))
])
model = RandomForestClassifier(random_state=2)
preprocessor = ColumnTransformer(
transformers=[
('ticket', TicketFeaturesTransformer() , ['Ticket']),
('names', N... | Titanic - Machine Learning from Disaster |
11,372,153 | add_lower(embed_fasttext, vocab )<compute_train_metric> | parameters = {
'model__n_estimators': [560, 580, 600, 620, 640],
}
grid_search = GridSearchCV(pipeline, parameters, scoring = 'neg_mean_absolute_error', n_jobs= 1, cv=3)
grid_search.fit(X_full, y ) | Titanic - Machine Learning from Disaster |
11,372,153 | vocab_temp = build_vocab(train_reserved['question_text'])
oov = check_coverage(vocab_temp, embed_fasttext)
print(oov[:20])
del oov, vocab_temp
time.sleep(5 )<feature_engineering> | print(grid_search.best_params_)
print(-1 * grid_search.best_score_ ) | Titanic - Machine Learning from Disaster |
11,372,153 | embeddings_index = embed_fasttext
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_embs.std()
embed_size = all_embs.shape[1]
word_index = tokenizer.word_index
nb_words = min(max_features, len(word_index))
embedding_matrix = np.random.normal(emb_mean, emb_std,(nb_words, embed_size... | model = RandomForestClassifier(random_state=2, n_estimators=580)
pipeline = Pipeline(steps=[('preprocessor', preprocessor)
,('model', model)
])
pipeline.fit(X_full.drop(['Survived'], axis=1), y)
predict = pipeline.predict(X_test_full.drop(['PassengerId'], axis=1)) | Titanic - Machine Learning from Disaster |
11,372,153 | 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> | out = pd.DataFrame({'PassengerId': X_test_full['PassengerId'], 'Survived': predict})
out['Survived'] = out.apply(lambda x : int(x['Survived']), axis=1)
out.to_csv('titanicOut.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,372,153 | <drop_column><EOS> | out = pd.read_csv('titanicOut.csv')
out | Titanic - Machine Learning from Disaster |
4,557,766 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_pretrained> | warnings.filterwarnings('ignore')
%matplotlib inline
mpl.style.use('ggplot')
sns.set_style('white')
pylab.rcParams[ 'figure.figsize' ] = 8 , 6
py.init_notebook_mode(connected=True)
train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv')
full_data = [train_df, test_df]
train_df.he... | Titanic - Machine Learning from Disaster |
4,557,766 | paragram = '.. /input/embeddings/paragram_300_sl999/paragram_300_sl999.txt'
print("Extracting Paragram embedding")
embed_paragram = load_embed(paragram )<compute_test_metric> | def check_missing_data(df):
flag=df.isna().sum().any()
if flag==True:
total = df.isnull().sum()
percent =(df.isnull().sum())/(df.isnull().count() *100)
output = pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
data_type = []
for col in df.columns:
dtype = str(df[col].dtype)
data_type.append(dtype)
out... | Titanic - Machine Learning from Disaster |
4,557,766 | add_lower(embed_paragram, vocab )<compute_train_metric> | train_df[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean().sort_values(by='Survived', ascending=False)
| Titanic - Machine Learning from Disaster |
4,557,766 | vocab_temp = build_vocab(train_reserved['question_text'])
oov = check_coverage(vocab_temp, embed_paragram)
print(oov[:20])
del oov, vocab_temp
time.sleep(5 )<feature_engineering> | print("Before", train_df.shape, test_df.shape, full_data[0].shape, full_data[1].shape)
train_df = train_df.drop(['Ticket', 'Cabin', 'PassengerId'], axis=1)
test_df = test_df.drop(['Ticket', 'Cabin'], axis=1)
full_data = [train_df, test_df]
print("After", train_df.shape, test_df.shape, full_data[0].shape, full_data[1... | Titanic - Machine Learning from Disaster |
4,557,766 | embeddings_index = embed_paragram
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_embs.std()
embed_size = all_embs.shape[1]
word_index = tokenizer.word_index
nb_words = min(max_features, len(word_index))
embedding_matrix = np.random.normal(emb_mean, emb_std,(nb_words, embed_size... | def get_person(passenger):
age,sex = passenger
return 'child' if age < 16 else sex
train_df['Person'] = train_df[['Age','Sex']].apply(get_person,axis=1)
test_df['Person'] = test_df[['Age','Sex']].apply(get_person,axis=1)
person_dummies_titanic = pd.get_dummies(train_df['Person'])
person_dummies_titanic.columns = ['C... | Titanic - Machine Learning from Disaster |
4,557,766 | 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> | for dataset in full_data:
dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1
train_df[['FamilySize', 'Survived']].groupby(['FamilySize'], as_index=False ).mean().sort_values(by='Survived', ascending=False)
for dataset in full_data:
dataset[ 'Family_Single' ] = dataset[ 'FamilySize' ].map(lambda s : 1 if s... | Titanic - Machine Learning from Disaster |
4,557,766 | pred_paragram_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | freq_port = train_df.Embarked.dropna().mode() [0]
for dataset in full_data:
dataset['Embarked'] = dataset['Embarked'].fillna(freq_port)
train_df[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False ).mean().sort_values(by='Survived', ascending=False)
for dataset in full_data:
dataset['Embarked'] = dataset['... | Titanic - Machine Learning from Disaster |
4,557,766 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x, embed_paragram
time.sleep(10 )<compute_test_metric> | test_df['Fare'].fillna(test_df['Fare'].dropna().median() , inplace=True)
train_df['FareBand'] = pd.qcut(train_df['Fare'], 4)
train_df[['FareBand', 'Survived']].groupby(['FareBand'], as_index=False ).mean().sort_values(by='FareBand', ascending=True)
for dataset in full_data:
dataset.loc[ dataset['Fare'] <= 7.91, 'Far... | Titanic - Machine Learning from Disaster |
4,557,766 | pred_val_y = 0.34*pred_glove_val_y + 0.33*pred_fasttext_val_y + 0.33*pred_paragram_val_y
best_score = 0
best_threshold = None
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
score = metrics.f1_score(val_y,(pred_val_y>thresh))
print("F1 score at threshold {0} is {1}".format(thresh, score))
if sc... | Titanic - Machine Learning from Disaster | |
4,557,766 | pred_test_y = 0.34*pred_glove_test_y + 0.33*pred_fasttext_test_y + 0.33*pred_paragram_test_y
pred_test_y =(pred_test_y > best_threshold ).astype(int)
out_df = pd.DataFrame({"qid":test["qid"].values})
out_df['prediction'] = pred_test_y
out_df.to_csv("submission.csv", index=False )<import_modules> | train, test = train_test_split(train_df, test_size = 0.3, random_state = 0)
split_train_X = train.drop("Survived", axis=1)
split_train_Y = train["Survived"]
split_test_X = test.drop("Survived", axis=1)
split_test_Y = test["Survived"] | Titanic - Machine Learning from Disaster |
4,557,766 | LSTM, GRU, GlobalMaxPool1D, Dense)
ReduceLROnPlateau)
tqdm(tqdm_notebook ).pandas()
print(os.listdir(".. /input"))
datapath='.. /input'
RANDOM_STATE = 2
SHUFFLE = True
TEST_SIZE = 0.8
THRESHOLD = 0.35
<load_pretrained> | logreg = LogisticRegression()
logreg.fit(split_train_X, split_train_Y)
logreg.score(split_test_X, split_test_Y ) | Titanic - Machine Learning from Disaster |
4,557,766 | @contextmanager
def timer(name):
t0 = time.time()
yield
print(f'[{name}] done in {time.time() - t0:.0f} s')
def load_trained_model(model, weights_path):
model.load_weights(weights_path)
return model<load_from_csv> | gaussian = GaussianNB()
gaussian.fit(split_train_X, split_train_Y)
gaussian.score(split_test_X, split_test_Y ) | Titanic - Machine Learning from Disaster |
4,557,766 | class DataReader(object):
def __init__(self,
train_file,
module,
test_file=None):
if not train_file:
raise Exception("DataReader requires a train_file!")
if not module:
raise Exception("DataReader requires a model that can transform data!")
self.raw_test = None
if test_file:
print("Loading test_data(%s)into dataframe... | perceptron = Perceptron()
perceptron.fit(split_train_X, split_train_Y)
perceptron.score(split_test_X, split_test_Y ) | Titanic - Machine Learning from Disaster |
4,557,766 | class PreProcessor(object):
def __init__(self, text):
self.text = text
self.puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$',
'&', '/', '[', ']', '>', '%', '=', '
'~', '@', '£', '·', '_', '{', '}', '©', '^', '®', '`', '<',
'→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â',
'█', '½', 'à... | decision_tree = DecisionTreeClassifier()
decision_tree.fit(split_train_X, split_train_Y)
decision_tree.score(split_test_X, split_test_Y ) | Titanic - Machine Learning from Disaster |
4,557,766 | class NeuralNetworkClassifier:
def __init__(self, model, batch_size=512, epochs=10, val_score='val_loss',
reduce_lr=True, balancing_class_weight=False, filepath=None):
self.model = model
self.batch_size = batch_size
self.epochs = epochs
self.val_score = val_score
self.reduce_lr = reduce_lr
self.balancing_class_weig... | random_forest = RandomForestClassifier(n_estimators=100)
parameters = {'n_estimators': [4, 6, 9],
'max_features': ['log2', 'sqrt','auto'],
'criterion': ['entropy', 'gini'],
'max_depth': [2, 3, 5, 10],
'min_samples_split': [2, 3, 5],
'min_samples_leaf': [1,5,8]
}
acc_scorer = make_scorer(accuracy_score)
kfold = Strati... | Titanic - Machine Learning from Disaster |
4,557,766 | def load_word_embedding(filepath):
def _get_vec(word, *arr):
return word, np.asarray(arr, dtype='float32')
print('Load word embeddings...')
try:
word_embedding = dict(_get_vec(*w.split(' ')) for w in open(filepath))
except UnicodeDecodeError:
word_embedding = dict(_get_vec(*w.split(' ')) for w in open(
filepath, e... | train_df_X = train_df.drop("Survived", axis=1)
train_df_Y = train_df["Survived"]
test_df_X = test_df.drop("PassengerId", axis=1 ).copy()
train_df_X.shape, train_df_Y.shape, test_df_X.shape
train_X = train_df_X.values
train_Y = train_df_Y.values
test_X = test_df_X.values
classifiers = [
KNeighborsClassifier(3),
SVC(pro... | Titanic - Machine Learning from Disaster |
4,557,766 | MAX_FEATURES = int(2.5e5)
MAX_LEN = 80
RNN_UNITS = 40
DENSE_UNITS_1 = 32
DENSE_UNITS_2 = 16
EMBED_FILEPATH = os.path.join(datapath, 'embeddings/glove.840B.300d/glove.840B.300d.txt')
EMBED_PICKLEPATH = 'glove.pkl'
MODEL_FILEPATH = 'submission.csv'<load_pretrained> | ensemble_lin_rbf = VotingClassifier(estimators=[('KNN', KNeighborsClassifier(n_neighbors=10)) ,
('RBF', SVC(probability=True,kernel='rbf',C=0.5,gamma=0.1)) ,
('RFor', RandomForestClassifier(n_estimators=500,random_state=0)) ,
('LR', LogisticRegression(C=0.05)) ,
('DT', DecisionTreeClassifier(random_state=0)) ,
('N... | Titanic - Machine Learning from Disaster |
4,557,766 | def get_network(embed_filepath):
input_layer = Input(shape=(MAX_LEN,), name='input')
print('load pre-trained embeddings weights...')
embed_weights = pd.read_pickle(EMBED_PICKLEPATH)
input_dim = embed_weights.shape[0]
output_dim = embed_weights.shape[1]
x = Embedding(
input_dim=input_dim,
output_dim=output_dim,
weig... | ntrain = train_X.shape[0]
ntest = test_X.shape[0]
SEED = 0
NFOLDS = 5
kf = StratifiedKFold(n_splits=NFOLDS, shuffle=True, random_state = SEED)
class SklearnHelper(object):
def __init__(self, clf, seed=0, params=None):
params['random_state'] = seed
self.clf = clf(**params)
def train(self, x_train, y_train):
self.clf.f... | Titanic - Machine Learning from Disaster |
4,557,766 | class fakemodule(object):
@staticmethod
def transform(a):
return transform(a)
dr = DataReader('%s/train.csv' % datapath, fakemodule, os.path.join(datapath, 'test.csv'))<load_pretrained> | rf_params = {
'n_jobs': -1,
'n_estimators': 500,
'warm_start': True,
'max_depth': 6,
'min_samples_leaf': 2,
'max_features' : 'sqrt',
'verbose': 0
}
et_params = {
'n_jobs': -1,
'n_estimators':500,
'max_depth': 8,
'min_samples_leaf': 2,
'verbose': 0
}
ada_params = {
'n_estimators': 500,
'learning_rate' : 0.75
}
gb_params... | Titanic - Machine Learning from Disaster |
4,557,766 | t0 = time.time()
with timer("Extract Word Index From Train and Test Data"):
print("Loading data...")
all_text = dr.get_all_text()
print('Tokenizing text...')
_, tokenizer = tokenize(all_text)
word_index = tokenizer.word_index
with timer("Create Embedding Weights Matrix"):
print('Loading embeddings file')
word_embed... | x_train = np.concatenate(( et_oof_train, rf_oof_train, ada_oof_train, gb_oof_train, svc_oof_train), axis=1)
x_test = np.concatenate(( et_oof_test, rf_oof_test, ada_oof_test, gb_oof_test, svc_oof_test), axis=1 ) | Titanic - Machine Learning from Disaster |
4,557,766 | <train_model><EOS> | gbm = xgb.XGBClassifier(
n_estimators= 2000,
max_depth= 4,
min_child_weight= 2,
gamma=0.9,
subsample=0.8,
colsample_bytree=0.8,
objective= 'binary:logistic',
nthread= -1,
scale_pos_weight=1 ).fit(train_X, train_Y)
predictions = gbm.predict(test_X)
submission = pd.DataFrame({
"PassengerId": test_df["PassengerId"],
"S... | Titanic - Machine Learning from Disaster |
5,888,223 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<import_modules> | plt.style.use('seaborn')
sns.set(font_scale=2.5)
warnings.filterwarnings('ignore')
%matplotlib inline
| Titanic - Machine Learning from Disaster |
5,888,223 | import pandas as pd
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import keras
import operator<load_from_csv> | df_train = pd.read_csv('.. /input/train.csv')
df_test = pd.read_csv('.. /input/test.csv')
| Titanic - Machine Learning from Disaster |
5,888,223 | df_train=pd.read_csv('.. /input/train.csv')
df_test=pd.read_csv('.. /input/test.csv' )<count_values> | def detect_outliers(df, n, features):
outlier_indices = []
for col in features:
Q1 = np.percentile(df[col], 25)
Q3 = np.percentile(df[col], 75)
IQR = Q3 - Q1
outlier_step = 1.5 * IQR
outlier_list_col = df[(df[col] < Q1 - outlier_step)|(df[col] > Q3 + outlier_step)].index
outlier_indices.extend(outlier_list_col)
outl... | Titanic - Machine Learning from Disaster |
5,888,223 | print("Train data target 1")
print(df_train[df_train['target']==1].count())
print("Train data target 0")
print(df_train[df_train['target']==0].count() )<string_transform> | df_train.loc[Outliers_to_drop] | Titanic - Machine Learning from Disaster |
5,888,223 | all_phrases=df_train[df_train.target != 2]
all_words = []
for t in all_phrases.question_text:
all_words.append(t)
all_words[:4]<concatenate> | df_train = df_train.drop(Outliers_to_drop, axis = 0 ).reset_index(drop=True ) | Titanic - Machine Learning from Disaster |
5,888,223 | all_text = pd.Series(all_words ).str.cat(sep=' ' )<set_options> | for col in df_train.columns:
msg = 'column: {:>10}\t Percent of NaN value: {:.2f}%'.format(col, 100 *(df_train[col].isnull().sum() / df_train[col].shape[0]))
print(msg)
| Titanic - Machine Learning from Disaster |
5,888,223 | wordcloud = WordCloud(width=1600, height=800, max_font_size=200 ).generate(all_text)
plt.figure(figsize=(12,10))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis("off")
plt.show()<string_transform> | for col in df_test.columns:
msg = 'column: {:>10}\t Percent of NaN value: {:.2f}%'.format(col, 100 *(df_test[col].isnull().sum() / df_test[col].shape[0]))
print(msg ) | Titanic - Machine Learning from Disaster |
5,888,223 | neg_phrases = df_train[df_train.target == 1]
neg_words = []
for t in neg_phrases.question_text:
neg_words.append(t)
neg_words[:4]<concatenate> | df_train[['Pclass', 'Survived']].groupby(['Pclass'], as_index = True ).count()
| Titanic - Machine Learning from Disaster |
5,888,223 | neg_text = pd.Series(neg_words ).str.cat(sep=' ')
neg_text[:100]<set_options> | df_train["FamilySize"] = df_train["SibSp"] + df_train["Parch"]+1
df_test["FamilySize"] = df_test["SibSp"] + df_test["Parch"]+1
| Titanic - Machine Learning from Disaster |
5,888,223 | wordcloud = WordCloud(width=1600, height=800, max_font_size=200 ).generate(neg_text)
plt.figure(figsize=(12,10))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis("off")
plt.show()<string_transform> | df_train["Fare"] = df_train["Fare"].map(lambda i:np.log(i)if i>0 else 0 ) | Titanic - Machine Learning from Disaster |
5,888,223 | pos_phrases = df_train[df_train.target == 0]
pos_words = []
for t in pos_phrases.question_text:
pos_words.append(t)
pos_words[:4]<concatenate> | df_train["Age"].isnull().sum() | Titanic - Machine Learning from Disaster |
5,888,223 | pos_text = pd.Series(pos_words ).str.cat(sep=' ')
pos_text[:100]<set_options> | df_train["Initial"] = df_train["Name"].str.extract("([A-Za-z]+)\.")
df_test["Initial"] = df_test["Name"].str.extract("([A-Za-z]+)\." ) | Titanic - Machine Learning from Disaster |
5,888,223 | wordcloud = WordCloud(width=1600, height=800, max_font_size=200 ).generate(pos_text)
plt.figure(figsize=(12,10))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis("off")
plt.show()<feature_engineering> | df_train["Initial"].replace(["Mlle","Mme", "Ms", "Dr","Major","Lady","Countess", "Jonkheer", "Col", "Rev", "Capt", "Sir", "Don", "Dona"],
["Miss", "Miss","Miss", "Mr", "Mr", "Mrs", "Mrs", "Other", "Other", "Other", "Mr", "Mr", "Mr", "Mr"], inplace = True)
df_test["Initial"].replace(["Mlle","Mme", "Ms", "Dr","Major","L... | Titanic - Machine Learning from Disaster |
5,888,223 | df_train['length'] = df_train['question_text'].str.count(' ')+ 1
df_test['length'] = df_test['question_text'].str.count(' ')+ 1<feature_engineering> | df_train.groupby("Initial" ).mean() | Titanic - Machine Learning from Disaster |
5,888,223 | 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 check_coverage(vocab, embeddings_index):
known_words = {}
unknown_words = {}
nb_known_words = 0
nb_unknown_word... | df_all.groupby("Initial" ).mean()
| Titanic - Machine Learning from Disaster |
5,888,223 | def add_lower(embedding, vocab):
count = 0
for word in vocab:
if word in embedding and word.lower() not in embedding:
embedding[word.lower() ] = embedding[word]
count += 1
print(f"Added {count} words to embedding" )<define_variables> | df_train.loc[(df_train["Age"].isnull())&(df_train["Initial"] == "Mr"), "Age"] = 33
df_train.loc[(df_train["Age"].isnull())&(df_train["Initial"] == "Master"),"Age"] = 5
df_train.loc[(df_train["Age"].isnull())&(df_train["Initial"] == "Miss"), "Age"] = 22
df_train.loc[(df_train["Age"].isnull())&(df_train["Initial"] == "Mr... | Titanic - Machine Learning from Disaster |
5,888,223 | contraction_mapping = {"ain't": "is not", "aren't": "are not","can't": "cannot", "'cause": "because", "could've": "could have", "couldn't": "could not", "didn't": "did not", "doesn't": "does not", "don't": "do not", "hadn't": "had not", "hasn't": "has not", "haven't": "have not", "he'd": "he would","he'll": "he will", ... | df_train["Age"].isnull().sum() | 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.