def train(epoch):
epoch_loss = 0
for iteration, batch in enumerate(training_data_loader, 1):
LR_r, LR_g, HR_2_target, HR_4_target = batch[0].to(device), batch[1].to(device), batch[2].to(device), batch[3].to(device)
optimizer_r.zero_grad()
optimizer_g.zero_grad()
HR_2_r, HR_4_r = model_r(LR_r)
HR_2_g, HR_4_g = model_g(LR_g)
black_2 = torch.zeros(1, HR_2_target[0].shape[1], HR_2_target[0].shape[2]).unsqueeze(0).to(device)
HR_2 = torch.cat((HR_2_r.squeeze(0), HR_2_g.squeeze(0), black_2.squeeze(0))).unsqueeze(0)
black_4 = torch.zeros(1, HR_4_target[0].shape[1], HR_4_target[0].shape[2]).unsqueeze(0).to(device)
HR_4 = torch.cat((HR_4_r.squeeze(0), HR_4_g.squeeze(0), black_4.squeeze(0))).unsqueeze(0)
loss1 = Loss(HR_2, HR_2_target)
loss2 = Loss(HR_4, HR_4_target)
loss = loss1 + loss2
epoch_loss += loss.item()
loss.backward()
optimizer_r.step()
optimizer_g.step()
print("===> Epoch {} Complete: Avg. Loss: {:.4f}".format(epoch, epoch_loss / len(training_data_loader)))
results['Avg. Loss'].append(float('%.4f'%(epoch_loss / len(training_data_loader))))
def build_model(self):
self.device = torch.device(
'cuda:0' if torch.cuda.is_available() else 'cpu')
self.net = Model(
Deeplabv2(self.args.num_classes, self.args.num_blocks,
self.args.atrous_rates),
self.args.multi_scales).to(self.device)
self.net.base.freeze_bn()
self.loss = Loss(self.args).to(self.device)
self.net.train()
self.net.apply(_init_weight)
self.optimizer = torch.optim.SGD(
[{
"params": self.get_params(self.net, key="resnet_conv"),
"lr": self.args.lr,
"weight_decay": self.args.weight_decay
}, {
"params": self.get_params(self.net, key="aspp_weight"),
"lr": 10 * self.args.lr,
"weight_decay": self.args.weight_decay
}, {
"params": self.get_params(self.net, key="aspp_bias"),
"lr": 20 * self.args.lr
}],
momentum=self.args.momentum)
self.restore()
self.print_param()
def train(model, batch_size, epoch, train_data: Dataset, optimizer, logger,
save_path):
data_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)
model.train()
loss = Loss()
# loss = nn.MSELoss()
for epoch_idx in range(epoch):
train_sample_sum, train_acc_sum, start = 0, 0., time.time()
for batch_idx, (inputs, label_x, label_y) in enumerate(data_loader):
inputs, label_x, label_y = inputs.cuda(), label_x.cuda(
), label_y.cuda()
outputs = model(inputs)
loss_output = loss(outputs, label_x, label_y)
# loss_output = loss(outputs, torch.stack([label_x, label_y], 1).float())
# loss_output = loss_output / batch_size
optimizer.zero_grad()
loss_output.backward()
# print(inputs.grad)
optimizer.step()
train_sample_sum += len(inputs)
train_acc_sum += loss_output
print(
f'epoch {str(epoch_idx)}, process {train_sample_sum / len(train_data):.2f}, time {time.time() - start:.2f}, loss {train_acc_sum / train_sample_sum:.3f}'
) # noqa
with open(save_path + 'loss.txt', 'a') as f:
f.write(str(train_acc_sum / train_sample_sum) + '\n')
torch.save(model.state_dict(), save_path + str(epoch_idx) + '.pt')
return model
def __init__(self, name_scope, clsNum, batch=8, is_trainning=True):
super(FCOS, self).__init__(name_scope)
self.trainning = is_trainning
self.resnet = ResNet(name_scope + "_ResNet", is_test=not is_trainning)
self.head = Head(name_scope + '_Head1',
clsNum,
is_test=not is_trainning) # head1用于前3层 fpn
# self.head2 = Head(name_scope + '_Head2', clsNum, is_test=not is_trainning) # head2用于后2层 fpn
self.stride = [8, 16, 32, 64, 128]
self.clsNum = clsNum
self.batch = batch
self.loss = Loss(name_scope + "_loss")
self.size2layer = [[125, 306], [63, 153], [32, 77], [16, 39], [
8, 20
]] # 各fpn层的featuremap size 因为在布匹检测中输入尺寸都相同。故用相同feature map
# self.area = [0, 38250, 47889, 50353, 50977, 51137]
self.feat_map = []
for i in range(5):
temp = np.zeros(shape=(self.size2layer[i] + [2]))
temp[:, :, 0] = np.arange(self.size2layer[i][1]).reshape(
1, -1) * self.stride[i] + self.stride[i] / 2
temp[:, :, 1] = np.arange(self.size2layer[i][0]).reshape(
-1, 1) * self.stride[i] + self.stride[i] / 2
self.feat_map.append(temp)
print("FCOS load final")
def __init__(self, cfg, num_classes):
self.device = cfg.MODEL.DEVICE
self.model = build_model(cfg, num_classes)
self.loss = Loss(cfg, num_classes, self.model.in_planes)
self.optimizer = make_optimizer(cfg, self.model)
self.scheduler = WarmupMultiStepLR(self.optimizer,
cfg.WARMUP.STEPS,
cfg.WARMUP.GAMMA,
cfg.WARMUP.FACTOR,
cfg.WARMUP.MAX_EPOCHS,
cfg.WARMUP.METHOD)
if cfg.APEX.IF_ON:
logger.info("Using apex")
try:
import apex
except ImportError:
raise ImportError("Please install apex from https://www.github.com/nvidia/apex to run this example.")
assert torch.backends.cudnn.enabled, "Amp requires cudnn backend to be enabled."
#
# if cfg.APEX.IF_SYNC_BN:
# logger.info("Using apex synced BN")
# self.module = apex.parallel.convert_syncbn_model(self.module)
if self.device is 'cuda':
self.model = self.model.cuda()
if cfg.APEX.IF_ON:
from apex import amp
self.model, self.optimizer = amp.initialize(self.model,
self.optimizer,
opt_level=cfg.APEX.OPT_LEVEL,
keep_batchnorm_fp32=None if cfg.APEX.OPT_LEVEL == 'O1' else True,
loss_scale=cfg.APEX.LOSS_SCALE[0])
def train(train_img_path, pths_path, batch_size, lr, decay, num_workers,
epoch_iter, interval, pretained):
file_num = len(os.listdir(train_img_path))
trainset = custom_dataset(train_img_path)
train_loader = data.DataLoader(trainset, batch_size=batch_size, \
shuffle=True, num_workers=num_workers, drop_last=True)
criterion = Loss()
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = EAST()
# TODO 可能是bug
if os.path.exists(pretained):
model.load_state_dict(torch.load(pretained))
data_parallel = False
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
data_parallel = True
model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=decay)
# scheduler = lr_scheduler.StepLR(optimizer, step_size=10000, gamma=0.94)
for epoch in range(epoch_iter):
model.train()
optimizer.step()
epoch_loss = 0
epoch_time = time.time()
for i, (img, gt_map) in enumerate(train_loader):
start_time = time.time()
img, gt_map = img.to(device), gt_map.to(device)
east_detect = model(img)
inside_score_loss, side_vertex_code_loss, side_vertex_coord_loss = criterion(
gt_map, east_detect)
loss = inside_score_loss + side_vertex_code_loss + side_vertex_coord_loss
epoch_loss += loss.item()
optimizer.zero_grad()
loss.backward()
optimizer.step()
if i % 10 == 0:
print('Epoch is [{}/{}], mini-batch is [{}/{}], time consumption is {:.8f}, batch_loss is {:.8f}'.format( \
epoch + 1, epoch_iter, i + 1, int(file_num / batch_size), time.time() - start_time, loss.item()))
print(
"inside_score_loss: %f | side_vertex_code_loss: %f | side_vertex_coord_loss: %f"
% (inside_score_loss, side_vertex_code_loss,
side_vertex_coord_loss))
print('epoch_loss is {:.8f}, epoch_time is {:.8f}'.format(
epoch_loss / int(file_num / batch_size),
time.time() - epoch_time))
print(time.asctime(time.localtime(time.time())))
# print('=' * 50)
if (epoch + 1) % interval == 0:
state_dict = model.module.state_dict(
) if data_parallel else model.state_dict()
torch.save(
state_dict,
os.path.join(
pths_path, cfg.train_task_id +
'_model_epoch_{}.pth'.format(epoch + 1)))
def train(train_img_path, train_gt_path, pths_path, batch_size, lr, num_workers, epoch_iter, interval, output_dir):
# 为CPU设置种子用于生成随机数，以使得结果是确定的
torch.manual_seed(970201) # 为CPU设置随机种子
torch.cuda.manual_seed(970201) # 为当前GPU设置随机种子
logger = setup_logger("east_matrix", output_dir, get_rank())
file_num = len(os.listdir(train_img_path)) # 图片数量
trainset = custom_dataset(train_img_path, train_gt_path) # 训练集进行处理 ？？？ ***
# 加载数据，组合一个数据集和一个采样器，并在给定的数据集上提供一个可迭代的。
train_loader = data.DataLoader(trainset, batch_size=batch_size, \
shuffle=True, num_workers=num_workers, drop_last=True)
criterion = Loss() # 损失函数 ？？？ ***
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = EAST() # 网络模型 ？？？ ***
# 是否多gpu
data_parallel = False
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
data_parallel = True
# 分配模型到gpu或cpu，根据device决定
model.to(device)
#优化器
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
# 学习率衰减策略，一半的时候衰减为十分之一
scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[epoch_iter//2], gamma=0.1)
def main(args):
coco_dataloader = CocoDataLoader(args)
trainloader = coco_dataloader.get_trainloader(args)
yolov2 = DarkNet19()
optimizer = Optimizer(yolov2.parameters(), args.lr)
criterion = Loss()
logger = Logger()
logger.info('----- Starting training -----')
for epoch in range(args.epochs):
for i,data in enumerate(trainloader):
images, targets = data
optimizer.zero_grad()
outputs = yolov2(images)
total_loss = criterion.get_total_loss(outputs, targets, args)
total_loss.backward()
optimizer.step()
logger.info(f'Epoch: {epoch+1}/{args.epochs}, Step: {i+1}, Loss: {loss.data}')
logger.info('----- Training done! -----')
def main():
args = parse_args()
torch.cuda.set_device(args.gpu_id)
# prepare training data
train_dataset, val_dataset = Vimeo90K_interp(args.data_dir)
train_loader = DataLoader(dataset=train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=8)
# val_loader = DataLoader(dataset=val_dataset, batch_size=args.batch_size, shuffle=True, num_workers=8)
# prepare test data
test_db = Middlebury_other(args.test_input, args.test_gt)
# initialize our model
model = CDFI_adacof(args).cuda()
print("# of model parameters is: " +
str(utility.count_network_parameters(model)))
# prepare the loss
loss = Loss(args)
# prepare the trainer
my_trainer = Trainer(args, train_loader, test_db, model, loss)
# start training
while not my_trainer.terminate():
my_trainer.train()
my_trainer.test()
my_trainer.close()
def main(hparam):
if not hparam.optimization_continue:
del_fold(hparam.tensorboard_log
) # clear log dir, avoid the messing of log dir
# init data and loss
data = Data(hparam)
loss = Loss(hparam, data.csv_table)
# init sub- and master- problem
sp = SubProblem(hparam, loss, data)
mp = MasterProblem(hparam, loss, data, sp)
# master and sp loop
nb_apertures = 0
dict_gradMaps, next_dict_segments, next_dict_lrs = mp.init_segments()
while multiply_dict(
dict_gradMaps, next_dict_segments
) < 0 and nb_apertures < hparam.nb_apertures: # next_seg * cur_grad < 0 means open next_seg (intensity of bixels - negative grad == increase the intensity) will decrease the loss
dict_gradMaps = mp.solve(next_dict_segments, next_dict_lrs,
nb_apertures) # {beam_id: matrix}
next_dict_segments, next_dict_lrs = sp.solve(
dict_gradMaps) # {beam_id: bool vector}
nb_apertures += 1
cprint(f'nb_apertures: {nb_apertures} done.', 'green')
# save optimized segments and MUs
pdb.set_trace()
save_result(mp)
# release memory
torch.cuda.empty_cache()
cprint('all done!!!', 'green')
def main():
"""
Main Function for searching process.
"""
torch.manual_seed(args.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(args.seed)
np.random.seed(args.seed)
random.seed(args.seed)
cudnn.enabled = True
cudnn.benchmark = True
cudnn.deterministic = True
checkpoint = utils.checkpoint(args)
if checkpoint.ok:
data_loader = DataLoader(args)
loss = Loss(args, checkpoint) if not args.test_only else None
search_model = Controller(args, loss).cuda()
srdarts = Searcher(args, data_loader, search_model, loss, checkpoint)
while not srdarts.terminate():
srdarts.search()
srdarts.valid()
checkpoint.done()
def __init__(self, model_file='best_lane_res18_stitch'):
net = resnet18_encoderdecoder().cuda()
self.model = Stitch_Classfier(net, n_class=2).cuda()
self.model.load_state_dict(torch.load(model_file))
self.model.eval()
self.bb_model = Yo4o_stitch(20, 2).cuda()
checkpoint = torch.load('stitch_bbox_best.pth.tar')
self.bb_model.load_state_dict(checkpoint['model'])
self.loss = Loss(20, 2)
self.bb_model.eval()
self.device = torch.device(
"cuda:0" if torch.cuda.is_available() else "cpu")
self.M_matrices = torch.tensor([
# CAM_FRONT_LEFT
[[-6.92946073e-02, -1.17143003e+00, 1.64122408e+02],
[-1.33781874e-14, -1.67019853e+00, 2.34084846e+02],
[-7.00394603e-17, -7.63146706e-03, 1.00000000e+00]],
# CAM_FRONT
[[-6.92636526e-02, -1.17089785e+00, 1.64264194e+02],
[-1.12965193e-14, -1.66944201e+00, 2.34140507e+02],
[-5.76795556e-17, -7.62799727e-03, 1.00000000e+00]],
# CAM_FRONT_RIGHT
[[-7.02452787e-02, -1.17762492e+00, 1.64369634e+02],
[-2.27595720e-14, -1.67903365e+00, 2.34318471e+02],
[-1.16009632e-16, -7.67182090e-03, 1.00000000e+00]],
# CAM_BACK_LEFT
[[-6.94775392e-02, -1.17675499e+00, 1.64135286e+02],
[-1.19904087e-14, -1.67779415e+00, 2.34164782e+02],
[-5.78963960e-17, -7.66615368e-03, 1.00000000e+00]],
# CAM_BACK
[[-6.82085369e-02, -1.16228084e+00, 1.64011808e+02],
[-1.23234756e-14, -1.65715610e+00, 2.33912863e+02],
[-6.39679282e-17, -7.57186452e-03, 1.00000000e+00]],
# CAM_BACK_RIGHT
[[-6.91003275e-02, -1.16814423e+00, 1.63997347e+02],
[-1.59872116e-14, -1.66551463e+00, 2.34087152e+02],
[-8.30498864e-17, -7.61006318e-03, 1.00000000e+00]]
]).to(self.device)
# rotation matrices
self.M_rotations = torch.tensor(
[[[5.0000e-01, 8.6603e-01, -1.8330e+01],
[-8.6603e-01, 5.0000e-01, 1.8725e+02]],
[[1.0000e+00, 0.0000e+00, 0.0000e+00],
[-0.0000e+00, 1.0000e+00, 0.0000e+00]],
[[5.0000e-01, -8.6603e-01, 1.7133e+02],
[8.6603e-01, 5.0000e-01, -7.7752e+01]],
[[-5.0000e-01, 8.6603e-01, 1.3467e+02],
[-8.6603e-01, -5.0000e-01, 2.9675e+02]],
[[-1.0000e+00, 8.7423e-08, 3.0600e+02],
[-8.7423e-08, -1.0000e+00, 2.1900e+02]],
[[-5.0000e-01, -8.6603e-01, 3.2433e+02],
[8.6603e-01, -5.0000e-01, 3.1748e+01]]]).to(self.device)
#flip 90 degree to align car facing right
self.M_flip = torch.tensor([[[-4.3711e-08, -1.0000e+00, 4.3800e+02],
[1.0000e+00, -4.3711e-08,
0.0000e+00]]]).to(self.device)
def __init__(self, functional_connectivity, patient_data, **kwargs):
self.types = [
'ConcentrationLinear', 'Constant', 'ConcentrationSigmoid',
'WeightedDegreeLinear', 'WeightedDegreeSigmoid'
]
self.producer = Producer(self.types)
self.params = self.producer.params
for key, value in kwargs.items():
if key == "nodeCoordinates":
self.nodeCoordinates = value
elif key == "optimizer":
self.optimizer = value
elif key == "loss":
self.loss = value
elif key == "euclideanAdjacency":
self.euclideanAdjacency = value
elif key == "producer":
self.producer = value
elif key == "diffuser":
self.diffuser = value
elif key == "params":
self.params.update(value)
else:
raise TypeError("Illegal Keyword '" + str(key) + "'")
self.functionalConnectivity = functional_connectivity
self.patientData = patient_data
self.numNodes, _ = np.shape(functional_connectivity)
self.loss = Loss("mse", self.patientData)
self.lastloss = 0
self.reset()
def build_model(self):
self.net = build_model().to(self.device)
if self.config.mode == 'train': self.loss = Loss().to(self.device)
self.net.train()
self.net.eval()
params_dict = dict(self.net.named_parameters())
self.optimizer = Adam(self.net.parameters(), self.config.lr)
def build_model(self):
self.net = torch.nn.DataParallel(build_model()).cuda()
if self.config.mode == 'train': self.loss = Loss().cuda()
self.net.train()
self.net.apply(weights_init)
if self.config.load == '': self.net.module.base.load_state_dict(torch.load(self.config.vgg))
if self.config.load != '': self.net.module.load_state_dict(torch.load(self.config.load))
self.optimizer = Adam(self.net.parameters(), self.config.lr)
self.print_network(self.net, 'DSS')
def __init__(self, word_vec, weight=None):
super(LatentRE, self).__init__()
''' load encoder '''
if Config.encoder == "bert":
self.encoder = Bert()
else:
self.encoder = TextRepre(word_vec)
self.selector = Selector()
self.loss = Loss(weight)
def main(args):
torch.cuda.set_device(args.gpu)
# Network Builders
builder = ModelBuilder()
unet1 = builder.build_unet(num_class=args.num_class,
arch=args.arch_unet,
weights=args.weights_unet1)
unet2 = builder.build_unet(num_class=args.num_class,
arch=args.arch_unet,
weights=args.weights_unet2)
unet3 = builder.build_unet(num_class=args.num_class,
arch=args.arch_unet,
weights=args.weights_unet3)
unet4 = builder.build_unet(num_class=args.num_class,
arch=args.arch_unet,
weights=args.weights_unet4)
unet5 = builder.build_unet(num_class=args.num_class,
arch=args.arch_unet,
weights=args.weights_unet5)
crit = Loss()
sm1 = SegmentationModule(unet1, crit)
sm2 = SegmentationModule(unet2, crit)
sm3 = SegmentationModule(unet3, crit)
sm4 = SegmentationModule(unet4, crit)
sm5 = SegmentationModule(unet5, crit)
test_augs = ComposeTest([PaddingCenterCropTest(384)])
ac17 = AC17(
root=args.data_root,
augmentations=test_augs,
img_norm=args.img_norm)
loader_val = data.DataLoader(
ac17,
batch_size=1,
shuffle=False,
collate_fn=user_scattered_collate,
num_workers=5,
drop_last=True)
sm1.cuda()
sm2.cuda()
sm3.cuda()
sm4.cuda()
sm5.cuda()
# Main loop
evaluate(sm1, sm2, sm3, sm4, sm5, loader_val, args)
print('Evaluation Done!')
def build_model(self):
self.net = build_model().to(self.device)
if self.config.mode == 'train': self.loss = Loss().to(self.device)
self.net.train()
self.net.apply(weights_init)
if self.config.load == '': self.net.base.load_state_dict(torch.load(self.config.vgg))
if self.config.load != '': self.net.load_state_dict(torch.load(self.config.load))
self.optimizer = Adam(self.net.parameters(), self.config.lr)
self.print_network(self.net, 'DSS')
def train(train_root_path, pths_path, batch_size, lr, num_workers, epoch_iter, interval):
trainset = custom_dataset(train_root_path)
file_num = trainset.__len__()
train_loader = data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers, drop_last=True)
criterion = Loss()
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = EAST(pretrained=False)
model.load_state_dict(torch.load('/home/chen-ubuntu/Desktop/checks_dataset/pths/model_epoch_stamp_8.pth'))
model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
optimizer.zero_grad()
# scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[epoch_iter//2], gamma=0.1)
for epoch in range(epoch_iter):
model.train()
epoch_loss = 0
loss_plot = []
bx = []
'''
for i, (img, gt_score, gt_geo, ignored_map) in enumerate(train_loader):
start_time = time.time()
img, gt_score, gt_geo, ignored_map = img.to(device), gt_score.to(device), gt_geo.to(device), ignored_map.to(
device)
pred_score, pred_geo = model(img)
loss = criterion(gt_score, pred_score, gt_geo, pred_geo, ignored_map)
epoch_loss += loss.item()
loss.backward()
if (i + 1) % 8 == 0:
optimizer.step()
optimizer.zero_grad()
if (i + 1) % 100 == 0:
print(
'Epoch is [{}/{}], mini-batch is [{}/{}], time consumption is {:.8f}, batch_loss is {:.8f}'.format(
epoch + 1, epoch_iter, i + 1, int(file_num / batch_size), time.time() - start_time,
loss.item()))
if (i + 1) % 30 == 0:
loss_plot.append(loss.item())
bx.append(i + epoch * int(file_num / batch_size))
plt.plot(bx, loss_plot, label='loss_mean', linewidth=1, color='b', marker='o',
markerfacecolor='green', markersize=2)
plt.savefig(os.path.abspath('./labeled2.jpg'))
print('epoch_loss is {:.8f}, epoch_time is {:.8f}'.format(epoch_loss / int(file_num / batch_size),
time.time() - epoch_time))
print(time.asctime(time.localtime(time.time())))
print('=' * 50)'''
if epoch % interval == 0:
validloss, validacc = valid(train_loader, model, criterion, device)
state_dict = model.module.state_dict() if data_parallel else model.state_dict()
def train(epoch):
epoch_loss = 0
for _, batch in enumerate(training_data_loader, 1):
LR, HR_2_target, HR_4_target = batch[0].to(device), batch[1].to(device), batch[2].to(device)
optimizer.zero_grad()
HR_2, HR_4 = model(LR)
loss1 = Loss(HR_2, HR_2_target)
loss2 = Loss(HR_4, HR_4_target)
loss = loss1+loss2
epoch_loss += loss.item()
loss.backward()
optimizer.step()
print("===> Epoch {} Complete: Avg. Loss: {:.4f}".format(epoch, epoch_loss / len(training_data_loader)))
results['Avg. Loss'].append(float('%.4f'%(epoch_loss / len(training_data_loader))))
def build_model(self):
self.device = torch.device(
'cuda:0' if torch.cuda.is_available() else 'cpu')
self.net = model(self.args).to(self.device)
self.loss = Loss(self.args).to(self.device)
self.net.train()
self.net.apply(_init_weight)
self.optimizer = self.get_optimizer(self.net)
self.restore()
self.print_param()
def train(train_img_path, train_gt_path, pths_path, batch_size, lr,
num_workers, epoch_iter, interval, pretrained_pth):
file_num = len(os.listdir(train_img_path))
trainset = custom_dataset(train_img_path, train_gt_path)
train_loader = data.DataLoader(trainset, batch_size=batch_size, \
shuffle=True, num_workers=num_workers, drop_last=True)
criterion = Loss()
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = EAST()
# if pretrained_path:
# model.load_state_dict(torch.load(pretrained_path))
data_parallel = False
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
data_parallel = True
model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
scheduler = lr_scheduler.MultiStepLR(optimizer,
milestones=[epoch_iter // 2],
gamma=0.1)
for epoch in range(epoch_iter):
model.train()
scheduler.step()
epoch_loss = 0
epoch_time = time.time()
for i, (img, gt_score, gt_geo, ignored_map) in enumerate(train_loader):
start_time = time.time()
img, gt_score, gt_geo, ignored_map = img.to(device), gt_score.to(
device), gt_geo.to(device), ignored_map.to(device)
pred_score, pred_geo = model(img)
loss = criterion(gt_score, pred_score, gt_geo, pred_geo,
ignored_map)
epoch_loss += loss.item()
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch is [{}/{}], mini-batch is [{}/{}], time consumption is {:.8f}, batch_loss is {:.8f}'.format(\
epoch+1, epoch_iter, i+1, int(file_num/batch_size), time.time()-start_time, loss.item()))
print('epoch_loss is {:.8f}, epoch_time is {:.8f}'.format(
epoch_loss / int(file_num / batch_size),
time.time() - epoch_time))
print(time.asctime(time.localtime(time.time())))
print('=' * 50)
if (epoch + 1) % interval == 0:
state_dict = model.module.state_dict(
) if data_parallel else model.state_dict()
torch.save(
state_dict,
os.path.join(pths_path,
'model_epoch_{}.pth'.format(epoch + 1)))
def __init__(self, is_train=True):
super(retinanet, self).__init__()
self.is_train = is_train
self.resnet = resNet()
self.fpn = PyramidFeatures()
self.classier = classier()
self.regressier = regressier()
self.loss = Loss()
self.inference = Inference()
def train(opts):
training_params = {'num_epochs' : opts.epochs, 'learning_rate' : 0.1, 'weight_decay' : 0.3, 'learning_rate_decay' : 0.9999, 'cuda' : False,
'summary_dir' : './runs/logs/', 'checkpoint_dir' : './runs/checkpoints/'}
loss = Loss()
trainer = Trainer(model, loss, data, training_params)
# print(trainer)
trainer.train(opts)
def get_component(self, cfg, num_classes):
self.device = cfg.MODEL.DEVICE
self.model = build_model(cfg, num_classes)
self.loss = Loss(cfg, num_classes, self.model.in_planes)
self.optimizer = make_optimizer(cfg, self.model)
self.scheduler = WarmupMultiStepLR(self.optimizer,
cfg.WARMUP.STEPS,
cfg.WARMUP.GAMMA,
cfg.WARMUP.FACTOR,
cfg.WARMUP.MAX_EPOCHS,
cfg.WARMUP.METHOD)
def __init__(self, epochs, dataloaders, model, optimizer, scheduler, device):
self.epochs = epochs
self.dataloaders = dataloaders
self.model = model
self.optimizer = optimizer
self.scheduler = scheduler
self.device = device
self.lossfn = Loss(self.device)
# save best model
self.best_val_loss = 100
def __init__(self, lr, train_loader, model, optimizer, scheduler, logger,
device):
self.lr = lr
self.train_loader = train_loader
self.model = model
self.optimizer = optimizer
self.scheduler = scheduler
self.device = device
self.lossfn = Loss(self.device)
self.logger = logger
self.run_count = 0
self.scalar_info = {}
def main_worker(rank, args):
args.rank = rank
args = setup(args)
loaders = Data(args).get_loader()
model = Model(args)
optimizer = Optimizer(args, model)
if args.amp:
model = optimizer.set_amp(model)
model.parallelize()
criterion = Loss(args, model=model, optimizer=optimizer)
trainer = Trainer(args, model, criterion, optimizer, loaders)
if args.stay:
interact(local=locals())
exit()
if args.demo:
trainer.evaluate(epoch=args.startEpoch, mode='demo')
exit()
for epoch in range(1, args.startEpoch):
if args.do_validate:
if epoch % args.validate_every == 0:
trainer.fill_evaluation(epoch, 'val')
if args.do_test:
if epoch % args.test_every == 0:
trainer.fill_evaluation(epoch, 'test')
for epoch in range(args.startEpoch, args.endEpoch + 1):
if args.do_train:
trainer.train(epoch)
if args.do_validate:
if epoch % args.validate_every == 0:
if trainer.epoch != epoch:
trainer.load(epoch)
trainer.validate(epoch)
if args.do_test:
if epoch % args.test_every == 0:
if trainer.epoch != epoch:
trainer.load(epoch)
trainer.test(epoch)
if args.rank == 0 or not args.launched:
print('')
trainer.imsaver.join_background()
cleanup(args)
def __init__(self, hparam):
self.hparam = hparam
# init data and loss
self.data = Data(hparam)
self.loss = Loss(hparam, self.data.csv_table)
# deposition matrix (#voxels, #bixels)
self.deposition = torch.tensor(self.data.deposition, dtype=torch.float32, device=hparam.device)
# MC dose
self.mc = MonteCarlo(hparam, self.data)
self.unitMUDose = self.mc.get_unit_MCdose()
def __init__(self,
dataloaders,
fusion_method='max',
output_intervals=torch.arange(0., 365 * 31, 365),
auxiliary_criterion=None,
unimodal_state_files=None,
freeze_up_to=None,
device=None):
super().__init__(dataloaders, fusion_method, output_intervals,
unimodal_state_files, freeze_up_to, device)
self.optimizer = Adam
self.loss = Loss()
self.aux_loss = auxiliary_criterion