def main():
batch_size = 32
# train
cifar_train = datasets.CIFAR10('cifar',
True,
transform=transforms.Compose([
transforms.Resize((32, 32)),
transforms.ToTensor()
]),
download=True)
cifar_train = dataloader(cifar_train, batch_size=batch_size, shuffle=True)
# validation
cifar_test = datasets.CIFAR10('cifar',
False,
transform=transforms.Compose([
transforms.Resize((32, 32)),
transforms.ToTensor()
]),
download=True)
cifar_test = dataloader(cifar_test, batch_size=batch_size, shuffle=True)
x, label = iter(cifar_train).next()
print('x: ', x.shape, 'label: ', label.shape)
def main():
# arg parser
args = arg_parser()
# set seed
set_seed(args.seed)
# dataset
id_traindata = datasets.CIFAR10('./data/', train=True, download=True)
id_testdata = datasets.CIFAR10('./data/', train=False, download=True)
id_traindata = RotDataset(id_traindata, train_mode=True)
id_testdata = RotDataset(id_testdata, train_mode=False)
# data loader
if args.method == 'rot' or args.method == 'msp':
train_loader = dataloader(id_traindata,
batch_size=args.batch_size,
num_workers=args.num_workers,
pin_memory=True)
else:
raise ValueError(args.method)
test_loader = dataloader(id_testdata,
batch_size=args.batch_size,
num_workers=args.num_workers,
pin_memory=True)
# model
num_classes = 10
model = WideResNet(args.layers,
num_classes,
args.widen_factor,
dropRate=args.droprate)
model.rot_head = nn.Linear(128, 4)
model = model.cuda()
# optimizer
optimizer = torch.optim.SGD(model.parameters(),
args.learning_rate,
momentum=args.momentum,
weight_decay=args.decay,
nesterov=True)
# training
for epoch in range(1, args.epochs + 1):
train_loss = train(args,
epoch,
model,
train_loader,
optimizer,
lr_scheduler=None)
test_loss, test_acc = test(args, model, test_loader)
print('epoch:{}, train_loss:{}, test_loss:{}, test_acc:{}'.format(
epoch, round(train_loss.item(), 4), round(test_loss.item(), 4),
round(test_acc, 4)))
torch.save(model.state_dict(),
'./trained_model_{}.pth'.format(args.method))
def main():
# arg parser
args = arg_parser()
# set seed
set_seed(args.seed)
# dataset
id_testdata = datasets.CIFAR10('./data/', train=False, download=True)
id_testdata = RotDataset(id_testdata, train_mode=False)
if args.ood_dataset == 'cifar100':
ood_testdata = datasets.CIFAR100('./data/', train=False, download=True)
elif args.ood_dataset == 'svhn':
ood_testdata = datasets.SVHN('./data/', split='test', download=True)
else:
raise ValueError(args.ood_dataset)
ood_testdata = RotDataset(ood_testdata, train_mode=False)
# data loader
id_test_loader = dataloader(id_testdata, batch_size=args.batch_size, num_workers=args.num_workers, pin_memory=True)
ood_test_loader = dataloader(ood_testdata, batch_size=args.batch_size, num_workers=args.num_workers, pin_memory=True)
# load model
num_classes = 10
model = WideResNet(args.layers, num_classes, args.widen_factor, dropRate=args.droprate)
model.rot_head = nn.Linear(128, 4)
model = model.cuda()
model.load_state_dict(torch.load('./models/trained_model_{}.pth'.format(args.method)))
TODO:
def train(**kwargs):
for k_, v_ in kwargs:
setattr(config, k_, v_)
train_dataset, val_dataset, test_dataset = Ali(config)
train_loader = dataloader(dataset=train_dataset, batch_size=config.batch_size,
shuffle=True, drop_last=True)
val_loader = dataloader(dataset=val_dataset, batch_size=config.batch_size)
model = DeepFM()
# testing
if config.test_flag:
test_loader = dataloader(dataset=test_dataset, batch_size=config.batch_size)
model.load_state_dict(torch.load(os.path.join(config.model_path, '_best')))
test(model, test_loader, config.output_path)
criterion = torch.nn.BCELoss()
optimizer = Adam(model.parameters, lr=config.lr, betas=(config.beta1, config.beta2))
best_val_loss = 1e6
if torch.cuda.is_available():
model.cuda()
criterion.cuda()
# resume training
start = 0
if config.resume:
model_epoch = [int(fname.split('_')[-1]) for fname in os.listdir(config.model_path)
if 'best' not in fname]
start = max(model_epoch)
model.load_state_dict(torch.load(os.path.join(config.model_path, '_epoch_{start}')))
if start >= config.epochs:
print('Training already Done!')
return
for i in range(start, config.epochs):
for ii, (c_data, labels) in enumerate(train_loader):
c_data = to_var(c_data)
labels = to_var(labels)
pred = model(c_data)
loss = criterion(pred, labels, criterion)
loss.backward()
optimizer.step()
if (ii + 1) % config.eval_every == 0:
val_loss = val(model, val_loader)
print(f'''epochs: {i + 1}/{config.epochs} batch: {ii + 1}/{len(train_loader)}\t
train_loss: {loss.data[0] / c_data.size(0)}, val_loss: {val_loss}''')
torch.save(model.state_dict(), os.path.join(config.model_path, '_epoch_{i}'))
if val_loss < best_val_loss:
torch.save(model.state_dict(), os.path.join(config.model_path, '_best'))
def split_data(datasets,
train_idx,
test_idxsamplers=torch.utils.data.SubsetRandomSampler,
batchsize=200):
test_smp, train_smp = samplers(test_idx), samplers(train_idx)
# returns train_loader, valid_loader, test_loader
train_loader, test_loader = dataloader(datasets,
sampler=train_smp,
batch_size=batchsize), dataloader(
datasets,
sampler=test_smp,
batch_size=batchsize)
return train_loader, test_loader
def main():
op = options
opt = op.parse()
# initialize train or test working directory
opt.model_dir = os.path.join("results",opt.name)
logging.info = ("model directory %s" % opt.model_dir)
if not os.path.exists(opt.model_dir):
os.makedirs(opt.model_dir)
log_dir = opt.model_dir
log_path = log_dir + "/train.log"
util.opt2file(opt, log_dir + "/opt.txt")
#log setting
log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
formatter = logging.Formatter(log_format)
fh = logging.FileHandler(log_path, 'a')
fh.setFormatter(formatter)
ch = logging.StreamHandler()
ch.setFormatter(formatter)
logging.getLogger().addHandler(fh)
logging.getLogger().addHandler(ch)
log_level = logging.INFO
logging.getLogger().setLevel(log_level)
#define database
indices = list(range(opt.num_example))
rand_indices = np.random.RandomState(0)
rand_indices.shuffle(indices)
train_idx = indices[0:0.9*len(indices)]
valid_idx = indices[0.9*len(indices)::]
ds_train = Try_On_dataset(root=opt.data_dir,
indices=train_idx,
data_aug=opt.data_aug,
img_size=opt.img_size,
crop_size=opt.crop_size)
ds_valid = Try_On_dataset(root=opt.data_dir,
indices=valid_idx,
data_aug=opt.data_aug,
img_size=opt.img_size,
crop_size=opt.crop_size)
loader_train = dataloader(ds_train,shuffel=True,batch_size=opt.batch_size,num_workers=opt.num_wokers)
loader_valid = dataloader(ds_valid,shuffel=True,batch_size=opt.batch_size,num_workers=opt.num_wokers)
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
]),
download=True)
test_dataset = datasets.MNIST(root='./data',
train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
]),
download=True)
train_loader = dataloader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
test_loader = dataloader(dataset=test_dataset,
batch_size=batch_size,
shuffle=False)
model = LogisticRegression(input_dim, output_dim)
model.cuda()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=lr_rate)
# start training
total_step = len(train_loader)
for epoch in range(num_epochs):
for i, (images, labels) in enumerate(train_loader):
import torch.nn as nn
from torch.utils.data import DataLoader as dataloader
from torch.autograd import Variable
mean_grey = 0.1307
stddev_grey = 0.3081
batch_size = 100
transforms = transforms.Compose([transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize((mean_grey, ), (stddev_grey, ))])
test_datasets = datasets.MNIST(root=r'./data',
train=False,
transform=transforms)
test_loader = dataloader(dataset=test_datasets,
shuffle=False,
batch_size=batch_size)
net = CNN()
CUDA = torch.cuda.is_available()
if CUDA:
net = net.cuda()
loss_function = nn.CrossEntropyLoss()
weights = torch.load('./weights/mnist_weights.pth.tar', map_location='cpu')
net.load_state_dict(weights)
import torch.nn as nn
from torch.nn import functional as F
from tqdm.notebook import tqdm
from torch.utils.data import DataLoader as dataloader
# Loading Up the data from the dataset
Train_Data = datasets.MNIST(root="./datasets",
train=True,
transform=transforms.ToTensor(),
download=True)
Test_Data = datasets.MNIST(root="./datasets",
train=False,
transform=transforms.ToTensor(),
download=True)
Train_Loader = dataloader(Train_Data, batch_size=200, shuffle=True)
Test_Loader = dataloader(Test_Data, batch_size=200, shuffle=False)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Building the model class
class Net(nn.Module):
def __init__(self):
super().__init__()
self.Layer1 = nn.Linear(784, 500)
self.Layer2 = nn.Linear(500, 10)
def forward(self, x):
x = x.view(-1, 784)
x = F.relu(self.Layer1(x))
num_epochs = 50
mean_grey = 0.1307
stddev_grey = 0.3081
transforms = transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize((mean_grey, ), (stddev_grey, ))
])
train_datasets = datasets.MNIST(root=r'./data',
train=True,
transform=transforms,
download=True)
train_loader = dataloader(dataset=train_datasets,
shuffle=True,
batch_size=batch_size)
net = CNN()
CUDA = torch.cuda.is_available()
if CUDA:
net = net.cuda()
optimizer = torch.optim.SGD(net.parameters(), lr=0.01)
loss_function = nn.CrossEntropyLoss()
train_loss = []
train_accuracy = []
for epoch in range(num_epochs):
def load_data_dataloader(self, batch_size):
x = []
y = []
itr = 0
with open(self.data_path) as file:
for line in file:
# skip first line (title)
if itr == 0:
itr += 1
continue
if itr % 10000 == 0:
print("Loaded: ", itr)
if itr >= self.num_data_points:
break
line_vars = line.split('\t')
peptide_sequence = line_vars[0]
retention_time = float(line_vars[1].rstrip('\n'))
# skip len > 20
if len(peptide_sequence) > self.max_length_sequence:
continue
peptide_matrix = self.peptide_seq_to_onehot_matrix(
peptide_sequence)
x.append(peptide_matrix)
y.append(retention_time)
if self.backwards:
x.append(peptide_matrix[::-1])
y.append(retention_time)
itr += 1
print("loaded: {}".format(self.data_path))
#test train split
cutoff = math.floor(len(x) * .9)
X_train = torch.Tensor(x[:cutoff])
Y_train = torch.Tensor(y[:cutoff])
X_val = torch.Tensor(x[cutoff:])
Y_val = torch.Tensor(y[cutoff:])
my_dataset = torch.utils.data.TensorDataset(
X_train, Y_train) # create your datset
my_dataloader = dataloader(my_dataset,
batch_size=batch_size,
shuffle=True) # create your dataloader
my_dataset_val = torch.utils.data.TensorDataset(
X_val, Y_val) # create your datset
my_dataloader_val = dataloader(
my_dataset_val, batch_size=batch_size,
shuffle=True) # create your dataloader
return my_dataloader, my_dataloader_val
def create_dataloader(config):
dataloader = find_model_using_name("data_loader.data_loaders",
config['data_loader']['type'])
instance = dataloader(config)
print("dataset [%s] was created" % (config['data_loader']['type']))
return instance
def main(args):
# set seed
set_seed(args.seed)
# dataset
id_testdata = datasets.CIFAR10('./data/', train=False, download=True)
id_testdata = RotDataset(id_testdata, train_mode=False)
if args.ood_dataset == 'cifar100':
ood_testdata = datasets.CIFAR100('./data/', train=False, download=True)
elif args.ood_dataset == 'svhn':
ood_testdata = datasets.SVHN('./data/', split='test', download=True)
else:
raise ValueError(args.ood_dataset)
ood_testdata = RotDataset(ood_testdata, train_mode=False)
# data loader
id_test_loader = dataloader(id_testdata,
batch_size=args.batch_size,
num_workers=args.num_workers,
pin_memory=True)
ood_test_loader = dataloader(ood_testdata,
batch_size=args.batch_size,
num_workers=args.num_workers,
pin_memory=True)
# load model
num_classes = 10
model = WideResNet(args.layers,
num_classes,
args.widen_factor,
dropRate=args.droprate)
model.rot_head = nn.Linear(128, 4)
model = model.to(device)
model.load_state_dict(
torch.load('./models/trained_model_{}.pth'.format(args.method),
map_location=device))
# TODO:
## 1. calculate ood score by two methods(MSP, Rot)
model.eval()
id_testdata_score, ood_testdata_score = [], []
for idx, loader in enumerate([id_test_loader, ood_test_loader]):
for x_tf_0, x_tf_90, x_tf_180, x_tf_270, batch_y in tqdm(loader):
batch_size = x_tf_0.shape[0]
batch_x = torch.cat([x_tf_0, x_tf_90, x_tf_180, x_tf_270],
0).to(device)
batch_y = batch_y.to(device)
batch_rot_y = torch.cat(
(torch.zeros(batch_size), torch.ones(batch_size),
2 * torch.ones(batch_size), 3 * torch.ones(batch_size)),
0).long().to(device)
logits, pen = model(batch_x)
classification_probabilities = F.softmax(logits[:batch_size],
dim=-1)
rot_logits = model.rot_head(pen)
classification_loss = torch.max(classification_probabilities,
dim=-1)[0].data.cpu()
rotation_loss = F.cross_entropy(rot_logits,
batch_rot_y,
reduction='none').data
uniform_distribution = torch.zeros_like(
classification_probabilities).fill_(1 / num_classes)
kl_divergence_loss = nn.KLDivLoss(reduction='none')(
classification_probabilities.log(), uniform_distribution).data
for i in range(batch_size):
if args.method == 'msp':
score = -classification_loss[i]
elif args.method == 'rot':
rotation_loss_tensor = torch.tensor([
rotation_loss[i], rotation_loss[i + batch_size],
rotation_loss[i + 2 * batch_size],
rotation_loss[i + 3 * batch_size]
])
score = -torch.sum(kl_divergence_loss[i]) + torch.mean(
rotation_loss_tensor)
if idx == 0:
id_testdata_score.append(score)
elif idx == 1:
ood_testdata_score.append(score)
y_true = torch.cat((torch.zeros(
len(id_testdata_score)), torch.ones(len(ood_testdata_score))), 0)
y_score = torch.cat(
(torch.tensor(id_testdata_score), torch.tensor(ood_testdata_score)),
0).float()
## 2. calculate AUROC by using ood scores
print(f"dataset : {args.ood_dataset}, method : {args.method}")
print(roc_auc_score(y_true, y_score))
batch_size = 64
learning_rate = 1e-2
num_epoches = 20
data_tf = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])])
train_dataset = datasets.MNIST(root='./MNIST_data',
train=True,
transform=data_tf,
download=True)
test_dataset = datasets.MNIST(root='./MNIST_data',
train=False,
transform=data_tf)
train_loader = dataloader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = dataloader(test_dataset, batch_size=batch_size, shuffle=True)
model = simplenn.Net(28 * 28, 300, 100, 10)
if torch.cuda.is_available():
model = model.cuda()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)
model.eval()
eval_loss = 0
eval_acc = 0
print(eval_acc.size(0))
for data in test_loader:
