kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,177,777 | <count_unique_values><EOS> | output = pd.DataFrame({'PassengerId': Id, 'Survived': final_predictions})
output.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
8,719,787 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.neighbors import KNeighborsClassifier
from xgboost import XGBClassifier... | Titanic - Machine Learning from Disaster |
8,719,787 | MODEL_VERSION = 'v15_param_tuning'
<define_variables> | train = pd.read_csv(".. /input/titanic/train.csv")
test = pd.read_csv(".. /input/titanic/test.csv")
testid = test['PassengerId']
train_len = len(train)
y = train['Survived']
X = pd.concat([train, test] ) | Titanic - Machine Learning from Disaster |
8,719,787 | TEST_RUN = False
pd.set_option('display.max_columns', 50)
KAGGLE_DATA_FOLDER = '/kaggle/input/m5-forecasting-accuracy'
BACKWARD_LAG = 60
END_DAY = 1913
BEGIN_DATE = '2013-08-01'
BEGIN_DAY = str(( datetime.strptime(BEGIN_DATE, '%Y-%m-%d')- datetime.strptime('2011-01-29', '%Y-%m-%d')).days)
TRAIN_SPLIT = '2016-03-27'
E... | X['Title'] = X['Name']
for name_string in X['Name']:
X['Title'] = X['Name'].str.extract('([A-Za-z]+)\.', expand=True)
mapping = {'Mlle': 'Miss', 'Major': 'Mr', 'Col': 'Mr', 'Sir': 'Mr', 'Don': 'Mr', 'Mme': 'Miss',
'Jonkheer': 'Mr', 'Lady': 'Mrs', 'Capt': 'Mr', 'Countess': 'Mrs', 'Ms': 'Miss', 'Dona': 'Mrs'}
X.replace(... | Titanic - Machine Learning from Disaster |
8,719,787 | CALENDAR_DTYPES = {
'date': 'str',
'wm_yr_wk': 'int16',
'weekday': 'category',
'wday': 'int16',
'month': 'int16',
'year': 'int16',
'd': 'object',
'event_name_1': 'category',
'event_type_1': 'category',
'event_name_2': 'category',
'event_type_2': 'category',
'snap_CA': 'int16',
'snap_TX': 'int16',
'snap_WI': 'int16'
}
P... | X['Family_Size'] = X['Parch'] + X['SibSp'] | Titanic - Machine Learning from Disaster |
8,719,787 | def load_data(train=True):
print("Loading train and validation data")
numcols = [f"d_{day}" for day in range(int(BEGIN_DAY),END_DAY+1)]
catcols = ['id', 'item_id', 'dept_id','store_id', 'cat_id', 'state_id']
dtype = {numcol:"float32" for numcol in numcols}
dtype.update({col: "category" for col in catcols if col != "... | X['Last_Name'] = X['Name'].apply(lambda x: str.split(x, ",")[0])
X['Fare'].fillna(X['Fare'].mean() , inplace=True)
DEFAULT_SURVIVAL_VALUE = 0.5
X['Family_Survival'] = DEFAULT_SURVIVAL_VALUE
for grp, grp_df in X[['Survived','Name', 'Last_Name', 'Fare', 'Ticket', 'PassengerId',
'SibSp', 'Parch', 'Age', 'Cabin']].groupb... | Titanic - Machine Learning from Disaster |
8,719,787 | def make_lag_features(strain):
print('in dataframe:', strain.shape)
print("headers:", strain.columns)
lags = [7, 28]
lag_cols = ['lag_{}'.format(lag)for lag in lags ]
for lag, lag_col in zip(lags, lag_cols):
strain[lag_col] = strain[['id', 'sales']].groupby('id')['sales'].shift(lag)
print('lag sales done')
window... | X['Fare'].fillna(X['Fare'].median() , inplace = True)
X['FareBin'] = pd.qcut(X['Fare'], 5)
label = LabelEncoder()
X['FareBin_Code'] = label.fit_transform(X['FareBin'])
X.drop(['Fare'], 1, inplace=True ) | Titanic - Machine Learning from Disaster |
8,719,787 | %%time
sales_train_validation = load_data()<data_type_conversions> | X['AgeBin'] = pd.qcut(X['Age'], 4)
label = LabelEncoder()
X['AgeBin_Code'] = label.fit_transform(X['AgeBin'])
X.drop(['Age'], 1, inplace=True ) | Titanic - Machine Learning from Disaster |
8,719,787 | sales_train_validation["sale"] =(( sales_train_validation['sell_price'] * 100 % 10)< 6 ).astype('int8' )<feature_engineering> | X['Sex'].replace(['male','female'],[0,1],inplace=True)
X.drop(['Name', 'PassengerId', 'SibSp', 'Parch', 'Ticket', 'Cabin',
'Embarked', 'Last_Name', 'FareBin', 'AgeBin', 'Survived'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
8,719,787 | %%time
make_lag_features(sales_train_validation)
make_date_features(sales_train_validation )<define_variables> | X_train = X[:train_len]
X_test = X[train_len:]
y_train = y | Titanic - Machine Learning from Disaster |
8,719,787 | total = len(sales_train_validation['event_type_2'])
zero = len(sales_train_validation.loc[sales_train_validation['event_type_2'] == 0])
one = len(sales_train_validation.loc[sales_train_validation['event_type_2'] == 1])
two = len(sales_train_validation.loc[sales_train_validation['event_type_2'] == 2])
print('0: '+ s... | scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test ) | Titanic - Machine Learning from Disaster |
8,719,787 | sales_train_validation.isnull().sum()<categorify> | kfold = StratifiedKFold(n_splits=8 ) | Titanic - Machine Learning from Disaster |
8,719,787 | before = len(sales_train_validation)
sales_train_validation.dropna(inplace = True)
after = len(sales_train_validation)
print(f"Reduced {(before-after)/before}%")
<split> | RFC = RandomForestClassifier()
rf_param_grid = {"max_depth": [None],
"max_features": [3,"sqrt", "log2"],
"min_samples_split": [2, 4],
"min_samples_leaf": [5, 7],
"bootstrap": [False, True],
"n_estimators" :[200, 500],
"criterion": ["gini", "entropy"]}
rf_param_grid_best = {"max_depth": [None],
"max_features": [3],
"min... | Titanic - Machine Learning from Disaster |
8,719,787 | print("Splitting data into train, validation, evaluation set")
<features_selection> | KNN = KNeighborsClassifier()
knn_param_grid = {'algorithm': ['auto'],
'weights': ['uniform', 'distance'],
'leaf_size': [20, 25, 30],
'n_neighbors': [12, 14, 16]}
gs_knn = GridSearchCV(KNN, param_grid = knn_param_grid, cv=kfold, scoring = "roc_auc", n_jobs= 4, verbose = 1)
gs_knn.fit(X_train, y_train)
KNN.fit(X_train,... | Titanic - Machine Learning from Disaster |
8,719,787 | %%time
np.random.seed(777)
validation_idx = np.random.choice(sales_train_validation.index.values, 2_000_000, replace = False)
train_idx = np.setdiff1d(sales_train_validation.index.values, validation_idx)
train = sales_train_validation.loc[train_idx]
validation = sales_train_validation.loc[validation_idx]
evaluation ... | GB = GradientBoostingClassifier()
gb_param_grid = {'loss' : ["deviance"],
'n_estimators' : [1000],
'learning_rate': [0.02, 0.05],
'min_samples_split': [15, 20, 25],
'max_depth': [4, 6],
'min_samples_leaf': [50, 60],
'max_features': ["sqrt"]
}
gb_param_grid_best = {'loss' : ["deviance"],
'n_estimators' : [1000],
'learni... | Titanic - Machine Learning from Disaster |
8,719,787 | print("Train:", train.shape)
print("Validation:", validation.shape)
print("Evaluation:", evaluation.shape )<define_variables> | XGB = XGBClassifier()
xgb_param_grid = {'learning_rate':[0.05, 0.1],
'reg_lambda':[0.3, 0.5],
'gamma': [0.8, 1],
'subsample': [0.8, 1],
'max_depth': [2, 3],
'n_estimators': [200, 300]
}
xgb_param_grid_best = {'learning_rate':[0.1],
'reg_lambda':[0.3],
'gamma': [1],
'subsample': [0.8],
'max_depth': [2],
'n_estimators': ... | Titanic - Machine Learning from Disaster |
8,719,787 | categorical_features = [
'item_id', 'dept_id', 'store_id', 'cat_id', 'state_id',
'event_name_1', 'event_type_1', 'event_name_2', 'event_type_2'
]<create_dataframe> | knn1 = KNeighborsClassifier(algorithm='auto', leaf_size=26, metric='minkowski',
metric_params=None, n_jobs=1, n_neighbors=6, p=2,
weights='uniform')
knn1.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
8,719,787 | train_pool = lgb.Dataset(
data=train[train_columns],
label=train["sales"],
categorical_feature=categorical_features,
free_raw_data=False)
del train; gc.collect()<create_dataframe> | y_pred = knn1.predict(X_test)
test_Survived = pd.Series(y_pred, name="Survived")
results = pd.concat([testid,test_Survived],axis=1)
results.to_csv("submit.csv",index=False ) | Titanic - Machine Learning from Disaster |
11,609,919 | val_pool = lgb.Dataset(
data=validation[train_columns],
label=validation["sales"],
categorical_feature=categorical_features,
free_raw_data=False
)
del validation; del evaluation; gc.collect()<init_hyperparams> | %matplotlib inline
warnings.filterwarnings('ignore')
warnings.filterwarnings('ignore', category=DeprecationWarning ) | Titanic - Machine Learning from Disaster |
11,609,919 | if TEST_RUN:
ITERATIONS=1
else:
ITERATIONS = 2000
params = {
"objective" : "poisson",
"metric" :"rmse",
"force_row_wise" : True,
"learning_rate" : 0.075,
"sub_row" : 0.75,
"bagging_freq" : 1,
"lambda_l2" : 0.1,
"metric": ["rmse"],
'verbosity': 1,
'num_iterations' : ITERATIONS,
'num_leaves': 128,
"min_data_in_leaf": 100... | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
11,609,919 | %%time
if TASK_TYPE=='GPU':
model = "todo"
else:
model = lgb.train(
params,
train_pool,
valid_sets = val_pool,
verbose_eval=20 )<save_model> | train['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
11,609,919 | model.save_model("model_{}.lgb".format(MODEL_VERSION))<set_options> | def detect_outlier(df,n,cols):
outlier_indices = []
for i in cols:
Q1 = np.percentile(df[i], 25)
Q3 = np.percentile(df[i], 75)
IQR = Q3 - Q1
outlier_step = 1.5*IQR
outlier_index_list = df[(df[i] < Q1-outlier_step)|(df[i] > Q3+outlier_step)].index
outlier_indices.extend(outlier_index_list)
outlier_indices = Counter(o... | Titanic - Machine Learning from Disaster |
11,609,919 | del train_pool, val_pool; gc.collect()<feature_engineering> | outliers_to_drop = detect_outlier(train,2,['Age', 'SibSp', 'Parch', 'Fare'])
train.loc[outliers_to_drop] | Titanic - Machine Learning from Disaster |
11,609,919 | df = load_data(train=False)
make_date_features(df )<data_type_conversions> | train = train.drop(outliers_to_drop, axis = 0 ).reset_index(drop=True ) | Titanic - Machine Learning from Disaster |
11,609,919 | df["sale"] =(( df['sell_price'] * 100 % 10)< 6 ).astype('int8' )<feature_engineering> | targets = train.Survived
train.drop(['Survived'], 1, inplace=True)
combined = train.append(test)
combined.reset_index(inplace=True)
combined.drop(['index', 'PassengerId'], inplace=True, axis=1 ) | Titanic - Machine Learning from Disaster |
11,609,919 | def lag_features_for_day(dt, day):
print(type(dt))
lags = [7, 28]
lag_cols = [f"lag_{lag}" for lag in lags]
for lag, lag_col in zip(lags, lag_cols):
dt.loc[dt['date'] == str(day), lag_col] = \
dt.loc[dt['date'] == str(day-timedelta(days=lag)) , 'sales'].values
windows = [7, 28]
for window in windows:
for lag, lag_col i... | titles = set()
for name in train['Name']:
titles.add(name.split(',')[1].split('.')[0].strip())
print(titles ) | Titanic - Machine Learning from Disaster |
11,609,919 | %%time
END_DATE = EVAL_SPLIT
ZERO_THRESHOLD = 0.01
PREDICT_DAYS = 28
for f_day in tqdm(range(1,PREDICT_DAYS+1)) :
pred_date =(datetime.strptime(END_DATE, '%Y-%m-%d')+ timedelta(days=f_day)).date()
print(f"Forecasting day {END_DAY+f_day}, date: {str(pred_date)}")
pred_begin_date = pred_date - timedelta(days=BACKWARD_LA... | combined['Title'] = combined['Name'].str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
11,609,919 | del prediction_data
gc.collect()<feature_engineering> | combined['Title'] = combined['Title'].replace(['Lady', 'Countess','Capt', 'Col', 'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
combined['Title'] = combined['Title'].replace('Mlle', 'Miss')
combined['Title'] = combined['Title'].replace('Ms', 'Miss')
combined['Title'] = combined['Title'].replace('Mm... | Titanic - Machine Learning from Disaster |
11,609,919 | submission_val = df.loc[df['date'] > END_DATE, ['id', 'day', 'sales']].copy()
submission_val.loc[submission_val['sales'] < 0, 'sales'] = 0
submission_val.sort_values('id', inplace=True)
submission_val['day'] = submission_val['day'].apply(lambda x: 'F{}'.format(x - END_DAY))
print(submission_val.columns )<prepare_outpu... | combined["Sex"][combined["Sex"] == "male"] = 0
combined["Sex"][combined["Sex"] == "female"] = 1
combined["Sex"] = combined["Sex"].astype(int ) | Titanic - Machine Learning from Disaster |
11,609,919 | submission_eval = submission_val.copy()
submission_eval['id'] = submission_eval['id'].str.replace('validation', 'evaluation')
submission = pd.concat([submission_val, submission_eval], axis=0, sort=False)
print(submission.columns)
print(submission.head(1))<save_to_csv> | combined['Age'] = combined.groupby('Pclass')['Age'].transform(lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
11,609,919 | submission.to_csv('submission.csv', index=False)
print('Submission shape', submission.shape )<load_from_csv> | combined["Age"] = combined["Age"].astype(int ) | Titanic - Machine Learning from Disaster |
11,609,919 | submission0 = pd.read_csv('/kaggle/input/m5-final-models/submission_LSTM.csv')
submission1 = pd.read_csv('/kaggle/input/m5-final-models/submission_XGBoost.csv')
submission2 = pd.read_csv('/kaggle/input/m5-final-models/submission_LGBM.csv')
submission3 = pd.read_csv('/kaggle/input/m5-final-models/submission_prophet.c... | combined['Ticket'] = tickets | Titanic - Machine Learning from Disaster |
11,609,919 |
<load_from_csv> | combined = pd.get_dummies(combined, columns= ["Ticket"], prefix = "T" ) | Titanic - Machine Learning from Disaster |
11,609,919 | calendar = pd.read_csv('/kaggle/input/m5-forecasting-accuracy/calendar.csv')
prices = pd.read_csv('/kaggle/input/m5-forecasting-accuracy/sell_prices.csv')
validation = pd.read_csv('/kaggle/input/m5-forecasting-accuracy/sales_train_evaluation.csv')
sample_sub = pd.read_csv('/kaggle/input/m5-forecasting-accuracy/sampl... | combined['Fare'] = combined.groupby("Pclass")['Fare'].transform(lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
11,609,919 | def perfect_sub() :
submission = OperateBaseModels(submission0,submission1, a=0, b=1)
diference = validation.merge(submission, how='right')
shift= 56
perfect_submission = diference[diference.columns[-shift:-shift+28]]
col = { 'd_'+str(1914+i):'F'+str(i+1)for i in range(28)}
perfect_submission = perfect_submission.ren... | combined['Zero_Fare'] = combined['Fare'].map(lambda x: 1 if x == 0 else(0)) | Titanic - Machine Learning from Disaster |
11,609,919 | class WRMSSEEvaluator(object):
def __init__(self, train_df: pd.DataFrame, valid_df: pd.DataFrame, calendar: pd.DataFrame, prices: pd.DataFrame):
train_y = train_df.loc[:, train_df.columns.str.startswith('d_')]
train_target_columns = train_y.columns.tolist()
weight_columns = train_y.iloc[:, -28:].columns.tolist()
train_... | def fare_category(fr):
if fr <= 7.91:
return 1
elif fr <= 14.454 and fr > 7.91:
return 2
elif fr <= 31 and fr > 14.454:
return 3
return 4 | Titanic - Machine Learning from Disaster |
11,609,919 | def function(solution):
solution = np.abs(solution)
submission = OperateBaseModels(submission0,submission1, a=solution[0], b=solution[1])
submission = OperateBaseModels(submission,submission2, a=1, b=solution[2])
submission = OperateBaseModels(submission,submission3, a=1, b=solution[3])
submission = OperateBaseMode... | combined['Fare_cat'] = combined['Fare'].apply(fare_category ) | Titanic - Machine Learning from Disaster |
11,609,919 | diference = validation.merge(submission,how='left')
error = np.mean(np.mean(np.abs(perfect_sub._get_numeric_data() -submission._get_numeric_data())) )<save_to_csv> | combined["Embarked"] = combined["Embarked"].fillna("C")
combined["Embarked"][combined["Embarked"] == "S"] = 1
combined["Embarked"][combined["Embarked"] == "C"] = 2
combined["Embarked"][combined["Embarked"] == "Q"] = 3
combined["Embarked"] = combined["Embarked"].astype(int ) | Titanic - Machine Learning from Disaster |
11,609,919 | submission.to_csv("submission.csv", index=False)
submission<define_variables> | combined['FamilySize'] = combined['SibSp'] + combined['Parch'] + 1 | Titanic - Machine Learning from Disaster |
11,609,919 | MODEL_VERSION = 'v10'
<define_variables> | combined['FamilySize_cat'] = combined['FamilySize'].map(lambda x: 1 if x == 1
else(2 if 5 > x >= 2
else(3 if 8 > x >= 5
else 4)
)) | Titanic - Machine Learning from Disaster |
11,609,919 | TEST_RUN = False
pd.set_option('display.max_columns', 50)
KAGGLE_DATA_FOLDER = '/kaggle/input/m5-forecasting-accuracy'
PATH_TO_CAT0="/kaggle/input/models-per-cat-with-sale/model_cat0_v10.lgb"
PATH_TO_CAT1="/kaggle/input/models-per-cat-with-sale/model_cat1_v10.lgb"
PATH_TO_CAT2="/kaggle/input/models-per-cat-with-sale/m... | combined['Alone'] = [1 if i == 1 else 0 for i in combined['FamilySize']] | Titanic - Machine Learning from Disaster |
11,609,919 | CALENDAR_DTYPES = {
'date': 'str',
'wm_yr_wk': 'int16',
'weekday': 'category',
'wday': 'int16',
'month': 'int16',
'year': 'int16',
'd': 'object',
'event_name_1': 'category',
'event_type_1': 'category',
'event_name_2': 'category',
'event_type_2': 'category',
'snap_CA': 'int16',
'snap_TX': 'int16',
'snap_WI': 'int16'
}
P... | combined['Cabin'] = combined['Cabin'].fillna('U' ) | Titanic - Machine Learning from Disaster |
11,609,919 | def load_data(train=True):
print("Loading train and validation data")
numcols = [f"d_{day}" for day in range(int(BEGIN_DAY),END_DAY+1)]
catcols = ['id', 'item_id', 'dept_id','store_id', 'cat_id', 'state_id']
dtype = {numcol:"float32" for numcol in numcols}
dtype.update({col: "category" for col in catcols if col != "... | combined['Cabin'] = combined['Cabin'].map(lambda x: re.compile("([a-zA-Z]+)" ).search(x ).group() ) | Titanic - Machine Learning from Disaster |
11,609,919 | def make_lag_features(strain):
print('in dataframe:', strain.shape)
print("headers:", strain.columns)
lags = [7, 28]
lag_cols = ['lag_{}'.format(lag)for lag in lags ]
for lag, lag_col in zip(lags, lag_cols):
strain[lag_col] = strain[['id', 'sales']].groupby('id')['sales'].shift(lag)
print('lag sales done')
window... | combined['Cabin'].value_counts() | Titanic - Machine Learning from Disaster |
11,609,919 | model_all = lgb.Booster(model_file = PATH_MODELS[0])
model_cat0 = lgb.Booster(model_file = PATH_MODELS[1])
model_cat1 = lgb.Booster(model_file = PATH_MODELS[2])
model_cat2 = lgb.Booster(model_file = PATH_MODELS[3])
model_per = [model_cat0, model_cat1, model_cat2]<data_type_conversions> | cabin_category = {'A':9, 'B':8, 'C':7, 'D':6, 'E':5, 'F':4, 'G':3, 'T':2, 'U':1} | Titanic - Machine Learning from Disaster |
11,609,919 | df = load_data(train=False)
df["sale"] =(( df['sell_price'] * 100 % 10)< 6 ).astype('int8')
make_lag_features(df)
make_date_features(df )<feature_engineering> | combined['Cabin'] = combined['Cabin'].map(cabin_category ) | Titanic - Machine Learning from Disaster |
11,609,919 | def lag_features_for_day(dt, day):
print(type(dt))
lags = [7, 28]
lag_cols = [f"lag_{lag}" for lag in lags]
for lag, lag_col in zip(lags, lag_cols):
dt.loc[dt['date'] == str(day), lag_col] = \
dt.loc[dt['date'] == str(day-timedelta(days=lag)) , 'sales'].values
windows = [7, 28]
for window in windows:
for lag, lag_col i... | dummy_col=['Title', 'Sex', 'Age_cat', 'SibSp', 'Parch', 'Fare_cat', 'Cabin', 'Embarked', 'Pclass', 'FamilySize_cat'] | Titanic - Machine Learning from Disaster |
11,609,919 | %%time
END_DATE = EVAL_SPLIT
ZERO_THRESHOLD = 0.01
PREDICT_DAYS = 28
for f_day in tqdm(range(1,PREDICT_DAYS+1)) :
pred_date =(datetime.strptime(END_DATE, '%Y-%m-%d')+ timedelta(days=f_day)).date()
print(f"Forecasting day {END_DAY+f_day}, date: {str(pred_date)}")
pred_begin_date = pred_date - timedelta(days=BACKWARD_LA... | dummy = pd.get_dummies(combined[dummy_col], columns=dummy_col, drop_first=False ) | Titanic - Machine Learning from Disaster |
11,609,919 | del prediction_data
gc.collect()<feature_engineering> | combined = pd.concat([dummy, combined], axis = 1 ) | Titanic - Machine Learning from Disaster |
11,609,919 | submission_val = df.loc[df['date'] > END_DATE, ['id', 'day', 'sales']].copy()
submission_val.loc[submission_val['sales'] < 0, 'sales'] = 0
submission_val.sort_values('id', inplace=True)
submission_val['day'] = submission_val['day'].apply(lambda x: 'F{}'.format(x - END_DAY))
print(submission_val.columns )<prepare_outpu... | combined['FareCat_Sex'] = combined['Fare_cat']*combined['Sex']
combined['Pcl_Sex'] = combined['Pclass']*combined['Sex']
combined['Pcl_Title'] = combined['Pclass']*combined['Title']
combined['Age_cat_Sex'] = combined['Age_cat']*combined['Sex']
combined['Age_cat_Pclass'] = combined['Age_cat']*combined['Pclass']
combined[... | Titanic - Machine Learning from Disaster |
11,609,919 | submission_eval = submission_val.copy()
submission_eval['id'] = submission_eval['id'].str.replace('validation', 'evaluation')
submission = pd.concat([submission_val, submission_eval], axis=0, sort=False)
print(submission.columns)
print(submission.head(1))<save_to_csv> | X_train = combined[:train.shape[0]]
X_test = combined[train.shape[0]:]
y = targets
X_train['Y'] = y
df = X_train
X = df.drop('Y', axis=1)
y = df.Y | Titanic - Machine Learning from Disaster |
11,609,919 | submission.to_csv('submission.csv', index=False)
print('Submission shape', submission.shape )<import_modules> | from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
11,609,919 | import os
import gc
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta, date
from tqdm.notebook import tqdm
import lightgbm as lgb<define_variables> | x_train, x_valid, y_train, y_valid = train_test_split(X, y, test_size=0.2, random_state=10 ) | Titanic - Machine Learning from Disaster |
11,609,919 | TEST_RUN = False
MODEL_VERSION = 'final'
pd.set_option('display.max_columns', 50)
KAGGLE_DATA_FOLDER = '/kaggle/input/m5-forecasting-accuracy'
SUBMISSION_PATH = "/kaggle/input/lgbmindividualbestsubmission/submission.csv"
MODEL_PATH = "/kaggle/input/lgbmindividualbestsubmission/model_v13_param_tuning.lgb"
BACKWARD_LAG ... | d_train = xgb.DMatrix(x_train, label=y_train)
d_valid = xgb.DMatrix(x_valid, label=y_valid)
d_test = xgb.DMatrix(X_test ) | Titanic - Machine Learning from Disaster |
11,609,919 | CALENDAR_DTYPES = {
'date': 'str',
'wm_yr_wk': 'int16',
'weekday': 'category',
'wday': 'int16',
'month': 'int16',
'year': 'int16',
'd': 'object',
'event_name_1': 'category',
'event_type_1': 'category',
'event_name_2': 'category',
'event_type_2': 'category',
'snap_CA': 'int16',
'snap_TX': 'int16',
'snap_WI': 'int16'
}
P... | params = {
'objective':'binary:logistic',
'eta': 0.3,
'max_depth':9,
'learning_rate':0.03,
'eval_metric':'auc',
'min_child_weight':1,
'subsample':1,
'colsample_bytree':0.4,
'seed':29,
'reg_lambda':2.8,
'reg_alpha':0,
'gamma':0,
'scale_pos_weight':1,
'n_estimators': 600,
'nthread':-1
} | Titanic - Machine Learning from Disaster |
11,609,919 | def load_data(train=True):
print("Loading train and validation data")
numcols = [f"d_{day}" for day in range(int(BEGIN_DAY),END_DAY+1)]
catcols = ['id', 'item_id', 'dept_id','store_id', 'cat_id', 'state_id']
dtype = {numcol:"float32" for numcol in numcols}
dtype.update({col: "category" for col in catcols if col != "... | watchlist = [(d_train, 'train'),(d_valid, 'valid')]
nrounds=10000 | Titanic - Machine Learning from Disaster |
11,609,919 | def make_lag_features(strain):
print('in dataframe:', strain.shape)
print("headers:", strain.columns)
lags = [7, 28]
lag_cols = ['lag_{}'.format(lag)for lag in lags ]
for lag, lag_col in zip(lags, lag_cols):
strain[lag_col] = strain[['item_id', 'sales']].groupby('item_id')['sales'].shift(lag)
print('lag sales done... | model = xgb.train(params, d_train, nrounds, watchlist, early_stopping_rounds=600,
maximize=True, verbose_eval=10 ) | Titanic - Machine Learning from Disaster |
11,609,919 | %%time
sales_train_evaluation = load_data()<feature_engineering> | leaks = {
897:1,
899:1,
930:1,
932:1,
949:1,
987:1,
995:1,
998:1,
999:1,
1016:1,
1047:1,
1083:1,
1097:1,
1099:1,
1103:1,
1115:1,
1118:1,
1135:1,
1143:1,
1152:1,
1153:1,
1171:1,
1182:1,
1192:1,
1203:1,
1233:1,
1250:1,
1264:1,
1286:1,
935:0,
957:0,
972:0,
988:0,
1004:0,
1006:0,
1011:0,
1105:0,
1130:0,
1138:0,
1173:0,
128... | Titanic - Machine Learning from Disaster |
11,609,919 | %%time
sales_train_evaluation["sale"] =(( sales_train_evaluation['sell_price'] * 100 % 10)< 6 ).astype('int8')
make_lag_features(sales_train_evaluation)
make_date_features(sales_train_evaluation )<categorify> | sub = pd.DataFrame()
sub['PassengerId'] = test['PassengerId']
sub['Survived'] = model.predict(d_test)
sub['Survived'] = sub['Survived'].apply(lambda x: 1 if x>0.8 else 0)
sub['Survived'] = sub.apply(lambda r: leaks[int(r['PassengerId'])] if int(r['PassengerId'])in leaks else r['Survived'], axis=1)
sub.to_csv('sub_ti... | Titanic - Machine Learning from Disaster |
9,054,318 | before = len(sales_train_evaluation)
sales_train_evaluation.dropna(inplace = True)
after = len(sales_train_evaluation)
print(f"Reduced {(before-after)/before}%" )<train_model> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
9,054,318 | %%time
print("Splitting data into train, validation, evaluation set")
np.random.seed(777)
SIZE = 2_000_000
validation_idx = np.random.choice(sales_train_evaluation.index.values, SIZE, replace = False)
train_idx = np.setdiff1d(sales_train_evaluation.index.values, validation_idx)
train = sales_train_evaluation.loc[tr... | train_data = train_data.drop(columns=['Name','Cabin'])
train_data['family_member'] = train_data['SibSp'] + train_data['Parch']
train_data = train_data.drop(columns=['SibSp', 'Parch'] ) | Titanic - Machine Learning from Disaster |
9,054,318 | categorical_features = [
'item_id', 'dept_id', 'store_id', 'cat_id', 'state_id',
'event_name_1', 'event_type_1', 'event_name_2', 'event_type_2'
]<create_dataframe> | test_data = test_data.drop(columns=['Name','Cabin'])
test_data['family_member'] = test_data['SibSp'] + test_data['Parch']
test_data = test_data.drop(columns=['SibSp', 'Parch'] ) | Titanic - Machine Learning from Disaster |
9,054,318 | train_pool = lgb.Dataset(
data=train[train_columns],
label=train["sales"],
categorical_feature=categorical_features,
free_raw_data=False)
del train; gc.collect()<create_dataframe> | train_data.fillna(0,inplace=True)
test_data.fillna(0,inplace=True ) | Titanic - Machine Learning from Disaster |
9,054,318 | val_pool = lgb.Dataset(
data=validation[train_columns],
label=validation["sales"],
categorical_feature=categorical_features,
free_raw_data=False
)
del validation; gc.collect()<init_hyperparams> | X = train_data.drop(columns=['Survived'])
Y = train_data['Survived']
cate_features_index = np.where(X.dtypes != float)[0]
| Titanic - Machine Learning from Disaster |
9,054,318 | if TEST_RUN:
ITERATIONS=1
else:
ITERATIONS = 1200
params = {
"objective" : "poisson",
"metric" : "rmse",
"force_row_wise" : True,
"learning_rate" : 0.075,
"sub_row" : 0.75,
"bagging_freq" : 1,
"lambda_l2" : 0.1,
'verbosity': 1,
'num_iterations': ITERATIONS,
'num_leaves': 128,
"min_data_in_leaf": 100,
"early_stopping": ... | from catboost import CatBoostClassifier, cv, Pool | Titanic - Machine Learning from Disaster |
9,054,318 | %%time
model = lgb.train(
params,
train_pool,
valid_sets = val_pool,
verbose_eval=20 )<drop_column> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
9,054,318 | model.save_model("model_{}.lgb".format(MODEL_VERSION))
del train_pool, val_pool; gc.collect()<data_type_conversions> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
9,054,318 | df = load_data(train=False)
df["sale"] =(( df['sell_price'] * 100 % 10)< 6 ).astype('int8')
make_date_features(df )<feature_engineering> | xtrain,xtest,ytrain,ytest = train_test_split(X,Y,train_size=0.82,random_state=42 ) | Titanic - Machine Learning from Disaster |
9,054,318 | def lag_features_for_day(dt, day):
print(type(dt))
lags = [7, 28]
lag_cols = [f"lag_{lag}" for lag in lags]
for lag, lag_col in zip(lags, lag_cols):
dt.loc[dt['date'] == str(day), lag_col] = \
dt.loc[dt['date'] == str(day-timedelta(days=lag)) , 'sales'].values
windows = [7, 28]
for window in windows:
for lag, lag_col i... | clf =CatBoostClassifier(eval_metric='Accuracy',use_best_model=True,random_seed=42 ) | Titanic - Machine Learning from Disaster |
9,054,318 | %%time
END_DATE = EVAL_SPLIT
PREDICT_DAYS = 28
for f_day in tqdm(range(1,PREDICT_DAYS+1)) :
pred_date =(datetime.strptime(END_DATE, '%Y-%m-%d')+ timedelta(days=f_day)).date()
print(f"Forecasting day {END_DAY+f_day}, date: {str(pred_date)}")
pred_begin_date = pred_date - timedelta(days=BACKWARD_LAG+1)
prediction_data ... | clf.fit(xtrain,ytrain,cat_features=cate_features_index,eval_set=(xtest,ytest), early_stopping_rounds=50 ) | Titanic - Machine Learning from Disaster |
9,054,318 | del prediction_data
gc.collect()<load_from_csv> | test_id = test_data.PassengerId | Titanic - Machine Learning from Disaster |
9,054,318 | sales_ = pd.read_csv(os.path.join(KAGGLE_DATA_FOLDER, 'sales_train_evaluation.csv'))
submission = pd.read_csv(os.path.join(SUBMISSION_PATH))<feature_engineering> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
9,054,318 | submission_eval = df.loc[df['date'] > END_DATE, ['id', 'day', 'sales']].copy()
submission_eval.loc[submission_eval['sales'] < 0, 'sales'] = 0
submission_eval.sort_values('id', inplace=True)
submission_eval['day'] = submission_eval['day'].apply(lambda x: 'F{}'.format(x - END_DAY))
print(submission_eval.columns)
print(... | prediction = clf.predict(test_data ) | Titanic - Machine Learning from Disaster |
9,054,318 | <save_to_csv><EOS> | df_sub = pd.DataFrame()
df_sub['PassengerId'] = test_id
df_sub['Survived'] = prediction.astype(np.int)
df_sub.to_csv('gender_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
7,770,899 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<import_modules> | print("pandas version: {}".format(pd.__version__))
print("NumPy version: {}".format(np.__version__))
print("matplotlib version: {}".format(matplotlib.__version__))
print("seaborn version: {}".format(sns.__version__))
print("scikit-learn version: {}".format(sklearn.__version__))
print("statsmodels version: {}".format(st... | Titanic - Machine Learning from Disaster |
7,770,899 | import numpy as np
import pandas as pd
import random
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import Linear, LayerNorm, ReLU, Dropout
from sklearn.model_selection import StratifiedKFold
from tqdm import tqdm
import os
import copy
from sklearn.cluster import KMeans
from sklearn.mo... | from sklearn.preprocessing import OneHotEncoder, LabelEncoder
from sklearn import feature_selection
from sklearn import model_selection
from sklearn import metrics
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.pylab as pylab
import seaborn as sns | Titanic - Machine Learning from Disaster |
7,770,899 | def Get_nowtime(fmat='%Y-%m-%d %H:%M:%S'):
return datetime.datetime.strftime(datetime.datetime.now() ,fmat)
def Metric(target,pred):
metric = 0
for i in range(target.shape[-1]):
metric +=(np.sqrt(np.mean(( target[:,:,i]-pred[:,:,i])**2)) /target.shape[-1])
return metric
def Write_log(logFile,text,isPrint=True):
if is... | data = pd.read_csv('.. /input/titanic/train.csv')
data_val = pd.read_csv('.. /input/titanic/test.csv')
data1 = data.copy(deep = True)
data_cleaner = [data1, data_val] | Titanic - Machine Learning from Disaster |
7,770,899 | token2int = {x:i for i, x in enumerate('().ACGUBEHIMSX')}
pred_cols = ['reactivity', 'deg_Mg_pH10', 'deg_pH10', 'deg_Mg_50C', 'deg_50C']
def mcrmse(y_actual, y_pred, weight=None, num_scored=5):
score = 0
for i in range(5):
if weight is not None:
score += torch.sqrt(torch.mean(( y_actual[:,:,i]-y_pred[:,:,i])**2*weight)... | print(data1.isnull().sum())
print("-"*10)
print(data_val.isnull().sum() ) | Titanic - Machine Learning from Disaster |
7,770,899 | train = pd.read_json('.. /input/stanford-covid-vaccine/train.json', lines=True)
test = pd.read_json('.. /input/stanford-covid-vaccine/test.json', lines=True)
def read_bpps_sum(df):
bpps_arr = []
for mol_id in df.id.to_list() :
bpps_arr.append(np.load(f".. /input/stanford-covid-vaccine/bpps/{mol_id}.npy" ).max(axis=1)... | for dataset in data_cleaner:
dataset['Age'].fillna(dataset['Age'].median() , inplace = True)
dataset['Embarked'].fillna(dataset['Embarked'].mode() [0], inplace = True)
dataset['Fare'].fillna(dataset['Fare'].median() , inplace = True)
dataset.drop('Cabin', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
7,770,899 | kmeans_model = KMeans(n_clusters=200, random_state=110 ).fit(preprocess_inputs(train)[:,:,0])
train['cluster_id'] = kmeans_model.labels_
<save_to_csv> | print(data1.isnull().sum())
print("-"*10)
print(data_val.isnull().sum() ) | Titanic - Machine Learning from Disaster |
7,770,899 | oof,sub = train_and_predict()
oof.to_csv('./oof.csv',index=False)
sub.to_csv('./submission.csv',index=False )<set_options> | varlist = ['Sex']
def binary_map(x):
return x.map({'male': 1, "female": 0})
for dataset in data_cleaner:
dataset[varlist] = dataset[varlist].apply(binary_map ) | Titanic - Machine Learning from Disaster |
7,770,899 | os.environ['CUDA_VISIBLE_DEVICES'] = '0'
def allocate_gpu_memory(gpu_number=0):
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if physical_devices:
try:
print("Found {} GPU(s)".format(len(physical_devices)))
tf.config.set_visible_devices(physical_devices[gpu_number], 'GPU')
tf.config.experime... | dummy1 = pd.get_dummies(data1['Embarked'], prefix='Embarked', drop_first=True)
data1 = pd.concat([data1, dummy1], axis=1 ) | Titanic - Machine Learning from Disaster |
7,770,899 | def gru_layer(hidden_dim, dropout):
return L.Bidirectional(L.GRU(hidden_dim, dropout=dropout, return_sequences=True, kernel_initializer = 'orthogonal'))
def lstm_layer(hidden_dim, dropout):
return L.Bidirectional(L.LSTM(hidden_dim, dropout=dropout, return_sequences=True, kernel_initializer = 'orthogonal'))
def build_mo... | dummy1 = pd.get_dummies(data_val['Embarked'], prefix='Embarked', drop_first=True)
data_val = pd.concat([data_val, dummy1], axis=1 ) | Titanic - Machine Learning from Disaster |
7,770,899 | token2int = {x:i for i, x in enumerate('().ACGUBEHIMSX')}
pred_cols = ['reactivity', 'deg_Mg_pH10', 'deg_pH10', 'deg_Mg_50C', 'deg_50C']
def preprocess_inputs(df, cols=['sequence', 'structure', 'predicted_loop_type']):
base_fea = np.transpose(
np.array(
df[cols]
.applymap(lambda seq: [token2int[x] for x in seq])
.va... | dummy1 = pd.get_dummies(data1['Pclass'], prefix='Pclass', drop_first=True)
data1 = pd.concat([data1, dummy1], axis=1 ) | Titanic - Machine Learning from Disaster |
7,770,899 | train = pd.read_json('.. /input/stanford-covid-vaccine/train.json', lines=True)
test = pd.read_json('.. /input/stanford-covid-vaccine/test.json', lines=True )<load_pretrained> | dummy1 = pd.get_dummies(data_val['Pclass'], prefix='Pclass', drop_first=True)
data_val = pd.concat([data_val, dummy1], axis=1 ) | Titanic - Machine Learning from Disaster |
7,770,899 | def read_bpps_sum(df):
bpps_arr = []
for mol_id in df.id.to_list() :
bpps_arr.append(np.load(f".. /input/stanford-covid-vaccine/bpps/{mol_id}.npy" ).max(axis=1))
return bpps_arr
def read_bpps_max(df):
bpps_arr = []
for mol_id in df.id.to_list() :
bpps_arr.append(np.load(f".. /input/stanford-covid-vaccine/bpps/{mol_id}.... | dummy1 = pd.get_dummies(data1['Sex'], prefix='Male', drop_first=True)
data1 = pd.concat([data1, dummy1], axis=1 ) | Titanic - Machine Learning from Disaster |
7,770,899 | kmeans_model = KMeans(n_clusters=200, random_state=110 ).fit(preprocess_inputs(train)[:,:,0])
train['cluster_id'] = kmeans_model.labels_<load_from_csv> | dummy1 = pd.get_dummies(data_val['Sex'], prefix='Male', drop_first=True)
data_val = pd.concat([data_val, dummy1], axis=1 ) | Titanic - Machine Learning from Disaster |
7,770,899 | aug_df = pd.read_csv(aug_data)
display(aug_df.head() )<merge> | data1['FamilySize'] = data1['SibSp'] + data1['Parch'] + 1
data1.head(2 ) | Titanic - Machine Learning from Disaster |
7,770,899 | def aug_data(df):
target_df = df.copy()
new_df = aug_df[aug_df['id'].isin(target_df['id'])]
del target_df['structure']
del target_df['predicted_loop_type']
new_df = new_df.merge(target_df, on=['id','sequence'], how='left')
df['cnt'] = df['id'].map(new_df[['id','cnt']].set_index('id' ).to_dict() ['cnt'])
df['log_gamma... | data_val['FamilySize'] = data_val['SibSp'] + data_val['Parch'] + 1
data_val.head(2 ) | Titanic - Machine Learning from Disaster |
7,770,899 | if debug:
train = train[:200]
test = test[:200]<split> | data1= data1.rename(columns={ 'Male_1' : 'Male'})
data_val= data_val.rename(columns={ 'Male_1' : 'Male'} ) | Titanic - Machine Learning from Disaster |
7,770,899 | def train_and_predict(type = 0, FOLD_N = 5):
gkf = GroupKFold(n_splits=FOLD_N)
public_df = test.query("seq_length == 107" ).copy()
private_df = test.query("seq_length == 130" ).copy()
public_inputs = preprocess_inputs(public_df)
private_inputs = preprocess_inputs(private_df)
holdouts = []
holdout_preds = []
for cv,(... | drop_column = ['PassengerId', 'Pclass', 'Name', 'Sex', 'Ticket', 'Fare', 'Embarked']
data1.drop(drop_column, axis=1, inplace = True ) | Titanic - Machine Learning from Disaster |
7,770,899 | val_df, val_preds, test_df, test_preds = [], [], [], []
if debug:
nmodel = 1
else:
nmodel = 4
for i in range(nmodel):
holdouts, holdout_preds, public_df, public_preds, private_df, private_preds = train_and_predict(i)
val_df += holdouts
val_preds += holdout_preds
test_df.append(public_df)
test_df.append(private_df)
t... | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
7,770,899 | preds_ls = []
for df, preds in zip(test_df, test_preds):
for i, uid in enumerate(df.id):
single_pred = preds[i]
single_df = pd.DataFrame(single_pred, columns=pred_cols)
single_df['id_seqpos'] = [f'{uid}_{x}' for x in range(single_df.shape[0])]
preds_ls.append(single_df)
preds_df = pd.concat(preds_ls ).groupby('id_seq... | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
7,770,899 | submission = preds_df[['id_seqpos', 'reactivity', 'deg_Mg_pH10', 'deg_pH10', 'deg_Mg_50C', 'deg_50C']]
submission.to_csv(f'submission.csv', index=False)
print(f'wrote to submission.csv' )<load_from_disk> | X = data1.drop(['Survived'], axis=1)
X.head() | Titanic - Machine Learning from Disaster |
7,770,899 | def print_mse(prd):
val = pd.read_json('.. /input/stanford-covid-vaccine/train.json', lines=True)
val_data = []
for mol_id in val['id'].unique() :
sample_data = val.loc[val['id'] == mol_id]
sample_seq_length = sample_data.seq_length.values[0]
for i in range(68):
sample_dict = {
'id_seqpos' : sample_data['id'].values[0... | y = data1['Survived']
y.head() | Titanic - Machine Learning from Disaster |
7,770,899 | print_mse(holdouts_df )<compute_test_metric> | X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, test_size=0.3, random_state=100 ) | Titanic - Machine Learning from Disaster |
7,770,899 | print_mse(holdouts_df[holdouts_df.SN_filter == 1] )<import_modules> | survived =(sum(data1['Survived'])/len(data1['Survived'].index)) *100
survived | Titanic - Machine Learning from Disaster |
7,770,899 | import pandas as pd
import numpy as np<import_modules> | logreg = LogisticRegression() | Titanic - Machine Learning from Disaster |
7,770,899 | import pandas as pd
import numpy as np<load_from_csv> | rfe = RFE(logreg, 15)
rfe = rfe.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
7,770,899 | df1 = pd.read_csv('/kaggle/input/gru-lstm-mix-with-custom-loss-tunning/ensemble_final.csv')
df2 = pd.read_csv('/kaggle/input/mvan-covid-mrna-vaccine-analysis-notebook-268/submission.csv')
df3 = pd.read_csv('/kaggle/input/gru-lstm-mix-with-custom-loss/ensemble_final.csv' )<prepare_output> | rfe.support_ | 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.