kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
1,242,882 | x_train = df_train[train_columns]
x_test = df_test[train_columns]
y_train = df_train["winPlacePerc"].astype('float' )<set_options> | ship['High_Fare'] = [1 if x > 50 else 0 for x in ship['Fare']]
print('High Fare column created.' ) | Titanic - Machine Learning from Disaster |
1,242,882 | del df_train; del df_test
gc.collect()<split> | ship.drop(['Age_was_missing'],axis=1,inplace=True)
print('Dropped "Age_was_missing" column from dataset.' ) | Titanic - Machine Learning from Disaster |
1,242,882 | folds = KFold(n_splits=5,random_state=6)
oof_preds = np.zeros(x_train.shape[0])
sub_preds = np.zeros(x_test.shape[0])
start = time.time()
valid_score = 0
importances = pd.DataFrame()
for n_fold,(trn_idx, val_idx)in enumerate(folds.split(x_train, y_train)) :
trn_x, trn_y = x_train.iloc[trn_idx], y_train[trn_idx]
val_... | ship.drop(['Age'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
1,242,882 | test_pred = pd.DataFrame({"Id":test_idx})
test_pred["winPlacePerc"] = sub_preds
test_pred.columns = ["Id", "winPlacePerc"]
test_pred.to_csv("lgb_base_model.csv", index=False )<set_options> | from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier | Titanic - Machine Learning from Disaster |
1,242,882 | def is_interactive() :
return 'runtime' in get_ipython().config.IPKernelApp.connection_file
print('Interactive?', is_interactive())
debug = False
use_amp = True<set_options> | df_tr = ship[ship.Survived.notnull() ]
df_tr.head() | Titanic - Machine Learning from Disaster |
1,242,882 | 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_everything(21 )<import_modules> | df_te = ship[ship.Survived.isnull() ]
df_te.drop(['Survived'], axis=1, inplace=True)
df_te = df_te.reset_index(drop=True)
df_te.head() | Titanic - Machine Learning from Disaster |
1,242,882 | torch.__version__, ignite.__version__<set_options> | x_train = df_tr.drop("Survived",axis=1)
y_train = df_tr["Survived"]
x_test = df_te.copy()
print('Test and Train ML variables are ready.' ) | Titanic - Machine Learning from Disaster |
1,242,882 | %%time
if use_amp:
try:
except ImportError:
!pip install -v --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext".. /input/nvidia-apex/repository/*
<normalization> | logreg = LogisticRegression()
logreg.fit(x_train, y_train)
y_pred = logreg.predict(x_test)
logreg.score(x_train, y_train ) | Titanic - Machine Learning from Disaster |
1,242,882 | class Swish(nn.Module):
def forward(self, x):
return x * torch.sigmoid(x)
class Flatten(nn.Module):
def forward(self, x):
return x.reshape(x.shape[0], -1 )<define_search_model> | random_forest = RandomForestClassifier(n_estimators=300)
random_forest.fit(x_train, y_train)
y_pred = random_forest.predict(x_test ).astype(int)
random_forest.score(x_train, y_train ) | Titanic - Machine Learning from Disaster |
1,242,882 | class SqueezeExcitation(nn.Module):
def __init__(self, inplanes, se_planes):
super(SqueezeExcitation, self ).__init__()
self.reduce_expand = nn.Sequential(
nn.Conv2d(inplanes, se_planes,
kernel_size=1, stride=1, padding=0, bias=True),
Swish() ,
nn.Conv2d(se_planes, inplanes,
kernel_size=1, stride=1, padding=0, bias=Tr... | df_test['Survived'] = y_pred.astype(int)
df_test.to_csv('SurvivedList.csv')
df_test | Titanic - Machine Learning from Disaster |
1,242,882 | class MBConv(nn.Module):
def __init__(self, inplanes, planes, kernel_size, stride,
expand_rate=1.0, se_rate=0.25,
drop_connect_rate=0.2):
super(MBConv, self ).__init__()
expand_planes = int(inplanes * expand_rate)
se_planes = max(1, int(inplanes * se_rate))
self.expansion_conv = None
if expand_rate > 1.0:
self.expansi... | submission = df_test[["PassengerId", "Survived"]] | Titanic - Machine Learning from Disaster |
1,242,882 | <choose_model_class><EOS> | submission.to_csv('titanic.csv', index=False, header=['PassengerID', 'Survived'] ) | Titanic - Machine Learning from Disaster |
548,581 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | import numpy as np
import pandas as pd
import seaborn as seaborn
from sklearn import preprocessing
from sklearn import tree
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt | Titanic - Machine Learning from Disaster |
548,581 | def print_num_params(model, display_all_modules=False):
total_num_params = 0
for n, p in model.named_parameters() :
num_params = 1
for s in p.shape:
num_params *= s
if display_all_modules: print("{}: {}".format(n, num_params))
total_num_params += num_params
print("-" * 50)
print("Total number of parameters: {:.2e}".fo... | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
train.info()
test.info() | Titanic - Machine Learning from Disaster |
548,581 | from torchvision.models.resnet import resnet18, resnet34, resnet50<find_best_params> | def dummies(col,train,test):
train_dum = pd.get_dummies(train[col])
test_dum = pd.get_dummies(test[col])
train = pd.concat([train, train_dum], axis=1)
test = pd.concat([test,test_dum],axis=1)
train.drop(col,axis=1,inplace=True)
test.drop(col,axis=1,inplace=True)
return train, test
dropping = ['PassengerId', 'Name... | Titanic - Machine Learning from Disaster |
548,581 | print_num_params(resnet18(pretrained=False, num_classes=1000))
print_num_params(resnet34(pretrained=False, num_classes=1000))
print_num_params(resnet50(pretrained=False, num_classes=1000))<load_pretrained> | print(train.Pclass.value_counts())
seaborn.factorplot("Pclass",'Survived',data=train,order=[1,2,3])
train, test = dummies('Pclass',train,test ) | Titanic - Machine Learning from Disaster |
548,581 | model_state = torch.load("/kaggle/input/efficientnet-pytorch/efficientnet-b4-e116e8b3.pth")
mapping = {
k: v for k, v in zip(model_state.keys() , model.state_dict().keys())
}
mapped_model_state = OrderedDict([
(mapping[k], v)for k, v in model_state.items()
])
model.load_state_dict(mapped_model_state, strict=False )... | print(train.Sex.value_counts(dropna=False))
seaborn.factorplot('Sex','Survived',data=train)
train,test = dummies('Sex',train,test)
train.drop('male',axis=1,inplace=True)
test.drop('male',axis=1,inplace=True)
| Titanic - Machine Learning from Disaster |
548,581 | with open("/kaggle/input/efficientnet-pytorch/efficientnet-pytorch/EfficientNet-PyTorch-master/examples/simple/labels_map.txt", "r")as h:
labels = json.load(h)
img = Image.open("/kaggle/input/efficientnet-pytorch/efficientnet-pytorch/EfficientNet-PyTorch-master/examples/simple/img.jpg")
tfms = transforms.Compose([tra... | print(train.Cabin.isnull().sum())
print(test.Cabin.isnull().sum())
train.drop('Cabin',axis=1,inplace=True)
test.drop('Cabin',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
548,581 | model.eval()
with torch.no_grad() :
y_pred = model(x)
print('-----')
for idx in torch.topk(y_pred, k=5)[1].squeeze(0 ).tolist() :
prob = torch.softmax(y_pred, dim=1)[0, idx].item()
print('{label:<75}({p:.2f}%)'.format(label=labels[str(idx)], p=prob*100))<import_modules> | def modeling(clf,ft,target):
acc = cross_val_score(clf,ft,target,cv=kf)
acc_lst.append(acc.mean())
return
accuracy = []
def ml(ft,target,time):
accuracy.append(acc_lst)
logreg = LogisticRegression()
modeling(logreg,ft,target)
rf = RandomForestClassifier(n_estimators=50,min_samples_split=4,min_samples_leaf=2)
model... | Titanic - Machine Learning from Disaster |
548,581 | from torchvision.transforms import *
from torch.utils.data import Subset
import torchvision.utils as vutils
import pandas as pd
from sklearn.utils import shuffle<load_from_csv> | train_ft = train.drop('Survived',axis=1)
train_y = train['Survived']
kf = KFold(n_splits=3,random_state=1)
acc_lst = []
ml(train_ft,train_y,'test_1')
| Titanic - Machine Learning from Disaster |
548,581 | df_train = pd.read_csv('.. /input/aptos2019-blindness-detection/train.csv')
df_test = pd.read_csv('.. /input/aptos2019-blindness-detection/test.csv')
x = df_train['id_code']
y = df_train['diagnosis']
x, y = shuffle(x, y)
_ = y.hist()
n_classes = int(y.max() +1)
class_weights = len(y)/ df_train.groupby('diagnosis' )... | train_ft_2=train.drop(['Survived','young'],axis=1)
test_2 = test.drop('young',axis=1)
train_ft.head()
kf = KFold(n_splits=3,random_state=1)
acc_lst=[]
ml(train_ft_2,train_y,'test_2')
| Titanic - Machine Learning from Disaster |
548,581 | train_x, valid_x, train_y, valid_y = train_test_split(x.values, y.values, test_size=0.10, stratify=y, random_state=42)
test_x = df_test.id_code.values
if debug:
train_x, train_y = train_x[:128], train_y[:128]
valid_x, valid_y = valid_x[:64], valid_y[:64]
print(train_x.shape)
print(train_y.shape)
print(valid_x.shape)... | train_ft_3=train.drop(['Survived','young','C'],axis=1)
test_3 = test.drop(['young','C'],axis=1)
train_ft.head()
kf = KFold(n_splits=3,random_state=1)
acc_lst = []
ml(train_ft_3,train_y,'test_3')
| Titanic - Machine Learning from Disaster |
548,581 | class ImageDataset(torch.utils.data.Dataset):
def __init__(self, root, path_list, targets=None, transform=None, extension='.png'):
super().__init__()
self.root = root
self.path_list = path_list
self.targets = targets
self.transform = transform
self.extension = extension
if targets is not None:
assert len(self.path_list... | train_ft_4=train.drop(['Survived','Fare'],axis=1)
test_4 = test.drop(['Fare'],axis=1)
train_ft.head()
kf = KFold(n_splits=3,random_state=1)
acc_lst = []
ml(train_ft_4,train_y,'test_4')
| Titanic - Machine Learning from Disaster |
548,581 | train_transform = Compose([
Resize([resolution]*2, BICUBIC),
ColorJitter(brightness=0.05, contrast=0.05, saturation=0.01, hue=0),
RandomAffine(degrees=15, translate=(0.01, 0.01), scale=(1.0, 1.25), fillcolor=(0,0,0), resample=BICUBIC),
RandomHorizontalFlip() ,
ToTensor() ,
Normalize(*img_stats)
])
test_transform = Co... | accuracy_df=pd.DataFrame(data=accuracy,
index=['test1','test2','test3','test4'],
columns=['logistic','rf','svc1','svc2','knn', 'mlp'])
accuracy_df
| Titanic - Machine Learning from Disaster |
548,581 | train_batch_size = 32
eval_batch_size = 16
num_workers = os.cpu_count()
print('num_workers:', num_workers)
train_loader = DataLoader(train_dataset, batch_size=train_batch_size, num_workers=num_workers,
shuffle=True, drop_last=True, pin_memory=True)
test_loader = DataLoader(test_dataset, batch_size=eval_batch_size, nu... | svc = SVC()
svc.fit(train_ft_4,train_y)
svc_pred = svc.predict(test_4)
print(svc.score(train_ft_4,train_y))
submission_test = pd.read_csv(".. /input/test.csv")
submission = pd.DataFrame({"PassengerId":submission_test['PassengerId'],
"Survived":svc_pred})
submission.to_csv("kaggle_SVC.csv",index=False ) | Titanic - Machine Learning from Disaster |
3,139,705 | model.eval()
with torch.no_grad() :
y_pred = model.cuda()(batch[0][:1].cuda())
print('-----')
for idx in torch.topk(y_pred, k=5)[1].squeeze(0 ).tolist() :
prob = torch.softmax(y_pred, dim=1)[0, idx].item()
print('{label:<75}({p:.2f}%)'.format(label=labels[str(idx)], p=prob*100))<set_options> | test_data_with_labels = pd.read_csv('.. /input/titanic-test-data/titanic.csv')
test_data = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
3,139,705 | del batch
torch.cuda.empty_cache()
gc.collect()<choose_model_class> | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
3,139,705 | model.head[6] = nn.Linear(in_features, n_classes+1)
classes =('No DR', 'Mild', 'Moderate', 'Severe', 'Proliferative DR' )<set_options> | for i, name in enumerate(test_data_with_labels['name']):
if '"' in name:
test_data_with_labels['name'][i] = re.sub('"', '', name)
for i, name in enumerate(test_data['Name']):
if '"' in name:
test_data['Name'][i] = re.sub('"', '', name ) | Titanic - Machine Learning from Disaster |
3,139,705 | assert torch.cuda.is_available()
assert torch.backends.cudnn.enabled, "NVIDIA/Apex:Amp requires cudnn backend to be enabled."
torch.backends.cudnn.benchmark = True
device = "cuda"<train_model> | survived = []
for name in test_data['Name']:
survived.append(int(test_data_with_labels.loc[test_data_with_labels['name'] == name]['survived'].values[-1])) | Titanic - Machine Learning from Disaster |
3,139,705 | <compute_train_metric><EOS> | submission = pd.read_csv('.. /input/titanic/gender_submission.csv')
submission['Survived'] = survived
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
2,531,357 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<compute_test_metric> | df_train = pd.read_csv('.. /input/titanic/train.csv')
df_test = pd.read_csv('.. /input/titanic/test.csv')
df_sub = pd.read_csv('.. /input/titanic/gender_submission.csv' ) | Titanic - Machine Learning from Disaster |
2,531,357 | activation = lambda y: y
def cont_kappa(input, targets, activation=None):
n = len(targets)
y = targets.float().unsqueeze(0)
pred = input.float().squeeze(-1 ).unsqueeze(0)
if activation is not None:
pred = activation(pred)
wo =(pred - y)**2
we =(pred - y.t())**2
return 1 -(n * wo.sum() / we.sum())
<compute_test_me... | df_train.drop(['Name','Ticket','Cabin'],axis=1,inplace=True)
df_test.drop(['Name','Ticket','Cabin'],axis=1,inplace=True)
sex = pd.get_dummies(df_train['Sex'],drop_first=True)
embark = pd.get_dummies(df_train['Embarked'],drop_first=True)
df_train = pd.concat([df_train,sex,embark],axis=1)
df_train.drop(['Sex','Embar... | Titanic - Machine Learning from Disaster |
2,531,357 | kappa_loss = lambda pred, y: 1 - cont_kappa(pred, y )<compute_test_metric> | import torch
import torch.nn as nn
from torch.nn import functional as F
from torch.autograd import Variable | Titanic - Machine Learning from Disaster |
2,531,357 | y = torch.from_numpy(np.random.randint(5, size=6))
preds = torch.ones_like(y.float())* 2
print(y.tolist())
print(preds.tolist())
print(activation(preds ).tolist())
cont_kappa(preds, y), kappa_loss(preds, y), F.mse_loss(preds, y.float() )<compute_train_metric> | class Net(nn.Module):
def __init__(self):
super(Net, self ).__init__()
self.fc1 = nn.Linear(8, 512)
self.fc2 = nn.Linear(512, 512)
self.fc3 = nn.Linear(512, 2)
self.dropout = nn.Dropout(0.2)
def forward(self, x):
x = F.relu(self.fc1(x))
x = self.dropout(x)
x = F.relu(self.fc2(x))
x = self.dropout(x)
x = self.fc3(... | Titanic - Machine Learning from Disaster |
2,531,357 | class MultiTaskLoss(FocalLoss):
def __init__(self, alpha=None, gamma=2.0, second_loss=F.mse_loss, second_mult=0.1):
super().__init__(alpha, gamma)
self.second_loss = second_loss
self.second_mult = second_mult
def forward(self, inputs, targets):
loss = super().forward(inputs[...,:-1], targets)
loss += self.second_mult... | criterion = nn.CrossEntropyLoss() | Titanic - Machine Learning from Disaster |
2,531,357 | criterion = MultiTaskLoss(gamma=2., alpha=class_weights, second_loss=kappa_loss, second_mult=0.5)
lr = 1e-2
optimizer = optim.SGD([
{
"params": chain(model.stem.parameters() , model.blocks.parameters()),
"lr": lr * 0.1,
},
{
"params": model.head[:6].parameters() ,
"lr": lr * 0.2,
},
{
"params": model.head[6].parameter... | optimizer = torch.optim.SGD(model.parameters() , lr=0.01 ) | Titanic - Machine Learning from Disaster |
2,531,357 | if use_amp:
model, optimizer = amp.initialize(model, optimizer, opt_level="O2", num_losses=1 )<train_model> | batch_size = 64
n_epochs = 500
batch_no = len(X_train)// batch_size
train_loss = 0
train_loss_min = np.Inf
for epoch in range(n_epochs):
for i in range(batch_no):
start = i*batch_size
end = start+batch_size
x_var = Variable(torch.FloatTensor(X_train[start:end]))
y_var = Variable(torch.LongTensor(y_train[start:end]))
op... | Titanic - Machine Learning from Disaster |
2,531,357 | def update_fn(engine, batch):
x = convert_tensor(batch[0], device=device, non_blocking=True)
y = convert_tensor(batch[1], device=device, non_blocking=True)
model.train()
y_pred = model(x)
loss = criterion(y_pred, y)
optimizer.zero_grad()
if use_amp:
with amp.scale_loss(loss, optimizer, loss_id=0)as scaled_loss:
sca... | X_test = df_test.iloc[:,1:].values
X_test_var = Variable(torch.FloatTensor(X_test), requires_grad=False)
with torch.no_grad() :
test_result = model(X_test_var)
values, labels = torch.max(test_result, 1)
survived = labels.data.numpy() | Titanic - Machine Learning from Disaster |
2,531,357 | torch.cuda.empty_cache()
gc.collect()
try:
batch = next(iter(train_loader))
res = update_fn(engine=None, batch=batch)
print(res)
finally:
print('max_memory_allocated:', torch.cuda.max_memory_allocated())
del batch
torch.cuda.empty_cache()
_ = gc.collect()<import_modules> | submission = pd.DataFrame({'PassengerId': df_sub['PassengerId'], 'Survived': survived})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
9,726,384 | from ignite.engine import Engine, Events, create_supervised_evaluator
from ignite.metrics import RunningAverage, Accuracy, Precision, Recall, Loss, TopKCategoricalAccuracy
from ignite.contrib.handlers import TensorboardLogger
from ignite.contrib.handlers.tensorboard_logger import OutputHandler, OptimizerParamsHandler<c... | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv')
train_final = pd.read_csv('/kaggle/input/titanic/train.csv')
test_final = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
9,726,384 | def qw_kappa(pred, y):
return cohen_kappa_score(torch.argmax(pred[...,:-1], dim=1 ).cpu().numpy() ,
y.cpu().numpy() ,
weights='quadratic')
def cl_accuracy(pred, y):
return accuracy_score(torch.argmax(pred[...,:-1], dim=1 ).cpu().numpy() ,
y.cpu().numpy())
trainer = Engine(update_fn)
metrics = {
'Loss': Loss(criterio... | train = train.drop(columns= ['Name','Ticket','Cabin'])
test = test.drop(columns= ['Name','Ticket','Cabin'] ) | Titanic - Machine Learning from Disaster |
9,726,384 | log_path = "./log"
tb_logger = TensorboardLogger(log_dir=log_path)
tb_logger.attach(trainer,
log_handler=OutputHandler('training', ['batchloss', ]),
event_name=Events.ITERATION_COMPLETED )<init_hyperparams> | train['Embarked_S'] =(train['Embarked'] == 'S' ).astype(int)
train['Embarked_C'] =(train['Embarked'] == 'C' ).astype(int)
train['Embarked_Q'] =(train['Embarked'] == 'Q' ).astype(int)
train['Gender'] =(train['Sex'] == 'male' ).astype(int ) | Titanic - Machine Learning from Disaster |
9,726,384 | weight_decay = 1e-4
cycle_mult = 2
sim_epochs = 31
epoch_size = len(train_loader)
lr_sched_params = {'param_name':'lr', 'cycle_size':epoch_size, 'cycle_mult':cycle_mult,
'start_value_mult':0.8, 'end_value_mult':0.25}
mom_sched_params = {'param_name':'momentum', 'cycle_size':epoch_size, 'cycle_mult':cycle_mult,
'start_... | test['Embarked_S'] =(test['Embarked'] == 'S' ).astype(int)
test['Embarked_C'] =(test['Embarked'] == 'C' ).astype(int)
test['Embarked_Q'] =(test['Embarked'] == 'Q' ).astype(int)
test['Gender'] =(test['Sex'] == 'male' ).astype(int ) | Titanic - Machine Learning from Disaster |
9,726,384 | scheduler = ParamGroupScheduler(schedulers=schedulers, names=names)
trainer.add_event_handler(Events.ITERATION_STARTED, scheduler )<train_model> | train = train.drop(columns = ['Sex'])
test = test.drop(columns = ['Sex'] ) | Titanic - Machine Learning from Disaster |
9,726,384 | tb_logger.attach(trainer,
log_handler=OptimizerParamsHandler(optimizer, "lr"),
event_name=Events.EPOCH_STARTED )<set_options> | train = train.drop(columns = ['Embarked'])
test = test.drop(columns = ['Embarked'] ) | Titanic - Machine Learning from Disaster |
9,726,384 | def setup_logger(logger):
handler = logging.StreamHandler()
formatter = logging.Formatter("%(asctime)s %(name)-12s %(levelname)-8s %(message)s")
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.INFO )<choose_model_class> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
9,726,384 | trainer.add_event_handler(Events.ITERATION_COMPLETED, TerminateOnNan())
def default_score_fn(engine):
score = engine.state.metrics['ClKappa']
return score
best_model_handler = ModelCheckpoint(dirname=log_path,
filename_prefix="best",
n_saved=10,
score_name="ClKappa",
score_function=default_score_fn,
require_empty=Fals... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
9,726,384 | @trainer.on(Events.EPOCH_STARTED)
def tweak_bn_momenta(engine):
epoch = engine.state.epoch
if epoch <= 6:
momentum = 0.06 / epoch
pbar.log_message(f"setting bn momentum to {momentum}")
for module in model.modules() :
if isinstance(module, nn.modules.batchnorm._BatchNorm):
module.momentum = momentum<train_model> | train.fillna(0,inplace=True)
test.fillna(0,inplace=True ) | Titanic - Machine Learning from Disaster |
9,726,384 | num_epochs = 7 if debug else sim_epochs
state = trainer.run(train_loader, max_epochs=num_epochs )<find_best_params> | X = train.drop(columns = ['Survived'])
y = train['Survived'] | Titanic - Machine Learning from Disaster |
9,726,384 | evaluator.state.metrics<find_best_params> | scaler = MinMaxScaler()
scaled_X = scaler.fit_transform(X ) | Titanic - Machine Learning from Disaster |
9,726,384 | !ls {log_path}
checkpoints = next(os.walk(log_path)) [2]
checkpoints = sorted(filter(lambda f: f.endswith(".pth"), checkpoints))
scores = [c.split('=')[-1][:-4] for c in checkpoints]
best_epoch = np.argmax(scores)
print(best_epoch, scores)
if not checkpoints:
print('No weight files in {}'.format(log_path))
else:
mode... | from sklearn.model_selection import StratifiedKFold
from sklearn.svm import SVC | Titanic - Machine Learning from Disaster |
9,726,384 | best_model = model
best_model.load_state_dict(torch.load(model_path))
best_model = best_model.cuda().eval()<find_best_params> | scores = []
best_svc = SVC(kernel='rbf')
cv = StratifiedKFold(n_splits =10, random_state=42, shuffle=True)
for train_index, test_index in cv.split(scaled_X, y):
print("Train Index: ",train_index)
print("Test Index: ",test_index)
X_train, X_test, y_train, y_test = scaled_X[train_index], scaled_X[test_index], y[train... | Titanic - Machine Learning from Disaster |
9,726,384 | with torch.no_grad() :
y_pred = best_model(batch[0][:16].cuda())
print('Regressor activations:')
print(activation(y_pred[:16,-1] ).reshape([2,8] ).cpu() , '
')
print('Predictions for first item:')
for idx in torch.topk(y_pred[0,:-1], k=n_classes)[1].squeeze(0 ).tolist() :
prob = torch.softmax(y_pred, dim=-1)[0, idx... | print("Overall Score: ",np.mean(scores)) | Titanic - Machine Learning from Disaster |
9,726,384 | del batch<predict_on_test> | scores_alt = cross_val_score(best_svc, scaled_X, y, cv=10)
print("Overall Score: ",np.mean(scores_alt)) | Titanic - Machine Learning from Disaster |
9,726,384 | use_regressor = False
def inference_update_with_tta(engine, batch, use_regressor=use_regressor):
global preds, targets
best_model.eval()
with torch.no_grad() :
x, y = batch
x = x.cuda()
if use_regressor:
y_pred1 = best_model(x)[...,-1]
y_pred2 = best_model(x.flip(dims=(-1,)))[...,-1]
curr_pred =(activation(y_pred1)+ ac... | clf = RandomForestClassifier(n_estimators=1000)
cbc = CatBoostClassifier(eval_metric = 'Accuracy', random_seed = 42, learning_rate=0.01)
xgb = XGBClassifier(n_estimators=1000, learning_rate=0.01, max_depth=3)
lgbm = LGBMClassifier(n_estimators=1000, learning_rate=0.01)
clf_scores = cross_val_score(clf, scaled_X, y,... | Titanic - Machine Learning from Disaster |
9,726,384 | preds, targets = [], []
result_state = inferencer.run(eval_train_loader, max_epochs=1)
print('valid accuracy:',(np.array(preds)== np.array(targets)).mean() )<predict_on_test> | print("Random Forest: ",np.mean(clf_scores))
print("CatBoost: ",np.mean(cbc_scores))
print("XGBoost: ",np.mean(xgb_scores))
print("LightGBM: ",np.mean(lgbm_scores)) | Titanic - Machine Learning from Disaster |
9,726,384 | class KappaOptimizer(nn.Module):
def __init__(self):
super().__init__()
self.coef = [0.5, 1.5, 2.5, 3.5]
self.func = self.quad_kappa
def predict(self, preds):
return self._predict(self.coef, preds)
@classmethod
def _predict(cls, coef, preds):
if type(preds ).__name__ == 'Tensor':
y_hat = preds.clone().view(-1)
else:
... | train_final.fillna(-999,inplace=True)
X = train_final.drop(columns = ['Survived'])
y = train_final['Survived']
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.85, random_state=1234)
features = np.where(X.dtypes!=float)[0]
cbc = CatBoostClassifier(eval_metric = 'Accuracy', random_seed = 42, use... | Titanic - Machine Learning from Disaster |
9,726,384 | preds, targets = [], []
result_state = inferencer.run(test_loader, max_epochs=1 )<predict_on_test> | pred = cbc.predict(X_test)
accuracy_score(y_test, pred ) | Titanic - Machine Learning from Disaster |
9,726,384 | if use_regressor:
preds = kappa_opt.predict(preds ).tolist()<load_from_csv> | test_final.fillna(-999,inplace=True)
predictions = cbc.predict(test_final)
predictions | Titanic - Machine Learning from Disaster |
9,726,384 | submission = pd.DataFrame({'id_code': pd.read_csv('.. /input/aptos2019-blindness-detection/sample_submission.csv' ).id_code.values,
'diagnosis': np.squeeze(preds ).astype(np.int32)})
submission.hist()
submission.head()<save_to_csv> | result = pd.DataFrame({'PassengerId':test['PassengerId'],'Survived':predictions} ) | Titanic - Machine Learning from Disaster |
9,726,384 | submission.to_csv('submission.csv', index=False )<save_to_csv> | result.to_csv("submission.csv", index=False ) | Titanic - Machine Learning from Disaster |
10,577,883 | submission.to_csv('submission.csv', index=False )<set_options> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data_drop = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data['Died'] = 1 - train_data['Survived']
train_data.head() | Titanic - Machine Learning from Disaster |
10,577,883 | %reload_ext autoreload
%autoreload 2
%matplotlib inline
%matplotlib inline
package_path = '.. /input/efficientnet-pytorch/efficientnet-pytorch/EfficientNet-PyTorch-master'
sys.path.append(package_path)
<load_pretrained> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
10,577,883 | md_ef = EfficientNet.from_pretrained('efficientnet-b5', num_classes=1 )<init_hyperparams> | women = train_data.loc[train_data.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
print("% of women survived:", rate_women)
men = train_data.loc[train_data.Sex == 'male']["Survived"]
rate_men = sum(men)/len(men)
print("% of men survived:", rate_men ) | Titanic - Machine Learning from Disaster |
10,577,883 | class ImagePreprocessor(object):
def __init__(self, root_dir: str, save_dir: str, img_size: int, tolerance: int = 10, remove_outer_pixels: float = 0.0):
if remove_outer_pixels > 0.50:
print("ERROR: eroding more than 50% of image")
raise InterruptedError
self.root_dir = root_dir
self.img_size = img_size
self.toleranc... | test_data["Fare"] = test_data["Fare"].fillna(test_data["Fare"].median())
train_data['FareGroup'] = pd.cut(train_data['Fare'],4)
print(train_data[['FareGroup', 'Survived']].groupby('FareGroup', as_index=False ).mean().sort_values('Survived', ascending=False))
def group_fare(fare):
if fare <= 128: return 0
if fare > 12... | Titanic - Machine Learning from Disaster |
10,577,883 | 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=['... | y = train_data["Survived"]
features = ["Pclass", "Sex", "SibSp", "Parch", "Age","Embarked","Fare Group"]
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
imp = SimpleImputer()
imp_X = imp.fit_transform(X)
imp_X_test = imp.transform(X_test)
model1 = RandomForestClassifier(n_estim... | Titanic - Machine Learning from Disaster |
10,577,883 | bs = 64
sz = 224
tfms = get_transforms(do_flip=True,flip_vert=True )<compute_test_metric> | model2 = GradientBoostingClassifier(random_state=42)
model2.fit(imp_X,y)
predictions2 = model2.predict(imp_X_test)
model2_preds = cross_val_predict(model2, imp_X, y)
model2_acc = accuracy_score(y, model2_preds)
print("Gradient Booster Accuracy:", model2_acc ) | Titanic - Machine Learning from Disaster |
10,577,883 | def qk(y_pred, y):
return torch.tensor(cohen_kappa_score(torch.round(y_pred), y, weights='quadratic'), device='cuda:0' )<load_pretrained> | model3 = XGBClassifier(max_depth=3, n_estimators=1000, learning_rate=0.05)
model3.fit(imp_X, y)
predictions3 = model3.predict(imp_X_test)
model3_preds = cross_val_predict(model3, imp_X, y)
model3_acc = accuracy_score(y, model3_preds)
print("XGBoost Accuracy:", model3_acc ) | Titanic - Machine Learning from Disaster |
10,577,883 | learn = Learner(data,
md_ef,
metrics = [qk],
model_dir="models")
learn.data.add_test(ImageList.from_df(test_df,
'test_processed/',
folder='',
suffix='.png',
))
learn.load('abcdef')
pass<categorify> | model4 = SVC(random_state = 1)
model4.fit(imp_X, y)
predictions4 = model4.predict(imp_X_test)
model4_preds = cross_val_predict(model4, imp_X, y)
model4_acc = accuracy_score(y, model4_preds)
print("SVC Accuracy:", model4_acc ) | Titanic - Machine Learning from Disaster |
10,577,883 | learn.to_fp32()
pass<compute_test_metric> | output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions1})
output.to_csv('my_submission.csv', index=False)
print("Your submission was succesfully saved!" ) | Titanic - Machine Learning from Disaster |
7,824,947 | 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 < coef... | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head(10)
train_data.tail(10)
train_data.query('Cabin == Cabin' ).shape
test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
7,824,947 | learn.dl(DatasetType.Test ).dataset.tfms=[]
op = _TTA(learn,ds_type=DatasetType.Test)
op_1 = [2*p-4 for p in op]<load_pretrained> | len(train_data.loc[(train_data.Sex == 'female')&(train_data.Survived == 1)]["Survived"])
train_data.loc[:,["Name", "Age", "Pclass"]]
train_data[["Name", "Age", "Pclass"]]
women = train_data.loc[train_data.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
print("% of women who survived:", rate_women)
me... | Titanic - Machine Learning from Disaster |
7,824,947 | !cp.. /input/l1-aptos/L1.pkl export.pkl
learn = load_learner('',test=ImageList.from_df(test_df,
'test_processed/',
folder='',
suffix='.png',
))
learn.dl(DatasetType.Test ).dataset.tfms=[]
op_2 = _TTA(learn,ds_type=DatasetType.Test )<feature_engineering> | y = train_data["Survived"]
features = ["Pclass", "Sex", "SibSp", "Parch"]
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)
actual = model.predict(X)
predictions = model.predict(X_test)... | Titanic - Machine Learning from Disaster |
7,824,947 | p = [0] * len(op_1)
for i in range(len(op_1)) :
p[i] =(op_1[i]+op_2[i])/2<save_to_csv> | y = train_data["Survived"]
features = ["Pclass", "Sex", "SibSp", "Parch", "Embarked"]
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
X['Age'] = train_data['Age']
X['Fare'] = train_data['Fare']
X['Cabin'] = np.where(train_data['Cabin'].isna() ==True,0,1)
X.groupby('Cabin' ).coun... | Titanic - Machine Learning from Disaster |
7,824,947 | <groupby><EOS> | np.random.seed(7)
| Titanic - Machine Learning from Disaster |
9,762,575 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<import_modules> | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Titanic - Machine Learning from Disaster |
9,762,575 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import LabelEncoder
from itertools import product
from sklearn.feature_extraction.text import TfidfVectorizer
import re
from xgboost import XGBRegressor
from sklearn.ensemble import RandomForestClassi... | train = pd.read_csv(".. /input/titanic/train.csv")
test = pd.read_csv(".. /input/titanic/test.csv")
data_cleaner = [train, test]
train.describe(include="all")
sub = test['PassengerId'] | Titanic - Machine Learning from Disaster |
9,762,575 | train = pd.read_csv(".. /input/competitive-data-science-predict-future-sales/sales_train.csv")
test = pd.read_csv(".. /input/competitive-data-science-predict-future-sales/test.csv")
item_category = pd.read_csv(".. /input/competitive-data-science-predict-future-sales/item_categories.csv")
item = pd.read_csv(".. /inpu... | print(pd.isnull(train ).sum())
| Titanic - Machine Learning from Disaster |
9,762,575 |
<import_modules> | print(pd.isnull(test ).sum())
| Titanic - Machine Learning from Disaster |
9,762,575 |
<choose_model_class> | for data in data_cleaner:
print(data.isnull().sum())
print('
')
| Titanic - Machine Learning from Disaster |
9,762,575 |
<save_to_csv> | age_ref = pd.DataFrame(data=[train.groupby('Pclass')['Age'].mean() ],columns=train['Pclass'].unique())
age_ref
| Titanic - Machine Learning from Disaster |
9,762,575 |
<data_type_conversions> | def fill_age(pclass,age):
if pd.isnull(age):
return float(age_ref[pclass])
else:
return age
for data in data_cleaner:
data['Age'] = train.apply(lambda x: fill_age(x['Pclass'],x['Age']), axis=1)
| Titanic - Machine Learning from Disaster |
9,762,575 | train['date'] = pd.to_datetime(train['date'],format = '%d.%m.%Y' )<filter> | def fill_fare(fare):
if pd.isnull(fare):
return train['Fare'].mean()
else:
return fare
def fill_embark(embark):
if pd.isnull(embark):
return train['Embarked'].mode().iloc[0]
else:
return embark
for data in data_cleaner:
data['Fare'] = train.apply(lambda x: fill_fare(x['Fare']), axis=1)
data['Embarked'] = train.apply(l... | Titanic - Machine Learning from Disaster |
9,762,575 | train[train.item_price > 100000]<filter> | for data in data_cleaner:
data.drop(['Cabin'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
9,762,575 | train[train.item_price < 0]<filter> | for data in data_cleaner:
print(data.isnull().sum())
print('
' ) | Titanic - Machine Learning from Disaster |
9,762,575 | train[train.item_cnt_day >= 1000]<filter> | title_list = list()
for data in data_cleaner:
for title in data['Name']:
title = title.split('.')[0].split(',')[1]
title_list.append(title)
data['Title'] = title_list
title_list = list() | Titanic - Machine Learning from Disaster |
9,762,575 | train[train.item_cnt_day < 0]<feature_engineering> | train['Title'] = train['Title'].replace([ ' Don', ' Rev', ' Dr', ' Mme',' Ms', ' Major', ' Lady', ' Sir', ' Mlle', ' Col', ' Capt',
' the Countess', ' Jonkheer'], 'Others')
train['Title'].value_counts()
| Titanic - Machine Learning from Disaster |
9,762,575 | shop["city"] = shop.shop_name.str.split(" " ).map(lambda x: x[0])
shop["type"] = shop.shop_name.str.split(" " ).map(lambda x: x[1] )<categorify> | test['Title'] = test['Title'].replace([ ' Don', ' Rev', ' Dr', ' Mme',' Ms', ' Major', ' Lady', ' Sir', ' Mlle', ' Col', ' Capt',
' the Countess', ' Jonkheer',' Dona'], 'Others')
test['Title'].value_counts() | Titanic - Machine Learning from Disaster |
9,762,575 | shop["shop_type"] = LabelEncoder().fit_transform(shop.type)
shop["shop_city"] = LabelEncoder().fit_transform(shop.city)
shop.head()<feature_engineering> | def get_size(df):
if df['SibSp'] + df['Parch'] + 1 == 1:
return 'Single'
if df['SibSp'] + df['Parch'] + 1 > 1:
return 'Small'
if df['SibSp'] + df['Parch'] + 1 > 4:
return 'Big'
for data in data_cleaner:
data['FamilySize'] = data.apply(get_size,axis=1)
for data in data_cleaner:
data['IsAlone'] = 1
data['IsAlone'].loc[d... | Titanic - Machine Learning from Disaster |
9,762,575 | item_category['item_type'] = item_category['item_category_name'].str.split('-' ).map(lambda x: x[0])
item_category['item_name'] = item_category['item_category_name'].str.split('-' ).map(lambda x: x[1].strip() if len(x)> 1 else x[0].strip())
item_category.head()<categorify> | sex = pd.get_dummies(train['Sex'],drop_first=True)
embark = pd.get_dummies(train['Embarked'],drop_first=True)
title = pd.get_dummies(train['Title'],drop_first=True)
Pclass = pd.get_dummies(train['Pclass'],drop_first=True)
FamilySize = pd.get_dummies(train['FamilySize'],drop_first=True)
sex2 = pd.get_dummies(test['... | Titanic - Machine Learning from Disaster |
9,762,575 | item_category['item_type_code'] = LabelEncoder().fit_transform(item_category.item_type)
item_category['item_name_code'] = LabelEncoder().fit_transform(item_category.item_name)
item_category.head()<drop_column> | X = train.drop('Survived',axis=1)
y = train['Survived']
x_test = test
| Titanic - Machine Learning from Disaster |
9,762,575 | item_category = item_category[['item_category_id', 'item_type_code', 'item_name_code']]
item_category.head()<string_transform> | warnings.simplefilter("ignore" ) | Titanic - Machine Learning from Disaster |
9,762,575 | def clean_text(item_name):
item_name = item_name.lower()
item_name = re.sub(r'[^\w\s]', '', item_name)
item_name = re.sub(r'\d+', '', item_name)
item_name = re.sub(' +', ' ', item_name)
item_name = item_name.strip()
return item_name<feature_engineering> | logreg = LogisticRegression(class_weight='balanced')
param = {'C':[0.001,0.003,0.005,0.01,0.03,0.05,0.1,0.3,0.5,1,2,3,3,4,5,10,20]}
clf = GridSearchCV(logreg,param,scoring='roc_auc',refit=True,cv=10)
clf.fit(X,y)
print('Best roc_auc: {:.4}, with best C: {}'.format(clf.best_score_, clf.best_params_)) | Titanic - Machine Learning from Disaster |
9,762,575 | item['clean_item_name'] = item['item_name'].apply(clean_text)
item.head()<feature_engineering> | seed = 60
kf = StratifiedKFold(n_splits=5,shuffle=True,random_state=seed)
pred_test_full =0
cv_score =[]
i=1
for train_index,test_index in kf.split(X,y):
print('{} of KFold {}'.format(i,kf.n_splits))
xtr,xvl = X.loc[train_index],X.loc[test_index]
ytr,yvl = y.loc[train_index],y.loc[test_index]
lr = LogisticRegression(C... | Titanic - Machine Learning from Disaster |
9,762,575 | item['sub_name1'] = item['clean_item_name'].str.split(' ' ).map(lambda x: x[0])
item['sub_name2'] = item['clean_item_name'].str.split(' ' ).map(lambda x: x[1].strip() if len(x)> 1 else x[0].strip())
item.head()<count_unique_values> | print('Confusion matrix
',confusion_matrix(yvl,lr.predict(xvl)))
print('Cv',cv_score,'
Mean cv Score',np.mean(cv_score)) | Titanic - Machine Learning from Disaster |
9,762,575 | <count_unique_values><EOS> | y_pred = pred_test_full/5
submit = pd.DataFrame({'PassengerId':sub,'Survived':y_pred})
submit['Survived'] = submit['Survived'].apply(lambda x: 1 if x>0.5 else 0)
submit.to_csv('lr_titanic.csv',index=False)
submit | Titanic - Machine Learning from Disaster |
9,963,645 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
9,963,645 | item['sub_name_1'] = LabelEncoder().fit_transform(item.sub_name1)
item['sub_name_2'] = LabelEncoder().fit_transform(item.sub_name2)
item.head()<concatenate> | df_train = pd.read_csv('/kaggle/input/titanic/train.csv')
df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
id_train = df_train['PassengerId']
id_test = df_test['PassengerId']
df = pd.concat([df_train, df_test])
df = df.set_index('PassengerId')
df.info()
df | Titanic - Machine Learning from Disaster |
9,963,645 | len(set(test.item_id)- set(test.item_id ).intersection(set(train.item_id)) )<data_type_conversions> | def category_to_one_hot(df, name_column):
one_hot = pd.get_dummies(df[name_column], prefix=name_column, prefix_sep='-')
df = pd.concat([df, one_hot], axis=1)
df = df.drop(name_column, axis=1)
return df, one_hot
def exclude_low_category(df, name_column, threshold_using_category):
df_value_counts = df[name_column].val... | Titanic - Machine Learning from Disaster |
9,963,645 | matrix = []
cols = ['date_block_num','shop_id','item_id']
for i in range(34):
sales = train[train.date_block_num==i]
matrix.append(np.array(list(product([i], sales.shop_id.unique() , sales.item_id.unique())) , dtype='int16'))
matrix = pd.DataFrame(np.vstack(matrix), columns=cols)
matrix['date_block_num'] = matrix['dat... | name_column = 'Pclass'
print(df[name_column].value_counts(dropna=False))
df, one_hot = category_to_one_hot(df, name_column)
one_hot | 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.