kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
6,135,017 | dls = dblock.dataloaders(df )<define_variables> | temp = full[full.groupby('Ticket' ).Cabin.transform(lambda x: x.fillna('' ).nunique())>1]
temp.sort_values(by=['Ticket','Cabin'], inplace=True)
temp[['Cabin','Embarked', 'Fare', 'Pclass','Name', 'Ticket']].head(10 ) | Titanic - Machine Learning from Disaster |
6,135,017 | dls.show_batch(nrows=3, ncols=3 )<train_model> | full['Embarked'] = full.Embarked.fillna(full.Embarked.mode() [0])
full['ppFare'] = full.groupby(['Pclass', 'Embarked'] ).ppFare.transform(lambda x: x.fillna(x.median()))
FareToFill = full.ppFare * full.ppTicket
full.loc[full.Fare.isna() , 'Fare'] = FareToFill[full.Fare.isna() ] | Titanic - Machine Learning from Disaster |
6,135,017 |
<train_model> | full['nFamily'] = full.groupby(['Last', 'Ticket_Type', 'Embarked'] ).Last.transform('count')
to_impute = full[['Age', 'ppFare', 'Parch', 'Pclass', 'SibSp', 'hasNickname', 'hasParenthesis', 'ppTicket', 'nFamily']]
dummy = pd.get_dummies(data=full[['Title','Embarked', 'Sex','Ticket_Type']])
to_impute = pd.concat([to_im... | Titanic - Machine Learning from Disaster |
6,135,017 |
<load_pretrained> | full['Title'] = full['Title'].replace(['Don.', 'Rev.', 'Jonkheer.', 'Sir.'], 'Honor')
full['Title'] = full['Title'].replace(['Dr.', 'Col.', 'Major.', 'Capt.'], 'Profession')
full['Title'] = full['Title'].replace(['Ms.', 'Mlle.', 'the Countess.', 'Lady.'], 'Miss.')
full['Title'] = full['Title'].replace(['Mme.', 'Dona... | Titanic - Machine Learning from Disaster |
6,135,017 | learn = load_learner(cassavaModelPath+'CassavaDiseaseModelResnet34.pkl')
learn.export(cassavaOutputPath+'CassavaDiseaseModelResnet34.pkl')
learn = load_learner(cassavaOutputPath+'CassavaDiseaseModelResnet34.pkl' )<save_to_csv> | full['isMarried'] = full.Title.isin(['Mrs.', 'Mme.', 'Dona.'])
full['FamilySize'] = full ['SibSp'] + full['Parch'] + 1
full['CabinGroup'] = full['Cabin_Level'].replace(['A','B'], 'AB')
full['CabinGroup'] = full['CabinGroup'].replace(['C','F'], 'CF')
full['CabinGroup'] = full['CabinGroup'].replace(['D','E'], 'DE')
f... | Titanic - Machine Learning from Disaster |
6,135,017 | print('Computing predictions...')
test_files = get_image_files(cassavaPath+'test_images')
predictions_ResultArray = [None for tempX in range(len(test_files)) ]
predictions_InputArray = [None for tempX in range(len(test_files)) ]
for test_idx in range(0,len(test_files)) :
predictions = learn.predict(test_files[test_id... | full2 = full[['PassengerId','Survived', 'Age','Pclass_cat', 'Embarked', 'Sex', 'Title', 'Cabin_Level', 'ppTicket', 'ppFare', 'Survival_Rate', 'isMarried', 'hasSurvivalInfo', 'FamilySize', 'Parch', 'SibSp', 'nFamily', 'GroupCat']]
dummyVars = full2.select_dtypes(include=['object','bool','category'] ).columns
full3 = pd.... | Titanic - Machine Learning from Disaster |
6,135,017 | df_sample_submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
df_exact_submission = pd.read_csv(cassavaOutputPath+'submission.csv')
print(df_sample_submission.compare(df_exact_submission))
print(df_sample_submission.equals(df_exact_submission))
<install_modules> | clf_ET = ExtraTreesClassifier(random_state=0, bootstrap=True, oob_score=True)
sss = model_selection.StratifiedShuffleSplit(n_splits=10, test_size=0.33, random_state= 0)
sss.get_n_splits(X_train, Y_train)
parameters = {'n_estimators' : np.r_[10:210:10],
'max_depth': np.r_[1:6]
}
grid = model_selection.GridSearchCV(cl... | Titanic - Machine Learning from Disaster |
6,135,017 | %%time
!cp.. /input/rapids/rapids.0.11.0 /opt/conda/envs/rapids.tar.gz
!cd /opt/conda/envs/ && tar -xzvf rapids.tar.gz
sys.path = ["/opt/conda/envs/rapids/lib"] + ["/opt/conda/envs/rapids/lib/python3.6"] + ["/opt/conda/envs/rapids/lib/python3.6/site-packages"] + sys.path
!cp /opt/conda/envs/rapids/lib/libxgboost.so /op... | p = a[a.param_max_depth==4].sort_values(by='mean_test_score', ascending=False ).iloc[0]
print("Best mean test score: %f using %s" %(p.mean_test_score, p.params))
bst_ET = grid.best_estimator_
bst_ET.set_params(**p.params)
bst_ET.fit(X_train,Y_train)
pred_ET = bst_ET.predict(X_test)
test['Survived'] = pred_ET.astype(... | Titanic - Machine Learning from Disaster |
5,787,184 | from cuml.linear_model import Ridge
<load_from_csv> | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
5,787,184 | train = cudf.read_csv('.. /input/multi-cat-encodings/X_train_te.csv')
test = cudf.read_csv('.. /input/multi-cat-encodings/X_test_te.csv')
sample_submission = cudf.read_csv('.. /input/cat-in-the-dat-ii/sample_submission.csv' )<define_variables> | sns.set_style('whitegrid' ) | Titanic - Machine Learning from Disaster |
5,787,184 | train_oof = cp.zeros(( train.shape[0],))
test_preds = 0
train_oof.shape<compute_train_metric> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
5,787,184 | def auc_cp(y_true,y_pred):
y_true = y_true.astype('float32')
ids = np.argsort(-y_pred)
y_true = y_true[ids.values]
y_pred = y_pred[ids.values]
zero = 1 - y_true
acc_one = cp.cumsum(y_true)
acc_zero = cp.cumsum(zero)
sum_one = cp.sum(y_true)
sum_zero = cp.sum(zero)
tpr = acc_one/sum_one
fpr = acc_zero/sum_zero
ret... | train_data['Embarked'] = train_data['Embarked'].fillna('S')
test_data['Embarked'] = test_data['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
5,787,184 | %%time
n_splits = 5
kf = KFold(n_splits=n_splits, random_state=137)
scores = []
for jj,(train_index, val_index)in enumerate(kf.split(train)) :
print("Fitting fold", jj+1)
train_features = train.loc[train['fold_column'] != jj][features]
train_target = train.loc[train['fold_column'] != jj]['target'].values.astype(float... | def fix_age(blob):
Age = blob[0]
Pclass = blob[1]
Sex = blob[2]
if pd.isnull(Age):
if Sex == 'male':
if Pclass == 1:
return 40
elif Pclass == 2:
return 30
else:
return 25
else:
if Pclass == 1:
return 35
elif Pclass == 2:
return 27
else:
return 22
else:
return Age | Titanic - Machine Learning from Disaster |
5,787,184 | sample_submission['target'] = test_preds
sample_submission.to_csv('submission.csv', index=False )<save_model> | train_data['Age'] = train_data[['Age','Pclass','Sex']].apply(fix_age,axis=1)
test_data['Age'] = test_data[['Age','Pclass','Sex']].apply(fix_age,axis=1 ) | Titanic - Machine Learning from Disaster |
5,787,184 | cp.save('test_preds', test_preds)
cp.save('train_oof', train_oof )<import_modules> | train_data["Fare"] = train_data["Fare"].fillna(train_data["Fare"].median())
test_data["Fare"] = test_data["Fare"].fillna(test_data["Fare"].median() ) | Titanic - Machine Learning from Disaster |
5,787,184 | import scipy
import pandas as pd
from sklearn.linear_model import LogisticRegression<load_from_csv> | train_data['Sex'] = train_data['Sex'].fillna('male')
test_data['Sex'] = test_data['Sex'].fillna('male' ) | Titanic - Machine Learning from Disaster |
5,787,184 | D0 = pd.read_csv("/kaggle/input/cat-in-the-dat-ii/train.csv", index_col="id")
D_test = pd.read_csv("/kaggle/input/cat-in-the-dat-ii/test.csv", index_col="id")
y_train = D0["target"]
D = D0.drop(columns="target")
test_ids = D_test.index
D_all = pd.concat([D, D_test])
num_train = len(D)
print(f"D_all.shape = {D_all.... | def add_family(blob):
temp = blob.split(' ')[0]
temp = temp[:len(temp)-1]
return temp | Titanic - Machine Learning from Disaster |
5,787,184 | ord_maps = {
"ord_0": {val: i for i, val in enumerate([1, 2, 3])},
"ord_1": {
val: i
for i, val in enumerate(
["Novice", "Contributor", "Expert", "Master", "Grandmaster"]
)
},
"ord_2": {
val: i
for i, val in enumerate(
["Freezing", "Cold", "Warm", "Hot", "Boiling Hot", "Lava Hot"]
)
},
**{col: {val: i for i, val ... | train_data['FamilyName'] = train_data['Name'].apply(add_family ) | Titanic - Machine Learning from Disaster |
5,787,184 | oh_cols = D_all.columns.difference(ord_maps.keys() - {"day", "month"})
print(f"OneHot encoding {len(oh_cols)} columns")
one_hot = pd.get_dummies(
D_all[oh_cols],
columns=oh_cols,
drop_first=True,
dummy_na=True,
sparse=True,
dtype="int8",
).sparse.to_coo()<categorify> | test_data['FamilyName'] = test_data['Name'].apply(add_family ) | Titanic - Machine Learning from Disaster |
5,787,184 | ord_cols = pd.concat([D_all[col].map(ord_map ).fillna(max(ord_map.values())//2 ).astype("float32")for col, ord_map in ord_maps.items() ], axis=1)
ord_cols /= ord_cols.max()
ord_cols_sqr = 4*(ord_cols - 0.5)**2<concatenate> | train_data['FamilyName'].value_counts() | Titanic - Machine Learning from Disaster |
5,787,184 | X = scipy.sparse.hstack([one_hot, ord_cols, ord_cols_sqr] ).tocsr()
print(f"X.shape = {X.shape}")
X_train = X[:num_train]
X_test = X[num_train:]<save_to_csv> | def apply_name_suffix(blob):
temp = blob.split(' ')[1]
return temp | Titanic - Machine Learning from Disaster |
5,787,184 | clf=LogisticRegression(C=0.05, solver="lbfgs", max_iter=5000)
clf.fit(X_train, y_train)
pred = clf.predict_proba(X_test)[:, 1]
pd.DataFrame({"id": test_ids, "target": pred} ).to_csv("submission.csv", index=False )<install_modules> | train_data['NameSuffix'] = train_data['Name'].apply(apply_name_suffix ) | Titanic - Machine Learning from Disaster |
5,787,184 | !pip install --no-warn-conflicts -q deepctr<import_modules> | test_data['NameSuffix'] = test_data['Name'].apply(apply_name_suffix ) | Titanic - Machine Learning from Disaster |
5,787,184 | warnings.simplefilter('ignore' )<load_from_csv> | def fix_name_suffix(blob):
temp = ['Mr.','Miss.','Mrs.','Master.','Dr.','Rev.']
if blob in temp:
return blob[0:len(blob)-1]
else:
return 'no_suffix' | Titanic - Machine Learning from Disaster |
5,787,184 | train = pd.read_csv('.. /input/cat-in-the-dat-ii/train.csv')
test = pd.read_csv('.. /input/cat-in-the-dat-ii/test.csv' )<feature_engineering> | train_data['NameSuffix'] = train_data['NameSuffix'].apply(fix_name_suffix)
test_data['NameSuffix'] = test_data['NameSuffix'].apply(fix_name_suffix ) | Titanic - Machine Learning from Disaster |
5,787,184 | test['target'] = -1<concatenate> | del train_data['Name']
del test_data['Name'] | Titanic - Machine Learning from Disaster |
5,787,184 | data = pd.concat([train, test] ).reset_index(drop=True )<feature_engineering> | train_data.Ticket = [i[0] for i in train_data.Ticket.astype("str")]
test_data.Ticket = [i[0] for i in test_data.Ticket.astype("str")] | Titanic - Machine Learning from Disaster |
5,787,184 | data['null'] = data.isna().sum(axis=1 )<feature_engineering> | train_data['Ticket'] = train_data['Ticket'].apply(lambda x: x if x in ['S','P','C','A','W','F','L'] else 'G' ) | Titanic - Machine Learning from Disaster |
5,787,184 | sparse_features = [feat for feat in train.columns if feat not in ['id','target']]
data[sparse_features] = data[sparse_features].fillna('-1', )<categorify> | test_data['Ticket'] = test_data['Ticket'].apply(lambda x: x if x in ['S','P','C','A','W','F','L'] else 'G' ) | Titanic - Machine Learning from Disaster |
5,787,184 | for feat in sparse_features:
lbe = LabelEncoder()
data[feat] = lbe.fit_transform(data[feat].fillna('-1' ).astype(str ).values )<prepare_x_and_y> | train_data.Cabin = [i[0] for i in train_data.Cabin.astype("str")]
test_data.Cabin = [i[0] for i in test_data.Cabin.astype("str")] | Titanic - Machine Learning from Disaster |
5,787,184 | train = data[data.target != -1].reset_index(drop=True)
test = data[data.target == -1].reset_index(drop=True )<count_unique_values> | def most_common(lst):
return max(set(lst), key=lst.count)
def fix_cabin(blob):
temp = blob.tolist()
temp1 = []
for i in temp :
if i == 'n':
continue
else:
temp1.append(i)
if temp1 == [] :
return 'Z'
else:
temp1 = most_common(temp1)
return temp1 | Titanic - Machine Learning from Disaster |
5,787,184 | fixlen_feature_columns = [SparseFeat(feat, data[feat].nunique())for feat in sparse_features]
dnn_feature_columns = fixlen_feature_columns
linear_feature_columns = fixlen_feature_columns
feature_names = get_feature_names(linear_feature_columns + dnn_feature_columns )<compute_test_metric> | train_data['Cabin'] = train_data['Cabin'].groupby(train_data['FamilyName'] ).transform(fix_cabin)
test_data['Cabin'] = test_data['Cabin'].groupby(test_data['FamilyName'] ).transform(fix_cabin ) | Titanic - Machine Learning from Disaster |
5,787,184 | def auc(y_true, y_pred):
def fallback_auc(y_true, y_pred):
try:
return roc_auc_score(y_true, y_pred)
except:
return 0.5
return tf.py_function(fallback_auc,(y_true, y_pred), tf.double )<compute_train_metric> | del train_data['PassengerId'] | Titanic - Machine Learning from Disaster |
5,787,184 | def focal_loss(gamma=2., alpha=.25):
def focal_loss_fixed(y_true, y_pred):
pt_1 = tf.where(tf.equal(y_true, 1), y_pred, tf.ones_like(y_pred))
pt_0 = tf.where(tf.equal(y_true, 0), y_pred, tf.zeros_like(y_pred))
return -K.mean(alpha * K.pow(1.- pt_1, gamma)* K.log(K.epsilon() +pt_1)) -K.mean(( 1-alpha)* K.pow(pt_0, gamma... | from sklearn.pipeline import Pipeline , FeatureUnion
from sklearn.preprocessing import FunctionTransformer
from sklearn.feature_extraction import DictVectorizer | Titanic - Machine Learning from Disaster |
5,787,184 | def custom_gelu(x):
return 0.5 * x *(1 + tf.tanh(tf.sqrt(2 / np.pi)*(x + 0.044715 * tf.pow(x, 3))))
get_custom_objects().update({'custom_gelu': Activation(custom_gelu)} )<choose_model_class> | list_of_obj = []
list_of_num = []
for i in train_data.columns :
if train_data[i].dtypes == 'object':
list_of_obj.append(i)
else:
if i == 'Survived':
continue
else:
list_of_num.append(i ) | Titanic - Machine Learning from Disaster |
5,787,184 | class WarmUpLearningRateScheduler(tf.keras.callbacks.Callback):
def __init__(self, warmup_batches, init_lr, verbose=0):
super(WarmUpLearningRateScheduler, self ).__init__()
self.warmup_batches = warmup_batches
self.init_lr = init_lr
self.verbose = verbose
self.batch_count = 0
self.learning_rates = []
def on_batch_e... | def return_text(df):
return df[list_of_obj] | Titanic - Machine Learning from Disaster |
5,787,184 | class CyclicLR(keras.callbacks.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 scal... | get_text = FunctionTransformer(func=return_text,validate=False ) | Titanic - Machine Learning from Disaster |
5,787,184 | target = ['target']
N_Splits = 50
Verbose = 0
Epochs = 10
SEED = 2020
Batch_S_T = 128
Batch_S_P = 512<prepare_x_and_y> | def return_num(df):
return df[list_of_num] | Titanic - Machine Learning from Disaster |
5,787,184 | oof_pred_deepfm = np.zeros(( len(train),))
y_pred_deepfm = np.zeros(( len(test),))
skf = StratifiedKFold(n_splits=N_Splits, shuffle=True, random_state=SEED)
for fold,(tr_ind, val_ind)in enumerate(skf.split(train, train[target])) :
X_train, X_val = train[sparse_features].iloc[tr_ind], train[sparse_features].iloc[val_in... | get_numerical = FunctionTransformer(func=return_num,validate=False ) | Titanic - Machine Learning from Disaster |
5,787,184 | print(f'OOF AUC : {round(roc_auc_score(train.target.values, oof_pred_deepfm), 5)}' )<save_to_csv> | num_pipeline = Pipeline([
('numerical',get_numerical),
] ) | Titanic - Machine Learning from Disaster |
5,787,184 | test_idx = test.id.values
submission = pd.DataFrame.from_dict({
'id': test_idx,
'target': y_pred_deepfm
})
submission.to_csv('submission.csv', index=False)
print('Submission file saved!' )<save_model> | def return_dict(blob):
return blob.to_dict("records" ) | Titanic - Machine Learning from Disaster |
5,787,184 | np.save('oof_pred_deepfm.npy',oof_pred_deepfm)
np.save('y_pred_deepfm.npy', y_pred_deepfm )<set_options> | text_pipeline = Pipeline([
('textual',get_text),
('dictifier',FunctionTransformer(func=return_dict,validate=False)) ,
('vectorizer',DictVectorizer(sort=False)) ,
] ) | Titanic - Machine Learning from Disaster |
5,787,184 | print(h2o.__version__)
h2o.init(max_mem_size='16G' )<load_from_csv> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
5,787,184 | %%time
train = h2o.import_file(".. /input/multi-cat-encodings/X_train_te.csv")
test = h2o.import_file(".. /input/multi-cat-encodings/X_test_te.csv" )<feature_engineering> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
5,787,184 | x = test.columns
y = 'target'
train[y] = train[y].asfactor()<train_model> | X_train, X_test, y_train, y_test = train_test_split(
...train_data.drop(['Survived'],axis=1), train_data['Survived'], test_size=0.2, random_state=42 ) | Titanic - Machine Learning from Disaster |
5,787,184 | aml = H2OAutoML(max_models=50, seed=47, max_runtime_secs=30000)
aml.train(x=x, y=y, training_frame=train, fold_column='fold_column' )<find_best_params> | from sklearn.metrics import confusion_matrix , classification_report, roc_auc_score | Titanic - Machine Learning from Disaster |
5,787,184 | aml.leader<predict_on_test> | import xgboost as xgb | Titanic - Machine Learning from Disaster |
5,787,184 | preds = aml.predict(test)
preds['p1'].as_data_frame().values.flatten().shape<load_from_csv> | xgb_model = xgb.XGBClassifier(silent=False,
scale_pos_weight=1,
learning_rate=0.01,
colsample_bytree = 0.4,
subsample = 0.8,
objective='binary:logistic',
n_estimators=500,
reg_alpha = 0.3,
gamma=10,
eval_metric = 'auc' ) | Titanic - Machine Learning from Disaster |
5,787,184 | sample_submission = pd.read_csv('.. /input/cat-in-the-dat-ii/sample_submission.csv')
sample_submission.shape<save_to_csv> | pipeline = Pipeline([
('union',FeatureUnion(
transformer_list = [
('num',num_pipeline),
('text',text_pipeline)
])) ,
('clf',xgb_model)
] ) | Titanic - Machine Learning from Disaster |
5,787,184 | sample_submission['target'] = preds['p1'].as_data_frame().values
sample_submission.to_csv('h2o_automl_submission_4.csv', index=False )<load_from_csv> | pipeline.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
5,787,184 | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
test = pd.read_csv('/kaggle/input/cat-in-the-dat-ii/test.csv')
train = pd.read_csv('/kaggle/input/cat-in-the-dat-ii/train.csv' )<categorify> | preds_xgb = pipeline.predict(X_test ) | Titanic - Machine Learning from Disaster |
5,787,184 | %%time
def random_permutation(x):
perm = np.random.permutation(len(x))
x = x.iloc[perm].reset_index(drop=True)
return x
train = random_permutation(train)
test = random_permutation(test)
train_ids = train.id
test_ids = test.id
train.drop('id', 1, inplace=True)
test.drop('id', 1, inplace=True)
train_targets = train.... | print(confusion_matrix(y_test,preds_xgb))
print(roc_auc_score(y_test,preds_xgb))
print(classification_report(y_test,preds_xgb)) | Titanic - Machine Learning from Disaster |
5,787,184 | %%time
bin_recode = {0: 0, 1: 1, 'F':0, 'T':1, 'N':0, 'Y':1}
for i in range(5):
train[f'bin_{i}'] = train[f'bin_{i}'].map(bin_recode)
test[f'bin_{i}'] = test[f'bin_{i}'].map(bin_recode)
levels = { 'Novice':0, 'Contributor':1,
'Expert':2, 'Master':3, 'Grandmaster':4 }
train['ord_1'] = train['ord_1'].map(levels)
test[... | from sklearn.model_selection import RandomizedSearchCV | Titanic - Machine Learning from Disaster |
5,787,184 | %%time
noms_0_4 = ['nom_0', 'nom_1', 'nom_2', 'nom_3', 'nom_4']
train = pd.get_dummies(train,
columns = noms_0_4,
prefix = noms_0_4,
drop_first=True,
sparse=True,
dtype=np.int8)
test = pd.get_dummies(test,
columns = noms_0_4,
prefix = noms_0_4,
drop_first=True,
sparse=True,
dtype=np.int8 )<categorify> | params = {
"clf__learning_rate" : list(np.arange(0.05,0.6,0.05)) ,
"clf__max_depth" : list(np.arange(1,20,2)) ,
"clf__min_child_weight" : list(np.arange(1,9,1)) ,
"clf__gamma" : list(np.arange(1,20,1)) ,
"clf__colsample_bytree" : [ 0.3, 0.4, 0.5 , 0.7 ],
"clf__subsample" : list(np.arange(0.1,0.9,0.1)) ,
"clf__n_estimat... | Titanic - Machine Learning from Disaster |
5,787,184 | %%time
for i in [5,6,7,8,9]:
cbe = CatBoostEncoder()
train[f'nom_{i}'] = cbe.fit_transform(train[f'nom_{i}'], train_targets)
test[f'nom_{i}'] = cbe.transform(test[f'nom_{i}'])
cbe = CatBoostEncoder()
train['ord_5'] = cbe.fit_transform(train['ord_5'], train_targets)
test['ord_5'] = cbe.transform(test['ord_5'] )<train... | grid = RandomizedSearchCV(pipeline,
param_distributions=params,
scoring='roc_auc',cv=5,verbose=5 ) | Titanic - Machine Learning from Disaster |
5,787,184 | %%time
cb = CatBoostClassifier(eval_metric='AUC',
learning_rate=0.1,
depth=3,
l2_leaf_reg=5)
cb.fit(train, train_targets, verbose=False )<save_to_csv> | grid.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
5,787,184 | preds = cb.predict_proba(test)[:, 1]
preds_df = pd.DataFrame(list(zip(test_ids, preds)) ,
columns = ['id', 'target'])
preds_df.sort_values(by=['id'], inplace = True)
preds_df.to_csv("./submission.csv", index=False )<load_from_csv> | grid.best_params_, grid.best_score_ | Titanic - Machine Learning from Disaster |
5,787,184 | train = pd.read_csv('.. /input/cat-in-the-dat-ii/train.csv')
test = pd.read_csv('.. /input/cat-in-the-dat-ii/test.csv')
train.sort_index(inplace=True)
train_y = train['target']; test_id = test['id']
train.drop(['target', 'id'], axis=1, inplace=True); test.drop('id', axis=1, inplace=True)
cat_feat_to_encode = train.... | best_matrix = {'subsample': 0.30000000000000004,
'reg_alpha': 0.2,
'n_estimators': 500,
'min_child_weight': 3,
'max_depth': 9,
'learning_rate': 0.15000000000000002,
'gamma': 4,
'colsample_bytree': 0.3} | Titanic - Machine Learning from Disaster |
5,787,184 | glm = linear_model.LogisticRegression(random_state=1, solver='lbfgs', max_iter=2020, fit_intercept=True, penalty='none', verbose=0); glm.fit(train, train_y )<import_modules> | xgb_model = xgb.XGBClassifier(**best_matrix,silent=False,
eval_metric = 'auc' ) | Titanic - Machine Learning from Disaster |
5,787,184 | from sklearn.linear_model import ElasticNet, Lasso, BayesianRidge, LassoLarsIC, LogisticRegression
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.kernel_ridge import KernelRidge
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import RobustScaler
from skl... | finalized_model = pipeline = Pipeline([
('union',FeatureUnion(
transformer_list = [
('num',num_pipeline),
('text',text_pipeline)
])) ,
('clf',xgb_model)
] ) | Titanic - Machine Learning from Disaster |
5,787,184 | n_folds = 5
def auc_score(model):
kf = KFold(n_folds, shuffle= True ).get_n_splits(train.values)
auc_score = cross_val_score(model, train.values, train_y, scoring = "roc_auc", cv = kf)
return auc_score<choose_model_class> | X = train_data.drop(['Survived'],axis=1)
y = train_data['Survived'] | Titanic - Machine Learning from Disaster |
5,787,184 | lasso = make_pipeline(RobustScaler() , Lasso(alpha =0.0005, random_state=1))<choose_model_class> | finalized_model.fit(X,y ) | Titanic - Machine Learning from Disaster |
5,787,184 | ENet = make_pipeline(RobustScaler() , ElasticNet(alpha=0.0005, l1_ratio=.9, random_state=3))
<choose_model_class> | final_test = test_data.drop(['PassengerId'],axis=1 ) | Titanic - Machine Learning from Disaster |
5,787,184 | KRR = KernelRidge(alpha=0.6, kernel='polynomial', degree=2, coef0=2.5 )<choose_model_class> | PassengerId = test_data['PassengerId'] | Titanic - Machine Learning from Disaster |
5,787,184 | GBoost = GradientBoostingRegressor(n_estimators=3000, learning_rate=0.05,
max_depth=4, max_features='sqrt',
min_samples_leaf=15, min_samples_split=10,
loss='huber', random_state =5 )<choose_model_class> | final_prediction = finalized_model.predict(final_test ) | Titanic - Machine Learning from Disaster |
5,787,184 | <choose_model_class><EOS> | submission = pd.DataFrame({ 'PassengerId': PassengerId,
'Survived': final_prediction })
submission.to_csv(path_or_buf ="Titanic_Submission.csv", index=False ) | Titanic - Machine Learning from Disaster |
4,215,533 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<compute_test_metric> | import pandas as pd
import numpy as np | Titanic - Machine Learning from Disaster |
4,215,533 | score = auc_score(lasso)
print("
Lasso score: {:.4f}({:.4f})
".format(score.mean() , score.std()))
score = auc_score(ENet)
print("ElasticNet score: {:.4f}({:.4f})
".format(score.mean() , score.std()))
score = auc_score(model_lgb)
print("LGBM score: {:.4f}({:.4f})
".format(score.mean() , score.std()))
score = auc_... | train=pd.read_csv(".. /input/train.csv")
test=pd.read_csv(".. /input/test.csv" ) | Titanic - Machine Learning from Disaster |
4,215,533 | class average_stacking(BaseEstimator, RegressorMixin, TransformerMixin):
def __init__(self,models):
self.models = models
def fit(self, x,y):
self.model_clones = [clone(x)for x in self.models]
for model in self.model_clones:
model.fit(x,y)
return self
def predict(self, x):
preds = np.column_stack([
model.predict(x)for ... | train.drop(['Name'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
4,215,533 | averaged_models = average_stacking(models =(ENet, glm,model_lgb, lasso))
score = auc_score(averaged_models)
print(" Averaged base models score: {:.4f}({:.4f})
".format(score.mean() , score.std()))<predict_on_test> | sample_sub=pd.read_csv(".. /input/gender_submission.csv" ) | Titanic - Machine Learning from Disaster |
4,215,533 | averaged_models.fit(train.values, train_y)
avg_pred = averaged_models.predict(test )<save_to_csv> | test.drop(['Name'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
4,215,533 | pd.DataFrame({'id': test_id, 'target': avg_pred} ).to_csv('submission.csv', index=False )<set_options> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
4,215,533 | %matplotlib inline
<load_from_csv> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
4,215,533 | def read_data(file_path):
print('Loading datasets...')
train = pd.read_csv(file_path + 'train.csv', sep=',')
test = pd.read_csv(file_path + 'test.csv', sep=',')
print('Datasets loaded')
return train, test<split> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,215,533 | PATH = '.. /input/cat-in-the-dat-ii/'
train, test = read_data(PATH )<count_unique_values> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,215,533 | def zoom_dataset(data):
Count_missing_val = data.isnull().sum()
Percent_missing =(data.isnull().sum() /data.isnull().count() *100)
Percent_no_missing = 100 - Percent_missing
Count_unique = data.nunique()
Percent_unique_val = Count_unique / len(data)*100
Type = data.dtypes
data=[[i, Counter(data[i][data[i].notna() ] ).... | train.drop(['Cabin'],axis=1,inplace=True)
test.drop(['Cabin'],axis=1,inplace=True)
test.drop(['Ticket'],axis=1,inplace=True)
train.drop(['Ticket'],axis=1,inplace=True)
train.drop(['PassengerId'],axis=1,inplace=True)
test.drop(['PassengerId'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
4,215,533 | def encoding(train, test, smooth):
print('Target encoding...')
train.sort_index(inplace=True)
target = train['target']
test_id = test['id']
train.drop(['target', 'id'], axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
cat_feat_to_encode = train.columns.tolist()
smoothing=smooth
oof = pd.DataFrame([])
fo... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
4,215,533 | def timer(start_time=None):
if not start_time:
start_time = datetime.now()
return start_time
elif start_time:
thour, temp_sec = divmod(( datetime.now() - start_time ).total_seconds() , 3600)
tmin, tsec = divmod(temp_sec, 60)
print('Time taken : %i hours %i minutes and %s seconds.' %(thour, tmin, round(tsec, 2)) )<tra... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
4,215,533 | def run_model(splits, features, target, train):
model = lgb.LGBMClassifier(**{
'learning_rate': 0.05,
'feature_fraction': 0.1,
'min_data_in_leaf' : 12,
'max_depth': 3,
'reg_alpha': 1,
'reg_lambda': 1,
'objective': 'binary',
'metric': 'auc',
'n_jobs': -1,
'n_estimators' : 5000,
'feature_fraction_seed': 42,
'bagging_seed... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,215,533 | train, test, test_id, features, target = encoding(train, test, 0.3)
model, cms, tprs, aucs, y_real, y_proba, mean_fpr, mean_tpr, df_ml = run_model(5, features, target, train)
graph_metrics(cms, tprs, aucs, y_real, y_proba, mean_fpr, mean_tpr )<save_to_csv> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,215,533 | pd.DataFrame({'id': test_id, 'target': model.predict_proba(test)[:,1]} ).to_csv('submission.csv', index=False )<import_modules> | train['Age'].fillna(( train['Age'].mean()), inplace=True ) | Titanic - Machine Learning from Disaster |
4,215,533 | import numpy as np
import pandas as pd
from time import time
import pprint
import joblib
from catboost import CatBoostClassifier, Pool
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import roc_auc_score, average_precision_score
from sklearn.metrics import make_scorer<choose_model_class> | test['Age'].fillna(( test['Age'].mean()), inplace=True ) | Titanic - Machine Learning from Disaster |
4,215,533 | SEED = 42
FOLDS = 10
skf = StratifiedKFold(n_splits=FOLDS, shuffle=True, random_state=SEED )<load_from_csv> | test['Fare'].fillna(( test['Fare'].mean()), inplace=True ) | Titanic - Machine Learning from Disaster |
4,215,533 | X = pd.read_csv("/kaggle/input/cat-in-the-dat-ii/train.csv")
Xt = pd.read_csv("/kaggle/input/cat-in-the-dat-ii/test.csv")
y = X.target.values
id_train = X.id
id_test = Xt.id
X.drop(['id', 'target'], axis=1, inplace=True)
Xt.drop(['id'], axis=1, inplace=True)
binary_vars = [c for c in X.columns if 'bin_' in c]
nomin... | train.dropna() | Titanic - Machine Learning from Disaster |
4,215,533 | X['ord_5_1'] = X['ord_5'].apply(lambda x: x[0] if type(x)== str else np.nan)
X['ord_5_2'] = X['ord_5'].apply(lambda x: x[1] if type(x)== str else np.nan)
Xt['ord_5_1'] = Xt['ord_5'].apply(lambda x: x[0] if type(x)== str else np.nan)
Xt['ord_5_2'] = Xt['ord_5'].apply(lambda x: x[1] if type(x)== str else np.nan)
ordi... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,215,533 | ordinals = {
'ord_1' : {
'Novice' : 0,
'Contributor' : 1,
'Expert' : 2,
'Master' : 3,
'Grandmaster' : 4
},
'ord_2' : {
'Freezing' : 0,
'Cold' : 1,
'Warm' : 2,
'Hot' : 3,
'Boiling Hot' : 4,
'Lava Hot' : 5
}
}
def return_order(X, Xt, var_name):
mode = X[var_name].mode() [0]
el = sorted(set(X[var_name].fillna(mode ).uniqu... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,215,533 | label_encoders = [LabelEncoder() for _ in range(X.shape[1])]
for col, column in enumerate(X.columns):
unique_values = pd.Series(X[column].append(Xt[column] ).unique())
unique_values = unique_values[unique_values.notnull() ]
label_encoders[col].fit(unique_values)
X.loc[X[column].notnull() , column] = label_encoders[co... | Pclass=pd.get_dummies(train['Pclass'],drop_first=True)
Pclass1=pd.get_dummies(test['Pclass'],drop_first=True)
Sex=pd.get_dummies(train['Sex'],drop_first=True)
Sex1=pd.get_dummies(test['Sex'],drop_first=True)
Embarked=pd.get_dummies(train['Embarked'],drop_first=True)
Embarked1=pd.get_dummies(test['Embarked'],drop_f... | Titanic - Machine Learning from Disaster |
4,215,533 | X = X.fillna(-1)
Xt = Xt.fillna(-1 )<categorify> | train=pd.concat([train,Pclass,Sex,Embarked],axis=1)
test=pd.concat([test,Pclass1,Sex1,Embarked1],axis=1 ) | Titanic - Machine Learning from Disaster |
4,215,533 | def frequency_encoding(column, df, df_test=None):
frequencies = df[column].value_counts().reset_index()
df_values = df[[column]].merge(frequencies, how='left',
left_on=column, right_on='index' ).iloc[:,-1].values
if df_test is not None:
df_test_values = df_test[[column]].merge(frequencies, how='left',
left_on=column, r... | train.drop(['Sex','Embarked','Pclass'],axis=1,inplace=True)
test.drop(['Sex','Embarked','Pclass'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
4,215,533 | cat_feat_to_encode = binary_vars + ordinal_vars + nominal_vars + time_vars
smoothing = 0.3
enc_x = np.zeros(X[cat_feat_to_encode].shape)
for tr_idx, oof_idx in skf.split(X, y):
encoder = cat_encs.TargetEncoder(cols=cat_feat_to_encode, smoothing=smoothing)
encoder.fit(X[cat_feat_to_encode].iloc[tr_idx], y[tr_idx])
en... | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
4,215,533 | X = X.astype(np.float32)
Xt = Xt.astype(np.float32)
cat_features = nominal_vars + ordinal_vars
X[cat_features] = X[cat_features].astype(np.int64)
Xt[cat_features] = Xt[cat_features].astype(np.int64 )<choose_model_class> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
4,215,533 | best_params = {'bagging_temperature': 0.8,
'depth': 5,
'iterations': 1000,
'l2_leaf_reg': 30,
'learning_rate': 0.05,
'random_strength': 0.8}<split> | y=train['Survived'] | Titanic - Machine Learning from Disaster |
4,215,533 | roc_auc = list()
average_precision = list()
oof = np.zeros(len(X))
cv_test_preds = np.zeros(len(Xt))
best_iteration = list()
for train_idx, test_idx in skf.split(X, y):
X_train, y_train = X.iloc[train_idx, :], y[train_idx]
X_test, y_test = X.iloc[test_idx, :], y[test_idx]
train = Pool(data=X_train,
label=y_train,
featu... | X=train.drop('Survived',axis=1 ) | Titanic - Machine Learning from Disaster |
4,215,533 | oof = pd.DataFrame({'id':id_train, 'catboost_oof': oof})
oof.to_csv("oof.csv", index=False)
cv_submission = pd.read_csv("/kaggle/input/cat-in-the-dat-ii/sample_submission.csv")
cv_submission.target = cv_test_preds
cv_submission.to_csv("./catboost_cv_submission.csv", index=False )<compute_test_metric> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=2 ) | Titanic - Machine Learning from Disaster |
4,215,533 | print("Average cv roc auc score %0.3f ± %0.3f" %(np.mean(roc_auc), np.std(roc_auc)))
print("Average cv roc average precision %0.3f ± %0.3f" %(np.mean(average_precision), np.std(average_precision)))
print("Roc auc score OOF %0.3f" % roc_auc_score(y_true=y, y_score=oof.catboost_oof))
print("Average precision OOF %0.3f"... | logmodel = LogisticRegression()
logmodel.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
4,215,533 | catb = CatBoostClassifier(**best_params,
loss_function='Logloss',
eval_metric = 'AUC',
nan_mode='Min',
thread_count=2,
verbose = False)
train = Pool(data=X,
label=y,
feature_names=list(X_train.columns),
cat_features=cat_features)
catb.fit(train,
verbose_eval=100,
plot=False)
Xt_pool = Pool(data=Xt[list(X_train.colum... | predictions = logmodel.predict(X_test ) | Titanic - Machine Learning from Disaster |
4,215,533 | import numpy as np
import pandas as pd
from time import time
import pprint
import joblib
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import roc_auc_score, average_precision_score
from sklearn.metrics import make_scorer
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessin... | from sklearn.metrics import classification_report | Titanic - Machine Learning from Disaster |
4,215,533 | import tensorflow as tf
from keras import backend as K
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam, Nadam
from keras.layers import Input, Embedding, Reshape, GlobalAveragePooling1D
from keras.layers import Flatten, concatenate, Concatenate, Lambda, Dropout, Spati... | classification_report(y_test,predictions ) | Titanic - Machine Learning from Disaster |
4,215,533 | X = pd.read_csv("/kaggle/input/cat-in-the-dat-ii/train.csv")
Xt = pd.read_csv("/kaggle/input/cat-in-the-dat-ii/test.csv" )<prepare_x_and_y> | from sklearn.metrics import confusion_matrix | Titanic - Machine Learning from Disaster |
4,215,533 | y = X.target.values
id_train = X.id
id_test = Xt.id
X.drop(['id', 'target'], axis=1, inplace=True)
Xt.drop(['id'], axis=1, inplace=True )<define_variables> | confusion_matrix(y_test,predictions ) | 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.