kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
4,851,629 | df['BsmtUnfSF']=df['BsmtUnfSF'].fillna(method='ffill' )<data_type_conversions> | logistic_reg = LogisticRegressionCV(cv= 7 ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['Electrical']=df['Electrical'].fillna(method='ffill' )<feature_engineering> | threshold = np.arange(1, 10, 0.5)*1e-1 | Titanic - Machine Learning from Disaster |
4,851,629 | df['BsmtFinSF1']=df['BsmtFinSF1'].fillna(df['BsmtFinSF1'].mean() )<feature_engineering> | print('The highest accuracy score is:', np.max(np.array(scores)) ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['KitchenQual']=df['KitchenQual'].fillna(method='ffill' )<feature_engineering> | number_of_features = list(range(1,13)) | Titanic - Machine Learning from Disaster |
4,851,629 | df['SaleType']=df['SaleType'].fillna(method='ffill' )<feature_engineering> | print("Maximum accuracy score is :", max(scores_k)) | Titanic - Machine Learning from Disaster |
4,851,629 | df['Exterior2nd']=df['Exterior2nd'].fillna(method='ffill' )<drop_column> | print("Optimal number of features :", np.argmax(np.array(scores_k)) + 1 ) | Titanic - Machine Learning from Disaster |
4,851,629 | df=df.drop(['Id'],axis=1 )<categorify> | print("Optimal number of features : %d" % selector.n_features_ ) | Titanic - Machine Learning from Disaster |
4,851,629 | df=pd.get_dummies(df )<count_missing_values> | print("Maximum accuracy score is :", np.max(selector.grid_scores_)) | Titanic - Machine Learning from Disaster |
4,851,629 | df.isnull().sum()<prepare_x_and_y> | threshold = np.arange(1, 5, 0.1)*1e-1 | Titanic - Machine Learning from Disaster |
4,851,629 | train=df.iloc[:1460,:]<split> | print("Maximum accuracy score is :", np.max(np.array(scores_sfm)) ) | Titanic - Machine Learning from Disaster |
4,851,629 | test=df.iloc[1460:,:]
<prepare_x_and_y> | print("Optimal threshold :", threshold[np.argmax(np.array(scores_sfm)) ] ) | Titanic - Machine Learning from Disaster |
4,851,629 | X_train=train.drop(["SalePrice"],axis=1)
y_train=train['SalePrice']<drop_column> | selector = sklearn.feature_selection.SelectFromModel(logistic_reg, threshold= 0.25)
selector.fit(features, target)
lr_selected_features = selector.get_support() | Titanic - Machine Learning from Disaster |
4,851,629 | test=test.drop(['SalePrice'],axis=1 )<choose_model_class> | logistic_reg = LogisticRegressionCV(
Cs=1, cv= 7, scoring='accuracy', max_iter=1000, refit=True ) | Titanic - Machine Learning from Disaster |
4,851,629 | XGB = XGBRegressor(colsample_bytree=0.4603, gamma=0.0468,
learning_rate=0.05, max_depth=3,
min_child_weight=1.7817, n_estimators=2200,
reg_alpha=0.4640, reg_lambda=0.8571,
subsample=0.5213, silent=1,
random_state =7, nthread = -1)
XGB.fit(X_train,y_train )<choose_model_class> | lr_parameters_1 = {'solver': ['liblinear', 'saga'], 'penalty': ['l1']}
lr_parameters_2 = {'solver': ['newton-cg', 'lbfgs', 'sag'], 'penalty': ['l2']} | Titanic - Machine Learning from Disaster |
4,851,629 | LGBM = LGBMRegressor(objective='regression',num_leaves=5,
learning_rate=0.05, n_estimators=720,
max_bin = 55, bagging_fraction = 0.8,
bagging_freq = 5, feature_fraction = 0.2319,
feature_fraction_seed=9, bagging_seed=9,
min_data_in_leaf =6, min_sum_hessian_in_leaf = 11)
LGBM.fit(X_train,y_train )<train_model> | rs_lr = RandomizedSearchCV(logistic_reg, param_distributions= lr_parameters_2, n_iter= 100 ) | Titanic - Machine Learning from Disaster |
4,851,629 | GBoost = GradientBoostingRegressor(n_estimators=3000, learning_rate=0.05,
max_depth=4, max_features='sqrt',
min_samples_leaf=15, min_samples_split=10,
loss='huber', random_state =5)
GBoost.fit(X_train,y_train )<predict_on_test> | rs_lr.fit(x_train.loc[:, lr_selected_features], y_train ) | Titanic - Machine Learning from Disaster |
4,851,629 | y_pred_XGB=XGB.predict(test)
y_pred_LGBM=LGBM.predict(test)
y_pred_GB=GBoost.predict(test )<create_dataframe> | print('Best Parameters are:
', rs_lr.best_params_,
'
Training accuracy score is:
', rs_lr.best_score_ ) | Titanic - Machine Learning from Disaster |
4,851,629 | y_pred_XGB=pd.DataFrame(y_pred_XGB)
y_pred_LGBM=pd.DataFrame(y_pred_LGBM)
y_pred_GB=pd.DataFrame(y_pred_GB )<prepare_output> | print('Validation accuracy score is:
', rs_lr.score(
x_valid.loc[:, lr_selected_features], y_valid)) | Titanic - Machine Learning from Disaster |
4,851,629 | y_pred= 0.20 * y_pred_XGB[0] + 0.60 * y_pred_LGBM[0] + 0.20 * y_pred_GB[0]
y_pred<save_to_csv> | param_name = 'Cs'
param_range = [1, 10, 100, 1000]
train_score, valid_score = [], []
for cs in param_range:
lr = LogisticRegressionCV(Cs=cs, cv=7, scoring='accuracy', solver= 'newton-cg',
penalty= 'l2', refit=True, max_iter=1000)
lr.fit(x_train.loc[:, lr_selected_features], y_train)
train_score.append(
lr.score(x_tr... | Titanic - Machine Learning from Disaster |
4,851,629 | sub=pd.concat([df_test['Id'],pd.DataFrame(y_pred)],axis=1)
sub.columns=['Id','SalePrice']
sub.to_csv('submission.csv',index=False)
sub.head()<set_options> | lr = LogisticRegressionCV(Cs= 10, cv= 7, solver= 'newton-cg', penalty= 'l2')
lr.fit(x_train.loc[:, lr_selected_features], y_train ) | Titanic - Machine Learning from Disaster |
4,851,629 | warnings.filterwarnings('ignore')
%matplotlib inline
plt.style.use('seaborn')
<load_from_csv> | y_scores_lr = lr.predict_proba(x_test.loc[:, lr_selected_features])[:, 1]
lr_fpr, lr_tpr, lr_thresholds = sklearn.metrics.roc_curve(y_test, y_scores_lr ) | Titanic - Machine Learning from Disaster |
4,851,629 | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
features = [c for c in train.columns if c not in ['ID_code', 'target']]<sort_values> | lr_auc = sklearn.metrics.auc(x=lr_fpr, y=lr_tpr ) | Titanic - Machine Learning from Disaster |
4,851,629 | obs = train.isnull().sum().sort_values(ascending = False)
percent = round(train.isnull().sum().sort_values(ascending = False)/len(train)*100, 2)
pd.concat([obs, percent], axis = 1,keys= ['Number of Observations', 'Percent'] )<set_options> | lr_acc = lr.score(x_test.loc[:, lr_selected_features], y_test ) | Titanic - Machine Learning from Disaster |
4,851,629 | lin_pca = KernelPCA(n_components = 2, kernel="linear", fit_inverse_transform=True)
rbf_pca = KernelPCA(n_components = 2, kernel="rbf", gamma=0.0433, fit_inverse_transform=True)
sig_pca = KernelPCA(n_components = 2, kernel="sigmoid", gamma=0.001, coef0=1, fit_inverse_transform=True)
plt.figure(figsize=(11, 4))
for su... | print('For logistic Regression:
Area Under Curve: {},
Test Accuracy score: {}'.format(
lr_auc, lr_acc)) | Titanic - Machine Learning from Disaster |
4,851,629 | def augment(x,y,t=2):
xs,xn = [],[]
for i in range(t):
mask = y>0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
np.random.shuffle(ids)
x1[:,c] = x1[ids][:,c]
xs.append(x1)
for i in range(t//2):
mask = y==0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
... | nb = GaussianNB() | Titanic - Machine Learning from Disaster |
4,851,629 | param = {
'bagging_freq': 5,
'bagging_fraction': 0.335,
'boost_from_average':'false',
'boost': 'gbdt',
'feature_fraction': 0.041,
'learning_rate': 0.0083,
'max_depth': -1,
'metric':'auc',
'min_data_in_leaf': 80,
'min_sum_hessian_in_leaf': 10.0,
'num_leaves': 13,
'num_threads': 8,
'tree_learner': 'serial',
'objective': ... | threshold = np.arange(1, 10, 0.5)*1e-1 | Titanic - Machine Learning from Disaster |
4,851,629 | num_folds = 11
features = [c for c in train.columns if c not in ['ID_code', 'target']]
folds = KFold(n_splits=num_folds, random_state=2319)
oof = np.zeros(len(train))
getVal = np.zeros(len(train))
predictions = np.zeros(len(target))
feature_importance_df = pd.DataFrame()
print('Light GBM Model')
for fold_,(trn_idx, v... | scores = []
for i in threshold:
selector = sklearn.feature_selection.VarianceThreshold(threshold= i)
selected_features = selector.fit_transform(features)
nb.fit(selected_features, target)
y_pred = nb.predict(features.loc[:, selector.get_support() ])
scores.append(sklearn.metrics.accuracy_score(target, y_pred))
plt.... | Titanic - Machine Learning from Disaster |
4,851,629 | num_sub = 26
print('Saving the Submission File')
sub = pd.DataFrame({"ID_code": test.ID_code.values})
sub["target"] = predictions
sub.to_csv('submission{}.csv'.format(num_sub), index=False)
getValue = pd.DataFrame(getVal)
getValue.to_csv("Validation_kfold.csv" )<load_from_csv> | print('The highest accuracy score is:', np.max(np.array(scores)) ) | Titanic - Machine Learning from Disaster |
4,851,629 | oof = pd.read_csv(".. /input/santander-outputs/Validation_Skfold.csv")['0']
oof_2 = pd.read_csv(".. /input/santander-outputs/Validation_kfold.csv")['0']
predictions = pd.read_csv(".. /input/santander-outputs/submission26_skfold.csv")["target"]
predictions_2 = pd.read_csv(".. /input/santander-outputs/submission26_kfold.... | number_of_features = list(range(1,13)) | Titanic - Machine Learning from Disaster |
4,851,629 | train = pd.read_csv('.. /input/santander-customer-transaction-prediction/train.csv')
features = [c for c in train.columns if c not in ['ID_code', 'target']]<drop_column> | print("Maximum accuracy score is :", max(scores_k)) | Titanic - Machine Learning from Disaster |
4,851,629 | target = train['target']
train = train.drop(["ID_code", "target"], axis=1 )<prepare_x_and_y> | print("Optimal number of features :", np.argmax(np.array(scores_k)) + 1 ) | Titanic - Machine Learning from Disaster |
4,851,629 | train_stack = np.vstack([oof,oof_2] ).transpose()
test_stack = np.vstack([predictions, predictions_2] ).transpose()
folds_stack = RepeatedKFold(n_splits=5, n_repeats=2, random_state=15)
oof_stack = np.zeros(train_stack.shape[0])
predictions_3 = np.zeros(test_stack.shape[0])
for fold_,(trn_idx, val_idx)in enumerate(f... | selector = sklearn.feature_selection.VarianceThreshold(threshold= 0.1)
selector.fit(features, target)
nb_selected_features = selector.get_support() | Titanic - Machine Learning from Disaster |
4,851,629 | sample_submission = pd.read_csv('.. /input/santander-customer-transaction-prediction/sample_submission.csv')
sample_submission['target'] = predictions_3
sample_submission.to_csv('submission_ashish.csv', index=False )<set_options> | nb_params = {'priors': [[0.7, 0.3], [0.6, 0.4],
[0.5, 0.5], [0.4, 0.6], [0.3, 0.7]]} | Titanic - Machine Learning from Disaster |
4,851,629 | py.init_notebook_mode(connected=True)
plt.style.use('ggplot')
sns.set(font_scale=1)
pd.set_option('display.max_columns', 500 )<load_from_csv> | rs_nb = RandomizedSearchCV(nb, param_distributions= nb_params,cv= 7 ,n_iter= 200 ) | Titanic - Machine Learning from Disaster |
4,851,629 | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' )<load_from_csv> | rs_nb.fit(x_train.loc[:, nb_selected_features], y_train ) | Titanic - Machine Learning from Disaster |
4,851,629 | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' )<prepare_x_and_y> | print('Best Parameters are:
', rs_nb.best_params_,
'
Training accuracy score is:
', rs_nb.best_score_ ) | Titanic - Machine Learning from Disaster |
4,851,629 | features = [c for c in train.columns if c not in ['ID_code', 'target']]
features_t = [c for c in test.columns if c not in ['ID_code']]
y = train.target<find_best_params> | print('Validation accuracy score is:
', rs_nb.score(
x_valid.loc[:, nb_selected_features], y_valid)) | Titanic - Machine Learning from Disaster |
4,851,629 | %%time
def clusters(train,y):
distance = []
for cluster in range(2,11,1):
plt.figure(figsize=(10,7))
print('Started checking {}'.format(cluster))
kmeans = KMeans(cluster, random_state=2702)
labels = kmeans.fit_predict(train)
plt.title('Clusters {}'.format(cluster))
sns.countplot(labels, hue=y)
plt.show()
distance.ap... | nb = GaussianNB(priors= [0.4, 0.6])
nb.fit(x_train.loc[:, nb_selected_features], y_train ) | Titanic - Machine Learning from Disaster |
4,851,629 | sc = StandardScaler(copy=False)
train_sc = pd.DataFrame(sc.fit_transform(train[features]), columns=features)
test_sc = pd.DataFrame(sc.fit_transform(test[features_t]), columns=features_t)
gc.collect()<prepare_x_and_y> | y_scores_nb = nb.predict_proba(x_test.loc[:, nb_selected_features])[:, 1]
nb_fpr, nb_tpr, nb_thresholds = sklearn.metrics.roc_curve(y_test, y_scores_nb ) | Titanic - Machine Learning from Disaster |
4,851,629 | mn = MinMaxScaler(copy=False)
train_mn = pd.DataFrame(mn.fit_transform(train[features]), columns=features)
test_mn = pd.DataFrame(mn.fit_transform(test[features_t]), columns=features_t)
gc.collect()<feature_engineering> | nb_auc = sklearn.metrics.auc(x=nb_fpr, y=nb_tpr ) | Titanic - Machine Learning from Disaster |
4,851,629 | qt = QuantileTransformer(n_quantiles = 200)
train_qt = pd.DataFrame(mn.fit_transform(train[features]), columns=features)
test_qt = pd.DataFrame(mn.fit_transform(test[features_t]), columns=features_t)
gc.collect()<prepare_x_and_y> | nb_acc = nb.score(x_test.loc[:, nb_selected_features], y_test ) | Titanic - Machine Learning from Disaster |
4,851,629 | rs = RobustScaler(copy=False)
train_rs = pd.DataFrame(rs.fit_transform(train[features]), columns=features)
test_rs = pd.DataFrame(rs.fit_transform(test[features_t]), columns=features_t)
gc.collect()<train_model> | print('For Gaussian Naive Bayes:
Area Under Curve: {},
Test Accuracy score: {}'.format(
nb_auc, nb_acc)) | Titanic - Machine Learning from Disaster |
4,851,629 | X_train, X_test, y_train, y_test = train_test_split(
train[features], y, test_size=0.3,stratify = y, random_state=2701)
model = lgb.LGBMClassifier(
n_estimators = 5000,
learning_rate= 0.1,
metric='auc',
)
model.fit(X_train, y_train)
eli5.explain_weights(model )<predict_on_test> | knn = KNeighborsClassifier(n_neighbors= 5 ) | Titanic - Machine Learning from Disaster |
4,851,629 | pred = model.predict(X_test)
print(f'AUC: {roc_auc_score(pred, y_test)}' )<split> | threshold = [0.001, 0.005, 0.01, 0.05, 0.1, 0.2] | Titanic - Machine Learning from Disaster |
4,851,629 | X_train, X_test, y_train, y_test = train_test_split(
train_sc[features], y, test_size=0.3,stratify = y, random_state=2701)
model.fit(X_train, y_train)
eli5.explain_weights(model )<predict_on_test> | number_of_features = list(range(1,13)) | Titanic - Machine Learning from Disaster |
4,851,629 | pred = model.predict(X_test)
print(f'AUC: {roc_auc_score(pred, y_test)}' )<split> | print("Maximum accuracy score is :", max(scores_k)) | Titanic - Machine Learning from Disaster |
4,851,629 | X_train, X_test, y_train, y_test = train_test_split(
train_qt[features], y, test_size=0.3,stratify = y, random_state=2701)
model.fit(X_train, y_train)
eli5.explain_weights(model )<split> | print("Optimal number of features :", np.argmax(np.array(scores_k)) + 1 ) | Titanic - Machine Learning from Disaster |
4,851,629 | X_train, X_test, y_train, y_test = train_test_split(
train_rs[features], y, test_size=0.3,stratify = y, random_state=2701)
model.fit(X_train, y_train)
eli5.explain_weights(model )<predict_on_test> | selector = sklearn.feature_selection.VarianceThreshold(threshold= 0.1)
selector.fit(features, target)
knn_selected_features = selector.get_support() | Titanic - Machine Learning from Disaster |
4,851,629 | pred = model.predict(X_test)
print(f'AUC: {roc_auc_score(pred, y_test)}' )<init_hyperparams> | knn_params = {'n_neighbors': [5, 7, 9] , 'weights': [
'uniform', 'distance'], 'leaf_size': [5, 10, 20], 'p': [1, 2, 3]} | Titanic - Machine Learning from Disaster |
4,851,629 | param = {
'bagging_freq': 5,
'bagging_fraction': 0.335,
'boost_from_average':'false',
'boost': 'gbdt',
'feature_fraction': 0.041,
'learning_rate': 0.0083,
'max_depth': -1,
'metric':'auc',
'min_data_in_leaf': 80,
'min_sum_hessian_in_leaf': 10.0,
'num_leaves': 13,
'num_threads': 8,
'tree_learner': 'serial',
'objective': ... | rs_knn = RandomizedSearchCV(knn, param_distributions= knn_params,
scoring='accuracy', cv= 7, n_iter= 200, refit=True ) | Titanic - Machine Learning from Disaster |
4,851,629 | num_folds = 11
folds = StratifiedKFold(n_splits=num_folds, shuffle=False, random_state=2702)
oof = np.zeros(len(train))
predictions = np.zeros(len(y))
for fold_,(trn_idx, val_idx)in enumerate(folds.split(train.values, y.values)) :
print("Fold idx:{}".format(fold_ + 1))
trn_data = lgb.Dataset(train.iloc[trn_idx][featur... | rs_knn.fit(x_train.loc[:, knn_selected_features], y_train ) | Titanic - Machine Learning from Disaster |
4,851,629 | sub = pd.DataFrame({"ID_code": test.ID_code.values})
sub["target"] = predictions
sub.to_csv('submission.csv', index=False )<load_from_csv> | print('Best Parameters are:
', rs_knn.best_params_,
'
Training accuracy score is:
', rs_knn.best_score_ ) | Titanic - Machine Learning from Disaster |
4,851,629 | df1 = pd.read_csv('.. /input/sctp-blend-data/submission_1.csv')
df2 = pd.read_csv('.. /input/sctp-blend-data/submission_2.csv')
df3 = pd.read_csv('.. /input/sctp-blend-data/submission_3.csv')
df4 = pd.read_csv('.. /input/sctp-blend-data/submission_4.csv' )<load_from_csv> | print('Validation accuracy score is:
', rs_knn.score(
x_valid.loc[:, knn_selected_features], y_valid)) | Titanic - Machine Learning from Disaster |
4,851,629 | blend = df4['target'] *0.25 + df3['target'] * 0.25 + df2['target'] * 0.25 + df1['target'] * 0.25
sample = pd.read_csv('.. /input/santander-customer-transaction-prediction/sample_submission.csv' )<save_to_csv> | param_name = 'n_neighbors'
param_range = np.arange(3,21)
train_score, valid_score = [], []
for k in param_range:
knn = KNeighborsClassifier(n_neighbors= k, weights= 'uniform', p= 2,leaf_size= 5)
knn.fit(x_train.loc[:, knn_selected_features], y_train)
train_score.append(
knn.score(x_train.loc[:, knn_selected_feature... | Titanic - Machine Learning from Disaster |
4,851,629 | sample['target'] = blend
sample.to_csv('blend_ver10.csv',index=False )<set_options> | knn = KNeighborsClassifier(n_neighbors= 4, weights= 'uniform', p= 2, leaf_size= 5 ) | Titanic - Machine Learning from Disaster |
4,851,629 | warnings.filterwarnings('ignore')
%matplotlib inline
plt.style.use('seaborn')
random_state = 42
np.random.seed(random_state )<load_from_csv> | knn.fit(x_train.loc[:, knn_selected_features], y_train ) | Titanic - Machine Learning from Disaster |
4,851,629 | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
features = [c for c in train.columns if c not in ['ID_code', 'target']]<sort_values> | y_scores_knn = knn.predict_proba(x_test.loc[:, knn_selected_features])[:, 1]
knn_fpr, knn_tpr, knn_thresholds = sklearn.metrics.roc_curve(y_test, y_scores_knn ) | Titanic - Machine Learning from Disaster |
4,851,629 | obs = train.isnull().sum().sort_values(ascending = False)
percent = round(train.isnull().sum().sort_values(ascending = False)/len(train)*100, 2)
pd.concat([obs, percent], axis = 1,keys= ['Number of Observations', 'Percent'] )<set_options> | knn_auc = sklearn.metrics.auc(x=knn_fpr, y=knn_tpr ) | Titanic - Machine Learning from Disaster |
4,851,629 | lin_pca = KernelPCA(n_components = 2, kernel="linear", fit_inverse_transform=True)
rbf_pca = KernelPCA(n_components = 2, kernel="rbf", gamma=0.0433, fit_inverse_transform=True)
sig_pca = KernelPCA(n_components = 2, kernel="sigmoid", gamma=0.001, coef0=1, fit_inverse_transform=True)
plt.figure(figsize=(11, 4))
for su... | knn_acc = knn.score(x_test.loc[:, knn_selected_features], y_test ) | Titanic - Machine Learning from Disaster |
4,851,629 | def augment(x,y,t=2):
xs,xn = [],[]
for i in range(t):
mask = y>0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
np.random.shuffle(ids)
x1[:,c] = x1[ids][:,c]
xs.append(x1)
for i in range(t//2):
mask = y==0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
... | print('Area Under Curve: {}, Accuracy: {}'.format(knn_auc, knn_acc)) | Titanic - Machine Learning from Disaster |
4,851,629 | param = {
"objective" : "binary",
"metric" : "auc",
"boosting": 'gbdt',
"max_depth" : -1,
"num_leaves" : 31,
"learning_rate" : 0.01,
"bagging_freq": 5,
"bagging_fraction" : 0.4,
"feature_fraction" : 0.05,
"min_data_in_leaf": 150,
"min_sum_heassian_in_leaf": 10,
"tree_learner": "serial",
"boost_from_average": "false",
"... | svm = SVC(probability=True ) | Titanic - Machine Learning from Disaster |
4,851,629 | num_folds = 11
features = [c for c in train.columns if c not in ['ID_code', 'target']]
folds = StratifiedKFold(n_splits=num_folds, shuffle=False, random_state=2319)
oof = np.zeros(len(train))
getVal = np.zeros(len(train))
predictions = np.zeros(len(target))
feature_importance_df = pd.DataFrame()
print('Light GBM Model... | threshold = np.arange(1, 10, 0.5)*1e-1 | Titanic - Machine Learning from Disaster |
4,851,629 | num_sub = 34
print('Saving the Submission File')
sub = pd.DataFrame({"ID_code": test.ID_code.values})
sub["target"] = predictions
sub.to_csv('submission{}.csv'.format(num_sub), index=False)
getValue = pd.DataFrame(getVal)
getValue.to_csv("Validation.csv" )<load_from_csv> | scores = []
for i in threshold:
selector = sklearn.feature_selection.VarianceThreshold(threshold= i)
selected_features = selector.fit_transform(features)
svm.fit(selected_features, target)
y_pred = svm.predict(features.loc[:, selector.get_support() ])
scores.append(sklearn.metrics.accuracy_score(target, y_pred))
pl... | Titanic - Machine Learning from Disaster |
4,851,629 | submission = pd.read_csv(".. /input/multiple-data-nn/submission__nn__0.9005821511281362.csv" )<feature_engineering> | print('The highest accuracy score is:', np.max(np.array(scores)) ) | Titanic - Machine Learning from Disaster |
4,851,629 | submission['target'] = submission['target'] * 12 /8<save_to_csv> | number_of_features = list(range(1,13)) | Titanic - Machine Learning from Disaster |
4,851,629 | submission.to_csv('output.csv',index=False )<set_options> | print("Maximum accuracy score is :", max(scores_k)) | Titanic - Machine Learning from Disaster |
4,851,629 | warnings.filterwarnings('ignore' )<load_from_csv> | print("Optimal number of features :", np.argmax(np.array(scores_k)) + 1 ) | Titanic - Machine Learning from Disaster |
4,851,629 | train_df = pd.read_csv('.. /input/santander-customer-transaction-prediction/train.csv')
test_df = pd.read_csv('.. /input/santander-customer-transaction-prediction/test.csv' )<load_from_csv> | selector = sklearn.feature_selection.VarianceThreshold(threshold= 0.1)
selector.fit(features, target)
svm_selected_features = selector.get_support() | Titanic - Machine Learning from Disaster |
4,851,629 |
<create_dataframe> | svm = SVC(probability=True ) | Titanic - Machine Learning from Disaster |
4,851,629 | train = train_df.copy()
test = test_df.copy()<drop_column> | svm_parameters = {'kernel': ['linear', 'rbf', 'sigmoid'], 'gamma': [
'auto', 'scale'], 'shrinking': [True, False]} | Titanic - Machine Learning from Disaster |
4,851,629 | del train_df
del test_df
<categorify> | rs_svm = RandomizedSearchCV(svm, cv= 7, param_distributions= svm_parameters, n_iter= 200 ) | Titanic - Machine Learning from Disaster |
4,851,629 | def augment(x,y,t=2):
xs,xn = [],[]
for i in range(t):
mask = y>0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
np.random.shuffle(ids)
x1[:,c] = x1[ids][:,c]
xs.append(x1)
for i in range(t//2):
mask = y==0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
... | rs_svm.fit(x_train.loc[:, svm_selected_features], y_train ) | Titanic - Machine Learning from Disaster |
4,851,629 | features = [c for c in train.columns if c not in ['ID_code', 'target']]
target = train['target']
X_test = test[features].values<init_hyperparams> | print('Best Parameters are:
', rs_svm.best_params_,
'
Training accuracy score is:
', rs_svm.best_score_ ) | Titanic - Machine Learning from Disaster |
4,851,629 | param = {
'bagging_freq': 5,
'bagging_fraction': 0.335,
'boost_from_average':'false',
'boost': 'gbdt',
'feature_fraction': 0.041,
'learning_rate': 0.0083,
'max_depth': -1,
'metric':'auc',
'min_data_in_leaf': 80,
'min_sum_hessian_in_leaf': 10.0,
'num_leaves': 13,
'num_threads': 8,
'tree_learner': 'serial',
'objective': ... | print('Validation accuracy score is:
', rs_svm.score(
x_valid.loc[:, svm_selected_features], y_valid)) | Titanic - Machine Learning from Disaster |
4,851,629 | num_folds = 9
features = [c for c in train.columns if c not in ['ID_code', 'target']]
folds = KFold(n_splits=num_folds, random_state=2319)
oof = np.zeros(len(train))
getVal = np.zeros(len(train))
predictions = np.zeros(len(target))
feature_importance_df = pd.DataFrame()
print('Light GBM Model')
for fold_,(trn_idx, va... | param_name = 'C'
param_range = np.arange(1,31)
train_score, valid_score = [], []
for c in param_range:
svm = SVC(C= c,probability= True)
svm.fit(x_train.loc[:, svm_selected_features], y_train)
train_score.append(
svm.score(x_train.loc[:, svm_selected_features], y_train))
valid_score.append(
svm.score(x_valid.loc[:... | Titanic - Machine Learning from Disaster |
4,851,629 | predictions['target'] = np.mean(predictions[[col for col in predictions.columns if col not in ['ID_code', 'target']]].values, axis=1)
sub = pd.DataFrame({"ID_code": test.ID_code.values})
sub["target"] = predictions['target']
sub.to_csv('submission_oof.csv', index=False )<load_from_csv> | svm = SVC(C=3, probability= True)
svm.fit(features.loc[:, svm_selected_features], target ) | Titanic - Machine Learning from Disaster |
4,851,629 | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
features = [c for c in train.columns if c not in ['ID_code', 'target']]
target = train['target']
print("Data is ready!" )<count_missing_values> | y_scores_svm = svm.predict_proba(x_test.loc[:, svm_selected_features])[:, 1]
svm_fpr, svm_tpr, svm_thresholds = sklearn.metrics.roc_curve(y_test, y_scores_svm ) | Titanic - Machine Learning from Disaster |
4,851,629 | print("Missing data at training")
train.isnull().values.any()<count_missing_values> | svm_auc = sklearn.metrics.auc(x=svm_fpr, y=svm_tpr ) | Titanic - Machine Learning from Disaster |
4,851,629 | print("Missing data at test")
test.isnull().values.any()<drop_column> | svm_acc = svm.score(x_test.loc[:, svm_selected_features], y_test ) | Titanic - Machine Learning from Disaster |
4,851,629 | train = train.drop(["ID_code", "target"], axis=1 )<set_options> | print('For logistic Regression:
Area Under Curve: {},
Test Accuracy score: {}'.format(
svm_auc, svm_acc)) | Titanic - Machine Learning from Disaster |
4,851,629 | sns.set_style('whitegrid')
sns.countplot(target)
sns.set_style('whitegrid' )<count_duplicates> | dt = DecisionTreeClassifier() | Titanic - Machine Learning from Disaster |
4,851,629 | @jit
def augment(x,y,t=2):
xs,xn = [],[]
for i in range(t):
mask = y>0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
np.random.shuffle(ids)
x1[:,c] = x1[ids][:,c]
xs.append(x1)
for i in range(t//2):
mask = y==0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[... | threshold = np.arange(1, 10, 0.5)*1e-1 | Titanic - Machine Learning from Disaster |
4,851,629 | param = {
'bagging_freq': 5,
'bagging_fraction': 0.335,
'boost_from_average':'false',
'boost': 'gbdt',
'feature_fraction': 0.041,
'learning_rate': 0.0083,
'max_depth': -1,
'metric':'auc',
'min_data_in_leaf': 80,
'min_sum_hessian_in_leaf': 10.0,
'num_leaves': 13,
'num_threads': 8,
'tree_learner': 'serial',
'objective': ... | print('The highest accuracy score is:', np.max(np.array(scores)) ) | Titanic - Machine Learning from Disaster |
4,851,629 | num_folds = 11
features = [c for c in train.columns if c not in ['ID_code', 'target']]
folds = KFold(n_splits=num_folds, random_state=2319)
oof = np.zeros(len(train))
getVal = np.zeros(len(train))
predictions = np.zeros(len(target))
feature_importance_df = pd.DataFrame()<split> | number_of_features = list(range(1,13)) | Titanic - Machine Learning from Disaster |
4,851,629 | for fold_,(trn_idx, val_idx)in enumerate(folds.split(train.values, target.values)) :
X_train, y_train = train.iloc[trn_idx][features], target.iloc[trn_idx]
X_valid, y_valid = train.iloc[val_idx][features], target.iloc[val_idx]
X_tr, y_tr = augment(X_train.values, y_train.values)
X_tr = pd.DataFrame(X_tr)
print("Fold ... | print("Maximum accuracy score is :", max(scores_k)) | Titanic - Machine Learning from Disaster |
4,851,629 | print("
>> CV score: {:<8.5f}".format(roc_auc_score(target, oof)) )<save_to_csv> | print("Optimal number of features :", np.argmax(np.array(scores_k)) + 1 ) | Titanic - Machine Learning from Disaster |
4,851,629 | submission = pd.DataFrame({"ID_code": test.ID_code.values})
submission["target"] = predictions
submission.to_csv("submission.csv", index=False )<load_from_csv> | print("Optimal number of features : %d" % selector.n_features_ ) | Titanic - Machine Learning from Disaster |
4,851,629 | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv' )<filter> | print("Maximum accuracy score is :", np.max(selector.grid_scores_)) | Titanic - Machine Learning from Disaster |
4,851,629 | pos=predictors[train_df[predictors].mean() >0]
neg=predictors[train_df[predictors].mean() <=0]<feature_engineering> | threshold = [0.001, 0.0025, 0.005, 0.01, 0.025 ,0.05, 0.1] | Titanic - Machine Learning from Disaster |
4,851,629 | idx = features = pos
for df in [train_df, test_df]:
df['sum_pos'] = df[idx].sum(axis=1)
df['min_pos'] = df[idx].min(axis=1)
df['max_pos'] = df[idx].max(axis=1)
df['mean_pos'] = df[idx].mean(axis=1)
df['std_pos'] = df[idx].std(axis=1)
df['skew_pos'] = df[idx].skew(axis=1)
df['kurt_pos'] = df[idx].kurtosis(axis=1)
... | print("Maximum accuracy score is :", np.max(np.array(scores_sfm)) ) | Titanic - Machine Learning from Disaster |
4,851,629 | idx = features = neg
for df in [train_df, test_df]:
df['sum_neg'] = df[idx].sum(axis=1)
df['min_neg'] = df[idx].min(axis=1)
df['max_neg'] = df[idx].max(axis=1)
df['mean_neg'] = df[idx].mean(axis=1)
df['std_neg'] = df[idx].std(axis=1)
df['skew_neg'] = df[idx].skew(axis=1)
df['kurt_neg'] = df[idx].kurtosis(axis=1)
... | print("Optimal threshold :", threshold[np.argmax(np.array(scores_sfm)) ] ) | Titanic - Machine Learning from Disaster |
4,851,629 | param = {
'num_leaves': 25,
'max_bin': 60,
'min_data_in_leaf': 5,
'learning_rate': 0.010614430970330217,
'min_sum_hessian_in_leaf': 0.0093586657313989123,
'feature_fraction': 0.056701788569420042,
'lambda_l1': 0.060222413158420585,
'lambda_l2': 4.6580550589317573,
'min_gain_to_split': 0.29588543202055562,
'max_depth': ... | dt_params = {'criterion': ['gini'], 'min_samples_split': [
21, 22, 23], 'max_features': ['auto', 'log2', None]} | Titanic - Machine Learning from Disaster |
4,851,629 | nfold = 10<define_variables> | rs_dt = RandomizedSearchCV(dt, param_distributions= dt_params,
scoring='accuracy', cv= StratifiedKFold(7), refit=True, n_iter= 500 ) | Titanic - Machine Learning from Disaster |
4,851,629 | target = 'target'
predictors = train_df.columns.values.tolist() [2:]<split> | rs_dt.fit(x_train, y_train ) | Titanic - Machine Learning from Disaster |
4,851,629 | skf = StratifiedKFold(n_splits=nfold, shuffle=True, random_state=2019)
oof = np.zeros(len(train_df))
predictions = np.zeros(len(test_df))
i = 1
for train_index, valid_index in skf.split(train_df, train_df.target.values):
print("
fold {}".format(i))
xg_train = lgb.Dataset(train_df.iloc[train_index][predictors].values,
... | print('Best Parameters are:
', rs_dt.best_params_,
'
Training accuracy score is:
', rs_dt.best_score_ ) | Titanic - Machine Learning from Disaster |
4,851,629 | submission = pd.DataFrame({"ID_code": test_df.ID_code.values})
submission["target"] = predictions
submission[:10]<save_to_csv> | print('Validation accuracy score is:
', rs_dt.score(x_valid, y_valid)) | Titanic - Machine Learning from Disaster |
4,851,629 | submission.to_csv("LGMB_210_featutes.csv", index=False )<import_modules> | param_name = 'max_depth'
param_range = np.arange(1, 21)
train_score, valid_score = [], []
for depth in param_range:
dt = DecisionTreeClassifier(
criterion='gini', max_features=None, min_samples_split=22, max_depth= depth)
dt.fit(x_train, y_train)
train_score.append(dt.score(x_train, y_train))
valid_score.append(dt.... | Titanic - Machine Learning from Disaster |
4,851,629 | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from pathlib import Path<load_from_csv> | dt = DecisionTreeClassifier(criterion='gini', max_features=None, min_samples_split=22, max_depth= 3)
dt.fit(features,target ) | Titanic - Machine Learning from Disaster |
4,851,629 | DATA_PATH = ".. /input/santander-customer-transaction-prediction/"
train = pd.read_csv(str(Path(DATA_PATH)/ "train.csv"))
test = pd.read_csv(str(Path(DATA_PATH)/ "test.csv"))
print("Train and test shapes", train.shape, test.shape )<count_values> | y_scores_dt = dt.predict_proba(x_test)[:, 1]
dt_fpr, dt_tpr, dt_thresholds = sklearn.metrics.roc_curve(y_test, y_scores_dt)
dt_auc = sklearn.metrics.auc(x=dt_fpr, y=dt_tpr ) | Titanic - Machine Learning from Disaster |
4,851,629 | train.target.value_counts()<feature_engineering> | dt_acc = dt.score(x_test, y_test ) | 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.