kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
1,388,734 | test['fare'] = test['fare'].fillna(test['fare'].mean() )<count_missing_values> | prediction = model3.predict(test)
submission = pd.DataFrame({
"PassengerId": test_id,
"Survived": prediction
} ) | Titanic - Machine Learning from Disaster |
1,388,734 | test.isnull().sum()<count_missing_values> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
1,388,734 | <categorify><EOS> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,378,744 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<concatenate> | %matplotlib inline
warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
11,378,744 | final_test = pd.concat([test,sex,pclass,embarked],axis = 1)
final_test.head()<drop_column> | train_df = pd.read_csv('.. /input/titanic/train.csv',index_col='PassengerId')
test_df = pd.read_csv('.. /input/titanic/test.csv',index_col='PassengerId' ) | Titanic - Machine Learning from Disaster |
11,378,744 | final_test = final_test.drop(['sex','embarked','pclass'],axis = 1)
final_test.head()<rename_columns> | df1 = train_df.copy() | Titanic - Machine Learning from Disaster |
11,378,744 | final_test.columns = ['age','sibsp','parch','fare','sex_male','pclass_2','pclass_3','embarked_q','embarked_s']
final_test.head()<prepare_x_and_y> | df2 = df1.dropna(subset=['Embarked'] ) | Titanic - Machine Learning from Disaster |
11,378,744 | X_train = final_train.drop('survived',axis=1)
y_train = final_train['survived']<prepare_x_and_y> | df3 = df2.drop('Cabin',axis=1 ) | Titanic - Machine Learning from Disaster |
11,378,744 | X_test = final_test<import_modules> | df3['Title'] = df3['Name'].str.replace(r' (.*,)|(\.. *)','' ) | Titanic - Machine Learning from Disaster |
11,378,744 | from sklearn.preprocessing import StandardScaler<normalization> | df4 = df3.drop(['Name','Ticket'],axis=1 ) | Titanic - Machine Learning from Disaster |
11,378,744 | scaler = StandardScaler()<normalization> | cat_col = ['Pclass','Sex','Embarked','Title']
num_col = ['Age','SibSp','Parch','Fare'] | Titanic - Machine Learning from Disaster |
11,378,744 | scaled_X_train = scaler.fit_transform(X_train)
scaled_X_test = scaler.transform(X_test)
<prepare_x_and_y> | df5 = df4.copy()
df5['Title'] = df5['Title'].apply(lambda x: 'others' if x not in ['Mr','Mrs','Miss','Master'] else x)
| Titanic - Machine Learning from Disaster |
11,378,744 | y_test = gen_sub['Survived']<import_modules> | df6 = df5.copy()
df6['SibSp'] = df6['SibSp'].apply(lambda x: 3 if x>2 else x)
df6['Parch'] = df6['Parch'].apply(lambda x: 3 if x>2 else x ) | Titanic - Machine Learning from Disaster |
11,378,744 | from sklearn.linear_model import LogisticRegression<import_modules> | for col in cat_col:
print(df6.groupby(col)['Survived'].mean() ) | Titanic - Machine Learning from Disaster |
11,378,744 | from sklearn.model_selection import GridSearchCV<import_modules> | df6.groupby('Pclass')['Age'].mean() | Titanic - Machine Learning from Disaster |
11,378,744 | from sklearn.model_selection import GridSearchCV<choose_model_class> | df7 = df6.copy()
def age_miss(df):
if np.isnan(df['Age']):
if df['Pclass']==1:
return 38
elif df['Pclass']==2:
return 29
elif df['Pclass']==3:
return 25
else:
return df['Age']
df7['Age'] = df6.apply(age_miss,axis=1 ) | Titanic - Machine Learning from Disaster |
11,378,744 | log_model = LogisticRegression(solver='saga',multi_class="ovr",max_iter=5000 )<define_search_space> | final_df = df7.copy() | Titanic - Machine Learning from Disaster |
11,378,744 | penalty = ['l1', 'l2']
C = np.logspace(0, 4, 10 )<choose_model_class> | test_df = test_df.dropna(subset=['Embarked'])
test_df = test_df.drop('Cabin',axis=1)
test_df['Title'] = test_df['Name'].str.replace(r' (.*,)|(\.. *)','')
test_df = test_df.drop(['Name','Ticket'],axis=1)
test_df['Title'] = test_df['Title'].apply(lambda x: 'others' if x not in ['Mr','Mrs','Miss','Master'] else x)
de... | Titanic - Machine Learning from Disaster |
11,378,744 | grid_model = GridSearchCV(log_model,param_grid={'C':C,'penalty':penalty} )<train_model> | features = ['Pclass', 'Sex','Age','Embarked', 'Title']
X = final_df[features]
y = final_df.Survived
test = test_df[features] | Titanic - Machine Learning from Disaster |
11,378,744 | grid_model.fit(scaled_X_train,y_train )<find_best_params> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=101 ) | Titanic - Machine Learning from Disaster |
11,378,744 | grid_model.best_params_<import_modules> | from sklearn.pipeline import make_pipeline,Pipeline
from sklearn.compose import make_column_transformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.... | Titanic - Machine Learning from Disaster |
11,378,744 | from sklearn.metrics import accuracy_score,confusion_matrix,classification_report,plot_confusion_matrix<predict_on_test> | ohe = OneHotEncoder()
params = [{'classifier':[RandomForestClassifier() ],
'classifier__n_estimators':[10,25,50,75,100],
'classifier__max_depth':[5,10,15,20]},
{'classifier':[LogisticRegression() ],
'classifier__penalty':['l1','l2'],
'classifier__C':[0.01,0.1,1,10,100,1000],
'classifier__max_iter':[10,100,1000]},
{'cla... | Titanic - Machine Learning from Disaster |
11,378,744 | y_lr_pred = grid_model.predict(scaled_X_test )<compute_test_metric> | gr = GridSearchCV(pipe,param_grid=params,cv=5 ).fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
11,378,744 | accuracy_score(y_test,y_lr_pred )<compute_test_metric> | gr.best_params_ | Titanic - Machine Learning from Disaster |
11,378,744 | confusion_matrix(y_test,y_lr_pred )<compute_test_metric> | submit = pd.DataFrame(gr.predict(test),index=test_df.index,columns=['Survived'] ) | Titanic - Machine Learning from Disaster |
11,378,744 | <import_modules><EOS> | submit.to_csv('Submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
346,654 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<import_modules> | warnings.filterwarnings('ignore')
sns.set_style('whitegrid')
%matplotlib inline | Titanic - Machine Learning from Disaster |
346,654 | from sklearn.metrics import precision_recall_curve,plot_precision_recall_curve,plot_roc_curve<import_modules> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
346,654 | from sklearn.neighbors import KNeighborsClassifier<import_modules> | for col in train.columns:
print('number of null values in ' + col + ': ' + str(train[pd.isnull(train[col])].shape[0])) | Titanic - Machine Learning from Disaster |
346,654 | from sklearn.neighbors import KNeighborsClassifier<import_modules> | for col in test.columns:
print('number of null values in ' + col + ': ' + str(test[pd.isnull(test[col])].shape[0])) | Titanic - Machine Learning from Disaster |
346,654 | from sklearn.neighbors import KNeighborsClassifier<choose_model_class> | train = train.join(pd.get_dummies(train.Sex))
test = test.join(pd.get_dummies(test.Sex)) | Titanic - Machine Learning from Disaster |
346,654 | knn_model = KNeighborsClassifier(n_neighbors=1 )<train_model> | class_dummies = pd.get_dummies(train.Pclass)
class_dummies.columns = ['Higher', 'Middle', 'Lower']
train = train.join(class_dummies ) | Titanic - Machine Learning from Disaster |
346,654 | knn_model.fit(scaled_X_train,y_train )<predict_on_test> | X_train = train[['male', 'female','Higher', 'Middle', 'Lower']]
y = train['Survived']
class_dummies = pd.get_dummies(test.Pclass)
class_dummies.columns = ['Higher', 'Middle', 'Lower']
test = test.join(class_dummies)
X_test = test[['male', 'female', 'Higher', 'Middle', 'Lower']] | Titanic - Machine Learning from Disaster |
346,654 | y_knn_pred = knn_model.predict(scaled_X_test )<compute_test_metric> | log_reg = linear_model.LogisticRegression()
baseline_log_reg = log_reg.fit(X_train, y)
predicted_survivors = baseline_log_reg.predict(X_test)
print('Accuracy: ', metrics.accuracy_score(train.Survived, baseline_log_reg.predict(X_train)))
sns.heatmap(metrics.confusion_matrix(train.Survived, baseline_log_reg.predict(X_... | Titanic - Machine Learning from Disaster |
346,654 | print(classification_report(y_test,y_knn_pred))<choose_model_class> | first_tree = tree.DecisionTreeClassifier()
first_tree_fit = first_tree.fit(X_train, y)
predicted_survivors = first_tree_fit.predict(X_test)
print('Accuracy: ', metrics.accuracy_score(train.Survived, first_tree_fit.predict(X_train)))
sns.heatmap(metrics.confusion_matrix(train.Survived, first_tree_fit.predict(X_train)... | Titanic - Machine Learning from Disaster |
346,654 | knn = KNeighborsClassifier()<define_search_space> | X_train = train[['male', 'female', 'Pclass', 'new_Parch', 'new_SibSp']]
y = train['Survived']
test['new_SibSp'] = test.SibSp
test['new_SibSp'] = test.SibSp.astype(int)
test.loc[train.new_SibSp > 1, 'new_SibSp'] = 2
test['new_Parch'] = test.Parch
test['new_Parch'] = test.new_Parch.astype(int)
test.loc[train.new_Parch ... | Titanic - Machine Learning from Disaster |
346,654 | k_values = list(range(1,20))
params_grid = {'n_neighbors':k_values}<choose_model_class> | second_tree = tree.DecisionTreeClassifier()
second_tree_fit = second_tree.fit(X_train, y)
predicted_survivors = second_tree_fit.predict(X_test)
print('Accuracy: ', metrics.accuracy_score(train.Survived, second_tree_fit.predict(X_train)))
sns.heatmap(metrics.confusion_matrix(train.Survived, second_tree_fit.predict(X_... | Titanic - Machine Learning from Disaster |
346,654 | knn_grid_model = GridSearchCV(knn,param_grid=params_grid,cv=5,scoring='accuracy' )<train_model> | model_names = [
'KNeighborsClassifier',
'SVC(kernel="linear")',
'RandomForestClassifier',
'AdaBoostClassifier() ',
'GaussianNB() ',
]
models = [
KNeighborsClassifier() ,
SVC(kernel="linear"),
RandomForestClassifier() ,
AdaBoostClassifier() ,
GaussianNB()
]
fit_models = []
for i in range(len(models)) :
temp_score = cros... | Titanic - Machine Learning from Disaster |
346,654 | knn_grid_model.fit(scaled_X_train,y_train )<find_best_params> | test_rf_model = test
test_rf_model['Survived'] = fit_models[2].predict(X_test)
test_rf_model = test_rf_model[['PassengerId', 'Survived']]
| Titanic - Machine Learning from Disaster |
346,654 | knn_grid_model.best_params_<predict_on_test> | print('S embarked survival %:',\
round(( train[train.Embarked == 'S']\
.Survived.sum() /train[train.Embarked == 'S'].Survived.count())*100., 3))
print('C embarked survival %:',\
round(( train[train.Embarked == 'C']\
.Survived.sum() /train[train.Embarked == 'C'].Survived.count())*100., 3))
print('Q embarked survival %... | Titanic - Machine Learning from Disaster |
346,654 | y_knn_grid_pred = knn_grid_model.predict(scaled_X_test )<compute_test_metric> | train[train.Embarked.isnull() ] | Titanic - Machine Learning from Disaster |
346,654 | print(classification_report(y_test,y_knn_grid_pred))<import_modules> | train.loc[train.Embarked.isnull() , 'Embarked'] = 'S'
train = train.join(pd.get_dummies(train.Embarked)) | Titanic - Machine Learning from Disaster |
346,654 | from sklearn.svm import SVC<train_on_grid> | test = test.join(pd.get_dummies(test.Embarked)) | Titanic - Machine Learning from Disaster |
346,654 | param_grid = {'C':[0.001,0.01,0.1,0.5,1],'gamma':['scale','auto']}
grid_svc = GridSearchCV(svc,param_grid )<train_model> | test[test.Fare.isnull() ] | Titanic - Machine Learning from Disaster |
346,654 | grid_svc.fit(scaled_X_train,y_train )<find_best_params> | test.loc[test.Fare.isnull() , 'Fare'] = test[(test.Pclass == 3)].Fare.median()
print(test[test.PassengerId == 1044] ) | Titanic - Machine Learning from Disaster |
346,654 | grid_svc.best_params_<predict_on_test> | train.loc[train.Age.isnull() , 'Age'] = -0.5
train = train.join(pd.get_dummies(pd.cut(train.Age, [-1,0,5, 12,18,35,60, 100],\
labels=['missing', 'infant', 'child', 'teen', 'youngAdult', 'adult', 'senior'])))
train = train.join(pd.cut(train.Age, [-1,0,5, 12,18,35,60, 100],\
labels=['missing', 'infant', 'child', 'teen',... | Titanic - Machine Learning from Disaster |
346,654 | y_svc_grid_pred = grid_svc.predict(scaled_X_test )<compute_test_metric> | train = train.join(pd.get_dummies(train.new_SibSp, prefix='SibSp_'))
train = train.join(pd.get_dummies(train.new_Parch, prefix='Parch_')) | Titanic - Machine Learning from Disaster |
346,654 | print(classification_report(y_test,y_svc_grid_pred))<import_modules> | test = test.join(pd.get_dummies(test.new_SibSp, prefix='SibSp_'))
test = test.join(pd.get_dummies(test.new_Parch, prefix='Parch_')) | Titanic - Machine Learning from Disaster |
346,654 | from sklearn.tree import DecisionTreeClassifier<train_model> | features = ['female', 'male',
'Higher', 'Middle', 'Lower', 'C', 'Q', 'S',
'missing', 'infant', 'child', 'teen', 'youngAdult', 'adult', 'senior'
, 'SibSp__0', 'SibSp__1', 'SibSp__2', 'Parch__0', 'Parch__1', 'Parch__2']
target = ['Survived'] | Titanic - Machine Learning from Disaster |
346,654 | dt_model.fit(X_train,y_train )<predict_on_test> | X_train = train[features]
y = train[target]
X_test = test[features] | Titanic - Machine Learning from Disaster |
346,654 | y_dt_pred = dt_model.predict(X_test )<create_dataframe> | model_names = [
'KNeighborsClassifier() ',
'SVC(kernel="linear")',
'RandomForestClassifier',
'AdaBoostClassifier',
'GradientBoostingClassifier'
]
models = [
KNeighborsClassifier() ,
SVC(kernel="linear"),
RandomForestClassifier() ,
AdaBoostClassifier() ,
GradientBoostingClassifier()
]
fit_models = []
for i in range(len(... | Titanic - Machine Learning from Disaster |
346,654 | <import_modules><EOS> | test_predictions_GBT = test
test_predictions_GBT['Survived'] = fit_models[4].predict(X_test)
test_predictions_GBT[['PassengerId', 'Survived']].to_csv('test_predictions_GBT.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,696,024 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<find_best_params> | import pandas as pd
import numpy as np | Titanic - Machine Learning from Disaster |
11,696,024 | max_depth = list(range(1,30))
params_grid = {'max_depth':max_depth,'max_leaf_nodes':[2,3,4,5,6,7,8]}
dt_grid_model = GridSearchCV(dt_model,param_grid=params_grid)
<predict_on_test> | train = pd.read_csv(r'/kaggle/input/titanic/train.csv')
test = pd.read_csv(r'/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
11,696,024 | dt_grid_model.fit(X_train,y_train)
y_dt_grid_pred = dt_grid_model.predict(X_test )<find_best_params> | train.isna().sum() | Titanic - Machine Learning from Disaster |
11,696,024 | dt_grid_model.best_params_<import_modules> | dfs = [train ,test]
for df in dfs:
df['Age'].fillna(df['Age'].median() , inplace = True ) | Titanic - Machine Learning from Disaster |
11,696,024 | from sklearn.ensemble import RandomForestClassifier<choose_model_class> | train.isna().sum() | Titanic - Machine Learning from Disaster |
11,696,024 | rf_model = RandomForestClassifier()<train_model> | train['Cabin'].value_counts() | Titanic - Machine Learning from Disaster |
11,696,024 | rf_model.fit(X_train,y_train )<predict_on_test> | letters = []
for i in cabins:
letter= i[0]
letters.append(letter ) | Titanic - Machine Learning from Disaster |
11,696,024 | y_rf_pred = rf_model.predict(X_test )<create_dataframe> | train['Cabin'] = letters | Titanic - Machine Learning from Disaster |
11,696,024 | pd.DataFrame(index=X_train.columns,data=rf_model.feature_importances_,columns=['Feature Importance'])
<define_search_space> | letters = []
for i in cabins:
letter = i[0]
letters.append(letter ) | Titanic - Machine Learning from Disaster |
11,696,024 | no_of_trees = list(range(10,50,500))
max_depth = list(range(1,30))
param_grid_rf = {'n_estimators':no_of_trees,'criterion':['gini','entropy'],
'max_depth':max_depth,'max_leaf_nodes':[2,3,4,5,6,7,8]}<train_on_grid> | test['Cabin'] = letters | Titanic - Machine Learning from Disaster |
11,696,024 | rf_grid_model = GridSearchCV(rf_model,param_grid=param_grid_rf )<predict_on_test> | train['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
11,696,024 | rf_grid_model.fit(X_train,y_train)
y_rf_grid_pred = rf_grid_model.predict(X_test )<find_best_params> | len(train[train['Pclass'] == 1]), len(train[train['Pclass'] == 2]), len(train[train['Pclass'] == 3] ) | Titanic - Machine Learning from Disaster |
11,696,024 | rf_grid_model.best_params_<compute_test_metric> | percentages = []
first = 136 / 216
second = 87/ 184
third = 119/491
percentages.append(first)
percentages.append(second)
percentages.append(third ) | Titanic - Machine Learning from Disaster |
11,696,024 | print('Logistic_Regression_best_accuracy: ',accuracy_score(y_test,y_lr_pred))
print('
')
print('KNN_best_accuracy: ',accuracy_score(y_test,y_knn_grid_pred))
print('
')
print('SVM_best_accuracy: ',accuracy_score(y_test,y_svc_grid_pred))
print('
')
print('Decision_tree_best_accuracy: ',accuracy_score(y_test,y_dt_grid_... | percents = pd.DataFrame(percentages)
percents.index+=1 | Titanic - Machine Learning from Disaster |
11,696,024 | test_pred = dt_grid_model.predict(X_test )<load_from_csv> | train['Family'] = train.apply(lambda x: x['SibSp'] + x['Parch'], axis = 1)
test['Family'] = test.apply(lambda x: x['SibSp'] + x['Parch'], axis = 1 ) | Titanic - Machine Learning from Disaster |
11,696,024 | test2 = pd.read_csv('/kaggle/input/titanic/test.csv')
test2.head()<define_variables> | train.drop(['SibSp', 'Parch', 'Name', 'Ticket'], axis = 1, inplace = True)
test.drop(['SibSp', 'Parch', 'Name', 'Ticket'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
11,696,024 | passengerid = test2['PassengerId']<save_to_csv> | test.isna().sum() | Titanic - Machine Learning from Disaster |
11,696,024 | submission = pd.DataFrame({"PassengerId": passengerid,"Survived": test_pred})
submission.PassengerId = submission.PassengerId.astype(int)
submission.Survived = submission.Survived.astype(int)
submission.to_csv("titanic1_submission.csv", index=False )<load_from_csv> | test['Fare'].fillna(test['Fare'].median() , inplace = True ) | Titanic - Machine Learning from Disaster |
11,696,024 | url="https://github.com/thisisjasonjafari/my-datascientise-handcode/raw/master/005-datavisualization/titanic.csv"
s=requests.get(url ).content
c=pd.read_csv(io.StringIO(s.decode('utf-8')))
test_data_with_labels = c
test_data = pd.read_csv('.. /input/titanic/test.csv' )<set_options> | train_df = pd.get_dummies(train)
test_df = pd.get_dummies(test ) | Titanic - Machine Learning from Disaster |
11,696,024 | warnings.filterwarnings('ignore' )<feature_engineering> | train_df.drop('PassengerId', axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
11,696,024 | for i, name in enumerate(test_data_with_labels['name']):
if '"' in name:
test_data_with_labels['name'][i] = re.sub('"', '', name)
for i, name in enumerate(test_data['Name']):
if '"' in name:
test_data['Name'][i] = re.sub('"', '', name )<filter> | y = train_df['Survived']
train_df.drop('Survived', axis = 1, inplace = True)
train_df.drop('Cabin_T', axis = 1, inplace = True)
test_df.drop('PassengerId', axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
11,696,024 | survived = []
for name in test_data['Name']:
survived.append(int(test_data_with_labels.loc[test_data_with_labels['name'] == name]['survived'].values[-1]))<save_to_csv> | X_test = test_df
X_train = train_df | Titanic - Machine Learning from Disaster |
11,696,024 | submission = pd.read_csv('.. /input/titanic/gender_submission.csv')
submission['Survived'] = survived
submission.to_csv('submission.csv', index=False )<load_from_csv> | from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
11,696,024 | %matplotlib inline
train= pd.read_csv('/kaggle/input/titanic/train.csv')
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
<feature_engineering> | rfc = RandomForestClassifier() | Titanic - Machine Learning from Disaster |
11,696,024 | train['Age']=train[['Age','Pclass']].apply(impute_age,axis = 1 )<drop_column> | param_grid = {
'n_estimators': [200, 500, 1000],
'max_features': ['auto'],
'max_depth': [6, 7, 8],
'criterion': ['entropy']
} | Titanic - Machine Learning from Disaster |
11,696,024 | train.drop('Cabin',inplace = True,axis =1 )<categorify> | CV = GridSearchCV(estimator = rfc, param_grid = param_grid, cv = 5)
CV.fit(X_train, y)
CV.best_estimator_ | Titanic - Machine Learning from Disaster |
11,696,024 | sex = pd.get_dummies(train['Sex'],drop_first=True)
embark = pd.get_dummies(train['Embarked'],drop_first=True )<concatenate> | from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, VotingClassifier | Titanic - Machine Learning from Disaster |
11,696,024 | train = pd.concat([train,sex,embark],axis=1)
<drop_column> | rfc = RandomForestClassifier(criterion = 'entropy', max_depth = 8, n_estimators = 500, random_state = 42)
gbc = GradientBoostingClassifier()
ada = AdaBoostClassifier() | Titanic - Machine Learning from Disaster |
11,696,024 | train.drop(['Sex','Embarked','PassengerId','Name','Ticket'],axis=1,inplace=True )<normalization> | rfc.fit(X_train, y)
gbc.fit(X_train, y)
ada.fit(X_train, y ) | Titanic - Machine Learning from Disaster |
11,696,024 | st = StandardScaler()
feature_scale = ['Age','Fare']
train[feature_scale] = st.fit_transform(train[feature_scale] )<categorify> | stack_gen = StackingCVClassifier(classifiers =(rfc, gbc, ada),
meta_classifier = rfc,
use_features_in_secondary = True)
stack_gen.fit(X_train.values, y)
y_pred = stack_gen.predict(X_test.values ) | Titanic - Machine Learning from Disaster |
11,696,024 | feature_scale = ['Age','Fare']
train[feature_scale] = st.fit_transform(train[feature_scale])
<prepare_x_and_y> | def blend(X_test):
y_pred =(( 0.25 * gbc.predict(X_test)) + \
0.25 * ada.predict(X_test)+ \
0.5 * stack_gen.predict(np.array(X_test)))
return y_pred
| Titanic - Machine Learning from Disaster |
11,696,024 | x = train.drop(['Survived'],axis=1)
y = train['Survived']<import_modules> | submission = y_pred.reshape(-1, 1 ) | Titanic - Machine Learning from Disaster |
11,696,024 | 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<train_model> | sub_df = pd.DataFrame(submission ) | Titanic - Machine Learning from Disaster |
11,696,024 | tree = DecisionTreeClassifier()
tree.fit(x,y)
tree.score(x,y )<load_from_csv> | sub_df['PassengerId'] = test['PassengerId']
sub_df['Survived'] = submission
cols = ['PassengerId',
'Survived']
sub_df.drop(0, axis = 1, inplace = True)
sub_df.columns = [i for i in cols]
sub_df = sub_df.set_index('PassengerId' ) | Titanic - Machine Learning from Disaster |
11,696,024 | test = pd.read_csv('/kaggle/input/titanic/test.csv' )<create_dataframe> | sub_df.to_csv(r'submission.csv' ) | Titanic - Machine Learning from Disaster |
10,566,591 | test2 = test.copy()
<feature_engineering> | plt.style.available | Titanic - Machine Learning from Disaster |
10,566,591 | test['Age']=test[['Age','Pclass']].apply(impute_age,axis = 1 )<drop_column> | train_df = pd.read_csv(".. /input/titanic/train.csv")
test_df = pd.read_csv(".. /input/titanic/test.csv")
test_PassengerId = test_df["PassengerId"] | Titanic - Machine Learning from Disaster |
10,566,591 | test.drop('Cabin',inplace = True,axis =1 )<categorify> | category2= ["Cabin", "Name", "Ticket"]
for c in category2:
print(f"{train_df[c].value_counts() }
" ) | Titanic - Machine Learning from Disaster |
10,566,591 | sex = pd.get_dummies(test['Sex'],drop_first=True)
embark = pd.get_dummies(test['Embarked'],drop_first=True )<concatenate> | train_df[["Pclass", "Survived"]].groupby(["Pclass"], as_index=False ).mean().sort_values(
by="Survived", ascending=False ) | Titanic - Machine Learning from Disaster |
10,566,591 | test = pd.concat([test,sex,embark],axis=1 )<drop_column> | train_df[["Sex", "Survived"]].groupby(["Sex"], as_index=False ).mean().sort_values(
by="Survived", ascending=False ) | Titanic - Machine Learning from Disaster |
10,566,591 | test.drop(['Sex','Embarked','PassengerId','Name','Ticket'],axis=1,inplace=True )<correct_missing_values> | train_df[["SibSp", "Survived"]].groupby(["SibSp"], as_index=False ).mean().sort_values(
by="Survived", ascending=False ) | Titanic - Machine Learning from Disaster |
10,566,591 | test['Fare'].fillna(test['Fare'].mean() ,inplace=True )<categorify> | train_df[["Parch", "Survived"]].groupby(["Parch"], as_index=False ).mean().sort_values(
by="Survived", ascending=False ) | Titanic - Machine Learning from Disaster |
10,566,591 | feature_scale = ['Age','Fare']
test[feature_scale] = st.fit_transform(test[feature_scale] )<import_modules> | train_df[["Sex", "Pclass", "Survived"]].groupby(["Sex", "Pclass"], as_index=False ).mean().sort_values(
by="Survived", ascending=False ) | Titanic - Machine Learning from Disaster |
10,566,591 | 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
<choose_model_class> | train_df[["Sex", "Pclass", "Parch", "SibSp","Survived"]].groupby(
["Sex", "Pclass", "Parch", "SibSp"], as_index=False ).mean().sort_values(by="Survived",
ascending=False)[:60] | Titanic - Machine Learning from Disaster |
10,566,591 | level1 = LogisticRegression()
model = StackingClassifier(estimators=level0,final_estimator=level1,cv=5 )<train_model> | def detect_outliers(df, features):
outlier_indices=list()
for c in features:
Q1 = np.percentile(df[c], 25)
Q3 = np.percentile(df[c], 75)
IQR = Q3 - Q1
outlier_step = IQR*1.5
outlier_detect_column = df[(df[c]<(Q1-outlier_step)) |(df[c]>(Q3+outlier_step)) ].index
outlier_indices.extend(outlier_detect_column)
outlier_i... | Titanic - Machine Learning from Disaster |
10,566,591 | model.fit(x,y )<compute_test_metric> | train_df.loc[detect_outliers(train_df, ["Age", "SibSp", "Parch", "Fare"])] | Titanic - Machine Learning from Disaster |
10,566,591 | model.score(x,y )<predict_on_test> | train_df = train_df.drop(detect_outliers(train_df, ["Age", "SibSp", "Parch", "Fare"]), axis=0 ).reset_index(
drop = True ) | Titanic - Machine Learning from Disaster |
10,566,591 | y_predicted = model.predict(test )<create_dataframe> | train_df_len = len(train_df)
train_df = pd.concat([train_df, test_df],axis=0 ).reset_index(drop=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.