kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
7,258,897 | if os.path.exists(PRED_PATH):
predictions = []
for index, row in tqdm(df.iterrows() , total = df.shape[0]):
image_id = row['image_id']
img_path = PRED_PATH + image_id + '.tiff'
img = skimage.io.MultiImage(img_path)[1]
patches = tile(img)
patches1 = patches.copy()
patches2 = patches.copy()
k = 0
while k < 42:
patches1[... | grid_hard = VotingClassifier(estimators = [('Random Forest', ran),
('Logistic Regression', log),
('XGBoost', xgb),
('Gradient Boosting', gbc),
('Extra Trees', ext),
('AdaBoost', ada),
('Gaussian Process', gpc),
('SVC', svc),
('K Nearest Neighbour', knn),
('Bagging Classifier', bag)], voting = 'hard')
grid_har... | Titanic - Machine Learning from Disaster |
7,258,897 | if os.path.exists(PRED_PATH):
sub['isup_grade'] = predictions
sub.to_csv("submission.csv", index=False)
else:
sub.to_csv("submission.csv", index=False )<define_variables> | grid_soft = VotingClassifier(estimators = [('Random Forest', ran),
('Logistic Regression', log),
('XGBoost', xgb),
('Gradient Boosting', gbc),
('Extra Trees', ext),
('AdaBoost', ada),
('Gaussian Process', gpc),
('SVC', svc),
('K Nearest Neighbour', knn),
('Bagging Classifier', bag)], voting = 'soft')
grid_sof... | Titanic - Machine Learning from Disaster |
7,258,897 | <define_variables><EOS> | predictions = grid_soft.predict(X_test)
submission = pd.concat([pd.DataFrame(passId), pd.DataFrame(predictions)], axis = 'columns')
submission.columns = ["PassengerId", "Survived"]
submission.to_csv('titanic_submission.csv', header = True, index = False ) | Titanic - Machine Learning from Disaster |
5,412,769 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<import_modules> | import numpy as np
import pandas as pd
from sklearn import ensemble
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier
from time ... | Titanic - Machine Learning from Disaster |
5,412,769 | import skimage.io
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader, Dataset
from efficientnet_pytorch import model as enet
import matplotlib.pyplot as plt
from tqdm import tqdm_notebook as tqdm
<load_from_csv> | train = pd.read_csv('.. /input/titanic/train.csv')
X_test = pd.read_csv('.. /input/titanic/test.csv')
id_for_subm = X_test['PassengerId'].copy()
train.head() | Titanic - Machine Learning from Disaster |
5,412,769 | data_dir = '.. /input/prostate-cancer-grade-assessment'
df_train = pd.read_csv(os.path.join(data_dir, 'train.csv'))
df_test = pd.read_csv(os.path.join(data_dir, 'test.csv'))
df_sub = pd.read_csv(os.path.join(data_dir, 'sample_submission.csv'))
image_folder = os.path.join(data_dir, 'test_images')
is_test = os.path.exis... | X = train.drop('Survived', axis=1)
y = train['Survived'] | Titanic - Machine Learning from Disaster |
5,412,769 | class enetv2(nn.Module):
def __init__(self, backbone, out_dim):
super(enetv2, self ).__init__()
self.enet = enet.EfficientNet.from_name(backbone)
self.myfc = nn.Linear(self.enet._fc.in_features, out_dim)
self.enet._fc = nn.Identity()
def extract(self, x):
return self.enet(x)
def forward(self, x):
x = self.extract(x)... | def preproc(train, test=[]):
num_col = []
cat_col = []
cat_to_encode = []
new_train = train.copy()
new_test = test.copy()
for col in train.columns:
if train[col].dtype == 'object': cat_col.append(col)
else: num_col.append(col)
num_imp = SimpleImputer(strategy='mean')
new_train[num_col] = num_imp.fit_transform(new_tr... | Titanic - Machine Learning from Disaster |
5,412,769 | model_files = [
{'file_name':'.. /input/efficientnetb2/efficientnetb2100epoch_best_fold1.pth','model':'efficientnet-b2','n_tiles':25},
{'file_name':'.. /input/panda-public-models/cls_effnet_b0_Rand36r36tiles256_big_bce_lr0.3_augx2_30epo_model_fold0.pth','model':'efficientnet-b0','n_tiles':36},
{'file_name':'.. /input/e... | X_train, X_test = preproc(X, X_test ) | Titanic - Machine Learning from Disaster |
5,412,769 | def get_tiles(img, mode=0):
result = []
h, w, c = img.shape
pad_h =(tile_size - h % tile_size)% tile_size +(( tile_size * mode)// 2)
pad_w =(tile_size - w % tile_size)% tile_size +(( tile_size * mode)// 2)
img2 = np.pad(img,[[pad_h // 2, pad_h - pad_h // 2], [pad_w // 2,pad_w - pad_w//2], [0,0]], constant_values=255)... | clf = RandomForestClassifier()
param_grid = {"max_depth": [7, 5, 3],
"max_features": [3, 5, 7],
"min_samples_split": [2, 3, 5],
"bootstrap": [True, False],
"criterion": ["gini", "entropy"],
"n_estimators": [150, 200, 250, 300]}
grid_search = GridSearchCV(clf, param_grid=param_grid, cv=5, iid=False)
start = time()
grid... | Titanic - Machine Learning from Disaster |
5,412,769 | LOGITS_FINAL = []
for i, model in enumerate(models):
LOGITS = []
LOGITS2 = []
n_tiles = model_files[i]['n_tiles']
dataset = PANDADataset(df, image_size, n_tiles, 0)
loader = DataLoader(dataset, batch_size=batch_size, num_workers=num_workers, shuffle=False)
dataset2 = PANDADataset(df, image_size, n_tiles, 2)
loader2 ... | def report(results, n_top=3):
for i in range(1, n_top + 1):
candidates = np.flatnonzero(results['rank_test_score'] == i)
for candidate in candidates:
print("Model with rank: {0}".format(i))
print("Mean validation score: {0:.3f}(std: {1:.3f})".format(
results['mean_test_score'][candidate],
results['std_test_score'][ca... | Titanic - Machine Learning from Disaster |
5,412,769 | DEBUG = False<define_variables> | best = np.argmin(grid_search.cv_results_['rank_test_score'])
par = grid_search.cv_results_['params'][best] | Titanic - Machine Learning from Disaster |
5,412,769 | sys.path = [
'.. /input/efficientnet-pytorch/EfficientNet-PyTorch/EfficientNet-PyTorch-master',
] + sys.path<import_modules> | eval_clf = RandomForestClassifier(**par)
eval_clf.fit(X_train, y)
pred = eval_clf.predict(X_test ) | Titanic - Machine Learning from Disaster |
5,412,769 | import skimage.io
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader, Dataset
from efficientnet_pytorch import model as enet
import matplotlib.pyplot as plt
from tqdm import tqdm_notebook as tqdm
<load_from_csv> | data_to_submit = pd.DataFrame({
'PassengerId':id_for_subm,
'Survived':pred
})
data_to_submit.to_csv('csv_to_submit.csv', index = False ) | Titanic - Machine Learning from Disaster |
12,918,821 | data_dir = '.. /input/prostate-cancer-grade-assessment'
df_train = pd.read_csv(os.path.join(data_dir, 'train.csv'))
df_test = pd.read_csv(os.path.join(data_dir, 'test.csv'))
df_sub = pd.read_csv(os.path.join(data_dir, 'sample_submission.csv'))
model_dir = '.. /input/panda-public-models'
image_folder = os.path.join(data... | import matplotlib.pyplot as plt
import sklearn
import seaborn as sb | Titanic - Machine Learning from Disaster |
12,918,821 | class enetv2(nn.Module):
def __init__(self, backbone, out_dim):
super(enetv2, self ).__init__()
self.enet = enet.EfficientNet.from_name(backbone)
self.myfc = nn.Linear(self.enet._fc.in_features, out_dim)
self.enet._fc = nn.Identity()
def extract(self, x):
return self.enet(x)
def forward(self, x):
x = self.extract(x)... | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv')
train.head() | Titanic - Machine Learning from Disaster |
12,918,821 | def get_tiles(img, mode=0):
result = []
h, w, c = img.shape
pad_h =(tile_size - h % tile_size)% tile_size +(( tile_size * mode)// 2)
pad_w =(tile_size - w % tile_size)% tile_size +(( tile_size * mode)// 2)
img2 = np.pad(img,[[pad_h // 2, pad_h - pad_h // 2], [pad_w // 2,pad_w - pad_w//2], [0,0]], constant_values=255)... | combine = [train,test] | Titanic - Machine Learning from Disaster |
12,918,821 | dataset = PANDADataset(df, image_size, n_tiles, 0)
loader = DataLoader(dataset, batch_size=batch_size, num_workers=num_workers, shuffle=False)
dataset2 = PANDADataset(df, image_size, n_tiles, 2)
loader2 = DataLoader(dataset2, batch_size=batch_size, num_workers=num_workers, shuffle=False )<save_to_csv> | for c in train.columns:
print(c, str(100*train[c].isnull().sum() /len(train)))
| Titanic - Machine Learning from Disaster |
12,918,821 | LOGITS = []
LOGITS2 = []
with torch.no_grad() :
for data in tqdm(loader):
data = data.to(device)
logits = models[0](data)
LOGITS.append(logits)
for data in tqdm(loader2):
data = data.to(device)
logits = models[0](data)
LOGITS2.append(logits)
LOGITS =(torch.cat(LOGITS ).sigmoid().cpu() + torch.cat(LOGITS2 ).sigmoi... | train['Age'] = train['Age'].fillna(train['Age'].mean() ) | Titanic - Machine Learning from Disaster |
12,918,821 | DEBUG = False<define_variables> | for c in train.columns:
print(c, str(100*train[c].isnull().sum() /len(train)) ) | Titanic - Machine Learning from Disaster |
12,918,821 | sys.path = [
'.. /input/efficientnet-pytorch/EfficientNet-PyTorch/EfficientNet-PyTorch-master',
] + sys.path<import_modules> | dependencies_sex = train[['Sex', 'Survived']].groupby(['Sex'],as_index=False ).mean()
dependencies_Pclass = train[['Pclass', 'Survived']].groupby(['Pclass'],as_index=False ).mean()
print(dependencies_Pclass)
print(dependencies_sex ) | Titanic - Machine Learning from Disaster |
12,918,821 | import skimage.io
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader, Dataset
from efficientnet_pytorch import model as enet
import matplotlib.pyplot as plt
from tqdm import tqdm_notebook as tqdm
<load_from_csv> | for dats in combine:
dats['Title'] = dats.Name.str.extract('([A-Za-z]+)\.',expand=False ) | Titanic - Machine Learning from Disaster |
12,918,821 | data_dir = '.. /input/prostate-cancer-grade-assessment'
df_train = pd.read_csv(os.path.join(data_dir, 'train.csv'))
df_test = pd.read_csv(os.path.join(data_dir, 'test.csv'))
df_sub = pd.read_csv(os.path.join(data_dir, 'sample_submission.csv'))
model_dir = '.. /input/panda-public-models'
image_folder = os.path.join(data... | for dataset in combine:
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col',
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
dataset['Title'] = dataset['Ti... | Titanic - Machine Learning from Disaster |
12,918,821 | class enetv2(nn.Module):
def __init__(self, backbone, out_dim):
super(enetv2, self ).__init__()
self.enet = enet.EfficientNet.from_name(backbone)
self.myfc = nn.Linear(self.enet._fc.in_features, out_dim)
self.enet._fc = nn.Identity()
def extract(self, x):
return self.enet(x)
def forward(self, x):
x = self.extract(x)... | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in combine:
dataset['Title'] = dataset['Title'].map(title_mapping)
dataset['Title'] = dataset['Title'].fillna(0 ) | Titanic - Machine Learning from Disaster |
12,918,821 | def get_tiles(img, mode=0):
result = []
h, w, c = img.shape
pad_h =(tile_size - h % tile_size)% tile_size +(( tile_size * mode)// 2)
pad_w =(tile_size - w % tile_size)% tile_size +(( tile_size * mode)// 2)
img2 = np.pad(img,[[pad_h // 2, pad_h - pad_h // 2], [pad_w // 2,pad_w - pad_w//2], [0,0]], constant_values=255)... | title_dependencies=train[['Title','Survived','Sex']].groupby(['Title','Sex'],as_index=False ).mean()
title_dependencies | Titanic - Machine Learning from Disaster |
12,918,821 | dataset = PANDADataset(df, image_size, n_tiles, 0)
loader = DataLoader(dataset, batch_size=batch_size, num_workers=num_workers, shuffle=False)
dataset2 = PANDADataset(df, image_size, n_tiles, 2)
loader2 = DataLoader(dataset2, batch_size=batch_size, num_workers=num_workers, shuffle=False )<save_to_csv> | train = train.drop(['Name', 'PassengerId', 'Cabin', 'Embarked','Ticket'], axis=1)
test = test.drop(['Name', 'PassengerId', 'Cabin', 'Embarked','Ticket'], axis=1)
combine=[train,test]
print(train.head())
for dataset in combine:
dataset['Sex'] = dataset['Sex'].map({'female': 1, 'male': 0} ).astype(int)
print(train.he... | Titanic - Machine Learning from Disaster |
12,918,821 | LOGITS = []
LOGITS2 = []
with torch.no_grad() :
for data in tqdm(loader):
data = data.to(device)
logits = models[0](data)
LOGITS.append(logits)
for data in tqdm(loader2):
data = data.to(device)
logits = models[0](data)
LOGITS2.append(logits)
LOGITS =(torch.cat(LOGITS ).sigmoid().cpu() + torch.cat(LOGITS2 ).sigmoi... | X_train, X_test , Y_train, Y_test = train_test_split(train.drop(['Survived'],axis=1),train['Survived'],test_size=0.10,random_state=None ) | Titanic - Machine Learning from Disaster |
12,918,821 | warnings.simplefilter(action='ignore', category=FutureWarning)
warnings.simplefilter(action='ignore', category=SettingWithCopyWarning)
warnings.simplefilter(action='ignore', category=FutureWarning )<compute_test_metric> | from sklearn.linear_model import LogisticRegression
from sklearn import metrics | Titanic - Machine Learning from Disaster |
12,918,821 | FEATS_EXCLUDED = ['first_active_month', 'target', 'card_id', 'outliers',
'hist_purchase_date_max', 'hist_purchase_date_min', 'hist_card_id_size',
'new_purchase_date_max', 'new_purchase_date_min', 'new_card_id_size',
'OOF_PRED', 'month_0']
@contextmanager
def timer(title):
t0 = time.time()
yield
print("{} - done in {:.0... | modelLR= LogisticRegression(solver='liblinear',C=0.21,random_state=1)
modelLR.fit(X_train,Y_train)
| Titanic - Machine Learning from Disaster |
12,918,821 | %%time
def load_data() :
train_df = pd.read_csv('.. /input/elo-blending/train_feature.csv')
test_df = pd.read_csv('.. /input/elo-blending/test_feature.csv')
display(train_df.head())
display(test_df.head())
print(train_df.shape,test_df.shape)
train = pd.read_csv('.. /input/elo-merchant-category-recommendation/train... | Y_pred_log=modelLR.predict(X_test)
acc_LR = metrics.accuracy_score(Y_test, Y_pred_log ) | Titanic - Machine Learning from Disaster |
12,918,821 | boosting = ["goss","dart"]
boosting[0],boosting[1]<load_pretrained> | print(Y_pred_log)
print("We see that Logistic regression gives an Accuracy of ",acc_LR*100,"% on the traing set.")
| Titanic - Machine Learning from Disaster |
12,918,821 | %%time
boosting = ["goss","dart"]
def kfold_lightgbm(train_df, test_df, num_folds, stratified = False, boosting = boosting[0]):
print("Starting LightGBM.Train shape: {}, test shape: {}".format(train_df.shape, test_df.shape))
if stratified:
folds = StratifiedKFold(n_splits= num_folds, shuffle=True, random_state=326)
el... | from sklearn.tree import DecisionTreeClassifier | Titanic - Machine Learning from Disaster |
12,918,821 | %%time
train_df,test_df = load_data()
print(gc.collect())
submission = kfold_lightgbm(train_df, test_df, num_folds=7, stratified=False, boosting=boosting[0] )<concatenate> | dtree = DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=1,
max_features=7, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=1, min_samples_split=2,
min_weight_fraction_leaf=0.0,
random_state=None, splitter='best')
dtree.fit(X_train, Y_train)
y_pred_tree =... | Titanic - Machine Learning from Disaster |
12,918,821 | submission1 = kfold_lightgbm(train_df, test_df, num_folds=7, stratified=False, boosting=boosting[1] )<save_to_csv> | acc_DT = metrics.accuracy_score(y_pred_tree, Y_test)
print(y_pred_tree)
print("We see that Decision Tree gives an Accuracy of ",acc_DT*100,"% on the traing set." ) | Titanic - Machine Learning from Disaster |
12,918,821 | final = pd.read_csv(".. /input/elo-merchant-category-recommendation/sample_submission.csv")
final['target'] = submission['target'] * 0.5 + submission1['target'] * 0.5
final.to_csv("blend.csv",index = False )<set_options> | from sklearn.ensemble import RandomForestClassifier | Titanic - Machine Learning from Disaster |
12,918,821 | %matplotlib inline
<choose_model_class> | rforest = RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
max_depth=None, max_features=7, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=1, min_samples_split=2,
min_weight_fraction_leaf=0.0, n_estimators=20, n_jobs=1,
oob_score=False, random_state=4... | Titanic - Machine Learning from Disaster |
12,918,821 | max_seq_len = 60
embed_size = 300
max_features = 50000
EMBEDDING = 'glove.840B.300d'
MODEL = 'attention'
embedding_matrix = 'None'
embeddings_idx = 'None'
checkpoint = ModelCheckpoint('./checkpoints/', monitor='val_acc', verbose=0, save_best_only=True)
earlystop = EarlyStopping(monitor='val_acc', min_delta=0, patience... | acc_RF = metrics.accuracy_score(y_pred_forest, Y_test)
print(y_pred_forest)
print("We see that Random Forest classifier gives an Accuracy of ",acc_RF*100,"% on the traing set." ) | Titanic - Machine Learning from Disaster |
12,918,821 | train_set = pd.read_csv('.. /input/train.csv')
test_set = pd.read_csv('.. /input/test.csv')
train_set.head()<count_values> | from sklearn.svm import SVC | Titanic - Machine Learning from Disaster |
12,918,821 | x = train_set['target'].value_counts(dropna=False)
print(x)
sincere_examples = x[0]
insincere_examples = x[1]<define_variables> | svc = SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',
max_iter=-1, probability=False, random_state=None, shrinking=True,
tol=0.001, verbose=False)
svc.fit(X_train, Y_train)
y_pred_svc = svc.predict(X_test ) | Titanic - Machine Learning from Disaster |
12,918,821 | print(len(lengths_without_puncs)- np.count_nonzero(lengths_without_puncs))<define_variables> | acc_SVC = metrics.accuracy_score(y_pred_svc, Y_test)
print(y_pred_svc)
print("We see that SVC classifier gives an Accuracy of ",acc_SVC*100,"% on the traing set." ) | Titanic - Machine Learning from Disaster |
12,918,821 | 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", ... | from xgboost import XGBClassifier | Titanic - Machine Learning from Disaster |
12,918,821 | sincere_counts = Counter()
insincere_counts = Counter()
word_dict = Counter()
sincere_to_insincere_ratio = Counter()
def prepare_dicts() :
qs = [clean(i)for i in train_set['question_text']]
lbl = [j for j in train_set['target']]
for i,j in zip(qs,lbl):
words = i.split()
for word in words:
word_dict[word] += 1
if j == 0... | xgb=XGBClassifier(learning_rate=0.05, n_estimators=500)
xgb.fit(X_train,Y_train)
y_pred_xgb=xgb.predict(X_test ) | Titanic - Machine Learning from Disaster |
12,918,821 | prepare_dicts()<split> | acc_XGB= metrics.accuracy_score(y_pred_xgb,Y_test)
print(y_pred_xgb)
print("We see that XGB classifier gives an Accuracy of ",acc_XGB*100,"% on the traing set." ) | Titanic - Machine Learning from Disaster |
12,918,821 | train_x = list(train_set['question_text'].fillna("_na_" ).values)
train_y = train_set['target'].values
test_x = list(test_set['question_text'].fillna("_na_" ).values)
train_x, val_x, train_y, val_y = train_test_split(train_x, train_y, test_size=0.2)
train_x = [clean(i)for i in train_x]
val_x = [clean(i)for i in val_... | import keras
from keras.layers import Dense
from keras.models import Sequential
from sklearn.metrics import classification_report | Titanic - Machine Learning from Disaster |
12,918,821 | def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
def get_embeddings(embedding_name, mode='new'):
filePath = '.. /input/embeddings/{0}/{0}.txt'.format(embedding_name)
if mode == 'new':
embeddings_idx = dict(get_coefs(*i.split(" ")) for i in open(filePath))
all_embs = np.stack(embeddings_idx.valu... | nn = Sequential()
nn.add(Dense(units= 14, activation = 'relu', input_dim=7, kernel_initializer="uniform"))
nn.add(Dense(units= 14, activation = 'relu',kernel_initializer="uniform"))
nn.add(Dense(units= 1, activation = 'sigmoid',kernel_initializer="uniform"))
nn.compile(optimizer='adam',
loss='mean_squared_error',
metri... | Titanic - Machine Learning from Disaster |
12,918,821 | def check_coverage(vocab, embeddings_index):
known_words = {}
unknown_words = {}
nb_known_words = 0
nb_unknown_words = 0
for word in vocab.keys() :
try:
known_words[word] = embeddings_index[word]
nb_known_words += vocab[word]
except:
unknown_words[word] = vocab[word]
nb_unknown_words += vocab[word]
pass
print('Found em... | nn.fit(X_train,Y_train, batch_size=32,epochs=50,verbose= 0)
nn_pred = nn.predict(X_test)
nn_pred = [ 1 if y>=0.5 else 0 for y in nn_pred]
print(nn_pred)
acc_NN = metrics.accuracy_score(Y_test, nn_pred ) | Titanic - Machine Learning from Disaster |
12,918,821 | embedding_idxs, embedding_mtx = get_embeddings(EMBEDDING, 'new')
unk_wrds = check_coverage(word_dict, embedding_idxs )<choose_model_class> | print("We can see that the neural network gives an Accuracy of ",acc_NN*100 , "% on the training set." ) | Titanic - Machine Learning from Disaster |
12,918,821 | def get_model(model_type):
if model_type == 'nb':
model = NaiveBayes()
elif model_type == 'svm':
model = __SVC__()
elif model_type == 'rnn':
inp = Input(shape=(max_seq_len,))
layer = Embedding(max_features, embed_size, weights=[embedding_mtx], trainable=False )(inp)
layer = SimpleRNN(32, return_sequences=True )(layer)... | best=best_model['Model'].iloc[0]
print(str(best)) | Titanic - Machine Learning from Disaster |
12,918,821 | class NaiveBayes() :
def __init__(self):
self.sincere_example_count = sincere_examples
self.insincere_example_count = insincere_examples
self.total_examples = x[0]+x[1]
self.sincere_dict = sincere_counts
self.insincere_dict = insincere_counts
self.word_dict= word_dict
self.sincere_word_count = np.sum(list(sincere_count... | test.head()
for c in test.columns:
print(c, str(100*test[c].isnull().sum() /len(test)))
print(".............. Before")
test['Age'] = test['Age'].fillna(test['Age'].mean())
test['Fare'] = test['Fare'].fillna(test['Fare'].mean())
print("
")
for c in test.columns:
print(c, str(100*test[c].isnull().sum() /len(test)))
... | Titanic - Machine Learning from Disaster |
12,918,821 | class Attention(Layer):
def __init__(self, step_dim, **kwargs):
self.supports_masking = True
self.init = initializers.get('glorot_uniform')
self.features_dim = 0
self.step_dim = step_dim
self.bias = True
super(Attention, self ).__init__(**kwargs)
def build(self, input_shape):
assert len(input_shape)== 3
self.W = self... | if best == 'Logistic Regression':
modelLR.fit(train.drop(['Survived'],axis=1),train['Survived'])
test_pred=modelLR.predict(test)
print(test_pred)
print('Logistic Regression')
if best == 'Decision Tree':
dtree.fit(train.drop(['Survived'],axis=1),train['Survived'])
test_pred=modelLR.predict(test)
print(test_pred)
... | Titanic - Machine Learning from Disaster |
12,918,821 | def print_f1s(predictions):
for threshold in np.arange(0.1, 0.501, 0.01):
threshold = np.round(threshold, 2)
print("F1 score at threshold {0} is {1}".format(threshold, f1_score(val_y,(predictions>threshold ).astype(int))))<prepare_output> | test_data=pd.read_csv('/kaggle/input/titanic/gender_submission.csv')
test_data = test_data.drop(['PassengerId'], axis=1)
test_data.head() | Titanic - Machine Learning from Disaster |
12,918,821 |
<find_best_model_class> | test_data.values.tolist()
test_acc = metrics.accuracy_score(test_data, test_pred)
print("Here we see that the test data has an Accuracy of ",test_acc*100,"% " ) | Titanic - Machine Learning from Disaster |
12,918,821 | rnn = get_model('rnn')
rnn.summary()
rnn.compile(loss='binary_crossentropy', optimizer=Adam(lr=1e-3), metrics=['accuracy'])
rnn.fit(train_X, train_y, batch_size=512, epochs=2, validation_data=(val_X, val_y), callbacks=[earlystop, reducelr])
predictions_rnn_real = rnn.predict(test_X)
predictions_rnn =(predictions_rn... | test_predict = pd.DataFrame(test_pred, columns= ['Survived'])
test_new= pd.read_csv('/kaggle/input/titanic/test.csv')
new_test = pd.concat([test_new, test_predict], axis=1, join='inner' ) | Titanic - Machine Learning from Disaster |
12,918,821 | <find_best_model_class><EOS> | submit=new_test[['PassengerId','Survived']]
submit.to_csv('predictions.csv',index=False ) | Titanic - Machine Learning from Disaster |
9,456,372 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<find_best_model_class> | random.seed(123)
sns.set_style("darkgrid")
train = pd.read_csv("/kaggle/input/titanic/train.csv")
test = pd.read_csv("/kaggle/input/titanic/test.csv")
len_train = len(train)
train_y = train["Survived"] | Titanic - Machine Learning from Disaster |
9,456,372 | attention = get_model('attention')
attention.summary()
attention.compile(loss='binary_crossentropy', optimizer=Adam(lr=1e-3), metrics=['accuracy'])
attention.fit(train_X, train_y, batch_size=512, epochs=2, validation_data=(val_X, val_y), callbacks=[earlystop, reducelr])
predictions_attention_real = attention.predict... | lm = ols('Age~ C(Pclass)+ C(Sex)* C(Embarked)+ C(SibSp)+ C(Parch)', pd.concat([train,test],axis=0)).fit()
anova_lm(lm,typ=2 ) | Titanic - Machine Learning from Disaster |
9,456,372 | val_preds = 0.50*predictions_val_gru + 0.25*predictions_val_lstm + 0.25*predictions_val_attention
val_preds =(val_preds > thresh ).astype(int)
print_f1s(val_preds )<save_to_csv> | lm = ols('Fare~ C(Pclass)+ C(Sex)+ C(Embarked)+ C(SibSp)+ C(Parch)', pd.concat([train,test],axis=0)).fit()
anova_lm(lm,typ=2 ) | Titanic - Machine Learning from Disaster |
9,456,372 | final_preds = 0.50*predictions_gru_real + 0.25*predictions_lstm_real + 0.25*predictions_attention_real
final_preds =(final_preds > thresh ).astype(int)
final_prediction = pd.DataFrame({"qid":test_set["qid"].values})
final_prediction['prediction'] = final_preds
final_prediction.to_csv("submission.csv", index=False )<i... | mapping = {'Mlle': 'Miss', 'Major': 'Mr', 'Col': 'Mr', 'Sir': 'Mr', 'Don': 'Mr', 'Mme': 'Miss',
'Jonkheer': 'Mr', 'Lady': 'Mrs', 'Capt': 'Mr', 'the Countess': 'Mrs', 'Ms': 'Miss', 'Dona': 'Mrs'}
class DataFrameSelector(BaseEstimator, TransformerMixin):
def __init__(self, attribute_names):
self.attribute_names = attribu... | Titanic - Machine Learning from Disaster |
9,456,372 | FOLD = 0
SEED = 1337
NOTIFY_EACH_EPOCH = False
WORKERS = 0
BATCH_SIZE = 512
N_SPLITS = 10
random.seed(SEED)
os.environ['PYTHONHASHSEED'] = str(SEED)
np.random.seed(SEED)
torch.manual_seed(SEED)
torch.cuda.manual_seed(SEED)
torch.backends.cudnn.deterministic = True
device = torch.device("cuda:0" if torch.cuda.is_av... | class TaitanicProcessing(BaseEstimator, TransformerMixin):
def fit(self, X, y=None):
self.y = y
return self
def transform(self, X):
X["Sex"] = X["Sex"].map({"male":1, "female":0})
X["Family"] = X["SibSp"] + X["Parch"] + 1
X["Family"] = X["Family"].astype(str)
X['Family'] = X['Family'].replace("1", 'Alone')
X['Family... | Titanic - Machine Learning from Disaster |
9,456,372 | sample_submission = pd.read_csv('.. /input/sample_submission.csv')
train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' )<feature_engineering> | df = pd.concat([train.drop("Survived",axis=1),test],axis=0,sort=False)
df.set_index("PassengerId",drop=True, inplace=True)
df = full_pipeline.fit_transform(df,train_y)
df.reset_index(drop=True,inplace=True)
df.info() | Titanic - Machine Learning from Disaster |
9,456,372 | def add_features(df):
df2 = df.copy(deep=True)
df2['question_text'] = df2['question_text'].apply(lambda x:str(x))
df2['total_length'] = df2['question_text'].apply(len)
df2['capitals'] = df2['question_text'].apply(lambda comment: sum(1 for c in comment if c.isupper()))
df2['caps_vs_length'] = df2.apply(lambda row: flo... | df.drop(["Embarked", "Name_map","Cabin","Family",'SibSp','Parch'],axis=1,inplace=True)
df.head() | Titanic - Machine Learning from Disaster |
9,456,372 | kfold = KFold(n_splits=N_SPLITS, shuffle=True, random_state=SEED)
train_idx, val_idx = list(kfold.split(train)) [FOLD]
x_train, x_val = train.iloc[train_idx], train.iloc[val_idx]
x_train_meta = add_features(x_train)
x_val_meta = add_features(x_val)
test_meta = add_features(test)
x_train = x_train.reset_index()
x_va... | train = df.iloc[:len_train,:].reset_index(drop=True)
test = df.iloc[len_train:,:].reset_index(drop=True ) | Titanic - Machine Learning from Disaster |
9,456,372 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | def rf_cv(n_estimators, max_depth, min_samples_split, min_samples_leaf, ccp_alpha, x_data=None, y_data=None, n_splits=5, output='score'):
score = 0
kf = StratifiedKFold(n_splits=n_splits, random_state=5, shuffle=True)
models = []
for train_index, valid_index in kf.split(x_data, y_data):
x_train, y_train = x_data.iloc[... | Titanic - Machine Learning from Disaster |
9,456,372 | nlp = English()
def tokenize(sentence):
sentence = str(sentence)
for punct in puncts:
sentence = sentence.replace(punct, f' {punct} ')
x = nlp(sentence)
return [token.text for token in x]<define_variables> | params = rf_ba.max['params']
rf_model = rf_cv(
params['n_estimators'],
params['max_depth'],
params['min_samples_split'],
params['min_samples_leaf'],
params['ccp_alpha'],
x_data=train, y_data=train_y, n_splits=5, output='model')
importances = pd.DataFrame(np.zeros(( train.shape[1], 5)) , columns=['Fold_{}'.format(i)fo... | Titanic - Machine Learning from Disaster |
9,456,372 | %%time
index_field = data.Field(sequential=False, use_vocab=False, batch_first=True)
question_field = data.Field(tokenize=tokenize, lower=True, batch_first=True, include_lengths=True)
target_field = data.Field(sequential=False, use_vocab=False, batch_first=True)
train_fields = [
('id', index_field),
('index', None... | y_pred = pred
y_pred[y_pred >= 0.5] = 1
y_pred = y_pred.astype(int)
submission = pd.read_csv("/kaggle/input/titanic/gender_submission.csv")
submission["Survived"] = y_pred
submission.to_csv("submission.csv",index = False ) | Titanic - Machine Learning from Disaster |
9,456,372 | class SelfAttention(nn.Module):
def __init__(self, hidden_size, batch_first=False):
super(SelfAttention, self ).__init__()
self.hidden_size = hidden_size
self.batch_first = batch_first
self.att_weights = nn.Parameter(torch.Tensor(1, hidden_size), requires_grad=True)
nn.init.xavier_uniform_(self.att_weights.data)
def ... | rfc_model = RandomForestClassifier(criterion='gini',n_estimators=1800,max_depth=7, min_samples_split=6,min_samples_leaf=6,
max_features='auto', oob_score=True, random_state=123,n_jobs=-1)
oob = 0
probs = pd.DataFrame(np.zeros(( len(test),10)) , columns=['Fold_{}_Sur_{}'.format(i, j)for i in range(1, 6)for j in range(2... | Titanic - Machine Learning from Disaster |
9,456,372 | def choose_threshold(val_preds, y_val):
thresholds = np.arange(0.1, 0.501, 0.01)
val_scores = []
for threshold in thresholds:
threshold = np.round(threshold, 2)
f1 = f1_score(y_val,(val_preds > threshold ).astype(int))
val_scores.append(f1)
best_val_f1 = np.max(val_scores)
best_threshold = np.round(thresholds[np.ar... | survived =[col for col in probs.columns if col.endswith('Sur_1')]
probs['survived'] = probs[survived].mean(axis=1)
probs['unsurvived'] = probs.drop(columns=survived ).mean(axis=1)
probs['pred'] = 0
sub = probs[probs['survived'] >= 0.5].index
probs.loc[sub, 'pred'] = 1
y_pred = probs['pred'].astype(int ) | Titanic - Machine Learning from Disaster |
9,456,372 | <load_pretrained><EOS> | submission = pd.read_csv("/kaggle/input/titanic/gender_submission.csv")
submission["Survived"] = y_pred
submission.to_csv("submission.csv",index = False ) | Titanic - Machine Learning from Disaster |
8,095,919 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_pretrained> | import pandas as pd
from matplotlib import pyplot as plt
import seaborn as sns
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import RepeatedKFold
import numpy as np
import re | Titanic - Machine Learning from Disaster |
8,095,919 | paragram_vectors = torchtext.vocab.Vectors('.. /input/embeddings/paragram_300_sl999/paragram_300_sl999.txt')
for file in os.listdir('./.vector_cache/'):
os.remove(f'./.vector_cache/{file}' )<feature_engineering> | df = pd.DataFrame(pd.read_csv('.. /input/titanic/train.csv'))
df_test = pd.DataFrame(pd.read_csv('.. /input/titanic/test.csv')) | Titanic - Machine Learning from Disaster |
8,095,919 | %%time
mean_vectors = torch.zeros(( len(question_field.vocab.stoi), 300))
for word, i in tqdm_notebook(question_field.vocab.stoi.items() , total=len(question_field.vocab.stoi)) :
glove_vector = glove_vectors[word]
paragram_vector = paragram_vectors[word]
vector = torch.stack([glove_vector, paragram_vector])
vector = t... | df.isnull().sum() | Titanic - Machine Learning from Disaster |
8,095,919 | val_preds, y_val, _, _, _, message = train(train_dataset, val_dataset, train_dataloader, val_dataloader, x_train_meta, x_val_meta, net, question_field, mean_vectors, question_field.vocab.stoi )<save_to_csv> | print(df.groupby(['Pclass'] ).mean() ['Age'])
print('
')
print(df.groupby(['Sex'] ).mean() ['Age'] ) | Titanic - Machine Learning from Disaster |
8,095,919 | preds =(preds > best_threshold ).astype(int)
sample_submission['prediction'] = preds
mlc.kaggle.save_sub(sample_submission, 'submission.csv')
sample_submission.head()<save_to_csv> | def age_nan(df):
for i in df.Sex.unique() :
for j in df.Pclass.unique() :
x = df.loc[(( df.Sex == i)&(df.Pclass == j)) , 'Age'].mean()
df.loc[(( df.Sex == i)&(df.Pclass == j)) , 'Age'] = df.loc[(( df.Sex == i)&(df.Pclass == j)) , 'Age'].fillna(x)
age_nan(df)
age_nan(df_test ) | Titanic - Machine Learning from Disaster |
8,095,919 | x_test['target'] = preds
pseudo_df = pd.concat([x_train, x_val, x_test] ).reset_index().drop('level_0', axis=1)
pseudo_df.to_csv('x_pseudo.csv' )<create_dataframe> | df['Embarked'] = df['Embarked'].fillna('S')
df_test['Embarked'] = df_test['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
8,095,919 | pseudo_meta = np.concatenate(( x_train_meta, x_val_meta, test_meta))
pseudo_dataset = data.TabularDataset('./x_pseudo.csv', format='CSV', skip_header=True, fields=train_fields)
pseudo_dataloader = data.BucketIterator(pseudo_dataset, 512, sort_key=lambda x: len(x.question_text), sort_within_batch=True )<train_model> | df['Cabin_NaN'] = df['Cabin'].isnull().astype(int)
df_test['Cabin_NaN'] = df_test['Cabin'].isnull().astype(int)
countplot('Cabin_NaN' ) | Titanic - Machine Learning from Disaster |
8,095,919 | pseudo_val_preds, pseudo_y_val, _, _, _, message = train(pseudo_dataset, val_dataset, pseudo_dataloader, val_dataloader, pseudo_meta, x_val_meta, net, question_field, mean_vectors, question_field.vocab.stoi )<set_options> | df_test.isnull().sum() | Titanic - Machine Learning from Disaster |
8,095,919 | del mean_vectors
gc.collect()<prepare_output> | df_test.Fare = df_test.Fare.fillna(-1 ) | Titanic - Machine Learning from Disaster |
8,095,919 | pseudo_preds =(pseudo_preds > pseudo_best_threshold ).astype(int)
sample_submission['prediction'] = pseudo_preds
mlc.kaggle.save_sub(sample_submission, 'submission.csv')
sample_submission.head()<import_modules> | def reg_cross_val(variables):
X = df[variables]
y = df['Survived']
rkfold = RepeatedKFold(n_splits = 2, n_repeats = 10, random_state = 10)
result = []
for treino, teste in rkfold.split(X):
X_train, X_test = X.iloc[treino], X.iloc[teste]
y_train, y_test = y.iloc[treino], y.iloc[teste]
reg = LogisticRegression(max_iter ... | Titanic - Machine Learning from Disaster |
8,095,919 | import keras
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from keras.layers import Input, Embedding, Dense, Dropout, Concatenate, Lambda, Flatten
from keras.layers import GlobalMaxPool1D
from keras.models import Model
import tqdm
<define_variables> | def is_female(x):
if x == 'female':
return 1
else:
return 0
df['Sex_bin'] = df['Sex'].map(is_female)
df_test['Sex_bin'] = df_test['Sex'].map(is_female ) | Titanic - Machine Learning from Disaster |
8,095,919 | MAX_SEQUENCE_LENGTH = 60
MAX_WORDS = 45000
EMBEDDINGS_TRAINED_DIMENSIONS = 100
EMBEDDINGS_LOADED_DIMENSIONS = 300<compute_test_metric> | def embarked_s(x):
if x == 'S':
return 1
else:
return 0
df['Embarked_S'] = df['Embarked'].map(embarked_s)
df_test['Embarked_S'] = df_test['Embarked'].map(embarked_s)
def embarked_c(x):
if x == 'C':
return 1
else:
return 0
df['Embarked_C'] = df['Embarked'].map(embarked_c)
df_test['Embarked_C'] = df_test['Embarked'].m... | Titanic - Machine Learning from Disaster |
8,095,919 | def load_embeddings(file):
embeddings = {}
with open(file)as f:
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings = dict(get_coefs(*line.split(" ")) for line in f)
print('Found %s word vectors.' % len(embeddings))
return embeddings<load_pretrained> | df['Family'] = df.SibSp + df.Parch
df_test['Family'] = df_test.SibSp + df_test.Parch | Titanic - Machine Learning from Disaster |
8,095,919 | pretrained_embeddings = load_embeddings(".. /input/embeddings/glove.840B.300d/glove.840B.300d.txt" )<load_from_csv> | text_ticket = ''
for i in df.Ticket:
text_ticket += i
lista = re.findall('[a-zA-Z]+', text_ticket)
print('Most repeated terms in Tickets:
')
print(pd.Series(lista ).value_counts().head(10)) | Titanic - Machine Learning from Disaster |
8,095,919 | df_train = pd.read_csv(".. /input/train.csv")
df_test = pd.read_csv(".. /input/test.csv" )<define_variables> | df['CA'] = df['Ticket'].str.contains('CA|C.A.' ).astype(int)
df['SOTON'] = df['Ticket'].str.contains('SOTON|STON' ).astype(int)
df['PC'] = df['Ticket'].str.contains('PC' ).astype(int)
df['SC'] = df['Ticket'].str.contains('SC|S.C' ).astype(int)
df['C'] = df['Ticket'].str.contains('C' ).astype(int)
df_test['CA'] = d... | Titanic - Machine Learning from Disaster |
8,095,919 | BATCH_SIZE = 512
Q_FRACTION = 1
questions = df_train.sample(frac=Q_FRACTION)
question_texts = questions["question_text"].values
question_targets = questions["target"].values
test_texts = df_test["question_text"].fillna("_na_" ).values
print(f"Working on {len(questions)} questions" )<train_model> | text_name = ''
for i in df.Name:
text_name += i
lista = re.findall('[a-zA-Z]+', text_name)
print('Most repeated words in Name column:
')
print(pd.Series(lista ).value_counts().head(10)) | Titanic - Machine Learning from Disaster |
8,095,919 | tokenizer = Tokenizer(num_words=MAX_WORDS)
tokenizer.fit_on_texts(list(df_train["question_text"].values))<categorify> | df['Master'] = df['Name'].str.contains('Master' ).astype(int)
df['Mr'] = df['Name'].str.contains('Mr' ).astype(int)
df['Miss'] = df['Name'].str.contains('Miss' ).astype(int)
df['Mrs'] = df['Name'].str.contains('Mrs' ).astype(int)
df_test['Master'] = df_test['Name'].str.contains('Master' ).astype(int)
df_test['Mr']... | Titanic - Machine Learning from Disaster |
8,095,919 | <load_pretrained><EOS> | variables = ['Age', 'Sex_bin', 'Pclass', 'Fare','Family', 'Embarked_S','Embarked_C','Cabin_NaN',\
'CA', 'SOTON', 'PC', 'SC', 'Master', 'Mr', 'Miss', 'C', 'Mrs']
X = df[variables]
y = df['Survived']
reg = LogisticRegression(max_iter = 500)
reg.fit(X,y)
resp = reg.predict(df_test[variables])
submit = pd.Series(resp, i... | Titanic - Machine Learning from Disaster |
5,639,062 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
5,639,062 | THRESHOLD = 0.35
class EpochMetricsCallback(keras.callbacks.Callback):
def on_train_begin(self, logs={}):
self.f1s = []
self.precisions = []
self.recalls = []
def on_epoch_end(self, epoch, logs={}):
predictions = self.model.predict(self.validation_data[0])
predictions =(predictions > THRESHOLD ).astype(int)
predictio... | Xy_train = pd.read_csv(".. /input/titanic/train.csv", index_col="PassengerId")
class CC:
def __init__(self, dataframe):
for col in dataframe.columns: setattr(self, col, col)
cc = CC(Xy_train)
X_train = Xy_train.drop(columns=[cc.Survived])
y_train = Xy_train[cc.Survived] | Titanic - Machine Learning from Disaster |
5,639,062 | X = pad_sequences(tokenizer.texts_to_sequences(question_texts),
maxlen=MAX_SEQUENCE_LENGTH)
Y = question_targets
test_word_tokens = pad_sequences(tokenizer.texts_to_sequences(test_texts),
maxlen=MAX_SEQUENCE_LENGTH )<choose_model_class> | class GenericTransformer(BaseEstimator, TransformerMixin):
def __init__(self, transformer, fitter=None):
self.transformer = transformer
self.fitter = fitter
def fit(self, X, y=None):
self.fit_val = None if self.fitter is None else self.fitter(X)
return self
def transform(self, X):
return self.transformer(X)if self.f... | Titanic - Machine Learning from Disaster |
5,639,062 | def make_model(filter_size, num_filters):
tokenized_input = Input(shape=(MAX_SEQUENCE_LENGTH,), name="tokenized_input")
pretrained = Embedding(MAX_WORDS,
EMBEDDINGS_LOADED_DIMENSIONS,
weights=[pretrained_emb_weights],
trainable=False )(tokenized_input)
pretrained = Reshape(( MAX_SEQUENCE_LENGTH, EMBEDDINGS_LOADED_DIM... | default_imputer = GenericTransformer(
fitter = lambda X: {
col: "missing" if X[col].dtype == "object" else X[col].median() for col in X.columns},
transformer = lambda X, default_values:(
X.assign(**{col: X[col].fillna(default_values[col])for col in X.columns})) ,
)
assert not default_imputer.fit_transform(X_train )... | Titanic - Machine Learning from Disaster |
5,639,062 | filter_sizes = [1, 2, 3, 5]
num_filters = 45
test_predictions = []
kaggle_predictions = []
train_X, test_X, train_Y, test_Y = train_test_split(X, Y, test_size=0.025)
for f in filter_sizes:
print("CNN MODEL WITH FILTER OF SIZE {0}".format(f))
epoch_callback = EpochMetricsCallback()
model = make_model(f, num_filters)
x... | class DummiesTransformer(BaseEstimator, TransformerMixin):
def __init__(self, drop_first=False):
self.drop_first = drop_first
def fit_transform(self, x, y=None):
result = pd.get_dummies(x, drop_first=self.drop_first)
self.output_cols = result.columns
return result
def fit(self, x, y = None):
self.fit_transform(x, y)... | Titanic - Machine Learning from Disaster |
5,639,062 | avg = np.average(kaggle_predictions, axis=0)
df_out = pd.DataFrame({"qid":df_test["qid"].values})
df_out['prediction'] =(avg > THRESHOLD ).astype(int)
df_out.to_csv("submission.csv", index=False )<save_to_csv> | drop_original = GenericTransformer(lambda X: X.drop(columns=X_train.columns))
assert len(drop_original.fit_transform(X_train ).columns)== 0 | Titanic - Machine Learning from Disaster |
5,639,062 |
<define_variables> | feat_accumulator = pd.DataFrame()
model = RidgeClassifier(random_state=0)
def test_features(label, isolated, combination, prev_label=None, extra_imputers=[]):
isolated_pipeline = make_pipeline(*extra_imputers, default_imputer, *isolated,
drop_original, add_dummies, model)
iso_accuracy = cross_val_score(isolated_pipel... | Titanic - Machine Learning from Disaster |
5,639,062 | embed_size = 300
max_features = 95000
maxlen = 70<import_modules> | add_age = GenericTransformer(
lambda X: X.assign(AGE_BINNED = pd.cut(
X[cc.Age], [0,7,14,35,60,1000],
labels=["young child","child", "young adult", "adult", "old"])))
test_features("age", [add_age], [add_age], "null" ) | Titanic - Machine Learning from Disaster |
5,639,062 | 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 sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklearn.metrics import f1_score, roc_auc_score
from keras.preprocessing.t... | add_class = GenericTransformer(lambda X: X.assign(CLASS_BINNED=X[cc.Pclass].astype(str)))
test_features("class", [add_class], [add_age, add_class], "age" ) | Titanic - Machine Learning from Disaster |
5,639,062 | def load_and_prec() :
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)
train_X = train_df["question_text"].fillna("_
test_X = test_df["question_text"].fillna("_
tokenizer = Tokenizer(num_words=max_fe... | class TicketSurvivalTransformer(BaseEstimator, TransformerMixin):
def __init__(self, xy):
self.xy = xy
def fit(self, X, y=None):
X_with_survival = X.assign(Survived = self.xy.reindex(X.index)[cc.Survived])
self.mean_survival = X_with_survival[cc.Survived].mean()
self.group_stats =(X_with_survival.groupby(cc.Ticket)[... | Titanic - Machine Learning from Disaster |
5,639,062 | 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')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE))
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_st... | add_tkt = TicketSurvivalTransformer(Xy_train)
test_features("tkt", [add_tkt], [add_age, add_class, add_tkt], "class" ) | Titanic - Machine Learning from Disaster |
5,639,062 | class Attention(Layer):
def __init__(self, step_dim,
W_regularizer=None, b_regularizer=None,
W_constraint=None, b_constraint=None,
bias=True, **kwargs):
self.supports_masking = True
self.init = initializers.get('glorot_uniform')
self.W_regularizer = regularizers.get(W_regularizer)
self.b_regularizer = regularizers.ge... | test_features("sex", [add_sex], [add_age, add_class, add_tkt, add_sex], "tkt" ) | Titanic - Machine Learning from Disaster |
5,639,062 | class CyclicLR(Callback):
def __init__(self, base_lr=0.001, max_lr=0.006, step_size=2000., mode='triangular',
gamma=1., scale_fn=None, scale_mode='cycle'):
super(CyclicLR, self ).__init__()
self.base_lr = base_lr
self.max_lr = max_lr
self.step_size = step_size
self.mode = mode
self.gamma = gamma
if scale_fn == None:
... | impute_age = TitleAgeImputer()
test_features("age_from_title", [add_age], [add_age, add_class, add_tkt, add_sex], "sex",
extra_imputers=[impute_age] ) | Titanic - Machine Learning from Disaster |
5,639,062 | def model_lstm_atten(embedding_matrix):
inp = Input(shape=(maxlen,))
x = Embedding(max_features, embed_size, weights=[embedding_matrix], trainable=False )(inp)
x = SpatialDropout1D(0.1 )(x)
x = Bidirectional(CuDNNLSTM(40, return_sequences=True))(x)
y = Bidirectional(CuDNNGRU(40, return_sequences=True))(x)
atten_1 =... | final_model = RidgeClassifier(random_state=0)
final_X_train = final_pipeline.fit_transform(X_train)
cvscore = cross_val_score(final_model, final_X_train, y_train, cv=4)
print(f"cv = {np.mean(cvscore)}:
{list(cvscore)}")
final_model.fit(final_X_train, y_train)
X_test = pd.read_csv(".. /input/titanic/test.csv", inde... | Titanic - Machine Learning from Disaster |
1,266,101 | def train_pred(model, train_X, train_y, val_X, val_y, epochs=2, callback=None):
for e in range(epochs):
model.fit(train_X, train_y, batch_size=512, epochs=1, validation_data=(val_X, val_y), callbacks = callback, verbose=0)
pred_val_y = model.predict([val_X], batch_size=1024, verbose=0)
best_score = metrics.f1_score(v... | def get_missing_data_table(dataframe):
total = dataframe.isnull().sum()
percentage = dataframe.isnull().sum() / dataframe.isnull().count()
missing_data = pd.concat([total, percentage], axis='columns', keys=['TOTAL','PERCENTAGE'])
return missing_data.sort_index(ascending=True)
def get_null_observations(dataframe, co... | 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.