def __init__(self, ext_loss_type='smoothl1'):
super(EXTLoss, self).__init__()
self.ext_loss_type = ext_loss_type
if ext_loss_type == 'smoothl1':
self.loss_func = nn.SmoothL1Loss(reduction='none')
def forward(self, p, targets=None, requestPrecision=False):
FT = torch.cuda.FloatTensor if p.is_cuda else torch.FloatTensor
bs = p.shape[0] # batch size
nG = p.shape[2] # number of grid points
stride = self.img_dim / nG
if p.is_cuda and not self.grid_x.is_cuda:
self.grid_x, self.grid_y = self.grid_x.cuda(), self.grid_y.cuda()
self.anchor_w, self.anchor_h = self.anchor_w.cuda(
), self.anchor_h.cuda()
#self.weights = self.weights.cuda()
# p.view(1, 30, 13, 13) -- > (1, 3, 13, 13, 10) # (bs, anchors, grid, grid, classes + xywh)
p = p.view(bs, self.nA, self.bbox_attrs, nG,
nG).permute(0, 1, 3, 4, 2).contiguous() # prediction
# Get outputs
P1_x = p[..., 0] # Point1 x
P1_y = p[..., 1] # Point1 y
P2_x = p[..., 2] # Point2 x
P2_y = p[..., 3] # Point2 y
P3_x = p[..., 4] # Point3 x
P3_y = p[..., 5] # Point3 y
P4_x = p[..., 6] # Point4 x
P4_y = p[..., 7] # Point4 y
pred_boxes = FT(bs, self.nA, nG, nG, 8)
pred_conf = p[..., 8] # Conf
pred_cls = p[..., 9:] # Class
# Training
if targets is not None:
MSELoss = nn.MSELoss()
BCEWithLogitsLoss = nn.BCEWithLogitsLoss()
CrossEntropyLoss = nn.CrossEntropyLoss()
SmoothL1Loss = nn.SmoothL1Loss()
if requestPrecision:
gx = self.grid_x[:, :, :nG, :nG]
gy = self.grid_y[:, :, :nG, :nG]
pred_boxes[..., 0] = P1_x.data + gx
pred_boxes[..., 1] = P1_y.data + gy
pred_boxes[..., 2] = P2_x.data + gx
pred_boxes[..., 3] = P2_y.data + gy
pred_boxes[..., 4] = P3_x.data + gx
pred_boxes[..., 5] = P3_y.data + gy
pred_boxes[..., 6] = P4_x.data + gx
pred_boxes[..., 7] = P4_y.data + gy
t1_x, t1_y, t2_x, t2_y, t3_x, t3_y, t4_x, t4_y, mask, tcls, TP, FP, FN, TC = \
build_targets(pred_boxes, pred_conf, pred_cls, targets, self.scaled_anchors, self.nA, self.nC, nG,
requestPrecision)
tcls = tcls[mask]
if P1_x.is_cuda:
t1_x, t1_y, t2_x, t2_y, t3_x, t3_y, t4_x, t4_y, mask, tcls = \
t1_x.cuda(), t1_y.cuda(), t2_x.cuda(), t2_y.cuda(), t3_x.cuda(), t3_y.cuda(), t4_x.cuda(), t4_y.cuda(), mask.cuda(), tcls.cuda()
# Compute losses
nT = sum([len(x) for x in targets]) # Number of targets
nM = mask.sum().float() # Number of anchors (assigned to targets)
nB = len(targets) # Batch size
k = nM / nB
if nM > 0:
lx1 = (k) * SmoothL1Loss(P1_x[mask], t1_x[mask]) / 8
ly1 = (k) * SmoothL1Loss(P1_y[mask], t1_y[mask]) / 8
lx2 = (k) * SmoothL1Loss(P2_x[mask], t2_x[mask]) / 8
ly2 = (k) * SmoothL1Loss(P2_y[mask], t2_y[mask]) / 8
lx3 = (k) * SmoothL1Loss(P3_x[mask], t3_x[mask]) / 8
ly3 = (k) * SmoothL1Loss(P3_y[mask], t3_y[mask]) / 8
lx4 = (k) * SmoothL1Loss(P4_x[mask], t4_x[mask]) / 8
ly4 = (k) * SmoothL1Loss(P4_y[mask], t4_y[mask]) / 8
lconf = (k * 10) * BCEWithLogitsLoss(pred_conf, mask.float())
lcls = (k / self.nC) * CrossEntropyLoss(
pred_cls[mask], torch.argmax(tcls, 1))
else:
lx1, ly1, lx2, ly2, lx3, ly3, lx4, ly4, lcls, lconf = \
FT([0]).requires_grad_(True), FT([0]).requires_grad_(True), FT([0]).requires_grad_(True), FT([0]).requires_grad_(True), FT([0]).requires_grad_(True), \
FT([0]).requires_grad_(True), FT([0]).requires_grad_(True), FT([0]).requires_grad_(True), FT([0]).requires_grad_(True), FT([0]).requires_grad_(True),
# Sum loss components
loss = lx1 + ly1 + lx2 + ly2 + lx3 + ly3 + lx4 + ly4 + lconf + lcls
# Sum False Positives from unassigned anchors
i = torch.sigmoid(pred_conf[~mask]) > 0.5
if i.sum() > 0:
FP_classes = torch.argmax(pred_cls[~mask][i], 1)
FPe = torch.bincount(FP_classes,
minlength=self.nC).float().cpu()
else:
FPe = torch.zeros(self.nC)
return loss, loss.item(), lconf.item(), lcls.item(
), nT, TP, FP, FPe, FN, TC
else:
pred_boxes[..., 0] = P1_x + self.grid_x
pred_boxes[..., 1] = P1_y + self.grid_y
pred_boxes[..., 2] = P2_x + self.grid_x
pred_boxes[..., 3] = P2_y + self.grid_y
pred_boxes[..., 4] = P3_x + self.grid_x
pred_boxes[..., 5] = P3_y + self.grid_y
pred_boxes[..., 6] = P4_x + self.grid_x
pred_boxes[..., 7] = P4_y + self.grid_y
output = torch.cat(
(pred_boxes.view(bs, -1, 8) * stride,
torch.sigmoid(pred_conf.view(
bs, -1, 1)), pred_cls.view(bs, -1, self.nC)), -1)
return output
def CartPole_():
global steps_done, hl_size, num_state, n_actions, EPS_END, BATCH_SIZE, GAMMA, EPS_START, EPS_DECAY, TARGET_UPDATE, Transition, episode_durations, device, memory, is_ipython, policy_net, target_net, loss_fn, optimizer
env = gym.make('CartPole-v0').unwrapped
num_state = env.reset()
num_state = len(
num_state
) #these last 2 lines to define the number of observations got from an state of the simulation (which is 4),
#and we will use it as the number of input for our Neural-Net
# set up matplotlib
is_ipython = 'inline' in matplotlib.get_backend()
if is_ipython:
from IPython import display
plt.ion()
# if gpu is to be used
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
Transition = namedtuple('Transition',
('state', 'action', 'next_state', 'reward'))
BATCH_SIZE = 64 #4 #16 #8 #64
GAMMA = 0.999
EPS_START = 0.9
EPS_END = 0.05
EPS_DECAY = 1000 #200 t was recomended a slower decay here: https://discuss.pytorch.org/t/help-for-dqn-example/13263
TARGET_UPDATE = 10
hl_size = 64 #Number of Neurons on each layer
# Get number of actions from gym action space
n_actions = 2 #Just in case here the number of possible actions is been fixed instead of calculating it with: env.action_space.n
steps_done = 0
episode_durations = []
policy_net = DQN_model(num_state).to(device).double()
policy_net.apply(weights_init_normal)
target_net = DQN_model(num_state).to(device).double()
target_net.load_state_dict(policy_net.state_dict())
target_net.eval()
#optimizer = optim.Adam(policy_net.parameters(), lr=1e-4)
optimizer = optim.RMSprop(policy_net.parameters(
)) #It works better with this than with Adam optimizer
#loss_fn = nn.MSELoss()
#loss_fn = nn.NLLLoss()
loss_fn = nn.SmoothL1Loss()
memory = ReplayMemory(2000) #500) #1000)
num_episodes = 500 #1000 #10000
for i_episode in range(num_episodes):
# Initialize the environment and state
state = env.reset()
state = torch.from_numpy(state)
for t in count():
#for t in range(num_episodes):
state = state.to(device)
action = select_action(state.double())
next_state, reward, done, info = env.step(action.item())
#pass reward as a tensor
reward = torch.tensor([reward], device=device)
# Observe new state
next_state = torch.tensor([next_state], device=device)
next_state = next_state if not done else None
# Store the transition in memory
assert state is not None
memory.push(state, action, next_state, reward)
# Move to the next state
state = next_state
# Perform one step of the optimization (on the target network)
optimize_model()
#env.render() #Commenting this line hopping to do a faster training
if done:
episode_durations.append(t + 1)
plot_durations()
break
# Update the target network, copying all weights and biases in DQN
if i_episode % TARGET_UPDATE == 0:
target_net.load_state_dict(policy_net.state_dict())
print('Complete')
env.render()
env.close()
plt.ioff()
plt.show()
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=batch_size,
shuffle=True,
num_workers=2)
# Choose device.
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
net = neural_networks.Net()
#net = neural_networks.DetectShapeNet()
# Put the network into the device.
net.to(device)
criterion = nn.SmoothL1Loss()
optimizer = optim.Adam(net.parameters(), lr=0.001)
print('START')
running_step = int(args.running_step)
start = time.time()
for epoch in range(int(args.num_epochs)):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs
images = data['image'].to(device)
plural_landmarks = data['landmarks'].to(device).reshape(-1)
def __init__(self):
super(Loss, self).__init__()
self.shape_c = nn.CrossEntropyLoss()
self.color_c = nn.CrossEntropyLoss()
self.coord_c = nn.SmoothL1Loss()
discriminator = Discriminator(env.observation_space.shape[0])
P_outer_optimizer = optim.SGD(policy.parameters(),
lr=0.00004,
momentum=0.79,
nesterov=True)
G_outer_optimizer = optim.SGD(generator.parameters(),
lr=0.00004,
momentum=0.79,
nesterov=True)
D_outer_optimizer = optim.SGD(discriminator.parameters(),
lr=0.00001,
momentum=0.79,
nesterov=True)
lossfn = nn.SmoothL1Loss()
update = 200
def reset_inner():
policy_inner = ActorCriticNet(env.action_space.n,
env.observation_space.shape[0])
policy_inner.load_state_dict(policy.state_dict())
generator_inner = FakeNet(env.observation_space.shape[0])
generator_inner.load_state_dict(generator.state_dict())
discriminator_inner = Discriminator(env.observation_space.shape[0])
discriminator_inner.load_state_dict(discriminator.state_dict())
collate_fn=csv_collator)
# Model
with peter('Building network'):
model = unet_model.UNet(3,
1,
height=args.height,
width=args.width,
known_n_points=args.n_points)
num_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f" with {ballpark(num_params)} trainable parameters. ", end='')
model = nn.DataParallel(model)
model.to(device)
# Loss function
loss_regress = nn.SmoothL1Loss()
loss_loc = losses.WeightedHausdorffDistance(resized_height=args.height,
resized_width=args.width,
p=args.p,
return_2_terms=True,
device=device)
l1_loss = nn.L1Loss(size_average=False)
mse_loss = nn.MSELoss(reduce=False)
optimizer = optim.SGD(model.parameters(), lr=999) # will be set later
def find_lr(init_value=1e-6, final_value=1e-3, beta=0.7):
num = len(trainset_loader) - 1
mult = (final_value / init_value)**(1 / num)
lr = init_value
def getLoss(self,
masked_center,
pred_center_r,
box_pred,
pred_seg,
seg_mask,
box_center,
head_c,
head_r,
size_r,
box_weight=1.0,
corner_weight=10.0,
trace=False,
reduction='elementwise_mean'):
L1loss = nn.SmoothL1Loss(reduction=reduction)
CEloss = nn.CrossEntropyLoss(reduction=reduction)
target = torch.zeros(masked_center.size(0))
target_corner = torch.zeros(masked_center.size(0), 8)
pred_head_c = box_pred[:, 3:self.head_class + 3].argmax(dim=1)
head_c_onehot = torch.zeros(pred_head_c.size(0), self.head_class)
if args.cuda:
target, target_corner, head_c_onehot, pred_head_c, self.box_mean = \
target.cuda(), target_corner.cuda(), head_c_onehot.cuda(), pred_head_c.cuda(), self.box_mean.cuda()
head_c_onehot.scatter_(1, pred_head_c.unsqueeze(-1), 1)
mask_loss = CEloss(torch.transpose(pred_seg, 1, 2), seg_mask)
center_loss = L1loss(
torch.norm(box_center - (pred_center_r + masked_center), dim=1),
target)
box_center_loss = L1loss(
torch.norm(box_center -
(box_pred[:, :3] + pred_center_r + masked_center),
dim=1), target)
head_class_loss = CEloss(box_pred[:, 3:self.head_class + 3], head_c)
head_residual_loss = L1loss(
torch.sum(
box_pred[:, self.head_class + 3:2 * self.head_class + 3] *
head_c_onehot,
dim=1), head_r / (np.pi / self.head_class))
size_residual_loss = L1loss(box_pred[:, 2 * self.head_class + 3:],
size_r / self.box_mean)
pred_corner_3d = self.getBox(box_pred, pred_center_r, masked_center)
float_head_c = head_c.type(torch.FloatTensor)
if args.cuda:
float_head_c = float_head_c.cuda()
heading = float_head_c * 2 * np.pi / self.head_class + head_r
flip_heading = heading + np.pi
size = self.box_mean + size_r
corner_3d = get_box3d_corners(box_center, heading, size)
corner_3d_flip = get_box3d_corners(box_center, flip_heading, size)
corner_dist = torch.min(
torch.norm(corner_3d - pred_corner_3d, dim=-1),
torch.norm(corner_3d_flip - pred_corner_3d, dim=-1))
corner_loss = L1loss(corner_dist, target_corner)
if trace:
print(
" mask loss {}\n center_loss {} \n box_center_loss {} \n head_class_loss {} \n head_residual_loss {} \n size_residual_loss {}\n corner_loss {}"
.format(mask_loss, center_loss, box_center_loss,
head_class_loss, head_residual_loss,
size_residual_loss, corner_loss))
return mask_loss + box_weight * (
center_loss + box_center_loss + head_class_loss +
head_residual_loss * 20 + size_residual_loss * 20 + corner_weight *
corner_loss), pred_corner_3d, corner_3d, corner_3d_flip
def run_origin():
inp_dim = 2
out_dim = 1
mod_dir = '..'
'''load data'''
data = load_data() # axis1: number, year, month
data_x = np.concatenate((data[:-2, 0:1], data[+1:-1, 0:1]), axis=1)
data_y = data[2:, 0]
train_size = int(len(data_x) * 0.75)
train_x = data_x[:train_size]
train_y = data_y[:train_size]
train_x = train_x.reshape((-1, 1, inp_dim))
train_y = train_y.reshape((-1, 1, out_dim))
'''build model'''
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
net = RegLSTM(inp_dim, out_dim, mid_dim=4, mid_layers=2).to(device)
criterion = nn.SmoothL1Loss()
optimizer = torch.optim.Adam(net.parameters(), lr=1e-2)
'''train'''
var_x = torch.tensor(train_x, dtype=torch.float32, device=device)
var_y = torch.tensor(train_y, dtype=torch.float32, device=device)
print('var_x.size():', var_x.size())
print('var_y.size():', var_y.size())
for e in range(512):
out = net(var_x)
loss = criterion(out, var_y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (e + 1) % 100 == 0: # 每 100 次输出结果
print('Epoch: {}, Loss: {:.5f}'.format(e + 1, loss.item()))
torch.save(net.state_dict(), '{}/net.pth'.format(mod_dir))
'''eval'''
# net.load_state_dict(torch.load('{}/net.pth'.format(mod_dir), map_location=lambda storage, loc: storage))
net = net.eval() # 转换成测试模式
"""
inappropriate way of seq prediction:
use all real data to predict the number of next month
"""
test_x = data_x.reshape((-1, 1, inp_dim))
var_data = torch.tensor(test_x, dtype=torch.float32, device=device)
eval_y = net(var_data) # 测试集的预测结果
pred_y = eval_y.view(-1).cpu().data.numpy()
plt.plot(pred_y[1:], 'r', label='pred inappr', alpha=0.3)
plt.plot(data_y, 'b', label='real', alpha=0.3)
plt.plot([train_size, train_size], [-1, 2], label='train | pred')
"""
appropriate way of seq prediction:
use real+pred data to predict the number of next 3 years.
"""
test_x = data_x.reshape((-1, 1, inp_dim))
test_x[train_size:] = 0 # delete the data of next 3 years.
test_x = torch.tensor(test_x, dtype=torch.float32, device=device)
for i in range(train_size, len(data) - 2):
test_y = net(test_x[:i])
test_x[i, 0, 0] = test_x[i - 1, 0, 1]
test_x[i, 0, 1] = test_y[-1, 0]
pred_y = test_x.cpu().data.numpy()
pred_y = pred_y[:, 0, 0]
plt.plot(pred_y[2:], 'g', label='pred appr')
plt.legend(loc='best')
plt.savefig('lstm_origin.png')
plt.pause(4)
def train_single_scale(netD, netG, shapes, train_loader, val_loader,
test_loader, noise_amp, opt, depth, writer):
alpha = opt.alpha
############################
# define optimizers, learning rate schedulers, and learning rates for lower stages
###########################
# setup optimizers for D
optimizerD = optim.Adam(netD.parameters(),
lr=opt.lr_d,
betas=(opt.beta1, opt.beta2))
# setup optimizers for G
# remove gradients from stages that are not trained
for block in netG.body[:-opt.train_depth]:
for param in block.parameters():
param.requires_grad = False
# set different learning rate for lower stages
parameter_list = [{
"params":
block.parameters(),
"lr":
opt.lr_g *
(opt.lr_scale**(len(netG.body[-opt.train_depth:]) - 1 - idx))
} for idx, block in enumerate(netG.body[-opt.train_depth:])]
# add parameters of head and tail to training
if depth - opt.train_depth < 0:
parameter_list += [{
"params": netG.head.parameters(),
"lr": opt.lr_g * (opt.lr_scale**depth)
}]
parameter_list += [{"params": netG.tail.parameters(), "lr": opt.lr_g}]
optimizerG = optim.Adam(parameter_list,
lr=opt.lr_g,
betas=(opt.beta1, opt.beta2))
# define learning rate schedules
schedulerD = torch.optim.lr_scheduler.MultiStepLR(
optimizer=optimizerD, milestones=[0.8 * opt.niter], gamma=opt.gamma)
schedulerG = torch.optim.lr_scheduler.MultiStepLR(
optimizer=optimizerG, milestones=[0.8 * opt.niter], gamma=opt.gamma)
############################
# calculate noise_amp
###########################
if depth == 0:
noise_amp.append(opt.noise_amp_init)
else:
noise_amp.append(opt.noise_amp_init)
###########################
# define losses
###########################
content_loss = nn.SmoothL1Loss()
adversarial_loss = nn.BCELoss()
real_label = 1.
fake_label = 0.
# start training
for iter_idx in range(opt.niter):
for batch_id, (data, _) in enumerate(train_loader):
real = data[depth + 1].to(opt.device)
net_in = data[0].to(opt.device)
############################
# (0) sample noise for unconditional generation
###########################
noise = functions.sample_random_noise(depth + 1, shapes, opt)
############################
# (1) Update D network: maximize D(x) + D(G(z))
###########################
netD.zero_grad()
# train with real
output = netD(real)
ones_label = torch.full(output.size(),
real_label,
dtype=torch.float,
device=opt.device,
requires_grad=False)
zeros_label = torch.full(output.size(),
fake_label,
dtype=torch.float,
device=opt.device,
requires_grad=False)
errD_real = adversarial_loss(output, ones_label)
errD_real.backward()
# D_x = output.mean().item()
# train with fake
fake = netG(noise, net_in, shapes, noise_amp)
output = netD(fake.detach())
errD_fake = adversarial_loss(output, zeros_label)
errD_fake.backward()
# D_G_z1 = output.mean().item()
errD_total = errD_real + errD_fake
# errD_total.backward()
optimizerD.step()
############################
# (2) Update G network: maximize D(G(z))
###########################
netG.zero_grad()
output = netD(fake)
errG_f = adversarial_loss(output, ones_label)
# errG_f.backward()
D_G_z2 = output.mean().item()
content_loss_f = content_loss(fake, real)
errG_total = 1e-3 * errG_f + content_loss_f
errG_total.backward()
optimizerG.step()
############################
# (3) Log Results
###########################
batch2check = 10
step_id = iter_idx * len(train_loader) + batch_id
if batch_id % batch2check == 0 or iter_idx == (len(train_loader) -
1):
writer.add_scalar('Stage{}/Loss/errD_real'.format(depth),
errD_real.item(), step_id + 1)
writer.add_scalar('Stage{}/Loss/errD_fake'.format(depth),
errD_fake.item(), step_id + 1)
writer.add_scalar('Stage{}/Loss/errD_total'.format(depth),
errD_total.item(), step_id + 1)
writer.add_scalar('Stage{}/Loss/errG_f'.format(depth),
errG_f.item(), step_id + 1)
writer.add_scalar('Stage{}/Loss/content_loss_f'.format(depth),
content_loss_f.item(), step_id + 1)
writer.add_scalar('Stage{}/Loss/errG_total'.format(depth),
errG_total.item(), step_id + 1)
schedulerD.step()
schedulerG.step()
############################
# (4) Validation
###########################
# if iter_idx % 5 == 0 or iter_idx == (opt.niter - 1):
val_nums = 20
with torch.no_grad():
for batch_id, (data, _) in enumerate(val_loader):
step_id = iter_idx * val_nums + batch_id
real = data[depth + 1].to(opt.device)
noise = functions.sample_random_noise(depth + 1, shapes, opt)
net_in = data[0].to(opt.device)
fake = netG(noise, net_in, shapes, noise_amp)
net_in = functions.denorm(net_in)
imgs_lr_1 = torch.nn.functional.interpolate(
net_in,
size=[shapes[depth + 1][2], shapes[depth + 1][3]],
mode='bicubic',
align_corners=True)
# 保存图像到tensorboard
fake = functions.denorm(fake)
real = functions.denorm(real)
imgs_lr = make_grid(imgs_lr_1, nrow=1, normalize=False)
imgs_fake = make_grid(fake, nrow=1, normalize=False)
imgs_real = make_grid(real, nrow=1, normalize=False)
img_grid = torch.cat((imgs_lr, imgs_fake, imgs_real), -1)
save_image(img_grid,
"{}/stage{}_epoch{}_val_{}.jpg".format(
opt.outf, depth, iter_idx, step_id),
normalize=False)
writer.add_image(
"Stage_{}/Epoch_{}/Val_{}".format(depth, iter_idx,
batch_id), img_grid,
step_id)
if batch_id == (val_nums - 1):
break
functions.save_networks(netG, netD, opt)
return noise_amp, netG, netD
def get_config():
conf = edict()
conf.data = edict()
conf.model = edict()
conf.model.network = edict()
conf.train = edict()
conf.train.optimizer = edict()
conf.train.criterion = edict()
conf.job_name = 'test-20200301-4@1-depth-01'
conf.train_list = 'anno/DEPTH/4@1_train.txt'
conf.val_list = [
'anno/DEPTH/4@1_dev.txt', 'anno/DEPTH/4@2_dev.txt',
'anno/DEPTH/4@3_dev.txt'
]
conf.test_list = ['anno/DEPTH/4@1_dev.txt', 'anno/DEPTH/4@1_test.txt']
conf.data.folder = '/mnt/cephfs/smartauto/users/guoli.wang/jiachen.xue/anti_spoofing/data/CASIA-CeFA/phase1'
conf.data.crop_size = [256, 256]
conf.data.input_size = [224, 224]
conf.data.expand_ratio = 1.0
conf.data.use_multi_color = False
if conf.data.use_multi_color:
conf.data.in_data_format = ['L', 'RGB', 'YCbCr']
conf.data.in_plane = sum(
[color_channel_index[x] for x in conf.data.in_data_format])
else:
conf.data.in_data_format = 'RGB'
conf.data.in_plane = color_channel_index[conf.data.in_data_format]
conf.data.pin_memory = True
conf.data.num_workers = 4
conf.data.train_transform = trans.Compose([
trans.RandomCrop(conf.data.input_size),
# trans.RandomResizedCrop(conf.crop_size),
trans.RandomHorizontalFlip(p=0.5),
# trans.ColorJitter(brightness=0.3, contrast=0.3,
# saturation=0.3, hue=(-0.1, 0.1)),
trans.ToTensor(),
])
conf.data.test_transform = trans.Compose([
trans.CenterCrop(conf.data.input_size),
trans.ToTensor(),
])
conf.model.save_path = './snapshots'
conf.model.batch_size = 128
conf.model.use_mixup = True
conf.model.mixup_alpha = 0.5
conf.model.use_center_loss = False
conf.model.center_loss_weight = 0.01
conf.model.network.use_senet = True
conf.model.network.se_reduction = 16
conf.model.network.drop_out = 0.
conf.model.network.embedding_size = 512
# --------------------Training Config ------------------------
# if training:
conf.train.epoches = 50
conf.train.optimizer.lr = 0.001
conf.train.optimizer.gamma = 0.1
conf.train.optimizer.milestones = [20, 35, 45]
conf.train.optimizer.momentum = 0.9
conf.train.optimizer.weight_decay = 1e-4
conf.train.criterion.sl1 = nn.SmoothL1Loss()
conf.train.criterion.ce = nn.CrossEntropyLoss()
conf.train.criterion.cent = CenterLoss(
num_classes=2, feat_dim=conf.model.network.embedding_size)
conf.test = edict()
conf.test.save_name = [
'4@1-dev-single-best-acc-loss', '4@1-test-single-best-acc-loss'
]
conf.test.epoch = 7
conf.test.pred_path = './result/single_frame'
return conf
def __init__(self, params, device):
super(Model, self).__init__()
self.params = params
self.device = device
self.max_frames = params['max_frames']
self.input_video_dim = params['input_video_dim']
self.max_words = params['max_words']
self.input_ques_dim = params['input_ques_dim']
self.hidden_size = params['hidden_size']
self.conv_bottom = nn.Sequential(
nn.Conv1d(self.input_video_dim,
self.hidden_size,
kernel_size=15,
stride=1,
padding=7), nn.BatchNorm1d(self.hidden_size), nn.ReLU(),
nn.Conv1d(self.hidden_size,
self.hidden_size,
kernel_size=15,
stride=1,
padding=7), nn.BatchNorm1d(self.hidden_size), nn.ReLU())
self.conv_encoder_64 = nn.Sequential(
nn.Conv1d(self.hidden_size,
self.hidden_size,
kernel_size=32,
stride=8), nn.BatchNorm1d(self.hidden_size), nn.ReLU())
self.conv_encoder_128 = nn.Sequential(
nn.Conv1d(self.hidden_size,
self.hidden_size,
kernel_size=64,
stride=16), nn.BatchNorm1d(self.hidden_size), nn.ReLU())
self.conv_encoder_256 = nn.Sequential(
nn.Conv1d(self.hidden_size,
self.hidden_size,
kernel_size=128,
stride=32), nn.BatchNorm1d(self.hidden_size), nn.ReLU())
self.conv_encoder_512 = nn.Sequential(
nn.Conv1d(self.hidden_size,
self.hidden_size,
kernel_size=256,
stride=64), nn.BatchNorm1d(self.hidden_size), nn.ReLU())
self.conv_top = nn.Sequential(
nn.Conv1d(self.hidden_size,
self.hidden_size,
kernel_size=3,
stride=1,
padding=1), nn.BatchNorm1d(self.hidden_size), nn.ReLU())
self.ques_rnn = nn.GRU(self.input_ques_dim,
self.hidden_size,
batch_first=True)
self.fc_base = nn.Linear(self.hidden_size * 4, self.hidden_size)
self.fc_score = nn.Linear(self.hidden_size, 1)
self.fc_reg = nn.Linear(self.hidden_size, 2)
self.calculate_reg_loss = nn.SmoothL1Loss(reduction='elementwise_mean')
def __init__(self, sequence_length, number_of_features, hidden_size=90, hidden_layer_depth=2, latent_length=20,
batch_size=32, learning_rate=0.005, block='LSTM',
n_epochs=5, dropout_rate=0., optimizer='Adam', loss='MSELoss', distribution='normal',
cuda=False, print_every=100, clip=True, max_grad_norm=5, dload='.'):
super(VRAE, self).__init__()
self.dtype = torch.FloatTensor
self.use_cuda = cuda
if not torch.cuda.is_available() and self.use_cuda:
self.use_cuda = False
if self.use_cuda:
self.dtype = torch.cuda.FloatTensor
self.encoder = Encoder(number_of_features = number_of_features,
hidden_size=hidden_size,
hidden_layer_depth=hidden_layer_depth,
latent_length=latent_length,
dropout=dropout_rate,
block=block)
self.lmbd = Lambda(hidden_size=hidden_size,
latent_length=latent_length,
distribution=distribution)
self.reparam = ReParam(latent_length=latent_length,
distribution=distribution)
self.decoder = Decoder(sequence_length=sequence_length,
batch_size = batch_size,
hidden_size=hidden_size,
hidden_layer_depth=hidden_layer_depth,
latent_length=latent_length,
output_size=number_of_features,
block=block,
dtype=self.dtype)
self.sequence_length = sequence_length
self.hidden_size = hidden_size
self.hidden_layer_depth = hidden_layer_depth
self.latent_length = latent_length
self.batch_size = batch_size
self.learning_rate = learning_rate
self.n_epochs = n_epochs
self.print_every = print_every
self.clip = clip
self.max_grad_norm = max_grad_norm
self.is_fitted = False
self.dload = dload
if self.use_cuda:
self.cuda()
if optimizer == 'Adam':
self.optimizer = optim.Adam(self.parameters(), lr=learning_rate)
elif optimizer == 'SGD':
self.optimizer = optim.SGD(self.parameters(), lr=learning_rate)
else:
raise ValueError('Not a recognized optimizer')
if loss == 'SmoothL1Loss':
self.loss_fn = nn.SmoothL1Loss(size_average=False)
elif loss == 'MSELoss':
self.loss_fn = nn.MSELoss(size_average=False)
def __init__(self, attention = False, multi_scale = True):
super(ModelMLTRCTW, self).__init__()
self.inplanes = 64
self.layer0 = nn.Sequential(
Conv2d(3, 16, 3, stride=1, padding=1, bias=False),
CReLU_IN(16),
Conv2d(32, 32, 3, stride=2, padding=1, bias=False),
CReLU_IN(32)
)
self.layer0_1 = nn.Sequential(
Conv2d(64, 64, 3, stride=1, padding=1, bias=False),
#nn.InstanceNorm2d(64, affine=True),
nn.ReLU(),
Conv2d(64, 64, 3, stride=2, padding=1, bias=False),
#nn.InstanceNorm2d(64, affine=True),
nn.ReLU(inplace=True)
)
self.conv5 = Conv2d(64, 128, (3,3), padding=(1, 1), bias=False)
self.conv6 = Conv2d(128, 128, (3,3), padding=1, bias=False)
self.conv7 = Conv2d(128,256, 3, padding=1, bias=False)
self.conv8 = Conv2d(256, 256, (3,3), padding=1, bias=False)
self.conv9 = Conv2d(256, 256, (3,3), padding=(1, 1), bias=False)
self.conv10_s = Conv2d(256, 256, (2, 3), padding=(0, 1), bias=False)
self.conv11 = Conv2d(256, 8400, (1, 1), padding=(0,0))
self.batch5 = InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
self.batch6 = InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
self.batch7 = InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
self.batch8 = InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
self.batch9 = InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
self.batch10_s = InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
self.max2 = nn.MaxPool2d((2, 1), stride=(2,1))
self.leaky = LeakyReLU(negative_slope=0.01, inplace=True)
self.layer1 = self._make_layer(BasicBlockIn, 64, 3, stride=1)
self.inplanes = 64
self.layer2 = self._make_layer(BasicBlockIn, 128, 4, stride=2)
self.layer3 = self._make_layer(BasicBlockSepIn, 256, 6, stride=2)
self.layer4 = self._make_layer(BasicBlockSepIn, 512, 4, stride=2)
self.feature4 = nn.Conv2d(512, 256, 1, stride=1, padding=0, bias=False)
self.feature3 = nn.Conv2d(256, 256, 1, stride=1, padding=0, bias=False)
self.feature2 = nn.Conv2d(128, 256, 1, stride=1, padding=0, bias=False)
self.upconv2 = conv_dw_plain(256, 256, stride=1)
self.upconv1 = conv_dw_plain(256, 256, stride=1)
self.feature1 = nn.Conv2d(64, 256, 1, stride=1, padding=0, bias=False)
self.act = Conv2d(256, 1, (1,1), padding=0, stride=1)
self.rbox = Conv2d(256, 4, (1,1), padding=0, stride=1)
self.angle = Conv2d(256, 2, (1,1), padding=0, stride=1)
self.drop1 = Dropout2d(p=0.2, inplace=False)
self.angle_loss = nn.MSELoss(reduction='elementwise_mean')
self.h_loss = nn.SmoothL1Loss(reduction='elementwise_mean')
self.w_loss = nn.SmoothL1Loss(reduction='elementwise_mean')
self.attention = attention
if self.attention:
self.conv_attenton = nn.Conv2d(256, 1, kernel_size=1, stride=1, padding=0, bias=True)
self.multi_scale = multi_scale
def __init__(self, net):
super(NetWarpper, self).__init__()
self.net = net
self.seg_criterion = nn.CrossEntropyLoss(reduce=False) # Segmetation の判定基準
self.vertex_criterion = nn.SmoothL1Loss(reduction="none") # vertex の判定基準
def main(args):
# Build data loader
if not os.path.isdir(args.model_path):
os.makedirs(args.model_path)
data_loader,ds_class = get_loader(args.data_dir,args.batch_size,
shuffle=True, num_workers=args.num_workers, ds = args.ds)
# Build eval data loader
if hasattr(ds_class, 'lbl2id'):
eval_data_loader,_ = get_loader(args.data_dir_test, args.batch_size,
shuffle=True, num_workers=args.num_workers, ds = args.ds, lbl2id = ds_class.lbl2id)
else:
eval_data_loader,_ = get_loader(args.data_dir_test, args.batch_size,
shuffle=True, num_workers=args.num_workers, ds = args.ds)
# Loss and Optimizer
model_base = SkeletonAction(args.input_size, args.hidden_size, args.num_class, args.num_action, args.num_layers, dropout = args.dropout)
model_value = ValueNetwork( args.hidden_size )
model_policy = PolicyNetwork( args.hidden_size, args.num_action )
model_c = CoreClassification( args.hidden_size, args.num_class )
criterion = nn.CrossEntropyLoss()
criterion_value = nn.SmoothL1Loss()
if torch.cuda.is_available():
model_base.cuda()
model_value.cuda()
model_policy.cuda()
model_c.cuda()
criterion = criterion.cuda()
criterion_value = criterion_value.cuda()
params = list(model_base.parameters()) + list(model_c.parameters()) + list(model_value.parameters()) \
+ list(model_policy.parameters())
#opt = torch.optim.Adam(params, lr=args.learning_rate, weight_decay = args.weight_decay)
opt = torch.optim.Adam(params, lr=args.learning_rate)
#opt_value = torch.optim.Adam(model_value.parameters(), lr = args.learning_rate)
#opt_policy = torch.optim.Adam(model_policy.parameters(), lr = args.learning_rate)
#opt_c = torch.optim.Adam(model_c.parameters(), lr = args.learning_rate)
# Load the trained model parameters
# Now, we try to find the latest encoder and decoder model.
if os.path.isdir(args.model_path) and os.listdir(args.model_path):
m_fn = max(glob.glob(os.path.join(args.model_path, 'model*')), key = os.path.getctime)
if m_fn:
logging.info("Loading model from %s", m_fn)
model.load_state_dict(torch.load(m_fn))
# Train the Models
total_step = len(data_loader)
# Initialize some variables.
h_tensor = torch.zeros(args.batch_size, args.hidden_size)
if torch.cuda.is_available():
h_tensor = h_tensor.cuda()
for epoch in range(args.num_epochs):
total_train = 0
total_correct = 0
total_train_2 = 0
total_correct_2 = 0
for i_step, (lbl, data, length) in enumerate(data_loader):
# Set mini-batch dataset
lbl = Variable(lbl.squeeze())
data = Variable(data)
mask = torch.zeros(data.size(0), data.size(1))
for i,m in zip(length, mask):
m[0:i[0]] = 1
mask = Variable(mask)
if torch.cuda.is_available():
lbl = lbl.cuda()
data = data.cuda()
mask = mask.cuda()
h_tensor.resize_(data.size(0), data.size(1))
init_h = Variable(h_tensor)
init_hs = [ init_h for i in range( args.num_layers ) ]
init_cs = init_hs
zero = torch.zeros(data.size(0),)
zero = Variable(zero)
if torch.cuda.is_available():
zero = zero.cuda()
hs = []
action_probs = []
actions = []
ht, ct = model_base( data[:,0,:], zero, init_hs, init_cs)
hs.append(ht[-1])
action_prob = model_policy(ht[-1])
action_probs.append(action_prob)
action = Categorical(action_prob)
action = action.sample()
actions.append(action)
for j_step in range(1, data.shape[1]):
ht, ct = model_base( data[:,j_step,:], actions[j_step-1].float(), ht, ct)
hs.append(ht[-1])
action_prob = model_policy(ht[-1])
# We need to smooth the probability
action = Categorical((action_prob + action_probs[j_step-1]) / 2)
action = action.sample()
actions.append(action)
action_probs.append(action_prob)
# now, we have finished all the actions.
# need to bp.
# the award only returns at the end of the episode.
hs_t = torch.stack(hs, dim = 1)
hs_t = (hs_t * mask.unsqueeze(2) ).sum(dim = 1) / mask.sum(dim = 1).unsqueeze(1)
logits = model_c(hs_t)
#log_p = F.log_softmax(logits, dim = 1)
loss_ent = criterion(logits, lbl)
#loss = - (mask.squeeze() * log_p[long_idx, lbl.squeeze().data]).sum() / mask.sum()
pred_lbl = logits.max(dim = 1)[1]
reward = Variable((pred_lbl.data == lbl.data).float())
reward = reward.view(data.size(0), 1)
reward = reward.repeat(1, data.size(1))
loss_value = []
loss_policy = []
actions = torch.stack(actions, dim = 1)
action_probs = torch.stack(action_probs, dim = 1)
hs = torch.stack(hs, dim = 1)
hs = hs.view(-1, hs.size(-1))
exp_reward = model_value(hs)
exp_reward = exp_reward.view(data.size(0), data.size(1))
loss_value =( exp_reward - reward ) ** 2
loss_value = (loss_value * mask).sum() / mask.sum()
pdb.set_trace()
advantage = reward - Variable(exp_reward.data)
idx = torch.LongTensor(range(data.size(0)))
idx = idx.view(data.size(0), 1)
idx = idx.repeat(1, data.size(1))
idx = idx.view(data.size(0) * data.size(1))
if torch.cuda.is_available():
idx = idx.cuda()
action_probs = action_probs.view(action_probs.size(0) * action_probs.size(1),action_probs.size(-1))
actions = actions.view(actions.size(0) * actions.size(1))
log_prob = action_probs[idx, actions]
log_prob = log_prob.view(mask.size(0), mask.size(1))
pdb.set_trace()
loss_policy = -torch.log(log_prob + 1e-7) * mask * advantage
pdb.set_trace()
loss_policy = loss_policy.sum() / mask.sum()
loss = loss_ent + loss_policy + loss_value
# Now we update the value network
#for j_step, (h, action, action_prob) in enumerate(zip(hs, actions, action_probs)):
# # total reward.
# target = reward * discount ** (data.size(0) - j_step)
# exp_reward = model_value(h)
# logging.info('exp_reward: %.4f, target: %.4f', exp_reward.mean().data[0], target.mean().data[0])
# l_value = criterion_value(exp_reward, target)
# loss_value.append( l_value )
# advantage = target - exp_reward
# c = Categorical(action_prob)
# l_policy = -c.log_prob(action) * advantage
# loss_policy.append( l_policy.mean() )
#loss_value = torch.stack(loss_value).mean()
#loss_policy = torch.stack(loss_policy).mean()
#loss += loss_value + loss_policy
opt.zero_grad()
loss.backward()
old_norm = clip_grad_norm(params, args.grad_clip)
opt.step()
total_train += data.size(0)
total_correct += (pred_lbl.data.cpu().squeeze() == lbl.data.cpu().squeeze()).sum()
# Use grad clip.
# Eval the trained model
#logging.info('Epoch [%d/%d], Loss: %.4f, reward: %5.4f, loss_value: %5.4f, loss_policy: %5.4f',
# epoch, args.num_epochs,
# loss_ent.data[0], reward.mean().data[0], loss_value.data[0], loss_policy.data[0])
if i_step % args.log_step == 0:
accuracy = total_correct * 1.0 / total_train
logging.info('Epoch [%d/%d], Loss: %.4f, reward: %5.4f, loss_value: %5.4f, loss_policy: %5.4f, accuracy: %5.4f',
epoch, args.num_epochs,
loss_ent.data[0], reward.mean().data[0], loss_value.data[0], loss_policy.data[0], accuracy)
#logging.info('Epoch [%d/%d], Loss: %.4f, accuracy: %5.4f, reward: %5.4f'
# ,epoch, args.num_epochs,
# loss_ent.data[0], accuracy, reward.mean().data[0])
if i_step % args.eval_step == 0:
model_base.eval()
model_c.eval()
model_policy.eval()
total_num = 0
correct_num = 0
for k_step, (lbl, data, length) in enumerate(eval_data_loader):
lbl = Variable(lbl.squeeze())
data = Variable(data)
mask = torch.zeros(data.size(0), data.size(1))
for i,m in zip(length, mask):
m[0:i[0]] = 1
if torch.cuda.is_available():
lbl = lbl.cuda()
data = data.cuda()
mask = mask.cuda()
mask = Variable(mask)
h_tensor.resize_(data.size(0), data.size(1))
init_h = Variable(h_tensor)
init_hs = [ init_h for i in range( args.num_layers ) ]
init_cs = init_hs
zero = torch.zeros(data.size(0),)
zero = Variable(zero)
if torch.cuda.is_available():
zero = zero.cuda()
hs = []
action_probs = []
actions = []
ht, ct = model_base( data[:,0,:], zero, init_hs, init_cs)
hs.append(ht[-1])
action_prob = model_policy(ht[-1])
action_probs.append(action_prob)
action = Categorical(action_prob)
action = action.sample()
actions.append(action)
for j_step in range(1, data.shape[1]):
ht, ct = model_base( data[:,j_step,:], action.float(), ht, ct)
hs.append(ht[-1])
action_prob = model_policy(ht[-1])
action = Categorical(action_prob)
action = action.sample()
actions.append(action)
# now, we have finished all the actions.
# need to bp.
# the award only returns at the end of the episode.
hs_t = torch.stack(hs, dim = 1)
hs_t = (hs_t * mask.unsqueeze(2) ).sum(dim = 1) / mask.sum(dim = 1).unsqueeze(1)
logits = model_c(hs_t)
log_p = F.log_softmax(logits, dim = 1)
pred_lbl = logits.max(dim = -1)[1].data.cpu()
total_num += data.size(0)
correct_num += (pred_lbl.squeeze() == lbl.data.cpu().squeeze()).sum()
loss = criterion(logits, lbl)
accuracy = correct_num * 1.0 / total_num
logging.info('Validating [%d], Loss: %.4f, accuracy: %.4f' ,epoch,
loss.data[0], accuracy)
model_base.train()
model_c.train()
model_policy.eval()
accuracy = total_correct * 1.0 / total_train
logging.info('Epoch [%d/%d], Loss: %.4f, accuracy: %5.4f, reward: %5.4f'
,epoch, args.num_epochs,
loss_ent.data[0], accuracy, reward.mean().data[0])
def __init__(self, alpha, beta):
super(VoxelLoss, self).__init__()
self.smoothl1loss = nn.SmoothL1Loss(size_average=False)
self.alpha = alpha
self.beta = beta
def train(self, model, data, testdata, num_epochs=100, epochsize=100):
#loss = self.loss_func
#optim = self.optim(model.parameters(), **self.optim_args)
optim = torch.optim.SGD(model.parameters(),
lr=0.001,
momentum=0.9,
weight_decay=0.9)
optim = torch.optim.Adam(model.parameters(),
lr=0.0001,
weight_decay=0.9)
#criterion = nn.CrossEntropyLoss()
#criterion = nn.MSELoss(size_average=False)
#criterion = nn.MultiLabelSoftMarginLoss()
criterion = nn.SmoothL1Loss(size_average=False)
#criterion = nn.BCELoss(size_average=False)
self._reset_histories()
iter_per_epoch = len(data)
inputs, labels = (data[0]), (data[1])
test, testlabels = (testdata[0]), (testdata[1])
print("inputs: ", inputs.size(), "targets: ", labels.size())
print('START TRAIN.')
iterations = int(inputs.size(0) / epochsize)
for epoch in range(num_epochs):
running_loss = 0.0
for iter in range(iterations):
randoms = random.sample(range(0, inputs.size(0)), epochsize)
input = torch.Tensor()
label = torch.Tensor()
for i in randoms:
input = torch.cat((input, inputs[i].view(1, 1, 64, 64)), 0)
label = torch.cat((label, (labels[i].view(1, 1, 64, 64))),
0)
if torch.cuda.is_available():
model = model.cuda()
input, label = (input.cuda()), (label.cuda())
input = Variable(input)
label = Variable(label)
optim.zero_grad()
output = model(input)
loss = criterion(output, label)
#own loss function
#frobinput = torch.add(label,bothbothboth torch.mul(output,-1)) #wrong function
#loss = torch.sum(torch.sum((torch.abs(frobinput))))
#frob = torch.rsqrt(torch.sum(torch.sum(torch.pow(torch.abs(frobinput),2))))
#loss = torch.sum(torch.sum(frob*frob))
#end own loss function
loss.backward()
running_loss += loss.data[0]
optim.step()
print("epoche: ", epoch, "iter:", iter, "loss:", loss.data[0])
torch.save(model.cpu(), 'facefronter.pt')
#accurency
epochtraining = 0
predicted = 1
predicted_right = 0
av_loss = 0
randoms = random.sample(range(0, test.size(0)), epochsize * 2)
input = torch.Tensor()
label = torch.Tensor()
for i in randoms:
input = test[i].view(1, 1, 64, 64)
label = (testlabels[i].view(1, 1, 64, 64))
if torch.cuda.is_available():
model = model.cuda()
input, label = (input.cuda()), (label.cuda())
input = Variable(input)
label = Variable(label)
optim.zero_grad()
output = model(input)
loss = criterion(output, label)
predicted += 1
av_loss += loss.data[0]
if loss.data[0] < 80:
predicted_right += 1
self.accurancy_test.append(predicted_right / predicted)
self.loss_test.append(av_loss / predicted)
self.loss.append(running_loss / iterations)
print("epoche: ", epoch, "loss:", running_loss / iterations,
"accurancy:", predicted_right / predicted,
av_loss / predicted)
print('Finished Training')
def __init__(self,
env,
seed=None,
lr=0.001,
training_steps=10000,
batch_size=32,
replay_size=10000,
final_epsilon=0.05,
exploration_steps=10000,
gamma=0.99,
hidden_sizes=[64, 64],
target_update_freq=1000,
**kwargs):
# This DQN implementation only works for flat actions
assert isinstance(env.action_space, FlatActionSpace)
print(f"\nRunning DQN with config:")
pprint(locals())
# set seeds
self.seed = seed
if self.seed is not None:
np.random.seed(self.seed)
# envirnment setup
self.env = env
self.num_actions = self.env.action_space.n
self.obs_dim = self.env.observation_space.shape
# logger setup
self.logger = SummaryWriter()
# Training related attributes
self.lr = lr
self.exploration_steps = exploration_steps
self.final_epsilon = final_epsilon
self.epsilon_schedule = np.linspace(1.0, self.final_epsilon,
self.exploration_steps)
self.batch_size = batch_size
self.discount = gamma
self.training_steps = training_steps
self.steps_done = 0
# Neural Network related attributes
self.device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu")
self.dqn = DQN(self.obs_dim, hidden_sizes,
self.num_actions).to(self.device)
print("\nUsing Neural Network:")
print(self.dqn)
self.target_dqn = DQN(self.obs_dim, hidden_sizes,
self.num_actions).to(self.device)
self.target_update_freq = target_update_freq
self.optimizer = optim.Adam(self.dqn.parameters(), lr=self.lr)
self.loss_fn = nn.SmoothL1Loss()
# replay setup
self.replay = ReplayMemory(replay_size, self.obs_dim, self.device)
def initialize_train_network(trainloader, testloader_flickr, testloader_div,
testloader_urban, debug):
results = "/home/harsh.shukla/SRCNN/SRSN_results"
if not os.path.exists(results):
os.makedirs(results)
# Initialising Checkpointing directory
checkpoints = os.path.join(results, "Checkpoints")
if not os.path.exists(checkpoints):
os.makedirs(checkpoints)
checkpoint_file = os.path.join(checkpoints, "check.pt")
# Initialising directory for Network Debugging
net_debug = os.path.join(results, "Debug")
if not os.path.exists(net_debug):
os.makedirs(net_debug)
model = SRSN_RRDB()
model = nn.DataParallel(model)
model.to(device)
print(next(model.parameters()).device)
model.apply(weight_init) ## Weight initialisation
optimizer = optim.Adam(model.parameters(),
lr=0.0001,
betas=(0.9, 0.999),
eps=1e-8)
# optimizer = optim.RMSprop(params, lr=0.01, alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=False)
my_lr_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
optimizer,
mode='min',
factor=0.5,
patience=5,
threshold=0.0001,
threshold_mode='rel',
cooldown=0,
min_lr=0,
eps=1e-08,
verbose=False)
# criterion = nn.MSELoss().to(device)
test_criterion = nn.MSELoss().to(device)
criterion = nn.SmoothL1Loss().to(device)
# load model if exists
if os.path.exists(checkpoint_file):
print("Loading from Previous Checkpoint...")
checkpoint = torch.load(checkpoint_file)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
model.train()
else:
print(
"No previous checkpoints exist, initialising network from start..."
)
## Parameters in Networks
print("Number of Parameters in Super Resolution Network")
count_parameters(model)
best_loss = 10000
train = []
test = []
psnr_div = []
psnr_flickr = []
psnr_urban = []
if os.path.exists((os.path.join(results, "Train_loss.txt"))):
dbfile = open(os.path.join(results, "Train_loss.txt"), 'rb')
train = pickle.load(dbfile)
dbfile = open(os.path.join(results, "Test_loss.txt"), 'rb')
test = pickle.load(dbfile)
dbfile = open(os.path.join(results, "PSNR_flickr.txt"), 'rb')
psnr_flickr = pickle.load(dbfile)
dbfile = open(os.path.join(results, "PSNR_div.txt"), 'rb')
psnr_div = pickle.load(dbfile)
dbfile = open(os.path.join(results, "PSNR_bsd.txt"), 'rb')
psnr_bsd = pickle.load(dbfile)
loss1 = 0
for epoch in range(80):
training_loss = []
test_loss_flickr = []
test_loss_div = []
test_loss_urban = []
list_no = 0
for input_, target in trainloader:
if torch.cuda.is_available():
input_ = input_.to(device)
target = target.to(device)
output = model(input_)
loss = criterion(output, target)
loss.backward()
optimizer.step()
if debug == True:
plot_grad_flow(net_debug, model.named_parameters(),
"super_resolution_network")
optimizer.zero_grad()
training_loss.append(loss.item())
with torch.set_grad_enabled(False):
for local_batch, local_labels in testloader_urban:
local_batch, local_labels = local_batch.to(
device), local_labels.to(device)
output = model(local_batch).to(device)
local_labels.require_grad = False
test_loss_urban.append(
test_criterion(output, local_labels).item())
for local_batch, local_labels in testloader_div:
local_batch, local_labels = local_batch.to(
device), local_labels.to(device)
output = model(local_batch).to(device)
local_labels.require_grad = False
test_loss_div.append(
test_criterion(output, local_labels).item())
for local_batch, local_labels in testloader_flickr:
local_batch, local_labels = local_batch.to(
device), local_labels.to(device)
output = model(local_batch).to(device)
local_labels.require_grad = False
test_loss_flickr.append(
test_criterion(output, local_labels).item())
# if debug == True:
# visualise_layer_activation(model,local_batch,net_debug)
my_lr_scheduler.step(test_loss_flickr[-1])
torch.save(
{
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
}, checkpoint_file)
if (debug == True):
label = im.fromarray(
np.uint8(
np.moveaxis((local_labels[0]).cpu().detach().numpy(), 0,
-1))).convert('RGB')
output = im.fromarray(
np.uint8(np.moveaxis((output[0].cpu()).detach().numpy(), 0,
-1))).convert('RGB')
label.save(
os.path.join(results,
str(epoch) + 'test_target' + '.png'))
output.save(
os.path.join(results,
str(epoch) + 'test_output' + '.png'))
train.append(sum(training_loss) / len(training_loss))
test.append(sum(test_loss_flickr) / len(test_loss_flickr))
psnr_flickr.append(
10 * math.log10(255 * 255 /
(sum(test_loss_flickr) / len(test_loss_flickr))))
psnr_div.append(10 *
math.log10(255 * 255 /
(sum(test_loss_div) / len(test_loss_div))))
psnr_urban.append(
10 * math.log10(255 * 255 /
(sum(test_loss_urban) / len(test_loss_urban))))
with open(os.path.join(results, "Train_loss.txt"), 'wb') as f:
pickle.dump(train, f)
with open(os.path.join(results, "Test_loss.txt"), 'wb') as f:
pickle.dump(test, f)
with open(os.path.join(results, "PSNR_flickr.txt"), 'wb') as f:
pickle.dump(psnr_flickr, f)
with open(os.path.join(results, "PSNR_div.txt"), 'wb') as f:
pickle.dump(psnr_div, f)
with open(os.path.join(results, "PSNR_bsd.txt"), 'wb') as f:
pickle.dump(psnr_urban, f)
print("Epoch :", epoch, flush=True)
print("Training loss :",
sum(training_loss) / len(training_loss),
flush=True)
print("Test loss for Flickr:",
sum(test_loss_flickr) / len(test_loss_flickr),
flush=True)
print("Test loss for Div:",
sum(test_loss_div) / len(test_loss_div),
flush=True)
print("Test loss for Urban:",
sum(test_loss_urban) / len(test_loss_urban),
flush=True)
print(
"PSNR for Flickr :",
10 * math.log10(255 * 255 /
(sum(test_loss_flickr) / len(test_loss_flickr))))
print(
"PSNR for Div :", 10 *
math.log10(255 * 255 / (sum(test_loss_div) / len(test_loss_div))))
print(
"PSNR for Urban100 :",
10 * math.log10(255 * 255 /
(sum(test_loss_urban) / len(test_loss_urban))))
print(
"-----------------------------------------------------------------------------------------------------------"
)
try:
file = open(os.path.join(results, "SR_train_loss.txt"), 'w+')
try:
for i in range(len(test)):
file.write(str(train[i]) + "," + str(test[i]))
file.write('\n')
finally:
file.close()
except IOError:
print("Unable to create loss file")
print(
"---------------------------------------------------------------------------------------------------------------"
)
print("Training Completed")
def main(args):
dataset = args.data
gpu = args.gpu
batch_size = args.batch_size
dropout_p = args.dropout_p
model_path = args.model_path
log_path = args.log_path
num_epochs = args.num_epochs
learning_rate = args.learning_rate
start_epoch = args.start_epoch
gan_loss = args.gan_loss
always_give_global_hint = args.always_give_global_hint
multi_injection = args.multi_injection
add_L = args.add_L
print("Running on gpu : ", gpu)
cuda.set_device(gpu)
make_folder(model_path, dataset)
make_folder(log_path, dataset + '/ckpt')
(train_dataset, train_loader,
imsize) = Color_Dataloader(dataset, batch_size, 0)
(G, D, G_optimizer, D_optimizer, G_scheduler,
D_scheduler) = init_models(batch_size, imsize, dropout_p, learning_rate,
multi_injection, add_L)
criterion_sL1 = nn.SmoothL1Loss().cuda()
criterion_bce = nn.BCELoss().cuda()
(G, G_optimizer, D, D_optimizer, _,
start_epoch) = resume(args.resume, log_path, dataset, G, G_optimizer, D,
D_optimizer)
tell_time = Timer()
iter = 0
gm = GanModel()
for epoch in range(start_epoch, num_epochs):
G.train()
for i, (images, pals) in enumerate(train_loader):
(_, _, loss,
sL1_loss) = train(gm, images, pals, G, D, G_optimizer,
D_optimizer, criterion_bce, criterion_sL1,
always_give_global_hint, add_L, gan_loss, True)
num_batches = (len(train_dataset) // batch_size)
print_log(0, 0, epoch, i, num_epochs, num_batches, sL1_loss,
tell_time, iter)
checkpoint = {
'epoch': epoch + 1,
'args': args,
'G_state_dict': G.state_dict(),
'G_optimizer': G_optimizer.state_dict(),
'D_state_dict': D.state_dict(),
'D_optimizer': D_optimizer.state_dict()
}
torch.save(checkpoint,
os.path.join(log_path, dataset, 'ckpt/model.ckpt'))
msg = "epoch: %d" % (epoch)
if (epoch + 1) % 10 == 0:
print('Saved model')
torch.save(
G.state_dict(),
os.path.join(model_path, dataset,
'%s_cGAN-unet_bird256.pkl' % (msg)))
def main():
print('Preparing data')
num_classes = get_num_classes(args)
embedding_size = get_embedding_size(args.embedding)
train_data, test_data, gt_annotations, text_embedding = load_data(args, embedding_size)
#sampler = torch.utils.data.sampler.WeightedRandomSampler(weights, len(weights))
train_loader = DataLoader(train_data, batch_size=args.batch_size, shuffle=True, num_workers=args.prefetch,
pin_memory=True)
test_loader = DataLoader(test_data, batch_size=args.batch_size, shuffle=True, num_workers=args.prefetch,
pin_memory=True)
print('Creating Model')
net = load_model(args, num_classes, embedding_size)
print('Optimizer: ', args.optim)
if args.optim == 'sgd':
optim = torch.optim.SGD(net.parameters(), args.learning_rate, momentum=args.momentum, weight_decay=args.decay, nesterov=True)
elif args.optim =='adam':
optim = torch.optim.Adam(filter(lambda p: p.requires_grad, net.parameters()), args.learning_rate, betas=(0.9, 0.999), eps=1e-08, weight_decay=args.decay)
elif args.optim =='radam':
optim_base = RAdam(filter(lambda p: p.requires_grad, net.parameters()), args.learning_rate)
optim = Lookahead(optim_base, k=5, alpha=0.5)
else: print("Optimizer not implemented")
# Weight Tensor for Criterion
weights = get_weight_criterion(args.dataset)
class_weights = torch.FloatTensor(weights).cuda()
criterion = nn.CrossEntropyLoss(weight=class_weights)
if args.regularization == 'L1':
criterion2 = nn.SmoothL1Loss()
if args.regularization == 'L2':
criterion2 = nn.MSELoss()
evaluation = None
print('Checking CUDA')
if args.cuda and args.ngpu > 1:
print('\t* Data Parallel **NOT TESTED**')
net = torch.nn.DataParallel(net, device_ids=list(range(args.ngpu)))
if args.cuda:
print('\t* CUDA ENABLED!')
net = net.cuda()
criterion = criterion.cuda()
# Init variables
early_stop_counter, start_epoch, best_perf = 0, 0, 0
if args.load is not None:
checkpoint = load_checkpoint(args.load)
net.load_state_dict(checkpoint)
for epoch in range(start_epoch, args.epochs):
# Update learning rate
adjust_learning_rate(optim, epoch)
if args.test == 'False':
print('\n*** TRAIN ***\n')
loss = train(train_loader, net, optim, args.cuda, criterion, epoch, args.log_interval, num_classes, args.batch_size, criterion2, args.epsilon)
print('\n*** TEST ***\n')
performance = test(test_loader, net, args.cuda, num_classes, args.batch_size)
# Early-Stop + Save model
if performance > best_perf:
best_perf = performance
best_epoch = epoch
early_stop_counter = 0
if args.save_weights:
save_filename = 'checkpoint_' + str(args.fusion) + '_' + str(args.epsilon) + '_' + str(args.regularization) + '_' + str(best_perf)
save_checkpoint(net, best_perf, directory=args.save, file_name=save_filename)
else:
if early_stop_counter == args.early_stop:
print('\nEarly stop reached!')
break
early_stop_counter += 1
# Load Best model in case of save it
print("\nBest Performance is: %f at Epoch No. %d" % (best_perf, best_epoch))
print('*** Training Completed ***')
sys.exit()
update_target_interval = 50 # 目标网络更新间隔
batch_size = 64
train_flag = False
train_len = 1000
# 初始化
Q_value = DQN(input_size=state_size,
output_size=output_size,
memory_len=memory_len)
Q_target = DQN(input_size=state_size,
output_size=output_size,
memory_len=memory_len)
score_list = []
loss_list = []
optimizer = optim.Adam(Q_value.parameters(), lr=learning_rate)
huber = nn.SmoothL1Loss()
for i in range(epoch_num):
epsilon = max(0.01, 0.16 - 0.01 * (i) / 200)
s = env.reset()
score = 0
for j in range(max_steps):
env.render()
a = Q_value.sample_action(s, epsilon=epsilon)
s_next, reward, done, info = env.step(a)
done_flag = 0.0 if done else 1.0
Q_value.save_memory((s, a, reward / 100, s_next, done_flag))
score += reward
s = s_next
if done:
break
# data paths data_asf_path = 'Data_Compiler/S35T07.asf' data_amc_path = 'Data_Compiler/S35T07.amc' ## Define model parameters model_path = 'CoreLSTM/models/LSTM_46_cell.pt' ## Define tuning parameters tuning_length = 10 # length of tuning horizon tuning_cycles = 3 # number of tuning cycles in each iteration # possible loss functions mse = nn.MSELoss() l1Loss = nn.L1Loss() # smL1Loss = nn.SmoothL1Loss() smL1Loss = nn.SmoothL1Loss(beta=0.4) # smL1Loss = nn.SmoothL1Loss(reduction='sum', beta=0.8) l2Loss = lambda x, y: mse(x, y) * (num_input_dimensions * num_input_features) # define learning parameters lstm_loss_function = mse at_learning_rate = 1 # TODO try different learning rates at_learning_rate_state = 0.0 # loss_scale_factor = 0.6 bm_momentum = 0.0 c_momentum = 0.0 r_momentum = 0.0 ## Define tuning variables
def train(q_net, target_net, start):
target_net.eval()
optimizer = optim.Adam(q_net.parameters(), lr=1e-6)
# criterion = nn.MSELoss()
criterion = nn.SmoothL1Loss()
replay_memory = []
steps_done = 0
for episode in range(600):
# state shape is 96 x 96 x 3
state = env.reset()
epsilon = q_net.initial_epsilon
epsilon_decrements = np.linspace(q_net.initial_epsilon,
q_net.final_epsilon,
q_net.number_of_iterations)
game_action = np.array(action_map[0]).astype('float32')
next_state, reward, terminal, info = env.step(game_action)
next_state = resize_and_bgr2gray(next_state)
next_state = image_to_tensor(next_state)
state = torch.cat(
(next_state, next_state, next_state, next_state)).unsqueeze(0)
iteration = 0
c_reward = 0
while True:
output = q_net(state)[0]
action = torch.zeros([q_net.number_of_actions],
dtype=torch.float32)
if torch.cuda.is_available():
action = action.cuda()
# epsilon greedy exploration
random_action = random.random() <= epsilon
action_index = [
torch.randint(
q_net.number_of_actions, torch.Size([]), dtype=torch.int)
if random_action else torch.argmax(output)
][0]
if torch.cuda.is_available():
action_index = action_index.cuda()
action[action_index] = 1
action = action.unsqueeze(0)
game_action = np.array(
action_map[action_index.item()]).astype('float32')
for i in range(q_net.game_step):
next_state_1, reward, terminal, info = env.step(game_action)
next_state_1 = resize_and_bgr2gray(next_state_1)
next_state_1 = image_to_tensor(next_state_1)
state_1 = torch.cat(
(state.squeeze(0)[1:, :, :], next_state_1)).unsqueeze(0)
# action = action.unsqueeze(0)
reward = torch.from_numpy(np.array([reward],
dtype=np.float32)).unsqueeze(0)
# save transition to replay memory
replay_memory.append((state, action, reward, state_1, terminal))
if len(replay_memory) > q_net.replay_memory_size:
replay_memory.pop(0)
# epsilon annealing
# epsilon = epsilon_decrements[iteration]
epsilon = q_net.final_epsilon + (q_net.initial_epsilon - q_net.final_epsilon) * \
math.exp(-1. * steps_done / 200)
steps_done += 1
minibatch = random.sample(
replay_memory, min(len(replay_memory), q_net.minibatch_size))
state_batch = torch.cat(tuple(d[0] for d in minibatch))
action_batch = torch.cat(tuple(d[1] for d in minibatch))
reward_batch = torch.cat(tuple(d[2] for d in minibatch))
state_1_batch = torch.cat(tuple(d[3] for d in minibatch))
if torch.cuda.is_available():
state_batch = state_batch.cuda()
action_batch = action_batch.cuda()
reward_batch = reward_batch.cuda()
state_1_batch = state_1_batch.cuda()
# output_1_batch = q_net(state_1_batch)
output_1_batch = target_net(state_1_batch)
y_batch = torch.cat(
tuple(reward_batch[i] if minibatch[i][4] else reward_batch[i] +
q_net.gamma * torch.max(output_1_batch[i])
for i in range(len(minibatch))))
q_value = torch.sum(q_net(state_batch) * action_batch, dim=1)
optimizer.zero_grad()
y_batch = y_batch.detach()
loss = criterion(q_value, y_batch)
loss.backward()
optimizer.step()
state = state_1
c_reward += reward.numpy()[0][0]
# print(
# "epoch: ", epoch,
# "iteration: ", iteration,
# "elapsed time: ", time.time() - start,
# "epsilon: ", epsilon,
# "action: ", action_index,
# "reward:", c_reward,
# "Q max:", np.max(output.cpu().detach().numpy())
# )
if iteration % 10 == 0:
print("episode: ", episode, "iteration: ", iteration,
"reward:", c_reward, "Q max:",
np.max(output.cpu().detach().numpy()))
if episode % q_net.target_update_freq == 0:
target_net.load_state_dict(q_net.state_dict())
if terminal or c_reward < -200:
break
iteration += 1
if (episode + 1) % 20 == 0:
torch.save(q_net, "models/current_model_" + str(episode) + ".pth")
env.close()
env.reset()
def trainIters(decoder,
n_iters,
print_every=1000,
plot_every=100,
learning_rate=0.01,
total_batch=maximum_target,
gamma=0.1):
start = time.time()
plot_losses = []
val_acc = []
print_loss_total = 0
plot_loss_total = 0
best_acc = 0
decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)
criterion = nn.SmoothL1Loss()
scheduler = optim.lr_scheduler.StepLR(decoder_optimizer,
step_size=total_batch,
gamma=gamma)
for iter in range(1, n_iters + 1):
num = iter % total_batch
verbose = (iter % print_every == 0)
input_tensor = train_X[num].to(device).float()
target_tensor = target_Tensor[num].to(device).float()
#input_tensor = Variable(input_tensor, requires_grad = True)
#print(input_tensor.shape, target_tensor.shape)
if input_tensor.shape[0] < 2:
continue
if input_tensor.shape[0] != target_tensor.shape[0]:
continue
loss = train(input_tensor,
target_tensor,
decoder,
decoder_optimizer,
criterion,
verbose=verbose)
print_loss_total += loss
plot_loss_total += loss
if iter % plot_every == 0:
plot_losses.append(plot_loss_total / plot_every)
plot_loss_total = 0
if iter % print_every == 0:
score = 0
acc, one_acc, score = validate(decoder, val_X, val_Y)
print_loss_avg = print_loss_total / print_every
print_loss_total = 0
val_acc.append((acc, one_acc))
print('%s (%d %d%%) %.4f' %
(timeSince(start, iter / n_iters), iter,
iter / n_iters * print_every, print_loss_avg))
print("validation accuracy:", acc)
print("validation prediction accuracy:", one_acc)
if (score > best_acc):
torch.save(
decoder.state_dict(),
'/home/yiqin/2018summer_project/saved_model/Bi-LSTM-CNN_best.pt'
)
best_acc = score
print("best_score:", best_acc)
if (iter % total_batch == 0 and iter > 0):
torch.save(
decoder.state_dict(),
'/home/yiqin/2018summer_project/saved_model/Bi-LSTM-CNN{}.pt'.
format(iter // total_batch))
scheduler.step()
return plot_losses, val_acc
def create_network(self, blocks):
models = nn.ModuleList()
prev_filters = 3
out_filters =[]
conv_id = 0
dynamic_count = 0
for block in blocks:
if block['type'] == 'net' or block['type'] == 'learnet':
prev_filters = int(block['channels'])
continue
elif block['type'] == 'convolutional':
conv_id = conv_id + 1
batch_normalize = int(block['batch_normalize'])
filters = int(block['filters'])
kernel_size = int(block['size'])
stride = int(block['stride'])
is_pad = int(block['pad'])
pad = (kernel_size-1)//2 if is_pad else 0
activation = block['activation']
groups = 1
bias = bool(int(block['bias'])) if 'bias' in block else True
if self.is_dynamic(block):
partial = int(block['partial']) if 'partial' in block else None
Conv2d = dynamic_conv2d(dynamic_count == 0, partial=partial)
dynamic_count += 1
else:
Conv2d = nn.Conv2d
if 'groups' in block:
groups = int(block['groups'])
model = nn.Sequential()
if batch_normalize:
model.add_module(
'conv{0}'.format(conv_id),
Conv2d(prev_filters, filters, kernel_size, stride, pad, groups=groups, bias=False))
model.add_module(
'bn{0}'.format(conv_id),
nn.BatchNorm2d(filters))
#model.add_module('bn{0}'.format(conv_id), BN2d(filters))
else:
model.add_module(
'conv{0}'.format(conv_id),
Conv2d(prev_filters, filters, kernel_size, stride, pad, groups=groups, bias=bias))
if activation == 'leaky':
model.add_module('leaky{0}'.format(conv_id), nn.LeakyReLU(0.1, inplace=True))
elif activation == 'relu':
model.add_module('relu{0}'.format(conv_id), nn.ReLU(inplace=True))
prev_filters = filters
out_filters.append(prev_filters)
models.append(model)
elif block['type'] == 'maxpool':
pool_size = int(block['size'])
stride = int(block['stride'])
if stride > 1:
model = nn.MaxPool2d(pool_size, stride)
else:
model = MaxPoolStride1()
out_filters.append(prev_filters)
models.append(model)
elif block['type'] == 'avgpool':
model = GlobalAvgPool2d()
out_filters.append(prev_filters)
models.append(model)
elif block['type'] == 'softmax':
model = nn.Softmax()
out_filters.append(prev_filters)
models.append(model)
elif block['type'] == 'cost':
if block['_type'] == 'sse':
model = nn.MSELoss(size_average=True)
elif block['_type'] == 'L1':
model = nn.L1Loss(size_average=True)
elif block['_type'] == 'smooth':
model = nn.SmoothL1Loss(size_average=True)
out_filters.append(1)
models.append(model)
elif block['type'] == 'reorg':
stride = int(block['stride'])
prev_filters = stride * stride * prev_filters
out_filters.append(prev_filters)
models.append(Reorg(stride))
elif block['type'] == 'route':
layers = block['layers'].split(',')
ind = len(models)
layers = [int(i) if int(i) > 0 else int(i)+ind for i in layers]
if len(layers) == 1:
prev_filters = out_filters[layers[0]]
elif len(layers) == 2:
assert(layers[0] == ind - 1)
prev_filters = out_filters[layers[0]] + out_filters[layers[1]]
out_filters.append(prev_filters)
models.append(EmptyModule())
elif block['type'] == 'shortcut':
ind = len(models)
prev_filters = out_filters[ind-1]
out_filters.append(prev_filters)
models.append(EmptyModule())
elif block['type'] == 'connected':
filters = int(block['output'])
if block['activation'] == 'linear':
model = nn.Linear(prev_filters, filters)
elif block['activation'] == 'leaky':
model = nn.Sequential(
nn.Linear(prev_filters, filters),
nn.LeakyReLU(0.1, inplace=True))
elif block['activation'] == 'relu':
model = nn.Sequential(
nn.Linear(prev_filters, filters),
nn.ReLU(inplace=True))
prev_filters = filters
out_filters.append(prev_filters)
models.append(model)
elif block['type'] == 'region':
loss = RegionLossV2()
anchors = block['anchors'].split(',')
loss.anchors = [float(i) for i in anchors]
loss.num_classes = int(block['classes'])
loss.num_anchors = int(block['num'])
loss.anchor_step = int(len(loss.anchors)/loss.num_anchors)
loss.object_scale = float(block['object_scale'])
loss.noobject_scale = float(block['noobject_scale'])
loss.class_scale = float(block['class_scale'])
loss.coord_scale = float(block['coord_scale'])
out_filters.append(prev_filters)
models.append(loss)
elif block['type'] == 'globalmax':
model = GlobalMaxPool2d()
out_filters.append(prev_filters)
models.append(model)
elif block['type'] == 'globalavg':
model = GlobalAvgPool2d()
out_filters.append(prev_filters)
models.append(model)
elif block['type'] == 'split':
splits = [int(sz) for sz in block['splits'].split(',')]
model = Split(splits)
prev_filters = splits[-1]
out_filters.append(prev_filters)
models.append(model)
else:
print('unknown type %s' % (block['type']))
# pdb.set_trace()
return models
def mlp_train(dataset, epochs, batch_size, device=torch.device("cpu")):
phases = ['train']
# these just repackage data from the usual dataloaders, so all
# transformations should remain intact.
train_dataset = HDataset(dataset)
dataloaders = {
'train':
DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=8)
}
model = SimpleIntensityMLP().double()
model = model.to(device=device)
criterion = nn.SmoothL1Loss()
optimizer = Adam(model.parameters())
scheduler = CyclicLR(
optimizer,
1e-6,
1e-2,
step_size_up=len(dataloaders['train']) // 2,
# mode='triangular2',
scale_fn=lambda x: 1 / ((5 / 4.)**(x - 1)),
cycle_momentum=False)
best_loss = 1000
pbar1 = tqdm(range(epochs), total=epochs, desc=f"Best Loss: {best_loss}")
for epoch in pbar1:
for phase in phases:
if phase == "train":
model.train()
else:
model.eval()
running_loss = 0.0
total = 0.0
for idx, batch in enumerate(dataloaders[phase]):
with torch.set_grad_enabled(phase == 'train'):
optimizer.zero_grad()
data = batch.to(device=device)
harmonization, target = model(data)
loss = criterion(harmonization.squeeze(), target.squeeze())
if phase == 'train':
loss.backward()
optimizer.step()
scheduler.step() # step per batch w/ CyclicLR
running_loss += loss.item() * batch_size
total += batch_size
running_loss /= len(dataloaders[phase])
pbar1.set_description(f"Loss: {running_loss:.3f}")
return model
loss_f = loss_func.loss_f()
loss_f.cuda()
img_list = dataset.load_all_h5(H5_address)
#print(img_list_left[1])
#print(img_list_right[1])
train_Dataset = dataset.train_gaze_dataset(img_list)
#test_Dataset = dataset.test_gaze_dataset(img_list)
train_loader = torch.utils.data.DataLoader(train_Dataset,
shuffle=True,
batch_size=BatchSize,
num_workers=6)
#test_loader = torch.utils.data.DataLoader(test_Dataset,shuffle=True,batch_size=BatchSize,num_workers=6)
l1_loss = nn.SmoothL1Loss().cuda()
l1_loss = nn.MSELoss().cuda()
#optimizer = torch.optim.Adam(gaze_model.parameters(),lr=0.01)
optimizer_AR = torch.optim.SGD(AR_model.parameters(), lr=0.00001, momentum=0.9)
optimizer_E = torch.optim.SGD(E_model.parameters(), lr=0.00001, momentum=0.9)
def d_3(result):
data = torch.zeros([result.size()[0], 3])
for i in range(0, result.size()[0]):
data[i][0] = (-1) * (torch.cos(result[i][0])) * (torch.sin(
result[i][1]))
def init_modules(self):
in_channels = self.in_channels
self.loc_feature1 = nn.Sequential(
nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(inplace=True),
)
self.loc_feature2 = nn.Sequential(
nn.Conv2d(in_channels * 2, in_channels, kernel_size=1, stride=1),
nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(inplace=True),
)
self.cls_feature1 = nn.Sequential(
nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(inplace=True),
)
self.cls_feature2 = nn.Sequential(
nn.Conv2d(in_channels * 2, in_channels, kernel_size=1, stride=1),
nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(inplace=True),
)
self.corners_feature = nn.Sequential(
nn.Conv2d(in_channels, in_channels, kernel_size=1, stride=1),
nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(inplace=True),
)
# self.orient_feature = nn.Sequential(
# nn.Conv2d(
# in_channels, in_channels, kernel_size=1, stride=1),
# nn.Conv2d(
# in_channels, in_channels, kernel_size=3, stride=1, padding=1),
# nn.ReLU(inplace=True),
# nn.Conv2d(
# in_channels, in_channels, kernel_size=3, stride=1, padding=1),
# nn.ReLU(inplace=True), )
self.os_out = nn.Conv2d(in_channels=in_channels,
out_channels=self.num_anchors * 2,
kernel_size=1)
self.cls_out = nn.Conv2d(in_channels,
self.num_anchors * self.num_classes,
kernel_size=1)
self.box_out1 = nn.Conv2d(in_channels,
out_channels=self.num_anchors *
self.num_regress,
kernel_size=1)
self.box_out2 = nn.Conv2d(in_channels,
out_channels=self.num_anchors *
self.num_regress,
kernel_size=1)
self.corners_out = nn.Conv2d(in_channels,
out_channels=self.num_anchors *
(2 + 4 + 1),
kernel_size=1)
# self.orient_out = nn.Conv2d(
# in_channels, out_channels=self.num_anchors * 5, kernel_size=1)
self.feature_extractor = PRNetFeatureExtractor(
self.feature_extractor_config)
self.two_step_loss = TwoStepFocalLoss(self.num_classes)
self.rpn_bbox_loss = nn.SmoothL1Loss(reduction='none')
if self.use_focal_loss:
# optimized too slowly
self.rpn_cls_loss = OldFocalLoss(self.num_classes)
# fg or bg
self.rpn_os_loss = OldFocalLoss(2)
else:
self.rpn_cls_loss = nn.CrossEntropyLoss(reduction='none')
self.rpn_os_loss = nn.CrossEntropyLoss(reduction='none')
self.retina_loss = RetinaNetLoss(self.num_classes)
self.l1_loss = nn.L1Loss(reduction='none')
self.smooth_l1_loss = nn.SmoothL1Loss(reduction='none')
