def parse_args(args=None):
parser = jsonargparse.ArgumentParser(
prog='scae',
description=
'Training/evaluation/inference script for Stacked Capsule Autoencoders',
allow_abbrev=False,
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
default_config_files=['scae/config/default.yaml'])
parser.add_argument('--cfg',
action=jsonargparse.ActionConfigFile,
help='Overides all args before this is passed')
# todo(maximsmol): add inference and evaluation
parser.add_argument('-n',
'--batch_size',
type=int,
default=128,
help='number of samples per mini_batch')
parser.add_argument('-N',
'--num_epochs',
type=int,
default=300,
metavar='NEPOCHS',
help='number of epochs')
parser.add_argument(
'--non_deterministic',
action='store_true',
default=False,
help=
'allow non_deterministic operations for potentially higher performance'
)
parser.add_argument('-d',
'--debug',
action='store_true',
default=False,
help='enable autograd anomaly detection')
parser.add_argument(
'--model',
type=str.lower,
default='pcae',
choices=['ccae', 'pcae', 'ocae', 'scae'],
# todo(maximsmol): change default
help='part of the model to run')
parser.add_argument('--dataset',
type=str.lower,
default='mnist',
choices=['mnist', 'usps', 'cifar10', 'svhn'])
parser.add_argument(
'--data_workers',
type=int,
default=len(os.sched_getaffinity(0)), # alt: os.cpu_count()
metavar='NWORKERS',
help='number of data loader workers')
add_pcae_args(parser)
add_ocae_args(parser)
add_log_args(parser)
return namespace_to_edict(parser.parse_args(args=args, _skip_check=True))
def get_args(argv: Optional[List[str]] = None) -> Dict[str, Any]:
parser = jsonargparse.ArgumentParser(parse_as_dict=True)
parser.add_argument("--config",
action=jsonargparse.ActionConfigFile,
help="Configuration file")
parser.add_argument(
"img_list",
type=str,
help=
("File containing the images to decode. Each image is expected to be in one "
'line. Lines starting with "#" will be ignored. Lines can be filepaths '
'(e.g. "/tmp/img.jpg") or filenames of images present in --img_dirs (e.g. '
"img.jpg). The filename extension is optional and case insensitive"),
)
parser.add_argument(
"--img_dirs",
type=Optional[List[str]],
default=None,
help=("Directories containing word images. "
"Optional if `img_list` contains filepaths"),
)
parser.add_class_arguments(CommonArgs, "common")
parser.add_class_arguments(DataArgs, "data")
parser.add_function_arguments(log.config, "logging")
parser.add_class_arguments(NetoutArgs, "netout")
parser.add_class_arguments(TrainerArgs, "trainer")
args = parser.parse_args(argv, with_meta=False)
args["common"] = CommonArgs(**args["common"])
args["data"] = DataArgs(**args["data"])
args["netout"] = NetoutArgs(**args["netout"])
args["trainer"] = TrainerArgs(**args["trainer"])
return args
def main():
parser = jsonargparse.ArgumentParser(
description=
"Monitor SSL certificates expiration registered in a F5 server.",
default_env=True,
)
parser.add_argument(
"-w",
"--warning",
help="number of days to raise a warning",
type=int,
required=True,
)
parser.add_argument(
"-c",
"--critical",
help="number of days to raise a critical",
type=int,
required=True,
)
parser.add_argument("--f5.ip",
help="F5 IP or hostname to connect to",
required=True)
parser.add_argument("--f5.user",
help="F5 user to access Big IP API",
required=True)
parser.add_argument("--f5.password",
help="F5 password to access Big IP API",
required=True)
args = parser.parse_args()
return check(args)
def get_args(argv: Optional[List[str]] = None) -> Dict[str, Any]:
parser = jsonargparse.ArgumentParser(
parse_as_dict=True,
description=
("Create a model for HTR composed of a set of convolutional blocks, followed"
" by a set of bidirectional RNN layers, and a final linear layer. Each"
" convolutional block is composed by a 2D convolutional layer, an optional"
" batch normalization layer, a non-linear activation function, and an"
" optional 2D max-pooling layer. A dropout layer might precede each"
" block, rnn layer, and the final linear layer"),
)
parser.add_argument("--config",
action=jsonargparse.ActionConfigFile,
help="Configuration file")
parser.add_argument(
"syms",
type=str,
help=("Mapping from strings to integers. "
"The CTC symbol must be mapped to integer 0"),
)
parser.add_argument(
"--fixed_input_height",
type=NonNegativeInt,
default=0,
help=
("Height of the input images. If 0, a variable height model "
"will be used (see `adaptive_pooling`). This will be used to compute the "
"model output height at the end of the convolutional layers"),
)
parser.add_argument(
"--adaptive_pooling",
type=str,
default="avgpool-16",
help=
("Use our custom adaptive pooling layers. This option allows training with"
" variable height images. Takes into account the size of each individual"
" image within the bach (before padding). (allowed: {avg,max}pool-N)"
),
)
parser.add_argument(
"--save_model",
type=bool,
default=True,
help="Whether to save the model to a file",
)
parser.add_class_arguments(CommonArgs, "common")
parser.add_function_arguments(log.config, "logging")
parser.add_class_arguments(CreateCRNNArgs, "crnn")
args = parser.parse_args(argv, with_meta=False)
args["common"] = CommonArgs(**args["common"])
args["crnn"] = CreateCRNNArgs(**args["crnn"])
return args
def get_config():
p = jsonargparse.ArgumentParser(
default_config_files=[
'/etc/netbox_agent.yaml',
'~/.config/netbox_agent.yaml',
'~/.netbox_agent.yaml',
],
prog='netbox_agent',
description="Netbox agent to run on your infrastructure's servers",
)
p.add_argument('-c', '--config', action=jsonargparse.ActionConfigFile)
p.add_argument('-r', '--register', action='store_true', help='Register server to Netbox')
p.add_argument('-u', '--update-all', action='store_true', help='Update all infos in Netbox')
p.add_argument('-d', '--debug', action='store_true', help='Print debug infos')
p.add_argument('--update-network', action='store_true', help='Update network')
p.add_argument('--update-inventory', action='store_true', help='Update inventory')
p.add_argument('--update-location', action='store_true', help='Update location')
p.add_argument('--update-psu', action='store_true', help='Update PSU')
p.add_argument('--log_level', default='debug')
p.add_argument('--netbox.url', help='Netbox URL')
p.add_argument('--netbox.token', help='Netbox API Token')
p.add_argument('--hostname_cmd', default=None,
help="Command to output hostname, used as Device's name in netbox")
p.add_argument('--datacenter_location.driver',
help='Datacenter location driver, ie: cmd, file')
p.add_argument('--datacenter_location.driver_file',
help='Datacenter location custom driver file path')
p.add_argument('--datacenter_location.regex',
help='Datacenter location regex to extract Netbox DC slug')
p.add_argument('--rack_location.driver', help='Rack location driver, ie: cmd, file')
p.add_argument('--rack_location.driver_file', help='Rack location custom driver file path')
p.add_argument('--rack_location.regex', help='Rack location regex to extract Rack name')
p.add_argument('--slot_location.driver', help='Slot location driver, ie: cmd, file')
p.add_argument('--slot_location.driver_file', help='Slot location custom driver file path')
p.add_argument('--slot_location.regex', help='Slot location regex to extract slot name')
p.add_argument('--network.ignore_interfaces', default=r'(dummy.*|docker.*)',
help='Regex to ignore interfaces')
p.add_argument('--network.ignore_ips', default=r'^(127\.0\.0\..*|fe80.*|::1.*)',
help='Regex to ignore IPs')
p.add_argument('--network.lldp', help='Enable auto-cabling feature through LLDP infos')
p.add_argument('--inventory', action='store_true',
help='Enable HW inventory (CPU, Memory, RAID Cards, Disks) feature')
options = p.parse_args()
return options
def get_args(argv: Optional[List[str]] = None) -> Dict[str, Any]:
parser = jsonargparse.ArgumentParser(parse_as_dict=True)
parser.add_argument("--config",
action=jsonargparse.ActionConfigFile,
help="Configuration file")
parser.add_argument(
"syms",
type=str,
help=("Mapping from strings to integers. "
"The CTC symbol must be mapped to integer 0"),
)
parser.add_argument(
"img_dirs",
type=List[str],
default=[],
help="Directories containing segmented line images",
)
parser.add_argument(
"tr_txt_table",
type=str,
help="Character transcription of each training image",
)
parser.add_argument(
"va_txt_table",
type=str,
help="Character transcription of each validation image",
)
parser.add_class_arguments(CommonArgs, "common")
parser.add_class_arguments(DataArgs, "data")
parser.add_class_arguments(TrainArgs, "train")
parser.add_function_arguments(log.config, "logging")
parser.add_class_arguments(OptimizerArgs, "optimizer")
parser.add_class_arguments(SchedulerArgs, "scheduler")
parser.add_class_arguments(TrainerArgs, "trainer")
args = parser.parse_args(argv, with_meta=False)
args["common"] = CommonArgs(**args["common"])
args["train"] = TrainArgs(**args["train"])
args["data"] = DataArgs(**args["data"])
args["optimizer"] = OptimizerArgs(**args["optimizer"])
args["scheduler"] = SchedulerArgs(**args["scheduler"])
args["trainer"] = TrainerArgs(**args["trainer"])
return args
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import jsonargparse
import logging
from SVS.model.infer import infer
if __name__ == "__main__":
parser = jsonargparse.ArgumentParser(description="SVS training")
parser.add_argument(
"-c",
"--config",
help="config file path",
action=jsonargparse.ActionConfigFile,
)
parser.add_argument("--test_align", help="alignment data dir used for validation.")
parser.add_argument("--test_pitch", help="pitch data dir used for validation.")
parser.add_argument("--test_wav", help="wave data dir used for validation")
parser.add_argument("--model_file", help="model file for prediction.")
parser.add_argument(
"--prediction_path", help="prediction result output (e.g. wav, png)."
)
parser.add_argument(
"--model_type",
def main():
parser = jsonargparse.ArgumentParser(description='General arguments',
default_meta=False)
parser.add_argument('-t',
'--general.experiment_type',
default='cifar_adversarial',
help='Type of experiment to execute',
type=str)
parser.add_argument(
'-p',
'--general.param_file_path',
default=os.path.join('./src/parameters', 'cifar_params.json'),
help=
'param file path used to load the parameters file containing default values to all '
'parameters',
type=str)
parser.add_argument('--general.save',
default=False,
action='store_true',
help='Whether to save adversarial samples output',
type=bool)
# parser.add_argument('-p', '--general.param_file_path', default='src/tests/test_mnist_pgd_with_pnml_expected_result/params.json',
# help='param file path used to load the parameters file containing default values to all '
# 'parameters', type=str)
parser.add_argument(
'-o',
'--general.output_root',
default='output',
help='the output directory where results will be saved',
type=str)
parser.add_argument('-f',
'--adv_attack_test.test_start_idx',
help='first test idx',
type=int)
parser.add_argument('-l',
'--adv_attack_test.test_end_idx',
help='last test idx',
type=int)
parser.add_argument('-e',
'--adv_attack_test.epsilon',
help='the epsilon strength of the attack',
type=float)
parser.add_argument('-ts',
'--adv_attack_test.pgd_step',
help='the step size of the attack',
type=float)
parser.add_argument('-ti',
'--adv_attack_test.pgd_iter',
help='the number of test pgd iterations',
type=int)
parser.add_argument(
'-b',
'--adv_attack_test.beta',
help='the beta value for regret reduction regularization ',
type=float)
parser.add_argument('--adv_attack_test.attack_type',
help='The type of the attack',
type=str)
parser.add_argument('-r',
'--fit_to_sample.epsilon',
help='the epsilon strength of the refinement (lambda)',
type=float)
parser.add_argument('-i',
'--fit_to_sample.pgd_iter',
help='the number of PGD iterations of the refinement',
type=int)
parser.add_argument('-s',
'--fit_to_sample.pgd_step',
help='the step size of the refinement',
type=float)
parser.add_argument(
'-n',
'--fit_to_sample.pgd_test_restart_num',
help='the number of PGD restarts where 0 means no random start',
type=int)
args = jsonargparse.namespace_to_dict(parser.parse_args())
general_args = args.pop('general')
exp = Experiment(general_args, args)
logger_utilities.init_logger(logger_name=exp.get_exp_name(),
output_root=exp.output_dir)
logger = logger_utilities.get_logger()
# Get models:
model_to_eval = exp.get_model(
exp.params['model']['model_arch'], exp.params['model']['ckpt_path'],
exp.params['model']['pnml_active'], True if
exp.params["adv_attack_test"]["attack_type"] != "natural" else False)
dataloaders = exp.get_dataloaders()
# Get adversarial attack:
attack = exp.get_attack_for_model(model_to_eval)
with open(os.path.join(logger.output_folder, 'params.json'),
'w',
encoding='utf8') as outfile:
outfile.write(json.dumps(exp.params, indent=4, sort_keys=False))
logger.info(exp.params)
# adv, adv_pnml, natural, natural_pnml = eval_all(model_to_eval, dataloaders['test'], attack, exp)
# logger.info("Base model adversarial - Accuracy: {}, Loss: {}".format(adv.get_accuracy(), adv.get_mean_loss()))
# logger.info("Pnml model adversarial - Accuracy: {}, Loss: {}".format(adv_pnml.get_accuracy(), adv_pnml.get_mean_loss()))
# logger.info("Base model natural - Accuracy: {}, Loss: {}".format(natural.get_accuracy(), natural.get_mean_loss()))
# logger.info("Pnml model natural - Accuracy: {}, Loss: {}".format(natural_pnml.get_accuracy(), natural_pnml.get_mean_loss()))
adv = eval_adversarial_dataset(model_to_eval, dataloaders['test'], attack,
general_args['save'])
loss = adv.get_mean_loss()
acc = adv.get_accuracy()
logger.info("Accuracy: {}, Loss: {}".format(acc, loss))
adv.dump(logger.output_folder)
return adv
def parse_cli_and_generate():
"""Parse CLI arguments and call :func:`generate` function.
Parsing is done using `jsonargparse
<https://omni-us.github.io/jsonargparse/>`_. This function is called by the
``foamgen`` executable.
"""
prs = jp.ArgumentParser(prog='foamgen',
error_handler=jp.usage_and_exit_error_handler,
description='Generate foam morphology.')
prs.add_argument('-v',
'--verbose',
default=False,
action='store_true',
help='verbose output')
prs.add_argument('-c',
'--config',
action=jp.ActionConfigFile,
help='name of config file')
prs.add_argument('-f', '--filename', default='Foam', help='base filename')
prs.add_argument('-p',
'--pack.active',
default=False,
action='store_true',
help='create sphere packing')
prs.add_argument('--pack.ncells',
default=27,
type=int,
help='number of cells')
prs.add_argument('--pack.shape',
default=0.2,
type=float,
help='sphere size distribution shape factor')
prs.add_argument('--pack.scale',
default=0.35,
type=float,
help='sphere size distribution scale factor')
prs.add_argument('--pack.alg', default='fba', help='packing algorithm')
prs.add_argument('--pack.render',
default=False,
action='store_true',
help='visualize packing')
prs.add_argument('--pack.clean',
default=True,
action='store_true',
help='clean redundant files')
prs.add_argument('--pack.maxit',
default=5,
type=int,
help='maximum number of iterations')
prs.add_argument('-t',
'--tess.active',
default=False,
action='store_true',
help='create tessellation')
prs.add_argument('--tess.render',
default=False,
action='store_true',
help='visualize tessellation')
prs.add_argument('--tess.clean',
default=True,
action='store_true',
help='clean redundant files')
prs.add_argument('-m',
'--morph.active',
default=False,
action='store_true',
help='create final morphology')
prs.add_argument('--morph.dwall',
default=0.02,
type=float,
help='wall thickness')
prs.add_argument('--morph.clean',
default=True,
action='store_true',
help='clean redundant files')
prs.add_argument('-u',
'--umesh.active',
default=False,
action='store_true',
help='create unstructured mesh')
prs.add_argument('--umesh.psize',
default=0.025,
type=float,
help='mesh size near geometry points')
prs.add_argument('--umesh.esize',
default=0.1,
type=float,
help='mesh size near geometry edges')
prs.add_argument('--umesh.csize',
default=0.1,
type=float,
help='mesh size in middle of geometry cells')
prs.add_argument('--umesh.convert',
default=True,
action='store_true',
help='convert mesh to *.xml for fenics')
prs.add_argument('-s',
'--smesh.active',
default=False,
action='store_true',
help='create structured mesh')
prs.add_argument('--smesh.strut',
default=0.6,
type=float,
help='strut content')
prs.add_argument('--smesh.por', default=0.94, type=float, help='porosity')
prs.add_argument('--smesh.isstrut',
default=4,
type=int,
help='initial guess of strut size parameter')
prs.add_argument('--smesh.binarize',
default=True,
action='store_true',
help='binarize structure')
prs.add_argument('--smesh.perbox',
default=True,
action='store_true',
help='transform structure to periodic box')
cfg = prs.parse_args(sys.argv[1:])
generate(cfg)
def get_config():
p = jsonargparse.ArgumentParser(
default_config_files=[
'/etc/netbox_agent.yaml',
'~/.config/netbox_agent.yaml',
'~/.netbox_agent.yaml',
],
prog='netbox_agent',
description="Netbox agent to run on your infrastructure's servers",
env_prefix='NETBOX_AGENT_',
default_env=True)
p.add_argument('-c', '--config', action=jsonargparse.ActionConfigFile)
p.add_argument('-r',
'--register',
action='store_true',
help='Register server to Netbox')
p.add_argument('-u',
'--update-all',
action='store_true',
help='Update all infos in Netbox')
p.add_argument('-d',
'--debug',
action='store_true',
help='Print debug infos')
p.add_argument('--update-network',
action='store_true',
help='Update network')
p.add_argument('--update-inventory',
action='store_true',
help='Update inventory')
p.add_argument('--update-location',
action='store_true',
help='Update location')
p.add_argument('--update-psu', action='store_true', help='Update PSU')
p.add_argument('--log_level', default='debug')
p.add_argument('--netbox.url', help='Netbox URL')
p.add_argument('--netbox.token', help='Netbox API Token')
p.add_argument('--netbox.ssl_verify',
default=True,
action='store_true',
help='Disable SSL verification')
p.add_argument('--virtual.enabled',
action='store_true',
help='Is a virtual machine or not')
p.add_argument('--virtual.cluster_name', help='Cluster name of VM')
p.add_argument(
'--hostname_cmd',
default=None,
help="Command to output hostname, used as Device's name in netbox")
p.add_argument('--device.tags', default=r'', help='tags to use for a host')
p.add_argument('--device.blade_role',
default=r'Blade',
help='role to use for a blade server')
p.add_argument('--device.chassis_role',
default=r'Server Chassis',
help='role to use for a chassis')
p.add_argument('--device.server_role',
default=r'Server',
help='role to use for a server')
p.add_argument('--tenant.driver', help='tenant driver, ie cmd, file')
p.add_argument('--tenant.driver_file',
help='tenant driver custom driver file path')
p.add_argument('--tenant.regex',
help='tenant regex to extract Netbox tenant slug')
p.add_argument('--datacenter_location.driver',
help='Datacenter location driver, ie: cmd, file')
p.add_argument('--datacenter_location.driver_file',
help='Datacenter location custom driver file path')
p.add_argument('--datacenter_location.regex',
help='Datacenter location regex to extract Netbox DC slug')
p.add_argument('--rack_location.driver',
help='Rack location driver, ie: cmd, file')
p.add_argument('--rack_location.driver_file',
help='Rack location custom driver file path')
p.add_argument('--rack_location.regex',
help='Rack location regex to extract Rack name')
p.add_argument('--slot_location.driver',
help='Slot location driver, ie: cmd, file')
p.add_argument('--slot_location.driver_file',
help='Slot location custom driver file path')
p.add_argument('--slot_location.regex',
help='Slot location regex to extract slot name')
p.add_argument('--network.ignore_interfaces',
default=r'(dummy.*|docker.*)',
help='Regex to ignore interfaces')
p.add_argument('--network.ignore_ips',
default=r'^(127\.0\.0\..*|fe80.*|::1.*)',
help='Regex to ignore IPs')
p.add_argument('--network.lldp',
help='Enable auto-cabling feature through LLDP infos')
p.add_argument(
'--inventory',
action='store_true',
help='Enable HW inventory (CPU, Memory, RAID Cards, Disks) feature')
options = p.parse_args()
return options
def main():
parser = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
"--data_dir",
default=None,
type=str,
required=True,
help=
"The input data dir. Should contain the .tsv files (or other data files) for the task.",
)
parser.add_argument(
"--model_type",
default=None,
type=str,
required=True,
help="Model type selected in the list: " +
", ".join(MODEL_CLASSES.keys()),
)
parser.add_argument(
"--model_name_or_path",
default=None,
type=str,
required=True,
help="Path to pre-trained model or shortcut name selected in the list: "
+ ", ".join(ALL_MODELS),
)
parser.add_argument(
"--task_name",
default=None,
type=str,
required=True,
help="The name of the task to train selected in the list: " +
", ".join(processors.keys()),
)
parser.add_argument(
"--output_dir",
default=None,
type=str,
required=True,
help=
"The output directory where the model predictions and checkpoints will be written.",
)
# Other parameters
parser.add_argument(
"--config_name",
default="",
type=str,
help="Pretrained config name or path if not the same as model_name")
parser.add_argument(
"--tokenizer_name",
default="",
type=str,
help="Pretrained tokenizer name or path if not the same as model_name",
)
parser.add_argument(
"--cache_dir",
default="",
type=str,
help=
"Where do you want to store the pre-trained models downloaded from s3",
)
parser.add_argument(
"--max_seq_length",
default=128,
type=int,
help=
"The maximum total input sequence length after tokenization. Sequences longer "
"than this will be truncated, sequences shorter will be padded.",
)
parser.add_argument("--do_train",
action="store_true",
help="Whether to run training.")
parser.add_argument("--do_eval",
action="store_true",
help="Whether to run eval on the dev set.")
parser.add_argument("--do_test",
action="store_true",
help="Whether to run test on the test set")
parser.add_argument(
"--evaluate_during_training",
action="store_true",
help="Run evaluation during training at each logging step.")
parser.add_argument(
"--do_lower_case",
action="store_true",
help="Set this flag if you are using an uncased model.")
parser.add_argument("--per_gpu_train_batch_size",
default=8,
type=int,
help="Batch size per GPU/CPU for training.")
parser.add_argument("--per_gpu_eval_batch_size",
default=8,
type=int,
help="Batch size per GPU/CPU for evaluation.")
parser.add_argument(
"--gradient_accumulation_steps",
type=int,
default=1,
help=
"Number of updates steps to accumulate before performing a backward/update pass.",
)
parser.add_argument("-opt",
"--optimizer",
default='adamw',
type=str,
help="Optimizers.")
parser.add_argument("--learning_rate",
default=5e-5,
type=float,
help="The initial learning rate for Adam.")
parser.add_argument("--weight_decay",
default=0.0,
type=float,
help="Weight deay if we apply some.")
parser.add_argument("--adam_epsilon",
default=1e-8,
type=float,
help="Epsilon for Adam optimizer.")
parser.add_argument("--max_grad_norm",
default=1.0,
type=float,
help="Max gradient norm.")
parser.add_argument("--num_train_epochs",
default=3.0,
type=float,
help="Total number of training epochs to perform.")
parser.add_argument(
"--max_steps",
default=-1,
type=int,
help=
"If > 0: set total number of training steps to perform. Override num_train_epochs.",
)
parser.add_argument("--warmup_steps",
default=0,
type=int,
help="Linear warmup over warmup_steps.")
parser.add_argument("--logging_steps",
type=int,
default=500,
help="Log every X updates steps.")
parser.add_argument("--save_steps",
type=int,
default=500,
help="Save checkpoint every X updates steps.")
parser.add_argument(
"--eval_all_checkpoints",
action="store_true",
help=
"Evaluate all checkpoints starting with the same prefix as model_name ending and ending with step number",
)
parser.add_argument("--no_cuda",
action="store_true",
help="Avoid using CUDA when available")
parser.add_argument("--overwrite_output_dir",
action="store_true",
help="Overwrite the content of the output directory")
parser.add_argument(
"--overwrite_cache",
action="store_true",
help="Overwrite the cached training and evaluation sets")
parser.add_argument("--seed",
type=int,
default=42,
help="random seed for initialization")
parser.add_argument(
"--fp16",
action="store_true",
help=
"Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit",
)
parser.add_argument(
"--fp16_opt_level",
type=str,
default="O1",
help=
"For fp16: Apex AMP optimization level selected in ['O0', 'O1', 'O2', and 'O3']."
"See details at https://nvidia.github.io/apex/amp.html",
)
parser.add_argument("--local_rank",
type=int,
default=-1,
help="For distributed training: local_rank")
# My exp argparse
parser.add_argument("--label_type", type=str)
parser.add_argument("--matching_method",
type=str,
default="fz",
choices=["fz", "sw"])
parser.add_argument("--threshold", type=float)
parser.add_argument("--max_n_candidates", type=int, default=4)
parser.add_argument("--loss_type", type=str)
parser.add_argument("--tau", type=float)
parser.add_argument("--writer", type=str, default="tensorboard")
parser.add_argument(
"--sync_tensorboard", type=bool,
default=False) # This is only availabel with jsonargparse.
parser.add_argument(
"--distance", type=bool,
default=False) # This is only availabel with jsonargparse.
# config file
parser.add_argument('--cfg', action=ActionConfigFile)
parser.add_argument('--data_cfg', action=ActionConfigFile)
parser.add_argument('--loss_cfg', action=ActionConfigFile)
args = parser.parse_args()
if args.loss_type == "hard-em":
dir_name = f"{args.task_name}_{args.loss_type}_{args.threshold}_{args.max_n_candidates}_{args.tau}"
else:
dir_name = f"{args.task_name}_{args.loss_type}_{args.threshold}_{args.max_n_candidates}"
args.output_dir = os.path.join(
args.output_dir,
dir_name,
)
if (os.path.exists(args.output_dir) and os.listdir(args.output_dir)
and args.do_train and not args.overwrite_output_dir):
raise ValueError(
f"Output directory ({args.output_dir}) already exists and is not empty. Use --overwrite_output_dir to overcome."
)
# Setup CUDA, GPU & distributed training
if args.local_rank == -1 or args.no_cuda:
device = torch.device("cuda" if torch.cuda.is_available()
and not args.no_cuda else "cpu")
args.n_gpu = 0 if args.no_cuda else torch.cuda.device_count()
else: # Initializes the distributed backend which will take care of sychronizing nodes/GPUs
torch.cuda.set_device(args.local_rank)
device = torch.device("cuda", args.local_rank)
torch.distributed.init_process_group(backend="nccl")
args.n_gpu = 1
args.device = device
# Setup logging
# logging.basicConfig(
# format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
# datefmt="%m/%d/%Y %H:%M:%S",
# level=logging.INFO if args.local_rank in [-1, 0] else logging.WARN,
# )
logger.warning(
"Process rank: {}, device: {}, n_gpu: {}, distributed training: {}, 16-bits training: {}"
.format(
args.local_rank,
device,
args.n_gpu,
bool(args.local_rank != -1),
args.fp16,
))
# Set seed
set_seed(args)
# Prepare GLUE task
args.task_name = args.task_name.lower()
if args.task_name not in processors:
raise ValueError("Task not found: %s" % (args.task_name))
processor = processors[args.task_name]()
label_list = processor.get_labels()
num_labels = len(label_list)
# Load pretrained model and tokenizer
if args.local_rank not in [-1, 0]:
torch.distributed.barrier(
) # Make sure only the first process in distributed training will download model & vocab
args.model_type = args.model_type.lower()
config_class, model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
config = config_class.from_pretrained(
args.config_name if args.config_name else args.model_name_or_path,
num_labels=num_labels,
finetuning_task=args.task_name,
cache_dir=args.cache_dir if args.cache_dir else None,
)
config.update({"loss_type": args.loss_type, "tau": args.tau})
tokenizer = tokenizer_class.from_pretrained(
args.tokenizer_name
if args.tokenizer_name else args.model_name_or_path,
do_lower_case=args.do_lower_case,
cache_dir=args.cache_dir if args.cache_dir else None,
)
model = model_class.from_pretrained(
args.model_name_or_path,
from_tf=bool(".ckpt" in args.model_name_or_path),
config=config,
cache_dir=args.cache_dir if args.cache_dir else None,
)
if args.local_rank == 0:
torch.distributed.barrier(
) # Make sure only the first process in distributed training will download model & vocab
model.to(args.device)
logger.info(f"Training/evaluation parameters")
for key, value in vars(args).items():
logger.seclog([key, 'light_blue'], value)
if args.local_rank in [-1, 0]:
if args.writer == "tensorboard":
tb_writer = SummaryWriter(
f"./runs/{args.loss_type}_{args.threshold}_{time.strftime('%Y%m%d%H%M%S')}"
)
elif args.writer == "comet":
tb_writer = CometWriter(
project_name="unsupervised-mrqa",
workspace="liangtaiwan",
exp_name=f"{args.loss_type}_{args.threshold}",
auto_param_logging=False,
auto_metric_logging=False,
auto_output_logging=False,
sync_tensorboard=args.sync_tensorboard,
)
tb_writer.log_parameters(vars(args))
else:
raise NotImplementedError()
best_steps = 0
# Training
if args.do_train:
train_dataset, _ = load_and_cache_examples(args,
args.task_name,
tokenizer,
evaluate=False)
global_step, tr_loss, best_steps, best_dev_acc = train(
args, train_dataset, model, tokenizer, tb_writer)
logger.info(f" global_step = {global_step}, average loss = {tr_loss}")
# Saving last-practices: if you use defaults names for the model, you can reload it using from_pretrained()
if args.do_train and (args.local_rank == -1
or torch.distributed.get_rank() == 0):
# Create output directory if needed
if not os.path.exists(args.output_dir) and args.local_rank in [-1, 0]:
os.makedirs(args.output_dir)
logger.info(f"Saving model checkpoint to {args.output_dir}")
# Save a trained model, configuration and tokenizer using `save_pretrained()`.
# They can then be reloaded using `from_pretrained()`
model_to_save = (model.module if hasattr(model, "module") else model
) # Take care of distributed/parallel training
model_to_save.save_pretrained(args.output_dir)
tokenizer.save_pretrained(args.output_dir)
# Good practice: save your training arguments together with the trained model
torch.save(args, os.path.join(args.output_dir, "training_args.bin"))
# Load a trained model and vocabulary that you have fine-tuned
model = model_class.from_pretrained(args.output_dir)
tokenizer = tokenizer_class.from_pretrained(args.output_dir)
model.to(args.device)
# Evaluation
results = {}
if args.do_eval and args.local_rank in [-1, 0]:
if not args.do_train:
args.output_dir = args.model_name_or_path
checkpoints = [args.output_dir]
if args.eval_all_checkpoints:
checkpoints = list(
os.path.dirname(c) for c in sorted(
glob.glob(args.output_dir + "/**/" + WEIGHTS_NAME,
recursive=True)))
logger.info("Evaluate the following checkpoints:", checkpoints)
for checkpoint in checkpoints:
global_step = checkpoint.split(
"-")[-1] if len(checkpoints) > 1 else ""
prefix = checkpoint.split(
"/")[-1] if checkpoint.find("checkpoint") != -1 else ""
model = model_class.from_pretrained(checkpoint)
model.to(args.device)
result = evaluate(args, model, tokenizer, prefix=prefix)
result = dict(
(k + "_{}".format(global_step), v) for k, v in result.items())
results.update(result)
for key, value in result.items():
tb_writer.add_scalar("eval_{}".format(key), value)
if args.do_test and args.local_rank in [-1, 0]:
if not args.do_train:
args.output_dir = args.model_name_or_path
checkpoints = [args.output_dir]
# if args.eval_all_checkpoints: # can not use this to do test!!
# checkpoints = list(os.path.dirname(c) for c in sorted(glob.glob(args.output_dir + '/**/' + WEIGHTS_NAME, recursive=True)))
# logging.getLogger("transformers.modeling_utils").setLevel(logging.WARN) # Reduce logging
logger.info(f"Evaluate the following checkpoints: {checkpoints}")
for checkpoint in checkpoints:
global_step = checkpoint.split(
"-")[-1] if len(checkpoints) > 1 else ""
prefix = checkpoint.split(
"/")[-1] if checkpoint.find("checkpoint") != -1 else ""
model = model_class.from_pretrained(checkpoint)
model.to(args.device)
result = evaluate(args, model, tokenizer, prefix=prefix, test=True)
result = dict(
(k + "_{}".format(global_step), v) for k, v in result.items())
results.update(result)
for key, value in result.items():
tb_writer.add_scalar("test_{}".format(key), value)
tb_writer.flush()
if best_steps:
logger.info(
f"best steps of eval acc is the following checkpoints: {best_steps}"
)
logger.info(f"best eval acc: {best_dev_acc}")
return results
# for i in range(len(labels)):
# CS2.collections[i].set_label(labels[i])
# plt.legend(loc='upper right')
# Display samples
for iter_num, (samples, labels) in enumerate(dataloader):
x = samples.numpy()
x_0 = x[labels == 0, :]
x_1 = x[labels == 1, :]
plt.scatter(x_0[:, 0], x_0[:, 1], c='r')
plt.scatter(x_1[:, 0], x_1[:, 1], c='b')
plt.show()
if __name__ == "__main__":
parser = jsonargparse.ArgumentParser(description='General arguments',
default_meta=False)
parser.add_argument('-t',
'--general.experiment_type',
default='synthetic',
help='Type of experiment to execute',
type=str)
parser.add_argument(
'-p',
'--general.param_file_path',
default=os.path.join('./src/parameters',
'train_synthetic_params.json'),
help=
'param file path used to load the parameters file containing default values to all '
'parameters',
type=str)
# parser.add_argument('-p', '--general.param_file_path', default='src/tests/test_mnist_pgd_with_pnml_expected_result/params.json',
def _main():
mp.set_start_method('spawn')
parser = jsonargparse.ArgumentParser(description='General arguments',
default_meta=False)
parser.add_argument('-t',
'--general.experiment_type',
default='imagenet_adversarial',
help='Type of experiment to execute',
type=str)
parser.add_argument(
'-p',
'--general.param_file_path',
default=os.path.join('./src/parameters', 'eval_imagenet_param.json'),
help=
'param file path used to load the parameters file containing default values to all '
'parameters',
type=str)
# parser.add_argument('-p', '--general.param_file_path', default='src/tests/test_mnist_pgd_with_pnml_expected_result/params.json',
# help='param file path used to load the parameters file containing default values to all '
# 'parameters', type=str)
parser.add_argument(
'-o',
'--general.output_root',
default='output',
help='the output directory where results will be saved',
type=str)
parser.add_argument('--adv_attack_test.attack_type',
help='attack type',
type=str,
default="natural")
parser.add_argument('-f',
'--adv_attack_test.test_start_idx',
help='first test idx',
type=int)
parser.add_argument('-l',
'--adv_attack_test.test_end_idx',
help='last test idx',
type=int)
parser.add_argument('-e',
'--adv_attack_test.epsilon',
help='the epsilon strength of the attack',
type=float)
parser.add_argument('-ts',
'--adv_attack_test.pgd_step',
help='the step size of the attack',
type=float)
parser.add_argument('-ti',
'--adv_attack_test.pgd_iter',
help='the number of test pgd iterations',
type=int)
parser.add_argument(
'-b',
'--adv_attack_test.beta',
help='the beta value for regret reduction regularization ',
type=float)
parser.add_argument('-r',
'--fit_to_sample.epsilon',
help='the epsilon strength of the refinement (lambda)',
type=float)
parser.add_argument('-i',
'--fit_to_sample.pgd_iter',
help='the number of PGD iterations of the refinement',
type=int)
parser.add_argument('-s',
'--fit_to_sample.pgd_step',
help='the step size of the refinement',
type=float)
parser.add_argument(
'-n',
'--fit_to_sample.pgd_test_restart_num',
help='the number of PGD restarts where 0 means no random start',
type=int)
args = jsonargparse.namespace_to_dict(parser.parse_args())
general_args = args.pop('general')
experiment_h = Experiment(general_args, args)
dataloaders = experiment_h.get_adv_dataloaders()
################
# Create logger and save params to output folder
logger_utilities.init_logger(logger_name=experiment_h.get_exp_name(),
output_root=experiment_h.output_dir)
logger = logger_utilities.get_logger()
# logger = Logger(experiment_type='TMP', output_root='output')
logger.info('OutputDirectory: %s' % logger.output_folder)
logger.info('Device: %s' % TorchUtils.get_device())
logger.info(experiment_h.get_params())
eval_dataset(dataloaders['test'], 29, logger, experiment_h)
logger.info("Done")
