kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
4,667,493 | m = CatBoostRegressor(random_state=0, verbose=1000, n_estimators=10000)
m.fit(X, y)
m.score(X, y )<drop_column> | import scipy
import scipy.stats as ss
from scipy.stats import pearsonr
from scipy import stats
| Titanic - Machine Learning from Disaster |
4,667,493 | m.save_model('hp_cb',
format="cbm",
export_parameters=None,
pool=None )<train_model> | def cramers_v(confusion_matrix):
chi2 = ss.chi2_contingency(confusion_matrix)[0]
n = confusion_matrix.sum()
phi2 = chi2 / n
r, k = confusion_matrix.shape
phi2corr = max(0, phi2 -(( k-1)*(r-1)) /(n-1))
rcorr = r -(( r-1)**2)/(n-1)
kcorr = k -(( k-1)**2)/(n-1)
return np.sqrt(phi2corr / min(( kcorr-1),(rcorr-1)) ) | Titanic - Machine Learning from Disaster |
4,667,493 | m = RandomForestRegressor(n_jobs=-1, n_estimators=60, random_state=0)
m.fit(X, y)
m.score(X, y )<train_model> | confusion_matrix = pd.crosstab(train["Survived"], train["Sex"] ).as_matrix()
cramers_v(confusion_matrix ) | Titanic - Machine Learning from Disaster |
4,667,493 | et = ExtraTreesRegressor(n_jobs=-1, n_estimators=500, random_state=0, max_features=0.5)
et.fit(X, y)
et.score(X, y )<train_model> | scipy.stats.spearmanr(train["Survived"], train["Sex"] ) | Titanic - Machine Learning from Disaster |
4,667,493 | m = ExtraTreesRegressor(n_jobs=-1, n_estimators=500, random_state=0, max_features=0.5)
m.fit(X, y)
m.score(X, y )<import_modules> | confusion_matrix = pd.crosstab(train["Survived"], train["Pclass"] ).as_matrix()
cramers_v(confusion_matrix ) | Titanic - Machine Learning from Disaster |
4,667,493 | import shap
from catboost import Pool<set_options> | scipy.stats.spearmanr(train["Survived"], train["Pclass"] ) | Titanic - Machine Learning from Disaster |
4,667,493 | pd.set_option('display.max_rows', 100 )<compute_test_metric> | confusion_matrix = pd.crosstab(train["Survived"], train["block"] ).as_matrix()
cramers_v(confusion_matrix ) | Titanic - Machine Learning from Disaster |
4,667,493 | shap_values = m.get_feature_importance(Pool(X, y), type='ShapValues' )<compute_test_metric> | confusion_matrix = pd.crosstab(train["Survived"], train["Parch"] ).as_matrix()
cramers_v(confusion_matrix ) | Titanic - Machine Learning from Disaster |
4,667,493 | m.get_feature_importance(Pool(X, y), type='LossFunctionChange', prettified=True )<define_search_space> | scipy.stats.pointbiserialr(train["Survived"], train["Age"] ) | Titanic - Machine Learning from Disaster |
4,667,493 | max_features = ['sqrt', 'log2', 0.5, None]
min_samples_leaf = [1, 3, 5, 10, 25, 100]
random_grid = {'min_samples_leaf': min_samples_leaf,
'max_features': max_features}
print(random_grid )<choose_model_class> | scipy.stats.pointbiserialr(train["Survived"], train["Fare"] ) | Titanic - Machine Learning from Disaster |
4,667,493 | rf = RandomForestRegressor(n_estimators=100)
rf_random = RandomizedSearchCV(estimator = rf, param_distributions = random_grid,
n_iter = 20, cv = 5, verbose=2, random_state=10, n_jobs=-1 )<train_model> | cat_feats=['Sex','block','Titles','Pclass'] | Titanic - Machine Learning from Disaster |
4,667,493 | search = rf_random.fit(X, y)
print('Par:', search.best_params_)
print('Score:', search.best_score_ )<predict_on_test> | train_ = pd.get_dummies(train_,columns=cat_feats,drop_first=False ) | Titanic - Machine Learning from Disaster |
4,667,493 | y_pred_xgb = xgb.predict(X_test )<predict_on_test> | test['Age'] = test['Age'].mask(test['Age'].eq(0)).fillna(test['PassengerId'].map(df.set_index('PassengerId')['Age']))
test['Fare'] = test['Fare'].mask(test['Fare'].eq(0)).fillna(test['PassengerId'].map(df.set_index('PassengerId')['Fare']))
test=pd.merge(test,df[['PassengerId','CabinOccupancy','block','Titles']],how='le... | Titanic - Machine Learning from Disaster |
4,667,493 | y_pred_cb = m.predict(X_test )<prepare_output> | test_ = pd.get_dummies(test_,columns=cat_feats,drop_first=False ) | Titanic - Machine Learning from Disaster |
4,667,493 | y_pred = 9/10 * y_pred_cb + 1/10 * y_pred_et<prepare_output> | X_train = train_.drop('Survived',axis=1)
y_train = train_['Survived']
| Titanic - Machine Learning from Disaster |
4,667,493 | y_pred = y_pred_cb<predict_on_test> | X_test=test_ | Titanic - Machine Learning from Disaster |
4,667,493 | y_pred = rf_random.predict(X_test )<prepare_output> | X_train=X_train.drop(columns=['Titles_ the Countess','Titles_ Sir','Titles_ Mme',
'Titles_ Mlle','Titles_ Major','Titles_ Lady','Titles_ Jonkheer',
'Titles_ Don','Titles_ Capt'])
X_test=X_test.drop(columns=['Titles_ Dona'] ) | Titanic - Machine Learning from Disaster |
4,667,493 | y_first = np.expm1(y_pred )<prepare_output> | dtree = DecisionTreeClassifier()
dtree.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
4,667,493 | y_pred = np.expm1(y_first )<create_dataframe> | predictions_dtree = dtree.predict(X_test ) | Titanic - Machine Learning from Disaster |
4,667,493 | my_submission = pd.DataFrame({'Id': test.index, 'SalePrice': y_pred} )<save_to_csv> | y_test=gender_submission['Survived'].values | Titanic - Machine Learning from Disaster |
4,667,493 | my_submission.to_csv('submission.csv', index=False )<create_dataframe> | print(classification_report(y_test,predictions_dtree)) | Titanic - Machine Learning from Disaster |
4,667,493 | processed = X.copy()
processed['SalePrice'] = y<split> | print(confusion_matrix(y_test,predictions_dtree)) | Titanic - Machine Learning from Disaster |
4,667,493 | def split_vals(a,n): return a[:n].copy() , a[n:].copy()
n_valid = int(len(processed)*0.2)
n_trn = len(df)-n_valid
raw_train, raw_valid = split_vals(processed, n_trn)
X_train, X_valid = split_vals(X, n_trn)
y_train, y_valid = split_vals(y, n_trn)
X_train.shape, y_train.shape, X_valid.shape<compute_test_metric> | rfc = RandomForestClassifier(n_estimators=300)
rfc.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
4,667,493 | def print_score(m):
res = [rmse(m.predict(X_train), y_train), rmse(m.predict(X_valid), y_valid),
m.score(X_train, y_train), m.score(X_valid, y_valid)]
if hasattr(m, 'oob_score_'): res.append(m.oob_score_)
print(res )<compute_test_metric> | predictions_rfc = rfc.predict(X_test ) | Titanic - Machine Learning from Disaster |
4,667,493 | print_score(m )<train_model> | print(classification_report(y_test,predictions_rfc)) | Titanic - Machine Learning from Disaster |
4,667,493 | m = ExtraTreesRegressor(n_jobs=-1, bootstrap=True, oob_score=True)
%time m.fit(X_train, y_train)
print_score(m )<train_model> | print(confusion_matrix(y_test,predictions_rfc)) | Titanic - Machine Learning from Disaster |
4,667,493 | m = RandomForestRegressor(n_jobs=-1, oob_score=True)
%time m.fit(X_train, y_train)
print_score(m )<split> | test['Survived']=predictions_rfc
test.head() | Titanic - Machine Learning from Disaster |
4,667,493 | df_trn, y_trn, nas = proc_df(df, 'SalePrice')
X_train, _ = split_vals(df_trn, n_trn)
y_train, _ = split_vals(y_trn, n_trn)
X_train.shape, y_train.shape, X_valid.shape<choose_model_class> | predictions=test[['PassengerId','Survived']] | Titanic - Machine Learning from Disaster |
4,667,493 | <train_model><EOS> | predictions.to_csv('output.csv', index=False ) | Titanic - Machine Learning from Disaster |
1,882,473 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | warnings.filterwarnings('ignore')
%matplotlib inline | Titanic - Machine Learning from Disaster |
1,882,473 | m = ExtraTreesRegressor(n_jobs=-1, n_estimators=500, bootstrap=True, oob_score=True)
m.fit(X_train, y_train)
print_score(m )<predict_on_test> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
1,882,473 | preds = np.stack([t.predict(X_valid)for t in m.estimators_])
<import_modules> | passenger_id = test['PassengerId']
target = train['Survived'] | Titanic - Machine Learning from Disaster |
1,882,473 | from sklearn import *<compute_test_metric> | for df in [train,test]:
df.drop('PassengerId',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
1,882,473 | plt.plot([metrics.r2_score(y_valid, np.mean(preds[:i+1], axis=0)) for i in range(1000)]);<choose_model_class> | all_data = pd.concat([train.drop('Survived',axis=1),test] ).reset_index(drop=True ) | Titanic - Machine Learning from Disaster |
1,882,473 | ??RandomForestRegressor<train_model> | ntrain = train.shape[0]
ntest = test.shape[0] | Titanic - Machine Learning from Disaster |
1,882,473 | m = RandomForestRegressor(bootstrap=True, n_jobs=-1)
m.fit(X_train, y_train)
print_score(m )<set_options> | all_data['FamSize'] = 1 + all_data['SibSp'] + all_data['Parch']
all_data.drop(['SibSp','Parch'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
1,882,473 | set_rf_samples(50000 )<split> | total_miss = all_data.isnull().sum()
percent_miss =(total_miss/all_data.isnull().count() *100)
missing_data = pd.DataFrame({'Total missing':total_miss,'% missing':percent_miss})
missing_data.sort_values(by='Total missing',ascending=False ).head() | Titanic - Machine Learning from Disaster |
1,882,473 | def split_vals(a,n): return a[:n].copy() , a[n:].copy()
n_valid = int(len(processed)*0.2)
n_trn = len(df)-n_valid
raw_train, raw_valid = split_vals(processed, n_trn)
X_train, X_valid = split_vals(X, n_trn)
y_train, y_valid = split_vals(y, n_trn)
X_train.shape, y_train.shape, X_valid.shape<split> | all_data[all_data['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
1,882,473 | raw_train, raw_valid = split_vals(df, n_trn )<predict_on_test> | display(all_data[all_data['Fare'].isnull() ])
display(all_data[all_data['Fare']==0] ) | Titanic - Machine Learning from Disaster |
1,882,473 | def get_preds(t): return t.predict(X_valid)
%time preds = np.stack(parallel_trees(m, get_preds))
np.mean(preds[:,0]), np.std(preds[:,0] )<feature_engineering> | _ = all_data.set_value(1043,'Fare',value=0 ) | Titanic - Machine Learning from Disaster |
1,882,473 | x['pred_std'] = np.std(preds, axis=0)
x['pred'] = np.mean(preds, axis=0)
flds = ['Neighborhood', 'SalePrice', 'pred', 'pred_std']
nei_summ = x[flds].groupby('Neighborhood', as_index=False ).mean()
nei_summ.head()<train_model> | splits = 5 | Titanic - Machine Learning from Disaster |
1,882,473 | m = ExtraTreesRegressor(n_jobs=-1, n_estimators=100, bootstrap=True, oob_score=True)
m.fit(X_train, y_train)
print_score(m )<compute_test_metric> | def discretize_fare(val):
fare_group = pd.qcut(all_data['Fare'],splits ).sort_values().unique()
for i in range(splits):
if val in fare_group[i]:
return i+1
elif np.isnan(val):
return val | Titanic - Machine Learning from Disaster |
1,882,473 | fi = rf_feat_importance(m, X )<compute_test_metric> | all_data['Fare'] = all_data['Fare'].apply(discretize_fare ) | Titanic - Machine Learning from Disaster |
1,882,473 | fi = rf_feat_importance(m, df_trn )<split> | all_data['Fare'] = all_data['Fare'].fillna(5 ).astype(int ) | Titanic - Machine Learning from Disaster |
1,882,473 | df_keep = df_trn[to_keep].copy()
X_train, X_valid = split_vals(df_keep, n_trn )<create_dataframe> | def discretize_age(val):
age_group = pd.cut(all_data['Age'],splits ).sort_values().unique()
for i in range(splits):
if val in age_group[i]:
return i+1
elif np.isnan(val):
return 0 | Titanic - Machine Learning from Disaster |
1,882,473 | df_keep = X[to_keep].copy()<train_model> | all_data['Age'] = all_data['Age'].apply(discretize_age ).astype(int ) | Titanic - Machine Learning from Disaster |
1,882,473 | m = ExtraTreesRegressor(n_jobs=-1, n_estimators=500, random_state=0)
m.fit(df_keep, y )<train_model> | all_data['Title'] = all_data['Name'].apply(get_title ) | Titanic - Machine Learning from Disaster |
1,882,473 | m = RandomForestRegressor(max_features=0.5,
n_jobs=-1, oob_score=True)
m.fit(X_train, y_train)
print_score(m )<count_values> | all_data['Title'] = all_data['Title'].replace(['Ms','Mlle'],'Miss')
all_data['Title'] = all_data['Title'].replace('Mme','Mrs')
all_data['Title'] = all_data['Title'].replace(['Don','Dona','Lady','Sir',
'Countess','Jonkheer'],'Royal')
all_data['Title'] = all_data['Title'].replace(['Rev','Major','Col','Capt','Dr'],'Oth... | Titanic - Machine Learning from Disaster |
1,882,473 | df.Neighborhood.value_counts()<count_values> | def impute_age(row):
pclass = row['Pclass']
title = row['Title']
age = row['Age']
if age == 0:
return int(round(all_data.loc[(all_data['Age']!=0)&
(all_data['Pclass']==pclass)&
(all_data['Title']==title)]['Age'].mean() ,1))
else:
return age | Titanic - Machine Learning from Disaster |
1,882,473 | df.MSSubClass.value_counts()<count_values> | all_data['Age'] = all_data.apply(impute_age,axis=1 ) | Titanic - Machine Learning from Disaster |
1,882,473 | df.GarageType.value_counts()<import_modules> | _ = all_data.rename({'Cabin':'Deck'},axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
1,882,473 | from scipy.cluster import hierarchy as hc<import_modules> | all_data['Deck'] = all_data['Deck'].fillna('N' ) | Titanic - Machine Learning from Disaster |
1,882,473 | from scipy.stats import spearmanr as sp<train_model> | def cabin_to_deck(row):
return row['Deck'][0] | Titanic - Machine Learning from Disaster |
1,882,473 | def get_oob(df):
m = RandomForestRegressor(n_estimators=500, n_jobs=-1, oob_score=True)
x, _ = split_vals(df, n_trn)
m.fit(x, y_train)
return m.oob_score_<feature_engineering> | all_data['Deck'] = all_data.apply(cabin_to_deck,axis=1 ) | Titanic - Machine Learning from Disaster |
1,882,473 | get_oob(df_keep )<install_modules> | ticket_list = []
for ticket_id in list(all_data['Ticket'].unique()):
count = all_data[all_data['Ticket']==ticket_id].count() [0]
decks = all_data[all_data['Ticket']==ticket_id]['Deck']
empty_decks =(decks=='N' ).sum()
if(count > 1)and(empty_decks > 0)and(empty_decks < len(decks)) :
ticket_list.append(ticket_id)
print(... | Titanic - Machine Learning from Disaster |
1,882,473 |
<install_modules> | for ticket in ticket_list:
display(all_data[all_data['Ticket']==ticket] ) | Titanic - Machine Learning from Disaster |
1,882,473 | conda install -c conda-forge hdbscan<train_on_grid> | _ = all_data.set_value(533,'Deck',value=all_data.loc[128]['Deck'])
_ = all_data.set_value(1308,'Deck',value=all_data.loc[128]['Deck'])
_ = all_data.set_value(258,'Deck',all_data.loc[679]['Deck'])
_ = all_data.set_value(373,'Deck',value='C')
_ = all_data.set_value(290,'Deck',value=all_data.loc[741]['Deck'])
_ = all... | Titanic - Machine Learning from Disaster |
1,882,473 | data = df_keep
clusterer = hdbscan.HDBSCAN(min_cluster_size=3, gen_min_span_tree=True)
clusterer.fit(data )<import_modules> | decks_by_class = [[],[],[]]
for i in range(3):
decks_by_class[i] = list(all_data[all_data['Pclass']==i+1]['Deck'].unique())
print(f'Pclass = {i+1} decks:',decks_by_class[i] ) | Titanic - Machine Learning from Disaster |
1,882,473 | from pdpbox import pdp
from plotnine import *<feature_engineering> | for i in range(3):
if 'N' in decks_by_class[i]:
decks_by_class[i].remove('N')
if 'T' in decks_by_class[i]:
decks_by_class[i].remove('T' ) | Titanic - Machine Learning from Disaster |
1,882,473 | df_all = df_keep
df_all["SalePrice"] = y<install_modules> | weights_by_class = [[],[],[]]
for i,deck_list in enumerate(decks_by_class):
for deck in deck_list:
if i == 0:
class_total = all_data[(all_data['Deck']!='N')&(all_data['Pclass']==i+1)].count() [0]-1
else:
class_total = all_data[(all_data['Deck']!='N')&(all_data['Pclass']==i+1)].count() [0]
deck_total = all_data[(all_dat... | Titanic - Machine Learning from Disaster |
1,882,473 | !pip install scikit-misc<install_modules> | ticket_dict = {} | Titanic - Machine Learning from Disaster |
1,882,473 | !pip install treeinterpreter<import_modules> | def impute_deck(row):
ticket = row['Ticket']
deck = row['Deck']
pclass = row['Pclass']
if(deck == 'N')and(ticket not in ticket_dict):
if pclass == 1:
deck = list(np.random.choice(decks_by_class[0],size=1,
p=weights_by_class[0])) [0]
elif pclass ==2:
deck = list(np.random.choice(decks_by_class[1],size=1,
p=weights_by_cl... | Titanic - Machine Learning from Disaster |
1,882,473 | from treeinterpreter import treeinterpreter as ti<split> | all_data['Deck'] = all_data.apply(impute_deck,axis=1 ) | Titanic - Machine Learning from Disaster |
1,882,473 | df_train, df_valid = split_vals(df[df_keep.columns], n_trn )<predict_on_test> | all_data = all_data.drop(['Name','Ticket','Title'],axis=1 ) | Titanic - Machine Learning from Disaster |
1,882,473 | prediction, bias, contributions = ti.predict(m, row )<sort_values> | all_data['Deck'] = all_data['Deck'].map({'F':0,'C':1,'E':2,
'G':3,'D':4,'A':5,
'B':6,'T':7} ).astype(int ) | Titanic - Machine Learning from Disaster |
1,882,473 | idxs = np.argsort(contributions[0] )<define_variables> | all_data['Embarked'] = all_data['Embarked'].map({'S':0,'C':1,'Q':2} ).astype(int ) | Titanic - Machine Learning from Disaster |
1,882,473 | [o for o in zip(df_keep.columns[idxs], df_valid.iloc[0][idxs], contributions[0][idxs])]<define_variables> | all_data['Sex'] = all_data['Sex'].map({'female':0,'male':1} ).astype(int ) | Titanic - Machine Learning from Disaster |
1,882,473 | columns = ['OverallQual', 'GrLivArea', 'YearBuilt', 'GarageCars',
'TotalBsmtSF', '1stFlrSF', 'BsmtFinSF1', 'GarageArea', 'LotArea']
df.loc[:, columns]<set_options> | all_data['Alone'] = 0
all_data.loc[all_data['FamSize']==1,'Alone'] = 1 | Titanic - Machine Learning from Disaster |
1,882,473 | %whos<define_variables> | from sklearn.model_selection import KFold, GridSearchCV, cross_val_score
from sklearn.ensemble import RandomForestClassifier,AdaBoostClassifier,ExtraTreesClassifier
from sklearn.svm import SVC | Titanic - Machine Learning from Disaster |
1,882,473 | numeric_feats = X.dtypes[X.dtypes != "bool"].index<sort_values> | def rmse_cv(model,train):
kf = KFold(n_folds,shuffle=True,random_state=42 ).get_n_splits(train)
return np.sqrt(-cross_val_score(model,train,target,scoring='neg_mean_squared_error',cv=kf))
def logloss_cv(model,train):
kf = KFold(n_folds,shuffle=True,random_state=42 ).get_n_splits(train)
return -cross_val_score(model,t... | Titanic - Machine Learning from Disaster |
1,882,473 | skewed_feats = X.apply(lambda x: skew().sort_value<feature_engineering> | def rmse(y_true,y_pred):
return np.sqrt(mean_squared_error(y_true,y_pred))
def accuracy(y_true,y_pred):
return accuracy_score(y_true,y_pred ) | Titanic - Machine Learning from Disaster |
1,882,473 | skewness = skewness[abs(skewness)> 0.75]
print("There are {} skewed numerical features to Box Cox transform".format(skewness.shape[0]))
skewed_features = skewness.index
lam = 0.15
for feat in skewed_features:
all_data[feat] = boxcox1p(all_data[feat], lam )<categorify> | rf = RandomForestClassifier(n_estimators=700,max_depth=4,
min_samples_leaf=1,n_jobs=-1,
warm_start=True,
random_state=42)
et = ExtraTreesClassifier(n_estimators=550,max_depth=4,
min_samples_leaf=1,n_jobs=-1,
random_state=42)
ada = AdaBoostClassifier(n_estimators=550,learning_rate=0.001,
random_state=42)
svc = SVC(C=... | Titanic - Machine Learning from Disaster |
1,882,473 | all_features = pd.get_dummies(all_features ).reset_index(drop=True)
all_features.shape<define_variables> | from sklearn.base import BaseEstimator, TransformerMixin, ClassifierMixin, clone
from sklearn.metrics import mean_squared_error, accuracy_score | Titanic - Machine Learning from Disaster |
1,882,473 | VAL_FILE = '.. /input/training-and-validation-data-pickle/validation.pkl.gz'<define_variables> | class StackerLvl1(BaseEstimator, ClassifierMixin, TransformerMixin):
def __init__(self, base_models, meta_model, n_folds=5):
self.base_models = base_models
self.meta_model = meta_model
self.n_folds = n_folds
def oof_pred(self, X, y):
self.base_models_ = [list() for x in self.base_models]
kfold = KFold(n_splits=self.n_f... | Titanic - Machine Learning from Disaster |
1,882,473 | almost_zero = 1e-10
almost_one = 1 - almost_zero<define_variables> | train = all_data[:ntrain]
test = all_data[ntrain:] | Titanic - Machine Learning from Disaster |
1,882,473 | base_models = {
'lgb1 ': "Python LGBM based on Pranav Pandya's R version",
'wbftl': "anttip's Wordbatch FM-FTRL",
'nngpu': "Downampled Neural Network run on GPU"
}<define_variables> | stack_model = StackerLvl1(base_models=(rf,et,svc),meta_model = ada)
stack_model.fit(train,target)
print('Accuracy:',accuracy(stack_model.predict(train),target))
print('RMSE:',rmse(stack_model.predict(train),target)) | Titanic - Machine Learning from Disaster |
1,882,473 | cvfiles = {
'lgb1 ': '.. /input/validate-pranav-lgb-model/pranav_lgb_val_nostop.csv',
'wbftl': '.. /input/validate-anttip-s-wordbatch-fm-ftrl-9711-version/wordbatch_fm_ftrl_val.csv',
'nngpu': '.. /input/gpu-validation/gpu_val1.csv'
}<define_variables> | stack_model_pred = stack_model.predict(test ) | Titanic - Machine Learning from Disaster |
1,882,473 | <define_variables><EOS> | sub = pd.DataFrame({'PassengerId':passenger_id,
'Survived':stack_model_pred})
sub.to_csv('submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
1,370,221 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | sns.set_style("whitegrid")
%matplotlib inline
warnings.filterwarnings("ignore")
print(os.listdir(".. /input")) | Titanic - Machine Learning from Disaster |
1,370,221 | model_order = [m for m in base_models]<prepare_x_and_y> | training = pd.read_csv(".. /input/train.csv")
testing = pd.read_csv(".. /input/test.csv" ) | Titanic - Machine Learning from Disaster |
1,370,221 | cvdata = pd.DataFrame({
m:pd.read_csv(cvfiles[m])['is_attributed'].clip(almost_zero,almost_one ).apply(logit)
for m in base_models
})
X_train = np.array(cvdata[model_order])
y_train = pd.read_pickle(VAL_FILE)['is_attributed']<train_model> | def null_table(training, testing):
print("Training Data Frame")
print(pd.isnull(training ).sum())
print(" ")
print("Testing Data Frame")
print(pd.isnull(testing ).sum())
null_table(training, testing ) | Titanic - Machine Learning from Disaster |
1,370,221 | stack_model = LogisticRegression()
stack_model.fit(X_train, y_train)
stack_model.coef_<compute_test_metric> | training.drop(labels = ["Cabin", "Ticket"], axis = 1, inplace = True)
testing.drop(labels = ["Cabin", "Ticket"], axis = 1, inplace = True)
null_table(training, testing ) | Titanic - Machine Learning from Disaster |
1,370,221 | print('Stacker score: ', roc_auc_score(y_train, stack_model.predict_proba(X_train)[:,1]))<load_from_csv> | training["Age"].fillna(training["Age"].median() , inplace = True)
testing["Age"].fillna(testing["Age"].median() , inplace = True)
training["Embarked"].fillna("S", inplace = True)
testing["Fare"].fillna(testing["Fare"].median() , inplace = True)
null_table(training, testing ) | Titanic - Machine Learning from Disaster |
1,370,221 | final_sub = pd.DataFrame()
subs = {m:pd.read_csv(subfiles[m] ).rename({'is_attributed':m},axis=1)for m in base_models}
first_model = list(base_models.keys())[0]
final_sub['click_id'] = subs[first_model]['click_id']<merge> | le_sex = LabelEncoder()
le_sex.fit(training["Sex"])
encoded_sex_training = le_sex.transform(training["Sex"])
training["Sex"] = encoded_sex_training
encoded_sex_testing = le_sex.transform(testing["Sex"])
testing["Sex"] = encoded_sex_testing
le_embarked = LabelEncoder()
le_embarked.fit(training["Embarked"])
encoded_e... | Titanic - Machine Learning from Disaster |
1,370,221 | df = subs[first_model]
for m in base_models:
if m != first_model:
df = df.merge(subs[m], on='click_id')
df.head()<predict_on_test> | training["FamSize"] = training["SibSp"] + training["Parch"] + 1
testing["FamSize"] = testing["SibSp"] + testing["Parch"] + 1 | Titanic - Machine Learning from Disaster |
1,370,221 | X_test = np.array(df.drop(['click_id'],axis=1)[model_order].clip(almost_zero,almost_one ).apply(logit))
final_sub['is_attributed'] = stack_model.predict_proba(X_test)[:,1]
final_sub.head(10 )<save_to_csv> | training["IsAlone"] = training.FamSize.apply(lambda x: 1 if x == 1 else 0)
testing["IsAlone"] = testing.FamSize.apply(lambda x: 1 if x == 1 else 0 ) | Titanic - Machine Learning from Disaster |
1,370,221 | final_sub.to_csv("sub_stacked.csv", index=False, float_format='%.9f' )<define_variables> | for name in training["Name"]:
training["Title"] = training["Name"].str.extract("([A-Za-z]+)\.",expand=True)
for name in testing["Name"]:
testing["Title"] = testing["Name"].str.extract("([A-Za-z]+)\.",expand=True ) | Titanic - Machine Learning from Disaster |
1,370,221 | NROWS1 = 3000000
NROWS2 = 1000000
RG = 500000
SKIPROWS = range(1,RG)
path = '.. /input/'
path_train = path + 'train.csv'
path_test = path + 'test.csv'
train_cols = ['ip', 'app', 'device', 'os', 'channel', 'click_time', 'is_attributed']
test_cols = ['ip', 'app', 'device', 'os', 'channel', 'click_time']
dtypes = {
'ip' ... | titles = set(training["Title"])
print(titles ) | Titanic - Machine Learning from Disaster |
1,370,221 | print("Unique data train")
Unique_data_train = pd.to_datetime(train.click_time ).dt.day.astype('uint8' ).value_counts().sort_index()
print(Unique_data_train)
print("Unique data test")
Unique_data_test = pd.to_datetime(test.click_time ).dt.day.astype('uint8' ).value_counts().sort_index()
print(Unique_data_test )<trai... | title_list = list(training["Title"])
frequency_titles = []
for i in titles:
frequency_titles.append(title_list.count(i))
print(frequency_titles ) | Titanic - Machine Learning from Disaster |
1,370,221 | len_train = len(train)
print('The initial size of the train set is', len_train)
train = train.append(test)
print('Binding the training and test set together...')
del test<train_model> | titles = list(titles)
title_dataframe = pd.DataFrame({
"Titles" : titles,
"Frequency" : frequency_titles
})
print(title_dataframe ) | Titanic - Machine Learning from Disaster |
1,370,221 | print("Train and test together")
print(train.head(5))<data_type_conversions> | title_replacements = {"Mlle": "Other", "Major": "Other", "Col": "Other", "Sir": "Other", "Don": "Other", "Mme": "Other",
"Jonkheer": "Other", "Lady": "Other", "Capt": "Other", "Countess": "Other", "Ms": "Other", "Dona": "Other"}
training.replace({"Title": title_replacements}, inplace=True)
testing.replace({"Title": ti... | Titanic - Machine Learning from Disaster |
1,370,221 | train['hour'] = pd.to_datetime(train.click_time ).dt.hour.astype('uint8')
train['day'] = pd.to_datetime(train.click_time ).dt.day.astype('uint8')
train['wday'] = pd.to_datetime(train.click_time ).dt.dayofweek.astype('uint8')
train['minute'] = pd.to_datetime(train.click_time ).dt.minute.astype('uint8')
train['second... | training.drop("Name", axis = 1, inplace = True)
testing.drop("Name", axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
1,370,221 | print("Frequent hours")
frequent_hour = train.hour.value_counts().sort_index()
print(frequent_hour)
print("Frequent days")
frequent_day = train.day.value_counts().sort_index()
print(frequent_day)
print("Frequent doy")
frequent_doy = train.doy.value_counts().sort_index()
print(frequent_doy)
print("Frequent week da... | scaler = StandardScaler()
ages_train = np.array(training["Age"] ).reshape(-1, 1)
fares_train = np.array(training["Fare"] ).reshape(-1, 1)
ages_test = np.array(testing["Age"] ).reshape(-1, 1)
fares_test = np.array(testing["Fare"] ).reshape(-1, 1)
training["Age"] = scaler.fit_transform(ages_train)
training["Fare"] =... | Titanic - Machine Learning from Disaster |
1,370,221 | most_freq_hours_in_data = [4, 5, 9, 10, 13, 14]
middle1_freq_hours_in_data = [16, 17, 22]
least_freq_hours_in_data = [6, 11, 15]
train['in_hh'] =(4
- 3*train['hour'].isin(most_freq_hours_in_data)
- 2*train['hour'].isin(middle1_freq_hours_in_data)
- 1*train['hour'].isin(least_freq_hours_in_data)).astype('uint8')
gp =... | from sklearn.svm import SVC, LinearSVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.tree import DecisionTreeClassifier | Titanic - Machine Learning from Disaster |
1,370,221 | print("Train new time parameters")
print(train.dtypes )<data_type_conversions> | from sklearn.metrics import make_scorer, accuracy_score | Titanic - Machine Learning from Disaster |
1,370,221 | train['app'] = train['app'].astype('uint16')
train['channel'] = train['channel'].astype('uint16')
train['device'] = train['device'].astype('uint16')
train['ip'] = train['ip'].astype('uint32')
train['os'] = train['os'].astype('uint16' )<data_type_conversions> | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
1,370,221 | train_X = train[:len_train].drop(['click_id', 'is_attributed'], axis=1)
train_y = train[:len_train]['is_attributed'].astype('uint8')
test_X = train[len_train:].drop(['click_id', 'is_attributed'], axis=1)
test_id = train[len_train:]['click_id'].astype('int')
del train<load_from_csv> | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
1,370,221 | predictors = ['app','device','os', 'channel', 'hour', 'day', 'doy', 'wday','minute','second',
'ip_app_channel_var_day',
'ip_app_device_var_day',
'ip_app_os_var_day',
'ip_day_hour_count_channel',
'ip_app_count_channel',
'ip_app_os_count_channel',
'ip_app_day_hour_count_channel',
'ip_app_channel_mean_hour',
'nip_day_hh']... | X_train = training.drop(labels=["PassengerId", "Survived"], axis=1)
y_train = training["Survived"]
X_test = testing.drop("PassengerId", axis=1)
| Titanic - Machine Learning from Disaster |
1,370,221 | metrics = 'auc'
lgb_params = {
'boosting_type': 'gbdt',
'objective': 'binary',
'metric':metrics,
'learning_rate': 0.05,
'num_leaves': 7,
'max_depth': 4,
'min_child_samples': 100,
'max_bin': 100,
'subsample': 0.7,
'subsample_freq': 1,
'colsample_bytree': 0.7,
'min_child_weight': 0,
'min_split_gain': 0,
'nthread': 8,
've... | X_training, X_valid, y_training, y_valid = train_test_split(X_train, y_train, test_size=0.2, random_state=0 ) | Titanic - Machine Learning from Disaster |
1,370,221 | sub = pd.DataFrame()
sub['click_id'] = test_id
print("Sub dimension " + str(sub.shape))
print("Test_X dimension " + str(test_X.shape))<save_to_csv> | svc_clf = SVC()
parameters_svc = {"kernel": ["rbf", "linear"], "probability": [True, False], "verbose": [True, False]}
grid_svc = GridSearchCV(svc_clf, parameters_svc, scoring=make_scorer(accuracy_score))
grid_svc.fit(X_training, y_training)
svc_clf = grid_svc.best_estimator_
svc_clf.fit(X_training, y_training)
pred_... | 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.