def __init__(self, env, args): # define some important self.env = env self.args = args # define the network self.net = net(self.env.action_space.n, self.args.use_dueling) # copy the self.net as the self.target_net = copy.deepcopy(self.net) # make sure the target net has the same weights as the network self.target_net.load_state_dict(self.net.state_dict()) if self.args.cuda: self.net.cuda() self.target_net.cuda() # define the optimizer self.optimizer = torch.optim.Adam(self.net.parameters(), lr=self.args.lr) # define the replay memory self.buffer = replay_buffer(self.args.buffer_size) # define the linear schedule of the exploration self.exploration_schedule = linear_schedule(int(self.args.total_timesteps * self.args.exploration_fraction), \ self.args.final_ratio, self.args.init_ratio) # create the folder to save the models if not os.path.exists(self.args.save_dir): os.mkdir(self.args.save_dir) # set the environment folder self.model_path = os.path.join(self.args.save_dir, self.args.env_name) if not os.path.exists(self.model_path): os.mkdir(self.model_path)
def __init__(self, envs, args): self.envs = envs self.args = args # define the network self.net = net(self.envs.action_space.n) if self.args.cuda: self.net.cuda() # define the optimizer self.optimizer = torch.optim.RMSprop(self.net.parameters(), lr=self.args.lr, eps=self.args.eps, alpha=self.args.alpha) if not os.path.exists(self.args.save_dir): os.mkdir(self.args.save_dir) # check the saved path for envs.. self.model_path = self.args.save_dir + self.args.env_name + '/' if not os.path.exists(self.model_path): os.mkdir(self.model_path) # get the obs.. self.batch_ob_shape = (self.args.num_workers * self.args.nsteps, ) + self.envs.observation_space.shape self.obs = np.zeros( (self.args.num_workers, ) + self.envs.observation_space.shape, dtype=self.envs.observation_space.dtype.name) self.obs[:] = self.envs.reset() self.dones = [False for _ in range(self.args.num_workers)]
HAS_CUDA = torch.cuda.is_available() # HAS_CUDA = False IMG_SCALE = 1. / 255 IMG_MEAN = np.array([0.485, 0.456, 0.406]).reshape((1, 1, 3)) IMG_STD = np.array([0.229, 0.224, 0.225]).reshape((1, 1, 3)) MAX_DEPTH = 8. MIN_DEPTH = 0. NUM_CLASSES = 40 NUM_TASKS = 2 # segm + depth def prepare_img(img): return (img * IMG_SCALE - IMG_MEAN) / IMG_STD model = net(num_classes=NUM_CLASSES, num_tasks=NUM_TASKS) if HAS_CUDA: _ = model.cuda() _ = model.eval() ckpt = torch.load('../../weights/ExpNYUD_joint.ckpt') model.load_state_dict(ckpt['state_dict']) mask_img = np.zeros((480, 640)) cap = cv2.VideoCapture(-1) # print(torch.cuda.available()) xx = 0 while (True): # Capture frame-by-frame ret, frame = cap.read() xx += 1
b_normcv2 = False batch_size = 2 # image visualization b_visualize = True # graph visualization b_plot = True save = True # weights pesi = '../weights_13_cpm_no_vgg_out_8BIT/weights.041-0.00920.hdf5' # model model = net(input_shape=(1, rows, cols), weights_path=pesi) # loading test names test_data_names = load_names(val_seq=2, augm=0, dataset=2) show = True thresold = 0.3 TP = TN = FP = FN = FP_DIST = 0 FPS = [] TOTiou = [] for image in range(len(test_data_names)): sys.stdout.write("\r%.2f%%" % (((image + 1) / float(len(test_data_names))) * 100)) sys.stdout.flush() seq = test_data_names[image]['image'].split('\\')[-3] frame = 0
# -----------start to train------------- print("Processing epoch {}".format(epoch)) frame_id = 0 if os.path.isdir("{}/{:04d}".format(output_folder, epoch)): continue else: os.makedirs("{}/{:04d}".format(output_folder, epoch)) if not os.path.isdir("{}/training".format(output_folder)): os.makedirs("{}/training".format(output_folder)) print(len(input_names), len(processed_names)) for id in range(num_of_sample): if with_IRT: if epoch < 6 and ARGS.IRT_initialization: net_in, net_gt = data_in_memory[0] #Option: prediction = net(net_in) crt_loss = loss_L1(prediction[:, :3, :, :], net_gt) + 0.9 * loss_L1( prediction[:, 3:, :, :], net_gt) else: net_in, net_gt = prepare_paired_input( task, id, input_names, processed_names) net_in = torch.from_numpy(net_in).permute( 0, 3, 1, 2).float().to(device) net_gt = torch.from_numpy(net_gt).permute( 0, 3, 1, 2).float().to(device) # net_in,net_gt = data_in_memory[id] prediction = net(net_in)
def main(): if not os.path.exists(args.outdir): os.makedirs(args.outdir) #device = torch.device("cuda:0") criterion = CrossEntropyLoss().cuda() if args.type == 'norm': loss_metric = NormSoftmax(args.embedding_size, args.num_classes, args.scale_rate).cuda() elif args.type == 'aamp': loss_metric = ArcMarginProduct(args.embedding_size, args.num_classes, s=args.scale_rate, m=args.margin).cuda() elif args.type == 'lmcp': loss_metric = AddMarginProduct(args.embedding_size, args.num_classes, s=args.scale_rate, m=args.margin).cuda() elif args.type == 'sphere': loss_metric = SphereProduct(args.embedding_size, args.num_classes, m=int(args.margin)).cuda() elif args.type == 'lgm': loss_metric = CovFixLGM(args.embedding_size, args.num_classes, args.margin).cuda() elif args.type == 'lgm2': loss_metric = LGMLoss(args.embedding_size, args.num_classes, args.margin).cuda() elif args.type == 'none': loss_metric = None if loss_metric is not None: model = net(embedding_size=args.embedding_size, class_size=args.num_classes, only_embeddings=True, pretrained=True) to_be_optimized = chain(model.parameters(), loss_metric.parameters()) else: model = net(embedding_size=args.embedding_size, class_size=args.num_classes, only_embeddings=False, pretrained=True) to_be_optimized = model.parameters() model = torch.nn.DataParallel(model).cuda() optimizer = torch.optim.SGD(to_be_optimized, lr=args.learning_rate, momentum=0.9, weight_decay=args.weight_decay) #scheduler = lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1) scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, cooldown=2, verbose=True) if args.start_epoch != 0: checkpoint = torch.load(args.outdir + '/model_checkpoint.pth.tar') args.start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) if args.evaluate: checkpoint = torch.load(args.outdir + '/model_best.pth.tar') args.start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) data_loaders = get_dataloader(args.database_dir, args.train_dir, args.valid_dir, args.test_dir, args.batch_size, args.num_workers) test(model, data_loaders['test'], '00', is_graph=True) else: for epoch in range(args.start_epoch, args.num_epochs + args.start_epoch): print(80 * '=') print('Epoch [{}/{}]'.format( epoch, args.num_epochs + args.start_epoch - 1)) data_loaders = get_dataloader(args.database_dir, args.train_dir, args.valid_dir, args.test_dir, args.batch_size, args.num_workers) train(model, optimizer, epoch, data_loaders['train'], criterion, loss_metric) is_best, acc, loss = validate(model, optimizer, epoch, data_loaders['valid'], criterion, loss_metric) scheduler.step(loss) if is_best and acc > 100: test(model, data_loaders['test'], epoch, is_graph=True) print(80 * '=') ## MODEL EVALUATION LOGGING ## data_loaders = get_dataloader(args.database_dir, args.train_dir, args.valid_dir, args.test_dir, args.batch_size, args.num_workers) checkpoint = torch.load(args.outdir + '/model_best.pth.tar') model.load_state_dict(checkpoint['state_dict']) EER = test(model, data_loaders['test'], epoch, is_graph=False) header = [ 'weight_decay', 'learning_rate', 'scale', 'margin', 'type', 'batch_size', 'embedding_size', 'EER', 'out_dir' ] info = [ args.weight_decay, args.learning_rate, args.scale_rate, args.margin, args.type, args.batch_size, args.embedding_size, EER, args.outdir ] if not os.path.exists(args.logdir): with open(args.logdir, 'w') as file: logger = csv.writer(file) logger.writerow(header) logger.writerow(info) else: with open(args.logdir, 'a') as file: logger = csv.writer(file) logger.writerow(info)
# update the current observation def get_tensors(obs): input_tensor = torch.tensor(np.transpose(obs, (2, 0, 1)), dtype=torch.float32).unsqueeze(0) return input_tensor if __name__ == "__main__": args = get_args() # create environment #env = VecFrameStack(wrap_deepmind(make_atari(args.env_name)), 4) env = make_atari(args.env_name) env = wrap_deepmind(env, frame_stack=True) # get the model path model_path = args.save_dir + args.env_name + '/model.pt' network = net(env.action_space.n) network.load_state_dict( torch.load(model_path, map_location=lambda storage, loc: storage)) obs = env.reset() while True: env.render() # get the obs with torch.no_grad(): input_tensor = get_tensors(obs) _, pi = network(input_tensor) actions = select_actions(pi, True) obs, reward, done, _ = env.step([actions]) env.close()
b_scale = True b_normcv2 = False b_tanh = False limit_train = 20 #limit_train = -1 limit_test = 10 #limit_test = -1 b_debug = False fulldepth = False removeBackground = False equalize = False WEIGHT = 'weights' model = net(input_shape=(1, rows, cols)) model.summary() # load train name train_data_names = load_names(dataset=0) train_data_names = train_data_names + load_names(dataset=1) # train_data_names = load_names(dataset=2) random.shuffle(train_data_names) # load validation name val_data_names = load_names_val() # data augmentation if data_augmentation: for i in range(1, 9): tmp = load_names(augm=i) train_data_names = train_data_names + tmp
default='model', type=str, help='name of the saved model') parser.add_argument('--num_epoch', default=100, type=int, help='number of epoch') parser.add_argument('--resume', '-r', action='store_true', help='resume from checkpoint') args = parser.parse_args() best_acc = 0 net = net().to('cuda') net = torch.nn.DataParallel(net) cudnn.benchmark = True if args.resume: print('==> Resuming from checkpoint..') assert os.path.isdir('checkpoint'), 'Error: no checkpoint directory found!' checkpoint = torch.load('./checkpoint/{}.t7'.format(args.model_name)) net.load_state_dict(checkpoint['net']) best_F2 = checkpoint['F2'] train_loader = Data.DataLoader(loader('datafile/train.txt'), batch_size=args.batch_size, shuffle=True, num_workers=8, drop_last=True)
import torch from rl_utils.env_wrapper.atari_wrapper import make_atari, wrap_deepmind def get_tensors(obs): obs = np.transpose(obs, (2, 0, 1)) obs = np.expand_dims(obs, 0) obs = torch.tensor(obs, dtype=torch.float32) return obs if __name__ == '__main__': args = get_args() # create the environment env = make_atari(args.env_name) env = wrap_deepmind(env, frame_stack=True) # create the network net = net(env.action_space.n, args.use_dueling) # model path model_path = args.save_dir + args.env_name + '/model.pt' # load the models net.load_state_dict(torch.load(model_path, map_location=lambda storage, loc: storage)) # start to test the demo obs = env.reset() for _ in range(2000): env.render() with torch.no_grad(): obs_tensor = get_tensors(obs) action_value = net(obs_tensor) action = torch.argmax(action_value.squeeze()).item() obs, reward, done, _ = env.step(action) if done: obs = env.reset()
image.requires_grad = True return image def load_crop_image(xmin, ymin, xmax, ymax): image_path = "data/1.png" image = crop_image(image_path, xmin, ymin, xmax, ymax) image = cv2.resize(image, (224, 224)) totensor = torchvision.transforms.ToTensor() image = totensor(image) image = torch.unsqueeze(image, 0) image.requires_grad = True return image detection = net() classi = mnasnet.MnasNet() #define the optimizer parameter optimizer = torch.optim.SGD(detection.parameters(), lr=0.01) optimizer2 = torch.optim.SGD(classi.parameters(), lr=0.01) #define the test def train(): for i in range(1000): if i % 10 == 0: torch.save(detection.state_dict(), 'data/params.pkl') image = load_image() _, loss, boxes = detection.forward(image) print(boxes)
import os import shutil from torch.utils.tensorboard import SummaryWriter if __name__ == '__main__': device = 'cuda:0' if torch.cuda.is_available() else 'cpu' parser = argparse.ArgumentParser() parser.add_argument('--batch_size', type=int, default=2) parser.add_argument('--lr', type=float, default=0.0001) parser.add_argument('--epoch', type=int, default=250) args = parser.parse_args() train_loader, test_loader = datasets.prepare(batch_size=args.batch_size) model = models.net(num_classes=datasets.num_classes).to(device) criterion = models.loss(num_classes=datasets.num_classes) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) log_dir = 'data/runs' if os.path.exists(log_dir): shutil.rmtree(log_dir) os.makedirs(log_dir) else: os.makedirs(log_dir) writer = SummaryWriter(log_dir=log_dir) epoch_digit = len(list(str(args.epoch))) for epoch in range(args.epoch): model.train() train_loss = 0 train_acc = 0