kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,493,956 | train_data['cont13_cont4_mul'] = train_data['cont13']*train_data['cont4']
train_data['cont13_cont11_mul'] = train_data['cont13']*train_data['cont11']
train_data['cont13_cont7_mul'] = train_data['cont13']*train_data['cont7']
train_data['cont13_cont2_mul'] = train_data['cont13']*train_data['cont2']
train_data['cont13_con... | df_train = pd.read_csv('/kaggle/input/titanic/train.csv')
df_train.head() | Titanic - Machine Learning from Disaster |
13,493,956 | num_bins = int(1 + np.log2(len(train_data)))
train_data.loc[:,'bins'] = pd.cut(train_data['target'].to_numpy() ,bins=num_bins,labels=False)
features = [f'cont{x}' for x in range(1,15)]
features += [
'cont13_cont4_mul',
'cont13_cont11_mul',
'cont13_cont7_mul',
'cont13_cont2_mul',
'cont13_cont10_mul',
]
target_feature ... | df_train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,493,956 | def rmse_score(y_true, y_pred):
return np.sqrt(mean_squared_error(y_true, y_pred))<init_hyperparams> | df_train['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
13,493,956 | nfolds = 5
seed = 42
lgb_params={'objective':'regression',
'metrics':'rmse',
'boosting':'gbdt',
'min_data_per_group': 5,
'num_leaves': 256,
'max_depth': -1,
'learning_rate': 0.005,
'subsample_for_bin': 200000,
'lambda_l1': 1.074622455507616e-05,
'lambda_l2': 2.0521330798729704e-06,
'n_jobs': -1,
'cat_smooth': 1.0,
'ver... | df_train['Survived'].value_counts() /len(df_train)*100 | Titanic - Machine Learning from Disaster |
13,493,956 | final_preds = np.zeros(test_data.shape[0])
kfold = StratifiedKFold(n_splits=nfolds,random_state=seed)
for f,(train_idx, valid_idx)in enumerate(kfold.split(X=train_data,y=bins)) :
print(f"Fold: {f}")
X_train, X_valid, y_train, y_valid = train_data[train_idx],train_data[valid_idx],target[train_idx],target[valid_idx]
p... | df_train = df_train.drop(['PassengerId','Ticket','Name','Cabin'],axis=1 ) | Titanic - Machine Learning from Disaster |
13,493,956 | sample.target = final_preds.ravel()
sample.to_csv("submission.csv",index=False)
sample.head()<install_modules> | df_train['Sex'].value_counts() /len(df_train)*100 | Titanic - Machine Learning from Disaster |
13,493,956 | !pip install --upgrade xgboost
xgb.__version__<load_from_csv> | df_train[df_train['Survived']==0]['Sex'].value_counts() /len(df_train[df_train['Survived']==0])*100 | Titanic - Machine Learning from Disaster |
13,493,956 | sub = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/sample_submission.csv")
data = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/train.csv")
final_test = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/test.csv" )<train_model> | df_train[df_train['Survived']==1]['Sex'].value_counts() /len(df_train[df_train['Survived']==1])*100 | Titanic - Machine Learning from Disaster |
13,493,956 | print('Training Data')
print(data.isnull().sum())
print()
print()
print('Testing Data')
print(final_test.isnull().sum() )<prepare_x_and_y> | df_train[df_train['Survived']==1]['Pclass'].value_counts() /len(df_train[df_train['Survived']==1])*100 | Titanic - Machine Learning from Disaster |
13,493,956 | columns = final_test.columns[1:]
train = data[columns]
target = data['target']<split> | df_train[df_train['Survived']==0]['Pclass'].value_counts() /len(df_train[df_train['Survived']==0])*100 | Titanic - Machine Learning from Disaster |
13,493,956 | x_train, x_test, y_train, y_test =train_test_split(
train, target, random_state= 2021, test_size = 0.20)
xgb_initial = xgb.XGBRegressor()
xgb_initial.fit(x_train, y_train)
initial_preds = xgb_initial.predict(x_test )<compute_test_metric> | df_train['Family']=df_train['SibSp']+df_train['Parch'] | Titanic - Machine Learning from Disaster |
13,493,956 | mean_squared_error(y_test, initial_preds, squared=False)
<split> | df_train['Embarked'].value_counts() /len(df_train ) | Titanic - Machine Learning from Disaster |
13,493,956 | def objective(trial, X_data = train, Y_data = target):
x_train, x_test, y_train, y_test = train_test_split(
X_data, Y_data, random_state= 2021, test_size = 0.20)
param = {
'tree_method':'gpu_hist',
'predictor': 'gpu_predictor',
'learning_rate': trial.suggest_discrete_uniform('learning_rate',0.01,0.50,0.05),
'colsampl... | df_train[df_train['Survived']==1]['Embarked'].value_counts() /len(df_train[df_train['Survived']==1])*100 | Titanic - Machine Learning from Disaster |
13,493,956 | study = optuna.create_study(direction='minimize')
study.optimize(objective, n_trials= 100 )<train_model> | df_train[df_train['Survived']==0]['Embarked'].value_counts() /len(df_train[df_train['Survived']==0])*100 | Titanic - Machine Learning from Disaster |
13,493,956 | print('Number of finished trials:', len(study.trials))
print('Best trial:', study.best_trial.params)
print('Best objective value:', study.best_value)
<find_best_params> | df_train['Sex'] = pd.get_dummies(df_train['Sex'])
df_train['Age'] = df_train['Age'].fillna(df_train['Age'].median())
df_train['Embarked'] = df_train['Embarked'].map({'C':0,'Q':1,'S':2} ) | Titanic - Machine Learning from Disaster |
13,493,956 | best_trial = study.best_trial.params
best_trial['tree_method'] = 'gpu_hist'
best_trial['predictor'] = 'gpu_predictor'<init_hyperparams> | df_train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,493,956 | best_trial= {'learning_rate': 0.01,
'colsample_bylevel': 0.6100000000000001,
'colsample_bytree': 0.91,
'max_depth': 10,
'subsample': 0.8,
'min_child_weight': 67,
'lambda': 0.012157425362490908,
'alpha': 7.278941365308569e-08,
'random_state': 3000,
'gamma': 1,
'tree_method': 'gpu_hist',
'predictor': 'gpu_predictor'}
<p... | df_train = df_train.dropna() | Titanic - Machine Learning from Disaster |
13,493,956 | final_test = xgb.DMatrix(final_test[columns] )<define_variables> | from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.impute import SimpleImputer
from sklearn.model_selection import train_test_split, cross_validate, GridSearchCV
from sklearn.dummy import DummyClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear... | Titanic - Machine Learning from Disaster |
13,493,956 | train_oof = np.zeros(( 300000,))
test_preds = 0
train_oof.shape<train_model> | X = df_train.drop(['Survived'],axis=1)
y = df_train['Survived']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.2,stratify=y, random_state=42 ) | Titanic - Machine Learning from Disaster |
13,493,956 | NUM_FOLDS=10
kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=0)
fold_rmse =[]
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(train, target))):
train_df, val_df = train.iloc[train_ind][columns], train.iloc[val_ind][columns]
train_target, val_target = target[train_ind], target[val_ind]
train_df = xgb.DMa... | columns = ['Model Name', 'accuracy','precision','recall','ROC AUC score','run time']
results = pd.DataFrame(columns=columns ) | Titanic - Machine Learning from Disaster |
13,493,956 | sub['target'] = test_preds
sub.to_csv('submission2_post_competition.csv', index=False )<split> | def metrics(model_name,y_test,y_pred):
accuracy = accuracy_score(y_test,y_pred)
roc_auc =roc_auc_score(y_test, y_pred)
precision = precision_score(y_pred=y_pred, y_true=y_test,zero_division=1)
recall = recall_score(y_pred=y_pred, y_true=y_test,zero_division=1)
print(classification_report(y_test, y_pred,zero_divisio... | Titanic - Machine Learning from Disaster |
13,493,956 | def objective_2(trial, X_data = train, Y_data = target):
x_train, x_test, y_train, y_test = train_test_split(
X_data, Y_data, random_state= 2021, test_size = 0.20)
param = {
'tree_method':'gpu_hist',
'predictor': 'gpu_predictor',
'learning_rate': 0.01,
'colsample_bylevel': trial.suggest_discrete_uniform('colsample_by... | model_name = 'Dummy'
model = DummyClassifier(strategy='most_frequent')
pipe_dummy = make_pipeline(
SimpleImputer(strategy='median'),
StandardScaler() ,
model)
t0 = time.time()
pipe_dummy.fit(X_train,y_train)
t1 = time.time() - t0
y_pred = pipe_dummy.predict(X_test)
print('time to run in seconds: ',format(t1))
resu... | Titanic - Machine Learning from Disaster |
13,493,956 | study_2 = optuna.create_study(direction='minimize')
study_2.optimize(objective_2, n_trials= 100 )<train_model> | model_name = 'Naive Bayes'
NB = GaussianNB()
params_NB = {'var_smoothing': np.logspace(0,-9, num=100)}
grid = GridSearchCV(estimator=NB, param_grid=params_NB, cv=5)
grid = grid.fit(X_train,y_train)
model = grid.best_estimator_
pipe_NB = make_pipeline(
SimpleImputer(strategy='median'),
StandardScaler() ,
model)
t0 =... | Titanic - Machine Learning from Disaster |
13,493,956 | print('Number of finished trials:', len(study_2.trials))
print('Best trial:', study_2.best_trial.params)
print('Best objective value:', study_2.best_value)
<find_best_params> | model_name = 'Logistic Regression'
param_grid = [{'penalty' : ['l1', 'l2'],
'C' : np.logspace(0, 4, 10),
'solver' : ['liblinear']}]
LR = LogisticRegression()
grid = GridSearchCV(estimator=LR, param_grid=param_grid, cv=5)
grid = grid.fit(X_train,y_train)
model = grid.best_estimator_
pipe_LR = make_pipeline(
SimpleImp... | Titanic - Machine Learning from Disaster |
13,493,956 | best_trial_2 = study_2.best_trial.params
best_trial_2['tree_method'] = 'gpu_hist'
best_trial_2['predictor'] = 'gpu_predictor'
best_trial_2['learning_rate'] = 0.01<define_variables> | model_name = 'kNN'
knn = KNeighborsClassifier()
param_grid = {'n_neighbors': [3, 5, 7, 9, 11],
'weights': ['uniform', 'distance']
}
grid = GridSearchCV(estimator=knn, param_grid=param_grid, cv=5)
grid = grid.fit(X_train,y_train)
model = grid.best_estimator_
pipe_kNN = make_pipeline(
SimpleImputer(strategy='median'),... | Titanic - Machine Learning from Disaster |
13,493,956 | train_oof = np.zeros(( 300000,))
test_preds_2 = 0
train_oof.shape<init_hyperparams> | model_name = 'Random Forest'
rfc=RandomForestClassifier(random_state=1234)
param_grid = {'n_estimators': [100,200],
'max_features': ['auto', 'sqrt', 'log2'],
'max_depth' : [5,10,15,20,25,50],
'criterion' :['gini', 'entropy']}
grid = GridSearchCV(estimator=rfc, param_grid=param_grid, cv= 5)
grid = grid.fit(X_train,y_t... | Titanic - Machine Learning from Disaster |
13,493,956 | best_trial_2 = {'colsample_bylevel': 0.91,
'colsample_bytree': 0.6100000000000001,
'max_depth': 10,
'subsample': 0.5,
'min_child_weight': 21,
'lambda': 2.4118345076896113e-05,
'alpha': 3.234942680594196e-08,
'random_state': 3000,
'gamma': 1.51,
'tree_method': 'gpu_hist',
'predictor': 'gpu_predictor',
'learning_rate': 0... | df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
df_test.head() | Titanic - Machine Learning from Disaster |
13,493,956 | NUM_FOLDS=10
kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=0)
fold_rmse_2 =[]
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(train, target))):
train_df, val_df = train.iloc[train_ind][columns], train.iloc[val_ind][columns]
train_target, val_target = target[train_ind], target[val_ind]
train_df = xgb.D... | df_test.isnull().sum() | Titanic - Machine Learning from Disaster |
13,493,956 | sub['target'] = test_preds_2
sub.to_csv('submission3_post_competition.csv', index=False )<install_modules> | passengerId = df_test['PassengerId']
df_test['Family'] = df_test['SibSp'] + df_test['Parch']
df_test = df_test.drop(['Cabin','Name','Ticket','PassengerId'],axis=1 ) | Titanic - Machine Learning from Disaster |
13,493,956 | !pip install tensorflow_addons==0.9.1<set_options> | df_test['Age'] = df_test['Age'].fillna(df_test['Age'].median())
df_test['Fare'] = df_test['Fare'].fillna(df_test['Fare'].median() ) | Titanic - Machine Learning from Disaster |
13,493,956 | warnings.simplefilter('ignore')
warnings.filterwarnings('ignore')
pd.set_option('display.max_columns', 1000)
pd.set_option('display.max_rows', 500 )<define_variables> | df_test['Embarked'] = df_test['Embarked'].map({'C':0,'Q':1,'S':2})
df_test['Sex'] = pd.get_dummies(df_test['Sex'] ) | Titanic - Machine Learning from Disaster |
13,493,956 | EPOCHS = 180
NNBATCHSIZE = 16
GROUP_BATCH_SIZE = 4000
SEED = 321
LR = 0.001
SPLITS = 5
def seed_everything(seed):
random.seed(seed)
np.random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
tf.random.set_seed(seed )<load_from_csv> | prediction = []
for i in range(len(df_test)) :
test = pipe_rfc.predict([df_test.loc[i]])
prediction.append(test ) | Titanic - Machine Learning from Disaster |
13,493,956 | def read_data() :
train_data = pd.read_csv('.. /input/data-without-drift/train_clean.csv')
clean_train = pd.read_csv('.. /input/liverpool-noiseremoval/clean_train_signal.csv')
train_oofs = pd.read_csv('.. /input/liverpool-lgbm-oofs/oofs_train.csv')
test_data = pd.read_csv('.. /input/data-without-drift/test_clean.csv... | prediction = pd.DataFrame(prediction, columns = ['Survived'] ) | Titanic - Machine Learning from Disaster |
13,493,956 | train_or = pd.read_csv('/kaggle/input/liverpool-ion-switching/train.csv')
sub = pd.read_csv('submission_wavenet.csv')
sub[700000:800000]['open_channels']=sub[700000:800000]['open_channels'].values + train_or[4000000:4100000]['open_channels'].values
sub.to_csv('final_submission_wavenet.csv', index=False, float_format=... | test_data_predictions = pd.concat([passengerId,prediction],axis=1 ) | Titanic - Machine Learning from Disaster |
13,493,956 | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
<define_search_space> | test_data_predictions.to_csv('Titanic_survivor_prediction.csv',index=False ) | Titanic - Machine Learning from Disaster |
13,493,956 | seed = 42
test_size = 0.2
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
workspace = "./unet"
backbone = [1, 1, 1, 1]
encoder_channels = np.array([64, 128, 256, 512, 1024])*2
decoder_channels = np.array([512, 256, 128, 64])*2
fold = 0
time_step = 4000
time_step_test = 10000
stride = 2
batch_si... | pd.read_csv('Titanic_survivor_prediction.csv' ) | Titanic - Machine Learning from Disaster |
13,407,215 | train = pd.read_csv('/kaggle/input/liverpool-ion-switching/train.csv')
test = pd.read_csv('/kaggle/input/liverpool-ion-switching/test.csv')
sample = pd.read_csv('/kaggle/input/liverpool-ion-switching/sample_submission.csv' )<define_variables> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
train_data.head() | Titanic - Machine Learning from Disaster |
13,407,215 | def make_batch(df, batchsize=500000):
batches = df.shape[0] // batchsize
df['batch'] = 0
for i in range(batches):
idx = np.arange(i*batchsize,(i+1)*batchsize)
df.loc[idx, 'batch'] = i + 1
return df<define_variables> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
13,407,215 | train = make_batch(train)
test = make_batch(test, batchsize=500000)
train.groupby('batch')['signal'].describe()<define_variables> | data = [train_data, test_data]
for dataset in data:
mean = train_data['Age'].mean()
dataset['Age'].fillna(mean, inplace = True)
dataset["Age"] = dataset["Age"].astype(int)
| Titanic - Machine Learning from Disaster |
13,407,215 |
<split> | for dataset in data:
dataset['relatives'] = dataset['SibSp'] + dataset['Parch']
dataset.loc[dataset['relatives'] > 0, 'relatives'] = 1
dataset.loc[dataset['relatives'] == 0, 'relatives'] = 0 | Titanic - Machine Learning from Disaster |
13,407,215 | train_segm_separators = np.concatenate([[0,500000,600000], np.arange(1000000,5000000+1,500000)])
train_segm_signal_groups = [0,0,0,1,2,4,3,1,2,3,4]
train_segm_is_shifted = [False, True, False, False, False, False, False, True, True, True, True]
train_signal = np.split(train['signal'].values, train_segm_separators[1:-1... | for dataset in data:
dataset['Embarked'].fillna("S", inplace = True ) | Titanic - Machine Learning from Disaster |
13,407,215 | test_segm_separators = np.concatenate([np.arange(0,1000000+1,100000), [1500000,2000000]])
test_segm_signal_groups = [0,2,3,0,1,4,3,4,0,2,0,0]
test_segm_is_shifted = [True, True, False, False, True, False, True, True, True, False, True, False]
test_signal = np.split(test['signal'].values, test_segm_separators[1:-1] )<t... | women = train_data.loc[train_data.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
print("女性生还率:", rate_women)
men = train_data.loc[train_data.Sex == 'male']["Survived"]
rate_men = sum(men)/len(men)
print("男性生还率:", rate_men ) | Titanic - Machine Learning from Disaster |
13,407,215 | <concatenate><EOS> | y = train_data["Survived"]
features = ["Pclass", "Sex", "Age", "Embarked", "relatives"]
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=1)
model.fit(X, y)
predictions = model.predict(X_test)
output = pd... | Titanic - Machine Learning from Disaster |
13,430,729 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | pip install -U lightautoml | Titanic - Machine Learning from Disaster |
13,430,729 | test_signal_shift_clean = []
test_signal_detrend = []
test_remove_shift = [True, True, False, False, True, False, True, True, True, False, True, False]
for data, use_fit, signal in zip(test_signal_shift, test_segm_is_shifted, test_signal):
if use_fit:
data_x = np.arange(len(data), dtype=float)* window_size + window_siz... | import os
import time
import re
import numpy as np
import pandas as pd
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
import torch
from lightautoml.automl.presets.tabular_presets import TabularAutoML, TabularUtilizedAutoML
from lightautoml.dataset.roles import DatetimeRo... | Titanic - Machine Learning from Disaster |
13,430,729 | test_signal = np.ndarray(0)
for arr in test_signal_detrend:
test_signal = np.append(test_signal, arr )<split> | N_THREADS = 4
N_FOLDS = 5
RANDOM_STATE = 42
TEST_SIZE = 0.2
TIMEOUT = 600 | Titanic - Machine Learning from Disaster |
13,430,729 | train_time = train['time'][:].values
test_time = test['time'][:].values<drop_column> | np.random.seed(RANDOM_STATE)
torch.set_num_threads(N_THREADS ) | Titanic - Machine Learning from Disaster |
13,430,729 | train = train.drop(['signal'], axis=1)
test = test.drop(['signal'], axis=1 )<groupby> | %%time
train_data = pd.read_csv('.. /input/titanic/train.csv')
train_data.head() | Titanic - Machine Learning from Disaster |
13,430,729 | def data_filter(data, time, signal, sigm=6, batchsize=500000):
mean_std, cut_off, lower, upper, filtered_signal, filtered_time = [], [], [], [], [], []
for x, y in zip(data.groupby('batch')['signal'].agg('mean'), data.groupby('batch')['signal'].agg('std')) :
mean_std.append(( x, y))
for i in range(len(mean_std)) :
lowe... | test_data = pd.read_csv('.. /input/titanic/test.csv')
test_data.head() | Titanic - Machine Learning from Disaster |
13,430,729 | train['signal'] = train_signal
test['signal'] = test_signal<split> | submission = pd.read_csv('.. /input/titanic/gender_submission.csv')
submission.head() | Titanic - Machine Learning from Disaster |
13,430,729 | train_time, train_signal = data_filter(train, train_time, train_signal)
test_time, test_signal = data_filter(test, test_time, test_signal, sigm=6, batchsize=500000 )<prepare_x_and_y> | def get_title(name):
title_search = re.search('([A-Za-z]+)\.', name)
if title_search:
return title_search.group(1)
return ""
def create_extra_features(data):
data['Ticket_type'] = data['Ticket'].map(lambda x: x[0:3])
data['Name_Words_Count'] = data['Name'].map(lambda x: len(x.split()))
data['Has_Cabin'] = data["Cabi... | Titanic - Machine Learning from Disaster |
13,430,729 | def interpol(time, signal):
if len(time)> 2000000:
LENA =(0.0001, 500.0001, 0.0001)
elif(len(time)> 500000)and(len(time)< 2000000):
LENA =(500.0001, 700.0001, 0.0001)
else:
LENA =(350.0001, 400.0001, 0.0001)
y = np.array(signal[:])
x = np.array(time[:])
f = interpolate.interp1d(x, y)
new_time = np.arange(*LENA)
... | tr_data, te_data = train_test_split(train_data,
test_size=TEST_SIZE,
stratify=train_data['Survived'],
random_state=RANDOM_STATE)
print('Data splitted.Parts sizes: tr_data = {}, te_data = {}'.format(tr_data.shape, te_data.shape)) | Titanic - Machine Learning from Disaster |
13,430,729 | train = train.drop(['signal', 'time'], axis=1)
test = test.drop(['signal', 'time'], axis=1)
train['time'], train_signal = interpol(train_time, train_signal)
test['time'], test_signal = interpol(test_time, test_signal)
train['signal'] = train_signal
test['signal'] = test_signal<import_modules> | %%time
def acc_score(y_true, y_pred, **kwargs):
return accuracy_score(y_true,(y_pred > 0.5 ).astype(int), **kwargs)
task = Task('binary', metric = acc_score ) | Titanic - Machine Learning from Disaster |
13,430,729 | from scipy.signal import butter,filtfilt<init_hyperparams> | %%time
roles = {
'target': 'Survived',
'drop': ['PassengerId', 'Name','Ticket'],
} | Titanic - Machine Learning from Disaster |
13,430,729 | T = 5.0
fs = 30.0
cutoff = 2
nyq = 0.5 * fs
order = 2
n = int(T * fs )<split> | %%time
automl = TabularAutoML(task = task,
timeout = TIMEOUT,
cpu_limit = N_THREADS,
general_params = {'use_algos': [['linear_l2', 'lgb', 'lgb_tuned']]},
reader_params = {'n_jobs': N_THREADS})
oof_pred = automl.fit_predict(tr_data, roles = roles)
print('oof_pred:
{}
Shape = {}'.format(oof_pred[:10], oof_pred.shape)) | Titanic - Machine Learning from Disaster |
13,430,729 | def butter_lowpass_filter(data, cutoff, fs, order):
normal_cutoff = cutoff / nyq
b, a = butter(order, normal_cutoff, btype='low', analog=False)
y = filtfilt(b, a, data)
return y<define_variables> | %%time
test_pred = automl.predict(te_data)
print('Prediction for test data:
{}
Shape = {}'.format(test_pred[:10], test_pred.shape))
print('Check scores...')
print('OOF score: {}'.format(acc_score(tr_data['Survived'].values, oof_pred.data[:, 0])))
print('TEST score: {}'.format(acc_score(te_data['Survived'].values, te... | Titanic - Machine Learning from Disaster |
13,430,729 | seventh_batch_time, seventh_batch_signal = [x/10000 for x in range(3500001, 4000001, 1)], list(train_signal[3500000:4000000] )<define_variables> | %%time
automl = TabularUtilizedAutoML(task = task,
timeout = TIMEOUT,
cpu_limit = N_THREADS,
general_params = {'use_algos': [['linear_l2', 'lgb', 'lgb_tuned']]},
reader_params = {'n_jobs': N_THREADS})
oof_pred = automl.fit_predict(tr_data, roles = roles)
print('oof_pred:
{}
Shape = {}'.format(oof_pred[:10], oof_pred.... | Titanic - Machine Learning from Disaster |
13,430,729 | poper = 0
for i in range(1, 499999):
if(train_signal[i+3500000] > 2.2)or(train_signal[i+3500000] < -3.8):
seventh_batch_time.pop(i-poper)
seventh_batch_signal.pop(i-poper)
poper += 1<feature_engineering> | %%time
test_pred = automl.predict(te_data)
print('Prediction for test data:
{}
Shape = {}'.format(test_pred[:10], test_pred.shape))
print('Check scores...')
print('OOF score: {}'.format(acc_score(tr_data['Survived'].values, oof_pred.data[:, 0])))
print('TEST score: {}'.format(acc_score(te_data['Survived'].values, te... | Titanic - Machine Learning from Disaster |
13,430,729 | _, seventh_batch_signal = interpol(seventh_batch_time, seventh_batch_signal )<feature_engineering> | %%time
automl = TabularUtilizedAutoML(task = task,
timeout = TIMEOUT,
cpu_limit = N_THREADS,
general_params = {'use_algos': [['linear_l2', 'lgb', 'lgb_tuned']]},
reader_params = {'n_jobs': N_THREADS})
oof_pred = automl.fit_predict(train_data, roles = roles)
print('oof_pred:
{}
Shape = {}'.format(oof_pred[:10], oof_pr... | Titanic - Machine Learning from Disaster |
13,430,729 | train_signal[3500000:4000000] = seventh_batch_signal[:]<drop_column> | %%time
test_pred = automl.predict(test_data)
print('Prediction for test data:
{}
Shape = {}'.format(test_pred[:10], test_pred.shape))
print('Check scores...')
print('OOF score: {}'.format(acc_score(train_data['Survived'].values, oof_pred.data[:, 0])) ) | Titanic - Machine Learning from Disaster |
13,430,729 | <normalization><EOS> | submission['Survived'] =(test_pred.data[:, 0] > 0.5 ).astype(int)
submission.to_csv('automl_utilized_600.csv', index = False ) | Titanic - Machine Learning from Disaster |
6,144,784 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<data_type_conversions> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import random
from keras.models import Sequential
from keras.layers.core import Dense
from keras.optimizers import adam
from keras.wrappers.scikit_learn import KerasClassifier
from sklearn.model_selection import GridSearchCV
fr... | Titanic - Machine Learning from Disaster |
6,144,784 | class IonDataset(Dataset):
def __init__(self, data, labels=None, type='train', transform=None):
self.data = data
self.labels = labels
self.type = type
self.transform = transform
def __getitem__(self, i):
signal = self.data[i].astype(np.float32)
if self.type == 'train':
label = self.labels[i].astype(np.int64)
if self.... | train_titanic = pd.read_csv(".. /input/titanic/train.csv")
real_test_titanic = pd.read_csv(".. /input/titanic/test.csv")
| Titanic - Machine Learning from Disaster |
6,144,784 | class SEModule(nn.Module):
def __init__(self, in_channels, reduction=4):
super().__init__()
self.conv1 = nn.Conv1d(in_channels, in_channels//reduction, kernel_size=1, padding=0)
self.conv2 = nn.Conv1d(in_channels//reduction, in_channels, kernel_size=1, padding=0)
def forward(self, x):
s = F.adaptive_avg_pool1d(x, 1)
... | train_titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
6,144,784 | class ClassificationMeter:
def __init__(self, nCls, eps=1e-5, names=None):
self.nCls = nCls
self.names = names
self.eps = eps
self.N = 0
self.table = np.zeros(( self.nCls, 4), dtype=np.int32)
self._measure = None
def clear(self):
self.N = 0
self.table = np.zeros(( self.nCls, 4), dtype=np.int32)
def prepare_inputs(s... | randomvalue = [i for i in range(age_sd,age_mean)]
for _ in range(train_titanic.isnull().sum().Age):
number_to_insert = choice(randomvalue)
train_titanic['Age'].fillna(number_to_insert, inplace = True ) | Titanic - Machine Learning from Disaster |
6,144,784 | if TRAIN:
batch = 1; a = 500000*(batch-1); b = 500000*batch
batch = 2; c = 500000*(batch-1); d = 500000*batch
X_train_1s = np.concatenate([train.signal.values[a:b],train.signal.values[c:d]] ).reshape(( -1,1))
y_train_1s = np.concatenate([train.open_channels.values[a:b],train.open_channels.values[c:d]] ).reshape(( -1,1)... | train_titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
6,144,784 | if PREDICT:
sub = pd.read_csv(".. /input/liverpool-ion-switching/sample_submission.csv", dtype={'time':str})
predictors = {}
for num_classes, model_name in zip(
np.array([1, 1, 3, 5, 10])+1,
['1s', '1f', '3', '5', '10']
):
if not ENSEMBLE:
models = [Unet(num_classes=num_classes),]
predictor = Predictor(device, model... | print("The most frequent value in 'Embarked' column is :", train_titanic['Embarked'].value_counts().idxmax() ) | Titanic - Machine Learning from Disaster |
6,144,784 | import pandas as pd
import numpy as np
from cuml.ensemble import RandomForestRegressor
from sklearn.pipeline import make_pipeline
from sklearn.base import BaseEstimator, TransformerMixin
import cudf<prepare_x_and_y> | train_titanic['Embarked'] = train_titanic['Embarked'].fillna(train_titanic['Embarked'].value_counts().idxmax())
train_titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
6,144,784 | class ShiftedFeatureMaker(BaseEstimator, TransformerMixin):
def __init__(self, periods=[1], column="signal", add_minus=False, fill_value=None, copy=True):
self.periods = periods
self.column = column
self.add_minus = add_minus
self.fill_value = fill_value
self.copy = copy
def fit(self, X, y):
return self
def transform... | real_test_titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
6,144,784 | %%time
shifted_rfc = make_pipeline(
ShiftedFeatureMaker(
periods=range(1, 20),
add_minus=True,
fill_value=0
),
ColumnDropper(
columns=["open_channels", "time" ]
),
RandomForestRegressor(
n_estimators=150,
max_depth=19,
max_features=10,
split_algo=0,
bootstrap=False
)
)
train, test = read_input()
train, test = a... | age_mean_test = int(( round(real_test_titanic['Age'].mean() ,2)))
age_sd_test = int(round(real_test_titanic['Age'].std() ,2))
randomvalue = [i for i in range(age_sd_test,age_mean_test)]
for _ in range(real_test_titanic.isnull().sum().Age):
number_to_insert = choice(randomvalue)
real_test_titanic['Age'].fillna(number_... | Titanic - Machine Learning from Disaster |
6,144,784 | !pip install tensorflow_addons==0.9.1<import_modules> | real_test_titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
6,144,784 | Add, AveragePooling1D, Multiply, GRU, GRUCell, LSTMCell, SimpleRNNCell, SimpleRNN, TimeDistributed, RNN,
RepeatVector, Conv1D, MaxPooling1D, Concatenate, GlobalAveragePooling1D, UpSampling1D)
warnings.simplefilter('ignore')
warnings.filterwarnings('ignore')
pd.set_option('display.max_columns', 1000)
pd.set_option('... | real_test_titanic['Fare'] = real_test_titanic['Fare'].fillna(int(real_test_titanic['Fare'].mean())) | Titanic - Machine Learning from Disaster |
6,144,784 | def plot_cm(y_true, y_pred, title):
figsize=(14,14)
y_pred = y_pred.astype(int)
cm = confusion_matrix(y_true, y_pred, labels=np.unique(y_true))
cm_sum = np.sum(cm, axis=1, keepdims=True)
cm_perc = cm / cm_sum.astype(float)* 100
annot = np.empty_like(cm ).astype(str)
nrows, ncols = cm.shape
for i in range(nrows):
fo... | real_test_titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
6,144,784 | def Classifier(shape_):
def wave_block(x, filters, kernel_size, n):
dilation_rates = [2**i for i in range(n)]
x = Conv1D(filters = filters,
kernel_size = 1,
padding = 'same' )(x)
res_x = x
for dilation_rate in dilation_rates:
tanh_out = Conv1D(filters = filters,
kernel_size = kernel_size,
padding = 'same',
activation ... | total_passengers = train_titanic['Sex'].count()
total_males = train_titanic['Sex'].value_counts() ['male']
total_females = train_titanic['Sex'].value_counts() ['female']
survived_males = train_titanic.query('Survived==1')['Sex'].value_counts() ['male']
survived_females = train_titanic.query('Survived==1')['Sex'].value_... | Titanic - Machine Learning from Disaster |
6,144,784 | EPOCHS = 70
NNBATCHSIZE = 16
GROUP_BATCH_SIZE = 4000
SEED = 321
LR = 0.001
SPLITS = 5
SLIDE = 800
seed_everything(SEED )<load_from_csv> | train_titanic = train_titanic.drop(['Ticket', 'Cabin','Name'], axis=1)
real_test_titanic = real_test_titanic.drop(['Ticket', 'Cabin','Name'], axis=1 ) | Titanic - Machine Learning from Disaster |
6,144,784 | train = pd.read_csv("/kaggle/input/remove-trends-giba/train_clean_giba.csv", usecols=["signal","open_channels"], dtype={'signal': np.float32, 'open_channels':np.int32})
test = pd.read_csv("/kaggle/input/remove-trends-giba/test_clean_giba.csv", usecols=["signal"], dtype={'signal': np.float32})
train['group'] = np.aran... | train_survived = train_titanic['Survived'] | Titanic - Machine Learning from Disaster |
6,144,784 | train["mlp"] = np.load("/kaggle/input/into-the-wild-mlp-regression/mlp_reg.npz")['valid']
test["mlp"] = np.load("/kaggle/input/into-the-wild-mlp-regression/mlp_reg.npz")['test']
train["lgb"] = np.load("/kaggle/input/into-the-wild-lgb-regression/lgb_reg.npz")['valid']
test["lgb"] = np.load("/kaggle/input/into-the-wild-l... | train_titanic['Sex'] = train_titanic['Sex'].map({'female': 0, 'male': 1} ).astype(int)
train_titanic['Embarked'] = train_titanic['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int ) | Titanic - Machine Learning from Disaster |
6,144,784 | for item in ['signal','mlp','lgb']:
if item in train.columns:
print(item)
train_input_mean = train[item].mean()
train_input_sigma = train[item].std()
train[item]=(train[item] - train_input_mean)/ train_input_sigma
test[item] =(test[item] - train_input_mean)/ train_input_sigma
train['batch'] = train.groupby(train.index... | real_test_titanic['Sex'] = real_test_titanic['Sex'].map({'female': 0, 'male': 1} ).astype(int)
real_test_titanic['Embarked'] = real_test_titanic['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int ) | Titanic - Machine Learning from Disaster |
6,144,784 | def run_cv_model_by_batch(train, test, n_splits, feats, nn_epochs, nn_batch_size):
seed_everything(SEED)
K.clear_session()
config = tf.compat.v1.ConfigProto(intra_op_parallelism_threads=1,inter_op_parallelism_threads=1)
sess = tf.compat.v1.Session(graph=tf.compat.v1.get_default_graph() , config=config)
tf.compat.v1.... | train_titanic = train_titanic.set_index('PassengerId')
real_test_titanic = real_test_titanic.set_index('PassengerId' ) | Titanic - Machine Learning from Disaster |
6,144,784 | preds, oof, oof_tta = run_cv_model_by_batch(train, test, n_splits=5, feats=feats, nn_epochs=EPOCHS, nn_batch_size=NNBATCHSIZE )<compute_test_metric> | X = train_titanic.drop(['Survived'], axis = 1)
y = train_titanic["Survived"]
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size = 0.10)
print("Dimension of Train data :", x_train.shape)
print("Dimension of Test data :", x_test.shape ) | Titanic - Machine Learning from Disaster |
6,144,784 | oof_df = train[['signal','open_channels']].copy()
oof_df["oof"] = np.argmax(oof+oof_tta, axis=1)
oof_df = oof_df.head(5000_000)
gc.collect()
oof_f1 = f1_score(oof_df['open_channels'],oof_df['oof'],average = 'macro')
oof_recall = recall_score(oof_df['open_channels'],oof_df['oof'],average = 'macro')
oof_precision = p... | scaler = MinMaxScaler()
x_train_scaled = scaler.fit_transform(x_train)
x_test_scaled = scaler.transform(x_test ) | Titanic - Machine Learning from Disaster |
6,144,784 | np.savez_compressed(f'wavenet.npz',valid=oof, test=preds,tta=oof_tta )<save_to_csv> | mlp_model = MLPClassifier(hidden_layer_sizes=(150,150,150),activation ='relu', max_iter=500, alpha=0.0001,
solver='sgd', verbose=10, learning_rate = 'adaptive', momentum=0.9)
mlp_model.fit(x_train_scaled, y_train)
y_pred = mlp_model.predict(x_test_scaled)
| Titanic - Machine Learning from Disaster |
6,144,784 | sample_submission = pd.read_csv('/kaggle/input/liverpool-ion-switching/sample_submission.csv', dtype={'time': np.float32})
sample_submission['open_channels'] = np.argmax(preds, axis=1 ).astype(int)
sample_submission.to_csv(f'submission.csv', index=False, float_format='%.4f')
print(sample_submission.open_channels.mea... | confusion = confusion_matrix(y_test, y_pred)
print('Confusion Matrix
', confusion)
print('Accuracy: {:.2f}'.format(accuracy_score(y_test, y_pred)) ) | Titanic - Machine Learning from Disaster |
6,144,784 | df = pd.read_csv("/kaggle/input/remove-trends-giba/train_clean_giba.csv", usecols=["signal","open_channels"], dtype={'signal': np.float32, 'open_channels':np.int32})
test_df = pd.read_csv("/kaggle/input/remove-trends-giba/test_clean_giba.csv", usecols=["signal"], dtype={'signal': np.float32})
df.shape, test_df.shape<... | classifier = MLPClassifier()
parameter_space = {
'hidden_layer_sizes': [(50,50,50),(100,100,100),(150,150,150),(200,200,200)],
'activation': ['tanh', 'relu', 'logistic'],
'solver': ['sgd', 'adam'],
'alpha': [0.0001, 0.05],
'learning_rate': ['constant','adaptive'],
} | Titanic - Machine Learning from Disaster |
6,144,784 | df['group'] = np.arange(df.shape[0])//500_000
aug_df = df[df["group"] == 5].copy()
aug_df["group"] = 10
for col in ["signal", "open_channels"]:
aug_df[col] += df[df["group"] == 8][col].values
df = df.append(aug_df, sort=False ).reset_index(drop=True)
df.shape
del aug_df
gc.collect()<feature_engineering> | model = GridSearchCV(classifier, parameter_space, n_jobs=-1, cv=3)
model.fit(x_train_scaled, y_train ) | Titanic - Machine Learning from Disaster |
6,144,784 | wavenet_oof =(np.load("/kaggle/input/into-the-wild-wavenet/wavenet.npz")["valid"] + np.load("/kaggle/input/into-the-wild-wavenet/wavenet.npz")["tta"])/2
wavenet_test = np.load("/kaggle/input/into-the-wild-wavenet/wavenet.npz")["test"]
for i in range(wavenet_oof.shape[1]):
df["prob_{}".format(i)] = wavenet_oof[:, i]
tes... | print('Best parameters calculated :', model.best_params_ ) | Titanic - Machine Learning from Disaster |
6,144,784 | def get_margin(x):
return np.log(x)
M = get_margin(wavenet_oof)
M_test = get_margin(wavenet_test )<import_modules> | predicted_y = model.predict(x_test_scaled)
| Titanic - Machine Learning from Disaster |
6,144,784 | f1_score(df["open_channels"], df["wave_pred"], average="macro" )<compute_test_metric> | confusion = confusion_matrix(y_test, predicted_y)
print('Confusion Matrix after hyperparameter optimization
', confusion)
print('Accuracy after hyperparameter optimization: {:.2f}'.format(accuracy_score(y_test, predicted_y)) ) | Titanic - Machine Learning from Disaster |
6,144,784 | log_loss(df["open_channels"], wavenet_oof )<feature_engineering> | layer1 = Dense(units = 10,activation = 'relu', input_dim = 7)
layer2 = Dense(units = 15, activation = 'relu')
layer3 = Dense(units = 2, activation = 'sigmoid')
model = Sequential([layer1, layer2, layer3])
model.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])
clf = mode... | Titanic - Machine Learning from Disaster |
6,144,784 | NUM_FOLDS = 5
df["mg"] = df.index//100_000
test_df["mg"] = test_df.index//100_000
df["fold"] = df["mg"] % NUM_FOLDS<categorify> | predicted_on_test = model.predict_classes(x_test_scaled, batch_size = 25)
confusion = confusion_matrix(y_test, predicted_on_test)
print('Confusion Matrix
', confusion)
print('Accuracy: {:.2f}'.format(accuracy_score(y_test, predicted_on_test)) ) | Titanic - Machine Learning from Disaster |
6,144,784 | for data in [df, test_df]:
y_time_since = np.empty(( data.shape[0], 11))
y_time_till = np.empty(( data.shape[0], 11))
y_pred = data["wave_pred"].values
for sec in range(data.shape[0]//100_000):
begin, end = sec*100_000,(sec+1)*100_000
last_seen = np.array([np.nan]*11)
for index in range(begin, end):
y_time_since[index... | real_test_titanic_scaled = scaler.transform(real_test_titanic ) | Titanic - Machine Learning from Disaster |
6,144,784 | features = ["signal", "noise",
"prob_0", "prob_1", "prob_2", "prob_3", "prob_4", "prob_5", "prob_6", "prob_7", "prob_8", "prob_9", "prob_10"]
for i in range(11):
f = "time_since_{}".format(i)
features.append(f)
f = "time_till_{}".format(i)
features.append(f )<prepare_x_and_y> | predicted_on_actual = model.predict_classes(real_test_titanic_scaled, batch_size = 25 ) | Titanic - Machine Learning from Disaster |
6,144,784 | <compute_test_metric><EOS> | actual_test = pd.read_csv(".. /input/titanic/test.csv")
for_submission = pd.DataFrame({"PassengerId": actual_test['PassengerId'],
"Survived":predicted_on_actual.astype(int)})
for_submission.to_csv("prediction_file_by_arunjith.csv",index=False ) | Titanic - Machine Learning from Disaster |
11,217,180 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<compute_test_metric> | !/opt/conda/bin/python3.7 -m pip install --upgrade pip
!pip uninstall -y typing
!pip install carefree-learn | Titanic - Machine Learning from Disaster |
11,217,180 | df["xgb_pred"] = np.argmax(y_oof, axis=1)
f1_score(df["open_channels"], df["xgb_pred"], average="macro" )<compute_train_metric> |
file_folder = "/kaggle/input/titanic"
working_folder = "/kaggle/working" | Titanic - Machine Learning from Disaster |
11,217,180 | f1_score(df.iloc[:5_000_000]["open_channels"], df.iloc[:5_000_000]["xgb_pred"], average="macro" )<feature_engineering> | def scoring(raw_metrics, mean, std):
return mean + std
def test() :
train_file = f"{file_folder}/train.csv"
test_file = f"{file_folder}/test.csv"
data_config = {"label_name": "Survived"}
hpo = cflearn.tune_with(
train_file,
model="tree_dnn",
temp_folder=f"{working_folder}/__hpo__",
task_type=TaskTypes.CLASSIFICATION,
... | Titanic - Machine Learning from Disaster |
11,217,180 | df["ensemble_pred"] = df[["wave_pred", "xgb_pred"]].max(axis=1)
f1_score(df["open_channels"], df["ensemble_pred"], average="macro" )<compute_test_metric> | experiments = results.experiments
ms = {k: list(map(cflearn.load_task, v)) for k, v in experiments.tasks.items() }
print(ms ) | Titanic - Machine Learning from Disaster |
11,217,180 | f1_score(df.iloc[:5_000_000]["open_channels"], df.iloc[:5_000_000]["ensemble_pred"], average="macro" )<feature_engineering> | model = ms["tree_dnn"][0].model
data = model.tr_data
print("=== Raw ===")
print(f"Feature dimension : {len(data.raw.x[0])}")
print()
for line in data.raw.x[:3]:
print(line)
print(data.raw.y[:3])
print()
print("=== Converted ===")
print(f"Feature dimension : {data.converted.x.shape[1]}")
print(data.converted.x[:3]... | Titanic - Machine Learning from Disaster |
11,217,180 | <save_to_csv><EOS> | print(model.encoders ) | Titanic - Machine Learning from Disaster |
972,273 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<predict_on_test> | import csv
import re
import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.python.framework import ops
from sklearn import preprocessing
from sklearn.model_selection import train_test_split | 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.