kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,536,929 | yPred = pd.DataFrame(yPred,index=index,columns=sorted(parent_data.species.unique()))
yPred.to_csv('predictions.csv' )<drop_column> | checkpoint_path = 'bestmodel4.hdf5'
checkpoint = ModelCheckpoint(checkpoint_path, monitor='val_acc', verbose=0, save_best_only=True, mode='max')
callbacks_list = [checkpoint]
history = model.fit(X_train, Y_train, batch_size=30, epochs=3000,
callbacks=callbacks_list, verbose=0, validation_split=0.2 ) | Titanic - Machine Learning from Disaster |
10,536,929 | yPredTest = yPredTest.set_value(1190, 'Acer_Rubrum', 1 )<save_to_csv> | model.load_weights(checkpoint_path)
pred = model.predict(X_test)
Y_pred =(pred > 0.5 ).astype(int ) | Titanic - Machine Learning from Disaster |
10,536,929 | yPredTest.to_csv('predictions.csv' )<define_variables> | Y_pred = Y_pred[:, 0]
Y_pred | Titanic - Machine Learning from Disaster |
10,536,929 | ( -np.log10(10**-15)/594 )<compute_test_metric> | submission = pd.DataFrame({"Survived": Y_pred}, index=test.index)
submission.to_csv("submission.csv" ) | Titanic - Machine Learning from Disaster |
10,536,929 | 0.407/(-np.log10(10**-15)/594)
<load_from_csv> | pd.concat([submission, pd.read_csv('.. /input/titanic/gender_submission.csv', index_col=0)], axis=1 ) | Titanic - Machine Learning from Disaster |
10,536,929 | df_train=pd.read_csv(".. /input/leaf-classification/train.csv.zip",index_col='id')
df_train.shape<count_missing_values> | print(confusion_matrix(pd.read_csv('.. /input/titanic/gender_submission.csv', index_col=0 ).values, Y_pred))
accuracy_score(pd.read_csv('.. /input/titanic/gender_submission.csv', index_col=0 ).values, Y_pred ) | Titanic - Machine Learning from Disaster |
10,536,929 | df_train.isna().sum()<prepare_x_and_y> | precision_recall_fscore_support(pd.read_csv('.. /input/titanic/gender_submission.csv', index_col=0 ).values,
Y_pred, average='binary' ) | Titanic - Machine Learning from Disaster |
10,536,929 | y_train=df_train.species
X_train=df_train.drop(columns=['species'],axis=1 )<count_unique_values> | param_grid = [
{'penalty' : ['l1', 'l2', 'elasticnet', 'none'],
'C' : np.logspace(-4, 4, 500),
'solver' : ['lbfgs','newton-cg','liblinear','sag','saga'],
'max_iter' : np.arange(100, 150, 10)
}
]
scoring = {'Accuracy': 'accuracy'}
gs = GridSearchCV(LogisticRegression() , return_train_score=True,
param_grid=param_grid, ... | Titanic - Machine Learning from Disaster |
10,536,929 | object_cols = [cname for cname in X_train.columns if X_train[cname].nunique() < 10 and X_train[cname].dtype == "object"]
object_cols<count_values> | gs.fit(X_train, Y_train)
print("best params: " + str(gs.best_estimator_))
print("best params: " + str(gs.best_params_))
print('best score:', gs.best_score_ ) | Titanic - Machine Learning from Disaster |
10,536,929 | len(y_train.value_counts() )<categorify> | Y_pred2 = gs.predict(X_test ) | Titanic - Machine Learning from Disaster |
10,536,929 | encoder = LabelEncoder()
y_fit = encoder.fit(y_train)
y_train = y_fit.transform(y_train)
classes = list(y_fit.classes_ )<normalization> | submission2 = pd.DataFrame({"Survived": Y_pred2}, index=test.index)
submission2.to_csv("submission2.csv" ) | Titanic - Machine Learning from Disaster |
10,536,929 | quantile_transformer = QuantileTransformer(random_state=0)
scaler = quantile_transformer.fit(X_train)
X_train= quantile_transformer.transform(X_train )<define_search_space> | pd.concat([submission2, pd.read_csv('.. /input/titanic/gender_submission.csv', index_col=0)], axis=1 ) | Titanic - Machine Learning from Disaster |
10,536,929 | parameters = {
'tol':[0.001, 0.009],
'C':list(range(100, 1000,100)) ,
'max_iter': list(range(10, 100, 10)) ,
"solver":("newton-cg", "lbfgs", "liblinear"),
"penalty":("l1", "l2")
}
parameters<define_variables> | print(confusion_matrix(pd.read_csv('.. /input/titanic/gender_submission.csv', index_col=0 ).values, Y_pred2))
accuracy_score(pd.read_csv('.. /input/titanic/gender_submission.csv', index_col=0 ).values, Y_pred2 ) | Titanic - Machine Learning from Disaster |
10,536,929 | my_randome_state=500<choose_model_class> | precision_recall_fscore_support(pd.read_csv('.. /input/titanic/gender_submission.csv', index_col=0 ).values,
Y_pred2, average='binary' ) | Titanic - Machine Learning from Disaster |
10,393,050 | log_reg =LogisticRegression(multi_class='multinomial',
random_state=my_randome_state)
gsearch = GridSearchCV(estimator=log_reg,
param_grid = parameters,
scoring="neg_log_loss",
n_jobs=4,cv=5, verbose=7 )<train_model> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
10,393,050 | gsearch.fit(X_train, y_train )<find_best_params> | train_df=pd.read_csv('/kaggle/input/titanic/train.csv')
test_df=pd.read_csv('/kaggle/input/titanic/test.csv')
train_df.head() | Titanic - Machine Learning from Disaster |
10,393,050 | best_max_iter = gsearch.best_params_.get('max_iter')
best_tol = gsearch.best_params_.get('tol')
best_C = gsearch.best_params_.get('C')
best_solver = gsearch.best_params_.get('solver')
best_penalty = gsearch.best_params_.get('penalty')
best_max_iter,best_tol,best_C,best_penalty,best_solver<choose_model_class> | print(train_df.isnull().sum())
print('\t\t\t')
print(test_df.isnull().sum() ) | Titanic - Machine Learning from Disaster |
10,393,050 | final_model = LogisticRegression(max_iter=best_max_iter,
random_state=my_randome_state,
tol=best_tol,
C=best_C,
solver=best_solver,
penalty=best_penalty )<train_model> | train_df.isnull().sum() | Titanic - Machine Learning from Disaster |
10,393,050 | final_model.fit(X_train, y_train )<load_from_csv> | train_gp=train_df.groupby(['Sex','Pclass'])['Age'].mean()
print(train_gp)
test_gp=test_df.groupby(['Sex','Pclass'])['Age'].mean()
print(test_gp)
| Titanic - Machine Learning from Disaster |
10,393,050 | X_test=pd.read_csv(".. /input/leaf-classification/test.csv.zip" )<drop_column> | def fillAgeNa(df):
for i in range(len(df)) :
if pd.isnull(df.loc[i, "Age"]):
if(df.loc[i,'Sex']=='female')and(df.loc[i,'Pclass']==1):
df.loc[i,'Age']=37
elif(df.loc[i,'Sex']=='female')and(df.loc[i,'Pclass']==2):
df.loc[i,'Age']=26
elif(df.loc[i,'Sex']=='female')and(df.loc[i,'Pclass']==3):
df.loc[i,'Age']=22
elif(df.loc... | Titanic - Machine Learning from Disaster |
10,393,050 | test_ids = X_test.id
X_test = X_test.drop(['id'], axis =1 )<normalization> | ndf=train_df.copy()
train_df=fillAgeNa(ndf)
train_df.isnull().sum()
ndf=test_df.copy()
test_df=fillAgeNa(ndf)
train_df['Embarked'].fillna('S',inplace=True ) | Titanic - Machine Learning from Disaster |
10,393,050 | X_test = scaler.transform(X_test )<predict_on_test> | train_df.isnull().sum() | Titanic - Machine Learning from Disaster |
10,393,050 | final_predictions = final_model.predict_proba(X_test )<prepare_output> | test_df['Fare'].fillna(test_df['Fare'].mean() ,inplace=True)
test_df.isnull().sum()
test_df.shape | Titanic - Machine Learning from Disaster |
10,393,050 | submission = pd.DataFrame(final_predictions, columns=classes)
submission.insert(0, 'id', test_ids)
submission<save_to_csv> | train_data=train_df.drop('Cabin',axis=1)
test_data=test_df.drop('Cabin',axis=1)
test_data.shape | Titanic - Machine Learning from Disaster |
10,393,050 | submission.to_csv('submission_log_reg.csv', index = False)
print("done" )<define_variables> | train_data.drop(['PassengerId','Name','Ticket'],inplace=True,axis=1)
test_data.drop(['PassengerId','Name','Ticket'],inplace=True,axis=1 ) | Titanic - Machine Learning from Disaster |
10,393,050 | CAL_DTYPES={"event_name_1": "category", "event_name_2": "category", "event_type_1": "category",
"event_type_2": "category", "weekday": "category", 'wm_yr_wk': 'int16', "wday": "int16",
"month": "int16", "year": "int16", "snap_CA": "float32", 'snap_TX': 'float32', 'snap_WI': 'float32' }
PRICE_DTYPES = {"store_id": "cate... | encd1=pd.get_dummies(train_data[['Sex','Embarked']],drop_first=True)
encd2=pd.get_dummies(test_data[['Sex','Embarked']],drop_first=True ) | Titanic - Machine Learning from Disaster |
10,393,050 | sell_prices = pd.read_csv("/kaggle/input/m5-forecasting-accuracy/sell_prices.csv", dtype = PRICE_DTYPES)
calendar_df = pd.read_csv("/kaggle/input/m5-forecasting-accuracy/calendar.csv", dtype = CAL_DTYPES)
sales_train_validation = pd.read_csv("/kaggle/input/m5-forecasting-accuracy/sales_train_validation.csv")
subm = ... | train_data=pd.concat([train_data,encd1],axis=1)
test_data=pd.concat([test_data,encd2],axis=1)
| Titanic - Machine Learning from Disaster |
10,393,050 | from datetime import datetime, timedelta
import gc<define_search_space> | train_data['FamilySize']=train_data['SibSp']+train_data['Parch']+1
test_data['FamilySize']=test_data['SibSp']+test_data['Parch']+1
| Titanic - Machine Learning from Disaster |
10,393,050 | h = 28
max_lags = 57
tr_last = 1913
fday = datetime(2016,4, 25 )<load_from_csv> | train_data['Isalone']=train_data['FamilySize'].apply(lambda x : 1 if x>1 else 0)
test_data['Isalone']=test_data['FamilySize'].apply(lambda x : 1 if x>1 else 0 ) | Titanic - Machine Learning from Disaster |
10,393,050 | def create_dt(is_train = True, nrows = None, first_day = 1200):
prices = pd.read_csv("/kaggle/input/m5-forecasting-accuracy/sell_prices.csv", dtype = PRICE_DTYPES)
for col, col_dtype in PRICE_DTYPES.items() :
if col_dtype == "category":
prices[col] = prices[col].cat.codes.astype("int16")
prices[col] -= prices[col].mi... | from sklearn.preprocessing import LabelEncoder | Titanic - Machine Learning from Disaster |
10,393,050 | def create_fea(dt):
lags = [7, 28]
lag_cols = [f"lag_{lag}" for lag in lags ]
for lag, lag_col in zip(lags, lag_cols):
dt[lag_col] = dt[["id","sales"]].groupby("id")["sales"].shift(lag)
wins = [7, 28]
for win in wins :
for lag,lag_col in zip(lags, lag_cols):
dt[f"rmean_{lag}_{win}"] = dt[["id", lag_col]].groupby("id")... | train_data.drop(['Sex','Embarked','FamilySize'],axis=1,inplace=True)
test_data.drop(['Sex','Embarked','FamilySize'],axis=1,inplace=True)
| Titanic - Machine Learning from Disaster |
10,393,050 | FIRST_DAY = 350<correct_missing_values> | scaler=MinMaxScaler()
scaler.fit(train_data[['Fare']])
train_data['Fare']=scaler.transform(train_data[['Fare']])
train_data['Age']=scaler.fit_transform(train_data[['Age']])
test_data['Fare']=scaler.fit_transform(test_data[['Fare']])
test_data['Age']=scaler.fit_transform(test_data[['Age']] ) | Titanic - Machine Learning from Disaster |
10,393,050 | df.dropna(inplace = True)
df.shape<prepare_x_and_y> | train_data['SibSp']=train_data['SibSp'].apply(lambda x: 1 if x>0 else 0)
test_data['SibSp']=test_data['SibSp'].apply(lambda x: 1 if x>0 else 0 ) | Titanic - Machine Learning from Disaster |
10,393,050 | cat_feats = ['item_id', 'dept_id','store_id', 'cat_id', 'state_id'] + ["event_name_1", "event_name_2", "event_type_1", "event_type_2"]
useless_cols = ["id", "date", "sales","d", "wm_yr_wk", "weekday"]
train_cols = df.columns[~df.columns.isin(useless_cols)]
X_train = df[train_cols]
y_train = df["sales"]<import_modules> | train_data['nw']=train_data['Age']*train_data['Pclass']
test_data['nw']=test_data['Age']*test_data['Pclass'] | Titanic - Machine Learning from Disaster |
10,393,050 | import lightgbm as lgb<create_dataframe> | X_train=train_data.drop('Survived',axis=1)
y_train=train_data[['Survived']]
print('shape of x train and y train')
print(X_train.shape,y_train.shape)
X_test=test_data
print('shape of x test')
print(X_test.shape)
| Titanic - Machine Learning from Disaster |
10,393,050 | %%time
np.random.seed(777)
fake_valid_inds = np.random.choice(X_train.index.values, 2_000_000, replace = False)
train_inds = np.setdiff1d(X_train.index.values, fake_valid_inds)
train_data = lgb.Dataset(X_train.loc[train_inds] , label = y_train.loc[train_inds],
categorical_feature=cat_feats, free_raw_data=False)
fak... | model1=RandomForestClassifier()
model2=XGBClassifier()
model3=LogisticRegression()
model4=SVC(kernel='poly',gamma=1,C=0.1)
model5=KNeighborsClassifier(n_neighbors=23,leaf_size=23,p=1)
model=[model1,model2,model3,model4,model5] | Titanic - Machine Learning from Disaster |
10,393,050 | del df, X_train, y_train, fake_valid_inds,train_inds ; gc.collect()<init_hyperparams> | c=0
for m in model:
c+=1
m.fit(X_train,y_train)
accur=round(m.score(X_train,y_train)*100,2)
print('Model',c)
print('accuracy =',accur ) | Titanic - Machine Learning from Disaster |
10,393,050 | 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' : 1200,
'num_leaves': 128,
"min_data_in_leaf": 100,
}<train_model> | model=RandomForestClassifier(n_estimators= 2000,
min_samples_split= 5,
min_samples_leaf= 2,
max_features= 'sqrt',
max_depth= None)
model.fit(X_train,y_train)
y_pred=model.predict(X_test)
y_pred=pd.Series(y_pred)
y_pred=y_pred.apply(lambda x: 1 if x else 0)
accur=round(model.score(X_train,y_train)*100,2)
accur
| Titanic - Machine Learning from Disaster |
10,393,050 | %%time
m_lgb = lgb.train(params, train_data, valid_sets = [fake_valid_data], verbose_eval=20 )<save_model> | dataframe=pd.read_csv('/kaggle/input/titanic/gender_submission.csv')
dataframe.head() | Titanic - Machine Learning from Disaster |
10,393,050 | m_lgb.save_model("save_model.lgb" )<set_options> | subm=pd.concat([test_df['PassengerId'],y_pred],axis=1)
subm.rename(columns={'PassengerId':'PassengerId',0:'Survived'},inplace=True ) | Titanic - Machine Learning from Disaster |
10,393,050 | %matplotlib inline
plt.style.use('seaborn-darkgrid' )<load_from_csv> | subm['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
10,393,050 | df_cal = pd.read_csv('.. /input/m5-forecasting-accuracy/calendar.csv')
df_eval = pd.read_csv('.. /input/m5-forecasting-accuracy/sales_train_evaluation.csv')
df_price = pd.read_csv('.. /input/m5-forecasting-accuracy/sell_prices.csv')
df_sample_output = pd.read_csv('.. /input/m5-forecasting-accuracy/sample_submission.... | subm.to_csv('submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
9,470,014 | holiday = ['NewYear', 'OrthodoxChristmas', 'MartinLutherKingDay', 'SuperBowl', 'PresidentsDay', 'StPatricksDay', 'Easter', 'Cinco De Mayo', 'IndependenceDay', 'EidAlAdha', 'Thanksgiving', 'Christmas']
weekend = ['Saturday', 'Sunday']
def is_holiday(x):
if x in holiday:
return 1
else:
return 0
def is_weekend(x):
if x in... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
9,470,014 | df_cal['is_holiday_1'] = df_cal['event_name_1'].apply(is_holiday)
df_cal['is_holiday_2'] = df_cal['event_name_2'].apply(is_holiday)
df_cal['is_holiday'] = df_cal[['is_holiday_1','is_holiday_2']].max(axis=1)
df_cal['is_weekend'] = df_cal['weekday'].apply(is_weekend )<drop_column> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
9,470,014 | df_cal = df_cal.drop(['weekday', 'wday', 'month', 'year', 'event_name_1', 'event_type_1', 'event_name_2', 'event_type_2'], axis='columns' )<drop_column> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
9,470,014 | del_col = []
for x in range(1851):
del_col.append('d_' + str(x+1))<drop_column> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval = df_eval.drop(del_col, axis='columns' )<merge> | %matplotlib inline
sns.set() | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval = pd.merge(df_eval, df_cal, how='left', on='d')
df_eval.head()<merge> | train_test_data = [train, test]
for dataset in train_test_data:
dataset['Title'] = dataset['Name'].str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval = pd.merge(df_eval, df_price, how='left', on=['item_id', 'wm_yr_wk', 'store_id'])
df_eval.head()<filter> | train['Title'].value_counts() | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval_test = df_eval.query('d == "d_1852"' )<drop_column> | test['Title'].value_counts() | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval_test = df_eval_test[['id', 'store_id', 'item_id', 'dept_id', 'cat_id', 'state_id', 'd', 'qty', 'sell_price']]<feature_engineering> | title_mapping = {"Mr": 0, "Miss": 1, "Mrs": 2,
"Master": 3, "Dr": 3, "Rev": 3, "Col": 3, "Major": 3, "Mlle": 3,"Countess": 3,
"Ms": 3, "Lady": 3, "Jonkheer": 3, "Don": 3, "Dona" : 3, "Mme": 3,"Capt": 3,"Sir": 3 }
for dataset in train_test_data:
dataset['Title'] = dataset['Title'].map(title_mapping ) | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval_test['qty'] = df_eval_test['d'].apply(lambda x: int(x.replace(x, '0')) )<define_variables> | train.drop('Name', axis=1, inplace=True)
test.drop('Name', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
9,470,014 | tmp_df = df_eval_test<concatenate> | sex_mapping = {"male": 0, "female": 1}
for dataset in train_test_data:
dataset['Sex'] = dataset['Sex'].map(sex_mapping ) | Titanic - Machine Learning from Disaster |
9,470,014 | for x in range(28):
df_eval_test = df_eval_test.append(tmp_df )<drop_column> | train["Age"].fillna(train.groupby("Title")["Age"].transform("median"), inplace=True)
test["Age"].fillna(test.groupby("Title")["Age"].transform("median"), inplace=True ) | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval_test = df_eval_test.reset_index(drop=True )<define_variables> | for dataset in train_test_data:
dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0,
dataset.loc[(dataset['Age'] > 16)&(dataset['Age'] <= 26), 'Age'] = 1,
dataset.loc[(dataset['Age'] > 26)&(dataset['Age'] <= 36), 'Age'] = 2,
dataset.loc[(dataset['Age'] > 36)&(dataset['Age'] <= 62), 'Age'] = 3,
dataset.loc[ dataset['Age'] > 6... | Titanic - Machine Learning from Disaster |
9,470,014 | lst_d = []
i = 0
lst_index = df_eval_test.index
for x in lst_index:
lst_d.append('d_' + str(((lst_index[i])// 30490)+ 1942))
i = i + 1
lst_d<feature_engineering> | Pclass1 = train[train['Pclass']==1]['Embarked'].value_counts()
Pclass2 = train[train['Pclass']==2]['Embarked'].value_counts()
Pclass3 = train[train['Pclass']==3]['Embarked'].value_counts()
df = pd.DataFrame([Pclass1, Pclass2, Pclass3])
df.index = ['1st class','2nd class', '3rd class']
df.plot(kind='bar',stacked=True, ... | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval_test['d'] = lst_d<merge> | for dataset in train_test_data:
dataset['Embarked'] = dataset['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval_test = pd.merge(df_eval_test, df_cal, how='left', on='d' )<merge> | embarked_mapping = {"S": 0, "C": 1, "Q": 2}
for dataset in train_test_data:
dataset['Embarked'] = dataset['Embarked'].map(embarked_mapping ) | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval_test = pd.merge(df_eval_test, df_price, how='left', on=['item_id', 'wm_yr_wk', 'store_id'] )<set_options> | train["Fare"].fillna(train.groupby("Pclass")["Fare"].transform("median"), inplace=True)
test["Fare"].fillna(test.groupby("Pclass")["Fare"].transform("median"), inplace=True)
train.head(50 ) | Titanic - Machine Learning from Disaster |
9,470,014 | del tmp_df
gc.collect()<categorify> | for dataset in train_test_data:
dataset.loc[ dataset['Fare'] <= 17, 'Fare'] = 0,
dataset.loc[(dataset['Fare'] > 17)&(dataset['Fare'] <= 30), 'Fare'] = 1,
dataset.loc[(dataset['Fare'] > 30)&(dataset['Fare'] <= 100), 'Fare'] = 2,
dataset.loc[ dataset['Fare'] > 100, 'Fare'] = 3 | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval = pd.get_dummies(data=df_eval, columns=['dept_id', 'cat_id', 'store_id', 'state_id'])
df_eval_test = pd.get_dummies(data=df_eval_test, columns=['dept_id', 'cat_id', 'store_id', 'state_id'] )<drop_column> | train.Cabin.value_counts() | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval_test = df_eval_test.drop(['sell_price_x', 'snap_CA', 'snap_TX', 'snap_WI'], axis='columns')
df_eval_test = df_eval_test.rename(columns={'sell_price_y': 'sell_price'})
df_eval = df_eval.drop(['snap_CA', 'snap_TX', 'snap_WI'], axis='columns' )<split> | for dataset in train_test_data:
dataset['Cabin'] = dataset['Cabin'].str[:1] | Titanic - Machine Learning from Disaster |
9,470,014 | target_col = 'qty'
exclude_cols = ['id', 'item_id', 'd', 'date', 'wm_yr_wk']
feature_cols = [col for col in df_eval.columns if col not in exclude_cols]
y = np.array(df_eval[target_col])
X = np.array(df_eval[feature_cols])
X_train, X_test, y_train, y_test = \
train_test_split(X, y, test_size=0.3, random_state=1234)
<t... | cabin_mapping = {"A": 0, "B": 0.4, "C": 0.8, "D": 1.2, "E": 1.6, "F": 2, "G": 2.4, "T": 2.8}
for dataset in train_test_data:
dataset['Cabin'] = dataset['Cabin'].map(cabin_mapping ) | Titanic - Machine Learning from Disaster |
9,470,014 | lgb_train = lgb.Dataset(X_train, y_train)
lgb_eval = lgb.Dataset(X_test, y_test)
params = {
'boosting_type': 'gbdt',
'metric': 'rmse',
'objective': 'regression',
'n_jobs': -1,
'seed': 236,
'learning_rate': 0.01,
'bagging_fraction': 0.75,
'bagging_freq': 10,
'colsample_bytree': 0.75}
model = lgb.train(params, lgb_trai... | train["Cabin"].fillna(train.groupby("Pclass")["Cabin"].transform("median"), inplace=True)
test["Cabin"].fillna(test.groupby("Pclass")["Cabin"].transform("median"), inplace=True ) | Titanic - Machine Learning from Disaster |
9,470,014 | pred = model.predict(df_eval_test[feature_cols] )<prepare_output> | train["FamilySize"] = train["SibSp"] + train["Parch"] + 1
test["FamilySize"] = test["SibSp"] + test["Parch"] + 1 | Titanic - Machine Learning from Disaster |
9,470,014 | df_eval_test['pred_qty'] = pred<prepare_output> | family_mapping = {1: 0, 2: 0.4, 3: 0.8, 4: 1.2, 5: 1.6, 6: 2, 7: 2.4, 8: 2.8, 9: 3.2, 10: 3.6, 11: 4}
for dataset in train_test_data:
dataset['FamilySize'] = dataset['FamilySize'].map(family_mapping ) | Titanic - Machine Learning from Disaster |
9,470,014 | predictions = df_eval_test[['id', 'date', 'pred_qty']]
predictions = pd.pivot(predictions, index = 'id', columns = 'date', values = 'pred_qty' ).reset_index()
predictions<drop_column> | features_drop = ['Ticket', 'SibSp', 'Parch']
train = train.drop(features_drop, axis=1)
test = test.drop(features_drop, axis=1)
train = train.drop(['PassengerId'], axis=1 ) | Titanic - Machine Learning from Disaster |
9,470,014 | predictions = predictions.drop(predictions.columns[1], axis=1)
predictions<rename_columns> | from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
import numpy as np | Titanic - Machine Learning from Disaster |
9,470,014 | predictions.columns = ['id'] + ['F' + str(i + 1)for i in range(28)]
predictions<prepare_x_and_y> | k_fold = KFold(n_splits=10, shuffle=True, random_state=0 ) | Titanic - Machine Learning from Disaster |
9,470,014 | x = 2744099 + 1 - 853720
df_val = df_eval[x:]<prepare_output> | clf = KNeighborsClassifier(n_neighbors = 13)
scoring = 'accuracy'
score = cross_val_score(clf, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
print(score ) | Titanic - Machine Learning from Disaster |
9,470,014 | predictions_v = df_val[['id', 'date', 'qty']]
predictions_v = pd.pivot(predictions_v, index = 'id', columns = 'date', values = 'qty' ).reset_index()
predictions_v<feature_engineering> | round(np.mean(score)*100, 2 ) | Titanic - Machine Learning from Disaster |
9,470,014 | predictions_v['id'] = predictions['id'].apply(lambda x: x.replace('evaluation', 'validation'))
predictions_v.head()<rename_columns> | clf = DecisionTreeClassifier()
scoring = 'accuracy'
score = cross_val_score(clf, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
print(score ) | Titanic - Machine Learning from Disaster |
9,470,014 | predictions_v.columns = ['id'] + ['F' + str(i + 1)for i in range(28)]
predictions_v.head()<concatenate> | round(np.mean(score)*100, 2 ) | Titanic - Machine Learning from Disaster |
9,470,014 | predictions_concat = pd.concat([predictions, predictions_v], axis=0 )<save_to_csv> | clf = RandomForestClassifier(n_estimators=13)
scoring = 'accuracy'
score = cross_val_score(clf, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
print(score ) | Titanic - Machine Learning from Disaster |
9,470,014 | predictions_concat.to_csv('submission.csv', index=False )<load_from_csv> | round(np.mean(score)*100, 2 ) | Titanic - Machine Learning from Disaster |
9,470,014 | 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... | clf = GaussianNB()
scoring = 'accuracy'
score = cross_val_score(clf, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
print(score ) | Titanic - Machine Learning from Disaster |
9,470,014 |
<load_from_csv> | round(np.mean(score)*100, 2 ) | Titanic - Machine Learning from Disaster |
9,470,014 | 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... | clf = SVC()
scoring = 'accuracy'
score = cross_val_score(clf, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
print(score ) | Titanic - Machine Learning from Disaster |
9,470,014 | 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... | round(np.mean(score)*100,2 ) | Titanic - Machine Learning from Disaster |
9,470,014 | 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_... | clf = SVC()
clf.fit(train_data, target)
test_data = test.drop("PassengerId", axis=1 ).copy()
prediction = clf.predict(test_data ) | Titanic - Machine Learning from Disaster |
9,470,014 | <merge><EOS> | submission = pd.DataFrame({
"PassengerId": test["PassengerId"],
"Survived": prediction
})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
9,177,777 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_to_csv> | warnings.filterwarnings('ignore')
| Titanic - Machine Learning from Disaster |
9,177,777 | submission.to_csv("submission.csv", index=False)
submission<load_from_csv> | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
Id = test.PassengerId | Titanic - Machine Learning from Disaster |
9,177,777 | submission = pd.read_csv('/kaggle/input/local-submission-files-m5/submission_46.csv' )<load_from_csv> | dataset = pd.concat([train, test], sort=False, ignore_index=True)
dataset.isnull().mean().sort_values(ascending=False ) | Titanic - Machine Learning from Disaster |
9,177,777 | sales = pd.read_csv(f'/kaggle/input/m5-forecasting-accuracy/sales_train_validation.csv')
ids = sorted(list(set(sales['id'])))
d_cols = [f'd_{x}' for x in range(1258,1914)]<compute_test_metric> | dataset['Fare'].fillna(dataset['Fare'].median() , inplace=True)
dataset['Embarked'] = dataset['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
9,177,777 | def calc_coef(x,y, alpha):
y = np.mean(y, axis = 0)
slope, intercept, r_value, p_value, std_err = stats.linregress(x,y)
line = slope*x+intercept
return 1 +(slope*y.shape[0]/alpha )<categorify> | dataset['Title'] = dataset['Name'].str.extract('([A-Za-z]+)\.', expand = False)
dataset['Title'].unique().tolist() | Titanic - Machine Learning from Disaster |
9,177,777 | stores = ['CA_1', 'CA_2', 'CA_3', 'CA_4', 'TX_1', 'TX_2', 'TX_3', 'WI_1', 'WI_2', 'WI_3']
for store in stores:
submission.loc[submission['id'].str.contains(store), [f'F{x}' for x in range(1,29)]] *= coefs[store]<save_to_csv> | dataset['Title'].value_counts(normalize=True)*100 | Titanic - Machine Learning from Disaster |
9,177,777 | submission.to_csv('submission.csv', index = False )<import_modules> | dataset['Title'] = dataset['Title'].replace(['Capt', 'Col', 'Major', 'Dr', 'Rev'], 'Officer')
dataset['Title'] = dataset['Title'].replace(['Jonkheer', 'Master'], 'Master')
dataset['Title'] = dataset['Title'].replace(['Don', 'Sir', 'the Countess', 'Lady', 'Dona'], 'Royalty')
dataset['Title'] = dataset['Title'].replac... | Titanic - Machine Learning from Disaster |
9,177,777 | from datetime import datetime, timedelta
import gc
import numpy as np, pandas as pd
import lightgbm as lgb<define_variables> | dataset['Age'].fillna(dataset['Age'].median() , inplace=True ) | Titanic - Machine Learning from Disaster |
9,177,777 | CAL_DTYPES={"event_name_1": "category", "event_name_2": "category", "event_type_1": "category",
"event_type_2": "category", "weekday": "category", 'wm_yr_wk': 'int16', "wday": "int16",
"month": "int16", "year": "int16", "snap_CA": "float32", 'snap_TX': 'float32', 'snap_WI': 'float32' }
PRICE_DTYPES = {"store_id": "cate... | dataset['FamSize'] = dataset['SibSp'] + dataset['Parch'] + 1 | Titanic - Machine Learning from Disaster |
9,177,777 | pd.options.display.max_columns = 50<define_variables> | def family_label(s):
if(s >= 2)&(s <= 4):
return 2
elif(( s > 4)&(s <= 7)) |(s == 1):
return 1
elif(s > 7):
return 0
dataset['FamLabel']=dataset['FamSize'].apply(family_label)
dataset.head() | Titanic - Machine Learning from Disaster |
9,177,777 | h = 28
max_lags = 70
tr_last = 1913
fday = datetime(2016,4, 25)
fday<load_from_csv> | dataset['Cabin'] = dataset['Cabin'].fillna('Unknown')
dataset['Deck']=dataset['Cabin'].str.get(0 ) | Titanic - Machine Learning from Disaster |
9,177,777 | def create_dt(is_train = True, nrows = None, first_day = 1200):
prices = pd.read_csv(".. /input/m5-forecasting-accuracy/sell_prices.csv", dtype = PRICE_DTYPES)
for col, col_dtype in PRICE_DTYPES.items() :
if col_dtype == "category":
prices[col] = prices[col].cat.codes.astype("int16")
prices[col] -= prices[col].min()
... | dataset.drop(['Name', 'Ticket', 'SibSp', 'Parch', 'FamSize', 'Cabin'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
9,177,777 | def create_fea(dt):
lags = [7, 28]
lag_cols = [f"lag_{lag}" for lag in lags ]
for lag, lag_col in zip(lags, lag_cols):
dt[lag_col] = dt[["id","sales"]].groupby("id")["sales"].shift(lag)
wins = [7, 28]
for win in wins :
for lag,lag_col in zip(lags, lag_cols):
dt[f"rmean_{lag}_{win}"] = dt[["id", lag_col]].groupby("id")... | label = LabelEncoder()
for col in ['Sex', 'Embarked', 'Deck', 'Title']:
dataset[col] = label.fit_transform(dataset[col] ) | Titanic - Machine Learning from Disaster |
9,177,777 | FIRST_DAY = 800
<correct_missing_values> | train = dataset[:len(train)]
test = dataset[len(train):]
test.drop(labels=['Survived'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
9,177,777 | df.dropna(inplace = True)
df.shape<prepare_x_and_y> | train['Survived'] = train['Survived'].astype(int ) | Titanic - Machine Learning from Disaster |
9,177,777 | cat_feats = ['item_id', 'dept_id','store_id', 'cat_id', 'state_id'] + ["event_name_1", "event_name_2", "event_type_1", "event_type_2"]
useless_cols = ["id", "date", "sales","d", "wm_yr_wk", "weekday"]
train_cols = df.columns[~df.columns.isin(useless_cols)]
X_train = df[train_cols]
y_train = df["sales"]<create_dataframe... | y = train.Survived
X = train.drop('Survived', axis=1)
| Titanic - Machine Learning from Disaster |
9,177,777 | train_data = lgb.Dataset(X_train, label = y_train, categorical_feature=cat_feats, free_raw_data=False)
fake_valid_inds = np.random.choice(len(X_train), 1000000)
fake_valid_data = lgb.Dataset(X_train.iloc[fake_valid_inds], label = y_train.iloc[fake_valid_inds],categorical_feature=cat_feats,
free_raw_data=False )<init_... | print("Logistic Regression:", cross_val_score(LogisticRegression() , X, y ).mean())
print("SVC:", cross_val_score(SVC() , X, y ).mean())
print("Random Forest:", cross_val_score(RandomForestClassifier() , X, y ).mean())
print("GaussianNB:", cross_val_score(GaussianNB() , X, y ).mean())
print("Decision Tree:", cross_... | Titanic - Machine Learning from Disaster |
9,177,777 | 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' : 2500,
}<train_model> | select = SelectKBest(k = 'all')
final_model = RandomForestClassifier(random_state = 10, warm_start = True,
n_estimators = 26,
max_depth = 6,
max_features = 'sqrt')
pipeline = make_pipeline(select, final_model)
cv_result = cross_validate(pipeline, X, y, cv= 10)
print("CV Test Score : Mean - %.7g | Std - %.7g " %(np.... | Titanic - Machine Learning from Disaster |
9,177,777 | %%time
m_lgb = lgb.train(params, train_data, valid_sets = [fake_valid_data], verbose_eval=100 )<save_model> | pipeline.fit(X, y)
final_predictions = pipeline.predict(test ) | 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.