def train_dqn(env, args, workdir):
action_space_size = env.action_space.n
if not os.path.exists('train_log'):
os.mkdir('train_log')
writer = TensorBoard(f'train_log/{args.run_name}')
dqn_config = dqn_config_default.copy()
dqn_config.update({
"batch_size": 4096,
"min_replay_history": 40960,
"training_steps": 4000,
"lr": 0.0001,
"target_update_period": 500
})
policy = DQNTorchPolicy(env.observation_space, env.action_space, env.config, dqn_config)
dqn_trainer = Trainer(env, policy, dqn_config)
max_mean_reward = - 1000
debug = False
mean_cost_list = []
total_cost_list = []
for i in range(args.iters):
result = dqn_trainer.train(i)
now_mean_reward = print_result(action_space_size, result, writer, i)
mean_cost_list.append(now_mean_reward)
if (i+1) % 5 == 0:
_total_value = draw_route(args, dqn_trainer, env, mean_cost_list, workdir)
total_cost_list.append(_total_value)
list_to_figure([total_cost_list], ['total_cost'], 'total_cost', f'{workdir}/dqn_total_cost_{args.problem}.png')
def train_dqn(dqn_trainer, env, args, workdir, suffix):
action_space_size = env.action_space.n
if not os.path.exists('train_log'):
os.mkdir('train_log')
writer = TensorBoard(f'train_log/{args.problem}_{args.run_name}')
max_mean_reward = - 1000
mean_cost_list = []
total_cost_list = []
total_valid_cost_list = []
# min_route_cost = 10000000
for i in range(args.iters):
print(suffix)
dqn_trainer.switch_mode(eval_mode=False)
result = dqn_trainer.train(i)
now_mean_reward = print_result( result, writer, i, dqn_trainer.policies_to_train, action_space_size )
# if now_mean_reward > max_mean_reward:
# dqn_trainer.save(f"{args.problem}_{suffix}", i)
mean_cost_list.append(now_mean_reward)
if (i+1) % 5 == 0 or (now_mean_reward > max_mean_reward):
reset_sequence = ((i+1) % args.sequence_update_freq == 0)
dqn_trainer.switch_mode(eval_mode=True)
_total_cost, _valid_route = draw_route(args, dqn_trainer, env, mean_cost_list, workdir, suffix, (now_mean_reward > max_mean_reward), reset_sequence)
total_cost_list.append(_total_cost)
if _valid_route:
total_valid_cost_list.append(_total_cost)
list_to_figure([total_cost_list], ['total_cost'], 'total_cost', f'{workdir}/dqn_total_cost_{args.problem}_{suffix}.png')
if len(total_valid_cost_list) > 0:
list_to_figure([total_valid_cost_list], ['total_valid_cost'], 'total_valid_cost', f'{workdir}/dqn_total_valid_cost_{args.problem}_{suffix}.png')
max_mean_reward = max(max_mean_reward, now_mean_reward)
return mean_cost_list
def train_dqn(dqn_trainer, env, args, workdir, suffix):
action_space_size = env.action_space.n
if not os.path.exists('train_log'):
os.mkdir('train_log')
writer = TensorBoard(f'train_log/{args.run_name}')
max_mean_reward = -1000
mean_cost_list = []
total_cost_list = []
total_valid_cost_list = []
min_route_cost = 10000000
for i in range(args.iters):
print(suffix)
result = dqn_trainer.train(i)
now_mean_reward = print_result(action_space_size, result, writer, i)
if now_mean_reward > max_mean_reward:
dqn_trainer.policy.save_param(f"{args.problem}_{suffix}_best")
mean_cost_list.append(now_mean_reward)
if (i + 1) % 5 == 0 or (now_mean_reward > max_mean_reward):
_total_cost, _valid_route = draw_route(
args,
dqn_trainer,
env,
mean_cost_list,
workdir,
suffix,
is_render=(now_mean_reward > max_mean_reward))
total_cost_list.append(_total_cost)
if _valid_route:
total_valid_cost_list.append(_total_cost)
list_to_figure(
[total_cost_list], ['total_cost'], 'total_cost',
f'{workdir}/dqn_total_cost_{args.problem}_{suffix}.png')
if len(total_valid_cost_list) > 0:
list_to_figure(
[total_valid_cost_list], ['total_valid_cost'],
'total_valid_cost',
f'{workdir}/dqn_total_valid_cost_{args.problem}_{suffix}.png'
)
max_mean_reward = max(max_mean_reward, now_mean_reward)
return mean_cost_list
#!/usr/bin/env python3
import cv2
import random
import numpy as np
import argparse
from DRL.evaluator import Evaluator
from utils.util import *
from utils.tensorboard import TensorBoard
import time
exp = os.path.abspath('.').split('/')[-1]
writer = TensorBoard('../train_log/{}'.format(exp))
os.system('ln -sf ../train_log/{} ./log'.format(exp))
os.system('mkdir ./model')
def train(agent, env, evaluate):
train_times = args.train_times
env_batch = args.env_batch
validate_interval = args.validate_interval
max_step = args.max_step
debug = args.debug
episode_train_times = args.episode_train_times
resume = args.resume
output = args.output
time_stamp = time.time()
step = episode = episode_steps = 0
tot_reward = 0.
observation = None
noise_factor = args.noise_factor
while step <= train_times:
step += 1
#!/usr/bin/env python3
import cv2
import random
import numpy as np
import argparse
from DRL.evaluator import Evaluator
from utils.util import *
from utils.tensorboard import TensorBoard
import time
exp = os.path.abspath('.').split('\\')[-1]
writer = TensorBoard('../train_log/{}'.format("191111"))
# os.system('ln -sf ../train_log/{} ./log'.format(exp))
os.system('mkdir ./model')
def train(agent, env, evaluate):
train_times = args.train_times
env_batch = args.env_batch
validate_interval = args.validate_interval
max_step = args.max_step
debug = args.debug
episode_train_times = args.episode_train_times
resume = args.resume
output = args.output
time_stamp = time.time()
step = episode = episode_steps = 0
tot_reward = 0.
observation = None
noise_factor = args.noise_factor
while step <= train_times:
from config import *
from dataset.pascal_voc import VOCDataset
from net.yolov3.darknet53 import DarkNet53
from utils.tensorboard import TensorBoard
from utils.transforms import *
exp_dir = './experiments/exp4'
with open(os.path.join(exp_dir, "pid.txt"), "w") as f:
f.write("pid: {}".format(os.getpid()))
with open(os.path.join(exp_dir, "cfg.json")) as f:
exp_cfg = json.load(f)
device = torch.device(exp_cfg['device'])
tensorboard = TensorBoard(exp_dir)
# ------------ train data ------------
transform_augment = Compose(SquarePad(), RandomFlip(px=0.5), RandomTranslate())
transform_img = Compose(
Resize((416, 416)), ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
transforms = Compose(transform_augment, transform_img)
transform_box_reverse = Box_CenterWH_To_TopBottom()
train_dataset = VOCDataset(VOC_DIR_PATH, exp_cfg['dataset']['image_set'],
transforms)
train_loader = DataLoader(train_dataset,
batch_size=exp_cfg['dataset']['batch_size'],
shuffle=True,
collate_fn=train_dataset.collate_fn,
import cv2
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
from utils.tensorboard import TensorBoard
from Renderer.model import FCN
from Renderer.stroke_gen import *
writer = TensorBoard("../train_log/")
import torch.optim as optim
criterion = nn.MSELoss()
net = FCN()
optimizer = optim.Adam(net.parameters(), lr=3e-6)
batch_size = 64
use_cuda = torch.cuda.is_available()
step = 0
def save_model():
if use_cuda:
net.cpu()
torch.save(net.state_dict(), "./renderer.pkl")
if use_cuda:
net.cuda()
def load_weights():
action='store_true',
help='print some info')
parser.add_argument('--seed', default=1234, type=int, help='random seed')
args = parser.parse_args()
args.output = get_output_folder(args.output, "Paint")
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if torch.cuda.is_available(): torch.cuda.manual_seed_all(args.seed)
random.seed(args.seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = True
from DRL.ddpg import DDPG
from DRL.multi import fastenv
writer = TensorBoard('{}/train_log/{}'.format(args.output, exp))
print('log_dir: ', '{}/train_log/{}'.format(args.output, exp))
model_output = os.path.join(args.output, 'model')
if not os.path.exists(model_output):
os.makedirs(model_output)
fenv = fastenv(args.max_step, args.env_batch, writer)
agent = DDPG(args.batch_size, args.env_batch, args.max_step, \
args.tau, args.discount, args.rmsize, \
writer, args.resume, model_output)
evaluate = Evaluator(args, writer)
print('observation_space', fenv.observation_space, 'action_space',
fenv.action_space)
train(agent, fenv, evaluate)
import cv2
import random
import numpy as np
import argparse
from DRL.evaluator import Evaluator
from utils.util import *
from utils.tensorboard import TensorBoard
import time
import datetime
from options.options import Options
date_and_time = datetime.datetime.now()
run_name = 'painter_' + date_and_time.strftime("%m_%d__%H_%M_%S")
# writer = TensorBoard('train_log_cats/{}'.format(run_name))
writer = TensorBoard('train_log_deleteme/{}'.format(run_name))
if not os.path.exists('model'):
os.mkdir('model')
def train(agent, env, evaluate):
train_times = opt.train_times
env_batch = opt.env_batch
validate_interval = opt.validate_interval
max_step = opt.max_step
debug = opt.debug
episode_train_times = opt.episode_train_times
resume = opt.resume
output = opt.output
time_stamp = time.time()
step = episode = episode_steps = 0
import cv2
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
from utils.tensorboard import TensorBoard
from Render.model import FCN
from Render.stroke_gen import *
writer = TensorBoard('../train_log/')
import torch.optim as optim
criterion = nn.MSELoss()
net = FCN(128)
optimizer = optim.Adam(net.parameters(), lr=3e-6)
batch_size = 64
use_cuda = torch.cuda.is_available()
step = 0
def save_model():
if use_cuda:
net.cpu()
torch.save(net.state_dict(), './NSR.pkl')
if use_cuda:
net.cuda()
def load_weights():
#from paint import *
import paint
import os
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import datetime
from utils.tensorboard import TensorBoard
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
date_and_time = datetime.datetime.now()
run_name = 'StrokePlacer_' + date_and_time.strftime("%m_%d__%H_%M_%S")
writer = TensorBoard('train_log/{}'.format(run_name))
from stroke_placement.stroke_placement import StrokePlacer
stroke_placer = StrokePlacer(pretrained=False)
criterion = nn.MSELoss()
optimizer = optim.Adam(stroke_placer.parameters(), lr=0.001)
epoch = 0
# Redefine this function for training
def paint_layer_train(canvas,
reference_image,
r,
def load_weights():
pretrained_dict = torch.load("renderer.pkl")
model_dict = network.state_dict()
pretrained_dict = {
k: v
for k, v in pretrained_dict.items() if k in model_dict
}
model_dict.update(pretrained_dict)
network.load_state_dict(model_dict)
if __name__ == '__main__':
writer = TensorBoard("train_log/")
device = torch.cuda.is_available()
objective = nn.MSELoss()
network = NeuralRenderer()
adam_optim = optim.Adam(network.parameters(), lr=3e-6)
batch_size = 64
step_num = 0
if os.path.isfile('renderer.pkl'):
load_weights()
while step_num < 500000:
network.train()
training_batch = []
trues = []
def val(exp_dir):
with open(os.path.join(exp_dir, "cfg.json")) as f:
exp_cfg = json.load(f)
device = torch.device(exp_cfg['device'])
tensorboard = TensorBoard(exp_dir)
net = DarkNet53((416, 416),
3,
val_dataset.num_class,
NUM_ANCHOR,
anchors,
pretrained=True)
net.cuda(device)
save_name = os.path.join(exp_dir, exp_dir.split('/')[-1] + '.pth')
save_dict = torch.load(save_name)
epoch = save_dict['epoch']
state_dict = save_dict['net']
net.load_state_dict(state_dict)
net.cuda(device)
bs = val_loader.batch_size
print("Val Epoch: {}".format(epoch))
net.eval()
val_loss = 0
progressbar = tqdm(range(len(val_loader)))
det_results = {}
with torch.no_grad():
for batch_idx, sample in enumerate(val_loader):
img = sample['img'].float().to(device)
boxes = sample['boxes']
labels = sample['labels']
yolo_outputs, loss = net(img, boxes, labels)
val_loss += loss.item()
for b in range(len(labels)):
origin_size = sample['origin_size'][b]
img_name = sample['img_name'][b]
img_id = os.path.basename(img_name).split(".")[0]
outs = []
for yolo_out, anchor in zip(yolo_outputs, anchors):
y = yolo_out[b].detach().cpu().numpy()
out = post.yolo_postprocess(y, anchor, origin_size,
(416, 416), OBJ_THRESHOLD)
if out is not None:
outs.append(out)
if len(outs) == 0:
# det_results[img_id] = np.array([], dtype=np.float).reshape(0, 6)
continue
outs = np.vstack(outs).astype(np.float32)
predict = post.yolo_nms(outs, NMS_THRESHOLD)
predict = np.array(
sorted(predict, key=lambda x: x[4], reverse=True))
det_results[img_id] = predict
progressbar.set_description("batch loss: {:.3f}".format(
loss.detach().cpu().data.numpy()))
progressbar.update(1)
progressbar.close()
print("------------------------\n")
write_results_voc(det_results, val_dataset.label_to_cls_name,
os.path.join(exp_dir, "det_results"))
det_results = load_results_voc(val_dataset.cls_name_to_label,
os.path.join(exp_dir, "det_results"))
class_name = "person"
with open(os.path.join(exp_dir, "map.txt"), "w") as f:
print(class_name, file=f)
print(ap_voc(det_results, "val_2012", class_name, 0.5,
metric_07=False),
file=f)
det_path = os.path.join(exp_dir, "det_results", "{}.txt")
annopath = os.path.join(VOC_DIR_PATH, "VOCdevkit", "VOC2012",
"Annotations", "{}.xml")
imagesetfile = os.path.join(VOC_DIR_PATH, "VOCdevkit", "VOC2012",
"ImageSets", "Main", "val.txt")
cache_dir = os.path.join(VOC_DIR_PATH, "cache")
with open(os.path.join(exp_dir, "map.txt"), "a") as f:
print(class_name, file=f)
print(voc_eval(det_path,
annopath,
imagesetfile,
class_name,
cache_dir,
use_07_metric=False)[2],
file=f)
'If True, use the constraints from paper. If False, use Huang et al. 2019.'
)
parser.add_argument('--resume',
action='store_true',
help='Resume training from file name')
parser.add_argument('--batch_size', default=64, type=int, help='Batch Size')
args = parser.parse_args()
renderer_fn = args.name + '.pkl'
if not os.path.exists('train_log'): os.mkdir('train_log')
log_dir = os.path.join('train_log', args.name)
if not os.path.exists(log_dir): os.mkdir(log_dir)
writer = TensorBoard(log_dir)
criterion = nn.MSELoss()
net = FCN()
optimizer = optim.Adam(net.parameters(), lr=3e-6)
batch_size = args.batch_size
use_cuda = torch.cuda.is_available()
step = 0
# For the constrained model. Can't make the brush width tiny all at once. Need to decrease slowly.
curr_brush_width = 0.6 # Starting brush width
dec_brush_width = 0.01 # Every interval, decrease by this amount
dec_brush_width_int = 1000 # Every this number of steps, decrease the brush width until target
#!/usr/bin/env python3
import cv2
import random
import numpy as np
import argparse
from DRL.evaluator import Evaluator
from utils.util import *
from utils.tensorboard import TensorBoard
import time
exp = os.path.abspath(".").split("/")[-1]
writer = TensorBoard("../train_log/{}".format(exp))
os.system("ln -sf ../train_log/{} ./log".format(exp))
os.system("mkdir ./model")
def train(agent, env, evaluate, warmup):
train_times = args.train_times
env_batch = args.env_batch
validate_interval = args.validate_interval
max_step = args.max_step
debug = args.debug
episode_train_times = args.episode_train_times
resume = args.resume
output = args.output
time_stamp = time.time()
step = episode = episode_steps = 0
tot_reward = 0.0
observation = None
noise_factor = args.noise_factor
#!/usr/bin/env python3
import cv2
import random
import numpy as np
import argparse
from DRL.evaluator import Evaluator
from utils.util import *
from utils.tensorboard import TensorBoard
import time
import gc
exp = os.path.abspath('.').split('/')[-1]
writer = TensorBoard('train_log/')
#os.system('ln -sf train_log/log')
#os.system('mkdir ./model')
def train(agent, env, evaluate):
train_times = args.train_times
env_batch = args.env_batch
validate_interval = args.validate_interval
max_step = args.max_step
debug = args.debug
episode_train_times = args.episode_train_times
resume = args.resume
output = args.output
time_stamp = time.time()
step = episode = episode_steps = 0
tot_reward = 0.
observation = None
noise_factor = args.noise_factor
