kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
6,168,266 | tuned_cat.best_params_<install_modules> | def generate_data(x1,x2,df,t):
X = pd.concat([df[x1], df[x2]], axis=1 ).values
if t==1:
y = train_y.values.astype(int)
return(X, y)
else:
return X | Titanic - Machine Learning from Disaster |
6,168,266 | !pip install lightgbm
<choose_model_class> | datasets = []
for i in range(len(clustered_features)) :
datasets.append(( generate_data(feature_first,clustered_features[i],train_x_all,1),{})) | Titanic - Machine Learning from Disaster |
6,168,266 | gbm = lgb.LGBMRegressor(random_state=123 )<data_type_conversions> | datasets_test = []
rez = pd.DataFrame(index = test_x.index)
for i in range(len(clustered_features)) :
datasets_test.append(generate_data(feature_first,clustered_features[i],test_x_all,0)) | Titanic - Machine Learning from Disaster |
6,168,266 | X_transformed_copy=X_transformed.copy()
for col in cat_columns:
X_transformed_copy[col] = X_transformed_copy[col].astype('category')
<define_search_space> | def generate_clustering_algorithms(Z,n_clusters):
bandwidth = cluster.estimate_bandwidth(df, quantile=params['quantile'])
connectivity = kneighbors_graph(
Z, n_neighbors=params['n_neighbors'], include_self=False)
connectivity = 0.5 *(connectivity + connectivity.T)
ms = cluster.MeanShift(bandwidth=bandwidth, bin_see... | Titanic - Machine Learning from Disaster |
6,168,266 | param_test ={'num_leaves': Integer(6, 50),
'min_child_samples': Integer(100, 500),
'min_child_weight': [1e-5, 1e-3, 1e-2, 1e-1, 1, 1e1, 1e2, 1e3, 1e4],
'subsample': Real(0.2,0.8),
'colsample_bytree': Real(0.4, 0.6),
'n_estimators':Integer(100, 2000),
'depth': Integer(1, 8),
'learning_rate': Real(0.01, 1.0, 'log-uniform... | train_x = pd.concat([train_x_all.WomanOrBoySurvived.fillna(0),
train_x_all.Alone,
train_x_all.Sex,
], axis=1)
test_x = pd.concat([test_x_all.WomanOrBoySurvived.fillna(0),
test_x_all.Alone,
test_x_all.Sex,
], axis=1 ) | Titanic - Machine Learning from Disaster |
6,168,266 | train_sizes, train_scores, test_scores, fit_times, _ = learning_curve(tuned_gbm.best_estimator_, X_transformed_copy, y, cv=3,
return_times=True,random_state=123,
scoring='neg_mean_squared_error')
train_scores_mean = np.mean(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
fig = go.Figure()
fig.a... | train_x = train_x.join(train_x_all[rez_col], how='left', lsuffix="_rez")
train_x.head(2 ) | Titanic - Machine Learning from Disaster |
6,168,266 | embeded_gbm_selector = SelectFromModel(tuned_gbm.best_estimator_, max_features=X_transformed_copy.shape[1])
embeded_gbm_selector.fit(X_transformed_copy, y )<features_selection> | test_x = test_x.join(rez[rez_col], how='left', lsuffix="_rez")
test_x.head(2 ) | Titanic - Machine Learning from Disaster |
6,168,266 | embeded_gbm_support = embeded_gbm_selector.get_support()
embeded_gbm_feature = X_transformed_copy.loc[:,embeded_gbm_support].columns.tolist()
print(str(len(embeded_gbm_feature)) , 'selected features' )<filter> | parameters = {'max_depth' : np.arange(2, 9, dtype=int),
'min_samples_leaf' : np.arange(1, 4, dtype=int)}
classifier = DecisionTreeClassifier(random_state=1000)
model = GridSearchCV(estimator=classifier, param_grid=parameters, scoring='accuracy', cv=10, n_jobs=-1)
model.fit(train_x, train_y)
best_parameters = model.b... | Titanic - Machine Learning from Disaster |
6,168,266 | X_gbm_reduced=X_transformed_copy[embeded_gbm_feature]<define_search_space> | model=DecisionTreeClassifier(max_depth = best_parameters['max_depth'],
random_state = 1118)
model.fit(train_x, train_y ) | Titanic - Machine Learning from Disaster |
6,168,266 | param_test ={'num_leaves': Integer(6, 50),
'min_child_samples': Integer(100, 500),
'min_child_weight': [1e-5, 1e-3, 1e-2, 1e-1, 1, 1e1, 1e2, 1e3, 1e4],
'subsample': Real(0.2,0.8),
'colsample_bytree': Real(0.4, 0.6),
'n_estimators':Integer(100, 2000),
'depth': Integer(1, 8),
'learning_rate': Real(0.01, 1.0, 'log-uniform... | dot_data = export_graphviz(model, out_file=None, feature_names=train_x.columns, class_names=['0', '1'],
filled=True, rounded=False,special_characters=True, precision=7)
graph = graphviz.Source(dot_data)
graph | Titanic - Machine Learning from Disaster |
6,168,266 | tuned_gbm.best_score_<train_on_grid> | y_pred = model.predict(test_x ).astype(int)
print('Mean =', y_pred.mean() , ' Std =', y_pred.std())
| Titanic - Machine Learning from Disaster |
6,168,266 | train_sizes, train_scores, test_scores, fit_times, _ = learning_curve(tuned_gbm.best_estimator_, X_gbm_reduced, y, cv=3,
return_times=True,random_state=123,
scoring='neg_mean_squared_error')
train_scores_mean = np.mean(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
fig = go.Figure()
fig.add_tr... | train_y_pred = model.predict(train_x ).astype(int)
diff = sum(abs(train_y-train_y_pred)) *100/len(train_y)
diff
| Titanic - Machine Learning from Disaster |
6,168,266 | test_df_copy=pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/test.csv" )<create_dataframe> | pd.DataFrame({'Survived': y_pred}, index=testdf.index ).reset_index().to_csv('survived_new.csv', index=False ) | Titanic - Machine Learning from Disaster |
6,168,266 | test_df=test_df_copy.copy()<data_type_conversions> | train_x_all['Pred'] = train_y_pred
train_x_all['Survived'] = train_y | Titanic - Machine Learning from Disaster |
6,168,266 | cat_columns=test_df.select_dtypes(include=['O','object'] ).columns
for cols in cat_columns:
test_df[cols].fillna(test_df[cols].mode() [0],inplace=True )<define_variables> | pd.set_option('max_columns',100)
pd.set_option('max_rows',100 ) | Titanic - Machine Learning from Disaster |
6,168,266 | outlier_cols=test_df.skew().index[test_df.skew().values>1]<data_type_conversions> | train_x_all[train_x_all['Survived'] != train_x_all['Pred']].sort_values(by=['Survived'] ) | Titanic - Machine Learning from Disaster |
6,168,266 | num_columns=test_df.select_dtypes(exclude=['O','object'] ).columns
for cols in num_columns:
if cols in outlier_cols:
test_df[cols].fillna(test_df[cols].median() ,inplace=True)
else:
test_df[cols].fillna(test_df[cols].mean() ,inplace=True )<count_missing_values> | diff_nrow = len(train_x_all[train_x_all['Survived'] != train_x_all['Pred']])
diff_nrow
| Titanic - Machine Learning from Disaster |
3,744,105 | test_df.isnull().sum().index[test_df.isnull().sum().values>0]<drop_column> | train = pd.read_csv('.. /input/train.csv' , index_col = 'PassengerId')
label = train['Survived']
test = pd.read_csv('.. /input/test.csv', index_col = 'PassengerId')
index = test.index | Titanic - Machine Learning from Disaster |
3,744,105 | test_df.drop(["Id"],axis=1,inplace=True )<categorify> | train['Deck'] = train.Cabin.str.get(0)
test['Deck'] = test.Cabin.str.get(0)
train['Deck'] = train['Deck'].fillna('NOTAVL')
test['Deck'] = test['Deck'].fillna('NOTAVL')
train.Deck.replace('T' , 'G' , inplace = True)
train.drop('Cabin' , axis = 1 , inplace =True)
test.drop('Cabin' , axis = 1 , inplace =True ) | Titanic - Machine Learning from Disaster |
3,744,105 | test_num_transformed=qt.transform(test_df[num_train_columns] )<create_dataframe> | train.isna().sum() | Titanic - Machine Learning from Disaster |
3,744,105 | df_test_num_transformed=pd.DataFrame(test_num_transformed.reshape(-1,36),columns=test_df[num_train_columns].columns )<define_search_space> | test.isna().sum() | Titanic - Machine Learning from Disaster |
3,744,105 | outlier_cols=df_test_num_transformed.skew().index[df_test_num_transformed.skew().values>1]
for cols in outlier_cols:
df_test_num_transformed[cols]=winsorize(df_test_num_transformed[cols], limits=[0.05, 0.05] )<categorify> | train.loc[train.Embarked.isna() , 'Embarked'] = 'S' | Titanic - Machine Learning from Disaster |
3,744,105 | X_test_num_transformed=rs.transform(df_test_num_transformed )<create_dataframe> | age_to_fill = train.groupby(['Pclass' , 'Sex' , 'Embarked'])[['Age']].median()
age_to_fill | Titanic - Machine Learning from Disaster |
3,744,105 | X_test_num_transformed=pd.DataFrame(X_test_num_transformed.reshape(-1,36),columns=test_df[num_train_columns].columns )<concatenate> | for cl in range(1,4):
for sex in ['male' , 'female']:
for E in ['C' , 'Q' , 'S']:
filll = pd.to_numeric(age_to_fill.xs(cl ).xs(sex ).xs(E ).Age)
train.loc[(train.Age.isna() &(train.Pclass == cl)&(train.Sex == sex)
&(train.Embarked == E)) , 'Age'] =filll
test.loc[(test.Age.isna() &(test.Pclass == cl)&(test.Sex == sex)... | Titanic - Machine Learning from Disaster |
3,744,105 | test_transformed= pd.concat([X_test_num_transformed,test_df[cat_columns]],axis=1 )<prepare_x_and_y> | train.Ticket = pd.to_numeric(train.Ticket.str.split().str[-1] , errors='coerce')
test.Ticket = pd.to_numeric(test.Ticket.str.split().str[-1] , errors='coerce' ) | Titanic - Machine Learning from Disaster |
3,744,105 | X_test_catboost_reduced=test_transformed[embeded_cat_feature]<predict_on_test> | train.isna().sum() | Titanic - Machine Learning from Disaster |
3,744,105 | test_cat_predictions=tuned_cat.predict(X_test_catboost_reduced )<predict_on_test> | test.isna().sum() | Titanic - Machine Learning from Disaster |
3,744,105 | test_transformed_copy=test_transformed.copy()
for col in cat_columns:
test_transformed_copy[col] = test_transformed_copy[col].astype('category')
X_test_gbm_reduced=test_transformed_copy[embeded_gbm_feature]
test_gbm_predictions=tuned_gbm.predict(X_test_gbm_reduced)
<create_dataframe> | train['Status'] = train['Name'].str.split(',' ).str.get(1 ).str.split('.' ).str.get(0 ).str.strip()
test['Status'] = test['Name'].str.split(',' ).str.get(1 ).str.split('.' ).str.get(0 ).str.strip()
importan_person = ['Dr' , 'Rev' , 'Col' , 'Major' , 'Mlle' , 'Don' , 'Sir' , 'Ms' , 'Capt' , 'Lady' , 'Mme' , 'the Countes... | Titanic - Machine Learning from Disaster |
3,744,105 | pd.DataFrame(np.expm1(test_gbm_predictions))<define_variables> | test.drop(['Name' , 'Ticket' ] ,axis = 1, inplace = True)
train.drop(['Survived','Ticket' ,'Name' ], inplace =True , axis =1 ) | Titanic - Machine Learning from Disaster |
3,744,105 | final_predictions=(0.7*np.expm1(test_cat_predictions)) +(0.3*np.expm1(test_gbm_predictions))<prepare_output> | cat_col = ['Pclass' , 'Sex' , 'Embarked' , 'Status' , 'Deck']
train.Pclass.replace({
1 :'A' , 2:'B' , 3:'C'
} , inplace =True)
test.Pclass.replace({
1 :'A' , 2:'B' , 3:'C'
} , inplace =True)
train = pd.get_dummies(train , columns=cat_col)
test = pd.get_dummies(test , columns=cat_col)
print(train.shape , test.shape ... | Titanic - Machine Learning from Disaster |
3,744,105 | sub = pd.DataFrame()
sub['Id'] = test_df_copy['Id']
sub['SalePrice'] = final_predictions
sub.head()<save_to_csv> | scaler = MinMaxScaler()
train= scaler.fit_transform(train)
test = scaler.transform(test ) | Titanic - Machine Learning from Disaster |
3,744,105 | sub.to_csv('submission.csv',index=False )<load_from_csv> | model = RandomForestClassifier(bootstrap= True , min_samples_leaf= 3, n_estimators = 500 ,
min_samples_split = 10, max_features = "sqrt", max_depth= 6)
cross_val_score(model , train , label , cv=5 ) | Titanic - Machine Learning from Disaster |
3,744,105 | categorical = pd.read_csv("/kaggle/input/categorical-raw/full_features.csv")
features = pd.read_csv("/kaggle/input/housepriceregression-featurecreation/FeatureFilled.csv")
targets = pd.read_csv("/kaggle/input/housepriceregression-featurecreation/salePrice.csv")
with open("/kaggle/input/housepriceregression-featurecr... | model = LogisticRegression()
cross_val_score(model , train , label , cv=5 ) | Titanic - Machine Learning from Disaster |
3,744,105 | features_sub = features.drop(['Utilities', 'Street', 'PoolQC',], axis=1 )<feature_engineering> | model = SVC(C=4)
cross_val_score(model , train , label , cv=5 ) | Titanic - Machine Learning from Disaster |
3,744,105 | features_add = features.copy()
features_add['YrBltAndRemod']=features['YearBuilt']+features['YearRemodAdd']
features_add['TotalSF']=features['TotalBsmtSF'] + features['1stFlrSF'] + features['2ndFlrSF']
features_add['Total_sqr_footage'] =(features['BsmtFinSF1'] + features['BsmtFinSF2'] +
features['1stFlrSF'] + features[... | model.fit(train , label)
pre = model.predict(test ) | Titanic - Machine Learning from Disaster |
3,744,105 | features_add['haspool'] = features['PoolArea'].apply(lambda x: 1 if x > 0 else 0)
features_add['has2ndfloor'] = features['2ndFlrSF'].apply(lambda x: 1 if x > 0 else 0)
features_add['hasgarage'] = features['GarageArea'].apply(lambda x: 1 if x > 0 else 0)
features_add['hasbsmt'] = features['TotalBsmtSF'].apply(lambda ... | ans = pd.DataFrame({'PassengerId' : index , 'Survived': pre})
ans.to_csv('submit.csv', index = False)
ans.head() | Titanic - Machine Learning from Disaster |
10,999,930 | features_addsub = features_add.drop(['Utilities', 'Street', 'PoolQC',], axis=1)
features_addsub<feature_engineering> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
train_data.head() | Titanic - Machine Learning from Disaster |
10,999,930 | features_pure_log = features_addsub.apply(lambda x: np.log1p(x))
features_pure_log<prepare_x_and_y> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
10,999,930 | train = features_pure_log.iloc[:1460]
train1 = features_pure_log.iloc[:1460]<split> | train_data = pd.get_dummies(train_data, columns = ['Pclass', 'Sex', 'Embarked'])
train_data | Titanic - Machine Learning from Disaster |
10,999,930 | X_train, X_test, y_train, y_test = train_test_split(train1, target, test_size=0.5, random_state=21 )<import_modules> | y_train = train_data['Survived']
X_train = train_data.copy().drop(['Survived', 'Age', 'Name', 'PassengerId', 'SibSp', 'Parch', 'Ticket', 'Cabin'], axis=1)
X_train | Titanic - Machine Learning from Disaster |
10,999,930 | from sklearn.preprocessing import RobustScaler, StandardScaler, MinMaxScaler
from sklearn.linear_model import ElasticNetCV, LassoCV, RidgeCV
from sklearn.svm import SVR
from sklearn.ensemble import GradientBoostingRegressor, AdaBoostRegressor, StackingRegressor
from xgboost import XGBRegressor
from lightgbm import LGBM... | test_data = pd.read_csv('/kaggle/input/titanic/test.csv')
test_data = pd.get_dummies(test_data, columns = ['Pclass', 'Sex', 'Embarked'])
test_data | Titanic - Machine Learning from Disaster |
10,999,930 | def rmsle(estimator, x, y):
rmsle = np.sqrt(mean_squared_error(y, estimator.predict(x)))
print(f"RMSLE score : {rmsle}" )<choose_model_class> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
10,999,930 | kfolds = KFold(n_splits=10, shuffle=True, random_state=12 )<train_on_grid> | X_test = test_data.copy().drop(['Name', 'Age', 'PassengerId', 'SibSp', 'Parch', 'Ticket', 'Cabin'], axis=1)
X_test.fillna(X_test['Fare'].mean() , inplace=True)
X_test, X_test.isnull().sum() | Titanic - Machine Learning from Disaster |
10,999,930 | ridge = make_pipeline(RobustScaler() , RidgeCV(alphas=np.linspace(10, 200, 10),
scoring="neg_mean_squared_error", cv=kfolds))
ridge.fit(X_train, y_train)
rmsle(ridge, X_test, y_test )<train_on_grid> | logr = LogisticRegression().fit(X_train,y_train)
logr.predict(X_test)
logr.score(X_train, y_train ) | Titanic - Machine Learning from Disaster |
10,999,930 | lasso = make_pipeline(RobustScaler() , LassoCV(cv=kfolds, max_iter=1e7, random_state=23))
lasso.fit(X_train, y_train)
rmsle(lasso, X_test, y_test )<train_model> | dt = DecisionTreeClassifier().fit(X_train,y_train)
dt.predict(X_test)
dt.score(X_train, y_train), dt.feature_importances_ | Titanic - Machine Learning from Disaster |
10,999,930 | elastic = make_pipeline(RobustScaler() , ElasticNetCV(max_iter=1e7, cv=kfolds, random_state=32))
elastic.fit(X_train, y_train)
rmsle(elastic, X_test, y_test )<train_model> | rf = RandomForestClassifier().fit(X_train,y_train)
y_test = rf.predict(X_test)
rf.score(X_train, y_train), rf.feature_importances_ | Titanic - Machine Learning from Disaster |
10,999,930 | svr = make_pipeline(RobustScaler() , SVR(kernel='poly' , C=1., degree=1,
gamma='auto', epsilon=0.001))
svr.fit(X_train, y_train)
rmsle(svr, X_test, y_test )<train_model> | submission = pd.DataFrame({'PassengerId': np.arange(892, 892 + len(list(y_test))), 'Survived': list(y_test)})
submission.to_csv('my_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
484,210 | gbr = GradientBoostingRegressor(n_estimators=4000, learning_rate=0.01, max_depth=3,
subsample=0.9, max_features='sqrt' , random_state=21)
gbr.fit(X_train, y_train)
rmsle(gbr, X_test, y_test )<train_model> | titanic_train = pd.read_csv('.. /input/train.csv')
titanic_test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
484,210 | xgboost = XGBRegressor(n_estimators=4000, learning_rate=0.009, max_depth=4,
min_child_weight=2., colsample_bytree=0.8 , subsample=0.69,
gamma=0.01, reg_lambda=1.1, reg_alpha=0.001, random_state=21)
xgboost.fit(X_train, y_train)
rmsle(xgboost, X_test, y_test )<train_model> | print("Age broken down by P-class")
titanic_train.groupby('Pclass' ).mean() [['Age']] | Titanic - Machine Learning from Disaster |
484,210 | lgbm = LGBMRegressor(n_estimators=1000, learning_rate=0.04, num_leaves=8, max_depth=3,
colsample_bytree=0.1, objective='regression',
random_state=21)
lgbm.fit(X_train, y_train)
rmsle(lgbm, X_test, y_test )<define_variables> | titanic_train.loc[titanic_train.Age.isnull() , 'Age'] = titanic_train.groupby('Pclass')['Age'].transform('mean')
titanic_test.loc[titanic_test.Age.isnull() , 'Age'] = titanic_test.groupby('Pclass')['Age'].transform('mean' ) | Titanic - Machine Learning from Disaster |
484,210 | estimators = [ridge, lasso, elastic, svr, gbr, lgbm, xgboost]
names = ["RidgeCV", "LassoCV", "ElasticNetCV", "SVR", "GBoost", "LGBM", "XGBoost"]<train_model> | titanic_train = titanic_train.drop('Cabin', axis=1)
titanic_test = titanic_test.drop('Cabin', axis=1 ) | Titanic - Machine Learning from Disaster |
484,210 | dtr = DecisionTreeRegressor(max_depth=10, max_features='sqrt', min_samples_leaf=2)
ada = AdaBoostRegressor(xgboost, learning_rate=0.1, n_estimators=10, loss='exponential', random_state=11)
ada.fit(X_train, y_train)
rmsle(ada, X_test, y_test )<save_to_csv> | titanic_train['Embarked'].fillna(titanic_train['Embarked'].mode() [0], inplace=True)
titanic_test['Fare'].fillna(titanic_test['Fare'].median() , inplace = True ) | Titanic - Machine Learning from Disaster |
484,210 | features_pure_log.to_csv("FeaturesLog.csv")
target_log.to_csv("TargetLog.csv" )<train_model> | print('Training Data Null Values')
print(titanic_train.isnull().sum())
print("-" * 30)
print('Test Data Null Values')
print(titanic_test.isnull().sum() ) | Titanic - Machine Learning from Disaster |
484,210 | ridge.fit(train1, target)
lasso.fit(train1, target)
elastic.fit(train1, target)
svr.fit(train1, target)
gbr.fit(train1, target)
lgbm.fit(train1, target)
xgboost.fit(train1, target)
ada.fit(train1, target )<split> | titanic_train.groupby('Survived' ).mean() [['Fare']] | Titanic - Machine Learning from Disaster |
484,210 | test = features_pure_log.iloc[1460:]
test<predict_on_test> | titanic_train.loc[titanic_train['Fare'] > 500, :] | Titanic - Machine Learning from Disaster |
484,210 | def blend_models(X):
return(0.1 * ridge.predict(X)) +(0.1 * lasso.predict(X)) +(0.1 * elastic.predict(X)) +\
(0.05 * svr.predict(X)) +(0.15 * gbr.predict(X)) +(0.1 * lgbm.predict(X)) +\
(0.3 * xgboost.predict(X)) +(0.1 * ada.predict(X))
prediction = np.expm1(blend_models(test))
prediction<save_to_csv> | titanic_train.groupby(['Embarked'] ).count() | Titanic - Machine Learning from Disaster |
484,210 | submit = pd.DataFrame({"Id": np.arange(1461, 2920), "SalePrice": prediction})
submit.to_csv("submission12a.csv", index=False )<import_modules> | traindf = titanic_train.copy()
testdf = titanic_test.copy() | Titanic - Machine Learning from Disaster |
484,210 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.stats import skew
import lightgbm as lgb<load_from_csv> | all_data = [traindf, testdf]
| Titanic - Machine Learning from Disaster |
484,210 | submission = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/sample_submission.csv')
submission.head()<load_from_csv> | for dat in all_data:
dat.drop(['Name', 'Ticket'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
484,210 | train = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/train.csv')
train.head()<load_from_csv> | for dat in all_data:
dat['Fam_Size'] = dat['SibSp'] + dat['Parch'] | Titanic - Machine Learning from Disaster |
484,210 | test = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/test.csv')
test.head()<train_model> | traindf = pd.get_dummies(traindf)
traindf.head() | Titanic - Machine Learning from Disaster |
484,210 | print('=========== train infomation ===========')
train.info()
print('
=========== test infomation ===========')
test.info()<concatenate> | testdf = pd.get_dummies(testdf)
testdf.head() | Titanic - Machine Learning from Disaster |
484,210 | data = pd.concat([train, test])
data.shape<categorify> | from sklearn.metrics import confusion_matrix
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_t... | Titanic - Machine Learning from Disaster |
484,210 | cat_data = pd.get_dummies(data.loc[:, cat_cols], drop_first=True)
cat_data.head()<drop_column> | X = traindf.drop(columns=['PassengerId', 'Survived'], axis=1)
y = traindf['Survived']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30 ) | Titanic - Machine Learning from Disaster |
484,210 | num_data = data.loc[:,data.dtypes != 'object'].drop('Id', axis=1)
num_data.head()<concatenate> | results = pd.DataFrame(columns=['Validation'], index=['Logistic Regression', 'Support Vector Machine', 'KNN', 'Random Forest'] ) | Titanic - Machine Learning from Disaster |
484,210 | optimized_data = pd.concat([data['Id'], cat_data, log_num_data], axis=1)
optimized_data.head()<prepare_x_and_y> | def log_reg(X_train, X_test, y_train, y_test):
logmodel = LogisticRegression(C=.01)
logmodel.fit(X_train, y_train)
predictions = logmodel.predict(X_test)
print(accuracy_score(y_test, predictions))
return accuracy_score(y_test, predictions ) | Titanic - Machine Learning from Disaster |
484,210 | train = optimized_data[:train.shape[0]]
test = optimized_data[train.shape[0]:].drop(['Id', 'SalePrice'], axis=1)
X_train = train.drop(['Id', 'SalePrice'], axis=1)
y_train = train['SalePrice']<train_model> | LR_preds = log_reg(X_train, X_test, y_train, y_test)
results.loc['Logistic Regression', 'Validation'] = LR_preds | Titanic - Machine Learning from Disaster |
484,210 | lgb_train = lgb.Dataset(X_train, y_train)
params = {
'task' : 'train',
'boosting_type' : 'gbdt',
'objective' : 'regression',
'metric' : {'l2'},
'num_leaves' : 40,
'learning_rate' : 0.1,
'feature_fraction' : 0.9,
'bagging_fraction' : 0.8,
'bagging_freq': 5,
'verbose' : 0
}
gbm = lgb.train(params, lgb_train)
pred = gbm... | def svm(X_train, X_test, y_train, y_test):
c_vals = list(range(1, 100))
accuracy = [0 for i in range(99)]
for i, c in enumerate(c_vals):
svc_model = SVC(C=c)
svc_model.fit(X_train, y_train)
predictions = svc_model.predict(X_test)
accuracy[i] = accuracy_score(y_test, predictions)
print("Best C Value:", c_vals[accura... | Titanic - Machine Learning from Disaster |
484,210 | pred = np.expm1(pred)
results = pd.Series(pred, name='SalePrice')
submission = pd.concat([submission['Id'], results], axis=1)
submission.to_csv('submission.csv', index=False)
submission.head()<set_options> | svm_preds = svm(X_train, X_test, y_train, y_test)
results.loc['Support Vector Machine', 'Validation'] = svm_preds
results.head()
| Titanic - Machine Learning from Disaster |
484,210 | %matplotlib inline
plt.style.use('fivethirtyeight')
warnings.simplefilter('ignore')
print('Setup complete' )<load_from_csv> | def knn(X_train, X_test, y_train, y_test):
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
ks = [i + 1 for i in range(20)]
accuracy = [0 for i in range(20)]
for i, k in enumerate(ks):
knn = KNeighborsClassifier(n_neighbors = k)
knn.fit(X_train, y_t... | Titanic - Machine Learning from Disaster |
484,210 | train = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/train.csv')
test = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/test.csv')
train.head()<create_dataframe> | knn_preds = knn(X_train, X_test, y_train, y_test)
results.loc['KNN', 'Validation'] = knn_preds
results.head() | Titanic - Machine Learning from Disaster |
484,210 | num_features = [col for col in train.columns if train[col].dtype in ['int64', 'float64']]
num_features.remove('Id')
num_features.remove('SalePrice')
num_analysis = train[num_features].copy()
for col in num_features:
if num_analysis[col].isnull().sum() > 0:
num_analysis[col] = SimpleImputer(strategy='median' ).fit_tra... | from sklearn.decomposition import PCA | Titanic - Machine Learning from Disaster |
484,210 | <categorify><EOS> | scaler = StandardScaler()
scaler.fit(X)
test_feats = testdf.drop('PassengerId', axis=1)
X = scaler.transform(X)
test_feats = scaler.transform(test_feats)
pca = PCA(n_components = 4)
pca.fit(X)
x_train_pca = pca.transform(X)
x_test_pca = pca.transform(test_feats)
svc_model = SVC(C = 1)
svc_model.fit(x_train_pca... | Titanic - Machine Learning from Disaster |
2,053,254 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | print(os.listdir(".. /input"))
sns.set(style="ticks")
pd.options.display.max_rows = 200
train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
train_copy = train.copy()
print(train.info())
print(train.isnull().sum() ) | Titanic - Machine Learning from Disaster |
2,053,254 | cat_features = [col for col in train.columns if train[col].dtype =='object']
cat_features = cat_features + ['MSSubClass','MoSold','YrSold']
num_features = [col for col in train.columns if train[col].dtype in ['int64', 'float64'] and col not in cat_features]
num_features.remove('Id')
num_features.remove('SalePrice')
t... | 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',fill_value='Missing')... | Titanic - Machine Learning from Disaster |
2,053,254 | cols_to_keep = list(feature_imp.sort_values(by='Value', ascending=False ).reset_index(drop=True ).loc[:59, 'Feature'])
print('Keeping the first {:d} most informative features'.format(len(cols_to_keep)) )<train_model> | clf = Pipeline(steps=[('preprocessor', preprocessor),
('classifier', RandomForestClassifier())])
X=train.drop(columns=['Survived'])
y=train['Survived']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=0)
clf.fit(X_train, y_train)
print("model score: %.3f" % clf.score(X_test, y_... | Titanic - Machine Learning from Disaster |
2,053,254 | outliers_id = set(train.loc[train.GrLivArea > 4500, 'Id'])
print('Outliers saved in outliers_id' )<categorify> | afeatures = ['Age', 'Fare'] + list(clf['preprocessor'].transformers_[1][1]['ohe'].get_feature_names(categorical_features))
| Titanic - Machine Learning from Disaster |
2,053,254 | X_train = train.loc[~train.Id.isin(outliers_id), cols_to_keep].reset_index(drop=True)
X_test = test[cols_to_keep]
cat_cols = [col for col in cols_to_keep if col in cat_features]
num_cols = [col for col in cols_to_keep if col not in cat_features]
lasso_preprocessor = ColumnTransformer(transformers=[
('num', PowerTrans... | afeatures = ['Age', 'Fare','Embarked', 'Sex', 'Pclass'] | Titanic - Machine Learning from Disaster |
2,053,254 | oof_lasso = np.zeros(len(X_train))
preds_lasso = np.zeros(len(X_test))
out_preds_lasso = np.zeros(2)
kf = KFold(n_splits=5, random_state=42, shuffle=True)
print('Training {:d} Lasso models...
'.format(kf.n_splits))
for i,(idxT, idxV)in enumerate(kf.split(X_train, y_train)) :
print('Fold', i)
print(' rows of train =... | train['Cabin'].fillna('0' ).str[:1].value_counts() | Titanic - Machine Learning from Disaster |
2,053,254 | lasso_submission = np.exp(preds_lasso)
lasso_submission[1089] = train.loc[train.GrLivArea>4500, 'SalePrice'].mean()<categorify> | train['modCabin'] = train['Cabin'].fillna('0' ).str[:1]
test['modCabin'] = train['Cabin'].fillna('0' ).str[:1] | Titanic - Machine Learning from Disaster |
2,053,254 | tree_preprocessor = ColumnTransformer(transformers=[
('num', 'passthrough', num_cols),
('cat', TargetEncoder(cols=cat_cols), cat_cols)
] )<split> | train['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
2,053,254 | oof_LGBM = np.zeros(len(X_train))
preds_LGBM = np.zeros(len(X_test))
out_preds_LGBM = np.zeros(2)
kf = KFold(n_splits=5, random_state=42, shuffle=True)
print('Training {:d} LGBM models...
'.format(kf.n_splits))
for i,(idxT, idxV)in enumerate(kf.split(X_train, y_train)) :
print('Fold', i)
print(' rows of train =', l... | train.groupby(['Survived'])['modCabin'].value_counts() | Titanic - Machine Learning from Disaster |
2,053,254 | LGBM_submission = np.exp(preds_LGBM)
LGBM_submission[1089] = train.loc[train.GrLivArea>4500, 'SalePrice'].mean()<save_to_csv> | train.groupby(['Survived'])['modCabin'].value_counts(normalize=True ) | Titanic - Machine Learning from Disaster |
2,053,254 | kaggle_sub = best_weight*lasso_submission +(1-best_weight)*LGBM_submission
output = pd.DataFrame({'Id': test.Id, 'SalePrice': kaggle_sub})
output.to_csv('my_submission.csv', index=False)
print('Your submission was successfully saved!' )<set_options> | vec = DictVectorizer(sparse=False, dtype=int)
res = vec.fit_transform(train[['modCabin', 'Pclass', 'Age', 'SibSp', 'Parch','Embarked', 'Sex']].fillna('NA' ).to_dict(orient='records'))
res | Titanic - Machine Learning from Disaster |
2,053,254 | %matplotlib inline
color = sns.color_palette()
sns.set_style("darkgrid")
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
pd.set_option(
"display.float_format", lambda x: f"{x:.3f}"
)
print(
check_output(["ls", ".. /input"] ).decode("utf8")
)<load_from_csv> | df = pd.DataFrame(res, columns=vec.get_feature_names())
df.head() | Titanic - Machine Learning from Disaster |
2,053,254 | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" )<prepare_x_and_y> | corr_df = df.corr().abs().unstack().sort_values(ascending=False)
corr_df[corr_df<1].drop_duplicates() [:10] | Titanic - Machine Learning from Disaster |
2,053,254 | ntrain = train.shape[0]
ntest = test.shape[0]
y_train = train.SalePrice.values
all_data = pd.concat(( train, test)).reset_index(drop=True)
all_data.drop(["SalePrice"], axis=1, inplace=True)
print(f"all_data size is : {all_data.shape}" )<create_dataframe> | gbes = ensemble.GradientBoostingClassifier(n_estimators=400,
validation_fraction=0.2,
n_iter_no_change=5, tol=0.01,
random_state=0)
X_train, X_test, y_train, y_test = train_test_split(train.Age, train.Survived, test_size=0.2,
random_state=0)
gbes.fit(X_train.fillna(0 ).values.reshape(-1, 1),y_train)
gbes.score(X_tes... | 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
)[:30]
missing_data = pd.DataFrame({"Missing Ratio": all_data_na})
missing_data.head(20 )<data_type_conversions> | from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["PoolQC"] = all_data["PoolQC"].fillna("None" )<data_type_conversions> | X_train, X_test, y_train, y_test = train_test_split(df, train.Survived, test_size=0.2,
random_state=0)
gbes.fit(X_train,y_train)
gbes.score(X_test,y_test ) | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["MiscFeature"] = all_data["MiscFeature"].fillna("None" )<data_type_conversions> | print(cross_val_score(gbes, df, train.Survived, cv=3)) | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["Alley"] = all_data["Alley"].fillna("None" )<data_type_conversions> | test_transf = vec.transform(test[['modCabin', 'Pclass', 'Age', 'SibSp', 'Parch','Embarked', 'Sex']].fillna('NA' ).to_dict(orient='records'))
df_test = pd.DataFrame(test_transf, columns=vec.get_feature_names())
df_test.head() | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["Fence"] = all_data["Fence"].fillna("None" )<data_type_conversions> | gbespred = gbes.predict(df_test)
out_df = pd.DataFrame({"PassengerId":test["PassengerId"].values})
out_df['Survived'] = gbespred
out_df.to_csv("submission.csv", index=False)
print('out_df.to_csv')
print(out_df.head())
out_df.Survived.value_counts() | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["FireplaceQu"] = all_data["FireplaceQu"].fillna("None" )<categorify> | preprocessing.KBinsDiscretizer(n_bins=[2,2,2,2], encode='ordinal' ).fit_transform(train.loc[:,['Age','Fare','SibSp','Parch']].dropna() ) | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["LotFrontage"] = all_data.groupby("Neighborhood")["LotFrontage"].transform(
lambda x: x.fillna(x.median())
)<data_type_conversions> | train.Embarked.value_counts() | Titanic - Machine Learning from Disaster |
2,053,254 | for col in("GarageType", "GarageFinish", "GarageQual", "GarageCond"):
all_data[col] = all_data[col].fillna("None" )<data_type_conversions> | train.loc[train.Embarked.isnull() ,'Embarked']='Q' | Titanic - Machine Learning from Disaster |
2,053,254 | for col in("GarageYrBlt", "GarageArea", "GarageCars"):
all_data[col] = all_data[col].fillna(0 )<data_type_conversions> | train['IsCabinNull'] = train.Cabin.isnull().astype(int)
test['IsCabinNull'] = test.Cabin.isnull().astype(int ) | Titanic - Machine Learning from Disaster |
2,053,254 | for col in(
"BsmtFinSF1",
"BsmtFinSF2",
"BsmtUnfSF",
"TotalBsmtSF",
"BsmtFullBath",
"BsmtHalfBath",
):
all_data[col] = all_data[col].fillna(0 )<data_type_conversions> | train.loc[train.Age.isnull() , 'Age'] = 28
test.loc[test.Age.isnull() , 'Age'] = 28 | Titanic - Machine Learning from Disaster |
2,053,254 | for col in("BsmtQual", "BsmtCond", "BsmtExposure", "BsmtFinType1", "BsmtFinType2"):
all_data[col] = all_data[col].fillna("None" )<data_type_conversions> | train.loc[(train.Fare==0), 'Fare'] = train.Fare.median()
test.loc[(test.Fare==0), 'Fare'] = test.Fare.median()
test.loc[(test.Fare.isnull()), 'Fare'] = test.Fare.median() | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["MasVnrType"] = all_data["MasVnrType"].fillna("None")
all_data["MasVnrArea"] = all_data["MasVnrArea"].fillna(0 )<data_type_conversions> | train['age_log'] = np.log(train['Age'])
test['age_log'] = np.log(test['Age'])
train['fare_log'] = np.log(train['Fare'])
test['fare_log'] = np.log(test['Fare'] ) | Titanic - Machine Learning from Disaster |
2,053,254 | all_data["MSZoning"] = all_data["MSZoning"].fillna(all_data["MSZoning"].mode() [0] )<drop_column> | scaler = StandardScaler()
scaler.fit(train[['Age']])
train['age_scale'] = scaler.transform(train[['Age']])
test['age_scale'] = scaler.transform(test[['Age']])
scaler = StandardScaler()
scaler.fit(train[['Fare']])
train['fare_scale'] = scaler.transform(train[['Fare']])
test['fare_scale'] = scaler.transform(test[['F... | 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.