kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,480,826 | data.show_batch(rows=3, figsize=(12,9))<choose_model_class> | submission = test['Survived']
submission.to_csv(f"submission.csv", index=True)
print(datetime.now().strftime("%y-%m-%d %H:%M:%S")," | ","Saving submission.. " ) | Titanic - Machine Learning from Disaster |
14,133,000 | arch = models.densenet121<find_best_params> | from sklearn.model_selection import train_test_split, validation_curve, learning_curve, GridSearchCV
from sklearn.linear_model import LinearRegression, Ridge, Lasso, LogisticRegression
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier, Decisio... | Titanic - Machine Learning from Disaster |
14,133,000 | acc_02 = partial(accuracy_thresh, thresh=0.19)
f_score = partial(fbeta, thresh=0.19)
learn = cnn_learner(data, arch, metrics=[acc_02, f_score], model_dir='/kaggle/working/' )<init_hyperparams> | train_data = pd.read_csv(".. /input/titanic/train.csv")
test_data = pd.read_csv(".. /input/titanic/test.csv")
train_data.groupby('Survived')['PassengerId'].nunique()
train_data.groupby('Pclass')['PassengerId'].nunique()
| Titanic - Machine Learning from Disaster |
14,133,000 | lr = 0.01<train_model> | train = train_data.copy()
train['Cab'] = pd.Series(['cab' + str(i)[0] for i in train.Cabin], index=train.index)
del train['PassengerId']
del train['Name']
del train['Ticket']
del train['Cabin']
del train['Parch']
dummy = pd.get_dummies(train['Sex'])
train = train.join(dummy)
del train['Sex']
dummy = pd.get_dummies(t... | Titanic - Machine Learning from Disaster |
14,133,000 | learn.fit_one_cycle(5, slice(lr))<save_model> | test = test_data.copy()
del test['PassengerId']
del test['Name']
del test['Ticket']
del test['Cabin']
del test['Parch']
dummy = pd.get_dummies(test['Sex'])
test = test.join(dummy)
del test['Sex']
dummy = pd.get_dummies(test['Embarked'])
test = test.join(dummy)
del test['Embarked']
test["Age"].fillna(test["Age"].mea... | Titanic - Machine Learning from Disaster |
14,133,000 | learn.save('stage-1-rn50' )<train_model> | X = train.drop(['Survived'], axis=1)
y = train['Survived']
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.05,
random_state=4 ) | Titanic - Machine Learning from Disaster |
14,133,000 | learn.fit_one_cycle(5, slice(1e-5, lr/5))<save_model> | XGBC_model = XGBClassifier(max_depth= 4, n_estimators=20)
XGBC_model.fit(X_train, y_train)
print('XGBC_model Training score:', XGBC_model.score(X_train,y_train))
print('XGBC_model Test score: ', XGBC_model.score(X_test,y_test),'
')
extratree_model = ExtraTreesClassifier(max_depth=5)
extratree_model.fit(X_train, y_t... | Titanic - Machine Learning from Disaster |
14,133,000 | learn.save('stage-2-rn50' )<categorify> | scores = cross_val_score(estimator=XGBC_model, X=X, y=y, cv=10)
print(scores, scores.mean() , scores.std() , "
")
scores = cross_val_score(estimator=extratree_model, X=X, y=y, cv=10)
print(scores, scores.mean() , scores.std() , "
")
scores = cross_val_score(estimator=bagging_model, X=X, y=y, cv=10)
print(scores, s... | Titanic - Machine Learning from Disaster |
14,133,000 | data =(src.transform(tfms, size=256)
.databunch(num_workers=0 ).normalize(imagenet_stats))
learn.data = data
data.train_ds[0][0].shape<find_best_params> | survived1 = gradient_boosting_model.predict(test)
survived2 = random_forest_model.predict(test)
survived3 = decision_tree_model.predict(test)
survived4 = extratree_model.predict(test)
survived5 = bagging_model.predict(test)
survived6 = XGBC_model.predict(test)
survived =(survived1 + survived2 + survived3 + surviv... | Titanic - Machine Learning from Disaster |
14,126,650 | lr=1e-2/2<train_model> | 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 |
14,126,650 | learn.fit_one_cycle(5, slice(lr))<save_model> | train_data.isna().sum() | Titanic - Machine Learning from Disaster |
14,126,650 | learn.save('stage-1-256-rn50' )<train_model> | test_data.isna().sum() | Titanic - Machine Learning from Disaster |
14,126,650 | learn.fit_one_cycle(5, slice(1e-5, lr/5))<save_model> | train_data.drop(['PassengerId', 'Name', 'Ticket', 'Cabin', 'Embarked'], inplace=True, axis=1)
test_data.drop([ 'Name', 'Ticket', 'Cabin', 'Embarked'], inplace=True, axis=1 ) | Titanic - Machine Learning from Disaster |
14,126,650 | learn.save('stage-2-256-rn50' )<define_variables> | train_data['Age'].fillna(24.0,inplace=True)
| Titanic - Machine Learning from Disaster |
14,126,650 | test =(ImageList.from_folder(path/'test-jpg-v2'))
len(test )<feature_engineering> | test_data['Age'].fillna(24.0,inplace=True ) | Titanic - Machine Learning from Disaster |
14,126,650 | learn_test = load_learner('/kaggle/working/', test=test, num_workers=0, bs=1)
preds, _ = learn_test.get_preds(ds_type=DatasetType.Test)
preds_tta, _ = learn_test.TTA(ds_type=DatasetType.Test)
<save_to_csv> | train_data.isna().sum() | Titanic - Machine Learning from Disaster |
14,126,650 | thresh = 0.15
labelled_preds = [' '.join([learn_test.data.classes[i] for i,p in enumerate(pred)if p > thresh])for pred in preds]
fnames = [f.name[:-4] for f in learn_test.data.test_ds.x.items]
df = pd.DataFrame({'image_name':fnames, 'tags':labelled_preds}, columns=['image_name', 'tags'])
df.to_csv('submission_015.csv'... | test_data['Fare'].fillna(7.75,inplace=True ) | Titanic - Machine Learning from Disaster |
14,126,650 | thresh = 0.18
labelled_preds = [' '.join([learn_test.data.classes[i] for i,p in enumerate(pred)if p > thresh])for pred in preds]
fnames = [f.name[:-4] for f in learn_test.data.test_ds.x.items]
df = pd.DataFrame({'image_name':fnames, 'tags':labelled_preds}, columns=['image_name', 'tags'])
df.to_csv('submission_018.csv'... | test_data.isna().sum() | Titanic - Machine Learning from Disaster |
14,126,650 | thresh = 0.19
labelled_preds = [' '.join([learn_test.data.classes[i] for i,p in enumerate(pred)if p > thresh])for pred in preds]
fnames = [f.name[:-4] for f in learn_test.data.test_ds.x.items]
df = pd.DataFrame({'image_name':fnames, 'tags':labelled_preds}, columns=['image_name', 'tags'])
df.to_csv('submission_019.csv'... | genderMap={
'male':0,
'female':1
}
train_data.Sex=train_data.Sex.map(genderMap)
test_data.Sex=test_data.Sex.map(genderMap ) | Titanic - Machine Learning from Disaster |
14,126,650 | thresh = 0.20
labelled_preds = [' '.join([learn_test.data.classes[i] for i,p in enumerate(pred)if p > thresh])for pred in preds]
fnames = [f.name[:-4] for f in learn_test.data.test_ds.x.items]
df = pd.DataFrame({'image_name':fnames, 'tags':labelled_preds}, columns=['image_name', 'tags'])
df.to_csv('submission_020.csv'... | X=np.array(train_data.drop('Survived',axis=1))
y=np.array(train_data['Survived'])
X.shape | Titanic - Machine Learning from Disaster |
14,126,650 | thresh = 0.21
labelled_preds = [' '.join([learn_test.data.classes[i] for i,p in enumerate(pred)if p > thresh])for pred in preds]
fnames = [f.name[:-4] for f in learn_test.data.test_ds.x.items]
df = pd.DataFrame({'image_name':fnames, 'tags':labelled_preds}, columns=['image_name', 'tags'])
df.to_csv('submission_021.csv'... | X_train, X_test, y_train, y_test = train_test_split(X,y,random_state=47 ) | Titanic - Machine Learning from Disaster |
14,126,650 | import os
import numpy as np
import keras
import sklearn
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import confusion_matrix, precision_score, recall_score, accuracy_s... | lr=LogisticRegression(solver='liblinear',multi_class='ovr')
lr.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
14,126,650 | data = pd.read_csv('.. /input/train.csv' )<split> | lr.score(X_test,y_test ) | Titanic - Machine Learning from Disaster |
14,126,650 | train_data = data.iloc[:,2:203]<prepare_x_and_y> | test_data['Survived']=lr.predict(test_data.drop(['PassengerId'],axis=1)) | Titanic - Machine Learning from Disaster |
14,126,650 | y = data.iloc[:,1]<split> | pd.read_csv('/kaggle/input/titanic/gender_submission.csv' ) | Titanic - Machine Learning from Disaster |
14,126,650 | X_train, X_test, y_train, y_test = train_test_split(train_data, y, test_size=0.2, random_state=142 )<import_modules> | Submission=test_data[['PassengerId','Survived']]
Submission.set_index('PassengerId',inplace=True ) | Titanic - Machine Learning from Disaster |
14,126,650 | from xgboost import XGBClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC, LinearSVC
from sklearn.ensemble import RandomForestClassifier,GradientBoostingClassifier, VotingClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB<trai... | Submission.to_csv('Submission.csv' ) | Titanic - Machine Learning from Disaster |
14,161,529 | gnb = GaussianNB()
gnb.fit(X_train, y_train )<predict_on_test> | %matplotlib inline | Titanic - Machine Learning from Disaster |
14,161,529 | y_preds_gnb = gnb.predict(X_test)
print(accuracy_score(y_test, y_preds_gnb))<load_from_csv> | train= pd.read_csv('/kaggle/input/titanic/train.csv' ) | Titanic - Machine Learning from Disaster |
14,161,529 | test_data = pd.read_csv('.. /input/test.csv' )<prepare_x_and_y> | def impute_age(cols):
Age = cols[0]
Pclass = cols[1]
if pd.isnull(Age):
if Pclass==1:
return 37
elif Pclass == 2:
return 29
else :
return 24
else:
return Age | Titanic - Machine Learning from Disaster |
14,161,529 | X_test_data = test_data.iloc[:,1:202]<predict_on_test> | train['Age']=train[['Age','Pclass']].apply(impute_age,axis = 1 ) | Titanic - Machine Learning from Disaster |
14,161,529 | y_preds_test_data_gnb = gnb.predict(X_test_data )<save_to_csv> | train.drop('Cabin',inplace = True,axis =1)
| Titanic - Machine Learning from Disaster |
14,161,529 | my_submission_gnb = pd.DataFrame({'ID_code': test_data.ID_code, 'target': y_preds_test_data_gnb})
my_submission_gnb.to_csv('submission_gnb.csv', index=False )<import_modules> | sex = pd.get_dummies(train['Sex'],drop_first=True)
embark = pd.get_dummies(train['Embarked'],drop_first=True ) | Titanic - Machine Learning from Disaster |
14,161,529 | from catboost import CatBoostClassifier<train_model> | train = pd.concat([train,sex,embark],axis=1 ) | Titanic - Machine Learning from Disaster |
14,161,529 | cat = CatBoostClassifier(iterations=3000, learning_rate=0.03, objective="Logloss", eval_metric='AUC')
cat.fit(X_train, y_train )<predict_on_test> | train.drop(['Sex','Embarked','PassengerId','Name','Ticket'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
14,161,529 | y_preds_cat = cat.predict(X_test)
print(accuracy_score(y_test, y_preds_cat))<predict_on_test> | st = StandardScaler() | Titanic - Machine Learning from Disaster |
14,161,529 | y_preds_test_data_cat = cat.predict(X_test_data )<save_to_csv> | feature_scale = ['Age','Fare']
train[feature_scale] = st.fit_transform(train[feature_scale])
| Titanic - Machine Learning from Disaster |
14,161,529 | my_submission_cat = pd.DataFrame({'ID_code': test_data.ID_code, 'target': y_preds_test_data_cat})
my_submission_cat.to_csv('submission_cat.csv', index=False )<import_modules> | x = train.drop(['Survived'],axis=1)
y = train['Survived'] | Titanic - Machine Learning from Disaster |
14,161,529 | import lightgbm as lgb
from sklearn.model_selection import StratifiedKFold
import time<categorify> | from sklearn.model_selection import GridSearchCV
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier | Titanic - Machine Learning from Disaster |
14,161,529 | def augment(x,y,t=2):
xs,xn = [],[]
for i in range(t):
mask = y>0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
np.random.shuffle(ids)
x1[:,c] = x1[ids][:,c]
xs.append(x1)
for i in range(t//2):
mask = y==0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
... | tree = DecisionTreeClassifier()
tree.fit(x,y)
tree.score(x,y ) | Titanic - Machine Learning from Disaster |
14,161,529 | n_fold = 5
folds = StratifiedKFold(n_splits=n_fold, shuffle=False, random_state=42 )<init_hyperparams> | test = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
14,161,529 | lgbm_params = {'bagging_freq': 5,
'bagging_fraction': 0.335,
'boost_from_average':'false',
'boost': 'gbdt',
'feature_fraction': 0.041,
'learning_rate': 0.0083,
'max_depth': -1,
'metric':'auc',
'min_data_in_leaf': 80,
'min_sum_hessian_in_leaf': 10.0,
'num_leaves': 13,
'num_threads': 8,
'tree_learner': 'serial',
'objecti... | test2 = test.copy() | Titanic - Machine Learning from Disaster |
14,161,529 | prediction_lgb_new = np.zeros(len(X_test_data))
for fold_n,(train_index, valid_index)in enumerate(folds.split(train_data,y)) :
print('Fold', fold_n)
X_training, X_validation = train_data.iloc[train_index], train_data.iloc[valid_index]
y_training, y_validation = y.iloc[train_index], y.iloc[valid_index]
X_training, y_tr... | test['Age']=test[['Age','Pclass']].apply(impute_age,axis = 1 ) | Titanic - Machine Learning from Disaster |
14,161,529 | my_submission_lgb_new = pd.DataFrame({'ID_code': test_data.ID_code, 'target': prediction_lgb_new})
my_submission_lgb_new.to_csv('submission_lgb_new.csv', index=False )<save_to_csv> | test.drop('Cabin',inplace = True,axis =1 ) | Titanic - Machine Learning from Disaster |
14,161,529 | my_submission_cat_lgb_gnb = pd.DataFrame({'ID_code': test_data.ID_code,
'target':(y_preds_test_data_cat + y_preds_test_data_gnb)/2})
my_submission_cat_lgb_gnb.to_csv('my_submission_cat_gnb.csv', index=False )<load_from_csv> | sex = pd.get_dummies(test['Sex'],drop_first=True)
embark = pd.get_dummies(test['Embarked'],drop_first=True ) | Titanic - Machine Learning from Disaster |
14,161,529 | test = pd.read_csv(".. /input/test.csv")
train = pd.read_csv(".. /input/train.csv" )<prepare_x_and_y> | test = pd.concat([test,sex,embark],axis=1 ) | Titanic - Machine Learning from Disaster |
14,161,529 | ytrain = train['target']
xtrain = train.iloc[:,2:]
xtest = test.iloc[:,1:]<train_model> | test.drop(['Sex','Embarked','PassengerId','Name','Ticket'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
14,161,529 | rus = RandomUnderSampler(random_state=1, replacement=True)
xtrain1,ytrain1 = rus.fit_sample(xtrain, ytrain)
<split> | test['Fare'].fillna(test['Fare'].mean() ,inplace=True ) | Titanic - Machine Learning from Disaster |
14,161,529 | param = {
'num_leaves': 2,
'learning_rate': 0.1,
'feature_fraction': 0.2,
'max_depth': -1,
'objective': 'binary',
'boosting_type': 'gbdt',
'metric': 'auc',
}
folds = StratifiedKFold(n_splits=5, shuffle=True, random_state=4590)
oof = np.zeros(len(xtrain))
ypred = np.zeros(len(xtest))
feature_importance_df = pd.DataFram... | feature_scale = ['Age','Fare']
test[feature_scale] = st.fit_transform(test[feature_scale] ) | Titanic - Machine Learning from Disaster |
14,161,529 | df = pd.DataFrame({'ID_code':test['ID_code'],'target':ypred})
df.to_csv('undersamping.csv',index=None )<compute_test_metric> | from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier | Titanic - Machine Learning from Disaster |
14,161,529 | roc_auc_score(ytrain,oof )<load_from_csv> | level1 = LogisticRegression()
model = StackingClassifier(estimators=level0,final_estimator=level1,cv=5 ) | Titanic - Machine Learning from Disaster |
14,161,529 | train=pd.read_csv(".. /input/train.csv")
test=pd.read_csv(".. /input/test.csv" )<drop_column> | level1 = LogisticRegression()
model = StackingClassifier(estimators=level0,final_estimator=level1,cv=5)
| Titanic - Machine Learning from Disaster |
14,161,529 | train.pop("ID_code")
test.pop("ID_code" )<count_values> | model.fit(x,y ) | Titanic - Machine Learning from Disaster |
14,161,529 | train["target"].value_counts()<prepare_x_and_y> | y_predicted = model.predict(test ) | Titanic - Machine Learning from Disaster |
14,161,529 | y=train["target"]<drop_column> | submission = pd.DataFrame({
"PassengerId":test2['PassengerId'],
"Survived":y_predicted
} ) | Titanic - Machine Learning from Disaster |
14,161,529 | train.pop("target" )<import_modules> | submission.to_csv('first_kaggale_titanic_submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
14,097,212 | from sklearn.model_selection import StratifiedKFold,KFold
import lightgbm as lgb<choose_model_class> | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data as tud | Titanic - Machine Learning from Disaster |
14,097,212 | n_fold = 5
folds = StratifiedKFold(n_splits=n_fold, shuffle=True, random_state=42 )<init_hyperparams> | trainRaw = pd.read_csv('/kaggle/input/titanic/train.csv')
testRaw = pd.read_csv('/kaggle/input/titanic/test.csv')
answer = pd.read_csv('/kaggle/input/titanic-answer/answers.csv' ) | Titanic - Machine Learning from Disaster |
14,097,212 | params = {'num_leaves': 8,
'min_data_in_leaf': 80,
'min_sum_hessian_in_leaf': 10.0,
'objective': 'binary',
'max_depth': 16,
'num_leaves': 13,
'learning_rate': 0.0085,
'boosting': 'gbdt',
'bagging_freq': 5,
'bagging_fraction': 0.38,
'feature_fraction': 0.04,
'bagging_seed': 11,
'reg_alpha': 0.1302650970728192,
'reg_lamb... | Pclass_dic = ['Pclass_1', 'Pclass_2', 'Pclass_3']
all_data[Pclass_dic] = all_data[Pclass_dic]/3
Sex_dic = ['Sex_female', 'Sex_male']
all_data[Sex_dic] = all_data[Sex_dic]/2
Embarked_dic = ['Embarked_C', 'Embarked_Q', 'Embarked_S']
all_data[Embarked_dic] = all_data[Embarked_dic]/3
Title_dic = ['Title_Master', 'Title_Mis... | Titanic - Machine Learning from Disaster |
14,097,212 | prediction = np.zeros(len(test))
for fold_n,(train_index, valid_index)in enumerate(folds.split(train,y)) :
print('Fold', fold_n)
X_train, X_valid = train.iloc[train_index], train.iloc[valid_index]
y_train, y_valid = y.iloc[train_index], y.iloc[valid_index]
train_data = lgb.Dataset(X_train, label=y_train)
valid_data =... | def minmaxscaler(data):
min = np.amin(data)
max = np.amax(data)
return(data - min)/(max-min)
def feature_normalize(data):
mu = np.mean(data,axis=0)
std = np.std(data,axis=0)
return(data - mu)/std
def unnormalized_show(img):
img = img * std + mu
npimg = img.numpy()
plt.figure()
plt.imshow(np.transpose(npimg,(1, 2, ... | Titanic - Machine Learning from Disaster |
14,097,212 | sub1=pd.read_csv(".. /input/sample_submission.csv" )<feature_engineering> | all_data.Age = minmaxscaler(all_data.Age)
all_data.Fare = minmaxscaler(all_data.Fare ) | Titanic - Machine Learning from Disaster |
14,097,212 | sub1["target"]=prediction<save_to_csv> | train=all_data[all_data['Survived'].notnull() ]
test=all_data[all_data['Survived'].isnull() ].drop('Survived',axis=1)
test_submssion=testRaw[['PassengerId']]
y = train.Survived
X = train.drop(['Survived'],axis=1 ) | Titanic - Machine Learning from Disaster |
14,097,212 | sub1.to_csv("submissionlgb.csv",index=False )<set_options> | class DATASET(tud.Dataset):
def __init__(self, train, test):
self.X = torch.from_numpy(np.asarray(train)).float()
self.y= torch.from_numpy(np.asarray(test)).float()
def __getitem__(self, index):
return self.X[index], self.y[index]
def __len__(self):
return len(self.y)
D_IN, H1, H2, H3, D_OUT = 31, 100, 100, 10, 1
DROP... | Titanic - Machine Learning from Disaster |
14,097,212 | pd.set_option('display.max_columns', 200)
InteractiveShell.ast_node_interactivity = "all"
warnings.filterwarnings('ignore' )<load_from_csv> | full_dataset = DATASET(X, y)
answer_dataset = DATASET(test, answer.Survived)
full_dataloador = tud.DataLoader(full_dataset, batch_size=64, shuffle=False, drop_last=False)
LEN_FULL_TRAIN = len(full_dataset.y)
LEN_ANSWER = len(answer_dataset.y)
LEARNING_RATE = 1e-3
WEIGHT_DECAY = 2e-4
model = Base_net()
optimizer = ... | Titanic - Machine Learning from Disaster |
14,097,212 | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv' )<count_missing_values> | test = torch.from_numpy(np.asarray(test)).float()
model.eval()
test_submssion.loc[:,'Survived'] = model(test ).detach().numpy().flatten()
test_submssion.loc[:,'Survived'] = test_submssion.loc[:,'Survived'].apply(lambda x : 1 if x > 0.5 else 0 ) | Titanic - Machine Learning from Disaster |
14,097,212 | train_df.isnull().sum().sum()
test_df.isnull().sum().sum()<feature_engineering> | test_submssion.to_csv('/kaggle/working/submssion.csv',index=False ) | Titanic - Machine Learning from Disaster |
13,794,910 | def add_new_feature_row(df,features):
for feature in features:
df[feature+"_pct"] = df[feature].pct_change()
df[feature+"_diff"] = df[feature].diff()
df.drop(feature,axis=1)
return df
<feature_engineering> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
train_data.head() | Titanic - Machine Learning from Disaster |
13,794,910 | def normalize_df(df,features):
for feature in features:
df[feature+'_norm'] =(df[feature] - df[feature].mean())/df[feature].std()
return df
<sort_values> | test_data = pd.read_csv('/kaggle/input/titanic/test.csv')
test_data.head() | Titanic - Machine Learning from Disaster |
13,794,910 | correlations = train_df[features].corr().abs().unstack().sort_values(kind="quicksort" ).reset_index()
correlations = correlations[correlations['level_0'] != correlations['level_1']]
<set_options> | categorical_cols = [col for col in train_data.columns if train_data[col].dtype == object
and train_data[col].nunique() <= 10]
print("Categorical columns: ",categorical_cols)
categorical_cols_missing_val = [col for col in train_data[categorical_cols].columns
if train_data[col].isnull().any() ]
print('
Categorical colum... | Titanic - Machine Learning from Disaster |
13,794,910 | gc.collect()<concatenate> | categorical_test_cols = [col for col in test_data.columns
if test_data[col].nunique() <= 10 and test_data[col].dtype == object]
print("Categorical columns: ",categorical_test_cols)
categorical_test_cols_missing_val = [col for col in test_data[categorical_test_cols].columns
if test_data[col].isnull().any() ]
print('
Ca... | Titanic - Machine Learning from Disaster |
13,794,910 | test_df['target']= np.nan
combine_df = train_df.append(test_df,ignore_index=True )<concatenate> | numerical_cols = [col for col in train_data.columns if train_data[col].dtype != object]
numerical_cols.remove('Survived')
numerical_cols.remove('PassengerId')
print("Numerical columns: ",numerical_cols)
num_cols_with_missing = [col for col in train_data[numerical_cols].columns
if train_data[col].isnull().any() ]
pri... | Titanic - Machine Learning from Disaster |
13,794,910 | features = train_df.columns.values[2:]
combine_df = normalize_df(combine_df,features )<split> | numerical_test_cols = [col for col in test_data.columns if test_data[col].dtype != object]
numerical_test_cols.remove('PassengerId')
print("Numerical columns: ",numerical_test_cols)
num_test_cols_with_missing = [col for col in test_data[numerical_test_cols].columns
if test_data[col].isnull().any() ]
print('
Nummerica... | Titanic - Machine Learning from Disaster |
13,794,910 | train_df = combine_df[combine_df['target'].notnull() ].reset_index(drop=True)
test_df = combine_df[combine_df['target'].isnull() ].reset_index(drop=True)
<define_variables> | my_cols = numerical_cols + categorical_cols | Titanic - Machine Learning from Disaster |
13,794,910 | predictors = train_df.columns.values.tolist() [2:]
nfold = 10
target = 'target'<init_hyperparams> | print('Number of unique values in X
',train_data[my_cols].nunique() ,'
' ) | Titanic - Machine Learning from Disaster |
13,794,910 | param = {
'num_leaves': 18,
'max_bin': 63,
'min_data_in_leaf': 5,
'learning_rate': 0.010614430970330217,
'min_sum_hessian_in_leaf': 0.0093586657313989123,
'feature_fraction': 0.056701788569420042,
'lambda_l1': 0.060222413158420585,
'lambda_l2': 4.6580550589317573,
'min_gain_to_split': 0.29588543202055562,
'max_depth': ... | women = train_data.loc[train_data.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
print("% of women who survived:", rate_women)
men = train_data.loc[train_data.Sex == 'male']["Survived"]
rate_men = sum(men)/len(men)
print("% of men who survived:", rate_men ) | Titanic - Machine Learning from Disaster |
13,794,910 | sub_df = pd.DataFrame({"ID_code": test_df.ID_code.values})
sub_df["target"] = predictions
sub_df.to_csv("sant_lgb.csv", index=False)
sub_df[:10]<set_options> | numerical_cols.remove('Age' ) | Titanic - Machine Learning from Disaster |
13,794,910 | warnings.filterwarnings('ignore')
<load_from_csv> | categorical_cols.remove('Embarked' ) | Titanic - Machine Learning from Disaster |
13,794,910 | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv" )<prepare_x_and_y> | y = train_data.Survived
X = train_data.drop(['Survived','Name'], axis=1)
train_X_full, val_X_full, train_y, val_y = train_test_split(X, y,
train_size=0.8, test_size=0.2,
random_state=0)
train_X = train_X_full[my_cols].copy()
val_X = val_X_full[my_cols].copy() | Titanic - Machine Learning from Disaster |
13,794,910 | train_cols = [c for c in train_df.columns if c not in ["ID_code", "target"]]
y_train = train_df["target"]<count_values> | numerical_transformer = SimpleImputer(strategy='median')
categorical_transformer = Pipeline(steps=
[('imputer', SimpleImputer(strategy='constant')) ,
('onehot', OneHotEncoder(handle_unknown='ignore'))
])
preprocessor = ColumnTransformer(
transformers=[
('num', numerical_transformer, numerical_cols),
('cat', categ... | Titanic - Machine Learning from Disaster |
13,794,910 | y_train.value_counts()<choose_model_class> | my_cols = numerical_cols + categorical_cols
my_model_full_data = RandomForestClassifier(n_estimators=72,
random_state=0,
max_leaf_nodes=50,
max_depth=10)
prep_full_data = Pipeline(steps=
[('preprocessor', preprocessor),
('model', my_model_full_data)])
prep_full_data.fit(X[my_cols], y ) | Titanic - Machine Learning from Disaster |
13,794,910 | folds = StratifiedKFold(n_splits=5, shuffle=True, random_state=1001 )<init_hyperparams> | test_X = test_data[my_cols].copy() | Titanic - Machine Learning from Disaster |
13,794,910 | params = {'tree_method': 'hist',
'objective': 'binary:logistic',
'eval_metric': 'auc',
'learning_rate': 0.0936165921314771,
'max_depth': 2,
'colsample_bytree': 0.3561271102144279,
'subsample': 0.8246604621518232,
'min_child_weight': 53,
'gamma': 9.943467991283027,
'silent': 1}<split> | test_preds = prep_full_data.predict(test_X)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived':test_preds})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
14,073,582 | %%time
oof_preds = np.zeros(train_df.shape[0])
sub_preds = np.zeros(test_df.shape[0])
feature_importance_df = pd.DataFrame()
for n_fold,(trn_idx, val_idx)in enumerate(folds.split(train_df, y_train)) :
trn_x, trn_y = train_df[train_cols].iloc[trn_idx], y_train.iloc[trn_idx]
val_x, val_y = train_df[train_cols].iloc[val... | mainData = pd.read_csv('/kaggle/input/titanic/train.csv')
testData = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
14,073,582 | print(confusion_matrix(y_train, np.round(oof_preds)) )<sort_values> | mainData = mainData[mainData.Embarked.notna() ]
mainData.drop(['Cabin'], axis='columns', inplace=True)
testData.drop(['Cabin'], axis='columns', inplace=True ) | Titanic - Machine Learning from Disaster |
14,073,582 | feature_importance_df.groupby(["feature"])["fscore",].mean().sort_values("fscore", ascending=False )<feature_engineering> | def rank(row):
a = ['Mrs.','Mr.','Miss','Master']
ret = []
for b in a:
if b in row.Name:
ret.append(b)
if len(ret)==0:
if row.Sex == 'male':
ret = ['Mr.']
else:
ret = ['Miss']
return ' '.join(ret)
mainData['rank'] = mainData.apply(rank, axis = 1)
testData['rank'] = testData.apply(rank, axis = 1 ) | Titanic - Machine Learning from Disaster |
14,073,582 | test_df['target'] = sub_preds<compute_test_metric> | mainData = mainData.drop(['Name','Ticket','Sex'], axis = 1)
testData = testData.drop(['Name','Ticket','Sex'], axis = 1 ) | Titanic - Machine Learning from Disaster |
14,073,582 | oof_roc = roc_auc_score(y_train, oof_preds)
oof_roc<save_to_csv> | mainData["Embarked"] = mainData["Embarked"].map({'S': 1,'C':2,'Q':3})
testData["Embarked"] = testData["Embarked"].map({'S': 1,'C':2,'Q':3})
mainData["rank_num"] = mainData["rank"].map({'Mrs.': 1,'Mr.':2,'Miss':3,'Master':4})
testData["rank_num"] = testData["rank"].map({'Mrs.': 1,'Mr.':2,'Miss':3,'Master':4})
def gr... | Titanic - Machine Learning from Disaster |
14,073,582 | ss = pd.DataFrame({"ID_code":test_df["ID_code"], "target":test_df["target"]})
ss.to_csv("sant_xgb_%sFold_%.6f.csv"%(folds.n_splits, oof_roc), index=None)
ss.head()<set_options> | mainData['predict'] = mainData.groupby('grouping')['Survived'].transform(lambda x: x.mode() [0])
groupDict = dict(zip(mainData.grouping, mainData.predict))
print(f'Train accuracy is {1 - abs(mainData.Survived - mainData.predict ).sum() /mainData.shape[0]:.2%}')
groupValTrain = set(mainData.grouping)
groupValTest = s... | Titanic - Machine Learning from Disaster |
14,073,582 | sns.set_style('whitegrid')
print(os.listdir(".. /input"))
<load_from_csv> | for v in groupDiff:
groupDict[v] = 1 | Titanic - Machine Learning from Disaster |
14,073,582 | %%time
train = pd.read_csv('.. /input/train.csv' )<load_from_csv> | testData['Survived'] = testData.grouping.apply(lambda x: groupDict[x])
testData[['PassengerId','Survived']].to_csv("final_submission.csv",index = False)
print("That's all!" ) | Titanic - Machine Learning from Disaster |
13,873,876 | test_df = pd.read_csv('.. /input/test.csv' )<prepare_x_and_y> | df1=pd.read_csv('/kaggle/input/titanic/train.csv')
df2=pd.read_csv('/kaggle/input/titanic/test.csv')
df3=pd.read_csv('/kaggle/input/titanic/gender_submission.csv')
| Titanic - Machine Learning from Disaster |
13,873,876 | X = train.drop(["ID_code", "target"], axis=1)
Y = train["target"]
X_test = test_df.drop(["ID_code"], axis=1 )<categorify> | print(df1.nunique())
print(df2.nunique() ) | Titanic - Machine Learning from Disaster |
13,873,876 | def augment(x,y,t=2):
xs,xn = [],[]
for i in range(t):
mask = y>0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
np.random.shuffle(ids)
x1[:,c] = x1[ids][:,c]
xs.append(x1)
for i in range(t//2):
mask = y==0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
... | df1.drop(['PassengerId','Name','Ticket'],axis=1,inplace=True)
df2.drop(['Name','Ticket'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
13,873,876 | n_fold = 15
folds = StratifiedKFold(n_splits=n_fold, shuffle=True, random_state=42 )<init_hyperparams> | print(df1.isnull().sum())
print(( df1.isnull().sum() /len(df1)) *100 ) | Titanic - Machine Learning from Disaster |
13,873,876 | params = {'num_leaves': 13,
'min_data_in_leaf': 80,
'min_sum_hessian_in_leaf': 10.0,
'objective': 'binary',
'boost_from_average': False,
'max_depth': -1,
'learning_rate': 0.0083,
'boost': 'gbdt',
'bagging_freq': 5,
'tree_learner': "serial",
'bagging_fraction': 0.335,
'feature_fraction': 0.041,
'metric': 'auc',
'num_thr... | df1.drop(['Cabin'],axis=1,inplace=True)
df2.drop(['Cabin'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
13,873,876 | prediction = np.zeros(len(X_test))
oof = np.zeros(len(X))
for fold_n,(train_index, valid_index)in enumerate(folds.split(X,Y)) :
print('Fold', fold_n, 'started at', time.ctime())
X_train, X_valid = X.iloc[train_index], X.iloc[valid_index]
y_train, y_valid = Y.iloc[train_index], Y.iloc[valid_index]
X_tr, y_tr = augment(... | df1.isnull().sum() | Titanic - Machine Learning from Disaster |
13,873,876 | sub = pd.DataFrame({"ID_code": test_df.ID_code.values})
sub["target"] = prediction
sub.to_csv("submission.csv", index=False )<load_from_csv> | df1['Age']=df1['Age'].fillna(method='ffill')
df1['Embarked']=df1['Embarked'].fillna(method='ffill')
df2['Age']=df1['Age'].fillna(method='ffill')
df2['Embarked']=df1['Embarked'].fillna(method='ffill' ) | Titanic - Machine Learning from Disaster |
13,873,876 | df_train=pd.read_csv('.. /input/train.csv' )<load_from_csv> | df2['Fare']=df1['Fare'].fillna(method='ffill' ) | Titanic - Machine Learning from Disaster |
13,873,876 | df_test=pd.read_csv('.. /input/test.csv' )<data_type_conversions> | print(df1.isnull().sum())
print(df2.isnull().sum() ) | Titanic - Machine Learning from Disaster |
13,873,876 | def memory_usage(df):
numerics = ['int8', 'int16', 'int32', 'int64', 'float16', 'float32', 'float64']
for col in df.columns:
if str(df[col].dtype)in numerics:
if str(df[col].dtype)[:3] == 'int':
if(( df[col].min() > np.iinfo(np.int8 ).min)and(df[col].max() < np.iinfo(np.int8 ).max)) :
df[col] = df[col].astype('int8')
... | df11=pd.get_dummies(data=df1,columns=['Sex','Embarked'],drop_first=True)
df12=pd.get_dummies(data=df2,columns=['Sex','Embarked'],drop_first=True ) | 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.