kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,161,774 | df_train_original = pd.read_csv('.. /input/exam-for-students20200129/train.csv', index_col=0)
df_test_original = pd.read_csv('.. /input/exam-for-students20200129/test.csv',index_col=0)
target = 'ConvertedSalary'
df_country_original = pd.read_csv('.. /input/exam-for-students20200129/country_info.csv')
df_train_original.shape, df_test_original.shape<create_dataframe> | train_df['Cabin'] = train_df['Cabin'].fillna('X')
test_df['Cabin']=test_df['Cabin'].fillna('X' ) | Titanic - Machine Learning from Disaster |
10,161,774 | df_train = df_train_original.copy()
df_test = df_test_original.copy()
df_country = df_country_original.copy()
df_test_with_targetcol = df_test_original.copy()
df_test_with_targetcol[target] = -1
df_all = pd.concat([df_train, df_test_with_targetcol], axis=0 )<merge> | for data in df:
data['Cabin'] = data['Cabin'].map(lambda x: re.compile("([a-zA-Z]+)" ).search(x ).group())
category = {'A':1, 'B':2, 'C':3, 'D':4, 'E':5, 'F':6, 'G':7, 'X':8, 'T':9}
for data in df:
data['Cabin'] = data['Cabin'].map(category ) | Titanic - Machine Learning from Disaster |
10,161,774 | df_GDP = df_country[['Country', 'GDP($ per capita)']]
df_train = df_train.merge(df_GDP, on = ['Country'], how = 'left')
df_test = df_test.merge(df_GDP, on = ['Country'], how = 'left')
df_all = df_all.merge(df_GDP, on = ['Country'], how = 'left' )<count_values> | train_df['Fare'] = pd.to_numeric(train_df['Fare'] ) | Titanic - Machine Learning from Disaster |
10,161,774 | c = 'Country'
df_train[c].value_counts()<count_values> | label = {'male':1, 'female':0}
train_df.replace({'Sex':label}, inplace = True)
test_df.replace({'Sex':label}, inplace = True ) | Titanic - Machine Learning from Disaster |
10,161,774 | df_test[c].value_counts()
<filter> | for data in df:
data['FamilySize'] = data['SibSp'] + data['Parch'] + 1
train_df[['FamilySize', 'Survived']].groupby(['FamilySize'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
10,161,774 | df_train[df_train['Country'] == 'Germany']
df_train[df_train['Country'] == 'France']<count_values> | for data in df:
data['IsAlone'] = 0
data.loc[data['FamilySize'] == 1, 'IsAlone'] = 1
train_df[['IsAlone', 'Survived']].groupby(['IsAlone'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
10,161,774 | for col in df_all.columns:
print(df_all[col].value_counts())
print('____')
<define_variables> | train_df.drop(['PassengerId', 'Name', 'Ticket', 'Age', 'SibSp', 'Parch', 'FamilySize'], axis = 1, inplace = True)
test_df.drop(['Name', 'Ticket', 'Age', 'SibSp', 'Parch', 'FamilySize'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
10,161,774 | first_log = True<concatenate> | X = train_df.drop('Survived', axis = 1)
y = train_df['Survived'] | Titanic - Machine Learning from Disaster |
10,161,774 | y_train = df_train[target]
X_train = df_train.drop([target], axis=1)
X_test = df_test
X_all = pd.concat([X_train, X_test], axis = 0)
X_train = X_train[y_train.isnull() ==False]
y_train = y_train[y_train.isnull() ==False]
if(first_log == True):
y_train = y_train.apply(np.log1p )<create_dataframe> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 123 ) | Titanic - Machine Learning from Disaster |
10,161,774 | TXT_train_DevType = X_train.DevType.copy()
TXT_test_DevType = X_test.DevType.copy()
TXT_train_CommunicationTools = X_train.CommunicationTools.copy()
TXT_test_CommunicationTools = X_test.CommunicationTools.copy()
TXT_train_FrameworkWorkedWith = X_train.FrameworkWorkedWith.copy()
TXT_test_FrameworkWorkedWith = X_test.FrameworkWorkedWith.copy()
TXT_train_DevType.fillna('
TXT_test_DevType.fillna('
TXT_train_CommunicationTools.fillna('
TXT_test_CommunicationTools.fillna('
TXT_train_FrameworkWorkedWith.fillna('
TXT_test_FrameworkWorkedWith.fillna('<feature_engineering> | from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
10,161,774 | X_train['missing_sum'] = X_train.isnull().sum(axis=1)
X_test['missing_sum'] = X_test.isnull().sum(axis=1 )<data_type_conversions> | lr = LogisticRegression()
lr.fit(X_train, y_train)
y_pred = lr.predict(X_test)
print('Classification Report:
', classification_report(y_pred, y_test))
lr_train_acc = round(lr.score(X_train, y_train)* 100, 2)
print('Training Accuracy: ', lr_train_acc)
lr_test_acc = round(lr.score(X_test, y_test)* 100, 2)
print('Testing Accuracy: ', lr_test_acc ) | Titanic - Machine Learning from Disaster |
10,161,774 | X_train['DevType'].fillna('
X_test['DevType'].fillna('
X_train['CommunicationTools'].fillna('
X_test['CommunicationTools'].fillna('
X_train['FrameworkWorkedWith'].fillna('
X_test['FrameworkWorkedWith'].fillna('<categorify> | knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
print('Classification Report:
', classification_report(y_pred, y_test))
knn_train_acc = round(knn.score(X_train, y_train)* 100, 2)
print('Training Accuracy: ', knn_train_acc)
knn_test_acc = round(knn.score(X_test, y_test)* 100, 2)
print('Testing Accuracy: ', knn_test_acc ) | Titanic - Machine Learning from Disaster |
10,161,774 | def mapping(map_col, mapping):
X_train[map_col]=X_train[map_col].map(mapping)
X_test[map_col]=X_test[map_col].map(mapping )<define_variables> | svc = SVC()
param_grid = {'C': [0.01, 0.1, 1 ,10 , 100], 'kernel':['linear', 'rbf'], 'gamma':[0.1, 1, 10, 100]}
gcv = GridSearchCV(estimator = svc, param_grid = param_grid, cv = 5, n_jobs=-1, refit=True)
gcv.fit(X_train, y_train)
gcv.best_params_ | Titanic - Machine Learning from Disaster |
10,161,774 | Age_mapping = {'Under 18 years old':18, '18 - 24 years old':24, '25 - 34 years old':34, '35 - 44 years old':44,
'45 - 54 years old':54, '55 - 64 years old':64, '65 years or older':65}
CompanySize_mapping ={'Fewer than 10 employees':10, '10 to 19 employees':19,
'20 to 99 employees':99, '100 to 499 employees':499, '500 to 999 employees':999,
'1,000 to 4,999 employees':4999, '5,000 to 9,999 employees':9999,
'10,000 or more employees':20000}
Exercise_mapping = {'I don't typically exercise':0, '1 - 2 times per week':2,
'3 - 4 times per week':4, 'Daily or almost every day':7}
HoursComputer_mapping = {'Less than 1 hour':1, '1 - 4 hours':4, '5 - 8 hours':8, '9 - 12 hours':12, 'Over 12 hours':15}
HoursOutside_mapping = {'Less than 30 minutes':0.5, '30 - 59 minutes':1, '1 - 2 hours':2, '3 - 4 hours':4, 'Over 4 hours':6}
LastNewJob_mapping = {'I've never had a job':0, 'Less than a year ago':1, 'Between 1 and 2 years ago':2,
'Between 2 and 4 years ago':4, 'More than 4 years ago': 5}
SkipMeals_mapping = {'Never':0, '1 - 2 times per week':2, '3 - 4 times per week':4, 'Daily or almost every day':7}
StackOverflowJobsRecommend_mapping = {'0(Not Likely)':0, '1':1, '2':2, '3':3, '4':4, '5':5, '6':6, '7':7, '8':8, '9':9,
'10(Very Likely)':10}
YearsCoding_mapping ={'0-2 years':2, '3-5 years':5, '6-8 years': 8, '9-11 years':11, '12-14 years':14, '15-17 years':17,
'18-20 years':20, '21-23 years':23, '24-26 years':26,
'27-29 years':29, '30 or more years':25}
YearsCodingProf_mapping = YearsCoding_mapping<categorify> | svc = SVC(C = 10, gamma = 0.1, kernel = 'rbf')
svc.fit(X_train,y_train)
y_pred = svc.predict(X_test)
print('Classification Report:
', classification_report(y_pred, y_test))
svc_train_acc = round(svc.score(X_train, y_train)* 100, 2)
print('Training Accuracy: ', svc_train_acc)
svc_test_acc = round(svc.score(X_test, y_test)* 100, 2)
print('Testing Accuracy: ', svc_test_acc ) | Titanic - Machine Learning from Disaster |
10,161,774 | mapping('Age', Age_mapping)
mapping('CompanySize', CompanySize_mapping)
mapping('Exercise', Exercise_mapping)
mapping('HoursComputer', HoursComputer_mapping)
mapping('HoursOutside', HoursOutside_mapping)
mapping('LastNewJob', LastNewJob_mapping)
mapping('SkipMeals', SkipMeals_mapping)
mapping('StackOverflowJobsRecommend', StackOverflowJobsRecommend_mapping)
mapping('YearsCoding', YearsCoding_mapping)
mapping('YearsCodingProf', YearsCodingProf_mapping )<feature_engineering> | dt = DecisionTreeClassifier(max_depth = 6, min_samples_leaf = 2)
dt.fit(X_train, y_train)
y_pred = dt.predict(X_test)
print('Classification Report:
', classification_report(y_pred, y_test))
dt_train_acc = round(dt.score(X_train, y_train)* 100, 2)
print('Training Accuracy: ', dt_train_acc)
dt_test_acc = round(dt.score(X_test, y_test)* 100, 2)
print('Testing Accuracy: ', dt_test_acc ) | Titanic - Machine Learning from Disaster |
10,161,774 | count_col = ['DevType', 'CommunicationTools', 'FrameworkWorkedWith']
for i in count_col:
X_train[i + '_count'] = X_train[i].apply(lambda x: len(re.split('\s*;\s*', x)))
X_test[i + '_count'] = X_test[i].apply(lambda x: len(re.split('\s*;\s*', x)) )<feature_engineering> | rf = RandomForestClassifier()
param_grid = {'max_depth': [2, 4, 5, 6, 7, 8], 'criterion':['gini', 'entropy'], 'min_samples_leaf':[1, 2 ,4 ,6], 'max_features':['auto', 'log2'], 'n_estimators':[100,150,200]}
gcv = GridSearchCV(estimator=rf, param_grid=param_grid, cv = 5, n_jobs = -1)
gcv.fit(X_train, y_train)
gcv.best_params_ | Titanic - Machine Learning from Disaster |
10,161,774 | X_train['Github'] = X_train['CommunicationTools'].str.contains('Github')
X_test['Github'] = X_test['CommunicationTools'].str.contains('Github')
X_train['Full-stack'] = X_train['DevType'].str.contains('Full-stack')
X_test['Full-stack'] = X_test['DevType'].str.contains('Full-stack')
X_train['DataScientist'] = X_train['DevType'].str.contains('Data scientist')
X_test['DataScientist'] = X_test['DevType'].str.contains('Data scientist' )<drop_column> | rf = RandomForestClassifier(max_depth = 8, min_samples_leaf = 6, n_estimators = 150)
rf.fit(X_train, y_train)
y_pred = rf.predict(X_test)
print('Classification Report:
', classification_report(y_pred, y_test))
rf_train_acc = round(rf.score(X_train, y_train)* 100, 2)
print('Training Accuracy: ', rf_train_acc)
rf_test_acc = round(rf.score(X_test, y_test)* 100, 2)
print('Testing Accuracy: ', rf_test_acc ) | Titanic - Machine Learning from Disaster |
10,161,774 | del X_train['Country']
del X_test['Country']
del X_train['DevType']
del X_test['DevType']
del X_train['CommunicationTools']
del X_test['CommunicationTools']
del X_train['FrameworkWorkedWith']
del X_test['FrameworkWorkedWith']
del X_train['MilitaryUS']
del X_test['MilitaryUS']
del X_train['SurveyTooLong']
del X_test['SurveyTooLong']
del X_train['SurveyEasy']
del X_test['SurveyEasy']<data_type_conversions> | adb = AdaBoostClassifier(rf, n_estimators = 200)
adb.fit(X_train, y_train)
y_pred = adb.predict(X_test)
print('Classification Report:
', classification_report(y_pred, y_test))
adb_train_acc = round(adb.score(X_train, y_train)* 100, 2)
print('Training Accuracy: ', adb_train_acc)
adb_test_acc = round(adb.score(X_test, y_test)* 100, 2)
print('Testing Accuracy: ', adb_test_acc ) | Titanic - Machine Learning from Disaster |
10,161,774 | X_train['AssessJob_null'] = X_train['AssessJob1'].isnull().astype(int)
X_test['AssessJob_null'] = X_test['AssessJob1'].isnull().astype(int)
X_train['AssessBenefits_null'] = X_train['AssessBenefits1'].isnull().astype(int)
X_test['AssessBenefits_null'] = X_train['AssessBenefits1'].isnull().astype(int)
X_train['JobContactPriorities_null'] = X_train['JobContactPriorities1'].isnull().astype(int)
X_test['JobContactPriorities_null'] = X_test['JobContactPriorities1'].isnull().astype(int)
X_train['JobEmailPriorities_null'] = X_train['JobEmailPriorities1'].isnull().astype(int)
X_test['JobEmailPriorities_null'] = X_train['JobEmailPriorities1'].isnull().astype(int)
X_train['questionaare_missing_count'] = X_train['AssessJob_null'] + X_train['AssessBenefits_null'] + X_train['JobContactPriorities_null'] + X_train['JobEmailPriorities_null']
X_test['questionaare_missing_count'] = X_test['AssessJob_null'] + X_test['AssessBenefits_null'] + X_test['JobContactPriorities_null'] + X_test['JobEmailPriorities_null']
del X_train['AssessJob_null']
del X_test['AssessJob_null']
del X_train['AssessBenefits_null']
del X_test['AssessBenefits_null']
del X_train['JobContactPriorities_null']
del X_test['JobContactPriorities_null']
del X_train['JobEmailPriorities_null']
del X_test['JobEmailPriorities_null']<categorify> | gdb = GradientBoostingClassifier()
params = {'learning_rate':[0.01,0.1,1,10],'n_estimators':[100,150,200,300],'subsample':[0.6,0.8,1.0],'max_depth':[2,3,4,6],'min_samples_leaf':[1,2,4,6]}
gcv = GridSearchCV(estimator=gdb, param_grid=params, cv=5, n_jobs=-1)
gcv.fit(X_train, y_train)
gcv.best_params_ | Titanic - Machine Learning from Disaster |
10,161,774 | col_yj_transform = ['GDP($ per capita)']
for col in col_yj_transform:
pt = PowerTransformer(method='yeo-johnson')
reshape_train = X_train[col].values.reshape(-1,1)
reshape_test = X_test[col].values.reshape(-1,1)
pt.fit(reshape_train)
X_train[col] = pt.transform(reshape_train)
X_test[col] = pt.transform(reshape_test )<count_unique_values> | gdb = GradientBoostingClassifier(max_depth = 2, n_estimators = 300, subsample = 0.8)
gdb.fit(X_train, y_train)
y_pred = gdb.predict(X_test)
print('Classification Report:
', classification_report(y_pred, y_test))
gdb_train_acc = round(gdb.score(X_train, y_train)* 100, 2)
print('Training Accuracy: ', gdb_train_acc)
gdb_test_acc = round(gdb.score(X_test, y_test)* 100, 2)
print('Testing Accuracy: ', gdb_test_acc ) | Titanic - Machine Learning from Disaster |
10,161,774 | cats = []
for col in X_train.columns:
if(X_train[col].dtype == 'object'):
cats.append(col)
print(col, X_train[col].nunique() )<categorify> | xgbc = XGBClassifier(max_depth = 4)
xgbc.fit(X_train, y_train)
y_pred = xgbc.predict(X_test)
print('Classification Report:
', classification_report(y_pred, y_test))
xgbc_train_acc = round(xgbc.score(X_train, y_train)* 100, 2)
print('Training Accuracy: ', xgbc_train_acc)
xgbc_test_acc = round(xgbc.score(X_test, y_test)* 100, 2)
print('Testing Accuracy: ', xgbc_test_acc ) | Titanic - Machine Learning from Disaster |
10,161,774 | ordinal_col = cats
ordinal_encoder = OrdinalEncoder(cols = ordinal_col)
X_train = ordinal_encoder.fit_transform(X_train)
X_test = ordinal_encoder.transform(X_test )<train_model> | test_df['Fare'] = pd.to_numeric(test_df['Fare'] ) | Titanic - Machine Learning from Disaster |
10,161,774 | X_train.fillna(-9999, inplace = True)
X_test.fillna(-9999, inplace = True )<count_values> | test_df['Survived'] = rf.predict(test_df.drop(['PassengerId'], axis = 1))
test_df[['PassengerId', 'Survived']].to_csv('MySubmission.csv', index = False ) | Titanic - Machine Learning from Disaster |
9,761,238 | for col in X_train.columns:
print(X_train[col].value_counts())
print('____' )<split> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
9,761,238 | %%time
num_split = 5
num_iter = 3
stop_round = 50
scores = []
y_pred_cva = np.zeros(len(X_test))
scores = []
for h in range(num_iter):
kf = KFold(n_splits=num_split, random_state=h, shuffle=True)
for i,(train_ix, test_ix)in tqdm(enumerate(kf.split(X_train, y_train))):
X_train_, y_train_ = X_train.values[train_ix], y_train.values[train_ix]
X_val, y_val = X_train.values[test_ix], y_train.values[test_ix]
clf = LGBMRegressor(n_estimators=9999, random_state=71, colsample_bytree=0.9,
learning_rate=0.05, min_child_samples=20,
min_child_weight=0.001, min_split_gain=0.0, num_leaves=15)
clf.fit(X_train_, y_train_, early_stopping_rounds=stop_round, eval_metric='rmse', eval_set=[(X_val, y_val)])
y_pred = clf.predict(X_val)
score = mean_squared_error(y_val, y_pred)**0.5
scores.append(score)
y_pred_cva += clf.predict(X_test)
print(clf.predict(X_test))
print(np.mean(scores))
print(scores)
y_pred_cva /=(num_split * num_iter )<prepare_output> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
9,761,238 | y_pred_exp = np.exp(y_pred_cva)- 1
y_pred_exp<load_from_csv> | pip install lofo-importance | Titanic - Machine Learning from Disaster |
9,761,238 | submission = pd.read_csv('.. /input/exam-for-students20200129/sample_submission.csv', index_col=0)
submission.ConvertedSalary = y_pred_exp<save_to_csv> | %matplotlib inline | Titanic - Machine Learning from Disaster |
9,761,238 | submission.to_csv('submission.csv')
submission<set_options> | lr = lgb.LGBMClassifier()
lr.fit(X_test[["Pclass", "Sex", "SibSp", "Parch" ,"Age", "Fare" , "Embarked"]], X_test["Survived"])
fi = FLOFOImportance(lr, X_test, ["Pclass", "Sex", "SibSp", "Parch" ,"Age", "Fare" , "Embarked"], 'Survived', scoring="neg_mean_absolute_error")
importances = fi.get_importance()
importances | Titanic - Machine Learning from Disaster |
9,761,238 | %matplotlib inline
plt.style.use('ggplot')
pd.set_option('display.max_columns', 500)
pd.set_option('display.max_rows', 20 )<import_modules> | y = train_data["Survived"]
features = ["Pclass", "Sex", "SibSp", "Parch" ,"Age", "Fare" , "Embarked"]
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
model = lgb.LGBMClassifier().fit(X, y ) | Titanic - Machine Learning from Disaster |
9,761,238 | from sklearn.preprocessing import StandardScaler
from sklearn.metrics import roc_auc_score
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import StratifiedKFold, KFold
from sklearn.feature_extraction.text import TfidfVectorizer
from category_encoders import OrdinalEncoder, OneHotEncoder, TargetEncoder, CatBoostEncoder
from tqdm import tqdm_notebook as tqdm
import lightgbm as lgb
from lightgbm import LGBMClassifier
<load_from_csv> | params = {"num_leaves": [16,12,8,4],
"learning_rate": [0.4, 0.1, 0.8, 0.05],
"max_depth":[10,8,6,4],
"feature_fraction": [0.1, 0.3, 0.5, 0.8],
"subsample": [0.2, 0.5, 0.75]} | Titanic - Machine Learning from Disaster |
9,761,238 | df_train = pd.read_csv('.. /input/exam-for-students20200129/train.csv', index_col=0)
<load_from_csv> | cv_model = GridSearchCV(model , params, cv=10, verbose=2 , n_jobs=-1 ).fit(X , y ) | Titanic - Machine Learning from Disaster |
9,761,238 | df_test = pd.read_csv('.. /input/exam-for-students20200129/test.csv', index_col=0)
<define_variables> | cv_model.best_params_ | Titanic - Machine Learning from Disaster |
9,761,238 | tgt_col = 'ConvertedSalary'<data_type_conversions> | model_tuned = lgb.LGBMClassifier(max_depth= 10, feature_fraction=0.1, learning_rate=0.1,
num_leaves= 16,
subsample= 0.2 ).fit(X , y ) | Titanic - Machine Learning from Disaster |
9,761,238 | df_train2 = df_train.copy()
df_test2 = df_test.copy()
df_train2['missing_amnt'] = df_train2.isnull().sum(axis=1)
df_test2['missing_amnt'] = df_test2.isnull().sum(axis=1 )<feature_engineering> | output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
9,287,401 | df_train2[tgt_col] = np.log1p(df_train2[tgt_col] )<prepare_x_and_y> | train = pd.read_csv(".. /input/titanic/train.csv")
test = pd.read_csv(".. /input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
9,287,401 | y_train = df_train2[tgt_col]
X_train = df_train2.drop([tgt_col], axis=1)
X_test = df_test2<normalization> | data_size_train = train.memory_usage().sum() / 1024 / 1024
print("Data memory size: %.2f MB" % data_size_train ) | Titanic - Machine Learning from Disaster |
9,287,401 | num_cols = []
for col in X_train.columns:
if X_train[col].dtype == 'int64' or X_train[col].dtype == 'float64':
num_cols.append(col)
scaler = StandardScaler()
scaler.fit(X_train[num_cols])
X_train[num_cols] = scaler.transform(X_train[num_cols])
X_test[num_cols] = scaler.transform(X_test[num_cols] )<categorify> | data_size_test = test.memory_usage().sum() / 1024 / 1024
print("Data memory size: %.2f MB" % data_size_test ) | Titanic - Machine Learning from Disaster |
9,287,401 | def student_enc(x):
if x == 'No':
return 3
elif x == 'Yes, part-time':
return 2
elif x == 'Yes, full-time':
return 1<feature_engineering> | train["NameTitle"] = train["Name"].str.split(", ", expand = True)[1].str.split(".", expand = True)[0]
test["NameTitle"] = test["Name"].str.split(", ", expand = True)[1].str.split(".", expand = True)[0]
train = train.drop("Name", axis = 1)
test = test.drop("Name", axis = 1)
print(train["NameTitle"].unique())
print("------------------------" * 3)
print(test["NameTitle"].unique() ) | Titanic - Machine Learning from Disaster |
9,287,401 | X_train['Student'] = X_train['Student'].apply(student_enc)
X_test['Student'] = X_test['Student'].apply(student_enc )<categorify> | min_titles =(train["NameTitle"].value_counts() < 10)
train["NameTitle"] = train["NameTitle"].apply(lambda x: "Misc" if min_titles.loc[x] == True else x)
print(train["NameTitle"].unique() ) | Titanic - Machine Learning from Disaster |
9,287,401 | def company_size_enc(x):
if x == 'Fewer than 10 employees':
return 1
elif x == '10 to 19 employees':
return 2
elif x == '20 to 99 employees':
return 3
elif x == '100 to 499 employees':
return 4
elif x == '500 to 999 employees':
return 5
elif x == '1,000 to 4,999 employees':
return 6
elif x == '5,000 to 9,999 employees':
return 7
elif x == '10,000 or more employees':
return 8<feature_engineering> | min_titles =(test["NameTitle"].value_counts() < 10)
test["NameTitle"] = test["NameTitle"].apply(lambda x: "Misc" if min_titles.loc[x] == True else x)
print(test["NameTitle"].unique() ) | Titanic - Machine Learning from Disaster |
9,287,401 | X_train['CompanySize'] = X_train['CompanySize'].apply(company_size_enc)
X_test['CompanySize'] = X_test['CompanySize'].apply(company_size_enc )<categorify> | train["FamilySize"] = train["SibSp"] + train["Parch"]
test["FamilySize"] = test["SibSp"] + test["Parch"] | Titanic - Machine Learning from Disaster |
9,287,401 | def years_coding_enc(x):
if x == '0-2 years':
return 1
elif x == '3-5 years':
return 2
elif x == '6-8 years':
return 3
elif x == '9-11 years':
return 4
elif x == '12-14 years':
return 5
elif x == '15-17 years':
return 6
elif x == '18-20 years':
return 7
elif x == '21-23 years':
return 8
elif x == '24-26 years':
return 9
elif x == '27-29 years':
return 10
elif x == '30 or more years':
return 11<categorify> | train["AgeGroup"] = ""
train.loc[train["Age"] < 21, "AgeGroup"] = "under 21"
train.loc[train["Age"] >= 21, "AgeGroup"] = "21-65"
train.loc[train["Age"] > 65, "AgeGroup"] = "65+"
test["AgeGroup"] = ""
test.loc[test["Age"] < 21, "AgeGroup"] = "under 21"
test.loc[test["Age"] >= 21, "AgeGroup"] = "21-65"
test.loc[test["Age"] > 65, "AgeGroup"] = "65+"
train = train.drop("Age", axis = 1)
test = test.drop("Age", axis = 1 ) | Titanic - Machine Learning from Disaster |
9,287,401 | X_train['YearsCoding'] = X_train['YearsCoding'].apply(years_coding_enc)
X_test['YearsCoding'] = X_test['YearsCoding'].apply(years_coding_enc )<categorify> | train["FareGroup"] = ""
train.loc[train["Fare"] < 170, "FareGroup"] = "0-170"
train.loc[train["Fare"] >= 170, "FareGroup"] = "170-340"
train.loc[train["Fare"] > 340, "FareGroup"] = "340+"
test["FareGroup"] = ""
test.loc[test["Fare"] < 170, "FareGroup"] = "0-170"
test.loc[test["Fare"] >= 170, "FareGroup"] = "170-340"
test.loc[test["Fare"] > 340, "FareGroup"] = "340+"
train = train.drop("Fare", axis = 1)
test = test.drop("Fare", axis = 1 ) | Titanic - Machine Learning from Disaster |
9,287,401 | def years_coding_prof_enc(x):
if x == '0-2 years':
return 1
elif x == '3-5 years':
return 2
elif x == '6-8 years':
return 3
elif x == '9-11 years':
return 4
elif x == '12-14 years':
return 5
elif x == '15-17 years':
return 6
elif x == '18-20 years':
return 7
elif x == '21-23 years':
return 8
elif x == '24-26 years':
return 9
elif x == '27-29 years':
return 10
elif x == '30 or more years':
return 11<feature_engineering> | train = train.drop(["SibSp", "Parch"], axis = 1)
test = test.drop(["SibSp", "Parch"], axis = 1 ) | Titanic - Machine Learning from Disaster |
9,287,401 | X_train['YearsCodingProf'] = X_train['YearsCodingProf'].apply(years_coding_prof_enc)
X_test['YearsCodingProf'] = X_test['YearsCodingProf'].apply(years_coding_prof_enc )<categorify> | train = pd.get_dummies(train, columns = ["Sex", "Embarked", "NameTitle", "AgeGroup", "FareGroup"])
test = pd.get_dummies(test, columns = ["Sex", "Embarked", "NameTitle", "AgeGroup", "FareGroup"] ) | Titanic - Machine Learning from Disaster |
9,287,401 | def job_satisfaction_enc(x):
if x == 'Extremely dissatisfied':
return 1
elif x == 'Moderately dissatisfied':
return 2
elif x == 'Slightly dissatisfied':
return 3
elif x == 'Neither satisfied nor dissatisfied':
return 4
elif x == 'Slightly satisfied':
return 5
elif x == 'Moderately satisfied':
return 6
elif x == 'Extremely satisfied':
return 7<feature_engineering> | upper = corr.where(np.triu(np.ones(corr.shape), k = 1 ).astype(np.bool))
to_drop = [column for column in upper.columns if any(upper[column] > 0.90)]
print(to_drop ) | Titanic - Machine Learning from Disaster |
9,287,401 | X_train['JobSatisfaction'] = X_train['JobSatisfaction'].apply(job_satisfaction_enc)
X_test['JobSatisfaction'] = X_test['JobSatisfaction'].apply(job_satisfaction_enc )<categorify> | X = train.drop(["PassengerId", "Survived"], axis = 1)
Y = train["Survived"] | Titanic - Machine Learning from Disaster |
9,287,401 | def career_satisfaction_enc(x):
if x == 'Extremely dissatisfied':
return 1
elif x == 'Moderately dissatisfied':
return 2
elif x == 'Slightly dissatisfied':
return 3
elif x == 'Neither satisfied nor dissatisfied':
return 4
elif x == 'Slightly satisfied':
return 5
elif x == 'Moderately satisfied':
return 6
elif x == 'Extremely satisfied':
return 7<feature_engineering> | from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, BaggingClassifier, ExtraTreesClassifier, StackingClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from catboost import CatBoostClassifier
from xgboost import XGBClassifier
import lightgbm as lgb | Titanic - Machine Learning from Disaster |
9,287,401 | X_train['CareerSatisfaction'] = X_train['CareerSatisfaction'].apply(career_satisfaction_enc)
X_test['CareerSatisfaction'] = X_test['CareerSatisfaction'].apply(career_satisfaction_enc )<categorify> | style.use("seaborn-whitegrid")
%matplotlib inline
%config InlineBackend.figure_format = "retina"
def model_builder(X, Y, pipeline, params, kfolds, classifier_name, data_split = False):
if data_split == True:
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
random_state = 0,
test_size = 0.25)
cv = StratifiedKFold(n_splits = kfolds)
start = time.time()
grid = GridSearchCV(pipeline, params, cv = cv, verbose = 0, n_jobs = -1)
grid = grid.fit(X_train, Y_train)
print("Best Params:")
print("")
print(grid.best_params_)
grid = grid.best_estimator_
classifier_score = cross_val_score(grid, X_test, Y_test, cv = cv, n_jobs = -1)
Y_predicted = grid.predict(X_test)
stop = time.time()
print("")
print("
print("Cross-Validated-Score: " + str(round(classifier_score.mean() , 6)))
print("
print("")
print("Training time: " + str(round(stop - start, 2)) + "s")
train_size, train_score, test_score = learning_curve(grid, X_train, Y_train, cv = cv, n_jobs = -1)
print("")
print("Learning Curve:")
plt.figure(figsize =(12,6))
plt.plot(train_size, np.mean(train_score, axis = 1), label = "Train scores")
plt.plot(train_size, np.mean(test_score, axis = 1), label = "Test scores")
plt.title(classifier_name)
plt.legend()
plt.show()
return X_train, X_test, Y_train, Y_test, classifier_score, grid
if data_split == False:
cv = StratifiedKFold(n_splits = kfolds)
start = time.time()
grid = GridSearchCV(pipeline, params, cv = cv, verbose = 0, n_jobs = -1)
grid = grid.fit(X, Y)
print("Best Params:")
print("")
print(grid.best_params_)
grid = grid.best_estimator_
classifier_score = cross_val_score(grid, X, Y, cv = cv, n_jobs = -1)
Y_predicted = grid.predict(X)
stop = time.time()
print("")
print("
print("Cross-Validated-Score: " + str(round(classifier_score.mean() , 6)))
print("
print("")
print("Training time: " + str(round(stop - start, 2)) + "s")
train_size, train_score, test_score = learning_curve(grid, X, Y, cv = cv, n_jobs = -1)
print("")
print("Learning Curve:")
plt.figure(figsize =(12,6))
plt.plot(train_size, np.mean(train_score, axis = 1), label = "Train scores")
plt.plot(train_size, np.mean(test_score, axis = 1), label = "Test scores")
plt.title(classifier_name)
plt.legend()
plt.show()
return classifier_score, grid | Titanic - Machine Learning from Disaster |
9,287,401 | def age_enc(x):
if x == 'Under 18 years old':
return 1
elif x == '18 - 24 years old':
return 2
elif x == '25 - 34 years old':
return 3
elif x == '35 - 44 years old':
return 4
elif x == '45 - 54 years old':
return 5
elif x == '55 - 64 years old':
return 6
elif x == '65 years or older':
return 7<feature_engineering> | pipe_xgb = Pipeline([
("scaler", StandardScaler()),
("pca", PCA()),
("xgb", XGBClassifier())])
params_xgb = {
"pca__n_components" : [2, 6, 10, 18],
"xgb__n_estimators" : [300, 500, 700],
"xgb__learning_rate" : [0.005, 0.1],
"xgb__max_depth" : [5, 7],
"xgb__max_features" : [3, 5],
"xgb__gamma" : [0.5, 0.6, 0.7]}
xgb_score, grid_xgb = model_builder(X, Y, pipe_xgb, params_xgb, 10, "XGBoost")
Y_predicted_xgb = grid_xgb.predict_proba(X)[:, 1] | Titanic - Machine Learning from Disaster |
9,287,401 | X_train['Age'] = X_train['Age'].apply(age_enc)
X_test['Age'] = X_test['Age'].apply(age_enc )<categorify> | pipe_boost = Pipeline([
("scaler", StandardScaler()),
("pca", PCA()),
("boost", GradientBoostingClassifier())])
params_boost = {
"pca__n_components" : [2, 6, 10, 18],
"boost__n_estimators" : [300, 500, 700],
"boost__learning_rate" : [0.005, 0.1],
"boost__max_depth" : [3, 5],
"boost__max_features" : [3, 5]}
boost_score, grid_boost = model_builder(X, Y, pipe_boost, params_boost, 10, "Gradient Boosting")
Y_predicted_boost = grid_boost.predict_proba(X)[:, 1] | Titanic - Machine Learning from Disaster |
9,287,401 | def edu_enc(x):
if x == 'They never completed any formal education':
return 1
elif x == 'Primary/elementary school':
return 2
elif x == 'Secondary school(e.g.American high school, German Realschule or Gymnasium, etc.) ':
return 3
elif x == 'Some college/university study without earning a degree':
return 4
elif x == 'Bachelor’s degree(BA, BS, B.Eng., etc.) ':
return 6
elif x == 'Master’s degree(MA, MS, M.Eng., MBA, etc.) ':
return 7
elif x == 'Associate degree':
return 5
elif x == 'Other doctoral degree(Ph.D, Ed.D., etc.) ':
return 8
elif x == 'Professional degree(JD, MD, etc.) ':
return 9<count_unique_values> | pipe_xt = Pipeline([
("scaler", StandardScaler()),
("pca", PCA()),
("xt", ExtraTreesClassifier(criterion = "gini",
max_features = "auto")) ])
params_xt = {
"pca__n_components" : [2, 6, 10, 18],
"xt__n_estimators" : [300, 500, 700],
"xt__max_depth" : [5, 7, 9]}
xt_score, grid_xt = model_builder(X, Y, pipe_xt, params_xt, 10, "Extra Trees")
Y_predicted_xt = grid_xt.predict_proba(X)[:, 1] | Titanic - Machine Learning from Disaster |
9,287,401 | cat_cols = []
for col in X_train.columns:
if X_train[col].dtype == 'object':
cat_cols.append(col)
<categorify> | pipe_knn = Pipeline([
("scaler", StandardScaler()),
("knn", KNeighborsClassifier(algorithm = "auto")) ])
params_knn = {
"knn__n_neighbors" : [2, 3, 5, 7, 9],
"knn__leaf_size" : [10, 20, 30, 40]}
knn_score, grid_knn = model_builder(X, Y, pipe_knn, params_knn, 10, "KNN")
Y_predicted_knn = grid_knn.predict_proba(X)[:, 1] | Titanic - Machine Learning from Disaster |
9,287,401 | for i in cat_cols:
summary = X_train[i].value_counts() / len(X_train)
X_train[i] = X_train[i].map(summary)
X_test[i] = X_test[i].map(summary )<feature_engineering> | all_results = [xgb_score, boost_score, log_score, rf_score,
svm_score, bag_score, xt_score, knn_score, cat_score, gbm_score]
result_names = ["XGBoost",
"Gradient Boosting",
"Logistic Regression",
"Random Forest",
"SVM",
"Bagging Classifier",
"Extra Trees Classifier",
"KNN",
"CatBoost",
"LightGBM"]
fig = plt.figure(figsize =(14,7))
fig.suptitle("Algorithm Comparison")
ax = fig.add_subplot(111)
plt.boxplot(all_results)
ax.set_xticklabels(result_names)
plt.show() | Titanic - Machine Learning from Disaster |
9,287,401 | X_train['Country_LastNewJob'] = X_train['Country'] * X_train['LastNewJob']
X_train['Country_YearsCodingProf'] = X_train['Country'] * X_train['YearsCodingProf']
X_train['LastNewJob_YearsCodingProf'] = X_train['LastNewJob'] * X_train['YearsCodingProf']<feature_engineering> | %%capture
!pip install keras-tuner | Titanic - Machine Learning from Disaster |
9,287,401 | X_test['Country_LastNewJob'] = X_test['Country'] * X_test['LastNewJob']
X_test['Country_YearsCodingProf'] = X_test['Country'] * X_test['YearsCodingProf']
X_test['LastNewJob_YearsCodingProf'] = X_test['LastNewJob'] * X_test['YearsCodingProf']<prepare_x_and_y> | import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from kerastuner.tuners import RandomSearch | Titanic - Machine Learning from Disaster |
9,287,401 | X_train.fillna(X_train.median() , inplace=True)
X_test.fillna(X_train.median() , inplace=True )<split> | X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
random_state = 0,
test_size = 0.25 ) | Titanic - Machine Learning from Disaster |
9,287,401 | scores = []
kf = KFold(n_splits=5, random_state=71, shuffle=True)
for i,(train_ix, test_ix)in enumerate(tqdm(kf.split(X_train, y_train))):
X_train_, y_train_ = X_train.values[train_ix], y_train.values[train_ix]
X_val, y_val = X_train.values[test_ix], y_train.values[test_ix]
model = lgb.LGBMRegressor(boosting_type='gbdt', class_weight=None, colsample_bytree=0.9,
importance_type='split', learning_rate=0.05, max_depth=-1,
min_child_samples=20, min_child_weight=0.001, min_split_gain=0.0,
n_estimators=9999, n_jobs=-1, num_leaves=15, objective=None,
random_state=71, reg_alpha=0.0, reg_lambda=0.0, silent=True,
subsample=1.0, subsample_for_bin=200000, subsample_freq=0)
model.fit(X_train_, y_train_, early_stopping_rounds=20, eval_metric='rmse', eval_set=[(X_val, y_val)])
y_pred = model.predict(X_val)
mse = mean_squared_error(y_val, y_pred)
rmse = np.sqrt(mse)
scores.append(rmse)
print('CV Score of Fold_%d is %f' %(i, rmse))<train_model> | %%capture
def tune_model(hp):
nn = Sequential()
nn.add(Dense(hp.Choice("units_1", [512, 1024, 2048]), activation = "relu", input_shape =(18,)))
nn.add(Dropout(hp.Choice("dropout_1", [0.0, 0.15, 0.2, 0.25])))
nn.add(Dense(hp.Choice("units_2", [128, 256, 512]), activation = "relu"))
nn.add(Dropout(hp.Choice("dropout_2", [0.0, 0.15, 0.2, 0.25])))
nn.add(Dense(hp.Choice("units_3", [32, 64, 128]), activation = "relu"))
nn.add(Dropout(hp.Choice("dropout_3", [0.0, 0.15, 0.2, 0.25])))
nn.add(Dense(hp.Choice("units_4", [8, 16, 32]), activation = "relu"))
nn.add(Dropout(hp.Choice("dropout_4", [0.0, 0.15, 0.2, 0.25])))
nn.add(Dense(1, activation = "relu"))
lr = hp.Choice("learning_rate", [0.0001, 0.001, 0.01, 0.1])
mm = hp.Choice("momentum", [0.0, 0.2, 0.4, 0.6, 0.8])
nn.compile(optimizer = keras.optimizers.RMSprop(learning_rate = lr, momentum = mm),
loss = "binary_crossentropy",
metrics = ["accuracy"])
return nn
tuner = RandomSearch(tune_model,
objective = "val_accuracy",
max_trials = 3)
tuner.search(x = X_train,
y = Y_train,
verbose = 3,
epochs = 400,
batch_size = 25,
validation_data =(X_test, Y_test)) | Titanic - Machine Learning from Disaster |
9,287,401 | model.fit(X_train, y_train)
y_pred = model.predict(X_test )<save_to_csv> | print("Best Params: " + str(tuner.oracle.get_best_trials(num_trials = 1)[0].hyperparameters.values))
nn = tuner.get_best_models() [0]
print("")
print("Test score: " + str(nn.evaluate(X_test, Y_test)))
print("")
print("Train score: " + str(nn.evaluate(X_train, Y_train)) ) | Titanic - Machine Learning from Disaster |
9,287,401 | submission = pd.read_csv('.. /input/exam-for-students20200129/sample_submission.csv', index_col=0)
submission[tgt_col] = y_pred
submission[tgt_col] = np.exp(submission[tgt_col])- 1
submission.to_csv('submission.csv')
<import_modules> | Y_predicted_nn = nn.predict(test.drop(["PassengerId"], axis = 1))
Y_predicted_nn =(Y_predicted_nn.ravel() > 0.5 ).astype(int ) | Titanic - Machine Learning from Disaster |
9,287,401 | from sklearn.feature_extraction.text import TfidfVectorizer
from nltk.corpus import stopwords
from nltk import word_tokenize
import pandas as pd
import numpy as np
import re
from sklearn.model_selection import train_test_split
from collections import defaultdict
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score, classification_report
import json<load_from_disk> | from sklearn.metrics import roc_curve, roc_auc_score | Titanic - Machine Learning from Disaster |
9,287,401 | with open('.. /input/train.json')as f:
raw_train = json.load(f)
with open('.. /input/test.json')as f:
raw_test = json.load(f )<string_transform> | log_fpr, log_tpr, log_treshholds = roc_curve(Y, Y_predicted_log)
boost_fpr, boost_tpr, boost_treshholds = roc_curve(Y, Y_predicted_boost)
svm_fpr, svm_tpr, svm_treshholds = roc_curve(Y, Y_predicted_svm)
rf_fpr, rf_tpr, rf_treshholds = roc_curve(Y, Y_predicted_rf)
xgb_fpr, xgb_tpr, xgb_treshholds = roc_curve(Y, Y_predicted_xgb)
bag_fpr, bag_tpr, bag_treshholds = roc_curve(Y, Y_predicted_bag)
xt_fpr, xt_tpr, xt_treshholds = roc_curve(Y, Y_predicted_xt)
knn_fpr, knn_tpr, knn_treshholds = roc_curve(Y, Y_predicted_knn)
auc_score_log = roc_auc_score(Y, Y_predicted_log)
auc_score_boost = roc_auc_score(Y, Y_predicted_boost)
auc_score_svm = roc_auc_score(Y, Y_predicted_svm)
auc_score_rf = roc_auc_score(Y, Y_predicted_rf)
auc_score_xgb = roc_auc_score(Y, Y_predicted_xgb)
auc_score_bag = roc_auc_score(Y, Y_predicted_bag)
auc_score_xt = roc_auc_score(Y, Y_predicted_xt)
auc_score_knn = roc_auc_score(Y, Y_predicted_knn)
plt.figure(figsize =(14,7))
plt.plot([0,1], [0,1])
plt.plot(log_fpr, log_tpr, label = "Logistic Regression(AUC-Score: " + str(round(auc_score_log, 2)) + ")")
plt.plot(boost_fpr, boost_tpr, label = "Gradient Boosting(AUC-Score: " + str(round(auc_score_boost, 2)) + ")")
plt.plot(svm_fpr, svm_tpr, label = "SVM(AUC-Score: " + str(round(auc_score_svm, 2)) + ")")
plt.plot(rf_fpr, rf_tpr, label = "Random Forest(AUC-Score: " + str(round(auc_score_rf, 2)) + ")")
plt.plot(xgb_fpr, xgb_tpr, label = "XGBoost(AUC-Score: " + str(round(auc_score_xgb, 2)) + ")")
plt.plot(bag_fpr, bag_tpr, label = "Bagging Classifier(AUC-Score: " + str(round(auc_score_bag, 2)) + ")")
plt.plot(xt_fpr, xt_tpr, label = "Extra Trees Clasifier(AUC-Score: " + str(round(auc_score_xt, 2)) + ")")
plt.plot(knn_fpr, knn_tpr, label = "K-Nearest-Neighbor(AUC-Score: " + str(round(auc_score_knn, 2)) + ")")
plt.title("ROC-Curve")
plt.xlabel("FPR")
plt.ylabel("TPR")
plt.legend()
plt.show() | Titanic - Machine Learning from Disaster |
9,287,401 | def ru_token(string):
return [i for i in word_tokenize(string)if re.match(r'[\u0400-\u04ffа́]+$', i)]<init_hyperparams> | stack = StackingClassifier(estimators = [("XGBoost", grid_xgb),
("GradientBoosting", grid_boost),
("RandomForest", grid_rf),
("Logistic Regression", grid_log),
("SVM", grid_svm),
("Extra Trees Classifier", grid_xt),
("KNeighborsClassifier", grid_knn),
("CatBoost", grid_cat),
("LightGBM", grid_gbm)], n_jobs = -1)
cv = StratifiedKFold(n_splits = 5)
stack = stack.fit(X, Y)
stack_score = cross_val_score(stack, X, Y, cv = cv, n_jobs = -1)
print("
print("Cross-Validated-Score: " + str(round(stack_score.mean() , 6)))
print("
Y_predicted_stack = stack.predict(test.drop(["PassengerId"], axis = 1)) | Titanic - Machine Learning from Disaster |
9,287,401 | params = {}
params['tokenizer'] = ru_token
params['stop_words'] = stopwords.words('russian')
params['ngram_range'] =(1, 3)
params['min_df'] = 3<feature_engineering> | submission = pd.DataFrame({"PassengerId" : test.PassengerId,
"Survived" : Y_predicted_stack})
submission.to_csv("submission_clf.csv", index = False ) | Titanic - Machine Learning from Disaster |
9,287,401 | tfidf = TfidfVectorizer(**params )<train_model> | submission_nn = pd.DataFrame({"PassengerId" : test.PassengerId,
"Survived" : Y_predicted_nn})
submission_nn.to_csv("submission_nn.csv", index = False ) | Titanic - Machine Learning from Disaster |
9,287,401 | tfidf.fit([i['text'] for i in raw_train + raw_test] )<split> | train = pd.read_csv(".. /input/titanic/train.csv")
test = pd.read_csv(".. /input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
9,287,401 | train = {}
val = {}
tmp = defaultdict(list)
for e in raw_train:
tmp[e['sentiment']].append(e['text'])
for l in tmp:
train[l], val[l] = train_test_split(tmp[l], test_size=0.2, random_state=2018 )<statistical_test> | data_size_train = train.memory_usage().sum() / 1024 / 1024
print("Data memory size: %.2f MB" % data_size_train ) | Titanic - Machine Learning from Disaster |
9,287,401 | def upsampling_align(some_dict, random_state=2018):
rand = np.random.RandomState(random_state)
upper = max([len(some_dict[l])for l in some_dict])
print('upper bound: {}'.format(upper))
tmp = {}
for l in some_dict:
if len(some_dict[l])< upper:
repeat_time = int(upper/len(some_dict[l]))
remainder = upper % len(some_dict[l])
_tmp = some_dict[l].copy()
rand.shuffle(_tmp)
tmp[l] = some_dict[l] * repeat_time + _tmp[:remainder]
rand.shuffle(tmp[l])
else:
tmp[l] = some_dict[l]
return tmp<concatenate> | data_size_test = test.memory_usage().sum() / 1024 / 1024
print("Data memory size: %.2f MB" % data_size_test ) | Titanic - Machine Learning from Disaster |
9,287,401 | btrain = upsampling_align(train )<init_hyperparams> | train["NameTitle"] = train["Name"].str.split(", ", expand = True)[1].str.split(".", expand = True)[0]
test["NameTitle"] = test["Name"].str.split(", ", expand = True)[1].str.split(".", expand = True)[0]
train = train.drop("Name", axis = 1)
test = test.drop("Name", axis = 1)
print(train["NameTitle"].unique())
print("------------------------" * 3)
print(test["NameTitle"].unique() ) | Titanic - Machine Learning from Disaster |
9,287,401 | m_params = {}
m_params['solver'] = 'lbfgs'
m_params['multi_class'] = 'multinomial'<choose_model_class> | min_titles =(train["NameTitle"].value_counts() < 10)
train["NameTitle"] = train["NameTitle"].apply(lambda x: "Misc" if min_titles.loc[x] == True else x)
print(train["NameTitle"].unique() ) | Titanic - Machine Learning from Disaster |
9,287,401 | softmax = LogisticRegression(**m_params )<categorify> | min_titles =(test["NameTitle"].value_counts() < 10)
test["NameTitle"] = test["NameTitle"].apply(lambda x: "Misc" if min_titles.loc[x] == True else x)
print(test["NameTitle"].unique() ) | Titanic - Machine Learning from Disaster |
9,287,401 | train_x = [j for i in sorted(btrain.keys())for j in btrain[i]]
train_y = [i for i in sorted(btrain.keys())for j in btrain[i]]
softmax.fit(tfidf.transform(train_x), train_y )<define_variables> | train["FamilySize"] = train["SibSp"] + train["Parch"]
test["FamilySize"] = test["SibSp"] + test["Parch"] | Titanic - Machine Learning from Disaster |
9,287,401 | test_x = [j for i in sorted(val.keys())for j in val[i]]
true = [i for i in sorted(val.keys())for j in val[i]]<predict_on_test> | train["AgeGroup"] = ""
train.loc[train["Age"] < 21, "AgeGroup"] = "under 21"
train.loc[train["Age"] >= 21, "AgeGroup"] = "21-65"
train.loc[train["Age"] > 65, "AgeGroup"] = "65+"
test["AgeGroup"] = ""
test.loc[test["Age"] < 21, "AgeGroup"] = "under 21"
test.loc[test["Age"] >= 21, "AgeGroup"] = "21-65"
test.loc[test["Age"] > 65, "AgeGroup"] = "65+"
train = train.drop("Age", axis = 1)
test = test.drop("Age", axis = 1 ) | Titanic - Machine Learning from Disaster |
9,287,401 | pred = softmax.predict(tfidf.transform(test_x))<compute_test_metric> | train["FareGroup"] = ""
train.loc[train["Fare"] < 170, "FareGroup"] = "0-170"
train.loc[train["Fare"] >= 170, "FareGroup"] = "170-340"
train.loc[train["Fare"] > 340, "FareGroup"] = "340+"
test["FareGroup"] = ""
test.loc[test["Fare"] < 170, "FareGroup"] = "0-170"
test.loc[test["Fare"] >= 170, "FareGroup"] = "170-340"
test.loc[test["Fare"] > 340, "FareGroup"] = "340+"
train = train.drop("Fare", axis = 1)
test = test.drop("Fare", axis = 1 ) | Titanic - Machine Learning from Disaster |
9,287,401 | accuracy_score(true, pred )<categorify> | train = train.drop(["SibSp", "Parch"], axis = 1)
test = test.drop(["SibSp", "Parch"], axis = 1 ) | Titanic - Machine Learning from Disaster |
9,287,401 | lab = LabelEncoder()
c_true = lab.fit_transform(true)
c_pred = lab.transform(pred)
print(classification_report(c_true, c_pred, target_names=lab.classes_, digits=5))<concatenate> | train = pd.get_dummies(train, columns = ["Sex", "Embarked", "NameTitle", "AgeGroup", "FareGroup"])
test = pd.get_dummies(test, columns = ["Sex", "Embarked", "NameTitle", "AgeGroup", "FareGroup"] ) | Titanic - Machine Learning from Disaster |
9,287,401 | bval = upsampling_align(val )<categorify> | upper = corr.where(np.triu(np.ones(corr.shape), k = 1 ).astype(np.bool))
to_drop = [column for column in upper.columns if any(upper[column] > 0.90)]
print(to_drop ) | Titanic - Machine Learning from Disaster |
9,287,401 | b_test_x = [j for i in sorted(bval.keys())for j in bval[i]]
b_true = [i for i in sorted(bval.keys())for j in bval[i]]
b_pred = softmax.predict(tfidf.transform(b_test_x))
lab = LabelEncoder()
c_true = lab.fit_transform(b_true)
c_pred = lab.transform(b_pred)
print(classification_report(c_true, c_pred, target_names=lab.classes_, digits=5))<prepare_output> | X = train.drop(["PassengerId", "Survived"], axis = 1)
Y = train["Survived"] | Titanic - Machine Learning from Disaster |
9,287,401 | sub_pred = softmax.predict(tfidf.transform([i['text'] for i in raw_test]))
sub_df = pd.DataFrame()
sub_df['id'] = [i['id'] for i in raw_test]
sub_df['sentiment'] = sub_pred<save_to_csv> | from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, BaggingClassifier, ExtraTreesClassifier, StackingClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from catboost import CatBoostClassifier
from xgboost import XGBClassifier
import lightgbm as lgb | Titanic - Machine Learning from Disaster |
9,287,401 | sub_df.to_csv('softmax_reg.csv', index=False )<load_from_csv> | style.use("seaborn-whitegrid")
%matplotlib inline
%config InlineBackend.figure_format = "retina"
def model_builder(X, Y, pipeline, params, kfolds, classifier_name, data_split = False):
if data_split == True:
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
random_state = 0,
test_size = 0.25)
cv = StratifiedKFold(n_splits = kfolds)
start = time.time()
grid = GridSearchCV(pipeline, params, cv = cv, verbose = 0, n_jobs = -1)
grid = grid.fit(X_train, Y_train)
print("Best Params:")
print("")
print(grid.best_params_)
grid = grid.best_estimator_
classifier_score = cross_val_score(grid, X_test, Y_test, cv = cv, n_jobs = -1)
Y_predicted = grid.predict(X_test)
stop = time.time()
print("")
print("
print("Cross-Validated-Score: " + str(round(classifier_score.mean() , 6)))
print("
print("")
print("Training time: " + str(round(stop - start, 2)) + "s")
train_size, train_score, test_score = learning_curve(grid, X_train, Y_train, cv = cv, n_jobs = -1)
print("")
print("Learning Curve:")
plt.figure(figsize =(12,6))
plt.plot(train_size, np.mean(train_score, axis = 1), label = "Train scores")
plt.plot(train_size, np.mean(test_score, axis = 1), label = "Test scores")
plt.title(classifier_name)
plt.legend()
plt.show()
return X_train, X_test, Y_train, Y_test, classifier_score, grid
if data_split == False:
cv = StratifiedKFold(n_splits = kfolds)
start = time.time()
grid = GridSearchCV(pipeline, params, cv = cv, verbose = 0, n_jobs = -1)
grid = grid.fit(X, Y)
print("Best Params:")
print("")
print(grid.best_params_)
grid = grid.best_estimator_
classifier_score = cross_val_score(grid, X, Y, cv = cv, n_jobs = -1)
Y_predicted = grid.predict(X)
stop = time.time()
print("")
print("
print("Cross-Validated-Score: " + str(round(classifier_score.mean() , 6)))
print("
print("")
print("Training time: " + str(round(stop - start, 2)) + "s")
train_size, train_score, test_score = learning_curve(grid, X, Y, cv = cv, n_jobs = -1)
print("")
print("Learning Curve:")
plt.figure(figsize =(12,6))
plt.plot(train_size, np.mean(train_score, axis = 1), label = "Train scores")
plt.plot(train_size, np.mean(test_score, axis = 1), label = "Test scores")
plt.title(classifier_name)
plt.legend()
plt.show()
return classifier_score, grid | Titanic - Machine Learning from Disaster |
9,287,401 | df_train = pd.read_csv('/kaggle/input/dma-fall19/yelp_train.csv')
df_test = pd.read_csv('/kaggle/input/dma-fall19/yelp_test.csv' )<correct_missing_values> | pipe_xgb = Pipeline([
("scaler", StandardScaler()),
("pca", PCA()),
("xgb", XGBClassifier())])
params_xgb = {
"pca__n_components" : [2, 6, 10, 18],
"xgb__n_estimators" : [300, 500, 700],
"xgb__learning_rate" : [0.005, 0.1],
"xgb__max_depth" : [5, 7],
"xgb__max_features" : [3, 5],
"xgb__gamma" : [0.5, 0.6, 0.7]}
xgb_score, grid_xgb = model_builder(X, Y, pipe_xgb, params_xgb, 10, "XGBoost")
Y_predicted_xgb = grid_xgb.predict_proba(X)[:, 1] | Titanic - Machine Learning from Disaster |
9,287,401 | df_train = df_train.dropna()<prepare_x_and_y> | pipe_boost = Pipeline([
("scaler", StandardScaler()),
("pca", PCA()),
("boost", GradientBoostingClassifier())])
params_boost = {
"pca__n_components" : [2, 6, 10, 18],
"boost__n_estimators" : [300, 500, 700],
"boost__learning_rate" : [0.005, 0.1],
"boost__max_depth" : [3, 5],
"boost__max_features" : [3, 5]}
boost_score, grid_boost = model_builder(X, Y, pipe_boost, params_boost, 10, "Gradient Boosting")
Y_predicted_boost = grid_boost.predict_proba(X)[:, 1] | Titanic - Machine Learning from Disaster |
9,287,401 | x_train = df_train[['cool', 'funny', 'useful', 'user_average_stars',
'user_review_count', 'business_latitude', 'business_longitude',
'business_review_count', 'business_average_stars']]
x_test = df_test[['cool', 'funny', 'useful', 'user_average_stars',
'user_review_count', 'business_latitude', 'business_longitude',
'business_review_count', 'business_average_stars']]
y_train = df_train['is_good_rating']<find_best_model_class> | pipe_xt = Pipeline([
("scaler", StandardScaler()),
("pca", PCA()),
("xt", ExtraTreesClassifier(criterion = "gini",
max_features = "auto")) ])
params_xt = {
"pca__n_components" : [2, 6, 10, 18],
"xt__n_estimators" : [300, 500, 700],
"xt__max_depth" : [5, 7, 9]}
xt_score, grid_xt = model_builder(X, Y, pipe_xt, params_xt, 10, "Extra Trees")
Y_predicted_xt = grid_xt.predict_proba(X)[:, 1] | Titanic - Machine Learning from Disaster |
9,287,401 | clf = DecisionTreeClassifier()
clf.fit(x_train, y_train)
accuracy_score(clf.predict(x_train), y_train )<predict_on_test> | pipe_knn = Pipeline([
("scaler", StandardScaler()),
("knn", KNeighborsClassifier(algorithm = "auto")) ])
params_knn = {
"knn__n_neighbors" : [2, 3, 5, 7, 9],
"knn__leaf_size" : [10, 20, 30, 40]}
knn_score, grid_knn = model_builder(X, Y, pipe_knn, params_knn, 10, "KNN")
Y_predicted_knn = grid_knn.predict_proba(X)[:, 1] | Titanic - Machine Learning from Disaster |
9,287,401 | clf.predict(x_test )<predict_on_test> | all_results = [xgb_score, boost_score, log_score, rf_score,
svm_score, bag_score, xt_score, knn_score, cat_score, gbm_score]
result_names = ["XGBoost",
"Gradient Boosting",
"Logistic Regression",
"Random Forest",
"SVM",
"Bagging Classifier",
"Extra Trees Classifier",
"KNN",
"CatBoost",
"LightGBM"]
fig = plt.figure(figsize =(14,7))
fig.suptitle("Algorithm Comparison")
ax = fig.add_subplot(111)
plt.boxplot(all_results)
ax.set_xticklabels(result_names)
plt.show() | Titanic - Machine Learning from Disaster |
9,287,401 | submission = pd.DataFrame(index=df_test.review_id)
submission['is_good_rating'] = clf.predict(x_test )<save_to_csv> | %%capture
!pip install keras-tuner | Titanic - Machine Learning from Disaster |
9,287,401 | submission.reset_index().to_csv('submission.csv', index=False )<load_from_csv> | import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from kerastuner.tuners import RandomSearch | Titanic - Machine Learning from Disaster |
9,287,401 | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv' )<create_dataframe> | X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
random_state = 0,
test_size = 0.25 ) | Titanic - Machine Learning from Disaster |
9,287,401 | submission_pd = pd.DataFrame(test_df.Id )<feature_engineering> | %%capture
def tune_model(hp):
nn = Sequential()
nn.add(Dense(hp.Choice("units_1", [512, 1024, 2048]), activation = "relu", input_shape =(18,)))
nn.add(Dropout(hp.Choice("dropout_1", [0.0, 0.15, 0.2, 0.25])))
nn.add(Dense(hp.Choice("units_2", [128, 256, 512]), activation = "relu"))
nn.add(Dropout(hp.Choice("dropout_2", [0.0, 0.15, 0.2, 0.25])))
nn.add(Dense(hp.Choice("units_3", [32, 64, 128]), activation = "relu"))
nn.add(Dropout(hp.Choice("dropout_3", [0.0, 0.15, 0.2, 0.25])))
nn.add(Dense(hp.Choice("units_4", [8, 16, 32]), activation = "relu"))
nn.add(Dropout(hp.Choice("dropout_4", [0.0, 0.15, 0.2, 0.25])))
nn.add(Dense(1, activation = "relu"))
lr = hp.Choice("learning_rate", [0.0001, 0.001, 0.01, 0.1])
mm = hp.Choice("momentum", [0.0, 0.2, 0.4, 0.6, 0.8])
nn.compile(optimizer = keras.optimizers.RMSprop(learning_rate = lr, momentum = mm),
loss = "binary_crossentropy",
metrics = ["accuracy"])
return nn
tuner = RandomSearch(tune_model,
objective = "val_accuracy",
max_trials = 3)
tuner.search(x = X_train,
y = Y_train,
verbose = 3,
epochs = 400,
batch_size = 25,
validation_data =(X_test, Y_test)) | Titanic - Machine Learning from Disaster |
9,287,401 | submission_pd['SalePrice'] = ybar<save_to_csv> | print("Best Params: " + str(tuner.oracle.get_best_trials(num_trials = 1)[0].hyperparameters.values))
nn = tuner.get_best_models() [0]
print("")
print("Test score: " + str(nn.evaluate(X_test, Y_test)))
print("")
print("Train score: " + str(nn.evaluate(X_train, Y_train)) ) | Titanic - Machine Learning from Disaster |
9,287,401 | submission_pd.to_csv('submission0.csv' )<save_to_csv> | Y_predicted_nn = nn.predict(test.drop(["PassengerId"], axis = 1))
Y_predicted_nn =(Y_predicted_nn.ravel() > 0.5 ).astype(int ) | Titanic - Machine Learning from Disaster |
9,287,401 | submission_pd.to_csv('submission.csv', index=False )<install_modules> | from sklearn.metrics import roc_curve, roc_auc_score | Titanic - Machine Learning from Disaster |
9,287,401 | !pip install -q albumentations
!pip install -q pretrainedmodels
!pip install -q kekas
!pip install -q adabound<set_options> | log_fpr, log_tpr, log_treshholds = roc_curve(Y, Y_predicted_log)
boost_fpr, boost_tpr, boost_treshholds = roc_curve(Y, Y_predicted_boost)
svm_fpr, svm_tpr, svm_treshholds = roc_curve(Y, Y_predicted_svm)
rf_fpr, rf_tpr, rf_treshholds = roc_curve(Y, Y_predicted_rf)
xgb_fpr, xgb_tpr, xgb_treshholds = roc_curve(Y, Y_predicted_xgb)
bag_fpr, bag_tpr, bag_treshholds = roc_curve(Y, Y_predicted_bag)
xt_fpr, xt_tpr, xt_treshholds = roc_curve(Y, Y_predicted_xt)
knn_fpr, knn_tpr, knn_treshholds = roc_curve(Y, Y_predicted_knn)
auc_score_log = roc_auc_score(Y, Y_predicted_log)
auc_score_boost = roc_auc_score(Y, Y_predicted_boost)
auc_score_svm = roc_auc_score(Y, Y_predicted_svm)
auc_score_rf = roc_auc_score(Y, Y_predicted_rf)
auc_score_xgb = roc_auc_score(Y, Y_predicted_xgb)
auc_score_bag = roc_auc_score(Y, Y_predicted_bag)
auc_score_xt = roc_auc_score(Y, Y_predicted_xt)
auc_score_knn = roc_auc_score(Y, Y_predicted_knn)
plt.figure(figsize =(14,7))
plt.plot([0,1], [0,1])
plt.plot(log_fpr, log_tpr, label = "Logistic Regression(AUC-Score: " + str(round(auc_score_log, 2)) + ")")
plt.plot(boost_fpr, boost_tpr, label = "Gradient Boosting(AUC-Score: " + str(round(auc_score_boost, 2)) + ")")
plt.plot(svm_fpr, svm_tpr, label = "SVM(AUC-Score: " + str(round(auc_score_svm, 2)) + ")")
plt.plot(rf_fpr, rf_tpr, label = "Random Forest(AUC-Score: " + str(round(auc_score_rf, 2)) + ")")
plt.plot(xgb_fpr, xgb_tpr, label = "XGBoost(AUC-Score: " + str(round(auc_score_xgb, 2)) + ")")
plt.plot(bag_fpr, bag_tpr, label = "Bagging Classifier(AUC-Score: " + str(round(auc_score_bag, 2)) + ")")
plt.plot(xt_fpr, xt_tpr, label = "Extra Trees Clasifier(AUC-Score: " + str(round(auc_score_xt, 2)) + ")")
plt.plot(knn_fpr, knn_tpr, label = "K-Nearest-Neighbor(AUC-Score: " + str(round(auc_score_knn, 2)) + ")")
plt.title("ROC-Curve")
plt.xlabel("FPR")
plt.ylabel("TPR")
plt.legend()
plt.show() | Titanic - Machine Learning from Disaster |
9,287,401 | %matplotlib inline
train_on_gpu = True
Blur, OpticalDistortion, GridDistortion, HueSaturationValue, Flip, VerticalFlip
print(os.listdir(".. /input/"))
sample_sub = pd.read_csv('.. /input/sample_submission.csv')
<prepare_output> | stack = StackingClassifier(estimators = [("XGBoost", grid_xgb),
("GradientBoosting", grid_boost),
("RandomForest", grid_rf),
("Logistic Regression", grid_log),
("SVM", grid_svm),
("Extra Trees Classifier", grid_xt),
("KNeighborsClassifier", grid_knn),
("CatBoost", grid_cat),
("LightGBM", grid_gbm)], n_jobs = -1)
cv = StratifiedKFold(n_splits = 5)
stack = stack.fit(X, Y)
stack_score = cross_val_score(stack, X, Y, cv = cv, n_jobs = -1)
print("
print("Cross-Validated-Score: " + str(round(stack_score.mean() , 6)))
print("
Y_predicted_stack = stack.predict(test.drop(["PassengerId"], axis = 1)) | Titanic - Machine Learning from Disaster |
9,287,401 | train_folder = '.. /input/plates/plates/train/'
test_folder = '.. /input/plates/plates/test/'
cleaned = 'cleaned'
dirty = 'dirty'
train_clean = os.listdir(train_folder + cleaned)
train_dirty = os.listdir(train_folder + dirty)
test_files = os.listdir(test_folder)
train_df = pd.concat([pd.DataFrame(train_clean, columns=['id']), pd.DataFrame(train_dirty, columns=['id'])])
train_df.reset_index(drop=True, inplace=True)
test_df = pd.DataFrame(test_files, columns=['id'])
train_df['label'] = [1 if file_name.startswith('cleaned')else 0 for file_name in train_df['id']]
test_df['label'] = -1
print(train_df.head(3))
fig = plt.figure(figsize=(20,5))
for idx, img in enumerate(np.random.choice(train_df['id'], 10)) :
ax = fig.add_subplot(2, 10//2, idx+1, xticks=[], yticks=[])
im = Image.open(train_folder + img.split('_')[0] + '/' + img)
plt.imshow(im)
lab = img
ax.set_title(f'{lab}' )<feature_engineering> | submission = pd.DataFrame({"PassengerId" : test.PassengerId,
"Survived" : Y_predicted_stack})
submission.to_csv("submission_clf.csv", index = False ) | Titanic - Machine Learning from Disaster |
9,287,401 | <init_hyperparams><EOS> | submission_nn = pd.DataFrame({"PassengerId" : test.PassengerId,
"Survived" : Y_predicted_nn})
submission_nn.to_csv("submission_nn.csv", index = False ) | Titanic - Machine Learning from Disaster |
8,659,445 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<split> | warnings.filterwarnings('ignore')
| Titanic - Machine Learning from Disaster |
8,659,445 | train, valid = train_test_split(train_df, stratify=train_df.label, test_size=0.15 )<load_pretrained> | train = pd.read_csv(".. /input/titanic/train.csv")
test = pd.read_csv(".. /input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
8,659,445 | train_tfms, val_tfms = get_transforms("image", 224, 0.5)
train_dk = DataKek(df=train, reader_fn=reader_train_fn, transforms=train_tfms)
val_dk = DataKek(df=valid, reader_fn=reader_train_fn, transforms=val_tfms)
test_dk = DataKek(df=test_df, reader_fn=reader_test_fn, transforms=val_tfms)
batch_size = 2
workers = 8
train_dl = DataLoader(train_dk, batch_size=batch_size, num_workers=workers, shuffle=True, drop_last=True)
val_dl = DataLoader(val_dk, batch_size=batch_size, num_workers=workers, shuffle=False)
test_dl = DataLoader(test_dk, batch_size=30, num_workers=workers, shuffle=False )<compute_train_metric> | def detect_outliers(dataframe, n, features):
outliers_indices = []
for feature in features:
Quart1 = dataframe[feature].quantile(0.25)
Quart3 = dataframe[feature].quantile(0.75)
upper_outlier_threshold = Quart3 +(Quart3 - Quart1)* 1.5
lower_outlier_threshold = Quart1 -(Quart3 - Quart1)* 1.5
feature_outliers_list = dataframe[(dataframe[feature] > upper_outlier_threshold)|(dataframe[feature] < lower_outlier_threshold)].index
outliers_indices.extend(feature_outliers_list)
return list(a for a, b in Counter(outliers_indices ).items() if b > n ) | Titanic - Machine Learning from Disaster |
8,659,445 | dataowner = DataOwner(train_dl, val_dl, None)
BCEmodel = Net(num_classes=1)
CEmodel = Net(num_classes=2)
CEcriterion = nn.CrossEntropyLoss()
BCEcriterion = nn.BCEWithLogitsLoss()<compute_train_metric> | outliers = detect_outliers(train, 2, ["Age", "SibSp", "Fare", "Parch"])
train.loc[outliers] | 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.