kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
5,636,558 | def feature_engineering(df):
temporal_features = [feature for feature in df.columns if 'Yr' in feature or 'Year' in feature or 'Mo' in feature]
numeric_features = [feature for feature in df.columns if df[feature].dtype != 'O' and feature not in temporal_features and feature not in("Id", "kfold","SalePrice")]
categorica... | empt_models = [GradientBoostingClassifier() , LogisticRegression(solver='lbfgs'), SGDClassifier() , GaussianNB() ,
KNeighborsClassifier() , DecisionTreeClassifier() , RandomForestClassifier(n_estimators=100),
SVC(gamma='auto')]
for model in empt_models:
results = cross_val_predict(model, X, y, cv=5)
print("model: {}, ... | Titanic - Machine Learning from Disaster |
5,636,558 | def run(fold,model):
df = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/train.csv')
df_test = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/test.csv')
df["kfold"] = -1
kf = model_selection.StratifiedKFold(n_splits=4, shuffle=True, random_state=42)
for f,(train_idx, v... | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
5,636,558 | preds_df = pd.DataFrame()
for fold in range(3):
for keys,items in MODELS.items() :
preds_df["fold"+str(fold)+keys] = run(fold,keys)
<load_from_csv> | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
5,636,558 | def run(fold,model):
df = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/train.csv')
df_test = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/test.csv')
df["kfold"] = -1
kf = model_selection.StratifiedKFold(n_splits=4, shuffle=True, random_state=42)
for f,(train_idx, v... | params = [{'kernel':['linear'], 'gamma':[i / 10 for i in range(1, 100, 5)], 'C':[i / 10 for i in range(5, 30, 5)]},
{'kernel':['rbf'], 'C':[i / 10 for i in range(5, 30, 5)]},
{'kernel':['poly'], 'degree':np.arange(2, 10), 'C':[i / 10 for i in range(5, 30, 5)]}]
grid_search_svc = GridSearchCV(SVC(gamma='auto'), params, ... | Titanic - Machine Learning from Disaster |
5,636,558 | for cols in preds_df.columns:
preds_df[cols] = np.expm1(preds_df[cols])
<feature_engineering> | svc_model = SVC(gamma='auto', **grid_search_svc.best_params_)
svc_score = cross_val_predict(svc_model, X, y, cv=5)
f1_score(y, svc_score ) | Titanic - Machine Learning from Disaster |
5,636,558 | for e,col in enumerate(preds_df.columns):
if e == 0:
preds_df['SalePrice'] = preds_df[col]
elif col in ['fold0stack','fold1stack','fold2stack']:
preds_df['SalePrice'] += preds_df[col]*4
else:
preds_df['SalePrice'] += preds_df[col]
<feature_engineering> | params = {'learning_rate':[i/10 for i in range(3, 6)], 'n_estimators':np.arange(128, 132, 1),
'min_samples_split':np.arange(2, 3), 'min_samples_leaf':np.arange(6, 8),
'max_depth':np.arange(1, 3), 'max_features':np.arange(1, 8)}
grid_search_gbc = GridSearchCV(GradientBoostingClassifier() , params, cv=5, scoring='neg_mea... | Titanic - Machine Learning from Disaster |
5,636,558 | preds_df['SalePrice'] = preds_df['SalePrice']/30<load_from_csv> | gbc_model = GradientBoostingClassifier(**grid_search_gbc.best_params_)
gbc_score = cross_val_predict(gbc_model, X, y, cv=5)
f1_score(y, gbc_score ) | Titanic - Machine Learning from Disaster |
5,636,558 | df_test = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/test.csv',usecols=["Id"] )<concatenate> | params = {'n_neighbors':np.arange(10, 25), 'p':np.arange(1, 6)}
grid_search_knn = GridSearchCV(KNeighborsClassifier() , params, cv=5, scoring='neg_mean_squared_error')
grid_search_knn.fit(X, y)
grid_search_knn.best_params_ | Titanic - Machine Learning from Disaster |
5,636,558 | preds_df["id"] = df_test.values.flatten()<prepare_output> | knn_model = KNeighborsClassifier(**grid_search_knn.best_params_)
knn_score = cross_val_predict(knn_model, X, y, cv=5)
f1_score(y, knn_score ) | Titanic - Machine Learning from Disaster |
5,636,558 | submission = preds_df[['id','SalePrice']]<save_to_csv> | params = {'n_estimators':np.arange(50, 1000, 100), 'max_depth':np.arange(3, 8)}
grid_search_rfc = GridSearchCV(RandomForestClassifier(random_state=42), params, cv=5, scoring='neg_mean_squared_error')
grid_search_rfc.fit(X, y)
grid_search_rfc.best_params_ | Titanic - Machine Learning from Disaster |
5,636,558 | submission.to_csv(".. /.. /kaggle/working/submission.csv", index=False )<set_options> | rfc_model = RandomForestClassifier(random_state=42,**grid_search_rfc.best_params_)
rfc_score = cross_val_predict(rfc_model, X, y, cv=5)
f1_score(y, rfc_score ) | Titanic - Machine Learning from Disaster |
5,636,558 | warnings.simplefilter(action='ignore', category=FutureWarning)
warnings.simplefilter("ignore", category=ConvergenceWarning)
pd.pandas.set_option('display.max_columns', None)
pd.set_option('display.float_format', lambda x: '%.3f' % x )<load_from_csv> | X_test = prepare_pipeline.fit_transform(test_data ) | Titanic - Machine Learning from Disaster |
5,636,558 | def data() :
train_ = pd.read_csv(".. /input/house-prices-advanced-regression-techniques/train.csv")
test_ = pd.read_csv(".. /input/house-prices-advanced-regression-techniques/test.csv")
dataframe = pd.concat([train_, test_], ignore_index=True)
return dataframe, train_, test_
df, train, test = data()
df.head()<count... | svc_model.fit(X, y)
predictions = svc_model.predict(X_test ) | Titanic - Machine Learning from Disaster |
5,636,558 | <groupby><EOS> | my_submission = pd.DataFrame({'PassengerId': test_data.index.values, 'Survived': predictions})
my_submission.to_csv('submission.csv', index=False)
| Titanic - Machine Learning from Disaster |
551,980 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<count_values> | %matplotlib inline
plt.style.use('ggplot' ) | Titanic - Machine Learning from Disaster |
551,980 | for col in ['Neighborhood', 'Exterior1st', 'Exterior2nd']:
print(df[col].value_counts() )<create_dataframe> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
551,980 | def find_correlation(dataframe, corr_limit=0.60):
high_correlations = []
low_correlations = []
for col in num_cols:
if col == "SalePrice":
pass
else:
correlation = dataframe[[col, "SalePrice"]].corr().loc[col, "SalePrice"]
print(col, correlation)
if abs(correlation)> corr_limit:
high_correlations.append(col + ": " + s... | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
551,980 | def rare_analyser(dataframe, target, rare_perc):
rare_columns = [col for col in df.columns if len(df[col].value_counts())<= 20
and(df[col].value_counts() / len(df)< rare_perc ).any(axis=None)]
for var in rare_columns:
print(var, ":", len(dataframe[var].value_counts()))
print(pd.DataFrame({"COUNT": dataframe[var].value_... | train.drop(['PassengerId'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
551,980 | drop_list = ["Street", "Utilities", "LandSlope", "PoolQC", "MiscFeature"]
cat_cols = [col for col in df.columns if df[col].dtypes == 'O'
and col not in drop_list]
for col in drop_list:
df.drop(col, axis=1, inplace=True)
rare_analyser(df, "SalePrice", 0.01 )<categorify> | pd.isnull(train ).sum() | Titanic - Machine Learning from Disaster |
551,980 | def one_hot_encoder(dataframe, categorical_cols, nan_as_category=True):
original_columns = list(dataframe.columns)
dataframe = pd.get_dummies(dataframe, columns=categorical_cols, dummy_na=nan_as_category, drop_first=True)
new_columns = [c for c in dataframe.columns if c not in original_columns]
return dataframe, new_... | pd.isnull(test ).sum() | Titanic - Machine Learning from Disaster |
551,980 | def missing_values_table(dataframe):
variables_with_na = [col for col in dataframe.columns if dataframe[col].isnull().sum() > 0]
n_miss = dataframe[variables_with_na].isnull().sum().sort_values(ascending=False)
ratio =(dataframe[variables_with_na].isnull().sum() / dataframe.shape[0] * 100 ).sort_values(ascending=False... | for i in train.select_dtypes(include=['object']):
print('Column ',i,' has ',train[i].nunique() ,' unique values' ) | Titanic - Machine Learning from Disaster |
551,980 | df = df.apply(lambda x: x.fillna(x.median()), axis=0)
missing_values_table(df )<create_dataframe> | for i in test.select_dtypes(include=['object']):
print('Column ',i,' has ',test[i].nunique() ,' unique values' ) | Titanic - Machine Learning from Disaster |
551,980 | def outlier_thresholds(dataframe, variable):
quartile1 = dataframe[variable].quantile(0.05)
quartile3 = dataframe[variable].quantile(0.95)
interquantile_range = quartile3 - quartile1
up_limit = quartile3 + 1.5 * interquantile_range
low_limit = quartile1 - 1.5 * interquantile_range
return low_limit, up_limit
def has_o... | target = train.Survived
train_df = train.drop('Survived',axis=1)
test_df = test.drop('PassengerId',axis=1)
train_df['is_train'] = 1
test_df['is_train'] = 0
train_test = pd.concat([train_df,test_df],axis=0 ) | Titanic - Machine Learning from Disaster |
551,980 | def replace_with_thresholds(dataframe, variable):
low_limit, up_limit = outlier_thresholds(dataframe, variable)
dataframe.loc[(dataframe[variable] < low_limit), variable] = low_limit
dataframe.loc[(dataframe[variable] > up_limit), variable] = up_limit
for col in num_cols:
replace_with_thresholds(df, col)
has_outliers... | train['Initial']=0
for i in train:
train['Initial']=train.Name.str.extract('([A-Za-z]+)\.')
pd.crosstab(train.Initial,train.Sex ).T.style.background_gradient(cmap='summer_r' ) | Titanic - Machine Learning from Disaster |
551,980 | df['TotalSF'] = df['TotalBsmtSF'] + df['1stFlrSF'] + df['2ndFlrSF']
df["OverallGrade"] = df["OverallQual"] * df["OverallCond"]
df['haspool'] = df['PoolArea'].apply(lambda x: 1 if x > 0 else 0)
df['has2ndfloor'] = df['2ndFlrSF'].apply(lambda x: 1 if x > 0 else 0)
df.loc[df["OverallQual"] < 2, "OverallQual"] = 2
df.loc... | train_test['Initial'].replace(['Capt','Col','Countess','Don','Dona','Dr','Jonkheer','Lady','Major','Master','Mlle','Mme','Ms','Rev','Sir'],
['Special_male','Other_male','Special','Special_male','Special_female','Other','Special_male','Special','Special_male','Other_male','Special','Special','Special','Other_male','Spec... | Titanic - Machine Learning from Disaster |
551,980 | missing_values_table(df)
has_outliers(df, num_cols )<find_best_model_class> | train_test.groupby(['Initial','Pclass'])['Age'].aggregate(['mean','count'] ) | Titanic - Machine Learning from Disaster |
551,980 | train_df = df[df['SalePrice'].notnull() ]
test_df = df[df['SalePrice'].isnull() ]
X = train_df.drop('SalePrice', axis=1)
y = train_df[["SalePrice"]]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=46)
models = [('LinearRegression', LinearRegression()),
('Ridge', Ridge()),
('La... | train_test.loc[(train_test.Age.isnull())]['Initial'].value_counts() | Titanic - Machine Learning from Disaster |
551,980 | X = df.loc[:1459, :].drop(["SalePrice", "Id"], axis=1)
y = df.loc[:1459, "SalePrice"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=46)
catboost_model = CatBoostRegressor()
catboost_model = catboost_model.fit(X_train, y_train)
y_pred = catboost_model.predict(X_test)
print(np... | train_test.loc[(train_test.Age.isnull())]['Pclass'].value_counts() | Titanic - Machine Learning from Disaster |
551,980 | pip install shap<import_modules> | train_test.loc[(train_test.Age.isnull())].groupby(['Initial','Pclass'])['Name'].aggregate('count' ) | Titanic - Machine Learning from Disaster |
551,980 | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
<load_from_csv> | imp = Imputer(missing_values='NaN', strategy='mean', axis=0)
temp_train_test = pd.get_dummies(train_test[['Initial','Pclass','Age']])
train_test_age_filled = imp.fit_transform(temp_train_test ) | Titanic - Machine Learning from Disaster |
551,980 | data_train = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/train.csv')
data_test = pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/test.csv")
data_test = data_test.drop(['Id'],1)
data = data_train.append(data_test)
data = data.drop(['SalePrice'],1)
data = data.drop([... | train_test_age_filled = pd.DataFrame(train_test_age_filled,columns=temp_train_test.columns.tolist() ) | Titanic - Machine Learning from Disaster |
551,980 | print("p-value for shapiro-wilk test is ",shapiro(target)[1] )<compute_test_metric> | train_test.Age = train_test_age_filled.Age | Titanic - Machine Learning from Disaster |
551,980 | corr_cols = ['OverallQual', 'GrLivArea', 'GarageCars', 'TotalBsmtSF',
'FullBath', 'YearBuilt']
print("Correlations")
for i in corr_cols:
print(i,"and target",np.corrcoef(target,data_train[i])[0][1])
<sort_values> | train_test[np.isnan(train_test['Fare'])] | Titanic - Machine Learning from Disaster |
551,980 | nas_ratio = data.isnull().sum() / data.shape[0] * 100
nas_ratio = nas_ratio.drop(nas_ratio[nas_ratio==0].index ).sort_values(ascending=False)
nas_ratio<data_type_conversions> | train_test.groupby(['Pclass','Parch','SibSp'])['Fare'].mean() | Titanic - Machine Learning from Disaster |
551,980 | data["PoolQC"] = data["PoolQC"].fillna("None")
data["MiscFeature"] = data["MiscFeature"].fillna("None")
data["Alley"] = data["Alley"].fillna("None")
data["Fence"] = data["Fence"].fillna("None")
data["FireplaceQu"] = data["FireplaceQu"].fillna("None")
for col in('GarageType', 'GarageFinish', 'GarageQual', 'GarageCo... | train_test.loc[(train_test.Fare.isnull()),'Fare']=9 | Titanic - Machine Learning from Disaster |
551,980 | print(data.skew().sort_values(ascending=False ).head(10))
data["LotArea"], _ = stats.boxcox(data["LotArea"].values)
print("skew after:",data["LotArea"].skew() )<data_type_conversions> | train_test.loc[train_test.Embarked.isnull() ] | Titanic - Machine Learning from Disaster |
551,980 | to_std = ['LotFrontage', 'LotArea',
'YearBuilt','YearRemodAdd',
'MasVnrArea','BsmtFinSF1','BsmtFinSF2','BsmtUnfSF','TotalBsmtSF',
'1stFlrSF','BsmtFullBath','GarageYrBlt','GarageArea',
'WoodDeckSF','MoSold','YrSold','TotalSF']
for i in range(len(to_std)) :
data[to_std[i]] = data[to_std[i]].astype("float64" )<normalizati... | train_test.groupby(['Embarked','Pclass'])['Fare'].mean() | Titanic - Machine Learning from Disaster |
551,980 | for c in to_std:
std = StandardScaler()
std.fit(list(np.array(data[c] ).reshape(-1,1)))
data[c] = std.transform(list(np.array(data[c] ).reshape(-1,1)) )<categorify> | train_test["Embarked"] = train_test["Embarked"].fillna("S" ) | Titanic - Machine Learning from Disaster |
551,980 | data = pd.get_dummies(data )<prepare_x_and_y> | train_temp = pd.get_dummies(train['Cabin'])
res = dict(zip(train_temp.columns.tolist() ,
mutual_info_classif(train_temp, train['Survived'], discrete_features=True)
))
print(res ) | Titanic - Machine Learning from Disaster |
551,980 | X = data[:1460].values
y = data_train.SalePrice.values<split> | train_test.drop('Cabin',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
551,980 | test = data[1460:]<compute_train_metric> | train_df = train_test[train_test.is_train == 1] | Titanic - Machine Learning from Disaster |
551,980 | n_folds = 5
def rmsle_cv(model):
kf = KFold(n_folds, shuffle=True ).get_n_splits(X)
rmse= np.sqrt(-cross_val_score(model, X, y, scoring="neg_mean_squared_error", cv = kf))
return(rmse.mean())
<compute_train_metric> | train_df.drop(['is_train'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
551,980 | model_xgb = xgb.XGBRegressor(colsample_bytree=0.46, gamma=0.047,
learning_rate=0.05, max_depth=3,
min_child_weight=1.785, n_estimators=2200,
reg_alpha=0.465, reg_lambda=0.86,
subsample=0.522)
print("xgb: ",rmsle_cv(model_xgb))<choose_model_class> | train_df['Survived'] = train['Survived'] | Titanic - Machine Learning from Disaster |
551,980 | model_lgb = lgb.LGBMRegressor(objective='regression',num_leaves=5,
learning_rate=0.05, n_estimators=720,
max_bin = 55, bagging_fraction = 0.82,
bagging_freq = 5, feature_fraction = 0.232,
feature_fraction_seed=9, bagging_seed=9,
min_data_in_leaf =6, min_sum_hessian_in_leaf = 11)
print("lgb:",rmsle_cv(model_lgb))<compu... | train_df['Name_len'] = train_df.Name.apply(lambda x: len(x)) | Titanic - Machine Learning from Disaster |
551,980 | cat_boost = CatBoostRegressor(learning_rate=0.05,
n_estimators=800,depth=3,silent=True)
print("catboost: ",rmsle_cv(cat_boost))<compute_test_metric> | train_df['FamilySize'] = train_df['SibSp'] + train_df['Parch'] | Titanic - Machine Learning from Disaster |
551,980 | Enet = ElasticNet(alpha=0.005,
l1_ratio=0.85,max_iter=15000)
print("enet: ", rmsle_cv(Enet))<predict_on_test> | train_df.loc[(train_df['Pclass']==2)&(train_df['Fare'] == 0)] | Titanic - Machine Learning from Disaster |
551,980 | 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 mo... | train_test['Last_Name'] = train_test.Name.apply(lambda x: x.split('(')[0].split('"')[0].split(' ')[-1] ) | Titanic - Machine Learning from Disaster |
551,980 | models_forAverage = AveragingModels(models=(cat_boost,model_xgb,model_lgb))
print(rmsle_cv(models_forAverage))<train_model> | train_test['NameLen'] = train_test.Name.apply(lambda x : len(x)) | Titanic - Machine Learning from Disaster |
551,980 | cat_bst = CatBoostRegressor(iterations=1000,learning_rate=0.1,silent=True)
cat_bst.fit(X,y )<compute_test_metric> | train_test['Sex'] = train_test['Sex'].map({'female': 1, 'male': 0} ).astype(int ) | Titanic - Machine Learning from Disaster |
551,980 | feature_interactions = cat_bst.get_feature_importance(catboost.Pool(X,y),type="Interaction" )<define_variables> | train_test['FamilySize'] = train_test['Parch'] + train_test['SibSp'] | Titanic - Machine Learning from Disaster |
551,980 | fi_new = []
for k, item in enumerate(feature_interactions):
first = data.dtypes.index[feature_interactions[k][0]]
second = data.dtypes.index[feature_interactions[k][1]]
if first != second:
fi_new.append([first+ " " + second, feature_interactions[k][2]] )<create_dataframe> | train_test['Alone']=0
train_test.loc[(train_test.FamilySize==0),'Alone']=1 | Titanic - Machine Learning from Disaster |
551,980 | interaction_score = pd.DataFrame(fi_new,columns=['Feature-Pair','Interaction Score'])
interaction_score = interaction_score.sort_values(by="Interaction Score",ascending=False,
inplace=False,na_position='last' )<choose_model_class> | train_test['Small_Family']=0
train_test.loc[(train_test.FamilySize<=3)&(train_test.FamilySize!=0),'Small_Family']=1 | Titanic - Machine Learning from Disaster |
551,980 | extended_catboost = CatBoostRegressor(per_float_feature_quantization=['3:border_count=1024', '33:border_count=1024'],
depth=8,
learning_rate=0.025,
n_estimators=2000,silent=True)
print(rmsle_cv(extended_catboost))<compute_train_metric> | train_test['Big_Family']=0
train_test.loc[(train_test.FamilySize>=4),'Big_Family']=1 | Titanic - Machine Learning from Disaster |
551,980 | models_forAverage2 = AveragingModels(models=(extended_catboost,model_xgb))
print(rmsle_cv(models_forAverage2))<load_from_csv> | train_test.drop(['Name','SibSp','Parch','Ticket','FamilySize'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
551,980 | data_test = pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/test.csv")
IDS = data_test['Id']<train_model> | train_test = pd.get_dummies(train_test ) | Titanic - Machine Learning from Disaster |
551,980 | model_xgb2 = xgb.XGBRegressor(colsample_bytree=0.46, gamma=0.047,
learning_rate=0.05, max_depth=3,
min_child_weight=1.785, n_estimators=2200,
reg_alpha=0.465, reg_lambda=0.86,
subsample=0.522)
model_xgb2.fit(data[:1460],y)
extended_catboost2 = CatBoostRegressor(per_float_feature_quantization=['3:border_count=1024', '... | train = train_test[train_test.is_train == 1].drop(['is_train'],axis=1)
test = train_test[train_test.is_train == 0].drop(['is_train'],axis=1 ) | Titanic - Machine Learning from Disaster |
551,980 | sub = pd.DataFrame()
sub['Id'] = IDS
sub['SalePrice'] =(model_xgb2.predict(data[1460:])*0.5)+(extended_catboost2.predict(data[1460:])*0.5)
sub.to_csv('submission.csv',index=False )<set_options> | from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn import svm
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import LinearSVC
from sklearn import metrics
from sklearn.model_selection import ... | Titanic - Machine Learning from Disaster |
551,980 | %matplotlib inline
<load_from_csv> | X_train, X_test, Y_train, Y_test=train_test_split(train,train_df['Survived'],test_size=0.33,random_state=3 ) | Titanic - Machine Learning from Disaster |
551,980 | df_train=pd.read_csv('.. /input/house-prices-advanced-regression-techniques/train.csv')
df_test=pd.read_csv('.. /input/house-prices-advanced-regression-techniques/test.csv' )<concatenate> | model = LogisticRegression(random_state=51)
model.fit(X_train, Y_train)
prediction=model.predict(X_test)
print('Accuracy for rbf LogisticRegression is ',np.mean(cross_val_score(model, train, train_df['Survived'], cv=3)) ) | Titanic - Machine Learning from Disaster |
551,980 | df=pd.concat([df_train,df_test] ).reset_index(drop=True)
df<sort_values> | model = RandomForestClassifier(n_estimators=30,random_state=51)
model.fit(X_train, Y_train)
prediction=model.predict(X_test)
print('Accuracy for rbf RandomForestClassifier is ',np.mean(cross_val_score(model, train, train_df['Survived'], cv=3)) ) | Titanic - Machine Learning from Disaster |
551,980 | total=(df.isnull().sum() ).sort_values(ascending=False)
percentage=(( df.isnull().sum() /df.isnull().count())*100 ).sort_values(ascending=False)
missing_values=pd.concat([total,percentage],keys=['total','percentage'],axis=1)
missing_values.head(40 )<data_type_conversions> | model=svm.SVC(kernel='linear',C=0.1,gamma=0.1,random_state=51)
model.fit(X_train,Y_train)
prediction=model.predict(X_test)
print('Accuracy for linear SVM is',np.mean(cross_val_score(model, train, train_df['Survived'], cv=3)) ) | Titanic - Machine Learning from Disaster |
551,980 | df['PoolQC']=df['PoolQC'].fillna('None' )<feature_engineering> | model=LinearSVC(random_state=51)
model.fit(X_train, Y_train)
prediction=model.predict(X_test)
print('The accuracy of the NaiveBayes is',np.mean(cross_val_score(model, train, train_df['Survived'], cv=3)) ) | Titanic - Machine Learning from Disaster |
551,980 | <data_type_conversions><EOS> | model=RandomForestClassifier(n_estimators=30)
model.fit(X_train, Y_train)
prediction = model.predict(test)
submission = pd.read_csv('.. /input/gender_submission.csv')
submission.Survived = prediction
submission.to_csv('submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
4,851,629 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | warnings.filterwarnings('ignore')
%matplotlib inline
sns.set_style('white' ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['Fence']=df['Fence'].fillna('None' )<data_type_conversions> | labelled = pd.read_csv('.. /input/train.csv' ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['FireplaceQu']=df['FireplaceQu'].fillna('None' )<feature_engineering> | unlabelled = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['LotFrontage']=df['LotFrontage'].fillna(df['LotFrontage'].median() )<feature_engineering> | passengerID = unlabelled[['PassengerId']] | Titanic - Machine Learning from Disaster |
4,851,629 | df['GarageArea']=df['GarageArea'].fillna(0)
df['GarageArea'].isnull().sum()<count_values> | data = pd.concat([labelled, unlabelled], axis= 0, sort= False ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['GarageQual'].value_counts()<categorify> | class_mean_age = data.pivot_table(values='Age', index='Pclass', aggfunc='median' ) | Titanic - Machine Learning from Disaster |
4,851,629 | def impute_GarageQual(cols):
GarageArea=cols[1]
GarageQual=cols[0]
if pd.isnull(GarageQual):
if 0<GarageArea<400:
return 'Fa'
elif 400<GarageArea<550:
return 'Ta'
elif 550<GarageArea<700:
return 'Gd'
else:
return 'Ex'
else:
return GarageQual<feature_engineering> | null_age = data['Age'].isnull() | Titanic - Machine Learning from Disaster |
4,851,629 | df['GarageQual']=df['GarageQual'].fillna('None')
df['GarageQual'].isnull().sum()<categorify> | data.loc[null_age,'Age'] = data.loc[null_age,'Pclass'].apply(lambda x: class_mean_age.loc[x] ) | Titanic - Machine Learning from Disaster |
4,851,629 | def impute_GarageYrBlt(cols):
GarageYrBlt=cols[0]
GarageQual=cols[1]
if pd.isnull(GarageYrBlt):
if GarageQual=='Po':
return 1920
elif GarageQual=='Fa':
return 1930
elif GarageQual=='Ta':
return 1975
elif GarageQual=='Gd':
return 1980
elif GarageQual=='Ex':
return 2000
else:
return 2010
else:
return GarageYrBlt
<count_... | data.Age.isnull().sum() | Titanic - Machine Learning from Disaster |
4,851,629 | df['GarageYrBlt'].isnull().sum()<feature_engineering> | class_mean_fare = data.pivot_table(values= 'Fare', index= 'Pclass', aggfunc='median' ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['GarageYrBlt']=df['GarageYrBlt'].fillna(0)
df['GarageYrBlt'].isnull().sum()<categorify> | null_fare = data['Fare'].isnull() | Titanic - Machine Learning from Disaster |
4,851,629 | def impute_GarageCond(cols):
GarageArea=cols[1]
GarageCond=cols[0]
if pd.isnull(GarageCond):
if 0<GarageArea<400:
return 'Fa'
elif 400<GarageArea<550:
return 'Ta'
elif 550<GarageArea<700:
return 'Gd'
else:
return 'Ex'
else:
return GarageCond<feature_engineering> | data.loc[null_fare, 'Fare'] = data.loc[null_fare, 'Pclass'].apply(lambda x: class_mean_fare.loc[x] ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['GarageCond']=df['GarageCond'].fillna('None')
df['GarageCond'].isnull().sum()<count_values> | data.Fare.isnull().sum() | Titanic - Machine Learning from Disaster |
4,851,629 | df['GarageType'].value_counts()<categorify> | data.Embarked.value_counts() | Titanic - Machine Learning from Disaster |
4,851,629 | def impute_GarageType(cols):
GarageArea=cols[1]
GarageType=cols[0]
if pd.isnull(GarageType):
if 0<GarageArea<400:
return 'Detchd'
elif 400<GarageArea<600:
return 'Attchd'
elif 600<GarageArea<700:
return 'BuiltIn'
else:
return '2Types'
else:
return GarageType<feature_engineering> | data['Embarked'] = data.Embarked.fillna('S' ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['GarageType']=df['GarageType'].fillna('None')
df['GarageType'].isnull().sum()<feature_engineering> | data.Embarked.isnull().sum() | Titanic - Machine Learning from Disaster |
4,851,629 | df['TotalBsmtSF']=df['TotalBsmtSF'].fillna(df['TotalBsmtSF'].mean())
df['TotalBsmtSF'].isnull().sum()<categorify> | data['Title'] = data.Name.apply(lambda x : x[x.find(',')+2:x.find('.')] ) | Titanic - Machine Learning from Disaster |
4,851,629 | def impute_BsmtExposure(cols):
TotalBsmtSF=cols[1]
BsmtExposure=cols[0]
if pd.isnull(BsmtExposure):
if 0<TotalBsmtSF<900:
return 'No'
elif 900<TotalBsmtSF<1000:
return 'Mn'
elif 1000<TotalBsmtSF<1400:
return 'Av'
else:
return 'Gd'
else:
return BsmtExposure<data_type_conversions> | data.Title.value_counts() | Titanic - Machine Learning from Disaster |
4,851,629 | df['BsmtExposure']=df['BsmtExposure'].fillna('None')
df['BsmtExposure'].isnull().sum()<categorify> | rare_titles =(data['Title'].value_counts() < 10 ) | Titanic - Machine Learning from Disaster |
4,851,629 | def impute_BsmtCond(cols):
TotalBsmtSF=cols[1]
BsmtCond=cols[0]
if pd.isnull(BsmtCond):
if 0<TotalBsmtSF<700:
return 'Fa'
elif 700<TotalBsmtSF<1000:
return 'TA'
else:
return 'Gd'
else:
return BsmtCond<feature_engineering> | data['Title'] = data['Title'].apply(lambda x : 'Other' if rare_titles.loc[x] == True else x ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['BsmtCond']=df['BsmtCond'].fillna('None')
df['BsmtCond'].isnull().sum()<categorify> | data['FamilySize'] = data['SibSp'] + data['Parch'] + 1 | Titanic - Machine Learning from Disaster |
4,851,629 | def impute_BsmtQual(cols):
TotalBsmtSF=cols[1]
BsmtQual=cols[0]
if pd.isnull(BsmtQual):
if 0<TotalBsmtSF<800:
return 'TA'
elif 800<TotalBsmtSF<1400:
return 'Gd'
else:
return 'Ex'
else:
return BsmtQual
<feature_engineering> | data['IsAlone'] = 0 | Titanic - Machine Learning from Disaster |
4,851,629 | df['BsmtQual']=df['BsmtQual'].fillna('None')
df['BsmtQual'].isnull().sum()<feature_engineering> | data['IsAlone'].loc[ data['FamilySize'] == 1] = 1 | Titanic - Machine Learning from Disaster |
4,851,629 | df['BsmtFinType2']=df['BsmtFinType2'].fillna('NA')
df['BsmtFinType2'].isnull().sum()<categorify> | data['AgeBins'] = 0 | Titanic - Machine Learning from Disaster |
4,851,629 | def impute_BsmtFinType1(cols):
TotalBsmtSF=cols[1]
BsmtFinType1=cols[0]
if pd.isnull(BsmtFinType1):
if 0<TotalBsmtSF<800:
return 'Unf'
else:
return 'GLQ'
else:
return BsmtFinType1<data_type_conversions> | data['AgeBins'].loc[(data['Age'] >= 11)&(data['Age'] < 20)] = 1
data['AgeBins'].loc[(data['Age'] >= 20)&(data['Age'] < 60)] = 2
data['AgeBins'].loc[data['Age'] >= 60] = 3 | Titanic - Machine Learning from Disaster |
4,851,629 | df['BsmtFinType1']=df['BsmtFinType1'].fillna('None')
df['BsmtFinType1'].isnull().sum()<feature_engineering> | data['FareBins'] = pd.qcut(data['Fare'], 4 ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['MasVnrArea']=df['MasVnrArea'].fillna(df['MasVnrArea'].mean() )<feature_engineering> | data.drop(columns=['PassengerId','Name','Ticket', 'Cabin', 'Age', 'Fare', 'SibSp', 'Parch'], inplace= True ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['MSZoning']=df['MSZoning'].fillna('RL' )<data_type_conversions> | data = pd.get_dummies(
data, columns=['Embarked', 'Sex', 'Title'], drop_first=True ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['Utilities']=df['Utilities'].fillna('AllPub' )<feature_engineering> | label = LabelEncoder()
data['FareBins'] = label.fit_transform(data['FareBins'] ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['Functional']=df['Functional'].fillna('Typ' )<feature_engineering> | labelled = data[data.Survived.isnull() == False].reset_index(drop=True)
unlabelled = data[data.Survived.isnull() ].drop(columns = ['Survived'] ).reset_index(drop=True ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['BsmtFullBath']=df['BsmtFullBath'].fillna(df['BsmtFullBath'].mean() )<feature_engineering> | labelled['Survived'] = labelled.Survived.astype('int64' ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['BsmtHalfBath']=df['BsmtHalfBath'].fillna(df['BsmtHalfBath'].mean() )<feature_engineering> | scalers = [MinMaxScaler() , MaxAbsScaler() , StandardScaler() , RobustScaler() ,
Normalizer() , QuantileTransformer() , PowerTransformer() ] | Titanic - Machine Learning from Disaster |
4,851,629 | df['GarageArea']=df['GarageArea'].fillna(df['GarageArea'].mean() )<feature_engineering> | scaler_score = {}
labelled_copy = labelled.copy(deep= True)
for scaler in scalers:
scaler.fit(labelled_copy[['FamilySize']])
labelled_copy['FamilySize'] = scaler.transform(labelled_copy[['FamilySize']])
lr = LogisticRegressionCV(cv = 10, scoring= 'accuracy')
lr.fit(labelled_copy.drop(columns=['Survived']), labelled... | Titanic - Machine Learning from Disaster |
4,851,629 | df['BsmtFinSF2']=df['BsmtFinSF2'].fillna(df['BsmtFinSF2'].mean() )<feature_engineering> | scaler = StandardScaler()
scaler.fit(labelled[['FamilySize']])
labelled['FamilySize'] = scaler.transform(labelled[['FamilySize']])
unlabelled['FamilySize'] = scaler.transform(unlabelled[['FamilySize']] ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['Exterior1st']=df['Exterior1st'].fillna(method='ffill' )<data_type_conversions> | x_train, x_other, y_train, y_other = train_test_split(
labelled.drop(columns=['Survived']), labelled.Survived, train_size=0.7 ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['TotalBsmtSF']=df['TotalBsmtSF'].fillna(method='ffill' )<feature_engineering> | x_valid, x_test, y_valid, y_test = train_test_split(
x_other, y_other, train_size=0.5 ) | Titanic - Machine Learning from Disaster |
4,851,629 | df['GarageCars']=df['GarageCars'].fillna(0 )<data_type_conversions> | features = labelled.drop(columns=['Survived'])
target = labelled.Survived | 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.