kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
8,659,445 | model = Net(num_classes=1, last_conv_size=1000)
def bce_accuracy(target: torch.Tensor,
preds: torch.Tensor)-> float:
thresh = 0.5
target = target.cpu().detach().numpy()
preds =(torch.sigmoid(preds ).cpu().detach().numpy() > thresh ).astype(int)
return accuracy_score(target, preds)
BCE_keker = Keker(model=model,
dataowner=dataowner,
criterion=BCEcriterion,
step_fn=step_fn,
target_key="label",
metrics={"accuracy": bce_accuracy},
opt=adabound.AdaBound,
opt_params={'final_lr':0.001} )<define_variables> | train = train.drop(outliers, axis = 0 ).reset_index(drop = True ) | Titanic - Machine Learning from Disaster |
8,659,445 | logdir = 'logs'
lrlogdir = 'lrlogs'
<set_options> | def fill_age_missing_values(df):
Age_Nan_Indices = list(df[df["Age"].isnull() ].index)
for index in Age_Nan_Indices:
temp_Pclass = df.iloc[index]["Pclass"]
temp_SibSp = df.iloc[index]["SibSp"]
temp_Parch = df.iloc[index]["Parch"]
age_median = df["Age"][(( df["Pclass"] == temp_Pclass)&(df["SibSp"] == temp_SibSp)&(df["Parch"] == temp_Parch)) ].median()
if df.iloc[index]["Age"]:
df["Age"].iloc[index] = age_median
if np.isnan(age_median):
df["Age"].iloc[index] = df["Age"].median()
return df | Titanic - Machine Learning from Disaster |
8,659,445 | BCE_keker.freeze(model_attr='net')
BCE_keker.kek(lr=0.0001,
epochs=50,
cp_saver_params={
"savedir": "bce_sueeze",
"n_best": 3,
"prefix": "bce_squeeze",
"mode": "min"},
logdir=logdir )<predict_on_test> | df["Age"].isnull().sum() | Titanic - Machine Learning from Disaster |
8,659,445 | BCE_keker.load('bce_sueeze/bce_squeeze.best.h5')
preds = BCE_keker.predict_loader(test_dl)
test_df['label'] =(torch.sigmoid(torch.Tensor(preds)) > 0.5 ).numpy()<feature_engineering> | df["Title"] = pd.Series([name.split(",")[1].split(".")[0].strip() for name in df["Name"]])
df.head() | Titanic - Machine Learning from Disaster |
8,659,445 | test_df['id'] = test_df['id'].apply(lambda x: x.split('.')[0])
test_df['label'] = test_df['label'].apply(lambda x: 'cleaned' if x==1 else 'dirty' )<save_to_csv> | df["Title"] = df["Title"].replace(['Lady', 'the Countess', 'Countess', 'Don', 'Jonkheer', 'Dona', 'Sir'], 'Royals')
df["Title"] = df["Title"].replace(['Col', 'Dr', 'Major', 'Capt'], 'Professionals')
df["Title"] = df["Title"].replace(["Ms", "Mme", "Mlle", "Mrs"], 'Miss')
df["Title"] = df["Title"].replace(['Master', 'Rev'], 'Mas/Rev')
df["Title"] = df["Title"].map({"Mas/Rev": 0, "Miss": 1, "Mr": 2, "Royals": 3, "Professionals": 4} ) | Titanic - Machine Learning from Disaster |
8,659,445 | test_df.to_csv('sub.csv', index=False )<import_modules> | df["Ftotal"] = 1 + df["SibSp"] + df["Parch"] | Titanic - Machine Learning from Disaster |
8,659,445 | import numpy as np
import pandas as pd
import math
import xgboost as xgb
from xgboost import XGBClassifier
from sklearn import preprocessing
from sklearn.model_selection import KFold
from sklearn.metrics import accuracy_score<load_from_csv> | df["Age"] = df["Age"].astype(int)
df.loc[(df['Age'] <= 2), 'Age Group'] = 'Baby'
df.loc[(( df["Age"] > 2)&(df['Age'] <= 10)) , 'Age Group'] = 'Child'
df.loc[(( df["Age"] > 10)&(df['Age'] <= 19)) , 'Age Group'] = 'Young Adult'
df.loc[(( df["Age"] > 19)&(df['Age'] <= 60)) , 'Age Group'] = 'Adult'
df.loc[(df["Age"] > 60), 'Age Group'] = 'Senior'
df["Age Group"] = df["Age Group"].map({"Baby": 0, "Child": 1, "Young Adult": 2, "Adult": 3, "Senior": 4} ) | Titanic - Machine Learning from Disaster |
8,659,445 | df_train = pd.read_csv('.. /input/train.csv')
df_test = pd.read_csv('.. /input/test.csv' )<define_variables> | df["Sex"] = df["Sex"].map({"male": 0, "female": 1})
df.sample(5 ) | Titanic - Machine Learning from Disaster |
8,659,445 | labels = df_train['diabetes']<drop_column> | df["Embarked"] = df["Embarked"].map({"C": 0, "Q": 1, "S": 2})
df.sample(5 ) | Titanic - Machine Learning from Disaster |
8,659,445 | df_train.drop(columns=['p_id', 'diabetes'], axis=1, inplace=True)
df_test.drop(columns=['p_id'], axis=1, inplace=True )<normalization> | passenger_ID = pd.Series(df["PassengerId"], name = "PassengerId")
df = df.drop(["Name", "PassengerId", "SibSp", "Parch", "Age", "Ticket"], axis=1)
df.sample(5 ) | Titanic - Machine Learning from Disaster |
8,659,445 | min_max_scaler = preprocessing.MinMaxScaler()<normalization> | df = pd.get_dummies(df, columns = ["Title"])
df = pd.get_dummies(df, columns = ["Embarked"])
df = pd.get_dummies(df, columns = ["Pclass"])
df = pd.get_dummies(df, columns = ["Age Group"] ) | Titanic - Machine Learning from Disaster |
8,659,445 | scaler = min_max_scaler.fit(df_train)
X_train_scaled = min_max_scaler.transform(df_train)
train = pd.DataFrame(X_train_scaled, columns=df_train.columns)
X_test_scaled = min_max_scaler.transform(df_test)
test = pd.DataFrame(X_test_scaled, columns=df_train.columns )<compute_train_metric> | train = df[:train.shape[0]]
test = df[train.shape[0]:].drop(["Survived"], axis = 1 ) | Titanic - Machine Learning from Disaster |
8,659,445 | def xgb_CV(X, y, X_test, folds, params):
prediction = np.zeros(len(X_test))
scores = []
for fold_n,(train_index, valid_index)in enumerate(folds.split(X)) :
X_train, X_valid = X.iloc[train_index], X.iloc[valid_index]
y_train, y_valid = y.iloc[train_index], y.iloc[valid_index]
train_data = xgb.DMatrix(data=X_train, label=y_train, feature_names=X.columns)
valid_data = xgb.DMatrix(data=X_valid, label=y_valid, feature_names=X.columns)
watchlist = [(train_data, 'train'),(valid_data, 'valid_data')]
model = xgb.train(dtrain=train_data, num_boost_round=20000, evals=watchlist, \
early_stopping_rounds=200, verbose_eval=150, params=params)
y_pred_valid = model.predict(xgb.DMatrix(X_valid, feature_names=X.columns), ntree_limit=model.best_ntree_limit)
y_pred = model.predict(xgb.DMatrix(X_test, feature_names=X.columns), ntree_limit=model.best_ntree_limit)
scores.append(accuracy_score(y_valid, y_pred_valid))
prediction += y_pred
print('CV mean score: {0:.4f}, std: {1:.4f}.'.format(np.mean(scores), np.std(scores)))
prediction /= n_fold
return prediction<compute_train_metric> | k_fold = StratifiedKFold(n_splits=5)
X_train = train.drop(labels="Survived", axis=1)
y_train = train["Survived"]
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
LG_classifier = LogisticRegression(random_state=0)
SVC_classifier = SVC(kernel="rbf", random_state=0)
KNN_classifier = KNeighborsClassifier()
NB_classifier = GaussianNB()
DT_classifier = DecisionTreeClassifier(criterion="entropy", random_state=0)
RF_classifier = RandomForestClassifier(n_estimators=200, criterion="entropy", random_state=0)
titanic_classifiers = [LG_classifier, SVC_classifier, KNN_classifier, NB_classifier, DT_classifier, RF_classifier]
classifier_dict = {
0: "Logistic Regression",
1: "Support Vector Classfication",
2: "K Nearest Neighbor Classification",
3: "Naive bayes Classifier",
4: "Decision Trees Classifier",
5: "Random Forest Classifier",
}
titanic_results = pd.DataFrame({'Model': [],'Mean Accuracy': [], "Standard Deviation": []})
for i, classifier in enumerate(titanic_classifiers):
classifier_scores = cross_val_score(classifier, X_train, y_train, cv=k_fold, n_jobs=2, scoring="accuracy")
titanic_results = titanic_results.append(pd.DataFrame({"Model":[classifier_dict[i]],
"Mean Accuracy": [classifier_scores.mean() ],
"Standard Deviation": [classifier_scores.std() ]})) | Titanic - Machine Learning from Disaster |
8,659,445 | params = {'eta': 0.01,
'max_depth': 4,
'subsample': 0.05,
'colsample_bytree': 0.05,
'min_child_weight' : 1,
'objective': 'binary:hinge',
'eval_metric': 'error',
'silent': True,
'nthread': 4}
n_fold = 10
folds = KFold(n_splits=n_fold, shuffle=True, random_state=11)
predictions = xgb_CV(train, labels, test, folds, params )<prepare_output> | print(titanic_results.to_string(index=False)) | Titanic - Machine Learning from Disaster |
8,659,445 | preds = np.where(predictions > 0.5, 1, 0)
preds<save_to_csv> | RF_classifier = RandomForestClassifier()
RF_paramgrid = {"max_depth": [None],
"max_features": [1, 3, 10],
"min_samples_split": [2, 3, 10],
"min_samples_leaf": [1, 3, 10],
"bootstrap": [False],
"n_estimators" :[100,200,300],
"criterion": ["entropy"]}
RF_classifiergrid = GridSearchCV(RF_classifier, param_grid = RF_paramgrid, cv=k_fold, scoring="accuracy", n_jobs= -1, verbose=1)
RF_classifiergrid.fit(X_train,y_train)
RFC_optimum = RF_classifiergrid.best_estimator_
RF_classifiergrid.best_score_ | Titanic - Machine Learning from Disaster |
8,659,445 | df_submission = pd.read_csv('.. /input/sample_submission.csv')
df_submission['diabetes'] = preds
df_submission.to_csv('my_submission.csv', index=False )<compute_train_metric> | IDtest = passenger_ID[train.shape[0]:].reset_index(drop = True ) | Titanic - Machine Learning from Disaster |
8,659,445 | def get_metrics(x, y, e):
z = e.predict(x)
print(classification_report(z, y, digits=4))<set_options> | X_train = train.drop(labels="Survived", axis=1)
y_train = train["Survived"]
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.fit_transform(test)
RFC_optimum.fit(X_train, y_train)
test_predictions = pd.Series(RFC_optimum.predict(X_test ).astype(int), name="Survived")
titanic_results = pd.concat([IDtest, test_predictions], axis = 1)
titanic_results.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
5,455,381 | warnings.filterwarnings('ignore' )<load_from_csv> | df_trainval=pd.read_csv("/kaggle/input/titanic/train.csv")
df_test=pd.read_csv("/kaggle/input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
5,455,381 | flight = pd.read_csv(".. /input/datavidia2019/flight.csv")
test = pd.read_csv(".. /input/datavidia2019/test.csv")
hotel = pd.read_csv(".. /input/datavidia2019/hotel.csv" )<feature_engineering> | df_trainval_C=df_trainval.copy() | Titanic - Machine Learning from Disaster |
5,455,381 | def preprocess_city_trx(df):
df["v_city_proc"] = df.visited_city.map(lambda x: ast.literal_eval(x.strip("''")))
df["log_trx_proc"] = df.log_transaction.map(lambda x: ast.literal_eval(x.strip("''")))
return df
preprocess_city_trx(test)
preprocess_city_trx(flight ).head()<create_dataframe> | print("% Of Males Survived:",(((((df_trainval["Sex"]=="male")&(df_trainval["Survived"]==1)).astype(int)).sum())/(df_trainval["Sex"]=="male" ).astype(int ).sum())*100,"%")
print("% Of Females Survived:",(((((df_trainval["Sex"]=="female")&(df_trainval["Survived"]==1)).astype(int)).sum())/(df_trainval["Sex"]=="female" ).astype(int ).sum())*100,"%")
fig, ax = plt.subplots(figsize=(8, 5))
sns.countplot(df_trainval['Survived'],hue=df_trainval["Sex"])
plt.title('Survived labels values')
plt.show() | Titanic - Machine Learning from Disaster |
5,455,381 | missing_data = pd.DataFrame({'total_missing': flight.isnull().sum() , 'perc_missing':(flight.isnull().sum() /len(flight.index)) *100})
missing_data<create_dataframe> | print("% Of Males Survived from class 1:",(((((df_trainval["Sex"]=="male")&(df_trainval["Survived"]==1)&(df_trainval["Pclass"]==1)).astype(int)).sum())/(((df_trainval["Sex"]=="male")&(df_trainval["Pclass"]==1)).astype(int)).sum())*100,"%")
print("% Of Males Survived from class 2:",(((((df_trainval["Sex"]=="male")&(df_trainval["Survived"]==1)&(df_trainval["Pclass"]==2)).astype(int)).sum())/(((df_trainval["Sex"]=="male")&(df_trainval["Pclass"]==2)).astype(int)).sum())*100,"%")
print("% Of Males Survived from class 3:",(((((df_trainval["Sex"]=="male")&(df_trainval["Survived"]==1)&(df_trainval["Pclass"]==3)).astype(int)).sum())/(((df_trainval["Sex"]=="male")&(df_trainval["Pclass"]==3)).astype(int)).sum())*100,"%")
print("% Of Females Survived from class 1:",(((((df_trainval["Sex"]=="female")&(df_trainval["Survived"]==1)&(df_trainval["Pclass"]==1)).astype(int)).sum())/(((df_trainval["Sex"]=="female")&(df_trainval["Pclass"]==1)).astype(int)).sum())*100,"%")
print("% Of Females Survived from class 2:",(((((df_trainval["Sex"]=="female")&(df_trainval["Survived"]==1)&(df_trainval["Pclass"]==2)).astype(int)).sum())/(((df_trainval["Sex"]=="female")&(df_trainval["Pclass"]==2)).astype(int)).sum())*100,"%")
print("% Of Females Survived from class 3:",(((((df_trainval["Sex"]=="female")&(df_trainval["Survived"]==1)&(df_trainval["Pclass"]==3)).astype(int)).sum())/(((df_trainval["Sex"]=="female")&(df_trainval["Pclass"]==3)).astype(int)).sum())*100,"%")
sns.catplot(x='Survived',hue="Pclass",col='Sex',kind="count",data=df_trainval)
plt.show() | Titanic - Machine Learning from Disaster |
5,455,381 | missing_data2 = pd.DataFrame({'total_missing': test.isnull().sum() , 'perc_missing':(test.isnull().sum() /len(test.index)) *100})
missing_data2<feature_engineering> | df_trainval["Parch"].value_counts() | Titanic - Machine Learning from Disaster |
5,455,381 | def get_is_cross_sell(df):
df["is_cross_sell"] = df.hotel_id.map(lambda x: 0 if x == "None" else 1)
return df
get_is_cross_sell(flight ).is_cross_sell.value_counts()<count_values> | print("% of people survived with having 0 Parch: ",(((((df_trainval["Parch"]==0)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["Parch"]==0 ).astype(int ).sum())) *100," %")
print("% of people survived with having 1 Parch: ",(((((df_trainval["Parch"]==1)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["Parch"]==1 ).astype(int ).sum())) *100," %")
print("% of people survived with having 2 Parch: ",(((((df_trainval["Parch"]==2)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["Parch"]==2 ).astype(int ).sum())) *100," %")
print("% of people survived with having 3 Parch: ",(((((df_trainval["Parch"]==3)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["Parch"]==3 ).astype(int ).sum())) *100," %")
print("% of people survived with having 4 Parch: ",(((((df_trainval["Parch"]==4)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["Parch"]==4 ).astype(int ).sum())) *100," %")
print("% of people survived with having 5 Parch: ",(((((df_trainval["Parch"]==5)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["Parch"]==5 ).astype(int ).sum())) *100," %")
print("% of people survived with having 6 Parch: ",(((((df_trainval["Parch"]==6)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["Parch"]==6 ).astype(int ).sum())) *100," %")
sns.catplot(x='Survived',hue="Parch",kind="count",data=df_trainval ) | Titanic - Machine Learning from Disaster |
5,455,381 | flight["route"].value_counts()<count_unique_values> | df_trainval["SibSp"].value_counts() | Titanic - Machine Learning from Disaster |
5,455,381 | flight['order_id'].nunique() , flight.shape[0]<count_values> | print("% of people survived with having 0 Siblings: ",(((((df_trainval["SibSp"]==0)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["SibSp"]==0 ).astype(int ).sum())) *100," %")
print("% of people survived with having 1 Siblings: ",(((((df_trainval["SibSp"]==1)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["SibSp"]==1 ).astype(int ).sum())) *100," %")
print("% of people survived with having 2 Siblings: ",(((((df_trainval["SibSp"]==2)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["SibSp"]==2 ).astype(int ).sum())) *100," %")
print("% of people survived with having 3 Siblings: ",(((((df_trainval["SibSp"]==3)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["SibSp"]==3 ).astype(int ).sum())) *100," %")
print("% of people survived with having 4 Siblings: ",(((((df_trainval["SibSp"]==4)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["SibSp"]==4 ).astype(int ).sum())) *100," %")
print("% of people survived with having 5 Siblings: ",(((((df_trainval["SibSp"]==5)&(df_trainval["Survived"]==1)).astype(int ).sum())/(df_trainval["SibSp"]==5 ).astype(int ).sum())) *100," %")
sns.catplot(x='Survived',hue="SibSp",kind="count",data=df_trainval ) | Titanic - Machine Learning from Disaster |
5,455,381 | flight.visited_city.value_counts()<feature_engineering> | print("% Of male Survived with boarding at Southampton :",(((((df_trainval["Sex"]=="male")&(df_trainval["Survived"]==1)&(df_trainval["Embarked"]=="S")).astype(int)).sum())/(((df_trainval["Sex"]=="male")&(df_trainval["Embarked"]=="S")).astype(int)).sum())*100,"%")
print("% Of female Survived with boarding at Southampton :",(((((df_trainval["Sex"]=="female")&(df_trainval["Survived"]==1)&(df_trainval["Embarked"]=="S")).astype(int)).sum())/(((df_trainval["Sex"]=="female")&(df_trainval["Embarked"]=="S")).astype(int)).sum())*100,"%")
print("% Of male Survived with boarding at Cherbourg :",(((((df_trainval["Sex"]=="male")&(df_trainval["Survived"]==1)&(df_trainval["Embarked"]=="C")).astype(int)).sum())/(((df_trainval["Sex"]=="male")&(df_trainval["Embarked"]=="C")).astype(int)).sum())*100,"%")
print("% Of female Survived with boarding at Cherbourg :",(((((df_trainval["Sex"]=="female")&(df_trainval["Survived"]==1)&(df_trainval["Embarked"]=="C")).astype(int)).sum())/(((df_trainval["Sex"]=="female")&(df_trainval["Embarked"]=="C")).astype(int)).sum())*100,"%")
print("% Of female Survived with boarding at Queenstown :",(((((df_trainval["Sex"]=="male")&(df_trainval["Survived"]==1)&(df_trainval["Embarked"]=="Q")).astype(int)).sum())/(((df_trainval["Sex"]=="male")&(df_trainval["Embarked"]=="Q")).astype(int)).sum())*100,"%")
print("% Of female Survived with boarding at Queenstown :",(((((df_trainval["Sex"]=="female")&(df_trainval["Survived"]==1)&(df_trainval["Embarked"]=="Q")).astype(int)).sum())/(((df_trainval["Sex"]=="female")&(df_trainval["Embarked"]=="Q")).astype(int)).sum())*100,"%")
sns.catplot(x='Survived',col="Embarked",hue="Sex",kind="count",data=df_trainval)
plt.show() | Titanic - Machine Learning from Disaster |
5,455,381 | y = flight.copy()
y["n_trx"] = y.log_trx_proc.map(len)
y[y.n_trx == 2][y.trip == "trip"].visited_city.value_counts()<define_variables> | df_trainval["Sex"].value_counts() | Titanic - Machine Learning from Disaster |
5,455,381 | num_columns = ["sum_transaction", "num_transaction", "price", "member_duration_days", "no_of_seats"]
cat_columns = ["trip", "is_tx_promo", "airlines_name", "visited_city", "account_id", "service_class", "gender"]<feature_engineering> | df_trainval["Sex_labels"],Sex_uniques=pd.factorize(df_trainval["Sex"])
df_trainval.head() | Titanic - Machine Learning from Disaster |
5,455,381 | num_columns = ["avg_transaction", "price", "no_of_seats", "member_duration_days"]
cat_columns = ["trip", "is_tx_promo", "airlines_name", "visited_city", "account_id", "service_class", "gender", "num_transaction", "member_registered_quarter"]
def process_data2(df):
f = df.copy()
f["num_transaction"] = f.log_trx_proc.map(len)
f["avg_transaction"] = f.log_trx_proc.map(sum)/ f["num_transaction"]
f["num_transaction"] = f["num_transaction"].astype(np.int32 ).map(lambda x: x if x <= 14 else 15)
f.avg_transaction = f.avg_transaction / 10**4
f.price = f.price / 10**4
f["member_registered_quarter"] =(( f.member_duration_days - 329)// 90 ).astype("int32")
f = f.drop(columns=["order_id", "hotel_id", "route", "log_transaction", "v_city_proc", "log_trx_proc", "is_cross_sell"])
return f<data_type_conversions> | df_trainval["Pclass"].value_counts() | Titanic - Machine Learning from Disaster |
5,455,381 | def cast_columns(f):
for c in num_columns:
f[c] = f[c].astype(np.int32)
for c in cat_columns:
f[c] = f[c].astype("category")
return f<prepare_x_and_y> | Age_mean=df_trainval["Age"].mean()
df_trainval["Age"].fillna(Age_mean,inplace=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | ty = flight["hotel_id"].map(lambda x: 0 if x == "None" else 1 )<concatenate> | a,age_bins=pd.qcut(df_trainval["Age"],7,retbins=True)
df_trainval["Age_label"],Age_unique=pd.factorize(a)
df_trainval.head() | Titanic - Machine Learning from Disaster |
5,455,381 | train_split = flight.shape[0]
full_df = pd.concat(( flight, test), sort=True)
p = cast_columns(process_data2(full_df))
tx, tex = p.iloc[:train_split], p.iloc[train_split:]
tx.shape, ty.shape, tex.shape<define_variables> | df_trainval["Age_label"].value_counts() | Titanic - Machine Learning from Disaster |
5,455,381 | categ_feat_idx = np.where(tx.dtypes == "category")[0]<split> | age_cat=[]
for i in range(7):
i1=age_bins[i]
i2=age_bins[i+1]
age_cat.append(str(i)+" : "+i1.astype(str)+"-"+i2.astype(str))
| Titanic - Machine Learning from Disaster |
5,455,381 | train_X, valid_X, train_y, valid_y = train_test_split(tx, ty, test_size=0.25, stratify=ty, random_state=17 )<choose_model_class> | df_trainval["Parch"].value_counts() | Titanic - Machine Learning from Disaster |
5,455,381 | parameters = {
"random_seed": 17,
"eval_metric": "F1",
"custom_metric": ["F1", "Precision", "Recall"],
"loss_function": "Logloss",
"task_type": "GPU",
"random_strength": 3,
"od_type": "Iter",
"verbose":100,
"cat_features":categ_feat_idx
}
ctb = CatBoostClassifier(**parameters )<train_model> | df_trainval["(Sex_labels+1)/Parch"]=(df_trainval["Sex_labels"]+1)/df_trainval["Pclass"]
df_trainval["Parch+SibSp+1"]=df_trainval["SibSp"]+df_trainval["Parch"]+1
df_trainval["Pclass/Parch"]=df_trainval["Parch"]/df_trainval["Pclass"]
df_trainval["Parch+SibSp+sex_label"]=df_trainval["SibSp"]+df_trainval["Parch"]+df_trainval["Sex_labels"]
df_trainval.head() | Titanic - Machine Learning from Disaster |
5,455,381 | ctb.fit(train_X, train_y )<compute_test_metric> | df_trainval["Embarked"].value_counts() | Titanic - Machine Learning from Disaster |
5,455,381 | get_metrics(valid_X,valid_y, e=ctb )<feature_engineering> | df_trainval["Embarked_label"],Embarked_unique=pd.factorize(df_trainval["Embarked"])
df_trainval.head() | Titanic - Machine Learning from Disaster |
5,455,381 | ctb.get_feature_importance(prettified=True )<install_modules> | b,Fare_bins=pd.qcut(df_trainval["Fare"],5,retbins=True)
df_trainval["Fare_labels"],Fare_unique=pd.factorize(b)
df_trainval.head() | Titanic - Machine Learning from Disaster |
5,455,381 | !pip uninstall scikit-optimize --yes
!pip install git+https://github.com/darenr/scikit-optimize<import_modules> | df_trainval["Fare_labels"].value_counts() | Titanic - Machine Learning from Disaster |
5,455,381 | from scipy.stats import randint
from scipy.stats import uniform
from sklearn.model_selection import StratifiedKFold
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.model_selection import cross_val_score
from sklearn.metrics import average_precision_score, roc_auc_score, mean_absolute_error, f1_score, make_scorer
from skopt import BayesSearchCV
from skopt import gp_minimize
from skopt.space import Real, Categorical, Integer
from skopt.utils import use_named_args
from skopt.callbacks import DeadlineStopper
from skopt.callbacks import VerboseCallback
from skopt.callbacks import DeltaXStopper<train_on_grid> | df_trainval["Fare_labels*(Sex_labels+1)"]=df_trainval["Fare_labels"]*(df_trainval["Sex_labels"]+1 ) | Titanic - Machine Learning from Disaster |
5,455,381 |
def report_perf(optimizer, X, y, title, callbacks=None):
start = time()
if callbacks:
optimizer.fit(X, y, callback=callbacks)
else:
optimizer.fit(X, y)
best_score = optimizer.best_score_
best_score_std = optimizer.cv_results_['std_test_score'][optimizer.best_index_]
best_params = optimizer.best_params_
print(( title + " took %.2f seconds, candidates checked: %d, best CV score: %.3f "
+u"\u00B1"+" %.3f")%(time() - start,
len(optimizer.cv_results_['params']),
best_score,
best_score_std))
print('Best parameters:')
pprint.pprint(best_params)
print()
return best_params<choose_model_class> | X_trainval=df_trainval.drop(columns=["Survived","Sex","Fare","Embarked","Cabin","Name","Ticket","PassengerId","Age"])
Y_trainval=df_trainval["Survived"]
print("X_trainval shape: ",X_trainval.shape)
print("Y_trainval shape: ",Y_trainval.shape ) | Titanic - Machine Learning from Disaster |
5,455,381 | skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=8)
scorer = make_scorer(f1_score, average="macro")
search_spaces = {'iterations': Integer(100, 1000),
'depth': Integer(4, 8),
'random_strength': Real(1e-9, 10, 'log-uniform'),
'bagging_temperature': Real(0.0, 1.0),
'border_count': Integer(128, 255),
'l2_leaf_reg': Integer(2, 30),
'scale_pos_weight':Real(1.0, 5.0, 'uniform')}
opt = BayesSearchCV(ctb,
search_spaces,
scoring=scorer,
cv=skf,
n_jobs=1,
return_train_score=False,
refit=True,
optimizer_kwargs={'base_estimator': 'GP'},
fit_params={'cat_features': categ_feat_idx, 'silent': True},
random_state=22,
verbose=True )<compute_test_metric> | X_train1,X_val1,Y_train1,Y_val1=train_test_split(X_trainval,Y_trainval,test_size=0.2,random_state=42)
print("X_train shape: ",X_train1.shape)
print("X_val shape: ",X_val1.shape)
print("Y_train shape: ",Y_train1.shape)
print("Y_val shape: ",Y_val1.shape ) | Titanic - Machine Learning from Disaster |
5,455,381 | best_params = report_perf(opt, tx, ty,'CatBoost',
callbacks=[VerboseCallback(100),
DeltaXStopper(0.0001),
DeadlineStopper(60*5)] )<init_hyperparams> | model1=LogisticRegression()
model1.fit(X_train1,Y_train1)
print("train set Accuracy: ",model1.score(X_train1,Y_train1))
print("test set Accuracy: ",model1.score(X_val1,Y_val1)) | Titanic - Machine Learning from Disaster |
5,455,381 | best_params = {'bagging_temperature': 0.36426463210895726,
'border_count': 206,
'depth': 8,
'iterations': 342,
'l2_leaf_reg': 5,
'random_strength': 3.3149120967201682e-06,
'scale_pos_weight': 4.210304871687331}<choose_model_class> | Y_val1_predict= model1.predict(X_val1)
print(confusion_matrix(Y_val1,Y_val1_predict)) | Titanic - Machine Learning from Disaster |
5,455,381 | tuned_model = CatBoostClassifier(**best_params, cat_features=categ_feat_idx, verbose=100, od_type="Iter" )<count_values> | scaler=StandardScaler()
standard_scaled_features=scaler.fit_transform(X_trainval)
X_trainval_2=pd.DataFrame(standard_scaled_features,index=X_trainval.index,columns=X_trainval.columns)
X_trainval_2.head()
| Titanic - Machine Learning from Disaster |
5,455,381 | train_y.value_counts() [0] // train_y.value_counts() [1]<choose_model_class> | X_train2,X_val2,Y_train2,Y_val2=train_test_split(X_trainval_2,Y_trainval,test_size=0.2,random_state=42)
print("X_train shape: ",X_train2.shape)
print("X_val shape: ",X_val2.shape)
print("Y_train shape: ",Y_train2.shape)
print("Y_val shape: ",Y_val2.shape ) | Titanic - Machine Learning from Disaster |
5,455,381 | ctb2 = CatBoostClassifier(**{"random_seed": 40,
"eval_metric": "F1",
"custom_metric": ["F1", "Precision", "Recall"],
"loss_function": "Logloss",
"task_type": "GPU",
"random_strength": 3,
"od_type": "Iter",
"scale_pos_weight": 12,
"verbose":100,
"cat_features":categ_feat_idx} )<count_duplicates> | model2=LogisticRegression()
model2.fit(X_train2,Y_train2)
print("train set Accuracy: ",model2.score(X_train2,Y_train2))
print("test set Accuracy: ",model1.score(X_val2,Y_val2)) | Titanic - Machine Learning from Disaster |
5,455,381 | flight2 = flight.copy()
d = flight.duplicated(subset=("account_id", "airlines_name", "trip", "is_tx_promo", "price"))
flight2 = flight[~d]<categorify> | Y_val2_predict= model2.predict(X_val2)
print(confusion_matrix(Y_val2,Y_val2_predict)) | Titanic - Machine Learning from Disaster |
5,455,381 | ty2 = flight2.hotel_id.map(lambda x: 0 if x == "None" else 1)
tx2 = cast_columns(process_data2(flight2)) [tx.columns]<define_variables> | scaler=MinMaxScaler()
minmax_scaled_features=scaler.fit_transform(X_trainval)
X_trainval_3=pd.DataFrame(minmax_scaled_features,index=X_trainval.index,columns=X_trainval.columns)
X_trainval_3.head()
| Titanic - Machine Learning from Disaster |
5,455,381 | categ_feat_idx2 = np.where(tx2.dtypes == "category")[0]<choose_model_class> | X_train3,X_val3,Y_train3,Y_val3=train_test_split(X_trainval_3,Y_trainval,test_size=0.2,random_state=42)
print("X_train shape: ",X_train3.shape)
print("X_val shape: ",X_val3.shape)
print("Y_train shape: ",Y_train3.shape)
print("Y_val shape: ",Y_val3.shape ) | Titanic - Machine Learning from Disaster |
5,455,381 | ctb4 = CatBoostClassifier(**{"random_seed": 40,
"eval_metric": "F1",
"custom_metric": ["F1", "Precision", "Recall"],
"loss_function": "Logloss",
"task_type": "GPU",
"random_strength": 3,
"od_type": "Iter",
"scale_pos_weight": 3.5,
"verbose":100,
"cat_features":categ_feat_idx2} )<split> | model3=LogisticRegression()
model3.fit(X_train3,Y_train3)
print("train set Accuracy: ",model3.score(X_train3,Y_train3))
print("test set Accuracy: ",model3.score(X_val3,Y_val3)) | Titanic - Machine Learning from Disaster |
5,455,381 | train_X2, valid_X2, train_y2, valid_y2 = train_test_split(tx2, ty2, test_size=0.25, stratify=ty2, random_state=17 )<import_modules> | Y_val3_predict= model3.predict(X_val3)
print(confusion_matrix(Y_val3,Y_val3_predict)) | Titanic - Machine Learning from Disaster |
5,455,381 |
<train_model> | model4=LinearSVC()
model4.fit(X_train1,Y_train1)
print("train set Accuracy: ",model4.score(X_train1,Y_train1))
print("test set Accuracy: ",model4.score(X_val1,Y_val1)) | Titanic - Machine Learning from Disaster |
5,455,381 | tuned_model.fit(tx, ty )<train_model> | Y_val4_predict= model4.predict(X_val1)
print(confusion_matrix(Y_val1,Y_val4_predict)) | Titanic - Machine Learning from Disaster |
5,455,381 | ctb.fit(tx, ty)
ctb2.fit(tx, ty)
ctb4.fit(tx2, ty2 )<compute_test_metric> | model5=LinearSVC()
model5.fit(X_train2,Y_train2)
print("train set Accuracy: ",model5.score(X_train2,Y_train2))
print("test set Accuracy: ",model5.score(X_val2,Y_val2)) | Titanic - Machine Learning from Disaster |
5,455,381 | get_metrics(valid_X,valid_y, e=vc )<train_model> | Y_val5_predict= model5.predict(X_val2)
print(confusion_matrix(Y_val2,Y_val5_predict)) | Titanic - Machine Learning from Disaster |
5,455,381 | eclf = EnsembleVoteClassifier(clfs=[ctb2, tuned_model], weights=[1,1.1], refit=False, voting="soft")
eclf.fit(tx, ty )<count_values> | model6=LinearSVC()
model6.fit(X_train3,Y_train3)
print("train set Accuracy: ",model6.score(X_train3,Y_train3))
print("test set Accuracy: ",model6.score(X_val3,Y_val3)) | Titanic - Machine Learning from Disaster |
5,455,381 | f_pred = pd.Series(eclf.predict(tex.to_numpy())).map(lambda x: "no" if x == 0 else "yes")
f_pred.value_counts()<prepare_output> | model7=DecisionTreeClassifier(max_depth=9,min_samples_split=8,min_samples_leaf=2)
model7.fit(X_train1,Y_train1)
print("train set Accuracy: ",model7.score(X_train1,Y_train1))
print("test set Accuracy: ",model7.score(X_val1,Y_val1)) | Titanic - Machine Learning from Disaster |
5,455,381 | submission = test[["order_id"]]
submission["is_cross_sell"] = f_pred
submission<save_to_csv> | Y_val7_predict= model7.predict(X_val1)
print(confusion_matrix(Y_val1,Y_val7_predict)) | Titanic - Machine Learning from Disaster |
5,455,381 | submission.to_csv('submission.csv', header=True, index=False )<set_options> | model8=DecisionTreeClassifier(max_depth=9,min_samples_split=8,min_samples_leaf=2)
model8.fit(X_train2,Y_train2)
print("train set Accuracy: ",model8.score(X_train2,Y_train2))
print("test set Accuracy: ",model8.score(X_val2,Y_val2)) | Titanic - Machine Learning from Disaster |
5,455,381 | %matplotlib inline
<load_from_csv> | Y_val8_predict= model8.predict(X_val2)
print(confusion_matrix(Y_val2,Y_val8_predict)) | Titanic - Machine Learning from Disaster |
5,455,381 | train_csv = pd.read_csv(".. /input/train_set.csv", low_memory=False)
test_csv = pd.read_csv(".. /input/test_set.csv", low_memory=False )<drop_column> | model9=DecisionTreeClassifier(max_depth=9,min_samples_split=8,min_samples_leaf=2)
model9.fit(X_train3,Y_train3)
print("train set Accuracy: ",model9.score(X_train3,Y_train3))
print("test set Accuracy: ",model9.score(X_val3,Y_val3)) | Titanic - Machine Learning from Disaster |
5,455,381 | X_trainvalid = train_csv.drop(["PRICE", "Id"], axis=1)
X_test = test_csv.drop(["Id"], axis=1 )<data_type_conversions> | Y_val9_predict= model9.predict(X_val3)
print(confusion_matrix(Y_val3,Y_val9_predict)) | Titanic - Machine Learning from Disaster |
5,455,381 | X_traintest = pd.concat([X_trainvalid, X_test], axis=0)
X_traintest["SALEDATE"] = pd.to_datetime(X_traintest["SALEDATE"] ).astype("int")
X_traintest["GIS_LAST_MOD_DTTM"] = pd.to_datetime(X_traintest["GIS_LAST_MOD_DTTM"] ).astype("int" )<data_type_conversions> | model10=RandomForestClassifier(n_estimators=100,max_leaf_nodes=50)
model10.fit(X_train1,Y_train1)
print("train set Accuracy: ",model10.score(X_train1,Y_train1))
print("test set Accuracy: ",model10.score(X_val1,Y_val1)) | Titanic - Machine Learning from Disaster |
5,455,381 | for c in categorical_features:
X_traintest[c] = X_traintest[c].astype('category' )<init_hyperparams> | model11=RandomForestClassifier(n_estimators=100,max_leaf_nodes=50)
model11.fit(X_train2,Y_train2)
print("train set Accuracy: ",model11.score(X_train2,Y_train2))
print("test set Accuracy: ",model11.score(X_val2,Y_val2)) | Titanic - Machine Learning from Disaster |
5,455,381 | params = {
'boosting_type': 'gbdt',
'objective': 'regression',
'metric': 'l2',
'num_leaves': 511,
'learning_rate': 0.01,
'feature_fraction': 0.8,
'verbose': 0
}<train_model> | model12=RandomForestClassifier(n_estimators=100,max_leaf_nodes=50)
model12.fit(X_train3,Y_train3)
print("train set Accuracy: ",model12.score(X_train3,Y_train3))
print("test set Accuracy: ",model12.score(X_val3,Y_val3)) | Titanic - Machine Learning from Disaster |
5,455,381 | X_train = X_traintest.iloc[:train_csv.shape[0], :]
X_test = X_traintest.iloc[train_csv.shape[0]:, :]
y_train = np.log(train_csv["PRICE"].values)
X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size=0.2, random_state=71)
lgb_train = lgb.Dataset(X_train, y_train, categorical_feature=categorical_features)
lgb_valid = lgb.Dataset(X_valid, y_valid, categorical_feature=categorical_features)
print('Starting training...')
model = lgb.train(
params,
lgb_train,
valid_sets=lgb_valid,
num_boost_round=10000,
early_stopping_rounds=100
)
<predict_on_test> | K.clear_session()
tf.reset_default_graph()
| Titanic - Machine Learning from Disaster |
5,455,381 | test_pred = np.exp(model.predict(X_test))<save_to_csv> | model13 = Sequential()
model13.add(Dense(8,input_shape=(12,)))
model13.add(Activation('sigmoid'))
model13.add(Dense(16))
model13.add(Activation('sigmoid'))
model13.add(Dense(32))
model13.add(Activation('sigmoid'))
model13.add(Dense(2))
model13.add(Activation('sigmoid'))
model13.add(Dense(1))
model13.add(Activation('sigmoid')) | Titanic - Machine Learning from Disaster |
5,455,381 | sub_df = pd.DataFrame({"Id":test_csv["Id"].values,"PRICE":test_pred})
sub_df.to_csv("sub_harada.csv", index=False )<import_modules> | model13.compile(
loss='mean_squared_error',
optimizer='adagrad',
metrics=['accuracy']
) | Titanic - Machine Learning from Disaster |
5,455,381 | import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split<import_modules> | model13.fit(
X_train3,
Y_train3,
batch_size=32,
epochs=100,
validation_split=0.2
) | Titanic - Machine Learning from Disaster |
5,455,381 | import keras
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.layers.normalization import BatchNormalization<load_from_csv> | print("test set Accuracy: ",model13.evaluate(x=X_val3, y=Y_val3, batch_size=2, verbose=1)) | Titanic - Machine Learning from Disaster |
5,455,381 | data_train = pd.read_csv('.. /input/train42000.csv')
data_test = pd.read_csv('.. /input/test28000.csv' )<prepare_x_and_y> | g1=df_test["PassengerId"]
df_test["Sex_labels"],Sex_test_uniques=pd.factorize(df_test["Sex"])
df_test.drop(columns=["Sex"],inplace=True)
df_test["Age"].fillna(Age_mean,inplace=True)
a1=pd.qcut(df_test["Age"],6)
df_test["Age_label"],Age_test_unique=pd.factorize(a1)
df_test.drop(columns=["Age"],inplace=True)
df_test.drop(columns=["Cabin","Name","Ticket","PassengerId"],inplace=True)
df_test["(Sex_labels+1)/Parch"]=(df_test["Sex_labels"]+1)/df_test["Pclass"]
df_test["Parch+SibSp+1"]=df_test["SibSp"]+df_test["Parch"]+1
df_test["Pclass/Parch"]=df_test["Pclass"]/df_test["Parch"]
df_test["Parch+SibSp+sex_label"]=df_test["SibSp"]+df_test["Parch"]+df_test["Sex_labels"]
df_test["Embarked_label"],Embarked_test_unique=pd.factorize(df_test["Embarked"])
df_test.drop(columns=["Embarked"],inplace=True)
a2=pd.qcut(df_test["Fare"],5)
df_test["Fare_labels"],Fare_uniques=pd.factorize(a2)
df_test.drop(columns=["Fare"],inplace=True)
df_test["Fare_labels*(Sex_labels+1)"]=df_test["Fare_labels"]*(df_test["Sex_labels"]+1)
df_test["Parch+SibSp+sex_label"]=df_test["SibSp"]+df_test["Parch"]+df_test["Sex_labels"]
| Titanic - Machine Learning from Disaster |
5,455,381 | X = np.array(data_train.iloc[:, 1:] )<prepare_x_and_y> | result_1=model1.predict(df_test)
Result_logistic_Regression=pd.DataFrame({'PassengerId':g1,'Survived':result_1})
Result_logistic_Regression.to_csv("Result_logistic_Regression_1.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | y_tmp = np.array(data_train.iloc[:, 0])
y_tmp<categorify> | scaler=StandardScaler()
df_test_2=scaler.fit_transform(df_test ) | Titanic - Machine Learning from Disaster |
5,455,381 | y = to_categorical(y_tmp)
y<split> | result_2=model2.predict(df_test_2)
Result_logistic_Regression_2=pd.DataFrame({'PassengerId':g1,'Survived':result_2})
Result_logistic_Regression_2.to_csv("Result_logistic_Regression_2.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=13 )<prepare_x_and_y> | scaler=MinMaxScaler()
df_test_3=scaler.fit_transform(df_test ) | Titanic - Machine Learning from Disaster |
5,455,381 | X_test = np.array(data_test.iloc[:, 0:] )<train_model> | result_3=model3.predict(df_test_3)
Result_logistic_Regression_3=pd.DataFrame({'PassengerId':g1,'Survived':result_3})
Result_logistic_Regression_3.to_csv("Result_logistic_Regression_3.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | img_rows, img_cols = 28, 28
input_shape =(img_rows, img_cols, 1)
X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1)
X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1)
X_val = X_val.reshape(X_val.shape[0], img_rows, img_cols, 1 )<data_type_conversions> | result_4=model4.predict(df_test)
Result_logistic_Regression_4=pd.DataFrame({'PassengerId':g1,'Survived':result_4})
Result_logistic_Regression_4.to_csv("Result_SVM_1.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_val = X_val.astype('float32' )<feature_engineering> | result_5=model5.predict(df_test_2)
Result_logistic_Regression_5=pd.DataFrame({'PassengerId':g1,'Survived':result_5})
Result_logistic_Regression_5.to_csv("Result_SVM_2.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | X_train /= 255
X_test /= 255
X_val /= 255<choose_model_class> | result_6=model6.predict(df_test_3)
Result_logistic_Regression_6=pd.DataFrame({'PassengerId':g1,'Survived':result_6})
Result_logistic_Regression_6.to_csv("Result_SVM_3.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | num_classes = 10
model = Sequential()
model.add(Conv2D(20, kernel_size=(5, 5),
activation='relu',
kernel_initializer='he_normal',
input_shape=input_shape))
model.add(MaxPooling2D(( 2, 2)))
model.add(Flatten())
model.add(Dense(20, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))<choose_model_class> | result_7=model7.predict(df_test)
Result_logistic_Regression_7=pd.DataFrame({'PassengerId':g1,'Survived':result_7})
Result_logistic_Regression_7.to_csv("Result_Decision_tree_1.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam() ,
metrics=['accuracy'] )<define_variables> | result_8=model8.predict(df_test_2)
Result_logistic_Regression_8=pd.DataFrame({'PassengerId':g1,'Survived':result_8})
Result_logistic_Regression_8.to_csv("Result_Decision_tree_2.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | batch_size = 256
epochs = 5<train_model> | result_9=model9.predict(df_test_3)
Result_logistic_Regression_9=pd.DataFrame({'PassengerId':g1,'Survived':result_9})
Result_logistic_Regression_9.to_csv("Result_Decision_tree_3.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | history = model.fit(X_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(X_val, y_val))<predict_on_test> | result_10=model10.predict(df_test)
Result_logistic_Regression_10=pd.DataFrame({'PassengerId':g1,'Survived':result_10})
Result_logistic_Regression_10.to_csv("Result_Random_Forest_1.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | predicted_classes = model.predict_classes(X_test )<create_dataframe> | result_11=model11.predict(df_test_2)
Result_logistic_Regression_11=pd.DataFrame({'PassengerId':g1,'Survived':result_11})
Result_logistic_Regression_11.to_csv("Result_Random_Forest_2.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | df = pd.DataFrame(predicted_classes,columns=['label'] )<save_to_csv> | result_12=model12.predict(df_test_3)
Result_logistic_Regression_12=pd.DataFrame({'PassengerId':g1,'Survived':result_12})
Result_logistic_Regression_12.to_csv("Result_Random_Forest_3.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | df.to_csv(path_or_buf="Submission.csv",index_label="image_id" )<import_modules> | result_12=model12.predict(df_test_3)
Result_logistic_Regression_12=pd.DataFrame({'PassengerId':g1,'Survived':result_12})
Result_logistic_Regression_12.to_csv("Result_Random_Forest_3.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
5,455,381 | <normalization><EOS> | result_13=(model13.predict(df_test_3)>0.5 ).astype(int)
result_13=result_13.squeeze()
Result_logistic_Regression_13=pd.DataFrame({'PassengerId':g1,'Survived':result_13})
Result_logistic_Regression_13.to_csv("Neural_Network_3.csv",index=False,header=True ) | Titanic - Machine Learning from Disaster |
3,804,937 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | warnings.filterwarnings("ignore")
sns.set_style('whitegrid')
sns.set_context("talk")
%matplotlib inline | Titanic - Machine Learning from Disaster |
3,804,937 | def reorder(old_list,order):
new_list = []
for i in order:
new_list.append(old_list[i])
return new_list
np.random.seed(seed=42)
indices = np.arange(len(fruit_labels))
np.random.shuffle(indices)
indices = indices.tolist()
fruit_labels = reorder(fruit_labels,indices)
fruit_images = reorder(fruit_images,indices)
image_array = np.array(fruit_images)
label_array = np.array(fruit_labels )<categorify> | train_df = pd.read_csv('.. /input/titanic/train.csv')
test_df = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
3,804,937 | label_array=to_categorical(label_array,3 )<split> | all_df = pd.concat([train_df, test_df], axis=0, sort=False, ignore_index=True ) | Titanic - Machine Learning from Disaster |
3,804,937 | X_train, X_test, y_train, y_test = train_test_split(image_array,label_array, test_size=0.2)
X_train, X_val, y_train, y_val=train_test_split(X_train, y_train, test_size=0.3 )<choose_model_class> | all_df['Title'] = all_df['Name'].apply(lambda name: name.split(',')[1].strip().split('.')[0] ) | Titanic - Machine Learning from Disaster |
3,804,937 | model = Sequential([
Conv2D(32,(3,3), activation='relu', input_shape=(50,50,3),padding='same'),
MaxPooling2D(2, 2),
Conv2D(64,(3,3), activation='relu',padding='same'),
MaxPooling2D(2,2),
Conv2D(128,(3,3), activation='relu',padding='same'),
MaxPooling2D(2,2),
Flatten() ,
Dropout(0.50),
Dense(128, activation='relu'),
Dense(3, activation='softmax')
])
<choose_model_class> | newtitles={
"Capt": "Officer",
"Col": "Officer",
"Major": "Officer",
"Jonkheer": "Royalty",
"Don": "Royalty",
"Sir" : "Royalty",
"Dr": "Officer",
"Rev": "Officer",
"the Countess":"Royalty",
"Dona": "Royalty",
"Mme": "Mrs",
"Mlle": "Miss",
"Ms": "Mrs",
"Mr" : "Mr",
"Mrs" : "Mrs",
"Miss" : "Miss",
"Master" : "Master",
"Lady" : "Royalty"} | Titanic - Machine Learning from Disaster |
3,804,937 | l=[25]
for i in range(len(l)) :
model = Sequential([
Conv2D(32,(3,3), activation='relu', input_shape=(50,50,3),padding='same'),
MaxPooling2D(2, 2),
Conv2D(64,(3,3), activation='relu',padding='same'),
MaxPooling2D(2,2),
Conv2D(128,(3,3), activation='relu',padding='same'),
MaxPooling2D(2,2),
Flatten() ,
Dropout(0.50),
Dense(128, activation='relu'),
Dense(3, activation='softmax')
])
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(X_train,y_train,epochs=l[i],verbose=1)
modelsub=model.predict(X_val,batch_size=None, verbose=1)
c=0
f=0
for i in range(modelsub.shape[0]):
if np.argmax(modelsub[i])==np.argmax(y_val[i]):
c+=1
else:
f+=1
accuracy=c/(c+f)
print('Test Accuracy:',accuracy*100)
<predict_on_test> | all_df['Title'].update(all_df['Title'].map(newtitles)) | Titanic - Machine Learning from Disaster |
3,804,937 | modelsub=model.predict(X_test,batch_size=None, verbose=1)
c=0
f=0
for i in range(modelsub.shape[0]):
if np.argmax(modelsub[i])==np.argmax(y_test[i]):
c+=1
else:
f+=1
accuracy=c/(c+f)
print('Test Accuracy:',accuracy*100 )<load_from_csv> | all_df['Deck'] = all_df['Cabin'].apply(lambda cabin: cabin[0] if pd.notnull(cabin)else 'N' ) | Titanic - Machine Learning from Disaster |
3,804,937 | sub_df=pd.read_csv('.. /input/sample_submission_q2.csv')
test_id = sub_df['ID']
test_id=test_id.astype(str)
test_path='.. /input/test/Test/'
test = get_images(ids=test_id, filepath=test_path)
<save_to_csv> | all_df['Alone'] =(all_df['Parch'].apply(lambda value: not(value)) & all_df['SibSp'].apply(lambda value: not(value)) ).astype('int' ) | Titanic - Machine Learning from Disaster |
3,804,937 | l=[]
iid=np.arange(1,113,1)
c=model.predict(test,batch_size=None, verbose=1)
for i in range(len(c)) :
l.append(np.argmax(c[i]))
df=pd.DataFrame({'ID':iid,'Category':l
},index=iid)
print(l)
df.to_csv("q2.csv",index=False )<import_modules> | all_df['Relatives'] = all_df['SibSp'] + all_df['Parch'] | Titanic - Machine Learning from Disaster |
3,804,937 | from sklearn.decomposition import PCA
import matplotlib.pyplot as plt<compute_train_metric> | all_df[all_df['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
3,804,937 | def classification_reports(classifier,features,labels):
size_data = len(labels)
count_class_1 = sum(labels)
count_class_0 = size_data - count_class_1
print(' class 1 : ', count_class_1)
print(' class 0 : ', count_class_0)
y = classifier.predict(features)
fpr, tpr, thresholds = metr.roc_curve(labels, y)
print("Confusion Matrix:
",metr.confusion_matrix(labels,y))
score=metr.accuracy_score(labels,y)
print("Score: ",score)
auc=metr.roc_auc_score(labels,y)
print("AUC: ",auc)
print(metr.classification_report(labels,y))
plt.figure()
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
Legend = "FirstStage"
plt.plot(fpr, tpr,color='darkorange')
plt.show()
return fpr,tpr,score<normalization> | sort_embarked_features = ['Cabin', 'Sex', 'Pclass', 'Alone', 'Fare']
sorted_df = all_df.sort_values(by=sort_embarked_features)
sorted_df[(sorted_df['Survived'] == 1)&
(sorted_df['Sex'] == 'female')&
(sorted_df['Pclass'] == 1)&
(sorted_df['Alone'] == 1)].sort_values(by=sort_embarked_features)[sort_embarked_features+['Embarked']].head() | Titanic - Machine Learning from Disaster |
3,804,937 | def pre_process(features):
del features['Name']
del features['PlayerID']
x = np.isfinite(features)
features[(x == False)&(features > 0)] = 10000000
features[(x == False)&(features < 0)] = -10000000
imputer = Imputer(missing_values='NaN', strategy='mean', axis=0 ).fit(features)
features= imputer.transform(features)
features = normalize(features, axis=0,norm='max')
return features<concatenate> | all_df['Embarked'].fillna(value='C', inplace=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.