kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
8,262,215 | for f in train_all.columns[0:200]:
train_all[f+'duplicate_value'] = train_all[f]*train_all[f+'_duplicate']<split> | random_forest = RandomForestClassifier()
random_forest.fit(x_train, y_train)
y_pred_random_forest = random_forest.predict(x_test)
random_forest_accuracy = round(random_forest.score(x_train, y_train)*100, 2 ) | Titanic - Machine Learning from Disaster |
8,262,215 | train_features = train_all.iloc[:200000]
test_features = train_all.iloc[200000:400000]<set_options> | log_regres = LogisticRegression()
log_regres.fit(x_train, y_train)
y_pred_log_regres = log_regres.predict(x_test)
log_regres_accuracy = round(log_regres.score(x_train, y_train)*100, 2 ) | Titanic - Machine Learning from Disaster |
8,262,215 | del train_all
gc.collect()<split> | knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(x_train, y_train)
y_pred_knn = knn.predict(x_test)
knn_accuracy = round(knn.score(x_train, y_train)*100, 2 ) | Titanic - Machine Learning from Disaster |
8,262,215 | n_splits = 7
splits = list(StratifiedKFold(n_splits=n_splits, shuffle=True ).split(train_features, train_target))
splits[:3]<init_hyperparams> | gaussian = GaussianNB()
gaussian.fit(x_train, y_train)
y_pred_gaussian = gaussian.predict(x_test)
gaussian_accuracy = round(gaussian.score(x_train, y_train)*100, 2 ) | Titanic - Machine Learning from Disaster |
8,262,215 | cat_params = {
'learning_rate':0.01,
'max_depth':2,
'eval_metric': 'AUC',
'bootstrap_type': 'Bayesian',
'bagging_temperature': 1,
'objective': 'Logloss',
'od_type': 'Iter',
'l2_leaf_reg': 2,
'allow_writing_files': False}<prepare_x_and_y> | perceptron = Perceptron()
perceptron.fit(x_train, y_train)
y_pred_perceptron = perceptron.predict(x_test)
perceptron_accuracy = round(perceptron.score(x_train, y_train)*100, 2 ) | Titanic - Machine Learning from Disaster |
8,262,215 | oof_cb = np.zeros(len(train_features))
predictions_cb = np.zeros(len(test_features))
for i,(train_idx, valid_idx)in enumerate(splits):
print(f'Fold {i + 1}')
x_train = np.array(train_features)
y_train = np.array(train_target)
trn_x = x_train[train_idx.astype(int)]
trn_y = y_train[train_idx.astype(int)]
val_x = x_tra... | svc = LinearSVC()
svc.fit(x_train, y_train)
y_pred_svc = svc.predict(x_test)
svc_accuracy = round(svc.score(x_train, y_train)*100, 2 ) | Titanic - Machine Learning from Disaster |
8,262,215 | param = {
'bagging_freq': 5,
'bagging_fraction': 0.33,
'boost_from_average':'false',
'boost': 'gbdt',
'feature_fraction': 0.05,
'learning_rate': 0.01,
'max_depth': -1,
'metric':'auc',
'min_data_in_leaf': 80,
'min_sum_hessian_in_leaf': 10.0,
'num_leaves': 13,
'num_threads': 12,
'tree_learner': 'serial',
'objective': 'bi... | tree = DecisionTreeClassifier()
tree.fit(x_train, y_train)
y_pred_tree = tree.predict(x_train)
tree_accuracy = round(tree.score(x_train, y_train)*100, 2 ) | Titanic - Machine Learning from Disaster |
8,262,215 | oof = np.zeros(len(train_features))
predictions = np.zeros(len(test_features))
for i,(train_idx, valid_idx)in enumerate(splits):
print(f'Fold {i + 1}')
x_train = np.array(train_features)
y_train = np.array(train_target)
trn_data = lgb.Dataset(x_train[train_idx.astype(int)], label=y_train[train_idx.astype(int)])
val... | d_x_train = xgb.DMatrix(x_train, label=y_train ) | Titanic - Machine Learning from Disaster |
8,262,215 | esemble_lgbm_cat = 0.5*oof_cb+0.5*oof
print('LightBGM auc = {:<8.5f}'.format(roc_auc_score(train_target, oof)))
print('catboost auc = {:<8.5f}'.format(roc_auc_score(train_target, oof_cb)))
print('LightBGM+catboost auc = {:<8.5f}'.format(roc_auc_score(train_target, esemble_lgbm_cat)) )<define_variables> | param = {
'eta': 0.5,
'max_depth': 16,
'objective': 'multi:softprob',
'num_class': 3}
steps = 20 | Titanic - Machine Learning from Disaster |
8,262,215 | esemble_pred_lgbm_cat = 0.5*predictions+0.5*predictions_cb<define_variables> | xgb_model = xgb.train(param, d_x_train, steps)
y_pred_xgb = xgb_model.predict(d_x_train)
y_pred_xgb_new = np.asarray([np.argmax(line)for line in y_pred_xgb] ) | Titanic - Machine Learning from Disaster |
8,262,215 | id_code_test = test_df['ID_code']<create_dataframe> | xgb_model_accuracy = round(accuracy_score(y_train, y_pred_xgb_new)*100, 2 ) | Titanic - Machine Learning from Disaster |
8,262,215 | my_submission_lbgm = pd.DataFrame({"ID_code" : id_code_test, "target" : predictions})
my_submission_cat = pd.DataFrame({"ID_code" : id_code_test, "target" : predictions_cb})
my_submission_esemble_lgbm_cat = pd.DataFrame({"ID_code" : id_code_test, "target" : esemble_pred_lgbm_cat} )<save_to_csv> | rf = RandomForestClassifier()
scores = cross_val_score(rf, x_train, y_train, cv=10, scoring='accuracy')
print("Scores:", scores)
print("Mean:", scores.mean())
print("Standard Deviation:", scores.std() ) | Titanic - Machine Learning from Disaster |
8,262,215 | my_submission_lbgm.to_csv('submission_lbgm.csv', index = False, header = True)
my_submission_cat.to_csv('submission_cb.csv', index = False, header = True)
my_submission_esemble_lgbm_cat.to_csv('my_submission_esemble_lgbm_cat.csv', index = False, header = True )<set_options> | for i in range(23, importances_df.shape[0]):
column = importances_df['Feature'][i]
df_combined.drop([column], inplace=True, axis=1)
df_combined.head() | Titanic - Machine Learning from Disaster |
8,262,215 | %matplotlib inline
print(os.listdir(".. /input"))
<load_from_csv> | x_train = df_combined[:891].copy()
x_test = df_combined[891:].copy()
x_test.reset_index(inplace=True, drop=True ) | Titanic - Machine Learning from Disaster |
8,262,215 | train = pd.read_csv(r'.. /input/train.csv',low_memory=True,index_col='ID_code')
print(train.head(1))
train=reduce_mem_usage(train )<drop_column> | random_forest = RandomForestClassifier()
random_forest.fit(x_train, y_train)
y_prediction = random_forest.predict(x_test)
accuracy_random_forest = round(random_forest.score(x_train, y_train)*100, 2)
print("The accuracy after removing least important Features is {}, which is same as before removing.".format(accuracy_... | Titanic - Machine Learning from Disaster |
8,262,215 | train.replace(np.nan,0,inplace=True)
<load_from_csv> | tree = DecisionTreeClassifier()
tree.fit(x_train, y_train)
y_pred_tree = tree.predict(x_test)
tree_accuracy = round(tree.score(x_train, y_train)*100, 2)
print("The accuracy after removing least important Features is {}, which is same as before removing.".format(tree_accuracy)) | Titanic - Machine Learning from Disaster |
8,262,215 | test = pd.read_csv(r'.. /input/test.csv',low_memory=True,index_col='ID_code')
test=reduce_mem_usage(test )<drop_column> | d_x_train = xgb.DMatrix(x_train, label=y_train)
d_x_test = xgb.DMatrix(x_test ) | Titanic - Machine Learning from Disaster |
8,262,215 | train = reduce_mem_usage(train )<choose_model_class> | xgb_model = xgb.train(param, d_x_train, steps)
y_pred_xgb = xgb_model.predict(d_x_test)
y_pred_xgb_new = np.asarray([np.argmax(line)for line in y_pred_xgb])
| Titanic - Machine Learning from Disaster |
8,262,215 | <init_hyperparams><EOS> | output = pd.DataFrame({'PassengerID': test_data.PassengerId,'Survived':y_pred_xgb_new})
output.to_csv("my_submission.csv", index=False)
print("Submission successfully saved!!!" ) | Titanic - Machine Learning from Disaster |
6,232,601 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<create_dataframe> | %matplotlib inline | Titanic - Machine Learning from Disaster |
6,232,601 | oof_preds = np.zeros(train.shape[0])
sub_preds = np.zeros(len(test))
feature_importance_df = pd.DataFrame()
feats = [f for f in train.columns if f not in ['target']]
for n_fold,(train_idx, valid_idx)in enumerate(kf.split(train[feats], train['target'])) :
print(n_fold)
trn_data = lgb.Dataset(train.iloc[train_idx][feat... | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
6,232,601 |
<set_options> | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
IDtest = test["PassengerId"] | Titanic - Machine Learning from Disaster |
6,232,601 | del train
gc.collect()<import_modules> | dataset = pd.concat(objs=[train, test], axis=0 ).reset_index(drop=True)
len(dataset ) | Titanic - Machine Learning from Disaster |
6,232,601 |
<save_to_csv> | train_len = len(train ) | Titanic - Machine Learning from Disaster |
6,232,601 | output_xgb=pd.DataFrame({'ID_code':test.index,'target':sub_preds})
output_xgb.to_csv(r'predictions.csv',index=False )<set_options> | dataset.isnull().sum() | Titanic - Machine Learning from Disaster |
6,232,601 | sns.set(font_scale=1)
warnings.simplefilter(action='ignore', category=FutureWarning)
warnings.filterwarnings('ignore' )<load_from_csv> | sex_survived = pd.DataFrame(columns=['Total', 'Survived', 'Survived Ratio'])
sex_survived['Total'] = train['Sex'].value_counts()
sex_survived['Survived'] = train[train['Survived']==1].groupby(['Sex'] ).apply(lambda x: x.shape[0])
sex_survived['Survived Ratio'] = sex_survived['Survived'] / sex_survived['Total']
sex_su... | Titanic - Machine Learning from Disaster |
6,232,601 | random_state = 42
np.random.seed(random_state)
train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' )<normalization> | dataset['Sex'] = dataset['Sex'].map(lambda s: 1 if s == 'male' else 0 ) | Titanic - Machine Learning from Disaster |
6,232,601 | 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]):
... | dataset['Age'][dataset['Age'].isnull() == True] = dataset[dataset['Age'].isnull() == False].median() [0] | Titanic - Machine Learning from Disaster |
6,232,601 | lgb_params = {
"objective" : "binary",
"metric" : "auc",
"boosting": 'gbdt',
"max_depth" : -1,
"num_leaves" : 31,
"learning_rate" : 0.01,
"bagging_freq": 5,
"bagging_fraction" : 0.4,
"feature_fraction" : 0.05,
"min_data_in_leaf": 150,
"min_sum_heassian_in_leaf": 10,
"tree_learner": "serial",
"boost_from_average": "fals... | dataset['AgeGroup'] = None
dataset.loc[(( dataset['Sex'] == 1)&(dataset['Age'] <= 15)) , 'AgeGroup'] = 'boy'
dataset.loc[(( dataset['Sex'] == 0)&(dataset['Age'] <= 15)) , 'AgeGroup'] = 'girl'
dataset.loc[(( dataset['Sex'] == 1)&(dataset['Age'] > 15)) , 'AgeGroup'] = 'adult male'
dataset.loc[(( dataset['Sex'] == 0)&(dat... | Titanic - Machine Learning from Disaster |
6,232,601 | skf = StratifiedKFold(n_splits=7, shuffle=True, random_state=random_state)
oof = train[['ID_code', 'target']]
oof['predict'] = 0
predictions = test[['ID_code']]
val_aucs = []
feature_importance = pd.DataFrame()<prepare_x_and_y> | pd.DataFrame(dataset[['AgeGroup', 'Survived']]
.groupby(['AgeGroup', 'Survived'])
.apply(lambda x: x.shape[0]),
columns=['Count'] ) | Titanic - Machine Learning from Disaster |
6,232,601 | features = [col for col in train.columns if col not in ['target', 'ID_code']]
X_test = test[features].values<split> | dataset['AgeGroup'] = dataset['AgeGroup'].map({'boy': 0, 'girl': 1, 'adult male': 2, 'adult female': 3})
dataset['AgeGroup'] = dataset['AgeGroup'].astype(int ) | Titanic - Machine Learning from Disaster |
6,232,601 | for fold,(trn_idx, val_idx)in enumerate(skf.split(train, train['target'])) :
X_train, y_train = train.iloc[trn_idx][features], train.iloc[trn_idx]['target']
X_valid, y_valid = train.iloc[val_idx][features], train.iloc[val_idx]['target']
N = 3
p_valid,yp = 0,0
for i in range(N):
X_t, y_t = augment(X_train.values, y_trai... | pd.DataFrame(dataset[['Pclass', 'Survived', 'Sex']]
.groupby(['Pclass', 'Sex', 'Survived'])
.apply(lambda x: x.shape[0]),
columns=['Count'] ) | Titanic - Machine Learning from Disaster |
6,232,601 | predictions['target'] = np.mean(predictions[[col for col in predictions.columns if col not in ['ID_code', 'target']]].values, axis=1)
predictions.to_csv('lgb_all_predictions.csv', index=None)
sub = pd.DataFrame({"ID_code":test["ID_code"].values})
sub["target"] = predictions['target']
sub.to_csv("lgb_submission.csv",... | dataset[dataset['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
6,232,601 | print(os.listdir(".. /input"))
<load_from_csv> | embarked_survived = pd.DataFrame(dataset[['Embarked', 'Survived']]
.groupby(['Embarked', 'Survived'])
.apply(lambda x: x.shape[0]), columns=['count'] ).reset_index()
embarked_survived_pivot = embarked_survived.pivot(index='Embarked', columns='Survived', values='count')
embarked_survived_pivot | Titanic - Machine Learning from Disaster |
6,232,601 | test_data = pd.read_csv(".. /input/test.csv")
train_data= pd.read_csv(".. /input/train.csv")
train_data.head()<define_variables> | train['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
6,232,601 | count_0 = len(train_data[train_data["target"] == 0])
count_1 = len(train_data[train_data["target"] == 1])
percentage_count_0 =(( count_0)/(count_0+count_1)) * 100
percentage_count_1 = 100-percentage_count_0
print("{}{}{}{}{}".format("Percentage of 0 class is ",percentage_count_0,"
","Percentage of 1 class is ",percen... | dataset['Embarked'] = dataset['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ) | Titanic - Machine Learning from Disaster |
6,232,601 | labels = train_data["target"]
new_train_data = train_data.drop(["target","ID_code"],axis =1)
new_train_data.head()
x_train, x_test, y_train, y_test = train_test_split(new_train_data, labels, test_size = 0.25, random_state = 0)
print(x_train.shape,x_test.shape)
print(y_train.shape,y_test.shape)
x_train.head()<choose... | dataset['Embarked'].fillna(dataset['Embarked'].mode() [0], inplace=True ) | Titanic - Machine Learning from Disaster |
6,232,601 | folds = StratifiedKFold(n_splits=10, shuffle=False, random_state=2319)
param = {
'bagging_freq': 5,
'bagging_fraction': 0.33,
'boost_from_average':'false',
'boost': 'gbdt',
'feature_fraction': 0.0405,
'learning_rate': 0.083,
'max_depth': -1,
'metric':'auc',
'min_data_in_leaf': 80,
'min_sum_hessian_in_leaf': 10.0,
'num... | dataset['Embarked'] = dataset['Embarked'].astype('int' ) | Titanic - Machine Learning from Disaster |
6,232,601 | target = train_data.iloc[val_idx]['target']
print("
>> CV score: {:<8.5f}".format(roc_auc_score(target, oof[val_idx])))
<save_to_csv> | dataset['Embarked'].isnull().sum() | Titanic - Machine Learning from Disaster |
6,232,601 | ID_code = test_data["ID_code"]
submission = pd.DataFrame({'ID_code' : ID_code,
'target' : predictions})
submission.to_csv('./version1.csv', index=False)
sub = pd.read_csv('./version1.csv')
sub.head()<install_modules> | dataset['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
6,232,601 | !pip install target_encoding
<categorify> | dataset[dataset['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
6,232,601 | X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
enc = TargetEncoder()
new_X_train = enc.transform_train(X=X_train, y=y_train)
new_X_test = enc.transform_test(X_test)
rf = RandomForestClassifier(n_estimators=100, random_state=42)
r... | old_man_nan_fare_idx = dataset[dataset['Fare'].isnull() ].index
old_man_nan_fare_idx | Titanic - Machine Learning from Disaster |
6,232,601 | train=pd.read_csv(".. /input/train.csv" ).drop("ID_code",axis=1)
test=pd.read_csv(".. /input/test.csv" ).drop("ID_code",axis=1)
X = train.drop('target', axis=1)
y = train.target
sample_submission = pd.read_csv('.. /input/sample_submission.csv')
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42 )<comput... | dataset[dataset['Pclass'] == 3][dataset['Cabin'].isnull() ][dataset['Age'] < 20]['Fare'].mean() | Titanic - Machine Learning from Disaster |
6,232,601 | enc = TargetEncoderClassifier(alpha=100, max_unique=25, used_features=170)
score = cross_val_score(enc, X, y, scoring='roc_auc', cv=cv)
print(score.mean() , score.std() )<categorify> | mean_old_pclass3 = dataset[dataset['Pclass'] == 3][dataset['Cabin'].isnull() ][dataset['Age'] > 50]['Fare'].mean()
mean_old_pclass3 | Titanic - Machine Learning from Disaster |
6,232,601 | enc = TargetEncoderClassifier(alpha=100, max_unique=25, used_features=170)
enc.fit(X, y)
pred = enc.predict_proba(test)[:,1]<save_to_csv> | dataset.loc[old_man_nan_fare_idx, 'Fare'] = mean_old_pclass3 | Titanic - Machine Learning from Disaster |
6,232,601 | sample_submission['target'] = pred
sample_submission.to_csv('submission.csv', index=False )<load_from_csv> | dataset.iloc[old_man_nan_fare_idx] | Titanic - Machine Learning from Disaster |
6,232,601 | train_data = pd.read_csv(".. /input/train.csv")
test_data = pd.read_csv(".. /input/test.csv")
sample_data = pd.read_csv(".. /input/sample_submission.csv" )<prepare_x_and_y> | np.exp(2.3), np.exp(2.9), np.exp(3.5 ) | Titanic - Machine Learning from Disaster |
6,232,601 | oof = train_data[["ID_code","target"]]
oof['predict'] = 0
prediction = test_data['ID_code']
label_df = train_data['target']<choose_model_class> | dataset.loc[ dataset['Fare'] < 9.974, 'FareBin'] = 0
dataset.loc[(dataset['Fare'] >= 9.974)&(dataset['Fare'] <= 18.174), 'FareBin'] = 1
dataset.loc[(dataset['Fare'] > 18.174)&(dataset['Fare'] <= 33.115), 'FareBin'] = 2
dataset.loc[ dataset['Fare'] > 33.115, 'FareBin'] = 3
dataset['FareBin'] = dataset['FareBin'].astype(... | Titanic - Machine Learning from Disaster |
6,232,601 | skf_three= StratifiedKFold(n_splits=15, shuffle=True, random_state=2319 )<init_hyperparams> | dataset['Cabin'].value_counts() | Titanic - Machine Learning from Disaster |
6,232,601 | random_state = 42
np.random.seed(random_state)
params = {
"objective" : "binary", "metric" : "auc", "boosting": 'gbdt', "max_depth" : -1, "num_leaves" : 13,
"learning_rate" : 0.01, "bagging_freq": 0.5, "bagging_fraction" : 0.4, "feature_fraction" : 0.05,
"min_data_in_leaf": 80, "min_sum_heassian_in_leaf": 10, 'num_lea... | dataset['CabinType'] = dataset['Cabin'].apply(lambda x: str(x)[0].upper() if type(x)== str else 'None' ) | Titanic - Machine Learning from Disaster |
6,232,601 | random_state = 42
np.random.seed(random_state)
lgb_params = {
"objective" : "binary",
"metric" : "auc",
"boosting": 'gbdt',
"max_depth" : -1,
"num_leaves" : 13,
"learning_rate" : 0.01,
"bagging_freq": 5,
"bagging_fraction" : 0.4,
"feature_fraction" : 0.05,
"min_data_in_leaf": 80,
"min_sum_heassian_in_leaf": 10,
"tree_... | dataset[dataset['CabinType'] == 'T'] | Titanic - Machine Learning from Disaster |
6,232,601 | random_state = 42
np.random.seed(random_state)
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.ar... | t_idx = dataset[dataset['CabinType'] == 'T'].index
dataset.loc[t_idx, 'CabinType'] = 'None' | Titanic - Machine Learning from Disaster |
6,232,601 | def augmen(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]):
n... | dataset.iloc[t_idx] | Titanic - Machine Learning from Disaster |
6,232,601 | skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=random_state)
oof = train[['ID_code', 'target']]
oof['predict'] = 0
predictions = test[['ID_code']]
val_aucs = []
feature_importance_df = pd.DataFrame()
features = [col for col in train.columns if col not in ['target', 'ID_code']]
X_test = test[features].val... | survival_rate_with_cabin = 100 * train[train['Cabin'].isnull() == False]['Survived'].value_counts() [1] / \
train[train['Cabin'].isnull() == False]['Survived'].shape[0]
survival_rate_without_cabin = 100 * train[train['Cabin'].isnull() == True]['Survived'].value_counts() [1] / \
train[train['Cabin'].isnull() == True]['S... | Titanic - Machine Learning from Disaster |
6,232,601 | predictions['target'] = np.mean(predictions[[col for col in predictions.columns if col not in ['ID_code', 'target']]].values, axis=1)
predictions.to_csv('lgb_all_predictions.csv', index=None)
sub_df = pd.DataFrame({"ID_code":test["ID_code"].values})
sub_df["target"] = predictions['target']
sub_df.to_csv("lgb_submiss... | cabin_mapping = {"None": 0, "A": 1, "B": 2, "C": 3, "D": 4, "E": 5, "F": 6, "G": 7}
dataset['CabinType'] = dataset['CabinType'].map(cabin_mapping ) | Titanic - Machine Learning from Disaster |
6,232,601 | skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=random_state)
val_aucs = []
features = [col for col in train_data.columns if col not in ['target', 'ID_code']]
X_test = test_data[features].values
for fold,(trn_idx, val_idx)in enumerate(skf.split(train_data, label_df)) :
X_train, y_train = train_data.iloc[t... | dataset['CabinType'].value_counts() | Titanic - Machine Learning from Disaster |
6,232,601 | submission = pd.DataFrame({"ID_code":ID_code,"target":yp/N})
submission.to_csv("lgb_submission.csv", index=False)
submission1 = pd.DataFrame({"ID_code":ID_code,"target":yp/N*0.4+predictions['target']*0.6})
submission1.to_csv("lgb_submission1.csv", index=False)
submission2 = pd.DataFrame({"ID_code":ID_code,"target":... | def get_title(name):
title_search = re.search(r'([A-Za-z]+)\.', name)
if title_search:
return title_search.group(1)
return ''
dataset['Title'] = dataset['Name'].apply(get_title ) | Titanic - Machine Learning from Disaster |
6,232,601 | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv' )<load_from_csv> | dataset['Title'].value_counts() | Titanic - Machine Learning from Disaster |
6,232,601 | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv' )<merge> | def replace_titles(title):
if title in ['Lady', 'Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona']:
return 'Rare'
elif title in ['Countess', 'Mme']:
return 'Mrs'
elif title in ['Mlle', 'Ms']:
return 'Miss'
elif title =='Dr':
if x['Sex']=='Male':
return 'Mr'
else:
return 'Mrs'
else:
return ... | Titanic - Machine Learning from Disaster |
6,232,601 | def transform(df, var='var_12'):
df['random_{}'.format(var)] = np.random.normal(df[var].mean() , df[var].std() , 200000 ).round(4)
var_counts = pd.DataFrame(df.groupby(var)['ID_code'].count() ).reset_index()
var_counts_random = pd.DataFrame(df.groupby('random_{}'.format(var)) ['ID_code'].count() ).reset_index()
merged... | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
dataset['Title'] = dataset['Title'].map(title_mapping ) | Titanic - Machine Learning from Disaster |
6,232,601 | for var in tqdm(['var_{}'.format(x)for x in range(0, 200)]):
train_df = transform(train_df, var=var)
test_df = transform(test_df, var=var )<choose_model_class> | dataset['Noble'] = dataset['Name'].apply(lambda x: 1 if re.search(r'\ (.*?\)', x)else 0 ) | Titanic - Machine Learning from Disaster |
6,232,601 | random_state = 42
params = {
"objective" : "binary", "metric" : "auc", "boosting": 'gbdt', "max_depth" : -1, "num_leaves" : 13,
"learning_rate" : 0.01, "bagging_freq": 5, "bagging_fraction" : 0.4, "feature_fraction" : 0.05,
"min_data_in_leaf": 80, "min_sum_heassian_in_leaf": 10, "tree_learner": "serial", "boost_from_av... | dataset[:train_len][['Noble', 'Survived']].groupby(['Noble'] ).sum() | Titanic - Machine Learning from Disaster |
6,232,601 | df=pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/train.csv" )<filter> | dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1 | Titanic - Machine Learning from Disaster |
6,232,601 | df.skew().index[df.skew().values>1]<filter> | dataset.loc[ dataset['FamilySize'] == 1, 'FamilySizeBin'] = 0
dataset.loc[(dataset['FamilySize'] >= 2)&(dataset['FamilySize'] <= 3), 'FamilySizeBin'] = 1
dataset.loc[(dataset['FamilySize'] == 4), 'FamilySizeBin'] = 2
dataset.loc[(dataset['FamilySize'] >= 5)&(dataset['FamilySize'] <= 7), 'FamilySizeBin'] = 3
dataset.loc... | Titanic - Machine Learning from Disaster |
6,232,601 | outlier_cols=df.skew().index[df.skew().values>1]<count_missing_values> | dataset['FamilySizeBin'] = dataset['FamilySizeBin'].astype('int' ) | Titanic - Machine Learning from Disaster |
6,232,601 | df.isnull().sum().index[df.isnull().sum().values>0]<create_dataframe> | dataset['IsAlone'] = dataset['FamilySize'].map(lambda s: 1 if s == 1 else 0 ) | Titanic - Machine Learning from Disaster |
6,232,601 | df_copy=df.copy()<data_type_conversions> | dataset['LastName'] = dataset.Name.str.split(',' ).str[0] | Titanic - Machine Learning from Disaster |
6,232,601 | cat_columns=df_copy.select_dtypes(include=['O','object'] ).columns
for cols in cat_columns:
df_copy[cols].fillna(df_copy[cols].mode() [0],inplace=True )<data_type_conversions> | le = LabelEncoder()
dataset['LastName'] = le.fit_transform(dataset['LastName'])
dataset['LastName'] = dataset['LastName'].astype(int ) | Titanic - Machine Learning from Disaster |
6,232,601 | num_columns=df_copy.select_dtypes(exclude=['O','object'] ).columns
for cols in num_columns:
if cols in outlier_cols:
df_copy[cols].fillna(df_copy[cols].median() ,inplace=True)
else:
df_copy[cols].fillna(df_copy[cols].mean() ,inplace=True )<count_missing_values> | dataset.drop(labels=['Fare', 'Cabin', 'FamilySize', 'PassengerId', 'Ticket', 'Age', 'Name'],
axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
6,232,601 | df_copy.isnull().sum().index[df_copy.isnull().sum().values>0]<set_options> | dataset = pd.get_dummies(dataset, columns = ["Embarked"])
dataset = pd.get_dummies(dataset, columns = ["Parch"])
dataset = pd.get_dummies(dataset, columns = ["Pclass"])
dataset = pd.get_dummies(dataset, columns = ["CabinType"])
dataset = pd.get_dummies(dataset, columns = ["Title"])
dataset = pd.get_dummies(dataset... | Titanic - Machine Learning from Disaster |
6,232,601 | fig=px.box(df_copy['LotArea'])
fig.show("notebook" )<sort_values> | train = dataset[:len(train)]
test = dataset[len(train):]
test.drop(labels=["Survived"],axis = 1,inplace=True ) | Titanic - Machine Learning from Disaster |
6,232,601 | df_copy.corr() ['SalePrice'].sort_values()<prepare_x_and_y> | X_train = train.drop(labels = ["Survived"],axis = 1)
y_train = train["Survived"].astype(int ) | Titanic - Machine Learning from Disaster |
6,232,601 | X=df_copy.copy()
X.drop(["SalePrice","Id"],axis=1,inplace=True)
y=df_copy['SalePrice']<compute_test_metric> | from sklearn.model_selection import cross_val_score
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
6,232,601 | y = np.log1p(y )<define_variables> | gbdt = GradientBoostingClassifier(learning_rate=0.02, min_samples_split=6, min_samples_leaf=4)
cross_val_score(gbdt, X_train, y_train, cv=10 ).mean() | Titanic - Machine Learning from Disaster |
6,232,601 | num_train_columns=['MSSubClass', 'LotFrontage', 'LotArea', 'OverallQual',
'OverallCond', 'YearBuilt', 'YearRemodAdd', 'MasVnrArea', 'BsmtFinSF1',
'BsmtFinSF2', 'BsmtUnfSF', 'TotalBsmtSF', '1stFlrSF', '2ndFlrSF',
'LowQualFinSF', 'GrLivArea', 'BsmtFullBath', 'BsmtHalfBath', 'FullBath',
'HalfBath', 'BedroomAbvGr', 'Kitche... | model = GradientBoostingClassifier(learning_rate=0.02, min_samples_split=6, min_samples_leaf=4 ) | Titanic - Machine Learning from Disaster |
6,232,601 | qt=QuantileTransformer(output_distribution='normal',random_state=0)
X_num_transformed=qt.fit_transform(X[num_train_columns])
<create_dataframe> | model.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
6,232,601 | df_num_transformed=pd.DataFrame(X_num_transformed.reshape(-1,36),columns=X[num_train_columns].columns )<normalization> | model.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
6,232,601 | rs=RobustScaler()
X_num_transformed=rs.fit_transform(df_num_transformed )<create_dataframe> | test_Survived = pd.Series(model.predict(test), name="Survived")
results = pd.concat([IDtest, test_Survived], axis=1)
results.to_csv("titanic_with_ensemble.csv",index=False ) | Titanic - Machine Learning from Disaster |
6,232,601 | df_num_transformed=pd.DataFrame(X_num_transformed.reshape(-1,36),columns=X[num_train_columns].columns )<concatenate> | dataset.iloc[old_man_nan_fare_idx] | Titanic - Machine Learning from Disaster |
6,232,601 | X_transformed= pd.concat([df_num_transformed,X[cat_columns]],axis=1 )<categorify> | model.predict(dataset.iloc[old_man_nan_fare_idx].drop(['Survived'], axis=1)) | Titanic - Machine Learning from Disaster |
6,232,601 |
<set_options> | dataset.loc[train_len:, 'Survived'] = model.predict(dataset[train_len:].drop(['Survived'], axis=1)) | Titanic - Machine Learning from Disaster |
6,232,601 | <import_modules><EOS> | survived_corr = pd.DataFrame(dataset.corr() ['Survived'].drop('Survived'))
survived_corr_most = survived_corr[
(survived_corr['Survived'] > 0.1)|(survived_corr['Survived'] < -0.1)]\
.sort_values(['Survived'], ascending=True ) | Titanic - Machine Learning from Disaster |
6,168,266 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_on_grid> | traindf = pd.read_csv('.. /input/titanic/train.csv' ).set_index('PassengerId')
testdf = pd.read_csv('.. /input/titanic/test.csv' ).set_index('PassengerId')
df = pd.concat([traindf, testdf], axis=0, sort=False)
df['Title'] = df.Name.str.split(',' ).str[1].str.split('.' ).str[0].str.strip()
df['IsWomanOrBoy'] =(( df.T... | Titanic - Machine Learning from Disaster |
6,168,266 |
<categorify> | print(__doc__)
warnings.filterwarnings("ignore")
np.random.seed(0 ) | Titanic - Machine Learning from Disaster |
6,168,266 |
<create_dataframe> | df['Title'] = df['Title'].replace('Ms','Miss')
df['Title'] = df['Title'].replace('Mlle','Miss')
df['Title'] = df['Title'].replace('Mme','Mrs' ) | Titanic - Machine Learning from Disaster |
6,168,266 |
<categorify> | df['Embarked'] = df['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
6,168,266 |
<train_on_grid> | med_fare = df.groupby(['Pclass', 'Parch', 'SibSp'] ).Fare.median() [3][0][0]
df['Fare'] = df['Fare'].fillna(med_fare ) | Titanic - Machine Learning from Disaster |
6,168,266 |
<install_modules> | df['Deck'] = df['Cabin'].apply(lambda s: s[0] if pd.notnull(s)else 'M')
df.loc[(df['Deck'] == 'T'), 'Deck'] = 'A' | Titanic - Machine Learning from Disaster |
6,168,266 | !pip install catboost<choose_model_class> | df['Age'] = df.groupby(['Sex', 'Pclass', 'Title'])['Age'].apply(lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
6,168,266 | cat=CatBoostRegressor(random_state=123,cat_features= cat_columns)
<import_modules> | df['Family_Size'] = df['SibSp'] + df['Parch'] + 1 | Titanic - Machine Learning from Disaster |
6,168,266 | from skopt.space import Real, Categorical, Integer
from skopt import BayesSearchCV<choose_model_class> | pd.set_option('max_columns',100)
traindf.head(3 ) | Titanic - Machine Learning from Disaster |
6,168,266 | search_spaces = {'iterations': Integer(100, 2000),
'depth': Integer(1, 8),
'learning_rate': Real(0.01, 1.0, 'log-uniform'),
'random_strength': Real(1e-9, 10, 'log-uniform'),
'bagging_temperature': Real(0.0, 1.0),
'border_count': Integer(1, 255),
'l2_leaf_reg': Integer(2, 40)}
tuned_cat=BayesSearchCV(cat,search_spaces,c... | df.WomanOrBoySurvived = df.WomanOrBoySurvived.fillna(0)
df.WomanOrBoyCount = df.WomanOrBoyCount.fillna(0)
df.FamilySurvivedCount = df.FamilySurvivedCount.fillna(0)
df.Alone = df.Alone.fillna(0 ) | Titanic - Machine Learning from Disaster |
6,168,266 | tuned_cat.best_params_<train_model> | train_y = df.Survived.loc[traindf.index] | Titanic - Machine Learning from Disaster |
6,168,266 | embeded_cat_selector = SelectFromModel(tuned_cat.best_estimator_, max_features=X_transformed.shape[1])
embeded_cat_selector.fit(X_transformed, y )<features_selection> | cols_to_drop = ['Name','Ticket','Cabin','Survived']
df = df.drop(cols_to_drop, axis=1 ) | Titanic - Machine Learning from Disaster |
6,168,266 | embeded_cat_support = embeded_cat_selector.get_support()
embeded_cat_feature = X_transformed.loc[:,embeded_cat_support].columns.tolist()
print(str(len(embeded_cat_feature)) , 'selected features' )<define_variables> | numerics = ['int8', 'int16', 'int32', 'int64', 'float16', 'float32', 'float64']
categorical_columns = []
features = df.columns.values.tolist()
for col in features:
if df[col].dtype in numerics: continue
categorical_columns.append(col)
categorical_columns | Titanic - Machine Learning from Disaster |
6,168,266 | reduced_features_catboost=embeded_cat_feature<create_dataframe> | for col in categorical_columns:
if col in df.columns:
le = LabelEncoder()
le.fit(list(df[col].astype(str ).values))
df[col] = le.transform(list(df[col].astype(str ).values)) | Titanic - Machine Learning from Disaster |
6,168,266 | cat_importance_features=pd.DataFrame(zip(tuned_cat.best_estimator_.feature_importances_,X_transformed.columns), columns=['Value','Feature'])
cat_importance_features[cat_importance_features['Value']>0].shape[0]<filter> | train_x_all, test_x_all = df.loc[traindf.index], df.loc[testdf.index]
train_x_all.head(3 ) | Titanic - Machine Learning from Disaster |
6,168,266 | X_catboost_reduced=X_transformed[embeded_cat_feature]<choose_model_class> | limit_opt = 0.7 | Titanic - Machine Learning from Disaster |
6,168,266 | cat=CatBoostRegressor(random_state=123,cat_features= catboost_cat_columns)
search_spaces = {'iterations': Integer(100, 2000),
'depth': Integer(1, 8),
'learning_rate': Real(0.01, 1.0, 'log-uniform'),
'random_strength': Real(1e-9, 10, 'log-uniform'),
'bagging_temperature': Real(0.0, 1.0),
'border_count': Integer(1, 255)... | n_clusters_opt = 3
default_base = {'quantile':.2,
'eps':.3,
'damping':.9,
'preference': -200,
'n_neighbors': 10,
'n_clusters': n_clusters_opt,
'min_samples': 3,
'xi': 0.05,
'min_cluster_size': 0.05} | Titanic - Machine Learning from Disaster |
6,168,266 | tuned_cat.best_score_<find_best_params> | feature_first = 'WomanOrBoySurvived'
clustered_features = ['Pclass', 'Sex', 'Age', 'Fare', 'Embarked', 'Title', 'WomanOrBoyCount', 'Alone', 'Deck', 'Family_Size'] | 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.