def main():
args = parse_args()
num_classes = 10 if args.dataset == 'CIFAR10' else 100
have_cuda = torch.cuda.is_available()
def cast(x):
return x.cuda() if have_cuda else x
checkpoint = torch.load(args.checkpoint)
weights_unpacked = {}
for k, w in checkpoint.items():
if w.dtype == torch.uint8:
# weights are packed with np.packbits function
scale = np.sqrt(2 / (w.shape[1] * w.shape[2] * w.shape[3] * 8))
signed = np.unpackbits(w, axis=1).astype(np.int) * 2 - 1
weights_unpacked[k[7:]] = torch.from_numpy(signed).float() * scale
else:
weights_unpacked[k[7:]] = w
model = WRN_McDonnell(args.depth, args.width, num_classes)
model.load_state_dict(weights_unpacked)
model = cast(model)
model.eval()
class_acc = ClassErrorMeter(accuracy=True)
for inputs, targets in tqdm(DataLoader(create_dataset(args, train=False), 256)):
with torch.no_grad():
class_acc.add(model(cast(inputs)).cpu(), targets)
print(class_acc.value())
def validate(val_loader, model, criterion, opt):
data_time = TimeMeter(unit=1)
losses = AverageValueMeter()
errors = ClassErrorMeter(topk=[1])
# switch to evaluate mode
if isinstance(model, list):
for m in model:
m.eval()
else:
model.eval()
with torch.no_grad():
end = time.time()
for i, (win_past, inp_pred, labels, min_values) in enumerate(zip(*val_loaders)):
win_past = win_past.cuda(opt['g'], non_blocking=True)
inp_pred = inp_pred.cuda(opt['g'], non_blocking=True)
labels = labels.cuda(opt['g'], non_blocking=True)
min_values = min_values.cuda(opt['g'], non_blocking=True)
# compute output
yh_cl, yh_reg = basik_tasks_model(win_past, win_pred)
loss = criterion[0](yh_cl, labels)
ctx.losses['cl'].add(loss.item())
loss += opt['lambda'] * criterion[1](output, min_values)
# measure accuracy and record loss
errors.add(yh_cl.data, targets[0].data)
losses['reg'].add(loss.item() - ctx.losses['cl'].value())
losses['tot'].add(loss.item())
errors.add(yh_cl, labels)
losses.add(loss.item())
loss = losses['tot'].value()[0]
top1 = errors.value()[0]
# if i % opt['print_freq'] == 0:
# print('[{0}/{1}]\t'
# 'Time {time:.3f}\t'
# 'Loss {loss:.4f}\t'
# 'Err@1 {top1:.3f}\t'
# 'Err@5 {top5:.3f}'.format(
# i,
# len(val_loader),
# time=data_time.value(), loss=loss,
# top1=top1, top5=top5))
print('Loss {loss:.4f}'
' * Err@1 {top1:.3f}\t'
.format(loss=loss, top1=top1))
stats = {'loss': loss, 'top1': top1}
ctx.metrics = stats
return stats
def train(train_loader, model, criterion, optimizer, epoch, opt):
data_time = TimeMeter(unit=1)
ctx.losses['cl'] = AverageValueMeter()
ctx.losses['reg'] = AverageValueMeter()
ctx.losses['tot'] = AverageValueMeter()
ctx.errors = ClassErrorMeter(topk=[1])
# switch to train mode
if isinstance(model, list):
for m in model:
m.train()
else:
model.train()
# end = time.time()
for i, (win_past, inp_pred, labels, min_values) in enumerate(zip(*train_loaders)):
# tmp var (for convenience)
ctx.i = i
win_past = win_past.cuda(opt['g'], non_blocking=True)
inp_pred = inp_pred.cuda(opt['g'], non_blocking=True)
labels = labels.cuda(opt['g'], non_blocking=True)
min_values = min_values.cuda(opt['g'], non_blocking=True)
inputs = (win_past, inp_pred)
targets = (labels, min_values)
stats = runner(inputs, targets, model, criterion, optimizer)
loss = stats['loss']
top1 = stats['top1']
if i % opt['print_freq'] == 0:
print('Epoch: [{0}][{1}/{2}]\t'
'Time {time:.3f}\t'
'Loss {loss:.4f}\t'
'Err@1 {top1:.3f}'.format(
epoch, i, len(train_loader),
time=data_time.value(), loss=loss,
top1=top1))
return stats
def main(args):
# region -----------------------------------------记录训练日志-----------------------------------------
if 0 == len(args.resume):
logger = Logger('./logs/' + args.model + '.log')
else:
logger = Logger('./logs/' + args.model + '.log', True)
logger.append(vars(args))
# if args.display:
# writer = SummaryWriter()
# else:
# writer = None
writer = SummaryWriter()
# endregion
# region ----------------------------------------数据预处理配置----------------------------------------
data_transforms = {
'train':
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'val':
transforms.Compose([
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
}
# endregion
# region -------------------------------------------数据加载-------------------------------------------
train_datasets = datasets.CIFAR10(root="data",
train=True,
download=True,
transform=transforms.ToTensor())
val_datasets = datasets.CIFAR10(root="data",
train=False,
download=True,
transform=transforms.ToTensor())
# train_datasets = datasets.ImageFolder(os.path.join(args.data_root, 't256'), data_transforms['train'])
# val_datasets = datasets.ImageFolder(os.path.join(args.data_root, 'v256'), data_transforms['val'])
train_dataloaders = torch.utils.data.DataLoader(train_datasets,
batch_size=args.batch_size,
shuffle=True,
num_workers=4)
val_dataloaders = torch.utils.data.DataLoader(val_datasets,
batch_size=1024,
shuffle=False,
num_workers=4)
# endregion
# region --------------------------------------网络无关配置设置----------------------------------------
# 记录日志
if args.debug:
x, y = next(iter(train_dataloaders))
logger.append([x, y])
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
is_use_cuda = torch.cuda.is_available()
cudnn.benchmark = True
# 设置基础网络
if 'resnet50' == args.model.split('_')[0]:
my_model = models.resnet50(pretrained=False)
elif 'resnet50-cbam' == args.model.split('_')[0]:
my_model = resnet_cbam.resnet50_cbam(pretrained=False)
elif 'resnet101' == args.model.split('_')[0]:
my_model = models.resnet101(pretrained=False)
else:
raise ModuleNotFoundError
# endregion
# region --------------------------------------网络训练配置设置----------------------------------------
# 损失函数设定
loss_fn = [nn.CrossEntropyLoss()]
# 优化器设置
optimizer = optim.SGD(my_model.parameters(),
lr=0.1,
momentum=0.9,
weight_decay=1e-4)
# 学习率优化函数设置
lr_schedule = lr_scheduler.MultiStepLR(optimizer,
milestones=[30, 60],
gamma=0.1)
# 累计误差TOP5
metric = [ClassErrorMeter([1, 5], True)]
# 迭代次数
epoch = int(args.epoch)
# 传入训练器
my_trainer = Trainer(my_model, args.model, loss_fn, optimizer, lr_schedule,
500, is_use_cuda, train_dataloaders, val_dataloaders,
metric, 0, epoch, args.debug, logger, writer)
# 训练
my_trainer.fit()
logger.append('训练完毕')
def main(args):
if 0 == len(args.resume):
logger = Logger('./logs/' + args.model + '.log')
else:
logger = Logger('./logs/' + args.model + '.log', True)
logger.append(vars(args))
if args.display:
writer = SummaryWriter()
else:
writer = None
gpus = args.gpu.split(',')
data_transforms = {
'train':
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'val':
transforms.Compose([
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
}
train_datasets = datasets.ImageFolder(os.path.join(args.data_root, 't256'),
data_transforms['train'])
val_datasets = datasets.ImageFolder(os.path.join(args.data_root, 'v256'),
data_transforms['val'])
train_dataloaders = torch.utils.data.DataLoader(
train_datasets,
batch_size=args.batch_size * len(gpus),
shuffle=True,
num_workers=8)
val_dataloaders = torch.utils.data.DataLoader(val_datasets,
batch_size=1024,
shuffle=False,
num_workers=8)
if args.debug:
x, y = next(iter(train_dataloaders))
logger.append([x, y])
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
is_use_cuda = torch.cuda.is_available()
cudnn.benchmark = True
if 'resnet50' == args.model.split('_')[0]:
my_model = models.resnet50(pretrained=False)
elif 'resnet101' == args.model.split('_')[0]:
my_model = models.resnet101(pretrained=False)
elif 'mnasnet' == args.model.split('_')[0]:
my_model = mnasnet.MnasNet()
elif 'shufflenetv2' == args.model.split('_')[0]:
my_model = shufflenetv2.ShuffleNetV2()
else:
raise ModuleNotFoundError
#my_model.apply(fc_init)
if is_use_cuda and 1 == len(gpus):
my_model = my_model.cuda()
elif is_use_cuda and 1 < len(gpus):
my_model = nn.DataParallel(my_model.cuda())
loss_fn = [nn.CrossEntropyLoss()]
optimizer = optim.SGD(my_model.parameters(),
lr=0.1,
momentum=0.9,
weight_decay=1e-4)
lr_schedule = lr_scheduler.MultiStepLR(optimizer,
milestones=[30, 60],
gamma=0.1) #
metric = [ClassErrorMeter([1, 5], True)]
start_epoch = 0
num_epochs = 90
my_trainer = Trainer(my_model, args.model, loss_fn, optimizer, lr_schedule, 500, is_use_cuda, train_dataloaders, \
val_dataloaders, metric, start_epoch, num_epochs, args.debug, logger, writer)
my_trainer.fit()
logger.append('Optimize Done!')
def main():
# Load iris dataset with total of 150 samples
x, y = load_iris(return_X_y=True)
y = np.reshape(y, (150, 1))
# concatenate both x and y to shuffle and split
data = np.concatenate((x, y), axis=1)
dataset = IrisDataset(data)
dataset_train, dataset_test = random_split(dataset, [int(len(dataset) * 0.8), int(len(dataset) * 0.2)])
# https://pytorch.org/docs/1.1.0/_modules/torch/utils/data/dataloader.html
train_loader = DataLoader(
dataset_train,
BATCH_SIZE,
shuffle=True,
drop_last=True,
)
test_loader = DataLoader(
dataset_test,
BATCH_SIZE,
shuffle=True,
drop_last=True,
)
model = nn.Sequential(nn.Linear(INPUT_DIM, 48, bias=True),
nn.ReLU(),
nn.Linear(48, 24, bias=True),
nn.Tanh(),
nn.Linear(24, OUTPUT_DIM, bias=True),
nn.Softmax(dim=1))
# Training properties
l_rate = 1e-3
criterion = LossCrossEntropy()
optimizer = torch.optim.Adam(model.parameters(), lr=l_rate)
meters = {
"train_loss": AverageValueMeter(),
"test_loss": AverageValueMeter(),
"train_acc": ClassErrorMeter(accuracy=True),
"test_acc": ClassErrorMeter(accuracy=True),
"train_f1": MetricAccuracyClassification(),
"test_f1": MetricAccuracyClassification()
}
for epoch in range(EPOCHS):
# print("\nepoch = ", epoch)
# reset meters to default settings before each epoch
for k in meters.keys():
meters[k].reset()
for loader in [train_loader, test_loader]:
if loader == train_loader:
# print("\n\ttraining:")
meter_prefix = "train"
model = model.train()
torch.set_grad_enabled(True)
else:
# print("\n\ttesting:")
meter_prefix = "test"
# automatically turns off some modules (like DropOut), which are not used during testing
model = model.eval()
torch.set_grad_enabled(False)
for x, y, idx in loader:
# print("\t\tbatch = ", idx)
# clear grads
optimizer.zero_grad()
# forward
y_prim = model.forward(x.float())
loss = criterion.forward(y_prim, y)
# update parameters when training
if loader == train_loader:
loss.backward()
optimizer.step()
optimizer.zero_grad()
# update metrics
meters[f'{meter_prefix}_loss'].add(loss.detach().numpy())
# TODO: acc curve?
# # convert from one hot encoding to flower classes
# tg = np.argmax(y, axis=1).numpy()
# (y_prim.detach().numpy(), target=tg)
# TODO: f1
tb.add_scalars(
main_tag='learning_curve',
tag_scalar_dict={
f'{meter_prefix}_loss': meters[f'{meter_prefix}_loss'].value()[0]
},
global_step=epoch
)
tb.close()
def __init__(self,
sub_class_list: Sequence,
class_partition: Sequence[Union[int, Sequence[int]]],
positive_class: Sequence[int],
val_phases: Dict[bool, str] = None,
is_visualize: bool = True,
patient_info: SheetCollection = None,
patient_pred: CascadedPred = None,
port: int = AbstractModelStats.DEFAULT_PORT,
env: str = AbstractModelStats.DEFAULT_ENV,
previous_preds=None):
super().__init__(
sub_class_list=sub_class_list,
class_partition=class_partition,
val_phases=val_phases,
is_visualize=is_visualize,
port=port,
env=env,
previous_preds=previous_preds,
)
self.patient_info = patient_info
self.patient_pred = patient_pred
self._positive_class = positive_class
self._best_loss = np.inf
self._best_stats = dict()
# class_list=sub_class_list,
# partition=self.class_partition)
self._membership: Dict[str, Union[torch.Tensor, np.ndarray]] = dict()
self.meter_container.add_meter(DefaultStats.PATCH_ACC,
ClassErrorMeter(accuracy=True))
self.meter_container.add_meter(
DefaultStats.PATCH_CONF,
ConfusionMeter(self.num_classes, normalized=False))
self.meter_container.add_meter(DefaultStats.LOSS_METER,
AverageValueMeter())
self.meter_container.add_meter(DefaultStats.PATCH_AUC,
MultiAUC(num_class=self.num_classes))
phase_name_list = [
VizLogContainer.mode_to_phase_name(phase)
for phase in [True, False]
]
plot_opts_by_phase = {'legend': phase_name_list}
class_name_cross_phase = [
DefaultStats.class_per_phase(x, y) for x in self.sub_class_list
for y in phase_name_list
]
plot_opts_by_class_name = {'legend': class_name_cross_phase}
if self.patient_pred is not None and self.patient_info is not None:
self.meter_container.add_meter(
DefaultStats.MULTI_INSTANCE,
MultiInstanceMeter(
self.patient_info,
self.patient_pred,
positive_class=MultiInstanceMeter.default_positive(
self.class_partition, self._positive_class)))
self.vizlog_container.add_logger(VisdomPlotLogger,
'line',
DefaultStats.VIZ_MULTI_TRUE_PRED,
[DefaultStats.PHASE_COMBINE],
opts=plot_opts_by_class_name)
self.vizlog_container.add_logger(VisdomPlotLogger,
'line',
DefaultStats.VIZ_MULTI_AUC,
[DefaultStats.PHASE_COMBINE],
opts=plot_opts_by_phase)
self.vizlog_container.add_logger(VisdomPlotLogger,
'line',
DefaultStats.VIZ_LOSS,
[DefaultStats.PHASE_COMBINE],
opts=plot_opts_by_phase)
self.vizlog_container.add_logger(VisdomPlotLogger,
'line',
DefaultStats.VIZ_PATCH_TRUE_PRED,
[DefaultStats.PHASE_COMBINE],
opts=plot_opts_by_class_name)
self.vizlog_container.add_logger(VisdomPlotLogger,
'line',
DefaultStats.VIZ_PATCH_AUC,
[DefaultStats.PHASE_COMBINE],
opts=plot_opts_by_class_name)