def test_swallowing_exception(self):
with TemporaryDirectory() as tmp_dir:
writer = SummaryWriter(tmp_dir)
writer.add_scalar = MagicMock(side_effect=NotImplementedError("test"))
writer.exceptions_to_ignore = (NotImplementedError, KeyError)
with summary_writer_context(writer):
SummaryWriterContext.add_scalar("test", torch.ones(1))
class TensorBoardReporting(ReportingHook):
"""Log results to tensorboard.
Writes tensorboard logs to a directory specified in the `mead-settings`
section for tensorboard. Otherwise it defaults to `runs`.
"""
def __init__(self, **kwargs):
super(TensorBoardReporting, self).__init__(**kwargs)
from tensorboardX import SummaryWriter
# Base dir is often the dir created to save the model into
base_dir = kwargs.get('base_dir', '.')
log_dir = os.path.expanduser(kwargs.get('log_dir', 'runs'))
if not os.path.isabs(log_dir):
log_dir = os.path.join(base_dir, log_dir)
# Run dir is the name of an individual run
run_dir = kwargs.get('run_dir')
pid = str(os.getpid())
run_dir = '{}-{}'.format(run_dir, pid) if run_dir is not None else pid
log_dir = os.path.join(log_dir, run_dir)
flush_secs = int(kwargs.get('flush_secs', 2))
self._log = SummaryWriter(log_dir, flush_secs=flush_secs)
def step(self, metrics, tick, phase, tick_type=None, **kwargs):
tick_type = ReportingHook._infer_tick_type(phase, tick_type)
for metric in metrics.keys():
name = "{}/{}/{}".format(phase, tick_type, metric)
self._log.add_scalar(name, metrics[metric], tick)
def __init__(self, log_dir, params, up_factor):
"""
Args:
log_dir: (str) The path to the folder where the summary files are
going to be written. The summary object creates a train and a
val folders to store the summary files.
params: (train.utils.Params) The parameters loaded from the
parameters.json file.
up_factor: (int) The upscale factor that indicates how much the
scores maps need to be upscaled to match the original scale
(used when superposing the embeddings and score maps to the
input images).
Attributes:
writer_train: (tensorboardX.writer.SummaryWriter) The tensorboardX
writer that writes the training informations.
writer_val: (tensorboardX.writer.SummaryWriter) The tensorboardX
writer that writes the validation informations.
epoch: (int) Stores the current epoch.
ref_sz: (int) The size in pixels of the reference image.
srch_sz: (int) The size in pixels of the search image.
up_factor: (int) The upscale factor. See Args.
"""
# We use two different summary writers so we can plot both curves in
# the same plot, as suggested in https://www.quora.com/How-do-you-plot-training-and-validation-loss-on-the-same-graph-using-TensorFlow%E2%80%99s-TensorBoard
self.writer_train = SummaryWriter(join(log_dir, 'train'))
self.writer_val = SummaryWriter(join(log_dir, 'val'))
self.epoch = None
self.ref_sz = params.reference_sz
self.srch_sz = params.search_sz
self.up_factor = up_factor
def test_add_custom_scalars(self):
with TemporaryDirectory() as tmp_dir:
writer = SummaryWriter(tmp_dir)
writer.add_custom_scalars = MagicMock()
with summary_writer_context(writer):
SummaryWriterContext.add_custom_scalars_multilinechart(
["a", "b"], category="cat", title="title"
)
with self.assertRaisesRegexp(
AssertionError, "Title \(title\) is already in category \(cat\)"
):
SummaryWriterContext.add_custom_scalars_multilinechart(
["c", "d"], category="cat", title="title"
)
SummaryWriterContext.add_custom_scalars_multilinechart(
["e", "f"], category="cat", title="title2"
)
SummaryWriterContext.add_custom_scalars_multilinechart(
["g", "h"], category="cat2", title="title"
)
SummaryWriterContext.add_custom_scalars(writer)
writer.add_custom_scalars.assert_called_once_with(
{
"cat": {
"title": ["Multiline", ["a", "b"]],
"title2": ["Multiline", ["e", "f"]],
},
"cat2": {"title": ["Multiline", ["g", "h"]]},
}
)
def test_not_swallowing_exception(self):
with TemporaryDirectory() as tmp_dir:
writer = SummaryWriter(tmp_dir)
writer.add_scalar = MagicMock(side_effect=NotImplementedError("test"))
with self.assertRaisesRegexp(
NotImplementedError, "test"
), summary_writer_context(writer):
SummaryWriterContext.add_scalar("test", torch.ones(1))
def test_writing(self):
with TemporaryDirectory() as tmp_dir:
writer = SummaryWriter(tmp_dir)
writer.add_scalar = MagicMock()
with summary_writer_context(writer):
SummaryWriterContext.add_scalar("test", torch.ones(1))
writer.add_scalar.assert_called_once_with(
"test", torch.ones(1), global_step=0
)
def log_to_tensorboard(self, writer: SummaryWriter, epoch: int) -> None:
def none_to_zero(x: Optional[float]) -> float:
if x is None or math.isnan(x):
return 0.0
return x
for name, value in [
("Training/td_loss", self.get_recent_td_loss()),
("Training/reward_loss", self.get_recent_reward_loss()),
]:
writer.add_scalar(name, none_to_zero(value), epoch)
def one_stage_train(myModel, data_reader_trn, my_optimizer,
loss_criterion, snapshot_dir, log_dir,
i_iter, start_epoch, best_val_accuracy=0, data_reader_eval=None,
scheduler=None):
report_interval = cfg.training_parameters.report_interval
snapshot_interval = cfg.training_parameters.snapshot_interval
max_iter = cfg.training_parameters.max_iter
avg_accuracy = 0
accuracy_decay = 0.99
best_epoch = 0
writer = SummaryWriter(log_dir)
best_iter = i_iter
iepoch = start_epoch
snapshot_timer = Timer('m')
report_timer = Timer('s')
while i_iter < max_iter:
iepoch += 1
for i, batch in enumerate(data_reader_trn):
i_iter += 1
if i_iter > max_iter:
break
scheduler.step(i_iter)
my_optimizer.zero_grad()
add_graph = False
scores, total_loss, n_sample = compute_a_batch(batch, myModel, eval_mode=False,
loss_criterion=loss_criterion,
add_graph=add_graph, log_dir=log_dir)
total_loss.backward()
accuracy = scores / n_sample
avg_accuracy += (1 - accuracy_decay) * (accuracy - avg_accuracy)
clip_gradients(myModel, i_iter, writer)
my_optimizer.step()
if i_iter % report_interval == 0:
save_a_report(i_iter, total_loss.data[0], accuracy, avg_accuracy, report_timer,
writer, data_reader_eval,myModel, loss_criterion)
if i_iter % snapshot_interval == 0 or i_iter == max_iter:
best_val_accuracy, best_epoch, best_iter = save_a_snapshot(snapshot_dir, i_iter, iepoch, myModel,
my_optimizer, loss_criterion, best_val_accuracy,
best_epoch, best_iter, snapshot_timer,
data_reader_eval)
writer.export_scalars_to_json(os.path.join(log_dir, "all_scalars.json"))
writer.close()
print("best_acc:%.6f after epoch: %d/%d at iter %d" % (best_val_accuracy, best_epoch, iepoch, best_iter))
sys.stdout.flush()
class TBVisualizer:
def __init__(self, opt):
self._opt = opt
self._save_path = os.path.join(opt.checkpoints_dir, opt.name)
self._log_path = os.path.join(self._save_path, 'loss_log2.txt')
self._tb_path = os.path.join(self._save_path, 'summary.json')
self._writer = SummaryWriter(self._save_path)
with open(self._log_path, "a") as log_file:
now = time.strftime("%c")
log_file.write('================ Training Loss (%s) ================\n' % now)
def __del__(self):
self._writer.close()
def display_current_results(self, visuals, it, is_train, save_visuals=False):
for label, image_numpy in visuals.items():
sum_name = '{}/{}'.format('Train' if is_train else 'Test', label)
self._writer.add_image(sum_name, image_numpy, it)
if save_visuals:
util.save_image(image_numpy,
os.path.join(self._opt.checkpoints_dir, self._opt.name,
'event_imgs', sum_name, '%08d.png' % it))
self._writer.export_scalars_to_json(self._tb_path)
def plot_scalars(self, scalars, it, is_train):
for label, scalar in scalars.items():
sum_name = '{}/{}'.format('Train' if is_train else 'Test', label)
self._writer.add_scalar(sum_name, scalar, it)
def print_current_train_errors(self, epoch, i, iters_per_epoch, errors, t, visuals_were_stored):
log_time = time.strftime("[%d/%m/%Y %H:%M:%S]")
visuals_info = "v" if visuals_were_stored else ""
message = '%s (T%s, epoch: %d, it: %d/%d, t/smpl: %.3fs) ' % (log_time, visuals_info, epoch, i, iters_per_epoch, t)
for k, v in errors.items():
message += '%s:%.3f ' % (k, v)
print(message)
with open(self._log_path, "a") as log_file:
log_file.write('%s\n' % message)
def print_current_validate_errors(self, epoch, errors, t):
log_time = time.strftime("[%d/%m/%Y %H:%M:%S]")
message = '%s (V, epoch: %d, time_to_val: %ds) ' % (log_time, epoch, t)
for k, v in errors.items():
message += '%s:%.3f ' % (k, v)
print(message)
with open(self._log_path, "a") as log_file:
log_file.write('%s\n' % message)
def save_images(self, visuals):
for label, image_numpy in visuals.items():
image_name = '%s.png' % label
save_path = os.path.join(self._save_path, "samples", image_name)
util.save_image(image_numpy, save_path)
def test_global_step(self):
with TemporaryDirectory() as tmp_dir:
writer = SummaryWriter(tmp_dir)
writer.add_scalar = MagicMock()
with summary_writer_context(writer):
SummaryWriterContext.add_scalar("test", torch.ones(1))
SummaryWriterContext.increase_global_step()
SummaryWriterContext.add_scalar("test", torch.zeros(1))
writer.add_scalar.assert_has_calls(
[
call("test", torch.ones(1), global_step=0),
call("test", torch.zeros(1), global_step=1),
]
)
self.assertEqual(2, len(writer.add_scalar.mock_calls))
def setup(self):
"""Setups TensorBoard logger."""
def replace_loggers():
# Replace all log_* methods with dummy _nop
self.log_metrics = self._nop
self.log_scalar = self._nop
self.log_activations = self._nop
self.log_gradients = self._nop
# No log_dir given, bail out
if not self.log_dir:
replace_loggers()
return
# Detect tensorboard
try:
from tensorboardX import SummaryWriter
except ImportError as ie:
replace_loggers()
return
else:
self.available = True
# Construct full folder path
self.log_dir = pathlib.Path(self.log_dir).expanduser()
self.log_dir = self.log_dir / self.subfolder / self.exp_id
self.log_dir.mkdir(parents=True, exist_ok=True)
# Set up summary writer
self.writer = SummaryWriter(self.log_dir)
def test_writing_stack(self):
with TemporaryDirectory() as tmp_dir1, TemporaryDirectory() as tmp_dir2:
writer1 = SummaryWriter(tmp_dir1)
writer1.add_scalar = MagicMock()
writer2 = SummaryWriter(tmp_dir2)
writer2.add_scalar = MagicMock()
with summary_writer_context(writer1):
with summary_writer_context(writer2):
SummaryWriterContext.add_scalar("test2", torch.ones(1))
SummaryWriterContext.add_scalar("test1", torch.zeros(1))
writer1.add_scalar.assert_called_once_with(
"test1", torch.zeros(1), global_step=0
)
writer2.add_scalar.assert_called_once_with(
"test2", torch.ones(1), global_step=0
)
def __init__(self, opt):
self.opt = opt
print('> training arguments:')
for arg in vars(opt):
print('>>> {0}: {1}'.format(arg, getattr(opt, arg)))
# >>> model_name: lstm
# >>> dataset: twitter
# >>> optimizer: <class 'torch.optim.adam.Adam'>
# >>> initializer: <function xavier_uniform_ at 0x10858b510>
# >>> learning_rate: 0.001
# >>> dropout: 0
# >>> num_epoch: 20
# >>> batch_size: 128
# >>> log_step: 5
# >>> logdir: tmp_log
# >>> embed_dim: 100
# >>> hidden_dim: 200
# >>> max_seq_len: 80
# >>> polarities_dim: 3
# >>> hops: 3
# >>> device: cpu
# >>> model_class: <class 'models.lstm.LSTM'>
# >>> inputs_cols: ['text_raw_indices']
absa_dataset = ABSADatesetReader(dataset=opt.dataset, embed_dim=opt.embed_dim, max_seq_len=opt.max_seq_len)
self.train_data_loader = DataLoader(dataset=absa_dataset.train_data, batch_size=opt.batch_size, shuffle=True)
self.test_data_loader = DataLoader(dataset=absa_dataset.test_data, batch_size=len(absa_dataset.test_data), shuffle=False)
self.writer = SummaryWriter(log_dir=opt.logdir)
self.model = opt.model_class(absa_dataset.embedding_matrix, opt).to(opt.device) # 这里的 embedding_matrix 只存了索引对应的 vector, 没有存字典
self.reset_parameters()
class TensorBoard(Callback):
# TODO: add option to write images; find fix for graph
def __init__(self, log_dir, update_frequency = 10):
super(Callback, self).__init__()
self.log_dir = log_dir
self.writer = None
self.update_frequency = update_frequency
def on_train_begin(self, **_):
self.writer = SummaryWriter(os.path.join(self.log_dir, datetime.datetime.now().__str__()))
rndm_input = torch.autograd.Variable(torch.rand(1, *self.model.input_shape), requires_grad = True).to(self.logger['device'])
# fwd_pass = self.model(rndm_input)
self.writer.add_graph(self.model, rndm_input)
return self
def on_epoch_end(self, **_):
if (self.logger['epoch'] % self.update_frequency) == 0:
epoch_metrics = self.logger['epoch_metrics'][self.logger['epoch']]
for e_metric, e_metric_dct in epoch_metrics.iteritems():
for e_metric_split, e_metric_val in e_metric_dct.iteritems():
self.writer.add_scalar('{}/{}'.format(e_metric_split, e_metric), e_metric_val, self.logger['epoch'])
for name, param in self.model.named_parameters():
self.writer.add_histogram(name.replace('.', '/'), param.clone().cpu().data.numpy(), self.logger['epoch'])
return self
def on_train_end(self, **_):
return self.writer.close()
def __init__(self, log_file_dir=None):
self.counter = 0
self.epi_counter = 0
self.step_counter = 0
self.u_stats = dict()
self.path_info = defaultdict(list)
self.extra_info = dict()
self.scores = []
self.tstart = time.time()
self.writer = SummaryWriter(log_file_dir)
def run(self):
self.writer = SummaryWriter(os.path.join(self.env.model_dir, self.env.args.run))
while True:
name, kwargs = self.queue.get()
if name is None:
break
func = getattr(self, 'summary_' + name)
try:
func(**kwargs)
except:
traceback.print_exc()
def __init__(self, learn:Learner, base_dir:Path, name:str, loss_iters:int=25, hist_iters:int=500, stats_iters:int=100):
super().__init__(learn=learn)
self.base_dir,self.name,self.loss_iters,self.hist_iters,self.stats_iters = base_dir,name,loss_iters,hist_iters,stats_iters
log_dir = base_dir/name
self.tbwriter = SummaryWriter(log_dir=str(log_dir))
self.hist_writer = HistogramTBWriter()
self.stats_writer = ModelStatsTBWriter()
self.graph_writer = GraphTBWriter()
self.data = None
self.metrics_root = '/metrics/'
self._update_batches_if_needed()
def __init__(self, gpu='0'):
# Device configuration
self.__device = torch.device('cuda:'+gpu if torch.cuda.is_available() else 'cpu')
self.__writer = SummaryWriter('logs')
self.__model = CNNDriver()
# Set model to train mode
self.__model.train()
print(self.__model)
self.__writer.add_graph(self.__model, torch.rand(10, 3, 66, 200))
# Put model on GPU
self.__model = self.__model.to(self.__device)
def __init__(self, opt):
self._opt = opt
self._save_path = os.path.join(opt.checkpoints_dir, opt.name)
self._log_path = os.path.join(self._save_path, 'loss_log2.txt')
self._tb_path = os.path.join(self._save_path, 'summary.json')
self._writer = SummaryWriter(self._save_path)
with open(self._log_path, "a") as log_file:
now = time.strftime("%c")
log_file.write('================ Training Loss (%s) ================\n' % now)
def log_to_tensorboard(self, writer: SummaryWriter, epoch: int) -> None:
def none_to_zero(x: Optional[float]) -> float:
if x is None or math.isnan(x):
return 0.0
return x
for name, value in [
("Reward_CPE/Direct Method Reward", self.direct_method.normalized),
("Reward_CPE/IPS Reward", self.inverse_propensity.normalized),
("Reward_CPE/Doubly Robust Reward", self.doubly_robust.normalized),
(
"Value_CPE/Sequential Doubly Robust",
self.sequential_doubly_robust.normalized,
),
(
"Value_CPE/Weighted Doubly Robust",
self.weighted_doubly_robust.normalized,
),
("Value_CPE/MAGIC Estimator", self.magic.normalized),
]:
writer.add_scalar(name, none_to_zero(value), epoch)
def train(self, epoch_to_restore=0):
g = Generator(self.nb_channels_first_layer, self.dim)
if epoch_to_restore > 0:
filename_model = os.path.join(self.dir_models, 'epoch_{}.pth'.format(epoch_to_restore))
g.load_state_dict(torch.load(filename_model))
else:
g.apply(weights_init)
g.cuda()
g.train()
dataset = EmbeddingsImagesDataset(self.dir_z_train, self.dir_x_train)
dataloader = DataLoader(dataset, self.batch_size, shuffle=True, num_workers=4, pin_memory=True)
fixed_dataloader = DataLoader(dataset, 16)
fixed_batch = next(iter(fixed_dataloader))
criterion = torch.nn.L1Loss()
optimizer = optim.Adam(g.parameters())
writer = SummaryWriter(self.dir_logs)
try:
epoch = epoch_to_restore
while True:
g.train()
for _ in range(self.nb_epochs_to_save):
epoch += 1
for idx_batch, current_batch in enumerate(tqdm(dataloader)):
g.zero_grad()
x = Variable(current_batch['x']).type(torch.FloatTensor).cuda()
z = Variable(current_batch['z']).type(torch.FloatTensor).cuda()
g_z = g.forward(z)
loss = criterion(g_z, x)
loss.backward()
optimizer.step()
writer.add_scalar('train_loss', loss, epoch)
z = Variable(fixed_batch['z']).type(torch.FloatTensor).cuda()
g.eval()
g_z = g.forward(z)
images = make_grid(g_z.data[:16], nrow=4, normalize=True)
writer.add_image('generations', images, epoch)
filename = os.path.join(self.dir_models, 'epoch_{}.pth'.format(epoch))
torch.save(g.state_dict(), filename)
finally:
print('[*] Closing Writer.')
writer.close()
def __init__(self, **kwargs):
super(TensorBoardReporting, self).__init__(**kwargs)
from tensorboardX import SummaryWriter
# Base dir is often the dir created to save the model into
base_dir = kwargs.get('base_dir', '.')
log_dir = os.path.expanduser(kwargs.get('log_dir', 'runs'))
if not os.path.isabs(log_dir):
log_dir = os.path.join(base_dir, log_dir)
# Run dir is the name of an individual run
run_dir = kwargs.get('run_dir')
pid = str(os.getpid())
run_dir = '{}-{}'.format(run_dir, pid) if run_dir is not None else pid
log_dir = os.path.join(log_dir, run_dir)
flush_secs = int(kwargs.get('flush_secs', 2))
self._log = SummaryWriter(log_dir, flush_secs=flush_secs)
class TensorBoard(Callback):
def __init__(self, logdir):
super().__init__()
self.logdir = logdir
self.writer = None
def on_train_begin(self):
os.makedirs(self.logdir, exist_ok=True)
self.writer = SummaryWriter(self.logdir)
def on_epoch_end(self, epoch):
for k, v in self.metrics_collection.train_metrics.items():
self.writer.add_scalar('train/{}'.format(k), float(v), global_step=epoch)
for k, v in self.metrics_collection.val_metrics.items():
self.writer.add_scalar('val/{}'.format(k), float(v), global_step=epoch)
for idx, param_group in enumerate(self.estimator.optimizer.param_groups):
lr = param_group['lr']
self.writer.add_scalar('group{}/lr'.format(idx), float(lr), global_step=epoch)
def on_train_end(self):
self.writer.close()
def __init__(self, config):
self.config = config
self.logger = logging.getLogger("STGAN")
self.logger.info("Creating STGAN architecture...")
self.G = Generator(len(self.config.attrs), self.config.g_conv_dim, self.config.g_layers, self.config.shortcut_layers, use_stu=self.config.use_stu, one_more_conv=self.config.one_more_conv)
self.D = Discriminator(self.config.image_size, len(self.config.attrs), self.config.d_conv_dim, self.config.d_fc_dim, self.config.d_layers)
self.data_loader = globals()['{}_loader'.format(self.config.dataset)](
self.config.data_root, self.config.mode, self.config.attrs,
self.config.crop_size, self.config.image_size, self.config.batch_size)
self.current_iteration = 0
self.cuda = torch.cuda.is_available() & self.config.cuda
if self.cuda:
self.device = torch.device("cuda")
self.logger.info("Operation will be on *****GPU-CUDA***** ")
print_cuda_statistics()
else:
self.device = torch.device("cpu")
self.logger.info("Operation will be on *****CPU***** ")
self.writer = SummaryWriter(log_dir=self.config.summary_dir)
train_obs_v = torch.FloatTensor(train_obs)
train_act_v = torch.LongTensor(train_act)
return train_obs_v, train_act_v, reward_bound, reward_mean
if __name__ == "__main__":
env = DiscreteOneHotWrapper(gym.make("FrozenLake-v0"))
# env = gym.wrappers.Monitor(env, directory="mon", force=True)
obs_size = env.observation_space.shape[0]
n_actions = env.action_space.n
net = Net(obs_size, HIDDEN_SIZE, n_actions)
objective = nn.CrossEntropyLoss()
optimizer = optim.Adam(params=net.parameters(), lr=0.01)
writer = SummaryWriter(comment="-frozenlake-naive")
for iter_no, batch in enumerate(iterate_batches(env, net, BATCH_SIZE)):
obs_v, acts_v, reward_b, reward_m = filter_batch(batch, PERCENTILE)
optimizer.zero_grad()
action_scores_v = net(obs_v)
loss_v = objective(action_scores_v, acts_v)
loss_v.backward()
optimizer.step()
print("%d: loss=%.3f, reward_mean=%.1f, reward_bound=%.1f" %
(iter_no, loss_v.item(), reward_m, reward_b))
writer.add_scalar("loss", loss_v.item(), iter_no)
writer.add_scalar("reward_bound", reward_b, iter_no)
writer.add_scalar("reward_mean", reward_m, iter_no)
if reward_m > 0.8:
print("Solved!")
def get_pnp_solver():
from inference.detector import CuboidPNPSolver
from inference.cuboid import Cuboid3d
from shared_code import load_params, get_config_options
params = load_params()
matrix_camera, dist_coeffs, config_detect = get_config_options(params)
for model in params['weights']:
pnp_solver = CuboidPNPSolver(model, matrix_camera, Cuboid3d(params['dimensions'][model]), dist_coeffs=dist_coeffs)
return pnp_solver, config_detect
writer = SummaryWriter()
pnp_solver, config = get_pnp_solver()
for epoch in range(1, opt.epochs + 1):
if not trainingdata is None:
_runnetwork(epoch, trainingdata, True, writer, pnp_solver, config)
if not opt.datatest == "":
_runnetwork(epoch, testingdata, False, writer, pnp_solver, config)
if opt.data == "":
break # lets get out of this if we are only testing
try:
torch.save(net.state_dict(), '{}/net_{}_{}.pth'.format(opt.outf, opt.namefile, epoch))
except:
pass
def main(args):
# initialization
print("Input arguments:")
for key, val in vars(args).items():
print("{:16} {}".format(key, val))
if not os.path.exists(args.snapshot_dir):
os.makedirs(args.snapshot_dir)
writer = SummaryWriter(logdir=os.path.join(args.log_dir, args.method))
random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.enabled = True
cudnn.benchmark = True
# conduct seg network
seg_model = get_model(num_classes=args.num_classes)
saved_state_dict = torch.load(args.restore_from)
new_params = seg_model.state_dict().copy()
if args.init:
for i in saved_state_dict:
i_parts = i.split('.')
if not i_parts[0] == 'fc':
new_params['encoder.' + '.'.join(i_parts[:])] = saved_state_dict[i]
seg_model.load_state_dict(new_params)
print('loading params w/o fc')
else:
seg_model.load_state_dict(saved_state_dict)
print('loading params all')
model = DataParallelModel(seg_model)
model.float()
model.cuda()
# define dataloader
train_loader = data.DataLoader(DataGenerator(root=args.root, list_path=args.lst,
crop_size=args.crop_size, training=True),
batch_size=args.batch_size, shuffle=True, num_workers=4, pin_memory=True)
val_loader = data.DataLoader(DataGenerator(root=args.val_root, list_path=args.val_lst,
crop_size=args.crop_size, training=False),
batch_size=args.batch_size, shuffle=False, num_workers=4, pin_memory=True)
# define criterion & optimizer
criterion = ABRLovaszLoss(ignore_index=args.ignore_label, only_present=True, cls_p=args.num_classes, cls_h=args.hbody_cls, cls_f=args.fbody_cls)
criterion = DataParallelCriterion(criterion).cuda()
optimizer = optim.SGD(
[{'params': filter(lambda p: p.requires_grad, seg_model.parameters()), 'lr': args.learning_rate}],
lr=args.learning_rate, momentum=0.9, weight_decay=5e-4)
# key points
best_val_mIoU = 0
best_val_pixAcc = 0
start = time.time()
for epoch in range(0, args.epochs):
print('\n{} | {}'.format(epoch, args.epochs - 1))
# training
_ = train(model, train_loader, epoch, criterion, optimizer, writer)
# validation
if epoch %10 ==0 or epoch > args.epochs*0.8:
val_pixacc, val_miou = validation(model, val_loader, epoch, writer)
# save model
if val_pixacc > best_val_pixAcc:
best_val_pixAcc = val_pixacc
if val_miou > best_val_mIoU:
best_val_mIoU = val_miou
model_dir = os.path.join(args.snapshot_dir, args.method + '_miou.pth')
torch.save(seg_model.state_dict(), model_dir)
print('Model saved to %s' % model_dir)
os.rename(model_dir, os.path.join(args.snapshot_dir, args.method + '_miou'+str(best_val_mIoU)+'.pth'))
print('Complete using', time.time() - start, 'seconds')
print('Best pixAcc: {} | Best mIoU: {}'.format(best_val_pixAcc, best_val_mIoU))
def start(self):
self.writer = SummaryWriter(logdir=self.log_path)
def train(epoch_num,
model,
train_dataloader,
dev_dataloader,
optimizer,
criterion,
label_list,
out_model_file,
log_dir,
print_step,
data_type='word'):
model.train()
writer = SummaryWriter(log_dir=log_dir + '/' +
time.strftime('%H:%M:%S', time.gmtime()))
global_step = 0
best_dev_loss = float('inf')
for epoch in range(int(epoch_num)):
print(f'---------------- Epoch: {epoch+1:02} ----------')
epoch_loss = 0
train_steps = 0
all_preds = np.array([], dtype=int)
all_labels = np.array([], dtype=int)
for step, batch in enumerate(tqdm(train_dataloader, desc="Iteration")):
optimizer.zero_grad()
if data_type == 'word':
logits = model(batch.text)
elif data_type == 'highway':
logits = model(batch.text_word, batch.text_char)
loss = criterion(logits.view(-1, len(label_list)), batch.label)
labels = batch.label.detach().cpu().numpy()
preds = np.argmax(logits.detach().cpu().numpy(), axis=1)
loss.backward()
optimizer.step()
global_step += 1
epoch_loss += loss.item()
train_steps += 1
all_preds = np.append(all_preds, preds)
all_labels = np.append(all_labels, labels)
if global_step % print_step == 0:
train_loss = epoch_loss / train_steps
train_acc, train_report = classifiction_metric(
all_preds, all_labels, label_list)
dev_loss, dev_acc, dev_report = evaluate(
model, dev_dataloader, criterion, label_list, data_type)
c = global_step // print_step
writer.add_scalar("loss/train", train_loss, c)
writer.add_scalar("loss/dev", dev_loss, c)
writer.add_scalar("acc/train", train_acc, c)
writer.add_scalar("acc/dev", dev_acc, c)
for label in label_list:
writer.add_scalar(label + ":" + "f1/train",
train_report[label]['f1-score'], c)
writer.add_scalar(label + ":" + "f1/dev",
dev_report[label]['f1-score'], c)
print_list = ['macro avg', 'weighted avg']
for label in print_list:
writer.add_scalar(label + ":" + "f1/train",
train_report[label]['f1-score'], c)
writer.add_scalar(label + ":" + "f1/dev",
dev_report[label]['f1-score'], c)
if dev_loss < best_dev_loss:
best_dev_loss = dev_loss
torch.save(model.state_dict(), out_model_file)
model.train()
writer.close()
def initialize_and_train(task_config, trainset, augmentset, validset, testset,
uset, uset_aug, hp, run_tag):
"""The train process.
Args:
task_config (dictionary): the configuration of the task
trainset (SnippextDataset): the training set
augmentset (SnippextDataset): the augmented training set
validset (SnippextDataset): the validation set
testset (SnippextDataset): the testset
uset (SnippextDataset): the unlabeled dataset
uset_aug (SnippextDataset): the unlabeled dataset, augmented
hp (Namespace): the parsed hyperparameters
run_tag (string): the tag of the run (for logging purpose)
Returns:
None
"""
padder = SnippextDataset.pad
# iterators for dev/test set
valid_iter = data.DataLoader(dataset=validset,
batch_size=hp.batch_size * 4,
shuffle=False,
num_workers=0,
collate_fn=padder)
test_iter = data.DataLoader(dataset=testset,
batch_size=hp.batch_size * 4,
shuffle=False,
num_workers=0,
collate_fn=padder)
# initialize model
device = 'cuda' if torch.cuda.is_available() else 'cpu'
if device == 'cpu':
model = MultiTaskNet([task_config],
device,
hp.finetuning,
bert_path=hp.bert_path)
optimizer = AdamW(model.parameters(), lr=hp.lr)
else:
model = MultiTaskNet([task_config],
device,
hp.finetuning,
bert_path=hp.bert_path).cuda()
optimizer = AdamW(model.parameters(), lr=hp.lr)
model, optimizer = amp.initialize(model, optimizer, opt_level='O2')
# learning rate scheduler
num_steps = (len(trainset) // hp.batch_size * 2) * hp.n_epochs
scheduler = get_linear_schedule_with_warmup(optimizer,
num_warmup_steps=num_steps //
10,
num_training_steps=num_steps)
# create logging
if not os.path.exists(hp.logdir):
os.makedirs(hp.logdir)
writer = SummaryWriter(log_dir=hp.logdir)
# start training
best_dev_f1 = best_test_f1 = 0.0
for epoch in range(1, hp.n_epochs + 1):
train(model,
trainset,
augmentset,
uset,
uset_aug,
optimizer,
scheduler=scheduler,
batch_size=hp.batch_size,
num_aug=hp.num_aug,
alpha=hp.alpha,
alpha_aug=hp.alpha_aug,
u_lambda=hp.u_lambda,
fp16=hp.fp16)
print(f"=========eval at epoch={epoch}=========")
dev_f1, test_f1 = eval_on_task(epoch, model, task_config['name'],
valid_iter, validset, test_iter,
testset, writer, run_tag)
if hp.save_model:
if dev_f1 > best_dev_f1:
best_dev_f1 = dev_f1
torch.save(model.state_dict(), run_tag + '_dev.pt')
if test_f1 > best_test_f1:
best_test_f1 = test_f1
torch.save(model.state_dict(), run_tag + '_test.pt')
writer.close()
class DQN(object):
# 每次把一个任务分配给一个虚拟机
def __init__(self, task_dim, vms, vm_dim):
self.task_dim = task_dim # 任务维度
self.vms = vms # 虚拟机数量
self.vm_dim = vm_dim # 虚拟机维度
self.s_task_dim = self.task_dim # 任务状态维度
self.s_vm_dim = self.vms * self.vm_dim # 虚拟机状态维度
self.a_dim = self.vms # 动作空间：虚拟机的个数
self.lr = 0.003 # learning rate
self.batch_size = 32 # 128
self.epsilon = 0.95
self.epsilon_decay = 0.997
self.epsilon_min = 0.1
self.step = 0
self.eval_net = QNet_v1(self.s_task_dim, self.s_vm_dim, self.a_dim)
self.eval_net.apply(self.weights_init)
self.target_net = QNet_v1(self.s_task_dim, self.s_vm_dim, self.a_dim)
self.optimizer = torch.optim.Adam(self.eval_net.parameters(),
lr=self.lr)
self.hard_update(self.target_net, self.eval_net) # 初始化为相同权重
self.loss_f = nn.MSELoss()
try:
shutil.rmtree('dqn/logs/') # 递归删除文件夹
except:
print("没有发现logs文件目录")
self.writer = SummaryWriter("dqn/logs/")
dummy_input = Variable(torch.rand(5, self.s_task_dim + self.s_vm_dim))
with SummaryWriter(logdir="dqn/logs/graph", comment="Q_net") as w:
w.add_graph(self.eval_net, (dummy_input))
# 多个状态传入，给每个状态选择一个动作
def choose_action(self, s_list):
if self.epsilon > self.epsilon_min: # epsilon最小值
self.epsilon *= self.epsilon_decay
if np.random.uniform(
) > self.epsilon: # np.random.uniform()输出0到1之间的一个随机数
self.eval_net.eval()
actions_value = self.eval_net(torch.from_numpy(s_list).float())
# 原始方式，直接根据最大值选择动作
# actions = torch.max(actions_value, 1)[1].data.numpy()
# Boltzmann动作选择策略，按概率选择动作
actions_pro_value = torch.softmax(
actions_value, dim=1).data.numpy() # softmax 计算概率
actions = [] # action 存储action值
indexs = [i for i in range(self.a_dim)]
for line in actions_pro_value:
actions.append(
np.random.choice(indexs,
p=line.ravel()).tolist()) # 根据概率选择动作
actions = np.array(actions)
else:
# 范围：[low,high),随机选择，虚拟机编号1到self.vms+1，共n_actions个任务
actions = np.random.randint(0, self.vms, size=[1, len(s_list)])[0]
# 后面的代码增加分配VM的合理性
adict = {}
for i, num in enumerate(actions):
if num not in adict:
adict[num] = 1
elif adict[num] > 2 and np.random.uniform(
) < adict[num] / 4: # 如果VM被分配的任务个数大于2，按后面的概率随机给任务分配VM
actions[i] = np.random.randint(self.vms) # 范围:[0,20)
adict[num] += 1
else:
adict[num] += 1
return actions
def learn(self):
# 更新 Target Net
if self.step % TARGET_REPLACE_ITER == 0:
self.hard_update(self.target_net, self.eval_net)
# 训练Q网络
self.eval_net.train()
q_eval = self.eval_net(self.bstate).gather(
1, self.baction) # shape (batch, 1), gather表示获取每个维度action为下标的Q值
self.target_net.eval()
q_next = self.target_net(self.bstate_).detach() # 设置 Target Net 不需要梯度
q_target = self.breward + GAMMA * q_next.max(1)[0].view(
self.batch_size, 1) # shape (batch, 1)
loss = self.loss_f(q_eval, q_target)
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
# 画图
if self.step % 10 == 0:
self.writer.add_scalar('Q-value',
q_eval.detach().numpy()[0], self.step)
self.writer.add_scalar('Loss', loss.detach().numpy(), self.step)
return loss.detach().numpy()
def store_memory(self, state_all, action_all, reward_all):
indexs = np.random.choice(len(state_all[:-1]), size=self.batch_size)
self.bstate = torch.from_numpy(state_all[indexs, :]).float()
self.bstate_ = torch.from_numpy(state_all[indexs + 1, :]).float()
self.baction = torch.LongTensor(action_all[indexs, :])
self.breward = torch.from_numpy(
reward_all[indexs, :]).float() # 奖励值值越大越好
# 全部更新
def hard_update(self, target_net, eval_net):
target_net.load_state_dict(eval_net.state_dict())
# 初始化网络参数
def weights_init(self, m):
if isinstance(m, nn.Linear):
nn.init.xavier_normal_(m.weight)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.BatchNorm1d): # 批归一化层初始化
nn.init.uniform_(m.bias) # 初始化为U(0,1)
nn.init.constant_(m.bias, 0)
def main():
args = parse_args()
reset_config(config, args)
logger, final_output_dir, tb_log_dir = create_logger(
config, args.cfg, 'train')
time_stamp = tb_log_dir.split('_')[-1]
new_folder = os.path.join(final_output_dir, time_stamp)
os.makedirs(new_folder)
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
# cudnn related setting
cudnn.benchmark = config.CUDNN.BENCHMARK
torch.backends.cudnn.deterministic = config.CUDNN.DETERMINISTIC
torch.backends.cudnn.enabled = config.CUDNN.ENABLED
model = eval('models.'+config.MODEL.NAME+'.get_pose_net_second_deconv')(
config, is_train=True
).cuda()
second_deconv = eval('models.'+config.MODEL.NAME+'.get_second_deconv')(
config#, pretrained='output/coco/pose_resnet_50/256x192_d256x3_adam_lr1e-3/2021-02-15-03-49/model_best.pth.tar'
).cuda()
# copy model file
this_dir = os.path.dirname(__file__)
shutil.copy2(
os.path.join(this_dir, '../lib/models', config.MODEL.NAME + '.py'),
final_output_dir)
writer_dict = {
'writer': SummaryWriter(log_dir=tb_log_dir),
'train_global_steps': 0,
'valid_global_steps': 0,
}
# dump_input = torch.rand((config.TRAIN.BATCH_SIZE,
# 3,
# config.MODEL.IMAGE_SIZE[1],
# config.MODEL.IMAGE_SIZE[0]))
# writer_dict['writer'].add_graph(model, (dump_input, ), verbose=False)
gpus = [int(i) for i in config.GPUS.split(',')]
# model = torch.nn.DataParallel(model, device_ids=gpus).cuda()
# define loss function (criterion) and optimizer
criterion = JointsMSELoss(
use_target_weight=config.LOSS.USE_TARGET_WEIGHT, use_gain_loss=False
).cuda()
# optimizer = get_optimizer(config, model)
second_deconv_optimizer = get_optimizer(config, second_deconv)
# lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(
# optimizer, config.TRAIN.LR_STEP, config.TRAIN.LR_FACTOR
# )
second_deconv_lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(
second_deconv_optimizer, config.TRAIN.LR_STEP, config.TRAIN.LR_FACTOR
)
# Data loading code
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_dataset = eval('dataset.'+config.DATASET.DATASET)(
config,
config.DATASET.ROOT,
config.DATASET.TRAIN_SET,
True,
transforms.Compose([
transforms.ToTensor(),
normalize,
])
)
valid_dataset = eval('dataset.'+config.DATASET.DATASET)(
config,
config.DATASET.ROOT,
config.DATASET.TEST_SET,
False,
transforms.Compose([
transforms.ToTensor(),
normalize,
])
)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config.TRAIN.BATCH_SIZE*len(gpus),
shuffle=config.TRAIN.SHUFFLE,
num_workers=config.WORKERS,
pin_memory=True
)
valid_loader = torch.utils.data.DataLoader(
valid_dataset,
batch_size=config.TEST.BATCH_SIZE*len(gpus),
shuffle=False,
num_workers=config.WORKERS,
pin_memory=True
)
best_perf = 0.0
best_model = False
for epoch in range(config.TRAIN.BEGIN_EPOCH, config.TRAIN.END_EPOCH):
# lr_scheduler.step()
second_deconv_lr_scheduler.step()
# train for one epoch
train(config, train_loader, model, second_deconv, criterion, second_deconv_optimizer, epoch,
new_folder, tb_log_dir, writer_dict)
# evaluate on validation set
perf_indicator = validate(config, valid_loader, valid_dataset, model, second_deconv,
criterion, new_folder, tb_log_dir,
writer_dict)
if perf_indicator > best_perf:
best_perf = perf_indicator
best_model = True
else:
best_model = False
logger.info('=> saving checkpoint to {}'.format(new_folder))
save_checkpoint({
'epoch': epoch + 1,
'model': get_model_name(config),
'state_dict': second_deconv.state_dict(),
'perf': perf_indicator,
'optimizer': second_deconv_optimizer.state_dict(),
}, best_model, new_folder)
final_model_state_file = os.path.join(new_folder,
'final_state.pth.tar')
logger.info('saving final model state to {}'.format(
final_model_state_file))
torch.save(model.module.state_dict(), final_model_state_file)
writer_dict['writer'].close()
parser.add_argument('--log-directory',
type=str,
default='/home/sungwonlyu/experiment/gan',
metavar='N',
help='log directory')
parser.add_argument(
'--parameters',
type=list,
default=[784, 400, 10, 10],
metavar='N',
help='gan parameters [input_size, hidden_size, latent_size, L]')
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
writer = SummaryWriter(args.log_directory + '/' + args.time_stamp + '/')
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
train_loader = dataloader.train_loader('mnist', args.data_directory,
args.batch_size)
input_size, hidden_size, latent_size, L = args.parameters
if args.load_model != '000000':
gan = torch.load(args.log_directory + '/' + args.load_model + '/gan.pt')
else:
gan = model2.GAN()
return self.net(x)
def calc_qvals(rewards):
res = []
sum_r = 0.0
for r in reversed(rewards):
sum_r *= GAMMA
sum_r += r
res.append(sum_r)
return list(reversed(res))
if __name__ == "__main__":
env = gym.make("CartPole-v0")
writer = SummaryWriter(comment="-cartpole-reinforce")
net = PGN(env.observation_space.shape[0], env.action_space.n)
print(net)
agent = ptan.agent.PolicyAgent(net, preprocessor=ptan.agent.float32_preprocessor,
apply_softmax=True)
exp_source = ptan.experience.ExperienceSourceFirstLast(env, agent, gamma=GAMMA)
optimizer = optim.Adam(net.parameters(), lr=LEARNING_RATE)
total_rewards = []
step_idx = 0
done_episodes = 0
batch_episodes = 0
def main_worker(gpu, ngpus_per_node, args):
global best_acc1
args.gpu = gpu
# suppress printing if not master
if args.multiprocessing_distributed and args.gpu != 0:
def print_pass(*args):
pass
builtins.print = print_pass
if args.gpu is not None:
print("Use GPU: {} for training".format(args.gpu))
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
# For multiprocessing distributed training, rank needs to be the
# global rank among all the processes
args.rank = args.rank * ngpus_per_node + gpu
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# create model
print("=> creating model '{}'".format(args.arch))
model = models.__dict__[args.arch]()
# freeze all layers but the last fc
for name, param in model.named_parameters():
if name not in ['fc.weight', 'fc.bias']:
param.requires_grad = False
# init the fc layer
# monkey patch fix for cifar100
if args.data == 'cifar100':
model.fc = nn.Linear(model.fc.weight.size(1), 100)
model.fc.weight.data.normal_(mean=0.0, std=0.01)
model.fc.bias.data.zero_()
# load from pre-trained, before DistributedDataParallel constructor
if args.pretrained:
if os.path.isfile(args.pretrained):
print("=> loading checkpoint '{}'".format(args.pretrained))
checkpoint = torch.load(args.pretrained, map_location="cpu")
# rename moco pre-trained keys
state_dict = checkpoint['state_dict']
for k in list(state_dict.keys()):
# retain only encoder_q up to before the embedding layer
if k.startswith('module.encoder_q') and not k.startswith('module.encoder_q.fc'):
# remove prefix
state_dict[k[len("module.encoder_q."):]] = state_dict[k]
# delete renamed or unused k
del state_dict[k]
args.start_epoch = 0
msg = model.load_state_dict(state_dict, strict=False)
assert set(msg.missing_keys) == {"fc.weight", "fc.bias"}
print("=> loaded pre-trained model '{}'".format(args.pretrained))
else:
print("=> no checkpoint found at '{}'".format(args.pretrained))
if args.distributed:
# For multiprocessing distributed, DistributedDataParallel constructor
# should always set the single device scope, otherwise,
# DistributedDataParallel will use all available devices.
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.cuda(args.gpu)
# When using a single GPU per process and per
# DistributedDataParallel, we need to divide the batch size
# ourselves based on the total number of GPUs we have
args.batch_size = int(args.batch_size / ngpus_per_node)
args.workers = int(
(args.workers + ngpus_per_node - 1) / ngpus_per_node)
model = torch.nn.parallel.DistributedDataParallel(
model, device_ids=[args.gpu])
else:
model.cuda()
# DistributedDataParallel will divide and allocate batch_size to all
# available GPUs if device_ids are not set
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model = model.cuda(args.gpu)
else:
# DataParallel will divide and allocate batch_size to all available GPUs
if args.arch.startswith('alexnet') or args.arch.startswith('vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
if args.rank == 0:
writer = SummaryWriter(logdir=args.save_dir)
else:
writer = None
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda(args.gpu)
# optimize only the linear classifier
parameters = list(filter(lambda p: p.requires_grad, model.parameters()))
assert len(parameters) == 2 # fc.weight, fc.bias
optimizer = torch.optim.SGD(parameters, args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
if args.gpu is None:
checkpoint = torch.load(args.resume)
else:
# Map model to be loaded to specified single gpu.
loc = 'cuda:{}'.format(args.gpu)
checkpoint = torch.load(args.resume, map_location=loc)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_acc1']
if args.gpu is not None:
# best_acc1 may be from a checkpoint from a different GPU
best_acc1 = best_acc1.to(args.gpu)
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
if args.data == 'cifar10':
if os.path.exists(f'{data_path}/cifar10'):
traindir = os.path.join(f'{data_path}/cifar10')
else:
traindir = '../cifar10'
elif args.data == 'cifar100':
if os.path.exists(f'{data_path}/cifar100'):
traindir = os.path.join(f'{data_path}/cifar100')
else:
traindir = '../cifar100'
valdir = traindir
if args.data == 'cifar10':
dataset_cls = datasets.CIFAR10
normalize = transforms.Normalize(mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010))
elif args.data == 'cifar100':
dataset_cls = datasets.CIFAR100
normalize = transforms.Normalize(mean=(0.5071, 0.4867, 0.4408),
std=(0.2675, 0.2565, 0.2761))
train_dataset = dataset_cls(
traindir, train=True,
transform=transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]))
if args.distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset)
else:
train_sampler = None
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=args.batch_size, shuffle=(
train_sampler is None),
num_workers=args.workers, pin_memory=True, sampler=train_sampler)
val_loader = torch.utils.data.DataLoader(
dataset_cls(valdir, train=False, transform=transforms.Compose([
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
if args.evaluate:
validate(val_loader, model, criterion, args, writer)
return
for epoch in range(args.start_epoch, args.epochs):
if args.distributed:
train_sampler.set_epoch(epoch)
adjust_learning_rate(optimizer, epoch, args)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, args, writer)
# evaluate on validation set
acc1 = validate(val_loader, model, criterion, args, writer, epoch)
# remember best acc@1 and save checkpoint
is_best = acc1 > best_acc1
best_acc1 = max(acc1, best_acc1)
if not args.multiprocessing_distributed or (args.multiprocessing_distributed
and args.rank % ngpus_per_node == 0):
if epoch % 10 == 0 or epoch == args.epochs - 1:
save_checkpoint({
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer': optimizer.state_dict(),
}, is_best, filename='{}/checkpoint.pt'.format(args.save_dir))
if epoch == args.start_epoch:
sanity_check(model.state_dict(), args.pretrained)
print(args)
param = {'env' : args.env,
'batch_size' : 32,
'lr' : 0.0001,
'GAMMA' : 0.95,
'replay_buffer' : 500000,
'end_eps' : 0.1,
'exp_length' : 2000000}
param['version'] = ", ".join([ "{}:{}".format(key,val) for key, val in param.items()]) + " "+str(datetime.datetime.now())[:16]
print(param['version'])
memory = utils.ReplayMemory(param['replay_buffer'])
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
eps = utils.EpsilonDecay(start_eps = 1.0, end_eps = param['end_eps'], length = param['exp_length'])
writer = SummaryWriter(log_dir = "tensorboard/" + param['version'])
checkpoint = utils.CheckpointIfBetter(param, device)
env = wrap_deepmind(gym.make(param['env']), frame_stack = True)
dqn = model.DQN(num_actions = env.action_space.n).to(device)
target_dqn = copy.deepcopy(dqn)
def dqn_epsilon_agent(state, net = dqn, th = 0.05):
if random.random() > th:
yhat = net(default_states_preprocessor(state))
return int(yhat.argmax().cpu().numpy())
else:
return env.action_space.sample()
optimizer = optim.Adam(dqn.parameters(), lr = param['lr'])
n2_win += 1
elif r > 0.5:
n1_win += 1
return n1_win / (n1_win + n2_win)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("-n", "--name", required=True, help="Name of the run")
parser.add_argument("--cuda", default=False, action="store_true", help="Enable CUDA")
args = parser.parse_args()
device = torch.device("cuda" if args.cuda else "cpu")
saves_path = os.path.join("saves", args.name)
os.makedirs(saves_path, exist_ok=True)
writer = SummaryWriter(comment="-" + args.name)
net = model.Net(input_shape=model.OBS_SHAPE, actions_n=game.GAME_COLS).to(device)
best_net = ptan.agent.TargetNet(net)
print(net)
optimizer = optim.SGD(net.parameters(), lr=LEARNING_RATE, momentum=0.9)
replay_buffer = collections.deque(maxlen=REPLAY_BUFFER)
mcts_store = mcts.MCTS()
step_idx = 0
best_idx = 0
with ptan.common.utils.TBMeanTracker(writer, batch_size=10) as tb_tracker:
while True:
t = time.time()
self.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 10)
self.bn = nn.BatchNorm2d(20)
def forward(self, x):
x = F.max_pool2d(self.conv1(x), 2)
x = F.relu(x) + F.relu(-x)
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
x = self.bn(x)
x = x.view(-1, 320)
x = F.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
x = F.softmax(x, dim=1)
return x
dummy_input = torch.rand(13, 1, 28, 28)
model = Net1()
with SummaryWriter(log_dir='test_tensorboard') as writer:
# for epoch in range(100):
# writer.add_scalar('scalar/test',np.random.rand(),epoch)
# writer.add_scalar('scalar/test',epoch*np.sin(epoch))
# writer.add_scalars('scalar/0/scalars_test',{'xsinx':epoch*np.sin(epoch)},epoch)
# writer.add_scalars('scalar/0/scalars_test',{'xcosx': epoch * np.cos(epoch)}, epoch)
# writer.add_scalars('scalar/1/scalars_test', {'xsinx': epoch * np.sin(epoch)}, epoch)
# writer.add_scalars('scalar/1/scalars_test', {'xcosx': epoch * np.cos(epoch)}, epoch)
writer.add_graph(model, (dummy_input, ))
writer.close()
parser = argparse.ArgumentParser(description="config")
parser.add_argument(
"--config",
nargs="?",
type=str,
help="Configuration file to use"
)
args = parser.parse_args()
with open(args.config) as fp:
cfg = yaml.load(fp)
index = 0
logdir = os.path.join('runs', cfg["training"]["logdir"] + "/" + str(index))
while True:
index += 1
if os.path.exists(logdir):
logdir = logdir[:-len(str(index-1))] + str(index)
else:
break
writer = SummaryWriter(log_dir=logdir)
print('RUNDIR: {}'.format(logdir))
shutil.copy(args.config, logdir)
logger = get_logger(logdir)
logger.info('Let the games begin')
train(cfg, writer, logger)
def train(args, return_early=False):
writer = SummaryWriter(args.log_dir)
envs = utils.make_parallel_envs(args)
master = setup_master(args)
# evaluate 时用
eval_master, eval_env = setup_master(args, return_env=True)
obs = envs.reset() # shape - num_processes x num_agents x obs_dim
master.initialize_obs(obs)
n = len(master.all_agents)
episode_rewards = torch.zeros([args.num_processes, n], device=args.device)
final_rewards = torch.zeros([args.num_processes, n], device=args.device)
start = datetime.datetime.now()
for j in range(args.num_updates):
for step in range(args.num_steps):
with torch.no_grad():
actions_list = master.act(step)
agent_actions = np.transpose(np.array(actions_list),(1,0,2))
obs, reward, done, info = envs.step(agent_actions)
reward = torch.from_numpy(np.stack(reward)).float().to(args.device)
episode_rewards += reward
masks = torch.FloatTensor(1-1.0*done).to(args.device)
final_rewards *= masks
final_rewards += (1 - masks) * episode_rewards
episode_rewards *= masks
master.update_rollout(obs, reward, masks)
master.wrap_horizon()
return_vals = master.update()
value_loss = return_vals[:, 0]
action_loss = return_vals[:, 1]
dist_entropy = return_vals[:, 2]
master.after_update()
if j%args.save_interval == 0 and not args.test:
savedict = {'models': [agent.actor_critic.state_dict() for agent in master.all_agents]}
ob_rms = (None, None) if envs.ob_rms is None else (envs.ob_rms[0].mean, envs.ob_rms[0].var)
savedict['ob_rms'] = ob_rms
savedir = args.save_dir+'/ep'+str(j)+'.pt'
torch.save(savedict, savedir)
total_num_steps = (j + 1) * args.num_processes * args.num_steps
if j%args.log_interval == 0:
end = datetime.datetime.now()
seconds = (end-start).total_seconds()
mean_reward = final_rewards.mean(dim=0).cpu().numpy()
print("Updates {} | Num timesteps {} | Time {} | FPS {}\nMean reward {}\nEntropy {:.4f} Value loss {:.4f} Policy loss {:.4f}\n".
format(j, total_num_steps, str(end-start), int(total_num_steps / seconds),
mean_reward, dist_entropy[0], value_loss[0], action_loss[0]))
if not args.test:
for idx in range(n):
writer.add_scalar('agent'+str(idx)+'/training_reward', mean_reward[idx], j)
writer.add_scalar('all/value_loss', value_loss[0], j)
writer.add_scalar('all/action_loss', action_loss[0], j)
writer.add_scalar('all/dist_entropy', dist_entropy[0], j)
if args.eval_interval is not None and j%args.eval_interval==0:
ob_rms = (None, None) if envs.ob_rms is None else (envs.ob_rms[0].mean, envs.ob_rms[0].var)
print('===========================================================================================')
_, eval_perstep_rewards, final_min_dists, num_success, eval_episode_len = evaluate(args, None, master.all_policies,
ob_rms=ob_rms, env=eval_env,
master=eval_master)
print('Evaluation {:d} | Mean per-step reward {:.2f}'.format(j//args.eval_interval, eval_perstep_rewards.mean()))
print('Num success {:d}/{:d} | Episode Length {:.2f}'.format(num_success, args.num_eval_episodes, eval_episode_len))
if final_min_dists:
print('Final_dists_mean {}'.format(np.stack(final_min_dists).mean(0)))
print('Final_dists_var {}'.format(np.stack(final_min_dists).var(0)))
print('===========================================================================================\n')
if not args.test:
writer.add_scalar('all/eval_success', 100.0*num_success/args.num_eval_episodes, j)
writer.add_scalar('all/episode_length', eval_episode_len, j)
for idx in range(n):
writer.add_scalar('agent'+str(idx)+'/eval_per_step_reward', eval_perstep_rewards.mean(0)[idx], j)
if final_min_dists:
writer.add_scalar('agent'+str(idx)+'/eval_min_dist', np.stack(final_min_dists).mean(0)[idx], j)
curriculum_success_thres = 0.9
if return_early and num_success*1./args.num_eval_episodes > curriculum_success_thres:
savedict = {'models': [agent.actor_critic.state_dict() for agent in master.all_agents]}
ob_rms = (None, None) if envs.ob_rms is None else (envs.ob_rms[0].mean, envs.ob_rms[0].var)
savedict['ob_rms'] = ob_rms
savedir = args.save_dir+'/ep'+str(j)+'.pt'
torch.save(savedict, savedir)
print('===========================================================================================\n')
print('{} agents: training complete. Breaking.\n'.format(args.num_agents))
print('===========================================================================================\n')
break
writer.close()
if return_early:
return savedir
type=int,
default=256,
help='The number of RNN units in the encoder. 2x this '
'number of RNN units will be used in the decoder')
parser.add_argument('--embedding_size',
type=int,
default=128,
help='Embedding size used in both encoder and decoder')
parser.add_argument(
'--max_length',
type=int,
default=200,
help='Sequences will be padded or truncated to this size.')
args = parser.parse_args()
writer = SummaryWriter('./logs/%s_%s' %
(args.model_name, str(int(time.time()))))
if args.scheduled_teacher_forcing:
schedule = np.arange(1.0, 0.0, -1.0 / args.epochs)
else:
schedule = np.ones(args.epochs) * args.teacher_forcing_fraction
main(args.model_name, args.use_cuda, args.batch_size, schedule,
args.keep_prob, args.val_size, args.lr, args.decoder_type,
args.vocab_limit, args.hidden_size, args.embedding_size,
args.max_length)
# main(str(int(time.time())), args.use_cuda, args.batch_size, schedule, args.keep_prob, args.val_size, args.lr, args.decoder_type, args.vocab_limit, args.hidden_size, args.embedding_size, args.max_length)
pass
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--cuda", default=False, action="store_true", help="Enable cuda")
parser.add_argument("-n", "--name", required=True, help="Name of the run")
parser.add_argument("-m", "--model", required=True, help="File with model to load")
args = parser.parse_args()
saves_path = os.path.join("saves", "02_env_" + args.name)
os.makedirs(saves_path, exist_ok=True)
envs = [common.make_env() for _ in range(NUM_ENVS)]
writer = SummaryWriter(comment="-02_env_" + args.name)
net = common.AtariA2C(envs[0].observation_space.shape, envs[0].action_space.n)
net_em = i2a.EnvironmentModel(envs[0].observation_space.shape, envs[0].action_space.n)
net.load_state_dict(torch.load(args.model, map_location=lambda storage, loc: storage))
if args.cuda:
net.cuda()
net_em.cuda()
print(net_em)
optimizer = optim.Adam(net_em.parameters(), lr=LEARNING_RATE)
step_idx = 0
best_loss = np.inf
with ptan.common.utils.TBMeanTracker(writer, batch_size=100) as tb_tracker:
for mb_obs, mb_obs_next, mb_actions, mb_rewards, done_rewards, done_steps in iterate_batches(envs, net, cuda=args.cuda):
if len(done_rewards) > 0:
def train(self,
train_dataset,
output_dir,
show_running_loss=True,
eval_df=None):
"""
Trains the model on train_dataset.
Utility function to be used by the train_model() method. Not intended to be used directly.
"""
tokenizer = self.tokenizer
device = self.device
model = self.model
args = self.args
tb_writer = SummaryWriter()
train_sampler = RandomSampler(train_dataset)
train_dataloader = DataLoader(train_dataset,
sampler=train_sampler,
batch_size=args["train_batch_size"])
t_total = len(train_dataloader) // args[
"gradient_accumulation_steps"] * args["num_train_epochs"]
no_decay = ["bias", "LayerNorm.weight"]
optimizer_grouped_parameters = [{
"params": [
p for n, p in model.named_parameters()
if not any(nd in n for nd in no_decay)
],
"weight_decay":
args["weight_decay"]
}, {
"params": [
p for n, p in model.named_parameters()
if any(nd in n for nd in no_decay)
],
"weight_decay":
0.0
}]
warmup_steps = math.ceil(t_total * args["warmup_ratio"])
args["warmup_steps"] = warmup_steps if args[
"warmup_steps"] == 0 else args["warmup_steps"]
optimizer = AdamW(optimizer_grouped_parameters,
lr=args["learning_rate"],
eps=args["adam_epsilon"])
scheduler = get_linear_schedule_with_warmup(
optimizer,
num_warmup_steps=args["warmup_steps"],
num_training_steps=t_total)
if args["fp16"]:
try:
from apex import amp
except ImportError:
raise ImportError(
"Please install apex from https://www.github.com/nvidia/apex to use fp16 training."
)
model, optimizer = amp.initialize(model,
optimizer,
opt_level=args["fp16_opt_level"])
if args["n_gpu"] > 1:
model = torch.nn.DataParallel(model)
global_step = 0
tr_loss, logging_loss = 0.0, 0.0
model.zero_grad()
train_iterator = trange(int(args["num_train_epochs"]),
desc="Epoch",
disable=args['silent'])
model.train()
for _ in train_iterator:
# epoch_iterator = tqdm(train_dataloader, desc="Iteration")
for step, batch in enumerate(
tqdm(train_dataloader,
desc="Current iteration",
disable=args['silent'])):
batch = tuple(t.to(self.device) for t in batch)
inputs = self._get_inputs_dict(batch)
if self.sliding_window:
outputs = model(inputs)
else:
outputs = model(**inputs)
# model outputs are always tuple in pytorch-transformers (see doc)
loss = outputs[0]
if show_running_loss:
print("\rRunning loss: %f" % loss, end="")
if args['n_gpu'] > 1:
loss = loss.mean(
) # mean() to average on multi-gpu parallel training
if args["gradient_accumulation_steps"] > 1:
loss = loss / args["gradient_accumulation_steps"]
if args["fp16"]:
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
torch.nn.utils.clip_grad_norm_(
amp.master_params(optimizer), args["max_grad_norm"])
else:
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(),
args["max_grad_norm"])
tr_loss += loss.item()
if (step + 1) % args["gradient_accumulation_steps"] == 0:
optimizer.step()
scheduler.step() # Update learning rate schedule
model.zero_grad()
global_step += 1
if args["logging_steps"] > 0 and global_step % args[
"logging_steps"] == 0:
# Log metrics
if args['evaluate_during_training']:
# Only evaluate when single GPU otherwise metrics may not average well
results, _, _ = self.eval_model(eval_df,
verbose=True)
for key, value in results.items():
tb_writer.add_scalar('eval_{}'.format(key),
value, global_step)
tb_writer.add_scalar("lr",
scheduler.get_lr()[0],
global_step)
tb_writer.add_scalar("loss", (tr_loss - logging_loss) /
args["logging_steps"],
global_step)
logging_loss = tr_loss
if args["save_steps"] > 0 and global_step % args[
"save_steps"] == 0:
# Save model checkpoint
output_dir_current = os.path.join(
output_dir, "checkpoint-{}".format(global_step))
if not os.path.exists(output_dir_current):
os.makedirs(output_dir_current)
# Take care of distributed/parallel training
model_to_save = model.module if hasattr(
model, "module") else model
model_to_save.save_pretrained(output_dir_current)
self.tokenizer.save_pretrained(output_dir_current)
return global_step, tr_loss / global_step
model = nn.DataParallel(model)
#load trained model if needed
#model.load_state_dict(torch.load('/workspace/1.pth'))
print('Model created.')
epochs=50
lr=0.0001
batch_size=64
depth_dataset = DepthDataset(traincsv=traincsv, root_dir='./content/',
transform=transforms.Compose([Augmentation(0.5),ToTensor()]))
train_loader=DataLoader(depth_dataset, batch_size, shuffle=True)
l1_criterion = nn.L1Loss()
optimizer = torch.optim.Adam( model.parameters(), lr )
writer = SummaryWriter()
# Start training...
for epoch in range(epochs):
batch_time = AverageMeter()
losses = AverageMeter()
N = len(train_loader)
# Switch to train mode
model.train()
end = time.time()
for i, sample_batched in enumerate(train_loader):
optimizer.zero_grad()
#Prepare sample and target
def train(args, train_dataset, model, tokenizer):
""" Train the model """
if args.local_rank in [-1, 0]:
tb_writer = SummaryWriter()
args.train_batch_size = args.per_gpu_train_batch_size * max(1, args.n_gpu)
train_sampler = RandomSampler(train_dataset) if args.local_rank == -1 else DistributedSampler(train_dataset)
train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size)
if args.max_steps > 0:
t_total = args.max_steps
args.num_train_epochs = args.max_steps // (len(train_dataloader) // args.gradient_accumulation_steps) + 1
else:
t_total = len(train_dataloader) // args.gradient_accumulation_steps * args.num_train_epochs
# Prepare optimizer and schedule (linear warmup and decay)
no_decay = ['bias', 'LayerNorm.weight']
optimizer_grouped_parameters = [
{'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': args.weight_decay},
{'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
]
optimizer = AdamW(optimizer_grouped_parameters, lr=args.learning_rate, eps=args.adam_epsilon)
scheduler = WarmupLinearSchedule(optimizer, warmup_steps=args.warmup_steps, t_total=t_total)
if args.fp16:
try:
from apex import amp
except ImportError:
raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
# multi-gpu training (should be after apex fp16 initialization)
if args.n_gpu > 1:
model = torch.nn.DataParallel(model)
# Distributed training (should be after apex fp16 initialization)
if args.local_rank != -1:
model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank],
output_device=args.local_rank,
find_unused_parameters=True)
# Train!
logger.info("***** Running training *****")
logger.info(" Num examples = %d", len(train_dataset))
logger.info(" Num Epochs = %d", args.num_train_epochs)
logger.info(" Instantaneous batch size per GPU = %d", args.per_gpu_train_batch_size)
logger.info(" Total train batch size (w. parallel, distributed & accumulation) = %d",
args.train_batch_size * args.gradient_accumulation_steps * (torch.distributed.get_world_size() if args.local_rank != -1 else 1))
logger.info(" Gradient Accumulation steps = %d", args.gradient_accumulation_steps)
logger.info(" Total optimization steps = %d", t_total)
global_step = 0
tr_loss, logging_loss = 0.0, 0.0
model.zero_grad()
train_iterator = trange(int(args.num_train_epochs), desc="Epoch", disable=args.local_rank not in [-1, 0])
set_seed(args) # Added here for reproducibility (even between python 2 and 3)
for _ in train_iterator:
epoch_iterator = tqdm(train_dataloader, desc="Iteration", disable=args.local_rank not in [-1, 0])
for step, (batch,lengths) in enumerate(epoch_iterator):
inputs, labels = mask_tokens(batch, tokenizer, args) if args.mlm else (batch, batch)
inputs = inputs.to(args.device)
labels = labels.to(args.device)
model.train()
max_len = len(inputs[0])
mask = (torch.arange(max_len).expand(len(lengths), max_len) < lengths.unsqueeze(1)).long().to(args.device)
#print(inputs)
# print(mask)
outputs = model(inputs, masked_lm_labels=labels) if args.mlm else model(inputs,mask, labels=labels)
loss = outputs[0] # model outputs are always tuple in pytorch-transformers (see doc)
# print(outputs)
if args.n_gpu > 1:
loss = loss.mean() # mean() to average on multi-gpu parallel training
if args.gradient_accumulation_steps > 1:
loss = loss / args.gradient_accumulation_steps
if args.fp16:
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
else:
loss.backward()
tr_loss += loss.item()
if (step + 1) % args.gradient_accumulation_steps == 0:
if args.fp16:
torch.nn.utils.clip_grad_norm_(amp.master_params(optimizer), args.max_grad_norm)
else:
torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
optimizer.step()
scheduler.step() # Update learning rate schedule
model.zero_grad()
global_step += 1
if args.local_rank in [-1, 0] and args.logging_steps > 0 and global_step % args.logging_steps == 0:
# Log metrics
if args.local_rank == -1 and args.evaluate_during_training: # Only evaluate when single GPU otherwise metrics may not average well
results = evaluate(args, model, tokenizer)
for key, value in results.items():
tb_writer.add_scalar('eval_{}'.format(key), value, global_step)
tb_writer.add_scalar('lr', scheduler.get_lr()[0], global_step)
tb_writer.add_scalar('loss', (tr_loss - logging_loss)/args.logging_steps, global_step)
logging_loss = tr_loss
if args.local_rank in [-1, 0] and args.save_steps > 0 and global_step % args.save_steps == 0:
# Save model checkpoint
output_dir = os.path.join(args.output_dir, 'checkpoint-{}'.format(global_step))
if not os.path.exists(output_dir):
os.makedirs(output_dir)
model_to_save = model.module if hasattr(model, 'module') else model # Take care of distributed/parallel training
model_to_save.save_pretrained(output_dir)
torch.save(args, os.path.join(output_dir, 'training_args.bin'))
logger.info("Saving model checkpoint to %s", output_dir)
if args.max_steps > 0 and global_step > args.max_steps:
epoch_iterator.close()
break
if args.max_steps > 0 and global_step > args.max_steps:
train_iterator.close()
break
if args.local_rank in [-1, 0]:
tb_writer.close()
return global_step, tr_loss / global_step
def train(model, train_loader, val_loader, optimizer, num_epochs,
path_to_save_best_weights):
model.train()
log_softmax = nn.LogSoftmax(dim=1) # Use for NLLLoss()
softmax = nn.Softmax(dim=1)
# weights = [1.0,1.0,1.0,1.0,1.0, 0.0]
# class_weights = torch.FloatTensor(weights).to(device)
criterion_nlloss = nn.NLLLoss() #(weight=class_weights)
metrics_evaluator = PerformanceMetricsEvaluator()
to_tensor = transforms.ToTensor()
writer = SummaryWriter('runs/unet')
since = time.time()
best_model_weights = model.state_dict()
best_IoU = 0.0
best_val_loss = 1000000000
curr_val_loss = 0.0
curr_training_loss = 0.0
curr_training_IoU = 0.0
curr_val_IoU = 0.0
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch, num_epochs - 1))
print('-' * 10)
for phase in ['train', 'val']:
if phase == 'train':
# scheduler.step(best_val_loss)
model.train()
data_loader = train_loader
else:
model.eval()
data_loader = val_loader
running_loss = 0.0
running_IoU = 0
# Iterate over data.
ind = 0
for imgs, masks in tqdm(data_loader):
imgs = imgs.to(device)
masks = masks.to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward
logits = model(imgs)
log_softmax_logits = log_softmax(logits)
loss = criterion_nlloss(log_softmax_logits, masks)
# backward + optimize only if in training phase
if phase == 'train':
loss.backward()
optimizer.step()
# ================================================================== #
# Tensorboard Logging #
# ================================================================== #
unet_softmax_collupsed = softmax(logits)
unet_softmax_collupsed = np.argmax(
unet_softmax_collupsed.detach().cpu(), axis=1)
if ind % 10 == 0:
if phase == 'val':
img_name = 'ValidationEpoch: {}'.format(str(epoch))
else:
img_name = 'TrainingEpoch: {}'.format(str(epoch))
rgb_prediction = unet_softmax_collupsed.repeat(3, 1,
1).float()
rgb_prediction = np.moveaxis(rgb_prediction.numpy(), 0, -1)
converted_img = img_to_visible(rgb_prediction)
converted_img = torch.unsqueeze(to_tensor(converted_img),
0)
# converted_img = np.moveaxis(converted_img, -1, 0)
masks_changed = masks.detach().cpu()
masks_changed = masks_changed.repeat(3, 1, 1).float()
masks_changed = np.moveaxis(masks_changed.numpy(), 0, -1)
masks_changed = img_to_visible(masks_changed)
masks_changed = torch.unsqueeze(to_tensor(masks_changed),
0)
# print(np.unique(converted_img, return_counts=True))
third_tensor = torch.cat(
(converted_img, imgs.detach().cpu(), masks_changed),
-1)
writer.add_image(
img_name,
# vutils.make_grid([
# imgs.detach().cpu(),
# rgb_prediction
third_tensor,
# ]),
epoch)
# statistics
running_loss += loss.detach().item()
running_IoU += metrics_evaluator.mean_IU(
unet_softmax_collupsed.numpy()[0],
masks.cpu().numpy()[0])
ind += 1
epoch_loss = running_loss / len(data_loader)
epoch_IoU = running_IoU / len(data_loader)
print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss,
epoch_IoU))
# deep copy the model
if phase == 'val' and epoch_loss < best_val_loss: # TODO add IoU
best_val_loss = epoch_loss
best_IoU = epoch_IoU
best_model_weights = model.state_dict()
if phase == 'val':
# print(optimizer.param_groups[0]['lr'])
curr_val_loss = epoch_loss
curr_val_IoU = epoch_IoU
else:
curr_training_loss = epoch_loss
curr_training_IoU = epoch_IoU
writer.add_scalars('TrainValIoU', {
'trainIoU': curr_training_IoU,
'validationIoU': curr_val_IoU
}, epoch)
writer.add_scalars('TrainValLoss', {
'trainLoss': curr_training_loss,
'validationLoss': curr_val_loss
}, epoch)
# Saving best model
torch.save(
best_model_weights,
os.path.join(path_to_save_best_weights,
'unet{:2f}.pth'.format(best_val_loss)))
# Show the timing and final statistics
time_elapsed = time.time() - since
print('Training complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
print('Best val Loss: {:4f}'.format(best_val_loss)) # TODO add IoU
weight_decay=_C.OPTIM.WEIGHT_DECAY,
)
lr_scheduler = optim.lr_scheduler.LambdaLR( # type: ignore
optimizer,
lr_lambda=lambda iteration: 1 - iteration / _C.OPTIM.NUM_ITERATIONS)
# COS scheduler
# lr_scheduler = optim.lr_scheduler.LambdaLR( # type: ignore
# optimizer, lr_lambda=lambda iteration: np.cos(iteration / _C.OPTIM.NUM_ITERATIONS * np.pi / 2)
# )
# --------------------------------------------------------------------------------------------
# BEFORE TRAINING STARTS
# --------------------------------------------------------------------------------------------
# Tensorboard summary writer for logging losses and metrics.
tensorboard_writer = SummaryWriter(logdir=_A.serialization_dir)
# Checkpoint manager to serialize checkpoints periodically while training and keep track of
# best performing checkpoint.
checkpoint_manager = CheckpointManager(model,
optimizer,
_A.serialization_dir,
mode="max")
# Evaluator submits predictions to EvalAI and retrieves results.
evaluator = NocapsEvaluator(phase="val")
# Load checkpoint to resume training from there if specified.
# Infer iteration number through file name (it's hacky but very simple), so don't rename
# saved checkpoints if you intend to continue training.
if _A.start_from_checkpoint != "":
from torch.backends import cudnn
from torch.optim.lr_scheduler import ReduceLROnPlateau
from torch.utils.data import DataLoader
import utils.transforms as extended_transforms
from datasets import voc
from models import *
from utils import check_mkdir, evaluate, AverageMeter, CrossEntropyLoss2d
sys.path.append("../..")
cudnn.benchmark = True
ckpt_path = '../../ckpt'
exp_name = 'voc-fcn8s'
writer = SummaryWriter(os.path.join(ckpt_path, 'exp', exp_name))
args = {
'epoch_num': 300,
'lr': 1e-10,
'weight_decay': 1e-4,
'momentum': 0.95,
'lr_patience': 100, # large patience denotes fixed lr
'snapshot': '', # empty string denotes learning from scratch
'print_freq': 20,
'val_save_to_img_file': False,
'val_img_sample_rate':
0.1 # randomly sample some validation results to display
}
class Logger:
def __init__(self, model_name, data_name):
self.model_name = model_name
self.data_name = data_name
self.comment = '{}_{}'.format(model_name, data_name)
self.data_subdir = '{}/{}'.format(model_name, data_name)
# TensorBoard
self.writer = SummaryWriter(comment=self.comment)
def log(self, d_error, g_error, epoch, n_batch, num_batches):
# var_class = torch.autograd.variable.Variable
if isinstance(d_error, torch.autograd.Variable):
d_error = d_error.data.cpu().numpy()
if isinstance(g_error, torch.autograd.Variable):
g_error = g_error.data.cpu().numpy()
step = Logger._step(epoch, n_batch, num_batches)
self.writer.add_scalar('{}/D_error'.format(self.comment), d_error,
step)
self.writer.add_scalar('{}/G_error'.format(self.comment), g_error,
step)
def log_images(self,
images,
num_images,
epoch,
n_batch,
num_batches,
format='NCHW',
normalize=True):
'''
input images are expected in format (NCHW)
'''
if type(images) == np.ndarray:
images = torch.from_numpy(images)
if format == 'NHWC':
images = images.transpose(1, 3)
step = Logger._step(epoch, n_batch, num_batches)
img_name = '{}/images{}'.format(self.comment, '')
# Make horizontal grid from image tensor
horizontal_grid = vutils.make_grid(images,
normalize=normalize,
scale_each=True)
# Make vertical grid from image tensor
nrows = int(np.sqrt(num_images))
grid = vutils.make_grid(images,
nrow=nrows,
normalize=True,
scale_each=True)
# Add horizontal images to tensorboard
self.writer.add_image(img_name, horizontal_grid, step)
# Save plots
self.save_torch_images(horizontal_grid, grid, epoch, n_batch)
def save_torch_images(self,
horizontal_grid,
grid,
epoch,
n_batch,
plot_horizontal=True):
out_dir = './data/images/{}'.format(self.data_subdir)
Logger._make_dir(out_dir)
# Plot and save horizontal
fig = plt.figure(figsize=(16, 16))
plt.imshow(np.moveaxis(horizontal_grid.numpy(), 0, -1))
plt.axis('off')
if plot_horizontal:
display.display(plt.gcf())
self._save_images(fig, epoch, n_batch, 'hori')
plt.close()
# Save squared
fig = plt.figure()
plt.imshow(np.moveaxis(grid.numpy(), 0, -1))
plt.axis('off')
self._save_images(fig, epoch, n_batch)
plt.close()
def _save_images(self, fig, epoch, n_batch, comment=''):
out_dir = './data/images/{}'.format(self.data_subdir)
Logger._make_dir(out_dir)
fig.savefig('{}/{}_epoch_{}_batch_{}.png'.format(
out_dir, comment, epoch, n_batch))
def display_status(self, epoch, num_epochs, n_batch, num_batches, d_error,
g_error, d_pred_real, d_pred_fake):
# var_class = torch.autograd.variable.Variable
if isinstance(d_error, torch.autograd.Variable):
d_error = d_error.data.cpu().numpy()
if isinstance(g_error, torch.autograd.Variable):
g_error = g_error.data.cpu().numpy()
if isinstance(d_pred_real, torch.autograd.Variable):
d_pred_real = d_pred_real.data
if isinstance(d_pred_fake, torch.autograd.Variable):
d_pred_fake = d_pred_fake.data
print('Epoch: [{}/{}], Batch Num: [{}/{}]'.format(
epoch, num_epochs, n_batch, num_batches))
print('Discriminator Loss: {:.4f}, Generator Loss: {:.4f}'.format(
d_error, g_error))
print('D(x): {:.4f}, D(G(z)): {:.4f}'.format(d_pred_real.mean(),
d_pred_fake.mean()))
def save_models(self, generator, discriminator, epoch):
out_dir = './data/models/{}'.format(self.data_subdir)
Logger._make_dir(out_dir)
torch.save(generator.state_dict(),
'{}/G_epoch_{}'.format(out_dir, epoch))
torch.save(discriminator.state_dict(),
'{}/D_epoch_{}'.format(out_dir, epoch))
def close(self):
self.writer.close()
# Private Functionality
@staticmethod
def _step(epoch, n_batch, num_batches):
return epoch * num_batches + n_batch
@staticmethod
def _make_dir(directory):
try:
os.makedirs(directory)
except OSError as e:
if e.errno != errno.EEXIST:
raise
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--cuda",
default=False,
action="store_true",
help="Enable cuda")
parser.add_argument("-n", "--name", required=True, help="Name of the run")
args = parser.parse_args()
device = torch.device("cuda" if args.cuda else "cpu")
make_env = lambda: ptan.common.wrappers.wrap_dqn(
gym.make("PongNoFrameskip-v4"))
envs = [make_env() for _ in range(NUM_ENVS)]
writer = SummaryWriter(comment="-pong-a2c_" + args.name)
net = AtariA2C(envs[0].observation_space.shape,
envs[0].action_space.n).to(device)
print(net)
agent = ptan.agent.PolicyAgent(lambda x: net(x)[0],
apply_softmax=True,
device=device)
exp_source = ptan.experience.ExperienceSourceFirstLast(
envs, agent, gamma=GAMMA, steps_count=REWARD_STEPS)
optimizer = optim.Adam(net.parameters(), lr=LEARNING_RATE, eps=1e-3)
batch = []
def repeat_eval_ckpt(root_result_dir, ckpt_dir):
root_result_dir = os.path.join(root_result_dir, 'eval',
'eval_all_' + args.extra_tag)
os.makedirs(root_result_dir, exist_ok=True)
log_file = os.path.join(root_result_dir,
'log_eval_all_%s.txt' % cfg.TEST.SPLIT)
logger = create_logger(log_file)
logger.info('**********************Start logging**********************')
# save config
for key, val in vars(args).items():
logger.info("{:16} {}".format(key, val))
save_config_to_file(cfg, logger=logger)
# create dataloader & network
test_loader = create_dataloader(logger)
model = PointRCNN(num_classes=test_loader.dataset.num_class,
use_xyz=True,
mode='TEST')
model.cuda()
# copy important files to backup
backup_dir = os.path.join(root_result_dir, 'backup_files')
os.makedirs(backup_dir, exist_ok=True)
os.system('cp *.py %s/' % backup_dir)
os.system('cp ../lib/net/*.py %s/' % backup_dir)
os.system('cp ../lib/datasets/kitti_rcnn_dataset.py %s/' % backup_dir)
# evaluated ckpt record
ckpt_record_file = os.path.join(root_result_dir,
'eval_list_%s.txt' % cfg.TEST.SPLIT)
with open(ckpt_record_file, 'a'):
pass
# tensorboard log
tb_log = SummaryWriter(
log_dir=os.path.join(root_result_dir, 'tensorboard_%s' %
cfg.TEST.SPLIT))
while True:
# check whether there is checkpoint which is not evaluated
cur_epoch_id, cur_ckpt = get_no_evaluated_ckpt(ckpt_dir,
ckpt_record_file)
if cur_epoch_id == -1 or int(float(cur_epoch_id)) < args.start_epoch:
wait_second = 30
print('Wait %s second for next check: %s' %
(wait_second, ckpt_dir))
time.sleep(wait_second)
continue
# load checkpoint
train_utils.load_checkpoint(model, filename=cur_ckpt)
# start evaluation
cur_result_dir = os.path.join(root_result_dir,
'epoch_%s' % cur_epoch_id,
cfg.TEST.SPLIT)
tb_dict = eval_one_epoch(model, test_loader, cur_epoch_id,
cur_result_dir, logger)
step = int(float(cur_epoch_id))
if step == float(cur_epoch_id):
for key, val in tb_dict.items():
tb_log.add_scalar(key, val, step)
# record this epoch which has been evaluated
with open(ckpt_record_file, 'a') as f:
print('%s' % cur_epoch_id, file=f)
logger.info('Epoch %s has been evaluated' % cur_epoch_id)
from options import read_options
import numpy as np
import torch
import random
from evaluator import evaluate_synonym_ranking_prediction
from losses import TripletLoss
from tensorboardX import SummaryWriter
from test_semantic_classes import obtain_semantic_classes
from predictor import pair_prediction, pair_prediction_with_pair_feature
if __name__ == '__main__':
args = read_options()
# Add TensorBoard Writer
writer = SummaryWriter(log_dir=None, comment=args.comment)
# Initialize random seed
random.seed(args.random_seed)
torch.manual_seed(args.random_seed)
np.random.seed(args.random_seed)
if args.device_id != -1:
torch.cuda.manual_seed_all(args.random_seed)
torch.backends.cudnn.deterministic = True
torch.set_default_tensor_type(torch.cuda.FloatTensor)
else:
torch.set_default_tensor_type(torch.FloatTensor)
torch.set_printoptions(precision=9)
torch.set_num_threads(1)
# Load command line options
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Mar 4 14:48:00 2019
@author: ben
"""
import math
from tensorboardX import SummaryWriter
import torch.nn as nn
import torch
import numpy as np
writer = SummaryWriter()
#Visualise some functions
funcs = {"sin": math.sin, "cos": math.cos, "tan": math.tan}
for angle in range(-360, 360):
angle_rad = angle * math.pi / 180
for name, fun in funcs.items():
val = fun(angle_rad)
writer.add_scalar(name, val, angle)
#Visualise a model
class ANN(nn.Module):
def __init__(self, in_dim, out_dim):
checkpoint = torch.load('model_best_checkpoint_resnet50.pth.tar')
model.load_state_dict(checkpoint['state_dict'])
model.eval()
# ------------------------------------ step 3/4 : 定义损失函数和优化器等 -------------------------
lr_init = 0.0001
lr_stepsize = 20
weight_decay = 0.001
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(),
lr=lr_init,
weight_decay=weight_decay)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=lr_stepsize,
gamma=0.1)
writer = SummaryWriter('runs/resnet50')
# ------------------------------------ step 4/4 : 训练 -----------------------------------------
best_prec1 = 0
for epoch in range(epochs):
scheduler.step()
train(train_loader, model, criterion, optimizer, epoch, writer)
# 在验证集上测试效果
valid_prec1, valid_prec5 = validate(valid_loader,
model,
criterion,
epoch,
writer,
phase="VAL")
is_best = valid_prec1 > best_prec1
best_prec1 = max(valid_prec1, best_prec1)
save_checkpoint(
# from pybullet_envs.bullet.racecarGymEnv import RacecarGymEnv
# from pybullet_envs.bullet.kukaGymEnv import KukaGymEnv
from evaluator import Evaluator
from ddpg import DDPG
from util import *
from tensorboardX import SummaryWriter
from observation_processor import queue
from multi import fastenv
# from llll import Subprocess
gym.undo_logger_setup()
import time
writer = SummaryWriter()
def train(num_iterations, agent, env, evaluate, bullet):
fenv = fastenv(env, args.action_repeat, args.vis, args.atari)
window_length = args.window_length
validate_interval = args.validate_interval
save_interval = args.save_interval
max_episode_length = args.max_episode_length // args.action_repeat
debug = args.debug
visualize = args.vis
traintimes = args.traintimes
output = args.output
resume = args.resume
validate_episodes = args.validate_episodes
if resume is not None:
class H2C(nn.Module):
def __init__(self, nfeat, nhid, nout, dropout, alpha, nheads, cuda,
learning_rate_H, learning_rate_L, momentum, gamma):
super(H2C, self).__init__()
self.HigherActor, self.HigherCriticor = HigherActionModule(
cuda), HigherActionModule(cuda)
self.LowerActor = LowerActionModule(nfeat, nhid, nout, dropout, alpha,
nheads, cuda)
self.learning_rate_H = learning_rate_H
self.learning_rate_L = learning_rate_L
self.alpha = 1
self.lamda = 2
self.momentum = momentum
self.gamma = gamma
self.explore = 0.8 #initial exploration rate
self.optimizer_H = optim.Adam(self.HigherActor.parameters(),
self.learning_rate_H,
betas=[0.9, 0.999])
self.optimizer_L = optim.SGD(self.LowerActor.parameters(),
self.learning_rate_L, self.momentum)
self.loss_func_L = nn.CosineEmbeddingLoss()
self.loss_func_H = nn.MSELoss()
self.update_count_H = 0
self.update_count_L = 0
#record initialize
path = "./logging/400_500_12/"
self.writer_L = SummaryWriter(
path + 'lower/loss/' +
time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime(time.time())))
self.writer_H = SummaryWriter(
path + 'higher/loss/' +
time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime(time.time())))
self.writer_WR = SummaryWriter(
path + 'reward/whole/' +
time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime(time.time())))
self.writer_R = SummaryWriter(
path + 'reward/step/' +
time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime(time.time())))
self.writer_RA = SummaryWriter(
path + 'reward/idle/' +
time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime(time.time())))
def load_model(self, model_path):
if os.path.exists(model_path):
print("load model!")
check_point = torch.load(model_path)
self.HigherActor.load_state_dict(check_point['HigherActor'])
self.LowerActor.load_state_dict(check_point['LowerActor'])
self.HigherCriticor.load_state_dict(check_point['HigherCriticor'])
self.HigherActor.chosen_goals = check_point['chosen_goals']
def save_model(self, model_path):
if not os.path.exists("./trained_model/"):
os.mkdir("./trained_model/")
check_point = {
'HigherActor': self.HigherActor.state_dict(),
'LowerActor': self.LowerActor.state_dict(),
'HigherCriticor': self.HigherCriticor.state_dict(),
'chosen_goals': self.HigherActor.chosen_goals,
}
torch.save(check_point, model_path)
def reshape_input(self, inputs):
results = []
for node in inputs.keys():
results.append(inputs[node])
return results
def state_reshape(self, state):
# reshape private state into same dimension
state_final = []
batch_size = len(state)
for batch in range(batch_size):
state_final_one_batch = []
state_one_batch = state[batch]
for item in state_one_batch:
state_node = self.reshape_for_input_step(item)
state_final_one_batch.append(state_node)
state_final.append(state_final_one_batch)
return Variable(torch.FloatTensor(state_final).permute(1, 0, 2, 3, 4),
requires_grad=True)
def reshape_for_input_step(self, state_private):
amb_count = [
len(state_private) if len(state_private) < NUM_AMBS else NUM_AMBS
][0]
final_state = np.zeros((NUM_AMBS, 10))
if amb_count != 0:
final_state[:amb_count, :] = state_private[:amb_count]
else:
pass
final_state = final_state.reshape((1, NUM_AMBS, 10))
return final_state
def select_higher_action(self, state_now, bufferhigher, t, goal, flag):
#select the optimal distribution state as higher action from replay buffer in training process.
#two pattern could be chosen select.For online training, select the goal not the state.
update_count = bufferhigher.counts()
if bufferhigher.counts() == 0:
return goal
else:
state, reward, new_state, done, T, next_T, real_goal = bufferhigher.getBatch(
update_count)
states, values = self.HigherActor(
Variable(
torch.cat([
torch.FloatTensor(state_now).view(-1, NUM_NODES),
torch.FloatTensor(t).view(-1, NUM_TIMESTEP)
],
dim=1).repeat(
torch.FloatTensor(real_goal).shape[0],
1).cuda().view(-1, NUM_NODES + NUM_TIMESTEP,
1)),
Variable(
torch.FloatTensor(real_goal).cuda().view(-1, NUM_NODES,
1)))
states2, values2 = self.HigherActor(
Variable(
torch.cat([
torch.FloatTensor(state_now).view(-1, NUM_NODES),
torch.FloatTensor(t).view(-1, NUM_TIMESTEP)
],
dim=1).repeat(
torch.FloatTensor(state).shape[0],
1).cuda().view(-1, NUM_NODES + NUM_TIMESTEP,
1)),
Variable(
torch.FloatTensor(state).cuda().view(-1, NUM_NODES, 1)))
max_index = values.max(0)[1].data[0].cpu().numpy().tolist()
max_index_2 = values2.max(0)[1].data[0].cpu().numpy().tolist()
if np.random.random(1) > 0:
goal = state[max_index_2]
else:
goal = real_goal[max_index]
if flag: #flag=1 if online training
goal = real_goal[max_index]
return goal
def update_learningrate(self):
self.explore = self.explore * 1.01
def select_lower_action(self, state_pri, state_order, adj, idle_num, goal,
n_round, online_times, flag, T):
# preprocesing for private state
state_node = [state_pri]
state_pri = self.state_reshape(state_node)
# output the probability of actions for agents in each node
value_list = self.LowerActor(state_pri, state_order, goal, adj, T)
#select the optimal actions
action = value_list.max(2)[1].permute(2, 1,
0).data.cpu().numpy().tolist()
# cut out the idle agents' action
action_list = [
action[i][:idle_num[i]]
if idle_num[i] <= NUM_AMBS else action[i][:idle_num[i]]
for i in range(len(idle_num))
]
# exploration with 1- self.explore
if n_round < online_times:
for j in range(len(action_list)):
if len(action_list[j]) > 0:
for z in range(len(action_list[j])):
if np.random.random(1) >= self.explore:
action_list[j][z] = [
np.random.choice(range(NUM_ACTIONS), 1).item()
]
else:
pass
else:
pass
else:
pass
return action_list
def update_actor(self, buffers, batch_size, adj):
state_pri, idle_driver, action, goal, state_higher, next_state_higher, reward, done, T, next_T, order_num, next_goal = buffers.getBatch(
batch_size)
#sample one batch of tuple to update
loss = self.update_higher_actor(state_higher, reward,
next_state_higher, done, T, next_T,
goal, next_goal)
self.update_lower_actor(state_pri, order_num, idle_driver, action,
goal, state_higher, next_state_higher, adj,
loss, batch_size, T)
if self.update_count_L % 288 == 0:
self.update_learningrate()
def update_higher_actor(self, state, reward, new_state, done, T, next_T,
goal, next_goal):
state = torch.FloatTensor(state).cuda().view(-1, NUM_NODES, 1)
reward = Variable(torch.FloatTensor(reward).cuda().view(-1, 1),
requires_grad=True)
done = Variable(torch.FloatTensor(done).cuda().view(-1, 1),
requires_grad=True)
next_state = Variable(torch.FloatTensor(new_state).cuda().view(
-1, NUM_NODES, 1),
requires_grad=True)
GAMMA = torch.Tensor(np.ones(
(next_state.size(0), 1)) * self.gamma).cuda()
T = torch.FloatTensor(T).cuda().view(-1, NUM_TIMESTEP, 1)
next_T = torch.FloatTensor(next_T).cuda().view(-1, NUM_TIMESTEP, 1)
state = Variable(torch.cat([state, T],
dim=1).view(-1, NUM_TIMESTEP + NUM_NODES,
1),
requires_grad=True)
new_state = Variable(torch.cat([next_state, next_T],
dim=1).view(-1,
NUM_TIMESTEP + NUM_NODES,
1),
requires_grad=True)
goal = Variable(torch.FloatTensor(goal).cuda().view(-1, NUM_NODES, 1),
requires_grad=True)
next_goal = Variable(torch.FloatTensor(next_goal).cuda().view(
-1, NUM_NODES, 1),
requires_grad=True)
predict_state, value = self.HigherActor(state, goal)
predict_next_state, next_value = self.HigherCriticor(
new_state, next_goal)
expect_value = reward + torch.mul(torch.mul(GAMMA, next_value), done)
TD_ERROR = expect_value - value
predict_state = predict_state.view(-1, NUM_NODES, 1)
target = torch.ones_like(reward).cuda()
loss_value = self.loss_func_H(value, expect_value)
loss_state = self.loss_func_L(predict_state, next_state, target)
loss = loss_state * self.alpha + loss_value
self.writer_H.add_scalar('loss/value_loss_higher', loss,
self.update_count_H)
self.writer_H.add_scalar('loss/value_loss_value', loss_value,
self.update_count_H)
self.writer_H.add_scalar('loss/value_loss_state', loss_state,
self.update_count_H)
self.optimizer_H.zero_grad()
loss.backward()
self.optimizer_H.step()
self.update_count_H += 1
if self.update_count_H % 50 == 0:
self.HigherCriticor.load_state_dict(self.HigherActor.state_dict())
return TD_ERROR
def update_lower_actor(self, state_pri, order_num, idle_driver, action,
goal, state_higher, next_state_higher, adj,
loss_higher, batch_size, T):
state_pri = self.state_reshape(state_pri)
value_list = self.LowerActor(state_pri, order_num, goal, adj,
T).permute(0, 1, 3, 2)
next_state_higher = np.array(next_state_higher) - np.array(
state_higher)
goal = np.array(goal) - np.array(state_higher)
next_state_higher_vec = Variable(
torch.FloatTensor(next_state_higher).cuda().view(-1, NUM_NODES, 1),
requires_grad=True)
goal_vec = Variable(torch.FloatTensor(goal).cuda().view(
-1, NUM_NODES, 1),
requires_grad=True)
target = torch.ones_like(goal_vec).cuda()[:, 1, :].view(-1, 1)
grad_loss = self.loss_func_L(next_state_higher_vec, goal_vec, target)
#mask
action_space = []
for batch in range(batch_size):
action_space_batch = []
action_batch = action[batch]
for act_node in action_batch:
action_space_node = np.zeros(NUM_AMBS * NUM_ACTIONS)
for i in range(len(act_node)):
action_space_node[i * NUM_ACTIONS + act_node[i][0]] += 1
action_space_node = [
True if x == 1 else False for x in action_space_node
]
action_space_batch.append(action_space_node)
action_space.append(action_space_batch)
action_space = torch.ByteTensor(action_space).cuda()
action_space = action_space.squeeze(2)
log_action = torch.log(value_list).view(-1, NUM_NODES,
NUM_AMBS * NUM_ACTIONS)
loss = -1 * (
log_action.masked_select(action_space) *
(loss_higher.detach() - self.lamda * grad_loss.detach())).mean()
self.writer_L.add_scalar('loss/value_loss_lower', loss,
self.update_count_L)
self.writer_L.add_scalar('loss/value_loss_lower_TD',
loss_higher.mean(), self.update_count_L)
self.writer_L.add_scalar('loss/value_loss_lower_GRAD', grad_loss,
self.update_count_L)
self.optimizer_L.zero_grad()
loss.backward()
self.optimizer_L.step()
self.update_count_L += 1
def main():
cfg = Config()
# Redirect logs to both console and file.
if cfg.log_to_file:
ReDirectSTD(cfg.stdout_file, 'stdout', False)
ReDirectSTD(cfg.stderr_file, 'stderr', False)
# Lazily create SummaryWriter
writer = None
TVT, TMO = set_devices(cfg.sys_device_ids)
if cfg.seed is not None:
set_seed(cfg.seed)
# Dump the configurations to log.
import pprint
print('-' * 60)
print('cfg.__dict__')
pprint.pprint(cfg.__dict__)
print('-' * 60)
###########
# Dataset #
###########
train_set = create_dataset(**cfg.train_set_kwargs)
test_sets = []
test_set_names = []
if cfg.dataset == 'combined':
for name in ['market1501', 'cuhk03', 'duke']:
cfg.test_set_kwargs['name'] = name
test_sets.append(create_dataset(**cfg.test_set_kwargs))
test_set_names.append(name)
else:
test_sets.append(create_dataset(**cfg.test_set_kwargs))
test_set_names.append(cfg.dataset)
###########
# Models #
###########
model = Model(local_conv_out_channels=cfg.local_conv_out_channels,
num_classes=len(train_set.ids2labels))
# Model wrapper
model_w = DataParallel(model)
#############################
# Criteria and Optimizers #
#############################
id_criterion = nn.CrossEntropyLoss()
g_tri_loss = TripletLoss(margin=cfg.global_margin)
l_tri_loss = TripletLoss(margin=cfg.local_margin)
optimizer = optim.Adam(model.parameters(),
lr=cfg.base_lr,
weight_decay=cfg.weight_decay)
# Bind them together just to save some codes in the following usage.
modules_optims = [model, optimizer]
################################
# May Resume Models and Optims #
################################
if cfg.resume:
resume_ep, scores = load_ckpt(modules_optims, cfg.ckpt_file)
# May Transfer Models and Optims to Specified Device. Transferring optimizer
# is to cope with the case when you load the checkpoint to a new device.
TMO(modules_optims)
########
# Test #
########
def test(load_model_weight=False):
if load_model_weight:
if cfg.model_weight_file != '':
map_location = (lambda storage, loc: storage)
sd = torch.load(cfg.model_weight_file, map_location=map_location)
load_state_dict(model, sd)
print('Loaded model weights from {}'.format(cfg.model_weight_file))
else:
load_ckpt(modules_optims, cfg.ckpt_file)
use_local_distance = (cfg.l_loss_weight > 0) \
and cfg.local_dist_own_hard_sample
for test_set, name in zip(test_sets, test_set_names):
test_set.set_feat_func(ExtractFeature(model_w, TVT))
print('\n=========> Test on dataset: {} <=========\n'.format(name))
test_set.eval(
normalize_feat=cfg.normalize_feature,
use_local_distance=use_local_distance)
if cfg.only_test:
test(load_model_weight=True)
return
############
# Training #
############
start_ep = resume_ep if cfg.resume else 0
for ep in range(start_ep, cfg.total_epochs):
# Adjust Learning Rate
if cfg.lr_decay_type == 'exp':
adjust_lr_exp(
optimizer,
cfg.base_lr,
ep + 1,
cfg.total_epochs,
cfg.exp_decay_at_epoch)
else:
adjust_lr_staircase(
optimizer,
cfg.base_lr,
ep + 1,
cfg.staircase_decay_at_epochs,
cfg.staircase_decay_multiply_factor)
may_set_mode(modules_optims, 'train')
g_prec_meter = AverageMeter()
g_m_meter = AverageMeter()
g_dist_ap_meter = AverageMeter()
g_dist_an_meter = AverageMeter()
g_loss_meter = AverageMeter()
l_prec_meter = AverageMeter()
l_m_meter = AverageMeter()
l_dist_ap_meter = AverageMeter()
l_dist_an_meter = AverageMeter()
l_loss_meter = AverageMeter()
id_loss_meter = AverageMeter()
loss_meter = AverageMeter()
ep_st = time.time()
step = 0
epoch_done = False
while not epoch_done:
step += 1
step_st = time.time()
ims, im_names, labels, mirrored, epoch_done = train_set.next_batch()
ims_var = Variable(TVT(torch.from_numpy(ims).float()))
labels_t = TVT(torch.from_numpy(labels).long())
labels_var = Variable(labels_t)
global_feat, local_feat, logits = model_w(ims_var)
g_loss, p_inds, n_inds, g_dist_ap, g_dist_an, g_dist_mat = global_loss(
g_tri_loss, global_feat, labels_t,
normalize_feature=cfg.normalize_feature)
if cfg.l_loss_weight == 0:
l_loss = 0
elif cfg.local_dist_own_hard_sample:
# Let local distance find its own hard samples.
l_loss, l_dist_ap, l_dist_an, _ = local_loss(
l_tri_loss, local_feat, None, None, labels_t,
normalize_feature=cfg.normalize_feature)
else:
l_loss, l_dist_ap, l_dist_an = local_loss(
l_tri_loss, local_feat, p_inds, n_inds, labels_t,
normalize_feature=cfg.normalize_feature)
id_loss = 0
if cfg.id_loss_weight > 0:
id_loss = id_criterion(logits, labels_var)
loss = g_loss * cfg.g_loss_weight \
+ l_loss * cfg.l_loss_weight \
+ id_loss * cfg.id_loss_weight
optimizer.zero_grad()
loss.backward()
optimizer.step()
############
# Step Log #
############
# precision
g_prec = (g_dist_an > g_dist_ap).data.float().mean()
# the proportion of triplets that satisfy margin
g_m = (g_dist_an > g_dist_ap + cfg.global_margin).data.float().mean()
g_d_ap = g_dist_ap.data.mean()
g_d_an = g_dist_an.data.mean()
g_prec_meter.update(g_prec)
g_m_meter.update(g_m)
g_dist_ap_meter.update(g_d_ap)
g_dist_an_meter.update(g_d_an)
g_loss_meter.update(to_scalar(g_loss))
if cfg.l_loss_weight > 0:
# precision
l_prec = (l_dist_an > l_dist_ap).data.float().mean()
# the proportion of triplets that satisfy margin
l_m = (l_dist_an > l_dist_ap + cfg.local_margin).data.float().mean()
l_d_ap = l_dist_ap.data.mean()
l_d_an = l_dist_an.data.mean()
l_prec_meter.update(l_prec)
l_m_meter.update(l_m)
l_dist_ap_meter.update(l_d_ap)
l_dist_an_meter.update(l_d_an)
l_loss_meter.update(to_scalar(l_loss))
if cfg.id_loss_weight > 0:
id_loss_meter.update(to_scalar(id_loss))
loss_meter.update(to_scalar(loss))
if step % cfg.log_steps == 0:
time_log = '\tStep {}/Ep {}, {:.2f}s'.format(
step, ep + 1, time.time() - step_st, )
if cfg.g_loss_weight > 0:
g_log = (', gp {:.2%}, gm {:.2%}, '
'gd_ap {:.4f}, gd_an {:.4f}, '
'gL {:.4f}'.format(
g_prec_meter.val, g_m_meter.val,
g_dist_ap_meter.val, g_dist_an_meter.val,
g_loss_meter.val, ))
else:
g_log = ''
if cfg.l_loss_weight > 0:
l_log = (', lp {:.2%}, lm {:.2%}, '
'ld_ap {:.4f}, ld_an {:.4f}, '
'lL {:.4f}'.format(
l_prec_meter.val, l_m_meter.val,
l_dist_ap_meter.val, l_dist_an_meter.val,
l_loss_meter.val, ))
else:
l_log = ''
if cfg.id_loss_weight > 0:
id_log = (', idL {:.4f}'.format(id_loss_meter.val))
else:
id_log = ''
total_loss_log = ', loss {:.4f}'.format(loss_meter.val)
log = time_log + \
g_log + l_log + id_log + \
total_loss_log
print(log)
#############
# Epoch Log #
#############
time_log = 'Ep {}, {:.2f}s'.format(ep + 1, time.time() - ep_st, )
if cfg.g_loss_weight > 0:
g_log = (', gp {:.2%}, gm {:.2%}, '
'gd_ap {:.4f}, gd_an {:.4f}, '
'gL {:.4f}'.format(
g_prec_meter.avg, g_m_meter.avg,
g_dist_ap_meter.avg, g_dist_an_meter.avg,
g_loss_meter.avg, ))
else:
g_log = ''
if cfg.l_loss_weight > 0:
l_log = (', lp {:.2%}, lm {:.2%}, '
'ld_ap {:.4f}, ld_an {:.4f}, '
'lL {:.4f}'.format(
l_prec_meter.avg, l_m_meter.avg,
l_dist_ap_meter.avg, l_dist_an_meter.avg,
l_loss_meter.avg, ))
else:
l_log = ''
if cfg.id_loss_weight > 0:
id_log = (', idL {:.4f}'.format(id_loss_meter.avg))
else:
id_log = ''
total_loss_log = ', loss {:.4f}'.format(loss_meter.avg)
log = time_log + \
g_log + l_log + id_log + \
total_loss_log
print(log)
# Log to TensorBoard
if cfg.log_to_file:
if writer is None:
writer = SummaryWriter(log_dir=osp.join(cfg.exp_dir, 'tensorboard'))
writer.add_scalars(
'loss',
dict(global_loss=g_loss_meter.avg,
local_loss=l_loss_meter.avg,
id_loss=id_loss_meter.avg,
loss=loss_meter.avg, ),
ep)
writer.add_scalars(
'tri_precision',
dict(global_precision=g_prec_meter.avg,
local_precision=l_prec_meter.avg, ),
ep)
writer.add_scalars(
'satisfy_margin',
dict(global_satisfy_margin=g_m_meter.avg,
local_satisfy_margin=l_m_meter.avg, ),
ep)
writer.add_scalars(
'global_dist',
dict(global_dist_ap=g_dist_ap_meter.avg,
global_dist_an=g_dist_an_meter.avg, ),
ep)
writer.add_scalars(
'local_dist',
dict(local_dist_ap=l_dist_ap_meter.avg,
local_dist_an=l_dist_an_meter.avg, ),
ep)
# save ckpt
if cfg.log_to_file:
save_ckpt(modules_optims, ep + 1, 0, cfg.ckpt_file)
########
# Test #
########
test(load_model_weight=False)
def test(env):
n_test_round = 20
step_higher = 12
model_path = "./trained_model/model_400_50_12checkpoint.pth"
writer = SummaryWriter(
'./logging/400_500_12/reward/test/' +
time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime(time.time())))
model = H2C(nfeat=128,
nhid=100,
nout=100,
dropout=0.1,
alpha=0.05,
nheads=2,
cuda=True,
learning_rate_H=0.005,
learning_rate_L=0.01,
momentum=0.78,
gamma=0.8)
model.load_model(model_path=model_path)
public_state_last_round = np.random.randint(1, 20, size=(NUM_TIMESTEP))
for j in range(n_test_round):
print("round {}".format(j))
env.reset()
env.step_ini()
state_private = env.get_observation_private()
state_statistic = env.get_observation_statistic()
select_higher_action_T = [
env.StatetoOneHot([i], NUM_TIMESTEP) for i in range(NUM_TIMESTEP)
]
for i in range(NUM_TIMESTEP - 1):
# print(state_private)
if i % 30 == 0:
print("step {}".format(i))
else:
pass
T = select_higher_action_T[i]
next_T = select_higher_action_T[i + 1]
if i % step_higher == 0:
goal = model.HigherActor.chosen_goals[math.floor(i /
step_higher)]
else:
pass
joint_action = model.select_lower_action(
state_private['state_pri'],
state_private['order_num'],
env.adj,
state_private['idle_driver'],
goal,
j,
online_times=0,
flag=False,
T=T)
reward, next_state_pri, next_state_sta, done = env.step(
joint_action)
state_private = next_state_pri
state_statistic = next_state_sta
whole_reward = sum(env.final_response_rate['finish']) / sum(
env.final_response_rate['all'])
writer.add_scalar('Whole_value/reward', whole_reward, j)
train_obs_v = torch.FloatTensor(train_obs)
train_act_v = torch.LongTensor(train_act)
return train_obs_v, train_act_v, reward_bound, reward_mean
if __name__ == "__main__":
env = DiscreteOneHotWrapper(gym.make("FrozenLake-v0"))
# env = gym.wrappers.Monitor(env, directory="mon", force=True)
obs_size = env.observation_space.shape[0]
n_actions = env.action_space.n
net = Net(obs_size, HIDDEN_SIZE, n_actions)
objective = nn.CrossEntropyLoss()
optimizer = optim.Adam(params=net.parameters(), lr=0.01)
writer = SummaryWriter(comment="-frozenlake-naive")
for iter_no, batch in enumerate(iterate_batches(env, net, BATCH_SIZE)):
obs_v, acts_v, reward_b, reward_m = filter_batch(batch, PERCENTILE)
optimizer.zero_grad()
action_scores_v = net(obs_v)
loss_v = objective(action_scores_v, acts_v)
loss_v.backward()
optimizer.step()
print("%d: loss=%.3f, reward_mean=%.1f, reward_bound=%.1f" % (
iter_no, loss_v.item(), reward_m, reward_b))
writer.add_scalar("loss", loss_v.item(), iter_no)
writer.add_scalar("reward_bound", reward_b, iter_no)
writer.add_scalar("reward_mean", reward_m, iter_no)
if reward_m > 0.8:
print("Solved!")
def main():
env = gym.make(env_name)
env.seed(500)
torch.manual_seed(500)
# num_inputs = env.observation_space.shape[0]
num_inputs = 2
num_actions = env.action_space.n
print('state size:', num_inputs)
print('action size:', num_actions)
online_net = DRQN(num_inputs, num_actions)
target_net = DRQN(num_inputs, num_actions)
update_target_model(online_net, target_net)
optimizer = optim.Adam(online_net.parameters(), lr=lr)
N_EPISODES = 5000
# scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, N_EPISODES)
writer = SummaryWriter('logs')
online_net.to(device)
target_net.to(device)
online_net.train()
target_net.train()
memory = Memory(replay_memory_capacity)
running_score = 0
epsilon = 1.0
steps = 0
loss = 0
for e in range(N_EPISODES):
done = False
score = 0
state = env.reset()
state = state_to_partial_observability(state)
state = torch.Tensor(state).to(device)
hidden = None
while not done:
steps += 1
# print(state.type(), hidden)
action, hidden = get_action(state, target_net, epsilon, env,
hidden)
next_state, reward, done, _ = env.step(action)
next_state = state_to_partial_observability(next_state)
next_state = torch.Tensor(next_state).to(device)
mask = 0 if done else 1
reward = reward if not done or score == 499 else -1
memory.push(state, next_state, action, reward, mask)
score += reward
state = next_state
if steps > initial_exploration and len(memory) > batch_size:
epsilon -= 0.00005
epsilon = max(epsilon, 0.01)
batch = memory.sample(batch_size)
loss = DRQN.train_model(online_net, target_net, optimizer,
batch)
if steps % update_target == 0:
update_target_model(online_net, target_net)
# scheduler.step()
score = score if score == 500.0 else score + 1
if running_score == 0:
running_score = score
else:
running_score = 0.99 * running_score + 0.01 * score
if e % log_interval == 0:
print(
'{} episode | score: {:.2f} | loss: {:.5f} | epsilon: {:.2f}'.
format(e, running_score, loss, epsilon))
writer.add_scalar('log/score', float(running_score), e)
writer.add_scalar('log/loss', float(loss), e)
if running_score > goal_score:
break
