def train():
policy = build_policy()
writer = SummaryWriter(writer_path)
mean, std = [], []
for i_eps in range(episodes):
rewards = sample(env, policy, max_step, rand_theta=True)
reward_mean = np.mean(rewards)
reward_std = np.std(rewards)
mean.append(reward_mean)
std.append(reward_std)
#==============learn==============
pg_loss, q_loss, a_loss = policy.learn()
if PLOT:
plot(mean, POLT_NAME, model_save_dir, 50)
if WRITER:
writer.add_scalar('reward', reward_mean, global_step=i_eps)
writer.add_scalar('loss/pg_loss', pg_loss, global_step=i_eps)
writer.add_scalar('loss/q_loss', q_loss, global_step=i_eps)
writer.add_scalar('loss/alpha_loss', a_loss, global_step=i_eps)
if i_eps % 1 == 0:
print (f'EPS:{i_eps}, reward:{reward_mean:.3f}, pg_loss:{pg_loss:.3f}, q_loss:{q_loss:.3f}, alpha_loss:{a_loss:.3f}', end='\r')
if i_eps % 50 == 0 and i_eps > 0:
policy.save_model(model_save_dir, save_file, save_actor=True, save_critic=True)
print(f'save model at {i_eps}')
writer.close()
return mean, std
def main():
if not TRAIN:
policy.load_model(model_save_dir, save_file, load_actor=True)
live_time = []
# while policy.warm_up():
# sample(env, policy, max_step)
# print (f'Warm up for buffer {policy.buffer.size()}', end='\r')
for i_eps in range(episodes):
reward_avg = sample(env, policy, max_step)
if not TRAIN:
print (f'EPS:{i_eps + 1}, reward:{round(reward_avg, 3)}')
else:
#==============learn==============
pg_loss, v_loss = policy.learn()
if PLOT:
live_time.append(reward_avg)
plot(live_time, 'DDPG_'+env_name, model_save_dir, 100)
if WRITER:
writer.add_scalar('reward', reward_avg, global_step=i_eps)
writer.add_scalar('loss/pg_loss', pg_loss, global_step=i_eps)
writer.add_scalar('loss/v_loss', v_loss, global_step=i_eps)
if i_eps % 5 == 0:
print (f'EPS:{i_eps}, reward_avg:{round(reward_avg, 3)}, pg_loss:{round(pg_loss, 3)}, v_loss:{round(v_loss, 3)}')
if i_eps % 200 == 0:
policy.save_model(model_save_dir, save_file, save_actor=True, save_critic=True)
writer.close()
env.close()
def train_ddpg(env, agent, config):
episodes, tmax = config.episodes, config.tmax
tic = time.time()
means = []
mins = []
maxes = []
stds = []
mean_steps = []
steps = []
scores_window = deque(maxlen=100)
for e in range(1, episodes):
agent.reset_episode()
episode_scores = []
obs = env.reset()
for t in range(tmax):
actions = agent.act(obs.reshape(-1))
next_obs, rewards, dones = env.step(actions.reshape(2, -1))
# Step agent with reshaped observations
agent.step(obs.reshape(-1), actions.reshape(-1), np.max(rewards),
next_obs.reshape(-1), np.max(dones))
# Score tracking
episode_scores.append(np.max(rewards))
obs = next_obs
if dones.any():
steps.append(int(t))
break
scores_window.append(np.sum(episode_scores))
means.append(np.mean(scores_window))
mins.append(min(scores_window))
maxes.append(max(scores_window))
mean_steps.append(np.mean(steps))
stds.append(np.std(scores_window))
if e % 50 == 0:
toc = time.time()
r_mean = np.mean(scores_window)
r_max = max(scores_window)
r_min = min(scores_window)
r_std = np.std(scores_window)
plot(means,
maxes,
mins,
mean_steps,
num_agents=2,
name=config.name,
game='Tennis')
print(
"\rEpisode: {} out of {}, Steps {}, Mean steps {:.2f}, Noise {:.2f}, Rewards: mean {:.2f}, min {:.2f}, max {:.2f}, std {:.2f}, Elapsed {:.2f}"
.format(e, episodes, np.sum(steps), np.mean(steps),
agent.noise_scale, r_mean, r_min, r_max, r_std,
(toc - tic) / 60))
if np.mean(scores_window) > config.winning_condition:
print('Env solved!')
# save scores
pickle.dump([means, maxes, mins, mean_steps],
open(str(config.name) + '_scores.p', 'wb'))
# save policy
agent.save_weights(config.checkpoint_path)
break
env.close()
def check_data(d: dict) -> dict:
try:
samples = d['RIDE']['SAMPLES']
powerdata = [x['WATTS'] for x in samples]
heartrate = [x['HR'] for x in samples]
# Find spikes/drops
print(len(heartrate))
spikes = collect_abnormal(heartrate)
for spike in spikes:
print(spike)
print('Start: {}'.format(format_time(spike[0])))
print('End: {}'.format(format_time(spike[1])))
xs = list(range(len(heartrate)))
# Smooth data
savitzky = list(
smooth.savitzky_golay(np.array(heartrate), window_size=21,
order=3))
plot.plot(xs, heartrate, savitzky)
# Assign smoothed data
return d
except KeyError:
return d
def train():
model = namedtuple('model', ['policy_net', 'value_net', 'v_net'])
actor = ActorModel(state_space, hidden_dim, action_space)
critic = CriticModel(state_space, hidden_dim, action_space)
v_net = ValueModel(state_space)
rl_agent = model(actor, critic, v_net)
policy = SAC(rl_agent,
buffer_size=buffer_size,
actor_learn_freq=actor_learn_freq,
update_iteration=update_iteration,
target_update_freq=target_update_freq,
target_update_tau=target_update_tau,
batch_size=batch_size,
learning_rate=lr)
writer = SummaryWriter(writer_path)
if not TRAIN:
policy.load_model(model_save_dir, save_file, load_actor=True)
mean, std = [], []
live_time = []
# while policy.warm_up():
# sample(env, policy, max_step, warm_up=True)
# print (f'Warm up for buffer {policy.buffer.size()}', end='\r')
for i_eps in range(episodes):
rewards = sample(env, policy, max_step)
reward_mean = np.mean(rewards)
reward_std = np.std(rewards)
mean.append(reward_mean)
std.append(reward_std)
if not TRAIN:
print(f'EPS:{i_eps + 1}, reward:{round(reward_mean, 3)}')
else:
#==============learn==============
pg_loss, q_loss, v_loss = policy.learn()
if PLOT:
live_time.append(reward_mean)
plot(live_time, POLT_NAME, model_save_dir, 100)
if WRITER:
writer.add_scalar('reward', reward_mean, global_step=i_eps)
writer.add_scalar('loss/pg_loss', pg_loss, global_step=i_eps)
writer.add_scalar('loss/q_loss', q_loss, global_step=i_eps)
writer.add_scalar('loss/v_loss', v_loss, global_step=i_eps)
if i_eps % 5 == 0:
print(
f'EPS:{i_eps}, reward_mean:{round(reward_mean, 3)}, pg_loss:{round(pg_loss, 3)}, q_loss:{round(q_loss, 3)}, alpha_loss:{round(v_loss, 3)}'
)
if i_eps % 200 == 0:
policy.save_model(model_save_dir,
save_file,
save_actor=True,
save_critic=True)
writer.close()
env.close()
return mean, std
def train():
mean, std = [], []
if not TRAIN:
policy.load_model(model_save_dir, save_file, load_actor=True)
live_time = []
# while policy.warm_up():
# sample(env, policy, max_step)
# print (f'Warm up for buffer {policy.buffer.size()}', end='\r')
for i_eps in range(episodes):
rewards = sample(env, policy, max_step)
reward_mean = np.mean(rewards)
reward_std = np.std(rewards)
mean.append(reward_mean)
std.append(reward_std)
if not TRAIN:
print(f'EPS:{i_eps + 1}, reward:{round(reward_mean, 3)}')
else:
#==============learn==============
pg_loss, q_loss, a_loss = policy.learn()
if PLOT:
live_time.append(reward_mean)
plot(live_time, POLT_NAME, model_save_dir, 100)
if WRITER:
writer.add_scalar('reward', reward_mean, global_step=i_eps)
writer.add_scalar('loss/pg_loss', pg_loss, global_step=i_eps)
writer.add_scalar('loss/q_loss', q_loss, global_step=i_eps)
writer.add_scalar('loss/alpha_loss', a_loss, global_step=i_eps)
if i_eps % 5 == 0:
print(
f'EPS:{i_eps}, reward_mean:{round(reward_mean, 3)}, pg_loss:{round(pg_loss, 3)}, q_loss:{round(q_loss, 3)}, alpha_loss:{round(a_loss, 3)}'
)
if i_eps % 200 == 0:
policy.save_model(model_save_dir,
save_file,
save_actor=True,
save_critic=True)
writer.close()
env.close()
return mean, std
def create_pdm(shapes):
'''
Create a new point distribution model based on landmark data.
Step 1: Generalised Procrustes Analysis on the landmark data
Step 2: Principal Component Analysis on the GPAed landmark data
This process will return an amount of eigenvectors from
which we construct deviations from the mean image.
Step 3: Create a deformable model from the processed data
In: list of directories of the landmark data
Out: DeformableModel instance created with preprocessed data.
'''
# perform gpa
mean, aligned = gpa(np.asarray(shapes))
plot('gpa', mean, aligned)
# perform PCA
eigenvalues, eigenvectors, m = pca(aligned, mean=mean, max_variance=0.99)
plot('eigenvectors', mean, eigenvectors)
# create PointDistributionModel instance
model = PointDistributionModel(eigenvalues, eigenvectors, mean)
plot('deformablemodel', model)
return model
def create_pdm(shapes):
'''
Create a new point distribution model based on landmark data.
Step 1: Generalised Procrustes Analysis on the landmark data
Step 2: Principal Component Analysis on the GPAed landmark data
This process will return an amount of eigenvectors from
which we construct deviations from the mean image.
Step 3: Create a deformable model from the processed data
In: list of directories of the landmark data
Out: DeformableModel instance created with preprocessed data.
'''
# perform gpa
mean, aligned = gpa(np.asarray(shapes))
plot('gpa', mean, aligned)
# perform PCA
eigenvalues, eigenvectors, m = pca(aligned, mean=mean, max_variance=0.99)
plot('eigenvectors', mean, eigenvectors)
# create PointDistributionModel instance
model = PointDistributionModel(eigenvalues, eigenvectors, mean)
plot('deformablemodel', model)
return model
def _rollout(self, seed, n_iter, L, mask, render=False, plot_ret=True):
mask = np.array(mask)
for i in range(0, n_iter):
ep_r = 0.0
observes, actions, rewards = [], [], []
done = False
step = 0
choose_idx = np.random.choice(np.where(mask == 1)[0])
env = self.envs[choose_idx]
obs = env.reset(rseed=seed) # obs here are unscaled
while not done:
if render:
env.render()
obs = obs.astype(np.float32).reshape((1, -1))
obs = np.append(obs, [[0.001 * step]], axis=1)
observes.append(obs)
action = self.policy.act(obs)
obs, reward, done, _ = env.step(np.squeeze(action, axis=0))
if not isinstance(reward, float):
reward = np.asscalar(reward)
reward = reward / self.rew_scale[choose_idx]
ep_r += reward
actions.append(action)
rewards.append(reward)
if done:
break
step += 1
if plot_ret:
plot.plot('ep_r_L{}'.format(L), ep_r)
plot.tick('ep_r_L{}'.format(L))
plot.flush(self.log_path, verbose=False)
print('average episode return={}'.format(ep_r))
yield np.array(observes), np.array(actions), np.array(rewards)
def pdm(r):
images, landmarks, landmarks_per_image = r
# perform GPA
mean, aligned = gpa(np.asarray(landmarks))
plot('gpa', mean, aligned)
# perform PCA
eigenvalues, eigenvectors, m = pca(aligned)
plot('eigenvectors', m, eigenvectors)
# create PointDistributionModel instance
model = PointDistributionModel(eigenvalues, eigenvectors, m)
plot('deformablemodel', model)
return model
todosAtributos = False
if problem == 'Iris':
dm = DataManipulation(iris_path, 0)
if todosAtributos:
data = dm.getData() # Base iris com apenas todos atributos
else:
data = [[p[2:]]
for p in dm.getData()] # Base iris com apenas 2 atributos
else:
dm = DataManipulation(art_path, 1)
data = dm.getData() # Base artificial
p = Perceptron(data, fn)
r = p.execution(realizacoes)
# Plot
bestAcc = r[0]
bestAccData = r[1]
bestW = r[2]
print()
print('### Informações do plot ###')
print('Melhor taxa de acerto: ', bestAcc)
print('Melhor vetor w: \n', bestW)
print('#############################')
if (problem == 'Iris' or problem == 'Artificial') and todosAtributos == False:
plotData.plotPatterns(bestAccData, problem)
plotData.plot(bestAccData, bestW[0])
plotData.plot(bestAccData, bestW[1])
plotData.plot(bestAccData, bestW[2]).show()
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
device = torch.device('cuda' if cfg.use_gpu else 'cpu')
if cfg.use_gpu and not torch.cuda.is_available():
sys.exit('Error: CUDA requested but not available')
os.makedirs(cfg.checkpoint_dir, exist_ok=True)
assert cfg.model.num_classes == len(cfg.data.classes)
num_classes = cfg.model.num_classes
model_cfg = cfg.model.copy()
model_name = model_cfg.pop('name')
net = getattr(models, model_name)
net = net(**model_cfg)
net = DataParallel(net)
net = net.to(device)
if cfg.use_gpu:
torch.backends.cudnn.benchmark = True
try:
weight = torch.Tensor(cfg.data.weights)
except KeyError:
if cfg.loss in ('CrossEntropy', 'mIoU', 'Focal'):
sys.exit(
'Error: The loss function used, need dataset weights values')
optimizer_cfg = cfg.optimizer.copy()
optimizer_name = optimizer_cfg.pop('name')
if optimizer_name == 'Adam':
optimizer_cfg.pop('momentum')
optimizer = getattr(optim, optimizer_name)
optimizer = optimizer(net.parameters(), **optimizer_cfg)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer, **cfg.scheduler)
resume = 0
if cfg.checkpoint:
def map_location(storage, _):
return storage.cuda() if cfg.use_gpu else storage.cpu()
# https://github.com/pytorch/pytorch/issues/7178
chkpt = torch.load(cfg.checkpoint, map_location=map_location)
net.load_state_dict(chkpt['state_dict'])
if cfg.resume:
optimizer.load_state_dict(chkpt['optimizer'])
resume = chkpt['epoch']
if cfg.loss == 'CrossEntropy':
criterion = CrossEntropyLoss2d(weight=weight).to(device)
elif cfg.loss == 'mIoU':
criterion = mIoULoss2d(weight=weight).to(device)
elif cfg.loss == 'Focal':
criterion = FocalLoss2d(weight=weight).to(device)
elif cfg.loss == 'Lovasz':
criterion = LovaszLoss2d().to(device)
elif cfg.loss == 'Dice':
criterion = DiceLoss().to(device)
elif cfg.loss == 'Mix':
criterion = MixedLovaszCrossEntropyLoss(weight=weight).to(device)
else:
sys.exit('Error: Unknown cfg.loss value !')
train_loader, val_loader = get_dataset_loaders(cfg)
num_epochs = cfg.num_epochs
if resume >= num_epochs:
sys.exit('Error: Epoch {} already reached by the checkpoint provided'.
format(num_epochs))
history = collections.defaultdict(list)
log = Log(os.path.join(cfg.checkpoint_dir, 'log'))
log.log('--- Hyper Parameters on this training: ---')
log.log('Model:\t\t {}'.format(model_name))
log.log('Backbone:\t {}'.format(cfg.model.backbone_name))
log.log('Pretrained:\t {}'.format(cfg.model.pretrained))
log.log('Loss function:\t {}'.format(cfg.loss))
log.log('Batch Size:\t {}'.format(cfg.batch_size))
log.log('optimizer:\t {}'.format(optimizer_name))
log.log('Learning Rate:\t {}'.format(cfg.optimizer.lr))
log.log('Momentum:\t {}'.format(cfg.optimizer.momentum))
log.log('Weight Decay:\t {}'.format(cfg.optimizer.weight_decay))
log.log('Step size:\t {}'.format(cfg.scheduler.step_size))
log.log('Gamma:\t\t {}'.format(cfg.scheduler.gamma))
log.log('Image Size:\t {}'.format(cfg.data.train.crop_size))
log.log('Resize Scale:\t {}'.format(cfg.data.train.resize_scale))
log.log('Flip Probability:\t {}'.format(cfg.data.train.flip_prob))
log.log('Rotation Probability:\t {}'.format(cfg.data.train.rotation_prob))
log.log('Rotation Degree:\t {}'.format(cfg.data.train.rotation_degree))
log.log('Rotate Degree:\t {}'.format(cfg.data.train.rotate_degree))
if 'weight' in locals():
log.log('Weights:\t {}'.format(cfg.data.weights))
log.log('------------------------------------------')
for epoch in range(resume, num_epochs):
log.log('Epoch: {}/{}'.format(epoch + 1, num_epochs))
train_hist = train(train_loader, num_classes, device, net, optimizer,
criterion, exp_lr_scheduler)
log.log(
'Train loss: {:.4f}, mIoU: {:.3f}, {} IoU: {:.3f}, MCC: {:.3f}'.
format(
train_hist['loss'],
train_hist['miou'],
cfg.data.classes[1],
train_hist['fg_iou'],
train_hist['mcc'],
))
for k, v in train_hist.items():
history['train ' + k].append(v)
val_hist = validate(val_loader, num_classes, device, net, criterion)
log.log(
'Validate loss: {:.4f}, mIoU: {:.3f}, {} IoU: {:.3f}, MCC: {:.3f}'.
format(val_hist['loss'], val_hist['miou'], cfg.data.classes[1],
val_hist['fg_iou'], val_hist['mcc']))
for k, v in val_hist.items():
history['val ' + k].append(v)
visual = 'history-{:05d}-of-{:05d}.png'.format(epoch + 1, num_epochs)
plot(os.path.join(cfg.checkpoint_dir, visual), history)
checkpoint = 'checkpoint-{:05d}-of-{:05d}.pth'.format(
epoch + 1, num_epochs)
states = {
'epoch': epoch + 1,
'state_dict': net.state_dict(),
'optimizer': optimizer.state_dict()
}
torch.save(states, os.path.join(cfg.checkpoint_dir, checkpoint))
model.rollouts.insert(current_obs, actions.view(-1, 1), action_log_prob, values, rewards, masks)
with torch.no_grad():
next_value = model.get_values(model.rollouts.observations[-1])
model.rollouts.compute_returns(next_value, config.GAMMA)
value_loss, action_loss, dist_entropy = model.update(model.rollouts)
model.rollouts.after_update()
if frame_idx % 100 == 0:
try:
clear_output()
end = timer()
total_num_steps = (frame_idx + 1) * config.num_agents * config.rollout
print(
"Updates {}, Num Timesteps {}, FPS {},\n"
"Mean/Median Reward {:.1f}/{:.1f}, Min/Max Reward {:.1f}/{:.1f},\n"
"Entropy {:.5f}, Value Loss {:.5f}, Policy Loss {:.5f}".format(
frame_idx, total_num_steps, int(total_num_steps / (end - start)),
np.mean(final_rewards), np.median(final_rewards), np.min(final_rewards), np.max(final_rewards),
dist_entropy, value_loss, action_loss))
plot(log_dir, "PongNoFrameskip-v4", 'PPO', config.MAX_FRAMES * config.num_agents * config.rollout)
except IOError:
pass
model.save_w()
envs.close()
def main():
args = get_args()
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
if args.cuda and torch.cuda.is_available() and args.cuda_deterministic:
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
base_dir = osp.expanduser(args.log_dir)
log_dir = osp.join(base_dir, 'train_log')
eval_log_dir = osp.join(base_dir, "eval_log")
tensorboard_dir = osp.join(base_dir, "tensorboard_log")
utils.cleanup_log_dir(log_dir)
utils.cleanup_log_dir(eval_log_dir)
utils.cleanup_log_dir(tensorboard_dir)
utils.dump_config(args, osp.join(base_dir, 'config.txt'))
torch.set_num_threads(1)
device = torch.device("cuda:0" if args.cuda else "cpu")
writer = SummaryWriter(tensorboard_dir)
# limited the number of steps for each episode
# IMPORTANT: for load balance / spark-sim we automatically do this by setting
# the number of stream jobs
if not args.use_proper_time_limits:
envs = make_vec_envs(env_name=args.env_name,
seed=args.seed,
num_processes=args.num_processes,
log_dir=log_dir,
device=device,
allow_early_resets=False,
args=args)
else:
envs = make_vec_envs(env_name=args.env_name,
seed=args.seed,
num_processes=args.num_processes,
log_dir=log_dir,
device=device,
allow_early_resets=True,
max_episode_steps=args.max_episode_steps,
args=args)
# create actor critic
actor_critic = Policy(envs.observation_space.shape,
envs.action_space,
base_kwargs={'recurrent': args.recurrent_policy})
# if the resume directory is provided, then directly load that checkpoint
if args.resume_dir is not None:
print("=> Resuming from checkpoint: {}".format(args.resume_dir))
actor_critic = torch.load(args.resume_dir, map_location='cpu')[0]
actor_critic.to(device)
# expert for imitation learning
if args.use_imitation_learning:
expert = LeastWorkAgent()
else:
expert = None
if args.algo == 'a2c':
agent = algorithms.A2C_ACKTR(actor_critic,
args.value_loss_coef,
args.entropy_coef,
lr=args.lr,
eps=args.eps,
alpha=args.alpha,
max_grad_norm=args.max_grad_norm,
expert=expert,
il_coef=args.il_coef)
elif args.algo == 'ppo':
agent = algorithms.PPO(actor_critic,
args.clip_param,
args.ppo_epoch,
args.num_mini_batch,
args.value_loss_coef,
args.entropy_coef,
lr=args.lr,
eps=args.eps,
max_grad_norm=args.max_grad_norm,
expert=expert,
il_coef=args.il_coef)
elif args.algo == 'acktr':
agent = algorithms.A2C_ACKTR(actor_critic,
args.value_loss_coef,
args.entropy_coef,
acktr=True)
elif args.algo == 'mib_a2c':
agent = algorithms.MIB_A2C(actor_critic,
args.entropy_coef,
lr=args.lr,
adapt_lr=args.adapt_lr,
num_inner_steps=args.num_inner_steps,
max_grad_norm=args.max_grad_norm,
expert=expert,
il_coef=args.il_coef)
elif args.algo == 'mib_ppo':
agent = algorithms.MIB_PPO(actor_critic=actor_critic,
clip_param=args.clip_param,
ppo_epoch=args.ppo_epoch,
num_mini_batch=args.num_mini_batch,
entropy_coef=args.entropy_coef,
lr=args.lr,
adapt_lr=args.adapt_lr,
num_inner_steps=args.num_inner_steps,
max_grad_norm=args.max_grad_norm,
expert=expert,
il_coef=args.il_coef)
elif args.algo == 'lacie_a2c':
agent = algorithms.LACIE_A2C(actor_critic=actor_critic,
value_coef=args.value_loss_coef,
entropy_coef=args.entropy_coef,
regularize_coef=args.regularize_coef,
lr=args.lr,
eps=args.eps,
alpha=args.alpha,
max_grad_norm=args.max_grad_norm,
expert=expert,
il_coef=args.il_coef,
num_cpc_steps=args.lacie_num_iter,
cpc_lr=args.cpc_lr)
elif args.algo == 'lacie_a2c_memory':
lacie_buffer = LacieStorage(args.num_steps,
envs.observation_space.shape,
envs.action_space,
max_size=args.lacie_buffer_size,
batch_size=args.lacie_batch_size,
n_processes=args.num_processes)
lacie_buffer.to(device)
agent = algorithms.LACIE_A2C_Memory(
actor_critic=actor_critic,
value_coef=args.value_loss_coef,
entropy_coef=args.entropy_coef,
regularize_coef=args.regularize_coef,
lr=args.lr,
eps=args.eps,
alpha=args.alpha,
max_grad_norm=args.max_grad_norm,
expert=expert,
il_coef=args.il_coef,
num_cpc_steps=args.lacie_num_iter,
lacie_batch_size=args.lacie_batch_size,
lacie_buffer=lacie_buffer,
use_memory_to_pred_weights=args.use_memory_to_pred_weights,
cpc_lr=args.cpc_lr)
elif args.algo == 'lacie_ppo':
agent = algorithms.LACIE_PPO(actor_critic,
args.clip_param,
args.ppo_epoch,
args.num_mini_batch,
args.value_loss_coef,
args.entropy_coef,
regularize_coef=args.regularize_coef,
lr=args.lr,
eps=args.eps,
max_grad_norm=args.max_grad_norm,
expert=expert,
il_coef=args.il_coef,
cpc_lr=args.cpc_lr)
elif args.algo == 'lacie_ppo_memory':
lacie_buffer = LacieStorage(args.num_steps,
envs.observation_space.shape,
envs.action_space,
max_size=args.lacie_buffer_size,
batch_size=args.lacie_batch_size,
n_processes=args.num_processes)
lacie_buffer.to(device)
agent = algorithms.LACIE_PPO_Memory(
actor_critic,
args.clip_param,
args.ppo_epoch,
args.num_mini_batch,
args.value_loss_coef,
args.entropy_coef,
regularize_coef=args.regularize_coef,
lr=args.lr,
eps=args.eps,
max_grad_norm=args.max_grad_norm,
expert=expert,
il_coef=args.il_coef,
num_cpc_steps=args.lacie_num_iter,
lacie_batch_size=args.lacie_batch_size,
lacie_buffer=lacie_buffer,
use_memory_to_pred_weights=args.use_memory_to_pred_weights,
cpc_lr=args.cpc_lr)
else:
raise ValueError("Not Implemented algorithm...")
rollouts = RolloutStorage(args.num_steps, args.num_processes,
envs.observation_space.shape, envs.action_space,
actor_critic.recurrent_hidden_state_size)
obs = envs.reset()
rollouts.obs[0].copy_(obs)
rollouts.to(device)
episode_rewards = deque(maxlen=10)
start = time.time()
num_updates = int(
args.num_env_steps) // args.num_steps // args.num_processes
# the gradient update interval to increase number of stream jobs
curriculum_interval = int(num_updates / args.num_curriculum_time)
for j in range(num_updates):
random_seed = args.seed if args.fix_job_sequence else args.seed + j
# if using load_balance environment: \
# we have to gradually increase number of stream jos
# if (args.env_name == 'load_balance') and ((j + 1) % curriculum_interval) == 0:
# args.num_stream_jobs = int(
# args.num_stream_jobs * args.num_stream_jobs_factor)
# # reconstruct environments to increase the number of stream jobs
# # also alter the random seed
# if not args.use_proper_time_limits:
# envs = make_vec_envs(env_name=args.env_name,
# seed=random_seed,
# num_processes=args.num_processes,
# log_dir=log_dir,
# device=device,
# allow_early_resets=False,
# args=args)
# else:
# envs = make_vec_envs(env_name=args.env_name,
# seed=random_seed,
# num_processes=args.num_processes,
# log_dir=log_dir,
# device=device,
# allow_early_resets=True,
# max_episode_steps=args.max_episode_steps,
# args=args)
# print("Increase the number of stream jobs to " +
# str(args.num_stream_jobs))
# obs = envs.reset()
# rollouts.obs[0].copy_(obs)
# rollouts.to(device)
# decrease learning rate linearly
if args.use_linear_lr_decay:
cur_lr = utils.update_linear_schedule(
agent.optimizer, j, num_updates,
agent.optimizer.lr if args.algo == "acktr" else args.lr)
if args.algo.startswith('lacie'):
cur_lr = utils.update_linear_schedule(agent.cpc_optimizer, j,
num_updates, args.cpc_lr)
else:
cur_lr = agent.optimizer.param_groups[0]["lr"]
# Rolling out, collecting and storing SARS (State, action, reward, new state)
for step in range(args.num_steps):
# Sample actions
with torch.no_grad():
value, action, action_log_prob, recurrent_hidden_states = actor_critic.act(
rollouts.obs[step], rollouts.recurrent_hidden_states[step],
rollouts.masks[step])
# Obser reward and next obs
# TODO: park env does not support cuda tensor???
obs, reward, done, infos = envs.step(action.cpu())
for info in infos:
if 'episode' in info.keys():
episode_rewards.append(info['episode']['r'])
# If done then clean the history of observations.
masks = torch.FloatTensor([[0.0] if done_ else [1.0]
for done_ in done])
bad_masks = torch.FloatTensor(
[[0.0] if 'bad_transition' in info.keys() else [1.0]
for info in infos])
rollouts.insert(obs, recurrent_hidden_states, action,
action_log_prob, value, reward, masks, bad_masks)
with torch.no_grad():
next_value = actor_critic.get_value(
rollouts.obs[-1], rollouts.recurrent_hidden_states[-1],
rollouts.masks[-1]).detach()
rollouts.compute_returns(next_value, args.use_gae, args.gamma,
args.gae_lambda, args.use_proper_time_limits)
results = agent.update(rollouts)
rollouts.after_update()
# SAVE trained model
if (j % args.save_interval == 0
or j == num_updates - 1) and args.save_dir != "":
save_path = os.path.join(args.save_dir, args.algo)
try:
os.makedirs(save_path)
except OSError:
pass
torch.save([
actor_critic,
getattr(utils.get_vec_normalize(envs), 'ob_rms', None)
], os.path.join(save_path, args.env_name + ".pt"))
# LOG TRAINING results
if j % args.log_interval == 0 and len(episode_rewards) > 1:
total_num_steps = (j + 1) * args.num_processes * args.num_steps
end = time.time()
print("=" * 90)
print("Updates {}, num timesteps {}, FPS {}, LR: {}"
"\n=> Last {} training episodes: mean/median reward "
"{:.1f}/{:.1f}, min/max reward {:.1f}/{:.1f}".format(
j, total_num_steps, int(total_num_steps / (end - start)),
cur_lr, len(episode_rewards), np.mean(episode_rewards),
np.median(episode_rewards), np.min(episode_rewards),
np.max(episode_rewards)))
result_str = "=> "
for k, v in results.items():
result_str = result_str + "{}: {:.2f} ".format(k, v)
print(result_str)
writer.add_scalar("train/reward", np.mean(episode_rewards), j)
for k, v in results.items():
writer.add_scalar("train/" + k.replace(' ', '_'), v, j)
plot(log_dir, 'load-balance', args.algo, args.num_env_steps)
# EVALUATE performance of learned policy along with heuristic
if (args.eval_interval is not None and len(episode_rewards) > 1
and j % args.eval_interval == 0):
# alter the random seed
eval_results = evaluate(actor_critic,
args.env_name,
seed=args.seed,
num_processes=args.num_processes,
eval_log_dir=eval_log_dir,
device=device,
env_args=args)
writer.add_scalars(
'eval/reward',
{k: np.mean(v)
for k, v in eval_results.items()}, j)
# plot(eval_log_dir, 'load-balance', args.algo,
# args.num_env_steps)
writer.close()
parser.add_argument('--render', default=False, type=bool)
parser.add_argument('--plotstyle', default=None, type=str)
parser.add_argument('--path', default='', type=str)
args = parser.parse_args()
if 'train' in args.do:
train(dataset_name=args.dataset_name,
env_name=args.env_name,
seed_min=args.seed_min,
seed_nb=args.seed_nb,
quantiles=args.quantiles,
path=args.path)
if 'test' in args.do:
test(args.env_name,
dataset_name=args.dataset_name,
seed_min=args.seed_min,
seed_nb=args.seed_nb,
n_trajectories=args.number_trajectories,
quantiles=args.quantiles,
render=args.render,
path=args.path)
if 'plot' in args.do:
from utils.plot import plot
plot(args.env_name,
args.dataset_name,
seed_min=args.seed_min,
seed_nb=args.seed_nb,
quantiles=args.quantiles,
plotstyle=args.plotstyle,
path=args.path)
from utils.plot import plot
parser = argparse.ArgumentParser(description=description)
parser.add_argument('-g', '--generations', metavar='N', type=int, help=generations_help)
parser.add_argument('--plot', nargs='+', type=str, help=plot_help, choices=choices_plot)
args = parser.parse_args()
if args.plot : args.plot = list(set(args.plot))
if args.generations is None: args.generations = 1
env = Environement(10,10,
Blob(1,4,speed=12,size=3,energy=400,sense=1),
Blob(9,0,speed=12,size=3,energy=400,sense=1, name='001'),
Blob(8,3,speed=12,size=3,energy=400,sense=1, name='002'),
Blob(1,4,speed=12,size=3,energy=400,sense=1, name='003'),
Blob(9,0,speed=12,size=3,energy=400,sense=1, name='004'),
Blob(8,6,speed=12,size=3,energy=400,sense=1, name='005'),
Blob(1,4,speed=12,size=3,energy=400,sense=1, name='006'),
Blob(9,4,speed=12,size=3,energy=400,sense=1, name='007'),
Blob(8,9,speed=12,size=3,energy=400,sense=1, name='008')
)
print(env.blobs)
env.set_food()
env.draw_board()
env.simulate(args.generations)
env.print_blobs()
plot(env,args.plot)
import matplotlib.pyplot as plt
import json
from collections import defaultdict
import numpy as np
from utils.plot import plot
from utils.italy_data import compute_provinces_confirmed_cases
ALIGN_AROUND = 20 # cases
if __name__ == "__main__":
# Compute the number of cases for each country
confirmed = compute_provinces_confirmed_cases()
# Compute maximum number of cases we can align around: min (ALIGN_AROUND, x)
# Take the second biggest one
minimums = [sorted(v)[-2] for c, v in confirmed.items()]
new_align_around = np.minimum(ALIGN_AROUND, np.min(minimums))
# Compute the index for each country in order to align around the same number of cases
align_indexes = defaultdict(list)
for c, v in confirmed.items():
dist = np.abs(np.array(v) - ALIGN_AROUND)
align_indexes[c] = np.argmin(dist)
plot(confirmed, align_indexes, ALIGN_AROUND, "cases")
#json.dump(agent_schedule, open('./results/agent_schedule.json', 'w'))
print(agent_schedule)
with open('./results/agent_schedule.json', 'w') as f:
json.dump(agent_schedule, f)
runner = ScheduleRunner(schedule=agent_schedule,
dag_data=edls.dag.data,
speed_setting=processor_speeds,
base_powers=edls.base_powers,
beta=1.0,
agent_system=False)
runner.start()
# print(runner.processor_times)
print(f'Makespan: {runner.max_time}')
print(f'Total Energy: {runner.task_energy + sum(runner.idle_energy)}')
plot(runner.processor_times[:3], runner.max_time, 'edls_mod_gannt.png')
# ------------ FOr PEFT
"""
agent_schedule = json.load(open('./results/agent_schedule_peft.json'))
keys = list(agent_schedule.keys())
for task in keys:
agent_schedule[int(task)] = agent_schedule[task]
runner = ScheduleRunner(schedule=agent_schedule,
dag_data=edls.dag.data,
speed_setting=processor_speeds,
base_powers=edls.base_powers,
beta=1.0,
agent_system=False)
runner.start()
# print(runner.processor_times)
def main():
parser = argparse.ArgumentParser(
description='Eye Picture Classification Training With PyTorch')
parser.add_argument(
'--resume_model',
default='/mnt/data/qyx_data/torch/saveModel/Eye_resnet18_test.pth',
type=str,
help='Checkpoint state_dict file to resume training from')
parser.add_argument(
'--resume',
default=None,
type=str,
help='Checkpoint state_dict file to resume training from')
parser.add_argument('--model',
default='resnet18',
type=str,
help='the train model')
parser.add_argument('--start_epoch',
default=0,
type=int,
help='the start epoch of training')
parser.add_argument('--max_epoch',
default=1,
type=int,
help='the epoch to end training')
parser.add_argument('--log_step', default=20, type=int, help='log_step')
parser.add_argument('--batchsize', default=128, type=int, help='batchsize')
parser.add_argument('--pretrained',
default=1,
type=int,
help='if the model is pretrained')
args = parser.parse_args()
if not isinstance(args.pretrained, bool):
if args.pretrained == 1:
args.pretrained = True
elif args.pretrained == 0:
args.pretrained = False
root = cfg.IMGROOT
val_root = cfg.VALROOT
if args.model == 'resnet18':
model = make_model('resnet18',
num_classes=cfg.num_classes,
pretrained=args.pretrained,
input_size=(cfg.IMAGE_SIZE, cfg.IMAGE_SIZE))
if args.model == 'resnet101':
model = make_model('resnet101',
num_classes=cfg.num_classes,
pretrained=args.pretrained,
input_size=(cfg.IMAGE_SIZE, cfg.IMAGE_SIZE))
elif args.model == 'vgg16':
model = make_model('vgg16',
num_classes=cfg.num_classes,
pretrained=args.pretrained,
input_size=(cfg.IMAGE_SIZE, cfg.IMAGE_SIZE))
elif args.model == 'alexnet':
model = make_model('alexnet',
num_classes=cfg.num_classes,
pretrained=args.pretrained,
input_size=(cfg.IMAGE_SIZE, cfg.IMAGE_SIZE))
elif args.model == 'inception_v3':
model = make_model('inception_v3',
num_classes=cfg.num_classes,
pretrained=args.pretrained,
input_size=(cfg.IMAGE_SIZE, cfg.IMAGE_SIZE))
elif args.model == 'inceptionresnetv2':
model = make_model('inceptionresnetv2',
num_classes=cfg.num_classes,
pretrained=args.pretrained,
input_size=(cfg.IMAGE_SIZE, cfg.IMAGE_SIZE))
elif args.model == 'googlenet':
model = make_model('googlenet',
num_classes=cfg.num_classes,
pretrained=args.pretrained,
input_size=(cfg.IMAGE_SIZE, cfg.IMAGE_SIZE))
elif args.model == 'densenet121':
model = make_model('densenet121',
num_classes=cfg.num_classes,
pretrained=args.pretrained,
input_size=(cfg.IMAGE_SIZE, cfg.IMAGE_SIZE))
device = t.device("cuda" if t.cuda.is_available() else "cpu")
logger = logging.getLogger("Eye")
logger.setLevel(logging.DEBUG)
fileHanlder = logging.FileHandler(
cfg.LOG + time.asctime(time.localtime(time.time())) + 'Eye_' +
args.model + '.log')
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fileHanlder.setFormatter(formatter)
logger.addHandler(fileHanlder)
logger.info('Train Dataset uploaded!')
logger.info('device:{}'.format(device))
train_transform = train_augment(cfg.IMAGE_SIZE)
train_data = Eye(img_root=root,
tag_root='dataset/train.txt',
transform=train_transform)
data_len = train_data.__len__()
weight_prob = [data_len / w for w in [1, 6, 1, 1, 0.4, 0.8]]
weight_list = [weight_prob[label] for data, label in train_data]
train_sampler = WeightedRandomSampler(weights=weight_list,
num_samples=6 * 3000,
replacement=True)
train_dataloader = DataLoader(train_data,
batch_size=args.batchsize,
drop_last=True,
num_workers=8,
sampler=train_sampler)
val_transform = val_augment(cfg.IMAGE_SIZE)
val_data = Eye(img_root=root,
tag_root='dataset/test.txt',
transform=val_transform)
val_dataloader = DataLoader(val_data,
batch_size=args.batchsize,
shuffle=False,
drop_last=True,
num_workers=8)
plot_util = plot()
loss_list = []
train_acc = []
epoch_list = []
val_acc = []
iter_list = []
val_losslist = []
critertion = t.nn.CrossEntropyLoss()
#critertion=FocalLossV1()
optimizer = t.optim.Adam(model.parameters(),
lr=lr,
weight_decay=cfg.WEIGHT_DECAY)
model = nn.DataParallel(model)
model = model.to(device)
#summary(model,(3,cfg.IMAGE_SIZE,cfg.IMAGE_SIZE),batch_size=cfg.BATCHSIZE)
# logger.info("Resume from the model {}".format(args.resume_model))
# model.load_state_dict(t.load(args.resume_model))
#model.train()
loss_meter = meter.AverageValueMeter()
confusion_matrix = meter.ConfusionMeter(cfg.num_classes)
loss_meter.reset()
confusion_matrix.reset()
for epoch in range(args.start_epoch, args.max_epoch):
model = epoch_train(train_dataloader, val_dataloader, logger, epoch,
args, critertion, optimizer, model, device,
loss_meter, confusion_matrix, train_acc, loss_list,
val_acc, iter_list, val_losslist)
epoch_list.append(epoch)
#调节学习率
if epoch_list[-1] in lr_step:
step_index = lr_step.index(epoch_list[-1]) + 1
adjust_learning_rate(optimizer, cfg.GAMMA, step_index)
#plot
if os.path.exists('/mnt/data/qyx_data/torch/log/' + args.model + '_' +
str(args.pretrained)):
plot_util.plot_cm_matrix(confusion_matrix,
savepath='/mnt/data/qyx_data/torch/log/' +
args.model + '_' + str(args.pretrained) +
'/cm_matrix.png')
plot_util.plot_accuracy(savepath='/mnt/data/qyx_data/torch/log/' +
args.model + '_' + str(args.pretrained) +
'/train_acc.png',
epoch=epoch_list,
train_accuracy=train_acc,
val_accuracy=val_acc)
plot_util.plot_loss(savepath='/mnt/data/qyx_data/torch/log/' +
args.model + '_' + str(args.pretrained) +
'/loss.png',
iters=iter_list,
epoch=epoch_list,
loss=loss_list,
val_loss=val_losslist,
title='loss')
else:
os.mkdir('/mnt/data/qyx_data/torch/log/' + args.model + '_' +
str(args.pretrained))
plot_util.plot_cm_matrix(confusion_matrix,
savepath='/mnt/data/qyx_data/torch/log/' +
args.model + '_' + str(args.pretrained) +
'/cm_matrix.png')
plot_util.plot_accuracy(savepath='/mnt/data/qyx_data/torch/log/' +
args.model + '_' + str(args.pretrained) +
'/train_acc.png',
epoch=epoch_list,
train_accuracy=train_acc,
val_accuracy=val_acc)
plot_util.plot_loss(savepath='/mnt/data/qyx_data/torch/log/' +
args.model + '_' + str(args.pretrained) +
'/train_loss.png',
iters=iter_list,
epoch=epoch_list,
loss=loss_list,
val_loss=val_losslist,
title='loss')
with tf.Session() as sess:
tf.global_variables_initializer().run()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
for iteration in xrange(TOTAL_ITER_NUM):
# _, lossV, _trainY, _predict = sess.run([discOptimizer, loss, trainY, predict], feed_dict = {
# train_status: True
# })
_, lossV, _trainY, _predict = sess.run([discOptimizer, loss, batch_label, predict])
_label = np.argmax(_trainY, axis=1)
_accuracy = np.mean(_label == _predict)
plot.plot('train cross entropy', lossV)
plot.plot('train accuracy', _accuracy)
if iteration % 50 == 49:
dev_accuracy = []
dev_cross_entropy = []
for eval_idx in xrange(EVAL_ITER_NUM):
# eval_loss_v, _trainY, _predict = sess.run([loss, trainY, predict], feed_dict ={train_status: False})
eval_loss_v, _trainY, _predict = sess.run([loss, batch_eval_label, predict_eval])
_label = np.argmax(_trainY, axis=1)
_accuracy = np.mean(_label == _predict)
dev_accuracy.append(_accuracy)
dev_cross_entropy.append(eval_loss_v)
plot.plot('dev accuracy', np.mean(dev_accuracy))
plot.plot('dev cross entropy', np.mean(dev_cross_entropy))
#ensure equal usage of fake samples
entropy1_fake = entropy1(D_fake)
entropy1_fake.backward(mone)
G_cost = entropy2_fake + entropy1_fake
optimizerG.step()
D_cost = D_cost.cpu().data.numpy()
G_cost = G_cost.cpu().data.numpy()
entorpy2_real = entorpy2_real.cpu().data.numpy()
entorpy2_fake = entorpy2_fake.cpu().data.numpy()
#monitoring the loss
plot('errD', D_cost, iter_idx)
# plot('time', time.time() - start_time, iter_idx)
plot('errG', G_cost, iter_idx)
plot('errD_real', entorpy2_real, iter_idx)
plot('errD_fake', entorpy2_fake, iter_idx)
# Save plot every iter
flush(os.path.join(opt.results_dir, opt.name))
# Write losses to logs
log_writer.writerow([D_cost[0],G_cost[0],entorpy2_real[0],entorpy2_fake[0]])
print "iter%d[epoch %d]\t %s %.4f \t %s %.4f \t %s %.4f \t %s %.4f" % (iter_idx, epoch,
'errD', D_cost,
'errG', G_cost,
for i, color in zip(range(n_classes), colors):
plt.plot(fpr[i], tpr[i], color=color, lw=lw,
label='{0} (area = {1:0.2f})'
''.format(disease_class[i], roc_auc[i]))
plt.plot([0, 1], [0, 1], 'k--', lw=lw)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate',fontsize=15)
plt.ylabel('True Positive Rate',fontsize=15)
plt.title('ROC of model',fontsize=15)
plt.legend(loc="lower right")
plt.savefig('/mnt/data/qyx_data/torch/test_model/'+args.model+'_'+str(args.pretrained)+'/ROC.png')
cm_value = confusion_matrix.value()
plot_util = plot()
print(cm_value)
plot_util.plot_cm_matrix(cm_matrix=confusion_matrix,savepath='/mnt/data/qyx_data/torch/test_model/'+args.model+'_'+str(args.pretrained)+'/cm_matrix.png')
correct = 0
sensitive=dict()
specificity=dict()
for i in range(6):
correct+=cm_value[i][i]
sensitive[i] = cm_value[i][i]/cm_value.sum(axis=1)[i]
specificity[i] = (cm_value.sum(axis=1)[i]-cm_value[i][i])/((cm_value.sum(axis=0)[i]-cm_value[i][i])+(cm_value.sum(axis=1)[i]-cm_value[i][i]))
accuracy = 100.*(correct)/(cm_value.sum())
print('accuracy={}'.format(accuracy))
print(sensitive)
print(specificity)
def A2C_experiment(env, batch_size, max_frames, log_dir):
log_dir = log_dir+"A2C/"
try:
os.makedirs(log_dir)
except OSError:
files = glob.glob(os.path.join(log_dir, '*.monitor.csv'))
for f in files:
os.remove(f)
config = Config()
# a2c control
config.num_agents = 16
config.rollout = 5
# misc agent variables
config.GAMMA = 0.99
config.LR = 7e-4
config.entropy_loss_weight = 0.01
config.value_loss_weight = 0.5
# batch size
config.BATCH_SIZE = batch_size
# Number of updates in 10000000 frames
# config.MAX_FRAMES = int(1e7 / config.num_agents / config.rollout)
config.MAX_FRAMES = int(max_frames / config.num_agents / config.rollout)
# training loop
seed = 1
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(seed)
torch.set_num_threads(1)
#monitor = GPUMonitor()
env_id = env
envs = [make_env_a2c_atari(env_id, seed, i, log_dir) for i in range(config.num_agents)]
envs = SubprocVecEnv(envs) if config.num_agents > 1 else DummyVecEnv(envs)
obs_shape = envs.observation_space.shape
obs_shape = (obs_shape[0] * 4, *obs_shape[1:])
model = Model(log_dir, env=envs, config=config)
current_obs = torch.zeros(config.num_agents, *obs_shape,
device=config.device, dtype=torch.float)
def update_current_obs(obs):
shape_dim0 = envs.observation_space.shape[0]
obs = torch.from_numpy(obs.astype(np.float32)).to(config.device)
current_obs[:, :-shape_dim0] = current_obs[:, shape_dim0:]
current_obs[:, -shape_dim0:] = obs
obs = envs.reset()
update_current_obs(obs)
model.rollouts.observations[0].copy_(current_obs)
episode_rewards = np.zeros(config.num_agents, dtype=np.float)
final_rewards = np.zeros(config.num_agents, dtype=np.float)
start = timer()
print_step = 1
print_threshold = 10
#os.remove('./log/A2C/logs.csv')
for frame_idx in range(1, config.MAX_FRAMES + 1):
for step in range(config.rollout):
with torch.no_grad():
values, actions, action_log_prob = model.get_action(model.rollouts.observations[step])
cpu_actions = actions.view(-1).cpu().numpy()
obs, reward, done, _ = envs.step(cpu_actions)
episode_rewards += reward
masks = 1. - done.astype(np.float32)
final_rewards *= masks
final_rewards += (1. - masks) * episode_rewards
episode_rewards *= masks
rewards = torch.from_numpy(reward.astype(np.float32)).view(-1, 1).to(config.device)
masks = torch.from_numpy(masks).to(config.device).view(-1, 1)
current_obs *= masks.view(-1, 1, 1, 1)
update_current_obs(obs)
model.rollouts.insert(current_obs, actions.view(-1, 1), action_log_prob, values, rewards, masks)
with torch.no_grad():
next_value = model.get_values(model.rollouts.observations[-1])
model.rollouts.compute_returns(next_value, config.GAMMA)
value_loss, action_loss, dist_entropy = model.update(model.rollouts)
model.rollouts.after_update()
if frame_idx % 100 == 0:
try:
clear_output()
end = timer()
total_num_steps = (frame_idx + 1) * config.num_agents * config.rollout
#df = pd.DataFrame({'frame': frame_idx, 'timesteps': total_num_steps, 'fps': int(total_num_steps / (end - start)),
# 'mean reward': np.mean(final_rewards), 'median reward': np.median(final_rewards),
# 'min reward': np.min(final_rewards), 'max rewards': np.max(final_rewards),
# 'entropy': dist_entropy, 'value loss': value_loss, 'action loss': action_loss})
#if not os.path.isfile('./log/A2C/logs.csv'):
# df.to_csv('./log/A2C/logs.csv', header='column_names')
#else:
# df.to_csv('./log/A2C/logs.csv', mode='a', header=False)
#with open("./log/A2C/logs.txt", "a") as myfile:
# myfile.write(
# "Frame {}, Num Timesteps {}, FPS {},"
# "Mean/Median Reward {:.1f}/{:.1f}, Min/Max Reward {:.1f}/{:.1f},"
# "Entropy {:.5f}, Value Loss {:.5f}, Policy Loss {:.5f}".
# format(frame_idx, total_num_steps,
# int(total_num_steps / (end - start)),
# np.mean(final_rewards),
# np.median(final_rewards),
# np.min(final_rewards),
# np.max(final_rewards), dist_entropy,
# value_loss, action_loss))
plot(log_dir, env_id, 'A2C',
config.MAX_FRAMES * config.num_agents * config.rollout)
dtime = int(timer() - start)
plot_gpu(log_dir, env_id, 'A2C', config.MAX_FRAMES * config.num_agents * config.rollout, bin_size=10,
smooth=1, time=timedelta(seconds=dtime))
except IOError:
pass
model.save_w()
envs.close()
return
# print(type(epsilon))
action = model.get_action(observation, epsilon)
prev_observation = observation
observation, reward, done, _ = env.step(action)
observation = None if done else observation
model.update(prev_observation, action, reward, observation, frame_idx)
episode_reward += reward
if done:
model.finish_nstep()
observation = env.reset()
model.save_reward(episode_reward)
episode_reward = 0
if np.mean(model.rewards[-10:]) > 20:
plot(frame_idx, model.rewards, model.losses,
model.sigma_parameter_mag,
timedelta(seconds=int(timer() - start)))
save_plot(frame_idx,
model.rewards,
model.losses,
model.sigma_parameter_mag,
timedelta(seconds=int(timer() - start)),
nstep=model.nsteps,
name=agent_name)
log_content = "达到20提前结束，结束轮次," + str(frame_idx)
print(log_content)
with open(log_file, "a", encoding='utf-8') as lf:
lf.write(log_content + "\n")
lf.close()
break
def main():
parser = argparse.ArgumentParser(description='Eye Picture Classification Training With PyTorch')
parser.add_argument('--resume_model',
default='/mnt/data/qyx_data/torch/saveModel/Eye_resnet18_test.pth',
type=str,
help='Checkpoint state_dict file to resume training from')
parser.add_argument('--resume',
default=None,
type=str,
help='Checkpoint state_dict file to resume training from')
parser.add_argument('--model',default='resnet18',type=str,help='the train model')
parser.add_argument('--start_epoch', default=0, type=int,help='the start epoch of training')
parser.add_argument('--max_epoch', default=5, type=int, help='the epoch to end training')
args = parser.parse_args()
root=cfg.IMGROOT
val_root=cfg.VALROOT
if args.model == 'resnet18':
model = models.resnet18(pretrained=True)
model.conv1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=3, bias=False)
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, 7)
elif args.model == 'vgg16':
model = make_model('vgg16_bn',num_classes=7,pretrained=True,input_size = (224,224))
elif args.model =='alexnet':
model = make_model('alexnet',num_classes=7,pretrained=True,input_size = (224,224))
elif args.model =='inception_v3':
model = make_model('inception_v3',num_classes=7,pretrained=True,input_size = (224,224))
elif args.model =='inceptionresnetv2':
model = make_model('inceptionresnetv2',num_classes=7,pretrained=True,input_size = (224,224))
elif args.model =='googlenet':
model = make_model('googlenet',num_classes=7,pretrained=True,input_size = (224,224))
elif args.model =='densenet121':
model = make_model('densenet121',num_classes=7,pretrained=True,input_size = (224,224))
device = t.device("cuda" if t.cuda.is_available() else "cpu")
logger = logging.getLogger("Eye")
logger.setLevel(logging.DEBUG)
fileHanlder = logging.FileHandler('Eye_'+args.model+'.log')
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fileHanlder.setFormatter(formatter)
logger.addHandler(fileHanlder)
logger.info('Train Dataset uploaded!')
logger.info('device:{}'.format(device))
plot_util=plot()
loss_list=[]
train_acc=[]
epoch_list=[]
val_acc=[]
critertion=t.nn.CrossEntropyLoss()
#critertion=FocalLossV1()
optimizer=t.optim.Adam(model.parameters(),lr=lr, weight_decay=cfg.WEIGHT_DECAY)
model = nn.DataParallel(model)
model = model.to(device)
summary(model,(3,cfg.IMAGE_SIZE,cfg.IMAGE_SIZE),batch_size=cfg.BATCHSIZE)
# logger.info("Resume from the model {}".format(args.resume_model))
# model.load_state_dict(t.load(args.resume_model))
model.train()
k_model= []
for i in range(cfg.K):
k_model.append(model)
loss_meter = meter.AverageValueMeter()
confusion_matrix = meter.ConfusionMeter(7)
loss_meter.reset()
confusion_matrix.reset()
for epoch in range(args.start_epoch,args.max_epoch):
k_model = k_fold(logger,cfg.K,root,val_root,epoch,args,critertion,optimizer,k_model,device,loss_meter,confusion_matrix,train_acc,loss_list,val_acc)
epoch_list.append(epoch)
#调节学习率
if epoch_list[-1] in lr_step:
step_index = lr_step.index(epoch_list[-1]) + 1
adjust_learning_rate(optimizer, cfg.GAMMA, step_index)
#plot
plot_util.plot_cm_matrix(confusion_matrix,savepath='/mnt/data/qyx_data/torch/'+args.model+' cm_matrix.png')
plot_util.plot_accuracy(savepath='/mnt/data/qyx_data/torch/'+args.model+' train_acc.png',epoch=epoch_list,train_accuracy=train_acc,val_accuracy=val_acc)
plot_util.plot_loss(savepath='/mnt/data/qyx_data/torch/'+args.model+' train_loss.png',iters=epoch_list,loss=loss_list,title='train_loss')
