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,
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/191104_renderer/") 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") torch.save(net.state_dict(), "model/renderer.pkl") if use_cuda: net.cuda()
import cv2 import torch import numpy as np import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from utils.tensorboard import TensorBoard from renderer.model import FCN from renderer.stroke_gen import * writer = TensorBoard("../train_log/render/") use_cuda = torch.cuda.is_available() load_model = False batch_size = 64 step = 0 def save_model(): if use_cuda: net.cpu() torch.save(net.state_dict(), "../trans_model.pkl") if use_cuda: net.cuda() def load_weights(): pretrained_dict = torch.load("../trans_model.pkl") model_dict = net.state_dict() pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict} model_dict.update(pretrained_dict)
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