def __init__(self, gamma, decay_rate, size_x, size_y, use_deep_learning):
self.iter = 0
# Reinforcement learning parameters
self.gamma = gamma
self.decay_rate = decay_rate
# Game parameters
self.size_x = size_x
self.size_y = size_y
# Training data
self.reward = 0
# Actual situation
self.state = None
self.action = None
self.direction = None
self.snake_pos = None
self.snake_body = None
self.food_pos = None
# Scores
self.sum_score = 0
self.best_score = 0
self.avg_scores = []
self.best_scores = []
# GFX
self.visual = Visual(size_x, size_y)
# deep or not
self.use_deep_learning = use_deep_learning
def main():
# Configura a interface de chamada do programa via linha de
# comando (CLI)
str_descrip = ("Realiza um estudo de Planejamento Energético " +
"a partir de arquivos de entrada tabulares.\n")
parser = argparse.ArgumentParser(description=str_descrip)
parser.add_argument("entradas",
type=str,
nargs="+",
help="lista de caminhos relativos das entradas")
parser.add_argument("-l",
"--log",
dest="l",
type=str,
default="WARNING",
help="nível de logging desejado ao executar")
parser.add_argument("-s",
"--saida",
dest="s",
type=str,
default="results/",
help="diretorio raiz dos arquivos de saída")
# Extrai os parâmetros fornecidos para a execução do programa
args = parser.parse_args()
if args.l not in ["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"]:
raise Exception("Nível de LOG fornecido inválido")
# Atualiza o nível de LOG desejado
LOG_LEVEL = args.l
coloredlogs.install(logger=logger, level=args.l)
# Inicia a execução
logger.info("#### ESTUDO DE MODELOS DE PLANEJAMENTO ENERGÉTICO ####")
logger.info("------------------------------------------------------")
resultados: List[Resultado] = []
for entrada in args.entradas:
e = LeituraEntrada(entrada, LOG_LEVEL)
e.le_arquivo()
# Determina o método de solução
metodo = Metodo.obtem_metodo_pelo_nome(e.cfg.metodo)
resultados.append(metodo.resolve(e, LOG_LEVEL))
# Gera relatórios e gráficos de saída
for resultado in resultados:
caminho_saida = os.path.join(
args.s, "{}/{}/".format(resultado.cfg.nome, int(time.time())))
relator = EscreveSaida(resultado, caminho_saida, LOG_LEVEL)
relator.escreve_relatorio()
visualizador = Visual(resultado, caminho_saida, LOG_LEVEL)
visualizador.visualiza()
caminho_saida = os.path.join(args.s, "multi/{}/".format(int(time.time())))
visualizador = MultiVisual(resultados, caminho_saida, LOG_LEVEL)
visualizador.visualiza()
logger.info("#### FIM DA EXECUÇÃO ####")
optimizer_ft,
opt_level='O1',
loss_scale=128.0)
# model_ft.load_state_dict(torch.load(config_map['resume_from_path']))
# model_p = nn.DataParallel(model_ft, device_ids=train_cfg.gpu_ids)
model_p = DDP(model_ft)
if train_cfg.resume_from_path:
print("resume from %s" % (train_cfg.resume_from_path))
# model_p.load_state_dict(torch.load(train_cfg.resume_from_path))
model_p, optimizer_ft, train_cfg.resume_epoch = load_checkpoint(
model_p, optimizer_ft, train_cfg.resume_from_path)
logger = create_logger(train_cfg.model_bpath, train_cfg.log_name)
my_vis = Visual(train_cfg.model_bpath, log_to_file=train_cfg.vis_log)
# Observe that all parameters are being optimized
# Setup the loss fxn
# criterion = nn.CrossEntropyLoss()
criterion = ContrastiveLoss()
dataloaders = {}
train_loader = get_dataloader(CustomSiameseIterator, SiamesePipeline,
out_map, train_cfg, True)
test_loader = get_dataloader(CustomSiameseIterator, SiamesePipeline,
out_map, train_cfg, False)
# data_len = int(len(test_dataset) / train_cfg.batch_size)
logger.info('the dataset has %d images' %
backbone_net_p = nn.DataParallel(FCN_net, device_ids=config_map['gpu_ids'])
if config_map['resume_from_path']:
backbone_net_p.load_state_dict(torch.load(config_map['resume_from_path']))
summary(backbone_net_p, (3, 448, 448), batch_size=config_map['batch_size'])
optimizer = torch.optim.SGD(backbone_net_p.parameters(),
lr=learning_rate,
momentum=0.99) # , weight_decay=5e-4)
if not os.path.exists(config_map['base_save_path']):
os.makedirs(config_map['base_save_path'])
logger = create_logger(config_map['base_save_path'], config_map['log_name'])
my_vis = Visual(config_map['base_save_path'],
log_to_file=config_map['vis_log_path'])
# backbone_net_p.load_state_dict(torch.load('densenet_sgd_S7_yolo.pth'))
backbone_net_p.train()
transform = transforms.Compose([
transforms.Lambda(cv_resize),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
train_dataset = FCNDataset(list_file=config_map['train_txt_path'],
train=True,
transform=transform,
device=device,
with_sgd = True
optimizer = torch.optim.SGD(backbone_net_p.parameters(), lr=learning_rate, momentum=0.99) # , weight_decay=5e-4)
opt_name = 'sgd'
if not with_sgd:
optimizer = torch.optim.Adam(backbone_net_p.parameters(), lr=learning_rate, weight_decay=1e-8)
opt_name = 'adam'
base_save_path = '%s_%s_cellSize%d/'%(backbone_type, opt_name, S)
if not os.path.exists(base_save_path):
os.makedirs(base_save_path)
log_name = 'train'
logger = create_logger(base_save_path, log_name)
my_vis = Visual(base_save_path[:-1])
# backbone_net_p.load_state_dict(torch.load('densenet_sgd_S7_yolo.pth'))
lossLayer = YOLOLossV1(batch_size, S, B, clsN, lbd_coord, lbd_no_obj, _logger=logger, _vis=my_vis)
backbone_net_p.train()
transform = transforms.Compose([
transforms.Lambda(cv_resize),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
data_base = 'datasets/'
class abcTrain(ABC):
def __init__(self, gamma, decay_rate, size_x, size_y, use_deep_learning):
self.iter = 0
# Reinforcement learning parameters
self.gamma = gamma
self.decay_rate = decay_rate
# Game parameters
self.size_x = size_x
self.size_y = size_y
# Training data
self.reward = 0
# Actual situation
self.state = None
self.action = None
self.direction = None
self.snake_pos = None
self.snake_body = None
self.food_pos = None
# Scores
self.sum_score = 0
self.best_score = 0
self.avg_scores = []
self.best_scores = []
# GFX
self.visual = Visual(size_x, size_y)
# deep or not
self.use_deep_learning = use_deep_learning
def _reinit(self):
x_init = random.randrange(4, self.size_x - 3)
y_init = random.randrange(2, self.size_y - 3)
self.snake_pos = [x_init, y_init]
self.snake_body = [[x_init, y_init], [x_init - 1, y_init],
[x_init - 2, y_init]]
self.food_pos = [
random.randrange(1, self.size_x - 1),
random.randrange(1, self.size_y - 1)
]
self.direction = Direction.RIGHT
self.state = self.get_state()
self.action = self.choose_action(self.state)
self.iter += 1
@abstractmethod
def update_hyperparameters(self):
pass
@abstractmethod
def get_state(self):
pass
@abstractmethod
def choose_action(self, state):
pass
# To be implemented in SARSA and Q-learning train
def update_q_dict(self, state, state2, action, action2):
pass
# To be implemented in DQL train
def handle_deep_learning(self, state1, state2, action1, reward):
pass
@abstractmethod
def print_recap(self):
pass
def save_data(self):
self.avg_scores.append(self.sum_score / self.decay_rate)
self.best_scores.append(self.best_score)
def iterate(self,
visual=False,
speed=0,
test=False,
reward_plus=100,
reward_minus=-200,
nb_step_max=250):
if visual and speed == 0:
raise Error("Usage: train.iterate(visual=True, speed=speed)")
self._reinit()
if self.iter % self.decay_rate == 0:
self.print_recap()
if not test:
self.update_hyperparameters()
self.save_data()
self.best_score = 0
self.sum_score = 0
nb_step_wo_food = 0
score = 0
exit = False
while not exit:
nb_step_wo_food += 1
if nb_step_wo_food >= nb_step_max:
nb_step_wo_food = 0
exit = True
break
new_state = self.get_state()
new_action = self.choose_action(new_state)
self.reward = 0
# Make sure the snake cannot move in the opposite direction
if not self.direction.is_opposite(new_action):
self.direction = new_action
# Move the snake
self.direction.move(self.snake_pos)
# Snake body growing mechanism
self.snake_body.insert(0, list(self.snake_pos))
if self.snake_pos == self.food_pos:
score += 1
nb_step_wo_food = 0
self.reward = reward_plus
else:
self.snake_body.pop()
# Spawning food on the screen
if nb_step_wo_food == 0:
self.food_pos = [
random.randrange(1, self.size_x),
random.randrange(1, self.size_y)
]
# GFX
if visual:
self.visual.draw(self.snake_body, self.food_pos, score, speed)
# Update data
if not test:
if self.use_deep_learning:
self.handle_deep_learning(self.state, new_state,
self.action, self.reward)
else:
self.update_q_dict(self.state, new_state, self.action,
new_action)
self.action = new_action
self.state = new_state
# Game Over conditions
# - Getting out of bounds
if (self.snake_pos[0] < 0 or self.snake_pos[0] > self.size_x - 1
or self.snake_pos[1] < 0
or self.snake_pos[1] > self.size_y - 1):
self.reward = reward_minus
exit = True
break
# - Touching the snake body
for block in self.snake_body[1:]:
if self.snake_pos == block:
self.reward = reward_minus
nb_step_wo_food = 0
exit = True
break
self.sum_score += score
if score > self.best_score:
self.best_score = score
return score
parser = argparse.ArgumentParser(description='YOLO V1 Training params')
parser.add_argument('--config',
default='configs/resnet50_yolo_style_fpn_yolov3.py')
args = parser.parse_args()
config_map = Config()
train_config = config_map.train_config
device = "cuda:0" if torch.cuda.is_available() else "cpu"
# learning_rate = init_lr(config_map)
if not os.path.exists(train_config['base_save_path']):
os.makedirs(train_config['base_save_path'])
logger = create_logger(train_config['base_save_path'],
train_config['log_name'])
my_vis = Visual(train_config['base_save_path'],
log_to_file=train_config['vis_log_path'])
# yolo = init_model(config_map)
yolo = YOLO(config_map, logger=logger, vis=my_vis)
yolo_p = nn.DataParallel(yolo.to(device), device_ids=train_config['gpu_ids'])
if train_config['resume_from_path']:
yolo_p.load_state_dict(torch.load(train_config['resume_from_path']))
print(yolo_p)
# summary(yolo_p, (3, 416, 416), batch_size=train_config['batch_size'])
# exit()
lr0 = train_config['lbd_map']['lr0']
lrf = train_config['lbd_map']['lrf']
momentum = train_config['lbd_map']['momentum']
weight_decay = train_config['lbd_map']['weight_decay']
resume_epoch = train_config['resume_epoch']
# Print the model we just instantiated
# summary(model_p, (3, img_input_size, img_input_size))
# Send the model to GPU
# Gather the parameters to be optimized/updated in this run. If we are
# finetuning we will be updating all parameters. However, if we are
# doing feature extract method, we will only update the parameters
# that we have just initialized, i.e. the parameters with requires_grad
# is True.
logger = create_logger(config_map['model_save_path'], config_map['log_name'])
my_vis = Visual(config_map['model_save_path'], log_to_file=config_map['vis_log_path'])
# Observe that all parameters are being optimized
optimizer_ft = optim.SGD(model_p.parameters(), lr=0.1 * config_map['batch_size'] / 256.0, momentum=0.9)
# optimizer_ft = optim.RMSprop(params_to_update, momentum=0.9)
# optimizer_ft = optim.Adam(model_p.parameters(), lr=1e-2, eps=1e-8, betas=(0.9, 0.99), weight_decay=0.)
# optimizer_ft = optim.Adadelta(params_to_update, lr=1)
# Setup the loss fxn
criterion = nn.CrossEntropyLoss()
dataloaders = {}
train_dataset = ClassifyDataset(base_data_path=config_map['train_data_path'], train=True, transform = data_transforms['train'], id_name_path=config_map['id_name_txt'], device=device, little_train=False)
train_loader = DataLoader(train_dataset,batch_size=config_map['batch_size'], shuffle=True, num_workers=4, pin_memory=True)
test_dataset = ClassifyDataset(base_data_path=config_map['test_data_path'], train=False,transform = data_transforms['val'], id_name_path=config_map['id_name_txt'], device=device, little_train=False, with_file_path=False)
test_loader = DataLoader(test_dataset,batch_size=config_map['batch_size'],shuffle=True, num_workers=4, pin_memory=True)