kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
1,602,712 | submissionOrig["ConfirmedCases"]=pd.Series(preds )<feature_engineering> | max_accuracy = max(accuracy, key=accuracy.get)
print(max_accuracy, '\taccuracy:', accuracy[max_accuracy] ) | Titanic - Machine Learning from Disaster |
1,602,712 | for index, row in submissionOrig.iterrows() :
if index >= 1:
if submissionOrig.iloc[index, 'ConfirmedCases'] < submissionOrig.iloc[index - 1, 'ConfirmedCases']:
submissionOrig.at[index, 'ConfirmedCases'] = submissionOrig.iloc[index - 1,'ConfirmedCases']<predict_on_test> | m6_gb.fit(train_imputed, Survival)
m6_gb.feature_importances_ | Titanic - Machine Learning from Disaster |
1,602,712 | y_train = train["Fatalities"]
confirmed_reg = xgb.XGBRegressor(n_estimators=1000)
confirmed_reg.fit(X_train, y_train, verbose=True)
preds = confirmed_reg.predict(X_test)
preds = np.array(preds)
preds[preds < 0] = 0
preds = np.round(preds, 0)
submissionOrig["Fatalities"]=pd.Series(preds )<feature_engineering> | param_grid = {'max_depth': [1,3,5,10,15], 'n_estimators': [50,100,200,500,1000], 'learning_rate': [1,0.1,0.01,0.001,0.0001]}
grid = GridSearchCV(XGBClassifier() , param_grid, cv=kfold)
grid.fit(train_imputed[["Fare_", "Age_", "FamilySize", "Sex_"]], Survival)
grid.best_params_ | Titanic - Machine Learning from Disaster |
1,602,712 | for index, row in submissionOrig.iterrows() :
if index >= 1:
if submissionOrig.iloc[index, 'Fatalities'] < submissionOrig.iloc[index - 1, 'Fatalities']:
submissionOrig.at[index, 'Fatalities'] = submissionOrig.iloc[index - 1,'Fatalities']<save_to_csv> | gb = XGBClassifier(max_depth=3, n_estimators=1000, learning_rate=0.01)
np.mean(cross_val_score(gb, train_imputed[["Fare_", "Age_", "FamilySize", "Sex_"]], Survival, scoring="accuracy", cv=kfold)) | Titanic - Machine Learning from Disaster |
1,602,712 | submissionOrig.to_csv('submission.csv',index=False )<set_options> | gb.fit(train_imputed[["Fare_", "Age_", "FamilySize", "Sex_"]], Survival)
predictions = gb.predict(test_imputed[["Fare_", "Age_", "FamilySize", "Sex_"]] ) | Titanic - Machine Learning from Disaster |
1,602,712 | <load_from_csv><EOS> | submission = pd.DataFrame({ 'PassengerId': test.PassengerId,
'Survived': predictions })
submission.to_csv("TitanicSubmission.csv", index=False ) | Titanic - Machine Learning from Disaster |
546,554 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<sort_values> | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
546,554 | print(train_data["Pclass"].unique())
train_data[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<string_transform> | train_original = pd.read_csv('.. /input/train.csv')
test_original = pd.read_csv('.. /input/test.csv')
train_original.sample(10)
total = [train_original,test_original]
| Titanic - Machine Learning from Disaster |
546,554 | train_data.Name[1].split()<feature_engineering> | for dataset in total:
dataset['Salutation'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
546,554 | train_data = train_data.assign(fname = train_data.Name.str.split("," ).str[0])
train_data["title"] = pd.Series([i.split(",")[1].split(".")[0].strip() for i in train_data.Name], index=train_data.index )<feature_engineering> | for dataset in total:
dataset['Salutation'] = dataset['Salutation'].replace(['Lady', 'Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Salutation'] = dataset['Salutation'].replace('Mlle', 'Miss')
dataset['Salutation'] = dataset['Salutation'].replace('Ms', 'Miss')
data... | Titanic - Machine Learning from Disaster |
546,554 | test_data = test_data.assign(fname = test_data.Name.str.split("," ).str[0])
test_data["title"] = pd.Series([i.split(",")[1].split(".")[0].strip() for i in test_data.Name], index=test_data.index)
train_data.drop("Name", axis=1, inplace=True)
test_data.drop("Name", axis=1, inplace=True )<count_unique_values> | for dataset in total:
dataset['Salutation'] = pd.factorize(dataset['Salutation'])[0] | Titanic - Machine Learning from Disaster |
546,554 | print(test_data.fname.nunique())
print(test_data.title.nunique() )<categorify> | train=train_original.drop(['PassengerId','Name','Ticket','Cabin'], axis=1)
test=test_original.drop(['PassengerId','Name','Ticket','Cabin'], axis=1)
total = [train,test]
train.shape, test.shape | Titanic - Machine Learning from Disaster |
546,554 | train_data["title"] = train_data['title'].replace(other_titles, 'Other')
train_data["title"] = train_data["title"].map({"Mr":0, "Miss":1, "Ms" : 1 , "Mme":1, "Mlle":1, "Mrs":1, "Master":2, "Other":3})
test_data["title"] = test_data['title'].replace(other_titles, 'Other')
test_data["title"] = test_data["title"].map({... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
546,554 | print(train_data.title)
print(test_data.title.isna().sum() )<categorify> | def fill_missing_age(dataset):
for i in range(1,8):
median_age=dataset[dataset["Salutation"]==i]["Age"].median()
dataset["Age"]=dataset["Age"].fillna(median_age)
return dataset
train = fill_missing_age(train ) | Titanic - Machine Learning from Disaster |
546,554 | oh = OneHotEncoder(handle_unknown="ignore", sparse = False)
train_data = train_data.join(pd.DataFrame(oh.fit_transform(train_data[["fname", "title"]]), index = train_data.index))
test_data = test_data.join(pd.DataFrame(oh.transform(test_data[["fname", "title"]]), index = test_data.index))
train_data.drop("fname", axis... | train[train['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
546,554 | print(train_data["Sex"].unique())
train_data[['Sex', 'Survived']].groupby(['Sex'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<sort_values> | train["Embarked"] = train["Embarked"].fillna('C' ) | Titanic - Machine Learning from Disaster |
546,554 | interactions = train_data.assign(sex_class = train_data['Sex'] + "_" + train_data['Pclass'].astype("str"))
interactions[['sex_class', 'Survived']].groupby(['sex_class'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<data_type_conversions> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
546,554 | train_data = train_data.assign(sex_class = train_data['Sex'] + "_" + train_data['Pclass'].astype("str"))
test_data = test_data.assign(sex_class = test_data['Sex'] + "_" + test_data['Pclass'].astype("str"))<categorify> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
546,554 | train_data = train_data.join(pd.get_dummies(train_data['Pclass'], prefix="Pclass"))
test_data = test_data.join(pd.get_dummies(test_data['Pclass'], prefix="Pclass"))<categorify> | test = fill_missing_age(test ) | Titanic - Machine Learning from Disaster |
546,554 | train_data["Sex"] = train_data["Sex"].map({"female":0, "male":1})
test_data["Sex"] = test_data["Sex"].map({"female":0, "male":1} )<categorify> | def fill_missing_fare(dataset):
median_fare=dataset[(dataset["Pclass"]==3)&(dataset["Embarked"]=="S")]["Fare"].median()
dataset["Fare"]=dataset["Fare"].fillna(median_fare)
return dataset
test = fill_missing_fare(test ) | Titanic - Machine Learning from Disaster |
546,554 | train_data["sex_class"] = train_data["sex_class"].map({"female_1":0, "female_2":1, "female_3":2, "male_1":4, "male_2":5, "male_3":6})
test_data["sex_class"] = test_data["sex_class"].map({"female_1":0, "female_2":1, "female_3":2, "male_1":4, "male_2":5, "male_3":6} )<filter> | train.isnull().any() | Titanic - Machine Learning from Disaster |
546,554 | def find_similar_passengers(id, dataset):
subset = dataset[(dataset.title == dataset.title[id])&
(dataset.Pclass == dataset.Pclass[id])]
if subset["Age"].mean() == "NaN":
subset = dataset[(dataset["sex_class"] == dataset.iloc[id]["sex_class"])]
if subset["Age"].mean() == "NaN":
subset = dataset[(dataset["sex"] == data... | test.isnull().any() | Titanic - Machine Learning from Disaster |
546,554 | no_ages = train_data[train_data["Age"].isna() ].index
for pid in no_ages:
train_data.Age[pid] = find_similar_passengers(pid, train_data)
no_ages_test = test_data[test_data["Age"].isna() ].index
for pid2 in no_ages_test:
test_data.Age[pid2] = find_similar_passengers(pid2, test_data )<data_type_conversions> | pd.qcut(train["Age"], 6 ).value_counts() | Titanic - Machine Learning from Disaster |
546,554 | train_data["age_group"] = pd.cut(train_data["Age"], bins=[0,5,65,100], labels=[0,1,2] ).astype("int64")
test_data["age_group"] = pd.cut(test_data["Age"], bins=[0,5,65,100], labels=[0,1,2] ).astype("int64" )<sort_values> | for dataset in total:
dataset.loc[dataset["Age"] <= 19, "Age"] = 0
dataset.loc[(dataset["Age"] > 19)&(dataset["Age"] <= 25), "Age"] = 1
dataset.loc[(dataset["Age"] > 25)&(dataset["Age"] <= 32), "Age"] = 2
dataset.loc[(dataset["Age"] > 32)&(dataset["Age"] <= 35), "Age"] = 3
dataset.loc[(dataset["Age"] > 35)&(dataset["Ag... | Titanic - Machine Learning from Disaster |
546,554 | train_data[['SibSp', 'Survived']].groupby(['SibSp'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<sort_values> | pd.qcut(train["Fare"], 8 ).value_counts() | Titanic - Machine Learning from Disaster |
546,554 | train_data[['Parch', 'Survived']].groupby(['Parch'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<feature_engineering> | for dataset in total:
dataset.loc[dataset["Fare"] <= 7.75, "Fare"] = 0
dataset.loc[(dataset["Fare"] > 7.75)&(dataset["Fare"] <= 7.91), "Fare"] = 1
dataset.loc[(dataset["Fare"] > 7.91)&(dataset["Fare"] <= 9.841), "Fare"] = 2
dataset.loc[(dataset["Fare"] > 9.841)&(dataset["Fare"] <= 14.454), "Fare"] = 3
dataset.loc[(data... | Titanic - Machine Learning from Disaster |
546,554 | train_data["fsize"] = train_data["SibSp"] + train_data["Parch"] + 1
test_data["fsize"] = test_data["SibSp"] + test_data["Parch"] + 1<sort_values> | for dataset in total:
dataset['Sex'] = pd.factorize(dataset['Sex'])[0]
dataset['Embarked']= pd.factorize(dataset['Embarked'])[0]
train.head() | Titanic - Machine Learning from Disaster |
546,554 | train_data[['fsize', 'Survived']].groupby(['fsize'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<count_unique_values> | x = train.drop("Survived", axis=1)
y = train["Survived"] | Titanic - Machine Learning from Disaster |
546,554 | print(train_data.Ticket.nunique())
print(train_data.Ticket.tail() )<feature_engineering> | x_train, x_test, y_train, y_test = train_test_split(x,y,test_size=.25,random_state=1 ) | Titanic - Machine Learning from Disaster |
546,554 | train_data["ticket_prefix"] = pd.Series([len(i.split())> 1 for i in train_data.Ticket], index=train_data.index )<sort_values> | MLA = [
ensemble.AdaBoostClassifier() ,
ensemble.BaggingClassifier() ,
ensemble.ExtraTreesClassifier() ,
ensemble.GradientBoostingClassifier() ,
ensemble.RandomForestClassifier() ,
gaussian_process.GaussianProcessClassifier() ,
linear_model.LogisticRegressionCV() ,
linear_model.PassiveAggressiveClassifier() ,
linear_mo... | Titanic - Machine Learning from Disaster |
546,554 | train_data[['ticket_prefix', 'Survived']].groupby(['ticket_prefix'], as_index=False ).mean().sort_values(by='Survived', ascending=False)
<drop_column> | MLA_columns = []
MLA_compare = pd.DataFrame(columns = MLA_columns)
row_index = 0
for alg in MLA:
predicted = alg.fit(x_train, y_train ).predict(x_test)
fp, tp, th = roc_curve(y_test, predicted)
MLA_name = alg.__class__.__name__
MLA_compare.loc[row_index,'MLA Name'] = MLA_name
MLA_compare.loc[row_index, 'MLA Train Ac... | Titanic - Machine Learning from Disaster |
546,554 | train_data.drop("ticket_prefix", axis=1, inplace=True)
train_data.drop("Ticket", axis=1, inplace=True)
test_data.drop("Ticket", axis=1, inplace=True )<drop_column> | tunealg = ensemble.AdaBoostClassifier()
tunealg.fit(x_train, y_train)
print('BEFORE tuning Parameters: ', tunealg.get_params())
print("BEFORE tuning Training w/bin set score: {:.2f}".format(tunealg.score(x_train, y_train)))
print("BEFORE tuning Test w/bin set score: {:.2f}".format(tunealg.score(x_test, y_test)))
pr... | Titanic - Machine Learning from Disaster |
546,554 | train_data.drop("Cabin", axis=1, inplace=True)
test_data.drop("Cabin", axis=1, inplace=True )<sort_values> | param_grid = {'n_estimators': [10,15,25,35,45,50,55,60,65],
'learning_rate': [0.1,0.2,0.3,0.4,0.5,1.0],
'algorithm': ['SAMME','SAMME.R'],
'random_state': [1,2,3,4,5,50, None],
}
tune_model = model_selection.GridSearchCV(ensemble.AdaBoostClassifier() , param_grid=param_grid, scoring = 'roc_auc')
tune_model.fit(x_train,... | Titanic - Machine Learning from Disaster |
546,554 | train_data["Embarked"] = train_data["Embarked"].fillna("S")
train_data[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<count_missing_values> | y_pred = tune_model.fit(x, y ).predict(test ) | Titanic - Machine Learning from Disaster |
546,554 | <categorify><EOS> | submission = pd.DataFrame({
"PassengerId": test_original["PassengerId"],
"Survived": y_pred
})
submission.to_csv('titanic.csv', index=False)
| Titanic - Machine Learning from Disaster |
494,926 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<drop_column> | %matplotlib inline
sns.set_style('whitegrid')
warnings.filterwarnings('ignore')
| Titanic - Machine Learning from Disaster |
494,926 | train_data.drop("Embarked", axis=1, inplace=True)
test_data.drop("Embarked", axis=1, inplace=True )<prepare_x_and_y> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
494,926 | ss = StandardScaler()
train_y = train_data["Survived"]
train_data.drop("Survived", axis=1, inplace=True)
scoring_method = "f1"
train_scaled = ss.fit_transform(train_data)
test_scaled = ss.transform(test_data )<count_missing_values> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
494,926 | print(train_data.isna().sum())
print(test_data.isna().sum() )<define_search_space> | train['Cabin'].value_counts().head() | Titanic - Machine Learning from Disaster |
494,926 | model = LogisticRegression(random_state=10, max_iter = 1000)
logit_params = {
"C": [1, 3, 10, 20, 30, 40],
"solver": ["lbfgs", "liblinear"]
}
logit_gs = GridSearchCV(model, logit_params, scoring="f1", cv = 5, n_jobs=4 )<train_model> | def fill_age_train(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
def fill_age_test(cols):
Age = cols[0]
PClass = cols[1]
if pd.isnull(Age):
if PClass == 1:
return 39
elif PClass == 2:
return 28
else:
return 25
else:
return... | Titanic - Machine Learning from Disaster |
494,926 | logit_gs.fit(train_data, train_y )<find_best_score> | train['Age'] = train[['Age','Pclass']].apply(fill_age_train,axis=1)
test['Age'] = test[['Age','Pclass']].apply(fill_age_test,axis=1 ) | Titanic - Machine Learning from Disaster |
494,926 | print(logit_gs.best_params_)
print(logit_gs.best_score_ )<choose_model_class> | test['Fare'].fillna(stat.mode(test['Fare']),inplace=True)
train['Embarked'].fillna('S',inplace=True)
train['Cabin'].fillna('No Cabin',inplace=True)
test['Cabin'].fillna('No Cabin',inplace=True ) | Titanic - Machine Learning from Disaster |
494,926 | rf_model = RandomForestClassifier()
rf_params ={
'bootstrap': [True, False],
'max_depth': [10, None],
'max_features': ['auto', 'sqrt'],
'min_samples_leaf': [1, 2, 4],
'min_samples_split': [2, 5, 10],
'n_estimators': [5, 10, 15, 20, 25, 30]}
rf_gs = GridSearchCV(rf_model, rf_params, scoring=scoring_method, cv=8, n_jobs=... | train.drop('Ticket',axis=1,inplace=True)
test.drop('Ticket',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
494,926 | rf_gs.fit(train_data, train_y )<find_best_score> | train['IsTrain'] = 1
test['IsTrain'] = 0
df = pd.concat([train,test] ) | Titanic - Machine Learning from Disaster |
494,926 | print(rf_gs.best_params_)
print(rf_gs.best_score_ )<choose_model_class> | scaler = MinMaxScaler() | Titanic - Machine Learning from Disaster |
494,926 | svc_model = SVC()
test_parameters = {
"C": [1, 3, 10, 30, 100],
"kernel": ["linear", "poly", "rbf" , "sigmoid"],
}
svc_gs = GridSearchCV(svc_model, test_parameters, scoring="f1", cv=5, n_jobs=4 )<train_model> | df['Title'] = df['Name'].str.split(', ' ).str[1].str.split('.' ).str[0]
df['Title'].value_counts() | Titanic - Machine Learning from Disaster |
494,926 | svc_gs.fit(train_scaled, train_y )<find_best_params> | df['Title'].replace('Mme','Mrs',inplace=True)
df['Title'].replace(['Ms','Mlle'],'Miss',inplace=True)
df['Title'].replace(['Dr','Rev','Col','Major','Dona','Don','Sir','Lady','Jonkheer','Capt','the Countess'],'Others',inplace=True)
df['Title'].value_counts() | Titanic - Machine Learning from Disaster |
494,926 | print(svc_gs.best_params_)
print(svc_gs.best_score_ )<choose_model_class> | df.drop('Name',axis=1,inplace=True)
df.head() | Titanic - Machine Learning from Disaster |
494,926 | lgb_model = LGBMClassifier()
test_parameters = {
"n_estimators": [int(x)for x in np.linspace(5, 30, 6)],
"reg_alpha": [0, 0.75, 1, 1.25],
"learning_rate": [0.5, 0.4, 0.35, 0.3, 0.25, 0.2],
"subsample": [0.5, 0.75, 1]
}
lgb_gs = GridSearchCV(lgb_model, test_parameters, scoring=scoring_method, cv=8, n_jobs=4 )<train_mode... | df['AgeGroup'] = df['Age']
df.loc[df['AgeGroup']<=19, 'AgeGroup'] = 0
df.loc[(df['AgeGroup']>19)&(df['AgeGroup']<=30), 'AgeGroup'] = 1
df.loc[(df['AgeGroup']>30)&(df['AgeGroup']<=45), 'AgeGroup'] = 2
df.loc[(df['AgeGroup']>45)&(df['AgeGroup']<=63), 'AgeGroup'] = 3
df.loc[df['AgeGroup']>63, 'AgeGroup'] = 4 | Titanic - Machine Learning from Disaster |
494,926 | lgb_gs.fit(train_data, train_y )<find_best_score> | df.drop('Age',axis=1,inplace=True)
df.head() | Titanic - Machine Learning from Disaster |
494,926 | print(lgb_gs.best_params_)
print(lgb_gs.best_score_ )<choose_model_class> | df['FamilySize'] = df['SibSp'] + df['Parch'] + 1
df['IsAlone'] = 0
df.loc[df['FamilySize']==1, 'IsAlone'] = 1 | Titanic - Machine Learning from Disaster |
494,926 | ensemble_model = VotingClassifier(estimators=[
("logit", logit_gs.best_estimator_),
("rf", rf_gs.best_estimator_),
("svc", svc_gs.best_estimator_),
("lgb", lgb_gs.best_estimator_),
], voting = "hard" )<train_model> | df.drop(['SibSp','Parch','FamilySize'],axis=1,inplace=True)
df.head() | Titanic - Machine Learning from Disaster |
494,926 | ensemble_model.fit(train_data, train_y )<compute_test_metric> | df['Deck'] = df['Cabin']
df.loc[df['Deck']!='No Cabin','Deck'] = df[df['Cabin']!='No Cabin']['Cabin'].str.split().apply(lambda x: np.sort(x)).str[0].str[0]
df.loc[df['Deck']=='No Cabin','Deck'] = 'N/A' | Titanic - Machine Learning from Disaster |
494,926 | ensemble_model.score(train_data, train_y )<predict_on_test> | df.loc[df['Deck']=='N/A', 'Deck'] = 0
df.loc[df['Deck']=='G', 'Deck'] = 1
df.loc[df['Deck']=='F', 'Deck'] = 2
df.loc[df['Deck']=='E', 'Deck'] = 3
df.loc[df['Deck']=='D', 'Deck'] = 4
df.loc[df['Deck']=='C', 'Deck'] = 5
df.loc[df['Deck']=='B', 'Deck'] = 6
df.loc[df['Deck']=='A', 'Deck'] = 7
df.loc[df['Deck']=='T', 'Deck'... | Titanic - Machine Learning from Disaster |
494,926 | preds = ensemble_model.predict(test_data )<save_to_csv> | df.drop('Cabin',axis=1,inplace=True)
df.head() | Titanic - Machine Learning from Disaster |
494,926 | output = pd.DataFrame({'PassengerId': test_data.index,
'Survived': preds})
output.to_csv('submission.csv', index=False )<import_modules> | df[['Fare','Pclass','Deck']] = scaler.fit_transform(df[['Fare','Pclass','Deck']] ) | Titanic - Machine Learning from Disaster |
494,926 | warnings.filterwarnings("ignore")
<load_from_csv> | def process_dummies(df,cols):
for col in cols:
dummies = pd.get_dummies(df[col],prefix=col,drop_first=True)
df = pd.concat([df.drop(col,axis=1),dummies],axis=1)
return df | Titanic - Machine Learning from Disaster |
494,926 | train=pd.read_csv('.. /input/titanic/train.csv')
test=pd.read_csv('.. /input/titanic/test.csv')
y_test=pd.read_csv('.. /input/titanic/gender_submission.csv' )<drop_column> | df = process_dummies(df,['Embarked','Sex','Title','AgeGroup'] ) | Titanic - Machine Learning from Disaster |
494,926 | y_test.head()
PassengerId=y_test['PassengerId']
y_test=y_test.drop(['PassengerId'],axis=1)
<data_type_conversions> | dataset = df[df['IsTrain']==1]
dataset.drop(['IsTrain','PassengerId'],axis=1,inplace=True)
holdout = df[df['IsTrain']==0]
test_id = holdout['PassengerId']
holdout.drop(['IsTrain','PassengerId','Survived'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
494,926 | train_m=(max(train['Age'])+min(train['Age'])) /2
values={'Cabin':'nocabin','Age':train_m,'Embarked':'notknown'}
train=train.fillna(value=values)
test_m=(max(test['Age'])+min(test['Age'])) /2
print(test_m)
values={'Cabin':'nocabin','Age':test_m,'Embarked':'notknown',"Fare":max(test['Fare'])}
test=test.fillna(value=val... | class_one_total = int(np.sum(dataset['Survived']))
class_zero_counter = 0
indices_to_remove = []
for i in range(dataset.shape[0]):
if(dataset['Survived'].iloc[i] == 0):
class_zero_counter += 1
if(class_zero_counter > class_one_total):
indices_to_remove.append(i)
| Titanic - Machine Learning from Disaster |
494,926 | y= train["Survived"]
train=train.drop(["Survived"],axis=1 )<split> | df.to_csv('titanic_dataset_preprocessed.csv',index=False ) | Titanic - Machine Learning from Disaster |
494,926 | X_train, X_cv, y_train, y_cv = train_test_split(train, y, stratify=y, test_size=0.2 )<categorify> | X = dataset.drop(['Survived'],axis=1)
y = dataset['Survived'].astype('int')
| Titanic - Machine Learning from Disaster |
494,926 | vectorizer = CountVectorizer()
X_tr_emb =vectorizer.fit_transform(X_train['Embarked'])
X_cv_emb =vectorizer.transform(X_cv['Embarked'])
X_te_emb =vectorizer.transform(test['Embarked'])
enc = OneHotEncoder(handle_unknown='ignore')
X_tr_age =enc.fit_transform(np.array(X_train['Age'] ).reshape(-1,1))
X_cv_age =enc.tra... | model = RandomForestClassifier()
kf = KFold(n_splits=10,shuffle=True,random_state=101)
score = 0
train_indices, validation_indices = [],[]
for curr_train_indices, curr_validation_indices in kf.split(X):
result = model.fit(X.iloc[curr_train_indices], y.iloc[curr_train_indices])
curr_score = result.score(X.iloc[curr_va... | Titanic - Machine Learning from Disaster |
494,926 | max_depth=[1,5,10,15]
alpha=[1,3,7,15,24,31,60]
cv_log_error_array=[]
min_i=0
val=0
v=99999
for i in alpha:
clf = KNeighborsClassifier(n_neighbors=i,weights='distance')
clf.fit(X_tr, y_train)
sig_clf = CalibratedClassifierCV(clf, method="sigmoid")
sig_clf.fit(X_tr, y_train)
predict_y = sig_clf.predict_proba(X_cv)
... | param_grid = [
{'n_estimators':[1,10,20,50,100,1000,3000], 'min_samples_leaf':[1,2,3,4,5], 'max_features':[3,5,7,9,10,'auto']},
]
grid = GridSearchCV(model,param_grid,n_jobs=4)
grid.fit(X, y ) | Titanic - Machine Learning from Disaster |
494,926 | pred=sig_clf.predict(X_te)
df=pd.DataFrame(zip(PassengerId,pred),columns=['PassengerId',"Survived"])
df
df.to_csv('/kaggle/working/knn_output.csv',index=False)
<load_from_csv> | grid.best_params_, grid.best_score_ | Titanic - Machine Learning from Disaster |
494,926 | d=pd.read_csv('/kaggle/working/knn_output.csv')
d<set_options> | predictions = grid.predict(holdout ) | Titanic - Machine Learning from Disaster |
494,926 | <load_from_csv><EOS> | submission = pd.DataFrame({
'PassengerId': test_id,
'Survived': predictions
})
submission.to_csv('submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
1,388,734 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<rename_columns> | %matplotlib inline
warnings.filterwarnings('ignore')
plt.style.use("ggplot")
| Titanic - Machine Learning from Disaster |
1,388,734 | train.columns = [x.lower() for x in train.columns]
test.columns = [x.lower() for x in test.columns]<drop_column> | data.isnull().sum() | Titanic - Machine Learning from Disaster |
1,388,734 | train.drop(['passengerid','name','ticket'],axis=1,inplace=True)
train.head(2 )<count_missing_values> | data.isnull().sum() | Titanic - Machine Learning from Disaster |
1,388,734 | train.isnull().sum()<count_missing_values> | data.groupby(['Survived'])['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
1,388,734 | train.isnull().sum()<drop_column> | data['Embarked'].fillna('S', inplace=True)
data['Embarked'].isnull().sum() | Titanic - Machine Learning from Disaster |
1,388,734 | train.drop('cabin',axis=1,inplace=True)
train.head()<count_missing_values> | def extract_title(x):
res = re.findall(r'[A-Za-z]+[.]', x)
if res:
return res[0]
else:
return None
data['NameTitle'] = data['Name'].apply(extract_title)
data.head(3 ) | Titanic - Machine Learning from Disaster |
1,388,734 | train.isnull().sum()<count_missing_values> | data.loc[data['Age'].isnull() & data['NameTitle'].str.contains('Master.'), 'Age'] = 5
data.loc[data['Age'].isnull() & data['NameTitle'].str.contains('Miss.'), 'Age'] = 22
data.loc[data['Age'].isnull() & data['NameTitle'].str.contains('Mr.'), 'Age'] = 32
data.loc[data['Age'].isnull() & data['NameTitle'].str.contains('Mr... | Titanic - Machine Learning from Disaster |
1,388,734 | train.isnull().sum()<data_type_conversions> | data['NameTitle'].value_counts() | Titanic - Machine Learning from Disaster |
1,388,734 | age_mean = train['age'].mean()
train['age'] = train['age'].fillna(age_mean)
train.isnull().sum()
<count_missing_values> | data.drop('PassengerId', axis=1, inplace=True)
data.drop('Ticket', axis=1, inplace=True)
data.drop('Cabin', axis=1, inplace=True)
data.drop('Name', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
1,388,734 | train.isnull().sum()<count_missing_values> | def age_group(x):
if x <= 16:
return 4
elif x > 16 and x <= 32:
return 1
elif x > 32 and x <= 48:
return 2
elif x > 48 and x <= 64:
return 3
else:
return 0 | Titanic - Machine Learning from Disaster |
1,388,734 | train.isnull().sum()<count_values> | data['AgeGroup'] = data['Age'].apply(age_group)
data.head() | Titanic - Machine Learning from Disaster |
1,388,734 | train['embarked'].value_counts()<filter> | data.drop('AgeBand', axis=1, inplace=True)
data.drop('Age', axis=1, inplace=True)
data.head() | Titanic - Machine Learning from Disaster |
1,388,734 | train[train['embarked'].isnull() ]<categorify> | def fare_group(x):
if x <= 7.854:
return 0
elif x > 7.854 and x <= 10.5:
return 1
elif x > 10.5 and x <= 21.679:
return 2
elif x > 21.679 and x <= 39.688:
return 3
else:
return 4 | Titanic - Machine Learning from Disaster |
1,388,734 |
<feature_engineering> | data['FareGroup'] = data['Fare'].apply(fare_group)
data.head() | Titanic - Machine Learning from Disaster |
1,388,734 | train['embarked'] = train['embarked'].fillna('S' )<count_missing_values> | data.drop('Fare', axis=1, inplace=True)
data.drop('FareBand', axis=1, inplace=True)
data.head() | Titanic - Machine Learning from Disaster |
1,388,734 | train.isnull().sum()<count_missing_values> | data['Embarked'] = data['Embarked'].map({'S': 0, 'Q': 1, 'C': 2} ).astype(int)
data['Sex'] = data['Sex'].map({'male': 0, 'female': 1} ).astype(int)
data['NameTitle'] = data['NameTitle'].map({'Mr.': 0, 'Other.': 1, 'Master.': 2, 'Miss.': 3, 'Mrs.': 4} ).astype(int)
data.head() | Titanic - Machine Learning from Disaster |
1,388,734 | train.isnull().sum()<count_values> | data.drop('Sex', axis=1, inplace=True)
data.head() | Titanic - Machine Learning from Disaster |
1,388,734 | train['survived'].value_counts()<sort_values> | data['FamilySize'] = data['SibSp'] + data['Parch']
data.head() | Titanic - Machine Learning from Disaster |
1,388,734 | train[['pclass','survived']].groupby(['pclass'],as_index=False ).mean().sort_values(by='survived',ascending=False )<sort_values> | data.drop('SibSp', axis=1, inplace=True)
data.drop('Parch', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
1,388,734 | train[['sex','survived']].groupby(['sex'],as_index=False ).mean().sort_values(by='survived',ascending=False )<count_values> | X = data[data.columns[1:]]
y = data[data.columns[0]]
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42 ) | Titanic - Machine Learning from Disaster |
1,388,734 | train.sibsp.value_counts()<sort_values> | label = ['Linear SVM', 'Radial SVM', 'Decision Tree', 'Random Forest', 'Logistic Regression']
models = [svm.LinearSVC() , svm.SVC() , DecisionTreeClassifier() , RandomForestClassifier(n_estimators=100), LogisticRegression() ]
accuracy = []
fscore = []
for model in models:
model.fit(X_train, y_train)
prediction = model... | Titanic - Machine Learning from Disaster |
1,388,734 | train[["sibsp", "survived"]].groupby(['sibsp'], as_index=False ).mean().sort_values(by='survived', ascending=False )<count_values> | cv_accuracy = []
cv_std = []
kfold = KFold(n_splits=10, random_state=23)
for model in models:
cv_result = cross_val_score(model, X, y, cv=kfold)
cv_accuracy.append(cv_result.mean())
cv_std.append(cv_result.std())
model_df['cv_accuracy'] = cv_accuracy
model_df['cv_std'] = cv_std
model_df | Titanic - Machine Learning from Disaster |
1,388,734 | train.parch.value_counts()<sort_values> | estimators = [10, 100, 500, 1000]
criterions = ['gini', 'entropy']
bootstraps = [True, False]
parameters = {'n_estimators': estimators, 'criterion': criterions, 'bootstrap': bootstraps}
gd = GridSearchCV(RandomForestClassifier(random_state=23), parameters)
gd.fit(X, y)
print("Best Score: ", gd.best_score_)
print("Be... | Titanic - Machine Learning from Disaster |
1,388,734 | train[["parch", "survived"]].groupby(['parch'], as_index=False ).mean().sort_values(by='survived', ascending=False )<categorify> | n_estimators = list(range(100,1100,100))
learn_rate = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1]
hyper={'n_estimators':n_estimators,'learning_rate':learn_rate}
gd=GridSearchCV(estimator=AdaBoostClassifier(random_state=23),param_grid=hyper,verbose=True)
gd.fit(X, y)
print("Best Score: ", gd.best_score_)
print("Best Mode... | Titanic - Machine Learning from Disaster |
1,388,734 | sex = pd.get_dummies(train['sex'],drop_first=True)
sex.head()<categorify> | n_estimators = list(range(100,1100,100))
learn_rate = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1]
depth = [1,2,3]
hyper={'n_estimators':n_estimators,'learning_rate':learn_rate,'max_depth':depth}
gd=GridSearchCV(estimator=GradientBoostingClassifier(random_state=23),param_grid=hyper,verbose=True)
gd.fit(X, y)
print("Best S... | Titanic - Machine Learning from Disaster |
1,388,734 | pclass = pd.get_dummies(train['pclass'],drop_first= True)
pclass.head()<categorify> | n_estimators = list(range(100,1100,100))
learn_rate = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1]
gd=GridSearchCV(estimator=XGBClassifier(random_state=23),param_grid=hyper,verbose=True)
gd.fit(X, y)
print("Best Score: ", gd.best_score_)
print("Best Model: ", gd.best_estimator_ ) | Titanic - Machine Learning from Disaster |
1,388,734 | embarked = pd.get_dummies(train['embarked'],drop_first= True)
embarked.head()<concatenate> | f,(ax1, ax2)= plt.subplots(2,2,figsize=(15,7))
model1 = RandomForestClassifier(bootstrap=True, class_weight=None, criterion='entropy',
max_depth=None, max_features='auto', max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=1, min_samples_split=2,
min_weight_fraction_leaf=0.0, n_es... | Titanic - Machine Learning from Disaster |
1,388,734 | final_train = pd.concat([train,sex,pclass,embarked],axis = 1)
final_train.head()<drop_column> | test = pd.read_csv('.. /input/test.csv')
test.head() | Titanic - Machine Learning from Disaster |
1,388,734 | final_train = final_train.drop(['sex','embarked','pclass'],axis = 1 )<rename_columns> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
1,388,734 | final_train.columns = ['survived','age','sibsp','parch','fare','sex_male','pclass_2','pclass_3','embarked_q','embarked_s']
final_train.head()<count_missing_values> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
1,388,734 | test.isnull().sum()<count_missing_values> | test['NameTitle'] = test['Name'].apply(extract_title)
fix_title(test)
test.loc[test['Age'].isnull() & test['NameTitle'].str.contains('Master.'), 'Age'] = 5
test.loc[test['Age'].isnull() & test['NameTitle'].str.contains('Miss.'), 'Age'] = 22
test.loc[test['Age'].isnull() & test['NameTitle'].str.contains('Mr.'), 'Age']... | Titanic - Machine Learning from Disaster |
1,388,734 | test.isnull().sum()<data_type_conversions> | test['FamilySize'] = test['SibSp'] + test['Parch']
test.head() | Titanic - Machine Learning from Disaster |
1,388,734 | test.drop(['passengerid','name','ticket'],axis=1,inplace=True)
test.drop('cabin',axis=1,inplace=True)
age_mean = test['age'].mean()
test['age'] = test['age'].fillna(age_mean)
test.isnull().sum()
<feature_engineering> | test_id = test[test.columns[0]]
test.drop('PassengerId', axis=1, inplace=True)
test.drop('Name', axis=1, inplace=True)
test.drop('Sex', axis=1, inplace=True)
test.drop('Age', axis=1, inplace=True)
test.drop('Ticket', axis=1, inplace=True)
test.drop('Fare', axis=1, inplace=True)
test.drop('Cabin', axis=1, inplace=... | 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.