def create_models(): CNN_type = GLOBALS.CONFIG['CNN_model'] Dense_NN, CNN = get_network(CNN_type, dense_layers=GLOBALS.CONFIG['dense_model'], \ CNN_input_shape=GLOBALS.CONFIG['CNN_input_shape'], input_shape=GLOBALS.CONFIG['input_shape']) #CNN.load_weights if GLOBALS.CONFIG['pretrained']: CNN.trainable = False Multi_Input = tf.keras.layers.concatenate([Dense_NN.output, CNN.output]) #Not updated from 63 commit model = Model(inputs = [Dense_NN.input , CNN.input], outputs = create_concat_network(Multi_Input), name="combined") if GLOBALS.CONFIG['pretrained']: model.load_weights(GLOBALS.CONFIG['pretrained_weights_path']) print("model.name (combined): %s" % model.name) print("model.name (CNN): %s" % CNN.name) print("model.trainable (CNN): %s" % CNN.trainable) print("model.name (Dense): %s" % Dense_NN.name) print("model.trainable (Dense_NN): %s" % Dense_NN.trainable) model.summary() optimizer_functions={'Adam':keras.optimizers.Adam,'SGD':keras.optimizers.SGD,'RMSProp':keras.optimizers.RMSprop,'Adadelta':keras.optimizers.Adadelta} optimizer=optimizer_functions[GLOBALS.CONFIG['optimizer']](lr = GLOBALS.CONFIG['learning_rate']) with suppress_stdout(): model.compile(optimizer=optimizer, loss = GLOBALS.CONFIG['loss_function'], metrics=[tf.keras.metrics.MeanAbsolutePercentageError()]) return model, optimizer
def main(): args = get_args() args.mean = torch.tensor((0.4914, 0.4822, 0.4465)).view(3, 1, 1).cuda() args.std = torch.tensor((0.2471, 0.2435, 0.2616)).view(3, 1, 1).cuda() dataset = get_dataset(args) args.mean = dataset.mean args.std = dataset.std args.dataset = dataset model = get_network(args) model.load_state_dict(torch.load(args.checkpoint)["state_dict"]) eval(model, args, dataset)
def create_CNN(): CNN_type = GLOBALS.CONFIG['CNN_model'] _, CNN = get_network(CNN_type, dense_layers=GLOBALS.CONFIG['dense_model'], CNN_input_shape=GLOBALS.CONFIG['CNN_input_shape'], CNN_output_shape=GLOBALS.CONFIG['CNN_output_shape'], input_shape=GLOBALS.CONFIG['input_shape']) optimizer_functions={'Adam':keras.optimizers.Adam} optimizer=optimizer_functions[GLOBALS.CONFIG['optimizer']](lr= GLOBALS.CONFIG['learning_rate']) model = CNN with suppress_stdout(): model.compile(optimizer=optimizer, loss = GLOBALS.CONFIG['loss_function'], metrics=[tf.keras.metrics.MeanAbsolutePercentageError()]) return model
def reset(self, learning_rate: float) -> None: self.performance_statistics = dict() self.network = get_network(name=self.config['network'], num_classes=self.num_classes) self.metrics = Metrics(list(self.network.parameters()), p=self.config['p']) # TODO add other parallelisms if self.device == 'cpu': print("Resetting cpu-based network") elif self.dist: if self.gpu is not None: torch.cuda.set_device(self.gpu) self.network.cuda(self.gpu) self.network = torch.nn.parallel.DistributedDataParallel( self.network, device_ids=[self.gpu]) else: self.network.cuda() self.network = torch.nn.parallel.DistributedDataParallel( self.network) elif self.gpu is not None: torch.cuda.set_device(self.gpu) self.network = self.network.cuda(self.gpu) else: if isinstance(self.network, VGG): self.network.features = torch.nn.DataParallel( self.network.features) self.network.cuda() else: self.network = torch.nn.DataParallel(self.network) self.optimizer, self.scheduler = get_optimizer_scheduler( optim_method=self.config['optimizer'], lr_scheduler=self.config['scheduler'], init_lr=learning_rate, net_parameters=self.network.parameters(), listed_params=list(self.network.parameters()), train_loader_len=len(self.train_loader), mini_batch_size=self.config['mini_batch_size'], max_epochs=self.config['max_epochs'], optimizer_kwargs=self.config['optimizer_kwargs'], scheduler_kwargs=self.config['scheduler_kwargs']) self.early_stop.reset()
def create_config_file(agent_id: int, config_dir, pbt_input_base_dir): agent = models.get_agent(agent_id) evolution = models.get_evolution(agent["evolution"]) evolution_size = int(evolution["steps_stop"] - evolution["steps_start"]) network = models.get_network(evolution["network"]) with open(config_dir + "base_agent_config.yaml") as base_config: cfg = yaml.safe_load(base_config) # Write config with open(get_config_file_name(agent["uuid"], config_dir), 'w') as config_file: name = str(network["name"]) + "_" + str(agent["uuid"]) cfg['gpu'] = int(agent['gpu']) cfg['name'] = str(name) cfg['training']['lr_values'] = [float(agent["lr_values"])] cfg['training']['lr_boundaries'] = [] cfg['training']['total_steps'] = evolution_size cfg['training']['checkpoint_steps'] = evolution_size cfg['training']['test_steps'] = int(1000) cfg['model'] = { 'filters': int(network["filters"]), 'policy_channels': int(network["policy_channels"]), 'residual_blocks': int(network["residual_blocks"]), 'se_ratio': int(network["se_ratio"]) } cfg['dataset'] = { 'input_train': get_pbt_train_path(evolution["iteration"], pbt_input_base_dir), 'input_test': get_pbt_test_path(evolution["iteration"], pbt_input_base_dir), 'num_chunks': evolution_size * 25, 'train_ratio': float(20 / 25) } yaml.dump(cfg, config_file)
def run(): args = parse_args() # Set-up output directories dt = datetime.datetime.now().strftime('%y%m%d_%H%M') net_desc = '{}_{}'.format(dt, '_'.join(args.description.split())) save_folder = os.path.join(args.outdir, net_desc) if not os.path.exists(save_folder): os.makedirs(save_folder) tb = tensorboardX.SummaryWriter(os.path.join(args.logdir, net_desc)) # Load Dataset logging.info('Loading {} Dataset...'.format(args.dataset.title())) Dataset = get_dataset(args.dataset) # train_dataset = Dataset(args.dataset_path, start=0.0, end=args.split, ds_rotate=args.ds_rotate, # random_rotate=True, random_zoom=True, # include_depth=args.use_depth, include_rgb=args.use_rgb) train_dataset = Dataset(args.dataset_path, start=0.0, end=args.split, ds_rotate=args.ds_rotate, random_rotate=True, random_zoom=True, include_depth=args.use_depth, include_rgb=args.use_rgb) train_data = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers) val_dataset = Dataset(args.dataset_path, start=args.split, end=1.0, ds_rotate=args.ds_rotate, random_rotate=False, random_zoom=False, include_depth=args.use_depth, include_rgb=args.use_rgb) val_data = torch.utils.data.DataLoader(val_dataset, batch_size=1, shuffle=False, num_workers=args.num_workers) logging.info('Done') # Load the network logging.info('Loading Network...') input_channels = 1 * args.use_depth + 3 * args.use_rgb ggcnn = get_network(args.network) net = ggcnn(input_channels=input_channels) device = torch.device("cpu") # device = torch.device("cuda:0") net = net.to(device) optimizer = optim.Adam(net.parameters()) logging.info('Done') # Print model architecture. summary(net, (input_channels, 200, 200)) f = open(os.path.join(save_folder, 'arch.txt'), 'w') sys.stdout = f summary(net, (input_channels, 200, 200)) sys.stdout = sys.__stdout__ f.close() best_iou = 1000.0 for epoch in range(args.epochs): logging.info('Beginning Epoch {:02d}'.format(epoch)) train_results = train(epoch, net, device, train_data, optimizer, args.batches_per_epoch, vis=args.vis) # Log training losses to tensorboard tb.add_scalar('loss/train_loss', train_results['loss'], epoch) for n, l in train_results['losses'].items(): tb.add_scalar('train_loss/' + n, l, epoch) # Run Validation logging.info('Validating...') test_results = validate(net, device, val_data, args.val_batches) #logging.info('%d/%d = %f' % (test_results['correct'], test_results['correct'] + test_results['failed'], # test_results['correct']/(test_results['correct']+test_results['failed']))) # Log validation results to tensorbaord #tb.add_scalar('loss/IOU', test_results['correct'] / (test_results['correct'] + test_results['failed']), epoch) tb.add_scalar('loss/val_loss', test_results['loss'], epoch) for n, l in test_results['losses'].items(): tb.add_scalar('val_loss/' + n, l, epoch) # Save best performing network #iou = test_results['correct'] / (test_results['correct'] + test_results['failed']) iou = test_results['loss'] # only save if this epoch is better than prev one # always save the first one and then every 10 if iou < best_iou or epoch == 0 or (epoch % 10) == 0: torch.save( net, os.path.join(save_folder, 'epoch_%02d_iou_%0.2f' % (epoch, iou))) best_iou = iou
def run(): args = parse_args() # Vis window if args.vis: cv2.namedWindow('Display', cv2.WINDOW_NORMAL) # Set-up output directories dt = datetime.datetime.now().strftime('%y%m%d_%H%M') net_desc = '{}_{}'.format(dt, '_'.join(args.description.split())) save_folder = os.path.join(args.outdir, net_desc) if not os.path.exists(save_folder): os.makedirs(save_folder) tb = tensorboardX.SummaryWriter(os.path.join(args.logdir, net_desc)) # Load Dataset logging.info('Loading {} Dataset...'.format(args.dataset.title())) Dataset = get_dataset(args.dataset) train_dataset = Dataset(args.dataset_path, start=0.0, end=args.split, ds_rotate=args.ds_rotate, random_rotate=True, random_zoom=True, include_depth=args.use_depth, include_rgb=args.use_rgb) train_data = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers) val_dataset = Dataset(args.dataset_path, start=args.split, end=1.0, ds_rotate=args.ds_rotate, random_rotate=True, random_zoom=True, include_depth=args.use_depth, include_rgb=args.use_rgb) val_data = torch.utils.data.DataLoader(val_dataset, batch_size=1, shuffle=False, num_workers=args.num_workers) logging.info('Done') # Load the network logging.info('Loading Network...') input_channels = 1 * args.use_depth + 3 * args.use_rgb ggcnn = get_network(args.network) # net = ggcnn(input_channels=input_channels) print(torch.cuda.is_available()) print(torch.cuda.device_count()) device = torch.device("cuda:0") # net = torch.load("./ggcnn_weights_cornell/ggcnn_epoch_23_cornell",map_location=device) # net = torch.load("output/models2/cnn3/epoch_50_iou_0.49",map_location=device) net = torch.load("output/models2/211209_2216_/epoch_49_iou_0.22", map_location=device) # net = net.to(device) optimizer = optim.Adam(net.parameters()) logging.info('Done') # Print model architecture. summary(net, (input_channels, 300, 300)) f = open(os.path.join(save_folder, 'arch.txt'), 'w') sys.stdout = f summary(net, (input_channels, 300, 300)) sys.stdout = sys.__stdout__ f.close() # torch.load(os.path.join(save_folder,"epoch_10_iou_0.00_statedict.pt")) best_iou = 0.0 for epoch in range(args.epochs + 1): logging.info('Beginning Epoch {:02d}'.format(epoch)) train_results = train(epoch, net, device, train_data, optimizer, args.batches_per_epoch, vis=args.vis) # Log training losses to tensorboard tb.add_scalar('loss/train_loss', train_results['loss'], epoch) for n, l in train_results['losses'].items(): tb.add_scalar('train_loss/' + n, l, epoch) # Run Validation logging.info('Validating...') test_results = validate(net, device, val_data, args.val_batches) logging.info('%d/%d = %f' % (test_results['correct'], test_results['correct'] + test_results['failed'], test_results['correct'] / (test_results['correct'] + test_results['failed']))) # Log validation results to tensorbaord tb.add_scalar( 'loss/IOU', test_results['correct'] / (test_results['correct'] + test_results['failed']), epoch) tb.add_scalar('loss/val_loss', test_results['loss'], epoch) for n, l in test_results['losses'].items(): tb.add_scalar('val_loss/' + n, l, epoch) # Save best performing network iou = test_results['correct'] / (test_results['correct'] + test_results['failed']) if iou > best_iou or epoch == 0 or (epoch % 10) == 0: torch.save( net, os.path.join(save_folder, 'epoch_%02d_iou_%0.2f' % (epoch, iou))) torch.save( net.state_dict(), os.path.join( save_folder, 'epoch_%02d_iou_%0.2f_statedict.pt' % (epoch, iou))) if iou > best_iou: best_iou = iou
def run(args, save_folder, log_folder): tb = tensorboardX.SummaryWriter(log_folder) # Load Dataset logging.info('Loading {} Dataset...'.format(args.dataset.title())) Dataset = get_dataset(args.dataset) train_dataset = Dataset(args.dataset_path, start=0.0, end=args.split, ds_rotate=args.ds_rotate, random_rotate=True, random_zoom=True, include_depth=args.use_depth, include_rgb=args.use_rgb) train_data = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers ) val_dataset = Dataset(args.dataset_path, start=args.split, end=1.0, ds_rotate=args.ds_rotate, random_rotate=True, random_zoom=True, include_depth=args.use_depth, include_rgb=args.use_rgb) val_data = torch.utils.data.DataLoader( val_dataset, batch_size=1, shuffle=False, num_workers=args.num_workers ) logging.info('Done') # Load the network logging.info('Loading Network...') input_channels = 1*args.use_depth + 3*args.use_rgb ggcnn = get_network(args.network) net = ggcnn(input_channels=input_channels) device = torch.device("cuda:0") net = net.to(device) optimizer = optim.Adam(net.parameters()) logging.info('Done') # Print model architecture. summary(net, (input_channels, 300, 300)) f = open(os.path.join(save_folder, 'arch.txt'), 'w') sys.stdout = f summary(net, (input_channels, 300, 300)) sys.stdout = sys.__stdout__ f.close() best_iou = 0.0 for epoch in range(args.epochs): logging.info('Beginning Epoch {:02d}'.format(epoch)) train_results = train(epoch, net, device, train_data, optimizer, args.batches_per_epoch, vis=args.vis) # Log training losses to tensorboard tb.add_scalar('loss/train_loss', train_results['loss'], epoch) for n, l in train_results['losses'].items(): tb.add_scalar('train_loss/' + n, l, epoch) # Run Validation logging.info('Validating...') test_results = validate(net, device, val_data, args.val_batches) logging.info('%d/%d = %f' % (test_results['correct'], test_results['correct'] + test_results['failed'], test_results['correct']/(test_results['correct']+test_results['failed']))) # Log validation results to tensorbaord tb.add_scalar('loss/IOU', test_results['correct'] / (test_results['correct'] + test_results['failed']), epoch) tb.add_scalar('loss/val_loss', test_results['loss'], epoch) for n, l in test_results['losses'].items(): tb.add_scalar('val_loss/' + n, l, epoch) # Save best performing network iou = test_results['correct'] / (test_results['correct'] + test_results['failed']) if iou > best_iou or epoch == 0 or (epoch % 10) == 0: torch.save(net, os.path.join(save_folder, 'epoch_%02d_iou_%0.2f' % (epoch, iou))) torch.save(net.state_dict(), os.path.join( save_folder, 'epoch_%02d_iou_%0.2f_statedict.pt' % (epoch, iou))) best_iou = iou
if GLOBALS.CONFIG is None: print("error in initialize_hyper") sys.exit(1) # load dense mode # load data # print("start initializing dataset") # initialize_datasets() # print("finished initializing dataset") data_dict = create_data() GLOBALS.CONFIG['input_shape'] = data_dict['validation_stats'].shape[1] Dense_NN, _ = get_network(GLOBALS.CONFIG['CNN_model'], dense_layers=GLOBALS.CONFIG['dense_model'], CNN_input_shape=GLOBALS.CONFIG['CNN_input_shape'], input_shape=GLOBALS.CONFIG['input_shape']) print(Dense_NN.summary()) # load weights # path = "Output_Files\dense_nn\output_folder_sequential_0.1_None_raw_dataset_3\model_weights\model_weights.h5" # path = "Output_Files\dense_output_layer_1\output_folder_functional_3_0.001_None_raw_dataset_50\model_weights\model_weights.h5" # path = "Output_Files\dense_output_layer_1_attempt2\output_folder_functional_3_0.001_None_raw_dataset_3\model_weights\model_weights.h5" # path = "Output_Files\dense_output_layer_1_attempt2\output_folder_functional_5_0.002_None_raw_dataset_3\model_weights\model_weights.h5" # path = "Output_Files\dense_nn\output_folder_sequential_0.1_None_raw_dataset_3\model_weights\model_weights.h5" # mape of 64.7 path = "Output_Files\dense_nn\output_folder_sequential_1e-04_None_raw_dataset_250\model_weights\model_weights.h5" Dense_NN.load_weights(path)
def main(): args = get_args() if not os.path.exists(args.fname): os.makedirs(args.fname) if not os.path.exists(args.checkpoints): os.makedirs(args.checkpoints) if args.tensorboard: from tensorboardX import SummaryWriter writer = SummaryWriter(args.fname[8:]) else: import wandb wandb.init( project=args.project, name=args.fname.replace("/", "_")[8:], config=args.__dict__, settings=wandb.Settings(_disable_stats=True), ) writer = None logger = logging.getLogger(__name__) logging.basicConfig( format="[%(asctime)s] - %(message)s", datefmt="%Y/%m/%d %H:%M:%S", level=logging.DEBUG, handlers=[ logging.FileHandler(os.path.join(args.fname, "output.log")), logging.StreamHandler(), ], ) logger.info(args) logger.info(git_version()) random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) dataset = get_dataset(args) args.mean = dataset.mean args.std = dataset.std args.dataset = dataset model = get_network(args) opt = torch.optim.SGD(model.parameters(), args.lr, momentum=0.9, weight_decay=args.weight_decay) scheduler = Lr_schedule( opt, milestones=[int(v) for v in args.lr_adjust.split(",")], gamma=0.1) if args.resume_checkpoint != "": state = torch.load(args.resume_checkpoint) model.load_state_dict(state["state_dict"]) opt.load_state_dict(state["optimizer"]) args.epoch = state["epoch"] + 1 if not args.no_amp: # from torch.cuda.amp.grad_scaler import GradScaler # scaler = GradScaler() # args.scaler = scaler from apex import amp model, opt = amp.initialize(model, opt, opt_level="O1", loss_scale=1.0, verbosity=False) args.amp = amp args.opt = opt attack = get_attack(args, model=model) defense = get_defense(args, model, attack) trainer = Trainer( args=args, model=model, dataset=dataset, logger=logger, optimizer=opt, scheduler=scheduler, attack=attack, writer=writer, defense=defense, ) trainer.train() # logger.info("Begin evaluating last") # eval(model, args, dataset, logger) if not args.tensorboard: wandb.finish()
if args.jacquard_output and args.dataset != 'jacquard': raise ValueError( '--jacquard-output can only be used with the --dataset jacquard option.' ) if args.jacquard_output and args.augment: raise ValueError( '--jacquard-output can not be used with data augmentation.') return args if __name__ == '__main__': args = parse_args() # Load Network ggcnn = get_network(args.network) model = torch.load(args.path, map_location='cpu') #print(model) depth_im = np.load( "/home/silvia/dex-net/data/datasets/fc_4/tensors/depth_images_00000.npz" )['arr_0'][50] depth_tensor = torch.from_numpy( np.expand_dims(depth_im.reshape((200, 200)), 0).astype(np.float32)).reshape((1, 1, 200, 200)) device = torch.device("cpu") xc = depth_tensor.to(device) pos_pred, cos_pred, sin_pred = model(xc) x_n = xc.detach().numpy().reshape(200, 200)