kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
5,201,782 | train_cfg = cfg["train_data_loader"]
rasterizer = build_rasterizer(cfg, dm)
train_zarr = ChunkedDataset(dm.require(train_cfg["key"])).open()
train_dataset = AgentDataset(cfg, train_zarr, rasterizer)
train_dataloader = DataLoader(train_dataset, shuffle=train_cfg["shuffle"], batch_size=train_cfg["batch_size"],
num_work... | display(data_train.SibSp.value_counts(dropna=False ).sort_index())
display(data_test.SibSp.value_counts(dropna=False ).sort_index() ) | Titanic - Machine Learning from Disaster |
5,201,782 | test_cfg = cfg["test_data_loader"]
rasterizer = build_rasterizer(cfg, dm)
test_zarr = ChunkedDataset(dm.require(test_cfg["key"])).open()
test_mask = np.load(f"{DIR_INPUT}/scenes/mask.npz")["arr_0"]
test_dataset = AgentDataset(cfg, test_zarr, rasterizer, agents_mask=test_mask)
test_dataloader = DataLoader(test_dataset... | display(data_train.Parch.value_counts(dropna=False ).sort_index())
display(data_test.Parch.value_counts(dropna=False ).sort_index() ) | Titanic - Machine Learning from Disaster |
5,201,782 | class LyftMultiModel(nn.Module):
def __init__(self, cfg: Dict, num_modes=3):
super().__init__()
architecture = cfg["model_params"]["model_architecture"]
backbone = eval(architecture )(pretrained=True, progress=True)
self.backbone = backbone
num_history_channels =(cfg["model_params"]["history_num_frames"] + 1)* 2
num_i... | display(data_train.Embarked.value_counts(dropna=False ).sort_index())
display(data_test.Embarked.value_counts(dropna=False ).sort_index() ) | Titanic - Machine Learning from Disaster |
5,201,782 | def forward(data, model, device, criterion = pytorch_neg_multi_log_likelihood_batch):
inputs = data["image"].to(device)
target_availabilities = data["target_availabilities"].to(device)
targets = data["target_positions"].to(device)
preds, confidences = model(inputs)
loss = criterion(targets, preds, confidences, targ... | import seaborn as sns
import matplotlib.pyplot as plt
| Titanic - Machine Learning from Disaster |
5,201,782 | device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = LyftMultiModel(cfg)
weight_path = cfg["model_params"]["weight_path"]
if weight_path:
model.load_state_dict(torch.load(weight_path))
model.to(device)
optimizer = optim.Adam(model.parameters() , lr=cfg["model_params"]["lr"])
print(f'devic... | data_test[(data_test.Embarked=='S')].groupby(['Pclass', 'Sex'] ).size() | Titanic - Machine Learning from Disaster |
5,201,782 | print(model )<init_hyperparams> | data_train = pd.get_dummies(data_train, columns=['Pclass', 'Sex', 'SibSp', 'Parch', 'Embarked'])
data_train.info() | Titanic - Machine Learning from Disaster |
5,201,782 | if cfg["model_params"]["train"]:
tr_it = iter(train_dataloader)
progress_bar = tqdm(range(cfg["train_params"]["max_num_steps"]))
num_iter = cfg["train_params"]["max_num_steps"]
losses_train = []
iterations = []
metrics = []
times = []
model_name = cfg["model_params"]["model_name"]
start = time.time()
for i in progress... | data_test = pd.get_dummies(data_test, columns=['Pclass', 'Sex', 'SibSp', 'Parch', 'Embarked'])
data_test.info() | Titanic - Machine Learning from Disaster |
5,201,782 | pred_path = 'submission.csv'
write_pred_csv(pred_path,
timestamps=np.concatenate(timestamps),
track_ids=np.concatenate(agent_ids),
coords=np.concatenate(future_coords_offsets_pd),
confs = np.concatenate(confidences_list)
)<set_options> | data_train['Age'] =(data_train.Age//10*10 ) | Titanic - Machine Learning from Disaster |
5,201,782 | sns.set()
%matplotlib inline
EPOCHS = 150
BATCH_SIZE = 16
SEED = 20031976
LRATE = 0.0001
VERBOSE=0
<load_from_csv> | data_test['Age'] =(data_test.Age//10*10 ) | Titanic - Machine Learning from Disaster |
5,201,782 | np.random.seed(SEED)
tf.set_random_seed(SEED)
train_df = pd.read_csv('/kaggle/input/aptos2019-blindness-detection/train.csv')
test_df = pd.read_csv('/kaggle/input/aptos2019-blindness-detection/test.csv')
print("Datasets loaded.. ")
print('Train DF Shape', train_df.shape )<train_model> | data_train = pd.get_dummies(data_train, columns=['Age'] ) | Titanic - Machine Learning from Disaster |
5,201,782 | x_resampled, y_resampled = SMOTE(random_state=SEED ).fit_sample(x_train.reshape(x_train.shape[0], -1), train_df['diagnosis'].ravel())
print("x_resampled.shape=",x_resampled.shape)
print("y_resampled.shape=",y_resampled.shape)
x_train = x_resampled.reshape(x_resampled.shape[0], 224, 224, 3)
y_train = pd.get_dummies(... | data_test = pd.get_dummies(data_test, columns=['Age'] ) | Titanic - Machine Learning from Disaster |
5,201,782 | y_train_multi = np.empty(y_train.shape, dtype=y_train.dtype)
y_train_multi[:, 4] = y_train[:, 4]
for i in range(3, -1, -1):
y_train_multi[:, i] = np.logical_or(y_train[:, i], y_train_multi[:, i+1])
print("Original y_train:", y_train.sum(axis=0))
print("Multilabel version:", y_train_multi.sum(axis=0))<split> | b = data_train.pop('Survived')
data_train = pd.concat([data_train, b], axis=1)
data_train.head() | Titanic - Machine Learning from Disaster |
5,201,782 | x_sptrain, x_spval, y_sptrain, y_spval = train_test_split(
x_train, y_train_multi,
test_size=0.10,
random_state=SEED
)
print("train-validation splitted..." )<train_model> | X = data_train.drop(columns = ['Survived', 'PassengerId'], axis=1 ) | Titanic - Machine Learning from Disaster |
5,201,782 | def create_datagen() :
return ImageDataGenerator(
zoom_range=0.10,
fill_mode='constant',
cval=0.,
horizontal_flip=True,
vertical_flip=True,
)
data_generator = create_datagen().flow(x_sptrain, y_sptrain, batch_size=BATCH_SIZE, seed=SEED)
print("Image data augmentated..." )<compute_test_metric> | y = data_train.Survived | Titanic - Machine Learning from Disaster |
5,201,782 | def precision(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
precision = true_positives /(predicted_positives + K.epsilon())
return precision
def recall(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, ... | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
5,201,782 | from keras.applications import DenseNet169,DenseNet121
<choose_model_class> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
5,201,782 | densenet = DenseNet121(
weights='/kaggle/input/densenet-keras/DenseNet-BC-121-32-no-top.h5',
include_top=False,
input_shape=(224,224,3)
)
model = Sequential()
model.add(densenet)
model.add(layers.GlobalAveragePooling2D())
model.add(layers.Dropout(0.2))
model.add(layers.Dense(5, activation='sigmoid'))
model.compile(... | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=2 ) | Titanic - Machine Learning from Disaster |
5,201,782 | class KappaMetrics(Callback):
def on_train_begin(self, logs={}):
self.val_kappas = []
def on_epoch_end(self, epoch, logs={}):
X_val, y_val = self.validation_data[:2]
y_val = y_val.sum(axis=1)- 1
y_pred = self.model.predict(X_val)> 0.5
y_pred = y_pred.astype(int ).sum(axis=1)- 1
_val_kappa = cohen_kappa_score(
y_val,
y... | from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
5,201,782 | with open('history.json', 'w')as f:
json.dump(history.history, f)
history_df = pd.DataFrame(history.history)
history_df.head(EPOCHS )<save_to_csv> | num_trees = 1000
max_features = 3
kfold = KFold(n_splits=10, random_state=7)
rfc = RandomForestClassifier(n_estimators=num_trees, max_features=max_features ) | Titanic - Machine Learning from Disaster |
5,201,782 | y_test = model.predict(x_test)> 0.5
y_test = y_test.astype(int ).sum(axis=1)- 1
test_df['diagnosis'] = y_test
test_df.to_csv('submission.csv',index=False)
display(test_df.head(5))
<set_options> | rfc.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
5,201,782 | sns.set()
%matplotlib inline
EPOCHS = 50
BATCH_SIZE = 16
SEED = 20031976
LRATE = 0.00005
VERBOSE=0
<load_from_csv> | rfc.score(X_train, y_train ) | Titanic - Machine Learning from Disaster |
5,201,782 | np.random.seed(SEED)
tf.set_random_seed(SEED)
train_df = pd.read_csv('/kaggle/input/aptos2019-blindness-detection/train.csv')
test_df = pd.read_csv('/kaggle/input/aptos2019-blindness-detection/test.csv')
print("Datasets loaded.. ")
print('Train DF Shape', train_df.shape )<train_model> | rfc.score(X_test, y_test ) | Titanic - Machine Learning from Disaster |
5,201,782 | x_resampled, y_resampled = SMOTE(random_state=SEED ).fit_sample(x_train.reshape(x_train.shape[0], -1), train_df['diagnosis'].ravel())
print("x_resampled.shape=",x_resampled.shape)
print("y_resampled.shape=",y_resampled.shape)
x_train = x_resampled.reshape(x_resampled.shape[0], 224, 224, 3)
y_train = pd.get_dummies(... | y_pred = rfc.predict(X_test ) | Titanic - Machine Learning from Disaster |
5,201,782 | y_train_multi = np.empty(y_train.shape, dtype=y_train.dtype)
y_train_multi[:, 4] = y_train[:, 4]
for i in range(3, -1, -1):
y_train_multi[:, i] = np.logical_or(y_train[:, i], y_train_multi[:, i+1])
print("Original y_train:", y_train.sum(axis=0))
print("Multilabel version:", y_train_multi.sum(axis=0))<split> | from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
5,201,782 | x_sptrain, x_spval, y_sptrain, y_spval = train_test_split(
x_train, y_train_multi,
test_size=0.10,
random_state=SEED
)
print("train-validation splitted..." )<train_model> | acc = accuracy_score(y_test, y_pred ) | Titanic - Machine Learning from Disaster |
5,201,782 | def create_datagen() :
return ImageDataGenerator(
zoom_range=0.10,
fill_mode='constant',
cval=0.,
horizontal_flip=True,
vertical_flip=True,
)
data_generator = create_datagen().flow(x_sptrain, y_sptrain, batch_size=BATCH_SIZE, seed=SEED)
print("Image data augmentated..." )<compute_test_metric> | data_test.isnull().sum() | Titanic - Machine Learning from Disaster |
5,201,782 | def precision(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
precision = true_positives /(predicted_positives + K.epsilon())
return precision
def recall(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, ... | data_test = data_test.drop(columns=['PassengerId'] ) | Titanic - Machine Learning from Disaster |
5,201,782 | from keras.applications import DenseNet169
<choose_model_class> | df = pd.DataFrame({'PassengerId': range(892, 1310), 'Survived':(rfc.predict(data_test)) } ) | Titanic - Machine Learning from Disaster |
5,201,782 | <compute_train_metric><EOS> | df.to_csv('TitanicDataSetKaggleVersion2.csv', index=False ) | Titanic - Machine Learning from Disaster |
10,910,254 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_to_csv> | sns.set(style="whitegrid")
| Titanic - Machine Learning from Disaster |
10,910,254 | with open('history.json', 'w')as f:
json.dump(history.history, f)
history_df = pd.DataFrame(history.history)
history_df.head(EPOCHS )<save_to_csv> | path = '/kaggle/input/titanic/'
f_train = pd.read_csv(path + 'train.csv')
f_test = pd.read_csv(path + 'test.csv' ) | Titanic - Machine Learning from Disaster |
10,910,254 | y_test = model.predict(x_test)> 0.5
y_test = y_test.astype(int ).sum(axis=1)- 1
test_df['diagnosis'] = y_test
test_df.to_csv('submission.csv',index=False)
display(test_df.head(5))
<define_variables> | def missing_value(df):
value =(df.isnull().mean())
return value | Titanic - Machine Learning from Disaster |
10,910,254 | spacecutter_package_path = '.. /input/spacecutter/spacecutter-master/spacecutter-master/'
sys.path.append(spacecutter_package_path)
enet_package_path = '.. /input/efficientnet/efficientnet-pytorch/EfficientNet-PyTorch/'
sys.path.append(enet_package_path)
device = 'cuda' if torch.cuda.is_available() else 'cpu'
DEBUG =... | missing_value(f_train ) | Titanic - Machine Learning from Disaster |
10,910,254 | class RetinaDataset(Dataset):
CACHE_DIR = 'cache'
def __init__(self, dataframe, img_size, img_scale, train_transform, use_base_transform, use_cache=False):
if use_cache and not os.path.exists(self.CACHE_DIR): os.mkdir(self.CACHE_DIR)
self.use_cache = use_cache
self.df = dataframe
self.train_transform = train_transform... | missing_value(f_test ) | Titanic - Machine Learning from Disaster |
10,910,254 | class NNLogger(object):
def __init__(self):
self.y_true = {'train': [], 'val': []}
self.y_pred = {'train': [], 'val': []}
self.y_true = {'train': [], 'val': []}
self.y_pred = {'train': [], 'val': []}
self.loss = {'train': [], 'val': []}
self.elapsed_time = []
self.lr_history = []
self.current_epoch = 1
def step(self):
... | f_train['Title'] = f_train.Name.str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
10,910,254 | class BlindnessDetectionTrainer(object):
_train_2015_csv = '.. /input/resized-2015-2019-blindness-detection-images/labels/trainLabels15.csv'
_train_2015_img_path = '.. /input/resized-2015-2019-blindness-detection-images/resized train 15/'
_train_2015_ext = '.jpg'
_train_2019_csv = '.. /input/resized-2015-2019-blindness... | f_train[f_train.Age.isnull() ].Title.value_counts() | Titanic - Machine Learning from Disaster |
10,910,254 | IMG_SIZE = 224
train_params = {
'n_epochs': 2,
'img_size': IMG_SIZE,
'img_scale': 1.2,
'batch_size': 32,
'class_weights': [1, 2, 1, 2, 1],
'lr': 2e-3,
'lr_scale': 0.8,
'step_size': 1,
'train_type': 'old',
'use_base_transform' : ['weighted'],
'train_transform': transforms.Compose([
transforms.RandomHorizontalFlip() ,
tr... | age_missing = list(f_train[f_train.Age.isnull() ].Title.unique())
for i in age_missing:
median_age = f_train.groupby('Title')['Age'].median() [i]
f_train.loc[f_train['Age'].isnull() &(f_train['Title'] == i), 'Age'] = median_age | Titanic - Machine Learning from Disaster |
10,910,254 | trainer = BlindnessDetectionTrainer(freeze_pretrained=False, use_cache=DEBUG)
lr_find_loss, lr_find_lr = trainer.lr_finder(lr_find_epochs=6, start_lr=3e-5, end_lr=3e-2, train_type='old',
img_size=train_params['img_size'], img_scale=train_params['img_scale'],
train_transform=train_params['train_transform'],
use_base_tr... | missing_value(f_train ) | Titanic - Machine Learning from Disaster |
10,910,254 | trainer = BlindnessDetectionTrainer(freeze_pretrained=True, use_cache=DEBUG)
trainer.train_loop(**train_params )<split> | f_train['Family'] = f_train['SibSp'] + f_train['Parch'] + 1
f_train['TravelAlone']=np.where(f_train['Family']>1, 0, 1 ) | Titanic - Machine Learning from Disaster |
10,910,254 | trainer.train_dataset.show_sample_imgs(6, get_original=True, use_train_transform=False )<split> | f_train['Fare_Bin'] = pd.qcut(f_train['Fare'], 5)
label = LabelEncoder()
f_train['AgeGroup'] = label.fit_transform(f_train['AgeGroup'])
f_train['Fare_Bin'] = label.fit_transform(f_train['Fare_Bin'])
f_train['Title'] = label.fit_transform(f_train['Title'])
f_train['Sex'] = label.fit_transform(f_train['Sex'])
drop_l... | Titanic - Machine Learning from Disaster |
10,910,254 | trainer.train_dataset.show_sample_imgs(6, get_original=False, use_train_transform=train_params['train_transform'] )<load_pretrained> | f_test['Title'] = f_test.Name.str.extract('([A-Za-z]+)\.', expand=False)
age_missing = list(f_test[f_test.Age.isnull() ].Title.unique())
for i in age_missing:
median_age = f_test.groupby('Title')['Age'].median() [i]
f_test.loc[f_test['Age'].isnull() &(f_test['Title'] == i), 'Age'] = median_age
f_test.Age.fillna(28, i... | Titanic - Machine Learning from Disaster |
10,910,254 | train_params['n_epochs'] = 4
train_params['lr'] = 3e-3
train_params['step_size'] = 2
train_params['train_type'] = 'old'
trainer.load_best_state_dict()
trainer.unfreeze()
trainer.train_loop(**train_params )<load_pretrained> | X = f_train.drop('Survived', axis = 1)
Y = f_train.Survived
X_test = f_test
X_test = X_test.drop('PassengerId',axis = 1)
x_train, x_val, y_train, y_val = train_test_split(X, Y, test_size = 0.22, random_state = 0 ) | Titanic - Machine Learning from Disaster |
10,910,254 | train_params['n_epochs'] = 2
train_params['step_size'] = 1
train_params['lr'] = 1e-3
train_params['train_type'] = 'new'
trainer.load_best_state_dict()
trainer.freeze_except_fc()
trainer.train_loop(**train_params )<split> | def basic_model(x_train,y_train,x_val,y_val):
model = GradientBoostingClassifier()
model.fit(x_train, y_train)
y_pred = model.predict(x_val)
acc_gbc = round(accuracy_score(y_pred, y_val)* 100, 2)
print(f'Gradient Boosting Classifier : Score {acc_gbc}')
model = RandomForestClassifier()
model.fit(x_train, y_train)
y... | Titanic - Machine Learning from Disaster |
10,910,254 | trainer.train_dataset.show_sample_imgs(6, get_original=True, use_train_transform=False )<split> | acc_gbc, acc_rfc, acc_svc, acc_lgbm, acc_xgb = basic_model(x_train, y_train, x_val, y_val ) | Titanic - Machine Learning from Disaster |
10,910,254 | trainer.train_dataset.show_sample_imgs(6, get_original=False, use_train_transform=train_params['train_transform'] )<train_model> | models_basic = pd.DataFrame({
'Model': ['Gradient Boosting Classifier','Random Forest Classifier',
'Support Vector Machines', 'LightGBM Classifier',
'XGB Classifier'],
'Score Basic Model': [acc_gbc, acc_rfc, acc_svc, acc_lgbm, acc_xgb]
})
models_basic.sort_values(by='Score Basic Model', ascending=False ) | Titanic - Machine Learning from Disaster |
10,910,254 | train_params['n_epochs'] = 8
train_params['step_size'] = 2
train_params['use_base_transform'] = ['weighted']
trainer.load_best_state_dict()
trainer.unfreeze()
trainer.train_loop(**train_params )<feature_engineering> | class model_objectif(object):
def __init__(self, models, x, y):
self.models = models
self.x = x
self.y = y
def __call__(self, trial):
models, x, y = self.models, self.x, self.y
classifier_name = models
if classifier_name == "RFC":
model = RandomForestClassifier(
n_estimators = trial.suggest_int('n_estimators', 10, 100... | Titanic - Machine Learning from Disaster |
10,910,254 | class BlindnessDetectionPredictor(object):
def __init__(self, subm_df, state_dict_file, transform, use_base_transform, img_size,
img_scale, n_TTA, batch_size):
self.subm_df = subm_df
self.subm_df['img_path'] = self.subm_df['id_code'].apply(
lambda f: _subm_2019_img_path + f + _subm_2019_ext if os.path.isfile(
_subm_2... | models = 'RFC'
objective = model_objectif(models, X, Y)
study_RFC = optuna.create_study(direction='maximize')
study_RFC.optimize(objective, n_trials=100 ) | Titanic - Machine Learning from Disaster |
10,910,254 | _subm_2019_csv = '.. /input/aptos2019-blindness-detection/sample_submission.csv'
_subm_2019_img_path = '.. /input/aptos2019-blindness-detection/test_images/'
_subm_2019_ext = '.png'
submit_df = pd.read_csv(_subm_2019_csv )<choose_model_class> | best_params_RFC, best_score_RFC = parameters(study_RFC ) | Titanic - Machine Learning from Disaster |
10,910,254 | IMG_SIZE = 224
subm_params = {
'subm_df': submit_df,
'state_dict_file' : '.. /working/weight_best_kappa.pt',
'batch_size': 32,
'n_TTA': 3,
'img_size': IMG_SIZE,
'img_scale': 1.2,
'use_base_transform': ['crop', 'weighted'],
'transform': transforms.Compose([
transforms.RandomHorizontalFlip() ,
transforms.RandomVerticalFl... | models = 'SVM'
objective = model_objectif(models, X, Y)
study_SVM = optuna.create_study(direction='maximize')
study_SVM.optimize(objective, n_trials=100 ) | Titanic - Machine Learning from Disaster |
10,910,254 | submission = pd.DataFrame(
{
'id_code': submit_df.id_code.values,
'diagnosis': enet_subm_preds
}
)
print(submission.head())
print(submission.diagnosis.value_counts())
submission.to_csv('submission.csv', index=False)
print(os.listdir('./'))<set_options> | best_params_SVM, best_score_SVM = parameters(study_SVM ) | Titanic - Machine Learning from Disaster |
10,910,254 | %reload_ext autoreload
%autoreload 2
%matplotlib inline<import_modules> | models = 'GBC'
objective = model_objectif(models, X, Y)
study_GBC = optuna.create_study(direction='maximize')
study_GBC.optimize(objective, n_trials=100 ) | Titanic - Machine Learning from Disaster |
10,910,254 | import fastai
from fastai import *
from fastai.vision import *
from fastai.callbacks import *
import cv2
import pandas as pd
import matplotlib.pyplot as plt<set_options> | best_params_GBC, best_score_GBC = parameters(study_GBC ) | Titanic - Machine Learning from Disaster |
10,910,254 | print('Make sure cudnn is enabled:', torch.backends.cudnn.enabled )<set_options> | models = 'XGBC'
objective = model_objectif(models, X, Y)
study_XGBC = optuna.create_study(direction='maximize')
study_XGBC.optimize(objective, n_trials=100 ) | Titanic - Machine Learning from Disaster |
10,910,254 | def seed_everything(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
SEED = 1667
seed_everything(SEED )<feature_engineering> | best_params_XGBC, best_score_XGBC = parameters(study_XGBC ) | Titanic - Machine Learning from Disaster |
10,910,254 | 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=['id_code'])
df ... | models = 'LGBM'
objective = model_objectif(models, X, Y)
study_LGBM = optuna.create_study(direction='maximize')
study_LGBM.optimize(objective, n_trials=100 ) | Titanic - Machine Learning from Disaster |
10,910,254 | tfms = get_transforms(do_flip=True, flip_vert=True, max_rotate=0.10, max_zoom=1.3, max_warp=0.0, max_lighting=0.2)
data =(
src.transform(tfms,size=128)
.databunch(bs=bs)
.normalize(imagenet_stats)
)<compute_test_metric> | best_params_LGBM, best_score_LGBM = parameters(study_LGBM ) | Titanic - Machine Learning from Disaster |
10,910,254 | def quadratic_kappa(y_hat, y):
return torch.tensor(cohen_kappa_score(torch.round(y_hat), y, weights='quadratic'),device='cuda:0' )<choose_model_class> | models_tuning = pd.DataFrame({
'Model': ['Gradient Boosting Classifier',
'Random Forest Classifier',
'Support Vector Machines',
'LightGBM Classifier',
'XGB Classifier'],
'Score Tuning Model': [best_score_GBC,
best_score_RFC,
best_score_SVM,
best_score_LGBM,
best_score_XGBC]
})
model_all = pd.merge(models_basic, models... | Titanic - Machine Learning from Disaster |
10,910,254 | learn = cnn_learner(data, base_arch=models.densenet161 ,metrics=[quadratic_kappa],
callback_fns=[partial(EarlyStoppingCallback, monitor='quadratic_kappa',
min_delta=0.01, patience=3)],
model_dir='/kaggle',pretrained=True)
<train_model> | def submit_pred(df, test_data):
model_name = df.Model.values[0]
if model_name == 'Random Forest Classifier':
model = RandomForestClassifier(**best_params_RFC)
model.fit(x_train, y_train)
y_pred = model.predict(test_data)
if model_name == 'Gradient Boosting Classifier':
model = GradientBoostingClassifier(**best_param... | Titanic - Machine Learning from Disaster |
10,910,254 | learn.fit_one_cycle(5, 2e-2)
<find_best_params> | y_pred = submit_pred(model_all, X_test)
submission = pd.DataFrame({
"PassengerId": f_test['PassengerId'],
"Survived": y_pred
} ) | Titanic - Machine Learning from Disaster |
10,910,254 | learn.unfreeze()
learn.lr_find()
learn.recorder.plot()<train_model> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
10,910,254 | <predict_on_test><EOS> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
10,001,986 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<import_modules> | %matplotlib inline
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
X = pd.read_csv(".. /input/titanic/train.csv")
X_test_full = pd.read_csv(".. /input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
10,001,986 | import numpy as np
import pandas as pd
import os
import scipy as sp
from functools import partial
from sklearn import metrics
from collections import Counter
import json<compute_test_metric> | print('<<Training set>>
', X.isnull().sum())
print('---------------------------')
print('<<Test set>>
', X_test_full.isnull().sum() ) | Titanic - Machine Learning from Disaster |
10,001,986 | 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... | print('Percent of missing "Age" values on training dataset:', '%.2f%%' %(( X['Age'].isnull().sum() /X.shape[0])*100))
print('Percent of missing "Embarked" values on training dataset:', '%.2f%%' %(( X['Embarked'].isnull().sum() /X.shape[0])*100))
print('Percent of missing "Cabin" values on training dataset:', '%.2f%%' %... | Titanic - Machine Learning from Disaster |
10,001,986 | optR = OptimizedRounder()
optR.fit(valid_preds[0],valid_preds[1] )<load_from_csv> | women = X.loc[X.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
men = X.loc[X.Sex == 'male']["Survived"]
rate_men = sum(men)/len(men)
print("Rate of women who survived:", "%.5f"% rate_women)
print("Rate of men who survived:", "%.5f"% rate_men ) | Titanic - Machine Learning from Disaster |
10,001,986 | sample_df = pd.read_csv('.. /input/aptos2019-blindness-detection/sample_submission.csv')
sample_df.head()<predict_on_test> | first_class = X.loc[X.Pclass == 1]["Survived"]
first_rate = sum(first_class)/len(first_class)
second_class = X.loc[X.Pclass == 2]["Survived"]
second_rate = sum(second_class)/len(second_class)
third_class = X.loc[X.Pclass == 3]["Survived"]
third_rate = sum(third_class)/len(third_class)
print("Rate of 1st class who su... | Titanic - Machine Learning from Disaster |
10,001,986 | learn.data.add_test(ImageList.from_df(sample_df,'.. /input/aptos2019-blindness-detection',folder='test_images',suffix='.png'))
<choose_model_class> | sibs = X.loc[X.SibSp == 1]["Survived"]
sibs_rate = sum(sibs)/len(sibs)
parents = X.loc[X.Parch == 1]["Survived"]
parents_rate = sum(parents)/len(parents)
print("Rate of survivors with siblings:", "%.5f"% sibs_rate)
print("Rate of survivors with parents:", "%.5f"% parents_rate ) | Titanic - Machine Learning from Disaster |
10,001,986 | preds,y = learn.TTA(ds_type=DatasetType.Test)
<save_to_csv> | df = pd.DataFrame({'title':name[0], 'name':name[2], 'last_name' : name[1],
'survived': X['Survived'], 'sibsp': X['SibSp'], 'parch': X['Parch'],
'age': X['Age'], 'sex': X['Sex']})
df_test = pd.DataFrame({'title':name_test[0], 'name':name_test[2], 'last_name' : name_test[1],
'age': X_test_full['Age'], 'sex':X_test_full[... | Titanic - Machine Learning from Disaster |
10,001,986 | test_predictions = optR.predict(preds, coefficients)
sample_df.diagnosis = test_predictions.astype(int)
sample_df.head()
sample_df.to_csv('submission.csv',index=False )<set_options> | df1['last_name'].value_counts() | Titanic - Machine Learning from Disaster |
10,001,986 | %matplotlib inline
warnings.filterwarnings('always')
warnings.filterwarnings('ignore')
print(os.listdir(".. /input"))<load_from_csv> | fam = df1["survived"]
fam_rate = sum(fam)/len(fam)
lonely = df2["survived"]
lonely_rate = sum(lonely)/len(lonely)
print("Rate of survivors with family onboard:", "%.5f"% fam_rate)
print("Rate of survivors without family onboard:", "%.5f"% lonely_rate ) | Titanic - Machine Learning from Disaster |
10,001,986 | df_train = pd.read_csv('.. /input/aptos2019-blindness-detection/train.csv')
df_test = pd.read_csv('.. /input/aptos2019-blindness-detection/test.csv')
x_train = df_train['id_code']
y_train = df_train['diagnosis']<import_modules> | X.groupby('Pclass' ).Fare.mean() | Titanic - Machine Learning from Disaster |
10,001,986 | import torch
import torch.utils.data
import torchvision<define_variables> | emb_s = X.loc[X.Embarked == 'S']["Survived"]
s_rate = sum(emb_s)/len(emb_s)
emb_c = X.loc[X.Embarked == 'C']["Survived"]
c_rate = sum(emb_c)/len(emb_c)
emb_q = X.loc[X.Embarked == 'Q']["Survived"]
q_rate = sum(emb_q)/len(emb_q)
print("Rate of survivors that embarked from Southampton:", "%.5f"% s_rate)
print("Rate o... | Titanic - Machine Learning from Disaster |
10,001,986 | def get_label(diagnosis):
return ','.join([str(i)for i in range(diagnosis + 1)] )<feature_engineering> | X['Ticket'].value_counts() | Titanic - Machine Learning from Disaster |
10,001,986 | df_train['label'] = df_train.diagnosis.apply(get_label )<set_options> | df.groupby('title' ).age.mean() | Titanic - Machine Learning from Disaster |
10,001,986 | df_train.head(10)
torch.cuda.manual_seed_all(13 )<normalization> | def replace_titles(x):
title = x['title']
if title in ['Don', 'Major', 'Capt', 'Jonkheer', 'Rev', 'Col', 'Sir']:
return 'Mr'
elif title in ['the Countess', 'Mme', 'Dona', 'Lady']:
return 'Mrs'
elif title in ['Mlle', 'Ms']:
return 'Miss'
elif title =='Dr':
if x['sex']=='male':
return 'Mr'
else:
return 'Mrs'
else:
return... | Titanic - Machine Learning from Disaster |
10,001,986 | tfms =([RandTransform(tfm=TfmCrop(crop_pad), kwargs={'row_pct':(0.4, 1), 'col_pct':(0.1, 0.9), 'padding_mode': 'reflection'}, p=1.0, resolved={}, do_run=True, is_random=True, use_on_y=True),
RandTransform(tfm=TfmPixel(rgb_randomize), kwargs={'channel':2, 'thresh':0.1}, p=0.75, resolved={}, do_run=True, is_random=True, ... | X['Title'] = df['title'] | Titanic - Machine Learning from Disaster |
10,001,986 | data = ImageDataBunch.from_df('./',
df=df_train,
valid_pct=0.25,
folder=".. /input/aptos2019-blindness-detection/train_images",
suffix=".png",
ds_tfms=tfms,
size=224,
bs=156,
num_workers=32,
label_col='label', label_delim=',' ).normalize(imagenet_stats )<import_modules> | X_test_full.groupby('Pclass' ).Fare.mean() | Titanic - Machine Learning from Disaster |
10,001,986 | print(f'Classes:
{data.classes}' )<predict_on_test> | X_test_full.loc[X_test_full.Fare.isnull() ] | Titanic - Machine Learning from Disaster |
10,001,986 | def get_preds(arr):
mask = arr == 0
return np.clip(np.where(mask.any(1), mask.argmax(1), 5)- 1, 0, 4 )<define_variables> | X_test_full.Fare = X_test_full.Fare.fillna(12.46 ) | Titanic - Machine Learning from Disaster |
10,001,986 | last_output = torch.tensor([
[1.7226, 1.7226, 1.7226, 1.7226, 1.7226],
[0, 0, 0, 0, 1.7226],
[0.12841, -7.6266, -6.3899, -2.1333, -0.48995],
[0.68119, 1.7226, -1.9895, -0.097746, 0.53576]
])
arr =(torch.sigmoid(last_output)> 0.5 ).numpy() ; arr<predict_on_test> | df_test.groupby('title' ).title.count() | Titanic - Machine Learning from Disaster |
10,001,986 | assert(get_preds(arr)== np.array([4, 0, 0, 1])).all()<train_model> | df_test.loc[df_test.title.isin(['Col', 'Dona', 'Don', 'Dr', 'Ms', 'Rev'])] | Titanic - Machine Learning from Disaster |
10,001,986 | class ConfusionMatrix(Callback):
"Computes the confusion matrix."
def on_train_begin(self, **kwargs):
self.n_classes = 0
def on_epoch_begin(self, **kwargs):
self.cm = None
def on_batch_end(self, last_output:Tensor, last_target:Tensor, **kwargs):
preds = torch.tensor(get_preds(( torch.sigmoid(last_output)> 0.5 ).cpu().n... | df_test.groupby('title' ).age.mean() | Titanic - Machine Learning from Disaster |
10,001,986 | class Ranger(Optimizer):
def __init__(self, params, lr=1e-2, alpha=0.5, k=8, betas= (.9,0.999), eps=1e-8, weight_decay=0.1):
if not 0.0 <= alpha <= 1.0:
raise ValueError(f'Invalid slow update rate: {alpha}')
if not 1 <= k:
raise ValueError(f'Invalid lookahead steps: {k}')
if not lr > 0:
raise ValueError(f'Invalid Lea... | df_test['title']=df_test.apply(replace_titles, axis=1)
print(df_test.groupby('title' ).title.count())
print(df_test.groupby('title' ).age.mean())
print(df_test.groupby('title' ).age.median() ) | Titanic - Machine Learning from Disaster |
10,001,986 | kappa = KappaScore(weights="quadratic")
learn = cnn_learner(data, models.resnet50, metrics=[kappa, accuracy_thresh],
opt_func = optar,
callback_fns = [
partial(EarlyStoppingCallback, monitor='kappa_score', min_delta=0.001, patience=3),
partial(ReduceLROnPlateauCallback),
partial(SaveModelCallback, every = 'improvement... | X_test_full['Title'] = df_test['title'] | Titanic - Machine Learning from Disaster |
10,001,986 | lr = min_loss_lr
learn.fit_one_cycle(10, lr)
torch.cuda.manual_seed_all(18 )<train_model> | def f(row):
if row['Age'] <= 16: val = 1
else: val = 0
return val
X['Minor'] = X.apply(f, axis=1)
X_test_full['Minor'] = X_test_full.apply(f, axis=1)
def f(row):
if row['Parch'] > 0 and row['Title'] == 'Mrs' and row['Age'] > 18: val = 1
else: val = 0
return val
X['Mother'] = X.apply(f, axis=1)
X_test_full['Mother'] ... | Titanic - Machine Learning from Disaster |
10,001,986 | learn.unfreeze()
learn.lr_find
lrs = learn.recorder.lrs
losses = learn.recorder.losses
mg =(np.gradient(np.array(losses)) ).argmin()
ml = np.argmin(losses[1:])
min_grad_lr = lrs[mg]
print(min_grad_lr)
min_loss_lr = lrs[ml]/10
print(min_loss_lr)
lr2 = min_loss_lr
learn.unfreeze()
learn.fit_one_cycle(10, max_lr = lr2 ... | X['Embarked'].fillna(X['Embarked'].value_counts().idxmax() , inplace=True)
X['Deck'] = X['Cabin'].apply(lambda s: s[0] if pd.notnull(s)else 'U')
X_test_full['Deck'] = X_test_full['Cabin'].apply(lambda s: s[0] if pd.notnull(s)else 'U')
X['Deck'].unique()
X.drop('Cabin', axis=1, inplace=True)
X_test_full.drop('Cabin'... | Titanic - Machine Learning from Disaster |
10,001,986 | learn.load('bestordinal' )<train_model> | plt.figure(figsize=(10,5))
plt.title('Training dataset heatmap')
X['Title'] = LabelEncoder().fit_transform(X['Title'])
X['Embarked'] = X['Embarked'].astype('|S')
X['Embarked'] = LabelEncoder().fit_transform(X['Embarked'])
X['Deck'] = X['Deck'].astype('|S')
X['Deck'] = LabelEncoder().fit_transform(X['Deck'])
sns.h... | Titanic - Machine Learning from Disaster |
10,001,986 | learn.freeze()
learn.fit_one_cycle(15, max_lr=lr2/50,wd=1e-1 )<load_from_csv> | df['age'] = np.where(( df.age.isnull())&(df.title=="Master"),5,
np.where(( df.age.isnull())&(df.title=="Miss"),21,
np.where(( df.age.isnull())&(df.title=="Mr"),33,
np.where(( df.age.isnull())&(df.title=="Mrs"),36,
df.age)))) | Titanic - Machine Learning from Disaster |
10,001,986 | learn.load('bestordinal')
sample_df = pd.read_csv('.. /input/aptos2019-blindness-detection/sample_submission.csv')
sample_df.head()<define_variables> | df.isnull().sum() | Titanic - Machine Learning from Disaster |
10,001,986 | learn.data.add_test(ImageList.from_df(sample_df,'.. /input/aptos2019-blindness-detection',folder='test_images',suffix='.png'))<predict_on_test> | df[['title', 'survived']].groupby(['title'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
10,001,986 | preds, y = learn.get_preds(DatasetType.Test )<count_values> | X['Age'] = df['age']
X.isnull().sum() | Titanic - Machine Learning from Disaster |
10,001,986 | sample_df.diagnosis = get_preds(( preds > 0.5 ).cpu().numpy())
sample_df.diagnosis.value_counts()<save_to_csv> | X.isnull().sum() | Titanic - Machine Learning from Disaster |
10,001,986 | sample_df.to_csv('submission.csv',index=False )<import_modules> | plt.figure(figsize=(10,5))
plt.title('Test dataset heatmap')
X_test_full['Title'] = LabelEncoder().fit_transform(X_test_full['Title'])
X_test_full['Embarked'] = X_test_full['Embarked'].astype('|S')
X_test_full['Embarked'] = LabelEncoder().fit_transform(X_test_full['Embarked'])
X_test_full['Deck'] = X_test_full['Dec... | Titanic - Machine Learning from Disaster |
10,001,986 | from fastai import *
from fastai.vision import *
import numpy as np
import scipy as sp
from sklearn import metrics
import cv2
import PIL<define_variables> | df_test['age'] = np.where(( df_test.age.isnull())&(df_test.title=="Master"),7,
np.where(( df_test.age.isnull())&(df_test.title=="Miss"),22,
np.where(( df_test.age.isnull())&(df_test.title=="Mr"),32,
np.where(( df_test.age.isnull())&(df_test.title=="Mrs"),39,
df_test.age)))) | Titanic - Machine Learning from Disaster |
10,001,986 | path = Path('/kaggle/input/aptos2019-blindness-detection' )<set_options> | df_test.isnull().sum() | Titanic - Machine Learning from Disaster |
10,001,986 | path.ls()<load_from_csv> | X_test_full['Age'] = df_test['age'].copy()
X_test_full.isnull().sum() | Titanic - Machine Learning from Disaster |
10,001,986 | df = pd.read_csv(path/'train.csv' )<count_values> | for df in([X, X_test_full]):
df['FamilySize'] = df.SibSp + df.Parch + 1
df['Fare'] = LabelEncoder().fit_transform(df['Fare'])
df['Age'] = LabelEncoder().fit_transform(df['Age'])
df.drop(['SibSp'], axis=1, inplace=True)
df.drop(['Parch'], axis=1, inplace=True)
df.drop(['Ticket'], axis=1, inplace=True)
df.drop(['Nam... | Titanic - Machine Learning from Disaster |
10,001,986 | df.diagnosis.value_counts()<feature_engineering> | X['Deck_class'] = X['Pclass']*X['Deck']
X_test_full['Deck_class'] = X_test_full['Pclass']*X_test_full['Deck']
X['Emb_class'] = X['Pclass']*X['Embarked']
X_test_full['Emb_class'] = X_test_full['Pclass']*X_test_full['Embarked'] | Titanic - Machine Learning from Disaster |
10,001,986 | tfms = get_transforms(do_flip=True, flip_vert=True,max_warp=0., xtra_tfms =[crop_pad() ,symmetric_warp() ] )<normalization> | train_dummies = pd.get_dummies(X, columns=['Sex'])
test_dummies = pd.get_dummies(X_test_full, columns=['Sex'])
X = train_dummies.copy()
X_test_full = test_dummies.copy()
for df in([X, X_test_full]):
for col in(['Fare', 'Age', 'FamilySize', 'Deck', 'Title', 'Pclass', 'Deck_class', 'Emb_class']):
df[col] =(df[col]-df[c... | Titanic - Machine Learning from Disaster |
10,001,986 | data =(
src.transform(tfms,size=128)
.databunch()
.normalize(imagenet_stats)
)<compute_test_metric> | y = X.Survived
X.drop(['Survived'], axis=1, inplace=True)
X_train, X_valid, y_train, y_valid = train_test_split(X, y, train_size=0.7, test_size=0.3, random_state=27 ) | 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.