kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
943,976 | 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... | X_train = df_train[CATEGORY_COLUMNS].fillna(-1000)
y_train = df_train["Survived"]
X_test = df_test[CATEGORY_COLUMNS].fillna(-1000)
randomf=RandomForestClassifier(criterion='gini', n_estimators=700, min_samples_split=10,min_samples_leaf=1,max_features='auto',oob_score=True,random_state=1,n_jobs=-1)
randomf.fit(X_trai... | Titanic - Machine Learning from Disaster |
943,976 | splits = list(StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=SEED ).split(x_train, y_train))
splits[:3]<choose_model_class> | MLA = [
ensemble.ExtraTreesClassifier() ,
ensemble.GradientBoostingClassifier() ,
ensemble.RandomForestClassifier() ,
linear_model.LogisticRegressionCV() ,
neighbors.KNeighborsClassifier() ,
svm.SVC(probability=True),
]
index = 1
for alg in MLA:
predicted = alg.fit(X_train, y_train ).predict(X_test)
fp, tp, th = roc_c... | Titanic - Machine Learning from Disaster |
943,976 | 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... | REVISED_NUMERIC_COLUMNS=['Pclass','Age','SibSp','Parch','Family_Survival','Alone','Title_Master', 'Title_Miss','Title_Mr', 'Title_Mrs', 'Title_Millitary','Embarked']
SIMPLE_COLUMNS=['Pclass','Age','SibSp','Parch','Family_Survival','Alone','Sex_female','Sex_male','Title_Master', 'Title_Miss','Title_Mr', 'Title_Mrs', 'Ti... | Titanic - Machine Learning from Disaster |
943,976 | 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... | logreg = LogisticRegression(C=10, solver='newton-cg')
logreg.fit(X_train, y_train)
y_pred_train_logreg = cross_val_predict(logreg,X_val, y_val)
y_pred_test_logreg = logreg.predict(X_test)
print('logreg first layer predicted')
tree = DecisionTreeClassifier(random_state=8,min_samples_leaf=6, max_features= 7, max_dep... | Titanic - Machine Learning from Disaster |
943,976 | 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... | votingC = VotingClassifier(estimators=[('logreg', logreg_cv.best_estimator_),('gbk', gbk_cv.best_estimator_),
('tree', tree_cv.best_estimator_),('randomforest',randomforest_cv.best_estimator_),('knn',knn_cv.best_estimator_)], voting='soft', n_jobs=4)
votingC = votingC.fit(X_train, y_train)
Submission['Survived'] = v... | Titanic - Machine Learning from Disaster |
943,976 | 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> | second_layer_train = pd.DataFrame({'Logistic Regression': y_pred_train_logreg.ravel() ,
'Gradient Boosting': y_pred_train_gbk.ravel() ,
'Decision Tree': y_pred_train_tree.ravel() ,
'Random Forest': y_pred_train_randomforest.ravel()
})
X_train_second = np.concatenate(( y_pred_train_logreg.reshape(-1, 1), y_pred_train_g... | Titanic - Machine Learning from Disaster |
943,976 | <data_type_conversions><EOS> | Submission.to_csv('tunedensemblesubmission04.csv',sep=',')
print('tuned Ensemble File created' ) | Titanic - Machine Learning from Disaster |
5,214,044 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<compute_test_metric> | train_data = pd.read_csv('/kaggle/input/train.csv')
test_data = pd.read_csv('/kaggle/input/test.csv' ) | Titanic - Machine Learning from Disaster |
5,214,044 | 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... | full_data = [train_data, test_data]
for idx, dataset in enumerate(full_data):
dataset = pd.concat([pd.get_dummies(dataset['Pclass'], prefix='Pclass'), dataset], axis=1)
dataset = dataset.drop(['Pclass', 'Pclass_3'], axis=1)
dataset['Title'] = dataset['Name'].apply(get_title)
dataset['Title'] = dataset['Title'].repla... | Titanic - Machine Learning from Disaster |
5,214,044 | submission = df_test[['qid']].copy()
submission['prediction'] =(test_preds > delta ).astype(int)
submission.to_csv('submission.csv', index=False )<load_from_csv> | kf = KFold(n_splits=5, random_state = 0)
clf = clf = RandomForestClassifier(n_estimators=400, max_depth=4, min_samples_split=4, random_state=0)
for train_index, test_index in kf.split(X_train):
__kf_X_train, __kf_X_test = X_train.values[train_index], X_train.values[test_index]
__kf_y_train, __kf_y_test = y_train.valu... | Titanic - Machine Learning from Disaster |
5,214,044 | <feature_engineering><EOS> | y_pred = pd.Series(clf.predict(X_test))
submission = pd.concat([submission_id, y_pred], axis=1)
submission = submission.rename(columns={0:'Survived'})
submission.to_csv('submisson.csv', index=False ) | Titanic - Machine Learning from Disaster |
6,678,936 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | %matplotlib inline
warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | path = ".. /input/titanic/" | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | cv_n_split = 2
random_state = 0
test_train_split_part = 0.15 | Titanic - Machine Learning from Disaster |
6,678,936 | print(os.listdir())
model = Sentiment(text.vocab.vectors, padding_idx=text.vocab.stoi[text.pad_token], batch_size=batch_size ).cuda()
model.load_state_dict(torch.load('checkpoint.pt'))<init_hyperparams> | metrics_all = {1 : 'r2_score', 2: 'acc', 3 : 'rmse', 4 : 're'}
metrics_now = [1, 2, 3, 4] | Titanic - Machine Learning from Disaster |
6,678,936 | print('Threshold:',search_result['threshold'])
submission_list = list(torchtext.data.BucketIterator(dataset=submission_x,
batch_size=batch_size,
sort=False,
train=False))
pred = []
with torch.no_grad() :
for submission_batch in submission_list:
model.eval()
x = submission_batch.text.cuda()
pred += torch.sigmoid(model(... | traindf = pd.read_csv(path + 'train.csv' ).set_index('PassengerId')
testdf = pd.read_csv(path + 'test.csv' ).set_index('PassengerId')
submission = pd.read_csv(path + 'gender_submission.csv' ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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...' )<load_from_csv> | target_name = 'Survived' | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | df = pd.concat([traindf, testdf], axis=0, sort=False)
df['Title'] = df.Name.str.split(',' ).str[1].str.split('.' ).str[0].str.strip()
df['Title'] = df.Name.str.split(',' ).str[1].str.split('.' ).str[0].str.strip()
df['IsWomanOrBoy'] =(( df.Title == 'Master')|(df.Sex == 'female'))
df['LastName'] = df.Name.str.split(','... | Titanic - Machine Learning from Disaster |
6,678,936 | glove = torchtext.vocab.Vectors('.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt')
text.vocab.set_vectors(glove.stoi, glove.vectors, dim=300 )<define_variables> | df['Title'] = df['Title'].replace('Ms','Miss')
df['Title'] = df['Title'].replace('Mlle','Miss')
df['Title'] = df['Title'].replace('Mme','Mrs')
df['Embarked'] = df['Embarked'].fillna('S')
med_fare = df.groupby(['Pclass', 'Parch', 'SibSp'] ).Fare.median() [3][0][0]
df['Fare'] = df['Fare'].fillna(med_fare)
df['famous... | Titanic - Machine Learning from Disaster |
6,678,936 | batch_size = 512
print('batch_size:',batch_size)
print('---')
train_loader = torchtext.data.BucketIterator(dataset=train,
batch_size=batch_size,
shuffle=True,
sort=False)
test_loader = torchtext.data.BucketIterator(dataset=test,
batch_size=batch_size,
shuffle=False,
sort=False)
<set_options> | cols_to_drop = ['Name','Ticket','Cabin']
df = df.drop(cols_to_drop, axis=1 ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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())
class SentimentLSTM(nn.Module):
def __init__(self,vocab_vectors,padding_idx,batch_size):
super(SentimentLSTM,self ).__init__()
print('... | Y = df.Survived.loc[traindf.index].astype(int)
X_train, X_test = df.loc[traindf.index], df.loc[testdf.index]
X_test = X_test.drop(['Survived'], axis = 1 ) | Titanic - Machine Learning from Disaster |
6,678,936 | model = SentimentLSTM(text.vocab.vectors, padding_idx=text.vocab.stoi[text.pad_token], batch_size=batch_size ).cuda()
print(model)
print('-'*80)
train(model,'lstm.pt',3)
print('-'*80 )<train_model> | print(X_train.isnull().sum())
| Titanic - Machine Learning from Disaster |
6,678,936 | model = SentimentBase().cuda()
print(model)
print('-'*80)
train(model,'base.pt',5)
print('-'*80 )<train_on_grid> | numerics = ['int8', 'int16', 'int32', 'int64', 'float16', 'float32', 'float64']
categorical_columns = []
features = X_train.columns.values.tolist()
for col in features:
if X_train[col].dtype in numerics: continue
categorical_columns.append(col)
categorical_columns | Titanic - Machine Learning from Disaster |
6,678,936 | model = SentimentCNN(text.vocab.vectors, padding_idx=text.vocab.stoi[text.pad_token], batch_size=batch_size ).cuda()
print(model)
print('-'*80)
train(model,'cnn.pt',3)
print('-'*80 )<train_on_grid> | for col in categorical_columns:
if col in X_train.columns:
le = LabelEncoder()
le.fit(list(X_train[col].astype(str ).values)+ list(X_test[col].astype(str ).values))
X_train[col] = le.transform(list(X_train[col].astype(str ).values))
X_test[col] = le.transform(list(X_test[col].astype(str ).values)) | Titanic - Machine Learning from Disaster |
6,678,936 | model = SentimentGRU(text.vocab.vectors, padding_idx=text.vocab.stoi[text.pad_token], batch_size=batch_size ).cuda()
print(model)
print('-'*80)
train(model,'gru.pt',3)
print('-'*80 )<choose_model_class> | X_train = X_train.reset_index()
X_test = X_test.reset_index()
X_dropna_categor = X_train.dropna().astype(int)
Xtest_dropna_categor = X_test.dropna().astype(int ) | Titanic - Machine Learning from Disaster |
6,678,936 | def disable_grad(layer):
for p in layer.parameters() :
p.requires_grad=False
class Ensemble(nn.Module):
def __init__(self,vocab_vectors,padding_idx,batch_size):
super(Ensemble,self ).__init__()
self.lstm = SentimentLSTM(text.vocab.vectors, padding_idx=text.vocab.stoi[text.pad_token], batch_size=batch_size ).cuda()
self... | Sex_female_Survived = X_dropna_categor.loc[(X_dropna_categor.Sex == 0)&(X_dropna_categor.Survived == 1)]
Sex_female_NoSurvived = X_dropna_categor.loc[(X_dropna_categor.Sex == 0)&(X_dropna_categor.Survived == 0)]
X_Sex_male_Survived = X_dropna_categor.loc[(X_dropna_categor.Sex == 1)&(X_dropna_categor.Survived == 1)]
X_S... | Titanic - Machine Learning from Disaster |
6,678,936 | print(os.listdir())
model = Ensemble(text.vocab.vectors, padding_idx=text.vocab.stoi[text.pad_token], batch_size=batch_size ).cuda()
model.load_state_dict(torch.load('ensemble.pt'))
<init_hyperparams> | def derf(sample, mean, std):
age_shape = sample['Age'].shape[0]
if age_shape > 0:
standard_error_ofthe_mean = std / math.sqrt(age_shape)
random_mean = round(random.uniform(mean-(1.96*standard_error_ofthe_mean), mean+(1.96*standard_error_ofthe_mean)) , 2)
else: random_mean = 0
return random_mean | Titanic - Machine Learning from Disaster |
6,678,936 | print('Threshold:',search_result['threshold'])
submission_list = list(torchtext.data.BucketIterator(dataset=submission_x,
batch_size=batch_size,
sort=False,
train=False))
pred = []
with torch.no_grad() :
for submission_batch in submission_list:
model.eval()
x = submission_batch.text.cuda()
pred += torch.sigmoid(model(... | for i in X_train.loc[(X_train['Sex']==0)&(X_train['Survived']==1)&(X_train['Age'].isnull())].index:
X_train.at[i, 'Age'] = derf(Sex_female_Survived, female_Survived_mean, female_Survived_std)
for h in X_train.loc[(X_train['Sex']==0)&(X_train['Survived']==0)&(X_train['Age'].isnull())].index:
X_train.at[h, 'Age'] = derf... | Titanic - Machine Learning from Disaster |
6,678,936 | tqdm.pandas(desc='Progress')
<define_variables> | X_train = X_train.drop(['Survived'], axis = 1 ) | Titanic - Machine Learning from Disaster |
6,678,936 | embed_size = 300
max_features = 120000
maxlen = 70
batch_size = 512
n_epochs = 5
n_splits = 5
SEED = 1029<set_options> | print(X_train.isnull().sum())
print(X_test.isnull().sum() ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | def fe_creation(df):
df['Age2'] = df['Age']//10
df['Fare2'] = df['Fare']//10
for i in ['Sex', 'Family_Size', 'Fare2','Alone', 'famous_cabin']:
for j in ['Age2','Title', 'Embarked', 'Deck']:
df[i + "_" + j] = df[i].astype('str')+ "_" + df[j].astype('str')
return df
X_train = fe_creation(X_train)
X_test = fe_creation(X... | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | categorical_columns = []
features = X_train.columns.values.tolist()
for col in features:
if X_train[col].dtype in numerics: continue
categorical_columns.append(col)
categorical_columns | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | for col in categorical_columns:
if col in X_train.columns:
le = LabelEncoder()
le.fit(list(X_train[col].astype(str ).values)+ list(X_test[col].astype(str ).values))
X_train[col] = le.transform(list(X_train[col].astype(str ).values))
X_test[col] = le.transform(list(X_test[col].astype(str ).values)) | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | train0, test0 = X_train, X_test
target0 = Y | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | scaler = StandardScaler()
train0 = pd.DataFrame(scaler.fit_transform(train0), columns = train0.columns)
test0 = pd.DataFrame(scaler.transform(test0), columns = test0.columns)
train0b = train0.copy()
test0b = test0.copy()
trainb, testb, targetb, target_testb = train_test_split(train0b, target0, test_size=test_train_sp... | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | scaler = MinMaxScaler()
train0 = pd.DataFrame(scaler.fit_transform(train0), columns = train0.columns)
test0 = pd.DataFrame(scaler.fit_transform(test0), columns = test0.columns ) | Titanic - Machine Learning from Disaster |
6,678,936 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | train, test, target, target_test = train_test_split(train0, target0, test_size=test_train_split_part, random_state=random_state ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | num_models = 20
acc_train = []
acc_test = []
acc_all = np.empty(( len(metrics_now)*2, 0)).tolist()
acc_all | Titanic - Machine Learning from Disaster |
6,678,936 | x_train, x_test, y_train, features, test_features, word_index = load_and_prec()
<save_model> | acc_all_pred = np.empty(( len(metrics_now), 0)).tolist()
acc_all_pred | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | cv_train = ShuffleSplit(n_splits=cv_n_split, test_size=test_train_split_part, random_state=random_state ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | def acc_d(y_meas, y_pred):
return mean_absolute_error(y_meas, y_pred)*len(y_meas)/sum(abs(y_meas))
def acc_rmse(y_meas, y_pred):
return(mean_squared_error(y_meas, y_pred)) **0.5 | Titanic - Machine Learning from Disaster |
6,678,936 | seed_everything()
glove_embeddings = load_glove(word_index)
paragram_embeddings = load_para(word_index)
embedding_matrix = np.mean([glove_embeddings, paragram_embeddings, paragram_embeddings], axis=0)
del glove_embeddings, paragram_embeddings
gc.collect()
np.shape(embedding_matrix )<split> | def acc_metrics_calc(num,model,train,test,target,target_test):
global acc_all
ytrain = model.predict(train ).astype(int)
ytest = model.predict(test ).astype(int)
print('target = ', target[:5].values)
print('ytrain = ', ytrain[:5])
print('target_test =', target_test[:5].values)
print('ytest =', ytest[:5])
num_acc ... | Titanic - Machine Learning from Disaster |
6,678,936 | splits = list(StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=SEED ).split(x_train, y_train))
splits[:3]<choose_model_class> | def acc_metrics_calc_pred(num,model,name_model,train,test,target):
global acc_all_pred
ytrain = model.predict(train ).astype(int)
ytest = model.predict(test ).astype(int)
print('**********')
print(name_model)
print('target = ', target[:15].values)
print('ytrain = ', ytrain[:15])
print('ytest =', ytest[:15])
num_... | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | linreg = LinearRegression()
linreg_CV = GridSearchCV(linreg, param_grid={}, cv=cv_train, verbose=False)
linreg_CV.fit(train, target)
print(linreg_CV.best_params_)
acc_metrics_calc(0,linreg_CV,train,test,target,target_test ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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-9
num_classes = 30
class Embed_Layer(nn.Module):
def __init__(self, e... | svr = SVC()
svr_CV = GridSearchCV(svr, param_grid={'kernel': ['linear', 'poly', 'rbf', 'sigmoid'],
'tol': [1e-4]},
cv=cv_train, verbose=False)
svr_CV.fit(train, target)
print(svr_CV.best_params_)
acc_metrics_calc(1,svr_CV,train,test,target,target_test ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | linear_svc = LinearSVC()
param_grid = {'dual':[False],
'C': np.linspace(1, 15, 15)}
linear_svc_CV = GridSearchCV(linear_svc, param_grid=param_grid, cv=cv_train, verbose=False)
linear_svc_CV.fit(train, target)
print(linear_svc_CV.best_params_)
acc_metrics_calc(2,linear_svc_CV,train,test,target,target_test ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | %%time
mlp = MLPClassifier()
param_grid = {'hidden_layer_sizes': [i for i in range(2,5)],
'solver': ['sgd'],
'learning_rate': ['adaptive'],
'max_iter': [1000]
}
mlp_GS = GridSearchCV(mlp, param_grid=param_grid, cv=cv_train, verbose=False)
mlp_GS.fit(train, target)
print(mlp_GS.best_params_)
acc_metrics_calc(3,mlp_GS... | Titanic - Machine Learning from Disaster |
6,678,936 | 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_... | sgd = SGDClassifier(early_stopping=True)
param_grid = {'alpha': [0.0001, 0.001, 0.01, 0.1, 1]}
sgd_CV = GridSearchCV(sgd, param_grid=param_grid, cv=cv_train, verbose=False)
sgd_CV.fit(train, target)
print(sgd_CV.best_params_)
acc_metrics_calc(4,sgd_CV,train,test,target,target_test ) | Titanic - Machine Learning from Disaster |
6,678,936 | for i,(train_idx, valid_idx)in enumerate(splits):
x_train = np.array(x_train)
y_train = np.array(y_train)
features = np.array(features)
x_train_fold = torch.tensor(x_train[train_idx.astype(int)], dtype=torch.long ).cuda()
y_train_fold = torch.tensor(y_train[train_idx.astype(int), np.newaxis], dtype=torch.float32 ).c... | decision_tree = DecisionTreeClassifier()
param_grid = {'min_samples_leaf': [i for i in range(2,10)]}
decision_tree_CV = GridSearchCV(decision_tree, param_grid=param_grid, cv=cv_train, verbose=False)
decision_tree_CV.fit(train, target)
print(decision_tree_CV.best_params_)
acc_metrics_calc(5,decision_tree_CV,train,tes... | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | %%time
random_forest = RandomForestClassifier()
param_grid = {'n_estimators': [300, 400, 500, 600], 'min_samples_split': [60], 'min_samples_leaf': [20, 25, 30, 35, 40],
'max_features': ['auto'], 'max_depth': [5, 6, 7, 8, 9, 10], 'criterion': ['gini'], 'bootstrap': [False]}
random_forest_CV = GridSearchCV(estimator=rand... | Titanic - Machine Learning from Disaster |
6,678,936 | submission = df_test[['qid']].copy()
submission['prediction'] =(test_preds > delta ).astype(int)
submission.to_csv('submission.csv', index=False )<import_modules> | %%time
xgb_clf = xgb.XGBClassifier(objective='reg:squarederror')
parameters = {'n_estimators': [200, 300, 400],
'learning_rate': [0.001, 0.003, 0.005, 0.006, 0.01],
'max_depth': [4, 5, 6]}
xgb_reg = GridSearchCV(estimator=xgb_clf, param_grid=parameters, cv=cv_train ).fit(trainb, targetb)
print("Best score: %0.3f" % x... | Titanic - Machine Learning from Disaster |
6,678,936 | tqdm.pandas(desc='Progress')
<define_variables> | Xtrain, Xval, Ztrain, Zval = train_test_split(trainb, targetb, test_size=test_train_split_part, random_state=random_state)
modelL = lgb.LGBMClassifier(n_estimators=1000, num_leaves=50)
modelL.fit(Xtrain, Ztrain, eval_set=[(Xval, Zval)], early_stopping_rounds=50, verbose=True ) | Titanic - Machine Learning from Disaster |
6,678,936 | embed_size = 300
max_features = 120000
maxlen = 70
batch_size = 512
n_epochs = 5
n_splits = 5
SEED = 1029<set_options> | acc_metrics_calc(8,modelL,trainb,testb,targetb,target_testb ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | gradient_boosting = GradientBoostingClassifier()
param_grid = {'learning_rate' : [0.001, 0.01, 0.1],
'max_depth': [i for i in range(2,5)],
'min_samples_leaf': [i for i in range(2,5)]}
gradient_boosting_CV = GridSearchCV(estimator=gradient_boosting, param_grid=param_grid,
cv=cv_train, verbose=False)
gradient_boosting_C... | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | ridge = RidgeClassifier()
ridge_CV = GridSearchCV(estimator=ridge, param_grid={'alpha': np.linspace (.1, 1.5, 15)}, cv=cv_train, verbose=False)
ridge_CV.fit(train, target)
print(ridge_CV.best_params_)
acc_metrics_calc(10,ridge_CV,train,test,target,target_test ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | %%time
bagging = BaggingClassifier(base_estimator=linear_svc_CV)
param_grid={'max_features': [0.5, 0.6, 0.7, 0.8, 0.9, 1.0],
'n_estimators': [3, 5, 10],
'warm_start' : [True],
'random_state': [random_state]}
bagging_CV = GridSearchCV(estimator=bagging, param_grid=param_grid, cv=cv_train, verbose=False)
bagging_CV.fit... | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | etr = ExtraTreesClassifier()
etr_CV = GridSearchCV(estimator=etr, param_grid={'min_samples_leaf' : [10, 20, 30, 40, 50]}, cv=cv_train, verbose=False)
etr_CV.fit(train, target)
acc_metrics_calc(12,etr_CV,train,test,target,target_test ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | Ada_Boost = AdaBoostClassifier()
Ada_Boost_CV = GridSearchCV(estimator=Ada_Boost, param_grid={'learning_rate' : [.01,.1,.5, 1]}, cv=cv_train, verbose=False)
Ada_Boost_CV.fit(train, target)
acc_metrics_calc(13,Ada_Boost_CV,train,test,target,target_test ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | logreg = LogisticRegression()
logreg_CV = GridSearchCV(estimator=logreg, param_grid={'C' : [.1,.3,.5,.7, 1]}, cv=cv_train, verbose=False)
logreg_CV.fit(train, target)
acc_metrics_calc(14,logreg_CV,train,test,target,target_test ) | Titanic - Machine Learning from Disaster |
6,678,936 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | knn = KNeighborsClassifier()
param_grid={'n_neighbors': range(2, 7)}
knn_CV = GridSearchCV(estimator=knn, param_grid=param_grid,
cv=cv_train, verbose=False ).fit(train, target)
print(knn_CV.best_params_)
acc_metrics_calc(15,knn_CV,train,test,target,target_test ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | gaussian = GaussianNB()
param_grid={'var_smoothing': [1e-8, 1e-9, 1e-10]}
gaussian_CV = GridSearchCV(estimator=gaussian, param_grid=param_grid, cv=cv_train, verbose=False)
gaussian_CV.fit(train, target)
print(gaussian_CV.best_params_)
acc_metrics_calc(16,gaussian_CV,train,test,target,target_test ) | Titanic - Machine Learning from Disaster |
6,678,936 | x_train, x_test, y_train, features, test_features, word_index = load_and_prec()
<save_model> | perceptron = Perceptron()
param_grid = {'penalty': [None, 'l2', 'l1', 'elasticnet']}
perceptron_CV = GridSearchCV(estimator=perceptron, param_grid=param_grid, cv=cv_train, verbose=False)
perceptron_CV.fit(train, target)
print(perceptron_CV.best_params_)
acc_metrics_calc(17,perceptron_CV,train,test,target,target_test... | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | gpc = GaussianProcessClassifier()
param_grid = {'max_iter_predict': [100, 200],
'warm_start': [True, False],
'n_restarts_optimizer': range(3)}
gpc_CV = GridSearchCV(estimator=gpc, param_grid=param_grid, cv=cv_train, verbose=False)
gpc_CV.fit(train, target)
print(gpc_CV.best_params_)
acc_metrics_calc(18,gpc_CV,train,... | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | Voting_ens = VotingClassifier(estimators=[('log', logreg_CV),('mlp', mlp_GS),('svc', linear_svc_CV)])
Voting_ens.fit(train, target)
acc_metrics_calc(19,Voting_ens,train,test,target,target_test ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | models = pd.DataFrame({
'Model': ['Linear Regression', 'Support Vector Machines', 'Linear SVC',
'MLPClassifier', 'Stochastic Gradient Decent',
'Decision Tree Classifier', 'Random Forest', 'XGBClassifier', 'LGBMClassifier',
'GradientBoostingClassifier', 'RidgeClassifier', 'BaggingClassifier', 'ExtraTreesClassifier',
'Ad... | Titanic - Machine Learning from Disaster |
6,678,936 | splits = list(StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=SEED ).split(x_train, y_train))
splits[:3]<choose_model_class> | for x in metrics_now:
xs = metrics_all[x]
models[xs + '_train'] = acc_all[(x-1)*2]
models[xs + '_test'] = acc_all[(x-1)*2+1]
if xs == "acc":
models[xs + '_diff'] = models[xs + '_train'] - models[xs + '_test']
models | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | print('Prediction accuracy for models')
ms = metrics_all[metrics_now[1]]
models.sort_values(by=[(ms + '_test'),(ms + '_train')], ascending=False ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | pd.options.display.float_format = '{:,.2f}'.format | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | metrics_main = 2
xs = metrics_all[metrics_main]
xs_train = metrics_all[metrics_main] + '_train'
xs_test = metrics_all[metrics_main] + '_test'
print('The best models by the',xs,'criterion:')
direct_sort = False if(metrics_main >= 2)else True
models_sort = models.sort_values(by=[xs_test, xs_train], ascending=direct_sort... | Titanic - Machine Learning from Disaster |
6,678,936 | 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> | models_sort = models_sort[models_sort.Model != 'VotingClassifier']
models_best = models_sort[(models_sort.acc_diff < 5)&(models_sort.acc_train > 90)]
models_best[['Model', ms + '_train', ms + '_test', 'acc_diff']].sort_values(by=['acc_test'], ascending=False ) | Titanic - Machine Learning from Disaster |
6,678,936 | 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_... | models_pred = pd.DataFrame(models_best.Model, columns = ['Model'])
N_best_models = len(models_best.Model ) | Titanic - Machine Learning from Disaster |
6,678,936 | for i,(train_idx, valid_idx)in enumerate(splits):
x_train = np.array(x_train)
y_train = np.array(y_train)
features = np.array(features)
x_train_fold = torch.tensor(x_train[train_idx.astype(int)], dtype=torch.long ).cuda()
y_train_fold = torch.tensor(y_train[train_idx.astype(int), np.newaxis], dtype=torch.float32 ).c... | def model_fit(name_model,train,target):
if name_model == 'LGBMClassifier':
Xtrain, Xval, Ztrain, Zval = train_test_split(train, target, test_size=test_train_split_part, random_state=random_state)
model = lgb.LGBMClassifier(n_estimators=1000)
model.fit(Xtrain, Ztrain, eval_set=[(Xval, Zval)], early_stopping_rounds=50,... | Titanic - Machine Learning from Disaster |
6,678,936 | 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... | for i in range(N_best_models):
name_model = models_best.iloc[i]['Model']
if(name_model == 'LGBMClassifier')or(name_model == 'XGBClassifier'):
model = model_fit(name_model,train0b,target0)
acc_metrics_calc_pred(i,model,name_model,train0b,test0b,target0)
else:
model = model_fit(name_model,train0,target0)
acc_metrics_c... | Titanic - Machine Learning from Disaster |
6,678,936 | <set_options><EOS> | for x in metrics_now:
xs = metrics_all[x]
models_pred[xs + '_train'] = acc_all_pred[(x-1)]
models_pred[['Model', 'acc_train']].sort_values(by=['acc_train'], ascending=False ) | Titanic - Machine Learning from Disaster |
965,330 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | import numpy as np
import pandas as pd
from catboost import CatBoostClassifier, Pool, cv
import hyperopt | Titanic - Machine Learning from Disaster |
965,330 | EMBEDDING_FILE = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
submission = pd.read_csv('.. /input/sample_submission.csv' )<string_transform> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
train_size = train.shape[0]
test_size = test.shape[0]
data = pd.concat([train, test] ) | Titanic - Machine Learning from Disaster |
965,330 | X_train = train["question_text"].fillna("fillna" ).values
y_train = train["target"].values
X_test = test["question_text"].fillna("fillna" ).values
max_features = 40000
maxlen = 50
embed_size = 300
tokenizer = text.Tokenizer(num_words=max_features)
tokenizer.fit_on_texts(list(X_train)+ list(X_test))
X_train = tokenizer... | data['Title'] = data['Name'].str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
965,330 | def get_coefs(word, *arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.rstrip().rsplit(' ')) for o in open(EMBEDDING_FILE))
word_index = tokenizer.word_index
nb_words = min(max_features, len(word_index))
embedding_matrix = np.zeros(( nb_words, embed_size))
for word, i in word_ind... | age_ref = data.groupby('Title' ).Age.mean()
data['Age'] = data.apply(lambda r: r.Age if pd.notnull(r.Age)else age_ref[r.Title] , axis=1)
del age_ref | Titanic - Machine Learning from Disaster |
965,330 | class F1Evaluation(Callback):
def __init__(self, validation_data=() , interval=1):
super(Callback, self ).__init__()
self.interval = interval
self.X_val, self.y_val = validation_data
def on_epoch_end(self, epoch, logs={}):
if epoch % self.interval == 0:
y_pred = self.model.predict(self.X_val, verbose=0)
y_pred =(y_pre... | data.loc[(data.PassengerId==1044, 'Fare')] = 14.43 | Titanic - Machine Learning from Disaster |
965,330 | filter_sizes = [1,2,3,5]
num_filters = 36
def get_model() :
inp = Input(shape=(maxlen,))
x = Embedding(max_features, embed_size, weights=[embedding_matrix] )(inp)
x = SpatialDropout1D(0.4 )(x)
conv_0 = Conv1D(num_filters, kernel_size=(filter_sizes[0]),
kernel_initializer='he_normal', activation='elu' )(x)
conv_1 = C... | data['Embarked'] = data['Embarked'].fillna('S')
data['Cabin'] = data['Cabin'].fillna('Undefined' ) | Titanic - Machine Learning from Disaster |
965,330 | batch_size = 1024
epochs = 4
X_tra, X_val, y_tra, y_val = train_test_split(x_train, y_train, train_size=0.95,
random_state=233)
F1_Score = F1Evaluation(validation_data=(X_val, y_val), interval=1)
hist = model.fit(X_tra, y_tra, batch_size=batch_size, epochs=epochs,
validation_data=(X_val, y_val),
callbacks=[F1_Score],... | cols = [
'Pclass',
'Name',
'Sex',
'Age',
'SibSp',
'Parch',
'Ticket',
'Fare',
'Cabin',
'Embarked'
]
X_train = data[:train_size][cols]
Y_train = data[:train_size]['Survived'].astype(int)
X_test = data[train_size:][cols]
categorical_features_indices = [0,1,2,6,8,9]
X_train.head() | Titanic - Machine Learning from Disaster |
965,330 | filter_sizes = [1,2,3,5]
num_filters = 36
def get_model() :
inp = Input(shape=(maxlen,))
x = Lambda(lambda x: K.reverse(x,axes=-1))(inp)
x = Embedding(max_features, embed_size, weights=[embedding_matrix] )(x)
x = SpatialDropout1D(0.4 )(x)
conv_0 = Conv1D(num_filters, kernel_size=(filter_sizes[0]),
kernel_initializer... | train_pool = Pool(X_train, Y_train, cat_features=categorical_features_indices ) | Titanic - Machine Learning from Disaster |
965,330 | hist_flip = model_flip.fit(X_tra, y_tra, batch_size=batch_size, epochs=epochs,
validation_data=(X_val, y_val),
callbacks=[F1_Score], verbose=True )<predict_on_test> | Titanic - Machine Learning from Disaster | |
965,330 | val_y_pred1 = model.predict(X_val, batch_size=1024, verbose = True)
val_y_pred2 = model_flip.predict(X_val, batch_size=1024, verbose = True)
<compute_test_metric> | model = CatBoostClassifier(
depth=3,
iterations=300,
eval_metric='Accuracy',
random_seed=42,
logging_level='Silent',
allow_writing_files=False
)
cv_data = cv(
train_pool,
model.get_params() ,
fold_count=5
)
print('Best validation accuracy score: {:.2f}±{:.2f} on step {}'.format(
np.max(cv_data['test-Accuracy-mea... | Titanic - Machine Learning from Disaster |
965,330 | val_y_pred = np.mean([val_y_pred1,val_y_pred2],axis = 0 )<predict_on_test> | feature_importances = model.get_feature_importance(train_pool)
feature_names = X_train.columns
for score, name in sorted(zip(feature_importances, feature_names), reverse=True):
print('{}: {}'.format(name, score)) | Titanic - Machine Learning from Disaster |
965,330 | <compute_test_metric><EOS> | Y_pred = model.predict(X_test)
submission = pd.DataFrame({
"PassengerId": data[train_size:]["PassengerId"],
"Survived": Y_pred.astype(int)
})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
737,908 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<compute_test_metric> | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
737,908 | best_threshold = 0.01
best_score = 0.0
for threshold in range(1, 100):
threshold = threshold / 100
score = f1_score(y_val, val_y_pred > threshold)
if score > best_score:
best_threshold = threshold
best_score = score
print("Score at threshold=0.5 is {}".format(f1_score(y_val, val_y_pred > 0.5)))
print("Optimal thresho... | train_set = pd.read_csv('.. /input/train.csv')
test_set = pd.read_csv('.. /input/test.csv')
train_set.shape, test_set.shape | Titanic - Machine Learning from Disaster |
737,908 | y_pred =(y_pred > best_threshold ).astype(int)
submission['prediction'] = y_pred
submission.to_csv('submission.csv', index=False )<set_options> | full_set = pd.concat([train_set, test_set])
full_set.head() | Titanic - Machine Learning from Disaster |
737,908 | start = time.time()
seed = 32
os.environ['PYTHONHASHSEED'] = str(seed)
os.environ['OMP_NUM_THREADS'] = '4'
np.random.seed(seed)
rn.seed(seed)
session_conf = tf.ConfigProto(intra_op_parallelism_threads = 1,
inter_op_parallelism_threads = 1)
tf.set_random_seed(seed)
sess = tf.Session(graph = tf.get_default_graph() ,... | full_set['Age'][full_set['Age'].isnull() ] = full_set['Age'].median()
full_set['Age'] = full_set['Age'].astype(int ) | Titanic - Machine Learning from Disaster |
737,908 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&',
'/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›',
'♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…', '“', '★', '”',
'–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | full_set['HasCabin'] = full_set['Cabin'].apply(lambda x: 0 if isinstance(x, float)else 1 ) | Titanic - Machine Learning from Disaster |
737,908 | sincere = train[train["target"] == 0]
insincere = train[train["target"] == 1]
print("Sincere questions {}; Insincere questions {}".format(sincere.shape[0], insincere.shape[0]))<compute_train_metric> | full_set['Embarked'][full_set['Embarked'].isnull() ] = 'S'
full_set['Embarked'] = full_set['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int ) | Titanic - Machine Learning from Disaster |
737,908 | def get_glove(embedding_file):
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(embedding_file))
all_embs = np.stack(embeddings_index.values())
emb_mean, emb_std = all_embs.mean() , all_embs.std()
return embeddings_index, emb_mean, ... | full_set[ full_set['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
737,908 | def get_embed(tokenizer = None, embeddings_index = None, emb_mean = None, emb_std = None):
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))
for word, i in word_index.items() :
if i >= max_features: continue
embe... | full_set['Fare'][ full_set['Fare'].isnull() ] = 0 . | Titanic - Machine Learning from Disaster |
737,908 | tokenizer = Tokenizer(num_words = max_features, lower = True)
tokenizer.fit_on_texts(train["question_text"])
train_token = tokenizer.texts_to_sequences(train["question_text"])
fake_test_token = tokenizer.texts_to_sequences(fake_test["question_text"])
test_token = tokenizer.texts_to_sequences(test["question_text"])
... | full_set['Title'] = full_set['Name'].apply(get_title)
print(full_set['Title'].unique() ) | Titanic - Machine Learning from Disaster |
737,908 | nb_words, embedding_matrix1 = get_embed(tokenizer = tokenizer, embeddings_index = glove_index,
emb_mean = glove_mean,
emb_std = glove_std)
nb_words, embedding_matrix2 = get_embed(tokenizer = tokenizer, embeddings_index = para_index,
emb_mean = para_mean,
emb_std = para_std)
embedding_matrix = np.mean([embedding_matri... | commons = ['Mr','Mrs','Miss','Mme','Ms','Mlle']
rares = list(set(full_set['Title'].unique())- set(commons))
full_set['Title'] = full_set['Title'].replace('Ms','Miss')
full_set['Title'] = full_set['Title'].replace('Mlle','Miss')
full_set['Title'] = full_set['Title'].replace('Mme','Mrs')
full_set['Title'][full_set['Ti... | Titanic - Machine Learning from Disaster |
737,908 | 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... | full_set['FamSize'] = full_set['Parch'] + full_set['SibSp'] + 1
| Titanic - Machine Learning from Disaster |
737,908 | def get_f1(true, val):
precision, recall, thresholds = precision_recall_curve(true, val)
thresholds = np.append(thresholds, 1.001)
F = 2 /(1/precision + 1/recall)
best_score = np.max(F)
best_threshold = thresholds[np.argmax(F)]
return best_threshold, best_score<choose_model_class> | full_set['Sex'] = full_set['Sex'].map({'male':0, 'female':1} ) | Titanic - Machine Learning from Disaster |
737,908 | def build_model(units = 40, dr = 0.3):
inp = Input(shape =(max_len,))
embed_layer = Embedding(nb_words, embed_size, input_length = max_len,
weights = [embedding_matrix], trainable = False )(inp)
x = SpatialDropout1D(dr, seed = seed )(embed_layer)
x = Bidirectional(CuDNNLSTM(units, kernel_initializer = glorot_normal(s... | full_set.drop(['Cabin','Name','Parch','PassengerId','SibSp','Ticket'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
737,908 | fold = 5
batch_size = 1024
epochs = 5
oof_pred = np.zeros(( train.shape[0], 1))
pred = np.zeros(( test_shape[0], 1))
fake_pred = np.zeros(( test_shape[0], 1))
thresholds = []
k_fold = StratifiedKFold(n_splits = fold, random_state = seed, shuffle = True)
for i,(train_idx, val_idx)in enumerate(k_fold.split(train_seq, ta... | def fare_bin(fare):
if fare <= 7.8958:
return 0.
elif 7.8958 < fare <= 14.4542:
return 1.
elif 14.4542 < fare <= 31.2750:
return 2.
else:
return 3 . | 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.