How to use the visdom.Visdom function in visdom

ac=test('/py/mnist/data/test_list.txt',28,'%s/lr-adaptivenet_%03d.pth' % (save_path, i + 1))
                vis.line(X=np.array([i]),Y=np.array([ac]),win='accurancy',update='append',name='lr-0.001',opts=dict(linecolor=np.array([[218,165,32]]),showlegend=True))
                


if __name__ == "__main__":

    parser = argparse.ArgumentParser()
    parser.add_argument('--epoch', default=1, help='epoches') 
    parser.add_argument('--img_size', default=28, help='img size ')
    parser.add_argument('--train_path', default='/py/mnist/data/traintrain_list.txt', help="train_list_txt_path")  
    parser.add_argument('--save_path', default='/py/mnist/weights', help='path to save model')
    parser.add_argument('--augmentation', default=False, help='aug ')
    opt = parser.parse_args()
    print(opt)
    vis = visdom.Visdom(env='MNIST')
    train(opt.epoch,opt.train_path,opt.img_size,opt.save_path,opt.augmentation)

def train():
    vis = visdom.Visdom()

    num_classses = 2
    net = facebox.FaceBox(num_classes=num_classses)
    if os.path.exists('weight/facebox.pt'):
        net.load_state_dict(torch.load('weight/facebox.pt', map_location=lambda storage, loc: storage))
    facebox_box_coder = facebox.FaceBoxCoder(net)

    root = os.path.expanduser('~/Data/WIDER')
    train_dataset = wider_face_loader.WiderFaceLoader(root=root, boxcoder=facebox_box_coder)
    train_dataloader = data.DataLoader(train_dataset, batch_size=1, shuffle=True)

    # optimizer = optim.SGD(net.parameters(), lr=1e-5, momentum=0.9, weight_decay=5e-4)
    optimizer = optim.Adam(net.parameters(), lr=1e-5, weight_decay=1e-4)
    criterion = facebox.FaceBoxLoss(num_classes=num_classses)

    for epoch in range(100):

MEANS))
    # ocr dataset
    else:
        cfg = ocr
        converter = strLabelConverter(args.alphabets)
        dataset = LPDataset(
            root=args.root,
            csv_root=None,
            transform=SSDAugmentation(cfg['min_dim'], MEANS),
            target_transform=converter.encode
        )


    if args.visdom:
        import visdom
        viz = visdom.Visdom()

    ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes'])
    net = ssd_net
    ctccriterion = OcrLoss(args.alphabets)


    if args.resume:
        print('Resuming training, loading {}...'.format(args.resume))
        # ssd_net.load_weights(args.resume)
        checkpoint = torch.load(args.resume)
        net.load_state_dict(checkpoint['model'])
        ctccriterion.load_state_dict(checkpoint['ocr'])
    else:
        vgg_weights = torch.load(args.save_folder + args.basenet)
        print('Loading base network...')
        ssd_net.vgg.load_state_dict(vgg_weights)

def __init__(self, opt):
        # self.opt = opt
        self.display_id = opt.display_id
        self.use_html = False and not opt.no_html
        self.win_size = opt.display_winsize
        self.name = 'inference'
        self.opt = opt
        self.saved = False
        if self.display_id > 0:
            import visdom
            self.vis = visdom.Visdom(server=opt.display_server, port=opt.display_port)

        if self.use_html:
            self.web_dir = os.path.join(opt.checkpoints_dir, 'web')
            self.img_dir = os.path.join(self.web_dir, 'images')
            print('create web directory %s...' % self.web_dir)
            util.mkdirs([self.web_dir, self.img_dir])
        self.log_name = os.path.join(opt.checkpoints_dir, 'loss_log.txt')
        with open(self.log_name, "a") as log_file:
            now = time.strftime("%c")
            log_file.write('================ Training Loss (%s) ================\n' % now)

def run(self, config_dict_file, config_dict):
        # create visualization windows
        try:
            import visdom
            port = 3557
            vis = visdom.Visdom(port=port)
            if not vis.check_connection():
                vis = None
                print("WARNING: Visdom server not running. Please run 'python -m visdom.server -port port' to see visual output")
            else:
                print("Visdom connected, reporting progress there!")
        except ImportError:
            vis = None
            print("WARNING: No visdom package is found. Please install it with command: \n pip install visdom to see visual output")
            #raise RuntimeError("WARNING: No visdom package is found. Please install it with command: \n pip install visdom to see visual output")
        vis_windows = {}
    
        # save path and config files
        save_path = self.get_parameter_description(config_dict)
        utils_io.savePythonFile(config_dict_file, save_path)
        utils_io.savePythonFile(__file__, save_path)

