kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
12,783,987 | def update_state(df):
def get_select_params(r):
values_uc = f'({r.user_id}, {r.content_id}, {r.answered_correctly}, {1-r.answered_correctly})'
values_u = f'({r.user_id}, {r.answered_correctly}, {1-r.answered_correctly})'
return values_uc, values_u
values = df.apply(get_select_params, axis=1, result_type='expand')
retu... | train_data[['normalized_Age', 'normalized_Fare']] = preprocessing.StandardScaler().fit_transform(train_data[['Age', 'Fare']])
test_data[['normalized_Age', 'normalized_Fare']] = preprocessing.StandardScaler().fit_transform(test_data[['Age', 'Fare']] ) | Titanic - Machine Learning from Disaster |
12,783,987 | %%time
df_batch_prior = None
counter = 0
for test_batch in iter_test:
counter += 1
if df_batch_prior is not None:
answers = eval(test_batch[0]['prior_group_answers_correct'].iloc[0])
df_batch_prior['answered_correctly'] = answers
cursor.executescript(update_state(df_batch_prior[df_batch_prior.content_type_id == 0]))
i... | bestfeatures = SelectKBest(score_func=chi2, k=10)
X = train_data[['Age', 'Fare', 'FamilySize','Pclass_1', 'Pclass_2',
'Pclass_3', 'Sex_female', 'Sex_male', 'SibSp_0', 'SibSp_1', 'SibSp_2',
'SibSp_3', 'SibSp_4', 'SibSp_5', 'SibSp_8', 'Parch_0', 'Parch_1',
'Parch_2', 'Parch_3', 'Parch_4', 'Parch_5', 'Parch_6', 'Embarked... | Titanic - Machine Learning from Disaster |
12,783,987 | import eli5
import numpy as np
import pandas as pd
from sklearn import set_config
from sklearn.base import TransformerMixin
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.metrics import mean_absolute_error, mean_squared_log_error, make_scorer
from sklearn.model_selec... | features = ["AgeBin", "FareBin", "FamilyBin"]
train_data = pd.get_dummies(train_data, columns=features, prefix = features)
test_data = pd.get_dummies(test_data, columns=features, prefix = features ) | Titanic - Machine Learning from Disaster |
12,783,987 | np.random.seed(42 )<load_from_csv> | X = train_data[['Pclass_1', 'Pclass_2', 'Pclass_3', 'Sex_female', 'Sex_male', 'Embarked_C', 'Embarked_Q', 'Embarked_S', 'AgeBin_1',
'AgeBin_2', 'AgeBin_3', 'AgeBin_4', 'AgeBin_5', 'FareBin_1',
'FareBin_2', 'FareBin_3', 'FareBin_4', 'FareBin_5', 'FamilyBin_1',
'FamilyBin_2', 'FamilyBin_3', 'FamilyBin_4']]
y = train_data... | Titanic - Machine Learning from Disaster |
12,783,987 | train_df = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/train.csv')
test_df = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/test.csv')
full_df = pd.concat([train_df, test_df], sort=True ).reset_index(drop=True )<compute_test_metric> | X = train_data[['Pclass_1', 'Pclass_2', 'Pclass_3', 'Sex_female', 'Sex_male', 'SibSp_0',
'SibSp_1', 'SibSp_2', 'SibSp_3', 'SibSp_4', 'SibSp_5', 'SibSp_8',
'Parch_0', 'Parch_1', 'Parch_2', 'Parch_3', 'Parch_4', 'Parch_5',
'Parch_6', 'Embarked_C', 'Embarked_Q', 'Embarked_S', 'AgeBin_1',
'AgeBin_2', 'AgeBin_3', 'AgeBin_4'... | Titanic - Machine Learning from Disaster |
12,783,987 | def neg_rmsle(y_true, y_pred):
y_pred = np.abs(y_pred)
return -1 * np.sqrt(mean_squared_log_error(y_true, y_pred))<compute_train_metric> | classifier = XGBClassifier()
results_kfold_CV = cross_val_score(classifier, X, y, cv=k_fold, n_jobs=-1)
results_kfold_CV.mean() *100 | Titanic - Machine Learning from Disaster |
12,783,987 | def score_model(model, X, Y):
scores = cross_validate(
model, X, Y,
scoring=['r2', 'neg_mean_absolute_error', 'neg_mean_squared_error'], cv=2,
n_jobs=-1, verbose=0)
rmsle_score = cross_val_score(model, X, Y, cv=2, scoring=make_scorer(neg_rmsle))
mse_score = np.sqrt(-1 * scores['test_neg_mean_squared_error'].mean())
... | classifier = DecisionTreeClassifier(max_depth=5)
results_kfold_CV = cross_val_score(classifier, X, y, cv=k_fold, n_jobs=-1)
results_kfold_CV.mean() *100 | Titanic - Machine Learning from Disaster |
12,783,987 | def get_columns_from_transformer(column_transformer, input_colums):
col_name = []
for transformer_in_columns in column_transformer.transformers_[:-1]:
raw_col_name = transformer_in_columns[2]
if isinstance(transformer_in_columns[1],Pipeline):
transformer = transformer_in_columns[1].steps[-1][1]
else:
transformer = tran... | clf = RandomForestClassifier(n_estimators=200, bootstrap=False, criterion='gini',min_samples_leaf = 1,
min_samples_split=2, max_depth=5, random_state=42 ).fit(X,y)
clf.score(X,y ) | Titanic - Machine Learning from Disaster |
12,783,987 | for feature in(
'PoolQC',
'FireplaceQu',
'Alley',
'Fence',
'MiscFeature',
'BsmtQual',
'BsmtCond',
'BsmtExposure',
'BsmtFinType1',
'BsmtFinType2',
'GarageType',
'GarageFinish',
'GarageQual',
'GarageCond',
'BsmtQual',
'BsmtCond',
'BsmtExposure',
'BsmtFinType1',
'BsmtFinType2',
'MasVnrType',
):
train_df[feature] = train... | k_fold = KFold(n_splits=10)
classifier = RandomForestClassifier(n_estimators=200, bootstrap=False, criterion='gini',min_samples_leaf = 1,
min_samples_split=2, max_depth=5, random_state=42)
results_kfold_CV = cross_val_score(classifier, X, y, cv=k_fold, n_jobs=-1)
results_kfold_CV.mean() *100 | Titanic - Machine Learning from Disaster |
12,783,987 | num_features = [f for f in train_df.columns if train_df.dtypes[f] != 'object']
num_features.remove('Id')
num_features.remove('SalePrice')
cat_features = [f for f in train_df.columns if train_df.dtypes[f] == 'object']<define_variables> | clf = XGBClassifier(n_estimators=70, eta=0.06, gamma=0.1, max_depth = 5, objective = 'binary:logistic', reg_lambda = 2 ).fit(X,y)
clf.score(X,y ) | Titanic - Machine Learning from Disaster |
12,783,987 | ordinal_feature_mapping = {
'ExterQual': {'Po': 0, 'Fa': 1, 'TA': 2, 'Gd': 3, 'Ex': 4},
'ExterCond': {'Po': 0, 'Fa': 1, 'TA': 2, 'Gd': 3, 'Ex': 4},
'BsmtQual': {'None': 0, 'Po': 1, 'Fa': 2, 'TA': 3, 'Gd': 4, 'Ex': 5},
'BsmtCond': {'None': 0, 'Po': 1, 'Fa': 2, 'TA': 3, 'Gd': 4, 'Ex': 5},
'BsmtFinType1': {'None': 0, 'Unf... | k_fold = KFold(n_splits=10)
classifier = XGBClassifier(n_estimators=70, eta=0.06, gamma=0.1, max_depth = 5, objective = 'binary:logistic', reg_lambda = 2)
results_kfold_CV = cross_val_score(classifier, X, y, cv=k_fold, n_jobs=-1)
results_kfold_CV.mean() *100 | Titanic - Machine Learning from Disaster |
12,783,987 | for dataframe in [train_df, test_df, full_df]:
dataframe['AvgRoomSF'] = dataframe['GrLivArea'] / dataframe['TotRmsAbvGrd']
dataframe['OverallHouseQC'] = dataframe['OverallQual'] + dataframe['OverallCond']
dataframe['IsNeighborhoodElite'] =(dataframe['Neighborhood'].isin(['NridgHt', 'CollgeCr', 'Crawfor', 'StoreBr', 'Ti... | X_test = test_data[['Pclass_1', 'Pclass_2', 'Pclass_3', 'Sex_female', 'Sex_male', 'SibSp_0',
'SibSp_1', 'SibSp_2', 'SibSp_3', 'SibSp_4', 'SibSp_5', 'SibSp_8',
'Parch_0', 'Parch_1', 'Parch_2', 'Parch_3', 'Parch_4', 'Parch_5',
'Parch_6', 'Embarked_C', 'Embarked_Q', 'Embarked_S', 'AgeBin_1',
'AgeBin_2', 'AgeBin_3', 'AgeBi... | Titanic - Machine Learning from Disaster |
12,783,987 | features = [
'GrLivArea',
'1stFlrSF',
'2ndFlrSF',
'LotArea',
'BsmtFinSF1',
'BsmtFinSF2',
'BsmtUnfSF',
'BsmtFinType1Enc',
'BsmtFinType2Enc',
'GarageCars',
'OverallCond',
'Neighborhood',
'LotShape',
'LandSlope',
'BsmtCondEnc',
'BsmtQualEnc',
'SaleCondition',
'CentralAirEnc',
'IsAdjArterialStreat',
'IsAdjFeederStreat',
'I... | testDF = pd.DataFrame()
testDF['PassengerId'] = test_data['PassengerId']
testDF['Survived'] = pred
testDF.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,496,059 | logTransformer = FunctionTransformer(func=np.log1p, inverse_func=np.expm1)
featureTransformer = ColumnTransformer([
('log_scaling', logTransformer, ['GrLivArea', 'BsmtFinSF1', 'BsmtFinSF2', 'BsmtUnfSF', 'LotArea', 'AvgRoomSF', 'Shed', 'TotRmsAbvGrd']),
('neighborhood_onehot', OneHotEncoder(categories=[neighborhoodCa... | train= pd.read_csv(".. /input/titanic/train.csv")
y=train['Survived']
train.head()
| Titanic - Machine Learning from Disaster |
13,496,059 | %%time
xgb_model = XGBRegressor(
max_depth=6,
n_estimators=8000,
learning_rate=0.01,
min_child_weight=1.5,
subsample=0.2,
gamma=0.01,
reg_alpha=1,
reg_lambda=0.325,
objective='reg:gamma',
booster='gbtree'
)
xgb_pipeline = Pipeline([
('preprocessing', featureTransformer),
('xgb_regressor', xgb_model),
])
print('XG... | print(train.shape)
print(train.columns)
print(train.isnull().sum())
print(train.dtypes)
print(train.columns ) | Titanic - Machine Learning from Disaster |
13,496,059 | xgb_pipeline.fit(X, Y)
X_columns = get_columns_from_transformer(xgb_pipeline.named_steps['preprocessing'], list(X.columns))<load_pretrained> | test = pd.read_csv(".. /input/titanic/test.csv")
test.head()
| Titanic - Machine Learning from Disaster |
13,496,059 | transformed_X = xgb_pipeline.named_steps['preprocessing'].transform(X)
permutation_importance = PermutationImportance(
xgb_model,
scoring=make_scorer(neg_rmsle),
cv=2,
random_state=42,
).fit(transformed_X, Y)
eli5.show_weights(permutation_importance, feature_names=X_columns, top=125 )<define_search_space> | print(test.shape)
print(test.columns)
print(test.isnull().sum())
print(test.dtypes)
passenger_id= test['PassengerId']
data_combined=train.append(test ) | Titanic - Machine Learning from Disaster |
13,496,059 | %%time
parameters = {
'xgb_regressor__objective': ['reg:gamma'],
'xgb_regressor__learning_rate': [0.01],
'xgb_regressor__n_estimators': [7900, 8000, 8100],
'xgb_regressor__max_depth': [11, 12, 13],
'xgb_regressor__booster': ['gbtree'],
'xgb_regressor__min_child_weight': [1.5],
'xgb_regressor__gamma': [0],
'xgb_regresso... | train.set_index(['PassengerId'] , inplace=True)
test.set_index(['PassengerId'] , inplace=True)
train.head() | Titanic - Machine Learning from Disaster |
13,496,059 | xgb_pipeline.fit(X, Y)
y_test_predicted = xgb_pipeline.predict(x_test)
y_test_predicted = np.rint(y_test_predicted ).astype(int)
submission_df = pd.DataFrame({
'Id': test_df['Id'],
'SalePrice': y_test_predicted,
})
submission_df.to_csv('./submission_xgb.csv', index=False )<import_modules> | women = train.loc[train.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
print("% of women who survived:", rate_women ) | Titanic - Machine Learning from Disaster |
13,496,059 | import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib
import matplotlib.pyplot as plt
from scipy.stats import skew,norm
from scipy.stats.stats import pearsonr<load_from_csv> | men = train.loc[train.Sex == 'male']["Survived"]
rate_men = sum(men)/len(men)
print("% of men who survived:", rate_men)
| Titanic - Machine Learning from Disaster |
13,496,059 | 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_size = train.shape[0]
submission = pd.read_csv(".. /input/house-prices-advanced-regression-techniques/sample_submission.csv")
warnings.filt... | imp= SimpleImputer(strategy='mean')
imp_train=imp.fit_transform(train[['Age']])
train['Age2']=imp_train
train.head()
| Titanic - Machine Learning from Disaster |
13,496,059 | all_data = pd.concat(( train.loc[:,'MSSubClass':'SaleCondition'],
test.loc[:,'MSSubClass':'SaleCondition']))
train["SalePrice"] = np.log1p(train["SalePrice"])
numeric_features = all_data.dtypes[all_data.dtypes != "object"].index
skewed_features = train[numeric_features].apply(lambda x: skew(x.dropna()))
skewed_feature... | imp_test=imp.fit_transform(test[['Age']])
test['Age2']=imp_test
test.head() | Titanic - Machine Learning from Disaster |
13,496,059 | X_train = all_data[:train_size]
X_test = all_data[train_size:]
y_train = train.SalePrice<compute_test_metric> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,496,059 | def mean_absolute_percentage_error(y_true, y_pred):
y_true, y_pred = np.array(y_true), np.array(y_pred)
return np.mean(np.abs(( y_true - y_pred)/ y_true)) * 100<find_best_params> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,496,059 | alphas = [0.05, 0.1, 0.5, 1, 5, 10, 20, 40, 80]
cv_ridge = [np.sqrt(-cross_val_score(Ridge(alpha = alpha), X_train, y_train, scoring="neg_mean_squared_error", cv = 5)).mean()
for alpha in alphas]
best_alpha = alphas[cv_ridge.index(min(cv_ridge)) ]
cv_ridge = pd.Series(cv_ridge, index = alphas)
min_rmse = cv_ridge.min(... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
13,496,059 | model_Ridge = Ridge(10 ).fit(X_train, y_train)
ridge_predict = np.exp(model_Ridge.predict(X_test))
solution = pd.DataFrame({"id":test.Id, "SalePrice": ridge_predict})
percentage_error = mean_absolute_percentage_error(submission.SalePrice, solution.SalePrice)
print(percentage_error )<save_to_csv> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
13,496,059 | solution.to_csv("ridge_sol.csv", index = False )<set_options> | train.Embarked.value_counts() | Titanic - Machine Learning from Disaster |
13,496,059 | %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: '{:.3f}'.format(x))
print(check_output(["ls", ".. /input"] ).decode("utf8"))
warnings.filterwarnings('ignore')
<import_modules> | train['Embarked'].fillna('S',inplace=True)
train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,496,059 | from numpy import sqrt<load_from_csv> | test['Fare'].fillna(test['Fare'].median() , inplace=True)
test.isnull().sum() | Titanic - Machine Learning from Disaster |
13,496,059 | train_data = pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/train.csv")
test_data = pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/test.csv" )<drop_column> | train.drop(columns=['Age','Cabin'],inplace=True)
test.drop(columns=['Age','Cabin'],inplace=True)
print(train.columns)
print(test.columns ) | Titanic - Machine Learning from Disaster |
13,496,059 | idsUnique = len(set(train_data.Id))
idsTotal = train_data.shape[0]
idsDupli = idsTotal - idsUnique
print("Train data: there are " + str(idsDupli)+ " duplicate IDs for " + str(idsTotal)+ " total entries")
train_data.drop("Id", axis = 1, inplace = True )<drop_column> | OH_sex=pd.get_dummies(train['Sex'])
train.head() | Titanic - Machine Learning from Disaster |
13,496,059 | idsUnique = len(set(test_data.Id))
idsTotal = test_data.shape[0]
idsDupli = idsTotal - idsUnique
print("Test data: there are " + str(idsDupli)+ " duplicate IDs for " + str(idsTotal)+ " total entries")
test_data.drop("Id", axis = 1, inplace = True )<filter> | OH_train=pd.concat([train,OH_sex],axis=1)
OH_train.head() | Titanic - Machine Learning from Disaster |
13,496,059 | quantitative = list(train_data.dtypes[train_data.dtypes != "object"].index)
len(quantitative )<define_variables> | OH_sex_test=pd.get_dummies(test['Sex'])
OH_test=pd.concat([test,OH_sex_test],axis=1)
OH_test.head() | Titanic - Machine Learning from Disaster |
13,496,059 | qualitative = list(train_data.dtypes[train_data.dtypes == "object"].index)
len(qualitative )<categorify> | OH_embarked= pd.get_dummies(OH_train['Embarked'])
OH_embarked.head() | Titanic - Machine Learning from Disaster |
13,496,059 | def encode(frame_train, frame_test,feature):
ordering = pd.DataFrame()
ordering['val'] = frame_train[feature].unique()
ordering.index = ordering.val
ordering['spmean'] = frame_train[[feature, 'SalePrice']].groupby(feature ).mean() ['SalePrice']
ordering = ordering.sort_values('spmean')
ordering['ordering'] = range(1, ... | OH_train.drop(columns=['Sex','Ticket','Embarked','Name'], inplace=True)
final_OH_train=pd.concat([OH_train,OH_embarked],axis=1)
final_OH_train.columns
print(final_OH_train.shape ) | Titanic - Machine Learning from Disaster |
13,496,059 | ordering = pd.DataFrame()
ordering['val'] = train_data['MSZoning'].unique()
ordering.index = ordering.val
ordering['spmean'] = train_data[['MSZoning', 'SalePrice']].groupby('MSZoning' ).mean() ['SalePrice']
ordering = ordering.sort_values('spmean')
ordering['ordering'] = range(1, ordering.shape[0]+1)
ordering = order... | OH_embarked_test= pd.get_dummies(OH_test['Embarked'])
OH_embarked_test.head()
print(OH_embarked_test.shape)
| Titanic - Machine Learning from Disaster |
13,496,059 | q = list(qualitative )<filter> | OH_test.drop(columns=['Sex','Ticket','Embarked','Name'], inplace=True)
final_OH_test=pd.concat([OH_test,OH_embarked_test],axis=1)
final_OH_test.columns | Titanic - Machine Learning from Disaster |
13,496,059 | train_data = train_data[train_data.GrLivArea < 4500]<prepare_x_and_y> | print(final_OH_train.shape)
print(final_OH_train.shape)
print(final_OH_train.isnull().sum() ) | Titanic - Machine Learning from Disaster |
13,496,059 | ntrain = train_data.shape[0]
ntest = test_data.shape[0]
y_train = train_data.SalePrice.values
all_data = pd.concat(( train_data, test_data),ignore_index = True)
all_data.drop(['SalePrice'], axis=1, inplace=True)
print("all_data size is : {}".format(all_data.shape))<count_missing_values> | final_OH_train.groupby('Survived' ).mean() | Titanic - Machine Learning from Disaster |
13,496,059 | print(all_data.isnull().sum() )<drop_column> | print(final_OH_train.columns)
final_OH_train.drop(columns=['Survived'],inplace=True)
X_train, X_valid, y_train, y_valid = train_test_split(final_OH_train, y, train_size=0.8, test_size=0.2,random_state=0 ) | Titanic - Machine Learning from Disaster |
13,496,059 | qx = list(set(qualitative ).difference(['Neighborhood']))
all_data.drop(qx,axis = 1,inplace=True )<sort_values> | def get_mae(max_leaf_nodes, train_X, val_X, train_y, val_y):
model = RandomForestClassifier(n_estimators=max_leaf_nodes, max_depth=11, random_state=1)
model.fit(train_X, train_y)
preds_val = model.predict(val_X)
mae = mean_absolute_error(val_y, preds_val)
return(mae)
leaf_nodes=[50,100,300,500,1000,2000]
for i in ... | Titanic - Machine Learning from Disaster |
13,496,059 | all_data_na = pd.DataFrame(( all_data.isnull().sum() / len(all_data)) * 100)
all_data_na = all_data_na[all_data_na[0] > 0]
all_data_na.sort_values(ascending=False,by = [0],inplace = True)
all_data_na.head(20 )<drop_column> | model = RandomForestClassifier(n_estimators=300, max_depth=11, random_state=1)
model.fit(X_train, y_train)
preds=model.predict(X_valid)
matrix=classification_report(y_valid,preds)
print(matrix)
predictions=model.predict(final_OH_test)
| Titanic - Machine Learning from Disaster |
13,496,059 | all_data.drop(['PoolQC_E','MiscFeature_E','Alley_E'],axis = 1,inplace=True )<groupby> | model2=LogisticRegression(random_state=0)
model2.fit(X_train, y_train)
preds2=model2.predict(X_valid)
matrix2=classification_report(y_valid,preds2)
print(matrix2 ) | Titanic - Machine Learning from Disaster |
13,496,059 | fea = list(all_data_na[all_data_na[0]<20].index)
for f in fea:
all_data[f] = all_data.groupby('Neighborhood')[f].apply(lambda x: x.fillna(x.median()))<drop_column> | output = pd.DataFrame({'PassengerId': passenger_id, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
13,509,273 | all_data.drop('Neighborhood',axis = 1,inplace=True )<create_dataframe> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
fro... | Titanic - Machine Learning from Disaster |
13,509,273 | all_data_na1 = pd.DataFrame(( all_data.isnull().sum() / len(all_data)) * 100)
all_data_na1 = all_data_na1[all_data_na1[0] > 0]<groupby> | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
13,509,273 | all_data['FireplaceQu_E'] = all_data.groupby('KitchenQual_E')['FireplaceQu_E'].apply(lambda x: x.fillna(x.median()))
all_data['Fence_E'] = all_data.groupby('KitchenQual_E')['Fence_E'].apply(lambda x: x.fillna(x.median()))<define_variables> | train['Title'] = train['Name'].str.extract(pat = '([a-zA-Z]+)\.', expand = False)
train.Title.value_counts() | Titanic - Machine Learning from Disaster |
13,509,273 | numeric_dtypes = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64']
numerics2 = []
for i in all_data.columns:
if all_data[i].dtype in numeric_dtypes:
numerics2.append(i )<concatenate> | train['Title'] = train['Title'].replace(['Mlle', 'Ms'], 'Miss')
train['Title'] = train['Title'].replace('Mme', 'Mrs')
train['Title'] = train['Title'].replace(['Mlle', 'Mme', 'Ms', 'Don', 'Rev', 'Lady', 'Sir', 'Major', 'Col', 'Capt', 'Countess', 'Jonkheer', 'Dr'], 'Other' ) | Titanic - Machine Learning from Disaster |
13,509,273 | num = list(set(quantitative ).difference(['YearBuilt','YearRemodAdd', 'MoSold', 'YrSold']))<feature_engineering> | test['Title'] = test['Name'].str.extract(pat = '([a-zA-Z]+)\.', expand = False)
test.Title.value_counts() | Titanic - Machine Learning from Disaster |
13,509,273 | skew_features = all_data.apply(lambda x: skew(x)).sort_values(ascending=False)
high_skew = skew_features[abs(skew_features)> 0.75]
print("There are {} skewed numerical features to Box Cox transform".format(high_skew.shape[0]))
skew_index = high_skew.index
for i in skew_index:
all_data[i] = boxcox1p(all_data[i], boxcox... | test['Title'] = test['Title'].replace('Ms', 'Miss')
test['Title'] = test['Title'].replace(['Rev', 'Col', 'Dona', 'Dr'], 'Other' ) | Titanic - Machine Learning from Disaster |
13,509,273 | train = all_data[:ntrain]
test = all_data[ntrain:]<compute_train_metric> | train['Cabin_Code'] = train.Cabin.str[0]
train.Cabin_Code.value_counts() | Titanic - Machine Learning from Disaster |
13,509,273 | kfolds = KFold(n_splits=10, shuffle=True, random_state=42)
def rmsle(y, y_pred):
return np.sqrt(mean_squared_error(y, y_pred))
def cv_rmse(model, X=train):
rmse = np.sqrt(-cross_val_score(model, X, y_train, scoring="neg_mean_squared_error", cv=kfolds))
return(rmse )<define_search_space> | test['Cabin_Code'] = test.Cabin.str[0]
test.Cabin_Code.value_counts() | Titanic - Machine Learning from Disaster |
13,509,273 | alphas_alt = [14.5, 14.6, 14.7, 14.8, 14.9, 15, 15.1, 15.2, 15.3, 15.4, 15.5]
alphas2 = [5e-05, 0.0001, 0.0002, 0.0003, 0.0004, 0.0005, 0.0006, 0.0007, 0.0008]
e_alphas = [0.0001, 0.0002, 0.0003, 0.0004, 0.0005, 0.0006, 0.0007]
e_l1ratio = [0.8, 0.85, 0.9, 0.95, 0.99, 1]<choose_model_class> | train['Ticket_Numeric'] = train.Ticket.str.isnumeric().astype('uint8')
test['Ticket_Numeric'] = test.Ticket.str.isnumeric().astype('uint8' ) | Titanic - Machine Learning from Disaster |
13,509,273 | ridge = make_pipeline(RobustScaler() , RidgeCV(alphas=alphas_alt, cv=kfolds))
lasso = make_pipeline(RobustScaler() , LassoCV(max_iter=1e7, alphas=alphas2, random_state=42, cv=kfolds))
elasticnet = make_pipeline(RobustScaler() , ElasticNetCV(max_iter=1e7, alphas=e_alphas, cv=kfolds, l1_ratio=e_l1ratio))
svr = make_pipel... | pd.pivot_table(train,index='Survived',columns='Ticket_Numeric',values='Name', aggfunc='count', fill_value=0 ) | Titanic - Machine Learning from Disaster |
13,509,273 | lightgbm = LGBMRegressor(objective='regression',
num_leaves=4,
learning_rate=0.01,
n_estimators=5000,
max_bin=200,
bagging_fraction=0.75,
bagging_freq=5,
bagging_seed=7,
feature_fraction=0.2,
feature_fraction_seed=7,
verbose=-1,
)<choose_model_class> | train['Ticket_Alphabets'] = train.Ticket.str.extract('([A-Za-z./0-9]+\)', expand = False ) | Titanic - Machine Learning from Disaster |
13,509,273 | gbr = GradientBoostingRegressor(n_estimators=3000, learning_rate=0.05, max_depth=4, max_features='sqrt', min_samples_leaf=15, min_samples_split=10, loss='huber', random_state =42 )<choose_model_class> | train.Ticket_Alphabets.value_counts() | Titanic - Machine Learning from Disaster |
13,509,273 | xgboost = XGBRegressor(learning_rate=0.01,n_estimators=3460,
max_depth=3, min_child_weight=0,
gamma=0, subsample=0.7,
colsample_bytree=0.7,
objective='reg:linear', nthread=-1,
scale_pos_weight=1, seed=27,
reg_alpha=0.00006 )<choose_model_class> | train['Ticket_Alphabets'] = train.Ticket_Alphabets.str.lower().str.extract('([a-z.]+)')
train['Ticket_Alphabets'] = train.Ticket_Alphabets.str.replace('.', '', regex = True ) | Titanic - Machine Learning from Disaster |
13,509,273 | stack_gen = StackingCVRegressor(regressors=(ridge, lasso, elasticnet, gbr, xgboost, lightgbm),
meta_regressor=xgboost,
use_features_in_secondary=True )<compute_test_metric> | train.Ticket_Alphabets.value_counts() | Titanic - Machine Learning from Disaster |
13,509,273 | score = cv_rmse(ridge)
print("RIDGE: {:.4f}({:.4f})
".format(score.mean() , score.std()), datetime.now() ,)
score = cv_rmse(lasso)
print("LASSO: {:.4f}({:.4f})
".format(score.mean() , score.std()), datetime.now() ,)
score = cv_rmse(elasticnet)
print("elastic net: {:.4f}({:.4f})
".format(score.mean() , score.std... | train.loc[(train['Title']=='Mr')&(train['Age'].isna()), 'Age'] = train.loc[(train['Title']=='Mr'), 'Age'].mean(skipna = True)
train.loc[(train['Title']=='Mrs')&(train['Age'].isna()), 'Age'] = train.loc[(train['Title']=='Mrs'), 'Age'].mean(skipna = True)
train.loc[(train['Title']=='Miss')&(train['Age'].isna()), 'Age']... | Titanic - Machine Learning from Disaster |
13,509,273 | print('START Fit')
print('stack_gen')
stack_gen_model = stack_gen.fit(np.array(train), np.array(y_train))
print('elasticnet')
elastic_model_full_data = elasticnet.fit(train, y_train)
print('Lasso')
lasso_model_full_data = lasso.fit(train, y_train)
print('Ridge')
ridge_model_full_data = ridge.fit(train, y_train)
... | train['Embarked'] = train['Embarked'].fillna(train['Embarked'].mode().iloc[0] ) | Titanic - Machine Learning from Disaster |
13,509,273 | def blend_models_predict(X):
return(( 0.1 * elastic_model_full_data.predict(X)) + \
(0.1 * lasso_model_full_data.predict(X)) + \
(0.1 * ridge_model_full_data.predict(X)) + \
(0.1 * svr_model_full_data.predict(X)) + \
(0.1 * gbr_model_full_data.predict(X)) + \
(0.1 * xgb_model_full_data.predict(X)) + \
(0.1 * lgb_... | test.loc[(test['Title']=='Mr')&(test['Age'].isna()), 'Age'] = train.loc[(train['Title']=='Mr'), 'Age'].mean(skipna = True)
test.loc[(test['Title']=='Mrs')&(test['Age'].isna()), 'Age'] = train.loc[(train['Title']=='Mrs'), 'Age'].mean(skipna = True)
test.loc[(test['Title']=='Miss')&(test['Age'].isna()), 'Age'] = train.... | Titanic - Machine Learning from Disaster |
13,509,273 | print('RMSLE score on train data:')
print(rmsle(y_train, np.expm1(blend_models_predict(train)) )<save_to_csv> | test['Fare'] = test['Fare'].fillna(train['Fare'].median() ) | Titanic - Machine Learning from Disaster |
13,509,273 | test_data = pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/test.csv")
output = pd.DataFrame({'Id': test_data.Id, 'SalePrice': np.floor(np.expm1(blend_models_predict(test)))})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" )<set_options> | train = pd.get_dummies(data = train, columns = ['Sex', 'Embarked'], drop_first = True)
train = pd.get_dummies(data = train, columns=['Cabin_Code'] ) | Titanic - Machine Learning from Disaster |
13,509,273 | warnings.filterwarnings('ignore')
<load_from_csv> | test = pd.get_dummies(data = test, columns = ['Sex', 'Embarked'], drop_first = True)
test = pd.get_dummies(data = test, columns=['Cabin_Code'])
test['Cabin_Code_T'] = 0
| Titanic - Machine Learning from Disaster |
13,509,273 | train = pd.read_csv('.. /input/santander-customer-transaction-prediction/train.csv')
test = pd.read_csv('.. /input/santander-customer-transaction-prediction/test.csv' )<create_dataframe> | sc = StandardScaler()
train[['Age', 'Fare']] = pd.DataFrame(sc.fit_transform(train[['Age', 'Fare']]))
test[['Age', 'Fare']] = pd.DataFrame(sc.transform(test[['Age', 'Fare']])) | Titanic - Machine Learning from Disaster |
13,509,273 | def func(df):
a = df.isnull().sum()
b = df.count()
c =(a/b)* 100
d = pd.DataFrame(a, columns = ['Missingvalue%'])
return d['Missingvalue%'].sum()<train_model> | train = train.drop(columns = ['Cabin', 'Ticket', 'PassengerId', 'Name', 'Title', 'Ticket_Alphabets'] ) | Titanic - Machine Learning from Disaster |
13,509,273 | print('missing values in train data:', func(train))
print('missing values in test data:', func(test))<count_values> | test = test.drop(columns = ['Cabin', 'Ticket', 'PassengerId', 'Name', 'Title'] ) | Titanic - Machine Learning from Disaster |
13,509,273 | print('% of 1 in train data:',(train.target.value_counts() [1]/train.shape[0])* 100 )<count_unique_values> | X = train.drop(columns = ['Survived'])
y = train['Survived'] | Titanic - Machine Learning from Disaster |
13,509,273 | features = train.columns.values[2:202]
unique_max_train = []
unique_max_test = []
for feature in features:
values = train[feature].value_counts()
unique_max_train.append([feature, values.max() , values.idxmax() ])
values = test[feature].value_counts()
unique_max_test.append([feature, values.max() , values.idxmax() ] )... | classifier_lr = LogisticRegression(penalty = 'l2', random_state=0 ) | Titanic - Machine Learning from Disaster |
13,509,273 | idx = features = train.columns.values[2:202]
for df in [test, train]:
df['sum'] = df[idx].sum(axis=1)
df['min'] = df[idx].min(axis=1)
df['max'] = df[idx].max(axis=1)
df['mean'] = df[idx].mean(axis=1)
df['std'] = df[idx].std(axis=1)
df['skew'] = df[idx].skew(axis=1)
df['kurt'] = df[idx].kurtosis(axis=1)
df['med']... | classifier_nb = GaussianNB() | Titanic - Machine Learning from Disaster |
13,509,273 | features = [c for c in train.columns if c not in ['ID_code', 'target']]
target = train['target']<init_hyperparams> | classifier_svm = SVC(C=1, kernel='rbf', gamma = 'auto' ) | Titanic - Machine Learning from Disaster |
13,509,273 | param = {
'bagging_freq': 5,
'bagging_fraction': 0.4,
'boost_from_average':'false',
'boost': 'gbdt',
'feature_fraction': 0.05,
'learning_rate': 0.01,
'max_depth': -1,
'metric':'auc',
'min_data_in_leaf': 80,
'min_sum_hessian_in_leaf': 10.0,
'num_leaves': 13,
'num_threads': 8,
'tree_learner': 'serial',
'objective': 'bina... | classifier_rf = RandomForestClassifier(n_estimators=100, criterion = 'entropy', min_samples_split=10, random_state=0 ) | Titanic - Machine Learning from Disaster |
13,509,273 | folds = StratifiedKFold(n_splits=10, shuffle=False, random_state=44000)
oof = np.zeros(len(train))
predictions = np.zeros(len(test))
feature_importance_df = pd.DataFrame()
for fold_,(trn_idx, val_idx)in enumerate(folds.split(train.values, target.values)) :
print("Fold {}".format(fold_))
trn_data = lgb.Dataset(train.il... | lr = cross_val_score(estimator = classifier_lr, X = X, y = y, cv = 10)
print(lr ) | Titanic - Machine Learning from Disaster |
13,509,273 | Prtd = pd.DataFrame({"ID_code":test["ID_code"].values})
Prtd["target"] = predictions
Prtd.to_csv("submission.csv", index=False )<install_modules> | nb = cross_val_score(estimator = classifier_nb, X = X, y = y, cv = 10)
print(nb ) | Titanic - Machine Learning from Disaster |
13,509,273 | !pip install snapml<import_modules> | svm = cross_val_score(estimator = classifier_svm, X = X, y = y, cv = 10)
print(svm ) | Titanic - Machine Learning from Disaster |
13,509,273 | import numpy as np
import pandas as pd
from sklearn import decomposition
from sklearn.metrics import roc_auc_score, roc_curve
from sklearn.model_selection import StratifiedKFold
from sklearn.utils.class_weight import compute_sample_weight
import sklearn.ensemble as skl
from os import path
import time
from scipy.stats i... | rf = cross_val_score(estimator = classifier_rf, X = X, y = y, cv = 10)
print(rf ) | Titanic - Machine Learning from Disaster |
13,509,273 | np.random.seed(130720 )<load_from_csv> | model = ['Logistic Regression', 'Naive Bayes', 'SVM', 'Random Forest']
accuracy_mean = [np.mean(lr), np.mean(nb), np.mean(svm), np.mean(rf)]
accuracy_std = [np.std(lr), np.std(nb), np.std(svm), np.std(rf)] | Titanic - Machine Learning from Disaster |
13,509,273 | path_to_folder = '/kaggle/input/santander-customer-transaction-prediction'
df = pd.read_csv(path.join(path_to_folder, 'train.csv'))
df_test = pd.read_csv(path.join(path_to_folder, 'test.csv'))
id_codes = df_test['ID_code']
df_test.drop('ID_code', axis=1, inplace=True)
df.drop('ID_code', axis=1, inplace=True)
features... | K_Fold = pd.DataFrame({'Model' : model, 'Accuracy_Mean' : accuracy_mean, 'Accuracy_Std' : accuracy_std})
print(K_Fold ) | Titanic - Machine Learning from Disaster |
13,509,273 | def time_decorator(function):
def timed(*args, **kwargs):
ts = time.time_ns()
result = function(*args, **kwargs)
te = time.time_ns()
return result,(te - ts)* 1e-9
return timed<count_values> | classifier_svm.fit(X, y)
y_pred = classifier_svm.predict(test ) | Titanic - Machine Learning from Disaster |
13,509,273 | <create_dataframe><EOS> | predictions = pd.DataFrame({"PassengerId" : list(range(892, 892 + len(y_pred))),"Survived" : y_pred})
predictions.to_csv('predictions.csv', index = False ) | Titanic - Machine Learning from Disaster |
13,504,093 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<create_dataframe> | import numpy as np
import pandas as pd
import os
from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
13,504,093 | def estimate_counts_based_on_real_testing_samples(training_and_validation_sets: List[pd.DataFrame], testing_set: pd.DataFrame, columns: List)-> List:
real_samples_indices, _ = get_real_synthetic_testing_samples(testing_set)
data_set_for_estimation = pd.concat([*training_and_validation_sets, testing_set.loc[real_samp... | data_root = '/kaggle/input/titanic'
train_data_path = os.path.join(data_root, 'train.csv')
test_data_path = os.path.join(data_root, 'test.csv')
train_data = pd.read_csv(train_data_path)
test_data = pd.read_csv(test_data_path ) | Titanic - Machine Learning from Disaster |
13,504,093 | def get_column_indices(df: pd.DataFrame, query_cols: List)-> np.array:
cols = df.columns.values
sidx = np.argsort(cols)
return sidx[np.searchsorted(cols, query_cols, sorter=sidx)]<train_model> | use_cols = ['Pclass', 'Sex', 'SibSp', 'Parch'] | Titanic - Machine Learning from Disaster |
13,504,093 | @time_decorator
def train(model: Union[snapml.RandomForestClassifier, skl.RandomForestClassifier], X_train: np.ndarray, y_train: np.array, weights: np.array):
model.fit(X_train, y_train, weights )<choose_model_class> | learn_data, valid_data = train_test_split(train_data, test_size=0.3, random_state=0)
X = pd.get_dummies(learn_data.loc[:, use_cols] ).values
y = learn_data.loc[:, 'Survived'].values
valid_X = pd.get_dummies(valid_data.loc[:, use_cols] ).values
valid_y = valid_data.loc[:, 'Survived'].values | Titanic - Machine Learning from Disaster |
13,504,093 | def create_model(library: str, params: Dict, r_seed: int, n_cpus: int)-> Union[snapml.RandomForestClassifier, skl.RandomForestClassifier]:
if library == 'snapml':
return snapml.RandomForestClassifier(**params, use_gpu=False, random_state=r_seed, n_jobs=n_cpus)
elif library == 'sklearn':
return skl.RandomForestClassi... | from xgboost import XGBClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier | Titanic - Machine Learning from Disaster |
13,504,093 | print(f'Number of NaN entries in train: {sum(df.isnull().sum())}, test: {sum(df_test.isnull().sum())}.' )<compute_test_metric> | cls = DecisionTreeClassifier()
cls.fit(X, y)
y_pred = cls.predict(valid_X)
y_true = valid_y
print(f1_score(y_true=y_true, y_pred=y_pred))
print(accuracy_score(y_true=y_true, y_pred=y_pred)) | Titanic - Machine Learning from Disaster |
13,504,093 | corr = np.tril(features.corr() , k=-1)
print(f'Maximal correlation: {corr.max() :.4f}, minimal correlation {corr.min() :.4f}.' )<compute_train_metric> | test_X = pd.get_dummies(test_data.loc[:, use_cols] ).values
test_y_pred = cls.predict(test_X)
predict_df = pd.DataFrame()
predict_df['PassengerId'] = test_data['PassengerId']
predict_df['Survived'] = test_y_pred
predict_df.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,459,641 | X, X_test = estimate_counts_based_on_real_testing_samples([features], df_test, columns )<init_hyperparams> | train=pd.read_csv('/kaggle/input/titanic/train.csv')
test=pd.read_csv('/kaggle/input/titanic/test.csv')
target=train['Survived']
submission=pd.DataFrame(test['PassengerId'] ) | Titanic - Machine Learning from Disaster |
13,459,641 | optimal_hyperparams = {
'max_depth': 5,
'min_samples_leaf': 386,
'n_estimators': 88
}<data_type_conversions> | a=dataset.groupby('Pclass')['Age'].median()
dataset['Age']=dataset['Age'].fillna(dataset['Pclass'].map(a))
a=dataset.groupby('Pclass')['Fare'].median()
dataset['Fare']=dataset['Fare'].fillna(dataset['Pclass'].map(a))
dataset['Embarked'].fillna('S',inplace=True)
| Titanic - Machine Learning from Disaster |
13,459,641 | features = [get_column_indices(X, X.filter(regex=fr'{col}(?!\d)' ).columns)for col in columns]
X = X.to_numpy()
X_test = X_test.to_numpy()
y = target.to_numpy()<count_values> | dataset['Name'].iloc[3].split() [1]
a=[]
for i in range(len(dataset)) :
a.append(dataset['Name'].iloc[i].split() [1])
a=pd.Series(a)
dataset['Title']=a
| Titanic - Machine Learning from Disaster |
13,459,641 | n_cpus = multiprocessing.cpu_count()<split> | dataset['Passenger']=dataset['SibSp']+dataset['Parch']+1
dataset
| Titanic - Machine Learning from Disaster |
13,459,641 | verbose = True
k = 5
y_pred_logit_snapml = np.zeros(X_test.shape[0])
validation_auc = 0
snapml_fit_time = 0
cv = StratifiedKFold(n_splits=k, shuffle=True, random_state=1)
for n_fold,(train_indices, val_indices)in enumerate(cv.split(X, y), start=1):
print(f'{n_fold}.fold(out of {k})is running.')
X_train = X[train_ind... | sky=LogisticRegression()
leaks = {
897:1,
899:1,
930:1,
932:1,
949:1,
987:1,
995:1,
998:1,
999:1,
1016:1,
1047:1,
1083:1,
1097:1,
1099:1,
1103:1,
1115:1,
}
| Titanic - Machine Learning from Disaster |
13,459,641 | <train_model><EOS> | sky.fit(train,target)
a=sky.predict(test)
submission['Survived']=a
submission['Survived'] = submission['Survived'].apply(lambda x: 1 if x>0.8 else 0)
submission['Survived'] = submission.apply(lambda r: leaks[int(r['PassengerId'])] if int(r['PassengerId'])in leaks else r['Survived'], axis=1)
submission.to_csv('sub_t... | Titanic - Machine Learning from Disaster |
13,407,226 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | mpl.rcParams.update({'font.size': 13} ) | Titanic - Machine Learning from Disaster |
13,407,226 | filepath = 'submission.csv'<save_to_csv> | folder = '/kaggle/input/titanic/'
train = pd.read_csv(folder + 'train.csv')
train_shape = train.shape
test = pd.read_csv(folder + 'test.csv')
test_shape = test.shape
target = 'survived'
train.columns = train.columns.str.lower()
test.columns = test.columns.str.lower() | Titanic - Machine Learning from Disaster |
13,407,226 | submission = pd.DataFrame({
"ID_code": id_codes,
"target": y_pred_logit_snapml
})
submission.to_csv(filepath, index=False )<set_options> | train.apply(lambda col: len(col.unique())) | Titanic - Machine Learning from Disaster |
13,407,226 | %matplotlib inline
warnings.filterwarnings('ignore' )<load_from_csv> | train.drop('fare', axis=1, inplace=True)
test.drop('fare', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
13,407,226 | train = pd.read_csv("/kaggle/input/santander-customer-transaction-prediction/train.csv")
test = pd.read_csv("/kaggle/input/santander-customer-transaction-prediction/test.csv" )<sort_values> | def check_features_list(features):
if type(features)== str:
features = [features]
return features
def convert_categorical_features(df, cat_features):
if len(cat_features)== 0:
return df
cat_features = check_features_list(cat_features)
for feature in cat_features:
dummies = pd.get_dummies(df[feature], prefix=featur... | Titanic - Machine Learning from Disaster |
13,407,226 | correlations = train[features].corr().abs().unstack().sort_values(kind="quicksort" ).reset_index()
correlations = correlations[correlations['level_0'] != correlations['level_1']]
correlations.head(10 )<count_unique_values> | lr = LogisticRegression()
cat_features = ['pclass','sex','embarked']
for feature in cat_features:
accuracy = evaluate_lr_model(train, cat_features=feature)
print('{}: {:.2f}%'.format(feature, accuracy*100))
num_features = ['sibsp','parch']
for feature in num_features:
accuracy = evaluate_lr_model(train, num_features=f... | Titanic - Machine Learning from Disaster |
13,407,226 | features = train.columns.values[2:202]
unique_max_train = []
unique_max_test = []
for feature in features:
values = train[feature].value_counts()
unique_max_train.append([feature, values.max() , values.idxmax() ])
values = test[feature].value_counts()
unique_max_test.append([feature, values.max() , values.idxmax() ] )... | accuracy = evaluate_lr_model(train, cat_features, num_features)
print('{}: {:.2f}%'.format(cat_features + num_features, accuracy*100)) | 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.