kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
2,053,254 | all_data = all_data.drop(["Utilities"], axis=1 )<data_type_conversions> | train_objs_num = len(train)
dataset = pd.concat(objs=[train, test],sort=False)
dataset['ngroup'] = dataset.groupby(['Pclass','Sex'] ).ngroup()
dataset = dataset['ngroup']
train['ngroup'] = copy.copy(dataset[:train_objs_num])
test['ngroup'] = copy.copy(dataset[train_objs_num:] ) | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["Functional"] = all_data["Functional"].fillna("Typ" )<data_type_conversions> | train['SibParchSum'] = train['SibSp'] + train['Parch']
test['SibParchSum'] = test['SibSp'] + test['Parch']
train['IsWithFamily'] =(train['SibParchSum']>0 ).astype(int)
test['IsWithFamily'] =(test['SibParchSum']>0 ).astype(int)
binner = KBinsDiscretizer(encode='ordinal')
binner.fit(train[['Fare']])
train['Fare_bins'... | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["Electrical"] = all_data["Electrical"].fillna(all_data["Electrical"].mode() [0] )<data_type_conversions> | encoder = OrdinalEncoder()
encoder.fit(train[['Sex']])
train['sex_integer'] = encoder.transform(train[['Sex']])
test['sex_integer'] = encoder.transform(test[['Sex']])
encoder = OrdinalEncoder()
encoder.fit(train[['Embarked']])
train['embarked_integer'] = encoder.transform(train[['Embarked']])
test['embarked_intege... | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["KitchenQual"] = all_data["KitchenQual"].fillna(all_data["KitchenQual"].mode() [0] )<categorify> | train_after_normalizer = preprocessing.Normalizer().fit_transform(train[['Age', 'Fare','SibSp', 'Parch','sex_integer','embarked_integer','Pclass']] ) | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["Exterior1st"] = all_data["Exterior1st"].fillna(all_data["Exterior1st"].mode() [0])
all_data["Exterior2nd"] = all_data["Exterior2nd"].fillna(all_data["Exterior2nd"].mode() [0] )<data_type_conversions> | train_after_normalizer = pd.DataFrame(train_after_normalizer, columns = ['Age', 'Fare','SibSp', 'Parch','sex_integer','embarked_integer','Pclass'] ) | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["SaleType"] = all_data["SaleType"].fillna(all_data["SaleType"].mode() [0] )<data_type_conversions> | print(train.groupby('Pclass')['Fare'].mean())
print(test.groupby('Pclass')['Fare'].mean())
print(test[test.Fare.isnull() ])
| Titanic - Machine Learning from Disaster |
2,053,254 | all_data["MSSubClass"] = all_data["MSSubClass"].fillna("None" )<sort_values> | test.loc[test.Fare.isnull() ,'Fare'] = 13 | Titanic - Machine Learning from Disaster |
2,053,254 | all_data_na =(all_data.isnull().sum() / len(all_data)) * 100
all_data_na = all_data_na.drop(all_data_na[all_data_na == 0].index ).sort_values(ascending=False)
missing_data = pd.DataFrame({"Missing Ratio": all_data_na})
missing_data.head()<data_type_conversions> | test.loc[test.PassengerId==1044] | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["MSSubClass"] = all_data["MSSubClass"].apply(str)
all_data["OverallCond"] = all_data["OverallCond"].astype(str)
all_data["YrSold"] = all_data["YrSold"].astype(str)
all_data["MoSold"] = all_data["MoSold"].astype(str )<define_variables> | test.groupby(['Pclass','Sex'])['Age'].mean() | Titanic - Machine Learning from Disaster |
2,053,254 | cols =(
"FireplaceQu",
"BsmtQual",
"BsmtCond",
"GarageQual",
"GarageCond",
"ExterQual",
"ExterCond",
"HeatingQC",
"PoolQC",
"KitchenQual",
"BsmtFinType1",
"BsmtFinType2",
"Functional",
"Fence",
"BsmtExposure",
"GarageFinish",
"LandSlope",
"LotShape",
"PavedDrive",
"Street",
"Alley",
"CentralAir",
"MSSubClass",
"Overal... | train['Survived'].value_counts(sort = False ) | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["TotalSF"] = all_data["TotalBsmtSF"] + all_data["1stFlrSF"] + all_data["2ndFlrSF"]<feature_engineering> | total = train.isnull().sum().sort_values(ascending=False)
percent =(train.isnull().sum() /train.isnull().count() ).sort_values(ascending=False)
missing_data = pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
missing_data.head(5 ) | Titanic - Machine Learning from Disaster |
2,053,254 | skewness = skewness[abs(skewness)> 0.75]
print("There are {} skewed numerical features to Box Cox transform".format(skewness.shape[0]))
skewed_features = skewness.index
lam = 0.15
for feat in skewed_features:
all_data[feat] = boxcox1p(all_data[feat], lam)
<categorify> | total = test.isnull().sum().sort_values(ascending=False)
percent =(test.isnull().sum() /test.isnull().count() ).sort_values(ascending=False)
missing_test_data = pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
missing_test_data.head(5 ) | Titanic - Machine Learning from Disaster |
2,053,254 | all_data = pd.get_dummies(all_data)
print(all_data.shape )<import_modules> | train.nunique() | Titanic - Machine Learning from Disaster |
2,053,254 | train = all_data[:ntrain]
test = all_data[ntrain:]
<import_modules> | y_train = train.Survived | Titanic - Machine Learning from Disaster |
2,053,254 | from sklearn.linear_model import ElasticNet, Lasso
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import KFold, cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import RobustScaler<compute_train_metric> | train.groupby(train.Cabin.isnull() , as_index=False ).size() | Titanic - Machine Learning from Disaster |
2,053,254 | n_folds = 5
def rmsle_cv(model):
kf = KFold(n_folds, shuffle=True, random_state=42 ).get_n_splits(train.values)
rmse = np.sqrt(
-cross_val_score(model, train.values, y_train, scoring="neg_mean_squared_error", cv=kf)
)
return rmse<choose_model_class> | train['SibSp'].value_counts(sort=False ) | Titanic - Machine Learning from Disaster |
2,053,254 | lasso = make_pipeline(RobustScaler() , Lasso(alpha=0.0005, random_state=1))<choose_model_class> | train[['SibSp', 'Survived']].groupby('SibSp')['Survived'].sum() | Titanic - Machine Learning from Disaster |
2,053,254 | ENet = make_pipeline(RobustScaler() , ElasticNet(alpha=0.0005, l1_ratio=0.9, random_state=3))<choose_model_class> | ( train[['SibSp', 'Survived']].groupby('SibSp')['Survived'].sum() /train['SibSp'].value_counts(sort=False)) *100 | Titanic - Machine Learning from Disaster |
2,053,254 | KRR = KernelRidge(alpha=0.6, kernel="polynomial", degree=2, coef0=2.5 )<choose_model_class> | train.Parch.value_counts(sort=False ) | Titanic - Machine Learning from Disaster |
2,053,254 | 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,
)<choose_model_class> | train[['Parch', 'Survived']].groupby('Parch')['Survived'].sum() | Titanic - Machine Learning from Disaster |
2,053,254 | model_xgb = 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,
)<choose_model_class> | ( train[['Parch', 'Survived']].groupby('Parch')['Survived'].sum() /train.Parch.value_counts(sort=False)) *100 | Titanic - Machine Learning from Disaster |
2,053,254 | model_lgb = lgb.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,
)<compute_test_metric> | ( train[['Pclass', 'Survived']].groupby('Pclass')['Survived'].sum() /train.Pclass.value_counts(sort=False)) *100 | Titanic - Machine Learning from Disaster |
2,053,254 | score = rmsle_cv(lasso)
print(f"
Lasso score: {score.mean() :.4f}({score.std() :.4f})
" )<compute_test_metric> | train.Embarked.value_counts() | Titanic - Machine Learning from Disaster |
2,053,254 | score = rmsle_cv(ENet)
print(f"ElasticNet score: {score.mean() :.4f}({score.std() :.4f})
" )<compute_test_metric> | const_cols = [c for c in train.columns if train[c].nunique(dropna=False)==1 ]
const_cols | Titanic - Machine Learning from Disaster |
2,053,254 | score = rmsle_cv(KRR)
print(f"Kernel Ridge score: {score.mean() :.4f}({score.std() :.4f})
" )<compute_test_metric> | train.groupby('Pclass')['Age'].agg(['size', 'count', 'mean'] ) | Titanic - Machine Learning from Disaster |
2,053,254 | score = rmsle_cv(GBoost)
print(f"Gradient Boosting score: {score.mean() :.4f}({score.std() :.4f})
" )<compute_test_metric> | train.groupby('Sex')['Age'].agg(['size', 'count', 'mean'] ) | Titanic - Machine Learning from Disaster |
2,053,254 | score = rmsle_cv(model_xgb)
print(f"Xgboost score: {score.mean() :.4f}({score.std() :.4f})
" )<compute_test_metric> | train.groupby('Embarked')['Age'].agg(['size', 'count', 'mean'] ) | Titanic - Machine Learning from Disaster |
2,053,254 | score = rmsle_cv(model_lgb)
print(f"LGBM score: {score.mean() :.4f}({score.std() :.4f})
" )<train_model> | np.random.seed(2019)
numeric_features = ['Age', 'Fare']
numeric_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='median')) ,
('scaler', StandardScaler())])
categorical_features = ['Embarked', 'Sex', 'Pclass']
categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant'... | Titanic - Machine Learning from Disaster |
2,053,254 | class AveragingModels(BaseEstimator, RegressorMixin, TransformerMixin):
def __init__(self, models):
self.models = models
def fit(self, X, y):
self.models_ = [clone(x)for x in self.models]
for model in self.models_:
model.fit(X, y)
return self
def predict(self, X):
predictions = np.column_stack([model.predict(X)for mod... | features= ['Age', 'Fare','SibSp', 'Parch','Sex','Embarked','Pclass']
num_features = ['SibSp','Parch']
num_features_to_scale = ['Age', 'Fare']
cat_features = ['Sex', 'Embarked','Pclass']
train_test_concat = pd.concat([train[features],test[features]] ) | Titanic - Machine Learning from Disaster |
2,053,254 | averaged_models = AveragingModels(models=(ENet, GBoost, KRR, lasso))
score = rmsle_cv(averaged_models)
print(f" Averaged base models score: {score.mean() :.4f}({score.std() :.4f})
" )<train_model> | scaler = StandardScaler()
scaler.fit(train_test_concat[num_features_to_scale] ) | Titanic - Machine Learning from Disaster |
2,053,254 | class StackingAveragedModels(BaseEstimator, RegressorMixin, TransformerMixin):
def __init__(self, base_models, meta_model, n_folds=5):
self.base_models = base_models
self.meta_model = meta_model
self.n_folds = n_folds
def fit(self, X, y):
self.base_models_ = [list() for x in self.base_models]
self.meta_model_ = clone(s... | train_scaled = train[num_features_to_scale].copy()
train_scaled = scaler.transform(train_scaled)
train_scaled = pd.DataFrame(train_scaled,columns=num_features_to_scale)
train_scaled = pd.concat([train_scaled,train[cat_features],train[num_features]],axis=1)
print(train_scaled.info() ) | Titanic - Machine Learning from Disaster |
2,053,254 | stacked_averaged_models = StackingAveragedModels(
base_models=(ENet, GBoost, KRR), meta_model=lasso
)
score = rmsle_cv(stacked_averaged_models)
print(f"Stacking Averaged models score: {score.mean() :.4f}({score.std() :.4f})" )<compute_test_metric> | test_scaled = test[num_features_to_scale].copy()
test_scaled = scaler.transform(test_scaled)
test_scaled = pd.DataFrame(test_scaled,columns=num_features_to_scale)
test_scaled = pd.concat([test_scaled,test[cat_features],test[num_features]],axis=1)
print(test_scaled.info() ) | Titanic - Machine Learning from Disaster |
2,053,254 | def rmsle(y, y_pred):
return np.sqrt(mean_squared_error(y, y_pred))<predict_on_test> | my_imputer = SimpleImputer(strategy='most_frequent')
my_imputer.fit(pd.concat([train_scaled,test_scaled]))
data_with_imputed_values = pd.DataFrame(
my_imputer.transform(train_scaled), columns=train_scaled.columns
).astype(train_scaled.dtypes.to_dict())
test_data_with_imputed_values = pd.DataFrame(
my_imputer.transf... | Titanic - Machine Learning from Disaster |
2,053,254 | stacked_averaged_models.fit(train.values, y_train)
stacked_train_pred = stacked_averaged_models.predict(train.values)
stacked_pred = np.expm1(stacked_averaged_models.predict(test.values))
print(rmsle(y_train, stacked_train_pred))<predict_on_test> | all_data = pd.concat([data_with_imputed_values,test_data_with_imputed_values])
for column in all_data.select_dtypes(include=[np.object] ).columns:
data_with_imputed_values[column] = pd.Categorical(data_with_imputed_values[column], categories = all_data[column].unique())
test_data_with_imputed_values[column] = pd.Cate... | Titanic - Machine Learning from Disaster |
2,053,254 | model_xgb.fit(train, y_train)
xgb_train_pred = model_xgb.predict(train)
xgb_pred = np.expm1(model_xgb.predict(test))
print(rmsle(y_train, xgb_train_pred))<predict_on_test> | data_with_imputed_values = pd.get_dummies(data_with_imputed_values,drop_first=True)
test_data_with_imputed_values = pd.get_dummies(test_data_with_imputed_values,drop_first=True ) | Titanic - Machine Learning from Disaster |
2,053,254 | model_lgb.fit(train, y_train)
lgb_train_pred = model_lgb.predict(train)
lgb_pred = np.expm1(model_lgb.predict(test.values))
print(rmsle(y_train, lgb_train_pred))<compute_test_metric> | param_grid = {
'n_estimators' : [500,1200],
'max_depth': range(1,5,2),
'max_features' :('log2', 'sqrt'),
'class_weight':[{1: w} for w in [1,1.5]]
}
GridRF = GridSearchCV(RandomForestClassifier(random_state=15), param_grid)
GridRF.fit(data_with_imputed_values, y_train)
print(
"
Best parameters
" + str(GridRF.best_par... | Titanic - Machine Learning from Disaster |
2,053,254 |
print("RMSLE score on train data:")
print(rmsle(y_train, stacked_train_pred * 0.70 + xgb_train_pred * 0.15 + lgb_train_pred * 0.15))<define_variables> | cross_val_score(rf, data_with_imputed_values, y_train,cv=5 ) | Titanic - Machine Learning from Disaster |
2,053,254 | ensemble = stacked_pred * 0.70 + xgb_pred * 0.15 + lgb_pred * 0.15<save_to_csv> | one = OneHotEncoder(handle_unknown='ignore')
simple = SimpleImputer(strategy='constant', fill_value='missing')
pre = one.fit_transform(simple.fit_transform(train[['Embarked', 'Sex', 'Pclass']])) | Titanic - Machine Learning from Disaster |
2,053,254 | sub = pd.DataFrame()
sub["Id"] = test_ID
sub["SalePrice"] = ensemble
sub.to_csv("submission.csv", index=False )<set_options> | def drop_cols_with_str(df,str_v):
return df[df.columns.drop(list(df.filter(regex=str_v)))]
data_with_imputed_values = drop_cols_with_str(data_with_imputed_values,'Cabin_')
test_data_with_imputed_values = drop_cols_with_str(test_data_with_imputed_values,'Cabin_')
| Titanic - Machine Learning from Disaster |
2,053,254 | warnings.simplefilter("ignore")
sns.set()
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))<load_from_csv> | X_t, X_v, y_t, y_v = train_test_split(data_with_imputed_values,y_train, stratify=y_train, test_size=0.2, random_state=2019)
def runXGB(X_t, X_v, y_t, y_v, feature_names=None, seed_val=2017, num_rounds=200):
param = {}
param['objective'] = 'binary:logistic'
param['eta'] = 0.1
param['max_depth'] = 6
param['silent'] = 1
... | Titanic - Machine Learning from Disaster |
2,053,254 | train = pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/train.csv")
test = pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/test.csv")
sample = pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/sample_submission.csv" )<drop_column> | preds = model.predict(xgb.DMatrix(data_with_imputed_values)) | Titanic - Machine Learning from Disaster |
2,053,254 | train.drop("Id", axis=1, inplace=True)
test.drop("Id", axis=1, inplace=True )<prepare_x_and_y> | pred_t = model.predict(xgb.DMatrix(data_with_imputed_values))
train_copy['Prediction'] =(pred_t > 0.4 ).astype(int)
tn, fp, fn, tp = confusion_matrix(train_copy['Survived'], train_copy['Prediction'] ).ravel()
(tn, fp, fn, tp ) | Titanic - Machine Learning from Disaster |
2,053,254 | target = train["SalePrice"]
train = train.drop("SalePrice", axis=1 )<count_missing_values> | Titanic - Machine Learning from Disaster | |
2,053,254 | train.isnull().sum().sum()<count_missing_values> | def runXGBcv(X, y, feature_names=None, seed_val=2017, num_rounds=100):
param = {}
param['objective'] = 'binary:logistic'
param['eta'] = 0.05
param['max_depth'] = 6
param['silent'] = 1
param['eval_metric'] = 'auc'
param['min_child_weight'] = 3
param['subsample'] = 0.5
param['colsample_bytree'] = 0.5
param['seed'] = seed... | Titanic - Machine Learning from Disaster |
2,053,254 | test.isnull().sum().sum()<categorify> | clf = xgb.XGBClassifier(
max_depth = 7,
n_estimators=700,
learning_rate=0.1,
nthread=4,
subsample=1.0,
colsample_bytree=0.5,
min_child_weight = 3,
seed=1301)
xgb_param = clf.get_xgb_params()
cvresult = xgb.cv(xgb_param, xgb.DMatrix(data_with_imputed_values,y_train),
num_boost_round=400, nfold=15, metrics=['auc'],
ear... | Titanic - Machine Learning from Disaster |
2,053,254 | test["MSZoning"].fillna("RL", inplace=True)
train["LotFrontage"].fillna(0, inplace=True)
test["LotFrontage"].fillna(0, inplace=True)
train["Alley"].fillna("No_alley", inplace=True)
test["Alley"].fillna("No_alley", inplace=True)
train.drop("Utilities", axis=1, inplace=True)
test.drop("Utilities", axis=1, inplace=T... | bclf = BalancedRandomForestClassifier(n_estimators=50, random_state=5)
X_t, X_v, y_t, y_v = train_test_split(data_with_imputed_values,y_train, stratify=y_train, test_size=0.1, random_state=0)
bclf.fit(X_t, y_t)
print(classification_report(y_v, bclf.predict(X_v)))
| Titanic - Machine Learning from Disaster |
2,053,254 |
<drop_column> | bclf.fit(data_with_imputed_values, y_train)
print('Predict based on features in the test set')
pred_bclf = bclf.predict(test_data_with_imputed_values)
| Titanic - Machine Learning from Disaster |
2,053,254 | train.drop("Condition2", axis=1, inplace=True)
test.drop("Condition2", axis=1, inplace=True)
train.drop("RoofMatl", axis=1, inplace=True)
test.drop("RoofMatl", axis=1, inplace=True)
train.drop("LowQualFinSF", axis=1, inplace=True)
test.drop("LowQualFinSF", axis=1, inplace=True)
def remode_flg(x):
if x["YearBuilt"... | X_t, X_v, y_t, y_v = train_test_split(data_with_imputed_values,y_train, stratify=y_train, test_size=0.1, random_state=0)
dtrain = xgb.DMatrix(X_t, label=y_t)
dtest = xgb.DMatrix(X_v, label=y_v)
def xgb_evaluate(max_depth, gamma, colsample_bytree):
params = {'eval_metric': 'auc',
'max_depth': int(max_depth),
'subsamp... | Titanic - Machine Learning from Disaster |
2,053,254 | col_df = pd.DataFrame({"col":train.dtypes.index, "dtype":train.dtypes.values})
obj_col = col_df[col_df["dtype"]=="object"]["col"].values
for i in obj_col:
ce_oe = ce.OneHotEncoder(cols=i, handle_unknown="impute")
train = ce_oe.fit_transform(train)
test = ce_oe.transform(test )<prepare_x_and_y> | params_xgb = xgb_bo.max['params']
params_xgb['max_depth'] = int(params_xgb['max_depth'])
params_xgb | Titanic - Machine Learning from Disaster |
2,053,254 | X_train = train
X_test = test
y_train = target<feature_engineering> | model2 = xgb.train(params_xgb, dtrain, num_boost_round=250)
y_test_pred = model2.predict(dtest)>0.5
y_train_pred = model2.predict(dtrain)>0.5
print(classification_report(y_v, y_test_pred))
print(classification_report(y_t, y_train_pred))
model3 = xgb.train(params_xgb, xgb.DMatrix(data_with_imputed_values, label=y_train... | Titanic - Machine Learning from Disaster |
2,053,254 | y_train = np.log10(y_train )<train_on_grid> | cb_model = CatBoostClassifier(
)
cb_model.fit(X_t, y_t,
eval_set=(X_v,y_v),
use_best_model=True,
)
print(classification_report(y_v, cb_model.predict(X_v)))
print(cb_model.get_params())
cat_params = cb_model.get_params()
cb_model = CatBoostClassifier(**cat_params)
cb_model.fit(data_with_imputed_values, y_train,
)... | Titanic - Machine Learning from Disaster |
2,053,254 | %%time
tree = DecisionTreeRegressor(random_state=10)
opt_tree = BayesSearchCV(
tree,
{"max_depth":(5,20),
"max_leaf_nodes":(30,100)},
n_iter = 50,
cv = 5,
n_jobs = -1)
bs_tree = opt_tree.fit(X_train, y_train)
print("Best score:{}".format(bs_tree.best_score_))
print("Best params:{}".format(bs_tree.best_params_))<com... | clf.get_booster().get_score(importance_type='weight' ) | Titanic - Machine Learning from Disaster |
2,053,254 | %%time
tree = DecisionTreeRegressor(max_depth=9, max_leaf_nodes=67, random_state=10)
print("Cross validation score")
cr_score = cross_val_score(tree, X_train, y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_score.std()))<train_on_grid> | pred_t = clf.predict(data_with_imputed_values, ntree_limit=cvresult.shape[0])
train_copy['Prediction'] = pred_t
tn, fp, fn, tp = confusion_matrix(train_copy['Survived'], train_copy['Prediction'] ).ravel()
(tn, fp, fn, tp ) | Titanic - Machine Learning from Disaster |
2,053,254 | %%time
forest = RandomForestRegressor(random_state=10)
opt_forest = BayesSearchCV(
forest,
{"max_depth":(5,40),
"max_leaf_nodes":(30,100),
"n_estimators":(50,100),
"min_samples_split":(0.00001,1.0),
"min_samples_leaf":(1,10)},
n_iter = 50,
cv = 5,
n_jobs = -1)
bs_forest = opt_forest.fit(X_train, y_train)
print("Bes... | preds_proba = clf.predict_proba(data_with_imputed_values, ntree_limit=cvresult.shape[0])
train_copy['Prediction'] = preds_proba[:,1] | Titanic - Machine Learning from Disaster |
2,053,254 | %%time
forest = RandomForestRegressor(n_estimators=100, max_depth=40, max_leaf_nodes=100, min_samples_leaf=1, min_samples_split=0.00001, random_state=10)
print("Cross validation score")
cr_score = cross_val_score(forest, X_train, y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_... | train_copy.Pclass.value_counts() | Titanic - Machine Learning from Disaster |
11,391,142 | forest.fit(X_train, y_train)
importance = forest.feature_importances_
indices = np.argsort(importance)[::-1]
for f in range(X_train.shape[1]):
print("%2d)%-*s %f" %(f+1, 30, X_train.columns[indices[f]], importance[indices[f]]))<find_best_model_class> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
11,391,142 | %%time
scores = []
for i in range(50,len(indices),5):
forest = RandomForestRegressor()
sel_features = X_train.columns[indices[:i]]
X_tra, X_val, y_tra, y_val = train_test_split(X_train[sel_features], y_train, test_size=0.2, random_state=0)
forest.fit(X_tra, y_tra)
y_pred = forest.predict(X_val)
score = r2_score(y_tr... | titanic_raw_train = pd.read_csv('.. //input/titanic/train.csv')
titanic_raw_test = pd.read_csv('.. //input/titanic/test.csv')
titanic_raw_train.info()
titanic_raw_test.info() | Titanic - Machine Learning from Disaster |
11,391,142 | sel_features_forest = X_train.columns[indices[:130]]<compute_train_metric> | train = titanic_raw_train.copy()
test = titanic_raw_test.copy()
train_test = pd.concat([train,test] ) | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
forest = RandomForestRegressor(n_estimators=100, max_depth=40, max_leaf_nodes=100, min_samples_leaf=1, min_samples_split=0.00001, random_state=10)
print("Cross validation score")
cr_score = cross_val_score(forest, X_train[sel_features_forest], y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(... | train[['Survived','Pclass']].groupby('Pclass' ).mean() | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
xgbr = xgb.XGBRegressor(random_state=10)
opt_xgb = BayesSearchCV(
xgbr,
{"learning_rate":(0.001,0.99),
"max_depth":(1,30),
"subsample":(0.1,0.99),
"colsample_bytree":(0.01,0.99)},
n_iter = 50,
cv = 5,
n_jobs = -1)
bs_xgb = opt_xgb.fit(X_train, y_train)
print("Best score:{}".format(bs_xgb.best_score_))
print(... | train_test['Title']=train_test.Name.str.extract('([A-Za-z]+)\.' ) | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
xgbr = xgb.XGBRegressor(learning_rate=0.1350, max_depth=3, subsample=0.7356, colsample_bytree=0.7682, random_state=10)
print("Cross validation score")
cr_score = cross_val_score(xgbr, X_train, y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_score.std()))<define_search_mo... | train_test.loc[train_test['Title'] == 'Mrs','Is_Married'] = 1 | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
lgbm = lgb.LGBMRegressor()
opt_lgbm = BayesSearchCV(
lgbm,
{"num_leaves":(20,100),
"n_estimators":(10,100),
"learning_rate":(0.001,1),
"max_depth":(1,30),
"min_split_gain":(0,0.5),
"min_child_weight":(0.001,0.1),
"min_child_samples":(5,50),
"subsample":(0.1,0.99),
"colsample_bytree":(0.01,0.99)},
n_iter = 50,
c... | train_test['Family_name'] = train_test.Name.str.extract('(\w+),', expand=False)
train_test.Family_name | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
lgbm = lgb.LGBMRegressor(learning_rate=0.2660, max_depth=26, colsample_bytree=0.6411, min_child_samples=36, min_child_weight=0.09835, min_split_gain=0, n_estimators=100, num_leaves=25, subsample=0.1146)
print("Cross validation score")
cr_score = cross_val_score(lgbm, X_train, y_train, cv=10)
print(cr_score)
... | m = train_test[['Family_name', 'Survived']].groupby('Family_name' ).mean()
c = train_test[['Family_name', 'PassengerId']].groupby('Family_name' ).count()
m = m.rename(columns={'Survived': 'Family_survived'})
c = c.rename(columns={'PassengerId': 'FamilyMemberCount'})
m = m.where(m.join(c ).FamilyMemberCount > 1, other... | Titanic - Machine Learning from Disaster |
11,391,142 | lgbm.fit(X_train, y_train)
importance = lgbm.feature_importances_
indices = np.argsort(importance)[::-1]
for f in range(X_train.shape[1]):
print("%2d)%-*s %f" %(f+1, 30, X_train.columns[indices[f]], importance[indices[f]]))<find_best_model_class> | train_test.Age.isnull().sum() | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
scores = []
for i in range(50,len(indices),5):
lgbm = lgb.LGBMRegressor()
sel_features = X_train.columns[indices[:i]]
X_tra, X_val, y_tra, y_val = train_test_split(X_train[sel_features], y_train, test_size=0.2, random_state=0)
lgbm.fit(X_tra, y_tra)
y_pred = lgbm.predict(X_val)
score = r2_score(y_true=y_val, ... | train_test[['Age','Title']].groupby('Title' ).mean() | Titanic - Machine Learning from Disaster |
11,391,142 | sel_features_lgbm = X_train.columns[indices[:100]]<compute_train_metric> | train_test.loc[(train_test.Age.isnull())&(train_test.Title=='Mr'),'Age']=32
train_test.loc[(train_test.Age.isnull())&(train_test.Title=='Mrs'),'Age']=37
train_test.loc[(train_test.Age.isnull())&(train_test.Title=='Master'),'Age']=5
train_test.loc[(train_test.Age.isnull())&(train_test.Title=='Miss'),'Age']=22
train_test... | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
lgbm = lgb.LGBMRegressor(learning_rate=0.2660, max_depth=26, colsample_bytree=0.6411, min_child_samples=36, min_child_weight=0.09835, min_split_gain=0, n_estimators=100, num_leaves=25, subsample=0.1146)
print("Cross validation score")
cr_score = cross_val_score(lgbm, X_train[sel_features_lgbm], y_train, cv=10)... | train_test['Age'] = train_test['Age'].astype('int64' ) | Titanic - Machine Learning from Disaster |
11,391,142 | sc = StandardScaler()
sc.fit(X_train)
X_train_std = sc.transform(X_train)
X_test_std = sc.transform(X_test )<train_on_grid> | train[['Survived','Sex']].groupby('Sex' ).mean() | Titanic - Machine Learning from Disaster |
11,391,142 | ridge = Ridge()
opt_r = BayesSearchCV(
ridge,
{"alpha":(0.0001,1000)},
n_iter = 50,
cv = 5,
n_jobs = -1)
bs_r = opt_r.fit(X_train_std, y_train)
print("Best score:{}".format(bs_r.best_score_))
print("Best params:{}".format(bs_r.best_params_))<compute_train_metric> | train_test.Fare.isnull().sum() | Titanic - Machine Learning from Disaster |
11,391,142 | ridge = Ridge(alpha=270.2)
print("Cross validation score")
cr_score = cross_val_score(ridge, X_train_std, y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_score.std()))<train_on_grid> | train_test.Fare.fillna(test.Fare.median() , inplace=True ) | Titanic - Machine Learning from Disaster |
11,391,142 | lasso = Lasso()
opt_l = BayesSearchCV(
lasso,
{"alpha":(0.00001,1)},
n_iter = 50,
cv = 5,
n_jobs = -1)
bs_l = opt_l.fit(X_train_std, y_train)
print("Best score:{}".format(bs_l.best_score_))
print("Best params:{}".format(bs_l.best_params_))<compute_train_metric> | train_test['Fare_log'] = np.log1p(train_test.Fare)
plot_skew(train_test.Fare_log ) | Titanic - Machine Learning from Disaster |
11,391,142 | lasso = Lasso(alpha=0.00001)
print("Cross validation score")
cr_score = cross_val_score(lasso, X_train_std, y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_score.std()))<train_on_grid> | train_test['Ticket_Frequency'] = train_test.groupby('Ticket')['Ticket'].transform('count')
train_test.Ticket_Frequency.astype('int64' ) | Titanic - Machine Learning from Disaster |
11,391,142 | elas = ElasticNet()
opt_e = BayesSearchCV(
elas,
{"alpha":(0.00001,1)},
n_iter = 50,
cv = 5,
n_jobs = -1)
bs_e = opt_e.fit(X_train_std, y_train)
print("Best score:{}".format(bs_e.best_score_))
print("Best params:{}".format(bs_e.best_params_))<compute_train_metric> | train_test.Cabin.isnull().sum() | Titanic - Machine Learning from Disaster |
11,391,142 | elas = ElasticNet(alpha=0.00365)
print("Cross validation score")
cr_score = cross_val_score(elas, X_train_std, y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_score.std()))<choose_model_class> | train_test['Cabin_code'] = train_test.Cabin.str.get(0 ).fillna('Z')
train_test[['Survived','Cabin_code']].groupby('Cabin_code' ).mean() | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
estimators = [("tr", DecisionTreeRegressor(max_depth=9, max_leaf_nodes=67, random_state=10)) ,
("rf", RandomForestRegressor(n_estimators=100, max_depth=40, max_leaf_nodes=100, min_samples_leaf=1, min_samples_split=0.00001, random_state=10)) ,
("xg", xgb.XGBRegressor(learning_rate=0.1350, max_depth=3, subsample... | train.Embarked.isnull().sum()
| Titanic - Machine Learning from Disaster |
11,391,142 | %%time
print("Cross validation score")
cr_score = cross_val_score(sreg, X_train, y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_score.std()))<predict_on_test> | train[['Embarked','Survived']].groupby('Embarked' ).mean() | Titanic - Machine Learning from Disaster |
11,391,142 | ps_test = sreg.predict(X_test)
X_test["y:pseudo"] = ps_test<concatenate> | train_test['Family_size']=train_test.SibSp+train_test.Parch
train_test['Is_alone']=1
train_test.loc[train_test['Family_size'] > 1,'Is_alone'] = 0
train_test['Family_size'].astype('int64')
train_test['Is_alone'].astype('int64' ) | Titanic - Machine Learning from Disaster |
11,391,142 | Ps_X_train = X_test.sample(int(len(X_train)/2))
Ps_X_train.reset_index(drop=True, inplace=True)
Ps_y_train = Ps_X_train["y:pseudo"]
Ps_X_train = Ps_X_train.drop("y:pseudo", axis=1)
n_X_train = pd.concat([X_train, Ps_X_train] ).reset_index(drop=True)
n_y_train = pd.concat([y_train, Ps_y_train] ).reset_index(drop=True... | Titanic - Machine Learning from Disaster | |
11,391,142 | %%time
tree = DecisionTreeRegressor(random_state=10)
opt_tree = BayesSearchCV(
tree,
{"max_depth":(5,20),
"max_leaf_nodes":(30,100)},
n_iter = 50,
cv = 5,
n_jobs = -1)
bs_tree = opt_tree.fit(n_X_train, n_y_train)
print("Best score:{}".format(bs_tree.best_score_))
print("Best params:{}".format(bs_tree.best_params_))... | train_test['Age_band'] = pd.cut(train_test.Age, bins=10, precision=0 ) | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
tree = DecisionTreeRegressor(max_depth=10, max_leaf_nodes=72, random_state=10)
print("Cross validation score")
cr_score = cross_val_score(tree, n_X_train, n_y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_score.std()))<train_on_grid> | train_test['Fare_band'] = pd.qcut(train_test.Fare_log, q=13, precision=2 ) | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
forest = RandomForestRegressor(random_state=10)
opt_forest = BayesSearchCV(
forest,
{"max_depth":(5,40),
"max_leaf_nodes":(30,100),
"n_estimators":(50,100),
"min_samples_split":(0.00001,1.0),
"min_samples_leaf":(1,10)},
n_iter = 50,
cv = 5,
n_jobs = -1)
bs_forest = opt_forest.fit(n_X_train[sel_features_forest... | MM_scaler = MinMaxScaler(feature_range=(0,1))
train_test[['Age_scaled']]=MM_scaler.fit_transform(train_test[['Age']])
sns.distplot(a=train_test.Age_scaled ) | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
forest = RandomForestRegressor(n_estimators=100, max_depth=40, max_leaf_nodes=100, min_samples_leaf=1, min_samples_split=0.00001, random_state=10)
print("Cross validation score")
cr_score = cross_val_score(forest, n_X_train[sel_features_forest], n_y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".for... | St_scaler = StandardScaler()
train_test[['Fare_scaled']]=St_scaler.fit_transform(train_test[['Fare_log']])
sns.distplot(a=train_test.Fare_scaled ) | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
xgbr = xgb.XGBRegressor(random_state=10)
opt_xgb = BayesSearchCV(
xgbr,
{"learning_rate":(0.001,0.99),
"max_depth":(1,30),
"subsample":(0.1,0.99),
"colsample_bytree":(0.01,0.99)},
n_iter = 50,
cv = 5,
n_jobs = -1)
bs_xgb = opt_xgb.fit(n_X_train, n_y_train)
print("Best score:{}".format(bs_xgb.best_score_))
pr... | le = OrdinalEncoder() | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
xgbr = xgb.XGBRegressor(learning_rate=0.07403, max_depth=211, subsample=0.7613, colsample_bytree=0.7985, random_state=10)
print("Cross validation score")
cr_score = cross_val_score(xgbr, n_X_train, n_y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_score.std()))<define_se... | train_test[['Age_code']] = le.fit_transform(train_test[['Age_band']])
train_test[['Fare_code']] = le.fit_transform(train_test[['Fare_band']] ) | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
lgbm = lgb.LGBMRegressor()
opt_lgbm = BayesSearchCV(
lgbm,
{"num_leaves":(20,100),
"n_estimators":(10,100),
"learning_rate":(0.001,1),
"max_depth":(1,30),
"min_split_gain":(0,0.5),
"min_child_weight":(0.001,0.1),
"min_child_samples":(5,50),
"subsample":(0.1,0.99),
"colsample_bytree":(0.01,0.99)},
n_iter = 50,
c... | for row in train_test:
train_test.loc[train_test['Family_size']==0, 'Family_type']=1
train_test.loc[(1<=train_test['Family_size'])&(train_test['Family_size']<=3), 'Family_type']=2
train_test.loc[(3<=train_test['Family_size'])&(train_test['Family_size']<=6), 'Family_type']=3
train_test.loc[7<=train_test['Family_size'], ... | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
lgbm = lgb.LGBMRegressor(learning_rate=0.1297, max_depth=20, colsample_bytree=0.9295, min_child_samples=43, min_child_weight=0.0484, min_split_gain=0, n_estimators=77, num_leaves=22, subsample=0.1)
print("Cross validation score")
cr_score = cross_val_score(lgbm, n_X_train[sel_features_lgbm], n_y_train, cv=10)
... | Titanic - Machine Learning from Disaster | |
11,391,142 | n_X_train_std = sc.transform(n_X_train )<train_on_grid> | train_test.Sex.replace(['female', 'male'], [1,0],inplace=True ) | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
ridge = Ridge()
opt_r = BayesSearchCV(
ridge,
{"alpha":(0.0001,1000)},
n_iter = 50,
cv = 5,
n_jobs = -1)
bs_r = opt_r.fit(n_X_train_std, n_y_train)
print("Best score:{}".format(bs_r.best_score_))
print("Best params:{}".format(bs_r.best_params_))<compute_train_metric> | X = pd.get_dummies(train_test[['Pclass','Sex','Title','Family_type',
'Age_code','Fare_code','Embarked',
'Cabin_code','Ticket_Code_Remap','Family_survived']])[:891]
X_test = pd.get_dummies(train_test[['Pclass','Sex','Title','Family_type',
'Age_code','Fare_code','Embarked',
'Cabin_code','Ticket_Code_Remap','Family_surviv... | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
ridge = Ridge(alpha=70.98)
print("Cross validation score")
cr_score = cross_val_score(ridge, n_X_train_std, n_y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_score.std()))<train_on_grid> | CV = StratifiedKFold(n_splits=5, shuffle=True,random_state=42)
n_trials = 500 | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
lasso = Lasso()
opt_l = BayesSearchCV(
lasso,
{"alpha":(0.00001,1)},
n_iter = 50,
cv = 5,
n_jobs = -1)
bs_l = opt_l.fit(n_X_train_std, n_y_train)
print("Best score:{}".format(bs_l.best_score_))
print("Best params:{}".format(bs_l.best_params_))<compute_train_metric> | Titanic - Machine Learning from Disaster | |
11,391,142 | %%time
lasso = Lasso(alpha=0.00012)
print("Cross validation score")
cr_score = cross_val_score(lasso, n_X_train_std, n_y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_score.std()))<train_on_grid> | Titanic - Machine Learning from Disaster | |
11,391,142 | %%time
elas = ElasticNet()
opt_e = BayesSearchCV(
elas,
{"alpha":(0.00001,1)},
n_iter = 50,
cv = 5,
n_jobs = -1)
bs_e = opt_e.fit(n_X_train_std, n_y_train)
print("Best score:{}".format(bs_e.best_score_))
print("Best params:{}".format(bs_e.best_params_))<compute_train_metric> | LR_param = {'penalty': 'l2', 'C': 109.16587461586346}
LR_best= LogisticRegression(**LR_param ) | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
elas = ElasticNet(alpha=0.00011)
print("Cross validation score")
cr_score = cross_val_score(elas, n_X_train_std, n_y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_score.std()))<choose_model_class> | DT_param ={'max_depth': 12, 'min_samples_split': 60, 'min_samples_leaf': 20}
DT_best= DecisionTreeClassifier(**DT_param ) | Titanic - Machine Learning from Disaster |
11,391,142 | %%time
estimators = [("tr", DecisionTreeRegressor(max_depth=10, max_leaf_nodes=72, random_state=10)) ,
("rf", RandomForestRegressor(n_estimators=100, max_depth=40, max_leaf_nodes=100, min_samples_leaf=1, min_samples_split=0.00001, random_state=10)) ,
("xg", xgb.XGBRegressor(learning_rate=0.07403, max_depth=211, subsa... | KNN_param ={'n_neighbors': 5, 'weights': 'uniform', 'p': 1}
KNN_best= KNeighborsClassifier(**KNN_param ) | Titanic - Machine Learning from Disaster |
11,391,142 | print("Cross validation score")
cr_score = cross_val_score(sreg, n_X_train, n_y_train, cv=10)
print(cr_score)
print("Ave_score:{} ± {}".format(cr_score.mean() , cr_score.std()))<normalization> | Titanic - Machine Learning from Disaster | |
11,391,142 | X_test.drop("y:pseudo", axis=1, inplace=True)
X_test_std = sc.transform(X_test )<predict_on_test> | Titanic - Machine Learning from Disaster | |
11,391,142 | y_pred_tree = 10**(bs_tree.predict(X_test))
y_pred_forest = 10**(bs_forest.predict(X_test[sel_features_forest]))
y_pred_xgb = 10**(bs_xgb.predict(X_test))
y_pred_lgbm = 10**(bs_lgbm.predict(X_test[sel_features_lgbm]))
y_pred_r = 10**(bs_r.predict(X_test_std))
y_pred_l = 10**(bs_l.predict(X_test_std))
y_pred_sreg = 10**... | Titanic - Machine Learning from Disaster | |
11,391,142 | submit_xgb = sample.copy()
submit_xgb["SalePrice"] = y_pred_xgb<prepare_output> | MLP_best= MLPClassifier(random_state=42,
solver='adam',
early_stopping=True,
activation='relu',
alpha= 0.0002746340910250398,
learning_rate='adaptive',
learning_rate_init=0.01,
batch_size=32,
hidden_layer_sizes=160 ) | Titanic - Machine Learning from Disaster |
11,391,142 | submit_lgbm = sample.copy()
submit_lgbm["SalePrice"] = y_pred_lgbm<prepare_output> | RF_param={'n_estimators': 50, 'max_depth': 5, 'min_samples_split': 40, 'min_samples_leaf': 20}
RF_best= RandomForestClassifier(random_state=42,
criterion='gini',
oob_score=True,
**RF_param ) | Titanic - Machine Learning from Disaster |
11,391,142 | submit_sreg = sample.copy()
submit_sreg["SalePrice"] = y_pred_sreg<prepare_output> | ET_params = {'n_estimators': 250, 'max_depth': 5, 'min_samples_split': 20, 'min_samples_leaf': 20}
ET_best = ExtraTreesClassifier(random_state=42,
criterion='gini',
n_jobs=-1,
**ET_params ) | 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.