kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
3,846,140 | data_raw = pd.read_csv('.. /input/titanic/train.csv')
data_val = pd.read_csv('.. /input/titanic/test.csv')
data1 = data_raw.copy(deep=True)
data_cleaner = [data1, data_val]
Target = ['Survived']<feature_engineering> | grid_svm.best_params_ | Titanic - Machine Learning from Disaster |
3,846,140 | for dataset in data_cleaner:
dataset.Age.fillna(dataset.Age.median() , inplace=True)
dataset.Embarked.fillna('S', inplace=True)
dataset.Fare.fillna(dataset.Fare.median() , inplace=True)
dataset['Family_members'] = dataset.Parch + dataset.SibSp<drop_column> | grid_svm.best_score_ | Titanic - Machine Learning from Disaster |
3,846,140 | data1.drop(['Name', 'PassengerId', 'Ticket', 'SibSp', 'Parch'], axis=1, inplace=True )<drop_column> | from sklearn.linear_model import LogisticRegression | Titanic - Machine Learning from Disaster |
3,846,140 | for dataset in data_cleaner:
dataset['Cabin_Allotted'] = np.where(dataset.Cabin.isnull() , 0, 1)
dataset.drop('Cabin', axis=1, inplace=True )<categorify> | clf_lr = LogisticRegression() | Titanic - Machine Learning from Disaster |
3,846,140 | lb = LabelEncoder()
for dataset in data_cleaner:
dataset['Sex_labeled'] = lb.fit_transform(dataset.Sex)
dataset['AgeBin'] = pd.qcut(dataset.Age, 3)
dataset['Age_labeled'] = lb.fit_transform(dataset['AgeBin'])
dataset['FareBin'] = pd.qcut(dataset.Fare, 4)
dataset['Fare_labeled'] = lb.fit_transform(dataset['FareBin']... | param_grid = dict(penalty = ['l2'], solver = ['newton-cg', 'lbfgs'])
param_grid | Titanic - Machine Learning from Disaster |
3,846,140 | print(data1['Age_labeled'].value_counts())
print(data1['Fare_labeled'].value_counts() )<set_options> | grid_lr = RandomizedSearchCV(clf_lr, param_grid, cv = 10, scoring='accuracy', return_train_score=True, n_iter=150)
grid_lr.fit(X, y ) | Titanic - Machine Learning from Disaster |
3,846,140 | MLA = [
ensemble.AdaBoostClassifier() ,
ensemble.BaggingClassifier() ,
ensemble.ExtraTreesClassifier() ,
ensemble.GradientBoostingClassifier() ,
ensemble.RandomForestClassifier() ,
neighbors.KNeighborsClassifier() ,
tree.DecisionTreeClassifier() ,
tree.ExtraTreeClassifier() ,
XGBClassifier(objective='binary:logistic', ... | grid_lr.best_params_ | Titanic - Machine Learning from Disaster |
3,846,140 | grid_n_estimator = [10, 50, 100, 300]
grid_ratio = [.1,.25,.5,.75, 1.0]
grid_learn = [.01,.03,.05,.1,.25]
grid_max_depth = [1, 2, 3, 4, 5, 6, 7, 8, 10, None]
grid_min_samples = [5, 10,.03,.05,.10]
grid_criterion = ['gini', 'entropy']
grid_seed = [1]
grid_param = [
[{
'learning_rate': grid_learn,
'n_estimators': grid_n_... | grid_lr.best_score_ | Titanic - Machine Learning from Disaster |
3,846,140 | model = ensemble.RandomForestClassifier(**{'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 50, 'random_state': 1})
model.fit(data1[data1_X], data1[Target].values.reshape(-1,))
predictions = model.predict(data_val[data1_X])
output = pd.DataFrame({'PassengerId': data_val.PassengerId, 'Survived': predictions})
... | from sklearn.tree import DecisionTreeClassifier | Titanic - Machine Learning from Disaster |
3,846,140 | train_df=pd.read_csv("/kaggle/input/titanic/train.csv")
test_df=pd.read_csv("/kaggle/input/titanic/test.csv")
gender_submission_df=pd.read_csv("/kaggle/input/titanic/gender_submission.csv")
test_PassengerId=test_df["PassengerId"]<sort_values> | clf_dt = DecisionTreeClassifier() | Titanic - Machine Learning from Disaster |
3,846,140 | train_df[["Pclass","Survived"]].groupby(["Pclass"],as_index=False ).mean().sort_values(by="Survived",ascending=False )<sort_values> | param_grid = dict(criterion = ['entropy'], max_depth = [6])
param_grid
| Titanic - Machine Learning from Disaster |
3,846,140 | train_df[["Sex","Survived"]].groupby(["Sex"],as_index=False ).mean().sort_values(by="Survived",ascending=False )<sort_values> | grid_tree = GridSearchCV(clf_dt, param_grid, cv = 10, scoring='accuracy', return_train_score=False)
grid_tree.fit(X, y ) | Titanic - Machine Learning from Disaster |
3,846,140 | train_df[["SibSp","Survived"]].groupby(["SibSp"],as_index=False ).mean().sort_values(by="Survived",ascending=False )<sort_values> | grid_tree.best_params_ | Titanic - Machine Learning from Disaster |
3,846,140 | train_df[["Parch","Survived"]].groupby(["Parch"],as_index=False ).mean().sort_values(by="Survived",ascending=False )<features_selection> | grid_tree.best_score_ | Titanic - Machine Learning from Disaster |
3,846,140 | train_df.columns[train_df.isnull().any() ]<features_selection> | from sklearn.ensemble import GradientBoostingClassifier | Titanic - Machine Learning from Disaster |
3,846,140 | test_df.columns[test_df.isnull().any() ]<concatenate> | clf_gb = GradientBoostingClassifier() | Titanic - Machine Learning from Disaster |
3,846,140 | train_df_len=len(train_df)
train_df=pd.concat([train_df,test_df],axis=0 ).reset_index(drop=True )<features_selection> | param_grid = dict(loss = ['exponential'], learning_rate = [0.2], n_estimators = [21], max_depth = [4])
param_grid | Titanic - Machine Learning from Disaster |
3,846,140 | train_df.columns[train_df.isnull().any() ]<count_missing_values> | grid_gb = GridSearchCV(clf_gb, param_grid, cv = 10, scoring='accuracy', return_train_score=False)
grid_gb.fit(X, y ) | Titanic - Machine Learning from Disaster |
3,846,140 | train_df.isnull().sum()<filter> | grid_gb.best_params_ | Titanic - Machine Learning from Disaster |
3,846,140 | train_df[train_df["Embarked"].isnull() ]<feature_engineering> | grid_gb.best_score_ | Titanic - Machine Learning from Disaster |
3,846,140 | train_df["Embarked"]=train_df["Embarked"].fillna("C" )<filter> | from sklearn.ensemble import AdaBoostClassifier | Titanic - Machine Learning from Disaster |
3,846,140 | train_df[train_df["Embarked"].isnull() ]<filter> | clf_ab = AdaBoostClassifier() | Titanic - Machine Learning from Disaster |
3,846,140 | train_df[train_df["Fare"].isnull() ]<feature_engineering> | param_grid = dict(n_estimators = [65], algorithm = ['SAMME'])
param_grid | Titanic - Machine Learning from Disaster |
3,846,140 | train_df["Embarked"]=train_df["Embarked"].fillna("C" )<feature_engineering> | grid_ab = GridSearchCV(clf_ab, param_grid, cv = 10, scoring='accuracy', return_train_score=False)
grid_ab.fit(X, y ) | Titanic - Machine Learning from Disaster |
3,846,140 | train_df.Fare[1043]=train_df[train_df["Pclass"]==3].Fare.mean()<filter> | grid_ab.best_params_ | Titanic - Machine Learning from Disaster |
3,846,140 | train_df[train_df["Age"].isnull() ]<count_values> | grid_ab.best_score_ | Titanic - Machine Learning from Disaster |
3,846,140 | train_df.Sex.value_counts()<define_variables> | from sklearn.ensemble import VotingClassifier | Titanic - Machine Learning from Disaster |
3,846,140 | index_nan_age=list(train_df["Age"][train_df["Age"].isnull() ].index )<define_variables> | eclf_hard = VotingClassifier(estimators = [('knn', grid_knn),('forest', grid_forest),('svm', grid_svm),
('Logistic', grid_lr),('tree', grid_tree),
('GradientBoost', grid_gb),
('AdaBoost', grid_ab)], voting='hard', weights=[2, 1, 2.5, 0.8, 3, 3.5, 1] ) | Titanic - Machine Learning from Disaster |
3,846,140 | for i in index_nan_age:
age_predict=train_df["Age"][(( train_df["SibSp"]==train_df.iloc[i]["SibSp"])&(train_df["Parch"]==train_df.iloc[i]["Parch"])&(train_df["Pclass"]==train_df.iloc[i]["Pclass"])) ].median()
age_med=train_df["Age"].median()
if not np.isnan(age_predict):
train_df["Age"].iloc[i]=age_predict
else:
train_... | eclf_hard = eclf_hard.fit(X, y ) | Titanic - Machine Learning from Disaster |
3,846,140 | train_df[train_df["Age"].isnull() ]<string_transform> | y_pred = eclf_hard.predict(X_t ) | Titanic - Machine Learning from Disaster |
3,846,140 | s="Braund, Mr.Owen Harris"
s.split("." )<string_transform> | sub = pd.DataFrame(y_pred, columns=['Survived'] ) | Titanic - Machine Learning from Disaster |
3,846,140 | s.split(".")[0].split("," )<string_transform> | titanic = pd.read_csv(".. /input/test.csv" ) | Titanic - Machine Learning from Disaster |
3,846,140 | s.split(".")[0].split(",")[1]<string_transform> | submission = pd.concat([titanic['PassengerId'], sub], axis=1 ) | Titanic - Machine Learning from Disaster |
3,846,140 | s.split(".")[0].split(",")[-1]<feature_engineering> | submission.to_csv('sub.csv', index=False ) | Titanic - Machine Learning from Disaster |
2,615,952 | name=train_df["Name"]
train_df["Title"]=[ i.split(".")[0].split(",")[-1].strip() for i in name]<count_values> | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv')
test_df.head() | Titanic - Machine Learning from Disaster |
2,615,952 | train_df["Title"].value_counts()<feature_engineering> | train_df.isnull().sum() / len(train_df)*100 | Titanic - Machine Learning from Disaster |
2,615,952 | train_df["Title"]=train_df["Title"].replace(["Lady","the Countess","Capt","Col","Don","Dr","Major","Rev","Sir","Jonkheer","Dona"],"other" )<count_values> | test_df.isnull().sum() / len(test_df)*100 | Titanic - Machine Learning from Disaster |
2,615,952 | train_df["Title"].value_counts()<feature_engineering> | train_df['Sex'].value_counts() | Titanic - Machine Learning from Disaster |
2,615,952 | train_df["Title"]=[0 if i == "Master" else 1 if i== "Miss" or i=="Ms" or i=="Mlle" or i=="Mrs" else 2 if i=="Mr" else 3 for i in train_df["Title"]]<drop_column> | train_df.groupby('Sex',as_index=False ).Survived.mean() | Titanic - Machine Learning from Disaster |
2,615,952 | train_df.drop(labels=["Name"],axis=1,inplace=True )<categorify> | train_df[['Pclass','Survived']].groupby(['Pclass'],as_index=False ).mean().sort_values(by='Survived',ascending = False ) | Titanic - Machine Learning from Disaster |
2,615,952 | train_df=pd.get_dummies(train_df,columns=["Title"] )<feature_engineering> | train_df[["Embarked", "Survived"]].groupby(['Embarked'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
2,615,952 | train_df["Fsize"]=train_df["SibSp"] + train_df["Parch"] + 1<feature_engineering> | train_df[['Parch','Survived']].groupby(['Parch'],as_index=False ).mean().sort_values(by='Survived',ascending=False ) | Titanic - Machine Learning from Disaster |
2,615,952 | train_df["family-size"]=[1 if i<5 else 0 for i in train_df["Fsize"]]<categorify> | train_df[["SibSp", "Survived"]].groupby(['SibSp'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
2,615,952 | train_df=pd.get_dummies(train_df,columns=["family-size"] )<categorify> | train_df.groupby('Sex',as_index='False')['Age'].median() | Titanic - Machine Learning from Disaster |
2,615,952 | train_df=pd.get_dummies(train_df,columns=["Embarked"] )<define_variables> | drop_list=['Cabin','Ticket','PassengerId']
train_df = train_df.drop(drop_list,axis=1)
test_passenger_df = pd.DataFrame(test_df.PassengerId)
test_df = test_df.drop(drop_list,axis=1)
test_passenger_df.head() | Titanic - Machine Learning from Disaster |
2,615,952 | a=" A./5.2152"<feature_engineering> | train_df.Embarked.fillna('S',inplace=True ) | Titanic - Machine Learning from Disaster |
2,615,952 | tickets=[]
for i in list(train_df.Ticket):
if not i.isdigit() :
tickets.append(i.replace(".","" ).replace("/","" ).strip().split() [0])
else:
tickets.append("x")
train_df["Ticket"]=tickets<categorify> | train_df.Age.fillna(28, inplace=True)
test_df.Age.fillna(28, inplace=True ) | Titanic - Machine Learning from Disaster |
2,615,952 | train_df=pd.get_dummies(train_df,columns=["Ticket"],prefix="T" )<data_type_conversions> | test_df.Fare.fillna(test_df.Fare.median() , inplace=True ) | Titanic - Machine Learning from Disaster |
2,615,952 | train_df["Pclass"]=train_df["Pclass"].astype("category" )<categorify> | Combined_data = [train_df, test_df]
Combined_data | Titanic - Machine Learning from Disaster |
2,615,952 | train_df=pd.get_dummies(train_df,columns=["Pclass"] )<data_type_conversions> | for dataset in Combined_data:
dataset['Title'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
2,615,952 | train_df.Sex=train_df.Sex.astype("category" )<count_values> | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Special": 5}
for dataset in Combined_data:
dataset['Title'] = dataset.Title.map(title_mapping)
dataset['Title'] = dataset.Title.fillna(0 ) | Titanic - Machine Learning from Disaster |
2,615,952 | train_df.Sex.value_counts()<categorify> | for dataset in Combined_data:
dataset["Family"] = dataset['SibSp'] + dataset['Parch']
dataset["IsAlone"] = np.where(dataset["Family"] > 0, 0,1)
dataset.drop('Family',axis=1,inplace=True)
train_df.head() | Titanic - Machine Learning from Disaster |
2,615,952 | train_df=pd.get_dummies(train_df,columns=["Sex"] )<drop_column> | for dataset in Combined_data:
dataset.drop(['SibSp','Parch','Name'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
2,615,952 | train_df.drop(labels=["PassengerId", "Cabin"],axis=1, inplace=True )<drop_column> | for dataset in Combined_data:
dataset["IsMinor"] = np.where(dataset["Age"] < 15, 1, 0 ) | Titanic - Machine Learning from Disaster |
2,615,952 | train_df.drop(labels=["SibSp", "Parch"],axis=1, inplace=True )<count_values> | train_df['Old_Female'] =(train_df['Age']>50)&(train_df['Sex']=='female')
train_df['Old_Female'] = train_df['Old_Female'].astype(int)
test_df['Old_Female'] =(test_df['Age']>50)&(test_df['Sex']=='female')
test_df['Old_Female'] = test_df['Old_Female'].astype(int ) | Titanic - Machine Learning from Disaster |
2,615,952 | train_df.Sex_0.value_counts()<import_modules> | train_df2 = pd.get_dummies(train_df,columns=['Pclass','Sex','Embarked'],drop_first=True)
test_df2 = pd.get_dummies(test_df,columns=['Pclass','Sex','Embarked'],drop_first=True)
train_df2.head() | Titanic - Machine Learning from Disaster |
2,615,952 | from sklearn.model_selection import train_test_split, StratifiedKFold, GridSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTr... | from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
2,615,952 | test=train_df[train_df_len:]<drop_column> | X = train_df2.drop("Survived",axis=1)
y = train_df2["Survived"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,random_state=42 ) | Titanic - Machine Learning from Disaster |
2,615,952 | test.drop(labels=["Survived"], axis=1, inplace=True )<split> | logreg = LogisticRegression()
logreg.fit(X_train,y_train)
y_pred = logreg.predict(X_test)
acc_logreg = round(accuracy_score(y_pred, y_test)* 100, 2)
acc_logreg | Titanic - Machine Learning from Disaster |
2,615,952 | train=train_df[:train_df_len]
X_train= train.drop(labels=["Survived"],axis=1)
y_train=train.Survived
print("X_train",len(X_train))
print("y_train",len(y_train))
X_train, X_test, y_train, y_test=train_test_split(X_train, y_train, test_size=0.10, random_state=42)
print("X_train",len(X_train))
print("X_test",len(X_test)... | cv_scores = cross_val_score(logreg,X,y,cv=5)
np.mean(cv_scores)*100 | Titanic - Machine Learning from Disaster |
2,615,952 | logreg=LogisticRegression(solver ='lbfgs',multi_class ='multinomial',max_iter = 500)
logreg.fit(X_train,y_train )<compute_test_metric> | decisiontree = DecisionTreeClassifier()
dep = np.arange(1,10)
param_grid = {'max_depth' : dep}
clf_cv = GridSearchCV(decisiontree, param_grid=param_grid, cv=5)
clf_cv.fit(X, y)
clf_cv.best_params_,clf_cv.best_score_*100
print('Best value of max_depth:',clf_cv.best_params_)
print('Best score:',clf_cv.best_score_*100... | Titanic - Machine Learning from Disaster |
2,615,952 | acc_log_train=round(logreg.score(X_train,y_train)*100,2 )<compute_test_metric> | random_forest = RandomForestClassifier()
ne = np.arange(1,20)
param_grid = {'n_estimators':ne}
rf_cv = GridSearchCV(random_forest,param_grid,cv=5)
rf_cv.fit(X, y)
print('Best value of n_estimators:',rf_cv.best_params_)
print('Best score:',rf_cv.best_score_*100 ) | Titanic - Machine Learning from Disaster |
2,615,952 | acc_log_test=round(logreg.score(X_test,y_test)*100,2 )<train_model> | gbk = GradientBoostingClassifier()
ne = np.arange(1,20)
dep = np.arange(1,10)
param_grid = {'n_estimators' : ne,'max_depth' : dep}
gbk_cv = GridSearchCV(gbk,param_grid=param_grid,cv=5)
gbk_cv.fit(X, y)
print('Best value of parameters:',gbk_cv.best_params_)
print('Best score:',gbk_cv.best_score_*100 ) | Titanic - Machine Learning from Disaster |
2,615,952 | print("Training accuracy {}".format(acc_log_train))
print("Test accuracy {}".format(acc_log_test))<train_model> | y_final = gbk_cv.predict(test_df2)
y_final | Titanic - Machine Learning from Disaster |
2,615,952 | nb=GaussianNB()
nb.fit(X_train,y_train)
acc_nb_train=round(nb.score(X_train,y_train)*100,2)
acc_nb_test=round(nb.score(X_test,y_test)*100,2)
print(acc_nb_train)
print(acc_nb_test)
<choose_model_class> | df = pd.DataFrame({"PassengerId": test_passenger_df["PassengerId"],"Survived": y_final})
df | Titanic - Machine Learning from Disaster |
2,615,952 | random_state=42
classifier=[DecisionTreeClassifier(random_state=random_state),
SVC(random_state=random_state),
RandomForestClassifier(random_state=random_state),
LogisticRegression(random_state=random_state),
KNeighborsClassifier() ]
dt_param_grid={"min_samples_split": range(10,500,20),
"max_depth": range(1,20,2)}
svc_... | df.to_csv('Survived.csv', index=False ) | Titanic - Machine Learning from Disaster |
2,324,043 | range(len(classifier))<train_on_grid> | warnings.filterwarnings('ignore')
%matplotlib inline | Titanic - Machine Learning from Disaster |
2,324,043 | cv_result=[]
best_estimators=[]
for i in range(len(classifier)) :
clf=GridSearchCV(classifier[i],param_grid=classifier_param[i],
cv=StratifiedKFold(n_splits=10),scoring="accuracy",
n_jobs=-1,
verbose=1
)
clf.fit(X_train,y_train)
cv_result.append(clf.best_score_)
best_estimators.append(clf.best_estimator_)
print(cv... | train_data = pd.read_csv(".. /input/train.csv")
train_data.columns | Titanic - Machine Learning from Disaster |
2,324,043 | votingC=VotingClassifier(estimators=[("dt",best_estimators[0]),
("rfc",best_estimators[2]),
("lr",best_estimators[3])],
voting="soft",n_jobs=-1)
votingC=votingC.fit(X_train,y_train)
print(accuracy_score(votingC.predict(X_test),y_test))<save_to_csv> | test = pd.read_csv(".. /input/test.csv")
IDtest = test["PassengerId"]
| Titanic - Machine Learning from Disaster |
2,324,043 | test_survived=pd.Series(votingC.predict(test),name="Survived")
results=pd.concat([test_PassengerId,test_survived],axis=1)
results.to_csv("titanic.csv",index=False )<save_to_csv> | train_data.drop(['PassengerId','Ticket'], axis=1, inplace = True)
| Titanic - Machine Learning from Disaster |
2,324,043 | test_survived=pd.Series(votingC.predict(test),name="Survived" ).astype(int)
results=pd.concat([test_PassengerId,test_survived],axis=1)
results.to_csv("titanic.csv",index=False )<load_from_csv> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
2,324,043 | train_df = pd.read_csv("/kaggle/input/titanic/train.csv")
train_df.head()<load_from_csv> | train_data["Embarked"] = train_data["Embarked"].fillna("C")
test["Embarked"] = test["Embarked"].fillna("C")
train_data['Fare'].fillna(train_data['Fare'].median() , inplace = True)
test['Fare'].fillna(test['Fare'].median() , inplace = True)
train_data.Cabin.fillna("N", inplace=True)
test.Cabin.fillna("N", inplace=T... | Titanic - Machine Learning from Disaster |
2,324,043 | test_df = pd.read_csv("/kaggle/input/titanic/test.csv")
test_df.head()<sort_values> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
2,324,043 | train_df[['Sex', 'Survived']].groupby(['Sex'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<sort_values> | train_title = [i.split(",")[1].split(".")[0].strip() for i in train_data["Name"]]
train_data["Title"] = pd.Series(train_title)
train_data["Title"].head() | Titanic - Machine Learning from Disaster |
2,324,043 | train_df[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<sort_values> | test_title = [i.split(",")[1].split(".")[0].strip() for i in test["Name"]]
test["Title"] = pd.Series(test_title)
test["Title"].head() | Titanic - Machine Learning from Disaster |
2,324,043 | train_df[['SibSp', 'Survived']].groupby(['SibSp'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<sort_values> | train_data["Title"] = train_data["Title"].replace(['Lady', 'the Countess','Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
train_data["Title"] = train_data["Title"].map({"Master":0, "Miss":1, "Ms" : 1 , "Mme":1, "Mlle":1, "Mrs":1, "Mr":2, "Rare":3})
train_data["Title"] = train... | Titanic - Machine Learning from Disaster |
2,324,043 | train_df[['Parch', 'Survived']].groupby(['Parch'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<sort_values> | test["Title"] = test["Title"].replace(['Lady', 'the Countess','Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
test["Title"] = test["Title"].map({"Master":0, "Miss":1, "Ms" : 1 , "Mme":1, "Mlle":1, "Mrs":1, "Mr":2, "Rare":3})
test["Title"] = test["Title"].astype(int ) | Titanic - Machine Learning from Disaster |
2,324,043 | train_df[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False ).mean().sort_values(by='Survived', ascending=False)
<define_variables> | train_data["Family_size"] = train_data["SibSp"] + train_data["Parch"] + 1
test["Family_size"] = test["SibSp"] + test["Parch"] + 1
| Titanic - Machine Learning from Disaster |
2,324,043 | all_df = [train_df, test_df]<data_type_conversions> | train_data['survived_dead'] = train_data['Survived'].apply(lambda x : 'Survived' if x == 1 else 'Dead' ) | Titanic - Machine Learning from Disaster |
2,324,043 | for df in all_df:
df['Sex'] = df['Sex'].map({'male': 0, 'female': 1} ).astype(int)
train_df.head()<data_type_conversions> | lbl = LabelEncoder()
lbl.fit(list(train_data['Embarked'].values))
train_data['Embarked'] = lbl.transform(list(train_data['Embarked'].values))
lbl.fit(list(test['Embarked'].values))
test['Embarked'] = lbl.transform(list(test['Embarked'].values)) | Titanic - Machine Learning from Disaster |
2,324,043 | common_Pclass = 'S'
train_df['Embarked'].fillna(common_Pclass, inplace=True)
train_df['Embarked'] = train_df['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int)
test_df['Embarked'] = test_df['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int)
train_df.head()<count_missing_values> | def encode(x): return 1 if x == 'female' else 0
train_data['enc_sex'] = train_data.Sex.apply(encode)
test['enc_sex'] = test.Sex.apply(encode ) | Titanic - Machine Learning from Disaster |
2,324,043 | train_df['Cabin'].isna().sum()<data_type_conversions> | train_data["has_cabin"] = [0 if i == 'N'else 1 for i in train_data.Cabin]
test["has_cabin"] = [0 if i == 'N'else 1 for i in test.Cabin] | Titanic - Machine Learning from Disaster |
2,324,043 | train_df['Cabin'].fillna('X', inplace=True)
test_df['Cabin'].fillna('X', inplace=True )<count_values> | def detect_outliers(train_data,n,features):
outlier_indices = []
for col in features:
Q1 = np.percentile(train_data[col], 25)
Q3 = np.percentile(train_data[col],75)
IQR = Q3 - Q1
outlier_step = 1.5 * IQR
outlier_list_col = train_data[(train_data[col] < Q1 - outlier_step)|(train_data[col] > Q3 + outlier_step)].index... | Titanic - Machine Learning from Disaster |
2,324,043 | train_df['Cabin'].value_counts()<data_type_conversions> | train_data.loc[Outliers_to_drop] | Titanic - Machine Learning from Disaster |
2,324,043 | for df in all_df:
df['Cabin'] = df['Cabin'].astype(str ).str[0]
test_df['Cabin']<groupby> | train_data = train_data.drop(Outliers_to_drop, axis = 0 ).reset_index(drop=True ) | Titanic - Machine Learning from Disaster |
2,324,043 | train_df.groupby(['Survived', 'Cabin'])['PassengerId'].sum()<feature_engineering> | y_train = train_data["Survived"]
X_train = data.drop(labels = ["Survived"],axis = 1 ) | Titanic - Machine Learning from Disaster |
2,324,043 | for df in all_df:
df.loc[(df['Cabin'] == 'A'), 'Cabin'] = 0
df.loc[(df['Cabin'] == 'B'), 'Cabin'] = 1
df.loc[(df['Cabin'] == 'C'), 'Cabin'] = 1
df.loc[(df['Cabin'] == 'D'), 'Cabin'] = 1
df.loc[(df['Cabin'] == 'E'), 'Cabin'] = 1
df.loc[(df['Cabin'] == 'F'), 'Cabin'] = 0
df.loc[(df['Cabin'] == 'G'), 'Cabin'] = 0
df.loc[(... | test = test.select_dtypes(include=[np.number] ).interpolate().dropna()
test = test[X_train.columns]
| Titanic - Machine Learning from Disaster |
2,324,043 | guess_df = np.zeros(( 3,2))
guess_df<categorify> | sc = StandardScaler()
X_train = sc.fit_transform(X_train)
test = sc.transform(test ) | Titanic - Machine Learning from Disaster |
2,324,043 | for df in all_df:
for i in range(0,3):
for j in range(0,2):
guess = df[(df['Pclass']==i+1)&(df['Sex']==j)]['Age'].dropna()
guess_df[i,j] = guess.median()
for i in range(0,3):
for j in range(0,2):
df.loc[(df['Age'].isna())&(df['Pclass']==i+1)&(df['Sex']==j), 'Age'] = guess_df[i,j]
df['Age'] = df['Age'].dropna().astype(i... | kfold = StratifiedKFold(n_splits=10 ) | Titanic - Machine Learning from Disaster |
2,324,043 | for df in all_df:
df.loc[(df['Age'] <= 16), 'Age'] = 0
df.loc[(df['Age'] > 16)&(df['Age'] <= 32), 'Age'] = 1
df.loc[(df['Age'] > 32)&(df['Age'] <= 48), 'Age'] = 2
df.loc[(df['Age'] > 48)&(df['Age'] <= 64), 'Age'] = 3
df.loc[(df['Age'] > 64), 'Age'] = 4
train_df.head()<sort_values> | ExtC = ExtraTreesClassifier()
ex_param_grid = {"max_depth": [n for n in range(9, 14)],
"max_features": [1, 3, 10],
"min_samples_split": [n for n in range(4, 11)],
"min_samples_leaf": [n for n in range(2, 5)],
"bootstrap": [False],
"n_estimators" :[n for n in range(10, 60, 10)],
"criterion": ["gini"]}
gsExtC = GridSearc... | Titanic - Machine Learning from Disaster |
2,324,043 | train_df.groupby('Age', as_index=False)['Survived'].mean().sort_values(by='Age', ascending=True )<count_missing_values> | RFC = RandomForestClassifier()
rf_param_grid = {"max_depth": [n for n in range(9, 14)],
"max_features": [1, 3, 10],
"min_samples_split": [n for n in range(4, 11)],
"min_samples_leaf": [n for n in range(2, 5)],
"bootstrap": [False],
"n_estimators" :[n for n in range(10, 60, 10)],
"criterion": ["gini"]}
gsRFC = GridSearc... | Titanic - Machine Learning from Disaster |
2,324,043 | train_df.isna().sum()<drop_column> | DTC = DecisionTreeClassifier()
adaDTC = AdaBoostClassifier(DTC, random_state=7)
ada_param_grid = {"base_estimator__criterion" : ["gini", "entropy"],
"base_estimator__splitter" : ["best", "random"],
"algorithm" : ["SAMME","SAMME.R"],
"n_estimators" :[30],
"learning_rate": [0.0001, 0.001, 0.01, 0.1, 0.2, 0.3,1.5]}
gsada... | Titanic - Machine Learning from Disaster |
2,324,043 | train_df.drop(['AgeBand'], axis=1, inplace=True )<count_missing_values> | SVMC = SVC(probability=True)
svc_param_grid = {'kernel': ['rbf'],
'gamma': [ 0.001, 0.01, 0.1, 1],
'C': [1, 10, 50, 100,200,300, 1000]}
gsSVMC = GridSearchCV(SVMC,param_grid = svc_param_grid, cv=kfold, scoring="accuracy", n_jobs= 4, verbose = 1)
gsSVMC.fit(X_train,y_train)
SVMC_best = gsSVMC.best_estimator_
gsSVMC.b... | Titanic - Machine Learning from Disaster |
2,324,043 | train_df.isna().sum()<count_missing_values> | GBC = GradientBoostingClassifier()
gb_param_grid = {'loss' : ["deviance"],
'n_estimators' : [n for n in range(10, 60, 10)],
'learning_rate': [0.1, 0.05, 0.01],
'max_depth': [n for n in range(9, 14)],
'min_samples_leaf': [n for n in range(2, 5)],
'max_features': [0.3, 0.1]
}
gsGBC = GridSearchCV(GBC,param_grid = gb_para... | Titanic - Machine Learning from Disaster |
2,324,043 | test_df.isna().sum()<correct_missing_values> | votingC = VotingClassifier(estimators=[('rfc', RFC_best),('extc', ExtC_best),('svm',SVMC_best),
('gbc',GBC_best)], voting='soft', n_jobs=4)
votingC = votingC.fit(X_train, y_train)
| Titanic - Machine Learning from Disaster |
2,324,043 | <categorify><EOS> | test_Survived = pd.Series(votingC.predict(test), name="Survived")
Submission = pd.concat([IDtest,test_Survived],axis=1)
Submission.to_csv("submission.csv",index=False ) | Titanic - Machine Learning from Disaster |
1,727,523 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<drop_column> | warnings.filterwarnings('ignore')
train = pd.read_csv(".. /input/train.csv")
train_shape = train.shape
print(train_shape ) | Titanic - Machine Learning from Disaster |
1,727,523 | train_df.drop('FareBand', axis=1, inplace=True )<sort_values> | test = pd.read_csv(".. /input/test.csv")
test_shape = test.shape
print(test_shape ) | Titanic - Machine Learning from Disaster |
1,727,523 | for df in all_df:
df['FamilySize'] = df['SibSp'] + df['Parch'] + 1
train_df.groupby('FamilySize', as_index=False)['Survived'].mean().sort_values('Survived', ascending=False )<sort_values> | def process_age(df, cut_points, label_names):
df["Age"] = df["Age"].fillna(-0.5)
df["Age_categories"] = pd.cut(df["Age"], cut_points, labels=label_names)
return df
cut_points = [-1, 0, 5, 12, 18, 35, 60, 100]
label_names = ["Missing", "Infant", "Child", "Teenager", "Young Adult", "Adult", "Senior"]
train = process_ag... | Titanic - Machine Learning from Disaster |
1,727,523 | for df in all_df:
df['Family'] = 0
df.loc[(df['FamilySize'] >= 5), 'Family'] = 1
df.loc[(df['FamilySize'] > 1)&(df['FamilySize'] < 5), 'Family'] = 2
train_df.groupby('Family', as_index=False)['Survived'].mean().sort_values('Survived', ascending=False )<drop_column> | train["Pclass"].value_counts() | 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.