def __init__(self, use_visdom):
        self.vis = visdom.Visdom() if use_visdom else None
        self.use_visdom = use_visdom

        self.epoch = 0

        self.metrics = {
                'loss_train', 'loss_test', 'accuracy_train', 'accuracy_test'}
        self.plots = {
                name: ScalarPlot(self.vis, name, use_visdom)
                for name in self.metrics}

# 3. dataset.curr_threshold
    stage, progress = get_stage_progress(model.step)
    start_ratio = STEP_RATIO ** (stage + 1)
    dataset.set_max_ratio(start_ratio)
    if progress > 0.5:
        dataset.set_combined()
        if progress > 0.6:
            model.chamfer_criteria.set_threshold(CD_THRESHOLD)
    else:
        model.chamfer_criteria.unset_threshold()
        dataset.unset_combined()

    dataloader = data.DataLoader(dataset, batch_size=1, pin_memory=True)

    # visualization
    vis_logger = visdom.Visdom(env=FLAGS.id)
    for epoch in range(start_epoch + 1, MAX_EPOCH):
        for i, examples in enumerate(dataloader):
            input_pc, label_pc, ratio = examples
            ratio = ratio.item()
            # 1xBx3xN
            input_pc = input_pc[0].to(DEVICE)
            label_pc = label_pc[0].to(DEVICE)
            model.set_input(input_pc, ratio, label_pc=label_pc)
            # run gradient decent and increment model.step
            model.optimize()
            new_stage, new_progress = get_stage_progress(model.step)
            # advance to the next training stage with an added ratio
            if stage + 1 == new_stage:
                dataset.add_next_ratio()
                dataset.unset_combined()
                model.chamfer_criteria.unset_threshold()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Fine-tune the fc layer only for  HBP(Hierarchical Bilinear Pooling for Fine-Grained Visual Recognition).
Usage:
    CUDA_VISIBLE_DEVICES=0,1 python HBP_fc.py --base_lr 1.0 --batch_size 12 --epochs 120 --weight_decay 0.000005 | tee 'hbp_fc.log'
"""

import os
import torch
import torchvision
import cub200
import visdom
import argparse

vis = visdom.Visdom(env=u'HBP_fc',use_incoming_socket=False)
torch.manual_seed(0)
torch.cuda.manual_seed_all(0)

class HBP(torch.nn.Module):
    def __init__(self):
        torch.nn.Module.__init__(self)
        # Convolution and pooling layers of VGG-16.
        self.features = torchvision.models.vgg16(pretrained=True).features
        self.features_conv5_1 = torch.nn.Sequential(*list(self.features.children())
                                            [:-5])  
        self.features_conv5_2 = torch.nn.Sequential(*list(self.features.children())
                                            [-5:-3])  
        self.features_conv5_3 = torch.nn.Sequential(*list(self.features.children())
                                            [-3:-1])     
        self.bilinear_proj = torch.nn.Sequential(torch.nn.Conv2d(512,8192,kernel_size=1,bias=False),
                                        torch.nn.BatchNorm2d(8192),

else:
            raise NotImplementedError('only support model H or B')

        self.net = cuda(net(self.z_dim, self.nc), self.use_cuda)
        self.optim = optim.Adam(self.net.parameters(), lr=self.lr,
                                    betas=(self.beta1, self.beta2))

        self.viz_name = args.viz_name
        self.viz_port = args.viz_port
        self.viz_on = args.viz_on
        self.win_recon = None
        self.win_kld = None
        self.win_mu = None
        self.win_var = None
        if self.viz_on:
            self.viz = visdom.Visdom(port=self.viz_port)

        self.ckpt_dir = os.path.join(args.ckpt_dir, args.viz_name)
        if not os.path.exists(self.ckpt_dir):
            os.makedirs(self.ckpt_dir, exist_ok=True)
        self.ckpt_name = args.ckpt_name
        if self.ckpt_name is not None:
            self.load_checkpoint(self.ckpt_name)

        self.save_output = args.save_output
        self.output_dir = os.path.join(args.output_dir, args.viz_name)
        if not os.path.exists(self.output_dir):
            os.makedirs(self.output_dir, exist_ok=True)

        self.gather_step = args.gather_step
        self.display_step = args.display_step
        self.save_step = args.save_step

from lenet import LeNet5
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision.datasets.mnist import MNIST
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import visdom
import onnx

viz = visdom.Visdom()

data_train = MNIST('./data/mnist',
                   download=True,
                   transform=transforms.Compose([
                       transforms.Resize((32, 32)),
                       transforms.ToTensor()]))
data_test = MNIST('./data/mnist',
                  train=False,
                  download=True,
                  transform=transforms.Compose([
                      transforms.Resize((32, 32)),
                      transforms.ToTensor()]))
data_train_loader = DataLoader(data_train, batch_size=256, shuffle=True, num_workers=8)
data_test_loader = DataLoader(data_test, batch_size=1024, num_workers=8)

net = LeNet5()