def test_cifar10_per_class(self): """ """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'PORT' not in os.environ: os.environ['PORT'] = '6006' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' # func name assert sys._getframe().f_code.co_name.startswith('test_') command = sys._getframe().f_code.co_name[5:] class_name = self.__class__.__name__[7:] \ if self.__class__.__name__.startswith('Testing') \ else self.__class__.__name__ outdir = f'results/{class_name}/{command}' os.makedirs(outdir, exist_ok=True) import matplotlib.pylab as plt from template_lib.d2.data.build_cifar10_per_class import data_path, kwargs_list from detectron2.data import MetadataCatalog pass
def test_ddp(self): """ Usage: export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 export TIME_STR=1 export PYTHONPATH=./exp:./stylegan2-pytorch:./ python -c "from exp.tests.test_styleganv2 import Testing_stylegan2;\ Testing_stylegan2().test_train_ffhq_128()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0,1' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config import get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, \ start_cmd_run command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file exp/configs/styleganv2.yaml --tl_command {command} --tl_outdir {outdir} """ args = setup_outdir_and_yaml(argv_str) nproc_per_node = len(os.environ['CUDA_VISIBLE_DEVICES'].split(',')) cmd_str = f""" python -m torch.distributed.launch --nproc_per_node={nproc_per_node} --master_port=8888 exp/scripts/train.py {get_append_cmd_str(args)} """ start_cmd_run(cmd_str) pass
def test_summary_defaultdict2txtfig(self): if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'PORT' not in os.environ: os.environ['PORT'] = '6006' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '1' # func name assert sys._getframe().f_code.co_name.startswith('test_') command = sys._getframe().f_code.co_name[5:] class_name = self.__class__.__name__[7:] \ if self.__class__.__name__.startswith('Testing') \ else self.__class__.__name__ outdir = f'results/{class_name}/{command}' argv_str = f""" --config template_lib/configs/config.yaml --command {command} --outdir {outdir} """ from template_lib.utils.config import parse_args_and_setup_myargs, config2args args, myargs, _ = parse_args_and_setup_myargs(argv_str, start_tb=False) prefix = 'test_summary_scalars' import collections summary_dict = collections.defaultdict(dict) for step in range(1000): summary = {'a': step, 'b': step + 1} for i in range(20): summary_dict[f'dict{i}'] = summary Trainer.summary_defaultdict2txtfig(default_dict=summary_dict, prefix=prefix, step=step, textlogger=myargs.textlogger, in_one_figure=False) Trainer.summary_defaultdict2txtfig(default_dict=summary_dict, prefix=prefix, step=step, textlogger=myargs.textlogger, in_one_figure=True) return
def test_gcn(self): """ """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'PORT' not in os.environ: os.environ['PORT'] = '6006' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '1' # func name assert sys._getframe().f_code.co_name.startswith('test_') command = sys._getframe().f_code.co_name[5:] class_name = self.__class__.__name__[7:] \ if self.__class__.__name__.startswith('Testing') \ else self.__class__.__name__ outdir = f'results/{class_name}/{command}' import shutil shutil.rmtree(outdir, ignore_errors=True) os.makedirs(outdir, exist_ok=True) from template_lib.examples.DGL import test_gcn pass
def test_OneCycleLR(self, debug=True): """ Usage: python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/pypi/torch1_7_0 -d /cache/pypi -t copytree for filename in /cache/pypi/*.whl; do pip install $filename done proj_root=moco-exp python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/codes/$proj_root -d /cache/$proj_root -t copytree -b /cache/$proj_root/code.zip cd /cache/$proj_root pip install -r requirements.txt export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 export TIME_STR=1 export PYTHONPATH=./exp:./stylegan2-pytorch:./ python -c "from exp.tests.test_styleganv2 import Testing_stylegan2;\ Testing_stylegan2().test_train_ffhq_128()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) tl_opts = ' '.join(sys.argv[sys.argv.index('--tl_opts') + 1:]) if '--tl_opts' in sys.argv else '' print(f'tl_opts:\n {tl_opts}') command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file none --tl_command none --tl_outdir {outdir} """ args = setup_outdir_and_yaml(argv_str, return_cfg=True) import torch.nn as nn from torch.optim import lr_scheduler from matplotlib import pyplot as plt model = nn.Linear(3, 64) def create_optimizer(): return SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=1e-4) def plot_lr(scheduler, title='', labels=['base'], nrof_epoch=100): lr_li = [[] for _ in range(len(labels))] epoch_li = list(range(nrof_epoch)) for epoch in epoch_li: scheduler.step() # 调用step()方法,计算和更新optimizer管理的参数基于当前epoch的学习率 lr = scheduler.get_last_lr() # 获取当前epoch的学习率 for i in range(len(labels)): lr_li[i].append(lr[i]) for lr, label in zip(lr_li, labels): plt.plot(epoch_li, lr, label=label) plt.grid() plt.xlabel('epoch') plt.ylabel('lr') plt.title(title) plt.legend() plt.show() optimizer = create_optimizer() scheduler = lr_scheduler.OneCycleLR(optimizer, 0.1, total_steps=100) plot_lr(scheduler, title='OneCycleLR') pass
def test_base_usage(self, debug=True): """ Usage: python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/pypi/torch1_7_0 -d /cache/pypi -t copytree for filename in /cache/pypi/*.whl; do pip install $filename done proj_root=moco-exp python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/codes/$proj_root -d /cache/$proj_root -t copytree -b /cache/$proj_root/code.zip cd /cache/$proj_root pip install -r requirements.txt export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 export TIME_STR=1 export PYTHONPATH=./exp:./stylegan2-pytorch:./ python -c "from exp.tests.test_styleganv2 import Testing_stylegan2;\ Testing_stylegan2().test_train_ffhq_128()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) tl_opts = ' '.join(sys.argv[sys.argv.index('--tl_opts') + 1:]) if '--tl_opts' in sys.argv else '' print(f'tl_opts:\n {tl_opts}') command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file none --tl_command none --tl_outdir {outdir} """ args = setup_outdir_and_yaml(argv_str, return_cfg=True) import torch import numpy as np import warnings warnings.filterwarnings('ignore') # ignore warnings x = torch.linspace(-np.pi, np.pi, 2000) y = torch.sin(x) p = torch.tensor([1, 2, 3]) xx = x.unsqueeze(-1).pow(p) model = torch.nn.Sequential(torch.nn.Linear(3, 1), torch.nn.Flatten(0, 1)) loss_fn = torch.nn.MSELoss(reduction='sum') learning_rate = 1e-3 optimizer = torch.optim.RMSprop(model.parameters(), lr=learning_rate) for t in range(1, 1001): y_pred = model(xx) loss = loss_fn(y_pred, y) if t % 100 == 0: print('No.{: 5d}, loss: {:.6f}'.format(t, loss.item())) optimizer.zero_grad() # 梯度清零 loss.backward() # 反向传播计算梯度 optimizer.step() # 梯度下降法更新参数 pass
def test_surface_3d_1(self): """ """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'PORT' not in os.environ: os.environ['PORT'] = '6006' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' # func name assert sys._getframe().f_code.co_name.startswith('test_') command = sys._getframe().f_code.co_name[5:] class_name = self.__class__.__name__[7:] \ if self.__class__.__name__.startswith('Testing') \ else self.__class__.__name__ outdir = f'results/{class_name}/{command}' from template_lib.utils.plot_results import PlotResults import collections, shutil shutil.rmtree(outdir, ignore_errors=True) os.makedirs(outdir, exist_ok=True) from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from matplotlib import cm from matplotlib.ticker import LinearLocator, FormatStrFormatter import numpy as np fig = plt.figure() ax = fig.gca(projection='3d') # Make data. X = np.arange(-5, 5, 0.1) Y = np.arange(-5, 5, 0.1) X, Y = np.meshgrid(X, Y) R = np.sqrt(X**2 + Y**2) Z = np.sin(R) # Plot the surface. surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm, rstride=1, cstride=1, linewidth=0, antialiased=False) # Customize the z axis. ax.set_zlim(-1.01, 1.01) ax.zaxis.set_major_locator(LinearLocator(10)) ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f')) # Add a color bar which maps values to colors. fig.colorbar(surf, shrink=0.5, aspect=5) plt.show() pass
def test_subplot_surface_3d(self): """ """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'PORT' not in os.environ: os.environ['PORT'] = '6006' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' # func name assert sys._getframe().f_code.co_name.startswith('test_') command = sys._getframe().f_code.co_name[5:] class_name = self.__class__.__name__[7:] \ if self.__class__.__name__.startswith('Testing') \ else self.__class__.__name__ outdir = f'results/{class_name}/{command}' from template_lib.utils.plot_results import PlotResults import collections, shutil shutil.rmtree(outdir, ignore_errors=True) os.makedirs(outdir, exist_ok=True) import matplotlib.pyplot as plt from mpl_toolkits.mplot3d.axes3d import Axes3D, get_test_data from matplotlib import cm, colors import numpy as np # set up a figure twice as wide as it is tall fig = plt.figure(figsize=plt.figaspect(0.5)) # =============== # First subplot # =============== # set up the axes for the first plot ax = fig.add_subplot(1, 2, 1, projection='3d') # plot a 3D surface like in the example mplot3d/surface3d_demo X = np.arange(-5, 5, 0.25) Y = np.arange(-5, 5, 0.25) X, Y = np.meshgrid(X, Y) R = np.sqrt(X**2 + Y**2) Z = np.sin(R) surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False) ax.set_zlim(-1.01, 1.01) # fig.colorbar(surf, shrink=0.5, aspect=10) # =============== # Second subplot # =============== # set up the axes for the second plot ax2 = fig.add_subplot(1, 2, 2, projection='3d') # plot a 3D wireframe like in the example mplot3d/wire3d_demo X, Y, Z = get_test_data(0.05) Z = np.ones_like(Z) # ax.plot_wireframe(X, Y, Z, rstride=10, cstride=10) surf2 = ax2.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False) # fig.colorbar(surf, shrink=0.5, aspect=10) norm = colors.Normalize(vmin=-1, vmax=1) surf.set_norm(norm) surf2.set_norm(norm) fig.colorbar(surf2, orientation='vertical', fraction=.1, shrink=0.5, aspect=10, anchor=(0, 0.5)) # fig.colorbar(surf, ax=[ax, ax2], orientation='horizontal', fraction=.1, shrink=0.5, aspect=10) fig.tight_layout() plt.show() pass
def test_MixedLayerCond(self): """ """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'PORT' not in os.environ: os.environ['PORT'] = '6006' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '1' # func name assert sys._getframe().f_code.co_name.startswith('test_') command = sys._getframe().f_code.co_name[5:] class_name = self.__class__.__name__[7:] \ if self.__class__.__name__.startswith('Testing') \ else self.__class__.__name__ outdir = f'results/{class_name}/{command}' import yaml from template_lib.d2.layers import build_d2layer cfg_str = """ layer: name: "MixedLayerCond" in_channels: "kwargs['in_channels']" out_channels: "kwargs['out_channels']" cfg_ops: "kwargs['cfg_ops']" cfg_bn: name: "BatchNorm2d" num_features: "kwargs['num_features']" affine: true track_running_stats: true cfg_act: name: "ReLU" cfg_ops: SNConv2d_3x3: name: "SNConv2d" in_channels: "kwargs['in_channels']" out_channels: "kwargs['out_channels']" kernel_size: 3 padding: 1 Conv2d_3x3: name: "Conv2d" in_channels: "kwargs['in_channels']" out_channels: "kwargs['out_channels']" kernel_size: 3 padding: 1 """ cfg = EasyDict(yaml.safe_load(cfg_str)) op = build_d2layer(cfg.layer, in_channels=8, out_channels=8, cfg_ops=cfg.cfg_ops) num_classes = 2 bs = num_classes num_ops = 2 op.cuda() x = torch.randn(bs, 8, 32, 32).cuda() y = torch.arange(bs).cuda() sample_arc = torch.arange(num_ops).cuda() x = op(x, y, sample_arc) pass
def test_hook_for_grad_cam(self, debug=True): """ Usage: python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/pypi/torch1_7_0 -d /cache/pypi -t copytree for filename in /cache/pypi/*.whl; do pip install $filename done proj_root=moco-exp python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/codes/$proj_root -d /cache/$proj_root -t copytree -b /cache/$proj_root/code.zip cd /cache/$proj_root pip install -r requirements.txt export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 export TIME_STR=1 export PYTHONPATH=./exp:./stylegan2-pytorch:./ python -c "from exp.tests.test_styleganv2 import Testing_stylegan2;\ Testing_stylegan2().test_train_ffhq_128()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) tl_opts = ' '.join(sys.argv[sys.argv.index('--tl_opts') + 1:]) if '--tl_opts' in sys.argv else '' print(f'tl_opts:\n {tl_opts}') command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file none --tl_command none --tl_outdir {outdir} --tl_opts {tl_opts} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) n_gpus = len(os.environ['CUDA_VISIBLE_DEVICES'].split(',')) cmd_str = f""" python template_lib/proj/pytorch/examples/hook_for_grad_cam.py {get_append_cmd_str(args)} """ if debug: cmd_str += f""" --tl_debug --tl_opts """ else: cmd_str += f""" --tl_opts {tl_opts} """ start_cmd_run(cmd_str) # from template_lib.v2.config_cfgnode import update_parser_defaults_from_yaml, global_cfg # from template_lib.modelarts import modelarts_utils # update_parser_defaults_from_yaml(parser) # modelarts_utils.setup_tl_outdir_obs(global_cfg) # modelarts_utils.modelarts_sync_results_dir(global_cfg, join=True) # modelarts_utils.prepare_dataset(global_cfg.get('modelarts_download', {}), global_cfg=global_cfg) # # modelarts_utils.prepare_dataset(global_cfg.get('modelarts_upload', {}), global_cfg=global_cfg, download=False) # modelarts_utils.modelarts_sync_results_dir(global_cfg, join=True) pass
def test_extract_ImageNet_1000x50(self): """ Usage: proj_root=moco-exp python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/codes/$proj_root -d /cache/$proj_root -t copytree cd /cache/$proj_root export CUDA_VISIBLE_DEVICES=0 export TIME_STR=0 export PYTHONPATH=./ python -c "from template_lib.proj.imagenet.tests.test_imagenet import Testing_PrepareImageNet;\ Testing_PrepareImageNet().test_extract_ImageNet_1000x50()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) from template_lib.v2.config_cfgnode import update_parser_defaults_from_yaml, global_cfg from template_lib.modelarts import modelarts_utils command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file template_lib/proj/imagenet/tests/configs/PrepareImageNet.yaml --tl_command {command} --tl_outdir {outdir} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) global_cfg.merge_from_dict(cfg) global_cfg.merge_from_dict(vars(args)) modelarts_utils.setup_tl_outdir_obs(global_cfg) modelarts_utils.modelarts_sync_results_dir(global_cfg, join=True) modelarts_utils.prepare_dataset(global_cfg.get('modelarts_download', {}), global_cfg=global_cfg) train_dir = f'{cfg.data_dir}/train' counter_cls = 0 for rootdir, subdir, files in os.walk(train_dir): if len(subdir) == 0: counter_cls += 1 extracted_files = sorted(files)[:cfg.num_per_class] for file in tqdm.tqdm(extracted_files, desc=f'class: {counter_cls}'): img_path = os.path.join(rootdir, file) img_rel_path = os.path.relpath(img_path, cfg.data_dir) saved_img_path = f'{cfg.saved_dir}/{os.path.dirname(img_rel_path)}' os.makedirs(saved_img_path, exist_ok=True) shutil.copy(img_path, saved_img_path) pass modelarts_utils.prepare_dataset(global_cfg.get('modelarts_upload', {}), global_cfg=global_cfg, download=False) modelarts_utils.modelarts_sync_results_dir(global_cfg, join=True) pass
def test_extract_ImageNet100_CMC(self): """ Usage: proj_root=moco-exp python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/codes/$proj_root -d /cache/$proj_root -t copytree cd /cache/$proj_root export CUDA_VISIBLE_DEVICES=0 export TIME_STR=0 export PYTHONPATH=./ python -c "from template_lib.proj.imagenet.tests.test_imagenet import Testing_PrepareImageNet;\ Testing_PrepareImageNet().test_extract_ImageNet100_CMC()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) from template_lib.v2.config_cfgnode import update_parser_defaults_from_yaml, global_cfg from template_lib.modelarts import modelarts_utils from distutils.dir_util import copy_tree command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file template_lib/proj/imagenet/tests/configs/PrepareImageNet.yaml --tl_command {command} --tl_outdir {outdir} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) modelarts_utils.setup_tl_outdir_obs(global_cfg) modelarts_utils.modelarts_sync_results_dir(global_cfg, join=True) modelarts_utils.prepare_dataset(global_cfg.get('modelarts_download', {}), global_cfg=global_cfg) train_dir = f'{cfg.data_dir}/train' val_dir = f'{cfg.data_dir}/val' save_train_dir = f'{cfg.saved_dir}/train' save_val_dir = f'{cfg.saved_dir}/val' os.makedirs(save_train_dir, exist_ok=True) os.makedirs(save_val_dir, exist_ok=True) with open(cfg.class_list_file, 'r') as f: class_list = f.readlines() for class_subdir in tqdm.tqdm(class_list): class_subdir, _ = class_subdir.strip().split() train_class_dir = f'{train_dir}/{class_subdir}' save_train_class_dir = f'{save_train_dir}/{class_subdir}' copy_tree(train_class_dir, save_train_class_dir) val_class_dir = f'{val_dir}/{class_subdir}' save_val_class_dir = f'{save_val_dir}/{class_subdir}' copy_tree(val_class_dir, save_val_class_dir) modelarts_utils.prepare_dataset(global_cfg.get('modelarts_upload', {}), global_cfg=global_cfg, download=False) modelarts_utils.modelarts_sync_results_dir(global_cfg, join=True) pass
def test_plot_FID_IS(self): if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file none --tl_command none --tl_outdir {outdir} """ args = setup_outdir_and_yaml(argv_str) outdir = args.tl_outdir from template_lib.utils.plot_results import PlotResults import collections outfigure = os.path.join(outdir, 'FID_IS.jpg') default_dicts = [] show_max = [] FID_c100 = collections.defaultdict(dict) title = 'FID_c100' log_file = 'textdir/evaltf.ma0.FID_tf.log' dd = eval(title) dd['/home/user321/user/code_sync/Omni-GAN-PyTorch/results/train_Omni_GAN_cifar100_3'] = \ {'Omni-GAN-c100': log_file, } dd['/home/user321/user/code_sync/Omni-GAN-PyTorch/results/train_BigGAN_cifar100'] = \ {'BigGAN-c100': log_file, } dd['properties'] = {'title': title, 'ylim': [0, 30]} default_dicts.append(dd) show_max.append(False) IS_c100 = collections.defaultdict(dict) title = 'IS_c100' log_file = 'textdir/evaltf.ma1.IS_mean_tf.log' dd = eval(title) dd['/home/user321/user/code_sync/Omni-GAN-PyTorch/results/train_Omni_GAN_cifar100_3'] = \ {'Omni-GAN-c100': log_file, } dd['/home/user321/user/code_sync/Omni-GAN-PyTorch/results/train_BigGAN_cifar100'] = \ {'BigGAN-c100': log_file, } dd['properties'] = { 'title': title, } default_dicts.append(dd) show_max.append(True) FID_c10 = collections.defaultdict(dict) title = 'FID_c10' log_file = 'textdir/evaltf.ma0.FID_tf.log' dd = eval(title) dd['/home/user321/user/code_sync/Omni-GAN-PyTorch/results/train_Omni_GAN_cifar10'] = \ {'Omni-GAN-c10': log_file, } dd['/home/user321/user/code_sync/Omni-GAN-PyTorch/results/train_BigGAN_cifar10'] = \ {'BigGAN-c10': log_file, } dd['properties'] = {'title': title, 'ylim': [0, 30]} default_dicts.append(dd) show_max.append(False) IS_c10 = collections.defaultdict(dict) title = 'IS_c10' log_file = 'textdir/evaltf.ma1.IS_mean_tf.log' dd = eval(title) dd['/home/user321/user/code_sync/Omni-GAN-PyTorch/results/train_Omni_GAN_cifar10'] = \ {'Omni-GAN-c10': log_file, } dd['/home/user321/user/code_sync/Omni-GAN-PyTorch/results/train_BigGAN_cifar10'] = \ {'BigGAN-c10': log_file, } dd['properties'] = { 'title': title, } default_dicts.append(dd) show_max.append(True) plotobs = PlotResults() label2datas_list = plotobs.plot_defaultdicts( outfigure=outfigure, default_dicts=default_dicts, show_max=show_max, figsize_wh=(16, 7.2)) print(f'Save to {outfigure}.') pass
def test__select_images(self, debug=True): """ Usage: ssh -o ServerAliveInterval=30 -o ServerAliveCountMax=2 root@localhost -p 2232 export CUDA_VISIBLE_DEVICES=4 export TIME_STR=1 export PYTHONPATH=./:./ada_lib python -c "from exp.tests.test_ada_ultra import Testing_train_StyleUltraGAN_ADA_Transfer_MixedFaces;\ Testing_train_StyleUltraGAN_ADA_Transfer_MixedFaces().test_projector_web(debug=False)" \ --tl_opts port 8530 start_web True :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) tl_opts = ' '.join(sys.argv[sys.argv.index('--tl_opts') + 1:]) if '--tl_opts' in sys.argv else '' print(f'tl_opts:\n {tl_opts}') command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file none --tl_command none --tl_outdir {outdir} --tl_opts {tl_opts} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) from pathlib import Path import shutil domain_dict = {} domain_dict['lso_sm'] = """ x0_lso: results/train_StyleUltraGAN_ADA_Transfer_MixedFaces/double_inversion_web-20210604_093503_613/exp/0024/29218_lso.jpg, x1_lso: results/train_StyleUltraGAN_ADA_Transfer_MixedFaces/double_inversion_web-20210604_093503_613/exp/0014/29438_lso.jpg, """ suffix_str = [''] * 2 for domain, image_list in domain_dict.items(): image_list = image_list.split(',') for item, suffix in zip(image_list, suffix_str): layer_name, image_path = item.strip().split(':') layer_name = layer_name.strip().replace(' ', '_') image_path = Path(image_path.strip()) select_path = Path( f"{image_path.parent}/{image_path.stem}{suffix}.jpg") saved_path = Path( f"{outdir}/images/{domain}/{layer_name}_{select_path.name}" ) os.makedirs(saved_path.parent, exist_ok=True) shutil.copy(select_path, saved_path) print(outdir) pass
def test_BERT_example(self): """ """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'PORT' not in os.environ: os.environ['PORT'] = '6006' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '1' # func name assert sys._getframe().f_code.co_name.startswith('test_') command = sys._getframe().f_code.co_name[5:] class_name = self.__class__.__name__[7:] \ if self.__class__.__name__.startswith('Testing') \ else self.__class__.__name__ outdir = f'results/{class_name}/{command}' from datetime import datetime TIME_STR = bool(int(os.getenv('TIME_STR', 0))) time_str = datetime.now().strftime("%Y%m%d-%H_%M_%S_%f")[:-3] outdir = outdir if not TIME_STR else (outdir + '_' + time_str) print(outdir) import collections, shutil shutil.rmtree(outdir, ignore_errors=True) os.makedirs(outdir, exist_ok=True) import torch from transformers import BertTokenizer, BertModel, BertForMaskedLM # OPTIONAL: if you want to have more information on what's happening under the hood, activate the logger as follows import logging logging.basicConfig(level=logging.INFO) # Load pre-trained model tokenizer (vocabulary) tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') # Tokenize input text = "[CLS] Who was Jim Henson ? [SEP] Jim Henson was a puppeteer [SEP]" tokenized_text = tokenizer.tokenize(text) # Mask a token that we will try to predict back with `BertForMaskedLM` masked_index = 8 tokenized_text[masked_index] = '[MASK]' assert tokenized_text == [ '[CLS]', 'who', 'was', 'jim', 'henson', '?', '[SEP]', 'jim', '[MASK]', 'was', 'a', 'puppet', '##eer', '[SEP]' ] # Convert token to vocabulary indices indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text) # Define sentence A and B indices associated to 1st and 2nd sentences (see paper) segments_ids = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1] # Convert inputs to PyTorch tensors tokens_tensor = torch.tensor([indexed_tokens]) segments_tensors = torch.tensor([segments_ids]) pass # Load pre-trained model (weights) model = BertModel.from_pretrained('bert-base-uncased') # Set the model in evaluation mode to deactivate the DropOut modules # This is IMPORTANT to have reproducible results during evaluation! model.eval() # If you have a GPU, put everything on cuda tokens_tensor = tokens_tensor.to('cuda') segments_tensors = segments_tensors.to('cuda') model.to('cuda') # Predict hidden states features for each layer with torch.no_grad(): # See the models docstrings for the detail of the inputs outputs = model(tokens_tensor, token_type_ids=segments_tensors) # Transformers models always output tuples. # See the models docstrings for the detail of all the outputs # In our case, the first element is the hidden state of the last layer of the Bert model encoded_layers = outputs[0] # We have encoded our input sequence in a FloatTensor of shape (batch size, sequence length, model hidden dimension) assert tuple(encoded_layers.shape) == (1, len(indexed_tokens), model.config.hidden_size) pass # Load pre-trained model (weights) model = BertForMaskedLM.from_pretrained('bert-base-uncased') model.eval() # If you have a GPU, put everything on cuda tokens_tensor = tokens_tensor.to('cuda') segments_tensors = segments_tensors.to('cuda') model.to('cuda') # Predict all tokens with torch.no_grad(): outputs = model(tokens_tensor, token_type_ids=segments_tensors) predictions = outputs[0] # confirm we were able to predict 'henson' predicted_index = torch.argmax(predictions[0, masked_index]).item() predicted_token = tokenizer.convert_ids_to_tokens([predicted_index])[0] assert predicted_token == 'henson'
def test_add_text_in_tensor(self, debug=True): """ Usage: export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 export TIME_STR=1 export PYTHONPATH=./exp:./stylegan2-pytorch:./ python -c "from exp.tests.test_styleganv2 import Testing_stylegan2;\ Testing_stylegan2().test_train_ffhq_128()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) tl_opts = ' '.join(sys.argv[sys.argv.index('--tl_opts') + 1:]) if '--tl_opts' in sys.argv else '' print(f'tl_opts:\n {tl_opts}') command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file none --tl_command none --tl_outdir {outdir} --tl_opts {tl_opts} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) n_gpus = len(os.environ['CUDA_VISIBLE_DEVICES'].split(',')) import torchvision.transforms.functional as trans_f img_path = "template_lib/datasets/images/zebra_GT_target_origin.png" left = [80, 300] upper = [120, 140] w = 50 h = 20 pad = 2 img = Image.open(img_path) img = sr_merge_original_image_and_patches(img, lefts=left, uppers=upper, w=w, h=h, pad=pad) img_tensor = trans_f.to_tensor(img) img_tensor_text = add_text_in_tensor(img_tensor=img_tensor, text='Image', xy=(5, 5)) img_pil = trans_f.to_pil_image(img_tensor_text) fig, axes = plt.subplots() axes.imshow(img_pil) fig.show() pass
def test_ConvNet(self, debug=True): """ Usage: python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/pypi/torch1_7_0 -d /cache/pypi -t copytree for filename in /cache/pypi/*.whl; do pip install $filename done proj_root=moco-exp python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/codes/$proj_root -d /cache/$proj_root -t copytree -b /cache/$proj_root/code.zip cd /cache/$proj_root pip install -r requirements.txt export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 export TIME_STR=1 export PYTHONPATH=./exp:./stylegan2-pytorch:./ python -c "from exp.tests.test_styleganv2 import Testing_stylegan2;\ Testing_stylegan2().test_train_ffhq_128()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) tl_opts = ' '.join(sys.argv[sys.argv.index('--tl_opts') + 1:]) if '--tl_opts' in sys.argv else '' print(f'tl_opts:\n {tl_opts}') command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file none --tl_command none --tl_outdir {outdir} --tl_opts {tl_opts} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) from template_lib.proj.pytorch.pytorch_hook import VerboseModel conv_net_new = nn.Sequential( collections.OrderedDict([ ('conv1', nn.Conv2d(1, 10, kernel_size=5, padding=2)), ('pool1', nn.MaxPool2d(kernel_size=2)), ('relu1', nn.ReLU()), ('conv2', nn.Conv2d(10, 20, kernel_size=5, padding=2)), ('pool2', nn.MaxPool2d(kernel_size=2)), ('relu2', nn.ReLU()), ('dropout1', nn.Dropout2d()), ('rerange', Rearrange('b c h w -> b (c h w)')), ('linear1', nn.Linear(320, 50)), ('relu3', nn.ReLU()), ('dropout2', nn.Dropout()), ('linear', nn.Linear(50, 10)), ('logsoftmax', nn.LogSoftmax(dim=1)) ])) net = VerboseModel(model=conv_net_new) x = torch.rand(1, 1, 16, 16) out = net(x) pass
def test_plot_lines_figure(self): """ Usage: export LD_LIBRARY_PATH=~/anaconda3/envs/py36/lib/ export TIME_STR=1 export PYTHONPATH=./exp:./BigGAN_PyTorch_1_lib:./ python -c "from exp.tests.test_BigGAN import TestingCIFAR10_BigGAN_v1;\ TestingCIFAR10_BigGAN_v1().test_save_FID_cbn_index_012_figure()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config import get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, \ start_cmd_run command, outdir = get_command_and_outdir(self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file exp/configs/BigGAN_v1.yaml --tl_command {command} --tl_outdir {outdir} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) import matplotlib.pyplot as plt import numpy as np from template_lib.utils import colors_dict fig, ax = plt.subplots() ax.set_xticks(range(0, 600, 100)) ax.tick_params(labelsize=cfg.fontsize.tick_fs) ax.set_xlabel(cfg.xlabel, fontsize=cfg.fontsize.xylabel_fs) ax.set_ylabel(cfg.ylabel, fontsize=cfg.fontsize.xylabel_fs) colors = list(colors_dict.values()) # colors = [plt.cm.cool(i / float(num_plot - 1)) for i in range(num_plot)] ax.set(**cfg.properties) for idx, (_, data_dict) in enumerate(cfg.lines.items()): log_file = os.path.join(data_dict.result_dir, data_dict.sub_path) data = np.loadtxt(log_file, delimiter=':') if 'xlim' in cfg.properties: data_xlim = cfg.properties.xlim[-1] data = data[data[:, 0] <= data_xlim] if cfg.get_min_value: best_index = data[:, 1].argmin() else: best_index = data[:, 1].argmax() best_x = int(data[:, 0][best_index]) best_y = data[:, 1][best_index] if cfg.add_auxi_label: data_dict.properties.label = f'x_{best_x}-y_{best_y:.3f}-' + getattr(data_dict.properties, 'label', '') ax.plot(data[:, 0], data[:, 1], color=colors[idx], **data_dict.properties) pass ax.legend(prop={'size': cfg.fontsize.legend_size}) fig.show() saved_file = os.path.join(args.tl_outdir, cfg.saved_file) fig.savefig(saved_file, bbox_inches='tight', pad_inches=0.01) print(f'Save to {saved_file}') pass
def test_transformer(self): """Sequence-to-Sequence Modeling with nn.Transformer and TorchText """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'PORT' not in os.environ: os.environ['PORT'] = '6006' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '1' # func name assert sys._getframe().f_code.co_name.startswith('test_') command = sys._getframe().f_code.co_name[5:] class_name = self.__class__.__name__[7:] \ if self.__class__.__name__.startswith('Testing') \ else self.__class__.__name__ outdir = f'results/{class_name}/{command}' from datetime import datetime TIME_STR = bool(int(os.getenv('TIME_STR', 0))) time_str = datetime.now().strftime("%Y%m%d-%H_%M_%S_%f")[:-3] outdir = outdir if not TIME_STR else (outdir + '_' + time_str) print(outdir) import collections, shutil shutil.rmtree(outdir, ignore_errors=True) os.makedirs(outdir, exist_ok=True) import math import torch import torch.nn as nn import torch.nn.functional as F class PositionalEncoding(nn.Module): """we use sine and cosine functions of different frequencies.""" def __init__(self, d_model, dropout=0.1, max_len=5000): super(PositionalEncoding, self).__init__() self.dropout = nn.Dropout(p=dropout) pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) div_term = torch.exp( torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) pe = pe.unsqueeze(0).transpose(0, 1) self.register_buffer('pe', pe) def forward(self, x): x = x + self.pe[:x.size(0), :] return self.dropout(x) class TransformerModel(nn.Module): def __init__(self, ntoken, ninp, nhead, nhid, nlayers, dropout=0.5): super(TransformerModel, self).__init__() from torch.nn import TransformerEncoder, TransformerEncoderLayer self.model_type = 'Transformer' self.src_mask = None self.pos_encoder = PositionalEncoding(ninp, dropout) encoder_layers = TransformerEncoderLayer( ninp, nhead, nhid, dropout) self.transformer_encoder = TransformerEncoder( encoder_layers, nlayers) self.encoder = nn.Embedding(ntoken, ninp) self.ninp = ninp self.decoder = nn.Linear(ninp, ntoken) self.init_weights() def _generate_square_subsequent_mask(self, sz): mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1) mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill( mask == 1, float(0.0)) return mask def init_weights(self): initrange = 0.1 self.encoder.weight.data.uniform_(-initrange, initrange) self.decoder.bias.data.zero_() self.decoder.weight.data.uniform_(-initrange, initrange) def forward(self, src): if self.src_mask is None or self.src_mask.size(0) != len(src): device = src.device mask = self._generate_square_subsequent_mask( len(src)).to(device) self.src_mask = mask src = self.encoder(src) * math.sqrt(self.ninp) src = self.pos_encoder(src) output = self.transformer_encoder(src, self.src_mask) output = self.decoder(output) return output import torchtext from torchtext.data.utils import get_tokenizer TEXT = torchtext.data.Field(tokenize=get_tokenizer("basic_english"), init_token='<sos>', eos_token='<eos>', lower=True) train_txt, val_txt, test_txt = torchtext.datasets.WikiText2.splits( TEXT, root='datasets') TEXT.build_vocab(train_txt) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") def batchify(data, bsz): data = TEXT.numericalize([data.examples[0].text]) # Divide the dataset into bsz parts. nbatch = data.size(0) // bsz # Trim off any extra elements that wouldn't cleanly fit (remainders). data = data.narrow(0, 0, nbatch * bsz) # Evenly divide the data across the bsz batches. data = data.view(bsz, -1).t().contiguous() return data.to(device) batch_size = 20 eval_batch_size = 10 train_data = batchify(train_txt, batch_size) val_data = batchify(val_txt, eval_batch_size) test_data = batchify(test_txt, eval_batch_size) bptt = 35 def get_batch(source, i): seq_len = min(bptt, len(source) - 1 - i) data = source[i:i + seq_len] target = source[i + 1:i + 1 + seq_len].view(-1) return data, target ntokens = len(TEXT.vocab.stoi) # the size of vocabulary emsize = 200 # embedding dimension nhid = 200 # the dimension of the feedforward network model in nn.TransformerEncoder nlayers = 2 # the number of nn.TransformerEncoderLayer in nn.TransformerEncoder nhead = 2 # the number of heads in the multiheadattention models dropout = 0.2 # the dropout value model = TransformerModel(ntokens, emsize, nhead, nhid, nlayers, dropout).to(device) criterion = nn.CrossEntropyLoss() lr = 5.0 # learning rate optimizer = torch.optim.SGD(model.parameters(), lr=lr) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1.0, gamma=0.95) import time def train(): model.train() # Turn on the train mode total_loss = 0. start_time = time.time() ntokens = len(TEXT.vocab.stoi) for batch, i in enumerate(range(0, train_data.size(0) - 1, bptt)): data, targets = get_batch(train_data, i) optimizer.zero_grad() output = model(data) loss = criterion(output.view(-1, ntokens), targets) loss.backward() grad_norm = torch.nn.utils.clip_grad_norm_( model.parameters(), 0.5) optimizer.step() total_loss += loss.item() log_interval = 200 if batch % log_interval == 0 and batch > 0: cur_loss = total_loss / log_interval elapsed = time.time() - start_time print('| epoch {:3d} | {:5d}/{:5d} batches | ' 'lr {:02.2f} | ms/batch {:5.2f} | ' 'loss {:5.2f} | ppl {:8.2f}'.format( epoch, batch, len(train_data) // bptt, scheduler.get_lr()[0], elapsed * 1000 / log_interval, cur_loss, math.exp(cur_loss))) total_loss = 0 start_time = time.time() def evaluate(eval_model, data_source): eval_model.eval() # Turn on the evaluation mode total_loss = 0. ntokens = len(TEXT.vocab.stoi) with torch.no_grad(): for i in range(0, data_source.size(0) - 1, bptt): data, targets = get_batch(data_source, i) output = eval_model(data) output_flat = output.view(-1, ntokens) total_loss += len(data) * criterion(output_flat, targets).item() return total_loss / (len(data_source) - 1) best_val_loss = float("inf") epochs = 3 # The number of epochs best_model = None for epoch in range(1, epochs + 1): epoch_start_time = time.time() train() val_loss = evaluate(model, val_data) print('-' * 89) print( '| end of epoch {:3d} | time: {:5.2f}s | valid loss {:5.2f} | ' 'valid ppl {:8.2f}'.format(epoch, (time.time() - epoch_start_time), val_loss, math.exp(val_loss))) print('-' * 89) if val_loss < best_val_loss: best_val_loss = val_loss best_model = model scheduler.step() test_loss = evaluate(best_model, test_data) print('=' * 89) print( '| End of training | test loss {:5.2f} | test ppl {:8.2f}'.format( test_loss, math.exp(test_loss))) print('=' * 89)
def test_save_early_collapse_on_cifar100(self): """ Usage: export LD_LIBRARY_PATH=~/anaconda3/envs/py36/lib/ export TIME_STR=1 export PYTHONPATH=./exp:./BigGAN_PyTorch_1_lib:./ python -c "from exp.tests.test_BigGAN import TestingCIFAR10_BigGAN_v1;\ TestingCIFAR10_BigGAN_v1().test_save_FID_cbn_index_012_figure()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import get_command_and_outdir, setup_outdir_and_yaml, \ get_append_cmd_str, start_cmd_run command, outdir = get_command_and_outdir(self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file exp/configs/Figures.yaml --tl_command {command} --tl_outdir {outdir} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) cfg_str = """ xlabel: "Epoch" ylabel: "FID" fontsize: tick_fs: 14 xylabel_fs: 20 legend_size: 12 clip_x: - 0 - 24500096 # properties: # xlim: # - 0 # - 336 # ylim: # - 0 # - 30 get_min_value: true add_auxi_label: false lines: biggan_pd: result_dir: "results/CIFAR10/train_cifar100_\ 20201002-19_37_05_825" sub_path: "textdir/evaltf.ma0.FID_tf.log" properties: label: "projection discriminator (BigGAN)" marker: "." saved_file: "early_collapse_cifar100.pdf" """ import matplotlib.pyplot as plt import numpy as np from template_lib.utils import colors_dict fig, ax = plt.subplots() # ax.set_xticks(range(0, 600, 100)) ax.tick_params(labelsize=cfg.fontsize.tick_fs) ax.set_xlabel(cfg.xlabel, fontsize=cfg.fontsize.xylabel_fs) ax.set_ylabel(cfg.ylabel, fontsize=cfg.fontsize.xylabel_fs) colors = list(colors_dict.values()) # colors = [plt.cm.cool(i / float(num_plot - 1)) for i in range(num_plot)] properties = cfg.get('properties', {}) ax.set(**properties) for idx, (_, data_dict) in enumerate(cfg.lines.items()): log_file = os.path.join(data_dict.result_dir, data_dict.sub_path) data = np.loadtxt(log_file, delimiter=':') if 'clip_x' in cfg: data_xlim = cfg.clip_x[-1] data = data[data[:, 0] <= data_xlim] if cfg.get_min_value: best_index = data[:, 1].argmin() else: best_index = data[:, 1].argmax() best_x = int(data[:, 0][best_index]) best_y = data[:, 1][best_index] if cfg.add_auxi_label: data_dict.properties.label = f'x_{best_x}-y_{best_y:.3f}-' + getattr(data_dict.properties, 'label', '') ax.plot(data[:, 0], data[:, 1], color=colors[idx], **data_dict.properties) pass ax.legend(prop={'size': cfg.fontsize.legend_size}) fig.show() saved_file = os.path.join(args.tl_outdir, cfg.saved_file) fig.savefig(saved_file, bbox_inches='tight', pad_inches=0.01) print(f'Save to {saved_file}') pass
def test_omni_GAN(self, debug=True): """ Usage: python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/pypi/torch1_7_0 -d /cache/pypi -t copytree for filename in /cache/pypi/*.whl; do pip install $filename done proj_root=moco-exp python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/codes/$proj_root -d /cache/$proj_root -t copytree -b /cache/$proj_root/code.zip cd /cache/$proj_root pip install -r requirements.txt export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 export TIME_STR=1 export PYTHONPATH=./exp:./stylegan2-pytorch:./ python -c "from exp.tests.test_styleganv2 import Testing_stylegan2;\ Testing_stylegan2().test_train_ffhq_128()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) tl_opts = ' '.join(sys.argv[sys.argv.index('--tl_opts') + 1:]) if '--tl_opts' in sys.argv else '' print(f'tl_opts:\n {tl_opts}') command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file template_lib/v2/GAN/loss/configs/omni_loss_OmniLoss.yaml --tl_command {command} --tl_outdir {outdir} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) import torch from template_lib.v2.GAN.loss import build_GAN_loss omni_loss = build_GAN_loss(cfg) b, nc = 32, 100 out_dim = nc + 2 pred = torch.rand(b, out_dim).cuda().requires_grad_() y = torch.randint(0, nc, (b, )).cuda() D_loss_real, logits_pos, logits_neg = omni_loss(pred=pred, positive=(y, out_dim - 2), return_logits=True) D_loss_fake = omni_loss(pred=pred, positive=(out_dim - 1, )) G_loss, logits_pos, logits_neg = omni_loss(pred=pred, positive=(y, out_dim - 2), return_logits=True) pass
def test_save_OmniGAN_ImageNet128_IS(self): """ Usage: export TIME_STR=1 export PYTHONPATH=./exp:./BigGAN_PyTorch_1_lib:./ python -c "from exp.tests.test_BigGAN_v1 import Testing_Figures;\ Testing_Figures().test_save_early_collapse_on_cifar100()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import get_command_and_outdir, setup_outdir_and_yaml, \ get_append_cmd_str, start_cmd_run from template_lib.v2.matplot import set_font set_font() command, outdir = get_command_and_outdir(self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file exp/tests/configs/Figures.yaml --tl_command {command} --tl_outdir {outdir} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) import matplotlib.pyplot as plt import numpy as np import pickle from template_lib.utils import colors_dict fig, ax = plt.subplots() # ax.set_xticks(range(0, 600, 100)) ax.tick_params(labelsize=cfg.fontsize.tick_fs) ax.set_xlabel(cfg.xlabel, fontsize=cfg.fontsize.xylabel_fs) ax.set_ylabel(cfg.ylabel, fontsize=cfg.fontsize.xylabel_fs) properties = cfg.get('properties', {}) ax.set(**properties) with open(cfg.data_pickle, 'rb') as f: data_list = pickle.load(f) load_data_dict = data_list[cfg.data_index] for idx, (_, data_dict) in enumerate(cfg.lines.items()): data = load_data_dict[data_dict.key] if 'clip_x' in cfg: data_xlim = cfg.clip_x[-1] data = data[data[:, 0] <= data_xlim] if cfg.get_min_value: best_index = data[:, 1].argmin() else: best_index = data[:, 1].argmax() best_x = int(data[:, 0][best_index]) best_y = data[:, 1][best_index] if cfg.get('add_auxi_label', False): data_dict.properties.label = f'x_{best_x}-y_{best_y:.3f}-' + getattr(data_dict.properties, 'label', '') ax.plot(data[:, 0], data[:, 1], color=colors_dict[data_dict.color], **data_dict.properties) pass ax.legend(prop={'size': cfg.fontsize.legend_size}, ncol=1) fig.show() saved_file = os.path.join(args.tl_outdir, cfg.saved_file) fig.savefig(saved_file, bbox_inches='tight', pad_inches=0.01) print(f'Save to {saved_file}') pass
def test_cmap(self): """ """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'PORT' not in os.environ: os.environ['PORT'] = '6006' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' # func name assert sys._getframe().f_code.co_name.startswith('test_') command = sys._getframe().f_code.co_name[5:] class_name = self.__class__.__name__[7:] \ if self.__class__.__name__.startswith('Testing') \ else self.__class__.__name__ outdir = f'results/{class_name}/{command}' from template_lib.utils.plot_results import PlotResults import collections, shutil shutil.rmtree(outdir, ignore_errors=True) os.makedirs(outdir, exist_ok=True) from matplotlib import colors import matplotlib.pyplot as plt import numpy as np np.random.seed(19680801) Nr = 3 Nc = 2 cmap = "cool" fig, axs = plt.subplots(Nr, Nc) fig.suptitle('Multiple images') images = [] for i in range(Nr): for j in range(Nc): # Generate data with a range that varies from one plot to the next. data = ((1 + i + j) / 10) * np.random.rand(10, 20) * 1e-6 images.append(axs[i, j].imshow(data, cmap=cmap)) axs[i, j].label_outer() # Find the min and max of all colors for use in setting the color scale. vmin = min(image.get_array().min() for image in images) vmax = max(image.get_array().max() for image in images) norm = colors.Normalize(vmin=vmin, vmax=vmax) for im in images: im.set_norm(norm) fig.colorbar(images[0], ax=axs, orientation='horizontal', fraction=.1) # Make images respond to changes in the norm of other images (e.g. via the # "edit axis, curves and images parameters" GUI on Qt), but be careful not to # recurse infinitely! def update(changed_image): for im in images: if (changed_image.get_cmap() != im.get_cmap() or changed_image.get_clim() != im.get_clim()): im.set_cmap(changed_image.get_cmap()) im.set_clim(changed_image.get_clim()) for im in images: im.callbacksSM.connect('changed', update) plt.show()
def test_plot_compare_methods(self): """ """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'PORT' not in os.environ: os.environ['PORT'] = '6006' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '1' # func name assert sys._getframe().f_code.co_name.startswith('test_') command = sys._getframe().f_code.co_name[5:] class_name = self.__class__.__name__[7:] \ if self.__class__.__name__.startswith('Testing') \ else self.__class__.__name__ outdir = f'results/{class_name}/{command}' from datetime import datetime TIME_STR = bool(int(os.getenv('TIME_STR', 0))) time_str = datetime.now().strftime("%Y%m%d-%H_%M_%S_%f")[:-3] outdir = outdir if not TIME_STR else (outdir + '_' + time_str) print(outdir) import collections, shutil shutil.rmtree(outdir, ignore_errors=True) os.makedirs(outdir, exist_ok=True) from collections import OrderedDict from functools import partial from time import time import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from matplotlib.ticker import NullFormatter from sklearn import manifold, datasets # Next line to silence pyflakes. This import is needed. Axes3D n_points = 1000 X, color = datasets.make_s_curve(n_points, random_state=0) n_neighbors = 10 n_components = 2 # Create figure fig = plt.figure(figsize=(15, 8)) fig.suptitle("Manifold Learning with %i points, %i neighbors" % (1000, n_neighbors), fontsize=14) # Add 3d scatter plot ax = fig.add_subplot(251, projection='3d') ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=color, cmap=plt.cm.Spectral) ax.view_init(4, -72) # Set-up manifold methods LLE = partial(manifold.LocallyLinearEmbedding, n_neighbors, n_components, eigen_solver='auto') methods = OrderedDict() methods['LLE'] = LLE(method='standard') methods['LTSA'] = LLE(method='ltsa') methods['Hessian LLE'] = LLE(method='hessian') methods['Modified LLE'] = LLE(method='modified') methods['Isomap'] = manifold.Isomap(n_neighbors, n_components) methods['MDS'] = manifold.MDS(n_components, max_iter=100, n_init=1) methods['SE'] = manifold.SpectralEmbedding(n_components=n_components, n_neighbors=n_neighbors) methods['t-SNE'] = manifold.TSNE(n_components=n_components, init='pca', random_state=0) # Plot results for i, (label, method) in enumerate(methods.items()): t0 = time() Y = method.fit_transform(X) t1 = time() print("%s: %.2g sec" % (label, t1 - t0)) ax = fig.add_subplot(2, 5, 2 + i + (i > 3)) ax.scatter(Y[:, 0], Y[:, 1], c=color, cmap=plt.cm.Spectral) ax.set_title("%s (%.2g sec)" % (label, t1 - t0)) ax.xaxis.set_major_formatter(NullFormatter()) ax.yaxis.set_major_formatter(NullFormatter()) ax.axis('tight') plt.show() pass
def test_modelarts_copy_data(self): """ Usage: exp_name=wgan-pytorch0 export root_obs=s3://bucket-cv-competition/ZhouPeng mkdir -p /cache/.keras/ && rm -rf $HOME/.keras && ln -s /cache/.keras $HOME/.keras export RESULTS_OBS=$root_obs/results/$exp_name python /home/work/user-job-dir/code/copy_tool.py \ -s $root_obs/code/$exp_name \ -d /cache/code/$exp_name -t copytree ln -s /cache/code/$exp_name /cache/code/template_lib cd /cache/code/$exp_name/ export CUDA_VISIBLE_DEVICES=0 export PORT=6006 export TIME_STR=1 export PYTHONPATH=../ python -c "from utils import modelarts_utils; \ modelarts_utils.TestingUnit().test_modelarts_copy_data()" :return: """ import template_lib.utils as utils if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'PORT' not in os.environ: os.environ['PORT'] = '6006' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '1' # func name outdir = os.path.join('results', sys._getframe().f_code.co_name) myargs = argparse.Namespace() def build_args(): argv_str = f""" --config ./configs/config.yaml --command test_command --resume False --resume_path None --resume_root None """ parser = utils.args_parser.build_parser() if len(sys.argv) == 1: args = parser.parse_args(args=argv_str.split()) else: args = parser.parse_args() args.CUDA_VISIBLE_DEVICES = os.environ['CUDA_VISIBLE_DEVICES'] args = utils.config_utils.DotDict(vars(args)) return args, argv_str args, argv_str = build_args() args.outdir = outdir args, myargs = utils.config.setup_args_and_myargs(args=args, myargs=myargs, start_tb=False) modelarts_sync_results(args, myargs, join=True) datapath_obs = 's3://bucket-cv-competition/ZhouPeng/keras/cifar10' datapath = '~/.keras/cifar10' modelarts_copy_data(datapath_obs=datapath_obs, datapath=datapath, overwrite=True) datapath_obs = 's3://bucket-cv-competition/ZhouPeng/keras/cifar10/cifar10_inception_moments.npz' datapath = '~/.keras/cifar10_inception_moments.npz' modelarts_copy_data(datapath_obs=datapath_obs, datapath=datapath, overwrite=False) modelarts_sync_results(args, myargs, join=True, end=True) input('End %s' % outdir) return
def test_show_video(self, debug=True): """ Usage: export CUDA_VISIBLE_DEVICES=7 export TIME_STR=1 export PYTHONPATH=./ python -c "from template_lib.proj.streamlit.tests.test_streamlit import Testing_Streamlit;\ Testing_Streamlit().test_show_video(debug=False)" \ --tl_opts port 8530 start_web True show_video.num_video 7 :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) tl_opts = ' '.join(sys.argv[sys.argv.index('--tl_opts') + 1:]) if '--tl_opts' in sys.argv else '' print(f'tl_opts:\n {tl_opts}') command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file template_lib/proj/streamlit/scripts/configs/Streamlit.yaml --tl_command {command} --tl_outdir {outdir} --tl_opts {tl_opts} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) n_gpus = len(os.environ['CUDA_VISIBLE_DEVICES'].split(',')) script = "template_lib/proj/streamlit/scripts/run_web.py" if debug: cmd_str = f""" python {script} {get_append_cmd_str(args)} --tl_debug --tl_opts """ else: if cfg.start_web: cmd_str_prefix = f""" {os.path.dirname(sys.executable)}/streamlit run --server.port {cfg.port} {script} -- """ else: cmd_str_prefix = f"python {script}" cmd_str = f""" {cmd_str_prefix} {get_append_cmd_str(args)} --tl_opts {tl_opts} """ start_cmd_run(cmd_str) pass
def test_step_closure(self, debug=True): """ Usage: python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/pypi/torch1_7_0 -d /cache/pypi -t copytree for filename in /cache/pypi/*.whl; do pip install $filename done proj_root=moco-exp python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/codes/$proj_root -d /cache/$proj_root -t copytree -b /cache/$proj_root/code.zip cd /cache/$proj_root pip install -r requirements.txt export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 export TIME_STR=1 export PYTHONPATH=./exp:./stylegan2-pytorch:./ python -c "from exp.tests.test_styleganv2 import Testing_stylegan2;\ Testing_stylegan2().test_train_ffhq_128()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) tl_opts = ' '.join(sys.argv[sys.argv.index('--tl_opts') + 1:]) if '--tl_opts' in sys.argv else '' print(f'tl_opts:\n {tl_opts}') command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file none --tl_command none --tl_outdir {outdir} """ args = setup_outdir_and_yaml(argv_str, return_cfg=True) from torch.nn import CrossEntropyLoss class DummyModel(nn.Module): def __init__(self, class_num=10): super(DummyModel, self).__init__() self.base = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.ReLU(), ) self.gap = nn.AdaptiveAvgPool2d(1) self.fc = nn.Linear(128, class_num) def forward(self, x): x = self.base(x) x = self.gap(x) x = x.view(x.shape[0], -1) x = self.fc(x) return x dummy_model = DummyModel().cuda() optimizer = SGD(dummy_model.parameters(), lr=1e-2, momentum=0.9, weight_decay=1e-4) # 定义loss loss_fn = CrossEntropyLoss() # 定义数据 batch_size = 2 data = torch.randn(64, 3, 64, 128).cuda() # 制造假数据shape=64 * 3 * 64 * 128 data_label = torch.randint(0, 10, size=(64, ), dtype=torch.long).cuda() # 制造假的label for batch_index in range(10): batch_data = data[batch_index * batch_size:batch_index * batch_size + batch_size] batch_label = data_label[batch_index * batch_size:batch_index * batch_size + batch_size] def closure(): optimizer.zero_grad() # 清空梯度 output = dummy_model(batch_data) # forward loss = loss_fn(output, batch_label) # 计算loss loss.backward() # backward print('No.{: 2d} loss: {:.6f}'.format(batch_index, loss.item())) return loss optimizer.step(closure=closure) # 更新参数 pass
def test_sr_merge_original_image_and_patches_tensor(self, debug=True): """ Usage: export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 export TIME_STR=1 export PYTHONPATH=./exp:./stylegan2-pytorch:./ python -c "from exp.tests.test_styleganv2 import Testing_stylegan2;\ Testing_stylegan2().test_train_ffhq_128()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) tl_opts = ' '.join(sys.argv[sys.argv.index('--tl_opts') + 1:]) if '--tl_opts' in sys.argv else '' print(f'tl_opts:\n {tl_opts}') command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file none --tl_command none --tl_outdir {outdir} --tl_opts {tl_opts} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) n_gpus = len(os.environ['CUDA_VISIBLE_DEVICES'].split(',')) import torchvision.transforms.functional as trans_f img_path = "template_lib/datasets/images/zebra_GT_target_origin.png" # img_path = "results/Recons_SR_web_OmniINRGAN256/load_G_recons_sr_OmniInrGAN256/imgdir/zebra_GT_reconstruction64x.png" left = [640, 2300] upper = [960, 800] w = 400 h = 160 pad = 20 size = 2048 width = 20 patch_width = 5 image = Image.open(img_path) img_tensor = trans_f.to_tensor(image) img_tensor = trans_f.resize(img_tensor, size=size, interpolation=Image.NEAREST) out_image = sr_merge_original_image_and_patches_tensor( img_tensor=img_tensor, lefts=left, uppers=upper, w=w, h=h, pad=pad, width=width, patch_width=patch_width) out_image = trans_f.to_pil_image(out_image) fig, axes = plt.subplots(1, 1) axes.imshow(out_image) # axes[1].imshow(patch) fig.show() pass
def test_diff_lr(self, debug=True): """ Usage: python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/pypi/torch1_7_0 -d /cache/pypi -t copytree for filename in /cache/pypi/*.whl; do pip install $filename done proj_root=moco-exp python template_lib/modelarts/scripts/copy_tool.py \ -s s3://bucket-7001/ZhouPeng/codes/$proj_root -d /cache/$proj_root -t copytree -b /cache/$proj_root/code.zip cd /cache/$proj_root pip install -r requirements.txt export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 export TIME_STR=1 export PYTHONPATH=./exp:./stylegan2-pytorch:./ python -c "from exp.tests.test_styleganv2 import Testing_stylegan2;\ Testing_stylegan2().test_train_ffhq_128()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) tl_opts = ' '.join(sys.argv[sys.argv.index('--tl_opts') + 1:]) if '--tl_opts' in sys.argv else '' print(f'tl_opts:\n {tl_opts}') command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file none --tl_command none --tl_outdir {outdir} """ args = setup_outdir_and_yaml(argv_str, return_cfg=True) from torch.optim import SGD from torch import nn class DummyModel(nn.Module): def __init__(self, class_num=10): super(DummyModel, self).__init__() self.base = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.ReLU(), ) self.gap = nn.AdaptiveAvgPool2d(1) self.fc = nn.Linear(128, class_num) def forward(self, x): x = self.base(x) x = self.gap(x) x = x.view(x.shape[0], -1) x = self.fc(x) return x model = DummyModel().cuda() optimizer = SGD( [ { 'params': model.base.parameters() }, { 'params': model.fc.parameters(), 'lr': 1e-3 } # 对 fc的参数设置不同的学习率 ], lr=1e-2, momentum=0.9) pass
def test_learning_methods_on_graphs(self): """ export LD_LIBRARY_PATH=/usr/local/cuda-10.0/lib64:/usr/local/cudnn-10.0-v7.6.5.32 proxychains python -c "from template_lib.examples.DGL.geometric.test_pytorch_geometric import TestingGeometric;\ TestingGeometric().test_learning_methods_on_graphs()" """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'PORT' not in os.environ: os.environ['PORT'] = '6006' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '1' # func name assert sys._getframe().f_code.co_name.startswith('test_') command = sys._getframe().f_code.co_name[5:] class_name = self.__class__.__name__[7:] \ if self.__class__.__name__.startswith('Testing') \ else self.__class__.__name__ outdir = f'results/{class_name}/{command}' from datetime import datetime TIME_STR = bool(int(os.getenv('TIME_STR', 0))) time_str = datetime.now().strftime("%Y%m%d-%H_%M_%S_%f")[:-3] outdir = outdir if not TIME_STR else (outdir + '_' + time_str) print(outdir) import collections, shutil shutil.rmtree(outdir, ignore_errors=True) os.makedirs(outdir, exist_ok=True) from torch_geometric.datasets import Planetoid dataset = Planetoid(root='datasets/cora', name='Cora') import torch import torch.nn.functional as F from torch_geometric.nn import GCNConv class Net(torch.nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = GCNConv(dataset.num_node_features, 16) self.conv2 = GCNConv(16, dataset.num_classes) def forward(self, data): x, edge_index = data.x, data.edge_index x = self.conv1(x, edge_index) x = F.relu(x) x = F.dropout(x, training=self.training) x = self.conv2(x, edge_index) return F.log_softmax(x, dim=1) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = Net().to(device) data = dataset[0].to(device) optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4) model.train() for epoch in range(200): optimizer.zero_grad() out = model(data) loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask]) loss.backward() optimizer.step() model.eval() _, pred = model(data).max(dim=1) correct = float(pred[data.test_mask].eq( data.y[data.test_mask]).sum().item()) acc = correct / data.test_mask.sum().item() print('Accuracy: {:.4f}'.format(acc)) pass