def __init__(self, config):
super().__init__(config)
# Create an instance from the Model
self.logger.info("Loading encoder pretrained in imagenet...")
if self.config.pretrained_encoder:
pretrained_enc = torch.nn.DataParallel(
ERFNet(self.config.imagenet_nclasses)).cuda()
pretrained_enc.load_state_dict(
torch.load(self.config.pretrained_model_path)['state_dict'])
pretrained_enc = next(pretrained_enc.children()).features.encoder
else:
pretrained_enc = None
# define erfNet model
self.model = ERF(self.config, pretrained_enc)
# Create an instance from the data loader
self.data_loader = VOCDataLoader(self.config)
# Create instance from the loss
self.loss = CrossEntropyLoss(self.config)
# Create instance from the optimizer
self.optimizer = torch.optim.Adam(
self.model.parameters(),
lr=self.config.learning_rate,
betas=(self.config.betas[0], self.config.betas[1]),
eps=self.config.eps,
weight_decay=self.config.weight_decay)
# Define Scheduler
lambda1 = lambda epoch: pow(
(1 - ((epoch - 1) / self.config.max_epoch)), 0.9)
self.scheduler = lr_scheduler.LambdaLR(self.optimizer,
lr_lambda=lambda1)
# initialize my counters
self.current_epoch = 0
self.current_iteration = 0
self.best_valid_mean_iou = 0
# Check is cuda is available or not
self.is_cuda = torch.cuda.is_available()
# Construct the flag and make sure that cuda is available
self.cuda = self.is_cuda & self.config.cuda
if self.cuda:
torch.cuda.manual_seed_all(self.config.seed)
self.device = torch.device("cuda")
torch.cuda.set_device(self.config.gpu_device)
self.logger.info("Operation will be on *****GPU-CUDA***** ")
print_cuda_statistics()
else:
self.device = torch.device("cpu")
torch.manual_seed(self.config.seed)
self.logger.info("Operation will be on *****CPU***** ")
self.model = self.model.to(self.device)
self.loss = self.loss.to(self.device)
# Model Loading from the latest checkpoint if not found start from scratch.
self.load_checkpoint(self.config.checkpoint_file)
# Tensorboard Writer
self.summary_writer = SummaryWriter(log_dir=self.config.summary_dir,
comment='FCN8s')
def __init__(self, config):
super().__init__(config)
# Create an instance from the Model
self.model = CondenseNet(self.config)
# Create an instance from the data loader
self.data_loader = Cifar10DataLoader(self.config)
# Create instance from the loss
self.loss = CrossEntropyLoss()
# Create instance from the optimizer
self.optimizer = torch.optim.SGD(self.model.parameters(),
lr=self.config.learning_rate,
momentum=float(self.config.momentum),
weight_decay=self.config.weight_decay,
nesterov=True)
# initialize my counters
self.current_epoch = 0
self.current_iteration = 0
self.best_valid_acc = 0
# Check is cuda is available or not
self.is_cuda = torch.cuda.is_available()
# Construct the flag and make sure that cuda is available
self.cuda = self.is_cuda & self.config.cuda
if self.cuda:
self.device = torch.device("cuda")
torch.cuda.manual_seed_all(self.config.seed)
torch.cuda.set_device(self.config.gpu_device)
self.logger.info("Operation will be on *****GPU-CUDA***** ")
print_cuda_statistics()
else:
self.device = torch.device("cpu")
torch.manual_seed(self.config.seed)
self.logger.info("Operation will be on *****CPU***** ")
self.model = self.model.to(self.device)
self.loss = self.loss.to(self.device)
# Model Loading from the latest checkpoint if not found start from scratch.
self.load_checkpoint(self.config.checkpoint_file)
# Tensorboard Writer
self.summary_writer = SummaryWriter(log_dir=self.config.summary_dir,
comment='CondenseNet')
def __init__(self, config):
super().__init__(config)
self.config = config
self.onlineExpert = ComputeECBSSolution(self.config)
self.dataTransformer = DataTransformer(self.config)
self.recorder = MonitoringMultiAgentPerformance(self.config)
self.model = DecentralPlannerNet(self.config)
self.logger.info("Model: \n".format(print(self.model)))
# define data_loader
self.data_loader = DecentralPlannerDataLoader(config=config)
# define loss
self.loss = CrossEntropyLoss()
self.l1_reg = L1Regularizer(self.model)
self.l2_reg = L2Regularizer(self.model)
# define optimizers
self.optimizer = optim.Adam(self.model.parameters(),
lr=self.config.learning_rate,
weight_decay=self.config.weight_decay)
print(self.config.weight_decay)
self.scheduler = optim.lr_scheduler.CosineAnnealingLR(
self.optimizer, T_max=self.config.max_epoch, eta_min=1e-6)
# for param in self.model.parameters():
# print(param)
# for name, param in self.model.state_dict().items():
# print(name, param)
# initialize counter
self.current_epoch = 0
self.current_iteration = 0
self.current_iteration_validStep = 0
self.rateReachGoal = 0.0
# set cuda flag
self.is_cuda = torch.cuda.is_available()
if self.is_cuda and not self.config.cuda:
self.logger.info(
"WARNING: You have a CUDA device, so you should probably enable CUDA"
)
self.cuda = self.is_cuda & self.config.cuda
# set the manual seed for torch
self.manual_seed = self.config.seed
if self.cuda:
torch.cuda.manual_seed_all(self.manual_seed)
self.config.device = torch.device("cuda")
torch.cuda.set_device(self.config.gpu_device)
self.model = self.model.to(self.config.device)
self.loss = self.loss.to(self.config.device)
self.logger.info("Program will run on *****GPU-CUDA***** ")
print_cuda_statistics()
else:
self.config.device = torch.device("cpu")
torch.manual_seed(self.manual_seed)
self.logger.info("Program will run on *****CPU*****\n")
# Model Loading from the latest checkpoint if not found start from scratch.
if self.config.train_TL or self.config.test_general:
self.load_pretrained_checkpoint(self.config.test_epoch,
lastest=self.config.lastest_epoch,
best=self.config.best_epoch)
else:
self.load_checkpoint(self.config.test_epoch,
lastest=self.config.lastest_epoch,
best=self.config.best_epoch)
# Summary Writer
self.robot = multiRobotSim(self.config)
self.switch_toOnlineExpert = False
self.summary_writer = SummaryWriter(log_dir=self.config.summary_dir,
comment='NerualMAPP')
self.plot_graph = True
self.save_dump_input = False
self.dummy_input = None
self.dummy_gso = None
self.time_record = None