kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,391,142 | submit_ems = sample.copy()
submit_ems["SalePrice"] = y_pred_tree*0.05 + y_pred_forest*0.1 + y_pred_xgb*0.3 + y_pred_lgbm*0.2 + y_pred_r*0.05 + y_pred_l*0.05 + y_pred_sreg*0.25<save_to_csv> | SVMB_params = {'n_estimators': 300, 'base_estimator__C': 3.232901108594473, 'base_estimator__gamma': 0.07183110256410177}
SVMB_best = BaggingClassifier(base_estimator=SVC(kernel = 'rbf',probability=True,C=3.232901108594473,gamma=0.07183110256410177),
random_state=42,n_jobs=-1,n_estimators=350 ) | Titanic - Machine Learning from Disaster |
11,391,142 | submit_xgb.to_csv('xgb_submission.csv', index=False)
submit_lgbm.to_csv('lgbm_submission.csv', index=False)
submit_sreg.to_csv('stack_submission.csv', index=False)
submit_ems.to_csv('ems_submission.csv', index=False)
print("Your submission was successfully saved!" )<import_modules> | ADB_best= AdaBoostClassifier(base_estimator=DecisionTreeClassifier(criterion='gini',
max_depth=2),
learning_rate=0.03990900089241141 ,
n_estimators=160,
random_state=42 ) | Titanic - Machine Learning from Disaster |
11,391,142 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.stats import norm<load_from_csv> | GDB_param = {'n_estimators': 420, 'learning_rate': 0.08199591231901683,
'max_depth': 3, 'min_samples_split': 140, 'min_samples_leaf': 20}
GDB_best= GradientBoostingClassifier(**GDB_param,
subsample=0.8,
n_iter_no_change=10,
random_state=42 ) | Titanic - Machine Learning from Disaster |
11,391,142 | 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' )<drop_column> | Titanic - Machine Learning from Disaster | |
11,391,142 | train_id = train['Id']
test_id = test['Id']
train = train.drop('Id', axis=1)
test = test.drop('Id', axis=1 )<drop_column> | XGB_param = {'max_depth': 5, 'n_estimators': 500, 'booster': 'dart',
'min_child_weight': 45, 'learning_rate': 0.00028818174062883895,
'gamma': 0.0701754028803822, 'reg_alpha': 0.09673762960851098, 'reg_lambda': 0.020973617864068886,
'colsample_bytree': 0.6000000000000001, 'subsample': 1.0}
XGB_best= XGBClassifier(**XGB... | Titanic - Machine Learning from Disaster |
11,391,142 | to_drop = ['PoolQC', 'MiscFeature', 'Alley', 'FireplaceQu']
train = train.drop(to_drop, axis=1)
test = test.drop(to_drop, axis=1 )<data_type_conversions> | votingC = VotingClassifier(estimators=[('XGB', XGB_best),
('RF',RF_best),
('ADB',ADB_best),
('ET', ET_best),
('GDB',GDB_best),
('DT',DT_best)],
voting='hard', n_jobs=-1,verbose=True)
votingC.fit(X,Y)
cv_result = cross_val_score(votingC,X,Y, cv = 5,scoring = "accuracy")
vot_acc = cv_result.mean()
vot_std = cv_re... | Titanic - Machine Learning from Disaster |
11,391,142 | LOG_FEATURES = ['LotFrontage', 'LotArea', 'BsmtFinSF1', 'BsmtFinSF2', 'BsmtUnfSF', 'TotalBsmtSF', '1stFlrSF', '2ndFlrSF', 'LowQualFinSF', 'GrLivArea', 'BsmtFullBath', 'BsmtHalfBath', 'FullBath', 'HalfBath', 'BedroomAbvGr', 'KitchenAbvGr', 'TotRmsAbvGrd', 'Fireplaces', 'GarageCars', 'GarageArea', 'WoodDeckSF', 'OpenPorc... | stacking = StackingClassifier(estimators=[('XGB', XGB_best),
('RF',RF_best),
('ADB',ADB_best),
('ET', ET_best),
('GDB',GDB_best),
('DT',DT_best)],
final_estimator=LogisticRegression() ,
cv=5,
n_jobs=-1)
cv_result = cross_val_score(stacking,X,Y, cv = 5,scoring = "accuracy")
stk_acc = cv_result.mean()
stk_std = cv... | Titanic - Machine Learning from Disaster |
11,391,142 | train = engineer_features(train)
test = engineer_features(test )<import_modules> | X_tr, X_te, Y_tr, Y_te = train_test_split(X,Y)
clf = RF_best.fit(X_tr,Y_tr)
mis_df = X_te[np.logical_xor(Y_te,clf.predict(X_te)) ]
mis_df=train.loc[mis_df.index]
mis_df.describe() | Titanic - Machine Learning from Disaster |
11,391,142 | from sklearn.model_selection import train_test_split, GridSearchCV, RandomizedSearchCV, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer, make_column_selector, TransformedTargetRegressor
from sklearn.preprocessing import OneHotEncoder, RobustScaler, OrdinalEncoder, Sta... | titanic_raw_train.loc[mis_df.index] | Titanic - Machine Learning from Disaster |
11,391,142 | X_train, y_train = train.drop('SalePrice', axis=1), train['SalePrice']<define_variables> | sub_model = RF_best | Titanic - Machine Learning from Disaster |
11,391,142 | categorical = [i for i in X_train.columns if train.dtypes[i] == 'object']
numerical = [i for i in X_train.columns if train.dtypes[i] != 'object']<categorify> | clf = RF_best.fit(X,Y)
sub = clf.predict(X_test)
sub_pd = pd.DataFrame({'PassengerId':titanic_raw_test.PassengerId,'Survived':sub})
sub_pd.to_csv('submit.csv' ,index=False ) | Titanic - Machine Learning from Disaster |
10,563,329 | def col_indicies(names):
return np.isin(missing_columns_output, names)
ordinal = ['ExterQual', 'ExterCond', 'BsmtQual', 'BsmtCond', 'HeatingQC', 'KitchenQual', 'GarageQual', 'GarageCond']
non_ordinal_categorical = np.setdiff1d(categorical, ordinal)
housing_encoder = ColumnTransformer([
('quality', OrdinalEncoder(c... | %matplotlib inline
| Titanic - Machine Learning from Disaster |
10,563,329 | ridge = Pipeline([
('fill_missing', missing_preprocessor),
('encoding', housing_encoder),
('scale', RobustScaler(with_centering=False)) ,
('ridge', Ridge(alpha=11.905772393787833))
])
ridge = TransformedTargetRegressor(ridge, func=np.log1p, inverse_func=np.expm1)
hot_ridge = Pipeline([
('fill_missing', missing_p... | training_data = pd.read_csv('/kaggle/input/titanic/train.csv')
testing_data = pd.read_csv('/kaggle/input/titanic/test.csv')
combined_data1 = [training_data, testing_data]
for data in combined_data1:
print('
',data.info() ) | Titanic - Machine Learning from Disaster |
10,563,329 |
<choose_model_class> | training_data.corr() ['Survived'].sort_values(ascending = False ) | Titanic - Machine Learning from Disaster |
10,563,329 | lasso = Pipeline([
('fill_missing', missing_preprocessor),
('encoding', housing_encoder),
('scale', RobustScaler(with_centering=False)) ,
('lasso', Lasso(alpha=0.000565620644760902))
])
lasso = TransformedTargetRegressor(lasso, func=np.log1p, inverse_func=np.expm1)
hot_lasso = Pipeline([
('fill_missing', missing... | for data in combined_data1:
data['title'] = data['Name'].apply(lambda x: x[x.find(',')+2:x.find('.')])
print(data['title'].value_counts())
print('
','='*50 ) | Titanic - Machine Learning from Disaster |
10,563,329 |
<choose_model_class> | def converttitle(x):
if x not in ['Mr','Miss','Mrs','Master']:
return 'other'
else:
return x
for data in combined_data1:
data['title'] = data['title'].apply(converttitle)
print(data['title'].value_counts())
print('
','='*50)
| Titanic - Machine Learning from Disaster |
10,563,329 | kernel_ridge = Pipeline([
('fill_missing', missing_preprocessor),
('encoding', housing_encoder),
('scale', RobustScaler(with_centering=False)) ,
('kridge', KernelRidge(kernel='poly', degree=2, alpha=48.93900918477494))
])
kernel_ridge = TransformedTargetRegressor(kernel_ridge, func=np.log1p, inverse_func=np.expm1 ... | for data in combined_data1:
data['family_members'] = data['SibSp'] + data['Parch']
data['aboard_alone'] = data['family_members'].apply(lambda x: 'yes' if x == 0 else 'no')
print(data.aboard_alone.value_counts() ) | Titanic - Machine Learning from Disaster |
10,563,329 |
<choose_model_class> | def pclass(x):
if x==1:
return 'Upper'
elif x==2:
return 'Middle'
else:
return 'Lower'
for data in combined_data1:
data['Pclass'] = data['Pclass'].apply(pclass)
print(data.Pclass.value_counts() ,'
' ) | Titanic - Machine Learning from Disaster |
10,563,329 | knn = Pipeline([
('fill_missing', missing_preprocessor),
('encoding', housing_encoder),
('scale', RobustScaler(with_centering=False)) ,
('knn', KNeighborsRegressor(n_neighbors=9, weights='distance', p=1))
])
knn = TransformedTargetRegressor(knn, func=np.log1p, inverse_func=np.expm1)
<train_on_grid> | train_data = training_data[['Survived','Pclass','Sex','Age','Fare','title','Embarked','aboard_alone']]
test_data = testing_data[['Pclass','Sex','Age','Fare','title','Embarked','aboard_alone']]
combined_data = [train_data, test_data]
for data in combined_data:
print(data.isnull().sum() ,'
' ) | Titanic - Machine Learning from Disaster |
10,563,329 |
<train_model> | def fare(x):
if x>300:
return mean
else:
return x
for data in combined_data:
mean = data.drop(data[data['Fare']>300].index)['Fare'].mean()
data['Fare'] = data['Fare'].apply(fare ) | Titanic - Machine Learning from Disaster |
10,563,329 | rf = Pipeline([
('fill_missing', missing_preprocessor),
('encoding', housing_encoder),
('scale', RobustScaler(with_centering=False)) ,
('rf', RandomForestRegressor(n_jobs=-1))
])
rf = TransformedTargetRegressor(rf, func=np.log1p, inverse_func=np.expm1)
<train_on_grid> | for data in combined_data:
data['Fare'] = pd.cut(data['Fare'], bins = [0,20,50,100,300], labels = ['Eco','business','prime','Deluxe'])
print(data.Fare.value_counts() ) | Titanic - Machine Learning from Disaster |
10,563,329 | param_grid = {
'regressor__rf__max_depth': [10, 20, 30, 40, 50, 60, None],
'regressor__rf__max_features': ['auto', 'sqrt'],
'regressor__rf__min_samples_leaf': [1, 2, 4],
'regressor__rf__n_estimators': [200, 400, 600, 800, 1000, 1200]
}
tuned_rf = RandomizedSearchCV(rf, param_grid, n_jobs=-1, cv=3, n_iter=10)
<init_hype... | final_train = pd.get_dummies(train_data, drop_first= True)
display('Train',final_train)
final_test = pd.get_dummies(test_data, drop_first= True)
display('Test',final_test ) | Titanic - Machine Learning from Disaster |
10,563,329 | param_init = {
"max_depth": 5,
"n_estimators": 3000,
"learning_rate": 0.01,
"subsample": 0.5,
"colsample_bytree": 0.7,
"min_child_weight": 1.5,
"reg_alpha": 0.75,
"reg_lambda": 0.4,
"seed": 42,
}
param_fit = {
"xgb__eval_metric": "rmse",
"xgb__verbose": 200
}
xgb_model = Pipeline([
('fill_missing', missing_preprocesso... | final_train.corr() ['Survived'].sort_values(ascending = False ) | Titanic - Machine Learning from Disaster |
10,563,329 | param_init = {
'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_model = Pipeline([
('f... | from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score, GridSearchCV
... | Titanic - Machine Learning from Disaster |
10,563,329 | models = {
'ridge': ridge,
'lasso': lasso,
'kernel ridge': kernel_ridge,
'knn': knn,
'random forest': rf,
'xgboost': xgb_model,
'lgbm': lgbm_model
}<compute_train_metric> | x = final_train.drop('Survived', axis = 1)
y = final_train['Survived'] | Titanic - Machine Learning from Disaster |
10,563,329 | for name, model in models.items() :
print(f'{name}:')
print(np.sqrt(np.mean(cross_val_score(model, X_train, y_train, cv=4, scoring=make_scorer(mean_squared_log_error), n_jobs=-1))))<compute_train_metric> | x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=0, stratify = y ) | Titanic - Machine Learning from Disaster |
10,563,329 | estimators = [('lasso', lasso),
('ridge', ridge),
('xgb', xgb_model),
('lgbm', lgbm_model)]
stacking_regressor = StackingRegressor(estimators=estimators, final_estimator=RidgeCV())
print(np.sqrt(np.mean(cross_val_score(stacking_regressor, X_train, y_train, cv=3, scoring=make_scorer(mean_squared_log_error), n_jobs=-... | lr_model = LogisticRegression()
lr_model.fit(x_train,y_train)
lr_predict = lr_model.predict(x_test)
print(lr_predict[:5])
print(y_test.head())
| Titanic - Machine Learning from Disaster |
10,563,329 | best_model = stacking_regressor
_ = best_model.fit(train.drop('SalePrice', axis=1), train['SalePrice'] )<save_to_csv> | sm.r2_score(y_test,lr_predict ) | Titanic - Machine Learning from Disaster |
10,563,329 | sub = pd.DataFrame()
sub['Id'] = test_id
sub['SalePrice'] = best_model.predict(test)
sub.to_csv('submission.csv', index=False )<compute_train_metric> | print(sm.classification_report(y_test,lr_predict)) | Titanic - Machine Learning from Disaster |
10,563,329 | def rmse_cv(model):
rmse= np.sqrt(-cross_val_score(model, X_train, y, scoring="neg_mean_squared_error", cv = 5))
return(rmse)
<set_options> | dt_model = DecisionTreeClassifier(random_state = 0)
clf = GridSearchCV(dt_model, param_grid = {'criterion':('gini', 'entropy'),
'max_depth':[2,3,4,5,6]},
cv=5)
clf.fit(x_train,y_train)
print(clf.best_params_)
print(clf.best_score_)
dt_predict = clf.predict(x_test)
| Titanic - Machine Learning from Disaster |
10,563,329 | pd.set_option('display.max_columns', 500 )<load_from_csv> | sm.r2_score(y_test,dt_predict ) | Titanic - Machine Learning from Disaster |
10,563,329 | 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' )<concatenate> | print(sm.classification_report(y_test,dt_predict)) | Titanic - Machine Learning from Disaster |
10,563,329 | all_data = pd.concat(( train.loc[:,'MSSubClass':'SaleCondition'],test.loc[:,'MSSubClass':'SaleCondition']))<feature_engineering> | rf_model = RandomForestClassifier(random_state=0)
rf_clf = GridSearchCV(rf_model, param_grid = {'n_estimators': [200, 300,400,500],
'max_depth' : [3,4,5,6,7],
'criterion' :['gini', 'entropy']},
cv=3)
rf_clf.fit(x_train,y_train)
print(rf_clf.best_params_)
print(rf_clf.best_score_)
rf_predict = rf_clf.predict(x_test... | Titanic - Machine Learning from Disaster |
10,563,329 | train["SalePrice"] = np.log1p(train["SalePrice"])
numeric_feats = all_data.dtypes[all_data.dtypes != "object"].index<feature_engineering> | print(sm.classification_report(y_test,rf_predict)) | Titanic - Machine Learning from Disaster |
10,563,329 | skewed_feats = train[numeric_feats].apply(lambda x: skew(x.dropna()))
skewed_feats = skewed_feats[skewed_feats > 0.75]
skewed_feats = skewed_feats.index
all_data[skewed_feats] = np.log1p(all_data[skewed_feats] )<categorify> | sm.r2_score(y_test,rf_predict ) | Titanic - Machine Learning from Disaster |
10,563,329 | all_data = pd.get_dummies(all_data)
all_data = all_data.fillna(all_data.mean() )<prepare_x_and_y> | model = RandomForestClassifier(random_state=0,
max_depth = 6,
n_estimators = 200)
model.fit(x,y)
pred =(model.predict(final_test)) | Titanic - Machine Learning from Disaster |
10,563,329 | X_train = all_data[:train.shape[0]]
X_test = all_data[train.shape[0]:]
y = train.SalePrice<find_best_params> | submission = pd.DataFrame({
'PassengerId': testing_data['PassengerId'],
'Survived': pred
} ) | Titanic - Machine Learning from Disaster |
10,563,329 | <train_on_grid><EOS> | submission.to_csv('Submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
10,707,758 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<find_best_params> | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename)) | Titanic - Machine Learning from Disaster |
10,707,758 | model_ridge = RandomForestRegressor()
cv_rf = [rmse_cv(RandomForestRegressor(n_estimators = estimators)).mean()
for estimators in [1,10,20,40,100]]
cf_rf = pd.Series(cv_ridge, index = [1,10,20,40,100])
print('random forest score ',cf_rf.min())
print("number of estimators: ",cf_rf.sort_values().index[0] )<train_model> | train_original = pd.read_csv('/kaggle/input/titanic/train.csv')
test_original = pd.read_csv('/kaggle/input/titanic/test.csv')
train = train_original.copy()
test = test_original.copy()
dfs = [train, test]
dfs_names = ['Train','Test'] | Titanic - Machine Learning from Disaster |
10,707,758 | rf = RandomForestRegressor(n_estimators=100)
rf.fit(X_train,y )<train_on_grid> | for df in [train,test]:
df['Title'] = df['Title'].replace(['Lady', 'Countess','Capt', 'Col',
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
for df in [train,test]:
df['Title'] = df['Title'].replace(['Mlle','Mme','Ms'], 'Miss')
train[['Title', 'Survived']].groupby(['Title'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
10,707,758 | param_grid = {
'max_depth': [80, 90,],
'max_features': [2, 3],
'min_samples_leaf': [3, 4, 5],
'min_samples_split': [8, 10, 12],
'n_estimators': [100, 200]
}
grid_search = GridSearchCV(estimator = GradientBoostingRegressor() , scoring="neg_mean_squared_error", param_grid = param_grid,
cv = 3, n_jobs = -1, verbose = 2)
... | for df in [train,test]:
df['Ticket Extracted'] = df['Ticket'].str.extract(r'([a-zA-Z]+)' ) | Titanic - Machine Learning from Disaster |
10,707,758 | pd.DataFrame(grid_search.cv_results_)['mean_test_score'].mean() *(-1 )<predict_on_test> | for i,j in enumerate(dfs):
print(dfs_names[i]+':')
for col in j.select_dtypes(include='object' ).columns:
print(f'Unique number of {col}: {j[col].nunique() }' ) | Titanic - Machine Learning from Disaster |
10,707,758 | gradient_boost_preds = np.expm1(grid_search.best_estimator_.predict(X_test))
rf_preds = np.expm1(rf.predict(X_test))
lasso_preds = np.expm1(model_lasso.predict(X_test))<save_to_csv> | label_enc = LabelEncoder()
to_encode = ['Sex','Embarked','Ticket Extracted','Title']
for df in [train, test]:
for i in to_encode:
df[i] = df[i].astype(str)
df[i] = label_enc.fit_transform(df[i])
for df in [train,test]:
df.drop(['Name','Ticket','Cabin'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
10,707,758 | preds = 0.45*gradient_boost_preds +0.1*rf_preds + 0.45*lasso_preds
kaggle_solution = pd.DataFrame({"id":test.Id, "SalePrice":preds})
kaggle_solution.to_csv("test_pred.csv", index = False )<set_options> | def get_dummies_and_drop(df,dummy_cols,drop_cols):
df_ = pd.get_dummies(df,columns=dummy_cols)
for i in to_drop:
try:
df_.drop(i,inplace=True,axis=1)
except:
pass
return df_
to_dummy = ['Sex','Embarked','Ticket Extracted','Title']
to_drop = ['Sex','Embarked','Name','Ticket','Cabin','Title']
| Titanic - Machine Learning from Disaster |
10,707,758 | np.random.seed(10)
%matplotlib inline
%reload_ext autoreload
%autoreload 2<load_from_csv> | def percent_na_values(df,df_name,impute_thres):
cols_with_na = df.columns[df.isna().any() ].to_list()
df_len = len(df)
for i in cols_with_na:
count_missing = df[i].isna().sum()
percent_missing = round(count_missing/df_len*100,1)
print(f'Percent of {df_name} {i} missing = {percent_missing}')
if percent_missing <= i... | Titanic - Machine Learning from Disaster |
10,707,758 | data_folder = Path(".. /input")
train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/sample_submission.csv" )<choose_model_class> | def multivariate_imputer(df):
imp = IterativeImputer(max_iter=20, random_state=0,min_value=0)
imp.fit(df)
df_imputed = imp.transform(df)
df_imputed = pd.DataFrame(df_imputed,columns=df.columns)
return df_imputed
train = multivariate_imputer(train)
test = multivariate_imputer(test ) | Titanic - Machine Learning from Disaster |
10,707,758 | learn_densnet = cnn_learner(train_img, models.densenet201, metrics=[error_rate, accuracy], model_dir="/tmp/model/" )<find_best_params> | imputer = SimpleImputer(strategy='most_frequent')
def impute_df(df):
df_imputed = pd.DataFrame(imputer.fit_transform(df))
df_imputed.columns = df.columns
df = df_imputed.copy()
return df
print(f'Total NA in train: {train.isna().sum().sum() }')
print(f'Total NA in test: {test.isna().sum().sum() }' ) | Titanic - Machine Learning from Disaster |
10,707,758 | learn_densnet.lr_find()
learn_densnet.recorder.plot()<train_model> | for df in [train, test]:
df['Family'] = df['Parch'] + df['SibSp'] | Titanic - Machine Learning from Disaster |
10,707,758 | lr = 1e-02
learn_densnet.fit_one_cycle(5 , slice(lr))<predict_on_test> | for df in [train,test]:
df.drop(['Age','Fare'],inplace=True,axis=1 ) | Titanic - Machine Learning from Disaster |
10,707,758 | preds,_ = learn_densnet.get_preds(ds_type=DatasetType.Test )<save_to_csv> | X = train.copy()
X.drop('Survived',inplace=True,axis=1)
y = train['Survived'].copy()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2 ) | Titanic - Machine Learning from Disaster |
10,707,758 | test_df.to_csv('submission.csv', index=False )<import_modules> | def gridsearch(X,y,model,grid,cv):
CV = GridSearchCV(estimator=model,param_grid=grid,cv=cv)
CV.fit(X, y)
print(CV.best_params_)
print('Best parameters returned for use')
return(CV.best_params_ ) | Titanic - Machine Learning from Disaster |
10,707,758 | import os
import time
import pandas as pd
import numpy as np
import cv2
from tqdm import tqdm
import matplotlib.pyplot as plt
from keras.models import Sequential,load_model
from keras.layers import Dense,Conv2D,Dropout,MaxPooling2D,Flatten,BatchNormalization
from keras.callbacks import EarlyStopping
from keras import o... | xgb = XGBClassifier(learning_rate=xgb_params['learning_rate'],max_depth=xgb_params['max_depth'],
n_estimators=xgb_params['n_estimators'],subsample=xgb_params['subsample'])
forest = RandomForestClassifier(max_depth=forest_params['max_depth'],max_leaf_nodes=forest_params['max_leaf_nodes'],
n_estimators=forest_params['n_... | Titanic - Machine Learning from Disaster |
10,707,758 | train_path='.. /input/train/train'
test_path='.. /input/test/test'<prepare_x_and_y> | def cross_val(model_name,model,X,y,cv):
scores = cross_val_score(model, X, y, cv=cv)
print(f'{model_name} Scores:')
for i in scores:
print(round(i,2))
print(f'Average {model_name} score: {round(scores.mean() ,2)}' ) | Titanic - Machine Learning from Disaster |
10,707,758 | label_train=pd.read_csv(".. /input/train.csv")
label_train=label_train.sort_values(by=['id'])
id=label_train['id'].values
l=label_train['has_cactus'].values
train=[]
X=[]
Y=[]
a=0
for i in tqdm(sorted(os.listdir(train_path))):
path=os.path.join(train_path,i)
i=cv2.imread(path,cv2.IMREAD_COLOR)
X.append(i)
train.ap... | xgb.fit(X,y)
preds = xgb.predict(test)
test.PassengerId.astype(int ) | Titanic - Machine Learning from Disaster |
10,707,758 | <choose_model_class><EOS> | output = pd.DataFrame({'PassengerId': test.PassengerId.astype(int), 'Survived': preds.astype(int)})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
10,137,620 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | %matplotlib inline
sns.set()
rcParams['figure.figsize'] = 12,8
| Titanic - Machine Learning from Disaster |
10,137,620 | m.compile(loss="binary_crossentropy",optimizer='adam',metrics=["accuracy"])
s=time.time()
h=m.fit(X,Y,batch_size=128,validation_split=0.2,epochs=100)
e=time.time()
t=e-s
print("Addestramento completato in %d minuti e %d secondi" %(t/60,t*60))<find_best_params> | train_df = pd.read_csv("/kaggle/input/titanic/train.csv")
test_df = pd.read_csv('/kaggle/input/titanic/test.csv')
train_df.head() | Titanic - Machine Learning from Disaster |
10,137,620 | acc=h.history['acc']
val_acc=h.history['val_acc']
loss=h.history['loss']
val_loss=h.history['val_loss']<save_to_csv> | print('Train dataset has only {} unique tickets'.format(len(train_df['Ticket'].unique())))
print('-'*40)
print('Test dataset has only {} unique tickets'.format(len(test_df['Ticket'].unique())) ) | Titanic - Machine Learning from Disaster |
10,137,620 | pred=m.predict(X_test)
ids=[]
label=[]
a=0
for i in tqdm(os.listdir(test_path)) :
id=i
ids.append(id)
label.append(pred[a])
a=a+1
label=np.array(label,dtype='float64')
out=pd.DataFrame({'id': ids,'has_cactus':label[:,0]})
out.to_csv('cactus_identifier_net.csv',index=False,header=True )<set_options> | new_train_df = train_df.copy()
new_test_df = test_df.copy() | Titanic - Machine Learning from Disaster |
10,137,620 | %reload_ext autoreload
%autoreload 2
%matplotlib inline<import_modules> | def total_famil_members(df):
return df['SibSp']+df['Parch']+1 | Titanic - Machine Learning from Disaster |
10,137,620 | from fastai.vision import *
from fastai import *
from fastai.metrics import error_rate
import pandas as pd
import torch<load_from_csv> | for data in [new_train_df, new_test_df]:
data['Members'] = total_famil_members(data)
data['Adjusted_Fare'] = data['Fare']/data['Members']
data['Title'] = data['Name'].apply(get_title ) | Titanic - Machine Learning from Disaster |
10,137,620 | path =".. /input/"
train_df=pd.read_csv(path+"train.csv")
test_df=pd.read_csv(path+"sample_submission.csv")
<load_from_csv> | for data in [new_train_df, new_test_df]:
data['Title'] = data['Title'].replace(['Lady', 'Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
data['Title'] = data['Title'].replace('Mlle', 'Miss')
data['Title'] = data['Title'].replace('Ms', 'Miss')
data['Title'] = data['Title'].rep... | Titanic - Machine Learning from Disaster |
10,137,620 | bs = 128
data = ImageDataBunch.from_csv(path=path, folder='train/train', csv_labels='train.csv', ds_tfms=get_transforms() , size=32, bs=bs ).normalize(imagenet_stats)
<define_variables> | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for data in [new_train_df, new_test_df]:
data['Title'] = data['Title'].map(title_mapping)
data['Title'] = data['Title'].fillna(0)
data['Embarked'] = data['Embarked'].fillna('S')
data['Sex'] = data['Sex'].map({'female': 0, 'male': 1} ).astype(int)... | Titanic - Machine Learning from Disaster |
10,137,620 | data.show_batch(rows=3, figsize=(7,6))<find_best_params> | for data in [new_train_df, new_test_df]:
data['Embarked'] = data['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int ) | Titanic - Machine Learning from Disaster |
10,137,620 | data.classes, data.c, len(data.train_ds), len(data.valid_ds )<choose_model_class> | data_train = new_train_df[~new_train_df['Age'].isnull() ]
data_test = new_test_df[~new_test_df['Age'].isnull() ] | Titanic - Machine Learning from Disaster |
10,137,620 | learn = cnn_learner(data, models.resnet50, metrics=error_rate, model_dir="/tmp/model/" )<train_model> | X_train = data_train[['Pclass','Sex','SibSp','Parch','Title']]
y_train = data_train['Age']
X_test = data_test[['Pclass','Sex','SibSp','Parch','Title']]
y_test = data_test['Age']
X_train.head() | Titanic - Machine Learning from Disaster |
10,137,620 | learn.fit_one_cycle(6 )<train_model> | model_age_prediction = RandomForestRegressor(n_estimators=900, max_depth=6, min_samples_leaf=0.001, random_state=100)
model_age_prediction.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
10,137,620 | learn.fit_one_cycle(5, max_lr=slice(3e-5,3e-4))<choose_model_class> | y_predict = model_age_prediction.predict(X_test ) | Titanic - Machine Learning from Disaster |
10,137,620 | interp = ClassificationInterpretation.from_learner(learn )<predict_on_test> | print('test score is: {}'.format(r2_score(y_test, y_predict)))
print('training score is: {}'.format(r2_score(y_train, model_age_prediction.predict(X_train)))) | Titanic - Machine Learning from Disaster |
10,137,620 | a,b,c=learn.predict(open_image(".. /input/test/test/000940378805c44108d287872b2f04ce.jpg"))
print(c)
print(c[1].numpy())
<predict_on_test> | train_missing_predicted = model_age_prediction.predict(new_train_df[new_train_df['Age'].isnull() ][['Pclass','Sex','SibSp','Parch','Title']])
test_missing_predicted = model_age_prediction.predict(new_test_df[new_test_df['Age'].isnull() ][['Pclass','Sex','SibSp','Parch','Title']] ) | Titanic - Machine Learning from Disaster |
10,137,620 | def pred(name):
a,b,c=learn.predict(open_image(".. /input/test/test/"+name))
return c[1].numpy()<feature_engineering> | new_train_df['Age'][np.isnan(new_train_df['Age'])] = train_missing_predicted
new_test_df['Age'][np.isnan(new_test_df['Age'])] = test_missing_predicted | Titanic - Machine Learning from Disaster |
10,137,620 | test_df["has_cactus"]=test_df["id"].apply(lambda x:pred(x))<save_to_csv> | new_test_df[new_test_df['Adjusted_Fare'].isna() ] | Titanic - Machine Learning from Disaster |
10,137,620 | test_df.to_csv('submission.csv',index=False )<set_options> | new_test_df['Fare'] = new_test_df['Adjusted_Fare']*new_test_df['Members']
new_test_df.info() | Titanic - Machine Learning from Disaster |
10,137,620 | %matplotlib inline
print(os.listdir(".. /input"))
<train_model> | data_model = new_train_df[['Survived', 'Pclass', 'Sex', 'Age', 'Embarked', 'Members', 'Adjusted_Fare', 'Title']]
data_model.head() | Titanic - Machine Learning from Disaster |
10,137,620 | def read_pix(jpg_dir):
filenames = glob.glob(os.path.join(jpg_dir, '*.jpg'))
img_array = np.zeros(( len(filenames), 32, 32, 3), dtype=int)
img_index = []
for idx, filename in enumerate(filenames):
im_tmp = matplotlib.image.imread(filename)
img_array[idx, :, :, :] = np.array(im_tmp, dtype=int)
img_index.append(os.pat... | train_X, test_X, train_y, test_y = train_test_split(data_model.drop(['Survived'], axis=1), data_model['Survived'],\
stratify=data_model['Survived'], random_state=123, test_size=0.25 ) | Titanic - Machine Learning from Disaster |
10,137,620 | train_labels = pd.read_csv('.. /input/train.csv')
sample_submission = pd.read_csv('.. /input/sample_submission.csv')
train_img_array, train_img_index = read_pix('.. /input/train/train')
test_img_array, test_img_index = read_pix('.. /input/test/test')
train_response = train_labels['has_cactus']
train_response.index ... | lr = LogisticRegression()
params_lr = {'C':[0.001, 0.01, 0.1, 1, 10, 100]} | Titanic - Machine Learning from Disaster |
10,137,620 | batch_size = 128
num_classes = 2
datagen = ImageDataGenerator(
rotation_range=90,
width_shift_range=.1,
height_shift_range=.1,
shear_range=.2,
zoom_range=.1,
horizontal_flip=True,
vertical_flip=True,
fill_mode='nearest',
)
x_train, y_train, x_test, y_test, y_train_series, y_test_series = prepare_data(train_img_array... | lr_cv = GridSearchCV(lr, params_lr, n_jobs=-1, cv=5 ) | Titanic - Machine Learning from Disaster |
10,137,620 | x_train = x_train / 255
x_test = x_test / 255
train_generator = datagen.flow(x_train, y_train)
test_datagen = ImageDataGenerator()
validation_generator = test_datagen.flow(x_test, y_test )<choose_model_class> | lr_cv.fit(train_X, train_y ) | Titanic - Machine Learning from Disaster |
10,137,620 | def convnet_model() :
model = Sequential()
model.add(Conv2D(32,(5, 5), input_shape=(32, 32, 3), activation='relu'))
model.add(Conv2D(32,(5, 5), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64,(5, 5), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.5)... | lr_cv_best_model = pd.DataFrame({'Params':lr_cv.best_params_.values() , 'best_score':lr_cv.best_score_,\
'Train Score':accuracy_score(train_y, lr_cv.best_estimator_.predict(train_X)) ,\
'Test Score': accuracy_score(test_y, lr_cv.best_estimator_.predict(test_X)) } ) | Titanic - Machine Learning from Disaster |
10,137,620 | model = convnet_model()
hist = model.fit_generator(train_generator,
steps_per_epoch=np.ceil(x_train.shape[0] / 32),
epochs=120,
validation_data=validation_generator,
validation_steps=np.ceil(x_test.shape[0] / 32)
)
scores = model.evaluate(x_test, y_test, verbose=0)
print('CNN error: {:.2f}'.format(100-scores[1]*100))... | svc = LinearSVC()
params_svc = params_lr | Titanic - Machine Learning from Disaster |
10,137,620 | probability = model.predict_proba(test_img_array/255)
res = pd.DataFrame({
'id': test_img_index,
'has_cactus': probability.ravel() ,
})
res.to_csv('submission.csv', index=False )<import_modules> | svc_cv = GridSearchCV(svc, params_svc, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
10,137,620 | import numpy as np
import pandas as pd
from pathlib import Path
from fastai import *
from fastai.vision import *
import torch
<load_from_csv> | svc_cv.fit(train_X, train_y ) | Titanic - Machine Learning from Disaster |
10,137,620 | data_folder = Path(".. /input")
train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/sample_submission.csv" )<define_variables> | svc_cv_best_model = pd.DataFrame({'Params':svc_cv.best_params_.values() , 'best_score':svc_cv.best_score_,\
'Train Score':accuracy_score(train_y, svc_cv.best_estimator_.predict(train_X)) ,\
'Test Score': accuracy_score(test_y, svc_cv.best_estimator_.predict(test_X)) } ) | Titanic - Machine Learning from Disaster |
10,137,620 | test_img = ImageList.from_df(test_df, path=data_folder/'test', folder='test' )<categorify> | max_depth =[]
min_samples_leaf = []
cv_rf_scores = []
test_roc_scores = []
train_roc_scores = []
test_acc_scores = []
train_acc_scores = []
for depth in [5,6,7,8,9]:
for samples_leaf in [0.009, 0.01]:
rf = RandomForestClassifier(n_estimators=400, n_jobs=-1, max_features='log2', max_depth=depth, min_samples_leaf=samples... | Titanic - Machine Learning from Disaster |
10,137,620 | src =(ImageList.from_df(train_df, path=data_folder/'train', folder='train')
.split_by_rand_pct(0.01)
.label_from_df()
.add_test(test_img)
)<load_pretrained> | rf_cv_scores = pd.DataFrame({'Max_depth':max_depth, 'Min_samples_leaf':min_samples_leaf, 'CV_Scores':cv_rf_scores,\
'Test_roc_score':test_roc_scores, 'Train_roc_scores':train_roc_scores,\
'Test_acc_score':test_acc_scores, 'Train_acc_scores':train_acc_scores} ) | Titanic - Machine Learning from Disaster |
10,137,620 | train_img=src.databunch('.',bs=50 )<define_variables> | rf_cv_scores_sorted = rf_cv_scores.sort_values(by='CV_Scores' ).reset_index()
rf_cv_scores_sorted.head(18 ) | Titanic - Machine Learning from Disaster |
10,137,620 | train_img.show_batch()<feature_engineering> | classifiers = [('Logistic Regression',LogisticRegression(C=0.1)) ,\
('SVC', LinearSVC(C=0.01)) ,\
('Random Forest', RandomForestClassifier(n_estimators=400, n_jobs=-1, max_features='log2', max_depth=7, min_samples_leaf=0.01, random_state=100)) ] | Titanic - Machine Learning from Disaster |
10,137,620 | tfms=get_transforms(flip_vert=True )<normalization> | vc = VotingClassifier(estimators=classifiers, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
10,137,620 | train_img =(src.transform(tfms,size=128)
.databunch('.',bs=50)
)<choose_model_class> | vc.fit(train_X, train_y ) | Titanic - Machine Learning from Disaster |
10,137,620 | denselearner = cnn_learner(train_img, models.densenet161, metrics=[FBeta() ,error_rate, accuracy] )<find_best_params> | vc_scores = pd.DataFrame({'Best_score':cross_val_score(vc, train_X, train_y, cv=5 ).mean() ,\
'Train Score':accuracy_score(train_y, vc.predict(train_X)) ,\
'Test Score': accuracy_score(test_y, vc.predict(test_X)) }, index=[0] ) | Titanic - Machine Learning from Disaster |
10,137,620 | denselearner.lr_find()
denselearner.recorder.plot(suggestion=True )<train_model> | print('ROC_AUC score for VC is {}'.format(roc_auc_score(test_y, vc.predict(test_X))))
print('Accuracy score for VC is {}'.format(accuracy_score(test_y, vc.predict(test_X)))) | Titanic - Machine Learning from Disaster |
10,137,620 | lr = 7.5e-03
denselearner.fit_one_cycle(5, slice(lr))<find_best_params> | rf1 = RandomForestClassifier(n_estimators=400, n_jobs=-1, max_features='log2', max_depth=7, min_samples_leaf=0.01, random_state=100)
rf1.fit(train_X, train_y ) | Titanic - Machine Learning from Disaster |
10,137,620 | denselearner.unfreeze()
denselearner.lr_find()
denselearner.recorder.plot(suggestion=True )<train_model> | print('ROC_AUC score for RF is {}'.format(roc_auc_score(test_y, rf1.predict(test_X))))
print('Accuracy score for RF is {}'.format(accuracy_score(test_y, rf1.predict(test_X)))) | Titanic - Machine Learning from Disaster |
10,137,620 | denselearner.fit_one_cycle(1, slice(1e-06))<choose_model_class> | results = rf1.predict(new_test_df[['Pclass', 'Sex', 'Age', 'Embarked', 'Members', 'Adjusted_Fare', 'Title']] ) | Titanic - Machine Learning from Disaster |
10,137,620 | reslearner = cnn_learner(train_img, models.resnet101, metrics=[FBeta() ,error_rate, accuracy] )<find_best_params> | submission = pd.DataFrame({'PassengerId':new_test_df.PassengerId, 'Survived':results} ) | Titanic - Machine Learning from Disaster |
10,137,620 | reslearner.lr_find()<define_search_space> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
10,137,620 | <train_model><EOS> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
2,444,244 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | %matplotlib inline
warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
2,444,244 | reslearner.unfreeze()
reslearner.fit_one_cycle(2,slice(1e-6))<predict_on_test> | print(os.listdir(".. /input"))
train= pd.read_csv('.. /input/train.csv')
train_init= pd.read_csv('.. /input/train.csv')
test= pd.read_csv('.. /input/test.csv')
test_init= pd.read_csv('.. /input/test.csv')
train.head() | 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.