class VisdomPlotter(object): """Plots to Visdom""" def __init__(self, env_name='gan'): self.viz = Visdom(server="http://0.0.0.0", port="800") self.env = env_name self.plots = {} def plot(self, var_name, split_name, x, y, xlabel='epoch'): if var_name not in self.plots: self.plots[var_name] = self.viz.line(X=np.array([x, x]), Y=np.array([y, y]), env=self.env, opts=dict(legend=[split_name], title=var_name, xlabel=xlabel, ylabel=var_name)) else: self.viz.line(X=np.array([x]), Y=np.array([y]), update="append", env=self.env, win=self.plots[var_name], name=split_name) def draw(self, var_name, images): if var_name not in self.plots: self.plots[var_name] = self.viz.images(images, env=self.env) else: self.viz.images(images, env=self.env, win=self.plots[var_name])
def main(): cnn = CNN() cnn.load_state_dict(torch.load('model.pkl')) print("load cnn net.") predict_dataloader = my_dataset.get_predict_data_loader() vis = Visdom() for i, (images, labels) in enumerate(predict_dataloader): image = images vimage = Variable(image) predict_label = cnn(vimage) c0 = captcha_setting.ALL_CHAR_SET[np.argmax( predict_label[0, 0:captcha_setting.ALL_CHAR_SET_LEN].data.numpy())] c1 = captcha_setting.ALL_CHAR_SET[np.argmax( predict_label[0, captcha_setting.ALL_CHAR_SET_LEN:2 * captcha_setting.ALL_CHAR_SET_LEN].data.numpy())] c2 = captcha_setting.ALL_CHAR_SET[np.argmax( predict_label[0, 2 * captcha_setting.ALL_CHAR_SET_LEN:3 * captcha_setting.ALL_CHAR_SET_LEN].data.numpy())] c3 = captcha_setting.ALL_CHAR_SET[np.argmax( predict_label[0, 3 * captcha_setting.ALL_CHAR_SET_LEN:4 * captcha_setting.ALL_CHAR_SET_LEN].data.numpy())] c = '%s%s%s%s' % (c0, c1, c2, c3) print(c) vis.images(image, opts=dict(caption=c))
class SampleImage(object): """ Make a grid and plot a class of image on one row """ def __init__(self, n_row, n_col): self.n_row = n_row self.n_col = n_col self.viz = Visdom() self.fixed_z = None self.win = None def __call__(self, trainer, gan_model): if trainer: global_step = trainer.global_step else: global_step = 0 if self.fixed_z is None: self.fixed_z = gan_model.sample_latent_code(self.n_row * self.n_col) output_images = (gan_model.generate('fixed', self.fixed_z) + 1.) / 2. if self.win is None: self.win = self.viz.images( output_images, nrow=self.n_row, opts=dict(caption='Step: {}'.format(global_step))) else: self.viz.images(output_images, nrow=self.n_row, win=self.win, opts=dict(caption='Step: {}'.format(global_step)))
class VisdomPlotter(object): """Plots to Visdom Server""" def __init__(self, env_name='gan'): """Initilized visdom, environment and plots dictionary""" self.viz = Visdom() self.env = env_name self.plots = {} def plot(self, var_name, split_name, x, y, xlabel='epoch'): """ Plots graphs in visdom server. Usually generator/discrimantor loss values """ if var_name not in self.plots: self.plots[var_name] = self.viz.line(X=np.array([x, x]), Y=np.array([y, y]), env=self.env, opts=dict(legend=[split_name], title=var_name, xlabel=xlabel, ylabel=var_name)) else: self.viz.updateTrace(X=np.array([x]), Y=np.array([y]), env=self.env, win=self.plots[var_name], name=split_name) def draw(self, var_name, images): """ Draws images in visdom server """ if var_name not in self.plots: self.plots[var_name] = self.viz.images(images, env=self.env) else: self.viz.images(images, env=self.env, win=self.plots[var_name])
def test_omniglot(): viz = Visdom(port=8000, env='main') splits = load_omniglot() n_way, n_support, n_query = 3, 5, 7 # task = omniglot_task(splits['train'], n_way=3, n_support=5, n_query=7) batch_size = 2 for i, batch in enumerate( taskbatch(omniglot_task, batch_size=batch_size, n_task=batch_size, split_dict=splits['val'], n_way=n_way, n_support=n_support, n_query=n_query)): for i_task in range(batch_size): x_train = batch['x_train'][i_task] x_test = batch['x_test'][i_task] y_train = batch['y_train'][i_task] y_test = batch['y_test'][i_task] viz.images(tensor=np.transpose(x_train, (0, 3, 1, 2)), nrow=n_support) viz.text(f'y_train: {y_train}') viz.images(tensor=np.transpose(x_test, (0, 3, 1, 2)), nrow=n_query) viz.text(f'y_test: {y_test}') viz.save(viz.get_env_list())
class VisdomLinePlotter(object): """Plots to Visdom""" def __init__(self, env_name='main'): self.viz = Visdom() self.env = env_name self.plots = {} def plot(self, var_name, split_name, title_name, x, y): if var_name not in self.plots: self.plots[var_name] = self.viz.line(X=np.array([x, x]), Y=np.array([y, y]), env=self.env, opts=dict(legend=[split_name], title=title_name, xlabel='Epochs', ylabel=var_name)) else: self.viz.line(X=np.array([x]), Y=np.array([y]), env=self.env, win=self.plots[var_name], name=split_name, update='append') def images(self, data, win, opts): self.viz.images(data, win=win, env=self.env, opts=opts) def text(self, pred, win, opts): self.viz.text(pred, win=win, opts=opts, env=self.env)
class VisdomPlotter(object): """Plots to Visdom""" def __init__(self, env_name='gan'): self.viz = Visdom(port=7777) self.env = env_name self.plots = {} def plot(self, var_name, split_name, x, y, xlabel='epoch'): x = list(range(y.shape[0])) if var_name not in self.plots: self.plots[var_name] = self.viz.line(X=np.asarray([x]), Y=np.asarray([y]), env=self.env, opts=dict(legend=[split_name], title=var_name, xlabel=xlabel, ylabel=var_name)) else: self.viz.line(X=np.asarray([x]), Y=np.asarray([y]), env=self.env, win=self.plots[var_name], name=split_name) def draw(self, var_name, images): if var_name not in self.plots: self.plots[var_name] = self.viz.images(images, env=self.env) else: self.viz.images(images, env=self.env, win=self.plots[var_name])
class VisdomPlotter(object): """Plots to Visdom""" def __init__(self, env_name='main'): self.viz = Visdom() self.env = env_name self.plots = {} self.paramList = {} def argsTile(self, argsDict): self.paramList = self.viz.text('<b>Training Parameters:</b>\n', env=self.env, opts=dict(width=220,height=320)) for key, value in argsDict.items(): self.viz.text(str(key) + ' = ' + str(value) + '\n', env=self.env, win=self.paramList, append=True) def plot(self, var_name, split_name, x, y): if var_name not in self.plots: self.plots[var_name] = self.viz.line(X=np.array([x,x]), Y=np.array([y,y]), env=self.env, opts=dict(legend=[split_name], title=var_name, xlabel='Epochs', ylabel=var_name)) else: self.viz.line(X=np.array([x]), Y=np.array([y]), env=self.env, win=self.plots[var_name], name=split_name, update='append') def showImage(self, imageTensor): # self.viz.image(imageTensor, win=self.images, env=self.env, opts=dict(title='Original and Reconstructed', caption='How random.'),) self.viz.images(imageTensor, win=self.images, env=self.env, opts=dict(title='Original and Reconstructed', caption='How random.', nrow=2),) def plotPerformance(self, var_name, split_name, x, y): if var_name not in self.plots: self.plots[var_name] = self.viz.line(X=x, Y=y, env=self.env, opts=dict(legend=[split_name], title=var_name, xlabel='Epochs', ylabel=var_name)) else: self.viz.line(X=x, Y=y, env=self.env, win=self.plots[var_name], name=split_name, update='append')
class VisdomPlotter(object): """Plots to Visdom""" def __init__(self, env_name='relational_net'): self.viz = Visdom() self.env = env_name self.plots = {} def plot(self, var_name, split_name, x, y, xlabel='iteration'): if var_name not in self.plots: self.plots[var_name] = self.viz.line(X=np.array([x, x]), Y=np.array([y, y]), env=self.env, opts=dict(legend=[split_name], title=var_name, xlabel=xlabel, ylabel=var_name)) else: self.viz.updateTrace(X=np.array([x]), Y=np.array([y]), env=self.env, win=self.plots[var_name], name=split_name) def draw(self, var_name, images): images = (images + 0.5) * 255 if var_name not in self.plots: self.plots[var_name] = self.viz.images(images, env=self.env) else: self.viz.images(images, env=self.env, win=self.plots[var_name]) def print(self, var_name, text): if var_name not in self.plots: self.plots[var_name] = self.viz.text(text, env=self.env) else: self.viz.text(text, env=self.env, win=self.plots[var_name])
class VisdomPlotter(object): def __init__(self, env_name='gan'): self.viz = Visdom() self.env = env_name self.plots = {} def plot(self, var_name, split_name, x, y, xlabel='epoch'): if var_name not in self.plots: self.plots[var_name] = self.viz.line(X=np.array([x, x]), Y=np.array([y, y]), env=self.env, opts=dict(legend=[split_name], title=var_name, xlabel=xlabel, ylabel=var_name)) else: self.viz.updateTrace(X=np.array([x]), Y=np.array([y]), env=self.env, win=self.plots[var_name], name=split_name) def draw(self, var_name, images): if var_name not in self.plots: self.plots[var_name] = self.viz.images(images, env=self.env) else: self.viz.images(images, env=self.env, win=self.plots[var_name])
class SampleImage(object): """ Make a grid and plot a class of image on one row """ def __init__(self, n_row, nb_classes, code_size): self.n_row = n_row self.viz = Visdom() self.fixed_z = np.random.normal(0, 1, (n_row * nb_classes, code_size)) self.labels = np.array( [num for _ in range(self.n_row) for num in range(nb_classes)]) self.win = None def __call__(self, trainer, gan_model): global_step = trainer.global_step output_images = (gan_model.generate( 'fixed', self.fixed_z, torch.from_numpy(self.labels)) + 1.) / 2. if self.win is None: self.win = self.viz.images( output_images, nrow=self.n_row, opts=dict(caption='Step: {}'.format(global_step))) else: self.viz.images(output_images, nrow=self.n_row, win=self.win, opts=dict(caption='Step: {}'.format(global_step)))
class Visualizer: def __init__(self): self.vis = Visdom() self.real_image = None self.real_heatmap = None self.real_concat = None self.real_batch = None self.fake_image = None self.fake_concat = None self.fake_heatmap = None self.fake_batch = None self.loss = None self.point = 0 def initiate_windows(self): random_image = torch.rand(1, 256, 256) random_batch = torch.rand(8, 1, 256, 256) self.real_image = self.vis.image(random_image, win="real_img", opts={"caption": "Real image"}) self.real_heatmap = self.vis.image(random_image, win="real_map") self.real_concat = self.vis.image(random_image, win="real_cat") self.real_batch = self.vis.images(random_batch, win="real_batch") self.fake_image = self.vis.image(random_image, win="fake_img") self.fake_concat = self.vis.image(random_image, win="fake_cat") self.fake_heatmap = self.vis.image(random_image, win="fake_map") self.fake_batch = self.vis.images(random_batch, win="fake_batch") self.loss = self.vis.line(X=torch.zeros(1), Y=torch.zeros(1, 2), win="loss", opts={ "xlabel": "Iteration", "ylabel": "Loss", "title": "Training progression", "legend": ["pred real", "pred fake"], }) self.point = 0 def update_image(self, img, name): self.vis.image(img, win=name, opts={"caption": name}) def update_batch(self, batch, name): self.vis.images(batch, win=name, opts={"caption": name}, nrow=8) def update_loss(self, pred_real, pred_fake): self.vis.line(X=torch.ones(1, 2) * self.point, Y=torch.stack([pred_real, pred_fake], dim=1), win="loss", update="append", opts={ "xlabel": "Iteration", "ylabel": "Loss", "title": "Here is a title", "legend": ["pred real", "pred fake"], }) self.point += 1
class VisdomLogger: def __init__(self, visdom_env='main', log_every=10, prefix=''): self.vis = None self.log_every = log_every self.prefix = prefix if visdom_env is not None: self.vis = Visdom(env=visdom_env) self.vis.close() def on_batch_end(self, state): iters = state['iters'] if self.log_every != -1 and iters % self.log_every == 0: self.log(iters, state['metrics']) def on_epoch_end(self, state): self.log(state['iters'], state['metrics']) def log(self, iters, xs, store_history=[]): if self.vis is None: return for name, x in xs.items(): name = self.prefix + name if isinstance(x, (float, int)): self.vis.line(X=[iters], Y=[x], update='append', win=name, opts=dict(title=name), name=name) elif isinstance(x, str): self.vis.text(x, win=name, opts=dict(title=name)) elif isinstance(x, torch.Tensor): if x.numel() == 1: self.vis.line(X=[iters], Y=[x.item()], update='append', win=name, opts=dict(title=name), name=name) elif x.dim() == 2: self.vis.heatmap(x, win=name, opts=dict(title=name)) elif x.dim() == 3: self.vis.image(x, win=name, opts=dict(title=name, store_history=name in store_history)) elif x.dim() == 4: self.vis.images(x, win=name, opts=dict(title=name, store_history=name in store_history)) else: assert False, "incorrect tensor dim" else: assert False, "incorrect type " + x.__class__.__name__
class Dashboard(): def __init__(self, port=8097): self.vis = Visdom(port=port) def grid_plot(self, images, nrow): self.vis.images(images, nrow=nrow, padding=10, opts=dict(title='Results'))
class Visualizer: def __init__(self, env='default', **kwargs): self.vis = Visdom(env=env, **kwargs) self.index = {} self.log = '' def reinit(self, env='default', **kwargs): # 重新配置visdom self.vis = Visdom(env=env, **kwargs) return self def plot_many(self, d): for k, v in d.items(): self.plot(k, v) def img_many(self, d): for k, v in d.items(): self.img(k, v) def plot(self, name, y): x = self.index.get(name, 0) self.vis.line(X=np.array([x]), Y=np.array([y]), win=name, opts=dict(title=name), update=None if x == 0 else 'append') self.index[name] = x + 1 def img(self, name, img_): if len(img_.size()) < 3: img_ = img_.cpu().unsqueeze(0) self.vis.images(tensor=img_.cpu(), win=name, opts=dict(title=name)) def img_grid_many(self, d): for k, v in d.items(): self.img_grid(k, v) def img_grid(self, name, input_3d): """ 一个batch的图片转成一个网格图,i.e. input(36,64,64) 会变成 6*6 的网格图,每个格子大小64*64 """ self.img( name=name, img_=tv.utils.make_grid( tensor=input_3d.cpu()[0].unsequeeze(1).clamp(max=1, min=0))) def log(self, info, win='log'): self.log += '[{time}] {info} <br>'.format( time=time.strftime('%m%d_%H%M%S'), info=info) self.vis.text(text=self.log, win=win) def __getattr__(self, name): return getattr(self.vis, name)
def test_03(self): from visdom import Visdom viz = Visdom() # 单张 viz.image( np.random.rand(3, 512, 256), opts=dict(title='Random!', caption='How random.'), ) # 多张 viz.images(np.random.randn(20, 3, 64, 64), opts=dict(title='Random images', caption='How random'))
class VisdomImage(object): """Show images on Visdom""" def __init__(self, env_name='main'): self.viz = Visdom() self.env = env_name def display_image(self, image, win, title_name): #self.viz.images(image, env=self.env, win = self.win, opts = dict(caption = title_name, width = 256, height = 256)) self.viz.images(image, env=self.env, win=win, opts=dict(caption=title_name))
class Logger(): def __init__(self, env): self.viz = Visdom(env=env) self.losses = {} self.loss_windows = {} self.image_windows = {} def log(self, epoch=None, losses=None, images=None, image_grid=None, env=None): # Draw images if images: for image_name, tensor in images.items(): # pdb.set_trace() if image_name not in self.image_windows: self.image_windows[image_name] = self.viz.image( masktensor2image(tensor.data), opts={'title': image_name}) else: self.viz.image(masktensor2image(tensor.data), win=self.image_windows[image_name], opts={'title': image_name}) if image_grid: for image_name, tensor in image_grid.items(): if image_name not in self.image_windows: self.image_windows[image_name] = self.viz.images( tensor, env=env, opts={'title': image_name}) else: self.viz.images(tensor, win=self.image_windows[image_name], env=env, opts={'title': image_name}) # Plot losses if losses: for loss_name, loss in losses.items(): if loss_name not in self.loss_windows: self.loss_windows[loss_name] = self.viz.line( X=np.array([epoch]), Y=np.array([loss]), opts={ 'xlabel': 'epochs', 'ylabel': loss_name, 'title': loss_name }) else: self.viz.line(X=np.array([epoch]), Y=np.array([loss]), win=self.loss_windows[loss_name], update='append')
def main(): mod=Mnist() optimizer=optim.SGD(mod.parameters(),lr=learning_rate) #当你想恢复某一阶段的训练(或者进行测试)时,那么就可以读取之前保存的网络模型参数等。 checkpoint = torch.load('minst.pth') mod.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) start_epoch = checkpoint['epoch'] + 1 loss_fun=nn.CrossEntropyLoss() vis=Visdom() vis.line([0.],[0.],win='train_loss',opts=dict(title='trai_loss')) vis.line([0.],[0.],win='accuracy',opts=dict(title='acc')) # vis.line([0.],[0.], win='val_loss', opts=dict(title='val_loss')) correct=0 total_num=0 global_step=0 for epoch in range(start_epoch,3): for batch_index,(x,y) in enumerate(train_loader): # x=x.view(-1,28*28) logits=mod(x) train_loss=loss_fun(logits,y) pred=logits.argmax(dim=1) correct+=torch.eq(y,pred).float().sum() total_num += x.size(0) optimizer.zero_grad() train_loss.backward() optimizer.step() global_step+=1 acc=100.*correct/total_num #vis.line([train_loss.item()],[global_step],win='train_loss',update='append') #vis.line([acc],[global_step],win='accuracy',update='append') print('the loss of {:d} step is {:.3f},the accuracy is {:.3f}%'.format(global_step,train_loss.item(),acc)) #https://www.zhihu.com/question/363144860/answer/951669576(预测时必须使用) mod.eval() with torch.no_grad(): val_correct=0 val_total=0 for validation_images,validation_label in validation_loader: # validation_images=validation_images.view(-1,28*28) val_logits=mod(validation_images) pred=val_logits.argmax(dim=1) val_loss=loss_fun(val_logits,validation_label) val_correct+=torch.eq(pred,validation_label).float().sum() val_total+=validation_images.size(0) # vis.line([val_loss.item()],[global_step],win='val_loss',update='append') vis.images(validation_images.view(-1,1,28,28),win='x') vis.text(str(pred.detach().cpu().numpy()), win='pred', opts=dict(title='pred')) val_acc=100.* val_correct/val_total print('the val acc of {:d} epoch is {:.3f}%'.format(epoch,val_acc))
class VisdomImagePlotter(object): """Plots to Visdom""" def __init__(self, env_name='main'): self.viz = Visdom() self.env = env_name self.plots = {} def plot(self, image, title, nrow=8): self.viz.images( image, env=self.env, opts=dict(title=title), nrow=nrow )
class VisdomPlotter(object): """Plots to Visdom""" def __init__(self, env_name: str, port: int): self.viz = Visdom(port=port) self.env = env_name self.line_plots = {} self.image_frames = {} def plot(self, var_name, split_name, title_name, x, y): if var_name not in self.line_plots: self.line_plots[var_name] = self.viz.line(X=np.array([x]), Y=np.array([y]), env=self.env, opts=dict( legend=[split_name], title=title_name, xlabel='Iteration', ylabel=var_name)) else: self.viz.line(X=np.array([x]), Y=np.array([y]), env=self.env, win=self.line_plots[var_name], name=split_name, update='append') def draw(self, caption, images): if caption not in self.image_frames: self.image_frames[caption] = self.viz.images(images, nrow=10, padding=2, env=self.env, opts={ "caption": caption, "title": caption }) else: self.viz.images(images, nrow=10, padding=2, env=self.env, opts={ "caption": caption, "title": caption }, win=self.image_frames[caption])
def main(): mnist_train = datasets.MNIST('E:/ai_learning_resource/mnist', True, transform=transforms.Compose( [transforms.ToTensor()]), download=True) mnist_train = DataLoader(mnist_train, batch_size=32, shuffle=True) mnist_test = datasets.MNIST('E:/ai_learning_resource/mnist', False, transform=transforms.Compose( [transforms.ToTensor()]), download=True) mnist_test = DataLoader(mnist_test, batch_size=32, shuffle=True) x, _ = next(iter(mnist_train)) print('x:', x.shape) device = torch.device('cuda') model = VAE().to(device) criteon = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=1e-3) print(model) viz = Visdom() for epoch in range(1000): for batchidx, (x, _) in enumerate(mnist_train): x = x.to(device) x_hat, kld = model(x) loss = criteon(x_hat, x) if kld is not None: elbo = -loss - 1.0 * kld loss = -elbo optimizer.zero_grad() loss.backward() optimizer.step() print(epoch, 'loss', loss.item(), 'kld:', kld.item()) x, _ = next(iter(mnist_test)) x = x.to(device) with torch.no_grad(): x_hat = model(x) viz.images(x, nrow=8, win='x', opts=dict(title='x')) viz.images(x_hat, nrow=8, win='x_hat', opts=dict(title='x_hat'))
class VisdomLinePlotter(object): """Plots to Visdom""" def __init__(self, env_name='main', port=8050, disable=False): self.disable = disable if self.disable: return try: self.viz = Visdom(port=port) except (ConnectionError, ConnectionRefusedError) as e: raise ConnectionError( "Visdom Server not running, please launch it with `visdom` in the terminal" ) self.env = env_name self.plots = {} def clear(self): self.plots = {} def imshow(self, var_name, images): if self.disable: return if var_name not in self.plots: self.plots[var_name] = self.viz.images(images) else: self.viz.images(images, win=self.plots[var_name], env=self.env) def plot(self, window_id, variable, title, x, y, xlabel='epochs'): if self.disable: return if window_id not in self.plots: self.plots[window_id] = self.viz.line(X=np.array([x, x]), Y=np.array([y, y]), env=self.env, opts=dict(legend=[variable], title=title, xlabel=xlabel, ylabel=variable)) else: self.viz.line(X=np.array([x]), Y=np.array([y]), env=self.env, win=self.plots[window_id], name=variable, update='append')
class Drawer: def __init__(self, name='evn'): self.vis = Visdom(env=name) self.name = name self.data = defaultdict(list) def add_value(self, key, value, update='append', name='', alpha=0.02): if hasattr(value, 'item'): value = value.item() self.data[key].append(value) ys = Drawer.smooth(np.array( self.data[key])) if len(self.data[key]) > 200 else np.array( self.data[key]) self.vis.line(X=np.arange(len(ys)), Y=ys, opts={ 'title': key, 'xlabel': 'step' }, win=key, env=self.name) @staticmethod def smooth(x, alpha=0.02): n = int(alpha * len(x)) k = n // 2 if n % 2 != 0 else (n // 2) - 1 ks = n - int(n % 2 == 0) cs = x[:ks].mean() cs2 = x[-ks:].mean() return np.convolve(np.pad(x, k, mode='constant', constant_values=(cs, cs2)), np.ones(ks) / ks, mode='valid') def add_images(self, key, images, nrow=None): if nrow is None: nrow = np.sqrt(len(images)) nrow = math.ceil(nrow) nrow = int(nrow) assert images.ndim == 4 self.data[key] = images self.vis.images(images, opts={'title': key}, nrow=nrow, win=key, env=self.name)
class VisdomLinePlotter(object): """Plots to Visdom""" def __init__(self, env_name='main'): self.viz = Visdom() self.env = env_name self.plots = {} def plot(self, var_name, split_name, x, y, exp_name='test', env=None): if env is not None: print_env = env else: print_env = self.env if var_name not in self.plots: self.plots[var_name] = self.viz.line(X=np.array([x,x]), Y=np.array([y,y]), env=print_env, opts=dict( legend=[split_name], title=var_name, xlabel='Epochs', ylabel=var_name )) else: self.viz.updateTrace(X=np.array([x]), Y=np.array([y]), env=print_env, win=self.plots[var_name], name=split_name) if not os.path.exists('runs/%s/data/'%(exp_name)): os.makedirs('runs/%s/data/'%(exp_name)) file = open('runs/%s/data/%s_%s_data.csv'%(exp_name, split_name, var_name), 'a') file.write('%d, %f\n'%(x, y)) file.close() def plot_mask(self, masks, epoch): self.viz.bar( X=masks, env=self.env, opts=dict( stacked=True, title=epoch, ) ) def plot_image(self, image, epoch, exp_name='test'): self.viz.image(image, env=exp_name+'_img', opts=dict( caption=epoch, )) def plot_images(self, images, run_split, epoch, nrow, padding=2, exp_name='test'): self.viz.images(images, env=exp_name+'_img', nrow=nrow, padding=padding, opts=dict( caption='%s_%d'%(run_split, epoch), # title='Random images', jpgquality=100, ))
class VisdomLinePlotter(object): """Plots to Visdom""" def __init__(self, env_name='main', port=8097): self.viz = Visdom(port=port) self.env = env_name self.plots = {} self.scores_window = None self.image_window = None def plot(self, var_name, split_name, x, y, x_label='Epochs'): if var_name not in self.plots: self.plots[var_name] = self.viz.line(X=np.array([x,x]), Y=np.array([y,y]), env=self.env, opts=dict( legend=[split_name], title=var_name, xlabel=x_label, ylabel=var_name )) else: self.viz.line(X=np.array([x]), Y=np.array([y]), env=self.env, win=self.plots[var_name], name=split_name, update = 'append') def close_window(self, var_name): self.viz.close(self.plots[var_name]) del self.plots[var_name] def images(self, images): if self.image_window != None: self.viz.close(self.image_window) self.image_window = self.viz.images(images, nrow=3, env=self.env, opts=dict(nrow=2, title='Images Batch'))
class VisdomLogger(): """ Logger that uses visdom to create learning curves Parameters ---------- - env: str, name of the visdom environment - log_checkpoints: bool, whether to use checkpoints or epoch averages for training loss - legend: tuple, names of the different losses that will be plotted. """ def __init__(self, server='http://localhost', port=8097): if Visdom is None: warnings.warn("Couldn't import visdom: `pip install visdom`") else: self.viz = Visdom(server=server, port=port) # self.viz.delete_env() def deleteWindow(self, win): self.viz.close(win=win) def appendLine(self, name, win, X, Y, xlabel='empty', ylabel='empty'): if xlabel == 'empty' or ylabel == 'empty': self.viz.line(X=X, Y=Y, win=win, name=name, update='append', opts=dict(title="Loss")) else: self.viz.line(X=X, Y=Y, win=win, name=name, update='append', opts=dict(title="Loss", xlabel=xlabel, ylabel=ylabel, showlegend=True)) def plotLine(self, name, win, X, Y): self.viz.line(X=X, Y=Y, win=win, name=name) def plotImage(self, image, win, title="Image", caption="Just a Image"): self.viz.image(image, win=win, opts=dict(title=title, caption=caption)) def plotImages(self, images, win, nrow, caption="Validation Output"): self.viz.images(images, win=win, nrow=nrow, opts=dict(caption=caption)) def plot3dScatter(self, point, win): print("Point is", point) self.viz.scatter(X = point, win=win, opts=dict(update='update'))
class VisdomImgsPlotter(object): """Plots to Visdom""" def __init__(self, env_name='main', port=8097): self.vis = Visdom(port=port) self.env = env_name self.plots = {} def plot(self, var_name, images, labels): if var_name not in self.plots: self.plots[var_name] = self.vis.images(images, env=self.env, opts=dict(title=var_name, caption=labels)) else: self.vis.images(images, env=self.env, win=self.plots[var_name], opts=dict(title=var_name, caption=labels))
class VisdomImagesPlotter(object): """Show images to Visdom""" def __init__(self, env_name: str, port: int): self.viz = Visdom(port=port) self.env = env_name self.frames = {} def draw(self, caption, images): if caption not in self.frames: self.frames[caption] = self.viz.images(images, nrow=10, padding=2, opts={"caption": caption}) else: self.viz.images(images, nrow=10, padding=2, opts={"caption": caption}, win=self.frames[caption])
class Reconstruction(object): def __init__(self, data_loader): self.images, _ = next(iter(data_loader)) self.images = self.images.type(FloatTensor) assert self.images.shape[0] == 100 self.viz = Visdom() self.win_original = None self.win_recon = None def __call__(self, trainer, gan_model): recon = gan_model.reconstruct(self.images) if self.win_original is None: self.win_original = self.viz.images( self.images, nrow=10, opts=dict(caption='Original Images')) if self.win_recon is None: self.win_recon = self.viz.images( recon, nrow=10, opts=dict(caption='Reconstructed Images')) else: self.viz.images(recon, nrow=10, win=self.win_recon, opts=dict(caption='Reconstructed Images'))
if os.path.isfile(videofile): viz.video(videofile=videofile) except ImportError: print('Skipped video example') # image demo viz.image( np.random.rand(3, 512, 256), opts=dict(title='Random!', caption='How random.'), ) # grid of images viz.images( np.random.randn(20, 3, 64, 64), opts=dict(title='Random images', caption='How random.') ) # scatter plots Y = np.random.rand(100) old_scatter = viz.scatter( X=np.random.rand(100, 2), Y=(Y[Y > 0] + 1.5).astype(int), opts=dict( legend=['Didnt', 'Update'], xtickmin=-50, xtickmax=50, xtickstep=0.5, ytickmin=-50, ytickmax=50, ytickstep=0.5,