kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,401,023 | train_df= train_df.drop(train_df[train_df['fare_amount']<0].index, axis = 0)
train_df.shape<count_values> | all_data['Age'].fillna(all_data.groupby(['title'])['Age'].transform('median'), inplace = True ) | Titanic - Machine Learning from Disaster |
9,401,023 | Counter(train_df['passenger_count']>6 )<drop_column> | def splitAgeColumns(x):
if x <= 16.0:
return 0
elif x > 16.0 and x <= 26.0:
return 1
elif x > 26.0 and x <= 36.0:
return 2
elif x > 36.0 and x <= 46.0:
return 3
else:
return 4 | Titanic - Machine Learning from Disaster |
9,401,023 | train_df= train_df.drop(train_df[train_df['passenger_count']>6].index, axis = 0)
train_df.shape<count_values> | all_data['Age'] = all_data['Age'].apply(lambda x : splitAgeColumns(x)) | Titanic - Machine Learning from Disaster |
9,401,023 | Counter(train_df['pickup_latitude']<-90 )<count_values> | all_data['calculate_fare'] = all_data['Fare'] /(all_data['Parch'] + all_data['SibSp'] + 1 ) | Titanic - Machine Learning from Disaster |
9,401,023 | Counter(train_df['pickup_latitude']>90 )<drop_column> | def splitFareColumns(x):
if x <= 5.0:
return 0
elif x > 5.0 and x <= 10.0:
return 1
elif x > 10.0 and x <= 15.0:
return 2
elif x > 15.0 and x <= 20.0:
return 3
elif x > 20.0 and x <= 25.0:
return 4
else:
return 5 | Titanic - Machine Learning from Disaster |
9,401,023 | train_df = train_df.drop(((train_df[train_df['pickup_latitude']<-90])|(train_df[train_df['pickup_latitude']>90])).index, axis=0 )<count_values> | all_data['calculate_fare'] = all_data['calculate_fare'].apply(lambda x : splitFareColumns(x)) | Titanic - Machine Learning from Disaster |
9,401,023 | Counter(train_df['pickup_longitude']<-180 )<count_values> | def splitSibSpColumns(x):
if x <= 0.0:
return 0
elif x > 0.0 and x <= 1.0:
return 1
else:
return 2
def splitParchColumns(x):
if x <= 0.0:
return 0
elif x > 0.0 and x <= 2.0:
return 1
else:
return 2 | Titanic - Machine Learning from Disaster |
9,401,023 | Counter(train_df['pickup_longitude']>180 )<drop_column> | all_data['SibSp'] = all_data['SibSp'].apply(lambda x : splitSibSpColumns(x))
all_data['Parch'] = all_data['Parch'].apply(lambda x : splitParchColumns(x)) | Titanic - Machine Learning from Disaster |
9,401,023 | train_df = train_df.drop(( train_df[train_df['pickup_longitude']<-180] ).index, axis=0 )<data_type_conversions> | data = [train, test]
for dataset in data:
dataset['pclass_fare'] = dataset['Fare'] * dataset['Pclass'] | Titanic - Machine Learning from Disaster |
9,401,023 | train_df['key']=pd.to_datetime(train_df['key'])
train_df['pickup_datetime']=pd.to_datetime(train_df['pickup_datetime'] )<data_type_conversions> | percent_null_value(train ) | Titanic - Machine Learning from Disaster |
9,401,023 | test_df['key']=pd.to_datetime(test_df['key'])
test_df['pickup_datetime']=pd.to_datetime(test_df['pickup_datetime'] )<feature_engineering> | df = all_data.drop(['Name', 'Ticket', 'Survived', 'Fare'], axis = 1 ) | Titanic - Machine Learning from Disaster |
9,401,023 | data=[train_df,test_df]
for i in data:
i['date']=i['pickup_datetime'].dt.day
i['month']=i['pickup_datetime'].dt.month
i['day_of_week']=i['pickup_datetime'].dt.dayofweek
i['hour']=i['pickup_datetime'].dt.hour
i['year']=i['pickup_datetime'].dt.year
<compute_test_metric> | mapping = {'male' : 0, 'female' : 1}
df['Sex'] = df['Sex'].map(mapping ) | Titanic - Machine Learning from Disaster |
9,401,023 | def sphere_distance(lat1,long1,lat2,long2):
data=[train_df,test_df]
for i in data:
R=6367
phi1 = np.radians(i[lat1])
phi2 = np.radians(i[lat2])
delta_phi = np.radians(i[lat2]-i[lat1])
delta_lambda = np.radians(i[long2]-i[long1])
a = np.sin(delta_phi / 2.0)** 2 + np.cos(phi1)* np.cos(phi2)* np.sin(delta_lambda / 2.0... | def getOneHotEncode(df, col):
cat = pd.get_dummies(df[col], prefix = col)
df = pd.concat([df, cat], axis = 1)
df.drop([col], axis = 1, inplace = True)
return df | Titanic - Machine Learning from Disaster |
9,401,023 | train_df.sort_values(['S_Distance','fare_amount'], ascending=False )<filter> | one_hot_columns = ['Pclass', 'Cabin', 'Embarked', 'title'] | Titanic - Machine Learning from Disaster |
9,401,023 | dis_0 = train_df.loc[(train_df['S_Distance'] == 0), ['S_Distance']]
dis_1 = train_df.loc[(train_df['S_Distance'] > 0)&(train_df['S_Distance'] <= 10), ['S_Distance']]
dis_2 = train_df.loc[(train_df['S_Distance'] > 10)&(train_df['S_Distance'] <= 50), ['S_Distance']]
dis_3 = train_df.loc[(train_df['S_Distance'] > 50)&(tra... | df = df.sort_values('PassengerId' ) | Titanic - Machine Learning from Disaster |
9,401,023 | x=Counter(dis_bin['bins'])
x<filter> | mapping = {'S' : 0, 'C' : 1, 'Q' : 2}
df['Embarked'] = df['Embarked'].map(mapping ) | Titanic - Machine Learning from Disaster |
9,401,023 | train_df.loc[(( train_df['pickup_latitude']==0)&(train_df['pickup_longitude']==0)) &(( train_df['dropoff_latitude']!=0)&(train_df['dropoff_longitude']!=0)) &(train_df['fare_amount']==0)]<filter> | from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import accuracy_score
from sklearn.svm import SVC
from xgboost import XGBClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from catboost import CatBoostClassifier | Titanic - Machine Learning from Disaster |
9,401,023 | train_df.loc[(( train_df['pickup_latitude']==0)&(train_df['pickup_longitude']==0)) &(( train_df['dropoff_latitude']!=0)&(train_df['dropoff_longitude']!=0)) &(train_df['fare_amount']==0)]<drop_column> | train, test = df[df.PassengerId <= 891], df[df.PassengerId > 891]
train, test = train.drop(['PassengerId'], axis = 1), test.drop(['PassengerId'], axis = 1)
X_train, X_val, Y_train, Y_val = train_test_split(train, survived, test_size = 0.2, shuffle = True, random_state = 1 ) | Titanic - Machine Learning from Disaster |
9,401,023 | train_df = train_df.drop(train_df.loc[(( train_df['pickup_latitude']==0)&(train_df['pickup_longitude']==0)) &(( train_df['dropoff_latitude']!=0)&(train_df['dropoff_longitude']!=0)) &(train_df['fare_amount']==0)].index, axis=0 )<drop_column> | clf = SVC(kernel = 'linear')
cross_val_score(clf, train, survived, cv = 5 ) | Titanic - Machine Learning from Disaster |
9,401,023 | train_df = train_df.drop(train_df.loc[(( train_df['pickup_latitude']==0)&(train_df['pickup_longitude']==0)) &(( train_df['dropoff_latitude']!=0)&(train_df['dropoff_longitude']!=0)) &(train_df['fare_amount']==0)].index, axis=0)
<filter> | clf = XGBClassifier()
cross_val_score(clf, train, survived, cv = 5 ) | Titanic - Machine Learning from Disaster |
9,401,023 | high_distance = train_df.loc[(train_df['S_Distance']>200)&(train_df['fare_amount']!=0)]<feature_engineering> | clf = DecisionTreeClassifier()
cross_val_score(clf, train, survived, cv = 5 ) | Titanic - Machine Learning from Disaster |
9,401,023 | high_distance['S_Distance'] = high_distance.apply(
lambda row:(row['fare_amount'] - 2.50)/1.56,
axis=1
)<filter> | clf = RandomForestClassifier(n_estimators=400)
cross_val_score(clf, train, survived, cv = 5 ) | Titanic - Machine Learning from Disaster |
9,401,023 | train_df[train_df['S_Distance']==0]<filter> | clf = CatBoostClassifier(verbose = False)
cross_val_score(clf, train, survived, cv = 5 ) | Titanic - Machine Learning from Disaster |
9,401,023 | train_df[(train_df['S_Distance']==0)&(train_df['fare_amount']==0)]<drop_column> | clf = SVC()
clf.fit(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
9,401,023 | train_df = train_df.drop(train_df[(train_df['S_Distance']==0)&(train_df['fare_amount']==0)].index, axis = 0 )<define_variables> | y_train_pred = clf.predict(X_train)
y_val_pred = clf.predict(X_val)
print('train accuracy: {}%'.format(accuracy_score(y_train_pred, Y_train)))
print('validation accuracy: {}%'.format(accuracy_score(y_val_pred, Y_val)) ) | Titanic - Machine Learning from Disaster |
9,401,023 | rush_hour = train_df.loc[(((train_df['hour']>=6)&(train_df['hour']<=20)) &(( train_df['day_of_week']>=1)&(train_df['day_of_week']<=5)) &(train_df['S_Distance']==0)&(train_df['fare_amount'] < 2.5)) ]
rush_hour<drop_column> | y_test = clf.predict(test)
result = pd.read_csv('.. /input/titanic/gender_submission.csv')
result['Survived'] = y_test
result.to_csv('submission.csv', index = False ) | Titanic - Machine Learning from Disaster |
9,408,731 | train_df=train_df.drop(rush_hour.index,axis=0 )<filter> | train_X = pd.read_csv(".. /input/titanic/train.csv")
test_y = pd.read_csv(".. /input/titanic/test.csv")
print("Test and Train FILES are loaded")
train_X.columns | Titanic - Machine Learning from Disaster |
9,408,731 | non_rush_hour = train_df.loc[(((train_df['hour']<6)|(train_df['hour']>20)) &(( train_df['day_of_week']>=1)&(train_df['day_of_week']<=5)) &(train_df['S_Distance']==0)&(train_df['fare_amount'] < 3.0)) ]<filter> | features = ["Pclass", "Sex", "SibSp", "Parch"]
train_y = train_X['Survived']
train_f= train_X[features]
le = LabelEncoder()
train_f['Sex']=le.fit_transform(train_f['Sex'])
test_y['Sex'] = le.fit_transform(test_y['Sex'])
| Titanic - Machine Learning from Disaster |
9,408,731 | non_rush_hour = train_df.loc[(((train_df['hour']<6)|(train_df['hour']>20)) &(( train_df['day_of_week']>=1)&(train_df['day_of_week']<=5)) &(train_df['S_Distance']==0)&(train_df['fare_amount'] < 3.0)) ]
non_rush_hour<feature_engineering> | model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=1)
model.fit(train_f,train_y)
predictions = model.predict(test_y[features])
predictions | Titanic - Machine Learning from Disaster |
9,408,731 | train_df.loc[(train_df['S_Distance']!=0)&(train_df['fare_amount']==0)]<filter> | output = pd.DataFrame({"PassengerId" :test_y['PassengerId'] , 'Survived':predictions})
output.to_csv('submission1.csv',index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
9,101,854 | scenario_3 = train_df.loc[(train_df['S_Distance']!=0)&(train_df['fare_amount']==0)]
scenario_3<filter> | titanic=pd.read_csv('/kaggle/input/titanic/train.csv')
titanic.head() | Titanic - Machine Learning from Disaster |
9,101,854 | scenario_3 = train_df.loc[(train_df['S_Distance']!=0)&(train_df['fare_amount']==0)]<feature_engineering> | titanic_dummies=pd.get_dummies(data=titanic,columns=['Sex','Embarked'],drop_first=True)
titanic_dummies.info() | Titanic - Machine Learning from Disaster |
9,101,854 | scenario_3['fare_amount'] = scenario_3.apply(
lambda row:(( row['S_Distance'] * 1.56)+ 2.50), axis=1
)<filter> | X=titanic_dummies.loc[:,['Sex_male','SibSp','Parch','Pclass','Fare','Embarked_S','Embarked_Q','Age','Fare']]
y=titanic_dummies['Survived']
X | Titanic - Machine Learning from Disaster |
9,101,854 | train_df.loc[(train_df['S_Distance']==0)&(train_df['fare_amount']!=0)]<filter> | dt=RandomForestClassifier()
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.3,random_state=42)
dt.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
9,101,854 | scenario_4 = train_df.loc[(train_df['S_Distance']==0)&(train_df['fare_amount']!=0)]<filter> | dt.score(X_test,y_test)
y_pred=dt.predict(X_test ) | Titanic - Machine Learning from Disaster |
9,101,854 | scenario_4.loc[(scenario_4['fare_amount']<=3.0)&(scenario_4['S_Distance']==0)]<filter> | confusion_matrix(y_test,y_pred ) | Titanic - Machine Learning from Disaster |
9,101,854 | scenario_4.loc[(scenario_4['fare_amount']>3.0)&(scenario_4['S_Distance']==0)]<filter> | test=pd.read_csv('/kaggle/input/titanic/test.csv')
test_dummies=pd.get_dummies(data=test,columns=['Sex','Embarked'],drop_first=True)
test_dummies['Fare'].fillna(test_dummies['Fare'].dropna().median() ,inplace=True)
test_dummies['Age'].fillna(test_dummies['Age'].dropna().median() ,inplace=True)
test_dummies.info() | Titanic - Machine Learning from Disaster |
9,101,854 | scenario_4_sub = scenario_4.loc[(scenario_4['fare_amount']>3.0)&(scenario_4['S_Distance']==0)]<feature_engineering> | X_testf=test_dummies.loc[:,['Sex_male','SibSp','Parch','Pclass','Fare','Embarked_S','Embarked_Q','Age','Fare']]
predictions=dt.predict(X_testf ) | Titanic - Machine Learning from Disaster |
9,101,854 | scenario_4_sub['S_Distance'] = scenario_4_sub.apply(
lambda row:(( row['fare_amount']-2.50)/1.56), axis=1
)<drop_column> | Id=test_dummies['PassengerId']
sub_df=pd.DataFrame({'PassengerId':Id,'Survived':predictions})
sub_df.head() | Titanic - Machine Learning from Disaster |
9,101,854 | train_df = train_df.drop(['key','pickup_datetime'], axis = 1)
test_df = test_df.drop(['key','pickup_datetime'], axis = 1 )<prepare_x_and_y> | sub_df.to_csv('submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
9,121,810 | x_train = train_df.iloc[:,train_df.columns!='fare_amount']
y_train = train_df['fare_amount'].values
x_test = test_df<train_model> | !pip install pycaret==1.0 | Titanic - Machine Learning from Disaster |
9,121,810 | rg=RandomForestRegressor()
rg.fit(x_train,y_train)
y_predict=rg.predict(x_test)
y_predict<save_to_csv> | import os
import random
import numpy as np
import pandas as pd | Titanic - Machine Learning from Disaster |
9,121,810 | submission = pd.read_csv('.. /input/sample_submission.csv')
submission['fare_amount'] = y_predict
submission.to_csv('submission_1.csv', index=False)
submission.head(10 )<import_modules> | def random_seed_initialize(seed=42):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed ) | Titanic - Machine Learning from Disaster |
9,121,810 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns<load_from_csv> | random_seed_initialize(777 ) | Titanic - Machine Learning from Disaster |
9,121,810 | train_df = pd.read_csv('.. /input/train.csv', nrows = 5_000_000 )<compute_test_metric> | train_data = pd.read_csv('.. /input/titanic/train.csv')
test_data = pd.read_csv('.. /input/titanic/test.csv')
submission_data = pd.read_csv('.. /input/titanic/gender_submission.csv' ) | Titanic - Machine Learning from Disaster |
9,121,810 | def haversine_np(lon1, lat1, lon2, lat2):
lon1, lat1, lon2, lat2 = map(np.radians, [lon1, lat1, lon2, lat2])
dlon = lon2 - lon1
dlat = lat2 - lat1
a = np.sin(dlat/2.0)**2 + np.cos(lat1)* np.cos(lat2)* np.sin(dlon/2.0)**2
c = 2 * np.arcsin(np.sqrt(a))
km = 6367 * c
return km<feature_engineering> | from pycaret.classification import * | Titanic - Machine Learning from Disaster |
9,121,810 | train_df['distance'] = haversine_np(train_df['pickup_longitude'], train_df['pickup_latitude'],
train_df['dropoff_longitude'], train_df['dropoff_latitude'] )<data_type_conversions> | exp = setup(data=train_data, target='Survived', ignore_features = ['PassengerId', 'Name'], silent=True, session_id=42 ) | Titanic - Machine Learning from Disaster |
9,121,810 | train_df['pickup_datetime'] = pd.to_datetime(train_df['pickup_datetime'] )<feature_engineering> | fold_start_number = 2
fold_end_number = 30 + 1
except_count = 0
for i in range(fold_start_number, fold_end_number, 1):
try:
blend_models(fold=i, verbose=False)
except:
except_count += 1
save_experiment('TitanicBlendModelsExperiment')
experiment = load_experiment('TitanicBlendModelsExperiment' ) | Titanic - Machine Learning from Disaster |
9,121,810 | train_df['year'] = train_df['pickup_datetime'].dt.year
train_df['month'] = train_df['pickup_datetime'].dt.month
train_df['day'] = train_df['pickup_datetime'].dt.day
train_df['hour'] = train_df['pickup_datetime'].dt.hour
train_df['minute'] = train_df['pickup_datetime'].dt.minute<train_model> | accuracy = []
best_fold_number = 0
best_accuracy = 0
best_model = None
for i in range(fold_end_number - fold_start_number - except_count, 0, -1):
fold_num = len(experiment[-i*2+1]['Accuracy'])- 2
accuracy_mean = experiment[-i*2+1]['Accuracy']['Mean']
model = experiment[-i*2]
if best_accuracy < accuracy_mean:
best_fold_... | Titanic - Machine Learning from Disaster |
9,121,810 | print('Old size: %d' % len(train_df))
train_df = train_df.dropna(how = 'any', axis = 'rows')
print('New size: %d' % len(train_df))<feature_engineering> | predictions = predict_model(best_model, data=test_data)
predictions.head() | Titanic - Machine Learning from Disaster |
9,121,810 | cond = True
for col in {'pickup_latitude', 'pickup_longitude', 'dropoff_latitude', 'dropoff_longitude'}:
cond &= abs(train_df[col] - train_df[col].mean())< 5
<feature_engineering> | submission_data['Survived'] = round(predictions['Label'] ).astype(int)
submission_data.to_csv('submission.csv',index=False)
submission_data.head() | Titanic - Machine Learning from Disaster |
14,245,867 | for col in {'pickup_latitude', 'pickup_longitude', 'dropoff_latitude', 'dropoff_longitude'}:
train_df['rough' + col] = train_df[col].round(2 )<groupby> | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
14,245,867 | a=train_df.groupby(['roughpickup_latitude','roughpickup_longitude'])[['pickup_latitude', 'pickup_longitude']].agg(['mean','count'] )<sort_values> | seed = 42 | Titanic - Machine Learning from Disaster |
14,245,867 | a.columns = ['mean_pickup_latitude','c1','mean_pickup_longitude','c2']
a.head()
a.sort_values(['c1','c2'],ascending=False ).head()
<groupby> | train = train.drop('Cabin',axis = 1)
train = train.drop('Name',axis = 1)
train = train.drop('Ticket',axis = 1)
train = train.drop('PassengerId',axis = 1)
train = train.reset_index(drop=True ) | Titanic - Machine Learning from Disaster |
14,245,867 | b=train_df.groupby(['roughdropoff_latitude','roughdropoff_longitude'])[['dropoff_latitude', 'dropoff_longitude']].agg(['mean','count'] )<sort_values> | for col in train.columns:
if train[col].dtype == 'O':
train[col] = pd.get_dummies(train[col])
train.head() | Titanic - Machine Learning from Disaster |
14,245,867 | b.columns = ['mean_dropoff_latitude','c1','mean_dropoff_longitude','c2']
b.head()
b.sort_values(['c1','c2'],ascending=False ).head(n=20)
<sort_values> | train = train.fillna(-9999 ) | Titanic - Machine Learning from Disaster |
14,245,867 | b[ b['mean_dropoff_latitude']<40.7].sort_values(['c1','c2'],ascending=False ).head()
<rename_columns> | X = train.iloc[:,1:]
y = train.iloc[:,0]
x_train, x_test,y_train, y_test = train_test_split(X,y,test_size = 0.2,random_state = seed ) | Titanic - Machine Learning from Disaster |
14,245,867 | a = a[['c1']].reset_index().rename(columns={'c1':'pickup_busyness'})
b = b[['c1']].reset_index().rename(columns={'c1':'dropoff_busyness'} )<merge> | import xgboost as xgb
import optuna | Titanic - Machine Learning from Disaster |
14,245,867 | train_df = pd.merge(train_df,a, how='left')
train_df = pd.merge(train_df,b, how='left' )<prepare_x_and_y> | def objective(trial):
dtrain = xgb.DMatrix(x_train,label = y_train)
dtest = xgb.DMatrix(x_test,label = y_test)
num_round = 1000
param = {
"eta": trial.suggest_float('eta',1e-3, 0.3),
"objective": "binary:logistic",
"eva_metric":'auc',
"max_depth": trial.suggest_int('max_depth',4,16),
"subsample": trial.suggest_float(... | Titanic - Machine Learning from Disaster |
14,245,867 | X = train_df[['distance','year','month','day','hour','pickup_busyness','dropoff_busyness']].values
Y = train_df['fare_amount'].values<import_modules> | if __name__ == "__main__":
study = optuna.create_study(
pruner=optuna.pruners.MedianPruner(n_warmup_steps=5), direction="maximize"
)
study.optimize(objective, n_trials=100)
print(study.best_trial ) | Titanic - Machine Learning from Disaster |
14,245,867 | from sklearn.ensemble import RandomForestRegressor<import_modules> | params={'eta': 0.001832623843952462, 'max_depth': 4, 'subsample': 0.8827284715195801, 'lambda': 7.80011028366904} | Titanic - Machine Learning from Disaster |
14,245,867 | from sklearn.ensemble import RandomForestRegressor<choose_model_class> | num_round = 100
dtrain = xgb.DMatrix(x_train,label = y_train)
dtest = xgb.DMatrix(x_test,label = y_test)
clf = xgb.XGBClassifier(**params)
kfold = StratifiedKFold(n_splits = 5)
results = cross_val_score(clf,x_train,y_train,cv = kfold)
avg_results = results.sum() /5 | Titanic - Machine Learning from Disaster |
14,245,867 | kwargs = {'bootstrap': True,
'max_depth': None,
'max_features': 3,
'min_samples_leaf': 9,
'min_samples_split': 2}
rand_regr = RandomForestRegressor(n_estimators=20, **kwargs )<train_model> | num_rounds = 10
bst = xgb.train(params,dtrain,num_rounds ) | Titanic - Machine Learning from Disaster |
14,245,867 | rand_regr.fit(X, Y )<predict_on_test> | lgb_train = lgb.Dataset(x_train,y_train)
lgb_test = lgb.Dataset(x_test,y_test ) | Titanic - Machine Learning from Disaster |
14,245,867 | y_pred = rand_regr.predict(X)
print('chi squared rand forest with date %s' %(np.sum(( Y-y_pred)**2.) /len(Y)) **0.5 )<compute_test_metric> | def lightgbm_objective(trial):
lgb_train = lgb.Dataset(x_train,y_train)
lgb_test = lgb.Dataset(x_test,y_test)
param = {
'boost_type': trial.suggest_categorical('boost_type',['dart','gbdt']),
"eta": trial.suggest_float('eta',1e-3, 0.3),
"objective": "binary:logistic",
"eva_metric":'auc',
"max_depth": trial.suggest_int... | Titanic - Machine Learning from Disaster |
14,245,867 | rand_regr.score(X,Y )<load_from_csv> | if __name__ == "__main__":
study = optuna.create_study(
pruner=optuna.pruners.MedianPruner(n_warmup_steps=5), direction="maximize"
)
study.optimize(lightgbm_objective, n_trials=80)
print(study.best_trial ) | Titanic - Machine Learning from Disaster |
14,245,867 | test_df = pd.read_csv('.. /input/test.csv' )<compute_test_metric> | params={'boost_type': 'dart', 'eta': 0.21195106328946775, 'max_depth': 9, 'subsample': 0.6526587206109331, 'lambda': 11.46556912870986, 'feature_fraction': 0.8104196182900097, 'num_boost_round': 88} | Titanic - Machine Learning from Disaster |
14,245,867 | test_df['distance'] = haversine_np(test_df['pickup_longitude'], test_df['pickup_latitude'],
test_df['dropoff_longitude'], test_df['dropoff_latitude'] )<data_type_conversions> | gbm = lgb.train(params,
lgb_train,
valid_sets=lgb_test,
)
preds = gbm.predict(x_test,num_iteration = gbm.best_iteration)
accuracy = sklearn.metrics.accuracy_score([int(round(x)) for x in preds],y_test)
accuracy | Titanic - Machine Learning from Disaster |
14,245,867 | test_df['pickup_datetime'] = pd.to_datetime(test_df['pickup_datetime'] )<feature_engineering> | lgb.cv(params = params,train_set = lgb_train,metrics = 'auc',nfold = 3 ) | Titanic - Machine Learning from Disaster |
14,245,867 | test_df['year'] = test_df['pickup_datetime'].dt.year
test_df['month'] = test_df['pickup_datetime'].dt.month
test_df['day'] = test_df['pickup_datetime'].dt.day
test_df['hour'] = test_df['pickup_datetime'].dt.hour
test_df['minute'] = test_df['pickup_datetime'].dt.minute<feature_engineering> | y_train.to_numpy() | Titanic - Machine Learning from Disaster |
14,245,867 | for col in {'pickup_latitude', 'pickup_longitude', 'dropoff_latitude', 'dropoff_longitude'}:
test_df['rough' + col] = test_df[col].round(2 )<merge> | nn_model = tf.keras.Sequential()
nn_model.add(Dense(units = 9, kernel_initializer = 'uniform', activation = 'relu'))
nn_model.add(Dense(units = 9, kernel_initializer = 'uniform', activation = 'relu'))
nn_model.add(Dense(units = 5, kernel_initializer = 'uniform', activation = 'relu'))
nn_model.add(Dense(units = 1, kerne... | Titanic - Machine Learning from Disaster |
14,245,867 | test_df = pd.merge(test_df,a, how='left')
test_df = pd.merge(test_df,b, how='left' )<data_type_conversions> | test = test.drop('Cabin',axis = 1)
test = test.drop('Name',axis = 1)
test = test.drop('Ticket',axis = 1)
test = test.drop('PassengerId',axis = 1)
for col in test.columns:
if test[col].dtype == 'O':
test[col] = pd.get_dummies(test[col])
test = test.fillna(-9999 ) | Titanic - Machine Learning from Disaster |
14,245,867 | test_df['pickup_busyness'] = test_df['pickup_busyness'].fillna(1)
test_df['dropoff_busyness'] = test_df['dropoff_busyness'].fillna(1 )<predict_on_test> | test_xgb = xgb.DMatrix(test)
pred_xgb = bst.predict(test_xgb)
pred_xgb = [round(x)for x in pred_xgb] | Titanic - Machine Learning from Disaster |
14,245,867 | X_to_pred = test_df[['distance','year','month','day','hour','pickup_busyness','dropoff_busyness']].values
y_pred = rand_regr.predict(X_to_pred )<save_to_csv> | test_lgb = lgb.Dataset(test)
pred_lgb = gbm.predict(test)
pred_lgb = [round(x)for x in pred_lgb] | Titanic - Machine Learning from Disaster |
14,245,867 | submission = pd.DataFrame(
{'key': test_df.key, 'fare_amount': y_pred},
columns = ['key', 'fare_amount'])
submission.to_csv('submission.csv', index = False )<prepare_x_and_y> | pred_nn = nn_model.predict(test)
pred_nn = [int(round(x)) for x in pred_nn.flat[:]] | Titanic - Machine Learning from Disaster |
14,245,867 |
<set_options> | Results = [round(( a+b+c)/3)for(a,b,c)in zip(pred_nn,pred_lgb,pred_xgb)]
| Titanic - Machine Learning from Disaster |
14,245,867 | %matplotlib inline
color = sns.color_palette()
sns.set_style('darkgrid')
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
train = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/train.csv')
test = pd.read_csv('.. ... | sub = pd.read_csv('/kaggle/input/titanic/test.csv')
sub['Survived'] = [int(x)for x in Results]
sub = sub[['PassengerId','Survived']] | Titanic - Machine Learning from Disaster |
14,245,867 | <set_options><EOS> | my_sub = sub.to_csv('my_sub.csv',index = False ) | Titanic - Machine Learning from Disaster |
14,271,675 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | np.set_printoptions(precision=4)
%config InlineBackend.figure_format = 'retina'
%matplotlib inline
init_notebook_mode(connected=True)
warnings.filterwarnings("ignore")
plt.style.use('fivethirtyeight')
sns.set(font_scale=1.5)
| Titanic - Machine Learning from Disaster |
14,271,675 | DATA_PATH = '.. /input/melanoma-merged-external-data-512x512-jpeg'<normalization> | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
14,271,675 | TEST_ROOT_PATH = f'{DATA_PATH}/512x512-test/512x512-test'
def get_valid_transforms() :
return A.Compose([
A.Resize(height=512, width=512, p=1.0),
ToTensorV2(p=1.0),
], p=1.0)
class DatasetRetriever(Dataset):
def __init__(self, image_ids, transforms=None):
super().__init__()
self.image_ids = image_ids
self.transforms =... | def var_standardized(v):
stand=(v - v.mean())/ train.std()
return stand
| Titanic - Machine Learning from Disaster |
14,271,675 | def get_net() :
net = EfficientNet.from_name('efficientnet-b5')
net._fc = nn.Linear(in_features=2048, out_features=2, bias=True)
return net
net = get_net().cuda()<load_from_csv> | num_var = [f for f in train.columns if train.dtypes[f] != 'object']
num_var.remove('Survived')
num_var.remove('PassengerId')
| Titanic - Machine Learning from Disaster |
14,271,675 | df_test = pd.read_csv(f'.. /input/siim-isic-melanoma-classification/test.csv', index_col='image_name')
test_dataset = DatasetRetriever(
image_ids=df_test.index.values,
transforms=get_valid_transforms() ,
)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=8,
num_workers=2,
shuffle=False,
sampler=... | TRM=train.isna().sum().sum()
TSM=test.isna().sum().sum()
print(f'Mising Value percentage for train: {(TRM/ len(train)) *100}%')
print(f'Mising Value percentage for test: {(TSM / len(test)) *100}%' ) | Titanic - Machine Learning from Disaster |
14,271,675 | checkpoint_path = '.. /input/melanoma-public-checkpoints/effnet5-best-score-checkpoint-015epoch-version2.bin'
checkpoint = torch.load(checkpoint_path)
net.load_state_dict(checkpoint);
net.eval() ;<concatenate> | print("- Mising Value:
", train.isna().sum() ,"
- Total of Mising Value : ", train.isna().sum().sum() ) | Titanic - Machine Learning from Disaster |
14,271,675 | result = {'image_name': [], 'target': []}
for images, image_names in tqdm(test_loader, total=len(test_loader)) :
with torch.no_grad() :
images = images.cuda().float()
outputs = net(images)
y_pred = nn.functional.softmax(outputs, dim=1 ).data.cpu().numpy() [:,1]
result['image_name'].extend(image_names)
result['target'... | print("- Mising Value:
", test.isna().sum() ,"
- Total of Mising Value : ", test.isna().sum().sum() ) | Titanic - Machine Learning from Disaster |
14,271,675 | submission.to_csv('submission.csv', index=False)
submission['target'].hist(bins=100);<set_options> | train.Embarked.replace(np.nan , 'S' , inplace=True)
test.Embarked.replace(np.nan , 'S' , inplace=True)
train['Cabin'] = train['Cabin'].map(lambda x:0 if pd.notnull(x)== False else 1)
test['Cabin'] = test['Cabin'].map(lambda x:0 if pd.notnull(x)== False else 1)
train['Name'] = train['Name'].str.replace('(' , '')
tr... | Titanic - Machine Learning from Disaster |
14,271,675 | %reload_ext autoreload
%autoreload 2
%matplotlib inline
%matplotlib inline
<categorify> | mean_age= pd.DataFrame(test.groupby('Pclass')[['Age']].mean())
mean_age | Titanic - Machine Learning from Disaster |
14,271,675 | GlobalParams = collections.namedtuple('GlobalParams', [
'batch_norm_momentum', 'batch_norm_epsilon', 'dropout_rate',
'num_classes', 'width_coefficient', 'depth_coefficient',
'depth_divisor', 'min_depth', 'drop_connect_rate', 'image_size'])
BlockArgs = collections.namedtuple('BlockArgs', [
'kernel_size', 'num_repeat', ... | def impute_age(age_pclass):
Age = age_pclass[0]
Pclass = age_pclass[1]
if pd.isnull(Age):
if Pclass == 1:
return 38
elif Pclass == 2:
return 30
else:
return 25
else:
return Age | Titanic - Machine Learning from Disaster |
14,271,675 | def efficientnet_params(model_name):
params_dict = {
'efficientnet-b0':(1.0, 1.0, 224, 0.2),
'efficientnet-b1':(1.0, 1.1, 240, 0.2),
'efficientnet-b2':(1.1, 1.2, 260, 0.3),
'efficientnet-b3':(1.2, 1.4, 300, 0.3),
'efficientnet-b4':(1.4, 1.8, 380, 0.4),
'efficientnet-b5':(1.6, 2.2, 456, 0.4),
'efficientnet-b6':(1.8, 2... | for item, i in train['Age'].iteritems() :
if pd.notnull(i)==False:
Age_ver2 = impute_age([i, train.Pclass.iloc[item]])
train['Age'].iloc[item] = Age_ver2
| Titanic - Machine Learning from Disaster |
14,271,675 | md_ef = EfficientNet.from_pretrained('efficientnet-b5', num_classes=1 )<load_from_csv> | for item, i in test['Age'].iteritems() :
if pd.notnull(i)==False:
Age_ver2 = impute_age([i, test.Pclass.iloc[item]])
test['Age'].iloc[item] = Age_ver2
| Titanic - Machine Learning from Disaster |
14,271,675 | def get_df() :
base_image_dir = os.path.join('.. ', 'input/aptos2019-blindness-detection/')
train_dir = os.path.join(base_image_dir,'train_images/')
df = pd.read_csv(os.path.join(base_image_dir, 'train.csv'))
df['path'] = df['id_code'].map(lambda x: os.path.join(train_dir,'{}.png'.format(x)))
df = df.drop(columns=['... | train.isna().sum().sum() | Titanic - Machine Learning from Disaster |
14,271,675 | bs = 32
sz = 224
tfms = get_transforms(do_flip=True,flip_vert=True )<compute_test_metric> | test.isna().sum().sum() | Titanic - Machine Learning from Disaster |
14,271,675 | def qk(y_pred, y):
return torch.tensor(cohen_kappa_score(torch.round(y_pred), y, weights='quadratic'), device='cuda:0' )<load_pretrained> | train= pd.get_dummies(train, columns=['Sex', 'Embarked'], drop_first=True)
train = pd.get_dummies(train, columns=['Pclass'], drop_first=True ) | Titanic - Machine Learning from Disaster |
14,271,675 | learn = Learner(data,
md_ef,
metrics = [qk],
model_dir="models" ).to_fp16()
learn.data.add_test(ImageList.from_df(test_df,
'.. /input/aptos2019-blindness-detection',
folder='test_images',
suffix='.png'))<train_model> | test= pd.get_dummies(test, columns=['Sex', 'Embarked'], drop_first=True)
test= pd.get_dummies(test, columns=['Pclass'], drop_first=True ) | Titanic - Machine Learning from Disaster |
14,271,675 | learn.fit_one_cycle(10, 1e-3 )<load_pretrained> | train['Name'] = train.Name.str.extract('([A-Za-z]+)\.', expand=False)
train['Name'] = train['Name'].replace(['Lady', 'Countess','Capt', 'Col',\
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
train['Name'] = train['Name'].replace('Mlle', 'Miss')
train['Name'] = train['Name'].replace('Ms', 'Miss')
t... | Titanic - Machine Learning from Disaster |
14,271,675 | learn.load('abcdef');<compute_test_metric> | test['Name'] = test.Name.str.extract('([A-Za-z]+)\.', expand=False)
test['Name'] = test['Name'].replace(['Lady', 'Countess','Capt', 'Col',\
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
test['Name'] = test['Name'].replace('Mlle', 'Miss')
test['Name'] = test['Name'].replace('Ms', 'Miss')
test['Nam... | Titanic - Machine Learning from Disaster |
14,271,675 | class OptimizedRounder(object):
def __init__(self):
self.coef_ = 0
def _kappa_loss(self, coef, X, y):
X_p = np.copy(X)
for i, pred in enumerate(X_p):
if pred < coef[0]:
X_p[i] = 0
elif pred >= coef[0] and pred < coef[1]:
X_p[i] = 1
elif pred >= coef[1] and pred < coef[2]:
X_p[i] = 2
elif pred >= coef[2] and pred < coe... | train["Fam_size"] = train['SibSp'] + train["Parch"] + 1
test["Fam_size"] = test['SibSp'] + test["Parch"] + 1
| Titanic - Machine Learning from Disaster |
14,271,675 | def run_subm(learn=learn, coefficients=[0.5, 1.5, 2.5, 3.5]):
opt = OptimizedRounder()
preds,y = learn.get_preds(DatasetType.Test)
tst_pred = opt.predict(preds, coefficients)
test_df.diagnosis = tst_pred.astype(int)
test_df.to_csv('submission.csv',index=False)
print('done' )<import_modules> | test.duplicated().sum() | Titanic - Machine Learning from Disaster |
14,271,675 | import numpy as np
import pandas as pd
<import_modules> | train.duplicated().sum() | Titanic - Machine Learning from Disaster |
14,271,675 | __all__ = [
'alexnet',
'densenet121', 'densenet169', 'densenet201', 'densenet161',
'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152',
'inceptionv3',
'squeezenet1_0', 'squeezenet1_1',
'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn',
'vgg19_bn', 'vgg19'
]
model_urls = {
'alexnet': 'https://downlo... | y_train = train.Survived
X_train = train.drop(['Survived', 'Ticket' ,'Fare_Range'] , axis=1)
X_test = test.drop([ 'Ticket' ] , axis=1 ) | 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.