kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,873,876 | X_train=df_train.iloc[:,2:]
Y_train=df_train.iloc[:,1]
ID_train=df_train.iloc[:,0]
X_test=df_test.iloc[:,1:]
ID_test=df_test.iloc[:,0]<count_missing_values> | from sklearn.linear_model import LogisticRegression | Titanic - Machine Learning from Disaster |
13,873,876 | df_null_train=X_train.isna().sum().reset_index()
df_null_train.columns=['Column_name','Null_Count']
df_null_train=df_null_train[df_null_train['Null_Count']>0]<count_missing_values> | y=df11['Survived']
X=df11.drop(['Survived'],axis=1)
| Titanic - Machine Learning from Disaster |
13,873,876 | df_null_test=X_test.isna().sum().reset_index()
df_null_test.columns=['Column_name','Null_Count']
df_null_test=df_null_test[df_null_test['Null_Count']>0]<count_unique_values> | from sklearn.ensemble import RandomForestClassifier | Titanic - Machine Learning from Disaster |
13,873,876 | df_Unique_train=X_train.nunique().reset_index()
df_Unique_train.columns=['Column_name','Unique_Count']
df_Unique_train=df_Unique_train[df_Unique_train['Unique_Count']==1]<count_unique_values> | model=RF=RandomForestClassifier(max_depth=5,criterion='entropy',n_estimators=83)
model.fit(X,y ) | Titanic - Machine Learning from Disaster |
13,873,876 | df_Unique_test=X_test.nunique().reset_index()
df_Unique_test.columns=['Column_name','Unique_Count']
df_Unique_test=df_Unique_test[df_Unique_test['Unique_Count']==1]<feature_engineering> | predictions=model.predict(X_test)
output = pd.DataFrame({'PassengerId': df12.PassengerId, 'Survived': predictions})
output.to_csv('first_submission.csv', index=False)
print("First model submission done" ) | Titanic - Machine Learning from Disaster |
13,821,516 | df_corr=X_train.corr().abs().unstack().sort_values().reset_index()
df_corr=df_corr[df_corr['level_0']!= df_corr['level_1']]
df_corr.head()<feature_engineering> | %matplotlib inline
%config InlineBackend.figure_format='retina'
sns.set_style("darkgrid")
| Titanic - Machine Learning from Disaster |
13,821,516 | X_train['sum'] = X_train.sum(axis=1)
X_train['min'] = X_train.min(axis=1)
X_train['max'] = X_train.max(axis=1)
X_train['mean'] = X_train.mean(axis=1)
X_train['median'] = X_train.median(axis=1)
X_train['std'] = X_train.std(axis=1)
X_train['skew'] = X_train.skew(axis=1)
X_train.head()<feature_engineering> | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
all_data = pd.concat([train,test], axis = 0)
print('train dataset has {} rows, {} columns'.format(train.shape[0],train.shape[1]))
print('test dataset has {} rows, {} columns'.format(test.shape[0],test.shape[1]))
train... | Titanic - Machine Learning from Disaster |
13,821,516 | X_test['sum'] = X_test.sum(axis=1)
X_test['min'] = X_test.min(axis=1)
X_test['max'] = X_test.max(axis=1)
X_test['mean'] = X_test.mean(axis=1)
X_test['median'] = X_test.median(axis=1)
X_test['std'] = X_test.std(axis=1)
X_test['skew'] = X_test.skew(axis=1)
X_test.head()<define_variables> | num_col = [col for col in train.columns if train[col].dtypes != object]
unique = [len(train[col].unique())for col in num_col]
num_unique = dict(zip(num_col,unique))
print('There are {} Numerical columns
'.format(len(num_col)))
print('Numerical unique values: {}'.format(num_unique)) | Titanic - Machine Learning from Disaster |
13,821,516 | skewed_columns=['var_0', 'var_1', 'var_2', 'var_5', 'var_13', 'var_18','var_19','var_20','var_21', 'var_22',
'var_24','var_26', 'var_35', 'var_36','var_40','var_44','var_45','var_47','var_48','var_49',
'var_51','var_52','var_54','var_56','var_61', 'var_66','var_67','var_70','var_74','var_75',
'var_76','var_80','var_81'... | cat_col = [col for col in train.columns if train[col].dtypes == object]
unique = [len(train[col].unique())for col in cat_col]
cat_unique = dict(zip(cat_col,unique))
print('There are {} Categorical columns
'.format(len(cat_col)))
print('Categorical unique values: {}'.format(cat_unique)) | Titanic - Machine Learning from Disaster |
13,821,516 | def bin_feature(col_name,X):
interval=pd.qcut(X[col_name],5 ).value_counts().index.sort_values()
X.loc[(X[col_name] <= interval[0].right),col_name] = 0
X.loc[(( X[col_name] > interval[1].left)&(X[col_name] <= interval[1].right)) ,col_name] = 1
X.loc[(( X[col_name] > interval[2].left)&(X[col_name] <= interval[2].right))... | all_data['Family_Group'] = all_data.SibSp + all_data.Parch | Titanic - Machine Learning from Disaster |
13,821,516 | for col in skewed_columns:
binned_col = col + '_bin'
X_train[binned_col] = X_train[col]
X_train[binned_col] = bin_feature(binned_col, X_train )<feature_engineering> | all_data['Ticket_short'] = all_data.Ticket.apply(lambda x: x[:1] ) | Titanic - Machine Learning from Disaster |
13,821,516 | for col in skewed_columns:
binned_col = col + '_bin'
X_test[binned_col] = X_test[col]
X_test[binned_col] = bin_feature(binned_col, X_test )<split> | all_data['Ticket_short'].replace(['7', 'W', '4', 'F', 'L', '9', '6', '5', '8'], 'O', inplace=True ) | Titanic - Machine Learning from Disaster |
13,821,516 | X_dev, X_val, Y_dev, Y_val=train_test_split(X_train, Y_train, test_size=0.4, random_state=0)
X_dev.shape, X_val.shape, Y_dev.shape, Y_val.shape<import_modules> | all_data['Embarked'] = all_data['Embarked'].transform(lambda x: x.fillna(x.mode() [0])) | Titanic - Machine Learning from Disaster |
13,821,516 | from sklearn.model_selection import KFold
from sklearn.metrics import roc_auc_score
import xgboost as xgb
from sklearn.ensemble import GradientBoostingClassifier<train_model> | all_data['Age'] = all_data.groupby(['Title'])['Age'].transform(lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
13,821,516 | def xgb_train(X_train, Y_train, X_test):
xgb_param = {
'objective' : "binary:logistic",
'eval_metric' : "auc",
'max_depth' : 6,
'eta' : 0.1,
'gamma' : 5,
'subsample' : 0.7,
'colsample_bytree' : 0.7,
'min_child_weight' : 50,
'colsample_bylevel' : 0.7,
'lambda' : 1,
'alpha' : 0,
'booster' : "gbtree",
'silent' : 1,
"rando... | all_data.drop(columns = ['Name', 'Ticket', 'PassengerId', 'Fare'], inplace =True)
all_data.head() | Titanic - Machine Learning from Disaster |
13,821,516 | oof_xgb_train, oof_xgb_test = xgb_train(X_train, Y_train, X_test )<load_from_csv> | num_col = [col for col in all_data.columns if all_data[col].dtypes != 'object']
num_col.remove('Survived')
cat_col = [col for col in all_data.columns if all_data[col].dtypes == 'object']
train_final = all_data[:train.shape[0]]
test_final = all_data[train.shape[0]:]
X = train_final.drop(columns = 'Survived')
y = train... | Titanic - Machine Learning from Disaster |
13,821,516 | df_sample_submission= pd.read_csv('.. /input/sample_submission.csv')
df_sample_submission.head()<save_to_csv> | skf = StratifiedKFold(n_splits=5, random_state=2020, shuffle=True)
numerical_transformer = make_pipeline(StandardScaler())
categorical_transformer = make_pipeline(SimpleImputer(strategy='most_frequent'),
OneHotEncoder(handle_unknown='ignore',sparse=False))
preprocess = ColumnTransformer(transformers=[
('num', numeri... | Titanic - Machine Learning from Disaster |
13,821,516 | output=pd.DataFrame({
"ID_code" : df_sample_submission['ID_code'],
"target" : oof_xgb_test
})
output.to_csv('SCP_xgb_test.csv', index=False)
output.head()<save_to_csv> | preprocess.fit_transform(X,y)
enc_cat_col = preprocess.named_transformers_['cat']['onehotencoder'].get_feature_names()
labels = np.concatenate([num_col, enc_cat_col])
X_transformed = pd.DataFrame(preprocess.fit_transform(X), columns=labels)
X_transformed | Titanic - Machine Learning from Disaster |
13,821,516 | id_train=df_train['ID_code']
df_out = pd.DataFrame({'id_train':id_train.values, 'target':oof_xgb_train})
df_out.to_csv('SCP_xgb_train.csv', index=False )<compute_test_metric> | random_state = 2020
clf_list = [('LogisticRegression', LogisticRegression(random_state = random_state)) ,
('KNN_Classifier', KNeighborsClassifier()),
('SVC', SVC(random_state = random_state, probability = True)) ,
('RandomForestClassifier', RandomForestClassifier(random_state = random_state)) ,
('XGBClassifier', XG... | Titanic - Machine Learning from Disaster |
13,821,516 | roc_auc_score(Y_train, oof_xgb_train )<load_from_csv> | estimators = [('lr', clf_list[0][1]),
('knn', clf_list[1][1]),('svc', clf_list[2][1]),
('rf', clf_list[3][1]),('xgb', clf_list[4][1]),
('adb', clf_list[5][1])]
base_voting_hard = VotingClassifier(estimators = estimators , voting = 'hard')
base_voting_soft = VotingClassifier(estimators = estimators , voting = 'soft'... | Titanic - Machine Learning from Disaster |
13,821,516 | train = pd.read_csv('.. /input/santander-customer-transaction-prediction/train.csv')
test = pd.read_csv('.. /input/santander-customer-transaction-prediction/test.csv')
train_knowledge = pd.read_csv('.. /input/santander-2019-distillation/lgbm_train.csv' )<prepare_x_and_y> | final_pipe = make_pipeline(preprocess, LogisticRegression())
param_grid = {'logisticregression__max_iter' : [100],
'logisticregression__penalty' : ['l1', 'l2'],
'logisticregression__C' : np.logspace(-2, 2, 20),
'logisticregression__solver' : ['lbfgs', 'liblinear']}
grid_lr = GridSearchCV(final_pipe, param_grid = param... | Titanic - Machine Learning from Disaster |
13,821,516 | y = train['target']
y_knowledge = train_knowledge['target']
id_code_train = train['ID_code']
id_code_test = test['ID_code']
features = [c for c in train.columns if c not in ['ID_code', 'target']]<feature_engineering> | lr = LogisticRegression()
param_grid = {'max_iter' : [100],
'penalty' : ['l1', 'l2'],
'C' : np.logspace(-2, 2, 20),
'solver' : ['lbfgs', 'liblinear']}
grid_lr = GridSearchCV(lr, param_grid = param_grid, cv = skf, verbose = False, n_jobs = -1)
best_grid_lr = grid_lr.fit(X_transformed, y)
lr_param = best_grid_lr.best_p... | Titanic - Machine Learning from Disaster |
13,821,516 | for feature in features:
train['sq_'+feature] =(train[feature])**2
train['c_'+feature] =(train[feature])**3
train['r2_'+feature] = np.round(train[feature], 2)
<feature_engineering> | knn = KNeighborsClassifier()
final_pipe = make_pipeline(preprocess, knn)
param_grid = {'kneighborsclassifier__n_neighbors' : np.arange(3, 30, 2),
'kneighborsclassifier__weights': ['uniform', 'distance'],
'kneighborsclassifier__algorithm': ['auto'],
'kneighborsclassifier__p': [1, 2]}
grid_knn = GridSearchCV(final_pipe,... | Titanic - Machine Learning from Disaster |
13,821,516 | for feature in features:
test['sq_'+feature] =(test[feature])**2
test['c_'+feature] =(test[feature])**3
test['r2_'+feature] = np.round(test[feature], 2 )<normalization> | knn = KNeighborsClassifier()
param_grid = {'n_neighbors' : np.arange(3, 30, 2),
'weights': ['uniform', 'distance'],
'algorithm': ['auto'],
'p': [1, 2]}
grid_knn = GridSearchCV(knn, param_grid = param_grid, cv = skf, verbose = False, n_jobs = -1)
best_grid_knn = grid_knn.fit(X_transformed, y)
knn_param = best_grid_knn... | Titanic - Machine Learning from Disaster |
13,821,516 | class GaussRankScaler() :
def __init__(self):
self.epsilon = 1e-9
self.lower = -1 + self.epsilon
self.upper = 1 - self.epsilon
self.range = self.upper - self.lower
def fit_transform(self, X):
i = np.argsort(X, axis = 0)
j = np.argsort(i, axis = 0)
assert(j.min() == 0 ).all()
assert(j.max() == len(j)- 1 ).all()
j_rang... | svc = SVC(probability = True)
param_grid = tuned_parameters = [{'kernel': ['rbf'],
'gamma': [0.01, 0.1, 0.5, 1, 2, 5],
'C': [.1, 1, 2, 5]},
{'kernel': ['linear'],
'C': [.1, 1, 2, 10]},
{'kernel': ['poly'],
'degree' : [2, 3, 4, 5],
'C': [.1, 1, 10]}]
grid_svc = GridSearchCV(svc, param_grid = param_grid, cv = skf, verbo... | Titanic - Machine Learning from Disaster |
13,821,516 | SPLIT = len(train)
train = train.append(test)
del test; gc.collect()
scaler = GaussRankScaler()
sc = StandardScaler()
for feat in tqdm(features):
train[feat] = sc.fit_transform(train[feat].values.reshape(-1, 1))
train[feat+'_r'] = rankdata(train[feat] ).astype('float32')
train[feat+'_n'] = norm.cdf(train[feat] ).ast... | rf = RandomForestClassifier(random_state = 2020)
param_grid = {'n_estimators': [50, 150, 300, 450],
'criterion': ['entropy'],
'bootstrap': [True],
'max_depth': [3, 5, 10],
'max_features': ['auto','sqrt'],
'min_samples_leaf': [2, 3],
'min_samples_split': [2, 3]}
grid_rf = GridSearchCV(rf, param_grid = param_grid, cv = ... | Titanic - Machine Learning from Disaster |
13,821,516 | x_train, x_valid, y_train, y_valid, y_knowledge_train, y_knowledge_valid = train_test_split(train, y, y_knowledge, stratify=y, test_size=0.2, random_state=8 )<choose_model_class> | xgb = XGBClassifier(random_state = 2020)
param_grid = {'n_estimators': [15, 25, 50, 100],
'colsample_bytree': [0.65, 0.75, 0.80],
'max_depth': [None],
'reg_alpha': [1],
'reg_lambda': [1, 2, 5],
'subsample': [0.50, 0.75, 1.00],
'learning_rate': [0.01, 0.1, 0.5],
'gamma': [0.5, 1, 2, 5],
'min_child_weight': [0.01],
'sam... | Titanic - Machine Learning from Disaster |
13,821,516 | function = 'relu'
def create_model(input_shape, n_out):
input_tensor = Input(shape=input_shape)
x = Dense(16, activation=function )(input_tensor)
x = Flatten()(x)
out_put = Dense(n_out, activation='sigmoid' )(x)
model = Model(input_tensor, out_put)
return model<compute_test_metric> | adblogis = AdaBoostClassifier(base_estimator = DecisionTreeClassifier(random_state = random_state), random_state=random_state)
param_grid = {'algorithm': ['SAMME', 'SAMME.R'],
'base_estimator__criterion' : ['gini', 'entropy'],
'base_estimator__splitter' : ['best', 'random'],
'n_estimators': [2, 5, 10, 50],
'learning_r... | Titanic - Machine Learning from Disaster |
13,821,516 | def auc(y_true, y_pred):
return tf.py_func(roc_auc_score,(y_true, y_pred), tf.double )<compute_train_metric> | clf_list = [("LogisticRegression", best_grid_lr.best_estimator_),
("KNN_Classifier", best_grid_knn.best_estimator_),
('SVC', best_grid_svc.best_estimator_),
('RandomForestClassifier', best_grid_rf.best_estimator_),
("XGBClassifier", best_grid_xgb.best_estimator_),
("AdaBoostClassifier", best_grid_adblogis.best_est... | Titanic - Machine Learning from Disaster |
13,821,516 | gamma = 2.0
alpha=.25
epsilon = K.epsilon()
def focal_loss(y_true, y_pred):
pt_1 = y_pred * y_true
pt_1 = K.clip(pt_1, epsilon, 1-epsilon)
CE_1 = -K.log(pt_1)
FL_1 = alpha* K.pow(1-pt_1, gamma)* CE_1
pt_0 =(1-y_pred)*(1-y_true)
pt_0 = K.clip(pt_0, epsilon, 1-epsilon)
CE_0 = -K.log(pt_0)
FL_0 =(1-alpha)* K.pow(1-pt... | test_final_transformed = pd.DataFrame(preprocess.fit_transform(test_final), columns = preprocess.transformers_[0][2] + list(preprocess.transformers_[1][1][1].get_feature_names()))
test_final_transformed.sample(7 ) | Titanic - Machine Learning from Disaster |
13,821,516 | def mixup_data(x, y, alpha=1.0):
if alpha > 0:
lam = np.random.beta(alpha, alpha)
else:
lam = 1
sample_size = x.shape[0]
index_array = np.arange(sample_size)
np.random.shuffle(index_array)
mixed_x = lam * x +(1 - lam)* x[index_array]
mixed_y =(lam * y)+(( 1 - lam)* y[index_array])
return mixed_x, mixed_y
def make_b... | best_lr = best_grid_lr.best_estimator_
best_knn = best_grid_knn.best_estimator_
best_svc = best_grid_svc.best_estimator_
best_rf = best_grid_rf.best_estimator_
best_xgb = best_grid_xgb.best_estimator_
best_ada = best_grid_adblogis.best_estimator_
estimators = [('lr', best_lr),('knn', best_knn),('svc', best_svc),
('rf'... | Titanic - Machine Learning from Disaster |
13,821,516 | model = create_model(( NUM_FEATURES,1), 1)
model.compile(loss='binary_crossentropy', optimizer='adam')
model.summary()
checkpoint = ModelCheckpoint('feed_forward_model.h5', monitor='val_loss', verbose=1,
save_best_only=True, mode='min', save_weights_only = True)
reduceLROnPlat = ReduceLROnPlateau(monitor='val_loss',... | base_voting_hard.fit(X_transformed, y)
base_voting_soft.fit(X_transformed, y)
y_pred_base_hard = base_voting_hard.predict(test_final_transformed)
y_pred_base_soft = base_voting_hard.predict(test_final_transformed ) | Titanic - Machine Learning from Disaster |
13,821,516 | model.load_weights('feed_forward_model.h5')
prediction = model.predict(x_valid, batch_size=512, verbose=1)
roc_auc_score(y_valid, prediction )<concatenate> | test_df = pd.DataFrame(pd.read_csv('.. /input/titanic/test.csv')['PassengerId'])
pd.DataFrame(data = {'PassengerId': test_df.PassengerId,
'Survived': y_pred_base_hard.astype(int)} ).to_csv('01-Baseline_Hard_voting.csv', index = False)
pd.DataFrame(data = {'PassengerId': test_df.PassengerId,
'Survived': y_pred_base_so... | Titanic - Machine Learning from Disaster |
11,901,220 | y_train = np.vstack(( y_train, y_knowledge_train)).T
y_valid = np.vstack(( y_valid, y_knowledge_valid)).T
print(y_train.shape)
y_train[0]<compute_test_metric> | df1 = pd.read_csv("/kaggle/input/titanic/train.csv")
df1.head() | Titanic - Machine Learning from Disaster |
11,901,220 | def knowledge_distillation_loss_withBE(y_true, y_pred, beta=0.1):
y_true, y_pred_teacher = y_true[: , :1], y_true[: , 1:]
y_pred, y_pred_stu = y_pred[: , :1], y_pred[: , 1:]
loss = beta*binary_crossentropy(y_true,y_pred)+(1-beta)*binary_crossentropy(y_pred_teacher, y_pred_stu)
return loss<compute_test_metric> | df2 = pd.read_csv("/kaggle/input/titanic/test.csv")
df2.head() | Titanic - Machine Learning from Disaster |
11,901,220 | def auc_2(y_true, y_pred):
y_true = y_true[:, :1]
y_pred = y_pred[:, :1]
return tf.py_func(roc_auc_score,(y_true, y_pred), tf.double)
def auc_3(y_true, y_pred):
y_true = y_true[:, :1]
y_pred = y_pred[:, 1:]
return tf.py_func(roc_auc_score,(y_true, y_pred), tf.double )<choose_model_class> | print(df1.isnull().sum())
print("
****************
")
print(df2.isnull().sum() ) | Titanic - Machine Learning from Disaster |
11,901,220 | model = create_model(( NUM_FEATURES,1), 2)
model.compile(loss=knowledge_distillation_loss_withBE, optimizer='adam', metrics=[auc_2])
checkpoint = ModelCheckpoint('student_model_BE.h5', monitor='val_auc_2', verbose=1,
save_best_only=True, mode='max', save_weights_only = True)
reduceLROnPlat = ReduceLROnPlateau(monito... | df1['Age'].fillna(df1['Age'].median() ,inplace=True)
df2['Age'].fillna(df2['Age'].median() ,inplace=True ) | Titanic - Machine Learning from Disaster |
11,901,220 | def knowledge_distillation_loss_withFL(y_true, y_pred, beta=0.1):
y_true, y_pred_teacher = y_true[: , :1], y_true[: , 1:]
y_pred, y_pred_stu = y_pred[: , :1], y_pred[: , 1:]
loss = beta*focal_loss(y_true,y_pred)+(1-beta)*binary_crossentropy(y_pred_teacher, y_pred_stu)
return loss<choose_model_class> | df2['Fare'].fillna(df2['Fare'].median() ,inplace=True ) | Titanic - Machine Learning from Disaster |
11,901,220 | model = create_model(( NUM_FEATURES,1), 2)
model.compile(loss=knowledge_distillation_loss_withFL, optimizer='adam', metrics=[auc_2, auc_3])
checkpoint = ModelCheckpoint('student_model_FL.h5', monitor='val_auc_2', verbose=1,
save_best_only=True, mode='max', save_weights_only = True)
reduceLROnPlat = ReduceLROnPlateau... | df1.drop(['PassengerId','Name','Ticket'],axis=1,inplace=True)
df2.drop(['Name','Ticket'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
11,901,220 | def sigmoid(x, derivative=False):
return x*(1-x)if derivative else 1/(1+np.exp(-x))
TEMPERATURE = 2
y_knowledge_logit = logit(y_knowledge)
y_temperature = sigmoid(y_knowledge_logit/TEMPERATURE)
x_train, x_valid, y_train, y_valid, y_knowledge_train, y_knowledge_valid = train_test_split(train, y, y_temperature,
stratif... | df1['family_members']=df1['Parch']+df1['SibSp']
df2['family_members']=df2['Parch']+df2['SibSp'] | Titanic - Machine Learning from Disaster |
11,901,220 | y_train = np.vstack(( y_train, y_knowledge_train)).T
y_valid = np.vstack(( y_valid, y_knowledge_valid)).T
print(y_train.shape)
y_train[0]<choose_model_class> | df1.drop(['SibSp','Parch','Embarked'],axis=1,inplace=True)
df2.drop(['SibSp','Parch','Embarked'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
11,901,220 | model = create_model(( NUM_FEATURES,1), 2)
model.compile(loss=knowledge_distillation_loss_withFL, optimizer='adam', metrics=[auc_2,auc_3])
checkpoint = ModelCheckpoint('student_model_FL.h5', monitor='val_auc_2', verbose=1,
save_best_only=True, mode='max', save_weights_only = True)
reduceLROnPlat = ReduceLROnPlateau(... | df1.groupby(df1['Cabin'].isnull())['Survived'].mean() | Titanic - Machine Learning from Disaster |
11,901,220 | num_fold = 5
folds = list(StratifiedKFold(n_splits=num_fold, shuffle=True, random_state=7 ).split(train, y))
y_test_pred_log = np.zeros(len(train))
y_train_pred_log = np.zeros(len(train))
print(y_test_pred_log.shape)
print(y_train_pred_log.shape)
score = []
for j,(train_idx, valid_idx)in enumerate(folds):
print('
===... | df1['Cabin_Alotted']=np.where(df1['Cabin'].isnull() ,0,1)
df2['Cabin_Alotted']=np.where(df2['Cabin'].isnull() ,0,1 ) | Titanic - Machine Learning from Disaster |
11,901,220 | print("OOF score: ", roc_auc_score(y, y_train_pred_log/num_fold))
print("average {} folds score: ".format(num_fold), np.sum(score)/num_fold)
<save_to_csv> | df1.drop('Cabin',axis=1,inplace=True)
df2.drop('Cabin',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
11,901,220 | submit = pd.read_csv('.. /input/santander-customer-transaction-prediction/sample_submission.csv')
submit['ID_code'] = id_code_test
submit['target'] = y_test_pred_log/num_fold
submit.to_csv('submission.csv', index=False)
submit.head()<import_modules> | df1['Age']=np.where(df1['Age']<18,'child','Adult')
df2['Age']=np.where(df2['Age']<18,'child','Adult' ) | Titanic - Machine Learning from Disaster |
11,901,220 | import numpy as np
import pandas as pd
import numba
from sympy import isprime, primerange
from math import sqrt
from sklearn.neighbors import KDTree
from tqdm import tqdm
from itertools import combinations, permutations
from functools import lru_cache<load_from_csv> | df1['Fare']=np.where(df1['Fare']<80,'low_cost','High_cost')
df2['Fare']=np.where(df2['Fare']<80,'low_cost','High_cost' ) | Titanic - Machine Learning from Disaster |
11,901,220 | cities = pd.read_csv('.. /input/traveling-santa-2018-prime-paths/cities.csv', index_col=['CityId'])
XY = np.stack(( cities.X.astype(np.float32), cities.Y.astype(np.float32)) , axis=1)
is_not_prime = np.array([0 if isprime(i)else 1 for i in cities.index], dtype=np.int32 )<compute_test_metric> | y = df1["Survived"]
features = ["Pclass","Sex","Age","Fare","family_members","Cabin_Alotted"]
X = pd.get_dummies(df1[features])
X_test = pd.get_dummies(df2[features])
model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=1)
model.fit(X, y)
predictions = model.predict(X_test)
output = pd.DataFr... | Titanic - Machine Learning from Disaster |
13,663,126 | @numba.jit('f8(i8, i8, i8)', nopython=True, parallel=False)
def cities_distance(offset, id_from, id_to):
xy_from, xy_to = XY[id_from], XY[id_to]
dx, dy = xy_from[0] - xy_to[0], xy_from[1] - xy_to[1]
distance = sqrt(dx * dx + dy * dy)
if offset % 10 == 9 and is_not_prime[id_from]:
return 1.1 * distance
return distance... | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
test_data = pd.read_csv("/kaggle/input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
13,663,126 | kdt = KDTree(XY )<load_from_csv> | train_data.isna().sum() | Titanic - Machine Learning from Disaster |
13,663,126 | path = np.array(pd.read_csv('.. /input/close-ends-chunks-optimization-aka-2-opt/1515567.693648386.csv' ).Path )<randomize_order> | train_data = train_data.drop(labels=["Cabin"], axis="columns")
test_data = test_data.drop(labels=["Cabin"], axis="columns" ) | Titanic - Machine Learning from Disaster |
13,663,126 | def not_trivial_permutations(iterable):
perms = permutations(iterable)
next(perms)
yield from perms
@lru_cache(maxsize=None)
def not_trivial_indexes_permutations(length):
return np.array([list(p)for p in not_trivial_permutations(range(length)) ])
path_index = np.argsort(path[:-1])
print(f'Total score is {score_pat... | train_data["Age"] = train_data["Age"].fillna(28)
test_data["Age"] = test_data["Age"].fillna(28 ) | Titanic - Machine Learning from Disaster |
13,663,126 | print(f'Final score is {score_path(path):.2f}.' )<save_to_csv> | test_data.isna().sum() | Titanic - Machine Learning from Disaster |
13,663,126 | def make_submission(name, path):
pd.DataFrame({'Path': path} ).to_csv(f'{name}.csv', index=False )<compute_test_metric> | test_data["Fare"] = test_data["Fare"].fillna(14.454200 ) | Titanic - Machine Learning from Disaster |
13,663,126 | make_submission(score_path(path), path )<import_modules> | label_encoder = LabelEncoder()
train_data["Sex"] = label_encoder.fit_transform(train_data["Sex"])
test_data["Sex"] = label_encoder.fit_transform(test_data["Sex"] ) | Titanic - Machine Learning from Disaster |
13,663,126 | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from keras.utils import to_categorical
from keras.models import Sequential, load_model
from keras.layers import Conv2D, Dense, Flatten, MaxPool2D, Dropout
from keras.optimize... | train_data["Embarked"] = train_data["Embarked"].fillna("X")
test_data["Embarked"] = test_data["Embarked"].fillna("X" ) | Titanic - Machine Learning from Disaster |
13,663,126 | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
print(train.head())
test = pd.read_csv('.. /input/digit-recognizer/test.csv')
print(test.head() )<prepare_x_and_y> | train_data["Embarked"] = label_encoder.fit_transform(train_data["Embarked"])
test_data["Embarked"] = label_encoder.fit_transform(test_data["Embarked"] ) | Titanic - Machine Learning from Disaster |
13,663,126 | X_train = train.drop(labels = ['label'], axis = 1)
y_train = train.label
del train<normalization> | Ticket1 = []
for i in list(train_data.Ticket):
if not i.isdigit() :
Ticket1.append(i.replace(".","" ).replace("/","" ).strip().split(' ')[0])
else:
Ticket1.append("X")
train_data["Ticket"] = Ticket1
Ticket2 = []
for j in list(test_data.Ticket):
if not j.isdigit() :
Ticket2.append(j.replace(".","" ).replace("/","" ).s... | Titanic - Machine Learning from Disaster |
13,663,126 | X_train = X_train / 255.0
test = test / 255.0<categorify> | unique1 = ["Ticket_" + s for s in unique1]
unique2 = ["Ticket_" + s for s in unique2] | Titanic - Machine Learning from Disaster |
13,663,126 | y_train = to_categorical(y_train, num_classes = 10 )<split> | train_data = pd.get_dummies(train_data, columns = ["Ticket"])
test_data = pd.get_dummies(test_data, columns = ["Ticket"] ) | Titanic - Machine Learning from Disaster |
13,663,126 | X_train, X_val, y_train, y_val = train_test_split(X_train, y_train,
test_size = 0.1,
random_state = 10,
stratify = y_train )<choose_model_class> | train_data = train_data.drop(labels = unique1 , axis = "columns")
test_data = test_data.drop(labels = unique2 , axis = "columns" ) | Titanic - Machine Learning from Disaster |
13,663,126 | annealer = LearningRateScheduler(lambda x: 1e-3 * 0.95 ** x, verbose = 0)
nets = 3
model = [0] * nets
for i in range(nets):
model[i] = Sequential()
model[i].add(Conv2D(filters = 32, kernel_size = 5, padding = 'same',
activation = 'relu',
input_shape =(28, 28, 1)))
model[i].add(MaxPool2D())
if i > 0:
model[i].add(Con... | train_title = [i.split(",")[1].split(".")[0].strip() for i in train_data["Name"]]
train_data["Title"] = pd.Series(train_title)
test_title = [i.split(",")[1].split(".")[0].strip() for i in test_data["Name"]]
test_data["Title"] = pd.Series(test_title ) | Titanic - Machine Learning from Disaster |
13,663,126 | nets = 7
model = [0] * nets
for i in range(nets):
model[i] = Sequential()
model[i].add(Conv2D(i*8+8, kernel_size = 5,
padding = 'same',
activation = 'relu',
input_shape =(28, 28, 1)))
model[i].add(MaxPool2D())
model[i].add(Conv2D(i*16+16, kernel_size = 5,
padding = 'same',
activation = 'relu'))
model[i].add(MaxPool2D... | train_data = train_data.drop(labels = "Name", axis = "columns")
test_data = test_data.drop(labels = "Name", axis = "columns" ) | Titanic - Machine Learning from Disaster |
13,663,126 | nets = 8
model = [0] * nets
for i in range(nets):
model[i] = Sequential()
model[i].add(Conv2D(48, kernel_size = 5,
padding = 'same',
activation = 'relu',
input_shape =(28, 28, 1)))
model[i].add(MaxPool2D())
model[i].add(Conv2D(96, kernel_size = 5,
activation = 'relu'))
model[i].add(MaxPool2D())
model[i].add(Flatten(... | 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 |
13,663,126 | nets = 8
model = [0] * nets
names = []
for i, n in enumerate(range(8)) :
names.append(f'{n*10}%')
for i in range(nets):
model[i] = Sequential()
model[i].add(Conv2D(48, kernel_size = 5,
padding = 'same',
activation = 'relu',
input_shape =(28, 28, 1)))
model[i].add(MaxPool2D())
model[i].add(Dropout(i*0.1))
model[i].ad... | pred = train_data['Survived'] | Titanic - Machine Learning from Disaster |
13,663,126 | def create_model(optimizer = 'adam', activation = 'relu'):
model = Sequential()
model.add(Conv2D(48, kernel_size = 5,
padding = 'same',
activation = activation,
input_shape =(28, 28, 1)))
model.add(MaxPool2D())
model.add(Dropout(0.4))
model.add(Conv2D(96, kernel_size = 5,
activation = activation))
model.add(MaxPool2D... | import statsmodels.formula.api as smf
import statsmodels.api as sm | Titanic - Machine Learning from Disaster |
13,663,126 | print('Best: {0: 5f} using {1}'.format(random_search_results.best_score_,
random_search_results.best_params_))<choose_model_class> | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_A4 + Ticket_A5 +Ticket_C + Ticket_CA+Ticket_FC + Ticket_FCC + Ticket_PC + Ticket_PP+ Ticket_SC + Ticket_SCA4 + Ticket_SCAH + Ticket_SCPARIS + Ticket_SCParis + Ticket_SOC+Ticket_SOPP+Ticket_SOTONO2+Ticket_SOTONOQ + Ticket_STONO +... | Titanic - Machine Learning from Disaster |
13,663,126 | early_stopping = EarlyStopping(monitor = 'val_loss', patience = 5,
verbose = 0,
restore_best_weights = True)
annealer = LearningRateScheduler(lambda x: 1e-3 * 0.95 ** x, verbose = 0)
model_checkpoint = ModelCheckpoint('Digit_Recognizer.hdf5', monitor='val_accuracy',
verbose=1, save_best_only=True,
mode='max')
cnn = ... | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_A4 + Ticket_A5 +Ticket_C + Ticket_CA + Ticket_FCC + Ticket_PC + Ticket_PP+ Ticket_SCAH + Ticket_SCPARIS + Ticket_SCParis + Ticket_SOC+Ticket_SOPP+Ticket_SOTONO2+Ticket_SOTONOQ + Ticket_STONO + Ticket_STONO2 + Ticket_WC + Ticket_... | Titanic - Machine Learning from Disaster |
13,663,126 | model = load_model('Digit_Recognizer.hdf5')
model.evaluate(X_val, y_val)
pred = model.predict(test)
pred = np.argmax(pred, axis=1)
pred = pd.Series(pred,name="Label")
result = pd.concat([pd.Series(range(1,28001),name = "ImageId"),pred],axis = 1)
result.to_csv("./digit_recognizer.csv",index=False )<load_pretrained... | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_A4 + Ticket_A5 +Ticket_C + Ticket_CA + Ticket_FCC + Ticket_PC + Ticket_PP+ Ticket_SCAH + Ticket_SCPARIS + Ticket_SCParis + Ticket_SOC+Ticket_SOPP+Ticket_SOTONOQ + Ticket_STONO + Ticket_STONO2 + Ticket_WC + Ticket_WEP + Ticket_X ... | Titanic - Machine Learning from Disaster |
13,663,126 | %run.. /input/python-recipes/dhtml.py
%run.. /input/python-recipes/load_kaggle_digits.py
%run.. /input/python-recipes/classify_kaggle_digits.py
dhtml('Data Processing' )<train_model> | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_A5 +Ticket_C + Ticket_CA + Ticket_FCC + Ticket_PC + Ticket_PP+ Ticket_SCAH + Ticket_SCPARIS + Ticket_SCParis + Ticket_SOC+Ticket_SOPP+Ticket_SOTONOQ + Ticket_STONO + Ticket_STONO2 + Ticket_WC + Ticket_WEP + Ticket_X +Title', dat... | Titanic - Machine Learning from Disaster |
13,663,126 | k=.75; cmap='Pastel1_r'
x_train,y_train,x_valid,y_valid,x_test,y_test,\
test_images,num_classes=\
load_kaggle_digits(k,cmap )<compute_test_metric> | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_A5 +Ticket_C + Ticket_CA + Ticket_FCC + Ticket_PC + Ticket_PP+ Ticket_SCAH + Ticket_SCPARIS + Ticket_SCParis + Ticket_SOC+Ticket_SOTONOQ + Ticket_STONO + Ticket_STONO2 + Ticket_WC + Ticket_WEP + Ticket_X +Title', data=train_data... | Titanic - Machine Learning from Disaster |
13,663,126 | num_test=100
model_evaluation(cnn_model,x_test,y_test,
weights,color,num_test )<save_to_csv> | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_A5 +Ticket_C + Ticket_CA + Ticket_FCC + Ticket_PC + Ticket_PP+ Ticket_SCAH + Ticket_SCPARIS + Ticket_SCParis + Ticket_SOC+Ticket_SOTONOQ + Ticket_STONO + Ticket_WC + Ticket_WEP + Ticket_X +Title', data=train_data, family=sm.fami... | Titanic - Machine Learning from Disaster |
13,663,126 | cnn_model.load_weights(weights)
predict_test_labels=\
cnn_model.predict_classes(test_images)
submission=pd.DataFrame(
{'ImageId':range(1,len(predict_test_labels)+1),
'Label':predict_test_labels})
submission.to_csv('kaggle_digits.csv',index=False)
fig=pl.figure(figsize=(10,6))
for i in range(15):
ax=fig.add_subplot... | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_C + Ticket_CA + Ticket_FCC + Ticket_PC + Ticket_PP+ Ticket_SCAH + Ticket_SCPARIS + Ticket_SCParis + Ticket_SOC+Ticket_SOTONOQ + Ticket_STONO + Ticket_WC + Ticket_WEP + Ticket_X +Title', data=train_data, family=sm.families.Binomi... | Titanic - Machine Learning from Disaster |
13,663,126 | random_seed = 2
%matplotlib inline
np.random.seed(2)
sns.set(style='white', context='notebook', palette='deep' )<load_from_csv> | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_C + Ticket_CA + Ticket_FCC + Ticket_PC + Ticket_PP+ Ticket_SCAH + Ticket_SCParis + Ticket_SOC+Ticket_SOTONOQ + Ticket_STONO + Ticket_WC + Ticket_WEP + Ticket_X +Title', data=train_data, family=sm.families.Binomial() ).fit()
prin... | Titanic - Machine Learning from Disaster |
13,663,126 | X = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
Y = X["label"]
X.drop("label",axis = 1, inplace = True)
<count_missing_values> | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_C + Ticket_CA + Ticket_FCC + Ticket_PC + Ticket_PP+ Ticket_SCAH + Ticket_SOC+Ticket_SOTONOQ + Ticket_STONO + Ticket_WC + Ticket_WEP + Ticket_X +Title', data=train_data, family=sm.families.Binomial() ).fit()
print(reg_log.summary... | Titanic - Machine Learning from Disaster |
13,663,126 | np.sum(X.isnull().any() )<count_missing_values> | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_C + Ticket_CA + Ticket_FCC + Ticket_PC + Ticket_PP + Ticket_SOC+Ticket_SOTONOQ + Ticket_STONO + Ticket_WC + Ticket_WEP + Ticket_X +Title', data=train_data, family=sm.families.Binomial() ).fit()
print(reg_log.summary() ) | Titanic - Machine Learning from Disaster |
13,663,126 | sum(test.isnull().any() )<choose_model_class> | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_C + Ticket_CA + Ticket_FCC + Ticket_PC + Ticket_PP + Ticket_SOC+Ticket_SOTONOQ + Ticket_STONO + Ticket_WC + Ticket_WEP +Title', data=train_data, family=sm.families.Binomial() ).fit()
print(reg_log.summary() ) | Titanic - Machine Learning from Disaster |
13,663,126 | def get_model(optim, loss):
model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))
mode... | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_C + Ticket_CA + Ticket_FCC + Ticket_PC + Ticket_PP + Ticket_SOC+ Ticket_STONO + Ticket_WC +Title', data=train_data, family=sm.families.Binomial() ).fit()
print(reg_log.summary() ) | Titanic - Machine Learning from Disaster |
13,663,126 | X_train,Y_train = normalize(X,Y)
X_test,_ = normalize(test)
encoder = OneHotEncoder()
encoder.fit(Y_train )<define_variables> | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_C +Ticket_PC + Ticket_PP + Ticket_SOC+ Ticket_STONO + Ticket_WC +Title', data=train_data, family=sm.families.Binomial() ).fit()
print(reg_log.summary() ) | Titanic - Machine Learning from Disaster |
13,663,126 | data_generator = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
<choose_m... | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked + Ticket_C +Ticket_PC + Ticket_STONO + Ticket_WC +Title', data=train_data, family=sm.families.Binomial() ).fit()
print(reg_log.summary() ) | Titanic - Machine Learning from Disaster |
13,663,126 | EPOCHS = 50
BATCH_SIZE = 20
ENSEMBLES = 7
results = np.zeros(( test.shape[0],10))
histories = []
models = []
callback_list = [
ReduceLROnPlateau(monitor='val_loss', factor=0.25, min_lr=0.00001, patience=2, verbose=1),
EarlyStopping(monitor='val_loss', min_delta=0.0001, patience=3, verbose=1)
]
optimizer = Adam(learnin... | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Embarked + Ticket_C +Ticket_PC + Ticket_STONO + Ticket_WC +Title', data=train_data, family=sm.families.Binomial() ).fit()
print(reg_log.summary() ) | Titanic - Machine Learning from Disaster |
13,663,126 | for i in range(ENSEMBLES):
X_train_tmp, X_val, y_train_tmp, y_val = get_samples(X_train, Y_train, encoder)
data_generator.fit(X_train_tmp)
models.append(get_model(optimizer, loss_fn))
history = models[i].fit_generator(data_generator.flow(X_train_tmp, y_train_tmp, batch_size=BATCH_SIZE),
epochs=EPOCHS,
callbacks=[call... | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp + Parch + Embarked + Ticket_C + Ticket_STONO + Ticket_WC +Title', data=train_data, family=sm.families.Binomial() ).fit()
print(reg_log.summary() ) | Titanic - Machine Learning from Disaster |
13,663,126 | results = np.zeros(( X_test.shape[0],10))
for i in range(ENSEMBLES):
results = results + models[i].predict(X_test)
results = np.argmax(results, axis = 1 )<save_to_csv> | reg_log = smf.glm('Survived ~ Pclass + Sex + Age + SibSp+ Embarked + Ticket_STONO + Ticket_WC +Title', data=train_data, family=sm.families.Binomial() ).fit()
print(reg_log.summary() ) | Titanic - Machine Learning from Disaster |
13,663,126 | submission = pd.DataFrame({"ImageID": range(1,len(results)+1), "Label": results})
submission.to_csv('submission.csv', index=False )<define_variables> | pr = reg_log.predict(test_data ) | Titanic - Machine Learning from Disaster |
13,663,126 | data_dir='/kaggle/input/digit-recognizer/'<load_from_csv> | y_pred =(pr > 0.65 ).astype(int ) | Titanic - Machine Learning from Disaster |
13,663,126 | <count_values><EOS> | output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': y_pred})
output.to_csv('./submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,773,137 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<count_missing_values> | %matplotlib inline | Titanic - Machine Learning from Disaster |
13,773,137 | train.isnull().sum()<count_missing_values> | train = pd.read_csv(".. /input/titanic/train.csv")
test = pd.read_csv(".. /input/titanic/test.csv")
train.describe(include="all" ) | Titanic - Machine Learning from Disaster |
13,773,137 | train.isnull().sum()<count_missing_values> | pd.isnull(train ).sum() | Titanic - Machine Learning from Disaster |
13,773,137 | features=[i for i in train.columns]
k=0
for feature in features:
if train[feature].isnull().sum() ==0:
k=k+1
else:
print('{0} has {1} null values'.format(feature,train[feature].isnull().sum()))
if(k==train.shape[1]):
print('no nan's in the train dataset,so proceed')
<count_missing_values> | train.drop(['Cabin'], axis = 1, inplace = True)
test.drop(['Cabin'], axis = 1, inplace = True)
train.drop(['Ticket'], axis = 1, inplace = True)
test.drop(['Ticket'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
13,773,137 | features=[i for i in test.columns]
k=0
for feature in features:
if test[feature].isnull().sum() ==0:
k=k+1
else:
print('{0} has {1} null values'.format(feature,test[feature].isnull().sum()))
if(k==test.shape[1]):
print('no nan's in the test dataset,so proceed' )<prepare_x_and_y> | train.fillna({'Embarked':'S'}, inplace = True ) | Titanic - Machine Learning from Disaster |
13,773,137 | train_y=train['label']
train_x=train.drop('label',axis=1 )<data_type_conversions> | for dataset in combine:
dataset['Title'] = dataset['Title'].replace(['Lady', 'Capt', 'Col',
'Don', 'Dr', 'Major', 'Rev', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace(['Countess', 'Sir'], 'Royal')
dataset['Title'] = dataset['Title'].replace(['Mlle', 'Ms'], 'Miss')
dataset['Title'] = datase... | Titanic - Machine Learning from Disaster |
13,773,137 | def image_printer(i,train_x):
idx=i
grid_data=train_x.iloc[idx].to_numpy().reshape(28,28 ).astype('uint8')
plt.imshow(grid_data)
<count_values> | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Royal": 5, "Rare": 6}
for dataset in combine:
dataset['Title'] = dataset['Title'].map(title_mapping)
dataset['Title'] = dataset['Title'].fillna(0)
train.head() | Titanic - Machine Learning from Disaster |
13,773,137 | label.value_counts()<normalization> | mr_age = train[train["Title"] == 1]["AgeGroup"].mode()
miss_age = train[train["Title"] == 2]["AgeGroup"].mode()
mrs_age = train[train["Title"] == 3]["AgeGroup"].mode()
master_age = train[train["Title"] == 4]["AgeGroup"].mode()
royal_age = train[train["Title"] == 5]["AgeGroup"].mode()
rare_age = train[train["Title"] == ... | Titanic - Machine Learning from Disaster |
13,773,137 | std_data=StandardScaler().fit_transform(data)
print(np.mean(std_data))
print(np.std(std_data))<train_model> | age_mapping = {'Baby': 1, 'Child': 2, 'Teenager': 3, 'Student': 4, 'Young Adult': 5, 'Adult': 6, 'Senior': 7}
train['AgeGroup'] = train['AgeGroup'].map(age_mapping)
test['AgeGroup'] = test['AgeGroup'].map(age_mapping)
train.head() | Titanic - Machine Learning from Disaster |
13,773,137 | temp_data=std_data
covar_matrix=np.matmul(temp_data.T,temp_data)
print(f'shape of covar matrix is {covar_matrix.shape}')
print(f'shape of my data is {temp_data.shape}' )<compute_test_metric> | train = train.drop(['Age'], axis = 1)
test = test.drop(['Age'], axis = 1 ) | Titanic - Machine Learning from Disaster |
13,773,137 | eigh_values,eigh_vectors=eigh(covar_matrix,eigvals=(782,783))
print(f'shape of eigen vectors {eigh_vectors.shape}' )<train_model> | train.drop(['Name'], axis = 1, inplace = True)
test.drop(['Name'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
13,773,137 | pca_points=np.matmul(temp_data,eigh_vectors)
print(f'shape of my pca points is {pca_points.shape}' )<create_dataframe> | sex_mapping = {"male": 0, "female": 1}
train['Sex'] = train['Sex'].map(sex_mapping)
test['Sex'] = test['Sex'].map(sex_mapping)
train.head() | Titanic - Machine Learning from Disaster |
13,773,137 | pca_data=np.vstack(( pca_points.T,label)).T
print(f'shape of my pca data is {pca_data.shape}')
pca_dataframe=pd.DataFrame(data=pca_data,columns=('1st Principal comp','2nd Principal comp','label'))
print(pca_dataframe.head(10))<normalization> | embarked_mapping = {"S": 1, "C": 2, "Q": 3}
train['Embarked'] = train['Embarked'].map(embarked_mapping)
test['Embarked'] = test['Embarked'].map(embarked_mapping)
train.head() | Titanic - Machine Learning from Disaster |
13,773,137 | pca=decomposition.PCA()<import_modules> | predictors = train.drop(['Survived', 'PassengerId'], axis = 1)
target = train['Survived']
x_train, x_val, y_train, y_val = train_test_split(predictors, target, test_size = 0.22, random_state = 0 ) | Titanic - Machine Learning from Disaster |
13,773,137 | from sklearn.manifold import TSNE<prepare_x_and_y> | gaussian = GaussianNB()
gaussian.fit(x_train, y_train)
y_pred = gaussian.predict(x_val)
acc_gaussian = round(accuracy_score(y_pred, y_val)*100, 2)
acc_gaussian | 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.