kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,084,367 | print('RMSE insample', np.sqrt(np.mean(( np.array(y_pred)- np.array(pred[1])) **2)) )<count_unique_values> | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
13,084,367 | np.unique(y_pred, return_counts=True )<save_to_csv> | for col in train.columns:
print(col, str(round(100* train[col].isnull().sum() / len(train), 2)) + '%' ) | Titanic - Machine Learning from Disaster |
13,084,367 | pred = learn.get_preds(ds_type=DatasetType.Test)
y_pred = [int(np.argmax(row)) for row in pred[0]]
test_csv['AdoptionSpeed'] = y_pred
test_csv[['PetID', 'AdoptionSpeed']].to_csv('submission.csv', index=False )<set_options> | train['LastName'] = train['Name'].str.split(',', expand=True)[0]
test['LastName'] = test['Name'].str.split(',', expand=True)[0]
ds = pd.concat([train, test])
sur = list()
died = list()
for index, row in ds.iterrows() :
s = ds[(ds['LastName']==row['LastName'])&(ds['Survived']==1)]
d = ds[(ds['LastName']==row['LastName'... | Titanic - Machine Learning from Disaster |
13,084,367 | %matplotlib inline
pd.options.display.max_rows = 128
pd.options.display.max_columns = 128
plt.rcParams['figure.figsize'] =(12, 9)
plt.style.use('ggplot' )<define_variables> | y = train['Survived']
X = train.drop(['Survived', 'Cabin_T'], axis=1)
X_test = test.copy()
X, X_val, y, y_val = train_test_split(X, y, random_state=0, test_size=0.2, shuffle=False ) | Titanic - Machine Learning from Disaster |
13,084,367 | Run_Tabular = True
Run_Metadata = False
Run_Sentiment = False
Run_Metadata_AvgSum = False
Run_Sentiment_AvgSum = False
Run_Breed_Map = False
Run_Rescuer_Cnt = True
Run_Text_Features = False<load_from_csv> | class Optimizer:
def __init__(self, metric, trials=30):
self.metric = metric
self.trials = trials
self.sampler = TPESampler(seed=666)
def objective(self, trial):
model = create_model(trial)
model.fit(X, y)
preds = model.predict(X_val)
if self.metric == 'acc':
return accuracy_score(y_val, preds)
else:
return f1_sco... | Titanic - Machine Learning from Disaster |
13,084,367 | train = pd.read_csv('.. /input/train/train.csv')
test = pd.read_csv('.. /input/test/test.csv')
sample_submission = pd.read_csv('.. /input/test/sample_submission.csv' )<load_from_csv> | rf = RandomForestClassifier(random_state=666)
rf.fit(X, y)
preds = rf.predict(X_val)
print('Random Forest accuracy: ', accuracy_score(y_val, preds))
print('Random Forest f1-score: ', f1_score(y_val, preds))
def create_model(trial):
max_depth = trial.suggest_int("max_depth", 2, 6)
n_estimators = trial.suggest_int("n... | Titanic - Machine Learning from Disaster |
13,084,367 | labels_breed = pd.read_csv('.. /input/breed_labels.csv')
labels_state = pd.read_csv('.. /input/color_labels.csv')
labels_color = pd.read_csv('.. /input/state_labels.csv' )<define_variables> | xgb = XGBClassifier(random_state=666)
xgb.fit(X, y)
preds = xgb.predict(X_val)
print('XGBoost accuracy: ', accuracy_score(y_val, preds))
print('XGBoost f1-score: ', f1_score(y_val, preds))
def create_model(trial):
max_depth = trial.suggest_int("max_depth", 2, 6)
n_estimators = trial.suggest_int("n_estimators", 1, 1... | Titanic - Machine Learning from Disaster |
13,084,367 | train_image_files = sorted(glob.glob('.. /input/train_images/*.jpg'))
train_metadata_files = sorted(glob.glob('.. /input/train_metadata/*.json'))
train_sentiment_files = sorted(glob.glob('.. /input/train_sentiment/*.json'))
print('num of train images files: {}'.format(len(train_image_files)))
print('num of train metad... | lgb = LGBMClassifier(random_state=666)
lgb.fit(X, y)
preds = lgb.predict(X_val)
print('LightGBM accuracy: ', accuracy_score(y_val, preds))
print('LightGBM f1-score: ', f1_score(y_val, preds))
def create_model(trial):
max_depth = trial.suggest_int("max_depth", 2, 6)
n_estimators = trial.suggest_int("n_estimators", 1... | Titanic - Machine Learning from Disaster |
13,084,367 | test_df_ids = test[['PetID']]
print(test_df_ids.shape)
test_df_imgs = pd.DataFrame(test_image_files)
test_df_imgs.columns = ['image_filename']
test_imgs_pets = test_df_imgs['image_filename'].apply(lambda x: x.split('/')[-1].split('-')[0])
test_df_imgs = test_df_imgs.assign(PetID=test_imgs_pets)
print(len(test_imgs_... | lr = LogisticRegression(random_state=666)
lr.fit(X, y)
preds = lr.predict(X_val)
print('Logistic Regression: ', accuracy_score(y_val, preds))
print('Logistic Regression f1-score: ', f1_score(y_val, preds)) | Titanic - Machine Learning from Disaster |
13,084,367 | class PetFinderParser(object):
def __init__(self, debug=False):
self.debug = debug
self.sentence_sep = ' '
self.extract_sentiment_text = False
def open_metadata_file(self, filename):
with open(filename, 'r', encoding="utf8")as f:
metadata_file = json.load(f)
return metadata_file
def open_sentiment_file(self, filenam... | dt = DecisionTreeClassifier(random_state=666)
dt.fit(X, y)
preds = dt.predict(X_val)
print('Decision Tree accuracy: ', accuracy_score(y_val, preds))
print('Decision Tree f1-score: ', f1_score(y_val, preds))
def create_model(trial):
max_depth = trial.suggest_int("max_depth", 2, 6)
min_samples_split = trial.suggest_i... | Titanic - Machine Learning from Disaster |
13,084,367 | train_proc = train.copy()
if Run_Sentiment_AvgSum == True:
train_proc = train_proc.merge(
train_sentiment_gr, how='left', on='PetID')
train_proc = train_proc.merge(
train_sentiment_desc, how='left', on='PetID')
if Run_Metadata_AvgSum == True:
train_proc = train_proc.merge(
train_metadata_gr, how='left', on='PetID'... | bc = BaggingClassifier(random_state=666)
bc.fit(X, y)
preds = bc.predict(X_val)
print('Bagging Classifier accuracy: ', accuracy_score(y_val, preds))
print('Bagging Classifier f1-score: ', f1_score(y_val, preds))
def create_model(trial):
n_estimators = trial.suggest_int('n_estimators', 2, 200)
max_samples = trial.su... | Titanic - Machine Learning from Disaster |
13,084,367 | train_breed_main = train_proc[['Breed1']].merge(
labels_breed, how='left',
left_on='Breed1', right_on='BreedID',
suffixes=('', '_main_breed'))
train_breed_main = train_breed_main.iloc[:, 2:]
train_breed_main = train_breed_main.add_prefix('main_breed_')
train_breed_second = train_proc[['Breed2']].merge(
labels_breed,... | knn = KNeighborsClassifier()
knn.fit(X, y)
preds = knn.predict(X_val)
print('KNN accuracy: ', accuracy_score(y_val, preds))
print('KNN f1-score: ', f1_score(y_val, preds))
sampler = TPESampler(seed=0)
def create_model(trial):
n_neighbors = trial.suggest_int("n_neighbors", 2, 25)
model = KNeighborsClassifier(n_neigh... | Titanic - Machine Learning from Disaster |
13,084,367 | X = pd.concat([train_proc, test_proc], ignore_index=True, sort=False)
print('NaN structure:
{}'.format(np.sum(pd.isnull(X))))<define_variables> | abc = AdaBoostClassifier(random_state=666)
abc.fit(X, y)
preds = abc.predict(X_val)
print('AdaBoost accuracy: ', accuracy_score(y_val, preds))
print('AdaBoost f1-score: ', f1_score(y_val, preds))
def create_model(trial):
n_estimators = trial.suggest_int("n_estimators", 2, 150)
learning_rate = trial.suggest_uniform(... | Titanic - Machine Learning from Disaster |
13,084,367 | column_types = X.dtypes
int_cols = column_types[column_types == 'int']
float_cols = column_types[column_types == 'float']
cat_cols = column_types[column_types == 'object']
print('\tinteger columns:
{}'.format(int_cols))
print('
\tfloat columns:
{}'.format(float_cols))
print('
\tto encode categorical columns:
{}'.format... | et = ExtraTreesClassifier(random_state=666)
et.fit(X, y)
preds = et.predict(X_val)
print('ExtraTreesClassifier accuracy: ', accuracy_score(y_val, preds))
print('ExtraTreesClassifier f1-score: ', f1_score(y_val, preds))
def create_model(trial):
n_estimators = trial.suggest_int("n_estimators", 2, 150)
max_depth = tri... | Titanic - Machine Learning from Disaster |
13,084,367 | X_temp = X.copy()
text_columns = ['Description']
if Run_Metadata_AvgSum==True:
text_columns += ['metadata_annots_top_desc']
if Run_Sentiment_AvgSum==True:
text_columns += ['sentiment_entities']
categorical_columns = []
if Run_Breed_Map == True:
categorical_columns = ['main_breed_BreedName', 'second_breed_BreedName']
to... | model = SuperLearner(
folds=5,
random_state=666
)
model.add(
[
bc,
lgb,
xgb,
rf,
dt,
knn
]
)
model.add_meta(
LogisticRegression()
)
model.fit(X, y)
preds = model.predict(X_val)
print('SuperLearner accuracy: ', accuracy_score(y_val, preds))
print('SuperLearner f1-score: ', f1_score(y_val, preds)) | Titanic - Machine Learning from Disaster |
13,084,367 | rescuer_count = X.groupby(['RescuerID'])['PetID'].count().reset_index()
rescuer_count.columns = ['RescuerID', 'RescuerID_COUNT']
if Run_Rescuer_Cnt == True:
X_temp = X_temp.merge(rescuer_count, how='left', on='RescuerID' )<normalization> | mdict = {
'RF': RandomForestClassifier(random_state=666),
'XGB': XGBClassifier(random_state=666),
'LGBM': LGBMClassifier(random_state=666),
'DT': DecisionTreeClassifier(random_state=666),
'KNN': KNeighborsClassifier() ,
'BC': BaggingClassifier(random_state=666),
'OARF': RandomForestClassifier(**rf_acc_params),
'OFRF': ... | Titanic - Machine Learning from Disaster |
13,084,367 | for i in categorical_columns:
X_temp.loc[:, i] = pd.factorize(X_temp.loc[:, i])[0]<data_type_conversions> | def create_model(trial):
model_names = list()
models_list = [
'RF', 'XGB', 'LGBM', 'DT',
'KNN', 'BC', 'OARF', 'OFRF',
'OAXGB', 'OFXGB', 'OALGBM',
'OFLGBM', 'OADT', 'OFDT',
'OAKNN', 'OFKNN', 'OABC',
'OFBC', 'OAABC', 'OFABC',
'OAET', 'OFET', 'LR',
'ABC', 'SGD', 'ET',
'MLP', 'GB', 'RDG',
'PCP', 'PAC'
]
head_list = [
'RF',... | Titanic - Machine Learning from Disaster |
13,084,367 | X_text = X_temp[text_columns]
for i in X_text.columns:
X_text.loc[:, i] = X_text.loc[:, i].fillna('<MISSING>' )<feature_engineering> | model = SuperLearner(
folds=folds,
random_state=666
)
models = [
mdict[item] for item in result
]
model.add(models)
model.add_meta(mdict[head])
model.fit(X, y)
preds = model.predict(X_val)
print('Optimized SuperLearner accuracy: ', accuracy_score(y_val, preds))
print('Optimized SuperLearner f1-score: ', f1_score... | Titanic - Machine Learning from Disaster |
13,084,367 | n_components = 7
text_features = []
for i in X_text.columns:
print('generating features from: {}'.format(i))
svd_ = TruncatedSVD(
n_components=n_components, random_state=1337)
nmf_ = NMF(
n_components=n_components, random_state=1337)
tfidf_col = TfidfVectorizer().fit_transform(X_text.loc[:, i].values)
svd_col = sv... | preds = model.predict(X_test)
preds = preds.astype(np.int16 ) | Titanic - Machine Learning from Disaster |
13,084,367 | np.sum(pd.isnull(X_train))<count_missing_values> | submission = pd.read_csv('.. /input/titanic/gender_submission.csv')
submission['Survived'] = preds
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,127,762 | np.sum(pd.isnull(X_test))<import_modules> | sns.set()
train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
13,127,762 | def confusion_matrix(rater_a, rater_b, min_rating=None, max_rating=None):
assert(len(rater_a)== len(rater_b))
if min_rating is None:
min_rating = min(rater_a + rater_b)
if max_rating is None:
max_rating = max(rater_a + rater_b)
num_ratings = int(max_rating - min_rating + 1)
conf_mat = [[0 for i in range(num_rating... | print('Out of 891 entries, cabin is missing 687 so I'm droping it, also droping ticket and embarked because it isnt relevant')
train.isna().sum() | Titanic - Machine Learning from Disaster |
13,127,762 | params = {'application': 'regression',
'boosting': 'gbdt',
'metric': 'rmse',
'num_leaves': 70,
'max_depth': 9,
'learning_rate': 0.01,
'bagging_fraction': 0.85,
'feature_fraction': 0.8,
'min_split_gain': 0.02,
'min_child_samples': 150,
'min_child_weight': 0.02,
'lambda_l2': 0.0475,
'verbosity': -1,
'data_random_seed': 1... | train = train.drop(['Cabin', 'Ticket', 'Embarked'], axis=1)
test = test.drop(['Cabin', 'Ticket', 'Embarked'], axis=1 ) | Titanic - Machine Learning from Disaster |
13,127,762 | kfold = StratifiedKFold(n_splits=n_splits, random_state=1337)
oof_train = np.zeros(( X_train.shape[0]))
oof_test = np.zeros(( X_test.shape[0], n_splits))
i = 0
for train_index, valid_index in kfold.split(X_train, X_train['AdoptionSpeed'].values):
X_tr = X_train.iloc[train_index, :]
X_val = X_train.iloc[valid_index, :]... | print('filling age with age mean')
train.isna().sum() | Titanic - Machine Learning from Disaster |
13,127,762 | optR = OptimizedRounder()
optR.fit(oof_train, X_train['AdoptionSpeed'].values)
coefficients = optR.coefficients()
pred_test_y_k = optR.predict(oof_train, coefficients)
print("
Valid Counts = ", Counter(X_train['AdoptionSpeed'].values))
print("Predicted Counts = ", Counter(pred_test_y_k))
print("Coefficients = ", coef... | train['Age'] = train['Age'].fillna(np.mean(train['Age'])) | Titanic - Machine Learning from Disaster |
13,127,762 | coefficients_ = coefficients.copy()
coefficients_[0] = 1.645
coefficients_[1] = 2.115
coefficients_[3] = 2.84
train_predictions = optR.predict(oof_train, coefficients_ ).astype(int)
print('train pred distribution: {}'.format(Counter(train_predictions)))
test_predictions = optR.predict(oof_test.mean(axis=1), coefficie... | print('age and fare filling with mean')
test.isna().sum() | Titanic - Machine Learning from Disaster |
13,127,762 | print("True Distribution:")
print(pd.value_counts(X_train['AdoptionSpeed'], normalize=True ).sort_index())
print("
Train Predicted Distribution:")
print(pd.value_counts(train_predictions, normalize=True ).sort_index())
print("
Test Predicted Distribution:")
print(pd.value_counts(test_predictions, normalize=True ).... | test['Age'] = test['Age'].fillna(np.mean(test['Age']))
test['Fare'] = test['Fare'].fillna(np.mean(test['Fare'])) | Titanic - Machine Learning from Disaster |
13,127,762 | submission = pd.DataFrame({'PetID': test['PetID'].values, 'AdoptionSpeed': test_predictions.astype(np.int32)})
submission.head()
submission.to_csv('submission.csv', index=False )<set_options> | selected_features = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare'] | Titanic - Machine Learning from Disaster |
13,127,762 | %matplotlib inline
plt.rc('figure', figsize=(20.0, 10.0))<load_from_csv> | X_train = train[selected_features]
X_test = test[selected_features]
X_train = pd.get_dummies(X_train)
X_test = pd.get_dummies(X_test)
y_train = train['Survived'] | Titanic - Machine Learning from Disaster |
13,127,762 | train_df = pd.read_csv(os.path.join(INPUT_DIR, 'train', 'train.csv'))
X_test = pd.read_csv(os.path.join(INPUT_DIR, 'test', 'test.csv'))<categorify> | model = svm.LinearSVC()
model.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
13,127,762 | class DataFrameColumnMapper(BaseEstimator, TransformerMixin):
def __init__(self, column_name, mapping_func, new_column_name=None, drop_original=True):
self.column_name = column_name
self.mapping_func = mapping_func
self.new_column_name = new_column_name if new_column_name is not None else self.column_name
self.drop... | model = svm.SVC()
model.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
13,127,762 | class CategoricalToOneHotEncoder(BaseEstimator, TransformerMixin):
def __init__(self, columns=None):
self.columns = columns
self.mappings_ = None
def fit(self, X, y=None):
if self.columns is None:
self.columns = X.select_dtypes(exclude='number')
mappings = {}
for col in self.columns:
labels, uniques = X.loc[:, col].... | model = svm.NuSVC()
model.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
13,127,762 | class CategoricalTruncator(BaseEstimator, TransformerMixin):
def __init__(self, column_name, n_values_to_keep=5):
self.column_name = column_name
self.n_values_to_keep = n_values_to_keep
self.values_ = None
def fit(self, X, y=None):
self.values_ = list(X[self.column_name].value_counts() [:self.n_values_to_keep].keys()... | model = neighbors.KNeighborsClassifier()
model.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
13,127,762 | class DataFrameColumnDropper(BaseEstimator, TransformerMixin):
def __init__(self, column_names):
self.column_names = column_names
def fit(self, X, y=None):
return self
def transform(self, X):
return X.copy().drop(self.column_names, axis=1 )<train_model> | model = GradientBoostingClassifier(n_estimators=130, learning_rate=0.05)
model.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
13,127,762 | class ColumnByFeatureImportancePicker(BaseEstimator, TransformerMixin):
def __init__(self, n_features: int = 20, classifier=RandomForestClassifier(n_estimators=100, random_state=42)) :
self.n_features = n_features
self.classifier = classifier
self.attributes_ = None
def fit_and_compute_importances(self, X_df, y):
X... | predictions = model.predict(X_test ) | Titanic - Machine Learning from Disaster |
13,127,762 | <split><EOS> | output = pd.DataFrame({'PassengerId': test.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!")
output | Titanic - Machine Learning from Disaster |
13,514,343 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | %matplotlib inline
warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
13,514,343 | def has_field_transformer(column_name, new_column_name=None, is_missing_func=pd.notna)-> TransformerMixin:
return DataFrameColumnMapper(column_name=column_name,
mapping_func=lambda name: np.int(is_missing_func(name)) ,
drop_original=True,
new_column_name=new_column_name if new_column_name is not None else column_name)
... | train = pd.read_csv(".. /input/titanic/train.csv")
test = pd.read_csv(".. /input/titanic/test.csv")
train.describe(include="all" ) | Titanic - Machine Learning from Disaster |
13,514,343 | print("Number of features:", len(list(X_train_preprocessed)))
print("")
print("Numerical columns:", list(X_train_preprocessed.select_dtypes(include="number")))
print("")
print("Non-numerical columns:", list(X_train_preprocessed.select_dtypes(exclude="number")) )<categorify> | ids = test['PassengerId'] | Titanic - Machine Learning from Disaster |
13,514,343 | def build_preparation_pipeline() :
return Pipeline([
('to_numpy', DataFrameToValuesTransformer()),
('scaler', StandardScaler())
])
def build_full_pipeline(classifier=None):
preprocessing_pipeline = build_preprocessing_pipeline()
preparation_pipeline = build_preparation_pipeline()
return Pipeline([
('preprocessing'... | print(pd.isnull(train ).sum() ) | Titanic - Machine Learning from Disaster |
13,514,343 | rf_classifier = RandomForestClassifier(n_estimators=100)
rf_pipeline = build_full_pipeline(classifier=rf_classifier)
cross_val_score(rf_pipeline, X_train, y_train, cv=5, scoring=make_scorer(cohen_kappa_score))<train_on_grid> | all_data['Embarked'].fillna(all_data['Embarked'].mode() [0], inplace = True)
all_data['Fare'].fillna(all_data['Fare'].median() , inplace = True)
| Titanic - Machine Learning from Disaster |
13,514,343 | def build_search(pipeline, param_distributions, n_iter=10):
return RandomizedSearchCV(pipeline, param_distributions=param_distributions,
cv=5, return_train_score=True, refit='cohen_kappa',
n_iter=n_iter,
scoring={
'accuracy': make_scorer(accuracy_score),
'cohen_kappa': make_scorer(cohen_kappa_score)
},
verbose=1, rand... | all_data['Title'] = all_data.Name.str.extract('([A-Za-z]+)\.', expand=False)
all_data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
13,514,343 | param_distributions = {
'preprocessing__pick_columns_by_importance__n_features': [None, 50],
'classifier': [RandomForestClassifier(n_estimators=250, random_state=42, max_depth=10)],
'classifier__max_depth': [10, None]
}
rf_feature_search = build_search(build_full_pipeline() , param_distributions=param_distributions, n_... | frequent_titles = all_data['Title'].value_counts() [:5].index.tolist()
frequent_titles | Titanic - Machine Learning from Disaster |
13,514,343 | param_distributions = {
'preprocessing__pick_columns_by_importance__n_features': [None],
'classifier': [RandomForestClassifier(n_estimators=500, random_state=42)],
'classifier__n_estimators': [500],
'classifier__max_features': ['auto', 'log2'],
'classifier__max_depth': [None, 10],
'classifier__bootstrap': [False, True]... | all_data['Title'] = all_data['Title'].apply(lambda x: x if x in frequent_titles else 'Other')
| Titanic - Machine Learning from Disaster |
13,514,343 | param_distributions = {
'preprocessing__pick_columns_by_importance__n_features': [None],
'classifier': [ExtraTreesClassifier(n_estimators=500, random_state=42)],
'classifier__n_estimators': [500],
'classifier__max_features': ['auto', 'log2'],
'classifier__max_depth': [None],
'classifier__min_samples_split': [2, 5, 10],... | median_ages = {}
for title in frequent_titles:
median_ages[title] = all_data.loc[all_data['Title'] == title]['Age'].median()
median_ages['Other'] = all_data['Age'].median()
all_data.loc[all_data['Age'].isnull() , 'Age'] = all_data[all_data['Age'].isnull() ]['Title'].map(median_ages ) | Titanic - Machine Learning from Disaster |
13,514,343 | param_distributions = {
'preprocessing__pick_columns_by_importance__n_features': [None, 50],
'classifier': [LogisticRegression(solver='lbfgs', random_state=42)],
'classifier__multi_class': ['ovr', 'multinomial'],
'classifier__C': np.logspace(-3, 0, 4),
}
logistic_search = build_search(build_full_pipeline() , param_dist... | Cat_Features = ['Sex', 'Embarked', 'Title']
for feature in Cat_Features:
label = LabelEncoder()
all_data[feature] = label.fit_transform(all_data[feature] ) | Titanic - Machine Learning from Disaster |
13,514,343 | param_distributions = {
'preprocessing__pick_columns_by_importance__n_features': [None, 50],
'preparation__scaler': [MinMaxScaler() ],
'classifier': [MLPClassifier(hidden_layer_sizes=(100,), random_state=42)],
'classifier__hidden_layer_sizes': [[10], [10, 10,], [10, 10, 10]],
'classifier__alpha': np.logspace(-4, -2, 3)... | Cont_Features = ['Age', 'Fare']
num_bins = 5
for feature in Cont_Features:
bin_feature = feature + 'Bin'
all_data[bin_feature] = pd.qcut(all_data[feature], num_bins)
label = LabelEncoder()
all_data[bin_feature] = label.fit_transform(all_data[bin_feature] ) | Titanic - Machine Learning from Disaster |
13,514,343 |
<define_search_space> | all_data['Surname'] = all_data.Name.str.extract(r'([A-Za-z]+),', expand=False)
all_data['TicketPrefix'] = all_data.Ticket.str.extract(r' (.*\d)', expand=False)
all_data['Surname_Ticket'] = all_data['Surname'] + all_data['TicketPrefix']
all_data['IsFamily'] = all_data.Surname_Ticket.duplicated(keep=False ).astype(int ... | Titanic - Machine Learning from Disaster |
13,514,343 | param_distributions = {
'preprocessing__pick_columns_by_importance__n_features': [None],
'classifier': [ GradientBoostingClassifier(random_state=42)],
'classifier__loss': ['deviance'],
'classifier__n_estimators': [100, 300],
'classifier__max_features': ['log2', None],
'classifier__max_depth': [5, 10],
'classifier__min_... | all_data['Child'] = all_data.Age.map(lambda x: 1 if x <=16 else 0)
FamilyWithChild = all_data[(all_data.IsFamily==1)&(all_data.Child==1)]['Surname_Ticket'].unique()
len(FamilyWithChild ) | Titanic - Machine Learning from Disaster |
13,514,343 | param_distributions = {
'preprocessing__pick_columns_by_importance__n_features': [None],
'classifier': [ lgb.sklearn.LGBMClassifier(random_state=42, objective='multiclass')],
'classifier__boosting_type': ['gbdt', 'dart'],
'classifier__num_leaves': [20, 31, 50],
'classifier__max_depth': [-1],
'classifier__learning_rate'... | all_data['FamilyId'] = 0
for ind, identifier in enumerate(FamilyWithChild):
all_data.loc[all_data.Surname_Ticket==identifier, ['FamilyId']] = ind + 1 | Titanic - Machine Learning from Disaster |
13,514,343 | def cross_val_predictions(classifiers, X, y):
return np.hstack([cross_val_predict(classifier, X, y, cv=5, method='predict_proba')for classifier in classifiers])
def first_level_predictions(classifiers, X):
return np.hstack([classifier.predict_proba(X)for classifier in classifiers])
best_estimators = [
rf_search.b... | X_train = train[['Pclass', 'Sex', 'Parch', 'Embarked', 'CabinBool', 'Title', 'AgeBin', 'FareBin', 'FamilySurvival']]
y_train = train['Survived'] | Titanic - Machine Learning from Disaster |
13,514,343 | for estimator in best_estimators:
estimator.fit(X_train, y_train)
X_val_second_level = first_level_predictions(best_estimators, X_val)
y_val_pred = stacking_classifier.predict(X_val_second_level)
print("Performance of stacking classifier on the hold-out set:", cohen_kappa_score(y_val, y_val_pred))<find_best_model_cl... | model = CatBoostClassifier(verbose=False ) | Titanic - Machine Learning from Disaster |
13,514,343 | X_train_val_second_level = cross_val_predictions(best_estimators, X=X_train_val, y=y_train_val)
stacking_classifier.fit(X_train_val_second_level, y_train_val)
for estimator in best_estimators:
estimator.fit(X_train_val, y_train_val)
X_test_second_level = first_level_predictions(best_estimators, X=X_test )<predict_on... | main_features = ['Sex', 'FamilySurvival', 'FareBin', 'Pclass', 'Title']
X_test = test[main_features]
X_train = train[main_features] | Titanic - Machine Learning from Disaster |
13,514,343 | def get_predictions(estimator, X):
predictions = estimator.predict(X)
indices = X_test.loc[:, 'PetID']
as_dict = [{'PetID': index, 'AdoptionSpeed': prediction} for index, prediction in zip(indices, predictions)]
df = pd.DataFrame.from_dict(as_dict)
df = df.reindex(['PetID', 'AdoptionSpeed'], axis=1)
return df
predic... | cross_val_score(estimator=model, X=X_train, y=y_train, cv=5 ).mean() | Titanic - Machine Learning from Disaster |
13,514,343 | def write_submission(predictions):
submission_folder = '.'
dest_file = os.path.join(submission_folder, 'submission.csv')
predictions.to_csv(dest_file, index=False)
print("Wrote to {}".format(dest_file))
write_submission(predictions )<set_options> | ensemble = [CatBoostClassifier(verbose=False), RandomForestClassifier() , svm.NuSVC(probability=True), neighbors.KNeighborsClassifier() ]
classifiers_with_names = []
_ = [classifiers_with_names.append(( clf.__class__.__name__, clf)) for clf in ensemble]
voting = VotingClassifier(classifiers_with_names, voting='hard')
... | Titanic - Machine Learning from Disaster |
13,514,343 | <install_modules><EOS> | output = pd.DataFrame({'PassengerId': test.PassengerId, 'Survived': predictions.astype(int)})
output.to_csv('submission_new_session.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,484,368 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<set_options> | warnings.filterwarnings("ignore")
%matplotlib inline | Titanic - Machine Learning from Disaster |
13,484,368 | shap.initjs()<load_from_csv> | train = pd.read_csv(".. /input/titanic/train.csv")
test = pd.read_csv(".. /input/titanic/test.csv")
submission = pd.read_csv(".. /input/titanic/gender_submission.csv" ) | Titanic - Machine Learning from Disaster |
13,484,368 | train = pd.read_csv('.. /input/tabular-playground-series-jan-2021/train.csv')
test = pd.read_csv('.. /input/tabular-playground-series-jan-2021/test.csv')
sub = pd.read_csv('.. /input/tabular-playground-series-jan-2021/sample_submission.csv' )<define_variables> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,484,368 | train_oof = np.zeros(( 300000,))
test_preds = 0
train_oof.shape<init_hyperparams> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,484,368 | Best_trial= {'lambda': 0.0030282073258141168,
'alpha': 0.01563845128469084,
'colsample_bytree': 0.55,
'subsample': 0.7,
'learning_rate': 0.01,
'max_depth': 15,
'random_state': 2020,
'min_child_weight': 257,
'tree_method':'gpu_hist',
'predictor': 'gpu_predictor'}<prepare_x_and_y> | train.groupby('Pclass' ).Survived.value_counts() | Titanic - Machine Learning from Disaster |
13,484,368 | test = xgb.DMatrix(test[columns] )<train_model> | train['Name'] = train.Name.str.extract('([A-Za-z]+)\.',expand = False ) | Titanic - Machine Learning from Disaster |
13,484,368 | NUM_FOLDS = 8
kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=0)
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(train, target))):
train_df, val_df = train.iloc[train_ind][columns], train.iloc[val_ind][columns]
train_target, val_target = target[train_ind], target[val_ind]
train_df = xgb.DMatrix(train_df... | top6 = train['Name'].value_counts() [:6].index.to_list()
top6 | Titanic - Machine Learning from Disaster |
13,484,368 | mean_squared_error(train_oof, target, squared=False)
<save_model> | train['Name'] = train['Name'].apply(lambda x: x if x in top6 else 'Other' ) | Titanic - Machine Learning from Disaster |
13,484,368 | np.save('train_oof', train_oof)
np.save('test_preds', test_preds )<predict_on_test> | train.groupby('Name' ).Survived.value_counts() | Titanic - Machine Learning from Disaster |
13,484,368 | %%time
shap_preds = model.predict(test, pred_contribs=True )<load_from_csv> | train['family'] = train['SibSp'] + train['Parch'] + 1 | Titanic - Machine Learning from Disaster |
13,484,368 | test = pd.read_csv('.. /input/tabular-playground-series-jan-2021/test.csv')
<prepare_x_and_y> | train.groupby('family' ).Survived.value_counts() | Titanic - Machine Learning from Disaster |
13,484,368 | test = xgb.DMatrix(test[columns] )<predict_on_test> | for i in range(len(train)) :
if(train['family'][i] > 1):
train['family'][i] = 1
else:
train['family'][i] = 0 | Titanic - Machine Learning from Disaster |
13,484,368 | %%time
shap_interactions = model.predict(test, pred_interactions=True )<set_options> | train.groupby('Cabin' ).Survived.value_counts() | Titanic - Machine Learning from Disaster |
13,484,368 | del shap_interactions, shap_preds
gc.collect()
gc.collect()<load_from_csv> | train['Cabin'].fillna('S',inplace=True ) | Titanic - Machine Learning from Disaster |
13,484,368 | train = pd.read_csv('.. /input/tabular-playground-series-jan-2021/train.csv')
test = pd.read_csv('.. /input/tabular-playground-series-jan-2021/test.csv')
sub = pd.read_csv('.. /input/tabular-playground-series-jan-2021/sample_submission.csv' )<feature_engineering> | for i in range(len(train)) :
train['Cabin'][i] = train['Cabin'][i][0] | Titanic - Machine Learning from Disaster |
13,484,368 | train['cont13_cont4'] = train['cont13']*train['cont4']
train['cont13_cont11'] = train['cont13']*train['cont11']
train['cont13_cont7'] = train['cont13']*train['cont7']
train['cont13_cont2'] = train['cont13']*train['cont2']
train['cont13_cont10'] = train['cont13']*train['cont10']
test['cont13_cont4'] = test['cont13']*tes... | train.groupby('Cabin' ).Survived.value_counts() | Titanic - Machine Learning from Disaster |
13,484,368 | test = xgb.DMatrix(test[columns] )<init_hyperparams> | train['fare_val'] = 0
for i in range(len(train)) :
if(train['Fare'][i] > 32.0):
train['fare_val'][i] = 1 | Titanic - Machine Learning from Disaster |
13,484,368 | Best_trial= {'lambda': 0.0030282073258141168,
'alpha': 0.01563845128469084,
'colsample_bytree': 0.55,
'subsample': 0.7,
'learning_rate': 0.01,
'max_depth': 15,
'random_state': 2020,
'min_child_weight': 257,
'tree_method':'gpu_hist',
'predictor': 'gpu_predictor'}<train_model> | train.groupby('fare_val' ).Survived.value_counts() | Titanic - Machine Learning from Disaster |
13,484,368 | kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=0)
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(train, target))):
train_df, val_df = train.iloc[train_ind][columns], train.iloc[val_ind][columns]
train_target, val_target = target[train_ind], target[val_ind]
train_df = xgb.DMatrix(train_df, label=train_... | test['family'] = test['SibSp'] + test['Parch'] + 1
for i in range(len(test)) :
if(test['family'][i] > 1):
test['family'][i] = 1
else:
test['family'][i] = 0
test['Name'] = test['Name'].apply(lambda x: x if x in top6 else 'Other')
test['Cabin'].fillna('S',inplace=True)
for i in range(len(test)) :
test['Cabin'][i] = tes... | Titanic - Machine Learning from Disaster |
13,484,368 | mean_squared_error(train_oof_2, target, squared=False)
<compute_test_metric> | features = [
'Pclass',
'Sex',
'Age',
'family',
'fare_val',
'Embarked'
]
target = 'Survived' | Titanic - Machine Learning from Disaster |
13,484,368 | mean_squared_error(0.6*train_oof+0.4*train_oof_2, target, squared=False)
<save_model> | train[features].isnull().sum() | Titanic - Machine Learning from Disaster |
13,484,368 | np.save('train_oof_2', train_oof_2)
np.save('test_preds_2', test_preds_2 )<save_to_csv> | test[features].isnull().sum() | Titanic - Machine Learning from Disaster |
13,484,368 | sub['target'] = test_preds
sub.to_csv('submission.csv', index=False )<save_to_csv> | ; | Titanic - Machine Learning from Disaster |
13,484,368 | sub['target'] = test_preds_2
sub.to_csv('submission_2.csv', index=False )<save_to_csv> | Age_std = train['Age'].std()
train['Age'] = train['Age'].fillna(value = Age_std)
Age_std_t = test['Age'].std()
test['Age'] = test['Age'].fillna(value = Age_std_t)
f"'train',{Age_std}, 'test',{Age_std_t}" | Titanic - Machine Learning from Disaster |
13,484,368 | sub['target'] = 0.6*test_preds+0.4*test_preds_2
sub.to_csv('submission_average.csv', index=False )<set_options> | lbl = LabelEncoder()
train['Sex'] = lbl.fit_transform(train[['Sex']].values.ravel())
test['Sex'] = lbl.fit_transform(test[['Sex']].values.ravel() ) | Titanic - Machine Learning from Disaster |
13,484,368 | warnings.filterwarnings('ignore')
pd.set_option('display.max_rows', 50)
pd.set_option('display.max_columns', 50)
<load_from_csv> | Titanic - Machine Learning from Disaster | |
13,484,368 | df_train = pd.read_csv('.. /input/tabular-playground-series-jan-2021/train.csv')
df_test = pd.read_csv('.. /input/tabular-playground-series-jan-2021/test.csv')
continuous_features = [feature for feature in df_train.columns if feature.startswith('cont')]
target = 'target'
print(f'Training Set Shape = {df_train.shape}'... | train['Embarked'] = train['Embarked'].fillna(value=train['Embarked'].mode() [0])
test['Embarked'] = test['Embarked'].fillna(value=test['Embarked'].mode() [0])
| Titanic - Machine Learning from Disaster |
13,484,368 | class Preprocessor:
def __init__(self, train, test, n_splits, shuffle, random_state, scaler, discretize_features, create_features):
self.train = train.copy(deep=True)
self.test = test.copy(deep=True)
self.n_splits = n_splits
self.shuffle = shuffle
self.random_state = random_state
self.scaler = scaler() if scaler else... | train_ds = train[features]
test_ds = test[features] | Titanic - Machine Learning from Disaster |
13,484,368 | cross_validation_seed = 0
preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed,
scaler=None,
create_features=False, discretize_features=False)
df_train_processed, df_test_processed = preprocessor.transform()
print(f'
Preprocessed Training Set Shape = {d... | train_ds = pd.get_dummies(columns = ['Embarked','Pclass'],data=train_ds,drop_first = True)
test_ds = pd.get_dummies(columns = ['Embarked','Pclass'],data=test_ds,drop_first = True ) | Titanic - Machine Learning from Disaster |
13,484,368 | class TreeModels:
def __init__(self, predictors, target, model, model_parameters, boosting_rounds, early_stopping_rounds, seeds):
self.predictors = predictors
self.target = target
self.model = model
self.model_parameters = model_parameters
self.boosting_rounds = boosting_rounds
self.early_stopping_rounds = early_stoppi... | y_train = train[target] | Titanic - Machine Learning from Disaster |
13,484,368 | TRAIN_LGB = False
if TRAIN_LGB:
model = 'LGB'
lgb_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=None,
create_features=False, discretize_features=False)
df_train_lgb, df_test_lgb = lgb_preprocessor.transform()
print(f'
{model} Training Set... | X_train, X_valid, y_train, y_valid = train_test_split(train_ds, y_train, test_size=0.30 ) | Titanic - Machine Learning from Disaster |
13,484,368 | TRAIN_CB = False
if TRAIN_CB:
model = 'CB'
cb_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=None,
create_features=False, discretize_features=False)
df_train_cb, df_test_cb = cb_preprocessor.transform()
print(f'
{model} Training Set Shape ... | from sklearn.model_selection import train_test_split,cross_val_score,RandomizedSearchCV,GridSearchCV
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report
from sklearn.metrics import roc_auc_score, roc_curve
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassif... | Titanic - Machine Learning from Disaster |
13,484,368 | TRAIN_XGB = False
if TRAIN_XGB:
model = 'XGB'
xgb_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=None,
create_features=False, discretize_features=False)
df_train_xgb, df_test_xgb = xgb_preprocessor.transform()
print(f'
{model} Training Set... | ; | Titanic - Machine Learning from Disaster |
13,484,368 | TRAIN_RF = False
if TRAIN_RF:
model = 'RF'
rf_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=None,
create_features=False, discretize_features=False)
df_train_rf, df_test_rf = rf_preprocessor.transform()
print(f'
{model} Training Set Shape ... | rfc = XGBClassifier()
params = {'n_estimators': [200,500,800,1000,1200],
'max_depth': [3,5,7],
'objective' : ['binary:logistic'],
'min_samples_leaf' : [1, 2, 3, 4, 5],
'max_leaf_nodes':[2,3,5,7],
'min_child_weight': [1, 5, 10],
'gamma': [0.5, 1, 1.5, 2, 5],
}
rfc_cv = RandomizedSearchCV(rfc, params, cv = 10, n_jobs=-1,... | Titanic - Machine Learning from Disaster |
13,484,368 | class LinearModels:
def __init__(self, predictors, target, model, model_parameters):
self.predictors = predictors
self.target = target
self.model = model
self.model_parameters = model_parameters
def _train_and_predict_ridge_regression(self, X_train, y_train, X_test):
X = pd.concat([X_train[continuous_features], X_test[... | rfc_cv.best_params_
best_model = rfc_cv.best_estimator_
print(best_model)
print(rfc_cv.best_score_ ) | Titanic - Machine Learning from Disaster |
13,484,368 | FIT_RR = False
if FIT_RR:
model = 'Ridge'
ridge_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=None,
create_features=False, discretize_features=False)
df_train_ridge, df_test_ridge = ridge_preprocessor.transform()
print(f'
{model} Training... | rfc_pred = best_model.predict(X_valid)
print("Accuracy: ", accuracy_score(y_valid, rfc_pred))
print("
Confusion Matrix
")
print(confusion_matrix(y_valid, rfc_pred)) | Titanic - Machine Learning from Disaster |
13,484,368 | FIT_SVM = False
if FIT_SVM:
model = 'SVM'
svm_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=StandardScaler,
create_features=False, discretize_features=True)
df_train_svm, df_test_svm = svm_preprocessor.transform()
print(f'
{model} Trainin... | filename = 'Titanic_model.sav'
pickle.dump(best_model, open(filename, 'wb')) | Titanic - Machine Learning from Disaster |
13,484,368 | class NeuralNetworks:
def __init__(self, predictors, target, model, model_parameters, seeds):
self.predictors = predictors
self.target = target
self.model = model
self.model_parameters = model_parameters
self.seeds = seeds
def _set_seed(self, seed):
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
os.... | loaded_model = pickle.load(open(filename, 'rb'))
result = loaded_model.score(X_valid, y_valid)
print(result ) | Titanic - Machine Learning from Disaster |
13,484,368 | TRAIN_TMLP = False
if TRAIN_TMLP:
model = 'TMLP'
tmlp_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=StandardScaler,
create_features=False, discretize_features=True)
df_train_tmlp, df_test_tmlp = tmlp_preprocessor.transform()
print(f'
{mod... | passId = test[['PassengerId']].values | Titanic - Machine Learning from Disaster |
13,484,368 | TRAIN_RMLP = False
if TRAIN_RMLP:
model = 'RMLP'
rmlp_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=StandardScaler,
create_features=False, discretize_features=False)
df_train_rmlp, df_test_rmlp = rmlp_preprocessor.transform()
for feature ... | final_pred = best_model.predict(test_ds ) | Titanic - Machine Learning from Disaster |
13,484,368 | class SubmissionPipeline:
def __init__(self, train, test, blend, prediction_columns, add_public_best):
self.train = train
self.test = test
self.blend = blend
self.prediction_columns = prediction_columns
self.add_public_best = add_public_best
def weighted_average(self):
self.train['FinalPredictions'] =(0.77 * self.train... | sub = {'PassengerId':passId.ravel() , 'Survived':final_pred} | Titanic - Machine Learning from Disaster |
13,484,368 | df_test_processed['target'] = df_test_submission['FinalPredictions']
df_test_processed[['id', 'target']].to_csv('submission.csv', index=False)
df_test_processed[['id', 'target']].describe()<set_options> | submission_csv = pd.DataFrame(sub ) | Titanic - Machine Learning from Disaster |
13,484,368 | plt.style.use('fivethirtyeight')
y_ = Fore.YELLOW
r_ = Fore.RED
g_ = Fore.GREEN
b_ = Fore.BLUE
m_ = Fore.MAGENTA
c_ = Fore.CYAN
sr_ = Style.RESET_ALL
warnings.filterwarnings('ignore')
<load_from_csv> | submission_csv.to_csv('final_sub_titanic_xgb_cv_10.csv',index = False ) | Titanic - Machine Learning from Disaster |
13,484,368 | path = '.. /input/tabular-playground-series-jan-2021/'
train_data = pd.read_csv(path + 'train.csv')
test_data = pd.read_csv(path + 'test.csv')
sample = pd.read_csv(path + 'sample_submission.csv' )<feature_engineering> | x = pd.read_csv("./final_sub_titanic_xgb_cv_10.csv" ) | 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.