= version.parse('0.4.0'):\n interp = nn.Upsample(size=(1080, 1920), mode='bilinear', align_corners=True)\n else:\n interp = nn.Upsample(size=(1080, 1920), mode='bilinear')\n\n sm = torch.nn.Softmax(dim = 1)\n log_sm = torch.nn.LogSoftmax(dim = 1)\n kl_distance = nn.KLDivLoss( reduction = 'none')\n prior = np.load('./utils/prior_all.npy').transpose((2,0,1))[np.newaxis, :, :, :]\n prior = torch.from_numpy(prior)\n for index, img_data in enumerate(zip(testloader, testloader2) ):\n batch, batch2 = img_data\n image, _, name = batch\n image2, _, name2 = batch2\n\n inputs = image.cuda()\n inputs2 = image2.cuda()\n print('\\r>>>>Extracting feature...%04d/%04d'%(index*batchsize, args.batchsize*len(testloader)), end='')\n if args.model == 'DeepLab':\n with torch.no_grad():\n output1, output2 = model(inputs)\n output_batch = interp(sm(0.5* output1 + output2))\n\n heatmap_batch = torch.sum(kl_distance(log_sm(output1), sm(output2)), dim=1)\n\n output1, output2 = model(fliplr(inputs))\n output1, output2 = fliplr(output1), fliplr(output2)\n output_batch += interp(sm(0.5 * output1 + output2))\n del output1, output2, inputs\n\n output1, output2 = model(inputs2)\n output_batch += interp(sm(0.5* output1 + output2))\n output1, output2 = model(fliplr(inputs2))\n output1, output2 = fliplr(output1), fliplr(output2)\n output_batch += interp(sm(0.5 * output1 + output2))\n del output1, output2, inputs2\n ratio = 0.95\n output_batch = output_batch.cpu() / 4\n # output_batch = output_batch *(ratio + (1 - ratio) * prior)\n output_batch = output_batch.data.numpy()\n heatmap_batch = heatmap_batch.cpu().data.numpy()\n elif args.model == 'DeeplabVGG' or args.model == 'Oracle':\n output_batch = model(Variable(image).cuda())\n output_batch = interp(output_batch).cpu().data.numpy()\n\n output_batch = output_batch.transpose(0,2,3,1)\n score_batch = np.max(output_batch, axis=3)\n output_batch = np.asarray(np.argmax(output_batch, axis=3), dtype=np.uint8)\n\n threshold = 0.3274\n for i in range(output_batch.shape[0]):\n output_single = output_batch[i,:,:]\n output_col = colorize_mask(output_single)\n output = Image.fromarray(output_single)\n\n name_tmp = name[i].split('/')[-1]\n dir_name = name[i].split('/')[-2]\n save_path = args.save + '/' + dir_name\n if not os.path.isdir(save_path):\n os.mkdir(save_path)\n output.save('%s/%s' % (save_path, name_tmp))\n print('%s/%s' % (save_path, name_tmp))\n output_col.save('%s/%s_color.png' % (save_path, name_tmp.split('.')[0]))\n\n # heatmap_tmp = heatmap_batch[i,:,:]/np.max(heatmap_batch[i,:,:])\n # fig = plt.figure()\n # plt.axis('off')\n # heatmap = plt.imshow(heatmap_tmp, cmap='viridis')\n # fig.colorbar(heatmap)\n # fig.savefig('%s/%s_heatmap.png' % (save_path, name_tmp.split('.')[0]))\n\n if args.set == 'test' or args.set == 'val':\n # label\n output.save('%s/%s' % (label_path, name_tmp))\n # label invalid\n output_single[score_batch[i, :, :] < threshold] = 255\n output = Image.fromarray(output_single)\n output.save('%s/%s' % (label_invalid_path, name_tmp))\n # conficence\n\n confidence = score_batch[i, :, :] * 65535\n confidence = np.asarray(confidence, dtype=np.uint16)\n print(confidence.min(), confidence.max())\n iio.imwrite('%s/%s' % (confidence_path, name_tmp), confidence)\n\n return args.save","def get_config():\n\n parser = argparse.ArgumentParser(\n description='ZoomingSloMo or only Slo-Mo training argument parser')\n parser.add_argument('--cfg', default=\"./config.yaml\")\n args, _ = parser.parse_known_args()\n conf = read_yaml(args.cfg)\n\n parser.add_argument('--lmdb-data-gt', type=str, default=\"datasets/\",\n help='Path to HR frames lmdb for training')\n\n parser.add_argument('--lmdb-data-lq', type=str, default=\"datasets/\",\n help='Path to LR frames lmdb for training')\n\n parser.add_argument('--output-dir', type=str, default=\"models/\",\n help='Path to store trained models')\n\n parser.add_argument('--batch-size', type=int, default=\"12\",\n help='Maximum number of iterations for training')\n\n parser.add_argument('--gt-size', type=int, default=128,\n help='Ground truth frame size')\n\n parser.add_argument('--only-slomo', action='store_true', default=False,\n help='If True, network will train for Slo-Mo only (No Zooming)')\n\n args = parser.parse_args()\n\n # Refine config file variables\n conf.data.lmdb_data_gt = args.lmdb_data_gt\n conf.data.lmdb_data_lq = args.lmdb_data_lq\n conf.data.output_dir = args.output_dir\n conf.train.batch_size = args.batch_size\n conf.train.only_slomo = args.only_slomo\n conf.data.gt_size = args.gt_size if not args.only_slomo else args.gt_size // 4\n conf.data.lr_size = args.gt_size // 4\n\n return conf","def load_config(args):\n # Setup cfg.\n cfg = get_cfg()\n # Load config from cfg.\n if args.cfg_file is not None:\n cfg.merge_from_file(args.cfg_file)\n # Load config from command line, overwrite config from opts.\n if args.opts is not None:\n cfg.merge_from_list(args.opts)\n\n # Inherit parameters from args.\n if hasattr(args, \"num_shards\") and hasattr(args, \"shard_id\"):\n cfg.NUM_SHARDS = args.num_shards\n cfg.SHARD_ID = args.shard_id\n if hasattr(args, \"rng_seed\"):\n cfg.RNG_SEED = args.rng_seed\n if hasattr(args, \"output_dir\"):\n cfg.OUTPUT_DIR = args.output_dir\n\n # Create the checkpoint dir.\n # cu.make_checkpoint_dir(cfg.OUTPUT_DIR)\n\n return cfg","def predict_input_args():\n # Create Parse using ArgumentParser\n parser = argparse.ArgumentParser()\n parser.add_argument('image', type = str, help = 'Path to the folder and file name of image to be checked') \n parser.add_argument('checkpoint', type = str, help = 'Checkpoint folder name') \n parser.add_argument('--gpu', type = bool, default = False, help = 'True = GPU enabled, False = GPU disabled') \n parser.add_argument('--topk', type = int, default = 5, help = 'Top number of class predicitions') \n parser.add_argument('--json', type = str, default = 'cat_to_name.json', help = 'Path to the folder and file name of JSON map used') \n return parser.parse_args()","def _parse_args():\n\n \"\"\"\n Add arguments below. Example format:\n parser.add_argument('-cp', '--continue_training_policy',\n action='store_true', help='A help message'\n )\n\n parser.add_argument('--q1_checkpoint_filename', type=str,\n default='./q1_checkpoint.pth', help=\"Name of file to save and load\"\n )\n \"\"\"\n parser = argparse.ArgumentParser(\n description=\"Arguments for Experience Replay project\"\n )\n # Model related arguments here\n parser.add_argument(\"--env_name\", type=str, default=\"CartPole-v1\")\n parser.add_argument(\n \"--no_alpha_tune\", dest=\"alph_tune\", default=True, action=\"store_false\"\n )\n parser.add_argument(\"--eval_freq\", type=int, default=10000)\n # Training related arguments here\n parser.add_argument(\"--rand_seed\", type=int, default=1)\n parser.add_argument(\"--log_dir\", type=str, default=None)\n parser.add_argument(\"-t\", \"--time_limit\", type=int, default=10_000)\n parser.add_argument(\"-s\", \"--steps\", type=int, default=1_000_000)\n parser.add_argument(\"-n\", \"--num_episodes\", type=int, default=1000)\n parser.add_argument(\"-lr\", \"--learning_rate\", type=float, default=1e-3)\n parser.add_argument(\"-c\", \"--continue_training\", action=\"store_true\")\n parser.add_argument(\"--batch_size\", type=int, default=256)\n parser.add_argument(\"--buff_size\", type=int, default=100000)\n\n args = parser.parse_args()\n return args","def setup_args():\n parser = ParlaiParser()\n parser.add_argument(\n '-n',\n '--num-episodes',\n default=-1,\n type=int,\n help='Total number of episodes to convert, -1 to convert all examples',\n )\n parser.add_argument(\n '-of',\n '--outfile',\n default=None,\n type=str,\n help='Output file where to save, by default will be created in /tmp',\n )\n parser.add_argument(\n '-s1id', '--speaker-0-id', type=str, help='Speaker id of agent who speaks first'\n )\n parser.add_argument(\n '-s1id',\n '--speaker-1-id',\n type=str,\n help='Speaker id of agent who speaks second',\n )\n parser.add_argument(\n '--prepended-context',\n type='bool',\n default=False,\n help='specify if the context is prepended to the first act',\n )\n parser.add_argument('-ltim', '--log-every-n-secs', type=float, default=10)\n parser.set_defaults(datatype='train:ordered')\n\n return parser","def parse_args():\n parser = argparse.ArgumentParser('Reading Comprehension on BaiduRC dataset')\n parser.add_argument('--prepare', action='store_true',\n help='create the directories, prepare the vocabulary and embeddings')\n parser.add_argument('--train', action='store_true',\n help='train the model')\n parser.add_argument('--generate', action='store_true',\n help='predict the answers for test set with trained model')\n parser.add_argument('--gentest', action='store_true',\n help='predict the answers for test set with trained model')\n parser.add_argument('--gpu', type=str, default='0',\n help='specify gpu device')\n\n train_settings = parser.add_argument_group('train settings')\n train_settings.add_argument('--optim', default='Adam',\n help='optimizer type')\n train_settings.add_argument('--learning_rate', type=float, default=0.001,\n help='learning rate')\n train_settings.add_argument('--weight_decay', type=float, default=0,\n help='weight decay')\n train_settings.add_argument('--dropout', type=float, default=0,\n help='dropout keep rate')\n train_settings.add_argument('--batch_size', type=int, default=128,\n help='train batch size')\n train_settings.add_argument('--epochs', type=int, default=10,\n help='train epochs')\n\n model_settings = parser.add_argument_group('model settings')\n model_settings.add_argument('--embed_size', type=int, default=128,\n help='size of the embeddings')\n model_settings.add_argument('--hidden_size', type=int, default=256,\n help='size of LSTM hidden units')\n model_settings.add_argument('--max_seq_len', type=int, default=50,\n help='max passage num in one sample')\n model_settings.add_argument('--max_gen_len', type=int, default=50,\n help='max length of passage')\n\n path_settings = parser.add_argument_group('path settings')\n path_settings.add_argument('--vocab_dir', default='../data/vocab/',\n help='the dir to save vocabulary')\n path_settings.add_argument('--model_dir', default='../data/models/',\n help='the dir to store models')\n path_settings.add_argument('--result_dir', default='../data/results/',\n help='the dir to output the results')\n path_settings.add_argument('--summary_dir', default='../data/summary/',\n help='the dir to write tensorboard summary')\n path_settings.add_argument('--log_path',\n help='path of the log file. If not set, logs are printed to console')\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Train a model for image classification (Keras)\",\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n parser.add_argument(\n \"--rec-train\",\n type=str,\n default=\"../imgclsmob_data/imagenet_rec/train.rec\",\n help=\"the training data\")\n parser.add_argument(\n \"--rec-train-idx\",\n type=str,\n default=\"../imgclsmob_data/imagenet_rec/train.idx\",\n help='the index of training data')\n parser.add_argument(\n \"--rec-val\",\n type=str,\n default=\"../imgclsmob_data/imagenet_rec/val.rec\",\n help=\"the validation data\")\n parser.add_argument(\n \"--rec-val-idx\",\n type=str,\n default=\"../imgclsmob_data/imagenet_rec/val.idx\",\n help=\"the index of validation data\")\n\n parser.add_argument(\n \"--model\",\n type=str,\n required=True,\n help=\"type of model to use. see model_provider for options\")\n parser.add_argument(\n \"--use-pretrained\",\n action=\"store_true\",\n help=\"enable using pretrained model from github repo\")\n parser.add_argument(\n \"--dtype\",\n type=str,\n default=\"float32\",\n help=\"data type for training\")\n parser.add_argument(\n \"--resume\",\n type=str,\n default=\"\",\n help=\"resume from previously saved parameters if not None\")\n parser.add_argument(\n \"--resume-state\",\n type=str,\n default=\"\",\n help=\"resume from previously saved optimizer state if not None\")\n\n parser.add_argument(\n \"--input-size\",\n type=int,\n default=224,\n help=\"size of the input for model\")\n parser.add_argument(\n \"--resize-inv-factor\",\n type=float,\n default=0.875,\n help=\"inverted ratio for input image crop\")\n\n parser.add_argument(\n \"--num-gpus\",\n type=int,\n default=0,\n help=\"number of gpus to use\")\n parser.add_argument(\n \"-j\",\n \"--num-data-workers\",\n dest=\"num_workers\",\n default=4,\n type=int,\n help=\"number of preprocessing workers\")\n\n parser.add_argument(\n \"--batch-size\",\n type=int,\n default=512,\n help=\"training batch size per device (CPU/GPU)\")\n parser.add_argument(\n \"--num-epochs\",\n type=int,\n default=120,\n help=\"number of training epochs\")\n parser.add_argument(\n \"--start-epoch\",\n type=int,\n default=1,\n help=\"starting epoch for resuming, default is 1 for new training\")\n parser.add_argument(\n \"--attempt\",\n type=int,\n default=1,\n help=\"current number of training\")\n\n parser.add_argument(\n \"--optimizer-name\",\n type=str,\n default=\"nag\",\n help=\"optimizer name\")\n parser.add_argument(\n \"--lr\",\n type=float,\n default=0.1,\n help=\"learning rate\")\n parser.add_argument(\n \"--momentum\",\n type=float,\n default=0.9,\n help=\"momentum value for optimizer\")\n parser.add_argument(\n \"--wd\",\n type=float,\n default=0.0001,\n help=\"weight decay rate\")\n\n parser.add_argument(\n \"--log-interval\",\n type=int,\n default=50,\n help=\"number of batches to wait before logging\")\n parser.add_argument(\n \"--save-interval\",\n type=int,\n default=4,\n help=\"saving parameters epoch interval, best model will always be saved\")\n parser.add_argument(\n \"--save-dir\",\n type=str,\n default=\"\",\n help=\"directory of saved models and log-files\")\n parser.add_argument(\n \"--logging-file-name\",\n type=str,\n default=\"train.log\",\n help=\"filename of training log\")\n\n parser.add_argument(\n \"--seed\",\n type=int,\n default=-1,\n help=\"Random seed to be fixed\")\n parser.add_argument(\n \"--log-packages\",\n type=str,\n default=\"keras\",\n help=\"list of python packages for logging\")\n parser.add_argument(\n \"--log-pip-packages\",\n type=str,\n default=\"keras, keras-mxnet, keras-applications, keras-preprocessing\",\n help=\"list of pip packages for logging\")\n args = parser.parse_args()\n return args","def setup(args):\n cfg = get_cfg()\n add_imaterialist_config(cfg)\n cfg.merge_from_file(model_zoo.get_config_file(\"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml\"))\n cfg.merge_from_file(args.config_file)\n \n cfg.merge_from_list(args.opts)\n cfg.freeze()\n default_setup(cfg, args)\n # Setup logger for \"imaterialist\" module\n setup_logger(output=cfg.OUTPUT_DIR, distributed_rank=comm.get_rank(), name=\"imaterialist\")\n return cfg","def parse_args(args):\n parser = argparse.ArgumentParser(\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\n description='Train a detection model from an already prepared dataset')\n\n # Mandatory arguments\n parser.add_argument(\n 'base_dataset_dir', help='directory containing the prepared dataset')\n\n parser.add_argument('dataset_dir', help='path to temporary directory')\n\n # Options\n parser.add_argument(\n '-o',\n '--output-model',\n default='model.h5',\n help='filename for output model')\n\n parser.add_argument(\n '--seed', type=int, help='seed number for the random number generator')\n parser.add_argument(\n \"--test-size\",\n type=float,\n default=0.25,\n help=(\"The proportion of the dataset to include in the test split. \"\n \"Float number between 0.0 and 1.0\"))\n parser.add_argument(\n \"--validation-size\",\n type=float,\n default=0.25,\n help=(\n \"The proportion of the dataset to include in the validation split. \"\n \"Float number between 0.0 and 1.0\"))\n parser.add_argument(\n \"--balancing-multiplier\",\n type=float,\n default=1.0,\n help=\n \"proportion of false samples w.r.t true samples (e.g. 1.0 = 50%% true, 50%% false)\"\n )\n parser.add_argument(\n \"--trainable-layers\",\n type=int,\n default=5,\n help=\"number of upper layers of ResNet-50 to retrain\")\n parser.add_argument(\"--batch-size\", type=int, default=5, help=\"Batch size\")\n parser.add_argument(\n \"--epochs\", type=int, default=20, help=\"number of epochs to run\")\n\n parser.add_argument(\n '--version',\n action='version',\n version='aplatam {ver}'.format(ver=__version__))\n parser.add_argument(\n '-v',\n '--verbose',\n dest=\"loglevel\",\n help=\"set loglevel to INFO\",\n action='store_const',\n const=logging.INFO)\n parser.add_argument(\n '-vv',\n '--very-verbose',\n dest=\"loglevel\",\n help=\"set loglevel to DEBUG\",\n action='store_const',\n const=logging.DEBUG)\n\n return parser.parse_args(args)","def parse_args():\n parser = argparse.ArgumentParser(description='Eval')\n parser.add_argument(\n '--cfg', help='experiment configure file path', type=str, \\\n default=\"validation.config.Config\")\n return parser.parse_args()","def main() -> None:\n parser = ArgumentParser(description=\"SoccerPredictor:\", formatter_class=ArgumentDefaultsHelpFormatter)\n subparsers = parser.add_subparsers(title=\"Modes to run\", dest=\"command\")\n\n # Trainer args\n trainer_parser = subparsers.add_parser(RunMode.Train.value, help=\"Trains model and makes predictions.\",\n formatter_class=ArgumentDefaultsHelpFormatter)\n trainer_parser.add_argument(\"--resume\", action=\"store_true\", default=False,\n help=\"Resumes training of previously saved model. \"\n \"Tries to load the latest model saved if no name or prefix specified via --name.\")\n trainer_parser.add_argument(\"--epochs\", type=int, action=\"store\", default=1,\n help=\"Number of epochs to train model for.\")\n trainer_parser.add_argument(\"--ntest\", type=int, action=\"store\", default=10,\n help=\"Number of last samples used for testing for each team.\")\n trainer_parser.add_argument(\"--ndiscard\", type=int, action=\"store\", default=0,\n help=\"Number of last samples to discard for each team.\")\n trainer_parser.add_argument(\"--timesteps\", type=int, action=\"store\", default=40,\n help=\"Number of timesteps to use as data window size for input to network.\")\n trainer_parser.add_argument(\"--predict\", action=\"store_true\", default=False,\n help=\"Whether to rerun predictions without any training.\")\n trainer_parser.add_argument(\"--lrpatience\", type=int, action=\"store\", default=20,\n help=\"How many epochs to tolerate before decaying learning rate if no improvement. \"\n \"Turned off if 0.\")\n trainer_parser.add_argument(\"--lrdecay\", type=float, action=\"store\", default=0.95,\n help=\"How much to decay learning rate after patience exceeded.\")\n trainer_parser.add_argument(\"--seed\", type=int, action=\"store\",\n help=\"Specifies seed for rng.\")\n trainer_parser.add_argument(\"--savefreq\", type=int, action=\"store\", default=50,\n help=\"How often (number of epochs) to save models. No intermediate saving if 0.\")\n trainer_parser.add_argument(\"--printfreq\", type=int, action=\"store\", default=10,\n help=\"How often (number of epochs) to print current summaries. \"\n \"No intermediate printing if 0.\")\n trainer_parser.add_argument(\"--verbose\", type=int, action=\"store\", choices=VERBOSITY_LEVELS, default=1,\n help=\"Level of verbosity.\")\n\n # Visualizer args\n visualizer_parser = subparsers.add_parser(RunMode.Vis.value, help=\"Runs visualization of predictions.\",\n formatter_class=ArgumentDefaultsHelpFormatter)\n visualizer_parser.add_argument(\"--port\", type=int, action=\"store\", default=8050,\n help=\"Custom port for Dash visualization.\")\n visualizer_parser.add_argument(\"--host\", type=str, action=\"store\", default=\"127.0.0.1\",\n help=\"Custom host for Dash visualization. Can use 0 for 0.0.0.0 shortcut.\")\n\n # Backtester args\n backtester_parser = subparsers.add_parser(RunMode.Backtest.value, help=\"Runs backtesting on trained models.\",\n formatter_class=ArgumentDefaultsHelpFormatter)\n backtester_parser.add_argument(\"--path\", type=str, action=\"store\", default=f\"{DATA_DIR}{MODEL_DIR}\",\n help=\"Path to folder where the trained models are saved.\")\n\n # common args for trainer and visualizer\n for p in [trainer_parser, visualizer_parser]:\n p.add_argument(\"--name\", type=str, action=\"store\",\n help=\"Tries to load the latest saved model with given name prefix. \"\n \"Loads exact model if exact dir name specified.\")\n\n # Common args for visualizer and backtester\n for p in [visualizer_parser, backtester_parser]:\n p.add_argument(\"--ignoreodds\", type=float, action=\"store\", default=1.10,\n help=\"Ignores odds less than given amount when predicting which team to bet on.\")\n\n args = parser.parse_args()\n\n if args.command is None:\n parser.print_help()\n return\n elif args.command == RunMode.Vis.value:\n print(\"Visualizing...\")\n vis_args, _ = visualizer_parser.parse_known_args()\n check_visualizer_args(visualizer_parser, vis_args)\n print(vis_args)\n\n from soccerpredictor.visualizer import visualizer\n try:\n visualizer.run(vis_args.name, vis_args.host, vis_args.port, vis_args.ignoreodds)\n except KeyboardInterrupt:\n print(\"> Received CTRL+C command. Exiting.\")\n elif args.command == RunMode.Backtest.value:\n print(\"Backtesting...\")\n backtest_args, _ = backtester_parser.parse_known_args()\n check_backtester_args(backtester_parser, backtest_args)\n print(backtest_args)\n\n from soccerpredictor.backtester import backtester\n try:\n backtester.run(backtest_args.path, backtest_args.ignoreodds)\n except KeyboardInterrupt:\n print(\"> Received CTRL+C command. Exiting.\")\n elif args.command == RunMode.Train.value:\n print(\"Running model...\")\n train_args, _ = trainer_parser.parse_known_args()\n config = SPConfig()\n\n # Implicitly set resume to true if we are predicting only\n if train_args.predict and not train_args.resume:\n train_args.resume = True\n\n check_trainer_args(trainer_parser, train_args)\n config.set_args(train_args)\n print(train_args)\n\n dbmanager = SPDBManager()\n try:\n dbmanager.connect()\n\n # Load previous settings if we resume training\n if train_args.resume:\n print(\"Resuming training, loading previous settings... \"\n \"Any conflicting parameters will be ignored.\")\n\n # Load previous settings\n folder = get_latest_models_dir(train_args.name)\n model_settings = get_model_settings_file(folder)\n # Restore original config\n config.restore_args(model_settings)\n set_rng_seed(config.seed)\n\n from soccerpredictor.trainer.trainer import SPTrainer\n trainer = SPTrainer(dbmanager, model_settings=model_settings, folder=folder)\n else:\n # Need to generate folder prefix before seeding random number generators\n import random\n generated_folder_prefix = \"\".join(random.choices(ascii_uppercase, k=FOLDER_PREFIX_LEN))\n print(f\"New generated folder prefix: '{generated_folder_prefix}'\")\n set_rng_seed(train_args.seed)\n\n from soccerpredictor.trainer.trainer import SPTrainer\n trainer = SPTrainer(dbmanager, generated_folder_prefix=generated_folder_prefix)\n\n try:\n trainer.run()\n finally:\n trainer.cleanup()\n\n except KeyboardInterrupt:\n print(\"> Received CTRL+C command. Exiting.\")\n except (FileNotFoundError, ValueError, OperationalError) as e:\n print(e)\n sys.exit(1)\n finally:\n dbmanager.disconnect()","def main():\n if len(sys.argv) == 3:\n database_filepath, model_filepath = sys.argv[1:]\n nltk.download(['punkt', 'wordnet'])\n print('Loading data...\\n DATABASE: {}'.format(database_filepath))\n X, Y, category_names = load_data(database_filepath)\n X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)\n\n print('Building model...')\n model = build_model()\n\n print('Training model...')\n model.fit(X_train, Y_train)\n\n print('Evaluating model...')\n evaluate_model(model, X_test, Y_test, category_names)\n\n print('Saving model...\\n MODEL: {}'.format(model_filepath))\n save_model(model, model_filepath)\n\n print('Trained model saved!')\n\n else:\n print('Please provide the filepath of the disaster messages database '\\\n 'as the first argument and the filepath of the pickle file to '\\\n 'save the model to as the second argument. \\n\\nExample: python '\\\n 'train_classifier.py ../data/DisasterResponse.db classifier.pkl')","def get_args(args_list=None):\n\n parser = argparse.ArgumentParser(description='SwissArmyTransformer')\n parser = add_model_config_args(parser)\n parser = add_training_args(parser)\n parser = add_evaluation_args(parser)\n parser = add_data_args(parser)\n parser = add_tokenization_args(parser)\n parser = add_text_generate_args(parser)\n\n # Include DeepSpeed configuration arguments\n parser = deepspeed.add_config_arguments(parser)\n\n args = parser.parse_args(args_list)\n\n if not args.train_data:\n print('WARNING: No training data specified')\n\n assert (args.train_iters is None)^(args.epochs is None)\n\n args.cuda = torch.cuda.is_available()\n\n args.rank = int(os.getenv('RANK', '0'))\n args.world_size = int(os.getenv(\"WORLD_SIZE\", '1'))\n if args.local_rank is None:\n args.local_rank = int(os.getenv(\"LOCAL_RANK\", '0')) # torchrun\n \n if args.device == -1: # not set manually\n args.device = args.rank % torch.cuda.device_count()\n if args.local_rank is not None:\n args.device = args.local_rank\n\n # local rank should be consistent with device in DeepSpeed\n if args.local_rank != args.device and args.mode != 'inference':\n raise ValueError(\n 'LOCAL_RANK (default 0) and args.device inconsistent. '\n 'This can only happens in inference mode. '\n 'Please use CUDA_VISIBLE_DEVICES=x for single-GPU training. '\n )\n\n # args.model_parallel_size = min(args.model_parallel_size, args.world_size)\n if args.rank == 0:\n print('using world size: {} and model-parallel size: {} '.format(\n args.world_size, args.model_parallel_size))\n if args.vocab_size > 0:\n _adjust_vocab_size(args)\n \n if args.train_data_weights is not None:\n assert len(args.train_data_weights) == len(args.train_data)\n \n if args.mode != 'inference': # training with deepspeed\n args.deepspeed = True\n if args.deepspeed_config is None: # not specified\n args.deepspeed_config = os.path.join(os.path.dirname(__file__), 'training', f'deepspeed_zero{args.zero_stage}.json')\n override_deepspeed_config = True\n else:\n override_deepspeed_config = False\n if args.zero_stage > 0:\n if args.rank == 0 and not args.fp16:\n print('Automatically set fp16=True to use ZeRO.') \n args.fp16 = True\n args.bf16 = False\n\n if args.deepspeed:\n if args.checkpoint_activations:\n args.deepspeed_activation_checkpointing = True\n else:\n args.deepspeed_activation_checkpointing = False\n if args.deepspeed_config is not None:\n with open(args.deepspeed_config) as file:\n deepspeed_config = json.load(file)\n \n if override_deepspeed_config: # not specify deepspeed_config, use args\n if args.fp16:\n deepspeed_config[\"fp16\"][\"enabled\"] = True\n else:\n deepspeed_config[\"fp16\"][\"enabled\"] = False\n deepspeed_config[\"train_micro_batch_size_per_gpu\"] = args.batch_size\n deepspeed_config[\"gradient_accumulation_steps\"] = args.gradient_accumulation_steps\n optimizer_params_config = deepspeed_config[\"optimizer\"][\"params\"]\n optimizer_params_config[\"lr\"] = args.lr\n optimizer_params_config[\"weight_decay\"] = args.weight_decay\n else: # override args with values in deepspeed_config\n if args.rank == 0:\n print('Will override arguments with manually specified deepspeed_config!')\n if \"fp16\" in deepspeed_config and deepspeed_config[\"fp16\"][\"enabled\"]:\n args.fp16 = True\n else:\n args.fp16 = False\n if \"train_micro_batch_size_per_gpu\" in deepspeed_config:\n args.batch_size = deepspeed_config[\"train_micro_batch_size_per_gpu\"]\n if \"gradient_accumulation_steps\" in deepspeed_config:\n args.gradient_accumulation_steps = deepspeed_config[\"gradient_accumulation_steps\"]\n else:\n args.gradient_accumulation_steps = None\n if \"optimizer\" in deepspeed_config:\n optimizer_params_config = deepspeed_config[\"optimizer\"].get(\"params\", {})\n args.lr = optimizer_params_config.get(\"lr\", args.lr)\n args.weight_decay = optimizer_params_config.get(\"weight_decay\", args.weight_decay)\n args.deepspeed_config = deepspeed_config\n \n if args.sandwich_ln:\n args.layernorm_order = 'sandwich'\n # initialize distributed and random seed because it always seems to be necessary.\n initialize_distributed(args)\n set_random_seed(args.seed)\n return args","def parse_args():\n\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--ori_dir', type=str, default=os.path.join(Constants.TRAIN_PATH, 'para_train_ori.pt'),\n help='source training data location.'\n )\n parser.add_argument(\n '--ref_dir', type=str, default=os.path.join(Constants.TRAIN_PATH, 'para_train_ref.pt'),\n help='reference training data location.'\n )\n parser.add_argument(\n '--dict_dir', type=str, default=os.path.join(Constants.TRAIN_PATH, 'para_train_dict.pt'),\n help='token to index dictionary save location.'\n )\n parser.add_argument(\n '--epoch', type=int, default=20, help='number of training epochs'\n )\n parser.add_argument(\n '--lr', type=float, default=2.0, help='learning rate scale factor'\n )\n parser.add_argument(\n '--batch_size', type=int, default=128, help='batch size'\n )\n parser.add_argument(\n '--d_model', type=int, default=256, help='model dimension'\n )\n parser.add_argument(\n '--d_inner', type=int, default=1024, help='inner dimension'\n )\n parser.add_argument(\n '--d_k', type=int, default=64, help='dimension of key and query'\n )\n parser.add_argument(\n '--d_v', type=int, default=64, help='dimension of value'\n )\n parser.add_argument(\n '--n_trf_txt_enc_layer', type=int, default=4, help='number of text Transformer encoder layers'\n )\n parser.add_argument(\n '--n_trf_syn_enc_layer', type=int, default=2, help='number of syntax Transformer encoder layers'\n )\n parser.add_argument(\n '--n_trf_dec_layer', type=int, default=6, help='number of Transformer decoder layers'\n )\n parser.add_argument(\n '--n_txt_attn_head', type=int, default=4, help='number of text encoder attention heads'\n )\n parser.add_argument(\n '--n_syn_attn_head', type=int, default=2, help='number of syntax encoder attention heads'\n )\n parser.add_argument(\n '--dropout', type=float, default=0.1, help='dropout ratio'\n )\n parser.add_argument(\n '--tgt_emb_prj_weight_sharing', action='store_true',\n help='whether share weights between embedding and projection layers'\n )\n parser.add_argument(\n '--log', type=str, default=os.path.join('logs', 'LogFile'), help='log filepath to save'\n )\n parser.add_argument(\n '--model_save', type=str, default=os.path.join('models', 'model'),\n help='the path of the model to save'\n )\n parser.add_argument(\n '--no_cuda', action='store_true', help='disable cuda'\n )\n parser.add_argument(\n '--label_smoothing', action='store_true', help='whether use label smoothing'\n )\n parser.add_argument(\n '--n_warmup_steps', type=int, default=12800, help='number of warm-up steps'\n )\n parser.add_argument(\n '--pin_memory', action='store_true', help='whether pin your cuda memory during training'\n )\n parser.add_argument(\n '--random_seed', type=int, default=42\n )\n\n args = parser.parse_args()\n args.cuda = not args.no_cuda and torch.cuda.is_available()\n\n return args","def main():\n parser = argparse.ArgumentParser()\n\n # Add arguments to parser\n parser.add_argument(\n '-base_data_dir', default='../data',\n help='Root directory of data', type=str)\n parser.add_argument(\n '-dataset', default='litbank', choices=['litbank', 'ontonotes'], type=str)\n parser.add_argument('-base_model_dir',\n default='../models',\n help='Root folder storing model runs', type=str)\n parser.add_argument('-model_size', default='large', type=str,\n help='BERT model type')\n parser.add_argument('-doc_enc', default='overlap', type=str,\n choices=['independent', 'overlap'], help='BERT model type')\n parser.add_argument('-pretrained_bert_dir', default='../resources', type=str,\n help='SpanBERT model location')\n parser.add_argument('-max_segment_len', default=512, type=int,\n help='Max segment length of BERT segments.')\n parser.add_argument('-top_span_ratio', default=0.3, type=float,\n help='Ratio of top spans proposed as mentions.')\n\n parser.add_argument('-ment_emb', default='endpoint', choices=['attn', 'max', 'endpoint'],\n type=str)\n parser.add_argument('-max_span_width',\n help='Max span width', default=20, type=int)\n parser.add_argument('-mlp_depth', default=1, type=int,\n help='Number of hidden layers in other MLPs')\n parser.add_argument('-mlp_size', default=3000, type=int,\n help='MLP size used in the model')\n\n parser.add_argument('-cross_val_split', default=0, type=int,\n help='Cross validation split to be used.')\n parser.add_argument('--batch_size', '-bsize',\n help='Batch size', default=1, type=int)\n parser.add_argument('-num_train_docs', default=None, type=int,\n help='Number of training docs.')\n parser.add_argument('-dropout_rate', default=0.3, type=float,\n help='Dropout rate')\n parser.add_argument('-max_epochs',\n help='Maximum number of epochs', default=25, type=int)\n parser.add_argument('-seed', default=0,\n help='Random seed to get different runs', type=int)\n parser.add_argument('-init_lr', help=\"Initial learning rate\",\n default=5e-4, type=float)\n parser.add_argument('-checkpoint', help=\"Use checkpoint\",\n default=False, action=\"store_true\")\n parser.add_argument('-eval', help=\"Evaluate model\",\n default=False, action=\"store_true\")\n parser.add_argument('-slurm_id', help=\"Slurm ID\",\n default=None, type=str)\n\n args = parser.parse_args()\n\n model_name = get_mention_model_name(args)\n print(model_name)\n\n model_dir = path.join(args.base_model_dir, model_name)\n args.model_dir = model_dir\n best_model_dir = path.join(model_dir, 'best_models')\n args.best_model_dir = best_model_dir\n if not path.exists(model_dir):\n os.makedirs(model_dir)\n if not path.exists(best_model_dir):\n os.makedirs(best_model_dir)\n\n if args.dataset == 'litbank':\n args.data_dir = path.join(args.base_data_dir, f'{args.dataset}/{args.doc_enc}/{args.cross_val_split}')\n else:\n args.data_dir = path.join(args.base_data_dir, f'{args.dataset}/{args.doc_enc}')\n\n # if args.dataset == 'ontonotes':\n # args.pretrained_model = path.join(\n # args.pretrained_mention_model_dir, f'mention_ontonotes_{args.model_size}_{args.ment_emb}.pt')\n # Log directory for Tensorflow Summary\n\n Experiment(**vars(args))","def main():\n\n downloadData()\n\n parser = argparse.ArgumentParser(description=\"Train model or test model (default)\")\n parser.add_argument(\"--train-model\", action=\"store_true\", default=False)\n parser.add_argument(\"--num-channels\", type=int, help=\"Number of channels in lowest dimension\", default=8)\n\n arg_parser = parser.parse_args()\n\n if arg_parser.train_model:\n encoder, generator = train(channels=arg_parser.num_channels)\n torch.save(encoder.state_dict(), f\"../models/encoder_{arg_parser.num_channels}.model\")\n torch.save(generator.state_dict(), f\"../models/generator_{arg_parser.num_channels}.model\")\n else:\n validate_models(VALIDATE_CHANNELS)","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Trains a Discrete Spatial-BERT model.\"\n )\n parser.add_argument(\n \"--checkpoint_path\",\n type=str,\n default=None,\n help=\"Checkpoint to a pretrained model.\",\n )\n parser.add_argument(\n \"--train_dataset_path\",\n type=str,\n default=\"data/train_dataset.json\",\n help=\"Path to the train dataset.\",\n )\n parser.add_argument(\n \"--val_dataset_path\",\n type=str,\n default=\"data/val_dataset.json\",\n help=\"Path to the validation dataset.\",\n )\n parser.add_argument(\n \"--visuals_dicts_path\",\n type=str,\n default=\"data/visuals_dicts/\",\n help=\"Path to the directory with the visuals dictionaries.\",\n )\n parser.add_argument(\n \"--mask_probability\", type=float, default=0.15, help=\"The mask probability.\"\n )\n parser.add_argument(\"--batch_size\", type=int, default=128, help=\"The batch size.\")\n parser.add_argument(\n \"--epochs\", type=int, default=1000, help=\"The number of epochs.\"\n )\n parser.add_argument(\n \"--learning_rate\", type=float, default=2e-5, help=\"The learning rate.\"\n )\n parser.add_argument(\n \"--clip_val\", type=float, default=2.0, help=\"The clipping threshold.\"\n )\n parser.add_argument(\n \"--weight_decay\", type=float, default=0.0, help=\"The weight decay.\"\n )\n parser.add_argument(\n \"--save_model_path\",\n type=str,\n default=\"models/best.pt\",\n help=\"Where to save the model.\",\n )\n parser.add_argument(\n \"--intermediate_save_checkpoint_path\",\n type=str,\n default=\"models/intermediate.pt\",\n help=\"Where to save the intermediate checkpoint.\",\n )\n parser.add_argument(\n \"--bert_name\",\n type=str,\n default=\"bert-base-uncased\",\n help=\"The bert model name.\",\n )\n parser.add_argument(\n \"--log_filepath\", type=str, default=None, help=\"The logging file.\"\n )\n\n return parser.parse_args()","def parse_args():\n\n parser = argparse.ArgumentParser(description=\"Train segmentation model via SGD.\")\n\n # Data\n parser.add_argument(\"--data_dir\", help=\"Path to folder containing tfrecords\", required=True)\n parser.add_argument(\"--fp_k_test_set\", help=\"Hold out the test task for the fp-k classes.\", action=\"store_true\")\n parser.add_argument(\"--test_on_val_set\", help=\"If speced, will train on train shards and test on val shards, else will train on both train and val and test on test.\", action=\"store_true\")\n\n # Model\n parser.add_argument('--model_name',\n help=\"Name of the model architecture to meta-train. Must be in the set: {}.\".format(SUPPORTED_MODELS), required=False,\n default='EfficientLab')\n parser.add_argument(\"--rsd\", help=\"List of integers specifying the 1-indexed reduction endpionts from EfficientNet to input into the lightweight skip decoding layers of EfficientLab.\", type=int, nargs=\"+\")\n parser.add_argument(\"--feature_extractor_name\", help=\"efficientnet-b0 or efficientnet-b3\", type=str, default=\"efficientnet-b0\")\n parser.add_argument(\"--image_size\", help=\"size of image in pixels. images assumed to square\", type=int, default=224)\n parser.add_argument(\"--seperate_background_channel\", help=\"Whether or not to make a mutually exclusive background channel.\", action='store_true', default=False)\n\n # Training\n parser.add_argument(\"--restore_efficient_net_weights_from\", help=\"path to dir to restore efficientnet weights from\", type=str, default=None)\n parser.add_argument('--sgd', help='use vanilla SGD instead of Adam', action='store_true')\n parser.add_argument('--loss_name', help='Name of the loss function to use. Should be cross_entropy, cross_entropy_dice, or ce_dice', default='ce_dice')\n parser.add_argument(\"--l2\", help=\"Applies l2 weight decay to all weights in network\", action=\"store_true\")\n parser.add_argument(\"--augment\", help=\"Apply augmentations to training data\",\n action=\"store_true\")\n parser.add_argument(\"--final_layer_dropout_rate\", help=\"Probability to dropout inputs at final layer.\", type=float, default=0.0)\n parser.add_argument('--batch_size', help='Training batch size', default=64, type=int)\n parser.add_argument('--epochs', help='Number of training epochs', default=200, type=int)\n parser.add_argument(\"--steps_per_epoch\", help=\"Number of gradient steps to take per epoch. If unspecified will be determined from batch size and number of examples.\", type=int, default=None)\n parser.add_argument(\"--learning_rate\", default=0.005, type=float)\n parser.add_argument(\"--final_learning_rate\", default=5e-7, type=float)\n parser.add_argument(\"--label_smoothing\", default=0.0, type=float)\n\n\n # Evaluation\n parser.add_argument(\"--val_batches\", default=20, type=int)\n parser.add_argument('--pretrained', help='Evaluate a pre-trained model.',\n action='store_true', default=False)\n parser.add_argument('--eval_interval', help='Training steps per evaluation', default=2, type=int)\n\n # Misc. config\n parser.add_argument('--seed', help='random seed', default=0, type=int)\n parser.add_argument('--checkpoint', help='Checkpoint directory to write to (or restore from).', default='/tmp/model_checkpoint', type=str)\n return parser.parse_args()","def config_and_train(self, sys_args):\n \n self.run_config_function(sys_args)\n self.set_model_name('vgg_16')\n self.set_trainable_and_exclude_scopes(constants.checkpoint_exclude_scopes,\n constants.trainable_scopes)\n self.set_optimizer('sgd')\n self.set_max_number_of_steps(6000)\n self.train_or_eval_net(sys_args)","def add_models_args(parser):\r\n # Some common arguments for your convenience\r\n parser.add_argument('--seed', type=int, default=0, help='RNG seed (default = 0)')\r\n parser.add_argument('--epochs', type=int, default=10, help='num epochs to train for')\r\n parser.add_argument('--lr', type=float, default=1e-3)\r\n parser.add_argument('--batch_size', type=int, default=2, help='batch size')\r\n\r\n # 65 is all you need for GeoQuery\r\n parser.add_argument('--decoder_len_limit', type=int, default=65, help='output length limit of the decoder')\r\n\r\n # Feel free to add other hyperparameters for your input dimension, etc. to control your network\r\n # 50-200 might be a good range to start with for embedding and LSTM sizes\r","def get_input_args():\n \n parser = argparse.ArgumentParser()\n \n # command line parameter for dataset path\n parser.add_argument('data_directory', action='store', type=str, \n help='directory for new dataset to train')\n \n # command line parameter for saving checkpoint path \n parser.add_argument('--save_dir',type=str,default='checkpoint',\n help='directory where checkpoint is saved')\n \n # command line parameter to input model chosen. Defaults to vgg16. Chosen model can be either vgg16 or densenet121\n parser.add_argument('--arch',type=str,default='vgg16',choices=('vgg16', 'densenet121'),\n help='chosen model: vgg16 or densenet121')\n \n # command line parameter to input learning rate. Defaults to 0.00001\n parser.add_argument('--learning_rate',type=float,default='0.00001',\n help='learning rate for model')\n \n # command line parameter to input number of hidden units\n parser.add_argument('--hidden_units',type=int,default=0,\n help='add number of units in hidden layer to list')\n \n # command line paramter to input epochs. Defaults to 5\n parser.add_argument('--epochs',type=int,default='5',\n help='number of epochs')\n \n # command line parameter for using gpu\n parser.add_argument('--gpu', action='store_true', default=False,\n help='Set a switch to true')\n \n #return parsed argument collection\n return parser.parse_args()","def _parse_config(self, args, experiment_id):\r\n if not args:\r\n if experiment_id:\r\n config = importlib.import_module('configs.config_' + experiment_id)\r\n args = config.load_config()\r\n else:\r\n raise ValueError('No arguments or configuration data given')\r\n # Mandatory parameters for all architectures\r\n self.network_type = args.net\r\n self.is_training = args.training_mode\r\n self.train_data_file = args.train_data_file\r\n self.valid_data_file = args.valid_data_file\r\n self.test_data_file = args.test_data_file\r\n self.checkpoint_dir = args.checkpoint_dir\r\n self.trainlog_dir = args.trainlog_dir\r\n self.lr = args.lr\r\n self.batch_size = args.batch_size\r\n self.num_epochs = args.num_epochs\r\n self.loss_type = args.loss\r\n self.accuracy_type = args.accuracy\r\n self.optimizer = args.optimizer\r\n self.dropout = args.dropout\r\n self.gpu_load = args.gpu_load\r\n self.num_filters = args.num_filters\r\n self.nonlin = args.nonlin\r\n self.loss_type = args.loss\r\n self.task_type = args.task_type\r\n self.long_summary = args.long_summary\r\n self.experiment_path = args.experiment_path\r\n self.chpnt2load = args.chpnt2load\r\n self.lr_mode = args.lr_mode\r\n\r\n if not self.is_training:\r\n self.class_labels = args.class_labels\r\n if args.image_size:\r\n self.img_size = args.image_size\r\n else:\r\n self.img_size = None\r\n if args.num_classes:\r\n self.num_classes = args.num_classes\r\n else:\r\n self.num_classes = None\r\n if args.augmentation:\r\n self.augmentation_dict = args.augmentation\r\n else:\r\n self.augmentation_dict = None\r\n if args.normalize:\r\n self.normalize = args.normalize\r\n else:\r\n self.normalize = None\r\n if args.zero_center:\r\n self.zero_center = args.zero_center\r\n else:\r\n self.zero_center = None\r\n\r\n\r\n self._initialize_data()","def main():\n\n if len(sys.argv) == 3:\n database_filepath, model_filepath = sys.argv[1:]\n print('Loading data...\\n DATABASE: {}'.format(database_filepath))\n X, Y, category_names = load_data(database_filepath)\n X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)\n \n print('Building model...')\n model = build_model()\n \n print('Training model...')\n model.fit(X_train, Y_train)\n \n print('Evaluating model...')\n evaluate_model(model, X_test, Y_test, category_names)\n\n print('Saving model...\\n MODEL: {}'.format(model_filepath))\n save_model(model, model_filepath)\n\n print('Trained model saved!')\n\n else:\n print('Please provide the filepath of the disaster messages database '\\\n 'as the first argument and the filepath of the pickle file to '\\\n 'save the model to as the second argument. \\n\\nExample: python '\\\n 'train_classifier.py ../data/DisasterResponse.db classifier.pkl')","def main(args):\n # Generate detectron2 config from command line arguments.\n cfg = get_cfg()\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n\n # The configuration file should not contain any datasets. They are configured\n # from command line arguments instead.\n if len(cfg.DATASETS.TRAIN) > 0 or len(cfg.DATASETS.TEST) > 0:\n logging.error(\"Please set DATASETS.TRAIN = () and DATASETS.TEST = ().\")\n sys.exit(1)\n cfg.DATASETS.TRAIN = (TRAIN_SPLIT_NAME, )\n cfg.DATASETS.TEST = (VALID_SPLIT_NAME, )\n\n cfg.freeze()\n default_setup(cfg, args)\n\n # Register synthetic sign datasets.\n if args.image_width is not None or args.image_height is not None:\n if args.image_width is None or args.image_height is None:\n logging.error(\n \"Please specify both, image-width and image-height (or none).\")\n sys.exit(1)\n image_shape = args.image_height, args.image_width\n else:\n image_shape = None\n\n register_synthetic_signs(args.train_csv,\n args.label_map,\n cfg,\n name=TRAIN_SPLIT_NAME,\n image_shape=image_shape)\n if args.valid_csv is not None:\n register_synthetic_signs(args.valid_csv,\n args.label_map,\n cfg,\n name=VALID_SPLIT_NAME,\n image_shape=image_shape)\n\n # Run training or evaluation.\n if args.eval_only:\n model = Trainer.build_model(cfg)\n DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load(\n cfg.MODEL.WEIGHTS, resume=args.resume)\n res = Trainer.test(cfg, model)\n if comm.is_main_process():\n verify_results(cfg, res)\n return res\n\n trainer = Trainer(cfg)\n trainer.resume_or_load(resume=args.resume)\n return trainer.train()","def main(args):\n print(now(), \"craft_poisons_bp.py main() running.\")\n\n craft_log = \"craft_log.txt\"\n to_log_file(args, args.output, craft_log)\n\n ####################################################\n # Dataset\n if args.dataset.lower() == \"cifar10\":\n transform_test = get_transform(args.normalize, False)\n testset = torchvision.datasets.CIFAR10(\n root=\"./data\", train=False, download=True, transform=transform_test\n )\n trainset = torchvision.datasets.CIFAR10(\n root=\"./data\", train=True, download=True, transform=transform_test\n )\n elif args.dataset.lower() == \"tinyimagenet_first\":\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\n trainset = TinyImageNet(\n TINYIMAGENET_ROOT,\n split=\"train\",\n transform=transform_test,\n classes=\"firsthalf\",\n )\n testset = TinyImageNet(\n TINYIMAGENET_ROOT,\n split=\"val\",\n transform=transform_test,\n classes=\"firsthalf\",\n )\n elif args.dataset.lower() == \"tinyimagenet_last\":\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\n trainset = TinyImageNet(\n TINYIMAGENET_ROOT,\n split=\"train\",\n transform=transform_test,\n classes=\"lasthalf\",\n )\n testset = TinyImageNet(\n TINYIMAGENET_ROOT,\n split=\"val\",\n transform=transform_test,\n classes=\"lasthalf\",\n )\n elif args.dataset.lower() == \"tinyimagenet_all\":\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\n trainset = TinyImageNet(\n TINYIMAGENET_ROOT,\n split=\"train\",\n transform=transform_test,\n classes=\"all\",\n )\n testset = TinyImageNet(\n TINYIMAGENET_ROOT,\n split=\"val\",\n transform=transform_test,\n classes=\"all\",\n )\n else:\n print(\"Dataset not yet implemented. Exiting from craft_poisons_cp.py.\")\n sys.exit()\n ###################################################\n\n ####################################################\n # Find target and base images\n with open(args.poison_setups, \"rb\") as handle:\n setup_dicts = pickle.load(handle)\n setup = setup_dicts[args.setup_idx]\n\n target_img_idx = (\n setup[\"target index\"] if args.target_img_idx is None else args.target_img_idx\n )\n base_indices = (\n setup[\"base indices\"] if args.base_indices is None else args.base_indices\n )\n\n # get single target\n target_img, target_label = testset[target_img_idx]\n\n # get multiple bases\n base_imgs = torch.stack([trainset[i][0] for i in base_indices])\n base_labels = [trainset[i][1] for i in base_indices]\n poisoned_label = base_labels[0]\n\n # log target and base details\n to_log_file(\"base indices: \" + str(base_indices), args.output, craft_log)\n to_log_file(\"base labels: \" + str(base_labels), args.output, craft_log)\n to_log_file(\"target_label: \" + str(target_label), args.output, craft_log)\n to_log_file(\"target_index: \" + str(target_img_idx), args.output, craft_log)\n\n # Set visible CUDA devices\n cudnn.benchmark = True\n\n # load the pre-trained models\n sub_net_list = []\n for n_model, chk_name in enumerate(args.model_path):\n net = load_model_from_checkpoint(\n args.model[n_model], chk_name, args.pretrain_dataset\n )\n sub_net_list.append(net)\n\n target_net = load_model_from_checkpoint(\n args.target_model, args.target_model_path, args.pretrain_dataset\n )\n\n # Get the target image\n target = target_img.unsqueeze(0)\n\n chk_path = args.poisons_path\n if not os.path.exists(chk_path):\n os.makedirs(chk_path)\n\n base_tensor_list = [base_imgs[i] for i in range(base_imgs.shape[0])]\n base_tensor_list = [bt.to(\"cuda\") for bt in base_tensor_list]\n\n poison_init = base_tensor_list\n mean, std = data_mean_std_dict[args.dataset.lower()]\n poison_tuple_list = make_convex_polytope_poisons(\n sub_net_list,\n target_net,\n base_tensor_list,\n target,\n \"cuda\",\n opt_method=args.poison_opt,\n lr=args.poison_lr,\n momentum=args.poison_momentum,\n iterations=args.crafting_iters,\n epsilon=args.epsilon,\n decay_ites=args.poison_decay_ites,\n decay_ratio=args.poison_decay_ratio,\n mean=torch.Tensor(mean).reshape(1, 3, 1, 1),\n std=torch.Tensor(std).reshape(1, 3, 1, 1),\n chk_path=chk_path,\n poison_idxes=base_indices,\n poison_label=poisoned_label,\n tol=args.tol,\n start_ite=0,\n poison_init=poison_init,\n end2end=args.end2end,\n mode=\"mean\",\n )\n\n # move poisons to PIL format\n if args.normalize:\n target = un_normalize_data(target.squeeze(0), args.dataset)\n for i in range(len(poison_tuple_list)):\n poison_tuple_list[i] = (\n transforms.ToPILImage()(\n un_normalize_data(poison_tuple_list[i][0], args.dataset)\n ),\n poison_tuple_list[i][1],\n )\n else:\n target = target.squeeze(0)\n for i in range(len(poison_tuple_list)):\n poison_tuple_list[i] = (\n transforms.ToPILImage()(poison_tuple_list[i][0]),\n poison_tuple_list[i][1],\n )\n\n # get perturbation norms\n poison_perturbation_norms = []\n for idx, (poison_tensor, p_label) in enumerate(poison_tuple_list):\n poison_perturbation_norms.append(\n torch.max(\n torch.abs(\n transforms.ToTensor()(poison_tensor)\n - un_normalize_data(base_tensor_list[idx].cpu(), args.dataset)\n )\n ).item()\n )\n to_log_file(\n \"perturbation norms: \" + str(poison_perturbation_norms),\n args.output,\n \"craft_log.txt\",\n )\n\n ####################################################\n # Save Poisons\n print(now(), \"Saving poisons...\")\n if not os.path.isdir(args.poisons_path):\n os.makedirs(args.poisons_path)\n with open(os.path.join(args.poisons_path, \"poisons.pickle\"), \"wb\") as handle:\n pickle.dump(poison_tuple_list, handle, protocol=pickle.HIGHEST_PROTOCOL)\n with open(\n os.path.join(args.poisons_path, \"perturbation_norms.pickle\"), \"wb\"\n ) as handle:\n pickle.dump(poison_perturbation_norms, handle, protocol=pickle.HIGHEST_PROTOCOL)\n with open(os.path.join(args.poisons_path, \"base_indices.pickle\"), \"wb\") as handle:\n pickle.dump(base_indices, handle, protocol=pickle.HIGHEST_PROTOCOL)\n with open(os.path.join(args.poisons_path, \"target.pickle\"), \"wb\") as handle:\n pickle.dump(\n (transforms.ToPILImage()(target), target_label),\n handle,\n protocol=pickle.HIGHEST_PROTOCOL,\n )\n to_log_file(\"poisons saved.\", args.output, \"craft_log.txt\")\n ####################################################\n\n print(now(), \"craft_poisons_bp.py done.\")\n return","def read_args(self):\n parser = argparse.ArgumentParser()\n parser.add_argument('--algorithm', '-a', default='onelayer',\n choices=['onelayer', 'randomforest', 'sos'],\n help='which algorithm to run')\n parser.add_argument('--format', '-f', default='pcap',\n choices=['netflow', 'pcap'],\n help='which format are the files to process in')\n parser.add_argument('--operation', '-o', default='eval',\n choices=['eval', 'train', 'test'],\n help='which operation to run')\n parser.add_argument('--sos_model', '-s', default='networkml/trained_models/sos/SoSmodel',\n help='path to SoSmodel')\n parser.add_argument('--trained_model', '-m', default='networkml/trained_models/onelayer/OneLayerModel.pkl',\n help='path to the trained model file')\n parser.add_argument('--path', '-p', default='/pcaps',\n help='path to file or directory of files to process')\n parser.add_argument('--save', '-w', default='networkml/trained_models/onelayer/OneLayerModel.pkl',\n help='path to save the trained model, if training')\n\n self.args = parser.parse_args()\n return","def argparser():\n ap = argparse.ArgumentParser(fromfile_prefix_chars='@',\n description='Train and deploy a deep-learned [Fe/H] estimator'\n 'based on Gaia time-series photometry.',\n epilog=\"\")\n\n # use custom line parser for the parameter file\n ap.convert_arg_line_to_args = convert_arg_line_to_args\n\n ap.add_argument('-v',\n '--verbose',\n action='store_true', # assign True value if used\n help='Generate verbose output.')\n\n ap.add_argument('--seed',\n action='store',\n type=int,\n default=1,\n help='Integer seed for reproducible results.')\n\n ap.add_argument('--rootdir',\n action='store',\n type=str,\n default=os.path.expanduser('~'),\n help='Full path of the root directory '\n '(all other directory and file names will be relative to this, default: `~`).')\n\n ap.add_argument('--input_list',\n action='store',\n type=str,\n default='lcfit_input.lst',\n help='Name of the input list file (default: `lcfit_input.lst`)')\n\n ap.add_argument('--input_dir',\n action='store',\n type=str,\n default='.',\n help='Subdirectory of the input time series (default: `.`)')\n\n ap.add_argument('--gls_input_file',\n action='store',\n type=str,\n default='gls_input.dat',\n help='Name of the GLS input file (created by the external code `gls` and read by `lcfit`, '\n 'default: `gls_input.dat`)')\n\n ap.add_argument('--input_lc_suffix',\n action='store',\n type=str,\n default='.dat',\n help='Suffix for the input time series file names (default: `.dat`).')\n\n ap.add_argument('--input_lc_prefix',\n action='store',\n type=str,\n default='',\n help='Prefix for the input time series file names (default: no prefix).')\n\n ap.add_argument('--output_dir',\n action='store',\n type=str,\n default='data',\n help='If specified, the clipped, phased, phase-sorted light curves will be written to '\n 'this directory, into a separate file for each time series (default: `data`).')\n\n ap.add_argument('--output_syn_dir',\n action='store',\n type=str,\n default=None,\n help='If specified, the synthetic output time series will be written to '\n 'this directory (separate file for each time series).')\n\n ap.add_argument('--plot_dir',\n action='store',\n type=str,\n default='plots',\n help='Subdirectory of the output figures.')\n\n ap.add_argument('--plot_suffix',\n action='store',\n type=str,\n default='',\n help='Suffix for the output figures.')\n\n ap.add_argument('--syn_suffix',\n action='store',\n type=str,\n default='_syn',\n help='Suffix for the synthetic output time series.')\n\n ap.add_argument('--output_gpr_dir',\n action='store',\n type=str,\n default=None,\n help='Subdirectory (if specified) of the output Gaussian Process models.')\n\n ap.add_argument('--output_param_file',\n action='store',\n type=str,\n default='lcfit.out',\n help='Name of the output parameter file.')\n\n ap.add_argument('--output_data_dir',\n action='store',\n type=str,\n default='.',\n help='Subdirectory for output data files.')\n\n ap.add_argument('--merged_output_datafile',\n action='store',\n type=str,\n default=None,\n help='Name of the data file for writing all output time series, appended one after the other.')\n\n ap.add_argument('--degrade_lc',\n action='store_true',\n help='Degrade the light curve (see the source code for the corresponding parameters).')\n\n ap.add_argument('--compute_errors',\n action='store_true', # assign True value if used\n help='If `gpr_fit` is `True`, then `n_gpr_sample` random samples will be drawn from '\n 'the fitted GPR model at the original (or if the >maxn_gpr, then the '\n 'binned) phases, and each sample will be fitted with a Fourier series. '\n 'The errors of Fourier parameters will be estimated therefrom.')\n\n ap.add_argument('--pca_model_file',\n action='store',\n type=str,\n default=None,\n help='Apply the specified PCA transformation to the Fourier parameters.')\n\n ap.add_argument('--feh_model_file',\n action='store',\n type=str,\n default=None,\n help='Apply the specified model to predict the [Fe/H] from the Fourier parameters.')\n\n ap.add_argument('--fold_double_period',\n action='store_true', # assign True value if used\n help='Fold the time series also with twice the period, and create the corresponding output files.')\n\n ap.add_argument('--loss',\n action='store',\n type=str,\n choices=['linear', 'soft_l1', 'huber', 'cauchy', 'arctan'],\n default='huber',\n help='Type of regression loss.')\n\n ap.add_argument('--sigma_clip_threshold',\n action='store',\n type=float,\n default=None,\n help='If specified, outliers beyond `sigma_clip_threshold` * residual std. dev. '\n 'will be iteratively omitted.')\n\n ap.add_argument('--align_phi1',\n action='store_true',\n help='The time series will be phase-aligned by the first Fourier phase defined to be at zero.')\n\n ap.add_argument('--null_epoch',\n action='store',\n type=float,\n default=None,\n help='Reference epoch that will be subtracted from the time values. '\n 'If None (default), then the time of the first measurement will be used '\n 'for every time series.')\n\n ap.add_argument('--gpr_fit',\n action='store_true',\n help='Perform Gaussian Process Regression (GPR) on the phase-folded time series.')\n\n ap.add_argument('--kernel',\n action='store',\n type=str,\n choices=['matern', 'expsine2'],\n default='matern',\n help='Kernel type for the GPR. Available options: `matern`, `expsine2`. Default: `matern`.')\n\n ap.add_argument('--lower_length_scale_bound',\n action='store',\n type=float,\n default=0.1,\n help='Lower length scale bound for the GPR kernel. '\n 'Used if the --gpr_fit option is selected. Default: 0.1')\n\n ap.add_argument('--upper_length_scale_bound',\n action='store',\n type=float,\n default=10.0,\n help='Upper length scale bound for the GPR kernel. '\n 'Used if the --gpr_fit option is selected. Default: 10.0')\n\n ap.add_argument('--gpr_hparam_optimization',\n action='store',\n type=str,\n choices=['mle', 'cv'],\n default='mle',\n help='Method for hyperparameter optimization of the Gaussian Process Regression. '\n 'If `mle`, then the hyperparameters will be optimized by maximizing the log-likelihood '\n '(this is the widely-used standard method for GPR). '\n 'If `cv`, then the hyperparameters will be optimized by maximizing the R2 cross-validation '\n 'score. The hyperparameter-space will be searched using a Bayesian approach as implemented in '\n 'the `scikit-optimize` API, and 10-fold CV will be used for evaluation.')\n\n ap.add_argument('--gpr_cv_n_init',\n action='store',\n type=int,\n default=10,\n help='The number of initial estimates for Bayesian hyperparameter optimization if '\n '`gpr_hparam_optimization` is `cv`.')\n\n ap.add_argument('--gpr_cv_n_calls',\n action='store',\n type=int,\n default=10,\n help='The number of iterations for Bayesian hyperparameter optimization if '\n '`gpr_hparam_optimization` is `cv`.')\n\n ap.add_argument('--fourier_from_gpr',\n action='store_true',\n help='Infer the Fourier parameters from the best-fitting Gaussian Process Regression model.')\n\n ap.add_argument('--n_augment_data',\n action='store',\n type=int,\n default=None,\n help='If specified, the input time series will be augmented by drawing `n_augment_data` new '\n 'time series from the GPR model at the original phase points.')\n\n ap.add_argument('--plot_augmented',\n action='store_true',\n help='Plot the augmented time series.')\n\n ap.add_argument('--k_fold',\n action='store',\n type=int,\n default=10,\n help='Number of cross-validation folds.')\n\n ap.add_argument('--fourier_order_min',\n action='store',\n type=int,\n default=3,\n help='Minimum Fourier order to consider.')\n\n ap.add_argument('--fourier_order_max',\n action='store',\n type=int,\n default=8,\n help='Maximum Fourier order to consider.')\n\n ap.add_argument('--is_err_col',\n action='store_true',\n help='The input contains (a) column(s) with the magnitudes\\' uncertainties.')\n\n ap.add_argument('--is_zperr_col',\n action='store_true',\n help='The input contains (a) column(s) with zero-point uncertainties.')\n\n ap.add_argument('--n_data_cols',\n action='store',\n type=int,\n default=1,\n help='Number of data columns per input file.')\n\n ap.add_argument('--use_data_cols',\n action='store',\n nargs='*',\n type=int,\n default='1',\n help='List of data columns to use.')\n\n ap.add_argument('--known_data_cols',\n action='store_true',\n help='If set, the input list file is expected to contain an extra column with header name \\'col\\' '\n 'containing the number of the data column to be used for regression.')\n\n ap.add_argument('--known_phaseshift',\n action='store_true',\n help='If set, the input list file is expected to contain an extra column with header name '\n '\\'phaseshift\\', containing the phase shift to be applied to the time series.')\n\n ap.add_argument('--min_snr',\n action='store',\n type=float,\n default=None,\n help='If specified, a column with S/N is expected to follow each magnitude column '\n '(or magnitude error column if included). Data points with values below `min_snr` '\n 'will be rejected.')\n\n ap.add_argument('--flag_omit',\n action='store',\n type=str,\n default=None,\n help='If specified, a column with string flags is expected to follow each magnitude column '\n '(or magnitude error column / S/N column if included). Data points with values `flag_omit` '\n 'will be rejected.')\n\n ap.add_argument('--mean_phase2',\n action='store',\n type=float,\n default=None,\n help='Population mean of the phi2 Fourier parameter.')\n\n ap.add_argument('--mean_phase3',\n action='store',\n type=float,\n default=None,\n help='Population mean of the phi3 Fourier parameter.')\n\n ap.add_argument('--mean_phase21',\n action='store',\n type=float,\n default=None,\n help='Population mean of the phi21 Fourier parameter.')\n\n ap.add_argument('--mean_phase31',\n action='store',\n type=float,\n default=None,\n help='Population mean of the phi31 Fourier parameter.')\n\n ap.add_argument('--waveband',\n action='store',\n type=str,\n default=None,\n help='Name of the waveband (filter) of the input time series.')\n\n ap.add_argument('--plot_data',\n action='store_true',\n help='Plot the time series.')\n\n ap.add_argument('--save_figures',\n action='store_true',\n help='Save output plots into files.')\n\n ap.add_argument('--plot_gpr',\n action='store_true',\n help='Plot the results of the Gaussian Process Regression.')\n\n ap.add_argument('--plot_all_datasets',\n action='store_true',\n help='Create plots for all datasets.')\n\n ap.add_argument('--fit_period',\n action='store_true',\n help='Fit the period to the dataset (by non-linear least squares regression).')\n\n ap.add_argument('--do_gls',\n action='store_true',\n help='Compute an initial period estimate by the Generalized Lomb-Scargle Periodogram '\n 'method. Otherwise an initial period value is expected in the input file.')\n\n ap.add_argument('--redo_gls',\n action='store_true',\n help='Recompute the initial period estimate by the Generalized Lomb-Scargle Periodogram '\n 'method in the outlier rejection iterations.')\n\n ap.add_argument('--weighted_fit',\n action='store_true',\n help='Use squared inverse of the errors as weights in the regression.')\n\n ap.add_argument('--nsyn',\n action='store',\n type=int,\n default=120,\n help='Number of equidistant phase points for the output synthetic data '\n '(i.e., points of evaluation of the regression model.)')\n\n ap.add_argument('--min_ndata',\n action='store',\n type=int,\n default=20,\n help='Minimum number of data points in the time series to be considered for analysis.')\n\n ap.add_argument('--n_jobs',\n action='store',\n type=int,\n default=None,\n help='The number parallel threads. If not specified, n_jobs=max(n_cores, k_fold)')\n\n return ap","def handle_arguments():\n # process the command options\n parser = argparse.ArgumentParser()\n parser.add_argument('images', type=str, help='provide path in style: '\n r'\"kaggle\\input\\bengaliai-cv19\\images.npy\"')\n parser.add_argument('labels', type=str, help='provide path in style: '\n r'\"kaggle\\input\\bengaliai-cv19\\labels.csv\"')\n parser.add_argument('-t', '--test_ratio', type=float, default=0.2,\n help='proportion of data for testing, default: 0.2')\n parser.add_argument('-s', '--seed', type=int, default=None, help='seed '\n 'used for consistent data splitting, default: None')\n parser.add_argument('-a', '--data_augmentation', action='store_true',\n help='switch to augment the images')\n drop_info_fns = ['cutout', 'gridmask', 'None'] # info dropping algorithms\n parser.add_argument('-d', '--drop_info_fn', type=str, choices=drop_info_fns,\n default=None, help='whether cutout, GridMask, or no '\n 'information dropping algorithm is used, default: None')\n parser.add_argument('-c', '--class_balancing', action='store_true',\n help='switch to perform class balancing')\n parser.add_argument('-b', '--batch_size', type=int, default=32,\n help='batch size of DataLoader objects, default: 32')\n parser.add_argument('-l', '--label_smoothing', action='store_true',\n help='switch to use soft targets in loss computation')\n parser.add_argument('-e', '--epochs', type=int, default=50, help='number '\n 'of iterations over training data, default: 50')\n parser.add_argument('-m', '--model', type=str, default='model.pt',\n help='path to save trained model, default: \"model.pt\"')\n\n # parse and print arguments\n args = parser.parse_args()\n for arg in vars(args):\n print(f'{arg.upper()}: {getattr(args, arg)}')\n\n return args","def init_from_scratch(args, train_exs, dev_exs):\n \n # Build a dictionary from the data sqls+queries (train/dev splits)\n logger.info('-' * 100)\n logger.info('Build vocab')\n \n vocab = build_vocab(train_exs + dev_exs, args)\n logger.info('Num words = %d' % vocab.size())\n \n # Initialize model\n model = CopyNet(args, vocab)\n logger.info('-' * 100)\n logger.info('Model Architecture')\n logger.info(model)\n if args.embedding_file:\n model.load_embeddings(vocab.tokens(), args.embedding_file)\n \n return model, vocab","def get_arguments():\n parser = argparse.ArgumentParser(description=\"DeepLabLFOV Network Inference.\")\n parser.add_argument(\"--train_set\", type=str, default=\"drill\",\n help=\"Number of classes to predict (including background).\")\n args = parser.parse_args()\n train_set = args.train_set\n\n #test_set = \"drill_11_test_scenes\"\n\n NUM_CLASSES = 8\n SAVE_DIR = './testing_softmax_output/'\n DATA_DIR = '/'\n DATA_LIST_PATH = '/home/peteflo/spartan/src/CorlDev/experiments/sixobjects_multi_test_scenes.txt.imglist.txtdownsampled10.txt'\n DATA_DIRECTORY = ''\n IGNORE_LABEL = 255\n RESTORE_FROM = './snapshots_' + train_set + '/model.ckpt-20000'\n \n parser.add_argument(\"--num-classes\", type=int, default=NUM_CLASSES,\n help=\"Number of classes to predict (including background).\")\n parser.add_argument(\"--save-dir\", type=str, default=SAVE_DIR,\n help=\"Where to save predicted mask.\")\n parser.add_argument(\"--data-list\", type=str, default=DATA_LIST_PATH,\n help=\"Path to the file listing the images in the dataset.\")\n parser.add_argument(\"--data-dir\", type=str, default=DATA_DIRECTORY,\n help=\"Path to the directory containing the PASCAL VOC dataset.\")\n parser.add_argument(\"--ignore-label\", type=int, default=IGNORE_LABEL,\n help=\"The index of the label to ignore during the training.\")\n parser.add_argument(\"--restore-from\", type=str, default=RESTORE_FROM,\n help=\"Where restore model parameters from.\")\n return parser.parse_args()","def main():\n args = arg_parser()\n if(args.gpu):\n gpu = args.gpu\n else:\n print(\"GPU mode not specified, will use the default value - Use GPU\")\n gpu = \"Y\"\n # Device setting:\n device = device_setting(gpu)\n \n # Prepare the datasets and dataloaders:\n print(\"\\nPreparing dataset for train/valid/test ...\")\n train_loader, valid_loader, test_loader, train_data, valid_data, test_data = load_dataset()\n \n # Model architects, criterion and optimizer:\n print(\"\\nNetwork archetecture building ...\")\n model, criterion, optimizer = network(device=device,\n architecture=args.architecture,\n learning_rate=args.learning_rate,\n hidden_size=args.hidden_size,\n dropout=args.dropout,\n output_size=args.output_size)\n \n # Train the model:\n print(\"\\n\")\n model = train(model=model,\n epochs=5,\n learning_rate=args.learning_rate,\n criterion=criterion,\n optimizer=optimizer,\n train_loader=train_loader,\n valid_loader=valid_loader,\n device=device)\n \n # Validate the model performance on the test set:\n print(\"\\nValidate model performance on test set ...\")\n test(model=model, test_loader=test_loader, device=device)\n \n # Save model checkpoint:\n print(\"\\nSave model checkpoint ...\")\n save(model=model, train_data=train_data, epochs=args.epochs, architecture=args.architecture)","def load_args(self):\n\n # retrieve module path\n dir_path = os.path.dirname(os.path.abspath(__file__))\n dir_path = os.path.split(dir_path)[0]\n # get all the default yaml configs with glob\n dir_path = os.path.join(dir_path, 'configs', '*.yml')\n\n # -- From default yapt configuration\n self._defaults_path = {}\n self._defaults_yapt = OmegaConf.create(dict())\n for file in glob.glob(dir_path):\n # split filename from path to create key and val\n key = os.path.splitext(os.path.split(file)[1])[0]\n self._defaults_path[key] = file\n # parse default args\n self._defaults_yapt = OmegaConf.merge(\n self._defaults_yapt, OmegaConf.load(file))\n\n # -- From command line\n self._cli_args = OmegaConf.from_cli()\n if self._cli_args.config is not None:\n self.default_config = self._cli_args.config\n del self._cli_args['config']\n self.console_log.warning(\"override default config with: %s\", self.default_config)\n\n # -- From experiment default config file\n self._default_config_args = OmegaConf.create(dict())\n if self.default_config is not None:\n self._default_config_args = OmegaConf.load(self.default_config)\n\n # -- Merge default args\n self._args = OmegaConf.merge(\n self._defaults_yapt,\n self._default_config_args)\n\n # -- Resolve interpolations to be sure all nodes are explicit\n # self._args = OmegaConf.to_container(self._args, resolve=True)\n # self._args = OmegaConf.create(self._args)\n\n # -- make args structured: it fails if accessing a missing key\n OmegaConf.set_struct(self._args, True)","def main(cli_args=None):\n # build an arg parser\n parser = get_arg_parser()\n\n # run the parser on cli args\n args = parser.parse_args(cli_args)\n\n print(f\"Running script with arguments: {args}\")\n test_input(args.raw_training_data)\n test_input(args.raw_testing_data)\n test_output(args.train_output)\n test_output(args.test_output)","def main(_config, _run):\n sacred.commands.print_config(_run)\n dump_config_and_makefile()\n prepare_and_train()","def parse_arguments_for_single_machine():\n\n # setup command line parser and parse arguments\n parser = argparse.ArgumentParser()\n\n arg_help = 'the path of the point sprite data (positions and intensities)' \n parser.add_argument('--input-directory',\n action='store',\n dest='input_directory',\n help=arg_help)\n \n arg_help = 'the directory where the configuration files will be generated'\n parser.add_argument('--output-directory',\n action='store',\n dest='output_directory',\n help=arg_help)\n\n arg_help = 'the point sprite header file (meta data of the sprite)'\n parser.add_argument('--psh-file',\n action='store', default='NO_FILE_PROVIDED',\n dest='psh_file',\n help=arg_help)\n \n arg_help = 'the data configuration file for the circuit and the sensor'\n parser.add_argument('--data-config-file',\n action='store', default='NO_FILE_PROVIDED',\n dest='data_config_file',\n help=arg_help)\n\n arg_help = 'simulation method, direct-sprite, linear-sprite, ... '\n parser.add_argument('--simulation-method',\n action='store', default='direct-sprite',\n dest='simulation_method',\n help=arg_help)\n\n arg_help = 'the template pbrt sensor configuration file for sprite'\n parser.add_argument('--pbrt-sprite-sensor-config',\n action='store', default='NO_FILE_PROVIDED',\n dest='pbrt_sprite_sensor_config',\n help=arg_help)\n \n arg_help = 'the template pbrt sensor configuration file for volume'\n parser.add_argument('--pbrt-volume-sensor-config',\n action='store', default='NO_FILE_PROVIDED',\n dest='pbrt_volume_sensor_config',\n help=arg_help)\n\n arg_help = 'the path of the pbrt executable that will run the simulation'\n parser.add_argument('--pbrt-executable',\n action='store', default='pbrt', # installed\n dest='pbrt_executable',\n help=arg_help)\n\n arg_help = 'the path of the sprite volumeizer executable that will ' \\\n 'convert the sprite to a volume '\n parser.add_argument('--volumizer-executable',\n action='store', default='volumizesprite', # installed \n dest='volumizer_executable',\n help=arg_help)\n \n arg_help = 'the path of the spritebounds executable that will ' \\\n 'quicky extract the bounds of the sprite to get the sensor data'\n parser.add_argument('--sprite-bounds-executable',\n action='store', default='spritebounds', # installed \n dest='spritebounds_executable',\n help=arg_help)\n\n arg_help = 'resolution of the grid converted from the sprite'\n parser.add_argument('--grid-resolution',\n action='store', default='512',\n dest='grid_resolution',\n help=arg_help)\n\n arg_help = 'running node, cluster or local, cluster by default'\n parser.add_argument('--node',\n action='store', default='cluster',\n dest='node',\n help=arg_help)\n \n arg_help = 'the base (maximum) resolution of the sensor'\n parser.add_argument('--sensor-resolution',\n action='store', default='512', \n dest='sensor_resolution',\n help=arg_help)\n\n # parse the arguments\n args = parser.parse_args()\n \n return args","def _parse_args():\n parser = argparse.ArgumentParser(description='main.py')\n \n # General system running and configuration options\n parser.add_argument('--do_nearest_neighbor', dest='do_nearest_neighbor', default=False, action='store_true', help='run the nearest neighbor model')\n parser.add_argument('--debug', dest='debug', default=False, action='store_true', help='set to debug mode ')\n parser.add_argument('--num_train_sentence', dest='num_train_sentence', type=int, default=-1,\n help='set number of sentence to train on')\n parser.add_argument('--train_path', type=str, default='data/geo_train.tsv', help='path to train data')\n parser.add_argument('--dev_path', type=str, default='data/geo_dev.tsv', help='path to dev data')\n parser.add_argument('--test_path', type=str, default='data/geo_test.tsv', help='path to blind test data')\n parser.add_argument('--test_output_path', type=str, default='geo_test_output.tsv', help='path to write blind test results')\n parser.add_argument('--domain', type=str, default='geo', help='domain (geo for geoquery)')\n parser.add_argument('--attn_model', type=str, default='general', help='Attention model to use: general (default), dot, concat')\n\n # Some common arguments for your convenience\n parser.add_argument('--seed', type=int, default=0, help='RNG seed (default = 0)')\n parser.add_argument('--epochs', type=int, default=100, help='num epochs to train for')\n parser.add_argument('--lr', type=float, default=.001)\n parser.add_argument('--batch_size', type=int, default=2, help='batch size')\n # 65 is all you need for GeoQuery\n parser.add_argument('--decoder_len_limit', type=int, default=65, help='output length limit of the decoder')\n\n # Feel free to add other hyperparameters for your input dimension, etc. to control your network\n # 50-200 might be a good range to start with for embedding and LSTM sizes\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--input-model\", help=\"Path to read input model from\")\n options = parser.parse_args()\n return options","def train_input_args():\n # Create Parse using ArgumentParser\n parser = argparse.ArgumentParser()\n parser.add_argument('data_dir', type = str, help = 'Path to the data directory') \n parser.add_argument('--lr', type = float, default = 0.001, help = 'Learning rate (0.001)') \n parser.add_argument('--model', type = str, default = 'vgg16', help = 'TorchVision VGG model used: vgg19 or (vgg16)') \n parser.add_argument('--hidden', type = int, default = 4096, help = 'Number of hidden units (4096)') \n parser.add_argument('--epochs', type = int, default = 8, help = 'Number of training epochs (8)') \n parser.add_argument('--gpu', type = bool, default = True, help = '(True) = GPU enabled, False = GPU disabled') \n parser.add_argument('--chk', type = str, default = 'checkpoint', help = 'Checkpoint folder name') \n return parser.parse_args()","def add_args(parser):\r\n TransformerModel.add_args(parser)\r\n parser.add_argument(\r\n \"--pretrained-xlm-checkpoint\",\r\n type=str,\r\n metavar=\"STR\",\r\n help=\"XLM model to use for initializing transformer encoder and/or decoder\",\r\n )\r\n parser.add_argument(\r\n \"--init-encoder-only\",\r\n action=\"store_true\",\r\n help=\"if set, don't load the XLM weights and embeddings into decoder\",\r\n )\r\n parser.add_argument(\r\n \"--init-decoder-only\",\r\n action=\"store_true\",\r\n help=\"if set, don't load the XLM weights and embeddings into encoder\",\r\n )","def load_env(data_dir, model_dir):\n model_params = sketch_rnn_model.get_default_hparams()\n with tf.gfile.Open(os.path.join(model_dir, 'model_config.json'), 'r') as f:\n model_params.parse_json(f.read())\n return load_dataset(data_dir, model_params, inference_mode=True)","def add_train_args(parser):\n\n # Runtime environment\n runtime = parser.add_argument_group('Environment')\n runtime.add_argument('--dataset', type=str, default=\"searchqa\",\n help='Dataset: searchqa, quasart or unftriviaqa')\n runtime.add_argument('--base_dir', type=str, default=\".\",\n help='base_dir of the pre-processing')"],"string":"[\n \"def parse_args():\\n hpo_warning = 'Flag overwrites config value if set, used for HPO and PBT runs primarily'\\n parser = argparse.ArgumentParser('train.py')\\n add_arg = parser.add_argument\\n add_arg('config', nargs='?', default='configs/hello.yaml')\\n add_arg('-d', '--distributed', choices=['ddp-file', 'ddp-mpi', 'cray'])\\n add_arg('-v', '--verbose', action='store_true')\\n add_arg('--ranks-per-node', default=8)\\n add_arg('--gpu', type=int)\\n add_arg('--rank-gpu', action='store_true')\\n add_arg('--resume', action='store_true', help='Resume from last checkpoint')\\n add_arg('--show-config', action='store_true')\\n add_arg('--interactive', action='store_true')\\n add_arg('--output-dir', help='override output_dir setting')\\n add_arg('--seed', type=int, default=0, help='random seed')\\n add_arg('--fom', default=None, choices=['last', 'best'],\\n help='Print figure of merit for HPO/PBT')\\n add_arg('--n-train', type=int, help='Override number of training samples')\\n add_arg('--n-valid', type=int, help='Override number of validation samples')\\n add_arg('--batch-size', type=int, help='Override batch size. %s' % hpo_warning)\\n add_arg('--n-epochs', type=int, help='Specify subset of total epochs to run')\\n add_arg('--real-weight', type=float, default=None,\\n help='class weight of real to fake edges for the loss. %s' % hpo_warning)\\n add_arg('--lr', type=float, default=None,\\n help='Learning rate. %s' % hpo_warning)\\n add_arg('--hidden-dim', type=int, default=None,\\n help='Hidden layer dimension size. %s' % hpo_warning)\\n add_arg('--n-graph-iters', type=int, default=None,\\n help='Number of graph iterations. %s' % hpo_warning)\\n add_arg('--weight-decay', type=float)\\n return parser.parse_args()\",\n \"def load_arguments(parser):\\n\\n\\t# paths\\n\\tparser.add_argument('--train_path_src', type=str, required=True, help='train src dir')\\n\\tparser.add_argument('--train_path_tgt', type=str, required=True, help='train tgt dir')\\n\\tparser.add_argument('--path_vocab_src', type=str, required=True, help='vocab src dir')\\n\\tparser.add_argument('--path_vocab_tgt', type=str, required=True, help='vocab tgt dir')\\n\\tparser.add_argument('--dev_path_src', type=str, default=None, help='dev src dir')\\n\\tparser.add_argument('--dev_path_tgt', type=str, default=None, help='dev tgt dir')\\n\\tparser.add_argument('--save', type=str, required=True, help='model save dir')\\n\\tparser.add_argument('--load', type=str, default=None, help='model load dir')\\n\\tparser.add_argument('--load_embedding_src', type=str, default=None, help='pretrained src embedding')\\n\\tparser.add_argument('--load_embedding_tgt', type=str, default=None, help='pretrained tgt embedding')\\n\\tparser.add_argument('--train_attscore_path', type=str, default=None, help='train set reference attention scores')\\n\\tparser.add_argument('--dev_attscore_path', type=str, default=None, help='dev set reference attention scores')\\n\\n\\t# model\\n\\tparser.add_argument('--embedding_size_enc', type=int, default=200, help='encoder embedding size')\\n\\tparser.add_argument('--embedding_size_dec', type=int, default=200, help='decoder embedding size')\\n\\tparser.add_argument('--hidden_size_enc', type=int, default=200, help='encoder hidden size')\\n\\tparser.add_argument('--num_bilstm_enc', type=int, default=2, help='number of encoder bilstm layers')\\n\\tparser.add_argument('--num_unilstm_enc', type=int, default=0, help='number of encoder unilstm layers')\\n\\tparser.add_argument('--hidden_size_dec', type=int, default=200, help='encoder hidden size')\\n\\tparser.add_argument('--num_unilstm_dec', type=int, default=2, help='number of encoder bilstm layers')\\n\\tparser.add_argument('--hard_att', type=str, default='False', help='use hard attention or not')\\n\\tparser.add_argument('--att_mode', type=str, default='bahdanau', \\\\\\n\\t\\t\\t\\t\\t\\t\\thelp='attention mechanism mode - bahdanau / hybrid / dot_prod')\\t\\n\\tparser.add_argument('--hidden_size_att', type=int, default=1, \\\\\\n\\t\\t\\t\\t\\t\\t\\thelp='hidden size for bahdanau / hybrid attention')\\n\\tparser.add_argument('--hidden_size_shared', type=int, default=200, \\\\\\n\\t\\t\\t\\t\\t\\t\\thelp='transformed att output hidden size (set as hidden_size_enc)')\\n\\tparser.add_argument('--additional_key_size', type=int, default=0, \\\\\\n\\t\\t\\t\\t\\t\\t\\thelp='additional attention key size: keys = [values, add_feats]')\\n\\n\\t# train \\n\\tparser.add_argument('--random_seed', type=int, default=666, help='random seed')\\t\\n\\tparser.add_argument('--max_seq_len', type=int, default=32, help='maximum sequence length')\\n\\tparser.add_argument('--batch_size', type=int, default=64, help='batch size')\\t\\n\\tparser.add_argument('--embedding_dropout', type=float, default=0.0, help='embedding dropout')\\n\\tparser.add_argument('--dropout', type=float, default=0.0, help='dropout')\\n\\tparser.add_argument('--num_epochs', type=int, default=10, help='number of training epoches')\\n\\tparser.add_argument('--learning_rate', type=float, default=0.001, help='learning rate')\\n\\tparser.add_argument('--residual', type=str, default='False', help='residual connection')\\n\\tparser.add_argument('--max_grad_norm', type=float, default=1.0, help='optimiser gradient norm clipping: max grad norm')\\t\\n\\tparser.add_argument('--batch_first', type=str, default='True', help='batch as the first dimension')\\n\\tparser.add_argument('--use_gpu', type=str, default='False', help='whether or not using GPU')\\n\\tparser.add_argument('--eval_with_mask', type=str, default='True', help='calc loss excluding padded words')\\n\\tparser.add_argument('--scheduled_sampling', type=str, default='False', \\\\\\n\\t\\t\\t\\t\\t \\t\\thelp='gradually turn off teacher forcing \\\\\\n\\t\\t\\t\\t\\t \\t\\t(if True, use teacher_forcing_ratio as the starting point)')\\n\\n\\t# teacher forcing / attention forcing / dual\\n\\tparser.add_argument('--train_mode', type=str, default='dual', help='train mode; multi | dual | afdynamic')\\n\\tparser.add_argument('--load_tf', type=str, default=None, help='used with train_mode=af; tf model load dir')\\n\\tparser.add_argument('--teacher_forcing_ratio', type=float, default=1.0, help='ratio of teacher forcing')\\n\\tparser.add_argument('--attention_forcing', type=str, default='False', help='whether or not using attention forcing')\\n\\tparser.add_argument('--attention_loss_coeff', type=float, default=1.0, \\\\\\n\\t\\t\\t\\t\\t\\t\\thelp='attention loss coeff, ignored if attention_forcing=False')\\n\\t\\n\\t# save and print\\n\\tparser.add_argument('--checkpoint_every', type=int, default=10, help='save ckpt every n steps')\\t\\n\\tparser.add_argument('--print_every', type=int, default=10, help='print every n steps')\\t\\n\\n\\treturn parser\",\n \"def load_config():\\n parser = argparse.ArgumentParser(description='LTHNet_PyTorch_LinearLoss')\\n parser.add_argument('--dataset', default='imagenet-100-IF1', type=str,\\n help='Dataset name.')\\n parser.add_argument('--root', default='C:\\\\\\\\Users\\\\\\\\dell\\\\\\\\Desktop\\\\\\\\LTH_linearloss\\\\\\\\data\\\\\\\\imagenet100\\\\\\\\', type=str,\\n help='Path of dataset')\\n # parser.add_argument('--root', default='/home/13810427976/notespace/cifar-100/cifar-100-IF20/', type=str,\\n # help='Path of dataset')\\n parser.add_argument('--code-length', default='32,48,64,96', type=str,\\n help='Binary hash code length.(default: 32,48,64,96)')\\n parser.add_argument('--arch', default='resnet34', type=str,\\n help='CNN model name.(default: alexnet)')\\n parser.add_argument('--feature-dim', default=2000, type=int,\\n help='number of classes.(default: 2000)')\\n parser.add_argument('--num-classes', default=100, type=int,\\n help='number of classes.(default: 100)')\\n parser.add_argument('--num-prototypes', default=100, type=int,\\n help='number of prototypes.(default: 100)')\\n parser.add_argument('--batch-size', default=128, type=int,\\n help='Batch size.(default: 128)')\\n parser.add_argument('--lr', default=1e-5, type=float,\\n help='Learning rate.(default: 1e-5)')\\n parser.add_argument('--max-iter', default=100, type=int,\\n help='Number of iterations.(default: 300)')\\n parser.add_argument('--num-workers', default=6, type=int,\\n help='Number of loading data threads.(default: 6)')\\n parser.add_argument('--dynamic-meta-embedding', default=True, type=bool,\\n help='dynamic meta embedding.(default: True)')\\n parser.add_argument('--topk', default=-1, type=int,\\n help='Calculate map of top k.(default: all)')\\n parser.add_argument('--gpu', default=None, type=int,\\n help='Using gpu.(default: False)')\\n parser.add_argument('--beta', default=0.0, type=float,\\n help='Hyper-parameter: class-balanced factor.(default: 0.99)')\\n parser.add_argument('--gamma', default=1.0, type=float,\\n help='Hyper-parameter: balance between pointwise and pairwise loss.(default: 1.0)')\\n parser.add_argument('--seed', default=3367, type=int,\\n help='Random seed.(default: 3367)')\\n parser.add_argument('--evaluate-interval', default=1, type=int,\\n help='Evaluation interval.(default: 10)')\\n\\n args = parser.parse_args()\\n\\n # GPU\\n if args.gpu is None:\\n args.device = torch.device(\\\"cpu\\\")\\n else:\\n os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)\\n args.device = torch.device(\\\"cuda:%d\\\" % 0)\\n\\n # Hash code length\\n args.code_length = list(map(int, args.code_length.split(',')))\\n\\n return args\",\n \"def load_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--batchsize\\\",\\n help=\\\"the batch size of the dataloader\\\",\\n type=int,\\n default=2,\\n required=False)\\n parser.add_argument(\\\"--validsize\\\",\\n help=\\\"percentage that training set split into validation set\\\",\\n type=float,\\n default=1/6,\\n required=False)\\n parser.add_argument(\\\"--input-prefix\\\",\\n help=\\\"file for saving the data (.gz file)\\\",\\n type=str,\\n default=\\\"../mnistPC\\\",\\n required=False)\\n parser.add_argument(\\\"--demo\\\",\\n help=\\\"if demo is true, then only load small number of images\\\",\\n type=bool,\\n default=False,\\n required=False)\\n parser.add_argument(\\\"--test\\\",\\n help=\\\"if test is true, then load data from test dataset\\\",\\n type=bool,\\n default=False,\\n required=False)\\n parser.add_argument(\\\"--epochs\\\",\\n help=\\\"number of epochs\\\",\\n type=int,\\n default=5,\\n required=False)\\n parser.add_argument(\\\"--learning_rate\\\",\\n help=\\\"learning rate of the model\\\",\\n type=float,\\n default=1e-2,\\n required=False)\\n parser.add_argument(\\\"--num_classes\\\",\\n help=\\\"number of classes for classification\\\",\\n type=int,\\n default=10,\\n required=False)\\n parser.add_argument(\\\"--num_neighbors\\\",\\n help=\\\"num of neighbors for the network\\\",\\n type=int,\\n default=15,\\n required=False)\\n parser.add_argument(\\\"--cudas\\\",\\n help=\\\"cuda numbera to use, if use cpu, please enter -1\\\",\\n type=str,\\n default=\\\"0/1/2/3\\\",\\n required=False)\\n args = parser.parse_args()\\n return args\",\n \"def setup():\\n load_from_pretrain = args.pretrained is not None and os.path.exists(args.pretrained)\\n\\n if load_from_pretrain and not args.finetune:\\n cfg_folder = args.pretrained\\n cfg_from_file(os.path.join(cfg_folder, \\\"config.yaml\\\"), reset_model_spec=False)\\n cfg.RL_MODEL_SPEC = os.path.join(cfg_folder, cfg.RL_MODEL_SPEC.split(\\\"/\\\")[-1])\\n dt_string = args.pretrained.split(\\\"/\\\")[-1]\\n \\n else:\\n if args.fix_output_time is None:\\n dt_string = datetime.datetime.now().strftime(\\\"%d_%m_%Y_%H:%M:%S\\\")\\n else:\\n dt_string = args.fix_output_time\\n\\n model_output_dir = os.path.join(cfg.OUTPUT_DIR, dt_string)\\n print(\\\"Output will be saved to `{:s}`\\\".format(model_output_dir))\\n new_output_dir = not os.path.exists(model_output_dir) and not args.test\\n print(\\\"Using config:\\\")\\n pprint.pprint(cfg)\\n net_dict = make_nets_opts_schedulers(cfg.RL_MODEL_SPEC, cfg.RL_TRAIN)\\n print(\\\"Output will be saved to `{:s}`\\\".format(model_output_dir))\\n return net_dict, dt_string\",\n \"def use_args(args):\\n global DATA_PATH\\n global IMAGES_FILE\\n global WORKING_DIR\\n global OUTPUT_DIR\\n global OUTPUT_FILE_NAME\\n global OUTPUT_FILE\\n global LOAD_INDEXES\\n global INDEXES_DIR\\n global MODEL\\n global JOIN_MODELS\\n global MODEL1\\n global MODEL2\\n global ALL_TOGETHER\\n global TRAINED_MODELS\\n global TRAINED_MODELS_DIR\\n global TRAINED_MODELS_DIR2\\n global TRAINED_MODELS_DIRS\\n global CROSS_VALIDATION\\n global TRAIN_EPOCHS\\n global FEATURES\\n \\n if args.data_path:\\n # Change the default path of the images\\n DATA_PATH = args.data_path\\n IMAGES_FILE = os.path.join(DATA_PATH, IMAGES_FILE_NAME)\\n \\n if args.working_dir:\\n # Change the default path of the working directory\\n WORKING_DIR = args.working_dir\\n OUTPUT_DIR = WORKING_DIR\\n OUTPUT_FILE = os.path.join(OUTPUT_DIR, OUTPUT_FILE_NAME)\\n \\n if args.output_dir:\\n # Change the default path of the output directory\\n OUTPUT_DIR = os.path.join(WORKING_DIR, args.output_dir)\\n OUTPUT_FILE = os.path.join(OUTPUT_DIR, OUTPUT_FILE_NAME)\\n \\n if args.output:\\n # Change the default name of the output file\\n OUTPUT_FILE_NAME = args.output\\n OUTPUT_FILE = os.path.join(OUTPUT_DIR, OUTPUT_FILE_NAME)\\n \\n if args.indexes_dir:\\n # Load random and train indexes from file\\n LOAD_INDEXES = True\\n INDEXES_DIR = args.indexes_dir\\n \\n if args.model:\\n # Select model\\n MODEL = args.model\\n \\n if args.models:\\n \\n if not args.trained_models_dirs:\\n raise Exception(\\\"Arg. `-M --models` requires arg. \\\"\\n + \\\"`-T --trained_models_dirs`\\\")\\n \\n # Models to combine\\n JOIN_MODELS = True\\n MODEL1 = args.models[0]\\n MODEL2 = args.models[1]\\n \\n if args.trained_models_dir:\\n # Load trained models from file\\n TRAINED_MODELS = True\\n TRAINED_MODELS_DIR = args.trained_models_dir\\n \\n if args.trained_models_dirs:\\n # Load trained models from file\\n TRAINED_MODELS = True\\n TRAINED_MODELS_DIR = args.trained_models_dirs[0]\\n TRAINED_MODELS_DIR2 = args.trained_models_dirs[1]\\n \\n if args.all_together:\\n # The four models together\\n ALL_TOGETHER = True\\n TRAINED_MODELS_DIRS = args.all_together\\n \\n if args.cross_validation:\\n # Activate cross_validation\\n CROSS_VALIDATION = True\\n \\n if args.train_epochs:\\n # Change the default number of train epochs\\n TRAIN_EPOCHS = args.train_epochs\\n \\n if args.features:\\n # Nuber of best features to use\\n FEATURES = args.features\",\n \"def setup(args):\\n cfg = get_cfg()\\n\\n cfg.merge_from_file(model_zoo.get_config_file(\\\"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml\\\"))\\n cfg.merge_from_list(args.opts)\\n\\n # configs for training\\n if args.small_vidor: # cfg.DATASETS.VIDOR.SIZE == 'small':\\n cfg.DATASETS.TRAIN = (\\\"vidor_small_train\\\",)\\n elif args.small_vidor_10imgs: # cfg.DATASETS.VIDOR.SIZE == 'small-10imgs':\\n cfg.DATASETS.TRAIN = (\\\"vidor_small_10imgs_train\\\",)\\n else:\\n cfg.DATASETS.TRAIN = (\\\"vidor_large_train\\\",)\\n # cfg.DATALOADER.NUM_WORKERS = 2\\n if not args.eval_only:\\n cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(\\\"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml\\\") # Let training initialize from model zoo\\n factor = 4\\n cfg.SOLVER.IMS_PER_BATCH = 16 * factor\\n cfg.SOLVER.BASE_LR = 0.0001 * factor # finetune using 10x smaller base_lr\\n cfg.SOLVER.MAX_ITER = 270000 // factor \\n cfg.SOLVER.STEPS = [210000 // factor, 250000 // factor]\\n # cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 # default: 512\\n cfg.MODEL.ROI_HEADS.NUM_CLASSES = 78\\n\\n # configs for testing\\n # cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, \\\"model_final.pth\\\")\\n if args.small_vidor: # cfg.DATASETS.VIDOR.SIZE == 'small':\\n cfg.DATASETS.TEST = (\\\"vidor_small_val\\\",)\\n elif args.small_vidor_10imgs: # cfg.DATASETS.VIDOR.SIZE == 'small-10imgs':\\n cfg.DATASETS.TEST = (\\\"vidor_small_10imgs_val\\\",)\\n else:\\n cfg.DATASETS.TEST = (\\\"vidor_large_val\\\",)\\n # cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5\\n\\n # cfg.OUTPUT_DIR = './output/train_vidor_with_pseudo_labels'\\n \\n \\n if not args.eval_only:\\n os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)\\n cfg.freeze()\\n default_setup(cfg, args)\\n return cfg\",\n \"def main():\\n config = handle_args()\\n print(config)\\n\\n if config['mode'] == 'train':\\n logger.info('Train mode')\\n trainer = Trainer(config, shared_theano_params=None, **config)\\n trainer.train(**config)\\n logger.warn('Exiting train mode')\\n else:\\n logger.info('Test mode')\\n translator = Translator(**config)\\n translator.load_from_disk(config['models'], config['configs'],\\n config['src_dicts'], config['trg_dict'])\\n translator.translate_and_save(**config)\",\n \"def setup(args):\\n cfg = get_cfg()\\n cfg.merge_from_file(args.config_file)\\n cfg.merge_from_list(args.opts)\\n # customize reszied parameters\\n # cfg['INPUT']['MIN_SIZE_TRAIN'] = (20,)\\n # cfg['INPUT']['MAX_SIZE_TRAIN'] = 50\\n cfg.freeze()\\n default_setup(\\n cfg, args\\n ) # if you don't like any of the default setup, write your own setup code\\n return cfg\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--identifier\\\", required=True,\\n help=\\\"A short name/identifier for your experiment, e.g. 'ex42b'.\\\")\\n args = parser.parse_args()\\n\\n train(args)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser('Reading Comprehension on HOTPOT dataset')\\n parser.add_argument('--prepare', action='store_true',\\n help='create the directories, prepare the vocabulary and embeddings')\\n parser.add_argument('--train', action='store_true',\\n help='train the model')\\n parser.add_argument('--evaluate', action='store_true',\\n help='evaluate the model on dev set')\\n parser.add_argument('--predict', action='store_true',\\n help='predict the answers for test set with trained model')\\n parser.add_argument('--gpu', type=str, default='0',\\n help='specify gpu device')\\n\\n train_settings = parser.add_argument_group('train settings')\\n train_settings.add_argument('--mode', type=str,\\n default='D-graph',\\n help='fine-tune or D-graph')\\n train_settings.add_argument('--Bert_model', type=str,\\n default='bert-base-uncased',\\n help='model of Bert')\\n train_settings.add_argument('--at_head', type=int,\\n default=1,\\n help='The head for graph neural network.')\\n train_settings.add_argument('--propagate_count',type=int,default=3,\\n help='The number of propagating in graph neural network')\\n train_settings.add_argument('--optim', default='adam',\\n help='optimizer type')\\n train_settings.add_argument('--learning_rate', type=float, default=0.001,\\n help='learning rate')\\n train_settings.add_argument('--weight_decay', type=float, default=0,\\n help='weight decay')\\n train_settings.add_argument('--dropout_keep_prob', type=float, default=1,\\n help='dropout keep rate')\\n train_settings.add_argument('--batch_size', type=int, default=12,\\n help='train batch size')\\n train_settings.add_argument('--epochs', type=int, default=1,\\n help='train epochs')\\n train_settings.add_argument('--gradient_accumulation_steps', type=int, default=1,\\n help='gradient accumulation steps')\\n\\n model_settings = parser.add_argument_group('model settings')\\n model_settings.add_argument('--max_s_num', type=int, default=6,\\n help='max sentence num in one paragraph')\\n model_settings.add_argument('--max_p_len', type=int, default=491,\\n help='max length of paragraph')\\n model_settings.add_argument('--max_s_len', type=int, default=70,\\n help='max length of sentence')\\n\\n path_settings = parser.add_argument_group('path settings')\\n\\n path_settings.add_argument('--train_files', nargs='+',\\n default=['./data/hotpot_train_v1.1_small_refine.json'],\\n help='list of files that contain the preprocessed train data')\\n path_settings.add_argument('--dev_files', nargs='+',\\n default=['./data/hotpot_dev_fullwiki_v1_refine.json'],\\n help='list of files that contain the preprocessed dev data')\\n path_settings.add_argument('--test_files', nargs='+',\\n default=['./data/hotpot_test_fullwiki_v1_refine.json'],\\n help='list of files that contain the preprocessed test data')\\n path_settings.add_argument('--vocab_dir', default='./vocab/',\\n help='the dir to save vocabulary')\\n path_settings.add_argument('--model_dir', default='./models/',\\n help='the dir to store models')\\n path_settings.add_argument('--result_dir', default='./result/',\\n help='the dir to output the results')\\n path_settings.add_argument('--log_path',\\n help='path of the log file. If not set, logs are printed to console')\\n return parser.parse_args()\",\n \"def main(args):\\n\\n # Labels to be used in the experiment.\\n task_ids = {Labels.hotness.value: LossTypes.mse,\\n Labels.tempo.value: LossTypes.mse,\\n Labels.loudness.value: LossTypes.mse}\\n\\n # Get the training, validation and testing set data and ground-truths\\n x_train, x_validate, x_test, y_train, y_validate, y_test = fetch_data(task_ids)\\n\\n exp = Experiment(expt_name=args.experiment_name, task_ids=task_ids, x_train=x_train, x_validate=x_validate,\\n x_test=x_test, y_train=y_train, y_validate=y_validate, y_test=y_test,\\n model_class=LowLevelSharingModel, learning_rate=args.learning_rate,\\n batch_size=args.batch_size, num_epochs=args.num_epochs)\\n exp.initialize_network()\\n exp.train()\\n sys.stderr.write(\\\"------\\\\n\\\")\\n sys.stderr.write(\\\"Training complete. Logs, outputs, and model saved in \\\" + os.getcwd() + \\\"\\\\n\\\")\",\n \"def setup():\\n # Parse the command line arguments\\n args = parse_arguments()\\n\\n # Load training configurations\\n config = load_yaml(args.config)\\n update_not_none(config, vars(args))\\n\\n # Setup experiment directories and update them to configurations\\n setup_dirs(config)\\n\\n # Setup loggers\\n del logging.getLogger('tensorflow').handlers[0]\\n setup_loggers(config['log_dir'])\\n\\n # Setup GPUs\\n os.environ[\\\"CUDA_VISIBLE_DEVICES\\\"] = config['gpu']\\n\\n # Backup source code\\n backup_src(config['src_dir'])\\n\\n return config\",\n \"def main():\\n parser = argparse.ArgumentParser(description='Paperboy deep learning launcher')\\n\\n parser.add_argument('config', metavar='FILENAME', help='Configuration file for the run')\\n parser.add_argument('command', metavar='COMMAND', help='A command to run')\\n parser.add_argument('varargs', nargs='*', metavar='VARARGS', help='Extra options to the command')\\n parser.add_argument('-r', '--run_number', type=int, default=0, help=\\\"A run number\\\")\\n parser.add_argument('-d', '--device', default='cuda', help=\\\"A device to run the model on\\\")\\n parser.add_argument('-s', '--seed', type=int, default=None, help=\\\"Random seed for the project\\\")\\n parser.add_argument(\\n '-p', '--param', type=str, metavar='NAME=VALUE', action='append', default=[],\\n help=\\\"Configuration parameters\\\"\\n )\\n parser.add_argument(\\n '--continue', action='store_true', default=False, help=\\\"Continue previously started learning process\\\"\\n )\\n parser.add_argument(\\n '--profile', type=str, default=None, help=\\\"Profiler output\\\"\\n )\\n\\n args = parser.parse_args()\\n\\n model_config = ModelConfig.from_file(\\n args.config, args.run_number, continue_training=getattr(args, 'continue'), device=args.device, seed=args.seed,\\n params={k: v for (k, v) in (Parser.parse_equality(eq) for eq in args.param)}\\n )\\n\\n if model_config.project_dir not in sys.path:\\n sys.path.append(model_config.project_dir)\\n\\n multiprocessing_setting = model_config.provide_with_default('multiprocessing', default=None)\\n\\n if multiprocessing_setting:\\n # This needs to be called before any of PyTorch module is imported\\n multiprocessing.set_start_method(multiprocessing_setting)\\n\\n # Set seed already in the launcher\\n from vel.util.random import set_seed\\n set_seed(model_config.seed)\\n\\n model_config.banner(args.command)\\n\\n if args.profile:\\n print(\\\"[PROFILER] Running Vel in profiling mode, output filename={}\\\".format(args.profile))\\n import cProfile\\n import pstats\\n profiler = cProfile.Profile()\\n profiler.enable()\\n model_config.run_command(args.command, args.varargs)\\n profiler.disable()\\n\\n profiler.dump_stats(args.profile)\\n profiler.print_stats(sort='tottime')\\n\\n print(\\\"======================================================================\\\")\\n pstats.Stats(profiler).strip_dirs().sort_stats('tottime').print_stats(30)\\n print(\\\"======================================================================\\\")\\n pstats.Stats(profiler).strip_dirs().sort_stats('cumtime').print_stats(30)\\n else:\\n model_config.run_command(args.command, args.varargs)\\n\\n model_config.quit_banner()\",\n \"def set_defaults(args):\\n # Check critical files exist\\n args.train_file = os.path.join(args.data_dir, args.train_file)\\n if not os.path.isfile(args.train_file):\\n raise IOError('No such file: %s' % args.train_file)\\n args.dev_file = os.path.join(args.data_dir, args.dev_file)\\n if not os.path.isfile(args.dev_file):\\n raise IOError('No such file: %s' % args.dev_file)\\n if args.embedding_file:\\n args.embedding_file = os.path.join(args.embed_dir, args.embedding_file)\\n if not os.path.isfile(args.embedding_file):\\n raise IOError('No such file: %s' % args.embedding_file)\\n\\n # Set model directory\\n subprocess.call(['mkdir', '-p', args.model_dir])\\n\\n # Set model name\\n if not args.model_name:\\n import uuid\\n import time\\n args.model_name = time.strftime(\\\"%Y%m%d-\\\") + str(uuid.uuid4())[:8]\\n\\n # Set log + model file names\\n args.log_file = os.path.join(args.model_dir, args.model_name + '.txt')\\n args.model_file = os.path.join(args.model_dir, args.model_name + '.pt')\\n\\n # Embeddings options\\n if args.embedding_file:\\n with open(args.embedding_file) as f:\\n dim = len(f.readline().strip().split(' ')) - 1\\n args.embedding_dim = dim\\n elif not args.embedding_dim:\\n raise RuntimeError('Either embedding_file or embedding_dim '\\n 'needs to be specified.')\\n\\n # Make sure fix_embeddings and embedding_file are consistent\\n if args.fix_embeddings:\\n if not (args.embedding_file or args.pretrained):\\n logger.warning('WARN: fix_embeddings set to False '\\n 'as embeddings are random.')\\n args.fix_embeddings = False\\n return args\",\n \"def parse_params():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-c\\\", \\\"--config\\\",\\n help=\\\"Specify config file\\\", metavar=\\\"FILE\\\")\\n args, remaining_argv = parser.parse_known_args()\\n default_config_path = \\\"config/default.yaml\\\"\\n if args.config:\\n config = yaml.load(open(args.config))\\n default_config_path = config.get('default_config', default_config_path)\\n\\n default_config = yaml.load(open(default_config_path))\\n default_config = update(default_config, config)\\n parser.set_defaults(**default_config)\\n # Command line arguments - easy access\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\", type=int,\\n default=1, help=\\\"code verbosity\\\")\\n parser.add_argument(\\\"-g\\\", \\\"--gpu_id\\\", type=str,\\n default='0', help=\\\"gpu id\\\")\\n\\n args = parser.parse_args(remaining_argv)\\n # mkdir the model save directory\\n args.eventname = 'events/' + args.modelname\\n args.modelname = 'save/' + args.modelname\\n # Make sure the dirs exist:\\n if not osp.exists(args.eventname):\\n os.makedirs(args.eventname)\\n if not osp.exists(args.modelname):\\n os.makedirs(args.modelname)\\n # Create the logger\\n logger = create_logger(args.modelname, '%s/train.log' % args.modelname)\\n args = vars(args)\\n # parse list params #TODO check syntax for yaml directly\\n if \\\"network\\\" in args:\\n if \\\"num_layers\\\" in args['network']:\\n num_layers = read_list(args['network']['num_layers'])\\n if \\\"kernels\\\" in args['network']:\\n kernels = read_list(args['network']['kernels'])\\n if len(kernels) == 1:\\n args['network']['kernels'] = kernels * len(num_layers)\\n else:\\n assert len(kernels) == len(num_layers), \\\"the number of kernel sizes must match that of the network layers\\\"\\n args[\\\"network\\\"][\\\"kernels\\\"] = kernels\\n\\n args['network']['num_layers'] = num_layers\\n\\n return args\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n subparsers = parser.add_subparsers(dest='mode')\\n\\n # Add sub-parser for feature extraction\\n parser_extract = subparsers.add_parser('extract')\\n parser_extract.add_argument('dataset',\\n choices=['training', 'validation', 'test'],\\n )\\n\\n # Add sub-parser for training\\n subparsers.add_parser('train')\\n\\n # Add sub-parser for inference\\n parser_predict = subparsers.add_parser('predict')\\n parser_predict.add_argument('dataset',\\n nargs='?',\\n choices=['validation', 'test'],\\n default='test',\\n )\\n\\n # Add sub-parser for evaluation\\n parser_evaluate = subparsers.add_parser('evaluate')\\n parser_evaluate.add_argument('task',\\n nargs='?',\\n choices=['tagging', 'sed', 'all'],\\n default='all',\\n )\\n parser_evaluate.add_argument('dataset',\\n nargs='?',\\n choices=['validation', 'test'],\\n default='test',\\n )\\n parser_evaluate.add_argument('--thresholds', action='store_true')\\n\\n args = parser.parse_args()\\n\\n if args.mode == 'extract':\\n extract(cfg.to_dataset(args.dataset))\\n elif args.mode == 'train':\\n train()\\n elif args.mode == 'predict':\\n predict(cfg.to_dataset(args.dataset))\\n elif args.mode == 'evaluate':\\n eval_all = args.task == 'all'\\n dataset = cfg.to_dataset(args.dataset)\\n if args.task == 'tagging' or eval_all:\\n evaluate_audio_tagging(dataset, args.thresholds)\\n if args.task == 'sed' or eval_all:\\n evaluate_sed(dataset)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser('train.py')\\n add_arg = parser.add_argument\\n add_arg('config', nargs='?', default='configs/hello.yaml')\\n add_arg('-d', '--distributed', choices=['ddp-file', 'ddp-mpi', 'cray'])\\n add_arg('-v', '--verbose', action='store_true')\\n add_arg('--ranks-per-node', default=8)\\n add_arg('--gpu', type=int)\\n add_arg('--rank-gpu', action='store_true')\\n add_arg('--resume', action='store_true', help='Resume from last checkpoint')\\n add_arg('--show-config', action='store_true')\\n add_arg('--interactive', action='store_true')\\n add_arg('--output-dir', help='override output_dir setting')\\n add_arg('--seed', type=int, default=0, help='random seed')\\n return parser.parse_args()\",\n \"def main(command_line_parameters=None):\\n args = command_line_arguments(command_line_parameters)\\n\\n logger.debug(\\\"Loading preprocessor\\\")\\n preprocessor = bob.bio.base.load_resource(' '.join(args.preprocessor), \\\"preprocessor\\\")\\n logger.debug(\\\"Loading extractor\\\")\\n extractor = bob.bio.base.load_resource(' '.join(args.extractor), \\\"extractor\\\")\\n if extractor.requires_training:\\n if args.extractor_file is None:\\n raise ValueError(\\\"The desired extractor requires a pre-trained extractor file, but it was not specified\\\")\\n extractor.load(args.extractor_file)\\n\\n logger.debug(\\\"Loading preprocessed data from file '%s'\\\", args.input_file)\\n preprocessed = preprocessor.read_data(args.input_file)\\n\\n logger.info(\\\"Extracting features\\\")\\n extracted = extractor(preprocessed)\\n extractor.write_feature(extracted, args.output_file)\\n logger.info(\\\"Wrote extracted features to file '%s'\\\", args.output_file)\",\n \"def add_train_args(parser):\\n parser.register('type', 'bool', str2bool)\\n # Runtime environment\\n runtime = parser.add_argument_group('Environment')\\n runtime.add_argument('--no-cuda', type='bool', default=False,\\n help='Train on CPU, even if GPUs are available.')\\n runtime.add_argument('--gpu', type=int, default=-1,\\n help='Run on a specific GPU')\\n runtime.add_argument('--data-workers', type=int, default=5,\\n help='Number of subprocesses for data loading')\\n runtime.add_argument('--random-seed', type=int, default=1013,\\n help=('Random seed for all numpy/torch/cuda '\\n 'operations (for reproducibility)'))\\n runtime.add_argument('--num-epochs', type=int, default=40,\\n help='Train data iterations')\\n runtime.add_argument('--batch-size', type=int, default=32,\\n help='Batch size for training')\\n runtime.add_argument('--dev-batch-size', type=int, default=16,\\n help='Batch size for training')\\n\\n # Files\\n files = parser.add_argument_group('Filesystem')\\n files.add_argument('--model-dir', type=str, default=MODEL_DIR,\\n help='Directory for saved models/checkpoints/logs')\\n files.add_argument('--model-name', type=str, default='',\\n help='Unique model identifier (.mdl, .txt, .checkpoint)')\\n files.add_argument('--data-dir', type=str, default=DATA_DIR,\\n help='Directory of training/validation data')\\n files.add_argument('--train-file', type=str,\\n default='train_processed.jsonl',\\n help='Preprocessed train file')\\n files.add_argument('--dev-file', type=str,\\n default='dev_processed.jsonl',\\n help='Preprocessed dev file')\\n files.add_argument('--embed-dir', type=str, default=EMBED_DIR,\\n help='Directory of pre-trained embedding files')\\n files.add_argument('--embedding-file', type=str,\\n default='glove.840B.300d.txt',\\n help='Space-separated pretrained embeddings file')\\n\\n # Saving + loading\\n save_load = parser.add_argument_group('Saving/Loading')\\n save_load.add_argument('--checkpoint', type='bool', default=False,\\n help='Save model + optimizer state after each epoch')\\n save_load.add_argument('--pretrained', type=str, default='',\\n help='Path to a pretrained model to warm-start with')\\n\\n # General\\n general = parser.add_argument_group('General')\\n general.add_argument('--display-iter', type=int, default=25,\\n help='Log state after every <display_iter> epochs')\\n general.add_argument('--display-samples', type='bool', default=True,\\n help='Display top 5 samples in validation process.')\\n general.add_argument('--sort-by-len', type='bool', default=True,\\n help='Sort batches by length for speed')\\n \\n # Model architecture\\n model = parser.add_argument_group('Model Architecture')\\n model.add_argument('--decoder-type', type=str, default='copy',\\n help='Decoder architecture type')\\n model.add_argument('--vocab-limit', type=int, default=-1,\\n help='Limit for vocab creation')\\n model.add_argument('--use-extended-vocab', type='bool', default=True,\\n help='Use extended vocab for copying')\\n model.add_argument('--embedding-dim', type=int, default=300,\\n help='Embedding size if embedding_file is not given')\\n model.add_argument('--hidden-size', type=int, default=128,\\n help='Hidden size of RNN units')\\n model.add_argument('--rnn-type', type=str, default='lstm',\\n help='RNN type: LSTM, GRU, or RNN')\\n\\n # Optimization details\\n optim = parser.add_argument_group('Optimization')\\n optim.add_argument('--optimizer', type=str, default='adam',\\n help='Optimizer: sgd or adam')\\n optim.add_argument('--learning-rate', type=float, default=0.1,\\n help='Learning rate')\\n optim.add_argument('--weight-decay', type=float, default=0,\\n help='Weight decay factor')\\n optim.add_argument('--momentum', type=float, default=0,\\n help='Momentum factor')\\n optim.add_argument('--fix-embeddings', type='bool', default=True,\\n help='Keep word embeddings fixed (use pretrained)')\\n optim.add_argument('--rnn-padding', type='bool', default=False,\\n help='Explicitly account for padding in RNN encoding')\\n optim.add_argument('--max-length', type=int, default=30,\\n help='The max span allowed during decoding')\",\n \"def setup(args):\\n cfg = get_cfg()\\n\\n cfg.merge_from_file(model_zoo.get_config_file(args.model_zoo))\\n cfg.DATASETS.TRAIN = (args.train_dataset, )\\n cfg.DATASETS.TEST = (args.test_dataset, )\\n cfg.DATALOADER.NUM_WORKERS = args.num_workers\\n cfg.OUTPUT_DIR = args.output_dir\\n os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)\\n\\n cfg.image_w = args.size[0]\\n cfg.image_h = args.size[1]\\n\\n cfg.MODEL.WEIGHTS = args.model_zoo_weights\\n cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = args.roi_thresh # set a custom testing threshold\\n\\n default_setup(cfg, args)\\n return cfg\",\n \"def cli(sys_argv: List[str]):\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument('--model_definition', type=str,\\n help='Path to json model definition')\\n\\n parser.add_argument('--model_state_path', type=str,\\n help='Path where to the trained parameters')\\n\\n parser.add_argument('--data_path', type=str, default=TEST_PATH,\\n help='path to the pickled dataframe on which prediction should be made')\\n\\n parser.add_argument('--numerical_preprocessor', type=str, default=NUMERICAL_PREPROCESSOR_SAVE_PATH,\\n help='Path of the saved numerical preprocessor')\\n\\n parser.add_argument('--categorical_preprocessor', type=str, default=CATEGORICAL_PREPROCESSOR_SAVE_PATH,\\n help='Path to the saved categorical preprocessor')\\n\\n parser.add_argument('--output_directory', type=str, default=RESULTS_DIR,\\n help='Path where to save the prediction of the experiment')\\n\\n args = parser.parse_args(sys_argv)\\n\\n # # ---------- parse config file ---------- # #\\n config: dict = json.load(open(args.model_definition, 'r'))\\n\\n model_class: str = config['model_class']\\n model_name: str = config['model_name']\\n numerical_input_features: List[str] = config['data']['numerical_input_features']\\n categorical_input_features: List[str] = config['data']['categorical_input_features']\\n output_features: List[str] = config['data']['output_features']\\n batch_size_test: int = config['data']['batch_size_test']\\n\\n device = torch.device(CUDA if torch.cuda.is_available() else CPU)\\n\\n # # ---------- parse model state ---------- # #\\n model_state = load_model_state(args.model_state_path, device)\\n\\n model_hyperparameters: dict = model_state['hyperparameters']\\n model_hyperparameters.update(config['model'])\\n model_hyperparameters['device']: torch.device = device\\n model_weights: dict = model_state['best_model_state_dict']\\n\\n # # ---------- initialize model ---------- # #\\n model = REGISTERED_MODELS[model_class](**model_hyperparameters).to(device)\\n model.load(model_weights)\\n\\n # # ---------- preprocess data for inference ---------- # #\\n test_loader = preprocess_for_inference(\\n args.data_path,\\n numerical_input_features,\\n categorical_input_features,\\n output_features,\\n args.numerical_preprocessor,\\n args.categorical_preprocessor,\\n batch_size_test=batch_size_test\\n )\\n\\n # # ---------- compute and save predictions ---------- # #\\n predictions = model.predict(test_loader)\\n\\n # save predictions\\n data_file_name = os.path.basename(args.data_path)\\n data_file_name = os.path.splitext(data_file_name)[0] # remove extension\\n model_path = '{}/predictions_{}_{}.pickle'.format(args.output_directory, model_name, data_file_name)\\n print(' [predict] Saving predictions at: `{}`'.format(model_path))\\n file_utils.save_to_pickle(\\n predictions,\\n path=model_path\\n )\\n print(' [predict] Done')\",\n \"def main(args):\\n # ------------------------\\n # 1 INIT LIGHTNING MODEL\\n # ------------------------\\n model = LightningTemplateModel(**vars(args))\\n\\n # ------------------------\\n # 2 INIT TRAINER\\n # ------------------------\\n trainer = Trainer.from_argparse_args(args)\\n\\n # ------------------------\\n # 3 START TRAINING\\n # ------------------------\\n trainer.fit(model)\",\n \"def train(args):\\n print(args)\\n\\n # Run a training job\\n configs = LuxMatchConfigs_Default\\n\\n # Create a default opponent agent\\n opponent = Agent()\\n\\n # Create a RL agent in training mode\\n player = AgentPolicy(mode=\\\"train\\\")\\n\\n # Train the model\\n env_eval = None\\n if args.n_envs == 1:\\n env = LuxEnvironment(configs=configs,\\n learning_agent=player,\\n opponent_agent=opponent)\\n else:\\n env = SubprocVecEnv([make_env(LuxEnvironment(configs=configs,\\n learning_agent=AgentPolicy(mode=\\\"train\\\"),\\n opponent_agent=opponent), i) for i in range(args.n_envs)])\\n \\n run_id = args.id\\n print(\\\"Run id %s\\\" % run_id)\\n\\n if args.path:\\n # by default previous model params are used (lr, batch size, gamma...)\\n model = PPO.load(args.path)\\n model.set_env(env=env)\\n\\n # Update the learning rate\\n model.lr_schedule = get_schedule_fn(args.learning_rate)\\n\\n # TODO: Update other training parameters\\n else:\\n model = PPO(\\\"MlpPolicy\\\",\\n env,\\n verbose=1,\\n tensorboard_log=\\\"./lux_tensorboard/\\\",\\n learning_rate=args.learning_rate,\\n gamma=args.gamma,\\n gae_lambda=args.gae_lambda,\\n batch_size=args.batch_size,\\n n_steps=args.n_steps\\n )\\n\\n \\n \\n callbacks = []\\n\\n # Save a checkpoint and 5 match replay files every 100K steps\\n player_replay = AgentPolicy(mode=\\\"inference\\\", model=model)\\n callbacks.append(\\n SaveReplayAndModelCallback(\\n save_freq=100000,\\n save_path='./models/',\\n name_prefix=f'model{run_id}',\\n replay_env=LuxEnvironment(\\n configs=configs,\\n learning_agent=player_replay,\\n opponent_agent=Agent()\\n ),\\n replay_num_episodes=5\\n )\\n )\\n \\n # Since reward metrics don't work for multi-environment setups, we add an evaluation logger\\n # for metrics.\\n if args.n_envs > 1:\\n # An evaluation environment is needed to measure multi-env setups. Use a fixed 4 envs.\\n env_eval = SubprocVecEnv([make_env(LuxEnvironment(configs=configs,\\n learning_agent=AgentPolicy(mode=\\\"train\\\"),\\n opponent_agent=opponent), i) for i in range(4)])\\n\\n callbacks.append(\\n EvalCallback(env_eval, best_model_save_path=f'./logs_{run_id}/',\\n log_path=f'./logs_{run_id}/',\\n eval_freq=args.n_steps*2, # Run it every 2 training iterations\\n n_eval_episodes=30, # Run 30 games\\n deterministic=False, render=False)\\n )\\n\\n print(\\\"Training model...\\\")\\n model.learn(total_timesteps=args.step_count,\\n callback=callbacks)\\n if not os.path.exists(f'models/rl_model_{run_id}_{args.step_count}_steps.zip'):\\n model.save(path=f'models/rl_model_{run_id}_{args.step_count}_steps.zip')\\n print(\\\"Done training model.\\\")\\n\\n # Inference the model\\n print(\\\"Inference model policy with rendering...\\\")\\n saves = glob.glob(f'models/rl_model_{run_id}_*_steps.zip')\\n latest_save = sorted(saves, key=lambda x: int(x.split('_')[-2]), reverse=True)[0]\\n model.load(path=latest_save)\\n obs = env.reset()\\n for i in range(600):\\n action_code, _states = model.predict(obs, deterministic=True)\\n obs, rewards, done, info = env.step(action_code)\\n if i % 5 == 0:\\n print(\\\"Turn %i\\\" % i)\\n env.render()\\n\\n if done:\\n print(\\\"Episode done, resetting.\\\")\\n obs = env.reset()\\n print(\\\"Done\\\")\\n\\n '''\\n # Learn with self-play against the learned model as an opponent now\\n print(\\\"Training model with self-play against last version of model...\\\")\\n player = AgentPolicy(mode=\\\"train\\\")\\n opponent = AgentPolicy(mode=\\\"inference\\\", model=model)\\n env = LuxEnvironment(configs, player, opponent)\\n model = PPO(\\\"MlpPolicy\\\",\\n env,\\n verbose=1,\\n tensorboard_log=\\\"./lux_tensorboard/\\\",\\n learning_rate = 0.0003,\\n gamma=0.999,\\n gae_lambda = 0.95\\n )\\n model.learn(total_timesteps=2000)\\n env.close()\\n print(\\\"Done\\\")\\n '''\",\n \"def main(args: argparse.Namespace, config: Config) -> None:\\n # Notes:\\n # - 1878 is the number of unique answers from the GQA paper\\n # - 1843 is the number of answers across train, val and testdev\\n\\n # Download and initialise resources\\n print(colored(\\\"initialisation:\\\", attrs=[\\\"bold\\\"]))\\n stanza.download(lang=\\\"en\\\", dir=\\\".stanza\\\")\\n\\n # Print environment info\\n print(colored(\\\"environment:\\\", attrs=[\\\"bold\\\"]))\\n cuda = torch.cuda.is_available()\\n device = torch.device(\\\"cuda\\\" if cuda else \\\"cpu\\\")\\n print(f\\\"device: {torch.cuda.get_device_name(device) if cuda else 'CPU'}\\\")\\n print(config)\\n\\n if args.job == JobType.PREPROCESS:\\n preprocess(config)\\n elif args.job in (JobType.TRAIN, JobType.PREDICT):\\n resume = None\\n if args.resume != \\\"\\\":\\n run_id, checkpoint = args.resume.split(\\\":\\\")\\n resume = ResumeInfo(run_id, checkpoint)\\n if args.job == JobType.TRAIN:\\n train(config, device, resume)\\n else:\\n predict(config, device, resume)\\n else:\\n raise NotImplementedError()\",\n \"def run():\\n print('*-----------------------------------*')\\n print('Running main.py ...')\\n model = MLPModel(CFG, name='tfds_tryout')\\n print('* Model defined')\\n model.load_data(method='tfds')\\n print('* Data Loaded')\\n print(model.datasetinfo)\\n model.build()\\n model.train()\\n model.evaluate()\\n model.save()\",\n \"def parse_args(args):\\n assert os.path.isfile(args.data_path), \\\"The specified data file does not exist.\\\"\\n assert os.path.isfile(args.model_path), \\\"The specified model file does not exist.\\\"\\n\\n if args.read_batches is not False:\\n if args.read_batches.lower() in (\\\"y\\\", \\\"yes\\\", \\\"1\\\", \\\"\\\", \\\"true\\\", \\\"t\\\"):\\n args.read_batches = True\\n else:\\n args.read_batches = False\",\n \"def setup_training(args: argparse.Namespace) -> None:\\n # 1. Read hyperparameters from file\\n hp = HParams.from_yaml(args.path_config)\\n # check if GPU available and add it to parameters\\n hp[\\\"device\\\"] = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\\n\\n # 2. Create extension of the architecture of the model and timestamp for this run (use to\\n # identify folders and files created for this run)\\n # format: f(params_file)_t(n_tiers)_l(n_layers)_hd(hidden_size)_gmm(gmm_size).\\n extension_architecture = f\\\"d{hp.name}_t{hp.network.n_tiers}_\\\" \\\\\\n f\\\"l{'.'.join(map(str, hp.network.layers))}_\\\" \\\\\\n f\\\"hd{hp.network.hidden_size}_gmm{hp.network.gmm_size}\\\"\\n timestamp = f\\\"{datetime.now().strftime('%Y%m%d-%H%M%S')}\\\"\\n\\n # 3 Create directories for saving logs and model weights if they do not exist\\n # 3.1 Create model weights directory for this run (the same directory will be used for different\\n # runs of a model with same architecture and the difference will be in the file stored)\\n hp[\\\"training\\\"][\\\"dir_chkpt\\\"] = hp.training.dir_chkpt + extension_architecture\\n Path(hp.training.dir_chkpt).mkdir(parents=True, exist_ok=True)\\n # 3.2 Create general log directory for this run (the same directory will be used for different\\n # runs of a model with same architecture and the difference will be in the file stored)\\n hp[\\\"logging\\\"][\\\"dir_log\\\"] = hp.logging.dir_log + extension_architecture\\n Path(hp.logging.dir_log).mkdir(parents=True, exist_ok=True)\\n\\n # 4. Setup general logging (it will use the folder previously created and the filename will be:\\n tier = str(args.tier) if args.tier is not None else 'ALL'\\n filename = f\\\"{hp.logging.dir_log}/tier{tier}_{timestamp}\\\"\\n logging.basicConfig(\\n level=logging.INFO,\\n format='%(asctime)s - %(levelname)s - %(message)s',\\n handlers=[\\n logging.FileHandler(filename=filename), # handler to save the log to a file\\n logging.StreamHandler() # handler to output the log to the terminal\\n ])\\n logger = logging.getLogger()\\n\\n # 5. Show device that will be used for training: CPU or GPU\\n logger.info(f\\\"Device for training: {hp.device}\\\")\\n\\n # 6. Start training of the model (or a single tier, depending on args)\\n train_model(args, hp, extension_architecture, timestamp, logger)\",\n \"def load_args():\\n parser = argparse.ArgumentParser(description=\\\"Classify and predict digits using the mnist dataset\\\")\\n parser.add_argument('mode', help='the mode to run in: fit, model or predict')\\n parser.add_argument('--algo', help='which algorithm to use: RandomForest, KNN')\\n return parser.parse_args()\",\n \"def training_config_parser():\\n parser = argparse.ArgumentParser()\\n\\n # xml_annotation_path, csv_annotation_path, oxford_annotations_path, oxford_images_path\\n # Dataset info\\n parser.add_argument(\\n \\\"--xml_annotation_path\\\", type=str, required=True\\n )\\n parser.add_argument(\\n \\\"--csv_annotation_path\\\", type=str, required=True\\n )\\n parser.add_argument(\\n \\\"--oxford_annotations_path\\\", type=str, required=True\\n )\\n parser.add_argument(\\n \\\"--oxford_images_path\\\", type=str, required=True\\n )\\n \\n parser.add_argument(\\n \\\"--background_class\\\",\\n type=int,\\n required=False,\\n default=0,\\n help=\\\"Default background class\\\",\\n )\\n\\n # What to train\\n parser.add_argument(\\n \\\"--train_backbone\\\",\\n action=\\\"store_true\\\",\\n required=False,\\n default=False,\\n help=\\\"Train backbone\\\",\\n )\\n parser.add_argument(\\n \\\"--train_transformers\\\",\\n action=\\\"store_true\\\",\\n required=False,\\n default=False,\\n help=\\\"Train transformers\\\",\\n )\\n parser.add_argument(\\n \\\"--train_nlayers\\\",\\n action=\\\"store_true\\\",\\n required=False,\\n default=False,\\n help=\\\"Train new layers\\\",\\n )\\n\\n # How to train\\n parser.add_argument(\\n \\\"--finetuning\\\",\\n default=False,\\n required=False,\\n action=\\\"store_true\\\",\\n help=\\\"Load the model weight before to train\\\",\\n )\\n parser.add_argument(\\n \\\"--batch_size\\\",\\n type=int,\\n required=False,\\n default=1,\\n help=\\\"Batch size to use to train the model\\\",\\n )\\n parser.add_argument(\\n \\\"--gradient_norm_clipping\\\",\\n type=float,\\n required=False,\\n default=0.1,\\n help=\\\"Gradient norm clipping\\\",\\n )\\n parser.add_argument(\\n \\\"--target_batch\\\",\\n type=int,\\n required=False,\\n default=None,\\n help=\\\"When running on a single GPU, aggretate the gradient before to apply.\\\",\\n )\\n\\n # Learning rate\\n parser.add_argument(\\n \\\"--backbone_lr\\\", type=bool, required=False, default=1e-5, help=\\\"Train backbone\\\"\\n )\\n parser.add_argument(\\n \\\"--transformers_lr\\\",\\n type=bool,\\n required=False,\\n default=1e-4,\\n help=\\\"Train transformers\\\",\\n )\\n parser.add_argument(\\n \\\"--nlayers_lr\\\", type=bool, required=False, default=1e-4, help=\\\"Train new layers\\\"\\n )\\n\\n return parser\",\n \"def main():\\r\\n parser = get_parser()\\r\\n config = parser.parse_args(['--cfg', 'config.yaml'])\\r\\n result_filing.init_config_vars(config)\\r\\n run_id = config.info.run_id\\r\\n logger = custom_logger.CustomLogger(run_id+':'+file_id)\\r\\n\\r\\n operation = config.info.operation_type\\r\\n logger.info(\\\"Selected operation type %s.\\\"%(operation))\\r\\n if operation == const.TRAIN_OP:\\r\\n train.train_model(config)\\r\\n elif operation == const.DEPLOY_OP:\\r\\n test.test_model(config)\",\n \"def load_config(args):\\n cfg=get_cfg()\\n # load from yaml\\n if args.cfg_file is not None:\\n cfg.merge_from_file(args.cfg_file)\\n\\n #load from cmd\\n # print(args.opts)\\n # if args.opts is not None:\\n # cfg.merge_from_file(args.opts)\\n\\n # make a checkpoint dir\\n # cu.make_checkpoint_dir(cfg.OUTPUT_DIR,cfg)\\n return cfg\",\n \"def get_args(args):\\n argparser = argparse.ArgumentParser()\\n\\n argparser.add_argument('--config',\\n required=True,\\n help='config file with hyper parameters - in yaml format')\\n\\n def_log = None\\n argparser.add_argument('--log',\\n default=def_log,\\n help=f'log to this file (default {def_log}: log to screen)')\\n\\n def_checkpointfrq = 'epoch'\\n argparser.add_argument('--ckptfreq',\\n default=def_checkpointfrq,\\n help=f'how many examples passed in training before saving (default is once per epoch)')\\n\\n def_checkpointpath = 'saved_model/cp-{epoch:04d}.ckpt'\\n argparser.add_argument('--ckptpath',\\n type=str,\\n default=def_checkpointpath,\\n help=f'checkpoint path (default {def_checkpointpath})')\\n\\n def_impath = '../../rainforest/fixed-train-jpg/'\\n argparser.add_argument('--imagepath',\\n default=def_impath,\\n help=f'path to image directory (default {def_impath})')\\n\\n def_labelpath = '../../rainforest/train_v3.csv'\\n argparser.add_argument('--labelpath',\\n default=def_labelpath,\\n help=f'path to csv file for labels (defautlt {def_labelpath})')\\n\\n def_seed = 0\\n argparser.add_argument('-s',\\n '--seed',\\n default=def_seed,\\n type=int,\\n help=f'Set random seed to this number (default {def_seed})')\\n\\n def_dataseed = 0\\n argparser.add_argument('-ds',\\n '--dataseed',\\n default=def_dataseed,\\n type=int,\\n help=f'Set random seed for data split into train / valid / test sets')\\n\\n def_kernels = 4\\n argparser.add_argument('-k',\\n '--kernels',\\n default=def_kernels,\\n type=int,\\n help=f'Number of kernels in the CNN (default {def_kernels})')\\n def_ksize = 2\\n argparser.add_argument('-ks',\\n '--ksize',\\n default=def_ksize,\\n type=int,\\n help=f'Size of kernels in CNN (default {def_ksize})')\\n\\n def_f1 = 64\\n argparser.add_argument('-f1',\\n '--filter1',\\n default=def_f1,\\n type=int,\\n help=f'Number of kernels in the first VGG block (default {def_f1})')\\n\\n def_k1 = 3\\n argparser.add_argument('-ks1',\\n '--ksize1',\\n default=def_k1,\\n type=int,\\n help=f'Size of kernels in the first VGG block (default {def_k1})')\\n\\n def_s1 = 1\\n argparser.add_argument('-s1',\\n '--stride1',\\n default=def_s1,\\n type=int,\\n help=f'Stride in the first VGG block (default {def_s1})')\\n\\n def_p1 = 2\\n argparser.add_argument('-p1',\\n '--pool1',\\n default=def_p1,\\n type=int,\\n help=f'Max pooling size in the first VGG block (default {def_p1})')\\n\\n def_sp1 = 2\\n argparser.add_argument('-sp1',\\n '--stridepool1',\\n default=def_sp1,\\n type=int,\\n help=f'Pool stride in the first VGG block (default {def_sp1})')\\n\\n def_f2 = 128\\n argparser.add_argument('-f2',\\n '--filter2',\\n default=def_f2,\\n type=int,\\n help=f'Number of kernels in the second VGG block (default {def_f2})')\\n\\n def_k2 = 3\\n argparser.add_argument('-ks2',\\n '--ksize2',\\n default=def_k2,\\n type=int,\\n help=f'Size of kernels in the second VGG block (default {def_k2})')\\n\\n def_s2 = 1\\n argparser.add_argument('-s2',\\n '--stride2',\\n default=def_s2,\\n type=int,\\n help=f'Stride in the second VGG block (default {def_s2})')\\n\\n def_p2 = 2\\n argparser.add_argument('-p2',\\n '--pool2',\\n default=def_p2,\\n type=int,\\n help=f'Max pooling size in the second VGG block (default {def_p2})')\\n\\n def_sp2 = 2\\n argparser.add_argument('-sp2',\\n '--stridepool2',\\n default=def_sp2,\\n type=int,\\n help=f'Pool stride in the second VGG block (default {def_sp2})')\\n\\n def_f3 = 256\\n argparser.add_argument('-f3',\\n '--filter3',\\n default=def_f3,\\n type=int,\\n help=f'Number of kernels in the 3rd VGG block (default {def_f3})')\\n\\n def_k3 = 3\\n argparser.add_argument('-ks3',\\n '--ksize3',\\n default=def_k3,\\n type=int,\\n help=f'Size of kernels in the 3rd VGG block (default {def_k3})')\\n\\n def_s3 = 1\\n argparser.add_argument('-s3',\\n '--stride3',\\n default=def_s3,\\n type=int,\\n help=f'Stride in the 3rd VGG block (default {def_s3})')\\n\\n def_p3 = 2\\n argparser.add_argument('-p3',\\n '--pool3',\\n default=def_p3,\\n type=int,\\n help=f'Max pooling size in the 3rd VGG block (default {def_p3})')\\n\\n def_sp3 = 2\\n argparser.add_argument('-sp3',\\n '--stridepool3',\\n default=def_sp3,\\n type=int,\\n help=f'Pool stride in the 3rd VGG block (default {def_sp3})')\\n\\n def_f4 = 512\\n argparser.add_argument('-f4',\\n '--filter4',\\n default=def_f4,\\n type=int,\\n help=f'Number of kernels in the 4th VGG block (default {def_f4})')\\n\\n def_k4 = 3\\n argparser.add_argument('-ks4',\\n '--ksize4',\\n default=def_k4,\\n type=int,\\n help=f'Size of kernels in the 4th VGG block (default {def_k4})')\\n\\n def_s4 = 1\\n argparser.add_argument('-s4',\\n '--stride4',\\n default=def_s4,\\n type=int,\\n help=f'Stride in the 4th VGG block (default {def_s4})')\\n\\n def_p4 = 2\\n argparser.add_argument('-p4',\\n '--pool4',\\n default=def_p4,\\n type=int,\\n help=f'Max pooling size in the 4th VGG block (default {def_p4})')\\n\\n def_sp4 = 2\\n argparser.add_argument('-sp4',\\n '--stridepool4',\\n default=def_sp4,\\n type=int,\\n help=f'Pool stride in the 4th VGG block (default {def_sp4})')\\n\\n def_f5 = 512\\n argparser.add_argument('-f5',\\n '--filter5',\\n default=def_f5,\\n type=int,\\n help=f'Number of kernels in the 5th VGG block (default {def_f5})')\\n\\n def_k5 = 3\\n argparser.add_argument('-ks5',\\n '--ksize5',\\n default=def_k5,\\n type=int,\\n help=f'Size of kernels in the 5th VGG block (default {def_k5})')\\n\\n def_s5 = 1\\n argparser.add_argument('-s5',\\n '--stride5',\\n default=def_s5,\\n type=int,\\n help=f'Stride in the 5th VGG block (default {def_s5})')\\n\\n def_p5 = 2\\n argparser.add_argument('-p5',\\n '--pool5',\\n default=def_p5,\\n type=int,\\n help=f'Max pooling size in the 5th VGG block (default {def_p5})')\\n\\n def_sp5 = 2\\n argparser.add_argument('-sp5',\\n '--stridepool5',\\n default=def_sp5,\\n type=int,\\n help=f'Pool stride in the 5th VGG block (default {def_sp5})')\\n\\n def_dense1 = 4096\\n argparser.add_argument('-d1',\\n '--dense1',\\n default=def_dense1,\\n type=int,\\n help=f'Size of 1st dense layer in the VGG network (default {def_dense1})')\\n\\n def_dense2 = 4096\\n argparser.add_argument('-d2',\\n '--dense2',\\n default=def_dense2,\\n type=int,\\n help=f'Size of 2nd dense layer in the VGG network (default {def_dense2})')\\n\\n def_augmentpolicy = None\\n argparser.add_argument('-da',\\n '--dataaugment',\\n default=def_augmentpolicy,\\n type=str,\\n help=f'Data augmentation scheme based on AutoAugment Implemented options are \\\\n cifar10\\\\n imagenet \\\\n svhn \\\\n(default {def_augmentpolicy})')\\n\\n def_lr = 0.1\\n argparser.add_argument('-l',\\n '--lr',\\n default=def_lr,\\n type=float,\\n help=f'Learning rate (default {def_lr})')\\n\\n def_nepoch = 1\\n argparser.add_argument('-n',\\n '--nepoch',\\n default=def_nepoch,\\n type=int,\\n help=f'Number of epoch for training (default {def_nepoch})')\\n\\n def_patience = 10\\n argparser.add_argument('-p',\\n '--patience',\\n default=def_patience,\\n type=int,\\n help=f'Number of epoch without improvements before stopping training (default {def_patience})')\\n\\n def_batch = 4\\n argparser.add_argument('-b',\\n '--batchsize',\\n default=def_batch,\\n type=int,\\n help=f'batch size (default {def_batch})')\\n\\n args = argparser.parse_args(args)\\n return args\",\n \"def load_config():\\n model_type, run_name, run_comment, epoch, verbose = get_args()\\n name = run_name + '-' + run_comment\\n if model_type == \\\"s2s\\\": \\n run_title = \\\"seq2seq\\\"\\n else:\\n run_title = \\\"def2vec\\\"\\n path = \\\"outputs/{}/logs/{}/config.json\\\".format(run_title, name)\\n config = None\\n with open(path) as f:\\n config = dict(json.load(f))\\n config = load_config(eval=True)\\n return (config, name, model_type)\",\n \"def get_args():\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument('--training', type=argparse.FileType(), default='./data/cdt.epe',\\n help='epe file with training sentences.')\\n parser.add_argument('--validation', type=argparse.FileType(), default='./data/cdd.epe',\\n help='epe file with validation sentences.')\\n parser.add_argument('--metrics', type=argparse.FileType(\\\"w\\\"), default=sys.stdout,\\n help='where to output metrics computed on validation.')\\n parser.add_argument('--mode', choices=['BASELINE', 'BASELINE_C', 'BASELINE_C_POS'], default='BASELINE',\\n help='mode in which model is trained, C adds cue information, POS adds pos tags.')\\n parser.add_argument('--arch', choices=['LSTM', 'GRU'], default='LSTM',\\n help='which recurrent network architecture to use.')\\n parser.add_argument('--word_vectors', default=None,\\n help='file with word embeddings')\\n parser.add_argument('--epochs', type=int, default=10,\\n help='number of epochs to train the model.')\\n parser.add_argument('--lr', type=float, default=1e-4,\\n help='learning rate used in adam optimizer.')\\n parser.add_argument('--max_len', type=int, default=100,\\n help='maximum length of sentence.')\\n parser.add_argument('--hidden_size', type=int, default=200,\\n help='memory size of recurrent neural network.')\\n parser.add_argument('--negations_only', action='store_true', default=False,\\n help='if present, only sentences with at least one negation are used.')\\n parser.add_argument('--tensorboard', action='store_true', default=False)\\n parser.add_argument('--save', default=None, help='directory where to save model.')\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser()\\n\\n ##################################################################\\n # Required parameters:\\n # ---------------------------------------------------------------\\n # - input/output dirs\\n # - model config (BertConfig / CharacterBertConfig)\\n # - a flag for pre-training CharacterBERT instead of BERT\\n ##################################################################\\n\\n parser.add_argument(\\n \\\"--hdf5_directory\\\",\\n type=str, required=True,\\n help=\\\\\\n \\\"Path to a directory contraining hdf5 files: training.*.hdf5, \\\"\\n \\\"validation.*.hdf5 and test.*.hdf5 files.\\\"\\n )\\n parser.add_argument(\\n \\\"--output_directory\\\",\\n type=str, required=True,\\n help=\\\\\\n \\\"Path to a directory where model checkpoints and metrics \\\"\\n \\\"will be saved.\\\"\\n )\\n parser.add_argument(\\n '--is_character_bert',\\n action='store_true',\\n help=\\\"Pre-train CharacterBERT instead of BERT.\\\"\\n )\\n\\n ##################################################################\\n # Other parameters\\n ##################################################################\\n # Parameters related to checkpoint handling\\n\\n parser.add_argument(\\n '--random_seed',\\n required=False, type=int, default=42,\\n help=\\\\\\n \\\"An intial seed for controlling some of the randomness.\\\"\\n )\\n parser.add_argument(\\n \\\"--local_rank\\\",\\n type=int, default=-1,\\n help=\\\\\\n \\\"Identifier of the current process within the distributed process \\\"\\n \\\"group. This is always `-1` when distributed training is deactivated.\\\"\\n )\\n parser.add_argument(\\n '--phase1_end_step',\\n type=int, default=7038,\\n help=\\\\\\n \\\"Number of training steps (backprops) in pre-training phase n°1: \\\"\\n \\\"`max_input_length=128`and `max_masked_tokens_per_input=20`.\\\"\\n )\\n parser.add_argument(\\n '--phase2',\\n action='store_true',\\n help=\\\\\\n \\\"Whether it is pre-training phase n°2: \\\"\\n \\\"`max_input_length=512`and `max_masked_tokens_per_input=80`.\\\"\\n )\\n parser.add_argument(\\n \\\"--init_checkpoint\\\",\\n type=str, default=None,\\n help=\\\"An initial checkpoint to start pre-training from.\\\"\\n )\\n parser.add_argument(\\n \\\"--resume_pretraining\\\",\\n action='store_true',\\n help=\\\"Whether to resume pre-training from a checkpoint.\\\"\\n )\\n parser.add_argument(\\n '--resume_step',\\n type=int, default=-1,\\n help=\\\\\\n \\\"Step to resume pre-training from. By default, this is `-1` \\\"\\n \\\"which results in resuming from the latest checkpoint available.\\\"\\n )\\n\\n ##################################################################\\n # Training hyperparameters\\n\\n parser.add_argument(\\n '--max_input_length',\\n required=False, type=int, default=128,\\n help=\\\\\\n \\\"Maximum sequence length for the model input. \\\"\\n \\\"Set this according to the input .hdf5 files contents.\\\"\\n )\\n parser.add_argument(\\n \\\"--max_masked_tokens_per_input\\\",\\n type=int, default=20,\\n help=\\\\\\n \\\"Hard limit on the number of tokens that can be masked. \\\"\\n \\\"Set this according to the input .hdf5 files contents.\\\"\\n )\\n parser.add_argument(\\n '--num_accumulation_steps',\\n type=int, default=512,\\n help=\\\\\\n \\\"Number of steps (forward passes) during which gradients are \\\"\\n \\\"accumulated before running a single model parameters update.\\\"\\n )\\n parser.add_argument(\\n \\\"--target_batch_size\\\",\\n type=int, default=8192,\\n help=\\\\\\n \\\"Target batch size post-accumulation (actual batch size is \\\"\\n \\\"derived from the number of accumulation steps). For example, if \\\"\\n \\\"`target_batch_size=32` and `num_accumulation_steps=4` then the \\\"\\n \\\"actual batch size will be `32/4 = 8`. This is useful for \\\"\\n \\\"achieving larger batch sizes while keeping an actual batch size \\\"\\n \\\"that is small enough to fit in memory.\\\"\\n )\\n parser.add_argument(\\n \\\"--learning_rate\\\",\\n type=float, default=6e-3,\\n help=\\\"The initial learning rate for the FusedLAMB optimizer.\\\"\\n )\\n parser.add_argument(\\n \\\"--warmup_proportion\\\",\\n type=float, default=0.2843,\\n help=\\\\\\n \\\"A value of X means that learning rate will increase during \\\"\\n \\\"(100*X)%% of pre-training steps before reaching the desired value \\\"\\n \\\"then decrease to 0 during the rest of pre-training steps.\\\"\\n )\\n parser.add_argument(\\n \\\"--total_steps\\\",\\n type=float, default=7038,\\n help=\\\"Total number of pre-training steps to perform.\\\"\\n )\\n\\n ##################################################################\\n # fp16 related parameters\\n\\n parser.add_argument(\\n '--fp16',\\n action='store_true',\\n help=\\\"Whether to use 16-bit float precision instead of 32-bit\\\"\\n )\\n parser.add_argument(\\n '--loss_scale',\\n type=float, default=0.0,\\n help='Loss scaling, positive power of 2 values can improve fp16 convergence.'\\n )\\n parser.add_argument(\\n '--allreduce_post_accumulation',\\n action='store_true',\\n help=\\\"Whether to do allreduces during gradient accumulation steps.\\\"\\n )\\n parser.add_argument(\\n '--allreduce_post_accumulation_fp16',\\n action='store_true',\\n help=\\\"Whether to do fp16 allreduce post accumulation.\\\")\\n\\n ##################################################################\\n # Logging and checkpointing\\n\\n parser.add_argument(\\n '--do_validation',\\n action='store_true',\\n help=\\\"Whether to run a validation step before checkpointing.\\\"\\n )\\n\\n parser.add_argument(\\n '--checkpoint_interval',\\n type=int, default=200,\\n help=\\\\\\n \\\"Number of model updates before a model checkpoint is saved.\\\"\\n )\\n parser.add_argument(\\n '--num_checkpoints_to_keep',\\n type=int, default=3,\\n help=\\\\\\n \\\"Maximum number of checkpoints to keep.\\\"\\n )\\n parser.add_argument(\\n '--log_freq',\\n type=float, default=1.0,\\n help='Frequency of logging loss.'\\n )\\n parser.add_argument(\\n '--tensorboard_id',\\n type=str, default='default',\\n help=\\\"Name of the directory where Tensorboard logs will be saved.\\\"\\n )\\n\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = common.default_args(net_name=NET_NAME, \\n num_classes=21, image_size=IMAGE_SIZE)\\n parser.add_argument('--trained-model', required=False, help='Path to trained state_dict file', \\n default=TRAINED_MODEL_PATH)\\n return parser.parse_args()\",\n \"def init_argparser() -> ArgumentParser:\\n parser = ArgumentParser()\\n from_config = parser.add_argument_group('From config file', 'Provide full experiment setup via config file')\\n from_config.add_argument('-c', '--config', help='Path to json file containing classification config.')\\n from_cmd = parser.add_argument_group('From commandline', 'Specify experiment setup via commandline arguments')\\n\\n # Model options\\n from_cmd.add_argument(\\\"--recoding_type\\\", type=str, default=None,\\n choices=[\\\"mc_dropout\\\", \\\"surprisal\\\", \\\"ensemble\\\"],\\n help=\\\"Recoding model type used for trainign. Choices include recoding based on MC Dropout,\\\"\\n \\\"perplexity and anchored ensembles. If not specified, a vanilla model without recoding\\\"\\n \\\"is used.\\\")\\n from_cmd.add_argument(\\\"--step_type\\\", type=str, default=None, choices=[\\\"fixed\\\", \\\"mlp\\\", \\\"learned\\\"],\\n help=\\\"Specifies the way the step size is determined when using a recoding model.\\\")\\n from_cmd.add_argument(\\\"--step_size\\\", type=float,\\n help=\\\"Step size for recoding in case the fixed step predictor is used.\\\")\\n from_cmd.add_argument(\\\"--embedding_size\\\", type=int, help=\\\"Dimensionality of word embeddings.\\\")\\n from_cmd.add_argument(\\\"--hidden_size\\\", type=int, help=\\\"Dimensionality of hidden states.\\\")\\n from_cmd.add_argument(\\\"--num_layers\\\", type=int, help=\\\"Number of network layers.\\\")\\n from_cmd.add_argument(\\\"--mc_dropout\\\", type=float, help=\\\"Dropout probability when estimating uncertainty.\\\")\\n from_cmd.add_argument(\\\"--dropout\\\", type=float, help=\\\"Dropout probability for model in general.\\\")\\n from_cmd.add_argument(\\\"--num_samples\\\", type=int, help=\\\"Number of samples used when estimating uncertainty.\\\")\\n\\n # Training options\\n from_cmd.add_argument(\\\"--weight_decay\\\", type=float, help=\\\"Weight decay parameter when estimating uncertainty.\\\")\\n from_cmd.add_argument(\\\"--prior_scale\\\", type=float,\\n help=\\\"Prior length scale. A lower scale signifies a prior belief that the input data is \\\"\\n \\\"distributed infrequently, a higher scale does the opposite.\\\")\\n from_cmd.add_argument(\\\"--learning_rate\\\", type=float, help=\\\"Learning rate during training.\\\")\\n from_cmd.add_argument(\\\"--batch_size\\\", type=int, help=\\\"Batch size during training.\\\")\\n from_cmd.add_argument(\\\"--num_epochs\\\", type=int, help=\\\"Number of training epochs.\\\")\\n from_cmd.add_argument(\\\"--clip\\\", type=float, help=\\\"Threshold for gradient clipping.\\\")\\n\\n # Corpus options\\n from_cmd.add_argument(\\\"--corpus_dir\\\", type=str, help=\\\"Directory to corpus files.\\\")\\n from_cmd.add_argument(\\\"--max_seq_len\\\", type=int, help=\\\"Maximum sentence length when reading in the corpora.\\\")\\n\\n # Screen output optins\\n from_cmd.add_argument(\\\"--print_every\\\", type=int, help=\\\"Batch interval at which training info should be printed.\\\")\\n from_cmd.add_argument(\\\"--eval_every\\\", type=int,\\n help=\\\"Epoch interval at which the model should be evaluated on validation set.\\\")\\n\\n # Model saving and logging options\\n from_cmd.add_argument(\\\"--model_name\\\", type=str, help=\\\"Model identifier.\\\")\\n from_cmd.add_argument(\\\"--model_save_path\\\", type=str,\\n help=\\\"Directory to which current best model should be saved to.\\\")\\n from_cmd.add_argument(\\\"--device\\\", type=str, default=\\\"cpu\\\", help=\\\"Device used for training.\\\")\\n from_cmd.add_argument(\\\"--log_dir\\\", type=str, help=\\\"Directory to write (tensorboard) logs to.\\\")\\n\\n return parser\",\n \"def init_model(config, program, exe):\\n checkpoints = config['Global'].get('checkpoints')\\n if checkpoints:\\n if os.path.exists(checkpoints + '.pdparams'):\\n path = checkpoints\\n fluid.load(program, path, exe)\\n logger.info(\\\"Finish initing model from {}\\\".format(path))\\n else:\\n raise ValueError(\\\"Model checkpoints {} does not exists,\\\"\\n \\\"check if you lost the file prefix.\\\".format(\\n checkpoints + '.pdparams'))\\n else:\\n pretrain_weights = config['Global'].get('pretrain_weights')\\n if pretrain_weights:\\n path = pretrain_weights\\n load_params(exe, program, path)\\n logger.info(\\\"Finish initing model from {}\\\".format(path))\",\n \"def main():\\n args = parse_args()\\n args.seed = init_rand(seed=args.seed)\\n\\n _, log_file_exist = initialize_logging(\\n logging_dir_path=args.save_dir,\\n logging_file_name=args.logging_file_name,\\n script_args=args,\\n log_packages=args.log_packages,\\n log_pip_packages=args.log_pip_packages)\\n\\n batch_size = prepare_ke_context(\\n num_gpus=args.num_gpus,\\n batch_size=args.batch_size)\\n\\n net = prepare_model(\\n model_name=args.model,\\n use_pretrained=args.use_pretrained,\\n pretrained_model_file_path=args.resume.strip())\\n num_classes = net.classes if hasattr(net, \\\"classes\\\") else 1000\\n input_image_size = net.in_size if hasattr(net, \\\"in_size\\\") else (args.input_size, args.input_size)\\n\\n train_data, val_data = get_data_rec(\\n rec_train=args.rec_train,\\n rec_train_idx=args.rec_train_idx,\\n rec_val=args.rec_val,\\n rec_val_idx=args.rec_val_idx,\\n batch_size=batch_size,\\n num_workers=args.num_workers,\\n input_image_size=input_image_size,\\n resize_inv_factor=args.resize_inv_factor)\\n train_gen = get_data_generator(\\n data_iterator=train_data,\\n num_classes=num_classes)\\n val_gen = get_data_generator(\\n data_iterator=val_data,\\n num_classes=num_classes)\\n\\n net = prepare_trainer(\\n net=net,\\n optimizer_name=args.optimizer_name,\\n momentum=args.momentum,\\n lr=args.lr,\\n num_gpus=args.num_gpus,\\n state_file_path=args.resume_state)\\n\\n train_net(\\n net=net,\\n train_gen=train_gen,\\n val_gen=val_gen,\\n train_num_examples=1281167,\\n val_num_examples=50048,\\n num_epochs=args.num_epochs,\\n checkpoint_filepath=os.path.join(args.save_dir, \\\"imagenet_{}.h5\\\".format(args.model)),\\n start_epoch1=args.start_epoch)\",\n \"def load_arguments(config_file= None ):\\n if config_file is None :\\n cur_path = os.path.dirname(os.path.realpath(__file__))\\n config_file = os.path.join(cur_path, \\\"config.toml\\\")\\n print(config_file)\\n\\n p = argparse.ArgumentParser()\\n p.add_argument(\\\"--config_file\\\", default=config_file, help=\\\"Params File\\\")\\n p.add_argument(\\\"--config_mode\\\", default=\\\"test\\\", help=\\\"test/ prod /uat\\\")\\n p.add_argument(\\\"--log_file\\\", help=\\\"File to save the logging\\\") \\n\\n p.add_argument(\\\"--do\\\", default=\\\"test\\\", help=\\\"what to do test or search\\\") \\n p.add_argument(\\\"--ntrials\\\", default=100, help='number of trials during the hyperparameters tuning')\\n p.add_argument(\\\"--modelname\\\", default=\\\"model_dl.1_lstm.py\\\", help=\\\"name of the model to be tuned this name will be used to save the model\\\") \\n p.add_argument(\\\"--data_path\\\", default=\\\"dataset/GOOG-year_small.csv\\\", help=\\\"path of the training file\\\") \\n p.add_argument('--optim_engine', default='optuna',help='Optimization engine') \\n p.add_argument('--optim_method', default='normal/prune',help='Optimization method') \\n p.add_argument('--save_folder', default='model_save',help='folder that will contain saved version of best model') \\n \\n args = p.parse_args()\\n args = load_config(args, args.config_file, args.config_mode, verbose=0)\\n return args\",\n \"def parse_args():\\n hpo_warning = 'Flag overwrites config value if set, used for HPO and PBT runs primarily'\\n parser = argparse.ArgumentParser('train.py')\\n add_arg = parser.add_argument\\n add_arg('config', nargs='?', default='GraphLearning/configs/myconfig.yaml')\\n add_arg('results_dir', nargs='?', default='GraphLearning/results/withnoise')\\n \\n return parser.parse_args()\",\n \"def main():\\n args = parse_command_line()\\n expt_config = load_config(args.experiment_config_path)\\n run_cli(RunOptions.from_dict(expt_config))\",\n \"def initialize_model_from_cfg(args, gpu_id=0):\\n model = eval(args.model).loot_model(args)\\n model.eval()\\n\\n if args.cuda:\\n model.cuda()\\n\\n if args.load_ckpt:\\n load_name = args.load_ckpt\\n logger.info(\\\"loading checkpoint %s\\\", load_name)\\n checkpoint = torch.load(load_name, map_location=lambda storage, loc: storage)\\n net_utils.load_ckpt(model, checkpoint['model'])\\n\\n if args.load_detectron:\\n logger.info(\\\"loading detectron weights %s\\\", args.load_detectron)\\n load_detectron_weight(model, args.load_detectron)\\n\\n\\n return model\",\n \"def parse_arguments(args_to_parse):\\n\\tdefault_config = get_config_section([CONFIG_FILE], \\\"Custom\\\")\\n\\n\\tdescription = \\\"PyTorch implementation and evaluation of disentangled Variational AutoEncoders and metrics.\\\"\\n\\tparser = argparse.ArgumentParser(description=description,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t formatter_class=FormatterNoDuplicate)\\n\\n\\t# General options\\n\\tgeneral = parser.add_argument_group('General options')\\n\\tgeneral.add_argument('name', type=str,\\n\\t\\t\\t\\t\\t\\t help=\\\"Name of the model for storing and loading purposes.\\\")\\n\\tgeneral.add_argument('-L', '--log-level', help=\\\"Logging levels.\\\",\\n\\t\\t\\t\\t\\t\\t default=default_config['log_level'], choices=LOG_LEVELS)\\n\\tgeneral.add_argument('--no-progress-bar', action='store_true',\\n\\t\\t\\t\\t\\t\\t default=default_config['no_progress_bar'],\\n\\t\\t\\t\\t\\t\\t help='Disables progress bar.')\\n\\tgeneral.add_argument('--no-cuda', action='store_true',\\n\\t\\t\\t\\t\\t\\t default=default_config['no_cuda'],\\n\\t\\t\\t\\t\\t\\t help='Disables CUDA training, even when have one.')\\n\\tgeneral.add_argument('-s', '--seed', type=int, default=default_config['seed'],\\n\\t\\t\\t\\t\\t\\t help='Random seed. Can be `None` for stochastic behavior.')\\n\\tgeneral.add_argument('-c', '--classifier', type = str,\\n\\t\\t\\t\\t\\t\\t help='Name of the classifeir')\\n\\t# Learning options\\n\\ttraining = parser.add_argument_group('Training specific options')\\n\\ttraining.add_argument('--checkpoint-every',\\n\\t\\t\\t\\t\\t\\t type=int, default=default_config['checkpoint_every'],\\n\\t\\t\\t\\t\\t\\t help='Save a checkpoint of the trained model every n epoch.')\\n\\ttraining.add_argument('-d', '--dataset', help=\\\"Path to training data.\\\",\\n\\t\\t\\t\\t\\t\\t default=default_config['dataset'], choices=DATASETS)\\n\\ttraining.add_argument('-x', '--experiment',\\n\\t\\t\\t\\t\\t\\t default=default_config['experiment'], choices=EXPERIMENTS,\\n\\t\\t\\t\\t\\t\\t help='Predefined experiments to run. If not `custom` this will overwrite some other arguments.')\\n\\ttraining.add_argument('-e', '--epochs', type=int,\\n\\t\\t\\t\\t\\t\\t default=default_config['epochs'],\\n\\t\\t\\t\\t\\t\\t help='Maximum number of epochs to run for.')\\n\\ttraining.add_argument('-b', '--batch-size', type=int,\\n\\t\\t\\t\\t\\t\\t default=default_config['batch_size'],\\n\\t\\t\\t\\t\\t\\t help='Batch size for training.')\\n\\ttraining.add_argument('--lr', type=float, default=default_config['lr'],\\n\\t\\t\\t\\t\\t\\t help='Learning rate.')\\n\\ttraining.add_argument('-g', '--gamma', type = float, default = 1., help = 'gamma for var')\\n\\n\\t# Model Options\\n\\tmodel = parser.add_argument_group('Model specfic options')\\n\\tmodel.add_argument('-m', '--model-type',\\n\\t\\t\\t\\t\\t default=default_config['model'], choices=MODELS,\\n\\t\\t\\t\\t\\t help='Type of encoder and decoder to use.')\\n\\tmodel.add_argument('-z', '--latent-dim', type=int,\\n\\t\\t\\t\\t\\t default=default_config['latent_dim'],\\n\\t\\t\\t\\t\\t help='Dimension of the latent variable.')\\n\\tmodel.add_argument('-l', '--loss',\\n\\t\\t\\t\\t\\t default=default_config['loss'], choices=LOSSES,\\n\\t\\t\\t\\t\\t help=\\\"Type of VAE loss function to use.\\\")\\n\\tmodel.add_argument('-r', '--rec-dist', default=default_config['rec_dist'],\\n\\t\\t\\t\\t\\t choices=RECON_DIST,\\n\\t\\t\\t\\t\\t help=\\\"Form of the likelihood ot use for each pixel.\\\")\\n\\tmodel.add_argument('-a', '--reg-anneal', type=float,\\n\\t\\t\\t\\t\\t default=default_config['reg_anneal'],\\n\\t\\t\\t\\t\\t help=\\\"Number of annealing steps where gradually adding the regularisation. What is annealed is specific to each loss.\\\")\\n\\n\\t# Loss Specific Options\\n\\tbetaH = parser.add_argument_group('BetaH specific parameters')\\n\\tbetaH.add_argument('--betaH-B', type=float,\\n\\t\\t\\t\\t\\t default=default_config['betaH_B'],\\n\\t\\t\\t\\t\\t help=\\\"Weight of the KL (beta in the paper).\\\")\\n\\n\\tbetaB = parser.add_argument_group('BetaB specific parameters')\\n\\tbetaB.add_argument('--betaB-initC', type=float,\\n\\t\\t\\t\\t\\t default=default_config['betaB_initC'],\\n\\t\\t\\t\\t\\t help=\\\"Starting annealed capacity.\\\")\\n\\tbetaB.add_argument('--betaB-finC', type=float,\\n\\t\\t\\t\\t\\t default=default_config['betaB_finC'],\\n\\t\\t\\t\\t\\t help=\\\"Final annealed capacity.\\\")\\n\\tbetaB.add_argument('--betaB-G', type=float,\\n\\t\\t\\t\\t\\t default=default_config['betaB_G'],\\n\\t\\t\\t\\t\\t help=\\\"Weight of the KL divergence term (gamma in the paper).\\\")\\n\\n\\tfactor = parser.add_argument_group('factor VAE specific parameters')\\n\\tfactor.add_argument('--factor-G', type=float,\\n\\t\\t\\t\\t\\t\\tdefault=default_config['factor_G'],\\n\\t\\t\\t\\t\\t\\thelp=\\\"Weight of the TC term (gamma in the paper).\\\")\\n\\tfactor.add_argument('--lr-disc', type=float,\\n\\t\\t\\t\\t\\t\\tdefault=default_config['lr_disc'],\\n\\t\\t\\t\\t\\t\\thelp='Learning rate of the discriminator.')\\n\\n\\tbtcvae = parser.add_argument_group('beta-tcvae specific parameters')\\n\\tbtcvae.add_argument('--btcvae-A', type=float,\\n\\t\\t\\t\\t\\t\\tdefault=default_config['btcvae_A'],\\n\\t\\t\\t\\t\\t\\thelp=\\\"Weight of the MI term (alpha in the paper).\\\")\\n\\tbtcvae.add_argument('--btcvae-G', type=float,\\n\\t\\t\\t\\t\\t\\tdefault=default_config['btcvae_G'],\\n\\t\\t\\t\\t\\t\\thelp=\\\"Weight of the dim-wise KL term (gamma in the paper).\\\")\\n\\tbtcvae.add_argument('--btcvae-B', type=float,\\n\\t\\t\\t\\t\\t\\tdefault=default_config['btcvae_B'],\\n\\t\\t\\t\\t\\t\\thelp=\\\"Weight of the TC term (beta in the paper).\\\")\\n\\n\\t# Learning options\\n\\tevaluation = parser.add_argument_group('Evaluation specific options')\\n\\tevaluation.add_argument('--is-eval-only', action='store_true',\\n\\t\\t\\t\\t\\t\\t\\tdefault=default_config['is_eval_only'],\\n\\t\\t\\t\\t\\t\\t\\thelp='Whether to only evaluate using precomputed model `name`.')\\n\\tevaluation.add_argument('--is-metrics', action='store_true',\\n\\t\\t\\t\\t\\t\\t\\tdefault=default_config['is_metrics'],\\n\\t\\t\\t\\t\\t\\t\\thelp=\\\"Whether to compute the disentangled metrcics. Currently only possible with `dsprites` as it is the only dataset with known true factors of variations.\\\")\\n\\tevaluation.add_argument('--no-test', action='store_true',\\n\\t\\t\\t\\t\\t\\t\\tdefault=default_config['no_test'],\\n\\t\\t\\t\\t\\t\\t\\thelp=\\\"Whether not to compute the test losses.`\\\")\\n\\tevaluation.add_argument('--eval-batchsize', type=int,\\n\\t\\t\\t\\t\\t\\t\\tdefault=default_config['eval_batchsize'],\\n\\t\\t\\t\\t\\t\\t\\thelp='Batch size for evaluation.')\\n\\n\\targs = parser.parse_args(args_to_parse)\\n\\tif args.experiment != 'custom':\\n\\t\\tif args.experiment not in ADDITIONAL_EXP:\\n\\t\\t\\t# update all common sections first\\n\\t\\t\\tmodel, dataset = args.experiment.split(\\\"_\\\")\\n\\t\\t\\tcommon_data = get_config_section([CONFIG_FILE], \\\"Common_{}\\\".format(dataset))\\n\\t\\t\\tupdate_namespace_(args, common_data)\\n\\t\\t\\tcommon_model = get_config_section([CONFIG_FILE], \\\"Common_{}\\\".format(model))\\n\\t\\t\\tupdate_namespace_(args, common_model)\\n\\n\\t\\ttry:\\n\\t\\t\\texperiments_config = get_config_section([CONFIG_FILE], args.experiment)\\n\\t\\t\\tupdate_namespace_(args, experiments_config)\\n\\t\\texcept KeyError as e:\\n\\t\\t\\tif args.experiment in ADDITIONAL_EXP:\\n\\t\\t\\t\\traise e # only reraise if didn't use common section\\n\\n\\treturn args\",\n \"def get_config(parse=True, **optional_kwargs):\\n parser = argparse.ArgumentParser()\\n\\n # Mode\\n parser.add_argument('--mode', type=str, default='train')\\n parser.add_argument('--runs', type=int, default=5)\\n\\n # Bert\\n parser.add_argument('--use_bert', type=str2bool, default=True)\\n parser.add_argument('--use_cmd_sim', type=str2bool, default=True)\\n\\n # Train\\n time_now = datetime.now().strftime('%Y-%m-%d_%H:%M:%S')\\n parser.add_argument('--name', type=str, default=f\\\"{time_now}\\\")\\n parser.add_argument('--num_classes', type=int, default=0)\\n parser.add_argument('--batch_size', type=int, default=128)\\n parser.add_argument('--eval_batch_size', type=int, default=10)\\n parser.add_argument('--n_epoch', type=int, default=500)\\n parser.add_argument('--patience', type=int, default=6)\\n\\n parser.add_argument('--diff_weight', type=float, default=0.3)\\n parser.add_argument('--sim_weight', type=float, default=1.0)\\n parser.add_argument('--sp_weight', type=float, default=0.0)\\n parser.add_argument('--recon_weight', type=float, default=1.0)\\n\\n parser.add_argument('--learning_rate', type=float, default=1e-4)\\n parser.add_argument('--optimizer', type=str, default='Adam')\\n parser.add_argument('--clip', type=float, default=1.0)\\n\\n parser.add_argument('--rnncell', type=str, default='lstm')\\n parser.add_argument('--embedding_size', type=int, default=300)\\n parser.add_argument('--hidden_size', type=int, default=128)\\n parser.add_argument('--dropout', type=float, default=0.5)\\n parser.add_argument('--reverse_grad_weight', type=float, default=1.0)\\n # Selectin activation from 'elu', \\\"hardshrink\\\", \\\"hardtanh\\\", \\\"leakyrelu\\\", \\\"prelu\\\", \\\"relu\\\", \\\"rrelu\\\", \\\"tanh\\\"\\n parser.add_argument('--activation', type=str, default='relu')\\n\\n # Model\\n parser.add_argument('--model', type=str,\\n default='MISA', help='one of {MISA, }')\\n\\n # Data\\n parser.add_argument('--data', type=str, default='mosi')\\n\\n # Parse arguments\\n if parse:\\n kwargs = parser.parse_args()\\n else:\\n kwargs = parser.parse_known_args()[0]\\n\\n print(kwargs.data)\\n if kwargs.data == \\\"mosi\\\":\\n kwargs.num_classes = 1\\n kwargs.batch_size = 64\\n elif kwargs.data == \\\"mosei\\\":\\n kwargs.num_classes = 1\\n kwargs.batch_size = 16\\n elif kwargs.data == \\\"ur_funny\\\":\\n kwargs.num_classes = 2\\n kwargs.batch_size = 32\\n else:\\n print(\\\"No dataset mentioned\\\")\\n exit()\\n\\n # Namespace => Dictionary\\n kwargs = vars(kwargs)\\n kwargs.update(optional_kwargs)\\n\\n return Config(**kwargs)\",\n \"def getArgs():\\r\\n parser = argparse.ArgumentParser(\\r\\n description = \\\"\\\"\\\"This program uses the validation data and a given model to do brain segmentation that will be sent to FeTs challenge to get evaluated \\\"\\\"\\\")\\r\\n parser.add_argument(\\\"-d\\\", type = str, help = \\\"d is the path to validation dataset, e.g: C:/Documents/MICCAI_FeTS2021_TrainingData/\\\")\\r\\n parser.add_argument(\\\"-m\\\", type = str, help = \\\"m is the path for the model to load, e.g: C:/Documents/MICCAI_FeTS2021_TrainingData/cpt/cpt_0_1\\\")\\r\\n parser.add_argument(\\\"-o\\\", type = str, help = \\\"o is the output path, e.g: C:/Documents/inferences\\\")\\r\\n # Get your arguments\\r\\n return parser.parse_args()\",\n \"def main():\\n parser = argparse.ArgumentParser(description=\\\"Convert a checkpoint file into a support sets and a reconstructor \\\"\\n \\\"weights files\\\")\\n parser.add_argument('--exp', type=str, required=True, help=\\\"set experiment's model dir (created by `train.py`)\\\")\\n\\n # Parse given arguments\\n args = parser.parse_args()\\n\\n # Check structure of `args.exp`\\n if not osp.isdir(args.exp):\\n raise NotADirectoryError(\\\"Invalid given directory: {}\\\".format(args.exp))\\n models_dir = osp.join(args.exp, 'models')\\n if not osp.isdir(models_dir):\\n raise NotADirectoryError(\\\"Invalid models directory: {}\\\".format(models_dir))\\n checkpoint_file = osp.join(models_dir, 'checkpoint.pt')\\n if not osp.isfile(checkpoint_file):\\n raise FileNotFoundError(\\\"Checkpoint file not found: {}\\\".format(checkpoint_file))\\n\\n print(\\\"#. Convert checkpoint file into support sets and reconstructor weight files...\\\")\\n\\n # Load checkpoint file\\n checkpoint_dict = torch.load(checkpoint_file)\\n\\n # Get checkpoint iteration\\n checkpoint_iter = checkpoint_dict['iter']\\n print(\\\" \\\\\\\\__Checkpoint iteration: {}\\\".format(checkpoint_iter))\\n\\n # Save support sets weights file\\n print(\\\" \\\\\\\\__Save checkpoint support sets weights file...\\\")\\n torch.save(checkpoint_dict['support_sets'], osp.join(models_dir, 'support_sets-{}.pt'.format(checkpoint_iter)))\\n\\n # Save reconstructor weights file\\n print(\\\" \\\\\\\\__Save checkpoint reconstructor weights file...\\\")\\n torch.save(checkpoint_dict['reconstructor'], osp.join(models_dir, 'reconstructor-{}.pt'.format(checkpoint_iter)))\",\n \"def main(opts):\\n\\n # Create a dataloader for the training images\\n train_dataloader, _ = get_emoji_loader(opts.emoji, opts)\\n\\n # Create checkpoint and sample directories\\n utils.create_dir(opts.checkpoint_dir)\\n utils.create_dir(opts.sample_dir)\\n\\n train(train_dataloader, opts)\",\n \"def main(args):\\n\\n shared_policy_net = build_policy_net(args).share_memory()\\n shared_value_net = build_value_net(args).share_memory()\\n\\n start_training_processes(\\n args,\\n shared_policy_net,\\n shared_value_net,\\n )\",\n \"def initialize():\\n\\n parser = build_arg_parser()\\n par = parser.parse_known_args()[0]\\n\\n # Main arguments.\\n set('run_mode', par.run_mode)\\n set('input_files', par.image)\\n\\n # Sub-parser specific arguments.\\n if par.run_mode == 'train':\\n\\n set('batch_size', par.batch_size)\\n set('drop', par.drop)\\n set('epochs', par.epochs)\\n set('model', par.model)\\n set('level', par.level)\\n set('vfrac', par.vfrac)\\n set('data_augm', par.data_augm)\\n set('summary', par.summary)\\n set('outdir', par.outdir)\\n # Parameters associated with super-resolution. \\n set('super_resolution', par.super_resolution)\\n set('generator', par.generator)\\n set('discriminator', par.discriminator)\\n\\n elif par.run_mode == 'predict':\\n\\n set('tile_edge', par.edge)\\n set('model', par.model)\\n set('save_conv2d_kernels', par.save_conv2d_kernels) \\n set('save_conv2d_outputs', par.save_conv2d_outputs) \\n set('colormap', par.colormap)\\n # Parameters associated with super-resolution. \\n set('super_resolution', par.super_resolution)\\n set('generator', par.generator)\\n\\n elif par.run_mode == 'diagnose': \\n \\n set('model', par.model) \\n \\n else:\\n \\n pass\",\n \"def parse_args(argv):\\n parser = argparse.ArgumentParser(\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n parser.add_argument('--config', required=True,\\n choices=configs.valid_configs(),\\n help='The config to use.')\\n parser.add_argument('--ckpt_dir', required=True,\\n help=('Path to the folder where checkpoints should be '\\n 'stored. Passing the same folder twice will resume '\\n 'training.'))\\n parser.add_argument('--num_steps', default='1M',\\n help=('Number of steps to train for. Supports M and k '\\n 'postfix for \\\"million\\\" and \\\"thousand\\\", resp.'))\\n parser.add_argument('--init_autoencoder_from_ckpt_dir',\\n metavar='AUTOENC_CKPT_DIR',\\n help=('If given, restore encoder, decoder, and '\\n 'probability model from the latest checkpoint in '\\n 'AUTOENC_CKPT_DIR. See README.md.'))\\n parser.add_argument('--batch_size', type=int, default=8,\\n help='Batch size for training.')\\n parser.add_argument('--crop_size', type=int, default=256,\\n help='Crop size for input pipeline.')\\n parser.add_argument('--lpips_weight_path',\\n help=('Where to store the LPIPS weights. Defaults to '\\n 'current directory'))\\n\\n helpers.add_tfds_arguments(parser)\\n\\n parser.add_argument(\\n '--no-image-summaries',\\n dest='image_summaries',\\n action='store_false',\\n help='Disable image summaries.')\\n parser.set_defaults(image_summaries=True)\\n\\n args = parser.parse_args(argv[1:])\\n if args.ckpt_dir == args.init_autoencoder_from_ckpt_dir:\\n raise ValueError('--init_autoencoder_from_ckpt_dir should not point to '\\n 'the same folder as --ckpt_dir. If you simply want to '\\n 'continue training the model in --ckpt_dir, you do not '\\n 'have to pass --init_autoencoder_from_ckpt_dir, as '\\n 'continuing training is the default.')\\n args.num_steps = _parse_num_steps(args.num_steps)\\n return args\",\n \"def get_args():\\n \\n parser = argparse.ArgumentParser(description='Train a model on a given dataset.')\\n \\n parser.add_argument('-m', '--model', dest='model_name', metavar = 'model_name', \\n choices = ['ResNet-50', 'Xception', 'DenseNet-121', 'Inception-V3', \\n 'Inception-ResNet-V2', 'EfficientNet-B2'],\\n type = str, required = True,\\n help = 'the name of the model to be trained.\\\\n Choose from ResNet-50, Xception, DenseNet-121, Inception-V3,' \\n 'Inception-ResNet-V2, EfficientNet-B2')\\n \\n parser.add_argument('--size', '-s', dest='img_size', metavar = 'img_size',\\n type = int, required = True,\\n help = 'the size of dataset images')\\n \\n parser.add_argument('--path', '-p', dest='path', metavar='DATA_path', type=str,\\n required = True, help='the path that contains the dataset.')\\n\\n parser.add_argument('--output', '-o', dest='output', metavar='prediction_output_path', type=str,\\n default=None, required=True, help='the directory to output training curves and saved weights')\\n \\n parser.add_argument('--weight_path', '-w', dest='weight_path', metavar='weight_path', type=str,\\n required = True, help='the path to pretrained weights, either NIH if training from scratch or '\\n 'corresponding model weights from our pretrained weights if fine-tuning'\\n ' DeepCOVID-XR.')\\n\\n parser.add_argument('--hyperparameters', '-hy', dest='hyperparameters', metavar='Hyperparameters', type=str,\\n required=False, default=None, help='the path to pickled hyperparameters dictionary; will use '\\n 'default parameters if not provided.')\\n \\n return parser.parse_args()\",\n \"def add_generic_args(parser):\\n parser.add_argument(\\n \\\"--config_file\\\", type=str, help=\\\"path to config file for model\\\", required=True\\n )\\n parser.add_argument(\\n \\\"--checkpoint_folder\\\",\\n default=\\\"\\\",\\n type=str,\\n help=\\\"\\\"\\\"folder to use for saving checkpoints:\\n epochal checkpoints are stored as model_<epoch>.torch,\\n latest epoch checkpoint is at checkpoint.torch\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--checkpoint_load_path\\\",\\n default=\\\"\\\",\\n type=str,\\n help=\\\"\\\"\\\"path to load a checkpoint from, which can be a file or a directory:\\n If the path is a directory, the checkpoint file is assumed to be\\n checkpoint.torch\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--pretrained_checkpoint_path\\\",\\n default=\\\"\\\",\\n type=str,\\n help=\\\"\\\"\\\"path to load a pre-trained checkpoints from, which can be a file or a\\n directory:\\n If the path is a directory, the checkpoint file is assumed to be\\n checkpoint.torch. This checkpoint is only used for fine-tuning\\n tasks, and training will not resume from this checkpoint.\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--checkpoint_period\\\",\\n default=1,\\n type=int,\\n help=\\\"\\\"\\\"Checkpoint every x phases (default 1)\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--show_progress\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"shows progress bar during training / testing\\\",\\n )\\n parser.add_argument(\\n \\\"--skip_tensorboard\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"do not perform tensorboard visualization\\\",\\n )\\n parser.add_argument(\\n \\\"--visdom_server\\\",\\n default=\\\"\\\",\\n type=str,\\n help=\\\"visdom server to use (default None)\\\",\\n )\\n parser.add_argument(\\n \\\"--visdom_port\\\",\\n default=8097,\\n type=int,\\n help=\\\"port of visdom server (default = 8097)\\\",\\n )\\n parser.add_argument(\\n \\\"--profiler\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"specify this argument to profile training code\\\",\\n )\\n parser.add_argument(\\n \\\"--debug\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"specify this argument for debugging mode\\\",\\n )\\n parser.add_argument(\\n \\\"--ignore_checkpoint_config\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"\\\"\\\"specify this argument to ignore\\n the compatibility of the config (or lack of config) attached\\n to the checkpoint; this will allow mismatches between\\n the training specified in the config and the\\n actual training of the model\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--log_freq\\\",\\n default=5,\\n type=int,\\n help=\\\"Logging frequency for LossLrMeterLoggingHook (default 5)\\\",\\n )\\n parser.add_argument(\\n \\\"--image_backend\\\",\\n default=\\\"PIL\\\",\\n type=str,\\n help=\\\"torchvision image decoder backend (PIL or accimage). Default PIL\\\",\\n )\\n parser.add_argument(\\n \\\"--video_backend\\\",\\n default=\\\"pyav\\\",\\n type=str,\\n help=\\\"torchvision video decoder backend (pyav or video_reader). Default pyav\\\",\\n )\\n parser.add_argument(\\n \\\"--distributed_backend\\\",\\n default=\\\"none\\\",\\n type=str,\\n help=\\\"\\\"\\\"Distributed backend: either 'none' (for non-distributed runs)\\n or 'ddp' (for distributed runs). Default none.\\\"\\\"\\\",\\n )\\n\\n return parser\",\n \"def parse_arguments(args_to_parse):\\r\\n desc = 'Pytorch implementation and evaluation of flexible EHR embedding.'\\r\\n parser = argparse.ArgumentParser(\\r\\n description=desc, formatter_class=FormatterNoDuplicate)\\r\\n\\r\\n # General options\\r\\n general = parser.add_argument_group('General options')\\r\\n general.add_argument('name',\\r\\n type=str,\\r\\n help='Name of the model for storing and loading.')\\r\\n general.add_argument('-r', '--results',\\r\\n type=str, default='results',\\r\\n help='Directory to store results.')\\r\\n general.add_argument('--p-bar',\\r\\n action='store_true', default=True,\\r\\n help='Show progress bar.')\\r\\n general.add_argument('--cuda',\\r\\n action='store_true', default=True,\\r\\n help='Whether to use CUDA training.')\\r\\n general.add_argument('-s', '--seed',\\r\\n type=int, default=0,\\r\\n help='Random seed. `None` for stochastic behavior.')\\r\\n\\r\\n # Learning options\\r\\n training = parser.add_argument_group('Training options')\\r\\n training.add_argument('data',\\r\\n type=str,\\r\\n help='Path to data directory')\\r\\n training.add_argument('-e', '--epochs',\\r\\n type=int, default=20,\\r\\n help='Maximum number of epochs.')\\r\\n training.add_argument('-bs',\\r\\n type=int, default=128,\\r\\n help='Batch size for training.')\\r\\n training.add_argument('--lr',\\r\\n type=float, default=5e-4,\\r\\n help='Learning rate.')\\r\\n training.add_argument('--early-stopping',\\r\\n type=int, default=5,\\r\\n help='Epochs before early stopping.')\\r\\n\\r\\n # Model options\\r\\n model = parser.add_argument_group('Model specfic options')\\r\\n model.add_argument('-m', '--model-type',\\r\\n default='Mortality', choices=MODELS,\\r\\n help='Type of decoder to use.')\\r\\n model.add_argument('-t', '--t_hours',\\r\\n type=int, default=48,\\r\\n help='ICU data time length.')\\r\\n model.add_argument('-n', '--n_bins',\\r\\n type=int, default=20,\\r\\n help='Number of bins per continuous variable.')\\r\\n model.add_argument('--dt',\\r\\n type=float, default=1.0,\\r\\n help='Time increment between sequence steps.')\\r\\n model.add_argument('-z', '--latent-dim',\\r\\n type=int, default=32,\\r\\n help='Dimension of the token embedding.')\\r\\n model.add_argument('-H', '--hidden-dim',\\r\\n type=int, default=256,\\r\\n help='Dimension of the LSTM hidden state.')\\r\\n model.add_argument('-p', '--p-dropout',\\r\\n type=float, default=0.0,\\r\\n help='Embedding dropout rate.')\\r\\n model.add_argument('-w', '--weighted',\\r\\n type=bool, default=True,\\r\\n help='Whether to weight embeddings.')\\r\\n model.add_argument('-D', '--dynamic',\\r\\n type=bool, default=True,\\r\\n help='Whether to perform dynamic prediction.')\\r\\n\\r\\n # Evaluation options\\r\\n evaluation = parser.add_argument_group('Evaluation options')\\r\\n evaluation.add_argument('--eval',\\r\\n action='store_true', default=False,\\r\\n help='Whether to evaluate using pretrained model.')\\r\\n evaluation.add_argument('--test',\\r\\n action='store_true', default=True,\\r\\n help='Whether to compute test losses.')\\r\\n\\r\\n args = parser.parse_args(args_to_parse)\\r\\n\\r\\n return args\",\n \"def initialize(self, args):\\n # You must parse model_config. JSON string is not parsed here\\n self.model_config = json.loads(args['model_config'])\\n print(\\\"model_config:\\\", self.model_config)\\n\\n self.input_names = []\\n for input_config in self.model_config[\\\"input\\\"]:\\n self.input_names.append(input_config[\\\"name\\\"])\\n print(\\\"postprocess input names:\\\", self.input_names)\\n\\n self.output_names = []\\n self.output_dtype = []\\n for output_config in self.model_config[\\\"output\\\"]:\\n self.output_names.append(output_config[\\\"name\\\"])\\n dtype = pb_utils.triton_string_to_numpy(output_config[\\\"data_type\\\"])\\n self.output_dtype.append(dtype)\\n print(\\\"postprocess output names:\\\", self.output_names)\\n self.postprocessor = fd.vision.ocr.DBDetectorPostprocessor()\\n self.cls_preprocessor = fd.vision.ocr.ClassifierPreprocessor()\\n self.rec_preprocessor = fd.vision.ocr.RecognizerPreprocessor()\\n self.cls_threshold = 0.9\",\n \"def train(args):\\n print(args)\\n\\n # Run a training job\\n configs = LuxMatchConfigs_Default\\n\\n # Create a default opponent agent\\n opponent = Agent()\\n\\n # Create a RL agent in training mode\\n player = AgentPolicy(mode=\\\"train\\\")\\n\\n # Train the model\\n num_cpu = 1\\n if num_cpu == 1:\\n env = LuxEnvironment(configs=configs,\\n learning_agent=player,\\n opponent_agent=opponent)\\n else:\\n env = SubprocVecEnv([make_env(LuxEnvironment(configs=configs,\\n learning_agent=AgentPolicy(mode=\\\"train\\\"),\\n opponent_agent=opponent), i) for i in range(num_cpu)])\\n run_id = args.id\\n print(\\\"Run id %s\\\" % run_id)\\n\\n if args.path:\\n # by default previous model params are used (lr, batch size, gamma...)\\n model = PPO.load(args.path)\\n model.set_env(env=env)\\n\\n # Update the learning rate\\n model.lr_schedule = get_schedule_fn(args.learning_rate)\\n\\n # TODO: Update other training parameters\\n else:\\n model = PPO(\\\"MlpPolicy\\\",\\n env,\\n verbose=1,\\n tensorboard_log=\\\"./lux_tensorboard/\\\",\\n learning_rate=args.learning_rate,\\n gamma=args.gamma,\\n gae_lambda=args.gae_lambda,\\n batch_size=args.batch_size,\\n n_steps=args.n_steps\\n )\\n\\n print(\\\"Training model...\\\")\\n # Save a checkpoint every 1M steps\\n checkpoint_callback = CheckpointCallback(save_freq=1000000,\\n save_path='./models/',\\n name_prefix=f'rl_model_{run_id}')\\n model.learn(total_timesteps=args.step_count,\\n callback=checkpoint_callback) # 20M steps\\n if not os.path.exists(f'models/rl_model_{run_id}_{args.step_count}_steps.zip'):\\n model.save(path=f'models/rl_model_{run_id}_{args.step_count}_steps.zip')\\n print(\\\"Done training model.\\\")\\n\\n # Inference the model\\n print(\\\"Inference model policy with rendering...\\\")\\n saves = glob.glob(f'models/rl_model_{run_id}_*_steps.zip')\\n latest_save = sorted(saves, key=lambda x: int(x.split('_')[-2]), reverse=True)[0]\\n model.load(path=latest_save)\\n obs = env.reset()\\n for i in range(600):\\n action_code, _states = model.predict(obs, deterministic=True)\\n obs, rewards, done, info = env.step(action_code)\\n if i % 5 == 0:\\n print(\\\"Turn %i\\\" % i)\\n env.render()\\n\\n if done:\\n print(\\\"Episode done, resetting.\\\")\\n obs = env.reset()\\n print(\\\"Done\\\")\\n\\n '''\\n # Learn with self-play against the learned model as an opponent now\\n print(\\\"Training model with self-play against last version of model...\\\")\\n player = AgentPolicy(mode=\\\"train\\\")\\n opponent = AgentPolicy(mode=\\\"inference\\\", model=model)\\n env = LuxEnvironment(configs, player, opponent)\\n model = PPO(\\\"MlpPolicy\\\",\\n env,\\n verbose=1,\\n tensorboard_log=\\\"./lux_tensorboard/\\\",\\n learning_rate = 0.0003,\\n gamma=0.999,\\n gae_lambda = 0.95\\n )\\n\\n model.learn(total_timesteps=2000)\\n env.close()\\n print(\\\"Done\\\")\\n '''\",\n \"def main(args):\\r\\n\\r\\n # Logging info\\r\\n formatter = logging.Formatter('%(asctime)s %(levelname)s - '\\r\\n '%(funcName)s: %(message)s',\\r\\n '%H:%M:%S')\\r\\n logger = logging.getLogger(__name__)\\r\\n logger.setLevel('INFO')\\r\\n stream = logging.StreamHandler()\\r\\n stream.setLevel('INFO')\\r\\n stream.setFormatter(formatter)\\r\\n logger.addHandler(stream)\\r\\n\\r\\n set_seed(args.seed)\\r\\n device = torch.device(\\r\\n 'cuda' if torch.cuda.is_available() and args.cuda else 'cpu')\\r\\n model_name = f'{args.name}_lr{args.lr}_z{args.latent_dim}' \\\\\\r\\n + f'_h{args.hidden_dim}_p{args.p_dropout}'\\r\\n model_dir = os.path.join(args.results, model_name)\\r\\n logger.info(f'Directory for saving and loading models: {model_dir}')\\r\\n\\r\\n if not args.eval:\\r\\n # Model directory\\r\\n new_model_dir(model_dir, logger=logger)\\r\\n\\r\\n # Dataloaders\\r\\n train_loader, valid_loader = get_dataloaders(\\r\\n args.data, args.t_hours, args.n_bins,\\r\\n validation=True, dynamic=args.dynamic,\\r\\n batch_size=args.bs, logger=logger)\\r\\n logger.info(\\r\\n f'Train {args.model_type}-{args.t_hours} ' +\\r\\n f'with {len(train_loader.dataset)} samples')\\r\\n\\r\\n # Load model\\r\\n n_tokens = len(np.load(\\r\\n os.path.join(\\r\\n args.data, '_dicts', f'{args.t_hours}_{args.n_bins}.npy'),\\r\\n allow_pickle=True).item())\\r\\n model = init_model(\\r\\n args.model_type, n_tokens, args.latent_dim, args.hidden_dim,\\r\\n p_dropout=args.p_dropout, dt=args.dt,\\r\\n weighted=args.weighted, dynamic=args.dynamic)\\r\\n logger.info(f'#params in model: {get_n_param(model)}')\\r\\n\\r\\n # Optimizer\\r\\n optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\\r\\n loss_f = BCE()\\r\\n model = model.to(device)\\r\\n\\r\\n # Training\\r\\n trainer = Trainer(\\r\\n model, loss_f, optimizer,\\r\\n device=device, logger=logger, save_dir=model_dir, p_bar=args.p_bar)\\r\\n trainer.train(\\r\\n train_loader, valid_loader,\\r\\n epochs=args.epochs, early_stopping=args.early_stopping)\\r\\n\\r\\n # Save model\\r\\n metadata = vars(args)\\r\\n metadata['n_tokens'] = n_tokens\\r\\n save_model(trainer.model, model_dir, metadata=metadata)\\r\\n\\r\\n if args.test:\\r\\n # Load model\\r\\n model = load_model(model_dir, is_gpu=args.cuda)\\r\\n metadata = load_metadata(model_dir)\\r\\n\\r\\n # Dataloader\\r\\n test_loader, _ = get_dataloaders(\\r\\n metadata['data'], metadata['t_hours'], metadata['n_bins'],\\r\\n validation=False, dynamic=metadata['dynamic'], batch_size=128,\\r\\n shuffle=False, logger=logger)\\r\\n\\r\\n # Evaluate\\r\\n loss_f = BCE()\\r\\n evaluator = Trainer(\\r\\n model, loss_f,\\r\\n device=device, logger=logger, save_dir=model_dir, p_bar=args.p_bar)\\r\\n evaluator._valid_epoch(test_loader)\",\n \"def main():\\n\\n args = get_arguments()\\n\\n w, h = map(int, args.input_size.split(','))\\n\\n config_path = os.path.join(os.path.dirname(args.restore_from),'opts.yaml')\\n with open(config_path, 'r') as stream:\\n config = yaml.load(stream)\\n\\n args.model = config['model']\\n print('ModelType:%s'%args.model)\\n print('NormType:%s'%config['norm_style'])\\n gpu0 = args.gpu\\n batchsize = args.batchsize\\n\\n model_name = os.path.basename( os.path.dirname(args.restore_from) )\\n #args.save += model_name\\n\\n if not os.path.exists(args.save):\\n os.makedirs(args.save)\\n confidence_path = os.path.join(args.save, 'submit/confidence')\\n label_path = os.path.join(args.save, 'submit/labelTrainIds')\\n label_invalid_path = os.path.join(args.save, 'submit/labelTrainIds_invalid')\\n for path in [confidence_path, label_path, label_invalid_path]:\\n if not os.path.exists(path):\\n os.makedirs(path)\\n\\n if args.model == 'DeepLab':\\n model = DeeplabMulti(num_classes=args.num_classes, use_se = config['use_se'], train_bn = False, norm_style = config['norm_style'])\\n elif args.model == 'Oracle':\\n model = Res_Deeplab(num_classes=args.num_classes)\\n if args.restore_from == RESTORE_FROM:\\n args.restore_from = RESTORE_FROM_ORC\\n elif args.model == 'DeeplabVGG':\\n model = DeeplabVGG(num_classes=args.num_classes)\\n if args.restore_from == RESTORE_FROM:\\n args.restore_from = RESTORE_FROM_VGG\\n\\n if args.restore_from[:4] == 'http' :\\n saved_state_dict = model_zoo.load_url(args.restore_from)\\n else:\\n saved_state_dict = torch.load(args.restore_from)\\n\\n try:\\n model.load_state_dict(saved_state_dict)\\n except:\\n model = torch.nn.DataParallel(model)\\n model.load_state_dict(saved_state_dict)\\n model.eval()\\n model.cuda(gpu0)\\n\\n testloader = data.DataLoader(DarkZurichDataSet(args.data_dir, args.data_list, crop_size=(h, w), resize_size=(w, h), mean=IMG_MEAN, scale=False, mirror=False, set=args.set),\\n batch_size=batchsize, shuffle=False, pin_memory=True, num_workers=4)\\n\\n scale = 1.25\\n testloader2 = data.DataLoader(DarkZurichDataSet(args.data_dir, args.data_list, crop_size=(round(h*scale), round(w*scale) ), resize_size=( round(w*scale), round(h*scale)), mean=IMG_MEAN, scale=False, mirror=False, set=args.set),\\n batch_size=batchsize, shuffle=False, pin_memory=True, num_workers=4)\\n\\n\\n if version.parse(torch.__version__) >= version.parse('0.4.0'):\\n interp = nn.Upsample(size=(1080, 1920), mode='bilinear', align_corners=True)\\n else:\\n interp = nn.Upsample(size=(1080, 1920), mode='bilinear')\\n\\n sm = torch.nn.Softmax(dim = 1)\\n log_sm = torch.nn.LogSoftmax(dim = 1)\\n kl_distance = nn.KLDivLoss( reduction = 'none')\\n prior = np.load('./utils/prior_all.npy').transpose((2,0,1))[np.newaxis, :, :, :]\\n prior = torch.from_numpy(prior)\\n for index, img_data in enumerate(zip(testloader, testloader2) ):\\n batch, batch2 = img_data\\n image, _, name = batch\\n image2, _, name2 = batch2\\n\\n inputs = image.cuda()\\n inputs2 = image2.cuda()\\n print('\\\\r>>>>Extracting feature...%04d/%04d'%(index*batchsize, args.batchsize*len(testloader)), end='')\\n if args.model == 'DeepLab':\\n with torch.no_grad():\\n output1, output2 = model(inputs)\\n output_batch = interp(sm(0.5* output1 + output2))\\n\\n heatmap_batch = torch.sum(kl_distance(log_sm(output1), sm(output2)), dim=1)\\n\\n output1, output2 = model(fliplr(inputs))\\n output1, output2 = fliplr(output1), fliplr(output2)\\n output_batch += interp(sm(0.5 * output1 + output2))\\n del output1, output2, inputs\\n\\n output1, output2 = model(inputs2)\\n output_batch += interp(sm(0.5* output1 + output2))\\n output1, output2 = model(fliplr(inputs2))\\n output1, output2 = fliplr(output1), fliplr(output2)\\n output_batch += interp(sm(0.5 * output1 + output2))\\n del output1, output2, inputs2\\n ratio = 0.95\\n output_batch = output_batch.cpu() / 4\\n # output_batch = output_batch *(ratio + (1 - ratio) * prior)\\n output_batch = output_batch.data.numpy()\\n heatmap_batch = heatmap_batch.cpu().data.numpy()\\n elif args.model == 'DeeplabVGG' or args.model == 'Oracle':\\n output_batch = model(Variable(image).cuda())\\n output_batch = interp(output_batch).cpu().data.numpy()\\n\\n output_batch = output_batch.transpose(0,2,3,1)\\n score_batch = np.max(output_batch, axis=3)\\n output_batch = np.asarray(np.argmax(output_batch, axis=3), dtype=np.uint8)\\n\\n threshold = 0.3274\\n for i in range(output_batch.shape[0]):\\n output_single = output_batch[i,:,:]\\n output_col = colorize_mask(output_single)\\n output = Image.fromarray(output_single)\\n\\n name_tmp = name[i].split('/')[-1]\\n dir_name = name[i].split('/')[-2]\\n save_path = args.save + '/' + dir_name\\n if not os.path.isdir(save_path):\\n os.mkdir(save_path)\\n output.save('%s/%s' % (save_path, name_tmp))\\n print('%s/%s' % (save_path, name_tmp))\\n output_col.save('%s/%s_color.png' % (save_path, name_tmp.split('.')[0]))\\n\\n # heatmap_tmp = heatmap_batch[i,:,:]/np.max(heatmap_batch[i,:,:])\\n # fig = plt.figure()\\n # plt.axis('off')\\n # heatmap = plt.imshow(heatmap_tmp, cmap='viridis')\\n # fig.colorbar(heatmap)\\n # fig.savefig('%s/%s_heatmap.png' % (save_path, name_tmp.split('.')[0]))\\n\\n if args.set == 'test' or args.set == 'val':\\n # label\\n output.save('%s/%s' % (label_path, name_tmp))\\n # label invalid\\n output_single[score_batch[i, :, :] < threshold] = 255\\n output = Image.fromarray(output_single)\\n output.save('%s/%s' % (label_invalid_path, name_tmp))\\n # conficence\\n\\n confidence = score_batch[i, :, :] * 65535\\n confidence = np.asarray(confidence, dtype=np.uint16)\\n print(confidence.min(), confidence.max())\\n iio.imwrite('%s/%s' % (confidence_path, name_tmp), confidence)\\n\\n return args.save\",\n \"def get_config():\\n\\n parser = argparse.ArgumentParser(\\n description='ZoomingSloMo or only Slo-Mo training argument parser')\\n parser.add_argument('--cfg', default=\\\"./config.yaml\\\")\\n args, _ = parser.parse_known_args()\\n conf = read_yaml(args.cfg)\\n\\n parser.add_argument('--lmdb-data-gt', type=str, default=\\\"datasets/\\\",\\n help='Path to HR frames lmdb for training')\\n\\n parser.add_argument('--lmdb-data-lq', type=str, default=\\\"datasets/\\\",\\n help='Path to LR frames lmdb for training')\\n\\n parser.add_argument('--output-dir', type=str, default=\\\"models/\\\",\\n help='Path to store trained models')\\n\\n parser.add_argument('--batch-size', type=int, default=\\\"12\\\",\\n help='Maximum number of iterations for training')\\n\\n parser.add_argument('--gt-size', type=int, default=128,\\n help='Ground truth frame size')\\n\\n parser.add_argument('--only-slomo', action='store_true', default=False,\\n help='If True, network will train for Slo-Mo only (No Zooming)')\\n\\n args = parser.parse_args()\\n\\n # Refine config file variables\\n conf.data.lmdb_data_gt = args.lmdb_data_gt\\n conf.data.lmdb_data_lq = args.lmdb_data_lq\\n conf.data.output_dir = args.output_dir\\n conf.train.batch_size = args.batch_size\\n conf.train.only_slomo = args.only_slomo\\n conf.data.gt_size = args.gt_size if not args.only_slomo else args.gt_size // 4\\n conf.data.lr_size = args.gt_size // 4\\n\\n return conf\",\n \"def load_config(args):\\n # Setup cfg.\\n cfg = get_cfg()\\n # Load config from cfg.\\n if args.cfg_file is not None:\\n cfg.merge_from_file(args.cfg_file)\\n # Load config from command line, overwrite config from opts.\\n if args.opts is not None:\\n cfg.merge_from_list(args.opts)\\n\\n # Inherit parameters from args.\\n if hasattr(args, \\\"num_shards\\\") and hasattr(args, \\\"shard_id\\\"):\\n cfg.NUM_SHARDS = args.num_shards\\n cfg.SHARD_ID = args.shard_id\\n if hasattr(args, \\\"rng_seed\\\"):\\n cfg.RNG_SEED = args.rng_seed\\n if hasattr(args, \\\"output_dir\\\"):\\n cfg.OUTPUT_DIR = args.output_dir\\n\\n # Create the checkpoint dir.\\n # cu.make_checkpoint_dir(cfg.OUTPUT_DIR)\\n\\n return cfg\",\n \"def predict_input_args():\\n # Create Parse using ArgumentParser\\n parser = argparse.ArgumentParser()\\n parser.add_argument('image', type = str, help = 'Path to the folder and file name of image to be checked') \\n parser.add_argument('checkpoint', type = str, help = 'Checkpoint folder name') \\n parser.add_argument('--gpu', type = bool, default = False, help = 'True = GPU enabled, False = GPU disabled') \\n parser.add_argument('--topk', type = int, default = 5, help = 'Top number of class predicitions') \\n parser.add_argument('--json', type = str, default = 'cat_to_name.json', help = 'Path to the folder and file name of JSON map used') \\n return parser.parse_args()\",\n \"def _parse_args():\\n\\n \\\"\\\"\\\"\\n Add arguments below. Example format:\\n parser.add_argument('-cp', '--continue_training_policy',\\n action='store_true', help='A help message'\\n )\\n\\n parser.add_argument('--q1_checkpoint_filename', type=str,\\n default='./q1_checkpoint.pth', help=\\\"Name of file to save and load\\\"\\n )\\n \\\"\\\"\\\"\\n parser = argparse.ArgumentParser(\\n description=\\\"Arguments for Experience Replay project\\\"\\n )\\n # Model related arguments here\\n parser.add_argument(\\\"--env_name\\\", type=str, default=\\\"CartPole-v1\\\")\\n parser.add_argument(\\n \\\"--no_alpha_tune\\\", dest=\\\"alph_tune\\\", default=True, action=\\\"store_false\\\"\\n )\\n parser.add_argument(\\\"--eval_freq\\\", type=int, default=10000)\\n # Training related arguments here\\n parser.add_argument(\\\"--rand_seed\\\", type=int, default=1)\\n parser.add_argument(\\\"--log_dir\\\", type=str, default=None)\\n parser.add_argument(\\\"-t\\\", \\\"--time_limit\\\", type=int, default=10_000)\\n parser.add_argument(\\\"-s\\\", \\\"--steps\\\", type=int, default=1_000_000)\\n parser.add_argument(\\\"-n\\\", \\\"--num_episodes\\\", type=int, default=1000)\\n parser.add_argument(\\\"-lr\\\", \\\"--learning_rate\\\", type=float, default=1e-3)\\n parser.add_argument(\\\"-c\\\", \\\"--continue_training\\\", action=\\\"store_true\\\")\\n parser.add_argument(\\\"--batch_size\\\", type=int, default=256)\\n parser.add_argument(\\\"--buff_size\\\", type=int, default=100000)\\n\\n args = parser.parse_args()\\n return args\",\n \"def setup_args():\\n parser = ParlaiParser()\\n parser.add_argument(\\n '-n',\\n '--num-episodes',\\n default=-1,\\n type=int,\\n help='Total number of episodes to convert, -1 to convert all examples',\\n )\\n parser.add_argument(\\n '-of',\\n '--outfile',\\n default=None,\\n type=str,\\n help='Output file where to save, by default will be created in /tmp',\\n )\\n parser.add_argument(\\n '-s1id', '--speaker-0-id', type=str, help='Speaker id of agent who speaks first'\\n )\\n parser.add_argument(\\n '-s1id',\\n '--speaker-1-id',\\n type=str,\\n help='Speaker id of agent who speaks second',\\n )\\n parser.add_argument(\\n '--prepended-context',\\n type='bool',\\n default=False,\\n help='specify if the context is prepended to the first act',\\n )\\n parser.add_argument('-ltim', '--log-every-n-secs', type=float, default=10)\\n parser.set_defaults(datatype='train:ordered')\\n\\n return parser\",\n \"def parse_args():\\n parser = argparse.ArgumentParser('Reading Comprehension on BaiduRC dataset')\\n parser.add_argument('--prepare', action='store_true',\\n help='create the directories, prepare the vocabulary and embeddings')\\n parser.add_argument('--train', action='store_true',\\n help='train the model')\\n parser.add_argument('--generate', action='store_true',\\n help='predict the answers for test set with trained model')\\n parser.add_argument('--gentest', action='store_true',\\n help='predict the answers for test set with trained model')\\n parser.add_argument('--gpu', type=str, default='0',\\n help='specify gpu device')\\n\\n train_settings = parser.add_argument_group('train settings')\\n train_settings.add_argument('--optim', default='Adam',\\n help='optimizer type')\\n train_settings.add_argument('--learning_rate', type=float, default=0.001,\\n help='learning rate')\\n train_settings.add_argument('--weight_decay', type=float, default=0,\\n help='weight decay')\\n train_settings.add_argument('--dropout', type=float, default=0,\\n help='dropout keep rate')\\n train_settings.add_argument('--batch_size', type=int, default=128,\\n help='train batch size')\\n train_settings.add_argument('--epochs', type=int, default=10,\\n help='train epochs')\\n\\n model_settings = parser.add_argument_group('model settings')\\n model_settings.add_argument('--embed_size', type=int, default=128,\\n help='size of the embeddings')\\n model_settings.add_argument('--hidden_size', type=int, default=256,\\n help='size of LSTM hidden units')\\n model_settings.add_argument('--max_seq_len', type=int, default=50,\\n help='max passage num in one sample')\\n model_settings.add_argument('--max_gen_len', type=int, default=50,\\n help='max length of passage')\\n\\n path_settings = parser.add_argument_group('path settings')\\n path_settings.add_argument('--vocab_dir', default='../data/vocab/',\\n help='the dir to save vocabulary')\\n path_settings.add_argument('--model_dir', default='../data/models/',\\n help='the dir to store models')\\n path_settings.add_argument('--result_dir', default='../data/results/',\\n help='the dir to output the results')\\n path_settings.add_argument('--summary_dir', default='../data/summary/',\\n help='the dir to write tensorboard summary')\\n path_settings.add_argument('--log_path',\\n help='path of the log file. If not set, logs are printed to console')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Train a model for image classification (Keras)\\\",\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n parser.add_argument(\\n \\\"--rec-train\\\",\\n type=str,\\n default=\\\"../imgclsmob_data/imagenet_rec/train.rec\\\",\\n help=\\\"the training data\\\")\\n parser.add_argument(\\n \\\"--rec-train-idx\\\",\\n type=str,\\n default=\\\"../imgclsmob_data/imagenet_rec/train.idx\\\",\\n help='the index of training data')\\n parser.add_argument(\\n \\\"--rec-val\\\",\\n type=str,\\n default=\\\"../imgclsmob_data/imagenet_rec/val.rec\\\",\\n help=\\\"the validation data\\\")\\n parser.add_argument(\\n \\\"--rec-val-idx\\\",\\n type=str,\\n default=\\\"../imgclsmob_data/imagenet_rec/val.idx\\\",\\n help=\\\"the index of validation data\\\")\\n\\n parser.add_argument(\\n \\\"--model\\\",\\n type=str,\\n required=True,\\n help=\\\"type of model to use. see model_provider for options\\\")\\n parser.add_argument(\\n \\\"--use-pretrained\\\",\\n action=\\\"store_true\\\",\\n help=\\\"enable using pretrained model from github repo\\\")\\n parser.add_argument(\\n \\\"--dtype\\\",\\n type=str,\\n default=\\\"float32\\\",\\n help=\\\"data type for training\\\")\\n parser.add_argument(\\n \\\"--resume\\\",\\n type=str,\\n default=\\\"\\\",\\n help=\\\"resume from previously saved parameters if not None\\\")\\n parser.add_argument(\\n \\\"--resume-state\\\",\\n type=str,\\n default=\\\"\\\",\\n help=\\\"resume from previously saved optimizer state if not None\\\")\\n\\n parser.add_argument(\\n \\\"--input-size\\\",\\n type=int,\\n default=224,\\n help=\\\"size of the input for model\\\")\\n parser.add_argument(\\n \\\"--resize-inv-factor\\\",\\n type=float,\\n default=0.875,\\n help=\\\"inverted ratio for input image crop\\\")\\n\\n parser.add_argument(\\n \\\"--num-gpus\\\",\\n type=int,\\n default=0,\\n help=\\\"number of gpus to use\\\")\\n parser.add_argument(\\n \\\"-j\\\",\\n \\\"--num-data-workers\\\",\\n dest=\\\"num_workers\\\",\\n default=4,\\n type=int,\\n help=\\\"number of preprocessing workers\\\")\\n\\n parser.add_argument(\\n \\\"--batch-size\\\",\\n type=int,\\n default=512,\\n help=\\\"training batch size per device (CPU/GPU)\\\")\\n parser.add_argument(\\n \\\"--num-epochs\\\",\\n type=int,\\n default=120,\\n help=\\\"number of training epochs\\\")\\n parser.add_argument(\\n \\\"--start-epoch\\\",\\n type=int,\\n default=1,\\n help=\\\"starting epoch for resuming, default is 1 for new training\\\")\\n parser.add_argument(\\n \\\"--attempt\\\",\\n type=int,\\n default=1,\\n help=\\\"current number of training\\\")\\n\\n parser.add_argument(\\n \\\"--optimizer-name\\\",\\n type=str,\\n default=\\\"nag\\\",\\n help=\\\"optimizer name\\\")\\n parser.add_argument(\\n \\\"--lr\\\",\\n type=float,\\n default=0.1,\\n help=\\\"learning rate\\\")\\n parser.add_argument(\\n \\\"--momentum\\\",\\n type=float,\\n default=0.9,\\n help=\\\"momentum value for optimizer\\\")\\n parser.add_argument(\\n \\\"--wd\\\",\\n type=float,\\n default=0.0001,\\n help=\\\"weight decay rate\\\")\\n\\n parser.add_argument(\\n \\\"--log-interval\\\",\\n type=int,\\n default=50,\\n help=\\\"number of batches to wait before logging\\\")\\n parser.add_argument(\\n \\\"--save-interval\\\",\\n type=int,\\n default=4,\\n help=\\\"saving parameters epoch interval, best model will always be saved\\\")\\n parser.add_argument(\\n \\\"--save-dir\\\",\\n type=str,\\n default=\\\"\\\",\\n help=\\\"directory of saved models and log-files\\\")\\n parser.add_argument(\\n \\\"--logging-file-name\\\",\\n type=str,\\n default=\\\"train.log\\\",\\n help=\\\"filename of training log\\\")\\n\\n parser.add_argument(\\n \\\"--seed\\\",\\n type=int,\\n default=-1,\\n help=\\\"Random seed to be fixed\\\")\\n parser.add_argument(\\n \\\"--log-packages\\\",\\n type=str,\\n default=\\\"keras\\\",\\n help=\\\"list of python packages for logging\\\")\\n parser.add_argument(\\n \\\"--log-pip-packages\\\",\\n type=str,\\n default=\\\"keras, keras-mxnet, keras-applications, keras-preprocessing\\\",\\n help=\\\"list of pip packages for logging\\\")\\n args = parser.parse_args()\\n return args\",\n \"def setup(args):\\n cfg = get_cfg()\\n add_imaterialist_config(cfg)\\n cfg.merge_from_file(model_zoo.get_config_file(\\\"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml\\\"))\\n cfg.merge_from_file(args.config_file)\\n \\n cfg.merge_from_list(args.opts)\\n cfg.freeze()\\n default_setup(cfg, args)\\n # Setup logger for \\\"imaterialist\\\" module\\n setup_logger(output=cfg.OUTPUT_DIR, distributed_rank=comm.get_rank(), name=\\\"imaterialist\\\")\\n return cfg\",\n \"def parse_args(args):\\n parser = argparse.ArgumentParser(\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\\n description='Train a detection model from an already prepared dataset')\\n\\n # Mandatory arguments\\n parser.add_argument(\\n 'base_dataset_dir', help='directory containing the prepared dataset')\\n\\n parser.add_argument('dataset_dir', help='path to temporary directory')\\n\\n # Options\\n parser.add_argument(\\n '-o',\\n '--output-model',\\n default='model.h5',\\n help='filename for output model')\\n\\n parser.add_argument(\\n '--seed', type=int, help='seed number for the random number generator')\\n parser.add_argument(\\n \\\"--test-size\\\",\\n type=float,\\n default=0.25,\\n help=(\\\"The proportion of the dataset to include in the test split. \\\"\\n \\\"Float number between 0.0 and 1.0\\\"))\\n parser.add_argument(\\n \\\"--validation-size\\\",\\n type=float,\\n default=0.25,\\n help=(\\n \\\"The proportion of the dataset to include in the validation split. \\\"\\n \\\"Float number between 0.0 and 1.0\\\"))\\n parser.add_argument(\\n \\\"--balancing-multiplier\\\",\\n type=float,\\n default=1.0,\\n help=\\n \\\"proportion of false samples w.r.t true samples (e.g. 1.0 = 50%% true, 50%% false)\\\"\\n )\\n parser.add_argument(\\n \\\"--trainable-layers\\\",\\n type=int,\\n default=5,\\n help=\\\"number of upper layers of ResNet-50 to retrain\\\")\\n parser.add_argument(\\\"--batch-size\\\", type=int, default=5, help=\\\"Batch size\\\")\\n parser.add_argument(\\n \\\"--epochs\\\", type=int, default=20, help=\\\"number of epochs to run\\\")\\n\\n parser.add_argument(\\n '--version',\\n action='version',\\n version='aplatam {ver}'.format(ver=__version__))\\n parser.add_argument(\\n '-v',\\n '--verbose',\\n dest=\\\"loglevel\\\",\\n help=\\\"set loglevel to INFO\\\",\\n action='store_const',\\n const=logging.INFO)\\n parser.add_argument(\\n '-vv',\\n '--very-verbose',\\n dest=\\\"loglevel\\\",\\n help=\\\"set loglevel to DEBUG\\\",\\n action='store_const',\\n const=logging.DEBUG)\\n\\n return parser.parse_args(args)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='Eval')\\n parser.add_argument(\\n '--cfg', help='experiment configure file path', type=str, \\\\\\n default=\\\"validation.config.Config\\\")\\n return parser.parse_args()\",\n \"def main() -> None:\\n parser = ArgumentParser(description=\\\"SoccerPredictor:\\\", formatter_class=ArgumentDefaultsHelpFormatter)\\n subparsers = parser.add_subparsers(title=\\\"Modes to run\\\", dest=\\\"command\\\")\\n\\n # Trainer args\\n trainer_parser = subparsers.add_parser(RunMode.Train.value, help=\\\"Trains model and makes predictions.\\\",\\n formatter_class=ArgumentDefaultsHelpFormatter)\\n trainer_parser.add_argument(\\\"--resume\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"Resumes training of previously saved model. \\\"\\n \\\"Tries to load the latest model saved if no name or prefix specified via --name.\\\")\\n trainer_parser.add_argument(\\\"--epochs\\\", type=int, action=\\\"store\\\", default=1,\\n help=\\\"Number of epochs to train model for.\\\")\\n trainer_parser.add_argument(\\\"--ntest\\\", type=int, action=\\\"store\\\", default=10,\\n help=\\\"Number of last samples used for testing for each team.\\\")\\n trainer_parser.add_argument(\\\"--ndiscard\\\", type=int, action=\\\"store\\\", default=0,\\n help=\\\"Number of last samples to discard for each team.\\\")\\n trainer_parser.add_argument(\\\"--timesteps\\\", type=int, action=\\\"store\\\", default=40,\\n help=\\\"Number of timesteps to use as data window size for input to network.\\\")\\n trainer_parser.add_argument(\\\"--predict\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"Whether to rerun predictions without any training.\\\")\\n trainer_parser.add_argument(\\\"--lrpatience\\\", type=int, action=\\\"store\\\", default=20,\\n help=\\\"How many epochs to tolerate before decaying learning rate if no improvement. \\\"\\n \\\"Turned off if 0.\\\")\\n trainer_parser.add_argument(\\\"--lrdecay\\\", type=float, action=\\\"store\\\", default=0.95,\\n help=\\\"How much to decay learning rate after patience exceeded.\\\")\\n trainer_parser.add_argument(\\\"--seed\\\", type=int, action=\\\"store\\\",\\n help=\\\"Specifies seed for rng.\\\")\\n trainer_parser.add_argument(\\\"--savefreq\\\", type=int, action=\\\"store\\\", default=50,\\n help=\\\"How often (number of epochs) to save models. No intermediate saving if 0.\\\")\\n trainer_parser.add_argument(\\\"--printfreq\\\", type=int, action=\\\"store\\\", default=10,\\n help=\\\"How often (number of epochs) to print current summaries. \\\"\\n \\\"No intermediate printing if 0.\\\")\\n trainer_parser.add_argument(\\\"--verbose\\\", type=int, action=\\\"store\\\", choices=VERBOSITY_LEVELS, default=1,\\n help=\\\"Level of verbosity.\\\")\\n\\n # Visualizer args\\n visualizer_parser = subparsers.add_parser(RunMode.Vis.value, help=\\\"Runs visualization of predictions.\\\",\\n formatter_class=ArgumentDefaultsHelpFormatter)\\n visualizer_parser.add_argument(\\\"--port\\\", type=int, action=\\\"store\\\", default=8050,\\n help=\\\"Custom port for Dash visualization.\\\")\\n visualizer_parser.add_argument(\\\"--host\\\", type=str, action=\\\"store\\\", default=\\\"127.0.0.1\\\",\\n help=\\\"Custom host for Dash visualization. Can use 0 for 0.0.0.0 shortcut.\\\")\\n\\n # Backtester args\\n backtester_parser = subparsers.add_parser(RunMode.Backtest.value, help=\\\"Runs backtesting on trained models.\\\",\\n formatter_class=ArgumentDefaultsHelpFormatter)\\n backtester_parser.add_argument(\\\"--path\\\", type=str, action=\\\"store\\\", default=f\\\"{DATA_DIR}{MODEL_DIR}\\\",\\n help=\\\"Path to folder where the trained models are saved.\\\")\\n\\n # common args for trainer and visualizer\\n for p in [trainer_parser, visualizer_parser]:\\n p.add_argument(\\\"--name\\\", type=str, action=\\\"store\\\",\\n help=\\\"Tries to load the latest saved model with given name prefix. \\\"\\n \\\"Loads exact model if exact dir name specified.\\\")\\n\\n # Common args for visualizer and backtester\\n for p in [visualizer_parser, backtester_parser]:\\n p.add_argument(\\\"--ignoreodds\\\", type=float, action=\\\"store\\\", default=1.10,\\n help=\\\"Ignores odds less than given amount when predicting which team to bet on.\\\")\\n\\n args = parser.parse_args()\\n\\n if args.command is None:\\n parser.print_help()\\n return\\n elif args.command == RunMode.Vis.value:\\n print(\\\"Visualizing...\\\")\\n vis_args, _ = visualizer_parser.parse_known_args()\\n check_visualizer_args(visualizer_parser, vis_args)\\n print(vis_args)\\n\\n from soccerpredictor.visualizer import visualizer\\n try:\\n visualizer.run(vis_args.name, vis_args.host, vis_args.port, vis_args.ignoreodds)\\n except KeyboardInterrupt:\\n print(\\\"> Received CTRL+C command. Exiting.\\\")\\n elif args.command == RunMode.Backtest.value:\\n print(\\\"Backtesting...\\\")\\n backtest_args, _ = backtester_parser.parse_known_args()\\n check_backtester_args(backtester_parser, backtest_args)\\n print(backtest_args)\\n\\n from soccerpredictor.backtester import backtester\\n try:\\n backtester.run(backtest_args.path, backtest_args.ignoreodds)\\n except KeyboardInterrupt:\\n print(\\\"> Received CTRL+C command. Exiting.\\\")\\n elif args.command == RunMode.Train.value:\\n print(\\\"Running model...\\\")\\n train_args, _ = trainer_parser.parse_known_args()\\n config = SPConfig()\\n\\n # Implicitly set resume to true if we are predicting only\\n if train_args.predict and not train_args.resume:\\n train_args.resume = True\\n\\n check_trainer_args(trainer_parser, train_args)\\n config.set_args(train_args)\\n print(train_args)\\n\\n dbmanager = SPDBManager()\\n try:\\n dbmanager.connect()\\n\\n # Load previous settings if we resume training\\n if train_args.resume:\\n print(\\\"Resuming training, loading previous settings... \\\"\\n \\\"Any conflicting parameters will be ignored.\\\")\\n\\n # Load previous settings\\n folder = get_latest_models_dir(train_args.name)\\n model_settings = get_model_settings_file(folder)\\n # Restore original config\\n config.restore_args(model_settings)\\n set_rng_seed(config.seed)\\n\\n from soccerpredictor.trainer.trainer import SPTrainer\\n trainer = SPTrainer(dbmanager, model_settings=model_settings, folder=folder)\\n else:\\n # Need to generate folder prefix before seeding random number generators\\n import random\\n generated_folder_prefix = \\\"\\\".join(random.choices(ascii_uppercase, k=FOLDER_PREFIX_LEN))\\n print(f\\\"New generated folder prefix: '{generated_folder_prefix}'\\\")\\n set_rng_seed(train_args.seed)\\n\\n from soccerpredictor.trainer.trainer import SPTrainer\\n trainer = SPTrainer(dbmanager, generated_folder_prefix=generated_folder_prefix)\\n\\n try:\\n trainer.run()\\n finally:\\n trainer.cleanup()\\n\\n except KeyboardInterrupt:\\n print(\\\"> Received CTRL+C command. Exiting.\\\")\\n except (FileNotFoundError, ValueError, OperationalError) as e:\\n print(e)\\n sys.exit(1)\\n finally:\\n dbmanager.disconnect()\",\n \"def main():\\n if len(sys.argv) == 3:\\n database_filepath, model_filepath = sys.argv[1:]\\n nltk.download(['punkt', 'wordnet'])\\n print('Loading data...\\\\n DATABASE: {}'.format(database_filepath))\\n X, Y, category_names = load_data(database_filepath)\\n X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)\\n\\n print('Building model...')\\n model = build_model()\\n\\n print('Training model...')\\n model.fit(X_train, Y_train)\\n\\n print('Evaluating model...')\\n evaluate_model(model, X_test, Y_test, category_names)\\n\\n print('Saving model...\\\\n MODEL: {}'.format(model_filepath))\\n save_model(model, model_filepath)\\n\\n print('Trained model saved!')\\n\\n else:\\n print('Please provide the filepath of the disaster messages database '\\\\\\n 'as the first argument and the filepath of the pickle file to '\\\\\\n 'save the model to as the second argument. \\\\n\\\\nExample: python '\\\\\\n 'train_classifier.py ../data/DisasterResponse.db classifier.pkl')\",\n \"def get_args(args_list=None):\\n\\n parser = argparse.ArgumentParser(description='SwissArmyTransformer')\\n parser = add_model_config_args(parser)\\n parser = add_training_args(parser)\\n parser = add_evaluation_args(parser)\\n parser = add_data_args(parser)\\n parser = add_tokenization_args(parser)\\n parser = add_text_generate_args(parser)\\n\\n # Include DeepSpeed configuration arguments\\n parser = deepspeed.add_config_arguments(parser)\\n\\n args = parser.parse_args(args_list)\\n\\n if not args.train_data:\\n print('WARNING: No training data specified')\\n\\n assert (args.train_iters is None)^(args.epochs is None)\\n\\n args.cuda = torch.cuda.is_available()\\n\\n args.rank = int(os.getenv('RANK', '0'))\\n args.world_size = int(os.getenv(\\\"WORLD_SIZE\\\", '1'))\\n if args.local_rank is None:\\n args.local_rank = int(os.getenv(\\\"LOCAL_RANK\\\", '0')) # torchrun\\n \\n if args.device == -1: # not set manually\\n args.device = args.rank % torch.cuda.device_count()\\n if args.local_rank is not None:\\n args.device = args.local_rank\\n\\n # local rank should be consistent with device in DeepSpeed\\n if args.local_rank != args.device and args.mode != 'inference':\\n raise ValueError(\\n 'LOCAL_RANK (default 0) and args.device inconsistent. '\\n 'This can only happens in inference mode. '\\n 'Please use CUDA_VISIBLE_DEVICES=x for single-GPU training. '\\n )\\n\\n # args.model_parallel_size = min(args.model_parallel_size, args.world_size)\\n if args.rank == 0:\\n print('using world size: {} and model-parallel size: {} '.format(\\n args.world_size, args.model_parallel_size))\\n if args.vocab_size > 0:\\n _adjust_vocab_size(args)\\n \\n if args.train_data_weights is not None:\\n assert len(args.train_data_weights) == len(args.train_data)\\n \\n if args.mode != 'inference': # training with deepspeed\\n args.deepspeed = True\\n if args.deepspeed_config is None: # not specified\\n args.deepspeed_config = os.path.join(os.path.dirname(__file__), 'training', f'deepspeed_zero{args.zero_stage}.json')\\n override_deepspeed_config = True\\n else:\\n override_deepspeed_config = False\\n if args.zero_stage > 0:\\n if args.rank == 0 and not args.fp16:\\n print('Automatically set fp16=True to use ZeRO.') \\n args.fp16 = True\\n args.bf16 = False\\n\\n if args.deepspeed:\\n if args.checkpoint_activations:\\n args.deepspeed_activation_checkpointing = True\\n else:\\n args.deepspeed_activation_checkpointing = False\\n if args.deepspeed_config is not None:\\n with open(args.deepspeed_config) as file:\\n deepspeed_config = json.load(file)\\n \\n if override_deepspeed_config: # not specify deepspeed_config, use args\\n if args.fp16:\\n deepspeed_config[\\\"fp16\\\"][\\\"enabled\\\"] = True\\n else:\\n deepspeed_config[\\\"fp16\\\"][\\\"enabled\\\"] = False\\n deepspeed_config[\\\"train_micro_batch_size_per_gpu\\\"] = args.batch_size\\n deepspeed_config[\\\"gradient_accumulation_steps\\\"] = args.gradient_accumulation_steps\\n optimizer_params_config = deepspeed_config[\\\"optimizer\\\"][\\\"params\\\"]\\n optimizer_params_config[\\\"lr\\\"] = args.lr\\n optimizer_params_config[\\\"weight_decay\\\"] = args.weight_decay\\n else: # override args with values in deepspeed_config\\n if args.rank == 0:\\n print('Will override arguments with manually specified deepspeed_config!')\\n if \\\"fp16\\\" in deepspeed_config and deepspeed_config[\\\"fp16\\\"][\\\"enabled\\\"]:\\n args.fp16 = True\\n else:\\n args.fp16 = False\\n if \\\"train_micro_batch_size_per_gpu\\\" in deepspeed_config:\\n args.batch_size = deepspeed_config[\\\"train_micro_batch_size_per_gpu\\\"]\\n if \\\"gradient_accumulation_steps\\\" in deepspeed_config:\\n args.gradient_accumulation_steps = deepspeed_config[\\\"gradient_accumulation_steps\\\"]\\n else:\\n args.gradient_accumulation_steps = None\\n if \\\"optimizer\\\" in deepspeed_config:\\n optimizer_params_config = deepspeed_config[\\\"optimizer\\\"].get(\\\"params\\\", {})\\n args.lr = optimizer_params_config.get(\\\"lr\\\", args.lr)\\n args.weight_decay = optimizer_params_config.get(\\\"weight_decay\\\", args.weight_decay)\\n args.deepspeed_config = deepspeed_config\\n \\n if args.sandwich_ln:\\n args.layernorm_order = 'sandwich'\\n # initialize distributed and random seed because it always seems to be necessary.\\n initialize_distributed(args)\\n set_random_seed(args.seed)\\n return args\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n '--ori_dir', type=str, default=os.path.join(Constants.TRAIN_PATH, 'para_train_ori.pt'),\\n help='source training data location.'\\n )\\n parser.add_argument(\\n '--ref_dir', type=str, default=os.path.join(Constants.TRAIN_PATH, 'para_train_ref.pt'),\\n help='reference training data location.'\\n )\\n parser.add_argument(\\n '--dict_dir', type=str, default=os.path.join(Constants.TRAIN_PATH, 'para_train_dict.pt'),\\n help='token to index dictionary save location.'\\n )\\n parser.add_argument(\\n '--epoch', type=int, default=20, help='number of training epochs'\\n )\\n parser.add_argument(\\n '--lr', type=float, default=2.0, help='learning rate scale factor'\\n )\\n parser.add_argument(\\n '--batch_size', type=int, default=128, help='batch size'\\n )\\n parser.add_argument(\\n '--d_model', type=int, default=256, help='model dimension'\\n )\\n parser.add_argument(\\n '--d_inner', type=int, default=1024, help='inner dimension'\\n )\\n parser.add_argument(\\n '--d_k', type=int, default=64, help='dimension of key and query'\\n )\\n parser.add_argument(\\n '--d_v', type=int, default=64, help='dimension of value'\\n )\\n parser.add_argument(\\n '--n_trf_txt_enc_layer', type=int, default=4, help='number of text Transformer encoder layers'\\n )\\n parser.add_argument(\\n '--n_trf_syn_enc_layer', type=int, default=2, help='number of syntax Transformer encoder layers'\\n )\\n parser.add_argument(\\n '--n_trf_dec_layer', type=int, default=6, help='number of Transformer decoder layers'\\n )\\n parser.add_argument(\\n '--n_txt_attn_head', type=int, default=4, help='number of text encoder attention heads'\\n )\\n parser.add_argument(\\n '--n_syn_attn_head', type=int, default=2, help='number of syntax encoder attention heads'\\n )\\n parser.add_argument(\\n '--dropout', type=float, default=0.1, help='dropout ratio'\\n )\\n parser.add_argument(\\n '--tgt_emb_prj_weight_sharing', action='store_true',\\n help='whether share weights between embedding and projection layers'\\n )\\n parser.add_argument(\\n '--log', type=str, default=os.path.join('logs', 'LogFile'), help='log filepath to save'\\n )\\n parser.add_argument(\\n '--model_save', type=str, default=os.path.join('models', 'model'),\\n help='the path of the model to save'\\n )\\n parser.add_argument(\\n '--no_cuda', action='store_true', help='disable cuda'\\n )\\n parser.add_argument(\\n '--label_smoothing', action='store_true', help='whether use label smoothing'\\n )\\n parser.add_argument(\\n '--n_warmup_steps', type=int, default=12800, help='number of warm-up steps'\\n )\\n parser.add_argument(\\n '--pin_memory', action='store_true', help='whether pin your cuda memory during training'\\n )\\n parser.add_argument(\\n '--random_seed', type=int, default=42\\n )\\n\\n args = parser.parse_args()\\n args.cuda = not args.no_cuda and torch.cuda.is_available()\\n\\n return args\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n\\n # Add arguments to parser\\n parser.add_argument(\\n '-base_data_dir', default='../data',\\n help='Root directory of data', type=str)\\n parser.add_argument(\\n '-dataset', default='litbank', choices=['litbank', 'ontonotes'], type=str)\\n parser.add_argument('-base_model_dir',\\n default='../models',\\n help='Root folder storing model runs', type=str)\\n parser.add_argument('-model_size', default='large', type=str,\\n help='BERT model type')\\n parser.add_argument('-doc_enc', default='overlap', type=str,\\n choices=['independent', 'overlap'], help='BERT model type')\\n parser.add_argument('-pretrained_bert_dir', default='../resources', type=str,\\n help='SpanBERT model location')\\n parser.add_argument('-max_segment_len', default=512, type=int,\\n help='Max segment length of BERT segments.')\\n parser.add_argument('-top_span_ratio', default=0.3, type=float,\\n help='Ratio of top spans proposed as mentions.')\\n\\n parser.add_argument('-ment_emb', default='endpoint', choices=['attn', 'max', 'endpoint'],\\n type=str)\\n parser.add_argument('-max_span_width',\\n help='Max span width', default=20, type=int)\\n parser.add_argument('-mlp_depth', default=1, type=int,\\n help='Number of hidden layers in other MLPs')\\n parser.add_argument('-mlp_size', default=3000, type=int,\\n help='MLP size used in the model')\\n\\n parser.add_argument('-cross_val_split', default=0, type=int,\\n help='Cross validation split to be used.')\\n parser.add_argument('--batch_size', '-bsize',\\n help='Batch size', default=1, type=int)\\n parser.add_argument('-num_train_docs', default=None, type=int,\\n help='Number of training docs.')\\n parser.add_argument('-dropout_rate', default=0.3, type=float,\\n help='Dropout rate')\\n parser.add_argument('-max_epochs',\\n help='Maximum number of epochs', default=25, type=int)\\n parser.add_argument('-seed', default=0,\\n help='Random seed to get different runs', type=int)\\n parser.add_argument('-init_lr', help=\\\"Initial learning rate\\\",\\n default=5e-4, type=float)\\n parser.add_argument('-checkpoint', help=\\\"Use checkpoint\\\",\\n default=False, action=\\\"store_true\\\")\\n parser.add_argument('-eval', help=\\\"Evaluate model\\\",\\n default=False, action=\\\"store_true\\\")\\n parser.add_argument('-slurm_id', help=\\\"Slurm ID\\\",\\n default=None, type=str)\\n\\n args = parser.parse_args()\\n\\n model_name = get_mention_model_name(args)\\n print(model_name)\\n\\n model_dir = path.join(args.base_model_dir, model_name)\\n args.model_dir = model_dir\\n best_model_dir = path.join(model_dir, 'best_models')\\n args.best_model_dir = best_model_dir\\n if not path.exists(model_dir):\\n os.makedirs(model_dir)\\n if not path.exists(best_model_dir):\\n os.makedirs(best_model_dir)\\n\\n if args.dataset == 'litbank':\\n args.data_dir = path.join(args.base_data_dir, f'{args.dataset}/{args.doc_enc}/{args.cross_val_split}')\\n else:\\n args.data_dir = path.join(args.base_data_dir, f'{args.dataset}/{args.doc_enc}')\\n\\n # if args.dataset == 'ontonotes':\\n # args.pretrained_model = path.join(\\n # args.pretrained_mention_model_dir, f'mention_ontonotes_{args.model_size}_{args.ment_emb}.pt')\\n # Log directory for Tensorflow Summary\\n\\n Experiment(**vars(args))\",\n \"def main():\\n\\n downloadData()\\n\\n parser = argparse.ArgumentParser(description=\\\"Train model or test model (default)\\\")\\n parser.add_argument(\\\"--train-model\\\", action=\\\"store_true\\\", default=False)\\n parser.add_argument(\\\"--num-channels\\\", type=int, help=\\\"Number of channels in lowest dimension\\\", default=8)\\n\\n arg_parser = parser.parse_args()\\n\\n if arg_parser.train_model:\\n encoder, generator = train(channels=arg_parser.num_channels)\\n torch.save(encoder.state_dict(), f\\\"../models/encoder_{arg_parser.num_channels}.model\\\")\\n torch.save(generator.state_dict(), f\\\"../models/generator_{arg_parser.num_channels}.model\\\")\\n else:\\n validate_models(VALIDATE_CHANNELS)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Trains a Discrete Spatial-BERT model.\\\"\\n )\\n parser.add_argument(\\n \\\"--checkpoint_path\\\",\\n type=str,\\n default=None,\\n help=\\\"Checkpoint to a pretrained model.\\\",\\n )\\n parser.add_argument(\\n \\\"--train_dataset_path\\\",\\n type=str,\\n default=\\\"data/train_dataset.json\\\",\\n help=\\\"Path to the train dataset.\\\",\\n )\\n parser.add_argument(\\n \\\"--val_dataset_path\\\",\\n type=str,\\n default=\\\"data/val_dataset.json\\\",\\n help=\\\"Path to the validation dataset.\\\",\\n )\\n parser.add_argument(\\n \\\"--visuals_dicts_path\\\",\\n type=str,\\n default=\\\"data/visuals_dicts/\\\",\\n help=\\\"Path to the directory with the visuals dictionaries.\\\",\\n )\\n parser.add_argument(\\n \\\"--mask_probability\\\", type=float, default=0.15, help=\\\"The mask probability.\\\"\\n )\\n parser.add_argument(\\\"--batch_size\\\", type=int, default=128, help=\\\"The batch size.\\\")\\n parser.add_argument(\\n \\\"--epochs\\\", type=int, default=1000, help=\\\"The number of epochs.\\\"\\n )\\n parser.add_argument(\\n \\\"--learning_rate\\\", type=float, default=2e-5, help=\\\"The learning rate.\\\"\\n )\\n parser.add_argument(\\n \\\"--clip_val\\\", type=float, default=2.0, help=\\\"The clipping threshold.\\\"\\n )\\n parser.add_argument(\\n \\\"--weight_decay\\\", type=float, default=0.0, help=\\\"The weight decay.\\\"\\n )\\n parser.add_argument(\\n \\\"--save_model_path\\\",\\n type=str,\\n default=\\\"models/best.pt\\\",\\n help=\\\"Where to save the model.\\\",\\n )\\n parser.add_argument(\\n \\\"--intermediate_save_checkpoint_path\\\",\\n type=str,\\n default=\\\"models/intermediate.pt\\\",\\n help=\\\"Where to save the intermediate checkpoint.\\\",\\n )\\n parser.add_argument(\\n \\\"--bert_name\\\",\\n type=str,\\n default=\\\"bert-base-uncased\\\",\\n help=\\\"The bert model name.\\\",\\n )\\n parser.add_argument(\\n \\\"--log_filepath\\\", type=str, default=None, help=\\\"The logging file.\\\"\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser(description=\\\"Train segmentation model via SGD.\\\")\\n\\n # Data\\n parser.add_argument(\\\"--data_dir\\\", help=\\\"Path to folder containing tfrecords\\\", required=True)\\n parser.add_argument(\\\"--fp_k_test_set\\\", help=\\\"Hold out the test task for the fp-k classes.\\\", action=\\\"store_true\\\")\\n parser.add_argument(\\\"--test_on_val_set\\\", help=\\\"If speced, will train on train shards and test on val shards, else will train on both train and val and test on test.\\\", action=\\\"store_true\\\")\\n\\n # Model\\n parser.add_argument('--model_name',\\n help=\\\"Name of the model architecture to meta-train. Must be in the set: {}.\\\".format(SUPPORTED_MODELS), required=False,\\n default='EfficientLab')\\n parser.add_argument(\\\"--rsd\\\", help=\\\"List of integers specifying the 1-indexed reduction endpionts from EfficientNet to input into the lightweight skip decoding layers of EfficientLab.\\\", type=int, nargs=\\\"+\\\")\\n parser.add_argument(\\\"--feature_extractor_name\\\", help=\\\"efficientnet-b0 or efficientnet-b3\\\", type=str, default=\\\"efficientnet-b0\\\")\\n parser.add_argument(\\\"--image_size\\\", help=\\\"size of image in pixels. images assumed to square\\\", type=int, default=224)\\n parser.add_argument(\\\"--seperate_background_channel\\\", help=\\\"Whether or not to make a mutually exclusive background channel.\\\", action='store_true', default=False)\\n\\n # Training\\n parser.add_argument(\\\"--restore_efficient_net_weights_from\\\", help=\\\"path to dir to restore efficientnet weights from\\\", type=str, default=None)\\n parser.add_argument('--sgd', help='use vanilla SGD instead of Adam', action='store_true')\\n parser.add_argument('--loss_name', help='Name of the loss function to use. Should be cross_entropy, cross_entropy_dice, or ce_dice', default='ce_dice')\\n parser.add_argument(\\\"--l2\\\", help=\\\"Applies l2 weight decay to all weights in network\\\", action=\\\"store_true\\\")\\n parser.add_argument(\\\"--augment\\\", help=\\\"Apply augmentations to training data\\\",\\n action=\\\"store_true\\\")\\n parser.add_argument(\\\"--final_layer_dropout_rate\\\", help=\\\"Probability to dropout inputs at final layer.\\\", type=float, default=0.0)\\n parser.add_argument('--batch_size', help='Training batch size', default=64, type=int)\\n parser.add_argument('--epochs', help='Number of training epochs', default=200, type=int)\\n parser.add_argument(\\\"--steps_per_epoch\\\", help=\\\"Number of gradient steps to take per epoch. If unspecified will be determined from batch size and number of examples.\\\", type=int, default=None)\\n parser.add_argument(\\\"--learning_rate\\\", default=0.005, type=float)\\n parser.add_argument(\\\"--final_learning_rate\\\", default=5e-7, type=float)\\n parser.add_argument(\\\"--label_smoothing\\\", default=0.0, type=float)\\n\\n\\n # Evaluation\\n parser.add_argument(\\\"--val_batches\\\", default=20, type=int)\\n parser.add_argument('--pretrained', help='Evaluate a pre-trained model.',\\n action='store_true', default=False)\\n parser.add_argument('--eval_interval', help='Training steps per evaluation', default=2, type=int)\\n\\n # Misc. config\\n parser.add_argument('--seed', help='random seed', default=0, type=int)\\n parser.add_argument('--checkpoint', help='Checkpoint directory to write to (or restore from).', default='/tmp/model_checkpoint', type=str)\\n return parser.parse_args()\",\n \"def config_and_train(self, sys_args):\\n \\n self.run_config_function(sys_args)\\n self.set_model_name('vgg_16')\\n self.set_trainable_and_exclude_scopes(constants.checkpoint_exclude_scopes,\\n constants.trainable_scopes)\\n self.set_optimizer('sgd')\\n self.set_max_number_of_steps(6000)\\n self.train_or_eval_net(sys_args)\",\n \"def add_models_args(parser):\\r\\n # Some common arguments for your convenience\\r\\n parser.add_argument('--seed', type=int, default=0, help='RNG seed (default = 0)')\\r\\n parser.add_argument('--epochs', type=int, default=10, help='num epochs to train for')\\r\\n parser.add_argument('--lr', type=float, default=1e-3)\\r\\n parser.add_argument('--batch_size', type=int, default=2, help='batch size')\\r\\n\\r\\n # 65 is all you need for GeoQuery\\r\\n parser.add_argument('--decoder_len_limit', type=int, default=65, help='output length limit of the decoder')\\r\\n\\r\\n # Feel free to add other hyperparameters for your input dimension, etc. to control your network\\r\\n # 50-200 might be a good range to start with for embedding and LSTM sizes\\r\",\n \"def get_input_args():\\n \\n parser = argparse.ArgumentParser()\\n \\n # command line parameter for dataset path\\n parser.add_argument('data_directory', action='store', type=str, \\n help='directory for new dataset to train')\\n \\n # command line parameter for saving checkpoint path \\n parser.add_argument('--save_dir',type=str,default='checkpoint',\\n help='directory where checkpoint is saved')\\n \\n # command line parameter to input model chosen. Defaults to vgg16. Chosen model can be either vgg16 or densenet121\\n parser.add_argument('--arch',type=str,default='vgg16',choices=('vgg16', 'densenet121'),\\n help='chosen model: vgg16 or densenet121')\\n \\n # command line parameter to input learning rate. Defaults to 0.00001\\n parser.add_argument('--learning_rate',type=float,default='0.00001',\\n help='learning rate for model')\\n \\n # command line parameter to input number of hidden units\\n parser.add_argument('--hidden_units',type=int,default=0,\\n help='add number of units in hidden layer to list')\\n \\n # command line paramter to input epochs. Defaults to 5\\n parser.add_argument('--epochs',type=int,default='5',\\n help='number of epochs')\\n \\n # command line parameter for using gpu\\n parser.add_argument('--gpu', action='store_true', default=False,\\n help='Set a switch to true')\\n \\n #return parsed argument collection\\n return parser.parse_args()\",\n \"def _parse_config(self, args, experiment_id):\\r\\n if not args:\\r\\n if experiment_id:\\r\\n config = importlib.import_module('configs.config_' + experiment_id)\\r\\n args = config.load_config()\\r\\n else:\\r\\n raise ValueError('No arguments or configuration data given')\\r\\n # Mandatory parameters for all architectures\\r\\n self.network_type = args.net\\r\\n self.is_training = args.training_mode\\r\\n self.train_data_file = args.train_data_file\\r\\n self.valid_data_file = args.valid_data_file\\r\\n self.test_data_file = args.test_data_file\\r\\n self.checkpoint_dir = args.checkpoint_dir\\r\\n self.trainlog_dir = args.trainlog_dir\\r\\n self.lr = args.lr\\r\\n self.batch_size = args.batch_size\\r\\n self.num_epochs = args.num_epochs\\r\\n self.loss_type = args.loss\\r\\n self.accuracy_type = args.accuracy\\r\\n self.optimizer = args.optimizer\\r\\n self.dropout = args.dropout\\r\\n self.gpu_load = args.gpu_load\\r\\n self.num_filters = args.num_filters\\r\\n self.nonlin = args.nonlin\\r\\n self.loss_type = args.loss\\r\\n self.task_type = args.task_type\\r\\n self.long_summary = args.long_summary\\r\\n self.experiment_path = args.experiment_path\\r\\n self.chpnt2load = args.chpnt2load\\r\\n self.lr_mode = args.lr_mode\\r\\n\\r\\n if not self.is_training:\\r\\n self.class_labels = args.class_labels\\r\\n if args.image_size:\\r\\n self.img_size = args.image_size\\r\\n else:\\r\\n self.img_size = None\\r\\n if args.num_classes:\\r\\n self.num_classes = args.num_classes\\r\\n else:\\r\\n self.num_classes = None\\r\\n if args.augmentation:\\r\\n self.augmentation_dict = args.augmentation\\r\\n else:\\r\\n self.augmentation_dict = None\\r\\n if args.normalize:\\r\\n self.normalize = args.normalize\\r\\n else:\\r\\n self.normalize = None\\r\\n if args.zero_center:\\r\\n self.zero_center = args.zero_center\\r\\n else:\\r\\n self.zero_center = None\\r\\n\\r\\n\\r\\n self._initialize_data()\",\n \"def main():\\n\\n if len(sys.argv) == 3:\\n database_filepath, model_filepath = sys.argv[1:]\\n print('Loading data...\\\\n DATABASE: {}'.format(database_filepath))\\n X, Y, category_names = load_data(database_filepath)\\n X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)\\n \\n print('Building model...')\\n model = build_model()\\n \\n print('Training model...')\\n model.fit(X_train, Y_train)\\n \\n print('Evaluating model...')\\n evaluate_model(model, X_test, Y_test, category_names)\\n\\n print('Saving model...\\\\n MODEL: {}'.format(model_filepath))\\n save_model(model, model_filepath)\\n\\n print('Trained model saved!')\\n\\n else:\\n print('Please provide the filepath of the disaster messages database '\\\\\\n 'as the first argument and the filepath of the pickle file to '\\\\\\n 'save the model to as the second argument. \\\\n\\\\nExample: python '\\\\\\n 'train_classifier.py ../data/DisasterResponse.db classifier.pkl')\",\n \"def main(args):\\n # Generate detectron2 config from command line arguments.\\n cfg = get_cfg()\\n cfg.merge_from_file(args.config_file)\\n cfg.merge_from_list(args.opts)\\n\\n # The configuration file should not contain any datasets. They are configured\\n # from command line arguments instead.\\n if len(cfg.DATASETS.TRAIN) > 0 or len(cfg.DATASETS.TEST) > 0:\\n logging.error(\\\"Please set DATASETS.TRAIN = () and DATASETS.TEST = ().\\\")\\n sys.exit(1)\\n cfg.DATASETS.TRAIN = (TRAIN_SPLIT_NAME, )\\n cfg.DATASETS.TEST = (VALID_SPLIT_NAME, )\\n\\n cfg.freeze()\\n default_setup(cfg, args)\\n\\n # Register synthetic sign datasets.\\n if args.image_width is not None or args.image_height is not None:\\n if args.image_width is None or args.image_height is None:\\n logging.error(\\n \\\"Please specify both, image-width and image-height (or none).\\\")\\n sys.exit(1)\\n image_shape = args.image_height, args.image_width\\n else:\\n image_shape = None\\n\\n register_synthetic_signs(args.train_csv,\\n args.label_map,\\n cfg,\\n name=TRAIN_SPLIT_NAME,\\n image_shape=image_shape)\\n if args.valid_csv is not None:\\n register_synthetic_signs(args.valid_csv,\\n args.label_map,\\n cfg,\\n name=VALID_SPLIT_NAME,\\n image_shape=image_shape)\\n\\n # Run training or evaluation.\\n if args.eval_only:\\n model = Trainer.build_model(cfg)\\n DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load(\\n cfg.MODEL.WEIGHTS, resume=args.resume)\\n res = Trainer.test(cfg, model)\\n if comm.is_main_process():\\n verify_results(cfg, res)\\n return res\\n\\n trainer = Trainer(cfg)\\n trainer.resume_or_load(resume=args.resume)\\n return trainer.train()\",\n \"def main(args):\\n print(now(), \\\"craft_poisons_bp.py main() running.\\\")\\n\\n craft_log = \\\"craft_log.txt\\\"\\n to_log_file(args, args.output, craft_log)\\n\\n ####################################################\\n # Dataset\\n if args.dataset.lower() == \\\"cifar10\\\":\\n transform_test = get_transform(args.normalize, False)\\n testset = torchvision.datasets.CIFAR10(\\n root=\\\"./data\\\", train=False, download=True, transform=transform_test\\n )\\n trainset = torchvision.datasets.CIFAR10(\\n root=\\\"./data\\\", train=True, download=True, transform=transform_test\\n )\\n elif args.dataset.lower() == \\\"tinyimagenet_first\\\":\\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\\n trainset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"train\\\",\\n transform=transform_test,\\n classes=\\\"firsthalf\\\",\\n )\\n testset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"val\\\",\\n transform=transform_test,\\n classes=\\\"firsthalf\\\",\\n )\\n elif args.dataset.lower() == \\\"tinyimagenet_last\\\":\\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\\n trainset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"train\\\",\\n transform=transform_test,\\n classes=\\\"lasthalf\\\",\\n )\\n testset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"val\\\",\\n transform=transform_test,\\n classes=\\\"lasthalf\\\",\\n )\\n elif args.dataset.lower() == \\\"tinyimagenet_all\\\":\\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\\n trainset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"train\\\",\\n transform=transform_test,\\n classes=\\\"all\\\",\\n )\\n testset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"val\\\",\\n transform=transform_test,\\n classes=\\\"all\\\",\\n )\\n else:\\n print(\\\"Dataset not yet implemented. Exiting from craft_poisons_cp.py.\\\")\\n sys.exit()\\n ###################################################\\n\\n ####################################################\\n # Find target and base images\\n with open(args.poison_setups, \\\"rb\\\") as handle:\\n setup_dicts = pickle.load(handle)\\n setup = setup_dicts[args.setup_idx]\\n\\n target_img_idx = (\\n setup[\\\"target index\\\"] if args.target_img_idx is None else args.target_img_idx\\n )\\n base_indices = (\\n setup[\\\"base indices\\\"] if args.base_indices is None else args.base_indices\\n )\\n\\n # get single target\\n target_img, target_label = testset[target_img_idx]\\n\\n # get multiple bases\\n base_imgs = torch.stack([trainset[i][0] for i in base_indices])\\n base_labels = [trainset[i][1] for i in base_indices]\\n poisoned_label = base_labels[0]\\n\\n # log target and base details\\n to_log_file(\\\"base indices: \\\" + str(base_indices), args.output, craft_log)\\n to_log_file(\\\"base labels: \\\" + str(base_labels), args.output, craft_log)\\n to_log_file(\\\"target_label: \\\" + str(target_label), args.output, craft_log)\\n to_log_file(\\\"target_index: \\\" + str(target_img_idx), args.output, craft_log)\\n\\n # Set visible CUDA devices\\n cudnn.benchmark = True\\n\\n # load the pre-trained models\\n sub_net_list = []\\n for n_model, chk_name in enumerate(args.model_path):\\n net = load_model_from_checkpoint(\\n args.model[n_model], chk_name, args.pretrain_dataset\\n )\\n sub_net_list.append(net)\\n\\n target_net = load_model_from_checkpoint(\\n args.target_model, args.target_model_path, args.pretrain_dataset\\n )\\n\\n # Get the target image\\n target = target_img.unsqueeze(0)\\n\\n chk_path = args.poisons_path\\n if not os.path.exists(chk_path):\\n os.makedirs(chk_path)\\n\\n base_tensor_list = [base_imgs[i] for i in range(base_imgs.shape[0])]\\n base_tensor_list = [bt.to(\\\"cuda\\\") for bt in base_tensor_list]\\n\\n poison_init = base_tensor_list\\n mean, std = data_mean_std_dict[args.dataset.lower()]\\n poison_tuple_list = make_convex_polytope_poisons(\\n sub_net_list,\\n target_net,\\n base_tensor_list,\\n target,\\n \\\"cuda\\\",\\n opt_method=args.poison_opt,\\n lr=args.poison_lr,\\n momentum=args.poison_momentum,\\n iterations=args.crafting_iters,\\n epsilon=args.epsilon,\\n decay_ites=args.poison_decay_ites,\\n decay_ratio=args.poison_decay_ratio,\\n mean=torch.Tensor(mean).reshape(1, 3, 1, 1),\\n std=torch.Tensor(std).reshape(1, 3, 1, 1),\\n chk_path=chk_path,\\n poison_idxes=base_indices,\\n poison_label=poisoned_label,\\n tol=args.tol,\\n start_ite=0,\\n poison_init=poison_init,\\n end2end=args.end2end,\\n mode=\\\"mean\\\",\\n )\\n\\n # move poisons to PIL format\\n if args.normalize:\\n target = un_normalize_data(target.squeeze(0), args.dataset)\\n for i in range(len(poison_tuple_list)):\\n poison_tuple_list[i] = (\\n transforms.ToPILImage()(\\n un_normalize_data(poison_tuple_list[i][0], args.dataset)\\n ),\\n poison_tuple_list[i][1],\\n )\\n else:\\n target = target.squeeze(0)\\n for i in range(len(poison_tuple_list)):\\n poison_tuple_list[i] = (\\n transforms.ToPILImage()(poison_tuple_list[i][0]),\\n poison_tuple_list[i][1],\\n )\\n\\n # get perturbation norms\\n poison_perturbation_norms = []\\n for idx, (poison_tensor, p_label) in enumerate(poison_tuple_list):\\n poison_perturbation_norms.append(\\n torch.max(\\n torch.abs(\\n transforms.ToTensor()(poison_tensor)\\n - un_normalize_data(base_tensor_list[idx].cpu(), args.dataset)\\n )\\n ).item()\\n )\\n to_log_file(\\n \\\"perturbation norms: \\\" + str(poison_perturbation_norms),\\n args.output,\\n \\\"craft_log.txt\\\",\\n )\\n\\n ####################################################\\n # Save Poisons\\n print(now(), \\\"Saving poisons...\\\")\\n if not os.path.isdir(args.poisons_path):\\n os.makedirs(args.poisons_path)\\n with open(os.path.join(args.poisons_path, \\\"poisons.pickle\\\"), \\\"wb\\\") as handle:\\n pickle.dump(poison_tuple_list, handle, protocol=pickle.HIGHEST_PROTOCOL)\\n with open(\\n os.path.join(args.poisons_path, \\\"perturbation_norms.pickle\\\"), \\\"wb\\\"\\n ) as handle:\\n pickle.dump(poison_perturbation_norms, handle, protocol=pickle.HIGHEST_PROTOCOL)\\n with open(os.path.join(args.poisons_path, \\\"base_indices.pickle\\\"), \\\"wb\\\") as handle:\\n pickle.dump(base_indices, handle, protocol=pickle.HIGHEST_PROTOCOL)\\n with open(os.path.join(args.poisons_path, \\\"target.pickle\\\"), \\\"wb\\\") as handle:\\n pickle.dump(\\n (transforms.ToPILImage()(target), target_label),\\n handle,\\n protocol=pickle.HIGHEST_PROTOCOL,\\n )\\n to_log_file(\\\"poisons saved.\\\", args.output, \\\"craft_log.txt\\\")\\n ####################################################\\n\\n print(now(), \\\"craft_poisons_bp.py done.\\\")\\n return\",\n \"def read_args(self):\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--algorithm', '-a', default='onelayer',\\n choices=['onelayer', 'randomforest', 'sos'],\\n help='which algorithm to run')\\n parser.add_argument('--format', '-f', default='pcap',\\n choices=['netflow', 'pcap'],\\n help='which format are the files to process in')\\n parser.add_argument('--operation', '-o', default='eval',\\n choices=['eval', 'train', 'test'],\\n help='which operation to run')\\n parser.add_argument('--sos_model', '-s', default='networkml/trained_models/sos/SoSmodel',\\n help='path to SoSmodel')\\n parser.add_argument('--trained_model', '-m', default='networkml/trained_models/onelayer/OneLayerModel.pkl',\\n help='path to the trained model file')\\n parser.add_argument('--path', '-p', default='/pcaps',\\n help='path to file or directory of files to process')\\n parser.add_argument('--save', '-w', default='networkml/trained_models/onelayer/OneLayerModel.pkl',\\n help='path to save the trained model, if training')\\n\\n self.args = parser.parse_args()\\n return\",\n \"def argparser():\\n ap = argparse.ArgumentParser(fromfile_prefix_chars='@',\\n description='Train and deploy a deep-learned [Fe/H] estimator'\\n 'based on Gaia time-series photometry.',\\n epilog=\\\"\\\")\\n\\n # use custom line parser for the parameter file\\n ap.convert_arg_line_to_args = convert_arg_line_to_args\\n\\n ap.add_argument('-v',\\n '--verbose',\\n action='store_true', # assign True value if used\\n help='Generate verbose output.')\\n\\n ap.add_argument('--seed',\\n action='store',\\n type=int,\\n default=1,\\n help='Integer seed for reproducible results.')\\n\\n ap.add_argument('--rootdir',\\n action='store',\\n type=str,\\n default=os.path.expanduser('~'),\\n help='Full path of the root directory '\\n '(all other directory and file names will be relative to this, default: `~`).')\\n\\n ap.add_argument('--input_list',\\n action='store',\\n type=str,\\n default='lcfit_input.lst',\\n help='Name of the input list file (default: `lcfit_input.lst`)')\\n\\n ap.add_argument('--input_dir',\\n action='store',\\n type=str,\\n default='.',\\n help='Subdirectory of the input time series (default: `.`)')\\n\\n ap.add_argument('--gls_input_file',\\n action='store',\\n type=str,\\n default='gls_input.dat',\\n help='Name of the GLS input file (created by the external code `gls` and read by `lcfit`, '\\n 'default: `gls_input.dat`)')\\n\\n ap.add_argument('--input_lc_suffix',\\n action='store',\\n type=str,\\n default='.dat',\\n help='Suffix for the input time series file names (default: `.dat`).')\\n\\n ap.add_argument('--input_lc_prefix',\\n action='store',\\n type=str,\\n default='',\\n help='Prefix for the input time series file names (default: no prefix).')\\n\\n ap.add_argument('--output_dir',\\n action='store',\\n type=str,\\n default='data',\\n help='If specified, the clipped, phased, phase-sorted light curves will be written to '\\n 'this directory, into a separate file for each time series (default: `data`).')\\n\\n ap.add_argument('--output_syn_dir',\\n action='store',\\n type=str,\\n default=None,\\n help='If specified, the synthetic output time series will be written to '\\n 'this directory (separate file for each time series).')\\n\\n ap.add_argument('--plot_dir',\\n action='store',\\n type=str,\\n default='plots',\\n help='Subdirectory of the output figures.')\\n\\n ap.add_argument('--plot_suffix',\\n action='store',\\n type=str,\\n default='',\\n help='Suffix for the output figures.')\\n\\n ap.add_argument('--syn_suffix',\\n action='store',\\n type=str,\\n default='_syn',\\n help='Suffix for the synthetic output time series.')\\n\\n ap.add_argument('--output_gpr_dir',\\n action='store',\\n type=str,\\n default=None,\\n help='Subdirectory (if specified) of the output Gaussian Process models.')\\n\\n ap.add_argument('--output_param_file',\\n action='store',\\n type=str,\\n default='lcfit.out',\\n help='Name of the output parameter file.')\\n\\n ap.add_argument('--output_data_dir',\\n action='store',\\n type=str,\\n default='.',\\n help='Subdirectory for output data files.')\\n\\n ap.add_argument('--merged_output_datafile',\\n action='store',\\n type=str,\\n default=None,\\n help='Name of the data file for writing all output time series, appended one after the other.')\\n\\n ap.add_argument('--degrade_lc',\\n action='store_true',\\n help='Degrade the light curve (see the source code for the corresponding parameters).')\\n\\n ap.add_argument('--compute_errors',\\n action='store_true', # assign True value if used\\n help='If `gpr_fit` is `True`, then `n_gpr_sample` random samples will be drawn from '\\n 'the fitted GPR model at the original (or if the >maxn_gpr, then the '\\n 'binned) phases, and each sample will be fitted with a Fourier series. '\\n 'The errors of Fourier parameters will be estimated therefrom.')\\n\\n ap.add_argument('--pca_model_file',\\n action='store',\\n type=str,\\n default=None,\\n help='Apply the specified PCA transformation to the Fourier parameters.')\\n\\n ap.add_argument('--feh_model_file',\\n action='store',\\n type=str,\\n default=None,\\n help='Apply the specified model to predict the [Fe/H] from the Fourier parameters.')\\n\\n ap.add_argument('--fold_double_period',\\n action='store_true', # assign True value if used\\n help='Fold the time series also with twice the period, and create the corresponding output files.')\\n\\n ap.add_argument('--loss',\\n action='store',\\n type=str,\\n choices=['linear', 'soft_l1', 'huber', 'cauchy', 'arctan'],\\n default='huber',\\n help='Type of regression loss.')\\n\\n ap.add_argument('--sigma_clip_threshold',\\n action='store',\\n type=float,\\n default=None,\\n help='If specified, outliers beyond `sigma_clip_threshold` * residual std. dev. '\\n 'will be iteratively omitted.')\\n\\n ap.add_argument('--align_phi1',\\n action='store_true',\\n help='The time series will be phase-aligned by the first Fourier phase defined to be at zero.')\\n\\n ap.add_argument('--null_epoch',\\n action='store',\\n type=float,\\n default=None,\\n help='Reference epoch that will be subtracted from the time values. '\\n 'If None (default), then the time of the first measurement will be used '\\n 'for every time series.')\\n\\n ap.add_argument('--gpr_fit',\\n action='store_true',\\n help='Perform Gaussian Process Regression (GPR) on the phase-folded time series.')\\n\\n ap.add_argument('--kernel',\\n action='store',\\n type=str,\\n choices=['matern', 'expsine2'],\\n default='matern',\\n help='Kernel type for the GPR. Available options: `matern`, `expsine2`. Default: `matern`.')\\n\\n ap.add_argument('--lower_length_scale_bound',\\n action='store',\\n type=float,\\n default=0.1,\\n help='Lower length scale bound for the GPR kernel. '\\n 'Used if the --gpr_fit option is selected. Default: 0.1')\\n\\n ap.add_argument('--upper_length_scale_bound',\\n action='store',\\n type=float,\\n default=10.0,\\n help='Upper length scale bound for the GPR kernel. '\\n 'Used if the --gpr_fit option is selected. Default: 10.0')\\n\\n ap.add_argument('--gpr_hparam_optimization',\\n action='store',\\n type=str,\\n choices=['mle', 'cv'],\\n default='mle',\\n help='Method for hyperparameter optimization of the Gaussian Process Regression. '\\n 'If `mle`, then the hyperparameters will be optimized by maximizing the log-likelihood '\\n '(this is the widely-used standard method for GPR). '\\n 'If `cv`, then the hyperparameters will be optimized by maximizing the R2 cross-validation '\\n 'score. The hyperparameter-space will be searched using a Bayesian approach as implemented in '\\n 'the `scikit-optimize` API, and 10-fold CV will be used for evaluation.')\\n\\n ap.add_argument('--gpr_cv_n_init',\\n action='store',\\n type=int,\\n default=10,\\n help='The number of initial estimates for Bayesian hyperparameter optimization if '\\n '`gpr_hparam_optimization` is `cv`.')\\n\\n ap.add_argument('--gpr_cv_n_calls',\\n action='store',\\n type=int,\\n default=10,\\n help='The number of iterations for Bayesian hyperparameter optimization if '\\n '`gpr_hparam_optimization` is `cv`.')\\n\\n ap.add_argument('--fourier_from_gpr',\\n action='store_true',\\n help='Infer the Fourier parameters from the best-fitting Gaussian Process Regression model.')\\n\\n ap.add_argument('--n_augment_data',\\n action='store',\\n type=int,\\n default=None,\\n help='If specified, the input time series will be augmented by drawing `n_augment_data` new '\\n 'time series from the GPR model at the original phase points.')\\n\\n ap.add_argument('--plot_augmented',\\n action='store_true',\\n help='Plot the augmented time series.')\\n\\n ap.add_argument('--k_fold',\\n action='store',\\n type=int,\\n default=10,\\n help='Number of cross-validation folds.')\\n\\n ap.add_argument('--fourier_order_min',\\n action='store',\\n type=int,\\n default=3,\\n help='Minimum Fourier order to consider.')\\n\\n ap.add_argument('--fourier_order_max',\\n action='store',\\n type=int,\\n default=8,\\n help='Maximum Fourier order to consider.')\\n\\n ap.add_argument('--is_err_col',\\n action='store_true',\\n help='The input contains (a) column(s) with the magnitudes\\\\' uncertainties.')\\n\\n ap.add_argument('--is_zperr_col',\\n action='store_true',\\n help='The input contains (a) column(s) with zero-point uncertainties.')\\n\\n ap.add_argument('--n_data_cols',\\n action='store',\\n type=int,\\n default=1,\\n help='Number of data columns per input file.')\\n\\n ap.add_argument('--use_data_cols',\\n action='store',\\n nargs='*',\\n type=int,\\n default='1',\\n help='List of data columns to use.')\\n\\n ap.add_argument('--known_data_cols',\\n action='store_true',\\n help='If set, the input list file is expected to contain an extra column with header name \\\\'col\\\\' '\\n 'containing the number of the data column to be used for regression.')\\n\\n ap.add_argument('--known_phaseshift',\\n action='store_true',\\n help='If set, the input list file is expected to contain an extra column with header name '\\n '\\\\'phaseshift\\\\', containing the phase shift to be applied to the time series.')\\n\\n ap.add_argument('--min_snr',\\n action='store',\\n type=float,\\n default=None,\\n help='If specified, a column with S/N is expected to follow each magnitude column '\\n '(or magnitude error column if included). Data points with values below `min_snr` '\\n 'will be rejected.')\\n\\n ap.add_argument('--flag_omit',\\n action='store',\\n type=str,\\n default=None,\\n help='If specified, a column with string flags is expected to follow each magnitude column '\\n '(or magnitude error column / S/N column if included). Data points with values `flag_omit` '\\n 'will be rejected.')\\n\\n ap.add_argument('--mean_phase2',\\n action='store',\\n type=float,\\n default=None,\\n help='Population mean of the phi2 Fourier parameter.')\\n\\n ap.add_argument('--mean_phase3',\\n action='store',\\n type=float,\\n default=None,\\n help='Population mean of the phi3 Fourier parameter.')\\n\\n ap.add_argument('--mean_phase21',\\n action='store',\\n type=float,\\n default=None,\\n help='Population mean of the phi21 Fourier parameter.')\\n\\n ap.add_argument('--mean_phase31',\\n action='store',\\n type=float,\\n default=None,\\n help='Population mean of the phi31 Fourier parameter.')\\n\\n ap.add_argument('--waveband',\\n action='store',\\n type=str,\\n default=None,\\n help='Name of the waveband (filter) of the input time series.')\\n\\n ap.add_argument('--plot_data',\\n action='store_true',\\n help='Plot the time series.')\\n\\n ap.add_argument('--save_figures',\\n action='store_true',\\n help='Save output plots into files.')\\n\\n ap.add_argument('--plot_gpr',\\n action='store_true',\\n help='Plot the results of the Gaussian Process Regression.')\\n\\n ap.add_argument('--plot_all_datasets',\\n action='store_true',\\n help='Create plots for all datasets.')\\n\\n ap.add_argument('--fit_period',\\n action='store_true',\\n help='Fit the period to the dataset (by non-linear least squares regression).')\\n\\n ap.add_argument('--do_gls',\\n action='store_true',\\n help='Compute an initial period estimate by the Generalized Lomb-Scargle Periodogram '\\n 'method. Otherwise an initial period value is expected in the input file.')\\n\\n ap.add_argument('--redo_gls',\\n action='store_true',\\n help='Recompute the initial period estimate by the Generalized Lomb-Scargle Periodogram '\\n 'method in the outlier rejection iterations.')\\n\\n ap.add_argument('--weighted_fit',\\n action='store_true',\\n help='Use squared inverse of the errors as weights in the regression.')\\n\\n ap.add_argument('--nsyn',\\n action='store',\\n type=int,\\n default=120,\\n help='Number of equidistant phase points for the output synthetic data '\\n '(i.e., points of evaluation of the regression model.)')\\n\\n ap.add_argument('--min_ndata',\\n action='store',\\n type=int,\\n default=20,\\n help='Minimum number of data points in the time series to be considered for analysis.')\\n\\n ap.add_argument('--n_jobs',\\n action='store',\\n type=int,\\n default=None,\\n help='The number parallel threads. If not specified, n_jobs=max(n_cores, k_fold)')\\n\\n return ap\",\n \"def handle_arguments():\\n # process the command options\\n parser = argparse.ArgumentParser()\\n parser.add_argument('images', type=str, help='provide path in style: '\\n r'\\\"kaggle\\\\input\\\\bengaliai-cv19\\\\images.npy\\\"')\\n parser.add_argument('labels', type=str, help='provide path in style: '\\n r'\\\"kaggle\\\\input\\\\bengaliai-cv19\\\\labels.csv\\\"')\\n parser.add_argument('-t', '--test_ratio', type=float, default=0.2,\\n help='proportion of data for testing, default: 0.2')\\n parser.add_argument('-s', '--seed', type=int, default=None, help='seed '\\n 'used for consistent data splitting, default: None')\\n parser.add_argument('-a', '--data_augmentation', action='store_true',\\n help='switch to augment the images')\\n drop_info_fns = ['cutout', 'gridmask', 'None'] # info dropping algorithms\\n parser.add_argument('-d', '--drop_info_fn', type=str, choices=drop_info_fns,\\n default=None, help='whether cutout, GridMask, or no '\\n 'information dropping algorithm is used, default: None')\\n parser.add_argument('-c', '--class_balancing', action='store_true',\\n help='switch to perform class balancing')\\n parser.add_argument('-b', '--batch_size', type=int, default=32,\\n help='batch size of DataLoader objects, default: 32')\\n parser.add_argument('-l', '--label_smoothing', action='store_true',\\n help='switch to use soft targets in loss computation')\\n parser.add_argument('-e', '--epochs', type=int, default=50, help='number '\\n 'of iterations over training data, default: 50')\\n parser.add_argument('-m', '--model', type=str, default='model.pt',\\n help='path to save trained model, default: \\\"model.pt\\\"')\\n\\n # parse and print arguments\\n args = parser.parse_args()\\n for arg in vars(args):\\n print(f'{arg.upper()}: {getattr(args, arg)}')\\n\\n return args\",\n \"def init_from_scratch(args, train_exs, dev_exs):\\n \\n # Build a dictionary from the data sqls+queries (train/dev splits)\\n logger.info('-' * 100)\\n logger.info('Build vocab')\\n \\n vocab = build_vocab(train_exs + dev_exs, args)\\n logger.info('Num words = %d' % vocab.size())\\n \\n # Initialize model\\n model = CopyNet(args, vocab)\\n logger.info('-' * 100)\\n logger.info('Model Architecture')\\n logger.info(model)\\n if args.embedding_file:\\n model.load_embeddings(vocab.tokens(), args.embedding_file)\\n \\n return model, vocab\",\n \"def get_arguments():\\n parser = argparse.ArgumentParser(description=\\\"DeepLabLFOV Network Inference.\\\")\\n parser.add_argument(\\\"--train_set\\\", type=str, default=\\\"drill\\\",\\n help=\\\"Number of classes to predict (including background).\\\")\\n args = parser.parse_args()\\n train_set = args.train_set\\n\\n #test_set = \\\"drill_11_test_scenes\\\"\\n\\n NUM_CLASSES = 8\\n SAVE_DIR = './testing_softmax_output/'\\n DATA_DIR = '/'\\n DATA_LIST_PATH = '/home/peteflo/spartan/src/CorlDev/experiments/sixobjects_multi_test_scenes.txt.imglist.txtdownsampled10.txt'\\n DATA_DIRECTORY = ''\\n IGNORE_LABEL = 255\\n RESTORE_FROM = './snapshots_' + train_set + '/model.ckpt-20000'\\n \\n parser.add_argument(\\\"--num-classes\\\", type=int, default=NUM_CLASSES,\\n help=\\\"Number of classes to predict (including background).\\\")\\n parser.add_argument(\\\"--save-dir\\\", type=str, default=SAVE_DIR,\\n help=\\\"Where to save predicted mask.\\\")\\n parser.add_argument(\\\"--data-list\\\", type=str, default=DATA_LIST_PATH,\\n help=\\\"Path to the file listing the images in the dataset.\\\")\\n parser.add_argument(\\\"--data-dir\\\", type=str, default=DATA_DIRECTORY,\\n help=\\\"Path to the directory containing the PASCAL VOC dataset.\\\")\\n parser.add_argument(\\\"--ignore-label\\\", type=int, default=IGNORE_LABEL,\\n help=\\\"The index of the label to ignore during the training.\\\")\\n parser.add_argument(\\\"--restore-from\\\", type=str, default=RESTORE_FROM,\\n help=\\\"Where restore model parameters from.\\\")\\n return parser.parse_args()\",\n \"def main():\\n args = arg_parser()\\n if(args.gpu):\\n gpu = args.gpu\\n else:\\n print(\\\"GPU mode not specified, will use the default value - Use GPU\\\")\\n gpu = \\\"Y\\\"\\n # Device setting:\\n device = device_setting(gpu)\\n \\n # Prepare the datasets and dataloaders:\\n print(\\\"\\\\nPreparing dataset for train/valid/test ...\\\")\\n train_loader, valid_loader, test_loader, train_data, valid_data, test_data = load_dataset()\\n \\n # Model architects, criterion and optimizer:\\n print(\\\"\\\\nNetwork archetecture building ...\\\")\\n model, criterion, optimizer = network(device=device,\\n architecture=args.architecture,\\n learning_rate=args.learning_rate,\\n hidden_size=args.hidden_size,\\n dropout=args.dropout,\\n output_size=args.output_size)\\n \\n # Train the model:\\n print(\\\"\\\\n\\\")\\n model = train(model=model,\\n epochs=5,\\n learning_rate=args.learning_rate,\\n criterion=criterion,\\n optimizer=optimizer,\\n train_loader=train_loader,\\n valid_loader=valid_loader,\\n device=device)\\n \\n # Validate the model performance on the test set:\\n print(\\\"\\\\nValidate model performance on test set ...\\\")\\n test(model=model, test_loader=test_loader, device=device)\\n \\n # Save model checkpoint:\\n print(\\\"\\\\nSave model checkpoint ...\\\")\\n save(model=model, train_data=train_data, epochs=args.epochs, architecture=args.architecture)\",\n \"def load_args(self):\\n\\n # retrieve module path\\n dir_path = os.path.dirname(os.path.abspath(__file__))\\n dir_path = os.path.split(dir_path)[0]\\n # get all the default yaml configs with glob\\n dir_path = os.path.join(dir_path, 'configs', '*.yml')\\n\\n # -- From default yapt configuration\\n self._defaults_path = {}\\n self._defaults_yapt = OmegaConf.create(dict())\\n for file in glob.glob(dir_path):\\n # split filename from path to create key and val\\n key = os.path.splitext(os.path.split(file)[1])[0]\\n self._defaults_path[key] = file\\n # parse default args\\n self._defaults_yapt = OmegaConf.merge(\\n self._defaults_yapt, OmegaConf.load(file))\\n\\n # -- From command line\\n self._cli_args = OmegaConf.from_cli()\\n if self._cli_args.config is not None:\\n self.default_config = self._cli_args.config\\n del self._cli_args['config']\\n self.console_log.warning(\\\"override default config with: %s\\\", self.default_config)\\n\\n # -- From experiment default config file\\n self._default_config_args = OmegaConf.create(dict())\\n if self.default_config is not None:\\n self._default_config_args = OmegaConf.load(self.default_config)\\n\\n # -- Merge default args\\n self._args = OmegaConf.merge(\\n self._defaults_yapt,\\n self._default_config_args)\\n\\n # -- Resolve interpolations to be sure all nodes are explicit\\n # self._args = OmegaConf.to_container(self._args, resolve=True)\\n # self._args = OmegaConf.create(self._args)\\n\\n # -- make args structured: it fails if accessing a missing key\\n OmegaConf.set_struct(self._args, True)\",\n \"def main(cli_args=None):\\n # build an arg parser\\n parser = get_arg_parser()\\n\\n # run the parser on cli args\\n args = parser.parse_args(cli_args)\\n\\n print(f\\\"Running script with arguments: {args}\\\")\\n test_input(args.raw_training_data)\\n test_input(args.raw_testing_data)\\n test_output(args.train_output)\\n test_output(args.test_output)\",\n \"def main(_config, _run):\\n sacred.commands.print_config(_run)\\n dump_config_and_makefile()\\n prepare_and_train()\",\n \"def parse_arguments_for_single_machine():\\n\\n # setup command line parser and parse arguments\\n parser = argparse.ArgumentParser()\\n\\n arg_help = 'the path of the point sprite data (positions and intensities)' \\n parser.add_argument('--input-directory',\\n action='store',\\n dest='input_directory',\\n help=arg_help)\\n \\n arg_help = 'the directory where the configuration files will be generated'\\n parser.add_argument('--output-directory',\\n action='store',\\n dest='output_directory',\\n help=arg_help)\\n\\n arg_help = 'the point sprite header file (meta data of the sprite)'\\n parser.add_argument('--psh-file',\\n action='store', default='NO_FILE_PROVIDED',\\n dest='psh_file',\\n help=arg_help)\\n \\n arg_help = 'the data configuration file for the circuit and the sensor'\\n parser.add_argument('--data-config-file',\\n action='store', default='NO_FILE_PROVIDED',\\n dest='data_config_file',\\n help=arg_help)\\n\\n arg_help = 'simulation method, direct-sprite, linear-sprite, ... '\\n parser.add_argument('--simulation-method',\\n action='store', default='direct-sprite',\\n dest='simulation_method',\\n help=arg_help)\\n\\n arg_help = 'the template pbrt sensor configuration file for sprite'\\n parser.add_argument('--pbrt-sprite-sensor-config',\\n action='store', default='NO_FILE_PROVIDED',\\n dest='pbrt_sprite_sensor_config',\\n help=arg_help)\\n \\n arg_help = 'the template pbrt sensor configuration file for volume'\\n parser.add_argument('--pbrt-volume-sensor-config',\\n action='store', default='NO_FILE_PROVIDED',\\n dest='pbrt_volume_sensor_config',\\n help=arg_help)\\n\\n arg_help = 'the path of the pbrt executable that will run the simulation'\\n parser.add_argument('--pbrt-executable',\\n action='store', default='pbrt', # installed\\n dest='pbrt_executable',\\n help=arg_help)\\n\\n arg_help = 'the path of the sprite volumeizer executable that will ' \\\\\\n 'convert the sprite to a volume '\\n parser.add_argument('--volumizer-executable',\\n action='store', default='volumizesprite', # installed \\n dest='volumizer_executable',\\n help=arg_help)\\n \\n arg_help = 'the path of the spritebounds executable that will ' \\\\\\n 'quicky extract the bounds of the sprite to get the sensor data'\\n parser.add_argument('--sprite-bounds-executable',\\n action='store', default='spritebounds', # installed \\n dest='spritebounds_executable',\\n help=arg_help)\\n\\n arg_help = 'resolution of the grid converted from the sprite'\\n parser.add_argument('--grid-resolution',\\n action='store', default='512',\\n dest='grid_resolution',\\n help=arg_help)\\n\\n arg_help = 'running node, cluster or local, cluster by default'\\n parser.add_argument('--node',\\n action='store', default='cluster',\\n dest='node',\\n help=arg_help)\\n \\n arg_help = 'the base (maximum) resolution of the sensor'\\n parser.add_argument('--sensor-resolution',\\n action='store', default='512', \\n dest='sensor_resolution',\\n help=arg_help)\\n\\n # parse the arguments\\n args = parser.parse_args()\\n \\n return args\",\n \"def _parse_args():\\n parser = argparse.ArgumentParser(description='main.py')\\n \\n # General system running and configuration options\\n parser.add_argument('--do_nearest_neighbor', dest='do_nearest_neighbor', default=False, action='store_true', help='run the nearest neighbor model')\\n parser.add_argument('--debug', dest='debug', default=False, action='store_true', help='set to debug mode ')\\n parser.add_argument('--num_train_sentence', dest='num_train_sentence', type=int, default=-1,\\n help='set number of sentence to train on')\\n parser.add_argument('--train_path', type=str, default='data/geo_train.tsv', help='path to train data')\\n parser.add_argument('--dev_path', type=str, default='data/geo_dev.tsv', help='path to dev data')\\n parser.add_argument('--test_path', type=str, default='data/geo_test.tsv', help='path to blind test data')\\n parser.add_argument('--test_output_path', type=str, default='geo_test_output.tsv', help='path to write blind test results')\\n parser.add_argument('--domain', type=str, default='geo', help='domain (geo for geoquery)')\\n parser.add_argument('--attn_model', type=str, default='general', help='Attention model to use: general (default), dot, concat')\\n\\n # Some common arguments for your convenience\\n parser.add_argument('--seed', type=int, default=0, help='RNG seed (default = 0)')\\n parser.add_argument('--epochs', type=int, default=100, help='num epochs to train for')\\n parser.add_argument('--lr', type=float, default=.001)\\n parser.add_argument('--batch_size', type=int, default=2, help='batch size')\\n # 65 is all you need for GeoQuery\\n parser.add_argument('--decoder_len_limit', type=int, default=65, help='output length limit of the decoder')\\n\\n # Feel free to add other hyperparameters for your input dimension, etc. to control your network\\n # 50-200 might be a good range to start with for embedding and LSTM sizes\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--input-model\\\", help=\\\"Path to read input model from\\\")\\n options = parser.parse_args()\\n return options\",\n \"def train_input_args():\\n # Create Parse using ArgumentParser\\n parser = argparse.ArgumentParser()\\n parser.add_argument('data_dir', type = str, help = 'Path to the data directory') \\n parser.add_argument('--lr', type = float, default = 0.001, help = 'Learning rate (0.001)') \\n parser.add_argument('--model', type = str, default = 'vgg16', help = 'TorchVision VGG model used: vgg19 or (vgg16)') \\n parser.add_argument('--hidden', type = int, default = 4096, help = 'Number of hidden units (4096)') \\n parser.add_argument('--epochs', type = int, default = 8, help = 'Number of training epochs (8)') \\n parser.add_argument('--gpu', type = bool, default = True, help = '(True) = GPU enabled, False = GPU disabled') \\n parser.add_argument('--chk', type = str, default = 'checkpoint', help = 'Checkpoint folder name') \\n return parser.parse_args()\",\n \"def add_args(parser):\\r\\n TransformerModel.add_args(parser)\\r\\n parser.add_argument(\\r\\n \\\"--pretrained-xlm-checkpoint\\\",\\r\\n type=str,\\r\\n metavar=\\\"STR\\\",\\r\\n help=\\\"XLM model to use for initializing transformer encoder and/or decoder\\\",\\r\\n )\\r\\n parser.add_argument(\\r\\n \\\"--init-encoder-only\\\",\\r\\n action=\\\"store_true\\\",\\r\\n help=\\\"if set, don't load the XLM weights and embeddings into decoder\\\",\\r\\n )\\r\\n parser.add_argument(\\r\\n \\\"--init-decoder-only\\\",\\r\\n action=\\\"store_true\\\",\\r\\n help=\\\"if set, don't load the XLM weights and embeddings into encoder\\\",\\r\\n )\",\n \"def load_env(data_dir, model_dir):\\n model_params = sketch_rnn_model.get_default_hparams()\\n with tf.gfile.Open(os.path.join(model_dir, 'model_config.json'), 'r') as f:\\n model_params.parse_json(f.read())\\n return load_dataset(data_dir, model_params, inference_mode=True)\",\n \"def add_train_args(parser):\\n\\n # Runtime environment\\n runtime = parser.add_argument_group('Environment')\\n runtime.add_argument('--dataset', type=str, default=\\\"searchqa\\\",\\n help='Dataset: searchqa, quasart or unftriviaqa')\\n runtime.add_argument('--base_dir', type=str, default=\\\".\\\",\\n help='base_dir of the pre-processing')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64883953","0.6423853","0.6339392","0.63173246","0.63055223","0.6296296","0.6258348","0.6205302","0.6176762","0.61579216","0.61514276","0.61273324","0.6091553","0.6090854","0.60844326","0.608109","0.6078909","0.607694","0.6071167","0.60487896","0.6036241","0.6010098","0.6002534","0.5944961","0.59351194","0.5926877","0.59265924","0.59239185","0.5918209","0.5906126","0.59050655","0.58831763","0.5878644","0.5866068","0.5864794","0.5857321","0.58550173","0.58184105","0.580425","0.5803186","0.580284","0.5788868","0.5783483","0.5782496","0.57787","0.5761348","0.5760662","0.5752648","0.57522464","0.5738924","0.5738125","0.5730136","0.5719981","0.5718048","0.5717902","0.5717718","0.571079","0.5706796","0.5701906","0.56939656","0.56933266","0.5686616","0.56833386","0.56797135","0.5677457","0.567521","0.5660381","0.56533587","0.5651244","0.5634432","0.56314033","0.561938","0.56109315","0.56019","0.5598384","0.55975664","0.558975","0.5586507","0.5584532","0.5578043","0.5574028","0.5564362","0.556094","0.5559475","0.55588865","0.55587107","0.5552291","0.5551322","0.5549495","0.55467606","0.5541862","0.5541319","0.5538495","0.5538199","0.5535165","0.55331653","0.5526658","0.5525757","0.5521579","0.55208975"],"string":"[\n \"0.64883953\",\n \"0.6423853\",\n \"0.6339392\",\n \"0.63173246\",\n \"0.63055223\",\n \"0.6296296\",\n \"0.6258348\",\n \"0.6205302\",\n \"0.6176762\",\n \"0.61579216\",\n \"0.61514276\",\n \"0.61273324\",\n \"0.6091553\",\n \"0.6090854\",\n \"0.60844326\",\n \"0.608109\",\n \"0.6078909\",\n \"0.607694\",\n \"0.6071167\",\n \"0.60487896\",\n \"0.6036241\",\n \"0.6010098\",\n \"0.6002534\",\n \"0.5944961\",\n \"0.59351194\",\n \"0.5926877\",\n \"0.59265924\",\n \"0.59239185\",\n \"0.5918209\",\n \"0.5906126\",\n \"0.59050655\",\n \"0.58831763\",\n \"0.5878644\",\n \"0.5866068\",\n \"0.5864794\",\n \"0.5857321\",\n \"0.58550173\",\n \"0.58184105\",\n \"0.580425\",\n \"0.5803186\",\n \"0.580284\",\n \"0.5788868\",\n \"0.5783483\",\n \"0.5782496\",\n \"0.57787\",\n \"0.5761348\",\n \"0.5760662\",\n \"0.5752648\",\n \"0.57522464\",\n \"0.5738924\",\n \"0.5738125\",\n \"0.5730136\",\n \"0.5719981\",\n \"0.5718048\",\n \"0.5717902\",\n \"0.5717718\",\n \"0.571079\",\n \"0.5706796\",\n \"0.5701906\",\n \"0.56939656\",\n \"0.56933266\",\n \"0.5686616\",\n \"0.56833386\",\n \"0.56797135\",\n \"0.5677457\",\n \"0.567521\",\n \"0.5660381\",\n \"0.56533587\",\n \"0.5651244\",\n \"0.5634432\",\n \"0.56314033\",\n \"0.561938\",\n \"0.56109315\",\n \"0.56019\",\n \"0.5598384\",\n \"0.55975664\",\n \"0.558975\",\n \"0.5586507\",\n \"0.5584532\",\n \"0.5578043\",\n \"0.5574028\",\n \"0.5564362\",\n \"0.556094\",\n \"0.5559475\",\n \"0.55588865\",\n \"0.55587107\",\n \"0.5552291\",\n \"0.5551322\",\n \"0.5549495\",\n \"0.55467606\",\n \"0.5541862\",\n \"0.5541319\",\n \"0.5538495\",\n \"0.5538199\",\n \"0.5535165\",\n \"0.55331653\",\n \"0.5526658\",\n \"0.5525757\",\n \"0.5521579\",\n \"0.55208975\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6690745"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92874,"cells":{"query":{"kind":"string","value":"Load the model, training and evaluation configs for a regular sequence classifier from the given command line arguments. This classifier can either be used as a standalone model or as the final classifier for PET/iPET."},"document":{"kind":"string","value":"def load_sequence_classifier_configs(args) -> Tuple[WrapperConfig, pet.TrainConfig, pet.EvalConfig]:\n model_cfg = WrapperConfig(model_type=args.model_type, model_name_or_path=args.model_name_or_path,\n wrapper_type=SEQUENCE_CLASSIFIER_WRAPPER, task_name=args.task_name,\n label_list=args.label_list, max_seq_length=args.sc_max_seq_length,\n verbalizer_file=args.verbalizer_file, cache_dir=args.cache_dir,\n use_noisy_student=args.use_noisy_student, drop_prob=args.drop_prob,\n fix_deberta=args.fix_deberta)\n\n train_cfg = pet.TrainConfig(device=args.device, per_gpu_train_batch_size=args.sc_per_gpu_train_batch_size,\n per_gpu_unlabeled_batch_size=args.sc_per_gpu_unlabeled_batch_size, n_gpu=args.n_gpu,\n num_train_epochs=args.sc_num_train_epochs, max_steps=args.sc_max_steps,\n temperature=args.temperature,\n gradient_accumulation_steps=args.sc_gradient_accumulation_steps,\n weight_decay=args.weight_decay, learning_rate=args.learning_rate,\n adam_epsilon=args.adam_epsilon, warmup_steps=args.warmup_steps,\n max_grad_norm=args.max_grad_norm, use_logits=args.method != 'sequence_classifier')\n\n eval_cfg = pet.EvalConfig(device=args.device, n_gpu=args.n_gpu, metrics=args.metrics,\n per_gpu_eval_batch_size=args.sc_per_gpu_eval_batch_size)\n\n return model_cfg, train_cfg, eval_cfg"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def main(command_line_parameters=None):\n args = command_line_arguments(command_line_parameters)\n\n logger.debug(\"Loading preprocessor\")\n preprocessor = bob.bio.base.load_resource(' '.join(args.preprocessor), \"preprocessor\")\n logger.debug(\"Loading extractor\")\n extractor = bob.bio.base.load_resource(' '.join(args.extractor), \"extractor\")\n if extractor.requires_training:\n if args.extractor_file is None:\n raise ValueError(\"The desired extractor requires a pre-trained extractor file, but it was not specified\")\n extractor.load(args.extractor_file)\n\n logger.debug(\"Loading preprocessed data from file '%s'\", args.input_file)\n preprocessed = preprocessor.read_data(args.input_file)\n\n logger.info(\"Extracting features\")\n extracted = extractor(preprocessed)\n extractor.write_feature(extracted, args.output_file)\n logger.info(\"Wrote extracted features to file '%s'\", args.output_file)","def use_args(args):\n global DATA_PATH\n global IMAGES_FILE\n global WORKING_DIR\n global OUTPUT_DIR\n global OUTPUT_FILE_NAME\n global OUTPUT_FILE\n global LOAD_INDEXES\n global INDEXES_DIR\n global MODEL\n global JOIN_MODELS\n global MODEL1\n global MODEL2\n global ALL_TOGETHER\n global TRAINED_MODELS\n global TRAINED_MODELS_DIR\n global TRAINED_MODELS_DIR2\n global TRAINED_MODELS_DIRS\n global CROSS_VALIDATION\n global TRAIN_EPOCHS\n global FEATURES\n \n if args.data_path:\n # Change the default path of the images\n DATA_PATH = args.data_path\n IMAGES_FILE = os.path.join(DATA_PATH, IMAGES_FILE_NAME)\n \n if args.working_dir:\n # Change the default path of the working directory\n WORKING_DIR = args.working_dir\n OUTPUT_DIR = WORKING_DIR\n OUTPUT_FILE = os.path.join(OUTPUT_DIR, OUTPUT_FILE_NAME)\n \n if args.output_dir:\n # Change the default path of the output directory\n OUTPUT_DIR = os.path.join(WORKING_DIR, args.output_dir)\n OUTPUT_FILE = os.path.join(OUTPUT_DIR, OUTPUT_FILE_NAME)\n \n if args.output:\n # Change the default name of the output file\n OUTPUT_FILE_NAME = args.output\n OUTPUT_FILE = os.path.join(OUTPUT_DIR, OUTPUT_FILE_NAME)\n \n if args.indexes_dir:\n # Load random and train indexes from file\n LOAD_INDEXES = True\n INDEXES_DIR = args.indexes_dir\n \n if args.model:\n # Select model\n MODEL = args.model\n \n if args.models:\n \n if not args.trained_models_dirs:\n raise Exception(\"Arg. `-M --models` requires arg. \"\n + \"`-T --trained_models_dirs`\")\n \n # Models to combine\n JOIN_MODELS = True\n MODEL1 = args.models[0]\n MODEL2 = args.models[1]\n \n if args.trained_models_dir:\n # Load trained models from file\n TRAINED_MODELS = True\n TRAINED_MODELS_DIR = args.trained_models_dir\n \n if args.trained_models_dirs:\n # Load trained models from file\n TRAINED_MODELS = True\n TRAINED_MODELS_DIR = args.trained_models_dirs[0]\n TRAINED_MODELS_DIR2 = args.trained_models_dirs[1]\n \n if args.all_together:\n # The four models together\n ALL_TOGETHER = True\n TRAINED_MODELS_DIRS = args.all_together\n \n if args.cross_validation:\n # Activate cross_validation\n CROSS_VALIDATION = True\n \n if args.train_epochs:\n # Change the default number of train epochs\n TRAIN_EPOCHS = args.train_epochs\n \n if args.features:\n # Nuber of best features to use\n FEATURES = args.features","def load_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--batchsize\",\n help=\"the batch size of the dataloader\",\n type=int,\n default=2,\n required=False)\n parser.add_argument(\"--validsize\",\n help=\"percentage that training set split into validation set\",\n type=float,\n default=1/6,\n required=False)\n parser.add_argument(\"--input-prefix\",\n help=\"file for saving the data (.gz file)\",\n type=str,\n default=\"../mnistPC\",\n required=False)\n parser.add_argument(\"--demo\",\n help=\"if demo is true, then only load small number of images\",\n type=bool,\n default=False,\n required=False)\n parser.add_argument(\"--test\",\n help=\"if test is true, then load data from test dataset\",\n type=bool,\n default=False,\n required=False)\n parser.add_argument(\"--epochs\",\n help=\"number of epochs\",\n type=int,\n default=5,\n required=False)\n parser.add_argument(\"--learning_rate\",\n help=\"learning rate of the model\",\n type=float,\n default=1e-2,\n required=False)\n parser.add_argument(\"--num_classes\",\n help=\"number of classes for classification\",\n type=int,\n default=10,\n required=False)\n parser.add_argument(\"--num_neighbors\",\n help=\"num of neighbors for the network\",\n type=int,\n default=15,\n required=False)\n parser.add_argument(\"--cudas\",\n help=\"cuda numbera to use, if use cpu, please enter -1\",\n type=str,\n default=\"0/1/2/3\",\n required=False)\n args = parser.parse_args()\n return args","def main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--identifier\", required=True,\n help=\"A short name/identifier for your experiment, e.g. 'ex42b'.\")\n args = parser.parse_args()\n\n train(args)","def cli(sys_argv: List[str]):\n parser = argparse.ArgumentParser()\n\n parser.add_argument('--model_definition', type=str,\n help='Path to json model definition')\n\n parser.add_argument('--model_state_path', type=str,\n help='Path where to the trained parameters')\n\n parser.add_argument('--data_path', type=str, default=TEST_PATH,\n help='path to the pickled dataframe on which prediction should be made')\n\n parser.add_argument('--numerical_preprocessor', type=str, default=NUMERICAL_PREPROCESSOR_SAVE_PATH,\n help='Path of the saved numerical preprocessor')\n\n parser.add_argument('--categorical_preprocessor', type=str, default=CATEGORICAL_PREPROCESSOR_SAVE_PATH,\n help='Path to the saved categorical preprocessor')\n\n parser.add_argument('--output_directory', type=str, default=RESULTS_DIR,\n help='Path where to save the prediction of the experiment')\n\n args = parser.parse_args(sys_argv)\n\n # # ---------- parse config file ---------- # #\n config: dict = json.load(open(args.model_definition, 'r'))\n\n model_class: str = config['model_class']\n model_name: str = config['model_name']\n numerical_input_features: List[str] = config['data']['numerical_input_features']\n categorical_input_features: List[str] = config['data']['categorical_input_features']\n output_features: List[str] = config['data']['output_features']\n batch_size_test: int = config['data']['batch_size_test']\n\n device = torch.device(CUDA if torch.cuda.is_available() else CPU)\n\n # # ---------- parse model state ---------- # #\n model_state = load_model_state(args.model_state_path, device)\n\n model_hyperparameters: dict = model_state['hyperparameters']\n model_hyperparameters.update(config['model'])\n model_hyperparameters['device']: torch.device = device\n model_weights: dict = model_state['best_model_state_dict']\n\n # # ---------- initialize model ---------- # #\n model = REGISTERED_MODELS[model_class](**model_hyperparameters).to(device)\n model.load(model_weights)\n\n # # ---------- preprocess data for inference ---------- # #\n test_loader = preprocess_for_inference(\n args.data_path,\n numerical_input_features,\n categorical_input_features,\n output_features,\n args.numerical_preprocessor,\n args.categorical_preprocessor,\n batch_size_test=batch_size_test\n )\n\n # # ---------- compute and save predictions ---------- # #\n predictions = model.predict(test_loader)\n\n # save predictions\n data_file_name = os.path.basename(args.data_path)\n data_file_name = os.path.splitext(data_file_name)[0] # remove extension\n model_path = '{}/predictions_{}_{}.pickle'.format(args.output_directory, model_name, data_file_name)\n print(' [predict] Saving predictions at: `{}`'.format(model_path))\n file_utils.save_to_pickle(\n predictions,\n path=model_path\n )\n print(' [predict] Done')","def main(args):\n # Generate detectron2 config from command line arguments.\n cfg = get_cfg()\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n\n # The configuration file should not contain any datasets. They are configured\n # from command line arguments instead.\n if len(cfg.DATASETS.TRAIN) > 0 or len(cfg.DATASETS.TEST) > 0:\n logging.error(\"Please set DATASETS.TRAIN = () and DATASETS.TEST = ().\")\n sys.exit(1)\n cfg.DATASETS.TRAIN = (TRAIN_SPLIT_NAME, )\n cfg.DATASETS.TEST = (VALID_SPLIT_NAME, )\n\n cfg.freeze()\n default_setup(cfg, args)\n\n # Register synthetic sign datasets.\n if args.image_width is not None or args.image_height is not None:\n if args.image_width is None or args.image_height is None:\n logging.error(\n \"Please specify both, image-width and image-height (or none).\")\n sys.exit(1)\n image_shape = args.image_height, args.image_width\n else:\n image_shape = None\n\n register_synthetic_signs(args.train_csv,\n args.label_map,\n cfg,\n name=TRAIN_SPLIT_NAME,\n image_shape=image_shape)\n if args.valid_csv is not None:\n register_synthetic_signs(args.valid_csv,\n args.label_map,\n cfg,\n name=VALID_SPLIT_NAME,\n image_shape=image_shape)\n\n # Run training or evaluation.\n if args.eval_only:\n model = Trainer.build_model(cfg)\n DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load(\n cfg.MODEL.WEIGHTS, resume=args.resume)\n res = Trainer.test(cfg, model)\n if comm.is_main_process():\n verify_results(cfg, res)\n return res\n\n trainer = Trainer(cfg)\n trainer.resume_or_load(resume=args.resume)\n return trainer.train()","def main(args):\n\n shared_policy_net = build_policy_net(args).share_memory()\n shared_value_net = build_value_net(args).share_memory()\n\n start_training_processes(\n args,\n shared_policy_net,\n shared_value_net,\n )","def main(args: argparse.Namespace, config: Config) -> None:\n # Notes:\n # - 1878 is the number of unique answers from the GQA paper\n # - 1843 is the number of answers across train, val and testdev\n\n # Download and initialise resources\n print(colored(\"initialisation:\", attrs=[\"bold\"]))\n stanza.download(lang=\"en\", dir=\".stanza\")\n\n # Print environment info\n print(colored(\"environment:\", attrs=[\"bold\"]))\n cuda = torch.cuda.is_available()\n device = torch.device(\"cuda\" if cuda else \"cpu\")\n print(f\"device: {torch.cuda.get_device_name(device) if cuda else 'CPU'}\")\n print(config)\n\n if args.job == JobType.PREPROCESS:\n preprocess(config)\n elif args.job in (JobType.TRAIN, JobType.PREDICT):\n resume = None\n if args.resume != \"\":\n run_id, checkpoint = args.resume.split(\":\")\n resume = ResumeInfo(run_id, checkpoint)\n if args.job == JobType.TRAIN:\n train(config, device, resume)\n else:\n predict(config, device, resume)\n else:\n raise NotImplementedError()","def parse_args(args):\n assert os.path.isfile(args.data_path), \"The specified data file does not exist.\"\n assert os.path.isfile(args.model_path), \"The specified model file does not exist.\"\n\n if args.read_batches is not False:\n if args.read_batches.lower() in (\"y\", \"yes\", \"1\", \"\", \"true\", \"t\"):\n args.read_batches = True\n else:\n args.read_batches = False","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"A simple tool to train a character level classifier and predict a class based on an input \"\n \"string. Useful for tasks like detecting country by address line, nationality by name, \"\n \"etc. Prediction is printed into stdout.\",\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\n )\n\n required_group = parser.add_argument_group(\"Required\")\n optional_group = parser.add_argument_group(\"Optional\")\n\n required_group.add_argument(\n \"action\", help=\"Action: train or predict?\", choices=[\"train\", \"predict\"]\n )\n required_group.add_argument(\n \"-f\",\n \"--input-file\",\n help=\"\"\"A file with an input line and a prediction category, separated by SEP (--separator) symbol. If '-' then stdin is used\"\"\",\n required=True,\n )\n required_group.add_argument(\n \"-m\",\n \"--model-file\",\n help=\"Model file. Overwriten after training or loaded for prediction. Tokenizer data will be stored along as 2 <modelname>_tokenizer_x/y.pickle files\",\n required=True,\n )\n optional_group.add_argument(\n \"--extra-lstm-layer\",\n help=\"Add a second LSTM layer for finding extra structure in some cases\",\n action=\"store_true\",\n )\n optional_group.add_argument(\n \"--min-printable-score\",\n help=\"\"\"Don't print the class and its score if the probability is lower than this limit\"\"\",\n type=float,\n default=0.001,\n )\n optional_group.add_argument(\n \"--num-classes\",\n help=\"Print number of classes for each input line\",\n type=int,\n default=1,\n )\n optional_group.add_argument(\n \"--num-epochs\", help=\"Number of training epochs\", type=int, default=NUM_EPOCHS\n )\n optional_group.add_argument(\n \"--print-scores\",\n help=r\"Print scores for each class in such form: CLASS1=95.3%%,CLASS2=3.2%%,etc...\",\n action=\"store_true\",\n )\n optional_group.add_argument(\n \"--separator\",\n help=\"Output separator symbol: orig_lin<SEP><class1=0.98>,<class2=0.01>,...\",\n default=\"|\",\n )\n optional_group.add_argument(\n \"--weights-file\",\n help=\"Weight from previous run if you want to continue training\",\n type=str,\n default=None,\n )\n optional_group.add_argument(\n \"--word-level\",\n help=\"Replace char-level tokenizer for input string with word-level one\",\n action=\"store_true\",\n )\n\n if len(sys.argv) == 1:\n parser.print_help()\n sys.exit(1)\n\n return parser.parse_args()","def load_args():\n parser = argparse.ArgumentParser(description=\"Classify and predict digits using the mnist dataset\")\n parser.add_argument('mode', help='the mode to run in: fit, model or predict')\n parser.add_argument('--algo', help='which algorithm to use: RandomForest, KNN')\n return parser.parse_args()","def cmdline(argv: Sequence[str]) -> None:\n # Configure command line parser\n parser = argparse.ArgumentParser(description=\"Predicting with a flower classifier.\")\n parser.add_argument('image', metavar='IMAGE', type=str, help='path to image file')\n parser.add_argument('checkpoint', metavar='CHECKPOINT', type=str, help='path to checkpoint (.pth)')\n parser.add_argument('--category_names', metavar='PATH', type=str, help='path to category file',\n default='./cat_to_name.json')\n parser.add_argument('--top_k', metavar='K', type=int, help='k-most likely classes', default=5)\n parser.add_argument('--gpu', action='store_true', help='run calculations on GPU if possible',\n default=False, dest='gpu')\n parser.set_defaults(func=predict)\n args = parser.parse_args(argv)\n args.func(args)","def setup(args):\n cfg = get_cfg()\n\n cfg.merge_from_file(model_zoo.get_config_file(\"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml\"))\n cfg.merge_from_list(args.opts)\n\n # configs for training\n if args.small_vidor: # cfg.DATASETS.VIDOR.SIZE == 'small':\n cfg.DATASETS.TRAIN = (\"vidor_small_train\",)\n elif args.small_vidor_10imgs: # cfg.DATASETS.VIDOR.SIZE == 'small-10imgs':\n cfg.DATASETS.TRAIN = (\"vidor_small_10imgs_train\",)\n else:\n cfg.DATASETS.TRAIN = (\"vidor_large_train\",)\n # cfg.DATALOADER.NUM_WORKERS = 2\n if not args.eval_only:\n cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(\"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml\") # Let training initialize from model zoo\n factor = 4\n cfg.SOLVER.IMS_PER_BATCH = 16 * factor\n cfg.SOLVER.BASE_LR = 0.0001 * factor # finetune using 10x smaller base_lr\n cfg.SOLVER.MAX_ITER = 270000 // factor \n cfg.SOLVER.STEPS = [210000 // factor, 250000 // factor]\n # cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 # default: 512\n cfg.MODEL.ROI_HEADS.NUM_CLASSES = 78\n\n # configs for testing\n # cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, \"model_final.pth\")\n if args.small_vidor: # cfg.DATASETS.VIDOR.SIZE == 'small':\n cfg.DATASETS.TEST = (\"vidor_small_val\",)\n elif args.small_vidor_10imgs: # cfg.DATASETS.VIDOR.SIZE == 'small-10imgs':\n cfg.DATASETS.TEST = (\"vidor_small_10imgs_val\",)\n else:\n cfg.DATASETS.TEST = (\"vidor_large_val\",)\n # cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5\n\n # cfg.OUTPUT_DIR = './output/train_vidor_with_pseudo_labels'\n \n \n if not args.eval_only:\n os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)\n cfg.freeze()\n default_setup(cfg, args)\n return cfg","def main(args):\n # ------------------------\n # 1 INIT LIGHTNING MODEL\n # ------------------------\n model = LightningTemplateModel(**vars(args))\n\n # ------------------------\n # 2 INIT TRAINER\n # ------------------------\n trainer = Trainer.from_argparse_args(args)\n\n # ------------------------\n # 3 START TRAINING\n # ------------------------\n trainer.fit(model)","def main():\n config = handle_args()\n print(config)\n\n if config['mode'] == 'train':\n logger.info('Train mode')\n trainer = Trainer(config, shared_theano_params=None, **config)\n trainer.train(**config)\n logger.warn('Exiting train mode')\n else:\n logger.info('Test mode')\n translator = Translator(**config)\n translator.load_from_disk(config['models'], config['configs'],\n config['src_dicts'], config['trg_dict'])\n translator.translate_and_save(**config)","def initialize(self, args):\n # You must parse model_config. JSON string is not parsed here\n self.model_config = json.loads(args['model_config'])\n print(\"model_config:\", self.model_config)\n\n self.input_names = []\n for input_config in self.model_config[\"input\"]:\n self.input_names.append(input_config[\"name\"])\n print(\"postprocess input names:\", self.input_names)\n\n self.output_names = []\n self.output_dtype = []\n for output_config in self.model_config[\"output\"]:\n self.output_names.append(output_config[\"name\"])\n dtype = pb_utils.triton_string_to_numpy(output_config[\"data_type\"])\n self.output_dtype.append(dtype)\n print(\"postprocess output names:\", self.output_names)\n self.postprocessor = fd.vision.ocr.DBDetectorPostprocessor()\n self.cls_preprocessor = fd.vision.ocr.ClassifierPreprocessor()\n self.rec_preprocessor = fd.vision.ocr.RecognizerPreprocessor()\n self.cls_threshold = 0.9","def main(args):\n # If using a real ensemble, the actual number of models is --ensemble;\n # otherwise we only train 1 model (and construct a \"fake\" ensemble later)\n if args.ensemble_type == \"real\":\n n_ens = args.ensemble\n else:\n n_ens = 1\n\n # Check if resumable\n resumable = args.resume and all(\n io_util.is_resumable(args.exp_dir, i=i) for i in range(n_ens)\n )\n if resumable:\n logger.warning(\n \"When resuming, we don't support multiple start epochs...if --warm_start, models may get trained for an extra epoch or two\"\n )\n os.makedirs(args.exp_dir, exist_ok=True)\n if not resumable:\n io_util.save_args(args, args.exp_dir)\n\n # Seeds\n torch.manual_seed(args.seed)\n\n # Cuda device\n if args.cuda and args.cuda_id != -1:\n torch.cuda.set_device(args.cuda_id)\n\n dataloaders, vocab = builders.build_dataloaders(args)\n models, optimizer_func, losses = builders.build_ensemble(args, vocab)\n optimizers = optimizer_func()\n\n # Initialize / load checkpoint\n all_metrics = []\n if resumable:\n for i in range(n_ens):\n io_util.restore_checkpoint(models[i], optimizers[i], args.exp_dir, i=i)\n metrics = io_util.load_metrics(args.exp_dir, i=i)\n all_metrics.append(metrics)\n\n # FIXME: Resuming isn't quite correct yet:\n # (1) need to restore the dataloaders based on existing EIG (make that\n # a func used by al.acq)\n # (2) Reload eig_records, all_eig_details\n start_epoch = min(m[\"current_epoch\"] for m in all_metrics) + 1\n\n if os.path.exists(os.path.join(args.exp_dir, \"ens_metrics.json\")):\n ens_metrics = io_util.load_metrics(\n args.exp_dir, filename=\"ens_metrics.json\"\n )\n else:\n ens_metrics = util.init_metrics(ensemble=True)\n\n logger.info(\"Resuming from epoch {}\".format(start_epoch))\n else:\n for i in range(n_ens):\n metrics = util.init_metrics(ensemble=False)\n all_metrics.append(metrics)\n start_epoch = 0\n ens_metrics = util.init_metrics(ensemble=True)\n\n # Pooling (\n if args.eig_workers == 0 or args.eig_method == \"random\":\n pool_ctx = util.FakePool\n else:\n pool_ctx = mp.Pool\n\n all_eig_details = defaultdict(list)\n eig_records = []\n if args.warm_start or args.acquisition == \"eig_y\":\n # Keep the same EIG optimizer if warm start OR if acquire_y (to prevent waste)\n # Only applies to acquire_xy; in acquire_y, new optimizer for each image\n eig_config = builders.build_eig_estimator(\n args, vocab, model_batch_size=args.qhy_batch_size\n )\n else:\n eig_config = None\n\n # Loop through acquisition steps\n for acq_step in range(start_epoch, args.epochs):\n # ==== INDIVIDUAL MODEL TRAINING ====\n for i, (model, optimizer, loss, metrics) in enumerate(\n zip(models, optimizers, losses, all_metrics)\n ):\n if args.no_train:\n break\n # Train on seed set - inner loop\n best_model_state_dict = None\n val_evals_since_improvement = 0\n\n if args.dataset == \"wmt14\":\n best_val_metrics = {\n \"loss\": float(\"inf\"),\n \"top1\": 0.0,\n \"ppl\": float(\"inf\"),\n }\n rf = run_mt\n else:\n best_val_metrics = {\"loss\": float(\"inf\"), \"top5\": 0.0, \"top1\": 0.0}\n rf = run\n\n for epoch in trange(\n 0,\n args.inner_epochs,\n desc=f\"acq step {acq_step}/{args.epochs} (size {len(dataloaders['seed'].dataset)}): train model {i}\",\n ):\n train_metrics = rf(\n \"seed\", epoch, model, optimizer, loss, dataloaders, args, i\n )\n util.print_metrics_progress(\n \"train\", epoch, train_metrics, i, logger=logger\n )\n if (epoch + 1) % args.val_interval == 0: # since epochs are 0-indexed\n val_metrics = rf(\n \"val\", epoch, model, optimizer, loss, dataloaders, args, i\n )\n util.print_metrics_progress(\n \"val\", epoch, val_metrics, i, logger=logger\n )\n if val_metrics[\"top1\"] > best_val_metrics[\"top1\"]:\n best_val_metrics = val_metrics\n best_val_metrics[\"epoch\"] = epoch\n best_model_state_dict = copy.deepcopy(model.state_dict())\n val_evals_since_improvement = 0\n else:\n val_evals_since_improvement += 1\n\n if val_evals_since_improvement >= args.val_patience:\n logger.info(\n f\"Stopped at inner epoch {epoch}; no improvement after {val_evals_since_improvement} evals (best top1: {best_val_metrics['top1']:f})\"\n )\n break\n\n if best_model_state_dict is None:\n # No early stopping was performed, val was never evaluated\n best_model_state_dict = copy.deepcopy(model.state_dict())\n\n # Restore best model\n model.load_state_dict(best_model_state_dict)\n\n # Update your metrics, prepending the split name.\n for metric, value in train_metrics.items():\n metrics[\"train_{}\".format(metric)].append(value)\n for metric, value in best_val_metrics.items():\n metrics[\"val_{}\".format(metric)].append(value)\n metrics[\"current_epoch\"] = acq_step\n\n # Check if there was an improvement\n is_best = best_val_metrics[\"top1\"] > metrics[\"best_top1\"]\n if is_best:\n metrics[\"best_top1\"] = best_val_metrics[\"top1\"]\n metrics[\"best_loss\"] = best_val_metrics[\"loss\"]\n metrics[\"best_epoch\"] = acq_step\n\n if is_best:\n metrics[\"epochs_since_improvement\"] = 0\n else:\n metrics[\"epochs_since_improvement\"] += 1\n logger.info(\n f\"Epochs since last improvement: {metrics['epochs_since_improvement']}\"\n )\n\n state_dict = {\n \"state_dict\": model.state_dict(),\n \"optimizer\": optimizer.state_dict(),\n }\n io_util.save_checkpoint(state_dict, is_best, args.exp_dir, i=i)\n # Save checkpoint at fixed intervals based on epoch\n if acq_step % args.save_interval == 0:\n io_util.save_checkpoint(\n state_dict,\n False,\n args.exp_dir,\n filename=\"{}.pth\".format(acq_step),\n i=i,\n )\n\n io_util.save_metrics(metrics, args.exp_dir, i=i)\n\n # ==== ENSEMBLE EVAL ====\n if args.eval_ensemble:\n if args.dataset not in {\"mnist\"}:\n raise NotImplementedError\n if args.ensemble_type == \"mc\":\n raise NotImplementedError\n ens = ensemble.Ensemble(models)\n this_ens_metrics = eval_ensemble(\n \"val\", ens, dataloaders, args, eval_batch_size=4\n )\n for metric, value in this_ens_metrics.items():\n ens_metrics[\"ens_{}\".format(metric)].append(value)\n ens_metrics[\"current_epoch\"] = acq_step\n if this_ens_metrics[\"acc\"] > ens_metrics[\"best_ens_acc\"]:\n ens_metrics[\"best_ens_acc\"] = this_ens_metrics[\"acc\"]\n ens_metrics[\"best_ens_loss\"] = this_ens_metrics[\"loss\"]\n ens_metrics[\"best_ens_epoch\"] = acq_step\n io_util.save_metrics(ens_metrics, args.exp_dir, filename=\"ens_metrics.json\")\n\n util.print_ensemble_progress(\n acq_step, all_metrics, ens_metrics=ens_metrics, logger=logger\n )\n\n # ==== ACQUISITION ====\n # Compute sizes (e.g. if they are % of dataset)\n current_pool_size = len(dataloaders[\"pool\"].dataset)\n current_seed_size = len(dataloaders[\"seed\"].dataset)\n dataset_size = current_pool_size + current_seed_size\n pool_size = util.compute_size(\n args.pool_size, dataset_size, remaining_dataset_size=current_pool_size\n )\n acq_size = util.compute_size(args.acq_size, dataset_size)\n\n if args.ensemble_type == \"real\":\n ens = ensemble.Ensemble(models).eval()\n else:\n assert len(models) == 1\n ens = ensemble.MCEnsemble(models[0], n=args.ensemble).eval()\n if args.compare is not None:\n # Preselect a pool and evaluate EIG for each datum with all\n # available methods. Do selection according to the selected EIG\n pool = util.sample_idx(\n pool_size, RandomSampler(dataloaders[\"pool\"].dataset)\n )\n # Save real run for last\n acq_methods = args.compare[:]\n acq_methods.append(args.acquisition)\n else:\n # Just do one\n pool = None\n acq_methods = [args.acquisition]\n\n # Possible to run some acq methods multiple times\n acq_method_counts = Counter(acq_methods)\n counts = Counter()\n for acq_method_i, acq_method in enumerate(acq_methods):\n # Only the last acq_method is not a dry run\n dry_run = acq_method_i != len(acq_methods) - 1\n if acq_method in {\"eig_xy\", \"batchbald\", \"batcheig\"}:\n acqf = {\n \"eig_xy\": al.acquisition.acquire_xy,\n \"batcheig\": al.acquisition.acquire_batcheig,\n \"batchbald\": al.acquisition.acquire_batchbald,\n }[acq_method]\n eig_record, eig_details = acqf(\n acq_size,\n pool_size,\n ens,\n dataloaders,\n args,\n eig_config=eig_config,\n pool=pool,\n dry_run=dry_run,\n )\n else:\n with pool_ctx(args.eig_workers) as mp_pool:\n eig_record, eig_details = al.acquisition.acquire_y(\n al.funcs.ACQ_FUNCS[acq_method],\n acq_size,\n pool_size,\n ens,\n dataloaders,\n args,\n mp_pool=mp_pool,\n eig_config=eig_config,\n pool=pool,\n dry_run=dry_run,\n epoch=acq_step,\n )\n\n eig_record[\"epoch\"] = acq_step\n if not dry_run:\n logger.info(eig_record)\n\n if acq_method_counts[acq_method] > 1:\n n_done = counts[acq_method]\n counts[acq_method] += 1\n acq_method = f\"{acq_method}_{n_done}\"\n\n eig_record[\"method\"] = acq_method\n eig_record[\"dry_run\"] = dry_run\n eig_records.append(eig_record)\n\n for edname, edval in eig_details.items():\n all_eig_details[edname].extend(edval)\n all_eig_details[\"method\"].extend(acq_method for _ in eig_details[\"id\"])\n all_eig_details[\"dry_run\"].extend(dry_run for _ in eig_details[\"id\"])\n all_eig_details[\"epoch\"].extend(acq_step for _ in eig_details[\"id\"])\n\n eig_fname = os.path.join(args.exp_dir, \"eig.csv\")\n pd.DataFrame.from_records(eig_records).to_csv(eig_fname, index=False)\n\n eig_details_fname = os.path.join(args.exp_dir, \"eig_details.csv\")\n pd.DataFrame(all_eig_details).to_csv(eig_details_fname, index=False)\n\n # Done acquiring - reset parameters\n if not args.warm_start:\n ens.reset_parameters()\n optimizers = optimizer_func()","def load_arguments(parser):\n\n\t# paths\n\tparser.add_argument('--train_path_src', type=str, required=True, help='train src dir')\n\tparser.add_argument('--train_path_tgt', type=str, required=True, help='train tgt dir')\n\tparser.add_argument('--path_vocab_src', type=str, required=True, help='vocab src dir')\n\tparser.add_argument('--path_vocab_tgt', type=str, required=True, help='vocab tgt dir')\n\tparser.add_argument('--dev_path_src', type=str, default=None, help='dev src dir')\n\tparser.add_argument('--dev_path_tgt', type=str, default=None, help='dev tgt dir')\n\tparser.add_argument('--save', type=str, required=True, help='model save dir')\n\tparser.add_argument('--load', type=str, default=None, help='model load dir')\n\tparser.add_argument('--load_embedding_src', type=str, default=None, help='pretrained src embedding')\n\tparser.add_argument('--load_embedding_tgt', type=str, default=None, help='pretrained tgt embedding')\n\tparser.add_argument('--train_attscore_path', type=str, default=None, help='train set reference attention scores')\n\tparser.add_argument('--dev_attscore_path', type=str, default=None, help='dev set reference attention scores')\n\n\t# model\n\tparser.add_argument('--embedding_size_enc', type=int, default=200, help='encoder embedding size')\n\tparser.add_argument('--embedding_size_dec', type=int, default=200, help='decoder embedding size')\n\tparser.add_argument('--hidden_size_enc', type=int, default=200, help='encoder hidden size')\n\tparser.add_argument('--num_bilstm_enc', type=int, default=2, help='number of encoder bilstm layers')\n\tparser.add_argument('--num_unilstm_enc', type=int, default=0, help='number of encoder unilstm layers')\n\tparser.add_argument('--hidden_size_dec', type=int, default=200, help='encoder hidden size')\n\tparser.add_argument('--num_unilstm_dec', type=int, default=2, help='number of encoder bilstm layers')\n\tparser.add_argument('--hard_att', type=str, default='False', help='use hard attention or not')\n\tparser.add_argument('--att_mode', type=str, default='bahdanau', \\\n\t\t\t\t\t\t\thelp='attention mechanism mode - bahdanau / hybrid / dot_prod')\t\n\tparser.add_argument('--hidden_size_att', type=int, default=1, \\\n\t\t\t\t\t\t\thelp='hidden size for bahdanau / hybrid attention')\n\tparser.add_argument('--hidden_size_shared', type=int, default=200, \\\n\t\t\t\t\t\t\thelp='transformed att output hidden size (set as hidden_size_enc)')\n\tparser.add_argument('--additional_key_size', type=int, default=0, \\\n\t\t\t\t\t\t\thelp='additional attention key size: keys = [values, add_feats]')\n\n\t# train \n\tparser.add_argument('--random_seed', type=int, default=666, help='random seed')\t\n\tparser.add_argument('--max_seq_len', type=int, default=32, help='maximum sequence length')\n\tparser.add_argument('--batch_size', type=int, default=64, help='batch size')\t\n\tparser.add_argument('--embedding_dropout', type=float, default=0.0, help='embedding dropout')\n\tparser.add_argument('--dropout', type=float, default=0.0, help='dropout')\n\tparser.add_argument('--num_epochs', type=int, default=10, help='number of training epoches')\n\tparser.add_argument('--learning_rate', type=float, default=0.001, help='learning rate')\n\tparser.add_argument('--residual', type=str, default='False', help='residual connection')\n\tparser.add_argument('--max_grad_norm', type=float, default=1.0, help='optimiser gradient norm clipping: max grad norm')\t\n\tparser.add_argument('--batch_first', type=str, default='True', help='batch as the first dimension')\n\tparser.add_argument('--use_gpu', type=str, default='False', help='whether or not using GPU')\n\tparser.add_argument('--eval_with_mask', type=str, default='True', help='calc loss excluding padded words')\n\tparser.add_argument('--scheduled_sampling', type=str, default='False', \\\n\t\t\t\t\t \t\thelp='gradually turn off teacher forcing \\\n\t\t\t\t\t \t\t(if True, use teacher_forcing_ratio as the starting point)')\n\n\t# teacher forcing / attention forcing / dual\n\tparser.add_argument('--train_mode', type=str, default='dual', help='train mode; multi | dual | afdynamic')\n\tparser.add_argument('--load_tf', type=str, default=None, help='used with train_mode=af; tf model load dir')\n\tparser.add_argument('--teacher_forcing_ratio', type=float, default=1.0, help='ratio of teacher forcing')\n\tparser.add_argument('--attention_forcing', type=str, default='False', help='whether or not using attention forcing')\n\tparser.add_argument('--attention_loss_coeff', type=float, default=1.0, \\\n\t\t\t\t\t\t\thelp='attention loss coeff, ignored if attention_forcing=False')\n\t\n\t# save and print\n\tparser.add_argument('--checkpoint_every', type=int, default=10, help='save ckpt every n steps')\t\n\tparser.add_argument('--print_every', type=int, default=10, help='print every n steps')\t\n\n\treturn parser","def main():\n args = parse_args(sys.argv[1:])\n\n if args.version:\n print(birdvoxclassify.version.version)\n return\n\n if args.quiet:\n logger_level = 30\n elif args.verbose:\n logger_level = 20\n else:\n logger_level = 25\n\n run(args.inputs,\n output_dir=args.output_dir,\n output_summary_path=args.output_summary_path,\n model_name=args.model_name,\n batch_size=args.batch_size,\n select_best_candidates=args.select_best_candidates,\n hierarchical_consistency=args.hierarchical_consistency,\n suffix=args.suffix,\n logger_level=logger_level)","def parse_args(args):\n parser = argparse.ArgumentParser(\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\n description='Train a detection model from an already prepared dataset')\n\n # Mandatory arguments\n parser.add_argument(\n 'base_dataset_dir', help='directory containing the prepared dataset')\n\n parser.add_argument('dataset_dir', help='path to temporary directory')\n\n # Options\n parser.add_argument(\n '-o',\n '--output-model',\n default='model.h5',\n help='filename for output model')\n\n parser.add_argument(\n '--seed', type=int, help='seed number for the random number generator')\n parser.add_argument(\n \"--test-size\",\n type=float,\n default=0.25,\n help=(\"The proportion of the dataset to include in the test split. \"\n \"Float number between 0.0 and 1.0\"))\n parser.add_argument(\n \"--validation-size\",\n type=float,\n default=0.25,\n help=(\n \"The proportion of the dataset to include in the validation split. \"\n \"Float number between 0.0 and 1.0\"))\n parser.add_argument(\n \"--balancing-multiplier\",\n type=float,\n default=1.0,\n help=\n \"proportion of false samples w.r.t true samples (e.g. 1.0 = 50%% true, 50%% false)\"\n )\n parser.add_argument(\n \"--trainable-layers\",\n type=int,\n default=5,\n help=\"number of upper layers of ResNet-50 to retrain\")\n parser.add_argument(\"--batch-size\", type=int, default=5, help=\"Batch size\")\n parser.add_argument(\n \"--epochs\", type=int, default=20, help=\"number of epochs to run\")\n\n parser.add_argument(\n '--version',\n action='version',\n version='aplatam {ver}'.format(ver=__version__))\n parser.add_argument(\n '-v',\n '--verbose',\n dest=\"loglevel\",\n help=\"set loglevel to INFO\",\n action='store_const',\n const=logging.INFO)\n parser.add_argument(\n '-vv',\n '--very-verbose',\n dest=\"loglevel\",\n help=\"set loglevel to DEBUG\",\n action='store_const',\n const=logging.DEBUG)\n\n return parser.parse_args(args)","def main(args):\n args = parse_args(args)\n setup_logging(args.loglevel)\n dataset_opts = read_metadata(args.base_dataset_dir)\n size = dataset_opts[\"size\"]\n\n # Set seed number\n if args.seed:\n _logger.info('Seed: %d', args.seed)\n random.seed(args.seed)\n\n # Gather all files in dataset\n true_files = glob.glob(os.path.join(args.base_dataset_dir, 't', '*.jpg'))\n false_files = glob.glob(os.path.join(args.base_dataset_dir, 'f', '*.jpg'))\n\n # Split dataset into train, validation and test sets\n split_dataset(\n (true_files, false_files),\n args.base_dataset_dir,\n test_size=args.test_size,\n validation_size=args.validation_size,\n balancing_multiplier=args.balancing_multiplier)\n\n train(args.trainable_layers, args.output_model, args.batch_size,\n args.epochs, size, args.dataset_dir)\n\n _logger.info('Done')","def main():\r\n # Read dataset.\r\n reader = DatasetReader\r\n train_filename = sys.argv[1]\r\n test_filename = train_filename.replace('_train_', '_dev_')\r\n term_index, tag_index, train_data, test_data = reader.ReadData(train_filename, test_filename)\r\n (train_terms, train_tags, train_lengths) = train_data\r\n (test_terms, test_tags, test_lengths) = test_data\r\n\r\n model = SequenceModel(train_tags.shape[1], len(term_index), len(tag_index))\r\n model.build_inference()\r\n model.build_training()\r\n for j in range(5):\r\n model.train_epoch(train_terms,train_tags, train_lengths)\r\n print('Finished epoch %i. Evaluating ...' % (j+1))\r\n model.evaluate(test_terms, test_tags, test_lengths)","def main():\n\n if len(sys.argv) == 3:\n database_filepath, model_filepath = sys.argv[1:]\n print('Loading data...\\n DATABASE: {}'.format(database_filepath))\n X, Y, category_names = load_data(database_filepath)\n X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)\n \n print('Building model...')\n model = build_model()\n \n print('Training model...')\n model.fit(X_train, Y_train)\n \n print('Evaluating model...')\n evaluate_model(model, X_test, Y_test, category_names)\n\n print('Saving model...\\n MODEL: {}'.format(model_filepath))\n save_model(model, model_filepath)\n\n print('Trained model saved!')\n\n else:\n print('Please provide the filepath of the disaster messages database '\\\n 'as the first argument and the filepath of the pickle file to '\\\n 'save the model to as the second argument. \\n\\nExample: python '\\\n 'train_classifier.py ../data/DisasterResponse.db classifier.pkl')","def parse_arguments(args_to_parse):\n\tdefault_config = get_config_section([CONFIG_FILE], \"Custom\")\n\n\tdescription = \"PyTorch implementation and evaluation of disentangled Variational AutoEncoders and metrics.\"\n\tparser = argparse.ArgumentParser(description=description,\n\t\t\t\t\t\t\t\t\t formatter_class=FormatterNoDuplicate)\n\n\t# General options\n\tgeneral = parser.add_argument_group('General options')\n\tgeneral.add_argument('name', type=str,\n\t\t\t\t\t\t help=\"Name of the model for storing and loading purposes.\")\n\tgeneral.add_argument('-L', '--log-level', help=\"Logging levels.\",\n\t\t\t\t\t\t default=default_config['log_level'], choices=LOG_LEVELS)\n\tgeneral.add_argument('--no-progress-bar', action='store_true',\n\t\t\t\t\t\t default=default_config['no_progress_bar'],\n\t\t\t\t\t\t help='Disables progress bar.')\n\tgeneral.add_argument('--no-cuda', action='store_true',\n\t\t\t\t\t\t default=default_config['no_cuda'],\n\t\t\t\t\t\t help='Disables CUDA training, even when have one.')\n\tgeneral.add_argument('-s', '--seed', type=int, default=default_config['seed'],\n\t\t\t\t\t\t help='Random seed. Can be `None` for stochastic behavior.')\n\tgeneral.add_argument('-c', '--classifier', type = str,\n\t\t\t\t\t\t help='Name of the classifeir')\n\t# Learning options\n\ttraining = parser.add_argument_group('Training specific options')\n\ttraining.add_argument('--checkpoint-every',\n\t\t\t\t\t\t type=int, default=default_config['checkpoint_every'],\n\t\t\t\t\t\t help='Save a checkpoint of the trained model every n epoch.')\n\ttraining.add_argument('-d', '--dataset', help=\"Path to training data.\",\n\t\t\t\t\t\t default=default_config['dataset'], choices=DATASETS)\n\ttraining.add_argument('-x', '--experiment',\n\t\t\t\t\t\t default=default_config['experiment'], choices=EXPERIMENTS,\n\t\t\t\t\t\t help='Predefined experiments to run. If not `custom` this will overwrite some other arguments.')\n\ttraining.add_argument('-e', '--epochs', type=int,\n\t\t\t\t\t\t default=default_config['epochs'],\n\t\t\t\t\t\t help='Maximum number of epochs to run for.')\n\ttraining.add_argument('-b', '--batch-size', type=int,\n\t\t\t\t\t\t default=default_config['batch_size'],\n\t\t\t\t\t\t help='Batch size for training.')\n\ttraining.add_argument('--lr', type=float, default=default_config['lr'],\n\t\t\t\t\t\t help='Learning rate.')\n\ttraining.add_argument('-g', '--gamma', type = float, default = 1., help = 'gamma for var')\n\n\t# Model Options\n\tmodel = parser.add_argument_group('Model specfic options')\n\tmodel.add_argument('-m', '--model-type',\n\t\t\t\t\t default=default_config['model'], choices=MODELS,\n\t\t\t\t\t help='Type of encoder and decoder to use.')\n\tmodel.add_argument('-z', '--latent-dim', type=int,\n\t\t\t\t\t default=default_config['latent_dim'],\n\t\t\t\t\t help='Dimension of the latent variable.')\n\tmodel.add_argument('-l', '--loss',\n\t\t\t\t\t default=default_config['loss'], choices=LOSSES,\n\t\t\t\t\t help=\"Type of VAE loss function to use.\")\n\tmodel.add_argument('-r', '--rec-dist', default=default_config['rec_dist'],\n\t\t\t\t\t choices=RECON_DIST,\n\t\t\t\t\t help=\"Form of the likelihood ot use for each pixel.\")\n\tmodel.add_argument('-a', '--reg-anneal', type=float,\n\t\t\t\t\t default=default_config['reg_anneal'],\n\t\t\t\t\t help=\"Number of annealing steps where gradually adding the regularisation. What is annealed is specific to each loss.\")\n\n\t# Loss Specific Options\n\tbetaH = parser.add_argument_group('BetaH specific parameters')\n\tbetaH.add_argument('--betaH-B', type=float,\n\t\t\t\t\t default=default_config['betaH_B'],\n\t\t\t\t\t help=\"Weight of the KL (beta in the paper).\")\n\n\tbetaB = parser.add_argument_group('BetaB specific parameters')\n\tbetaB.add_argument('--betaB-initC', type=float,\n\t\t\t\t\t default=default_config['betaB_initC'],\n\t\t\t\t\t help=\"Starting annealed capacity.\")\n\tbetaB.add_argument('--betaB-finC', type=float,\n\t\t\t\t\t default=default_config['betaB_finC'],\n\t\t\t\t\t help=\"Final annealed capacity.\")\n\tbetaB.add_argument('--betaB-G', type=float,\n\t\t\t\t\t default=default_config['betaB_G'],\n\t\t\t\t\t help=\"Weight of the KL divergence term (gamma in the paper).\")\n\n\tfactor = parser.add_argument_group('factor VAE specific parameters')\n\tfactor.add_argument('--factor-G', type=float,\n\t\t\t\t\t\tdefault=default_config['factor_G'],\n\t\t\t\t\t\thelp=\"Weight of the TC term (gamma in the paper).\")\n\tfactor.add_argument('--lr-disc', type=float,\n\t\t\t\t\t\tdefault=default_config['lr_disc'],\n\t\t\t\t\t\thelp='Learning rate of the discriminator.')\n\n\tbtcvae = parser.add_argument_group('beta-tcvae specific parameters')\n\tbtcvae.add_argument('--btcvae-A', type=float,\n\t\t\t\t\t\tdefault=default_config['btcvae_A'],\n\t\t\t\t\t\thelp=\"Weight of the MI term (alpha in the paper).\")\n\tbtcvae.add_argument('--btcvae-G', type=float,\n\t\t\t\t\t\tdefault=default_config['btcvae_G'],\n\t\t\t\t\t\thelp=\"Weight of the dim-wise KL term (gamma in the paper).\")\n\tbtcvae.add_argument('--btcvae-B', type=float,\n\t\t\t\t\t\tdefault=default_config['btcvae_B'],\n\t\t\t\t\t\thelp=\"Weight of the TC term (beta in the paper).\")\n\n\t# Learning options\n\tevaluation = parser.add_argument_group('Evaluation specific options')\n\tevaluation.add_argument('--is-eval-only', action='store_true',\n\t\t\t\t\t\t\tdefault=default_config['is_eval_only'],\n\t\t\t\t\t\t\thelp='Whether to only evaluate using precomputed model `name`.')\n\tevaluation.add_argument('--is-metrics', action='store_true',\n\t\t\t\t\t\t\tdefault=default_config['is_metrics'],\n\t\t\t\t\t\t\thelp=\"Whether to compute the disentangled metrcics. Currently only possible with `dsprites` as it is the only dataset with known true factors of variations.\")\n\tevaluation.add_argument('--no-test', action='store_true',\n\t\t\t\t\t\t\tdefault=default_config['no_test'],\n\t\t\t\t\t\t\thelp=\"Whether not to compute the test losses.`\")\n\tevaluation.add_argument('--eval-batchsize', type=int,\n\t\t\t\t\t\t\tdefault=default_config['eval_batchsize'],\n\t\t\t\t\t\t\thelp='Batch size for evaluation.')\n\n\targs = parser.parse_args(args_to_parse)\n\tif args.experiment != 'custom':\n\t\tif args.experiment not in ADDITIONAL_EXP:\n\t\t\t# update all common sections first\n\t\t\tmodel, dataset = args.experiment.split(\"_\")\n\t\t\tcommon_data = get_config_section([CONFIG_FILE], \"Common_{}\".format(dataset))\n\t\t\tupdate_namespace_(args, common_data)\n\t\t\tcommon_model = get_config_section([CONFIG_FILE], \"Common_{}\".format(model))\n\t\t\tupdate_namespace_(args, common_model)\n\n\t\ttry:\n\t\t\texperiments_config = get_config_section([CONFIG_FILE], args.experiment)\n\t\t\tupdate_namespace_(args, experiments_config)\n\t\texcept KeyError as e:\n\t\t\tif args.experiment in ADDITIONAL_EXP:\n\t\t\t\traise e # only reraise if didn't use common section\n\n\treturn args","def init_argparser() -> ArgumentParser:\n parser = ArgumentParser()\n from_config = parser.add_argument_group('From config file', 'Provide full experiment setup via config file')\n from_config.add_argument('-c', '--config', help='Path to json file containing classification config.')\n from_cmd = parser.add_argument_group('From commandline', 'Specify experiment setup via commandline arguments')\n\n # Model options\n from_cmd.add_argument(\"--recoding_type\", type=str, default=None,\n choices=[\"mc_dropout\", \"surprisal\", \"ensemble\"],\n help=\"Recoding model type used for trainign. Choices include recoding based on MC Dropout,\"\n \"perplexity and anchored ensembles. If not specified, a vanilla model without recoding\"\n \"is used.\")\n from_cmd.add_argument(\"--step_type\", type=str, default=None, choices=[\"fixed\", \"mlp\", \"learned\"],\n help=\"Specifies the way the step size is determined when using a recoding model.\")\n from_cmd.add_argument(\"--step_size\", type=float,\n help=\"Step size for recoding in case the fixed step predictor is used.\")\n from_cmd.add_argument(\"--embedding_size\", type=int, help=\"Dimensionality of word embeddings.\")\n from_cmd.add_argument(\"--hidden_size\", type=int, help=\"Dimensionality of hidden states.\")\n from_cmd.add_argument(\"--num_layers\", type=int, help=\"Number of network layers.\")\n from_cmd.add_argument(\"--mc_dropout\", type=float, help=\"Dropout probability when estimating uncertainty.\")\n from_cmd.add_argument(\"--dropout\", type=float, help=\"Dropout probability for model in general.\")\n from_cmd.add_argument(\"--num_samples\", type=int, help=\"Number of samples used when estimating uncertainty.\")\n\n # Training options\n from_cmd.add_argument(\"--weight_decay\", type=float, help=\"Weight decay parameter when estimating uncertainty.\")\n from_cmd.add_argument(\"--prior_scale\", type=float,\n help=\"Prior length scale. A lower scale signifies a prior belief that the input data is \"\n \"distributed infrequently, a higher scale does the opposite.\")\n from_cmd.add_argument(\"--learning_rate\", type=float, help=\"Learning rate during training.\")\n from_cmd.add_argument(\"--batch_size\", type=int, help=\"Batch size during training.\")\n from_cmd.add_argument(\"--num_epochs\", type=int, help=\"Number of training epochs.\")\n from_cmd.add_argument(\"--clip\", type=float, help=\"Threshold for gradient clipping.\")\n\n # Corpus options\n from_cmd.add_argument(\"--corpus_dir\", type=str, help=\"Directory to corpus files.\")\n from_cmd.add_argument(\"--max_seq_len\", type=int, help=\"Maximum sentence length when reading in the corpora.\")\n\n # Screen output optins\n from_cmd.add_argument(\"--print_every\", type=int, help=\"Batch interval at which training info should be printed.\")\n from_cmd.add_argument(\"--eval_every\", type=int,\n help=\"Epoch interval at which the model should be evaluated on validation set.\")\n\n # Model saving and logging options\n from_cmd.add_argument(\"--model_name\", type=str, help=\"Model identifier.\")\n from_cmd.add_argument(\"--model_save_path\", type=str,\n help=\"Directory to which current best model should be saved to.\")\n from_cmd.add_argument(\"--device\", type=str, default=\"cpu\", help=\"Device used for training.\")\n from_cmd.add_argument(\"--log_dir\", type=str, help=\"Directory to write (tensorboard) logs to.\")\n\n return parser","def train(args):\n # Copy the project file.\n # TODO: If the file exists, ask the user if it shall be deleted.\n if os.path.isfile(args.outfile):\n os.remove(args.outfile)\n shutil.copyfile(args.train, args.outfile)\n\n # Create an ILP object for the project.\n proj = ILP(args.outfile, args.cache, args.compression)\n\n # Do the autocontext loop.\n autocontext(args.ilastik, proj, args.nloops, args.labeldataset, weights=args.weights, predict_file=args.predict_file)","def main():\n parser = argparse.ArgumentParser()\n subparsers = parser.add_subparsers(dest='mode')\n\n # Add sub-parser for feature extraction\n parser_extract = subparsers.add_parser('extract')\n parser_extract.add_argument('dataset',\n choices=['training', 'validation', 'test'],\n )\n\n # Add sub-parser for training\n subparsers.add_parser('train')\n\n # Add sub-parser for inference\n parser_predict = subparsers.add_parser('predict')\n parser_predict.add_argument('dataset',\n nargs='?',\n choices=['validation', 'test'],\n default='test',\n )\n\n # Add sub-parser for evaluation\n parser_evaluate = subparsers.add_parser('evaluate')\n parser_evaluate.add_argument('task',\n nargs='?',\n choices=['tagging', 'sed', 'all'],\n default='all',\n )\n parser_evaluate.add_argument('dataset',\n nargs='?',\n choices=['validation', 'test'],\n default='test',\n )\n parser_evaluate.add_argument('--thresholds', action='store_true')\n\n args = parser.parse_args()\n\n if args.mode == 'extract':\n extract(cfg.to_dataset(args.dataset))\n elif args.mode == 'train':\n train()\n elif args.mode == 'predict':\n predict(cfg.to_dataset(args.dataset))\n elif args.mode == 'evaluate':\n eval_all = args.task == 'all'\n dataset = cfg.to_dataset(args.dataset)\n if args.task == 'tagging' or eval_all:\n evaluate_audio_tagging(dataset, args.thresholds)\n if args.task == 'sed' or eval_all:\n evaluate_sed(dataset)","def main():\n if len(sys.argv) == 3:\n database_filepath, model_filepath = sys.argv[1:]\n nltk.download(['punkt', 'wordnet'])\n print('Loading data...\\n DATABASE: {}'.format(database_filepath))\n X, Y, category_names = load_data(database_filepath)\n X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)\n\n print('Building model...')\n model = build_model()\n\n print('Training model...')\n model.fit(X_train, Y_train)\n\n print('Evaluating model...')\n evaluate_model(model, X_test, Y_test, category_names)\n\n print('Saving model...\\n MODEL: {}'.format(model_filepath))\n save_model(model, model_filepath)\n\n print('Trained model saved!')\n\n else:\n print('Please provide the filepath of the disaster messages database '\\\n 'as the first argument and the filepath of the pickle file to '\\\n 'save the model to as the second argument. \\n\\nExample: python '\\\n 'train_classifier.py ../data/DisasterResponse.db classifier.pkl')","def add_train_args(parser):\n parser.register('type', 'bool', str2bool)\n # Runtime environment\n runtime = parser.add_argument_group('Environment')\n runtime.add_argument('--no-cuda', type='bool', default=False,\n help='Train on CPU, even if GPUs are available.')\n runtime.add_argument('--gpu', type=int, default=-1,\n help='Run on a specific GPU')\n runtime.add_argument('--data-workers', type=int, default=5,\n help='Number of subprocesses for data loading')\n runtime.add_argument('--random-seed', type=int, default=1013,\n help=('Random seed for all numpy/torch/cuda '\n 'operations (for reproducibility)'))\n runtime.add_argument('--num-epochs', type=int, default=40,\n help='Train data iterations')\n runtime.add_argument('--batch-size', type=int, default=32,\n help='Batch size for training')\n runtime.add_argument('--dev-batch-size', type=int, default=16,\n help='Batch size for training')\n\n # Files\n files = parser.add_argument_group('Filesystem')\n files.add_argument('--model-dir', type=str, default=MODEL_DIR,\n help='Directory for saved models/checkpoints/logs')\n files.add_argument('--model-name', type=str, default='',\n help='Unique model identifier (.mdl, .txt, .checkpoint)')\n files.add_argument('--data-dir', type=str, default=DATA_DIR,\n help='Directory of training/validation data')\n files.add_argument('--train-file', type=str,\n default='train_processed.jsonl',\n help='Preprocessed train file')\n files.add_argument('--dev-file', type=str,\n default='dev_processed.jsonl',\n help='Preprocessed dev file')\n files.add_argument('--embed-dir', type=str, default=EMBED_DIR,\n help='Directory of pre-trained embedding files')\n files.add_argument('--embedding-file', type=str,\n default='glove.840B.300d.txt',\n help='Space-separated pretrained embeddings file')\n\n # Saving + loading\n save_load = parser.add_argument_group('Saving/Loading')\n save_load.add_argument('--checkpoint', type='bool', default=False,\n help='Save model + optimizer state after each epoch')\n save_load.add_argument('--pretrained', type=str, default='',\n help='Path to a pretrained model to warm-start with')\n\n # General\n general = parser.add_argument_group('General')\n general.add_argument('--display-iter', type=int, default=25,\n help='Log state after every <display_iter> epochs')\n general.add_argument('--display-samples', type='bool', default=True,\n help='Display top 5 samples in validation process.')\n general.add_argument('--sort-by-len', type='bool', default=True,\n help='Sort batches by length for speed')\n \n # Model architecture\n model = parser.add_argument_group('Model Architecture')\n model.add_argument('--decoder-type', type=str, default='copy',\n help='Decoder architecture type')\n model.add_argument('--vocab-limit', type=int, default=-1,\n help='Limit for vocab creation')\n model.add_argument('--use-extended-vocab', type='bool', default=True,\n help='Use extended vocab for copying')\n model.add_argument('--embedding-dim', type=int, default=300,\n help='Embedding size if embedding_file is not given')\n model.add_argument('--hidden-size', type=int, default=128,\n help='Hidden size of RNN units')\n model.add_argument('--rnn-type', type=str, default='lstm',\n help='RNN type: LSTM, GRU, or RNN')\n\n # Optimization details\n optim = parser.add_argument_group('Optimization')\n optim.add_argument('--optimizer', type=str, default='adam',\n help='Optimizer: sgd or adam')\n optim.add_argument('--learning-rate', type=float, default=0.1,\n help='Learning rate')\n optim.add_argument('--weight-decay', type=float, default=0,\n help='Weight decay factor')\n optim.add_argument('--momentum', type=float, default=0,\n help='Momentum factor')\n optim.add_argument('--fix-embeddings', type='bool', default=True,\n help='Keep word embeddings fixed (use pretrained)')\n optim.add_argument('--rnn-padding', type='bool', default=False,\n help='Explicitly account for padding in RNN encoding')\n optim.add_argument('--max-length', type=int, default=30,\n help='The max span allowed during decoding')","def handle_arguments():\n # process the command options\n parser = argparse.ArgumentParser()\n parser.add_argument('images', type=str, help='provide path in style: '\n r'\"kaggle\\input\\bengaliai-cv19\\images.npy\"')\n parser.add_argument('labels', type=str, help='provide path in style: '\n r'\"kaggle\\input\\bengaliai-cv19\\labels.csv\"')\n parser.add_argument('-t', '--test_ratio', type=float, default=0.2,\n help='proportion of data for testing, default: 0.2')\n parser.add_argument('-s', '--seed', type=int, default=None, help='seed '\n 'used for consistent data splitting, default: None')\n parser.add_argument('-a', '--data_augmentation', action='store_true',\n help='switch to augment the images')\n drop_info_fns = ['cutout', 'gridmask', 'None'] # info dropping algorithms\n parser.add_argument('-d', '--drop_info_fn', type=str, choices=drop_info_fns,\n default=None, help='whether cutout, GridMask, or no '\n 'information dropping algorithm is used, default: None')\n parser.add_argument('-c', '--class_balancing', action='store_true',\n help='switch to perform class balancing')\n parser.add_argument('-b', '--batch_size', type=int, default=32,\n help='batch size of DataLoader objects, default: 32')\n parser.add_argument('-l', '--label_smoothing', action='store_true',\n help='switch to use soft targets in loss computation')\n parser.add_argument('-e', '--epochs', type=int, default=50, help='number '\n 'of iterations over training data, default: 50')\n parser.add_argument('-m', '--model', type=str, default='model.pt',\n help='path to save trained model, default: \"model.pt\"')\n\n # parse and print arguments\n args = parser.parse_args()\n for arg in vars(args):\n print(f'{arg.upper()}: {getattr(args, arg)}')\n\n return args","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Train a model for image classification (Keras)\",\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n parser.add_argument(\n \"--rec-train\",\n type=str,\n default=\"../imgclsmob_data/imagenet_rec/train.rec\",\n help=\"the training data\")\n parser.add_argument(\n \"--rec-train-idx\",\n type=str,\n default=\"../imgclsmob_data/imagenet_rec/train.idx\",\n help='the index of training data')\n parser.add_argument(\n \"--rec-val\",\n type=str,\n default=\"../imgclsmob_data/imagenet_rec/val.rec\",\n help=\"the validation data\")\n parser.add_argument(\n \"--rec-val-idx\",\n type=str,\n default=\"../imgclsmob_data/imagenet_rec/val.idx\",\n help=\"the index of validation data\")\n\n parser.add_argument(\n \"--model\",\n type=str,\n required=True,\n help=\"type of model to use. see model_provider for options\")\n parser.add_argument(\n \"--use-pretrained\",\n action=\"store_true\",\n help=\"enable using pretrained model from github repo\")\n parser.add_argument(\n \"--dtype\",\n type=str,\n default=\"float32\",\n help=\"data type for training\")\n parser.add_argument(\n \"--resume\",\n type=str,\n default=\"\",\n help=\"resume from previously saved parameters if not None\")\n parser.add_argument(\n \"--resume-state\",\n type=str,\n default=\"\",\n help=\"resume from previously saved optimizer state if not None\")\n\n parser.add_argument(\n \"--input-size\",\n type=int,\n default=224,\n help=\"size of the input for model\")\n parser.add_argument(\n \"--resize-inv-factor\",\n type=float,\n default=0.875,\n help=\"inverted ratio for input image crop\")\n\n parser.add_argument(\n \"--num-gpus\",\n type=int,\n default=0,\n help=\"number of gpus to use\")\n parser.add_argument(\n \"-j\",\n \"--num-data-workers\",\n dest=\"num_workers\",\n default=4,\n type=int,\n help=\"number of preprocessing workers\")\n\n parser.add_argument(\n \"--batch-size\",\n type=int,\n default=512,\n help=\"training batch size per device (CPU/GPU)\")\n parser.add_argument(\n \"--num-epochs\",\n type=int,\n default=120,\n help=\"number of training epochs\")\n parser.add_argument(\n \"--start-epoch\",\n type=int,\n default=1,\n help=\"starting epoch for resuming, default is 1 for new training\")\n parser.add_argument(\n \"--attempt\",\n type=int,\n default=1,\n help=\"current number of training\")\n\n parser.add_argument(\n \"--optimizer-name\",\n type=str,\n default=\"nag\",\n help=\"optimizer name\")\n parser.add_argument(\n \"--lr\",\n type=float,\n default=0.1,\n help=\"learning rate\")\n parser.add_argument(\n \"--momentum\",\n type=float,\n default=0.9,\n help=\"momentum value for optimizer\")\n parser.add_argument(\n \"--wd\",\n type=float,\n default=0.0001,\n help=\"weight decay rate\")\n\n parser.add_argument(\n \"--log-interval\",\n type=int,\n default=50,\n help=\"number of batches to wait before logging\")\n parser.add_argument(\n \"--save-interval\",\n type=int,\n default=4,\n help=\"saving parameters epoch interval, best model will always be saved\")\n parser.add_argument(\n \"--save-dir\",\n type=str,\n default=\"\",\n help=\"directory of saved models and log-files\")\n parser.add_argument(\n \"--logging-file-name\",\n type=str,\n default=\"train.log\",\n help=\"filename of training log\")\n\n parser.add_argument(\n \"--seed\",\n type=int,\n default=-1,\n help=\"Random seed to be fixed\")\n parser.add_argument(\n \"--log-packages\",\n type=str,\n default=\"keras\",\n help=\"list of python packages for logging\")\n parser.add_argument(\n \"--log-pip-packages\",\n type=str,\n default=\"keras, keras-mxnet, keras-applications, keras-preprocessing\",\n help=\"list of pip packages for logging\")\n args = parser.parse_args()\n return args","def main(args):\n\n # Labels to be used in the experiment.\n task_ids = {Labels.hotness.value: LossTypes.mse,\n Labels.tempo.value: LossTypes.mse,\n Labels.loudness.value: LossTypes.mse}\n\n # Get the training, validation and testing set data and ground-truths\n x_train, x_validate, x_test, y_train, y_validate, y_test = fetch_data(task_ids)\n\n exp = Experiment(expt_name=args.experiment_name, task_ids=task_ids, x_train=x_train, x_validate=x_validate,\n x_test=x_test, y_train=y_train, y_validate=y_validate, y_test=y_test,\n model_class=LowLevelSharingModel, learning_rate=args.learning_rate,\n batch_size=args.batch_size, num_epochs=args.num_epochs)\n exp.initialize_network()\n exp.train()\n sys.stderr.write(\"------\\n\")\n sys.stderr.write(\"Training complete. Logs, outputs, and model saved in \" + os.getcwd() + \"\\n\")","def setup(args):\n cfg = get_cfg()\n\n cfg.merge_from_file(model_zoo.get_config_file(args.model_zoo))\n cfg.DATASETS.TRAIN = (args.train_dataset, )\n cfg.DATASETS.TEST = (args.test_dataset, )\n cfg.DATALOADER.NUM_WORKERS = args.num_workers\n cfg.OUTPUT_DIR = args.output_dir\n os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)\n\n cfg.image_w = args.size[0]\n cfg.image_h = args.size[1]\n\n cfg.MODEL.WEIGHTS = args.model_zoo_weights\n cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = args.roi_thresh # set a custom testing threshold\n\n default_setup(cfg, args)\n return cfg","def predict_args():\n parser = argparse.ArgumentParser()\n\n parser.add_argument('image_path',\n help=\"Path to the image file\")\n\n parser.add_argument('checkpoint',\n default='checkpoint.pth',\n help=\"Path to the model checkpoint\")\n\n parser.add_argument('--top_k',\n dest='top_k',\n default=5,\n help=\"Return top K most likely classes\",\n type=int)\n\n parser.add_argument('--category_names',\n dest='category_names',\n default='cat_to_name.json',\n help='Use a mapping of categories to real names: '\n )\n\n parser.add_argument('--gpu', action='store_true',\n dest='gpu',\n help='Activate GPU')\n\n result = parser.parse_args()\n\n return result","def parse_args():\n hpo_warning = 'Flag overwrites config value if set, used for HPO and PBT runs primarily'\n parser = argparse.ArgumentParser('train.py')\n add_arg = parser.add_argument\n add_arg('config', nargs='?', default='configs/hello.yaml')\n add_arg('-d', '--distributed', choices=['ddp-file', 'ddp-mpi', 'cray'])\n add_arg('-v', '--verbose', action='store_true')\n add_arg('--ranks-per-node', default=8)\n add_arg('--gpu', type=int)\n add_arg('--rank-gpu', action='store_true')\n add_arg('--resume', action='store_true', help='Resume from last checkpoint')\n add_arg('--show-config', action='store_true')\n add_arg('--interactive', action='store_true')\n add_arg('--output-dir', help='override output_dir setting')\n add_arg('--seed', type=int, default=0, help='random seed')\n add_arg('--fom', default=None, choices=['last', 'best'],\n help='Print figure of merit for HPO/PBT')\n add_arg('--n-train', type=int, help='Override number of training samples')\n add_arg('--n-valid', type=int, help='Override number of validation samples')\n add_arg('--batch-size', type=int, help='Override batch size. %s' % hpo_warning)\n add_arg('--n-epochs', type=int, help='Specify subset of total epochs to run')\n add_arg('--real-weight', type=float, default=None,\n help='class weight of real to fake edges for the loss. %s' % hpo_warning)\n add_arg('--lr', type=float, default=None,\n help='Learning rate. %s' % hpo_warning)\n add_arg('--hidden-dim', type=int, default=None,\n help='Hidden layer dimension size. %s' % hpo_warning)\n add_arg('--n-graph-iters', type=int, default=None,\n help='Number of graph iterations. %s' % hpo_warning)\n add_arg('--weight-decay', type=float)\n return parser.parse_args()","def main(opts):\n\n # Create a dataloader for the training images\n train_dataloader, _ = get_emoji_loader(opts.emoji, opts)\n\n # Create checkpoint and sample directories\n utils.create_dir(opts.checkpoint_dir)\n utils.create_dir(opts.sample_dir)\n\n train(train_dataloader, opts)","def MachineClassifier(options, args):\n\n # Check for setup file in array args:\n if (len(args) >= 1) or (options.configfile):\n if args: config = args[0]\n elif options.configfile: config = options.configfile\n print swap.doubledashedline\n print swap.ML_hello\n print swap.doubledashedline\n print \"ML: taking instructions from\",config\n else:\n print MachineClassifier.__doc__\n return\n\n tonights = swap.Configuration(config)\n \n # Read the pickled random state file\n random_file = open(tonights.parameters['random_file'],\"r\");\n random_state = cPickle.load(random_file);\n random_file.close();\n np.random.set_state(random_state);\n\n\n time = tonights.parameters['start']\n print time\n\n # Get the machine threshold (make retirement decisions)\n threshold = tonights.parameters['machine_threshold']\n prior = tonights.parameters['prior']\n\n # Get list of evaluation metrics and criteria \n eval_metrics = tonights.parameters['evaluation_metrics']\n \n # How much cross-validation should we do? \n cv = tonights.parameters['cross_validation']\n\n survey = tonights.parameters['survey']\n\n #----------------------------------------------------------------------\n # read in the metadata for all subjects (Test or Training sample?)\n storage = swap.read_pickle(tonights.parameters['metadatafile'], 'metadata')\n subjects = storage.subjects\n\n #----------------------------------------------------------------------\n # read in the SWAP collection\n sample = swap.read_pickle(tonights.parameters['samplefile'],'collection')\n\n #----------------------------------------------------------------------\n # read in or create the ML collection\n MLsample = swap.read_pickle(tonights.parameters['MLsamplefile'],\n 'MLcollection')\n\n # read in or create the ML bureau for machine agents (history)\n MLbureau = swap.read_pickle(tonights.parameters['MLbureaufile'],'bureau')\n #if not tonights.parameters['MLbureaufile']:\n # MLbureaufile = swap.get_new_filename(tonights.parameters,'bureau','ML')\n # tonights.parameters['MLbureaufile'] = MLbureaufile\n\n #MLbureau = swap.read_pickle(tonights.parameters['MLbureaufile'],'bureau')\n\n\n #----------------------------------------------------------------------- \n # SELECT TRAINING & VALIDATION SAMPLES \n #-----------------------------------------------------------------------\n # TO DO: training sample should only select those which are NOT part of \n # validation sample (Nair catalog objects) 2/22/16\n\n train_sample = storage.fetch_subsample(sample_type='train',\n class_label='GZ2_label')\n \"\"\" Notes about the training sample:\n # this will select only those which have my morphology measured for them\n # AND which have a true \"answer\" according to GZ2\n # Eventually we could open this up to include the ~10k that aren't in the \n # GZ Main Sample but I think, for now, we should reduce ourselves to this\n # stricter sample so that we always have back-up \"truth\" for each galaxy.\n \"\"\"\n\n try:\n train_meta, train_features = ml.extract_features(train_sample)\n original_length = len(train_meta)\n\n except TypeError:\n print \"ML: can't extract features from subsample.\"\n print \"ML: Exiting MachineClassifier.py\"\n sys.exit()\n\n else:\n # TODO: consider making this part of SWAP's duties? \n # 5/18/16: Only use those subjects which are no longer on the prior\n off_the_fence = np.where(train_meta['SWAP_prob']!=prior)\n train_meta = train_meta[off_the_fence]\n train_features = train_features[off_the_fence]\n train_labels = np.array([1 if p > prior else 0 for p in \n train_meta['SWAP_prob']])\n\n #train_labels = train_meta['Nair_label'].filled()\n\n shortened_length = len(train_meta)\n print \"ML: found a training sample of %i subjects\"%shortened_length\n removed = original_length - shortened_length\n print \"ML: %i subjects had prior probability and were removed\"%removed\n \n\n valid_sample = storage.fetch_subsample(sample_type='valid',\n class_label='Expert_label')\n try:\n valid_meta, valid_features = ml.extract_features(valid_sample)\n except:\n print \"ML: there are no subjects with the label 'valid'!\"\n else:\n valid_labels = valid_meta['Expert_label'].filled()\n print \"ML: found a validation sample of %i subjects\"%len(valid_meta)\n\n # ---------------------------------------------------------------------\n # Require a minimum size training sample [Be reasonable, my good man!]\n # ---------------------------------------------------------------------\n if len(train_sample) < 10000: \n print \"ML: training sample is too small to be worth anything.\"\n print \"ML: Exiting MachineClassifier.py\"\n sys.exit()\n \n else:\n print \"ML: training sample is large enough to give it a shot.\"\n\n # TODO: LOOP THROUGH DIFFERENT MACHINES? \n # 5/12/16 -- no... need to make THIS a class and create multiple \n # instances? Each one can be passed an instance of a machine?\n\n # Machine can be trained to maximize/minimize different metrics\n # (ACC, completeness, purity, etc. Have a list of acceptable ones.)\n # Minimize a Loss function (KNC doesn't have a loss fcn). \n for metric in eval_metrics:\n \n # REGISTER Machine Classifier\n # Construct machine name --> Machine+Metric? For now: KNC\n machine = 'KNC'\n machine = 'RF'\n Name = machine+'_'+metric\n \n # register an Agent for this Machine\n # This \"Agent\" doesn't behave like a SW agent... at least not yet\n\n try: \n test = MLbureau.member[Name]\n except: \n MLbureau.member[Name] = swap.Agent_ML(Name, metric)\n \n MLagent = MLbureau.member[Name]\n\n #--------------------------------------------------------------- \n # TRAIN THE MACHINE; EVALUATE ON VALIDATION SAMPLE\n #---------------------------------------------------------------\n\n # Now we run the machine -- need cross validation on whatever size \n # training sample we have .. \n \n # Fixed until we build in other machine options\n # Need to dynamically determine appropriate parameters...\n\n #max_neighbors = get_max_neighbors(train_features, cv)\n #n_neighbors = np.arange(1, (cv-1)*max_neighbors/cv, 5, dtype=int)\n #params = {'n_neighbors':n_neighbors, \n # 'weights':('uniform','distance')}\n\n num_features = train_features.shape[1]\n \n min_features = int(round(np.sqrt(num_features)))\n params = {'max_features':np.arange(min_features, num_features+1),\n 'max_depth':np.arange(2,16)}\n\n # Create the model \n # for \"estimator=XXX\" all you need is an instance of a machine -- \n # any scikit-learn machine will do. However, non-sklearn machines..\n # That will be a bit trickier! (i.e. Phil's conv-nets)\n general_model = GridSearchCV(estimator=RF(n_estimators=30), \n param_grid=params, n_jobs=-1,\n error_score=0, scoring=metric, cv=cv) \n \n # Train the model -- k-fold cross validation is embedded\n print \"ML: Searching the hyperparameter space for values that \"\\\n \"optimize the %s.\"%metric\n trained_model = general_model.fit(train_features, train_labels)\n\n MLagent.model = trained_model\n\n # Test \"accuracy\" (metric of choice) on validation sample\n score = trained_model.score(valid_features, valid_labels)\n\n ratio = np.sum(train_labels==1) / len(train_labels)\n\n MLagent.record_training(model_described_by=\n trained_model.best_estimator_, \n with_params=trained_model.best_params_, \n trained_on=len(train_features), \n with_ratio=ratio,\n at_time=time, \n with_train_score=trained_model.best_score_,\n and_valid_score=trained_model.score(\n valid_features, valid_labels))\n\n fps, tps, thresh = mtrx.roc_curve(valid_labels, \n trained_model.predict_proba(valid_features)[:,1])\n\n metric_list = compute_binary_metrics(fps, tps)\n ACC, TPR, FPR, FNR, TNR, PPV, FDR, FOR, NPV = metric_list\n \n MLagent.record_validation(accuracy=ACC, recall=TPR, precision=PPV,\n false_pos=FPR, completeness_f=TNR,\n contamination_f=NPV)\n \n #MLagent.plot_ROC()\n\n # ---------------------------------------------------------------\n # IF TRAINED MACHINE PREDICTS WELL ON VALIDATION ....\n # ---------------------------------------------------------------\n if MLagent.is_trained(metric):\n print \"ML: %s has successfully trained and will be applied \"\\\n \"to the test sample.\"\n\n # Retrieve the test sample \n test_sample = storage.fetch_subsample(sample_type='test',\n class_label='GZ2_label')\n \"\"\" Notes on test sample:\n The test sample will, in real life, be those subjects for which\n we don't have an answer a priori. However, for now, this sample\n is how we will judge, in part, the performance of the overall\n method. As such, we only include those subjects which have \n GZ2 labels in the Main Sample.\n \"\"\"\n\n try:\n test_meta, test_features = ml.extract_features(test_sample)\n except:\n print \"ML: there are no subjects with the label 'test'!\"\n print \"ML: which means there's nothing more to do!\"\n else:\n print \"ML: found test sample of %i subjects\"%len(test_meta)\n\n #----------------------------------------------------------- \n # APPLY MACHINE TO TEST SAMPLE\n #----------------------------------------------------------- \n predictions = MLagent.model.predict(test_features)\n probabilities = MLagent.model.predict_proba(test_features)\n\n print \"ML: %s has finished predicting labels for the test \"\\\n \"sample.\"%Name\n print \"ML: Generating performance report on the test sample:\"\n\n test_labels = test_meta['GZ2_label'].filled()\n print mtrx.classification_report(test_labels, predictions)\n\n test_accuracy=mtrx.accuracy_score(test_labels,predictions)\n test_precision=mtrx.precision_score(test_labels,predictions)\n test_recall=mtrx.recall_score(test_labels,predictions)\n\n MLagent.record_evaluation(accuracy_score=test_accuracy,\n precision_score=test_precision,\n recall_score=test_recall,\n at_time=time)\n #pdb.set_trace()\n \n # ----------------------------------------------------------\n # Save the predictions and probabilities to a new pickle\n\n test_meta['predictions'] = predictions\n test_meta['probability_of_smooth'] = probabilities[:,1]\n \n filename=tonights.parameters['trunk']+'_'+Name+'.pickle'\n swap.write_pickle(test_meta, filename)\n\n\n\n \"\"\"\n for thing, pred, p in zip(test_meta, predictions,\n probabitilies):\n \n # IF MACHINE P >= THRESHOLD, INSERT INTO SWAP COLLECTION\n # --------------------------------------------------------\n if (p >= threshold) or (1-p >= threshold):\n print \"BOOM! WE'VE GOT A MACHINE-CLASSIFIED SUBJECT:\"\n print \"Probability:\", p\n # Initialize the subject in SWAP Collection\n ID = thing['asset_id']\n sample.member[ID] = swap.Subject(ID, str(s['SDSS_id']), \n location=s['external_ref']) \n sample.member[ID].retiredby = 'machine'\n \n # Flag subject as 'INACTIVE' / 'DETECTED' / 'REJECTED'\n # ----------------------------------------------------------\n if p >= threshold:\n sample.member[str(s['id'])].state = 'inactive'\n elif 1-p >= threshold:\n sample.member[str(s['id'])].status = 'rejected' \n\n #\"\"\"\n \n \n # If is hasn't been done already, save the current directory\n # ---------------------------------------------------------------------\n tonights.parameters['dir'] = os.getcwd()+'/'+tonights.parameters['trunk']\n \n if not os.path.exists(tonights.parameters['dir']):\n os.makedirs(tonights.parameters['dir'])\n\n\n # Repickle all the shits\n # -----------------------------------------------------------------------\n if tonights.parameters['repickle']:\n\n new_samplefile = swap.get_new_filename(tonights.parameters,'collection')\n print \"ML: saving SWAP subjects to \"+new_samplefile\n swap.write_pickle(sample, new_samplefile)\n tonights.parameters['samplefile'] = new_samplefile\n \n new_samplefile=swap.get_new_filename(tonights.parameters,'MLcollection')\n print \"ML: saving test sample subjects to \"+new_samplefile\n swap.write_pickle(MLsample,new_samplefile)\n tonights.parameters['MLsamplefile'] = new_samplefile\n\n new_bureaufile=swap.get_new_filename(tonights.parameters,'bureau','ML')\n print \"ML: saving MLbureau to \"+new_bureaufile\n swap.write_pickle(MLbureau, new_bureaufile)\n tonights.parameters['MLbureaufile'] = new_bureaufile\n\n metadatafile = swap.get_new_filename(tonights.parameters,'metadata')\n print \"ML: saving metadata to \"+metadatafile\n swap.write_pickle(storage, metadatafile)\n tonights.parameters['metadatafile'] = metadatafile\n\n\n # UPDATE CONFIG FILE with pickle filenames, dir/trunk, and (maybe) new day\n # ----------------------------------------------------------------------\n configfile = config.replace('startup','update')\n\n # Random_file needs updating, else we always start from the same random\n # state when update.config is reread!\n random_file = open(tonights.parameters['random_file'],\"w\");\n random_state = np.random.get_state();\n cPickle.dump(random_state,random_file);\n random_file.close();\n swap.write_config(configfile, tonights.parameters)\n\n return","def get_args(args):\n argparser = argparse.ArgumentParser()\n\n argparser.add_argument('--config',\n required=True,\n help='config file with hyper parameters - in yaml format')\n\n def_log = None\n argparser.add_argument('--log',\n default=def_log,\n help=f'log to this file (default {def_log}: log to screen)')\n\n def_checkpointfrq = 'epoch'\n argparser.add_argument('--ckptfreq',\n default=def_checkpointfrq,\n help=f'how many examples passed in training before saving (default is once per epoch)')\n\n def_checkpointpath = 'saved_model/cp-{epoch:04d}.ckpt'\n argparser.add_argument('--ckptpath',\n type=str,\n default=def_checkpointpath,\n help=f'checkpoint path (default {def_checkpointpath})')\n\n def_impath = '../../rainforest/fixed-train-jpg/'\n argparser.add_argument('--imagepath',\n default=def_impath,\n help=f'path to image directory (default {def_impath})')\n\n def_labelpath = '../../rainforest/train_v3.csv'\n argparser.add_argument('--labelpath',\n default=def_labelpath,\n help=f'path to csv file for labels (defautlt {def_labelpath})')\n\n def_seed = 0\n argparser.add_argument('-s',\n '--seed',\n default=def_seed,\n type=int,\n help=f'Set random seed to this number (default {def_seed})')\n\n def_dataseed = 0\n argparser.add_argument('-ds',\n '--dataseed',\n default=def_dataseed,\n type=int,\n help=f'Set random seed for data split into train / valid / test sets')\n\n def_kernels = 4\n argparser.add_argument('-k',\n '--kernels',\n default=def_kernels,\n type=int,\n help=f'Number of kernels in the CNN (default {def_kernels})')\n def_ksize = 2\n argparser.add_argument('-ks',\n '--ksize',\n default=def_ksize,\n type=int,\n help=f'Size of kernels in CNN (default {def_ksize})')\n\n def_f1 = 64\n argparser.add_argument('-f1',\n '--filter1',\n default=def_f1,\n type=int,\n help=f'Number of kernels in the first VGG block (default {def_f1})')\n\n def_k1 = 3\n argparser.add_argument('-ks1',\n '--ksize1',\n default=def_k1,\n type=int,\n help=f'Size of kernels in the first VGG block (default {def_k1})')\n\n def_s1 = 1\n argparser.add_argument('-s1',\n '--stride1',\n default=def_s1,\n type=int,\n help=f'Stride in the first VGG block (default {def_s1})')\n\n def_p1 = 2\n argparser.add_argument('-p1',\n '--pool1',\n default=def_p1,\n type=int,\n help=f'Max pooling size in the first VGG block (default {def_p1})')\n\n def_sp1 = 2\n argparser.add_argument('-sp1',\n '--stridepool1',\n default=def_sp1,\n type=int,\n help=f'Pool stride in the first VGG block (default {def_sp1})')\n\n def_f2 = 128\n argparser.add_argument('-f2',\n '--filter2',\n default=def_f2,\n type=int,\n help=f'Number of kernels in the second VGG block (default {def_f2})')\n\n def_k2 = 3\n argparser.add_argument('-ks2',\n '--ksize2',\n default=def_k2,\n type=int,\n help=f'Size of kernels in the second VGG block (default {def_k2})')\n\n def_s2 = 1\n argparser.add_argument('-s2',\n '--stride2',\n default=def_s2,\n type=int,\n help=f'Stride in the second VGG block (default {def_s2})')\n\n def_p2 = 2\n argparser.add_argument('-p2',\n '--pool2',\n default=def_p2,\n type=int,\n help=f'Max pooling size in the second VGG block (default {def_p2})')\n\n def_sp2 = 2\n argparser.add_argument('-sp2',\n '--stridepool2',\n default=def_sp2,\n type=int,\n help=f'Pool stride in the second VGG block (default {def_sp2})')\n\n def_f3 = 256\n argparser.add_argument('-f3',\n '--filter3',\n default=def_f3,\n type=int,\n help=f'Number of kernels in the 3rd VGG block (default {def_f3})')\n\n def_k3 = 3\n argparser.add_argument('-ks3',\n '--ksize3',\n default=def_k3,\n type=int,\n help=f'Size of kernels in the 3rd VGG block (default {def_k3})')\n\n def_s3 = 1\n argparser.add_argument('-s3',\n '--stride3',\n default=def_s3,\n type=int,\n help=f'Stride in the 3rd VGG block (default {def_s3})')\n\n def_p3 = 2\n argparser.add_argument('-p3',\n '--pool3',\n default=def_p3,\n type=int,\n help=f'Max pooling size in the 3rd VGG block (default {def_p3})')\n\n def_sp3 = 2\n argparser.add_argument('-sp3',\n '--stridepool3',\n default=def_sp3,\n type=int,\n help=f'Pool stride in the 3rd VGG block (default {def_sp3})')\n\n def_f4 = 512\n argparser.add_argument('-f4',\n '--filter4',\n default=def_f4,\n type=int,\n help=f'Number of kernels in the 4th VGG block (default {def_f4})')\n\n def_k4 = 3\n argparser.add_argument('-ks4',\n '--ksize4',\n default=def_k4,\n type=int,\n help=f'Size of kernels in the 4th VGG block (default {def_k4})')\n\n def_s4 = 1\n argparser.add_argument('-s4',\n '--stride4',\n default=def_s4,\n type=int,\n help=f'Stride in the 4th VGG block (default {def_s4})')\n\n def_p4 = 2\n argparser.add_argument('-p4',\n '--pool4',\n default=def_p4,\n type=int,\n help=f'Max pooling size in the 4th VGG block (default {def_p4})')\n\n def_sp4 = 2\n argparser.add_argument('-sp4',\n '--stridepool4',\n default=def_sp4,\n type=int,\n help=f'Pool stride in the 4th VGG block (default {def_sp4})')\n\n def_f5 = 512\n argparser.add_argument('-f5',\n '--filter5',\n default=def_f5,\n type=int,\n help=f'Number of kernels in the 5th VGG block (default {def_f5})')\n\n def_k5 = 3\n argparser.add_argument('-ks5',\n '--ksize5',\n default=def_k5,\n type=int,\n help=f'Size of kernels in the 5th VGG block (default {def_k5})')\n\n def_s5 = 1\n argparser.add_argument('-s5',\n '--stride5',\n default=def_s5,\n type=int,\n help=f'Stride in the 5th VGG block (default {def_s5})')\n\n def_p5 = 2\n argparser.add_argument('-p5',\n '--pool5',\n default=def_p5,\n type=int,\n help=f'Max pooling size in the 5th VGG block (default {def_p5})')\n\n def_sp5 = 2\n argparser.add_argument('-sp5',\n '--stridepool5',\n default=def_sp5,\n type=int,\n help=f'Pool stride in the 5th VGG block (default {def_sp5})')\n\n def_dense1 = 4096\n argparser.add_argument('-d1',\n '--dense1',\n default=def_dense1,\n type=int,\n help=f'Size of 1st dense layer in the VGG network (default {def_dense1})')\n\n def_dense2 = 4096\n argparser.add_argument('-d2',\n '--dense2',\n default=def_dense2,\n type=int,\n help=f'Size of 2nd dense layer in the VGG network (default {def_dense2})')\n\n def_augmentpolicy = None\n argparser.add_argument('-da',\n '--dataaugment',\n default=def_augmentpolicy,\n type=str,\n help=f'Data augmentation scheme based on AutoAugment Implemented options are \\n cifar10\\n imagenet \\n svhn \\n(default {def_augmentpolicy})')\n\n def_lr = 0.1\n argparser.add_argument('-l',\n '--lr',\n default=def_lr,\n type=float,\n help=f'Learning rate (default {def_lr})')\n\n def_nepoch = 1\n argparser.add_argument('-n',\n '--nepoch',\n default=def_nepoch,\n type=int,\n help=f'Number of epoch for training (default {def_nepoch})')\n\n def_patience = 10\n argparser.add_argument('-p',\n '--patience',\n default=def_patience,\n type=int,\n help=f'Number of epoch without improvements before stopping training (default {def_patience})')\n\n def_batch = 4\n argparser.add_argument('-b',\n '--batchsize',\n default=def_batch,\n type=int,\n help=f'batch size (default {def_batch})')\n\n args = argparser.parse_args(args)\n return args","def parse_args():\n\n parser = argparse.ArgumentParser()\n\n ##################################################################\n # Required parameters:\n # ---------------------------------------------------------------\n # - input/output dirs\n # - model config (BertConfig / CharacterBertConfig)\n # - a flag for pre-training CharacterBERT instead of BERT\n ##################################################################\n\n parser.add_argument(\n \"--hdf5_directory\",\n type=str, required=True,\n help=\\\n \"Path to a directory contraining hdf5 files: training.*.hdf5, \"\n \"validation.*.hdf5 and test.*.hdf5 files.\"\n )\n parser.add_argument(\n \"--output_directory\",\n type=str, required=True,\n help=\\\n \"Path to a directory where model checkpoints and metrics \"\n \"will be saved.\"\n )\n parser.add_argument(\n '--is_character_bert',\n action='store_true',\n help=\"Pre-train CharacterBERT instead of BERT.\"\n )\n\n ##################################################################\n # Other parameters\n ##################################################################\n # Parameters related to checkpoint handling\n\n parser.add_argument(\n '--random_seed',\n required=False, type=int, default=42,\n help=\\\n \"An intial seed for controlling some of the randomness.\"\n )\n parser.add_argument(\n \"--local_rank\",\n type=int, default=-1,\n help=\\\n \"Identifier of the current process within the distributed process \"\n \"group. This is always `-1` when distributed training is deactivated.\"\n )\n parser.add_argument(\n '--phase1_end_step',\n type=int, default=7038,\n help=\\\n \"Number of training steps (backprops) in pre-training phase n°1: \"\n \"`max_input_length=128`and `max_masked_tokens_per_input=20`.\"\n )\n parser.add_argument(\n '--phase2',\n action='store_true',\n help=\\\n \"Whether it is pre-training phase n°2: \"\n \"`max_input_length=512`and `max_masked_tokens_per_input=80`.\"\n )\n parser.add_argument(\n \"--init_checkpoint\",\n type=str, default=None,\n help=\"An initial checkpoint to start pre-training from.\"\n )\n parser.add_argument(\n \"--resume_pretraining\",\n action='store_true',\n help=\"Whether to resume pre-training from a checkpoint.\"\n )\n parser.add_argument(\n '--resume_step',\n type=int, default=-1,\n help=\\\n \"Step to resume pre-training from. By default, this is `-1` \"\n \"which results in resuming from the latest checkpoint available.\"\n )\n\n ##################################################################\n # Training hyperparameters\n\n parser.add_argument(\n '--max_input_length',\n required=False, type=int, default=128,\n help=\\\n \"Maximum sequence length for the model input. \"\n \"Set this according to the input .hdf5 files contents.\"\n )\n parser.add_argument(\n \"--max_masked_tokens_per_input\",\n type=int, default=20,\n help=\\\n \"Hard limit on the number of tokens that can be masked. \"\n \"Set this according to the input .hdf5 files contents.\"\n )\n parser.add_argument(\n '--num_accumulation_steps',\n type=int, default=512,\n help=\\\n \"Number of steps (forward passes) during which gradients are \"\n \"accumulated before running a single model parameters update.\"\n )\n parser.add_argument(\n \"--target_batch_size\",\n type=int, default=8192,\n help=\\\n \"Target batch size post-accumulation (actual batch size is \"\n \"derived from the number of accumulation steps). For example, if \"\n \"`target_batch_size=32` and `num_accumulation_steps=4` then the \"\n \"actual batch size will be `32/4 = 8`. This is useful for \"\n \"achieving larger batch sizes while keeping an actual batch size \"\n \"that is small enough to fit in memory.\"\n )\n parser.add_argument(\n \"--learning_rate\",\n type=float, default=6e-3,\n help=\"The initial learning rate for the FusedLAMB optimizer.\"\n )\n parser.add_argument(\n \"--warmup_proportion\",\n type=float, default=0.2843,\n help=\\\n \"A value of X means that learning rate will increase during \"\n \"(100*X)%% of pre-training steps before reaching the desired value \"\n \"then decrease to 0 during the rest of pre-training steps.\"\n )\n parser.add_argument(\n \"--total_steps\",\n type=float, default=7038,\n help=\"Total number of pre-training steps to perform.\"\n )\n\n ##################################################################\n # fp16 related parameters\n\n parser.add_argument(\n '--fp16',\n action='store_true',\n help=\"Whether to use 16-bit float precision instead of 32-bit\"\n )\n parser.add_argument(\n '--loss_scale',\n type=float, default=0.0,\n help='Loss scaling, positive power of 2 values can improve fp16 convergence.'\n )\n parser.add_argument(\n '--allreduce_post_accumulation',\n action='store_true',\n help=\"Whether to do allreduces during gradient accumulation steps.\"\n )\n parser.add_argument(\n '--allreduce_post_accumulation_fp16',\n action='store_true',\n help=\"Whether to do fp16 allreduce post accumulation.\")\n\n ##################################################################\n # Logging and checkpointing\n\n parser.add_argument(\n '--do_validation',\n action='store_true',\n help=\"Whether to run a validation step before checkpointing.\"\n )\n\n parser.add_argument(\n '--checkpoint_interval',\n type=int, default=200,\n help=\\\n \"Number of model updates before a model checkpoint is saved.\"\n )\n parser.add_argument(\n '--num_checkpoints_to_keep',\n type=int, default=3,\n help=\\\n \"Maximum number of checkpoints to keep.\"\n )\n parser.add_argument(\n '--log_freq',\n type=float, default=1.0,\n help='Frequency of logging loss.'\n )\n parser.add_argument(\n '--tensorboard_id',\n type=str, default='default',\n help=\"Name of the directory where Tensorboard logs will be saved.\"\n )\n\n args = parser.parse_args()\n return args","def initialize():\n\n parser = build_arg_parser()\n par = parser.parse_known_args()[0]\n\n # Main arguments.\n set('run_mode', par.run_mode)\n set('input_files', par.image)\n\n # Sub-parser specific arguments.\n if par.run_mode == 'train':\n\n set('batch_size', par.batch_size)\n set('drop', par.drop)\n set('epochs', par.epochs)\n set('model', par.model)\n set('level', par.level)\n set('vfrac', par.vfrac)\n set('data_augm', par.data_augm)\n set('summary', par.summary)\n set('outdir', par.outdir)\n # Parameters associated with super-resolution. \n set('super_resolution', par.super_resolution)\n set('generator', par.generator)\n set('discriminator', par.discriminator)\n\n elif par.run_mode == 'predict':\n\n set('tile_edge', par.edge)\n set('model', par.model)\n set('save_conv2d_kernels', par.save_conv2d_kernels) \n set('save_conv2d_outputs', par.save_conv2d_outputs) \n set('colormap', par.colormap)\n # Parameters associated with super-resolution. \n set('super_resolution', par.super_resolution)\n set('generator', par.generator)\n\n elif par.run_mode == 'diagnose': \n \n set('model', par.model) \n \n else:\n \n pass","def process_args_and_run(args, test_suite_iter: int = None):\n # load global arguments\n if args.save is not None and args.load is not None:\n print(\"Can't load and save a model at the same time...\"\n \"please choose just one of the two options\")\n sys.exit(1)\n\n if test_suite_iter is None:\n load_report_directory(args)\n\n #check if no parameters are given\n if all([argument not in args for argument in ['depth',\n 'impurity_method',\n 'trees',\n 'alpha',\n 'hidden_layers',\n 'max_iter',\n 'verbose']]):\n print(\"Please select at least one algorithm or test-suite to run this program\")\n sys.exit()\n\n # Load dataset\n train_data, train_labels = dataset.load_train_data()\n test_data, test_labels = dataset.load_test_data()\n # Random Forest\n if all([param in args for param in ['depth', 'impurity_method', 'trees']]):\n rf_classifier = RandomForest(n_estimators=args.trees, max_depth=args.depth, criterion=args.impurity_method,\n report_directory=args.report_directory, test_suite_iter=test_suite_iter)\n rf_classifier.run_classification(train_data, train_labels, test_data, test_labels,\n args.save, args.load)\n if all([param in args for param in ['alpha', 'hidden_layers', 'max_iter', 'verbose']]):\n hidden_layers = []\n # case when reading from a test suite where args.hidden_layers is just ['x y z'] and not ['x', 'y', 'z']\n if len(args.hidden_layers) == 1:\n args.hidden_layers = args.hidden_layers[0].split(\" \")\n for layer in args.hidden_layers:\n try:\n hidden_layers.append(int(layer))\n except ValueError:\n print(f\"Can't set a hidden layer value of {layer}. Please enter an integer value\")\n sys.exit(1)\n args.hidden_layers = tuple(hidden_layers)\n\n mlp_classifier = MLP(hidden_layer_sizes=args.hidden_layers,\n alpha=args.alpha,\n max_iter=args.max_iter,\n batch_size=args.batch_size,\n verbose=args.verbose,\n random_seed=args.random_seed,\n report_directory=args.report_directory,\n test_suite_iter=test_suite_iter)\n\n mlp_classifier.run_classification(train_data, train_labels, test_data, test_labels,\n args.save, args.load)","def training_config_parser():\n parser = argparse.ArgumentParser()\n\n # xml_annotation_path, csv_annotation_path, oxford_annotations_path, oxford_images_path\n # Dataset info\n parser.add_argument(\n \"--xml_annotation_path\", type=str, required=True\n )\n parser.add_argument(\n \"--csv_annotation_path\", type=str, required=True\n )\n parser.add_argument(\n \"--oxford_annotations_path\", type=str, required=True\n )\n parser.add_argument(\n \"--oxford_images_path\", type=str, required=True\n )\n \n parser.add_argument(\n \"--background_class\",\n type=int,\n required=False,\n default=0,\n help=\"Default background class\",\n )\n\n # What to train\n parser.add_argument(\n \"--train_backbone\",\n action=\"store_true\",\n required=False,\n default=False,\n help=\"Train backbone\",\n )\n parser.add_argument(\n \"--train_transformers\",\n action=\"store_true\",\n required=False,\n default=False,\n help=\"Train transformers\",\n )\n parser.add_argument(\n \"--train_nlayers\",\n action=\"store_true\",\n required=False,\n default=False,\n help=\"Train new layers\",\n )\n\n # How to train\n parser.add_argument(\n \"--finetuning\",\n default=False,\n required=False,\n action=\"store_true\",\n help=\"Load the model weight before to train\",\n )\n parser.add_argument(\n \"--batch_size\",\n type=int,\n required=False,\n default=1,\n help=\"Batch size to use to train the model\",\n )\n parser.add_argument(\n \"--gradient_norm_clipping\",\n type=float,\n required=False,\n default=0.1,\n help=\"Gradient norm clipping\",\n )\n parser.add_argument(\n \"--target_batch\",\n type=int,\n required=False,\n default=None,\n help=\"When running on a single GPU, aggretate the gradient before to apply.\",\n )\n\n # Learning rate\n parser.add_argument(\n \"--backbone_lr\", type=bool, required=False, default=1e-5, help=\"Train backbone\"\n )\n parser.add_argument(\n \"--transformers_lr\",\n type=bool,\n required=False,\n default=1e-4,\n help=\"Train transformers\",\n )\n parser.add_argument(\n \"--nlayers_lr\", type=bool, required=False, default=1e-4, help=\"Train new layers\"\n )\n\n return parser","def config_and_train(self, sys_args):\n \n self.run_config_function(sys_args)\n self.set_model_name('vgg_16')\n self.set_trainable_and_exclude_scopes(constants.checkpoint_exclude_scopes,\n constants.trainable_scopes)\n self.set_optimizer('sgd')\n self.set_max_number_of_steps(6000)\n self.train_or_eval_net(sys_args)","def main(args):\n # read data from disk\n X_train, X_val, X_test, Y_train, Y_val, Y_test = util_fruit.get_fruit_data()\n\n # build model\n model = get_model(model_name=\"fruit_classifier\")\n model.compile(\n loss='categorical_crossentropy',\n optimizer='adam',\n metrics=['accuracy']\n )\n # augment training and testing data\n datagen, X_train, X_val = augment_data(X_train, X_val)\n\n # save model and training history\n model_folder_path = util_fruit.make_model_folder(model_name=MODEL_NAME)\n\n # Callbacks\n callbacks=[]\n cp_callback = ModelCheckpoint(\"{}/{}_callback.hdf5\".format(model_folder_path, MODEL_NAME),\n monitor='val_loss',\n verbose=0,\n save_best_only=True,\n save_weights_only=False,\n period=10)\n callbacks.append(cp_callback)\n\n # train model and save train history \n batch_size = args.batch_size\n epochs = args.epochs\n history = train(model, X_train, X_val, Y_train, Y_val, callbacks, datagen, batch_size=batch_size, epochs=epochs)\n\n # winsound.Beep(5000, 10) # play sound after training completes\n \n \n save_model(model=model, save_folder_path=model_folder_path, model_name=MODEL_NAME, model_ext=MODEL_EXT)\n save_history(history=history, save_folder_path=model_folder_path)\n\n # evaluate model and save results-\n evaluate(model=model, datagen=datagen, X_test=X_test, Y_test=Y_test, batch_size=batch_size, save_folder_path=model_folder_path)","def parse_args():\n parser = argparse.ArgumentParser('train.py')\n add_arg = parser.add_argument\n add_arg('config', nargs='?', default='configs/hello.yaml')\n add_arg('-d', '--distributed', choices=['ddp-file', 'ddp-mpi', 'cray'])\n add_arg('-v', '--verbose', action='store_true')\n add_arg('--ranks-per-node', default=8)\n add_arg('--gpu', type=int)\n add_arg('--rank-gpu', action='store_true')\n add_arg('--resume', action='store_true', help='Resume from last checkpoint')\n add_arg('--show-config', action='store_true')\n add_arg('--interactive', action='store_true')\n add_arg('--output-dir', help='override output_dir setting')\n add_arg('--seed', type=int, default=0, help='random seed')\n return parser.parse_args()","def set_defaults(args):\n # Check critical files exist\n args.train_file = os.path.join(args.data_dir, args.train_file)\n if not os.path.isfile(args.train_file):\n raise IOError('No such file: %s' % args.train_file)\n args.dev_file = os.path.join(args.data_dir, args.dev_file)\n if not os.path.isfile(args.dev_file):\n raise IOError('No such file: %s' % args.dev_file)\n if args.embedding_file:\n args.embedding_file = os.path.join(args.embed_dir, args.embedding_file)\n if not os.path.isfile(args.embedding_file):\n raise IOError('No such file: %s' % args.embedding_file)\n\n # Set model directory\n subprocess.call(['mkdir', '-p', args.model_dir])\n\n # Set model name\n if not args.model_name:\n import uuid\n import time\n args.model_name = time.strftime(\"%Y%m%d-\") + str(uuid.uuid4())[:8]\n\n # Set log + model file names\n args.log_file = os.path.join(args.model_dir, args.model_name + '.txt')\n args.model_file = os.path.join(args.model_dir, args.model_name + '.pt')\n\n # Embeddings options\n if args.embedding_file:\n with open(args.embedding_file) as f:\n dim = len(f.readline().strip().split(' ')) - 1\n args.embedding_dim = dim\n elif not args.embedding_dim:\n raise RuntimeError('Either embedding_file or embedding_dim '\n 'needs to be specified.')\n\n # Make sure fix_embeddings and embedding_file are consistent\n if args.fix_embeddings:\n if not (args.embedding_file or args.pretrained):\n logger.warning('WARN: fix_embeddings set to False '\n 'as embeddings are random.')\n args.fix_embeddings = False\n return args","def __init__(self, **kwargs):\n\n # Identify the mode to start the model in\n if \"x\" in kwargs and \"y\" in kwargs:\n x = kwargs.get(\"x\")\n y = kwargs.get(\"y\")\n if \"model_name\" not in kwargs:\n self.__mode = \"train\"\n else:\n self.__mode = \"retrain\"\n elif \"model_name\" in kwargs:\n self.__mode = \"test\"\n else:\n raise NameError(\"Cannot infer mode from arguments.\")\n\n print(\"Initializing model in %s mode.\" % self.__mode)\n\n if self.mode == \"train\":\n # Infer input type from type(x)\n if type(x[0]) == np.bytes_:\n print(\"Input type is 'binary mols'.\")\n self.__input_type = \"mols\" # binary RDKit mols\n else:\n print(\"Input type is 'molecular descriptors'.\")\n self.__input_type = \"descriptors\" # other molecular descriptors\n\n # If scaling is required\n if kwargs.get(\"scaling\", False) is True:\n # Normalize the input\n print(\"Applying scaling on input.\")\n self.__scaler = StandardScaler()\n x = self.__scaler.fit_transform(x)\n else:\n self.__scaler = None\n\n # If PCA is required\n if kwargs.get(\"pca\", False) is True:\n print(\"Applying PCA on input.\")\n self.__pca = PCA(\n n_components=x.shape[1]\n ) # n_components=n_features for now\n x = self.__pca.fit_transform(x)\n else:\n self.__pca = None\n\n self.__maxlen = (\n kwargs.get(\"dataset_info\")[\"maxlen\"] + 10\n ) # Extend maxlen to avoid breaks in training\n self.__charset = kwargs.get(\"dataset_info\")[\"charset\"]\n self.__dataset_name = kwargs.get(\"dataset_info\")[\"name\"]\n self.__lstm_dim = kwargs.get(\"lstm_dim\", 256)\n self.__h_activation = kwargs.get(\"h_activation\", \"relu\")\n self.__bn = kwargs.get(\"bn\", True)\n self.__bn_momentum = kwargs.get(\"bn_momentum\", 0.9)\n self.__noise_std = kwargs.get(\"noise_std\", 0.01)\n self.__td_dense_dim = kwargs.get(\n \"td_dense_dim\", 0\n ) # >0 squeezes RNN connections with Dense sandwiches\n self.__batch_size = kwargs.get(\"batch_size\", 256)\n self.__dec_layers = kwargs.get(\"dec_layers\", 2)\n\n if self.input_type == \"descriptors\":\n self.__codelayer_dim = x.shape[1] # features\n if \"codelayer_dim\" in kwargs:\n print(\n \"Ignoring requested codelayer_dim because it is inferred from the cardinality of the descriptors.\"\n )\n else:\n self.__codelayer_dim = kwargs.get(\"codelayer_dim\", 128)\n \n # Create the left/right-padding vectorizers\n self.__smilesvec1 = SmilesVectorizer(\n canonical=False,\n augment=True,\n maxlength=self.maxlen,\n charset=self.charset,\n binary=True,\n )\n\n self.__smilesvec2 = SmilesVectorizer(\n canonical=False,\n augment=True,\n maxlength=self.maxlen,\n charset=self.charset,\n binary=True,\n leftpad=False,\n )\n\n # self.train_gen.next() #This line is needed to set train_gen.dims (to be fixed in HetSmilesGenerator)\n self.__input_shape = self.smilesvec1.dims\n self.__dec_dims = list(self.smilesvec1.dims)\n self.__dec_dims[0] = self.dec_dims[0] - 1\n self.__dec_input_shape = self.dec_dims\n self.__output_len = self.smilesvec1.dims[0] - 1\n self.__output_dims = self.smilesvec1.dims[-1]\n\n # Build all sub-models as untrained models\n if self.input_type == \"mols\":\n self.__build_mol_to_latent_model()\n else:\n self.__mol_to_latent_model = None\n\n self.__build_latent_to_states_model()\n self.__build_batch_model()\n\n # Build data generators\n self.__build_generators(x, y)\n\n # Retrain or Test mode\n else:\n self.__model_name = kwargs.get(\"model_name\")\n\n # Load the model\n self.__load(self.model_name)\n \n if self.mode == \"retrain\":\n # If scaling is required\n if self.scaler is not None:\n print(\"Applying scaling on input.\")\n x = self.scaler.transform(x)\n\n # If PCA is required\n if self.pca is not None:\n print(\"Applying PCA on input.\")\n x = self.pca.transform(x)\n \n # Build data generators\n self.__build_generators(x, y)\n\n # Build full model out of the sub-models\n self.__build_model()\n\n # Show the resulting full model\n print(self.model.summary())","def main():\n if sys.argv[1] == 'train':\n build_training_data()\n main_trainer()\n\n if sys.argv[1] == 'predict' and len(sys.argv) > 2:\n from predict import classification\n from AdaboostPredict import decision_stumps\n input_file = open(sys.argv[2])\n data = input_file.readlines()\n print(\"Decision Tree prediction\")\n for i in data:\n print(classification(i, i.strip().split()))\n\n print(\"\\nAdaboost prediction\")\n\n for i in data:\n print(decision_stumps(i, i.strip().split()))\n\n elif sys.argv[1] == 'predict':\n print('Wrong usage for prediction. Please supply a file after predict')","def main(parameters_file, no_parameters_file, initialise, iterations, scenario, data_dir, output, output_every_iteration,\n debug, repetitions, lockdown_file, use_cache, opencl, opencl_gui, opencl_gpu):\n\n # If we are running with opencl_gui then set opencl to True, so you only need to pass one flag\n if opencl_gui:\n opencl = True\n\n # First see if we're reading a parameters file or using command-line arguments.\n if no_parameters_file:\n print(\"Not reading a parameters file\")\n else:\n print(f\"Reading parameters file: {parameters_file}. \"\n f\"Any other model-related command-line arguments are being ignored\")\n with open(parameters_file, 'r') as f:\n parameters = load(f, Loader=SafeLoader)\n sim_params = parameters[\"microsim\"] # Parameters for the dynamic microsim (python)\n calibration_params = parameters[\"microsim_calibration\"]\n disease_params = parameters[\"disease\"] # Parameters for the disease model (r)\n # TODO Implement a more elegant way to set the parameters and pass them to the model. E.g.:\n # self.params, self.params_changed = Model._init_kwargs(params, kwargs)\n # [setattr(self, key, value) for key, value in self.params.items()]\n # Utility parameters\n scenario = sim_params[\"scenario\"]\n iterations = sim_params[\"iterations\"]\n data_dir = sim_params[\"data-dir\"]\n output = sim_params[\"output\"]\n output_every_iteration = sim_params[\"output-every-iteration\"]\n debug = sim_params[\"debug\"]\n repetitions = sim_params[\"repetitions\"]\n lockdown_file = sim_params[\"lockdown-file\"]\n\n # Check the parameters are sensible\n if iterations < 1:\n raise ValueError(\"Iterations must be > 1. If you want to just initialise the model and then exit, use\"\n \"the --initialise flag\")\n if repetitions < 1:\n raise ValueError(\"Repetitions must be greater than 0\")\n if (not output) and output_every_iteration:\n raise ValueError(\"Can't choose to not output any data (output=False) but also write the data at every \"\n \"iteration (output_every_iteration=True)\")\n\n print(f\"Running model with the following parameters:\\n\"\n f\"\\tParameters file: {parameters_file}\\n\"\n f\"\\tScenario directory: {scenario}\\n\"\n f\"\\tInitialise (and then exit?): {initialise}\\n\"\n f\"\\tNumber of iterations: {iterations}\\n\"\n f\"\\tData dir: {data_dir}\\n\"\n f\"\\tOutputting results?: {output}\\n\"\n f\"\\tOutputting results at every iteration?: {output_every_iteration}\\n\"\n f\"\\tDebug mode?: {debug}\\n\"\n f\"\\tNumber of repetitions: {repetitions}\\n\"\n f\"\\tLockdown file: {lockdown_file}\\n\",\n f\"\\tUse cache?: {use_cache}\\n\",\n f\"\\tUse OpenCL version?: {opencl}\\n\",\n f\"\\tUse OpenCL GUI?: {opencl_gui}\\n\",\n f\"\\tUse OpenCL GPU for processing?: {opencl_gpu}\\n\",\n f\"\\tCalibration parameters: {'N/A (not reading parameters file)' if no_parameters_file else str(calibration_params)}\\n\",\n f\"\\tDisease parameters: {'N/A (not reading parameters file)' if no_parameters_file else str(disease_params)}\\n\")\n\n # To fix file path issues, use absolute/full path at all times\n # Pick either: get working directory (if user starts this script in place, or set working directory\n # Option A: copy current working directory:\n base_dir = os.getcwd() # get current directory\n data_dir = os.path.join(base_dir, data_dir)\n r_script_dir = os.path.join(base_dir, \"R\", \"py_int\")\n\n ### section for fetching data\n if not os.path.isdir(data_dir):\n\n print(f\"No data directory detected.\")\n\n if os.path.isfile(data_dir + \".tar.gz\"):\n print(f\"An archive file matching the name of the data directory has been detected!\")\n print(f\"Unpacking this archive file now.\")\n unpack_data(data_dir + \".tar.gz\")\n \n else:\n print(f\"{data_dir} does not exist. Downloading devon_data.\")\n data_setup()\n\n # Temporarily only want to use Devon MSOAs\n # devon_msoas = pd.read_csv(os.path.join(data_dir, \"devon_msoas.csv\"), header=None,\n # names=[\"x\", \"y\", \"Num\", \"Code\", \"Desc\"])\n\n # Prepare the QUANT api (for estimating school and retail destinations)\n # we only need 1 QuantRampAPI object even if we do multiple iterations\n # the quant_object object will be called by each microsim object\n quant_path = os.path.join(data_dir, \"QUANT_RAMP\")\n if not os.path.isdir(quant_path):\n raise Exception(\"QUANT directory does not exist, please check input\")\n quant_object = QuantRampAPI(quant_path)\n\n # args for population initialisation\n population_args = {\"data_dir\": data_dir, \"debug\": debug,\n \"quant_object\": quant_object}\n\n # args for Python/R Microsim. Use same arguments whether running 1 repetition or many\n msim_args = {\"data_dir\": data_dir, \"r_script_dir\": r_script_dir, \"scen_dir\": scenario, \"output\": output,\n \"output_every_iteration\": output_every_iteration}\n\n if not no_parameters_file: # When using a parameters file, include the calibration parameters\n msim_args.update(**calibration_params) # python calibration parameters are unpacked now\n # Also read the R calibration parameters (this is a separate section in the .yml file)\n if disease_params is not None:\n # (If the 'disease_params' section is included but has no calibration variables then we want to ignore it -\n # it will be turned into an empty dictionary by the Microsim constructor)\n msim_args[\"disease_params\"] = disease_params # R parameters kept as a dictionary and unpacked later\n\n # Temporarily use dummy data for testing\n # data_dir = os.path.join(base_dir, \"dummy_data\")\n # m = Microsim(data_dir=data_dir, testing=True, output=output)\n\n # cache to hold previously calculate population data\n cache = InitialisationCache(cache_dir=os.path.join(data_dir, \"caches\"))\n\n # generate new population dataframes if we aren't using the cache, or if the cache is empty\n if not use_cache or cache.is_empty():\n print(f'Reading population data because {\"caching is disabled\" if not use_cache else \"the cache is empty\"}')\n population = PopulationInitialisation(**population_args)\n individuals = population.individuals\n activity_locations = population.activity_locations\n\n # store in cache so we can load later\n cache.store_in_cache(individuals, activity_locations)\n else: # load from cache\n print(\"Loading data from previous cache\")\n individuals, activity_locations = cache.read_from_cache()\n\n # Calculate the time-activity multiplier (this is for implementing lockdown)\n time_activity_multiplier = None\n if lockdown_file != \"\":\n print(f\"Implementing a lockdown with time activities from {lockdown_file}\")\n time_activity_multiplier: pd.DataFrame = \\\n PopulationInitialisation.read_time_activity_multiplier(os.path.join(data_dir, lockdown_file))\n\n # Select which model implementation to run\n if opencl:\n run_opencl_model(individuals, activity_locations, time_activity_multiplier, iterations, data_dir, base_dir,\n opencl_gui, opencl_gpu, use_cache, initialise, calibration_params, disease_params)\n else:\n # If -init flag set the don't run the model. Note for the opencl model this check needs to happen\n # after the snapshots have been created in run_opencl_model\n if initialise:\n print(\"Have finished initialising model. -init flag is set so not running it. Exitting\")\n return\n run_python_model(individuals, activity_locations, time_activity_multiplier, msim_args, iterations,\n repetitions, parameters_file)","def setup_args():\n parser = ParlaiParser()\n parser.add_argument(\n '-n',\n '--num-episodes',\n default=-1,\n type=int,\n help='Total number of episodes to convert, -1 to convert all examples',\n )\n parser.add_argument(\n '-of',\n '--outfile',\n default=None,\n type=str,\n help='Output file where to save, by default will be created in /tmp',\n )\n parser.add_argument(\n '-s1id', '--speaker-0-id', type=str, help='Speaker id of agent who speaks first'\n )\n parser.add_argument(\n '-s1id',\n '--speaker-1-id',\n type=str,\n help='Speaker id of agent who speaks second',\n )\n parser.add_argument(\n '--prepended-context',\n type='bool',\n default=False,\n help='specify if the context is prepended to the first act',\n )\n parser.add_argument('-ltim', '--log-every-n-secs', type=float, default=10)\n parser.set_defaults(datatype='train:ordered')\n\n return parser","def add_train_args(parser):\n\n # Runtime environment\n runtime = parser.add_argument_group('Environment')\n runtime.add_argument('--dataset', type=str, default=\"searchqa\",\n help='Dataset: searchqa, quasart or unftriviaqa')\n runtime.add_argument('--base_dir', type=str, default=\".\",\n help='base_dir of the pre-processing')","def main():\n\n downloadData()\n\n parser = argparse.ArgumentParser(description=\"Train model or test model (default)\")\n parser.add_argument(\"--train-model\", action=\"store_true\", default=False)\n parser.add_argument(\"--num-channels\", type=int, help=\"Number of channels in lowest dimension\", default=8)\n\n arg_parser = parser.parse_args()\n\n if arg_parser.train_model:\n encoder, generator = train(channels=arg_parser.num_channels)\n torch.save(encoder.state_dict(), f\"../models/encoder_{arg_parser.num_channels}.model\")\n torch.save(generator.state_dict(), f\"../models/generator_{arg_parser.num_channels}.model\")\n else:\n validate_models(VALIDATE_CHANNELS)","def train(args):\n print(args)\n\n # Run a training job\n configs = LuxMatchConfigs_Default\n\n # Create a default opponent agent\n opponent = Agent()\n\n # Create a RL agent in training mode\n player = AgentPolicy(mode=\"train\")\n\n # Train the model\n num_cpu = 1\n if num_cpu == 1:\n env = LuxEnvironment(configs=configs,\n learning_agent=player,\n opponent_agent=opponent)\n else:\n env = SubprocVecEnv([make_env(LuxEnvironment(configs=configs,\n learning_agent=AgentPolicy(mode=\"train\"),\n opponent_agent=opponent), i) for i in range(num_cpu)])\n run_id = args.id\n print(\"Run id %s\" % run_id)\n\n if args.path:\n # by default previous model params are used (lr, batch size, gamma...)\n model = PPO.load(args.path)\n model.set_env(env=env)\n\n # Update the learning rate\n model.lr_schedule = get_schedule_fn(args.learning_rate)\n\n # TODO: Update other training parameters\n else:\n model = PPO(\"MlpPolicy\",\n env,\n verbose=1,\n tensorboard_log=\"./lux_tensorboard/\",\n learning_rate=args.learning_rate,\n gamma=args.gamma,\n gae_lambda=args.gae_lambda,\n batch_size=args.batch_size,\n n_steps=args.n_steps\n )\n\n print(\"Training model...\")\n # Save a checkpoint every 1M steps\n checkpoint_callback = CheckpointCallback(save_freq=1000000,\n save_path='./models/',\n name_prefix=f'rl_model_{run_id}')\n model.learn(total_timesteps=args.step_count,\n callback=checkpoint_callback) # 20M steps\n if not os.path.exists(f'models/rl_model_{run_id}_{args.step_count}_steps.zip'):\n model.save(path=f'models/rl_model_{run_id}_{args.step_count}_steps.zip')\n print(\"Done training model.\")\n\n # Inference the model\n print(\"Inference model policy with rendering...\")\n saves = glob.glob(f'models/rl_model_{run_id}_*_steps.zip')\n latest_save = sorted(saves, key=lambda x: int(x.split('_')[-2]), reverse=True)[0]\n model.load(path=latest_save)\n obs = env.reset()\n for i in range(600):\n action_code, _states = model.predict(obs, deterministic=True)\n obs, rewards, done, info = env.step(action_code)\n if i % 5 == 0:\n print(\"Turn %i\" % i)\n env.render()\n\n if done:\n print(\"Episode done, resetting.\")\n obs = env.reset()\n print(\"Done\")\n\n '''\n # Learn with self-play against the learned model as an opponent now\n print(\"Training model with self-play against last version of model...\")\n player = AgentPolicy(mode=\"train\")\n opponent = AgentPolicy(mode=\"inference\", model=model)\n env = LuxEnvironment(configs, player, opponent)\n model = PPO(\"MlpPolicy\",\n env,\n verbose=1,\n tensorboard_log=\"./lux_tensorboard/\",\n learning_rate = 0.0003,\n gamma=0.999,\n gae_lambda = 0.95\n )\n\n model.learn(total_timesteps=2000)\n env.close()\n print(\"Done\")\n '''","def main(args):\r\n # Parse inputs\r\n parser = _argparse()\r\n argp = parser.parse_args(args[1:])\r\n # Read training data\r\n sparse_training = sp.sparse.load_npz( argp.training_data )\r\n training_data = np.array( sparse_training.todense() )\r\n training_labels = np.array(pd.read_csv(argp.training_labels,index_col = 0 ))\r\n\r\n # Train classifier \r\n classifier = train_classifier.train_LR( training_data, training_labels, num_genes = argp.num_genes, pct_var = argp.pca_variance/100, save_results = False )\r\n\r\n training_predictions, training_probabilities = predict_cell_types( training_data, classifier )\r\n confusion_mat = pd.DataFrame(confusion_matrix( training_labels, training_predictions ),\r\n index = np.unique(training_labels), columns = np.unique(training_labels)).to_csv(\r\n \"results/classification/confusion_matrix.csv\")\r\n # Make predictions for all cells\r\n sparse_scRNA_expression = sp.sparse.load_npz( argp.test_data )\r\n scRNA_expression = np.array( sparse_scRNA_expression.todense() )\r\n predicted_cell_types, prediction_probabilities = predict_cell_types( scRNA_expression, classifier ) \r\n \r\n sequencing_metrics = pd.read_csv(\"data/combined/processed_metrics.csv\",index_col = 0)\r\n # Save outputs\r\n pd.DataFrame(prediction_probabilities, \r\n index = sequencing_metrics.index.values,\r\n columns = np.unique(predicted_cell_types) ).to_csv(\"results/classification/prediction_probabilities.csv\")\r\n pd.DataFrame(predicted_cell_types, \r\n index = sequencing_metrics.index.values,\r\n columns = [\"predicted_cell_type\"] ).to_csv(\"results/classification/predicted_cell_types.csv\")","def main(_config, _run):\n sacred.commands.print_config(_run)\n dump_config_and_makefile()\n prepare_and_train()","def initialize_model_from_cfg(args, gpu_id=0):\n model = model_builder.Generalized_RCNN()\n model.eval()\n\n if args.cuda:\n model.cuda()\n\n if args.load_ckpt:\n load_name = args.load_ckpt\n logger.info(\"loading checkpoint %s\", load_name)\n checkpoint = torch.load(load_name, map_location=lambda storage, loc: storage)\n net_utils.load_ckpt(model, checkpoint['model'])\n\n if args.load_detectron:\n logger.info(\"loading detectron weights %s\", args.load_detectron)\n load_caffe2_detectron_weights(model, args.load_detectron)\n\n model = mynn.DataParallel(model, cpu_keywords=['im_info', 'roidb'], minibatch=True)\n\n return model","def __init__(self, args):\n self.train_img_file = os.path.join(args.data_dir, args.train_img_file)\n self.train_lbl_file = os.path.join(args.data_dir, args.train_lbl_file)\n self.test_img_file = os.path.join(args.data_dir, args.test_img_file)\n self.test_lbl_file = os.path.join(args.data_dir, args.test_lbl_file)\n self.batch_size = args.batch_size\n self.num_workers = args.data_workders\n self.shuffle = True\n self.dataset_name = args.dataset_name\n self.pin_memory = False #args.cuda\n\n # check dataset files exist\n files = [self.train_img_file, self.train_lbl_file,\n self.test_img_file, self.test_lbl_file]\n for file in files:\n if not os.path.isfile(file):\n msg = \"Data file not found. Please check the path \" +\\\n \"or download files using scripts/download_files.py \"\n raise IOError(msg)","def main():\n parser = argparse.ArgumentParser(description='Paperboy deep learning launcher')\n\n parser.add_argument('config', metavar='FILENAME', help='Configuration file for the run')\n parser.add_argument('command', metavar='COMMAND', help='A command to run')\n parser.add_argument('varargs', nargs='*', metavar='VARARGS', help='Extra options to the command')\n parser.add_argument('-r', '--run_number', type=int, default=0, help=\"A run number\")\n parser.add_argument('-d', '--device', default='cuda', help=\"A device to run the model on\")\n parser.add_argument('-s', '--seed', type=int, default=None, help=\"Random seed for the project\")\n parser.add_argument(\n '-p', '--param', type=str, metavar='NAME=VALUE', action='append', default=[],\n help=\"Configuration parameters\"\n )\n parser.add_argument(\n '--continue', action='store_true', default=False, help=\"Continue previously started learning process\"\n )\n parser.add_argument(\n '--profile', type=str, default=None, help=\"Profiler output\"\n )\n\n args = parser.parse_args()\n\n model_config = ModelConfig.from_file(\n args.config, args.run_number, continue_training=getattr(args, 'continue'), device=args.device, seed=args.seed,\n params={k: v for (k, v) in (Parser.parse_equality(eq) for eq in args.param)}\n )\n\n if model_config.project_dir not in sys.path:\n sys.path.append(model_config.project_dir)\n\n multiprocessing_setting = model_config.provide_with_default('multiprocessing', default=None)\n\n if multiprocessing_setting:\n # This needs to be called before any of PyTorch module is imported\n multiprocessing.set_start_method(multiprocessing_setting)\n\n # Set seed already in the launcher\n from vel.util.random import set_seed\n set_seed(model_config.seed)\n\n model_config.banner(args.command)\n\n if args.profile:\n print(\"[PROFILER] Running Vel in profiling mode, output filename={}\".format(args.profile))\n import cProfile\n import pstats\n profiler = cProfile.Profile()\n profiler.enable()\n model_config.run_command(args.command, args.varargs)\n profiler.disable()\n\n profiler.dump_stats(args.profile)\n profiler.print_stats(sort='tottime')\n\n print(\"======================================================================\")\n pstats.Stats(profiler).strip_dirs().sort_stats('tottime').print_stats(30)\n print(\"======================================================================\")\n pstats.Stats(profiler).strip_dirs().sort_stats('cumtime').print_stats(30)\n else:\n model_config.run_command(args.command, args.varargs)\n\n model_config.quit_banner()","def main(args):\n\n print(now(), \"test_model.py main() running.\")\n\n test_log = \"clean_test_log.txt\"\n to_log_file(args, args.output, test_log)\n\n # Set device\n device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n\n ####################################################\n # Dataset\n if args.dataset.lower() == \"cifar10\":\n transform_train = get_transform(args.normalize, args.train_augment)\n transform_test = get_transform(args.normalize, False)\n trainset = torchvision.datasets.CIFAR10(\n root=\"./data\", train=True, download=True, transform=transform_train\n )\n trainloader = torch.utils.data.DataLoader(trainset, batch_size=128)\n testset = torchvision.datasets.CIFAR10(\n root=\"./data\", train=False, download=True, transform=transform_test\n )\n testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False)\n elif args.dataset.lower() == \"cifar100\":\n transform_train = get_transform(args.normalize, args.train_augment)\n transform_test = get_transform(args.normalize, False)\n trainset = torchvision.datasets.CIFAR100(\n root=\"./data\", train=True, download=True, transform=transform_train\n )\n trainloader = torch.utils.data.DataLoader(trainset, batch_size=128)\n testset = torchvision.datasets.CIFAR100(\n root=\"./data\", train=False, download=True, transform=transform_test\n )\n testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False)\n\n elif args.dataset.lower() == \"tinyimagenet_first\":\n transform_train = get_transform(\n args.normalize, args.train_augment, dataset=args.dataset\n )\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\n trainset = TinyImageNet(\n TINYIMAGENET_ROOT,\n split=\"train\",\n transform=transform_train,\n classes=\"firsthalf\",\n )\n trainloader = torch.utils.data.DataLoader(\n trainset, batch_size=64, num_workers=1, shuffle=True\n )\n testset = TinyImageNet(\n TINYIMAGENET_ROOT,\n split=\"val\",\n transform=transform_test,\n classes=\"firsthalf\",\n )\n testloader = torch.utils.data.DataLoader(\n testset, batch_size=64, num_workers=1, shuffle=False\n )\n\n elif args.dataset.lower() == \"tinyimagenet_last\":\n transform_train = get_transform(\n args.normalize, args.train_augment, dataset=args.dataset\n )\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\n trainset = TinyImageNet(\n TINYIMAGENET_ROOT,\n split=\"train\",\n transform=transform_train,\n classes=\"lasthalf\",\n )\n trainloader = torch.utils.data.DataLoader(\n trainset, batch_size=64, num_workers=1, shuffle=True\n )\n testset = TinyImageNet(\n TINYIMAGENET_ROOT,\n split=\"val\",\n transform=transform_test,\n classes=\"lasthalf\",\n )\n testloader = torch.utils.data.DataLoader(\n testset, batch_size=64, num_workers=1, shuffle=False\n )\n\n elif args.dataset.lower() == \"tinyimagenet_all\":\n transform_train = get_transform(\n args.normalize, args.train_augment, dataset=args.dataset\n )\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\n trainset = TinyImageNet(\n TINYIMAGENET_ROOT,\n split=\"train\",\n transform=transform_train,\n classes=\"all\",\n )\n trainloader = torch.utils.data.DataLoader(\n trainset, batch_size=64, num_workers=1, shuffle=True\n )\n testset = TinyImageNet(\n TINYIMAGENET_ROOT,\n split=\"val\",\n transform=transform_test,\n classes=\"all\",\n )\n testloader = torch.utils.data.DataLoader(\n testset, batch_size=64, num_workers=1, shuffle=False\n )\n\n else:\n print(\"Dataset not yet implemented. Exiting from test_model.py.\")\n sys.exit()\n\n ####################################################\n\n ####################################################\n # Network and Optimizer\n net = get_model(args.model, args.dataset)\n\n # load model from path if a path is provided\n if args.model_path is not None:\n net = load_model_from_checkpoint(args.model, args.model_path, args.dataset)\n else:\n print(\"No model path provided, continuing test with untrained network.\")\n net = net.to(device)\n ####################################################\n\n ####################################################\n # Test Model\n training_acc = test(net, trainloader, device)\n natural_acc = test(net, testloader, device)\n print(now(), \" Training accuracy: \", training_acc)\n print(now(), \" Natural accuracy: \", natural_acc)\n stats = OrderedDict(\n [\n (\"model path\", args.model_path),\n (\"model\", args.model),\n (\"normalize\", args.normalize),\n (\"augment\", args.train_augment),\n (\"training_acc\", training_acc),\n (\"natural_acc\", natural_acc),\n ]\n )\n to_results_table(stats, args.output, \"clean_performance.csv\")\n ####################################################\n\n return","def main():\n parser = make_argument_parser()\n args = parser.parse_args()\n\n input_dirs = args.inputdirs\n tf = args.factor\n valid_chroms = args.validchroms\n valid_input_dirs = args.validinputdirs\n test_chroms = args.testchroms\n epochs = args.epochs\n patience = args.patience\n learningrate = args.learningrate\n seed = args.seed\n utils.set_seed(seed)\n dropout_rate = args.dropout\n L = args.seqlen\n w = args.motifwidth\n utils.L = L\n utils.w = w\n utils.w2 = w/2\n negatives = args.negatives\n assert negatives > 0\n meta = args.meta\n gencode = args.gencode\n motif = args.motif\n\n num_motifs = args.kernels\n num_recurrent = args.recurrent\n num_dense = args.dense\n \n features = ['bigwig'] \n\n if tf:\n print 'Single-task training:', tf\n singleTask = True\n if meta:\n print 'Including metadata features'\n features.append('meta')\n if gencode:\n print 'Including genome annotations'\n features.append('gencode')\n else:\n print 'Multi-task training'\n singleTask = False\n #Cannot use any metadata features\n assert not meta\n assert not gencode\n\n if args.outputdir is None:\n clobber = True\n output_dir = args.outputdirc\n else:\n clobber = False\n output_dir = args.outputdir\n\n try: # adapted from dreme.py by T. Bailey\n os.makedirs(output_dir)\n except OSError as exc:\n if exc.errno == errno.EEXIST:\n if not clobber:\n print >> sys.stderr, ('output directory (%s) already exists '\n 'but you specified not to clobber it') % output_dir\n sys.exit(1)\n else:\n print >> sys.stderr, ('output directory (%s) already exists '\n 'so it will be clobbered') % output_dir\n\n print 'Loading genome'\n genome = utils.load_genome()\n if valid_input_dirs:\n print 'You specified at least one validation input directory'\n assert singleTask # This option only works for single-task training\n print 'Loading ChIP labels'\n if singleTask:\n chip_bed_list, nonnegative_regions_bed_list = \\\n utils.load_chip_singleTask(input_dirs, tf)\n if valid_input_dirs:\n valid_chip_bed_list, valid_nonnegative_regions_bed_list = \\\n utils.load_chip_singleTask(valid_input_dirs, tf)\n num_tfs = 1\n else:\n assert len(input_dirs) == 1 # multi-task training only supports one cell line\n input_dir = input_dirs[0]\n tfs, positive_windows, y_positive, nonnegative_regions_bed = \\\n utils.load_chip_multiTask(input_dir)\n num_tfs = len(tfs)\n print 'Loading bigWig data'\n bigwig_names, bigwig_files_list = utils.load_bigwigs(input_dirs)\n num_bigwigs = len(bigwig_names)\n if valid_input_dirs:\n valid_bigwig_names, valid_bigwig_files_list = utils.load_bigwigs(valid_input_dirs)\n assert valid_bigwig_names == bigwig_names\n if not singleTask:\n bigwig_files = bigwig_files_list[0]\n if meta:\n print 'Loading metadata features'\n meta_names, meta_list = utils.load_meta(input_dirs)\n if valid_input_dirs:\n valid_meta_names, valid_meta_list = utils.load_load(valid_input_dirs)\n assert valid_meta_names == meta_names\n else:# meta option was not selected, pass empty metadata features to the functions\n meta_list = [[] for bigwig_files in bigwig_files_list]\n if valid_input_dirs:\n valid_meta_list = [[] for bigwig_files in valid_bigwig_files_list]\n \n print 'Making features'\n if singleTask:\n if not valid_input_dirs: #validation directories not used, must pass placeholder values\n valid_chip_bed_list = None\n valid_nonnegative_regions_bed_list = None\n valid_bigwig_files_list = None\n valid_meta_list = None \n datagen_train, datagen_valid = \\\n utils.make_features_singleTask(chip_bed_list,\n nonnegative_regions_bed_list, bigwig_files_list, bigwig_names,\n meta_list, gencode, genome, epochs, negatives, valid_chroms, test_chroms, \n valid_chip_bed_list, valid_nonnegative_regions_bed_list, \n valid_bigwig_files_list, valid_meta_list)\n else:\n datagen_train, datagen_valid = \\\n utils.make_features_multiTask(positive_windows, y_positive,\n nonnegative_regions_bed, bigwig_files, bigwig_names,\n genome, epochs, valid_chroms, test_chroms)\n print 'Building model'\n if num_recurrent == 0:\n print 'You specified 0 LSTM units. Omitting BLSTM layer'\n if num_recurrent < 0:\n print 'You specified less than 0 LSTM units. Replacing BLSTM layer with global max-pooling layer'\n if meta or gencode:\n num_meta = 0\n if meta:\n num_meta = len(meta_names)\n if gencode:\n num_meta += 6\n model = utils.make_meta_model(num_tfs, num_bigwigs, num_meta, num_motifs, num_recurrent, num_dense, dropout_rate)\n else:\n model = utils.make_model(num_tfs, num_bigwigs, num_motifs, num_recurrent, num_dense, dropout_rate)\n\n if motif:\n assert singleTask # This option only works with single-task training\n motifs_db = utils.load_motif_db('resources/HOCOMOCOv9.meme')\n if tf in motifs_db:\n print 'Injecting canonical motif'\n pwm = motifs_db[tf]\n pwm += 0.001\n pwm = pwm / pwm.sum(axis=1)[:, np.newaxis]\n pwm = np.log2(pwm/0.25)\n utils.inject_pwm(model, pwm)\n output_tf_file = open(output_dir + '/chip.txt', 'w')\n if singleTask:\n output_tf_file.write(\"%s\\n\" % tf)\n else:\n for tf in tfs:\n output_tf_file.write(\"%s\\n\" % tf)\n output_tf_file.close()\n output_feature_file = open(output_dir + '/feature.txt', 'w')\n for feature in features:\n output_feature_file.write(\"%s\\n\" % feature)\n output_feature_file.close()\n output_bw_file = open(output_dir + '/bigwig.txt', 'w')\n for bw in bigwig_names:\n output_bw_file.write(\"%s\\n\" % bw)\n output_bw_file.close()\n if meta:\n output_meta_file = open(output_dir + '/meta.txt', 'w')\n for meta_name in meta_names:\n output_meta_file.write(\"%s\\n\" % meta_name)\n output_meta_file.close()\n model_json = model.to_json()\n output_json_file = open(output_dir + '/model.json', 'w')\n output_json_file.write(model_json)\n output_json_file.close()\n train(datagen_train, datagen_valid, model, epochs, patience, learningrate, output_dir)","def add_args(parser):\n parser.add_argument(\"data\", metavar=\"FILE\", help=\"file prefix for data\")\n parser.add_argument(\n \"--num-classes0\",\n type=int,\n default=-1,\n help=\"number of classes0\",\n )\n parser.add_argument(\"--no-shuffle\", action=\"store_true\", default=False)","def add_args(parser):\n # fmt: off\n parser.add_argument('data', help='colon separated path to data directories list, \\\n will be iterated upon during epochs in round-robin manner')\n parser.add_argument('-s', '--source-lang', default=None, metavar='SRC',\n help='source language')\n parser.add_argument('-t', '--target-lang', default=None, metavar='TARGET',\n help='target language')\n parser.add_argument('--lazy-load', action='store_true',\n help='load the dataset lazily')\n parser.add_argument('--raw-text', action='store_true',\n help='load raw text dataset')\n parser.add_argument('--left-pad-source', default='True', type=str, metavar='BOOL',\n help='pad the source on the left')\n parser.add_argument('--left-pad-target', default='False', type=str, metavar='BOOL',\n help='pad the target on the left')\n parser.add_argument('--max-source-positions', default=1024, type=int, metavar='N',\n help='max number of tokens in the source sequence')\n parser.add_argument('--max-target-positions', default=1024, type=int, metavar='N',\n help='max number of tokens in the target sequence')\n parser.add_argument('--upsample-primary', default=1, type=int,\n help='amount to upsample primary dataset')\n # fmt: on\n parser.add_argument('--main-src-wordfreq', default=None, type=str,\n help='word frequency file of the main train source')\n parser.add_argument('--dialect-src-wordfreq', default=None, type=str,\n help='word frequency file of the dialect train source')\n parser.add_argument('--dialect-tau', default=1., type=float)\n parser.add_argument('--src-gradnorm-tau', default=1., type=float)\n parser.add_argument('--lm-path', default=None, type=str)\n parser.add_argument('--lm-dict-path', default=None, type=str)\n parser.add_argument('--lm-topk', default=0, type=int)\n parser.add_argument('--src-gradnorm-path', default=None, type=str)\n parser.add_argument('--src-gradnorm-nosoftmax', action='store_true')\n parser.add_argument('--exclude-self', action='store_true')","def load(self):\n self.classifier = joblib.load(\"data/models/repeatsfinder/repeatsfinder.joblib\")","def add_train_arguments(self):\n parser = self.parser\n parser.add_argument(\"source_dir\", help=\"Directory containing test source images.\")\n parser.add_argument(\"target_dir\", help=\"Directory containing test target images.\")\n parser.add_argument(\"--batch_size\", \"-bs\", default=1, type=int, help=\"Batch size.\")\n parser.add_argument(\"--cycle_loss_weight\", \"-clw\", default=0, type=int, help=\"Cycle loss weight.\")\n parser.add_argument(\n \"--discriminator_architecture\", \"-d\", default=\"basic\",\n help=\"architecture of the discriminator ('basic' | 'N_layers')\"\n )\n parser.add_argument(\n \"--discriminator_filters\", \"-df\", type=int, default=64,\n help=\"Number of filters in the last conv layer of the discriminator.\"\n )\n parser.add_argument(\n \"--n_frames_discriminator\", \"-dn\", type=int, default=0,\n help=\"Number of frames the sequence discriminators discriminate.\"\n )\n parser.add_argument(\n \"--discriminator_temporal_scales\", \"-dts\", type=int, default=1,\n help=\"Number of temporal scales in framerate sampling (= number of sequence discriminators).\"\n )\n parser.add_argument(\n \"--feature_matching_loss_weight\", \"-fmlw\", default=0, type=int, help=\"Loss weight of feature matching.\"\n )\n parser.add_argument(\n \"--flow_loss_weight\", \"-flw\", default=0, type=int, help=\"Loss weight of flow loss in vid2vid.\"\n )\n parser.add_argument(\n \"--gan_mode\", \"-gan\", default=\"lsgan\", help=\"type of the gan loss ('vanilla' | 'lsgan' | 'wgangp').\"\n )\n parser.add_argument(\n \"--init_epoch\", \"-ie\", default=0, type=int, help=\"If set, load models saved at a specific epoch.\"\n )\n parser.add_argument(\n \"--init_checkpoint_dir\", \"-i\",\n help=\"If set, initialize models from saved checkpoints in init_checkpoint_dir.\"\n )\n parser.add_argument(\n \"--log_every\", \"-le\", default=100, type=int, help=\"Log losses and images every log_every iterations.\"\n )\n parser.add_argument(\n \"--log_images_every\", \"-lie\", default=0, type=int,\n help=\"If specified, log images every log_images_every iterations, instead of every log_every iterations.\"\n )\n parser.add_argument(\"--load_height\", \"-lh\", type=int, default=0, help=\"image load height (before cropping).\")\n parser.add_argument(\"--l1_loss_weight\", \"-llw\", default=0, type=int, help=\"L1 loss weight.\")\n parser.add_argument(\"--learning_rate\", \"-lr\", default=0.0002, type=float, help=\"Learning rate.\")\n parser.add_argument(\"--load_width\", \"-lw\", type=int, default=0, help=\"Image load width (before cropping).\")\n parser.add_argument(\n \"--mask_loss_weight\", \"-mlw\", default=0, type=int, help=\"Loss weight of mask loss (weight loss) in vid2vid.\"\n )\n parser.add_argument(\"--num_epochs\", \"-ne\", default=10, type=int, help=\"Number of training epochs.\")\n parser.add_argument(\n \"--perceptual_loss_weight\", \"-plw\", default=0, type=int, help=\"Loss weight of perceptual (VGG19) loss.\"\n )\n parser.add_argument(\n \"--recycle_loss_weight\", \"-rclw\", default=0, type=int, help=\"Loss weight of recycle in RecycleGAN.\"\n )\n parser.add_argument(\n \"--recycle_predictor_architecture\", \"-rcp\", default=\"resnet_6blocks\",\n help=\"Architecture of RecycleGAN predictor. See generator_architecture for options.\"\n )\n parser.add_argument(\n \"--recycle_predictor_filters\", \"-rcpf\", type=int, default=64,\n help=\"Number of filters in the last conv layer of the RecycleGAN predictor.\"\n )\n parser.add_argument(\n \"--save_every\", \"-se\", default=1, type=int, help=\"Save model checkpoints every save_every epochs.\"\n )\n parser.add_argument(\n \"--spatial_scaling\", \"-ss\", default=[1], type=float, nargs='+',\n help=\"Set steps for spatial scaling.\\n\"\n \"I.e. [0.25, 0.5, 1] to train a model with width and height 256 on 64 > 128 > 256 images.\"\n )\n parser.add_argument(\"--timecycle_loss\", \"-tcl\", default=\"l1\", help=\"Timecycle loss ('l1' | 'l2')\")\n parser.add_argument(\"--timecycle_loss_weight\", \"-tclw\", default=0, type=int, help=\"Timecycle loss weight.\")\n parser.add_argument(\n \"--timecycle_motion_model_architecture\", \"-tcmm\", default=\"resnet_1blocks\",\n help=\"Architecture of Timecycle motion model. See generator_architecture for options.\"\n )\n parser.add_argument(\n \"--timecycle_motion_model_filters\", \"-tcmmf\", type=int, default=64,\n help=\"Number of filters in the last conv layer of the Timecycle motion model.\"\n )\n parser.add_argument(\n \"--timecycle_separate_motion_models\", \"-tcsmm\", action=\"store_true\",\n help=\"Set to use separate motion models for forward/backward predictions.\"\n )\n parser.add_argument(\n \"--timecycle_type\", \"-tct\", default=\"conditional\",\n help=\"Type of Timecycle ('conditional' | 'pingpong').\"\n )\n parser.add_argument(\n \"--timecycle_warp_loss_weight\", \"-tcwlw\", default=0, type=int, help=\"Timecycle warp loss weight.\"\n )\n parser.add_argument(\n \"--temporal_scaling\", \"-ts\", default=[1], type=float, nargs='+',\n help=\"Set steps for temporal scaling.\\n\"\n \"I.e. [0.2, 0.6, 1] to train a model with block_size 5 on 1 -> 3 -> 5 frames.\"\n )\n parser.add_argument(\n \"--warp_loss_weight\", \"-wlw\", default=0, type=int, help=\"Loss weight of warp loss in vid2vid.\"\n )","def train(args):\n print(args)\n\n # Run a training job\n configs = LuxMatchConfigs_Default\n\n # Create a default opponent agent\n opponent = Agent()\n\n # Create a RL agent in training mode\n player = AgentPolicy(mode=\"train\")\n\n # Train the model\n env_eval = None\n if args.n_envs == 1:\n env = LuxEnvironment(configs=configs,\n learning_agent=player,\n opponent_agent=opponent)\n else:\n env = SubprocVecEnv([make_env(LuxEnvironment(configs=configs,\n learning_agent=AgentPolicy(mode=\"train\"),\n opponent_agent=opponent), i) for i in range(args.n_envs)])\n \n run_id = args.id\n print(\"Run id %s\" % run_id)\n\n if args.path:\n # by default previous model params are used (lr, batch size, gamma...)\n model = PPO.load(args.path)\n model.set_env(env=env)\n\n # Update the learning rate\n model.lr_schedule = get_schedule_fn(args.learning_rate)\n\n # TODO: Update other training parameters\n else:\n model = PPO(\"MlpPolicy\",\n env,\n verbose=1,\n tensorboard_log=\"./lux_tensorboard/\",\n learning_rate=args.learning_rate,\n gamma=args.gamma,\n gae_lambda=args.gae_lambda,\n batch_size=args.batch_size,\n n_steps=args.n_steps\n )\n\n \n \n callbacks = []\n\n # Save a checkpoint and 5 match replay files every 100K steps\n player_replay = AgentPolicy(mode=\"inference\", model=model)\n callbacks.append(\n SaveReplayAndModelCallback(\n save_freq=100000,\n save_path='./models/',\n name_prefix=f'model{run_id}',\n replay_env=LuxEnvironment(\n configs=configs,\n learning_agent=player_replay,\n opponent_agent=Agent()\n ),\n replay_num_episodes=5\n )\n )\n \n # Since reward metrics don't work for multi-environment setups, we add an evaluation logger\n # for metrics.\n if args.n_envs > 1:\n # An evaluation environment is needed to measure multi-env setups. Use a fixed 4 envs.\n env_eval = SubprocVecEnv([make_env(LuxEnvironment(configs=configs,\n learning_agent=AgentPolicy(mode=\"train\"),\n opponent_agent=opponent), i) for i in range(4)])\n\n callbacks.append(\n EvalCallback(env_eval, best_model_save_path=f'./logs_{run_id}/',\n log_path=f'./logs_{run_id}/',\n eval_freq=args.n_steps*2, # Run it every 2 training iterations\n n_eval_episodes=30, # Run 30 games\n deterministic=False, render=False)\n )\n\n print(\"Training model...\")\n model.learn(total_timesteps=args.step_count,\n callback=callbacks)\n if not os.path.exists(f'models/rl_model_{run_id}_{args.step_count}_steps.zip'):\n model.save(path=f'models/rl_model_{run_id}_{args.step_count}_steps.zip')\n print(\"Done training model.\")\n\n # Inference the model\n print(\"Inference model policy with rendering...\")\n saves = glob.glob(f'models/rl_model_{run_id}_*_steps.zip')\n latest_save = sorted(saves, key=lambda x: int(x.split('_')[-2]), reverse=True)[0]\n model.load(path=latest_save)\n obs = env.reset()\n for i in range(600):\n action_code, _states = model.predict(obs, deterministic=True)\n obs, rewards, done, info = env.step(action_code)\n if i % 5 == 0:\n print(\"Turn %i\" % i)\n env.render()\n\n if done:\n print(\"Episode done, resetting.\")\n obs = env.reset()\n print(\"Done\")\n\n '''\n # Learn with self-play against the learned model as an opponent now\n print(\"Training model with self-play against last version of model...\")\n player = AgentPolicy(mode=\"train\")\n opponent = AgentPolicy(mode=\"inference\", model=model)\n env = LuxEnvironment(configs, player, opponent)\n model = PPO(\"MlpPolicy\",\n env,\n verbose=1,\n tensorboard_log=\"./lux_tensorboard/\",\n learning_rate = 0.0003,\n gamma=0.999,\n gae_lambda = 0.95\n )\n model.learn(total_timesteps=2000)\n env.close()\n print(\"Done\")\n '''","def main() -> None:\n parser = ArgumentParser(description=\"SoccerPredictor:\", formatter_class=ArgumentDefaultsHelpFormatter)\n subparsers = parser.add_subparsers(title=\"Modes to run\", dest=\"command\")\n\n # Trainer args\n trainer_parser = subparsers.add_parser(RunMode.Train.value, help=\"Trains model and makes predictions.\",\n formatter_class=ArgumentDefaultsHelpFormatter)\n trainer_parser.add_argument(\"--resume\", action=\"store_true\", default=False,\n help=\"Resumes training of previously saved model. \"\n \"Tries to load the latest model saved if no name or prefix specified via --name.\")\n trainer_parser.add_argument(\"--epochs\", type=int, action=\"store\", default=1,\n help=\"Number of epochs to train model for.\")\n trainer_parser.add_argument(\"--ntest\", type=int, action=\"store\", default=10,\n help=\"Number of last samples used for testing for each team.\")\n trainer_parser.add_argument(\"--ndiscard\", type=int, action=\"store\", default=0,\n help=\"Number of last samples to discard for each team.\")\n trainer_parser.add_argument(\"--timesteps\", type=int, action=\"store\", default=40,\n help=\"Number of timesteps to use as data window size for input to network.\")\n trainer_parser.add_argument(\"--predict\", action=\"store_true\", default=False,\n help=\"Whether to rerun predictions without any training.\")\n trainer_parser.add_argument(\"--lrpatience\", type=int, action=\"store\", default=20,\n help=\"How many epochs to tolerate before decaying learning rate if no improvement. \"\n \"Turned off if 0.\")\n trainer_parser.add_argument(\"--lrdecay\", type=float, action=\"store\", default=0.95,\n help=\"How much to decay learning rate after patience exceeded.\")\n trainer_parser.add_argument(\"--seed\", type=int, action=\"store\",\n help=\"Specifies seed for rng.\")\n trainer_parser.add_argument(\"--savefreq\", type=int, action=\"store\", default=50,\n help=\"How often (number of epochs) to save models. No intermediate saving if 0.\")\n trainer_parser.add_argument(\"--printfreq\", type=int, action=\"store\", default=10,\n help=\"How often (number of epochs) to print current summaries. \"\n \"No intermediate printing if 0.\")\n trainer_parser.add_argument(\"--verbose\", type=int, action=\"store\", choices=VERBOSITY_LEVELS, default=1,\n help=\"Level of verbosity.\")\n\n # Visualizer args\n visualizer_parser = subparsers.add_parser(RunMode.Vis.value, help=\"Runs visualization of predictions.\",\n formatter_class=ArgumentDefaultsHelpFormatter)\n visualizer_parser.add_argument(\"--port\", type=int, action=\"store\", default=8050,\n help=\"Custom port for Dash visualization.\")\n visualizer_parser.add_argument(\"--host\", type=str, action=\"store\", default=\"127.0.0.1\",\n help=\"Custom host for Dash visualization. Can use 0 for 0.0.0.0 shortcut.\")\n\n # Backtester args\n backtester_parser = subparsers.add_parser(RunMode.Backtest.value, help=\"Runs backtesting on trained models.\",\n formatter_class=ArgumentDefaultsHelpFormatter)\n backtester_parser.add_argument(\"--path\", type=str, action=\"store\", default=f\"{DATA_DIR}{MODEL_DIR}\",\n help=\"Path to folder where the trained models are saved.\")\n\n # common args for trainer and visualizer\n for p in [trainer_parser, visualizer_parser]:\n p.add_argument(\"--name\", type=str, action=\"store\",\n help=\"Tries to load the latest saved model with given name prefix. \"\n \"Loads exact model if exact dir name specified.\")\n\n # Common args for visualizer and backtester\n for p in [visualizer_parser, backtester_parser]:\n p.add_argument(\"--ignoreodds\", type=float, action=\"store\", default=1.10,\n help=\"Ignores odds less than given amount when predicting which team to bet on.\")\n\n args = parser.parse_args()\n\n if args.command is None:\n parser.print_help()\n return\n elif args.command == RunMode.Vis.value:\n print(\"Visualizing...\")\n vis_args, _ = visualizer_parser.parse_known_args()\n check_visualizer_args(visualizer_parser, vis_args)\n print(vis_args)\n\n from soccerpredictor.visualizer import visualizer\n try:\n visualizer.run(vis_args.name, vis_args.host, vis_args.port, vis_args.ignoreodds)\n except KeyboardInterrupt:\n print(\"> Received CTRL+C command. Exiting.\")\n elif args.command == RunMode.Backtest.value:\n print(\"Backtesting...\")\n backtest_args, _ = backtester_parser.parse_known_args()\n check_backtester_args(backtester_parser, backtest_args)\n print(backtest_args)\n\n from soccerpredictor.backtester import backtester\n try:\n backtester.run(backtest_args.path, backtest_args.ignoreodds)\n except KeyboardInterrupt:\n print(\"> Received CTRL+C command. Exiting.\")\n elif args.command == RunMode.Train.value:\n print(\"Running model...\")\n train_args, _ = trainer_parser.parse_known_args()\n config = SPConfig()\n\n # Implicitly set resume to true if we are predicting only\n if train_args.predict and not train_args.resume:\n train_args.resume = True\n\n check_trainer_args(trainer_parser, train_args)\n config.set_args(train_args)\n print(train_args)\n\n dbmanager = SPDBManager()\n try:\n dbmanager.connect()\n\n # Load previous settings if we resume training\n if train_args.resume:\n print(\"Resuming training, loading previous settings... \"\n \"Any conflicting parameters will be ignored.\")\n\n # Load previous settings\n folder = get_latest_models_dir(train_args.name)\n model_settings = get_model_settings_file(folder)\n # Restore original config\n config.restore_args(model_settings)\n set_rng_seed(config.seed)\n\n from soccerpredictor.trainer.trainer import SPTrainer\n trainer = SPTrainer(dbmanager, model_settings=model_settings, folder=folder)\n else:\n # Need to generate folder prefix before seeding random number generators\n import random\n generated_folder_prefix = \"\".join(random.choices(ascii_uppercase, k=FOLDER_PREFIX_LEN))\n print(f\"New generated folder prefix: '{generated_folder_prefix}'\")\n set_rng_seed(train_args.seed)\n\n from soccerpredictor.trainer.trainer import SPTrainer\n trainer = SPTrainer(dbmanager, generated_folder_prefix=generated_folder_prefix)\n\n try:\n trainer.run()\n finally:\n trainer.cleanup()\n\n except KeyboardInterrupt:\n print(\"> Received CTRL+C command. Exiting.\")\n except (FileNotFoundError, ValueError, OperationalError) as e:\n print(e)\n sys.exit(1)\n finally:\n dbmanager.disconnect()","def get_args():\r\n # Default root directory will be the directory in which this file is located\r\n default_root_dir = Path(__file__).parent\r\n\r\n parser = argparse.ArgumentParser(description='Predict image classification based on existing pretrained model')\r\n parser.add_argument('checkpoint', type=lambda p: train.path_exists(p, replace_keyword=\"checkpoint=\", is_file=True),\r\n metavar='<path to checkpoint file>', nargs='?',\r\n help='file path to torch checkpoint of the existing pretrained model')\r\n group = parser.add_mutually_exclusive_group(required=True)\r\n group.add_argument('-f', '--image_file', type=lambda p: train.path_exists(p, is_file=True),\r\n metavar='<path to image file>', nargs='?', help='use path to image file')\r\n group.add_argument('-i', '--image_dir', type=lambda p: train.path_exists(p), metavar='<path to images dir>',\r\n nargs='?', help='use directory containing image files; can be used as alternative to specifying'\r\n ' just a single image file path')\r\n group.add_argument('-t', '--test_mode', action='store_true', help='use test image dataset instead of '\r\n 'image file or directory; defaults to False')\r\n parser.add_argument('-d', '--test_data_dir', type=lambda p: train.path_exists(p),\r\n metavar='<path to test data dir>', nargs='?',\r\n default=default_root_dir.joinpath('flowers', 'test'),\r\n help='Will be used only when test_mode is enabled. Directory containing the test data '\r\n 'as expected by torchvision.datasets.ImageFolder; defaults to <script_dir>/flowers/test')\r\n parser.add_argument('-k', '--top_k', type=int, metavar='<integer>', nargs='?', default=5,\r\n help='number of top k most likely classes to be returned')\r\n parser.add_argument('-g', '--gpu', action='store_true', help='use gpu, if available; defaults to False')\r\n parser.add_argument('-c', '--category_names', type=lambda p: train.path_exists(p, is_file=True),\r\n metavar='<path to json file>', nargs='?', default=default_root_dir.joinpath('cat_to_name.json'),\r\n help='JSON file containing a mapping of categories and label names for targets'\r\n 'defaults to cat_to_name.json')\r\n parser.add_argument('-v', '--verbosity', action='count', default=0, help='increase output verbosity; defaults to 0')\r\n\r\n try:\r\n # vars returns dictionary\r\n return vars(parser.parse_args())\r\n except IOError as msg:\r\n parser.error(str(msg))","def do_start(self, arg):\n args = arg.split(\" \")\n self.model.initialise(args[0])\n self.model.run()","def setup():\n load_from_pretrain = args.pretrained is not None and os.path.exists(args.pretrained)\n\n if load_from_pretrain and not args.finetune:\n cfg_folder = args.pretrained\n cfg_from_file(os.path.join(cfg_folder, \"config.yaml\"), reset_model_spec=False)\n cfg.RL_MODEL_SPEC = os.path.join(cfg_folder, cfg.RL_MODEL_SPEC.split(\"/\")[-1])\n dt_string = args.pretrained.split(\"/\")[-1]\n \n else:\n if args.fix_output_time is None:\n dt_string = datetime.datetime.now().strftime(\"%d_%m_%Y_%H:%M:%S\")\n else:\n dt_string = args.fix_output_time\n\n model_output_dir = os.path.join(cfg.OUTPUT_DIR, dt_string)\n print(\"Output will be saved to `{:s}`\".format(model_output_dir))\n new_output_dir = not os.path.exists(model_output_dir) and not args.test\n print(\"Using config:\")\n pprint.pprint(cfg)\n net_dict = make_nets_opts_schedulers(cfg.RL_MODEL_SPEC, cfg.RL_TRAIN)\n print(\"Output will be saved to `{:s}`\".format(model_output_dir))\n return net_dict, dt_string","def launch(self, force_prep=False):\n #TODO process upploaded csv\n assert self.ready()\n self.launch_progress = 0\n self.set_status(\"Gathering data\")\n if 'O' not in set(self.labels.dict.values()):\n self.add_labels({max(list(self.labels.dict.keys()))+1:'O'})\n\n processed_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.csv')\n bert_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.bert')\n elmo_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.elmo')\n nlp_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.nlp')\n sbert_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.sbert')\n if os.path.exists(processed_file_path) and not force_prep:\n df = pd.read_csv(processed_file_path)\n if 'span_label' in df.columns:\n df['span_label']=df['span_label'].apply(eval)\n # Let's say loading the file is ~half the launch time\n # (if the file already exists)\n self.total = 2\n self.update(1)\n else:\n datafiles = [os.path.join(DATASETS_PATH, self.dataset_uuid, d) \\\n for d in os.listdir(os.path.join(DATASETS_PATH, self.dataset_uuid))]\n df = concat_dataset(datafiles)\n # expand total to account for time it takes to initialize the model\n self.total = len(df)*(1.1) \n self.set_status(\"Preprocessing data\")\n df = self.process_data(df, processed_file_path)\n\n # load list of 'allennlp.data.instance's. allennlp.data.instance can store true labels and tag info internally.\n if os.path.exists(nlp_file_path) and not force_prep:\n with open(nlp_file_path, 'rb') as f:\n sentences = pickle.load(f)\n else:\n #TODO define a universal reader for certain format\n # reader = RestaurantsDatasetReader()\n # data = reader.read(processed_file_path)\n #TODO handle when aux files do not exist\n pass\n bert_emb = np.load(bert_file_path, allow_pickle=True)\n elmo_emb = np.load(elmo_file_path, allow_pickle=True)\n sbert_emb = np.load(sbert_file_path, allow_pickle=True)\n for s, b, e, sb in zip(sentences, bert_emb, elmo_emb, sbert_emb):\n s.fields['bert'] = b\n s.fields['sbert'] = sb\n s.fields['elmo'] = e\n\n df['bert'] = bert_emb\n df['sbert'] = [sb for sb in sbert_emb]\n df['elmo'] = elmo_emb\n df['text_nlp'] = sentences\n\n columns_to_drop = list(\n set(df.columns).intersection(set(['span_label','file','label'])))\n df = df.drop(columns=columns_to_drop).reset_index()\n # since df['text_nlp'] contains true label info, drop 'labels' column.\n columns_to_drop = list(set(df.columns).difference(set(['index', 'Unnamed: 0', 'text', 'labels', 'split', 'bert', 'sbert',\n 'elmo', 'text_nlp'])))\n if len(columns_to_drop) > 0:\n df = df.drop(columns=columns_to_drop)\n df_train = df[df['split']=='train']\n df_dev = df[df['split'] == 'dev']\n df_valid = df[df['split'] == 'valid']\n df_test = df[df['split'] == 'test']\n\n self.text_inv_dict = dict(\n zip(list(df['text']),list(df.index))\n )\n\n # TODO split heldout set if necessary\n # for now, passing empty df as heldout set\n df_heldout = df_test\n\n self.emb_dict = Embeddings(df)\n\n self.set_status(\"Initializing modeler\")\n self.modeler = Modeler(df_train, df_dev, df_valid, df_test, df_heldout, self.labels, emb_dict=self.emb_dict)\n\n self.launch_progress = 1.0\n self.set_status(\"Finished\")\n return self.modeler","def setup(args):\n cfg = get_cfg()\n add_imaterialist_config(cfg)\n cfg.merge_from_file(model_zoo.get_config_file(\"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml\"))\n cfg.merge_from_file(args.config_file)\n \n cfg.merge_from_list(args.opts)\n cfg.freeze()\n default_setup(cfg, args)\n # Setup logger for \"imaterialist\" module\n setup_logger(output=cfg.OUTPUT_DIR, distributed_rank=comm.get_rank(), name=\"imaterialist\")\n return cfg","def parse_args(evaluation=False):\n parser = argparse.ArgumentParser(description='Referring Relationships.')\n\n # Session parameters.\n parser.add_argument('--batch-size', type=int, default=128,\n help='The batch size used in training.')\n parser.add_argument('--seed', type=int, default=1234,\n help='The random seed used to reproduce results.')\n parser.add_argument('--workers', type=int, default=1,\n help='Number workers used to load the data.')\n\n # Eval parameters.\n parser.add_argument('--heatmap-threshold', type=float, nargs='+',\n default=[0.3, 0.5, 0.6],\n help='The thresholds above which we consider '\n 'a heatmap to contain an object.')\n\n # Discovery Experiment.\n parser.add_argument('--discovery', action='store_true', default=False,\n help='Used when we run the discovery experinent '\n 'where objects are dropped during training.')\n parser.add_argument('--always-drop-file', type=str, default=None,\n help='Location of list of objects that should always '\n 'be dropped.')\n parser.add_argument('--subject-droprate', type=float, default=0.3,\n help='Rate at which subjects are dropped.')\n parser.add_argument('--object-droprate', type=float, default=0.3,\n help='Rate at which objects are dropped.')\n\n\n # Grab the other parameters.\n if evaluation:\n parse_evaluation_args(parser)\n else:\n parse_training_args(parser)\n\n args = parser.parse_args()\n\n if not evaluation:\n # Verify that we have at least one of the following flags set:\n args.use_subject = args.use_subject > 0\n args.use_predicate = args.use_predicate > 0\n args.use_object = args.use_object > 0\n if not (args.use_subject or args.use_predicate or args.use_object):\n raise ValueError('At least one of the 3 components of the '\n 'relationship should be included in training.')\n\n # set the random seed.\n np.random.seed(args.seed)\n\n # Set flags for multiprocessing.\n args.multiprocessing = args.workers > 1\n\n return args","def parse_args(argv):\n parser = argparse.ArgumentParser(\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n parser.add_argument('--config', required=True,\n choices=configs.valid_configs(),\n help='The config to use.')\n parser.add_argument('--ckpt_dir', required=True,\n help=('Path to the folder where checkpoints should be '\n 'stored. Passing the same folder twice will resume '\n 'training.'))\n parser.add_argument('--num_steps', default='1M',\n help=('Number of steps to train for. Supports M and k '\n 'postfix for \"million\" and \"thousand\", resp.'))\n parser.add_argument('--init_autoencoder_from_ckpt_dir',\n metavar='AUTOENC_CKPT_DIR',\n help=('If given, restore encoder, decoder, and '\n 'probability model from the latest checkpoint in '\n 'AUTOENC_CKPT_DIR. See README.md.'))\n parser.add_argument('--batch_size', type=int, default=8,\n help='Batch size for training.')\n parser.add_argument('--crop_size', type=int, default=256,\n help='Crop size for input pipeline.')\n parser.add_argument('--lpips_weight_path',\n help=('Where to store the LPIPS weights. Defaults to '\n 'current directory'))\n\n helpers.add_tfds_arguments(parser)\n\n parser.add_argument(\n '--no-image-summaries',\n dest='image_summaries',\n action='store_false',\n help='Disable image summaries.')\n parser.set_defaults(image_summaries=True)\n\n args = parser.parse_args(argv[1:])\n if args.ckpt_dir == args.init_autoencoder_from_ckpt_dir:\n raise ValueError('--init_autoencoder_from_ckpt_dir should not point to '\n 'the same folder as --ckpt_dir. If you simply want to '\n 'continue training the model in --ckpt_dir, you do not '\n 'have to pass --init_autoencoder_from_ckpt_dir, as '\n 'continuing training is the default.')\n args.num_steps = _parse_num_steps(args.num_steps)\n return args","def add_train_args(parser: ArgumentParser):\n # General arguments\n parser.add_argument('--task', type=str, default='regression',\n help='Regression or classification task')\n parser.add_argument('--seed', type=int, default=0,\n help='Random seed to use when splitting data into train/val/test sets.'\n 'When `num_folds` > 1, the first fold uses this seed and all'\n 'subsequent folds add 1 to the seed.')\n parser.add_argument('--data_path', type=str,\n help='Path to data CSV file')\n parser.add_argument('--split_path', type=str,\n help='Path to .npy file containing train/val/test split indices')\n parser.add_argument('--log_dir', type=str, default=None,\n help='Directory where model checkpoints will be saved')\n parser.add_argument('--model_path', type=str, default=None,\n help='Path to model file to load for evaluation time')\n parser.add_argument('--eval_output_dir', type=str, default=None,\n help='Directory to store outputs of evaluation, including predictions and attention visualization')\n\n\n # Training arguments\n parser.add_argument('--epoch', type=int, default=0,\n help='Starting epoch')\n parser.add_argument('--checkpoint_load_path', type=str,\n help='Path to model to load as checkpoint when resuming training')\n parser.add_argument('--checkpoint_dir', type=str,\n help='Path to save checkpoint model')\n parser.add_argument('--viz_dir', type=str,\n help='Path to save attention visualization')\n\n parser.add_argument('--n_epochs', type=int, default=60,\n help='Number of epochs to run')\n parser.add_argument('--batch_size', type=int, default=50,\n help='Batch size')\n parser.add_argument('--warmup_epochs', type=float, default=2.0,\n help='Number of epochs during which learning rate increases linearly from'\n 'init_lr to max_lr. Afterwards, learning rate decreases exponentially'\n 'from max_lr to final_lr.')\n parser.add_argument('--lr', type=float, default=1e-4,\n help='Learning rate')\n parser.add_argument('--num_workers', type=int, default=5,\n help='Number of workers to use in dataloader')\n parser.add_argument('--no_shuffle', action='store_true', default=False,\n help='Whether or not to retain default ordering during training')\n parser.add_argument('--shuffle_pairs', action='store_true', default=False,\n help='Whether or not to shuffle only pairs of stereoisomers')\n\n # Model arguments\n parser.add_argument('--gnn_type', type=str,\n choices=['gin', 'gcn', 'dmpnn', 'orig_dmpnn'],\n help='Type of gnn to use')\n parser.add_argument('--global_chiral_features', action='store_true', default=False,\n help='Use global chiral atom features')\n parser.add_argument('--chiral_features', action='store_true', default=False,\n help='Use local chiral atom features')\n parser.add_argument('--ft_boost', action='store_true', default=False, help='whether to concatenate R/S features after each MP layer')\n parser.add_argument('--hidden_size', type=int, default=32,\n help='Dimensionality of hidden layers')\n parser.add_argument('--depth', type=int, default=2,\n help='Number of message passing steps')\n parser.add_argument('--dropout', type=float, default=0.,\n help='Dropout probability')\n parser.add_argument('--graph_pool', type=str, default='sum',\n choices=['sum', 'mean', 'max', 'attn', 'set2set'],\n help='How to aggregate atom representations to molecule representation')\n parser.add_argument('--message', type=str, default='sum',\n choices=['sum', 'tetra_pd', 'tetra_permute', 'tetra_permute_concat'],\n help='How to pass neighbor messages')\n parser.add_argument('--n_layers', type=int, default=2,\n help='Number of final FFN layers')\n parser.add_argument('--skip_coef', type=float, default=1.,\n help='How much information retained in skip connections')\n\n # Attention arguments\n parser.add_argument('--attn_type', type=str, default='gat', choices=['gat', 'tang'],\n help='Attention type. GAT or that used in Tang 2020')\n parser.add_argument('--gat_act', type=str, default='leakyrelu',\n choices=['leakyrelu', 'relu'], help='Activation function used in GAT')\n parser.add_argument('--alpha', type=float, default=0.01,\n help='Alpha used in leakyReLU in GAT')\n parser.add_argument('--gat_depth', type=int, default=2,\n help='number of GAT attention layers')\n parser.add_argument('--heads', type=int, default=3,\n help='Number of attention heads')\n parser.add_argument('--attn_dropout', type=float, default=0.,\n help='Dropout probability for attention')\n parser.add_argument('--concat', action='store_true', default=False,\n help='concatenate heads or take average in multihead attention')","def main(cli_args=None):\n # build an arg parser\n parser = get_arg_parser()\n\n # run the parser on cli args\n args = parser.parse_args(cli_args)\n\n print(f\"Running script with arguments: {args}\")\n test_input(args.raw_training_data)\n test_input(args.raw_testing_data)\n test_output(args.train_output)\n test_output(args.test_output)","def process_command_line():\n\n # Add the command lien arguments\n parser = argparse.ArgumentParser(description=\"test autocontext\", formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n\n # Arguments\n parser.add_argument(\"--ilastik\", type=str, required=True,\n help=\"path to the file run_ilastik.sh\")\n\n parser.add_argument(\"--train\", type=str,\n help=\"path to the ilastik project that will be used for training\")\n\n parser.add_argument(\"--batch_predict\", type=str,\n help=\"path of the cache folder of a previously trained autocontext that will be used for batch \"\n \"prediction\")","def main(args):\r\n\r\n # Logging info\r\n formatter = logging.Formatter('%(asctime)s %(levelname)s - '\r\n '%(funcName)s: %(message)s',\r\n '%H:%M:%S')\r\n logger = logging.getLogger(__name__)\r\n logger.setLevel('INFO')\r\n stream = logging.StreamHandler()\r\n stream.setLevel('INFO')\r\n stream.setFormatter(formatter)\r\n logger.addHandler(stream)\r\n\r\n set_seed(args.seed)\r\n device = torch.device(\r\n 'cuda' if torch.cuda.is_available() and args.cuda else 'cpu')\r\n model_name = f'{args.name}_lr{args.lr}_z{args.latent_dim}' \\\r\n + f'_h{args.hidden_dim}_p{args.p_dropout}'\r\n model_dir = os.path.join(args.results, model_name)\r\n logger.info(f'Directory for saving and loading models: {model_dir}')\r\n\r\n if not args.eval:\r\n # Model directory\r\n new_model_dir(model_dir, logger=logger)\r\n\r\n # Dataloaders\r\n train_loader, valid_loader = get_dataloaders(\r\n args.data, args.t_hours, args.n_bins,\r\n validation=True, dynamic=args.dynamic,\r\n batch_size=args.bs, logger=logger)\r\n logger.info(\r\n f'Train {args.model_type}-{args.t_hours} ' +\r\n f'with {len(train_loader.dataset)} samples')\r\n\r\n # Load model\r\n n_tokens = len(np.load(\r\n os.path.join(\r\n args.data, '_dicts', f'{args.t_hours}_{args.n_bins}.npy'),\r\n allow_pickle=True).item())\r\n model = init_model(\r\n args.model_type, n_tokens, args.latent_dim, args.hidden_dim,\r\n p_dropout=args.p_dropout, dt=args.dt,\r\n weighted=args.weighted, dynamic=args.dynamic)\r\n logger.info(f'#params in model: {get_n_param(model)}')\r\n\r\n # Optimizer\r\n optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\r\n loss_f = BCE()\r\n model = model.to(device)\r\n\r\n # Training\r\n trainer = Trainer(\r\n model, loss_f, optimizer,\r\n device=device, logger=logger, save_dir=model_dir, p_bar=args.p_bar)\r\n trainer.train(\r\n train_loader, valid_loader,\r\n epochs=args.epochs, early_stopping=args.early_stopping)\r\n\r\n # Save model\r\n metadata = vars(args)\r\n metadata['n_tokens'] = n_tokens\r\n save_model(trainer.model, model_dir, metadata=metadata)\r\n\r\n if args.test:\r\n # Load model\r\n model = load_model(model_dir, is_gpu=args.cuda)\r\n metadata = load_metadata(model_dir)\r\n\r\n # Dataloader\r\n test_loader, _ = get_dataloaders(\r\n metadata['data'], metadata['t_hours'], metadata['n_bins'],\r\n validation=False, dynamic=metadata['dynamic'], batch_size=128,\r\n shuffle=False, logger=logger)\r\n\r\n # Evaluate\r\n loss_f = BCE()\r\n evaluator = Trainer(\r\n model, loss_f,\r\n device=device, logger=logger, save_dir=model_dir, p_bar=args.p_bar)\r\n evaluator._valid_epoch(test_loader)","def main():\n\n config = None\n\n try:\n args = get_args()\n config = process_config(args.config)\n raise RuntimeError(\"Missing or invalid arguments\")\n except Exception as e:\n logging.error(\"Failed\", exc_info=e)\n\n print(\"Create the data generator.\")\n # data_loader = MnistDataLoader(config=config)\n data_loader = IrisDataLoader(config=config)\n train_data = data_loader.get_train_data()\n test_data = data_loader.get_test_data()\n\n print(\"Build the model\")\n # cnn_model = ConvModel(config=config).build_model()\n cnn_model = ANNModel(config=config).build_model()\n\n print(\"Load the best weights\")\n cnn_model.load_weights(\"experiments/{}/{}/checkpoints/{}-weights.best.hdf5\".format(\n config.evaluation.date, config.exp.name, config.exp.name))\n\n print(\"Evaluate the model\")\n print(\"Training Metrics\")\n evaluate(model=cnn_model, data=train_data)\n print(\"Testing Metrics\")\n evaluate(model=cnn_model, data=test_data)\n\n # print(\"Visualize loss and accuracy for Training and Validation data\")\n # plot_history(config=config)\n\n # print(\"Plotting ROC Curve\")\n # plot_roc(model=cnn_model, data=test_data)\n\n print(\"Classifcation Accuracy Report\")\n classification_accuracy_report(model=cnn_model, data=test_data)","def main_train(args):\n if args.preprocessing is not None:\n raise NotImplementedError(\"ASV Preprocessing is not yet supported\")\n if args.output is None and args.snapshot_rate is not None:\n raise RuntimeError(\"Can not save snapshots without output\")\n\n # Create and load cm network\n cm_model, cm_feature_network = create_cm_network(args)\n cm_state_dict = torch.load(args.cm_model)\n # Remove the bonafide_average vector stored with\n # CM models\n average_bonafide = cm_state_dict.pop(\"average_bonafide\")\n # Do not load parameters if so desired\n if not args.from_scratch:\n cm_model.load_state_dict(cm_state_dict)\n # Get CM embedding size we are about to feed to ASV system\n cm_embedding_size = average_bonafide.shape[0]\n\n # Create and load ASV network\n asv_model, asv_feature_network = create_asv_network(XVECTOR_FEATURE_SIZE, args)\n asv_state_dict = torch.load(args.asv_model)\n # Remove any preprocessing steps\n preprocessing_parameters = {\n \"centering_mean\": asv_state_dict.pop(\"centering_mean\", None),\n \"lda\": asv_state_dict.pop(\"lda\", None)\n }\n if not args.from_scratch:\n asv_model.load_state_dict(asv_state_dict)\n\n asv_features, cm_features, speaker_labels, is_targets, is_spoofs = load_joint_train_data_asvspoof(\n args.joint_filelist, args.joint_asv_directory, args.joint_cm_directory,\n )\n\n # Move CM features to cuda already\n numpy_to_torch_cuda = lambda arr: torch.from_numpy(arr).float().cuda()\n cm_features = list(map(numpy_to_torch_cuda, cm_features))\n\n # Split bonafide spoof samples to a separate list for\n # saving CM model\n bonafide_cm_features = [cm_features[i] for i in range(len(cm_features)) if not is_spoofs[i]]\n\n # Preprocess data a little bit: Create a dictionary\n # that maps speaker labels to indeces where speaker has\n # bona fide samples\n speaker_label_to_indeces = {}\n for i, (speaker_label, is_target) in enumerate(zip(speaker_labels, is_targets)):\n if is_target:\n # Speaker label and input features match,\n # add this index to list of valid samples for that\n # speaker\n speaker_label_to_indeces[speaker_label] = (\n speaker_label_to_indeces.get(speaker_label, []) + [i]\n )\n\n # Also separate indeces of nontarget/target trials\n is_targets = np.array(is_targets)\n target_indeces = np.where(is_targets)[0]\n nontarget_indeces = np.where(~is_targets)[0]\n\n all_parameters = list(asv_model.parameters())\n all_parameters.extend(list(cm_model.parameters()))\n # SGD is stabler than Adam, but need to see how many epochs it takes to train\n optimizer = None\n if args.optimizer == \"adam\":\n optimizer = torch.optim.Adam(all_parameters, weight_decay=args.l2_weight, lr=args.lr)\n elif args.optimizer == \"sgd\":\n optimizer = torch.optim.SGD(all_parameters, weight_decay=args.l2_weight, lr=args.lr)\n\n num_samples = len(asv_features)\n total_iterations = int(args.epochs * (num_samples // BATCH_SIZE))\n\n progress_bar = tqdm(total=total_iterations)\n loss_deque = deque(maxlen=100)\n\n loss_function = LOSS_FUNCTIONS[args.loss]\n\n for update_i in range(total_iterations):\n (cm_inputs, asv_inputs), targets, is_spoof = create_joint_sample_batch(\n asv_features,\n cm_features,\n speaker_label_to_indeces,\n target_indeces,\n nontarget_indeces,\n is_spoofs,\n BATCH_SIZE\n )\n\n asv_predictions = asv_model(*asv_inputs)\n cm_predictions = cm_model(*cm_inputs)\n\n # Predictions are logits, turn into probablities\n asv_predictions = torch.sigmoid(asv_predictions)\n cm_predictions = torch.sigmoid(cm_predictions)\n\n # Loss should return a scalar value we then backprop through\n # and update parameters to minimize it\n loss = loss_function(asv_predictions, cm_predictions, targets, is_spoof, args)\n\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n\n loss_deque.append(loss.item())\n average_loss = np.mean(loss_deque)\n progress_bar.update(1)\n progress_bar.set_description(\"Loss: {:2.5f}\".format(average_loss))\n progress_bar.refresh()\n\n if args.snapshot_rate is not None and (update_i % args.snapshot_rate) == 0:\n save_models(\n args.output + \"_updates_{}\".format(update_i),\n asv_model,\n preprocessing_parameters,\n cm_feature_network,\n cm_model,\n bonafide_cm_features\n )\n\n\n if args.output is not None:\n save_models(\n args.output,\n asv_model,\n preprocessing_parameters,\n cm_feature_network,\n cm_model,\n bonafide_cm_features\n )","def argparser():\n ap = argparse.ArgumentParser(fromfile_prefix_chars='@',\n description='Train and deploy a deep-learned [Fe/H] estimator'\n 'based on Gaia time-series photometry.',\n epilog=\"\")\n\n # use custom line parser for the parameter file\n ap.convert_arg_line_to_args = convert_arg_line_to_args\n\n ap.add_argument('-v',\n '--verbose',\n action='store_true', # assign True value if used\n help='Generate verbose output.')\n\n ap.add_argument('--seed',\n action='store',\n type=int,\n default=1,\n help='Integer seed for reproducible results.')\n\n ap.add_argument('--rootdir',\n action='store',\n type=str,\n default=os.path.expanduser('~'),\n help='Full path of the root directory '\n '(all other directory and file names will be relative to this, default: `~`).')\n\n ap.add_argument('--input_list',\n action='store',\n type=str,\n default='lcfit_input.lst',\n help='Name of the input list file (default: `lcfit_input.lst`)')\n\n ap.add_argument('--input_dir',\n action='store',\n type=str,\n default='.',\n help='Subdirectory of the input time series (default: `.`)')\n\n ap.add_argument('--gls_input_file',\n action='store',\n type=str,\n default='gls_input.dat',\n help='Name of the GLS input file (created by the external code `gls` and read by `lcfit`, '\n 'default: `gls_input.dat`)')\n\n ap.add_argument('--input_lc_suffix',\n action='store',\n type=str,\n default='.dat',\n help='Suffix for the input time series file names (default: `.dat`).')\n\n ap.add_argument('--input_lc_prefix',\n action='store',\n type=str,\n default='',\n help='Prefix for the input time series file names (default: no prefix).')\n\n ap.add_argument('--output_dir',\n action='store',\n type=str,\n default='data',\n help='If specified, the clipped, phased, phase-sorted light curves will be written to '\n 'this directory, into a separate file for each time series (default: `data`).')\n\n ap.add_argument('--output_syn_dir',\n action='store',\n type=str,\n default=None,\n help='If specified, the synthetic output time series will be written to '\n 'this directory (separate file for each time series).')\n\n ap.add_argument('--plot_dir',\n action='store',\n type=str,\n default='plots',\n help='Subdirectory of the output figures.')\n\n ap.add_argument('--plot_suffix',\n action='store',\n type=str,\n default='',\n help='Suffix for the output figures.')\n\n ap.add_argument('--syn_suffix',\n action='store',\n type=str,\n default='_syn',\n help='Suffix for the synthetic output time series.')\n\n ap.add_argument('--output_gpr_dir',\n action='store',\n type=str,\n default=None,\n help='Subdirectory (if specified) of the output Gaussian Process models.')\n\n ap.add_argument('--output_param_file',\n action='store',\n type=str,\n default='lcfit.out',\n help='Name of the output parameter file.')\n\n ap.add_argument('--output_data_dir',\n action='store',\n type=str,\n default='.',\n help='Subdirectory for output data files.')\n\n ap.add_argument('--merged_output_datafile',\n action='store',\n type=str,\n default=None,\n help='Name of the data file for writing all output time series, appended one after the other.')\n\n ap.add_argument('--degrade_lc',\n action='store_true',\n help='Degrade the light curve (see the source code for the corresponding parameters).')\n\n ap.add_argument('--compute_errors',\n action='store_true', # assign True value if used\n help='If `gpr_fit` is `True`, then `n_gpr_sample` random samples will be drawn from '\n 'the fitted GPR model at the original (or if the >maxn_gpr, then the '\n 'binned) phases, and each sample will be fitted with a Fourier series. '\n 'The errors of Fourier parameters will be estimated therefrom.')\n\n ap.add_argument('--pca_model_file',\n action='store',\n type=str,\n default=None,\n help='Apply the specified PCA transformation to the Fourier parameters.')\n\n ap.add_argument('--feh_model_file',\n action='store',\n type=str,\n default=None,\n help='Apply the specified model to predict the [Fe/H] from the Fourier parameters.')\n\n ap.add_argument('--fold_double_period',\n action='store_true', # assign True value if used\n help='Fold the time series also with twice the period, and create the corresponding output files.')\n\n ap.add_argument('--loss',\n action='store',\n type=str,\n choices=['linear', 'soft_l1', 'huber', 'cauchy', 'arctan'],\n default='huber',\n help='Type of regression loss.')\n\n ap.add_argument('--sigma_clip_threshold',\n action='store',\n type=float,\n default=None,\n help='If specified, outliers beyond `sigma_clip_threshold` * residual std. dev. '\n 'will be iteratively omitted.')\n\n ap.add_argument('--align_phi1',\n action='store_true',\n help='The time series will be phase-aligned by the first Fourier phase defined to be at zero.')\n\n ap.add_argument('--null_epoch',\n action='store',\n type=float,\n default=None,\n help='Reference epoch that will be subtracted from the time values. '\n 'If None (default), then the time of the first measurement will be used '\n 'for every time series.')\n\n ap.add_argument('--gpr_fit',\n action='store_true',\n help='Perform Gaussian Process Regression (GPR) on the phase-folded time series.')\n\n ap.add_argument('--kernel',\n action='store',\n type=str,\n choices=['matern', 'expsine2'],\n default='matern',\n help='Kernel type for the GPR. Available options: `matern`, `expsine2`. Default: `matern`.')\n\n ap.add_argument('--lower_length_scale_bound',\n action='store',\n type=float,\n default=0.1,\n help='Lower length scale bound for the GPR kernel. '\n 'Used if the --gpr_fit option is selected. Default: 0.1')\n\n ap.add_argument('--upper_length_scale_bound',\n action='store',\n type=float,\n default=10.0,\n help='Upper length scale bound for the GPR kernel. '\n 'Used if the --gpr_fit option is selected. Default: 10.0')\n\n ap.add_argument('--gpr_hparam_optimization',\n action='store',\n type=str,\n choices=['mle', 'cv'],\n default='mle',\n help='Method for hyperparameter optimization of the Gaussian Process Regression. '\n 'If `mle`, then the hyperparameters will be optimized by maximizing the log-likelihood '\n '(this is the widely-used standard method for GPR). '\n 'If `cv`, then the hyperparameters will be optimized by maximizing the R2 cross-validation '\n 'score. The hyperparameter-space will be searched using a Bayesian approach as implemented in '\n 'the `scikit-optimize` API, and 10-fold CV will be used for evaluation.')\n\n ap.add_argument('--gpr_cv_n_init',\n action='store',\n type=int,\n default=10,\n help='The number of initial estimates for Bayesian hyperparameter optimization if '\n '`gpr_hparam_optimization` is `cv`.')\n\n ap.add_argument('--gpr_cv_n_calls',\n action='store',\n type=int,\n default=10,\n help='The number of iterations for Bayesian hyperparameter optimization if '\n '`gpr_hparam_optimization` is `cv`.')\n\n ap.add_argument('--fourier_from_gpr',\n action='store_true',\n help='Infer the Fourier parameters from the best-fitting Gaussian Process Regression model.')\n\n ap.add_argument('--n_augment_data',\n action='store',\n type=int,\n default=None,\n help='If specified, the input time series will be augmented by drawing `n_augment_data` new '\n 'time series from the GPR model at the original phase points.')\n\n ap.add_argument('--plot_augmented',\n action='store_true',\n help='Plot the augmented time series.')\n\n ap.add_argument('--k_fold',\n action='store',\n type=int,\n default=10,\n help='Number of cross-validation folds.')\n\n ap.add_argument('--fourier_order_min',\n action='store',\n type=int,\n default=3,\n help='Minimum Fourier order to consider.')\n\n ap.add_argument('--fourier_order_max',\n action='store',\n type=int,\n default=8,\n help='Maximum Fourier order to consider.')\n\n ap.add_argument('--is_err_col',\n action='store_true',\n help='The input contains (a) column(s) with the magnitudes\\' uncertainties.')\n\n ap.add_argument('--is_zperr_col',\n action='store_true',\n help='The input contains (a) column(s) with zero-point uncertainties.')\n\n ap.add_argument('--n_data_cols',\n action='store',\n type=int,\n default=1,\n help='Number of data columns per input file.')\n\n ap.add_argument('--use_data_cols',\n action='store',\n nargs='*',\n type=int,\n default='1',\n help='List of data columns to use.')\n\n ap.add_argument('--known_data_cols',\n action='store_true',\n help='If set, the input list file is expected to contain an extra column with header name \\'col\\' '\n 'containing the number of the data column to be used for regression.')\n\n ap.add_argument('--known_phaseshift',\n action='store_true',\n help='If set, the input list file is expected to contain an extra column with header name '\n '\\'phaseshift\\', containing the phase shift to be applied to the time series.')\n\n ap.add_argument('--min_snr',\n action='store',\n type=float,\n default=None,\n help='If specified, a column with S/N is expected to follow each magnitude column '\n '(or magnitude error column if included). Data points with values below `min_snr` '\n 'will be rejected.')\n\n ap.add_argument('--flag_omit',\n action='store',\n type=str,\n default=None,\n help='If specified, a column with string flags is expected to follow each magnitude column '\n '(or magnitude error column / S/N column if included). Data points with values `flag_omit` '\n 'will be rejected.')\n\n ap.add_argument('--mean_phase2',\n action='store',\n type=float,\n default=None,\n help='Population mean of the phi2 Fourier parameter.')\n\n ap.add_argument('--mean_phase3',\n action='store',\n type=float,\n default=None,\n help='Population mean of the phi3 Fourier parameter.')\n\n ap.add_argument('--mean_phase21',\n action='store',\n type=float,\n default=None,\n help='Population mean of the phi21 Fourier parameter.')\n\n ap.add_argument('--mean_phase31',\n action='store',\n type=float,\n default=None,\n help='Population mean of the phi31 Fourier parameter.')\n\n ap.add_argument('--waveband',\n action='store',\n type=str,\n default=None,\n help='Name of the waveband (filter) of the input time series.')\n\n ap.add_argument('--plot_data',\n action='store_true',\n help='Plot the time series.')\n\n ap.add_argument('--save_figures',\n action='store_true',\n help='Save output plots into files.')\n\n ap.add_argument('--plot_gpr',\n action='store_true',\n help='Plot the results of the Gaussian Process Regression.')\n\n ap.add_argument('--plot_all_datasets',\n action='store_true',\n help='Create plots for all datasets.')\n\n ap.add_argument('--fit_period',\n action='store_true',\n help='Fit the period to the dataset (by non-linear least squares regression).')\n\n ap.add_argument('--do_gls',\n action='store_true',\n help='Compute an initial period estimate by the Generalized Lomb-Scargle Periodogram '\n 'method. Otherwise an initial period value is expected in the input file.')\n\n ap.add_argument('--redo_gls',\n action='store_true',\n help='Recompute the initial period estimate by the Generalized Lomb-Scargle Periodogram '\n 'method in the outlier rejection iterations.')\n\n ap.add_argument('--weighted_fit',\n action='store_true',\n help='Use squared inverse of the errors as weights in the regression.')\n\n ap.add_argument('--nsyn',\n action='store',\n type=int,\n default=120,\n help='Number of equidistant phase points for the output synthetic data '\n '(i.e., points of evaluation of the regression model.)')\n\n ap.add_argument('--min_ndata',\n action='store',\n type=int,\n default=20,\n help='Minimum number of data points in the time series to be considered for analysis.')\n\n ap.add_argument('--n_jobs',\n action='store',\n type=int,\n default=None,\n help='The number parallel threads. If not specified, n_jobs=max(n_cores, k_fold)')\n\n return ap","def init_model(config, program, exe):\n checkpoints = config['Global'].get('checkpoints')\n if checkpoints:\n if os.path.exists(checkpoints + '.pdparams'):\n path = checkpoints\n fluid.load(program, path, exe)\n logger.info(\"Finish initing model from {}\".format(path))\n else:\n raise ValueError(\"Model checkpoints {} does not exists,\"\n \"check if you lost the file prefix.\".format(\n checkpoints + '.pdparams'))\n else:\n pretrain_weights = config['Global'].get('pretrain_weights')\n if pretrain_weights:\n path = pretrain_weights\n load_params(exe, program, path)\n logger.info(\"Finish initing model from {}\".format(path))","def main(_):\n if not FLAGS.model_output_dir:\n raise ValueError(\n \"Undefined model output directory. Perhaps you forgot to set the --model_output_dir flag?\")\n \n if FLAGS.predict_input_file:\n decode()\n else:\n train()","def main():\n parser = argparse.ArgumentParser(description=\"Convert a checkpoint file into a support sets and a reconstructor \"\n \"weights files\")\n parser.add_argument('--exp', type=str, required=True, help=\"set experiment's model dir (created by `train.py`)\")\n\n # Parse given arguments\n args = parser.parse_args()\n\n # Check structure of `args.exp`\n if not osp.isdir(args.exp):\n raise NotADirectoryError(\"Invalid given directory: {}\".format(args.exp))\n models_dir = osp.join(args.exp, 'models')\n if not osp.isdir(models_dir):\n raise NotADirectoryError(\"Invalid models directory: {}\".format(models_dir))\n checkpoint_file = osp.join(models_dir, 'checkpoint.pt')\n if not osp.isfile(checkpoint_file):\n raise FileNotFoundError(\"Checkpoint file not found: {}\".format(checkpoint_file))\n\n print(\"#. Convert checkpoint file into support sets and reconstructor weight files...\")\n\n # Load checkpoint file\n checkpoint_dict = torch.load(checkpoint_file)\n\n # Get checkpoint iteration\n checkpoint_iter = checkpoint_dict['iter']\n print(\" \\\\__Checkpoint iteration: {}\".format(checkpoint_iter))\n\n # Save support sets weights file\n print(\" \\\\__Save checkpoint support sets weights file...\")\n torch.save(checkpoint_dict['support_sets'], osp.join(models_dir, 'support_sets-{}.pt'.format(checkpoint_iter)))\n\n # Save reconstructor weights file\n print(\" \\\\__Save checkpoint reconstructor weights file...\")\n torch.save(checkpoint_dict['reconstructor'], osp.join(models_dir, 'reconstructor-{}.pt'.format(checkpoint_iter)))","def train_setup(additional_arg_parser=None, args=None):\n if args is None:\n args = parse_input_arguments(additional_arg_parser)\n if args.do_eval or args.do_test:\n args.load_pretrained = True\n if args.load_pretrained and args.pretrained_checkpoint == '':\n raise ValueError('Must provide --pretrained_checkpoint when using --load_pretrained')\n if args.eval_batch_size == 0:\n args.eval_batch_size = args.train_batch_size\n if args.load_pretrained:\n args.save_dir = \"/\".join(args.pretrained_checkpoint.split('/')[:-1])\n else:\n args.save_dir = get_save_dir(args.save_dir, args.run_name)\n if not os.path.exists(args.save_dir):\n os.makedirs(args.save_dir)\n args.start_epoch = 0\n args.start_step = 0\n\n split_name = 'train' if args.do_train else 'validation' if args.do_eval else 'test'\n logger = get_logger(args.save_dir, 'log_train')\n\n logger.info(\"local_rank: %d, node_index: %d, gpu_per_node: %d\"%(args.local_rank, args.node_index, args.gpu_per_node))\n # Setup CUDA, GPU & distributed training\n if args.local_rank == -1 or args.no_cuda:\n device = torch.device(\"cuda\" if torch.cuda.is_available() and not args.no_cuda else \"cpu\")\n args.n_gpu = torch.cuda.device_count()\n else: # Initializes the distributed backend which will take care of sychronizing nodes/GPUs\n torch.cuda.set_device(args.local_rank)\n device = torch.device(\"cuda\", args.local_rank)\n torch.distributed.init_process_group(backend='nccl')\n args.local_rank += args.node_index * args.gpu_per_node\n args.n_gpu = 1\n args.device = device\n\n logger.info(\"Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s, world size: %s\",\n args.local_rank, device, args.n_gpu, bool(args.local_rank != -1), args.fp16,\n torch.distributed.get_world_size() if args.local_rank != -1 else 1)\n\n set_seed(args)\n\n return args, logger","def __init__(self, classification, extras=[]):\n self.model_list = []\n self._generate_model_list(classification)\n self.model_list.extend(extras)\n self.classification = classification","def load_seq_model():\n model = joblib.load(os.path.join(os.path.dirname(__file__), 'RuleSet3.pkl'))\n return model","def setup(args):\n cfg = get_cfg()\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n # customize reszied parameters\n # cfg['INPUT']['MIN_SIZE_TRAIN'] = (20,)\n # cfg['INPUT']['MAX_SIZE_TRAIN'] = 50\n cfg.freeze()\n default_setup(\n cfg, args\n ) # if you don't like any of the default setup, write your own setup code\n return cfg","def main():\n\n ############################ variable settings #################################\n parser = argparse.ArgumentParser(description='Run Subtask C of GermEval 2017 Using Pre-Trained Language Model.')\n parser.add_argument('--seed', type=int, default=42, help='Random seed.')\n parser.add_argument('--lang_model', type=str, default='bert-base-german-dbmdz-uncased', help='The pre-trained language model.')\n parser.add_argument('--epochs', type=int, default=4, help='Number of epochs for training.')\n parser.add_argument('--lr', type=float, default=5e-5, help='The learning rate.')\n parser.add_argument('--max_len', type=int, default=256, help='The maximum sequence length of the input text.')\n parser.add_argument('--batch_size', type=int, default=32, help='Your train set batch size.')\n parser.add_argument('--df_path', type=str, default='./data/', help='The data directory.') \n parser.add_argument('--train_data', type=str, default='train_df_cat.tsv', help='The filename of the input train data.')\n parser.add_argument('--dev_data', type=str, default='dev_df_cat.tsv', help='The filename of the input development data.')\n parser.add_argument('--test_data1', type=str, default='test_syn_df_cat.tsv', help='The filename of the first input test data (synchronic).')\n parser.add_argument('--test_data2', type=str, default='test_dia_df_cat.tsv', help='The filename of the second input test data (diachronic).')\n parser.add_argument('--output_path', type=str, default='./output/subtaskC/', help='The output directory of the model and predictions.')\n parser.add_argument(\"--train\", default=True, action=\"store_true\", help=\"Flag for training.\")\n parser.add_argument(\"--save_prediction\", default=False, action=\"store_true\", help=\"Flag for saving predictions.\")\n parser.add_argument(\"--save_cr\", default=False, action=\"store_true\", help=\"Flag for saving confusion matrix.\")\n parser.add_argument(\"--exclude_general\", default=False, action=\"store_true\", help=\"Flag for excluding category Allgemein.\")\n parser.add_argument(\"--exclude_neutral\", default=False, action=\"store_true\", help=\"Flag for excluding neutral polarity.\")\n parser.add_argument(\"--exclude_general_neutral\", default=False, action=\"store_true\", help=\"Flag for excluding category Allgemein:neutral.\")\n args = parser.parse_args()\n ################################################################################\n set_all_seeds(args.seed)\n device, n_gpu = initialize_device_settings(use_cuda=True)\n \n # Load data\n train_df = pd.read_csv(args.df_path + args.train_data, delimiter = '\\t')\n dev_df = pd.read_csv(args.df_path + args.dev_data, delimiter = '\\t')\n test_syn_df = pd.read_csv(args.df_path + args.test_data1, delimiter = '\\t')\n test_dia_df = pd.read_csv(args.df_path + args.test_data2, delimiter = '\\t')\n \n # Create a tokenizer\n lower_case = False\n if args.lang_model[-7:] == \"uncased\":\n lower_case = True\n\n if args.lang_model[:4] == \"bert\":\n model_class = \"BERT\"\n tokenizer = BertTokenizer.from_pretrained(args.lang_model, do_lower_case=lower_case, max_length=args.max_len)\n \n if args.lang_model[:10] == \"distilbert\":\n model_class = \"DistilBERT\"\n tokenizer = DistilBertTokenizer.from_pretrained(args.lang_model, do_lower_case=lower_case, max_length=args.max_len)\n \n\n # get training features\n cats = train_df.columns[5:]\n end = \"full\"\n # exclude categories if required\n if (args.exclude_general):\n cats = [i for i in list(cats) if \"Allgemein\" not in i]\n end = \"excl_gen\"\n if (args.exclude_neutral):\n cats = [i for i in list(cats) if \"neutral\" not in i]\n end = \"excl_neu\"\n if (args.exclude_general_neutral):\n cats = [i for i in list(cats) if \"Allgemein:neutral\" not in i]\n end = \"excl_genneu\"\n \n num_labels = len(list(cats))\n\n # create one hot labels\n train_df['one_hot_labels'] = list(train_df[list(cats)].values)\n dev_df['one_hot_labels'] = list(dev_df[list(cats)].values)\n test_syn_df['one_hot_labels'] = list(test_syn_df[list(cats)].values)\n test_dia_df['one_hot_labels'] = list(test_dia_df[list(cats)].values)\n\n # retrieve sentences and labels\n df = pd.concat([train_df, dev_df])\n sentences = df.text.values\n labels = list(df.one_hot_labels.values) \n\n sentences_syn = test_syn_df.text.values\n labels_syn = list(test_syn_df.one_hot_labels.values)\n\n sentences_dia = test_dia_df.text.values\n labels_dia = list(test_dia_df.one_hot_labels.values)\n \n print(\"number of categories:\", len(list(cats)))\n\n # Tokenize all of the sentences and map the tokens to their word IDs. \n input_ids = [tokenizer.encode(sent, add_special_tokens=True, truncation=True, \n max_length=args.max_len) for sent in sentences]\n input_ids = pad_sequences(input_ids, maxlen=args.max_len, dtype=\"long\", \n value=0.0, truncating=\"post\", padding=\"post\")\n # Create attention masks\n attention_masks = [[int(token_id > 0) for token_id in sent] for sent in input_ids]\n \n # synchronic test data\n input_ids_syn = [tokenizer.encode(sent, add_special_tokens=True, truncation=True) for sent in sentences_syn]\n input_ids_syn = pad_sequences(input_ids_syn, maxlen=args.max_len, dtype=\"long\", \n value=0.0, truncating=\"post\", padding=\"post\")\n attention_masks_syn = [[int(token_id > 0) for token_id in sent] for sent in input_ids_syn]\n \n # diachronic test data\n input_ids_dia = [tokenizer.encode(sent, add_special_tokens=True, truncation=True) for sent in sentences_dia]\n input_ids_dia = pad_sequences(input_ids_dia, maxlen=args.max_len, dtype=\"long\", \n value=0.0, truncating=\"post\", padding=\"post\")\n attention_masks_dia = [[int(token_id > 0) for token_id in sent] for sent in input_ids_dia]\n\n # split train, dev\n train_inputs, train_labels, dev_inputs, dev_labels, train_masks, dev_masks = split_train_dev(\n train_df, dev_df, attention_masks, input_ids, labels)\n \n # transform to torch tensor\n train_inputs = torch.tensor(train_inputs)\n dev_inputs = torch.tensor(dev_inputs)\n\n train_labels = torch.tensor(train_labels)\n dev_labels = torch.tensor(dev_labels)\n\n train_masks = torch.tensor(train_masks)\n dev_masks = torch.tensor(dev_masks)\n\n test_syn_inputs = torch.tensor(input_ids_syn)\n test_syn_masks = torch.tensor(attention_masks_syn)\n test_syn_labels = torch.tensor(labels_syn)\n\n test_dia_inputs = torch.tensor(input_ids_dia)\n test_dia_masks = torch.tensor(attention_masks_dia)\n test_dia_labels = torch.tensor(labels_dia)\n\n # Create the DataLoader\n train_dataloader = create_dataloader(train_inputs, train_masks, \n train_labels, args.batch_size, train = True)\n\n dev_dataloader = create_dataloader(dev_inputs, dev_masks, \n dev_labels, args.batch_size, train = False)\n\n test_syn_dataloader = create_dataloader(test_syn_inputs, test_syn_masks, \n test_syn_labels, args.batch_size, \n train = False)\n\n test_dia_dataloader = create_dataloader(test_dia_inputs, test_dia_masks, \n test_dia_labels, args.batch_size, \n train = False)\n\n # Create model\n if args.train:\n if model_class == \"BERT\":\n config = BertConfig.from_pretrained(args.lang_model, num_labels=num_labels) \n config.hidden_dropout_prob = 0.1 \n model = BertForSequenceClassification.from_pretrained(\n args.lang_model,\n num_labels = num_labels,\n output_attentions = False,\n output_hidden_states = False\n )\n\n if model_class == \"DistilBERT\":\n config = DistilBertConfig.from_pretrained(args.lang_model, num_labels=num_labels) \n config.hidden_dropout_prob = 0.1 \n model = DistilBertForSequenceClassification.from_pretrained(\n args.lang_model,\n num_labels = num_labels,\n output_attentions = False,\n output_hidden_states = False\n )\n model.cuda()\n\n\n # Create an optimizer\n param_optimizer = list(model.named_parameters())\n no_decay = ['bias', 'LayerNorm.weight']\n optimizer_grouped_parameters = [\n {'params': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],\n 'weight_decay_rate': 0.01},\n {'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)],\n 'weight_decay_rate': 0.0}\n ]\n optimizer = AdamW(\n optimizer_grouped_parameters,\n lr=args.lr,\n eps = 1e-8\n )\n # Total number of training steps = number of batches * number of epochs\n total_steps = len(train_dataloader) * args.epochs\n # Create the learning rate scheduler\n scheduler = get_linear_schedule_with_warmup(\n optimizer,\n num_warmup_steps=0,\n num_training_steps=total_steps\n )\n \n # train model\n # Main Loop\n print(\"=================== Train ================\")\n print(\"##### Language Model:\", args.lang_model, \",\", \"learning rate:\", args.lr)\n print()\n\n track_time = time.time()\n # trange is a tqdm wrapper around the normal python range\n for epoch in trange(args.epochs, desc=\"Epoch\"):\n print(\"Epoch: %4i\"%epoch, dt.datetime.now())\n\n model, optimizer, scheduler, tr_loss = train_multilabel(\n train_dataloader=train_dataloader, \n model=model, \n device=device, \n optimizer=optimizer, \n scheduler=scheduler, \n num_labels=num_labels\n )\n # EVALUATION: TRAIN SET\n pred_bools_train, true_bools_train, f1_train = eval_multilabel(\n train_dataloader, model=model, device=device)\n print(\"TRAIN: micro F1 %.3f\"%(f1_train))\n \n # EVALUATION: DEV SET\n pred_bools_dev, true_bools_dev, f1_dev = eval_multilabel(\n dev_dataloader, model=model, device=device)\n print(\"EVAL: micro F1 %.3f\"%(f1_dev))\n \n\n print(\" Training and validation took in total: {:}\".format(format_time(time.time()-track_time)))\n\n # EVALUATION: TEST SYN SET\n pred_bools_syn, true_bools_syn, f1_test_syn = eval_multilabel(\n test_syn_dataloader, model=model, device=device)\n print(\"TEST SYN: micro F1 %.4f\"%(f1_test_syn))\n\n # classification report\n clf_report_syn = classification_report(true_bools_syn, pred_bools_syn, target_names=cats, digits=3)\n print(clf_report_syn)\n\n\n # EVALUATION: TEST DIA SET\n pred_bools_dia, true_bools_dia, f1_test_dia = eval_multilabel(\n test_dia_dataloader, model=model, device=device\n )\n print(\"TEST DIA: micro F1 %.4f\"%(f1_test_dia))\n\n # classification report\n clf_report_dia = classification_report(true_bools_dia, pred_bools_dia, target_names=cats, digits=3)\n print(clf_report_dia)\n \n if args.save_cr:\n pickle.dump(clf_report_syn, open(args.output_path+'clf_report_'+args.lang_model+'_test_syn_'+str(num_labels)+end+'.txt','wb'))\n pickle.dump(clf_report_dia, open(args.output_path+'clf_report_'+args.lang_model+'_test_dia_'+str(num_labels)+end+'.txt','wb'))\n\n\n if args.save_prediction:\n test_syn_df[\"category_pred\"] = pred_bools_syn\n test_dia_df[\"category_pred\"] = pred_bools_dia\n test_syn_df.category_pred.to_csv(args.output_path+args.lang_model+'_test_syn_'+str(num_labels)+end+\".tsv\", \n sep=\"\\t\", index = False, header = True, encoding = \"utf-8-sig\")\n test_dia_df.category_pred.to_csv(args.output_path+args.lang_model+'_test_dia_'+str(num_labels)+end+\".tsv\", \n sep=\"\\t\", index = False, header = True, encoding = \"utf-8-sig\")","def main(unused_argv):\n\n # Create tokenizer based on the training files.\n logging.info(\"Step 1: Loading tokenizer\")\n train_en = FLAGS.data_dir+'/EN_TRAIN_CORPUS_NAME'\n val_en = FLAGS.data_dir+'/EN_VAL_CORPUS_NAME'\n\n VOCAB_FILE = \"VOCAB_NAME\" \n vocab_file = os.path.join(FLAGS.data_dir, VOCAB_FILE)\n subtokenizer = tokenizer.Subtokenizer.init_from_files(\n vocab_file, [train_en], _TARGET_VOCAB_SIZE, _TARGET_THRESHOLD,\n min_count=None if FLAGS.search else _TRAIN_DATA_MIN_COUNT)\n\n compiled_train_files = (train_en, train_en)\n compiled_eval_files = (val_en, val_en)\n\n # Tokenize and save data as Examples in the TFRecord format.\n logging.info(\"Step 3: Preprocessing and saving data\")\n train_tfrecord_files = encode_and_save_files(\n subtokenizer, FLAGS.data_dir, compiled_train_files, _TRAIN_TAG,\n _TRAIN_SHARDS)\n encode_and_save_files(\n subtokenizer, FLAGS.data_dir, compiled_eval_files, _EVAL_TAG,\n _EVAL_SHARDS)\n\n for fname in train_tfrecord_files:\n shuffle_records(fname)","def main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"--model\",\n dest=\"model\",\n help=\"Model to train\",\n choices=[\"lstm\", \"bi-lstm\", \"lstm-attention\", \"bi-lstm-attention\"],\n required=True,\n )\n parser.add_argument(\n \"--units\", dest=\"units\", help=\"Num of LSTM units\", default=256, type=int\n )\n parser.add_argument(\n \"--epochs\",\n dest=\"epochs\",\n help=\"Num of epochs to train for\",\n default=100,\n type=int,\n )\n parser.add_argument(\n \"--sequence-length\",\n dest=\"sequence_length\",\n help=\"Sequence length\",\n default=100,\n type=int,\n )\n args = parser.parse_args()\n train_network(\n args.model,\n batch_size=64,\n epochs=args.epochs,\n num_units=args.units,\n sequence_length=args.sequence_length,\n )","def batch_mode(args):\n ui_mode = False\n extloader = ExtensionLoader()\n pipeline = Pipeline(extloader.cats_container, ui_mode)\n # processing args values\n if args.pipeline:\n # load the specified pipeline file\n # default url\n pipeline.load_pipeline_json(args.pipeline)\n if args.dir:\n # load the images from the specified source dir\n pipeline.set_input(args.dir)\n elif args.file:\n # load a single image\n pipeline.set_input(args.file)\n if args.out:\n pipeline.set_output_dir(args.out)\n pipeline.process()","def from_args(args, verbose=False, unhandled=None):\n\n # Create a list for unhandled arguments\n if unhandled is None:\n unhandled = []\n\n experiments = ExperimentList()\n ## First try as image files\n # experiments = ExperimentListFactory.from_datablock(\n # DataBlockFactory.from_args(args, verbose, unhandled1))\n\n # Try to load from serialized formats\n for filename in args:\n try:\n experiments.extend(\n ExperimentListFactory.from_serialized_format(filename)\n )\n if verbose:\n print(\"Loaded experiments from %s\" % filename)\n except Exception as e:\n if verbose:\n print(\"Could not load experiments from %s: %s\" % (filename, str(e)))\n unhandled.append(filename)\n\n # Return the experiments\n return experiments","def get_args():\n parser = argparse.ArgumentParser()\n\n parser.add_argument('--training', type=argparse.FileType(), default='./data/cdt.epe',\n help='epe file with training sentences.')\n parser.add_argument('--validation', type=argparse.FileType(), default='./data/cdd.epe',\n help='epe file with validation sentences.')\n parser.add_argument('--metrics', type=argparse.FileType(\"w\"), default=sys.stdout,\n help='where to output metrics computed on validation.')\n parser.add_argument('--mode', choices=['BASELINE', 'BASELINE_C', 'BASELINE_C_POS'], default='BASELINE',\n help='mode in which model is trained, C adds cue information, POS adds pos tags.')\n parser.add_argument('--arch', choices=['LSTM', 'GRU'], default='LSTM',\n help='which recurrent network architecture to use.')\n parser.add_argument('--word_vectors', default=None,\n help='file with word embeddings')\n parser.add_argument('--epochs', type=int, default=10,\n help='number of epochs to train the model.')\n parser.add_argument('--lr', type=float, default=1e-4,\n help='learning rate used in adam optimizer.')\n parser.add_argument('--max_len', type=int, default=100,\n help='maximum length of sentence.')\n parser.add_argument('--hidden_size', type=int, default=200,\n help='memory size of recurrent neural network.')\n parser.add_argument('--negations_only', action='store_true', default=False,\n help='if present, only sentences with at least one negation are used.')\n parser.add_argument('--tensorboard', action='store_true', default=False)\n parser.add_argument('--save', default=None, help='directory where to save model.')\n\n return parser.parse_args()","def add_cmdline_args(argparser):\n DictionaryAgent.add_cmdline_args(argparser)\n agent = argparser.add_argument_group('Fairseq Arguments')\n agent.add_argument(\n '-tr', '--truncate',\n type=int, default=-1,\n help='truncate input & output lengths to speed up training (may '\n 'reduce accuracy). This fixes all input and output to have a '\n 'maximum length. This reduces the total amount of padding in '\n 'the batches.')\n agent.add_argument(\n '--max-positions',\n default=1024,\n type=int,\n metavar='N',\n help='max number of tokens in the sequence')\n agent.add_argument(\n '--seed',\n default=1,\n type=int,\n metavar='N',\n help='pseudo random number generator seed')\n options.add_optimization_args(argparser)\n options.add_generation_args(argparser)\n options.add_model_args(argparser)","def main() -> None:\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--model-artm\", required=True,\n help=\"Path to directory with BigARTM model\")\n args = parser.parse_args()\n model_artm = artm.load_artm_model(args.model_artm)\n\n with open('topic_issue_model.pickle', 'rb') as issue_pickle_file:\n topic_issue_model: TopicIssueModel = pickle.load(issue_pickle_file)\n predict_topics(topic_issue_model, model_artm)","def main():\n\n parser = argparse.ArgumentParser(description='Duolingo shared task baseline model')\n parser.add_argument('--train', help='Training file name', required=True)\n parser.add_argument('--test', help='Test file name, to make predictions on', required=True)\n parser.add_argument('--pred', help='Output file name for predictions, defaults to test_name.pred')\n args = parser.parse_args()\n\n if not args.pred:\n args.pred = args.test + '.pred'\n\n assert os.path.isfile(args.train)\n assert os.path.isfile(args.test)\n\n # Assert that the train course matches the test course\n assert os.path.basename(args.train)[:5] == os.path.basename(args.test)[:5]\n\n training_data, training_labels = load_data(args.train)\n test_data = load_data(args.test)\n\n ####################################################################################\n # Here is the delineation between loading the data and running the baseline model. #\n # Replace the code between this and the next comment block with your own. #\n ####################################################################################\n\n\n vectorizer = DictVectorizer()\n X_train = [instance_data.to_features() for instance_data in training_data]\n Y_train = [training_labels[instance_data.instance_id] for instance_data in training_data]\n ids_train = [instance_data.instance_id for instance_data in training_data]\n\n X_test = [instance_data.to_features() for instance_data in test_data]\n ids_test = [instance_data.instance_id for instance_data in test_data]\n\n\n X_train = vectorizer.fit_transform(X_train)\n clf = LogisticRegression()\n clf.fit(X_train,Y_train)\n\n X_test = vectorizer.transform(X_test)\n preds_scores = [x[0] for x in clf.predict_proba(X_test)]\n predictions = dict([(instance_id,pred_score) for instance_id,pred_score in zip(ids_test,preds_scores)])\n\n ####################################################################################\n # This ends the baseline model code; now we just write predictions. #\n ####################################################################################\n\n with open(args.pred, 'wt') as f:\n for instance_id, prediction in iteritems(predictions):\n f.write(instance_id + ' ' + str(prediction) + '\\n')","def predict_input_args():\n # Create Parse using ArgumentParser\n parser = argparse.ArgumentParser()\n parser.add_argument('image', type = str, help = 'Path to the folder and file name of image to be checked') \n parser.add_argument('checkpoint', type = str, help = 'Checkpoint folder name') \n parser.add_argument('--gpu', type = bool, default = False, help = 'True = GPU enabled, False = GPU disabled') \n parser.add_argument('--topk', type = int, default = 5, help = 'Top number of class predicitions') \n parser.add_argument('--json', type = str, default = 'cat_to_name.json', help = 'Path to the folder and file name of JSON map used') \n return parser.parse_args()","def main(args):\n bad_words_file = codecs.open(args.language + \"/feature_files/bad_words\", \"r\", \"utf-8\").readlines()\n bad_words = read_known_words(bad_words_file)\n \n good_words_file = codecs.open(args.language + \"/feature_files/good_words\", \"r\", \"utf-8\").readlines()\n good_words = read_known_words(good_words_file)\n\n curse_words_file = codecs.open(args.language + \"/feature_files/curse_words\", \"r\", \"utf-8\").readlines()\n curse_words = read_known_words(curse_words_file)\n\n prepositions_file = codecs.open(args.language + \"/feature_files/prepositions\", \"r\", \"utf-8\").readlines()\n prepositions = read_known_words(prepositions_file)\n\n determiners_file = codecs.open(args.language + \"/feature_files/determiners\", \"r\", \"utf-8\").readlines()\n determiners = read_known_words(determiners_file)\n\n syllables_file = codecs.open(args.language + \"/feature_files/syllables\", \"r\", \"utf-8\").readlines()\n syllable_structure = read_syllables_file(syllables_file)\n\n other_feature_files = glob.glob(args.language + \"/feature_files/*.txt\")\n other_features = set_features_from_files(other_feature_files)\n \n ermaObj = ConllToErma(args, bad_words, good_words, curse_words, prepositions, \\\n determiners, syllable_structure, other_features)\n\n if not args.just_test:\n # Input training file.\n train_id = open(args.train, \"r\")\n train = train_id.readlines()\n train_id.close()\n sys.stdout.write(\"Reading training file...\\n\")\n (train_features, train_skip_chains) = ermaObj.read_conll_file(train)\n sys.stdout.write(\"Building model...\\n\")\n train_hash = ermaObj.make_nodes(train_features)\n # Freeze the known features based on what's seen in the training data\n ermaObj.cutoff_features()\n else:\n train_hash = {}\n train_skip_chains = {}\n # Input testing file.\n test_id = open(args.test, \"r\")\n test = test_id.readlines()\n test_id.close()\n sys.stdout.write(\"Reading test file...\\n\")\n (test_features, test_skip_chains) = ermaObj.read_conll_file(test)\n sys.stdout.write(\"Building model...\\n\")\n test_hash = ermaObj.make_nodes(test_features, test=True)\n ermaObj.write_out(train_hash, train_skip_chains, test_hash, test_skip_chains)","def parse_args():\n parser = argparse.ArgumentParser('Reading Comprehension on BaiduRC dataset')\n parser.add_argument('--prepare', action='store_true',\n help='create the directories, prepare the vocabulary and embeddings')\n parser.add_argument('--train', action='store_true',\n help='train the model')\n parser.add_argument('--generate', action='store_true',\n help='predict the answers for test set with trained model')\n parser.add_argument('--gentest', action='store_true',\n help='predict the answers for test set with trained model')\n parser.add_argument('--gpu', type=str, default='0',\n help='specify gpu device')\n\n train_settings = parser.add_argument_group('train settings')\n train_settings.add_argument('--optim', default='Adam',\n help='optimizer type')\n train_settings.add_argument('--learning_rate', type=float, default=0.001,\n help='learning rate')\n train_settings.add_argument('--weight_decay', type=float, default=0,\n help='weight decay')\n train_settings.add_argument('--dropout', type=float, default=0,\n help='dropout keep rate')\n train_settings.add_argument('--batch_size', type=int, default=128,\n help='train batch size')\n train_settings.add_argument('--epochs', type=int, default=10,\n help='train epochs')\n\n model_settings = parser.add_argument_group('model settings')\n model_settings.add_argument('--embed_size', type=int, default=128,\n help='size of the embeddings')\n model_settings.add_argument('--hidden_size', type=int, default=256,\n help='size of LSTM hidden units')\n model_settings.add_argument('--max_seq_len', type=int, default=50,\n help='max passage num in one sample')\n model_settings.add_argument('--max_gen_len', type=int, default=50,\n help='max length of passage')\n\n path_settings = parser.add_argument_group('path settings')\n path_settings.add_argument('--vocab_dir', default='../data/vocab/',\n help='the dir to save vocabulary')\n path_settings.add_argument('--model_dir', default='../data/models/',\n help='the dir to store models')\n path_settings.add_argument('--result_dir', default='../data/results/',\n help='the dir to output the results')\n path_settings.add_argument('--summary_dir', default='../data/summary/',\n help='the dir to write tensorboard summary')\n path_settings.add_argument('--log_path',\n help='path of the log file. If not set, logs are printed to console')\n return parser.parse_args()","def process_args():\n\n parser = argparse.ArgumentParser()\n\n # argument group for parameters related to input/output\n # (e.g. filenames, logging/verbosity options, target genes)\n #\n # these don't affect the model output, and thus don't need to be saved\n # with the results of the experiment\n io = parser.add_argument_group('io',\n 'arguments related to script input/output, '\n 'note these will *not* be saved in metadata ')\n io.add_argument('--custom_genes', nargs='*', default=None,\n help='currently this needs to be a subset of top_50')\n io.add_argument('--gene_set', type=str,\n choices=['top_50', 'vogelstein', 'custom'],\n default='top_50',\n help='choose which gene set to use. top_50 and vogelstein are '\n 'predefined gene sets (see data_utilities), and custom allows '\n 'any gene or set of genes in TCGA, specified in --custom_genes')\n io.add_argument('--log_file', default=None,\n help='name of file to log skipped genes to')\n io.add_argument('--results_dir', default=cfg.results_dirs['multimodal'],\n help='where to write results to')\n io.add_argument('--verbose', action='store_true')\n\n # argument group for parameters related to model training/evaluation\n # (e.g. model hyperparameters, preprocessing options)\n #\n # these affect the output of the model, so we want to save them in the\n # same directory as the experiment results\n opts = parser.add_argument_group('model_options',\n 'parameters for training/evaluating model, '\n 'these will affect output and are saved as '\n 'experiment metadata ')\n opts.add_argument('--debug', action='store_true',\n help='use subset of data for fast debugging')\n opts.add_argument('--n_dim', nargs='*', default=None,\n help='list of compressed dimensions to use, defaults to '\n 'uncompressed data for all data types')\n opts.add_argument('--num_folds', type=int, default=4,\n help='number of folds of cross-validation to run')\n opts.add_argument('--overlap_data_types', nargs='*',\n default=['expression'],\n help='data types to define set of samples to use; e.g. '\n 'set of data types for a model comparison, use only '\n 'overlapping samples from these data types')\n opts.add_argument('--seed', type=int, default=cfg.default_seed)\n opts.add_argument('--subset_mad_genes', type=int, default=cfg.num_features_raw,\n help='if included, subset gene features to this number of '\n 'features having highest mean absolute deviation')\n opts.add_argument('--training_data', nargs='*', default=['expression'],\n help='which data types to train model on')\n\n args = parser.parse_args()\n\n args.results_dir = Path(args.results_dir).resolve()\n\n if args.log_file is None:\n args.log_file = Path(args.results_dir, 'log_skipped.tsv').resolve()\n\n if args.gene_set == 'custom':\n if args.custom_genes is None:\n parser.error('must include --custom_genes when --gene_set=\\'custom\\'')\n args.gene_set = args.custom_genes\n del args.custom_genes\n elif (args.gene_set != 'custom' and args.custom_genes is not None):\n parser.error('must use option --gene_set=\\'custom\\' if custom genes are included')\n\n # check that all training data types are defined in config\n if (len(set(args.training_data).intersection(set(cfg.data_types.keys()))) !=\n len(set(args.training_data))):\n parser.error('training_data data types must be in config.data_types')\n\n # check that all data types in overlap_data_types are valid\n #\n # here I'm just checking this argument against the non-compressed data types,\n # downstream code will check if data types we request compressed data for\n # really have compressed data, but don't need to catch that here\n check_all_data_types(parser, args.overlap_data_types, args.debug)\n\n # split args into defined argument groups, since we'll use them differently\n arg_groups = du.split_argument_groups(args, parser)\n io_args, model_options = arg_groups['io'], arg_groups['model_options']\n\n # if no n_dim argument provided, set all to None\n if model_options.n_dim is None:\n model_options.n_dim = [None] * len(model_options.training_data)\n else:\n # convert None strings from argparse to python Nones\n model_options.n_dim = (\n [None if n == 'None' else n for n in model_options.n_dim]\n )\n\n # add some additional hyperparameters/ranges from config file to model options\n # these shouldn't be changed by the user, so they aren't added as arguments\n model_options.alphas = cfg.alphas\n model_options.l1_ratios = cfg.l1_ratios\n\n # for these experiments, we need to standardize all data types that are not\n # already PCA compressed\n model_options.standardize_data_types = (\n [t for ix, t in enumerate(model_options.training_data)\n if model_options.n_dim[ix] == None]\n )\n\n return io_args, model_options"],"string":"[\n \"def main(command_line_parameters=None):\\n args = command_line_arguments(command_line_parameters)\\n\\n logger.debug(\\\"Loading preprocessor\\\")\\n preprocessor = bob.bio.base.load_resource(' '.join(args.preprocessor), \\\"preprocessor\\\")\\n logger.debug(\\\"Loading extractor\\\")\\n extractor = bob.bio.base.load_resource(' '.join(args.extractor), \\\"extractor\\\")\\n if extractor.requires_training:\\n if args.extractor_file is None:\\n raise ValueError(\\\"The desired extractor requires a pre-trained extractor file, but it was not specified\\\")\\n extractor.load(args.extractor_file)\\n\\n logger.debug(\\\"Loading preprocessed data from file '%s'\\\", args.input_file)\\n preprocessed = preprocessor.read_data(args.input_file)\\n\\n logger.info(\\\"Extracting features\\\")\\n extracted = extractor(preprocessed)\\n extractor.write_feature(extracted, args.output_file)\\n logger.info(\\\"Wrote extracted features to file '%s'\\\", args.output_file)\",\n \"def use_args(args):\\n global DATA_PATH\\n global IMAGES_FILE\\n global WORKING_DIR\\n global OUTPUT_DIR\\n global OUTPUT_FILE_NAME\\n global OUTPUT_FILE\\n global LOAD_INDEXES\\n global INDEXES_DIR\\n global MODEL\\n global JOIN_MODELS\\n global MODEL1\\n global MODEL2\\n global ALL_TOGETHER\\n global TRAINED_MODELS\\n global TRAINED_MODELS_DIR\\n global TRAINED_MODELS_DIR2\\n global TRAINED_MODELS_DIRS\\n global CROSS_VALIDATION\\n global TRAIN_EPOCHS\\n global FEATURES\\n \\n if args.data_path:\\n # Change the default path of the images\\n DATA_PATH = args.data_path\\n IMAGES_FILE = os.path.join(DATA_PATH, IMAGES_FILE_NAME)\\n \\n if args.working_dir:\\n # Change the default path of the working directory\\n WORKING_DIR = args.working_dir\\n OUTPUT_DIR = WORKING_DIR\\n OUTPUT_FILE = os.path.join(OUTPUT_DIR, OUTPUT_FILE_NAME)\\n \\n if args.output_dir:\\n # Change the default path of the output directory\\n OUTPUT_DIR = os.path.join(WORKING_DIR, args.output_dir)\\n OUTPUT_FILE = os.path.join(OUTPUT_DIR, OUTPUT_FILE_NAME)\\n \\n if args.output:\\n # Change the default name of the output file\\n OUTPUT_FILE_NAME = args.output\\n OUTPUT_FILE = os.path.join(OUTPUT_DIR, OUTPUT_FILE_NAME)\\n \\n if args.indexes_dir:\\n # Load random and train indexes from file\\n LOAD_INDEXES = True\\n INDEXES_DIR = args.indexes_dir\\n \\n if args.model:\\n # Select model\\n MODEL = args.model\\n \\n if args.models:\\n \\n if not args.trained_models_dirs:\\n raise Exception(\\\"Arg. `-M --models` requires arg. \\\"\\n + \\\"`-T --trained_models_dirs`\\\")\\n \\n # Models to combine\\n JOIN_MODELS = True\\n MODEL1 = args.models[0]\\n MODEL2 = args.models[1]\\n \\n if args.trained_models_dir:\\n # Load trained models from file\\n TRAINED_MODELS = True\\n TRAINED_MODELS_DIR = args.trained_models_dir\\n \\n if args.trained_models_dirs:\\n # Load trained models from file\\n TRAINED_MODELS = True\\n TRAINED_MODELS_DIR = args.trained_models_dirs[0]\\n TRAINED_MODELS_DIR2 = args.trained_models_dirs[1]\\n \\n if args.all_together:\\n # The four models together\\n ALL_TOGETHER = True\\n TRAINED_MODELS_DIRS = args.all_together\\n \\n if args.cross_validation:\\n # Activate cross_validation\\n CROSS_VALIDATION = True\\n \\n if args.train_epochs:\\n # Change the default number of train epochs\\n TRAIN_EPOCHS = args.train_epochs\\n \\n if args.features:\\n # Nuber of best features to use\\n FEATURES = args.features\",\n \"def load_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--batchsize\\\",\\n help=\\\"the batch size of the dataloader\\\",\\n type=int,\\n default=2,\\n required=False)\\n parser.add_argument(\\\"--validsize\\\",\\n help=\\\"percentage that training set split into validation set\\\",\\n type=float,\\n default=1/6,\\n required=False)\\n parser.add_argument(\\\"--input-prefix\\\",\\n help=\\\"file for saving the data (.gz file)\\\",\\n type=str,\\n default=\\\"../mnistPC\\\",\\n required=False)\\n parser.add_argument(\\\"--demo\\\",\\n help=\\\"if demo is true, then only load small number of images\\\",\\n type=bool,\\n default=False,\\n required=False)\\n parser.add_argument(\\\"--test\\\",\\n help=\\\"if test is true, then load data from test dataset\\\",\\n type=bool,\\n default=False,\\n required=False)\\n parser.add_argument(\\\"--epochs\\\",\\n help=\\\"number of epochs\\\",\\n type=int,\\n default=5,\\n required=False)\\n parser.add_argument(\\\"--learning_rate\\\",\\n help=\\\"learning rate of the model\\\",\\n type=float,\\n default=1e-2,\\n required=False)\\n parser.add_argument(\\\"--num_classes\\\",\\n help=\\\"number of classes for classification\\\",\\n type=int,\\n default=10,\\n required=False)\\n parser.add_argument(\\\"--num_neighbors\\\",\\n help=\\\"num of neighbors for the network\\\",\\n type=int,\\n default=15,\\n required=False)\\n parser.add_argument(\\\"--cudas\\\",\\n help=\\\"cuda numbera to use, if use cpu, please enter -1\\\",\\n type=str,\\n default=\\\"0/1/2/3\\\",\\n required=False)\\n args = parser.parse_args()\\n return args\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--identifier\\\", required=True,\\n help=\\\"A short name/identifier for your experiment, e.g. 'ex42b'.\\\")\\n args = parser.parse_args()\\n\\n train(args)\",\n \"def cli(sys_argv: List[str]):\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument('--model_definition', type=str,\\n help='Path to json model definition')\\n\\n parser.add_argument('--model_state_path', type=str,\\n help='Path where to the trained parameters')\\n\\n parser.add_argument('--data_path', type=str, default=TEST_PATH,\\n help='path to the pickled dataframe on which prediction should be made')\\n\\n parser.add_argument('--numerical_preprocessor', type=str, default=NUMERICAL_PREPROCESSOR_SAVE_PATH,\\n help='Path of the saved numerical preprocessor')\\n\\n parser.add_argument('--categorical_preprocessor', type=str, default=CATEGORICAL_PREPROCESSOR_SAVE_PATH,\\n help='Path to the saved categorical preprocessor')\\n\\n parser.add_argument('--output_directory', type=str, default=RESULTS_DIR,\\n help='Path where to save the prediction of the experiment')\\n\\n args = parser.parse_args(sys_argv)\\n\\n # # ---------- parse config file ---------- # #\\n config: dict = json.load(open(args.model_definition, 'r'))\\n\\n model_class: str = config['model_class']\\n model_name: str = config['model_name']\\n numerical_input_features: List[str] = config['data']['numerical_input_features']\\n categorical_input_features: List[str] = config['data']['categorical_input_features']\\n output_features: List[str] = config['data']['output_features']\\n batch_size_test: int = config['data']['batch_size_test']\\n\\n device = torch.device(CUDA if torch.cuda.is_available() else CPU)\\n\\n # # ---------- parse model state ---------- # #\\n model_state = load_model_state(args.model_state_path, device)\\n\\n model_hyperparameters: dict = model_state['hyperparameters']\\n model_hyperparameters.update(config['model'])\\n model_hyperparameters['device']: torch.device = device\\n model_weights: dict = model_state['best_model_state_dict']\\n\\n # # ---------- initialize model ---------- # #\\n model = REGISTERED_MODELS[model_class](**model_hyperparameters).to(device)\\n model.load(model_weights)\\n\\n # # ---------- preprocess data for inference ---------- # #\\n test_loader = preprocess_for_inference(\\n args.data_path,\\n numerical_input_features,\\n categorical_input_features,\\n output_features,\\n args.numerical_preprocessor,\\n args.categorical_preprocessor,\\n batch_size_test=batch_size_test\\n )\\n\\n # # ---------- compute and save predictions ---------- # #\\n predictions = model.predict(test_loader)\\n\\n # save predictions\\n data_file_name = os.path.basename(args.data_path)\\n data_file_name = os.path.splitext(data_file_name)[0] # remove extension\\n model_path = '{}/predictions_{}_{}.pickle'.format(args.output_directory, model_name, data_file_name)\\n print(' [predict] Saving predictions at: `{}`'.format(model_path))\\n file_utils.save_to_pickle(\\n predictions,\\n path=model_path\\n )\\n print(' [predict] Done')\",\n \"def main(args):\\n # Generate detectron2 config from command line arguments.\\n cfg = get_cfg()\\n cfg.merge_from_file(args.config_file)\\n cfg.merge_from_list(args.opts)\\n\\n # The configuration file should not contain any datasets. They are configured\\n # from command line arguments instead.\\n if len(cfg.DATASETS.TRAIN) > 0 or len(cfg.DATASETS.TEST) > 0:\\n logging.error(\\\"Please set DATASETS.TRAIN = () and DATASETS.TEST = ().\\\")\\n sys.exit(1)\\n cfg.DATASETS.TRAIN = (TRAIN_SPLIT_NAME, )\\n cfg.DATASETS.TEST = (VALID_SPLIT_NAME, )\\n\\n cfg.freeze()\\n default_setup(cfg, args)\\n\\n # Register synthetic sign datasets.\\n if args.image_width is not None or args.image_height is not None:\\n if args.image_width is None or args.image_height is None:\\n logging.error(\\n \\\"Please specify both, image-width and image-height (or none).\\\")\\n sys.exit(1)\\n image_shape = args.image_height, args.image_width\\n else:\\n image_shape = None\\n\\n register_synthetic_signs(args.train_csv,\\n args.label_map,\\n cfg,\\n name=TRAIN_SPLIT_NAME,\\n image_shape=image_shape)\\n if args.valid_csv is not None:\\n register_synthetic_signs(args.valid_csv,\\n args.label_map,\\n cfg,\\n name=VALID_SPLIT_NAME,\\n image_shape=image_shape)\\n\\n # Run training or evaluation.\\n if args.eval_only:\\n model = Trainer.build_model(cfg)\\n DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load(\\n cfg.MODEL.WEIGHTS, resume=args.resume)\\n res = Trainer.test(cfg, model)\\n if comm.is_main_process():\\n verify_results(cfg, res)\\n return res\\n\\n trainer = Trainer(cfg)\\n trainer.resume_or_load(resume=args.resume)\\n return trainer.train()\",\n \"def main(args):\\n\\n shared_policy_net = build_policy_net(args).share_memory()\\n shared_value_net = build_value_net(args).share_memory()\\n\\n start_training_processes(\\n args,\\n shared_policy_net,\\n shared_value_net,\\n )\",\n \"def main(args: argparse.Namespace, config: Config) -> None:\\n # Notes:\\n # - 1878 is the number of unique answers from the GQA paper\\n # - 1843 is the number of answers across train, val and testdev\\n\\n # Download and initialise resources\\n print(colored(\\\"initialisation:\\\", attrs=[\\\"bold\\\"]))\\n stanza.download(lang=\\\"en\\\", dir=\\\".stanza\\\")\\n\\n # Print environment info\\n print(colored(\\\"environment:\\\", attrs=[\\\"bold\\\"]))\\n cuda = torch.cuda.is_available()\\n device = torch.device(\\\"cuda\\\" if cuda else \\\"cpu\\\")\\n print(f\\\"device: {torch.cuda.get_device_name(device) if cuda else 'CPU'}\\\")\\n print(config)\\n\\n if args.job == JobType.PREPROCESS:\\n preprocess(config)\\n elif args.job in (JobType.TRAIN, JobType.PREDICT):\\n resume = None\\n if args.resume != \\\"\\\":\\n run_id, checkpoint = args.resume.split(\\\":\\\")\\n resume = ResumeInfo(run_id, checkpoint)\\n if args.job == JobType.TRAIN:\\n train(config, device, resume)\\n else:\\n predict(config, device, resume)\\n else:\\n raise NotImplementedError()\",\n \"def parse_args(args):\\n assert os.path.isfile(args.data_path), \\\"The specified data file does not exist.\\\"\\n assert os.path.isfile(args.model_path), \\\"The specified model file does not exist.\\\"\\n\\n if args.read_batches is not False:\\n if args.read_batches.lower() in (\\\"y\\\", \\\"yes\\\", \\\"1\\\", \\\"\\\", \\\"true\\\", \\\"t\\\"):\\n args.read_batches = True\\n else:\\n args.read_batches = False\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"A simple tool to train a character level classifier and predict a class based on an input \\\"\\n \\\"string. Useful for tasks like detecting country by address line, nationality by name, \\\"\\n \\\"etc. Prediction is printed into stdout.\\\",\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\\n )\\n\\n required_group = parser.add_argument_group(\\\"Required\\\")\\n optional_group = parser.add_argument_group(\\\"Optional\\\")\\n\\n required_group.add_argument(\\n \\\"action\\\", help=\\\"Action: train or predict?\\\", choices=[\\\"train\\\", \\\"predict\\\"]\\n )\\n required_group.add_argument(\\n \\\"-f\\\",\\n \\\"--input-file\\\",\\n help=\\\"\\\"\\\"A file with an input line and a prediction category, separated by SEP (--separator) symbol. If '-' then stdin is used\\\"\\\"\\\",\\n required=True,\\n )\\n required_group.add_argument(\\n \\\"-m\\\",\\n \\\"--model-file\\\",\\n help=\\\"Model file. Overwriten after training or loaded for prediction. Tokenizer data will be stored along as 2 <modelname>_tokenizer_x/y.pickle files\\\",\\n required=True,\\n )\\n optional_group.add_argument(\\n \\\"--extra-lstm-layer\\\",\\n help=\\\"Add a second LSTM layer for finding extra structure in some cases\\\",\\n action=\\\"store_true\\\",\\n )\\n optional_group.add_argument(\\n \\\"--min-printable-score\\\",\\n help=\\\"\\\"\\\"Don't print the class and its score if the probability is lower than this limit\\\"\\\"\\\",\\n type=float,\\n default=0.001,\\n )\\n optional_group.add_argument(\\n \\\"--num-classes\\\",\\n help=\\\"Print number of classes for each input line\\\",\\n type=int,\\n default=1,\\n )\\n optional_group.add_argument(\\n \\\"--num-epochs\\\", help=\\\"Number of training epochs\\\", type=int, default=NUM_EPOCHS\\n )\\n optional_group.add_argument(\\n \\\"--print-scores\\\",\\n help=r\\\"Print scores for each class in such form: CLASS1=95.3%%,CLASS2=3.2%%,etc...\\\",\\n action=\\\"store_true\\\",\\n )\\n optional_group.add_argument(\\n \\\"--separator\\\",\\n help=\\\"Output separator symbol: orig_lin<SEP><class1=0.98>,<class2=0.01>,...\\\",\\n default=\\\"|\\\",\\n )\\n optional_group.add_argument(\\n \\\"--weights-file\\\",\\n help=\\\"Weight from previous run if you want to continue training\\\",\\n type=str,\\n default=None,\\n )\\n optional_group.add_argument(\\n \\\"--word-level\\\",\\n help=\\\"Replace char-level tokenizer for input string with word-level one\\\",\\n action=\\\"store_true\\\",\\n )\\n\\n if len(sys.argv) == 1:\\n parser.print_help()\\n sys.exit(1)\\n\\n return parser.parse_args()\",\n \"def load_args():\\n parser = argparse.ArgumentParser(description=\\\"Classify and predict digits using the mnist dataset\\\")\\n parser.add_argument('mode', help='the mode to run in: fit, model or predict')\\n parser.add_argument('--algo', help='which algorithm to use: RandomForest, KNN')\\n return parser.parse_args()\",\n \"def cmdline(argv: Sequence[str]) -> None:\\n # Configure command line parser\\n parser = argparse.ArgumentParser(description=\\\"Predicting with a flower classifier.\\\")\\n parser.add_argument('image', metavar='IMAGE', type=str, help='path to image file')\\n parser.add_argument('checkpoint', metavar='CHECKPOINT', type=str, help='path to checkpoint (.pth)')\\n parser.add_argument('--category_names', metavar='PATH', type=str, help='path to category file',\\n default='./cat_to_name.json')\\n parser.add_argument('--top_k', metavar='K', type=int, help='k-most likely classes', default=5)\\n parser.add_argument('--gpu', action='store_true', help='run calculations on GPU if possible',\\n default=False, dest='gpu')\\n parser.set_defaults(func=predict)\\n args = parser.parse_args(argv)\\n args.func(args)\",\n \"def setup(args):\\n cfg = get_cfg()\\n\\n cfg.merge_from_file(model_zoo.get_config_file(\\\"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml\\\"))\\n cfg.merge_from_list(args.opts)\\n\\n # configs for training\\n if args.small_vidor: # cfg.DATASETS.VIDOR.SIZE == 'small':\\n cfg.DATASETS.TRAIN = (\\\"vidor_small_train\\\",)\\n elif args.small_vidor_10imgs: # cfg.DATASETS.VIDOR.SIZE == 'small-10imgs':\\n cfg.DATASETS.TRAIN = (\\\"vidor_small_10imgs_train\\\",)\\n else:\\n cfg.DATASETS.TRAIN = (\\\"vidor_large_train\\\",)\\n # cfg.DATALOADER.NUM_WORKERS = 2\\n if not args.eval_only:\\n cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(\\\"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml\\\") # Let training initialize from model zoo\\n factor = 4\\n cfg.SOLVER.IMS_PER_BATCH = 16 * factor\\n cfg.SOLVER.BASE_LR = 0.0001 * factor # finetune using 10x smaller base_lr\\n cfg.SOLVER.MAX_ITER = 270000 // factor \\n cfg.SOLVER.STEPS = [210000 // factor, 250000 // factor]\\n # cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 # default: 512\\n cfg.MODEL.ROI_HEADS.NUM_CLASSES = 78\\n\\n # configs for testing\\n # cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, \\\"model_final.pth\\\")\\n if args.small_vidor: # cfg.DATASETS.VIDOR.SIZE == 'small':\\n cfg.DATASETS.TEST = (\\\"vidor_small_val\\\",)\\n elif args.small_vidor_10imgs: # cfg.DATASETS.VIDOR.SIZE == 'small-10imgs':\\n cfg.DATASETS.TEST = (\\\"vidor_small_10imgs_val\\\",)\\n else:\\n cfg.DATASETS.TEST = (\\\"vidor_large_val\\\",)\\n # cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5\\n\\n # cfg.OUTPUT_DIR = './output/train_vidor_with_pseudo_labels'\\n \\n \\n if not args.eval_only:\\n os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)\\n cfg.freeze()\\n default_setup(cfg, args)\\n return cfg\",\n \"def main(args):\\n # ------------------------\\n # 1 INIT LIGHTNING MODEL\\n # ------------------------\\n model = LightningTemplateModel(**vars(args))\\n\\n # ------------------------\\n # 2 INIT TRAINER\\n # ------------------------\\n trainer = Trainer.from_argparse_args(args)\\n\\n # ------------------------\\n # 3 START TRAINING\\n # ------------------------\\n trainer.fit(model)\",\n \"def main():\\n config = handle_args()\\n print(config)\\n\\n if config['mode'] == 'train':\\n logger.info('Train mode')\\n trainer = Trainer(config, shared_theano_params=None, **config)\\n trainer.train(**config)\\n logger.warn('Exiting train mode')\\n else:\\n logger.info('Test mode')\\n translator = Translator(**config)\\n translator.load_from_disk(config['models'], config['configs'],\\n config['src_dicts'], config['trg_dict'])\\n translator.translate_and_save(**config)\",\n \"def initialize(self, args):\\n # You must parse model_config. JSON string is not parsed here\\n self.model_config = json.loads(args['model_config'])\\n print(\\\"model_config:\\\", self.model_config)\\n\\n self.input_names = []\\n for input_config in self.model_config[\\\"input\\\"]:\\n self.input_names.append(input_config[\\\"name\\\"])\\n print(\\\"postprocess input names:\\\", self.input_names)\\n\\n self.output_names = []\\n self.output_dtype = []\\n for output_config in self.model_config[\\\"output\\\"]:\\n self.output_names.append(output_config[\\\"name\\\"])\\n dtype = pb_utils.triton_string_to_numpy(output_config[\\\"data_type\\\"])\\n self.output_dtype.append(dtype)\\n print(\\\"postprocess output names:\\\", self.output_names)\\n self.postprocessor = fd.vision.ocr.DBDetectorPostprocessor()\\n self.cls_preprocessor = fd.vision.ocr.ClassifierPreprocessor()\\n self.rec_preprocessor = fd.vision.ocr.RecognizerPreprocessor()\\n self.cls_threshold = 0.9\",\n \"def main(args):\\n # If using a real ensemble, the actual number of models is --ensemble;\\n # otherwise we only train 1 model (and construct a \\\"fake\\\" ensemble later)\\n if args.ensemble_type == \\\"real\\\":\\n n_ens = args.ensemble\\n else:\\n n_ens = 1\\n\\n # Check if resumable\\n resumable = args.resume and all(\\n io_util.is_resumable(args.exp_dir, i=i) for i in range(n_ens)\\n )\\n if resumable:\\n logger.warning(\\n \\\"When resuming, we don't support multiple start epochs...if --warm_start, models may get trained for an extra epoch or two\\\"\\n )\\n os.makedirs(args.exp_dir, exist_ok=True)\\n if not resumable:\\n io_util.save_args(args, args.exp_dir)\\n\\n # Seeds\\n torch.manual_seed(args.seed)\\n\\n # Cuda device\\n if args.cuda and args.cuda_id != -1:\\n torch.cuda.set_device(args.cuda_id)\\n\\n dataloaders, vocab = builders.build_dataloaders(args)\\n models, optimizer_func, losses = builders.build_ensemble(args, vocab)\\n optimizers = optimizer_func()\\n\\n # Initialize / load checkpoint\\n all_metrics = []\\n if resumable:\\n for i in range(n_ens):\\n io_util.restore_checkpoint(models[i], optimizers[i], args.exp_dir, i=i)\\n metrics = io_util.load_metrics(args.exp_dir, i=i)\\n all_metrics.append(metrics)\\n\\n # FIXME: Resuming isn't quite correct yet:\\n # (1) need to restore the dataloaders based on existing EIG (make that\\n # a func used by al.acq)\\n # (2) Reload eig_records, all_eig_details\\n start_epoch = min(m[\\\"current_epoch\\\"] for m in all_metrics) + 1\\n\\n if os.path.exists(os.path.join(args.exp_dir, \\\"ens_metrics.json\\\")):\\n ens_metrics = io_util.load_metrics(\\n args.exp_dir, filename=\\\"ens_metrics.json\\\"\\n )\\n else:\\n ens_metrics = util.init_metrics(ensemble=True)\\n\\n logger.info(\\\"Resuming from epoch {}\\\".format(start_epoch))\\n else:\\n for i in range(n_ens):\\n metrics = util.init_metrics(ensemble=False)\\n all_metrics.append(metrics)\\n start_epoch = 0\\n ens_metrics = util.init_metrics(ensemble=True)\\n\\n # Pooling (\\n if args.eig_workers == 0 or args.eig_method == \\\"random\\\":\\n pool_ctx = util.FakePool\\n else:\\n pool_ctx = mp.Pool\\n\\n all_eig_details = defaultdict(list)\\n eig_records = []\\n if args.warm_start or args.acquisition == \\\"eig_y\\\":\\n # Keep the same EIG optimizer if warm start OR if acquire_y (to prevent waste)\\n # Only applies to acquire_xy; in acquire_y, new optimizer for each image\\n eig_config = builders.build_eig_estimator(\\n args, vocab, model_batch_size=args.qhy_batch_size\\n )\\n else:\\n eig_config = None\\n\\n # Loop through acquisition steps\\n for acq_step in range(start_epoch, args.epochs):\\n # ==== INDIVIDUAL MODEL TRAINING ====\\n for i, (model, optimizer, loss, metrics) in enumerate(\\n zip(models, optimizers, losses, all_metrics)\\n ):\\n if args.no_train:\\n break\\n # Train on seed set - inner loop\\n best_model_state_dict = None\\n val_evals_since_improvement = 0\\n\\n if args.dataset == \\\"wmt14\\\":\\n best_val_metrics = {\\n \\\"loss\\\": float(\\\"inf\\\"),\\n \\\"top1\\\": 0.0,\\n \\\"ppl\\\": float(\\\"inf\\\"),\\n }\\n rf = run_mt\\n else:\\n best_val_metrics = {\\\"loss\\\": float(\\\"inf\\\"), \\\"top5\\\": 0.0, \\\"top1\\\": 0.0}\\n rf = run\\n\\n for epoch in trange(\\n 0,\\n args.inner_epochs,\\n desc=f\\\"acq step {acq_step}/{args.epochs} (size {len(dataloaders['seed'].dataset)}): train model {i}\\\",\\n ):\\n train_metrics = rf(\\n \\\"seed\\\", epoch, model, optimizer, loss, dataloaders, args, i\\n )\\n util.print_metrics_progress(\\n \\\"train\\\", epoch, train_metrics, i, logger=logger\\n )\\n if (epoch + 1) % args.val_interval == 0: # since epochs are 0-indexed\\n val_metrics = rf(\\n \\\"val\\\", epoch, model, optimizer, loss, dataloaders, args, i\\n )\\n util.print_metrics_progress(\\n \\\"val\\\", epoch, val_metrics, i, logger=logger\\n )\\n if val_metrics[\\\"top1\\\"] > best_val_metrics[\\\"top1\\\"]:\\n best_val_metrics = val_metrics\\n best_val_metrics[\\\"epoch\\\"] = epoch\\n best_model_state_dict = copy.deepcopy(model.state_dict())\\n val_evals_since_improvement = 0\\n else:\\n val_evals_since_improvement += 1\\n\\n if val_evals_since_improvement >= args.val_patience:\\n logger.info(\\n f\\\"Stopped at inner epoch {epoch}; no improvement after {val_evals_since_improvement} evals (best top1: {best_val_metrics['top1']:f})\\\"\\n )\\n break\\n\\n if best_model_state_dict is None:\\n # No early stopping was performed, val was never evaluated\\n best_model_state_dict = copy.deepcopy(model.state_dict())\\n\\n # Restore best model\\n model.load_state_dict(best_model_state_dict)\\n\\n # Update your metrics, prepending the split name.\\n for metric, value in train_metrics.items():\\n metrics[\\\"train_{}\\\".format(metric)].append(value)\\n for metric, value in best_val_metrics.items():\\n metrics[\\\"val_{}\\\".format(metric)].append(value)\\n metrics[\\\"current_epoch\\\"] = acq_step\\n\\n # Check if there was an improvement\\n is_best = best_val_metrics[\\\"top1\\\"] > metrics[\\\"best_top1\\\"]\\n if is_best:\\n metrics[\\\"best_top1\\\"] = best_val_metrics[\\\"top1\\\"]\\n metrics[\\\"best_loss\\\"] = best_val_metrics[\\\"loss\\\"]\\n metrics[\\\"best_epoch\\\"] = acq_step\\n\\n if is_best:\\n metrics[\\\"epochs_since_improvement\\\"] = 0\\n else:\\n metrics[\\\"epochs_since_improvement\\\"] += 1\\n logger.info(\\n f\\\"Epochs since last improvement: {metrics['epochs_since_improvement']}\\\"\\n )\\n\\n state_dict = {\\n \\\"state_dict\\\": model.state_dict(),\\n \\\"optimizer\\\": optimizer.state_dict(),\\n }\\n io_util.save_checkpoint(state_dict, is_best, args.exp_dir, i=i)\\n # Save checkpoint at fixed intervals based on epoch\\n if acq_step % args.save_interval == 0:\\n io_util.save_checkpoint(\\n state_dict,\\n False,\\n args.exp_dir,\\n filename=\\\"{}.pth\\\".format(acq_step),\\n i=i,\\n )\\n\\n io_util.save_metrics(metrics, args.exp_dir, i=i)\\n\\n # ==== ENSEMBLE EVAL ====\\n if args.eval_ensemble:\\n if args.dataset not in {\\\"mnist\\\"}:\\n raise NotImplementedError\\n if args.ensemble_type == \\\"mc\\\":\\n raise NotImplementedError\\n ens = ensemble.Ensemble(models)\\n this_ens_metrics = eval_ensemble(\\n \\\"val\\\", ens, dataloaders, args, eval_batch_size=4\\n )\\n for metric, value in this_ens_metrics.items():\\n ens_metrics[\\\"ens_{}\\\".format(metric)].append(value)\\n ens_metrics[\\\"current_epoch\\\"] = acq_step\\n if this_ens_metrics[\\\"acc\\\"] > ens_metrics[\\\"best_ens_acc\\\"]:\\n ens_metrics[\\\"best_ens_acc\\\"] = this_ens_metrics[\\\"acc\\\"]\\n ens_metrics[\\\"best_ens_loss\\\"] = this_ens_metrics[\\\"loss\\\"]\\n ens_metrics[\\\"best_ens_epoch\\\"] = acq_step\\n io_util.save_metrics(ens_metrics, args.exp_dir, filename=\\\"ens_metrics.json\\\")\\n\\n util.print_ensemble_progress(\\n acq_step, all_metrics, ens_metrics=ens_metrics, logger=logger\\n )\\n\\n # ==== ACQUISITION ====\\n # Compute sizes (e.g. if they are % of dataset)\\n current_pool_size = len(dataloaders[\\\"pool\\\"].dataset)\\n current_seed_size = len(dataloaders[\\\"seed\\\"].dataset)\\n dataset_size = current_pool_size + current_seed_size\\n pool_size = util.compute_size(\\n args.pool_size, dataset_size, remaining_dataset_size=current_pool_size\\n )\\n acq_size = util.compute_size(args.acq_size, dataset_size)\\n\\n if args.ensemble_type == \\\"real\\\":\\n ens = ensemble.Ensemble(models).eval()\\n else:\\n assert len(models) == 1\\n ens = ensemble.MCEnsemble(models[0], n=args.ensemble).eval()\\n if args.compare is not None:\\n # Preselect a pool and evaluate EIG for each datum with all\\n # available methods. Do selection according to the selected EIG\\n pool = util.sample_idx(\\n pool_size, RandomSampler(dataloaders[\\\"pool\\\"].dataset)\\n )\\n # Save real run for last\\n acq_methods = args.compare[:]\\n acq_methods.append(args.acquisition)\\n else:\\n # Just do one\\n pool = None\\n acq_methods = [args.acquisition]\\n\\n # Possible to run some acq methods multiple times\\n acq_method_counts = Counter(acq_methods)\\n counts = Counter()\\n for acq_method_i, acq_method in enumerate(acq_methods):\\n # Only the last acq_method is not a dry run\\n dry_run = acq_method_i != len(acq_methods) - 1\\n if acq_method in {\\\"eig_xy\\\", \\\"batchbald\\\", \\\"batcheig\\\"}:\\n acqf = {\\n \\\"eig_xy\\\": al.acquisition.acquire_xy,\\n \\\"batcheig\\\": al.acquisition.acquire_batcheig,\\n \\\"batchbald\\\": al.acquisition.acquire_batchbald,\\n }[acq_method]\\n eig_record, eig_details = acqf(\\n acq_size,\\n pool_size,\\n ens,\\n dataloaders,\\n args,\\n eig_config=eig_config,\\n pool=pool,\\n dry_run=dry_run,\\n )\\n else:\\n with pool_ctx(args.eig_workers) as mp_pool:\\n eig_record, eig_details = al.acquisition.acquire_y(\\n al.funcs.ACQ_FUNCS[acq_method],\\n acq_size,\\n pool_size,\\n ens,\\n dataloaders,\\n args,\\n mp_pool=mp_pool,\\n eig_config=eig_config,\\n pool=pool,\\n dry_run=dry_run,\\n epoch=acq_step,\\n )\\n\\n eig_record[\\\"epoch\\\"] = acq_step\\n if not dry_run:\\n logger.info(eig_record)\\n\\n if acq_method_counts[acq_method] > 1:\\n n_done = counts[acq_method]\\n counts[acq_method] += 1\\n acq_method = f\\\"{acq_method}_{n_done}\\\"\\n\\n eig_record[\\\"method\\\"] = acq_method\\n eig_record[\\\"dry_run\\\"] = dry_run\\n eig_records.append(eig_record)\\n\\n for edname, edval in eig_details.items():\\n all_eig_details[edname].extend(edval)\\n all_eig_details[\\\"method\\\"].extend(acq_method for _ in eig_details[\\\"id\\\"])\\n all_eig_details[\\\"dry_run\\\"].extend(dry_run for _ in eig_details[\\\"id\\\"])\\n all_eig_details[\\\"epoch\\\"].extend(acq_step for _ in eig_details[\\\"id\\\"])\\n\\n eig_fname = os.path.join(args.exp_dir, \\\"eig.csv\\\")\\n pd.DataFrame.from_records(eig_records).to_csv(eig_fname, index=False)\\n\\n eig_details_fname = os.path.join(args.exp_dir, \\\"eig_details.csv\\\")\\n pd.DataFrame(all_eig_details).to_csv(eig_details_fname, index=False)\\n\\n # Done acquiring - reset parameters\\n if not args.warm_start:\\n ens.reset_parameters()\\n optimizers = optimizer_func()\",\n \"def load_arguments(parser):\\n\\n\\t# paths\\n\\tparser.add_argument('--train_path_src', type=str, required=True, help='train src dir')\\n\\tparser.add_argument('--train_path_tgt', type=str, required=True, help='train tgt dir')\\n\\tparser.add_argument('--path_vocab_src', type=str, required=True, help='vocab src dir')\\n\\tparser.add_argument('--path_vocab_tgt', type=str, required=True, help='vocab tgt dir')\\n\\tparser.add_argument('--dev_path_src', type=str, default=None, help='dev src dir')\\n\\tparser.add_argument('--dev_path_tgt', type=str, default=None, help='dev tgt dir')\\n\\tparser.add_argument('--save', type=str, required=True, help='model save dir')\\n\\tparser.add_argument('--load', type=str, default=None, help='model load dir')\\n\\tparser.add_argument('--load_embedding_src', type=str, default=None, help='pretrained src embedding')\\n\\tparser.add_argument('--load_embedding_tgt', type=str, default=None, help='pretrained tgt embedding')\\n\\tparser.add_argument('--train_attscore_path', type=str, default=None, help='train set reference attention scores')\\n\\tparser.add_argument('--dev_attscore_path', type=str, default=None, help='dev set reference attention scores')\\n\\n\\t# model\\n\\tparser.add_argument('--embedding_size_enc', type=int, default=200, help='encoder embedding size')\\n\\tparser.add_argument('--embedding_size_dec', type=int, default=200, help='decoder embedding size')\\n\\tparser.add_argument('--hidden_size_enc', type=int, default=200, help='encoder hidden size')\\n\\tparser.add_argument('--num_bilstm_enc', type=int, default=2, help='number of encoder bilstm layers')\\n\\tparser.add_argument('--num_unilstm_enc', type=int, default=0, help='number of encoder unilstm layers')\\n\\tparser.add_argument('--hidden_size_dec', type=int, default=200, help='encoder hidden size')\\n\\tparser.add_argument('--num_unilstm_dec', type=int, default=2, help='number of encoder bilstm layers')\\n\\tparser.add_argument('--hard_att', type=str, default='False', help='use hard attention or not')\\n\\tparser.add_argument('--att_mode', type=str, default='bahdanau', \\\\\\n\\t\\t\\t\\t\\t\\t\\thelp='attention mechanism mode - bahdanau / hybrid / dot_prod')\\t\\n\\tparser.add_argument('--hidden_size_att', type=int, default=1, \\\\\\n\\t\\t\\t\\t\\t\\t\\thelp='hidden size for bahdanau / hybrid attention')\\n\\tparser.add_argument('--hidden_size_shared', type=int, default=200, \\\\\\n\\t\\t\\t\\t\\t\\t\\thelp='transformed att output hidden size (set as hidden_size_enc)')\\n\\tparser.add_argument('--additional_key_size', type=int, default=0, \\\\\\n\\t\\t\\t\\t\\t\\t\\thelp='additional attention key size: keys = [values, add_feats]')\\n\\n\\t# train \\n\\tparser.add_argument('--random_seed', type=int, default=666, help='random seed')\\t\\n\\tparser.add_argument('--max_seq_len', type=int, default=32, help='maximum sequence length')\\n\\tparser.add_argument('--batch_size', type=int, default=64, help='batch size')\\t\\n\\tparser.add_argument('--embedding_dropout', type=float, default=0.0, help='embedding dropout')\\n\\tparser.add_argument('--dropout', type=float, default=0.0, help='dropout')\\n\\tparser.add_argument('--num_epochs', type=int, default=10, help='number of training epoches')\\n\\tparser.add_argument('--learning_rate', type=float, default=0.001, help='learning rate')\\n\\tparser.add_argument('--residual', type=str, default='False', help='residual connection')\\n\\tparser.add_argument('--max_grad_norm', type=float, default=1.0, help='optimiser gradient norm clipping: max grad norm')\\t\\n\\tparser.add_argument('--batch_first', type=str, default='True', help='batch as the first dimension')\\n\\tparser.add_argument('--use_gpu', type=str, default='False', help='whether or not using GPU')\\n\\tparser.add_argument('--eval_with_mask', type=str, default='True', help='calc loss excluding padded words')\\n\\tparser.add_argument('--scheduled_sampling', type=str, default='False', \\\\\\n\\t\\t\\t\\t\\t \\t\\thelp='gradually turn off teacher forcing \\\\\\n\\t\\t\\t\\t\\t \\t\\t(if True, use teacher_forcing_ratio as the starting point)')\\n\\n\\t# teacher forcing / attention forcing / dual\\n\\tparser.add_argument('--train_mode', type=str, default='dual', help='train mode; multi | dual | afdynamic')\\n\\tparser.add_argument('--load_tf', type=str, default=None, help='used with train_mode=af; tf model load dir')\\n\\tparser.add_argument('--teacher_forcing_ratio', type=float, default=1.0, help='ratio of teacher forcing')\\n\\tparser.add_argument('--attention_forcing', type=str, default='False', help='whether or not using attention forcing')\\n\\tparser.add_argument('--attention_loss_coeff', type=float, default=1.0, \\\\\\n\\t\\t\\t\\t\\t\\t\\thelp='attention loss coeff, ignored if attention_forcing=False')\\n\\t\\n\\t# save and print\\n\\tparser.add_argument('--checkpoint_every', type=int, default=10, help='save ckpt every n steps')\\t\\n\\tparser.add_argument('--print_every', type=int, default=10, help='print every n steps')\\t\\n\\n\\treturn parser\",\n \"def main():\\n args = parse_args(sys.argv[1:])\\n\\n if args.version:\\n print(birdvoxclassify.version.version)\\n return\\n\\n if args.quiet:\\n logger_level = 30\\n elif args.verbose:\\n logger_level = 20\\n else:\\n logger_level = 25\\n\\n run(args.inputs,\\n output_dir=args.output_dir,\\n output_summary_path=args.output_summary_path,\\n model_name=args.model_name,\\n batch_size=args.batch_size,\\n select_best_candidates=args.select_best_candidates,\\n hierarchical_consistency=args.hierarchical_consistency,\\n suffix=args.suffix,\\n logger_level=logger_level)\",\n \"def parse_args(args):\\n parser = argparse.ArgumentParser(\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\\n description='Train a detection model from an already prepared dataset')\\n\\n # Mandatory arguments\\n parser.add_argument(\\n 'base_dataset_dir', help='directory containing the prepared dataset')\\n\\n parser.add_argument('dataset_dir', help='path to temporary directory')\\n\\n # Options\\n parser.add_argument(\\n '-o',\\n '--output-model',\\n default='model.h5',\\n help='filename for output model')\\n\\n parser.add_argument(\\n '--seed', type=int, help='seed number for the random number generator')\\n parser.add_argument(\\n \\\"--test-size\\\",\\n type=float,\\n default=0.25,\\n help=(\\\"The proportion of the dataset to include in the test split. \\\"\\n \\\"Float number between 0.0 and 1.0\\\"))\\n parser.add_argument(\\n \\\"--validation-size\\\",\\n type=float,\\n default=0.25,\\n help=(\\n \\\"The proportion of the dataset to include in the validation split. \\\"\\n \\\"Float number between 0.0 and 1.0\\\"))\\n parser.add_argument(\\n \\\"--balancing-multiplier\\\",\\n type=float,\\n default=1.0,\\n help=\\n \\\"proportion of false samples w.r.t true samples (e.g. 1.0 = 50%% true, 50%% false)\\\"\\n )\\n parser.add_argument(\\n \\\"--trainable-layers\\\",\\n type=int,\\n default=5,\\n help=\\\"number of upper layers of ResNet-50 to retrain\\\")\\n parser.add_argument(\\\"--batch-size\\\", type=int, default=5, help=\\\"Batch size\\\")\\n parser.add_argument(\\n \\\"--epochs\\\", type=int, default=20, help=\\\"number of epochs to run\\\")\\n\\n parser.add_argument(\\n '--version',\\n action='version',\\n version='aplatam {ver}'.format(ver=__version__))\\n parser.add_argument(\\n '-v',\\n '--verbose',\\n dest=\\\"loglevel\\\",\\n help=\\\"set loglevel to INFO\\\",\\n action='store_const',\\n const=logging.INFO)\\n parser.add_argument(\\n '-vv',\\n '--very-verbose',\\n dest=\\\"loglevel\\\",\\n help=\\\"set loglevel to DEBUG\\\",\\n action='store_const',\\n const=logging.DEBUG)\\n\\n return parser.parse_args(args)\",\n \"def main(args):\\n args = parse_args(args)\\n setup_logging(args.loglevel)\\n dataset_opts = read_metadata(args.base_dataset_dir)\\n size = dataset_opts[\\\"size\\\"]\\n\\n # Set seed number\\n if args.seed:\\n _logger.info('Seed: %d', args.seed)\\n random.seed(args.seed)\\n\\n # Gather all files in dataset\\n true_files = glob.glob(os.path.join(args.base_dataset_dir, 't', '*.jpg'))\\n false_files = glob.glob(os.path.join(args.base_dataset_dir, 'f', '*.jpg'))\\n\\n # Split dataset into train, validation and test sets\\n split_dataset(\\n (true_files, false_files),\\n args.base_dataset_dir,\\n test_size=args.test_size,\\n validation_size=args.validation_size,\\n balancing_multiplier=args.balancing_multiplier)\\n\\n train(args.trainable_layers, args.output_model, args.batch_size,\\n args.epochs, size, args.dataset_dir)\\n\\n _logger.info('Done')\",\n \"def main():\\r\\n # Read dataset.\\r\\n reader = DatasetReader\\r\\n train_filename = sys.argv[1]\\r\\n test_filename = train_filename.replace('_train_', '_dev_')\\r\\n term_index, tag_index, train_data, test_data = reader.ReadData(train_filename, test_filename)\\r\\n (train_terms, train_tags, train_lengths) = train_data\\r\\n (test_terms, test_tags, test_lengths) = test_data\\r\\n\\r\\n model = SequenceModel(train_tags.shape[1], len(term_index), len(tag_index))\\r\\n model.build_inference()\\r\\n model.build_training()\\r\\n for j in range(5):\\r\\n model.train_epoch(train_terms,train_tags, train_lengths)\\r\\n print('Finished epoch %i. Evaluating ...' % (j+1))\\r\\n model.evaluate(test_terms, test_tags, test_lengths)\",\n \"def main():\\n\\n if len(sys.argv) == 3:\\n database_filepath, model_filepath = sys.argv[1:]\\n print('Loading data...\\\\n DATABASE: {}'.format(database_filepath))\\n X, Y, category_names = load_data(database_filepath)\\n X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)\\n \\n print('Building model...')\\n model = build_model()\\n \\n print('Training model...')\\n model.fit(X_train, Y_train)\\n \\n print('Evaluating model...')\\n evaluate_model(model, X_test, Y_test, category_names)\\n\\n print('Saving model...\\\\n MODEL: {}'.format(model_filepath))\\n save_model(model, model_filepath)\\n\\n print('Trained model saved!')\\n\\n else:\\n print('Please provide the filepath of the disaster messages database '\\\\\\n 'as the first argument and the filepath of the pickle file to '\\\\\\n 'save the model to as the second argument. \\\\n\\\\nExample: python '\\\\\\n 'train_classifier.py ../data/DisasterResponse.db classifier.pkl')\",\n \"def parse_arguments(args_to_parse):\\n\\tdefault_config = get_config_section([CONFIG_FILE], \\\"Custom\\\")\\n\\n\\tdescription = \\\"PyTorch implementation and evaluation of disentangled Variational AutoEncoders and metrics.\\\"\\n\\tparser = argparse.ArgumentParser(description=description,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t formatter_class=FormatterNoDuplicate)\\n\\n\\t# General options\\n\\tgeneral = parser.add_argument_group('General options')\\n\\tgeneral.add_argument('name', type=str,\\n\\t\\t\\t\\t\\t\\t help=\\\"Name of the model for storing and loading purposes.\\\")\\n\\tgeneral.add_argument('-L', '--log-level', help=\\\"Logging levels.\\\",\\n\\t\\t\\t\\t\\t\\t default=default_config['log_level'], choices=LOG_LEVELS)\\n\\tgeneral.add_argument('--no-progress-bar', action='store_true',\\n\\t\\t\\t\\t\\t\\t default=default_config['no_progress_bar'],\\n\\t\\t\\t\\t\\t\\t help='Disables progress bar.')\\n\\tgeneral.add_argument('--no-cuda', action='store_true',\\n\\t\\t\\t\\t\\t\\t default=default_config['no_cuda'],\\n\\t\\t\\t\\t\\t\\t help='Disables CUDA training, even when have one.')\\n\\tgeneral.add_argument('-s', '--seed', type=int, default=default_config['seed'],\\n\\t\\t\\t\\t\\t\\t help='Random seed. Can be `None` for stochastic behavior.')\\n\\tgeneral.add_argument('-c', '--classifier', type = str,\\n\\t\\t\\t\\t\\t\\t help='Name of the classifeir')\\n\\t# Learning options\\n\\ttraining = parser.add_argument_group('Training specific options')\\n\\ttraining.add_argument('--checkpoint-every',\\n\\t\\t\\t\\t\\t\\t type=int, default=default_config['checkpoint_every'],\\n\\t\\t\\t\\t\\t\\t help='Save a checkpoint of the trained model every n epoch.')\\n\\ttraining.add_argument('-d', '--dataset', help=\\\"Path to training data.\\\",\\n\\t\\t\\t\\t\\t\\t default=default_config['dataset'], choices=DATASETS)\\n\\ttraining.add_argument('-x', '--experiment',\\n\\t\\t\\t\\t\\t\\t default=default_config['experiment'], choices=EXPERIMENTS,\\n\\t\\t\\t\\t\\t\\t help='Predefined experiments to run. If not `custom` this will overwrite some other arguments.')\\n\\ttraining.add_argument('-e', '--epochs', type=int,\\n\\t\\t\\t\\t\\t\\t default=default_config['epochs'],\\n\\t\\t\\t\\t\\t\\t help='Maximum number of epochs to run for.')\\n\\ttraining.add_argument('-b', '--batch-size', type=int,\\n\\t\\t\\t\\t\\t\\t default=default_config['batch_size'],\\n\\t\\t\\t\\t\\t\\t help='Batch size for training.')\\n\\ttraining.add_argument('--lr', type=float, default=default_config['lr'],\\n\\t\\t\\t\\t\\t\\t help='Learning rate.')\\n\\ttraining.add_argument('-g', '--gamma', type = float, default = 1., help = 'gamma for var')\\n\\n\\t# Model Options\\n\\tmodel = parser.add_argument_group('Model specfic options')\\n\\tmodel.add_argument('-m', '--model-type',\\n\\t\\t\\t\\t\\t default=default_config['model'], choices=MODELS,\\n\\t\\t\\t\\t\\t help='Type of encoder and decoder to use.')\\n\\tmodel.add_argument('-z', '--latent-dim', type=int,\\n\\t\\t\\t\\t\\t default=default_config['latent_dim'],\\n\\t\\t\\t\\t\\t help='Dimension of the latent variable.')\\n\\tmodel.add_argument('-l', '--loss',\\n\\t\\t\\t\\t\\t default=default_config['loss'], choices=LOSSES,\\n\\t\\t\\t\\t\\t help=\\\"Type of VAE loss function to use.\\\")\\n\\tmodel.add_argument('-r', '--rec-dist', default=default_config['rec_dist'],\\n\\t\\t\\t\\t\\t choices=RECON_DIST,\\n\\t\\t\\t\\t\\t help=\\\"Form of the likelihood ot use for each pixel.\\\")\\n\\tmodel.add_argument('-a', '--reg-anneal', type=float,\\n\\t\\t\\t\\t\\t default=default_config['reg_anneal'],\\n\\t\\t\\t\\t\\t help=\\\"Number of annealing steps where gradually adding the regularisation. What is annealed is specific to each loss.\\\")\\n\\n\\t# Loss Specific Options\\n\\tbetaH = parser.add_argument_group('BetaH specific parameters')\\n\\tbetaH.add_argument('--betaH-B', type=float,\\n\\t\\t\\t\\t\\t default=default_config['betaH_B'],\\n\\t\\t\\t\\t\\t help=\\\"Weight of the KL (beta in the paper).\\\")\\n\\n\\tbetaB = parser.add_argument_group('BetaB specific parameters')\\n\\tbetaB.add_argument('--betaB-initC', type=float,\\n\\t\\t\\t\\t\\t default=default_config['betaB_initC'],\\n\\t\\t\\t\\t\\t help=\\\"Starting annealed capacity.\\\")\\n\\tbetaB.add_argument('--betaB-finC', type=float,\\n\\t\\t\\t\\t\\t default=default_config['betaB_finC'],\\n\\t\\t\\t\\t\\t help=\\\"Final annealed capacity.\\\")\\n\\tbetaB.add_argument('--betaB-G', type=float,\\n\\t\\t\\t\\t\\t default=default_config['betaB_G'],\\n\\t\\t\\t\\t\\t help=\\\"Weight of the KL divergence term (gamma in the paper).\\\")\\n\\n\\tfactor = parser.add_argument_group('factor VAE specific parameters')\\n\\tfactor.add_argument('--factor-G', type=float,\\n\\t\\t\\t\\t\\t\\tdefault=default_config['factor_G'],\\n\\t\\t\\t\\t\\t\\thelp=\\\"Weight of the TC term (gamma in the paper).\\\")\\n\\tfactor.add_argument('--lr-disc', type=float,\\n\\t\\t\\t\\t\\t\\tdefault=default_config['lr_disc'],\\n\\t\\t\\t\\t\\t\\thelp='Learning rate of the discriminator.')\\n\\n\\tbtcvae = parser.add_argument_group('beta-tcvae specific parameters')\\n\\tbtcvae.add_argument('--btcvae-A', type=float,\\n\\t\\t\\t\\t\\t\\tdefault=default_config['btcvae_A'],\\n\\t\\t\\t\\t\\t\\thelp=\\\"Weight of the MI term (alpha in the paper).\\\")\\n\\tbtcvae.add_argument('--btcvae-G', type=float,\\n\\t\\t\\t\\t\\t\\tdefault=default_config['btcvae_G'],\\n\\t\\t\\t\\t\\t\\thelp=\\\"Weight of the dim-wise KL term (gamma in the paper).\\\")\\n\\tbtcvae.add_argument('--btcvae-B', type=float,\\n\\t\\t\\t\\t\\t\\tdefault=default_config['btcvae_B'],\\n\\t\\t\\t\\t\\t\\thelp=\\\"Weight of the TC term (beta in the paper).\\\")\\n\\n\\t# Learning options\\n\\tevaluation = parser.add_argument_group('Evaluation specific options')\\n\\tevaluation.add_argument('--is-eval-only', action='store_true',\\n\\t\\t\\t\\t\\t\\t\\tdefault=default_config['is_eval_only'],\\n\\t\\t\\t\\t\\t\\t\\thelp='Whether to only evaluate using precomputed model `name`.')\\n\\tevaluation.add_argument('--is-metrics', action='store_true',\\n\\t\\t\\t\\t\\t\\t\\tdefault=default_config['is_metrics'],\\n\\t\\t\\t\\t\\t\\t\\thelp=\\\"Whether to compute the disentangled metrcics. Currently only possible with `dsprites` as it is the only dataset with known true factors of variations.\\\")\\n\\tevaluation.add_argument('--no-test', action='store_true',\\n\\t\\t\\t\\t\\t\\t\\tdefault=default_config['no_test'],\\n\\t\\t\\t\\t\\t\\t\\thelp=\\\"Whether not to compute the test losses.`\\\")\\n\\tevaluation.add_argument('--eval-batchsize', type=int,\\n\\t\\t\\t\\t\\t\\t\\tdefault=default_config['eval_batchsize'],\\n\\t\\t\\t\\t\\t\\t\\thelp='Batch size for evaluation.')\\n\\n\\targs = parser.parse_args(args_to_parse)\\n\\tif args.experiment != 'custom':\\n\\t\\tif args.experiment not in ADDITIONAL_EXP:\\n\\t\\t\\t# update all common sections first\\n\\t\\t\\tmodel, dataset = args.experiment.split(\\\"_\\\")\\n\\t\\t\\tcommon_data = get_config_section([CONFIG_FILE], \\\"Common_{}\\\".format(dataset))\\n\\t\\t\\tupdate_namespace_(args, common_data)\\n\\t\\t\\tcommon_model = get_config_section([CONFIG_FILE], \\\"Common_{}\\\".format(model))\\n\\t\\t\\tupdate_namespace_(args, common_model)\\n\\n\\t\\ttry:\\n\\t\\t\\texperiments_config = get_config_section([CONFIG_FILE], args.experiment)\\n\\t\\t\\tupdate_namespace_(args, experiments_config)\\n\\t\\texcept KeyError as e:\\n\\t\\t\\tif args.experiment in ADDITIONAL_EXP:\\n\\t\\t\\t\\traise e # only reraise if didn't use common section\\n\\n\\treturn args\",\n \"def init_argparser() -> ArgumentParser:\\n parser = ArgumentParser()\\n from_config = parser.add_argument_group('From config file', 'Provide full experiment setup via config file')\\n from_config.add_argument('-c', '--config', help='Path to json file containing classification config.')\\n from_cmd = parser.add_argument_group('From commandline', 'Specify experiment setup via commandline arguments')\\n\\n # Model options\\n from_cmd.add_argument(\\\"--recoding_type\\\", type=str, default=None,\\n choices=[\\\"mc_dropout\\\", \\\"surprisal\\\", \\\"ensemble\\\"],\\n help=\\\"Recoding model type used for trainign. Choices include recoding based on MC Dropout,\\\"\\n \\\"perplexity and anchored ensembles. If not specified, a vanilla model without recoding\\\"\\n \\\"is used.\\\")\\n from_cmd.add_argument(\\\"--step_type\\\", type=str, default=None, choices=[\\\"fixed\\\", \\\"mlp\\\", \\\"learned\\\"],\\n help=\\\"Specifies the way the step size is determined when using a recoding model.\\\")\\n from_cmd.add_argument(\\\"--step_size\\\", type=float,\\n help=\\\"Step size for recoding in case the fixed step predictor is used.\\\")\\n from_cmd.add_argument(\\\"--embedding_size\\\", type=int, help=\\\"Dimensionality of word embeddings.\\\")\\n from_cmd.add_argument(\\\"--hidden_size\\\", type=int, help=\\\"Dimensionality of hidden states.\\\")\\n from_cmd.add_argument(\\\"--num_layers\\\", type=int, help=\\\"Number of network layers.\\\")\\n from_cmd.add_argument(\\\"--mc_dropout\\\", type=float, help=\\\"Dropout probability when estimating uncertainty.\\\")\\n from_cmd.add_argument(\\\"--dropout\\\", type=float, help=\\\"Dropout probability for model in general.\\\")\\n from_cmd.add_argument(\\\"--num_samples\\\", type=int, help=\\\"Number of samples used when estimating uncertainty.\\\")\\n\\n # Training options\\n from_cmd.add_argument(\\\"--weight_decay\\\", type=float, help=\\\"Weight decay parameter when estimating uncertainty.\\\")\\n from_cmd.add_argument(\\\"--prior_scale\\\", type=float,\\n help=\\\"Prior length scale. A lower scale signifies a prior belief that the input data is \\\"\\n \\\"distributed infrequently, a higher scale does the opposite.\\\")\\n from_cmd.add_argument(\\\"--learning_rate\\\", type=float, help=\\\"Learning rate during training.\\\")\\n from_cmd.add_argument(\\\"--batch_size\\\", type=int, help=\\\"Batch size during training.\\\")\\n from_cmd.add_argument(\\\"--num_epochs\\\", type=int, help=\\\"Number of training epochs.\\\")\\n from_cmd.add_argument(\\\"--clip\\\", type=float, help=\\\"Threshold for gradient clipping.\\\")\\n\\n # Corpus options\\n from_cmd.add_argument(\\\"--corpus_dir\\\", type=str, help=\\\"Directory to corpus files.\\\")\\n from_cmd.add_argument(\\\"--max_seq_len\\\", type=int, help=\\\"Maximum sentence length when reading in the corpora.\\\")\\n\\n # Screen output optins\\n from_cmd.add_argument(\\\"--print_every\\\", type=int, help=\\\"Batch interval at which training info should be printed.\\\")\\n from_cmd.add_argument(\\\"--eval_every\\\", type=int,\\n help=\\\"Epoch interval at which the model should be evaluated on validation set.\\\")\\n\\n # Model saving and logging options\\n from_cmd.add_argument(\\\"--model_name\\\", type=str, help=\\\"Model identifier.\\\")\\n from_cmd.add_argument(\\\"--model_save_path\\\", type=str,\\n help=\\\"Directory to which current best model should be saved to.\\\")\\n from_cmd.add_argument(\\\"--device\\\", type=str, default=\\\"cpu\\\", help=\\\"Device used for training.\\\")\\n from_cmd.add_argument(\\\"--log_dir\\\", type=str, help=\\\"Directory to write (tensorboard) logs to.\\\")\\n\\n return parser\",\n \"def train(args):\\n # Copy the project file.\\n # TODO: If the file exists, ask the user if it shall be deleted.\\n if os.path.isfile(args.outfile):\\n os.remove(args.outfile)\\n shutil.copyfile(args.train, args.outfile)\\n\\n # Create an ILP object for the project.\\n proj = ILP(args.outfile, args.cache, args.compression)\\n\\n # Do the autocontext loop.\\n autocontext(args.ilastik, proj, args.nloops, args.labeldataset, weights=args.weights, predict_file=args.predict_file)\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n subparsers = parser.add_subparsers(dest='mode')\\n\\n # Add sub-parser for feature extraction\\n parser_extract = subparsers.add_parser('extract')\\n parser_extract.add_argument('dataset',\\n choices=['training', 'validation', 'test'],\\n )\\n\\n # Add sub-parser for training\\n subparsers.add_parser('train')\\n\\n # Add sub-parser for inference\\n parser_predict = subparsers.add_parser('predict')\\n parser_predict.add_argument('dataset',\\n nargs='?',\\n choices=['validation', 'test'],\\n default='test',\\n )\\n\\n # Add sub-parser for evaluation\\n parser_evaluate = subparsers.add_parser('evaluate')\\n parser_evaluate.add_argument('task',\\n nargs='?',\\n choices=['tagging', 'sed', 'all'],\\n default='all',\\n )\\n parser_evaluate.add_argument('dataset',\\n nargs='?',\\n choices=['validation', 'test'],\\n default='test',\\n )\\n parser_evaluate.add_argument('--thresholds', action='store_true')\\n\\n args = parser.parse_args()\\n\\n if args.mode == 'extract':\\n extract(cfg.to_dataset(args.dataset))\\n elif args.mode == 'train':\\n train()\\n elif args.mode == 'predict':\\n predict(cfg.to_dataset(args.dataset))\\n elif args.mode == 'evaluate':\\n eval_all = args.task == 'all'\\n dataset = cfg.to_dataset(args.dataset)\\n if args.task == 'tagging' or eval_all:\\n evaluate_audio_tagging(dataset, args.thresholds)\\n if args.task == 'sed' or eval_all:\\n evaluate_sed(dataset)\",\n \"def main():\\n if len(sys.argv) == 3:\\n database_filepath, model_filepath = sys.argv[1:]\\n nltk.download(['punkt', 'wordnet'])\\n print('Loading data...\\\\n DATABASE: {}'.format(database_filepath))\\n X, Y, category_names = load_data(database_filepath)\\n X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)\\n\\n print('Building model...')\\n model = build_model()\\n\\n print('Training model...')\\n model.fit(X_train, Y_train)\\n\\n print('Evaluating model...')\\n evaluate_model(model, X_test, Y_test, category_names)\\n\\n print('Saving model...\\\\n MODEL: {}'.format(model_filepath))\\n save_model(model, model_filepath)\\n\\n print('Trained model saved!')\\n\\n else:\\n print('Please provide the filepath of the disaster messages database '\\\\\\n 'as the first argument and the filepath of the pickle file to '\\\\\\n 'save the model to as the second argument. \\\\n\\\\nExample: python '\\\\\\n 'train_classifier.py ../data/DisasterResponse.db classifier.pkl')\",\n \"def add_train_args(parser):\\n parser.register('type', 'bool', str2bool)\\n # Runtime environment\\n runtime = parser.add_argument_group('Environment')\\n runtime.add_argument('--no-cuda', type='bool', default=False,\\n help='Train on CPU, even if GPUs are available.')\\n runtime.add_argument('--gpu', type=int, default=-1,\\n help='Run on a specific GPU')\\n runtime.add_argument('--data-workers', type=int, default=5,\\n help='Number of subprocesses for data loading')\\n runtime.add_argument('--random-seed', type=int, default=1013,\\n help=('Random seed for all numpy/torch/cuda '\\n 'operations (for reproducibility)'))\\n runtime.add_argument('--num-epochs', type=int, default=40,\\n help='Train data iterations')\\n runtime.add_argument('--batch-size', type=int, default=32,\\n help='Batch size for training')\\n runtime.add_argument('--dev-batch-size', type=int, default=16,\\n help='Batch size for training')\\n\\n # Files\\n files = parser.add_argument_group('Filesystem')\\n files.add_argument('--model-dir', type=str, default=MODEL_DIR,\\n help='Directory for saved models/checkpoints/logs')\\n files.add_argument('--model-name', type=str, default='',\\n help='Unique model identifier (.mdl, .txt, .checkpoint)')\\n files.add_argument('--data-dir', type=str, default=DATA_DIR,\\n help='Directory of training/validation data')\\n files.add_argument('--train-file', type=str,\\n default='train_processed.jsonl',\\n help='Preprocessed train file')\\n files.add_argument('--dev-file', type=str,\\n default='dev_processed.jsonl',\\n help='Preprocessed dev file')\\n files.add_argument('--embed-dir', type=str, default=EMBED_DIR,\\n help='Directory of pre-trained embedding files')\\n files.add_argument('--embedding-file', type=str,\\n default='glove.840B.300d.txt',\\n help='Space-separated pretrained embeddings file')\\n\\n # Saving + loading\\n save_load = parser.add_argument_group('Saving/Loading')\\n save_load.add_argument('--checkpoint', type='bool', default=False,\\n help='Save model + optimizer state after each epoch')\\n save_load.add_argument('--pretrained', type=str, default='',\\n help='Path to a pretrained model to warm-start with')\\n\\n # General\\n general = parser.add_argument_group('General')\\n general.add_argument('--display-iter', type=int, default=25,\\n help='Log state after every <display_iter> epochs')\\n general.add_argument('--display-samples', type='bool', default=True,\\n help='Display top 5 samples in validation process.')\\n general.add_argument('--sort-by-len', type='bool', default=True,\\n help='Sort batches by length for speed')\\n \\n # Model architecture\\n model = parser.add_argument_group('Model Architecture')\\n model.add_argument('--decoder-type', type=str, default='copy',\\n help='Decoder architecture type')\\n model.add_argument('--vocab-limit', type=int, default=-1,\\n help='Limit for vocab creation')\\n model.add_argument('--use-extended-vocab', type='bool', default=True,\\n help='Use extended vocab for copying')\\n model.add_argument('--embedding-dim', type=int, default=300,\\n help='Embedding size if embedding_file is not given')\\n model.add_argument('--hidden-size', type=int, default=128,\\n help='Hidden size of RNN units')\\n model.add_argument('--rnn-type', type=str, default='lstm',\\n help='RNN type: LSTM, GRU, or RNN')\\n\\n # Optimization details\\n optim = parser.add_argument_group('Optimization')\\n optim.add_argument('--optimizer', type=str, default='adam',\\n help='Optimizer: sgd or adam')\\n optim.add_argument('--learning-rate', type=float, default=0.1,\\n help='Learning rate')\\n optim.add_argument('--weight-decay', type=float, default=0,\\n help='Weight decay factor')\\n optim.add_argument('--momentum', type=float, default=0,\\n help='Momentum factor')\\n optim.add_argument('--fix-embeddings', type='bool', default=True,\\n help='Keep word embeddings fixed (use pretrained)')\\n optim.add_argument('--rnn-padding', type='bool', default=False,\\n help='Explicitly account for padding in RNN encoding')\\n optim.add_argument('--max-length', type=int, default=30,\\n help='The max span allowed during decoding')\",\n \"def handle_arguments():\\n # process the command options\\n parser = argparse.ArgumentParser()\\n parser.add_argument('images', type=str, help='provide path in style: '\\n r'\\\"kaggle\\\\input\\\\bengaliai-cv19\\\\images.npy\\\"')\\n parser.add_argument('labels', type=str, help='provide path in style: '\\n r'\\\"kaggle\\\\input\\\\bengaliai-cv19\\\\labels.csv\\\"')\\n parser.add_argument('-t', '--test_ratio', type=float, default=0.2,\\n help='proportion of data for testing, default: 0.2')\\n parser.add_argument('-s', '--seed', type=int, default=None, help='seed '\\n 'used for consistent data splitting, default: None')\\n parser.add_argument('-a', '--data_augmentation', action='store_true',\\n help='switch to augment the images')\\n drop_info_fns = ['cutout', 'gridmask', 'None'] # info dropping algorithms\\n parser.add_argument('-d', '--drop_info_fn', type=str, choices=drop_info_fns,\\n default=None, help='whether cutout, GridMask, or no '\\n 'information dropping algorithm is used, default: None')\\n parser.add_argument('-c', '--class_balancing', action='store_true',\\n help='switch to perform class balancing')\\n parser.add_argument('-b', '--batch_size', type=int, default=32,\\n help='batch size of DataLoader objects, default: 32')\\n parser.add_argument('-l', '--label_smoothing', action='store_true',\\n help='switch to use soft targets in loss computation')\\n parser.add_argument('-e', '--epochs', type=int, default=50, help='number '\\n 'of iterations over training data, default: 50')\\n parser.add_argument('-m', '--model', type=str, default='model.pt',\\n help='path to save trained model, default: \\\"model.pt\\\"')\\n\\n # parse and print arguments\\n args = parser.parse_args()\\n for arg in vars(args):\\n print(f'{arg.upper()}: {getattr(args, arg)}')\\n\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Train a model for image classification (Keras)\\\",\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n parser.add_argument(\\n \\\"--rec-train\\\",\\n type=str,\\n default=\\\"../imgclsmob_data/imagenet_rec/train.rec\\\",\\n help=\\\"the training data\\\")\\n parser.add_argument(\\n \\\"--rec-train-idx\\\",\\n type=str,\\n default=\\\"../imgclsmob_data/imagenet_rec/train.idx\\\",\\n help='the index of training data')\\n parser.add_argument(\\n \\\"--rec-val\\\",\\n type=str,\\n default=\\\"../imgclsmob_data/imagenet_rec/val.rec\\\",\\n help=\\\"the validation data\\\")\\n parser.add_argument(\\n \\\"--rec-val-idx\\\",\\n type=str,\\n default=\\\"../imgclsmob_data/imagenet_rec/val.idx\\\",\\n help=\\\"the index of validation data\\\")\\n\\n parser.add_argument(\\n \\\"--model\\\",\\n type=str,\\n required=True,\\n help=\\\"type of model to use. see model_provider for options\\\")\\n parser.add_argument(\\n \\\"--use-pretrained\\\",\\n action=\\\"store_true\\\",\\n help=\\\"enable using pretrained model from github repo\\\")\\n parser.add_argument(\\n \\\"--dtype\\\",\\n type=str,\\n default=\\\"float32\\\",\\n help=\\\"data type for training\\\")\\n parser.add_argument(\\n \\\"--resume\\\",\\n type=str,\\n default=\\\"\\\",\\n help=\\\"resume from previously saved parameters if not None\\\")\\n parser.add_argument(\\n \\\"--resume-state\\\",\\n type=str,\\n default=\\\"\\\",\\n help=\\\"resume from previously saved optimizer state if not None\\\")\\n\\n parser.add_argument(\\n \\\"--input-size\\\",\\n type=int,\\n default=224,\\n help=\\\"size of the input for model\\\")\\n parser.add_argument(\\n \\\"--resize-inv-factor\\\",\\n type=float,\\n default=0.875,\\n help=\\\"inverted ratio for input image crop\\\")\\n\\n parser.add_argument(\\n \\\"--num-gpus\\\",\\n type=int,\\n default=0,\\n help=\\\"number of gpus to use\\\")\\n parser.add_argument(\\n \\\"-j\\\",\\n \\\"--num-data-workers\\\",\\n dest=\\\"num_workers\\\",\\n default=4,\\n type=int,\\n help=\\\"number of preprocessing workers\\\")\\n\\n parser.add_argument(\\n \\\"--batch-size\\\",\\n type=int,\\n default=512,\\n help=\\\"training batch size per device (CPU/GPU)\\\")\\n parser.add_argument(\\n \\\"--num-epochs\\\",\\n type=int,\\n default=120,\\n help=\\\"number of training epochs\\\")\\n parser.add_argument(\\n \\\"--start-epoch\\\",\\n type=int,\\n default=1,\\n help=\\\"starting epoch for resuming, default is 1 for new training\\\")\\n parser.add_argument(\\n \\\"--attempt\\\",\\n type=int,\\n default=1,\\n help=\\\"current number of training\\\")\\n\\n parser.add_argument(\\n \\\"--optimizer-name\\\",\\n type=str,\\n default=\\\"nag\\\",\\n help=\\\"optimizer name\\\")\\n parser.add_argument(\\n \\\"--lr\\\",\\n type=float,\\n default=0.1,\\n help=\\\"learning rate\\\")\\n parser.add_argument(\\n \\\"--momentum\\\",\\n type=float,\\n default=0.9,\\n help=\\\"momentum value for optimizer\\\")\\n parser.add_argument(\\n \\\"--wd\\\",\\n type=float,\\n default=0.0001,\\n help=\\\"weight decay rate\\\")\\n\\n parser.add_argument(\\n \\\"--log-interval\\\",\\n type=int,\\n default=50,\\n help=\\\"number of batches to wait before logging\\\")\\n parser.add_argument(\\n \\\"--save-interval\\\",\\n type=int,\\n default=4,\\n help=\\\"saving parameters epoch interval, best model will always be saved\\\")\\n parser.add_argument(\\n \\\"--save-dir\\\",\\n type=str,\\n default=\\\"\\\",\\n help=\\\"directory of saved models and log-files\\\")\\n parser.add_argument(\\n \\\"--logging-file-name\\\",\\n type=str,\\n default=\\\"train.log\\\",\\n help=\\\"filename of training log\\\")\\n\\n parser.add_argument(\\n \\\"--seed\\\",\\n type=int,\\n default=-1,\\n help=\\\"Random seed to be fixed\\\")\\n parser.add_argument(\\n \\\"--log-packages\\\",\\n type=str,\\n default=\\\"keras\\\",\\n help=\\\"list of python packages for logging\\\")\\n parser.add_argument(\\n \\\"--log-pip-packages\\\",\\n type=str,\\n default=\\\"keras, keras-mxnet, keras-applications, keras-preprocessing\\\",\\n help=\\\"list of pip packages for logging\\\")\\n args = parser.parse_args()\\n return args\",\n \"def main(args):\\n\\n # Labels to be used in the experiment.\\n task_ids = {Labels.hotness.value: LossTypes.mse,\\n Labels.tempo.value: LossTypes.mse,\\n Labels.loudness.value: LossTypes.mse}\\n\\n # Get the training, validation and testing set data and ground-truths\\n x_train, x_validate, x_test, y_train, y_validate, y_test = fetch_data(task_ids)\\n\\n exp = Experiment(expt_name=args.experiment_name, task_ids=task_ids, x_train=x_train, x_validate=x_validate,\\n x_test=x_test, y_train=y_train, y_validate=y_validate, y_test=y_test,\\n model_class=LowLevelSharingModel, learning_rate=args.learning_rate,\\n batch_size=args.batch_size, num_epochs=args.num_epochs)\\n exp.initialize_network()\\n exp.train()\\n sys.stderr.write(\\\"------\\\\n\\\")\\n sys.stderr.write(\\\"Training complete. Logs, outputs, and model saved in \\\" + os.getcwd() + \\\"\\\\n\\\")\",\n \"def setup(args):\\n cfg = get_cfg()\\n\\n cfg.merge_from_file(model_zoo.get_config_file(args.model_zoo))\\n cfg.DATASETS.TRAIN = (args.train_dataset, )\\n cfg.DATASETS.TEST = (args.test_dataset, )\\n cfg.DATALOADER.NUM_WORKERS = args.num_workers\\n cfg.OUTPUT_DIR = args.output_dir\\n os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)\\n\\n cfg.image_w = args.size[0]\\n cfg.image_h = args.size[1]\\n\\n cfg.MODEL.WEIGHTS = args.model_zoo_weights\\n cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = args.roi_thresh # set a custom testing threshold\\n\\n default_setup(cfg, args)\\n return cfg\",\n \"def predict_args():\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument('image_path',\\n help=\\\"Path to the image file\\\")\\n\\n parser.add_argument('checkpoint',\\n default='checkpoint.pth',\\n help=\\\"Path to the model checkpoint\\\")\\n\\n parser.add_argument('--top_k',\\n dest='top_k',\\n default=5,\\n help=\\\"Return top K most likely classes\\\",\\n type=int)\\n\\n parser.add_argument('--category_names',\\n dest='category_names',\\n default='cat_to_name.json',\\n help='Use a mapping of categories to real names: '\\n )\\n\\n parser.add_argument('--gpu', action='store_true',\\n dest='gpu',\\n help='Activate GPU')\\n\\n result = parser.parse_args()\\n\\n return result\",\n \"def parse_args():\\n hpo_warning = 'Flag overwrites config value if set, used for HPO and PBT runs primarily'\\n parser = argparse.ArgumentParser('train.py')\\n add_arg = parser.add_argument\\n add_arg('config', nargs='?', default='configs/hello.yaml')\\n add_arg('-d', '--distributed', choices=['ddp-file', 'ddp-mpi', 'cray'])\\n add_arg('-v', '--verbose', action='store_true')\\n add_arg('--ranks-per-node', default=8)\\n add_arg('--gpu', type=int)\\n add_arg('--rank-gpu', action='store_true')\\n add_arg('--resume', action='store_true', help='Resume from last checkpoint')\\n add_arg('--show-config', action='store_true')\\n add_arg('--interactive', action='store_true')\\n add_arg('--output-dir', help='override output_dir setting')\\n add_arg('--seed', type=int, default=0, help='random seed')\\n add_arg('--fom', default=None, choices=['last', 'best'],\\n help='Print figure of merit for HPO/PBT')\\n add_arg('--n-train', type=int, help='Override number of training samples')\\n add_arg('--n-valid', type=int, help='Override number of validation samples')\\n add_arg('--batch-size', type=int, help='Override batch size. %s' % hpo_warning)\\n add_arg('--n-epochs', type=int, help='Specify subset of total epochs to run')\\n add_arg('--real-weight', type=float, default=None,\\n help='class weight of real to fake edges for the loss. %s' % hpo_warning)\\n add_arg('--lr', type=float, default=None,\\n help='Learning rate. %s' % hpo_warning)\\n add_arg('--hidden-dim', type=int, default=None,\\n help='Hidden layer dimension size. %s' % hpo_warning)\\n add_arg('--n-graph-iters', type=int, default=None,\\n help='Number of graph iterations. %s' % hpo_warning)\\n add_arg('--weight-decay', type=float)\\n return parser.parse_args()\",\n \"def main(opts):\\n\\n # Create a dataloader for the training images\\n train_dataloader, _ = get_emoji_loader(opts.emoji, opts)\\n\\n # Create checkpoint and sample directories\\n utils.create_dir(opts.checkpoint_dir)\\n utils.create_dir(opts.sample_dir)\\n\\n train(train_dataloader, opts)\",\n \"def MachineClassifier(options, args):\\n\\n # Check for setup file in array args:\\n if (len(args) >= 1) or (options.configfile):\\n if args: config = args[0]\\n elif options.configfile: config = options.configfile\\n print swap.doubledashedline\\n print swap.ML_hello\\n print swap.doubledashedline\\n print \\\"ML: taking instructions from\\\",config\\n else:\\n print MachineClassifier.__doc__\\n return\\n\\n tonights = swap.Configuration(config)\\n \\n # Read the pickled random state file\\n random_file = open(tonights.parameters['random_file'],\\\"r\\\");\\n random_state = cPickle.load(random_file);\\n random_file.close();\\n np.random.set_state(random_state);\\n\\n\\n time = tonights.parameters['start']\\n print time\\n\\n # Get the machine threshold (make retirement decisions)\\n threshold = tonights.parameters['machine_threshold']\\n prior = tonights.parameters['prior']\\n\\n # Get list of evaluation metrics and criteria \\n eval_metrics = tonights.parameters['evaluation_metrics']\\n \\n # How much cross-validation should we do? \\n cv = tonights.parameters['cross_validation']\\n\\n survey = tonights.parameters['survey']\\n\\n #----------------------------------------------------------------------\\n # read in the metadata for all subjects (Test or Training sample?)\\n storage = swap.read_pickle(tonights.parameters['metadatafile'], 'metadata')\\n subjects = storage.subjects\\n\\n #----------------------------------------------------------------------\\n # read in the SWAP collection\\n sample = swap.read_pickle(tonights.parameters['samplefile'],'collection')\\n\\n #----------------------------------------------------------------------\\n # read in or create the ML collection\\n MLsample = swap.read_pickle(tonights.parameters['MLsamplefile'],\\n 'MLcollection')\\n\\n # read in or create the ML bureau for machine agents (history)\\n MLbureau = swap.read_pickle(tonights.parameters['MLbureaufile'],'bureau')\\n #if not tonights.parameters['MLbureaufile']:\\n # MLbureaufile = swap.get_new_filename(tonights.parameters,'bureau','ML')\\n # tonights.parameters['MLbureaufile'] = MLbureaufile\\n\\n #MLbureau = swap.read_pickle(tonights.parameters['MLbureaufile'],'bureau')\\n\\n\\n #----------------------------------------------------------------------- \\n # SELECT TRAINING & VALIDATION SAMPLES \\n #-----------------------------------------------------------------------\\n # TO DO: training sample should only select those which are NOT part of \\n # validation sample (Nair catalog objects) 2/22/16\\n\\n train_sample = storage.fetch_subsample(sample_type='train',\\n class_label='GZ2_label')\\n \\\"\\\"\\\" Notes about the training sample:\\n # this will select only those which have my morphology measured for them\\n # AND which have a true \\\"answer\\\" according to GZ2\\n # Eventually we could open this up to include the ~10k that aren't in the \\n # GZ Main Sample but I think, for now, we should reduce ourselves to this\\n # stricter sample so that we always have back-up \\\"truth\\\" for each galaxy.\\n \\\"\\\"\\\"\\n\\n try:\\n train_meta, train_features = ml.extract_features(train_sample)\\n original_length = len(train_meta)\\n\\n except TypeError:\\n print \\\"ML: can't extract features from subsample.\\\"\\n print \\\"ML: Exiting MachineClassifier.py\\\"\\n sys.exit()\\n\\n else:\\n # TODO: consider making this part of SWAP's duties? \\n # 5/18/16: Only use those subjects which are no longer on the prior\\n off_the_fence = np.where(train_meta['SWAP_prob']!=prior)\\n train_meta = train_meta[off_the_fence]\\n train_features = train_features[off_the_fence]\\n train_labels = np.array([1 if p > prior else 0 for p in \\n train_meta['SWAP_prob']])\\n\\n #train_labels = train_meta['Nair_label'].filled()\\n\\n shortened_length = len(train_meta)\\n print \\\"ML: found a training sample of %i subjects\\\"%shortened_length\\n removed = original_length - shortened_length\\n print \\\"ML: %i subjects had prior probability and were removed\\\"%removed\\n \\n\\n valid_sample = storage.fetch_subsample(sample_type='valid',\\n class_label='Expert_label')\\n try:\\n valid_meta, valid_features = ml.extract_features(valid_sample)\\n except:\\n print \\\"ML: there are no subjects with the label 'valid'!\\\"\\n else:\\n valid_labels = valid_meta['Expert_label'].filled()\\n print \\\"ML: found a validation sample of %i subjects\\\"%len(valid_meta)\\n\\n # ---------------------------------------------------------------------\\n # Require a minimum size training sample [Be reasonable, my good man!]\\n # ---------------------------------------------------------------------\\n if len(train_sample) < 10000: \\n print \\\"ML: training sample is too small to be worth anything.\\\"\\n print \\\"ML: Exiting MachineClassifier.py\\\"\\n sys.exit()\\n \\n else:\\n print \\\"ML: training sample is large enough to give it a shot.\\\"\\n\\n # TODO: LOOP THROUGH DIFFERENT MACHINES? \\n # 5/12/16 -- no... need to make THIS a class and create multiple \\n # instances? Each one can be passed an instance of a machine?\\n\\n # Machine can be trained to maximize/minimize different metrics\\n # (ACC, completeness, purity, etc. Have a list of acceptable ones.)\\n # Minimize a Loss function (KNC doesn't have a loss fcn). \\n for metric in eval_metrics:\\n \\n # REGISTER Machine Classifier\\n # Construct machine name --> Machine+Metric? For now: KNC\\n machine = 'KNC'\\n machine = 'RF'\\n Name = machine+'_'+metric\\n \\n # register an Agent for this Machine\\n # This \\\"Agent\\\" doesn't behave like a SW agent... at least not yet\\n\\n try: \\n test = MLbureau.member[Name]\\n except: \\n MLbureau.member[Name] = swap.Agent_ML(Name, metric)\\n \\n MLagent = MLbureau.member[Name]\\n\\n #--------------------------------------------------------------- \\n # TRAIN THE MACHINE; EVALUATE ON VALIDATION SAMPLE\\n #---------------------------------------------------------------\\n\\n # Now we run the machine -- need cross validation on whatever size \\n # training sample we have .. \\n \\n # Fixed until we build in other machine options\\n # Need to dynamically determine appropriate parameters...\\n\\n #max_neighbors = get_max_neighbors(train_features, cv)\\n #n_neighbors = np.arange(1, (cv-1)*max_neighbors/cv, 5, dtype=int)\\n #params = {'n_neighbors':n_neighbors, \\n # 'weights':('uniform','distance')}\\n\\n num_features = train_features.shape[1]\\n \\n min_features = int(round(np.sqrt(num_features)))\\n params = {'max_features':np.arange(min_features, num_features+1),\\n 'max_depth':np.arange(2,16)}\\n\\n # Create the model \\n # for \\\"estimator=XXX\\\" all you need is an instance of a machine -- \\n # any scikit-learn machine will do. However, non-sklearn machines..\\n # That will be a bit trickier! (i.e. Phil's conv-nets)\\n general_model = GridSearchCV(estimator=RF(n_estimators=30), \\n param_grid=params, n_jobs=-1,\\n error_score=0, scoring=metric, cv=cv) \\n \\n # Train the model -- k-fold cross validation is embedded\\n print \\\"ML: Searching the hyperparameter space for values that \\\"\\\\\\n \\\"optimize the %s.\\\"%metric\\n trained_model = general_model.fit(train_features, train_labels)\\n\\n MLagent.model = trained_model\\n\\n # Test \\\"accuracy\\\" (metric of choice) on validation sample\\n score = trained_model.score(valid_features, valid_labels)\\n\\n ratio = np.sum(train_labels==1) / len(train_labels)\\n\\n MLagent.record_training(model_described_by=\\n trained_model.best_estimator_, \\n with_params=trained_model.best_params_, \\n trained_on=len(train_features), \\n with_ratio=ratio,\\n at_time=time, \\n with_train_score=trained_model.best_score_,\\n and_valid_score=trained_model.score(\\n valid_features, valid_labels))\\n\\n fps, tps, thresh = mtrx.roc_curve(valid_labels, \\n trained_model.predict_proba(valid_features)[:,1])\\n\\n metric_list = compute_binary_metrics(fps, tps)\\n ACC, TPR, FPR, FNR, TNR, PPV, FDR, FOR, NPV = metric_list\\n \\n MLagent.record_validation(accuracy=ACC, recall=TPR, precision=PPV,\\n false_pos=FPR, completeness_f=TNR,\\n contamination_f=NPV)\\n \\n #MLagent.plot_ROC()\\n\\n # ---------------------------------------------------------------\\n # IF TRAINED MACHINE PREDICTS WELL ON VALIDATION ....\\n # ---------------------------------------------------------------\\n if MLagent.is_trained(metric):\\n print \\\"ML: %s has successfully trained and will be applied \\\"\\\\\\n \\\"to the test sample.\\\"\\n\\n # Retrieve the test sample \\n test_sample = storage.fetch_subsample(sample_type='test',\\n class_label='GZ2_label')\\n \\\"\\\"\\\" Notes on test sample:\\n The test sample will, in real life, be those subjects for which\\n we don't have an answer a priori. However, for now, this sample\\n is how we will judge, in part, the performance of the overall\\n method. As such, we only include those subjects which have \\n GZ2 labels in the Main Sample.\\n \\\"\\\"\\\"\\n\\n try:\\n test_meta, test_features = ml.extract_features(test_sample)\\n except:\\n print \\\"ML: there are no subjects with the label 'test'!\\\"\\n print \\\"ML: which means there's nothing more to do!\\\"\\n else:\\n print \\\"ML: found test sample of %i subjects\\\"%len(test_meta)\\n\\n #----------------------------------------------------------- \\n # APPLY MACHINE TO TEST SAMPLE\\n #----------------------------------------------------------- \\n predictions = MLagent.model.predict(test_features)\\n probabilities = MLagent.model.predict_proba(test_features)\\n\\n print \\\"ML: %s has finished predicting labels for the test \\\"\\\\\\n \\\"sample.\\\"%Name\\n print \\\"ML: Generating performance report on the test sample:\\\"\\n\\n test_labels = test_meta['GZ2_label'].filled()\\n print mtrx.classification_report(test_labels, predictions)\\n\\n test_accuracy=mtrx.accuracy_score(test_labels,predictions)\\n test_precision=mtrx.precision_score(test_labels,predictions)\\n test_recall=mtrx.recall_score(test_labels,predictions)\\n\\n MLagent.record_evaluation(accuracy_score=test_accuracy,\\n precision_score=test_precision,\\n recall_score=test_recall,\\n at_time=time)\\n #pdb.set_trace()\\n \\n # ----------------------------------------------------------\\n # Save the predictions and probabilities to a new pickle\\n\\n test_meta['predictions'] = predictions\\n test_meta['probability_of_smooth'] = probabilities[:,1]\\n \\n filename=tonights.parameters['trunk']+'_'+Name+'.pickle'\\n swap.write_pickle(test_meta, filename)\\n\\n\\n\\n \\\"\\\"\\\"\\n for thing, pred, p in zip(test_meta, predictions,\\n probabitilies):\\n \\n # IF MACHINE P >= THRESHOLD, INSERT INTO SWAP COLLECTION\\n # --------------------------------------------------------\\n if (p >= threshold) or (1-p >= threshold):\\n print \\\"BOOM! WE'VE GOT A MACHINE-CLASSIFIED SUBJECT:\\\"\\n print \\\"Probability:\\\", p\\n # Initialize the subject in SWAP Collection\\n ID = thing['asset_id']\\n sample.member[ID] = swap.Subject(ID, str(s['SDSS_id']), \\n location=s['external_ref']) \\n sample.member[ID].retiredby = 'machine'\\n \\n # Flag subject as 'INACTIVE' / 'DETECTED' / 'REJECTED'\\n # ----------------------------------------------------------\\n if p >= threshold:\\n sample.member[str(s['id'])].state = 'inactive'\\n elif 1-p >= threshold:\\n sample.member[str(s['id'])].status = 'rejected' \\n\\n #\\\"\\\"\\\"\\n \\n \\n # If is hasn't been done already, save the current directory\\n # ---------------------------------------------------------------------\\n tonights.parameters['dir'] = os.getcwd()+'/'+tonights.parameters['trunk']\\n \\n if not os.path.exists(tonights.parameters['dir']):\\n os.makedirs(tonights.parameters['dir'])\\n\\n\\n # Repickle all the shits\\n # -----------------------------------------------------------------------\\n if tonights.parameters['repickle']:\\n\\n new_samplefile = swap.get_new_filename(tonights.parameters,'collection')\\n print \\\"ML: saving SWAP subjects to \\\"+new_samplefile\\n swap.write_pickle(sample, new_samplefile)\\n tonights.parameters['samplefile'] = new_samplefile\\n \\n new_samplefile=swap.get_new_filename(tonights.parameters,'MLcollection')\\n print \\\"ML: saving test sample subjects to \\\"+new_samplefile\\n swap.write_pickle(MLsample,new_samplefile)\\n tonights.parameters['MLsamplefile'] = new_samplefile\\n\\n new_bureaufile=swap.get_new_filename(tonights.parameters,'bureau','ML')\\n print \\\"ML: saving MLbureau to \\\"+new_bureaufile\\n swap.write_pickle(MLbureau, new_bureaufile)\\n tonights.parameters['MLbureaufile'] = new_bureaufile\\n\\n metadatafile = swap.get_new_filename(tonights.parameters,'metadata')\\n print \\\"ML: saving metadata to \\\"+metadatafile\\n swap.write_pickle(storage, metadatafile)\\n tonights.parameters['metadatafile'] = metadatafile\\n\\n\\n # UPDATE CONFIG FILE with pickle filenames, dir/trunk, and (maybe) new day\\n # ----------------------------------------------------------------------\\n configfile = config.replace('startup','update')\\n\\n # Random_file needs updating, else we always start from the same random\\n # state when update.config is reread!\\n random_file = open(tonights.parameters['random_file'],\\\"w\\\");\\n random_state = np.random.get_state();\\n cPickle.dump(random_state,random_file);\\n random_file.close();\\n swap.write_config(configfile, tonights.parameters)\\n\\n return\",\n \"def get_args(args):\\n argparser = argparse.ArgumentParser()\\n\\n argparser.add_argument('--config',\\n required=True,\\n help='config file with hyper parameters - in yaml format')\\n\\n def_log = None\\n argparser.add_argument('--log',\\n default=def_log,\\n help=f'log to this file (default {def_log}: log to screen)')\\n\\n def_checkpointfrq = 'epoch'\\n argparser.add_argument('--ckptfreq',\\n default=def_checkpointfrq,\\n help=f'how many examples passed in training before saving (default is once per epoch)')\\n\\n def_checkpointpath = 'saved_model/cp-{epoch:04d}.ckpt'\\n argparser.add_argument('--ckptpath',\\n type=str,\\n default=def_checkpointpath,\\n help=f'checkpoint path (default {def_checkpointpath})')\\n\\n def_impath = '../../rainforest/fixed-train-jpg/'\\n argparser.add_argument('--imagepath',\\n default=def_impath,\\n help=f'path to image directory (default {def_impath})')\\n\\n def_labelpath = '../../rainforest/train_v3.csv'\\n argparser.add_argument('--labelpath',\\n default=def_labelpath,\\n help=f'path to csv file for labels (defautlt {def_labelpath})')\\n\\n def_seed = 0\\n argparser.add_argument('-s',\\n '--seed',\\n default=def_seed,\\n type=int,\\n help=f'Set random seed to this number (default {def_seed})')\\n\\n def_dataseed = 0\\n argparser.add_argument('-ds',\\n '--dataseed',\\n default=def_dataseed,\\n type=int,\\n help=f'Set random seed for data split into train / valid / test sets')\\n\\n def_kernels = 4\\n argparser.add_argument('-k',\\n '--kernels',\\n default=def_kernels,\\n type=int,\\n help=f'Number of kernels in the CNN (default {def_kernels})')\\n def_ksize = 2\\n argparser.add_argument('-ks',\\n '--ksize',\\n default=def_ksize,\\n type=int,\\n help=f'Size of kernels in CNN (default {def_ksize})')\\n\\n def_f1 = 64\\n argparser.add_argument('-f1',\\n '--filter1',\\n default=def_f1,\\n type=int,\\n help=f'Number of kernels in the first VGG block (default {def_f1})')\\n\\n def_k1 = 3\\n argparser.add_argument('-ks1',\\n '--ksize1',\\n default=def_k1,\\n type=int,\\n help=f'Size of kernels in the first VGG block (default {def_k1})')\\n\\n def_s1 = 1\\n argparser.add_argument('-s1',\\n '--stride1',\\n default=def_s1,\\n type=int,\\n help=f'Stride in the first VGG block (default {def_s1})')\\n\\n def_p1 = 2\\n argparser.add_argument('-p1',\\n '--pool1',\\n default=def_p1,\\n type=int,\\n help=f'Max pooling size in the first VGG block (default {def_p1})')\\n\\n def_sp1 = 2\\n argparser.add_argument('-sp1',\\n '--stridepool1',\\n default=def_sp1,\\n type=int,\\n help=f'Pool stride in the first VGG block (default {def_sp1})')\\n\\n def_f2 = 128\\n argparser.add_argument('-f2',\\n '--filter2',\\n default=def_f2,\\n type=int,\\n help=f'Number of kernels in the second VGG block (default {def_f2})')\\n\\n def_k2 = 3\\n argparser.add_argument('-ks2',\\n '--ksize2',\\n default=def_k2,\\n type=int,\\n help=f'Size of kernels in the second VGG block (default {def_k2})')\\n\\n def_s2 = 1\\n argparser.add_argument('-s2',\\n '--stride2',\\n default=def_s2,\\n type=int,\\n help=f'Stride in the second VGG block (default {def_s2})')\\n\\n def_p2 = 2\\n argparser.add_argument('-p2',\\n '--pool2',\\n default=def_p2,\\n type=int,\\n help=f'Max pooling size in the second VGG block (default {def_p2})')\\n\\n def_sp2 = 2\\n argparser.add_argument('-sp2',\\n '--stridepool2',\\n default=def_sp2,\\n type=int,\\n help=f'Pool stride in the second VGG block (default {def_sp2})')\\n\\n def_f3 = 256\\n argparser.add_argument('-f3',\\n '--filter3',\\n default=def_f3,\\n type=int,\\n help=f'Number of kernels in the 3rd VGG block (default {def_f3})')\\n\\n def_k3 = 3\\n argparser.add_argument('-ks3',\\n '--ksize3',\\n default=def_k3,\\n type=int,\\n help=f'Size of kernels in the 3rd VGG block (default {def_k3})')\\n\\n def_s3 = 1\\n argparser.add_argument('-s3',\\n '--stride3',\\n default=def_s3,\\n type=int,\\n help=f'Stride in the 3rd VGG block (default {def_s3})')\\n\\n def_p3 = 2\\n argparser.add_argument('-p3',\\n '--pool3',\\n default=def_p3,\\n type=int,\\n help=f'Max pooling size in the 3rd VGG block (default {def_p3})')\\n\\n def_sp3 = 2\\n argparser.add_argument('-sp3',\\n '--stridepool3',\\n default=def_sp3,\\n type=int,\\n help=f'Pool stride in the 3rd VGG block (default {def_sp3})')\\n\\n def_f4 = 512\\n argparser.add_argument('-f4',\\n '--filter4',\\n default=def_f4,\\n type=int,\\n help=f'Number of kernels in the 4th VGG block (default {def_f4})')\\n\\n def_k4 = 3\\n argparser.add_argument('-ks4',\\n '--ksize4',\\n default=def_k4,\\n type=int,\\n help=f'Size of kernels in the 4th VGG block (default {def_k4})')\\n\\n def_s4 = 1\\n argparser.add_argument('-s4',\\n '--stride4',\\n default=def_s4,\\n type=int,\\n help=f'Stride in the 4th VGG block (default {def_s4})')\\n\\n def_p4 = 2\\n argparser.add_argument('-p4',\\n '--pool4',\\n default=def_p4,\\n type=int,\\n help=f'Max pooling size in the 4th VGG block (default {def_p4})')\\n\\n def_sp4 = 2\\n argparser.add_argument('-sp4',\\n '--stridepool4',\\n default=def_sp4,\\n type=int,\\n help=f'Pool stride in the 4th VGG block (default {def_sp4})')\\n\\n def_f5 = 512\\n argparser.add_argument('-f5',\\n '--filter5',\\n default=def_f5,\\n type=int,\\n help=f'Number of kernels in the 5th VGG block (default {def_f5})')\\n\\n def_k5 = 3\\n argparser.add_argument('-ks5',\\n '--ksize5',\\n default=def_k5,\\n type=int,\\n help=f'Size of kernels in the 5th VGG block (default {def_k5})')\\n\\n def_s5 = 1\\n argparser.add_argument('-s5',\\n '--stride5',\\n default=def_s5,\\n type=int,\\n help=f'Stride in the 5th VGG block (default {def_s5})')\\n\\n def_p5 = 2\\n argparser.add_argument('-p5',\\n '--pool5',\\n default=def_p5,\\n type=int,\\n help=f'Max pooling size in the 5th VGG block (default {def_p5})')\\n\\n def_sp5 = 2\\n argparser.add_argument('-sp5',\\n '--stridepool5',\\n default=def_sp5,\\n type=int,\\n help=f'Pool stride in the 5th VGG block (default {def_sp5})')\\n\\n def_dense1 = 4096\\n argparser.add_argument('-d1',\\n '--dense1',\\n default=def_dense1,\\n type=int,\\n help=f'Size of 1st dense layer in the VGG network (default {def_dense1})')\\n\\n def_dense2 = 4096\\n argparser.add_argument('-d2',\\n '--dense2',\\n default=def_dense2,\\n type=int,\\n help=f'Size of 2nd dense layer in the VGG network (default {def_dense2})')\\n\\n def_augmentpolicy = None\\n argparser.add_argument('-da',\\n '--dataaugment',\\n default=def_augmentpolicy,\\n type=str,\\n help=f'Data augmentation scheme based on AutoAugment Implemented options are \\\\n cifar10\\\\n imagenet \\\\n svhn \\\\n(default {def_augmentpolicy})')\\n\\n def_lr = 0.1\\n argparser.add_argument('-l',\\n '--lr',\\n default=def_lr,\\n type=float,\\n help=f'Learning rate (default {def_lr})')\\n\\n def_nepoch = 1\\n argparser.add_argument('-n',\\n '--nepoch',\\n default=def_nepoch,\\n type=int,\\n help=f'Number of epoch for training (default {def_nepoch})')\\n\\n def_patience = 10\\n argparser.add_argument('-p',\\n '--patience',\\n default=def_patience,\\n type=int,\\n help=f'Number of epoch without improvements before stopping training (default {def_patience})')\\n\\n def_batch = 4\\n argparser.add_argument('-b',\\n '--batchsize',\\n default=def_batch,\\n type=int,\\n help=f'batch size (default {def_batch})')\\n\\n args = argparser.parse_args(args)\\n return args\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser()\\n\\n ##################################################################\\n # Required parameters:\\n # ---------------------------------------------------------------\\n # - input/output dirs\\n # - model config (BertConfig / CharacterBertConfig)\\n # - a flag for pre-training CharacterBERT instead of BERT\\n ##################################################################\\n\\n parser.add_argument(\\n \\\"--hdf5_directory\\\",\\n type=str, required=True,\\n help=\\\\\\n \\\"Path to a directory contraining hdf5 files: training.*.hdf5, \\\"\\n \\\"validation.*.hdf5 and test.*.hdf5 files.\\\"\\n )\\n parser.add_argument(\\n \\\"--output_directory\\\",\\n type=str, required=True,\\n help=\\\\\\n \\\"Path to a directory where model checkpoints and metrics \\\"\\n \\\"will be saved.\\\"\\n )\\n parser.add_argument(\\n '--is_character_bert',\\n action='store_true',\\n help=\\\"Pre-train CharacterBERT instead of BERT.\\\"\\n )\\n\\n ##################################################################\\n # Other parameters\\n ##################################################################\\n # Parameters related to checkpoint handling\\n\\n parser.add_argument(\\n '--random_seed',\\n required=False, type=int, default=42,\\n help=\\\\\\n \\\"An intial seed for controlling some of the randomness.\\\"\\n )\\n parser.add_argument(\\n \\\"--local_rank\\\",\\n type=int, default=-1,\\n help=\\\\\\n \\\"Identifier of the current process within the distributed process \\\"\\n \\\"group. This is always `-1` when distributed training is deactivated.\\\"\\n )\\n parser.add_argument(\\n '--phase1_end_step',\\n type=int, default=7038,\\n help=\\\\\\n \\\"Number of training steps (backprops) in pre-training phase n°1: \\\"\\n \\\"`max_input_length=128`and `max_masked_tokens_per_input=20`.\\\"\\n )\\n parser.add_argument(\\n '--phase2',\\n action='store_true',\\n help=\\\\\\n \\\"Whether it is pre-training phase n°2: \\\"\\n \\\"`max_input_length=512`and `max_masked_tokens_per_input=80`.\\\"\\n )\\n parser.add_argument(\\n \\\"--init_checkpoint\\\",\\n type=str, default=None,\\n help=\\\"An initial checkpoint to start pre-training from.\\\"\\n )\\n parser.add_argument(\\n \\\"--resume_pretraining\\\",\\n action='store_true',\\n help=\\\"Whether to resume pre-training from a checkpoint.\\\"\\n )\\n parser.add_argument(\\n '--resume_step',\\n type=int, default=-1,\\n help=\\\\\\n \\\"Step to resume pre-training from. By default, this is `-1` \\\"\\n \\\"which results in resuming from the latest checkpoint available.\\\"\\n )\\n\\n ##################################################################\\n # Training hyperparameters\\n\\n parser.add_argument(\\n '--max_input_length',\\n required=False, type=int, default=128,\\n help=\\\\\\n \\\"Maximum sequence length for the model input. \\\"\\n \\\"Set this according to the input .hdf5 files contents.\\\"\\n )\\n parser.add_argument(\\n \\\"--max_masked_tokens_per_input\\\",\\n type=int, default=20,\\n help=\\\\\\n \\\"Hard limit on the number of tokens that can be masked. \\\"\\n \\\"Set this according to the input .hdf5 files contents.\\\"\\n )\\n parser.add_argument(\\n '--num_accumulation_steps',\\n type=int, default=512,\\n help=\\\\\\n \\\"Number of steps (forward passes) during which gradients are \\\"\\n \\\"accumulated before running a single model parameters update.\\\"\\n )\\n parser.add_argument(\\n \\\"--target_batch_size\\\",\\n type=int, default=8192,\\n help=\\\\\\n \\\"Target batch size post-accumulation (actual batch size is \\\"\\n \\\"derived from the number of accumulation steps). For example, if \\\"\\n \\\"`target_batch_size=32` and `num_accumulation_steps=4` then the \\\"\\n \\\"actual batch size will be `32/4 = 8`. This is useful for \\\"\\n \\\"achieving larger batch sizes while keeping an actual batch size \\\"\\n \\\"that is small enough to fit in memory.\\\"\\n )\\n parser.add_argument(\\n \\\"--learning_rate\\\",\\n type=float, default=6e-3,\\n help=\\\"The initial learning rate for the FusedLAMB optimizer.\\\"\\n )\\n parser.add_argument(\\n \\\"--warmup_proportion\\\",\\n type=float, default=0.2843,\\n help=\\\\\\n \\\"A value of X means that learning rate will increase during \\\"\\n \\\"(100*X)%% of pre-training steps before reaching the desired value \\\"\\n \\\"then decrease to 0 during the rest of pre-training steps.\\\"\\n )\\n parser.add_argument(\\n \\\"--total_steps\\\",\\n type=float, default=7038,\\n help=\\\"Total number of pre-training steps to perform.\\\"\\n )\\n\\n ##################################################################\\n # fp16 related parameters\\n\\n parser.add_argument(\\n '--fp16',\\n action='store_true',\\n help=\\\"Whether to use 16-bit float precision instead of 32-bit\\\"\\n )\\n parser.add_argument(\\n '--loss_scale',\\n type=float, default=0.0,\\n help='Loss scaling, positive power of 2 values can improve fp16 convergence.'\\n )\\n parser.add_argument(\\n '--allreduce_post_accumulation',\\n action='store_true',\\n help=\\\"Whether to do allreduces during gradient accumulation steps.\\\"\\n )\\n parser.add_argument(\\n '--allreduce_post_accumulation_fp16',\\n action='store_true',\\n help=\\\"Whether to do fp16 allreduce post accumulation.\\\")\\n\\n ##################################################################\\n # Logging and checkpointing\\n\\n parser.add_argument(\\n '--do_validation',\\n action='store_true',\\n help=\\\"Whether to run a validation step before checkpointing.\\\"\\n )\\n\\n parser.add_argument(\\n '--checkpoint_interval',\\n type=int, default=200,\\n help=\\\\\\n \\\"Number of model updates before a model checkpoint is saved.\\\"\\n )\\n parser.add_argument(\\n '--num_checkpoints_to_keep',\\n type=int, default=3,\\n help=\\\\\\n \\\"Maximum number of checkpoints to keep.\\\"\\n )\\n parser.add_argument(\\n '--log_freq',\\n type=float, default=1.0,\\n help='Frequency of logging loss.'\\n )\\n parser.add_argument(\\n '--tensorboard_id',\\n type=str, default='default',\\n help=\\\"Name of the directory where Tensorboard logs will be saved.\\\"\\n )\\n\\n args = parser.parse_args()\\n return args\",\n \"def initialize():\\n\\n parser = build_arg_parser()\\n par = parser.parse_known_args()[0]\\n\\n # Main arguments.\\n set('run_mode', par.run_mode)\\n set('input_files', par.image)\\n\\n # Sub-parser specific arguments.\\n if par.run_mode == 'train':\\n\\n set('batch_size', par.batch_size)\\n set('drop', par.drop)\\n set('epochs', par.epochs)\\n set('model', par.model)\\n set('level', par.level)\\n set('vfrac', par.vfrac)\\n set('data_augm', par.data_augm)\\n set('summary', par.summary)\\n set('outdir', par.outdir)\\n # Parameters associated with super-resolution. \\n set('super_resolution', par.super_resolution)\\n set('generator', par.generator)\\n set('discriminator', par.discriminator)\\n\\n elif par.run_mode == 'predict':\\n\\n set('tile_edge', par.edge)\\n set('model', par.model)\\n set('save_conv2d_kernels', par.save_conv2d_kernels) \\n set('save_conv2d_outputs', par.save_conv2d_outputs) \\n set('colormap', par.colormap)\\n # Parameters associated with super-resolution. \\n set('super_resolution', par.super_resolution)\\n set('generator', par.generator)\\n\\n elif par.run_mode == 'diagnose': \\n \\n set('model', par.model) \\n \\n else:\\n \\n pass\",\n \"def process_args_and_run(args, test_suite_iter: int = None):\\n # load global arguments\\n if args.save is not None and args.load is not None:\\n print(\\\"Can't load and save a model at the same time...\\\"\\n \\\"please choose just one of the two options\\\")\\n sys.exit(1)\\n\\n if test_suite_iter is None:\\n load_report_directory(args)\\n\\n #check if no parameters are given\\n if all([argument not in args for argument in ['depth',\\n 'impurity_method',\\n 'trees',\\n 'alpha',\\n 'hidden_layers',\\n 'max_iter',\\n 'verbose']]):\\n print(\\\"Please select at least one algorithm or test-suite to run this program\\\")\\n sys.exit()\\n\\n # Load dataset\\n train_data, train_labels = dataset.load_train_data()\\n test_data, test_labels = dataset.load_test_data()\\n # Random Forest\\n if all([param in args for param in ['depth', 'impurity_method', 'trees']]):\\n rf_classifier = RandomForest(n_estimators=args.trees, max_depth=args.depth, criterion=args.impurity_method,\\n report_directory=args.report_directory, test_suite_iter=test_suite_iter)\\n rf_classifier.run_classification(train_data, train_labels, test_data, test_labels,\\n args.save, args.load)\\n if all([param in args for param in ['alpha', 'hidden_layers', 'max_iter', 'verbose']]):\\n hidden_layers = []\\n # case when reading from a test suite where args.hidden_layers is just ['x y z'] and not ['x', 'y', 'z']\\n if len(args.hidden_layers) == 1:\\n args.hidden_layers = args.hidden_layers[0].split(\\\" \\\")\\n for layer in args.hidden_layers:\\n try:\\n hidden_layers.append(int(layer))\\n except ValueError:\\n print(f\\\"Can't set a hidden layer value of {layer}. Please enter an integer value\\\")\\n sys.exit(1)\\n args.hidden_layers = tuple(hidden_layers)\\n\\n mlp_classifier = MLP(hidden_layer_sizes=args.hidden_layers,\\n alpha=args.alpha,\\n max_iter=args.max_iter,\\n batch_size=args.batch_size,\\n verbose=args.verbose,\\n random_seed=args.random_seed,\\n report_directory=args.report_directory,\\n test_suite_iter=test_suite_iter)\\n\\n mlp_classifier.run_classification(train_data, train_labels, test_data, test_labels,\\n args.save, args.load)\",\n \"def training_config_parser():\\n parser = argparse.ArgumentParser()\\n\\n # xml_annotation_path, csv_annotation_path, oxford_annotations_path, oxford_images_path\\n # Dataset info\\n parser.add_argument(\\n \\\"--xml_annotation_path\\\", type=str, required=True\\n )\\n parser.add_argument(\\n \\\"--csv_annotation_path\\\", type=str, required=True\\n )\\n parser.add_argument(\\n \\\"--oxford_annotations_path\\\", type=str, required=True\\n )\\n parser.add_argument(\\n \\\"--oxford_images_path\\\", type=str, required=True\\n )\\n \\n parser.add_argument(\\n \\\"--background_class\\\",\\n type=int,\\n required=False,\\n default=0,\\n help=\\\"Default background class\\\",\\n )\\n\\n # What to train\\n parser.add_argument(\\n \\\"--train_backbone\\\",\\n action=\\\"store_true\\\",\\n required=False,\\n default=False,\\n help=\\\"Train backbone\\\",\\n )\\n parser.add_argument(\\n \\\"--train_transformers\\\",\\n action=\\\"store_true\\\",\\n required=False,\\n default=False,\\n help=\\\"Train transformers\\\",\\n )\\n parser.add_argument(\\n \\\"--train_nlayers\\\",\\n action=\\\"store_true\\\",\\n required=False,\\n default=False,\\n help=\\\"Train new layers\\\",\\n )\\n\\n # How to train\\n parser.add_argument(\\n \\\"--finetuning\\\",\\n default=False,\\n required=False,\\n action=\\\"store_true\\\",\\n help=\\\"Load the model weight before to train\\\",\\n )\\n parser.add_argument(\\n \\\"--batch_size\\\",\\n type=int,\\n required=False,\\n default=1,\\n help=\\\"Batch size to use to train the model\\\",\\n )\\n parser.add_argument(\\n \\\"--gradient_norm_clipping\\\",\\n type=float,\\n required=False,\\n default=0.1,\\n help=\\\"Gradient norm clipping\\\",\\n )\\n parser.add_argument(\\n \\\"--target_batch\\\",\\n type=int,\\n required=False,\\n default=None,\\n help=\\\"When running on a single GPU, aggretate the gradient before to apply.\\\",\\n )\\n\\n # Learning rate\\n parser.add_argument(\\n \\\"--backbone_lr\\\", type=bool, required=False, default=1e-5, help=\\\"Train backbone\\\"\\n )\\n parser.add_argument(\\n \\\"--transformers_lr\\\",\\n type=bool,\\n required=False,\\n default=1e-4,\\n help=\\\"Train transformers\\\",\\n )\\n parser.add_argument(\\n \\\"--nlayers_lr\\\", type=bool, required=False, default=1e-4, help=\\\"Train new layers\\\"\\n )\\n\\n return parser\",\n \"def config_and_train(self, sys_args):\\n \\n self.run_config_function(sys_args)\\n self.set_model_name('vgg_16')\\n self.set_trainable_and_exclude_scopes(constants.checkpoint_exclude_scopes,\\n constants.trainable_scopes)\\n self.set_optimizer('sgd')\\n self.set_max_number_of_steps(6000)\\n self.train_or_eval_net(sys_args)\",\n \"def main(args):\\n # read data from disk\\n X_train, X_val, X_test, Y_train, Y_val, Y_test = util_fruit.get_fruit_data()\\n\\n # build model\\n model = get_model(model_name=\\\"fruit_classifier\\\")\\n model.compile(\\n loss='categorical_crossentropy',\\n optimizer='adam',\\n metrics=['accuracy']\\n )\\n # augment training and testing data\\n datagen, X_train, X_val = augment_data(X_train, X_val)\\n\\n # save model and training history\\n model_folder_path = util_fruit.make_model_folder(model_name=MODEL_NAME)\\n\\n # Callbacks\\n callbacks=[]\\n cp_callback = ModelCheckpoint(\\\"{}/{}_callback.hdf5\\\".format(model_folder_path, MODEL_NAME),\\n monitor='val_loss',\\n verbose=0,\\n save_best_only=True,\\n save_weights_only=False,\\n period=10)\\n callbacks.append(cp_callback)\\n\\n # train model and save train history \\n batch_size = args.batch_size\\n epochs = args.epochs\\n history = train(model, X_train, X_val, Y_train, Y_val, callbacks, datagen, batch_size=batch_size, epochs=epochs)\\n\\n # winsound.Beep(5000, 10) # play sound after training completes\\n \\n \\n save_model(model=model, save_folder_path=model_folder_path, model_name=MODEL_NAME, model_ext=MODEL_EXT)\\n save_history(history=history, save_folder_path=model_folder_path)\\n\\n # evaluate model and save results-\\n evaluate(model=model, datagen=datagen, X_test=X_test, Y_test=Y_test, batch_size=batch_size, save_folder_path=model_folder_path)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser('train.py')\\n add_arg = parser.add_argument\\n add_arg('config', nargs='?', default='configs/hello.yaml')\\n add_arg('-d', '--distributed', choices=['ddp-file', 'ddp-mpi', 'cray'])\\n add_arg('-v', '--verbose', action='store_true')\\n add_arg('--ranks-per-node', default=8)\\n add_arg('--gpu', type=int)\\n add_arg('--rank-gpu', action='store_true')\\n add_arg('--resume', action='store_true', help='Resume from last checkpoint')\\n add_arg('--show-config', action='store_true')\\n add_arg('--interactive', action='store_true')\\n add_arg('--output-dir', help='override output_dir setting')\\n add_arg('--seed', type=int, default=0, help='random seed')\\n return parser.parse_args()\",\n \"def set_defaults(args):\\n # Check critical files exist\\n args.train_file = os.path.join(args.data_dir, args.train_file)\\n if not os.path.isfile(args.train_file):\\n raise IOError('No such file: %s' % args.train_file)\\n args.dev_file = os.path.join(args.data_dir, args.dev_file)\\n if not os.path.isfile(args.dev_file):\\n raise IOError('No such file: %s' % args.dev_file)\\n if args.embedding_file:\\n args.embedding_file = os.path.join(args.embed_dir, args.embedding_file)\\n if not os.path.isfile(args.embedding_file):\\n raise IOError('No such file: %s' % args.embedding_file)\\n\\n # Set model directory\\n subprocess.call(['mkdir', '-p', args.model_dir])\\n\\n # Set model name\\n if not args.model_name:\\n import uuid\\n import time\\n args.model_name = time.strftime(\\\"%Y%m%d-\\\") + str(uuid.uuid4())[:8]\\n\\n # Set log + model file names\\n args.log_file = os.path.join(args.model_dir, args.model_name + '.txt')\\n args.model_file = os.path.join(args.model_dir, args.model_name + '.pt')\\n\\n # Embeddings options\\n if args.embedding_file:\\n with open(args.embedding_file) as f:\\n dim = len(f.readline().strip().split(' ')) - 1\\n args.embedding_dim = dim\\n elif not args.embedding_dim:\\n raise RuntimeError('Either embedding_file or embedding_dim '\\n 'needs to be specified.')\\n\\n # Make sure fix_embeddings and embedding_file are consistent\\n if args.fix_embeddings:\\n if not (args.embedding_file or args.pretrained):\\n logger.warning('WARN: fix_embeddings set to False '\\n 'as embeddings are random.')\\n args.fix_embeddings = False\\n return args\",\n \"def __init__(self, **kwargs):\\n\\n # Identify the mode to start the model in\\n if \\\"x\\\" in kwargs and \\\"y\\\" in kwargs:\\n x = kwargs.get(\\\"x\\\")\\n y = kwargs.get(\\\"y\\\")\\n if \\\"model_name\\\" not in kwargs:\\n self.__mode = \\\"train\\\"\\n else:\\n self.__mode = \\\"retrain\\\"\\n elif \\\"model_name\\\" in kwargs:\\n self.__mode = \\\"test\\\"\\n else:\\n raise NameError(\\\"Cannot infer mode from arguments.\\\")\\n\\n print(\\\"Initializing model in %s mode.\\\" % self.__mode)\\n\\n if self.mode == \\\"train\\\":\\n # Infer input type from type(x)\\n if type(x[0]) == np.bytes_:\\n print(\\\"Input type is 'binary mols'.\\\")\\n self.__input_type = \\\"mols\\\" # binary RDKit mols\\n else:\\n print(\\\"Input type is 'molecular descriptors'.\\\")\\n self.__input_type = \\\"descriptors\\\" # other molecular descriptors\\n\\n # If scaling is required\\n if kwargs.get(\\\"scaling\\\", False) is True:\\n # Normalize the input\\n print(\\\"Applying scaling on input.\\\")\\n self.__scaler = StandardScaler()\\n x = self.__scaler.fit_transform(x)\\n else:\\n self.__scaler = None\\n\\n # If PCA is required\\n if kwargs.get(\\\"pca\\\", False) is True:\\n print(\\\"Applying PCA on input.\\\")\\n self.__pca = PCA(\\n n_components=x.shape[1]\\n ) # n_components=n_features for now\\n x = self.__pca.fit_transform(x)\\n else:\\n self.__pca = None\\n\\n self.__maxlen = (\\n kwargs.get(\\\"dataset_info\\\")[\\\"maxlen\\\"] + 10\\n ) # Extend maxlen to avoid breaks in training\\n self.__charset = kwargs.get(\\\"dataset_info\\\")[\\\"charset\\\"]\\n self.__dataset_name = kwargs.get(\\\"dataset_info\\\")[\\\"name\\\"]\\n self.__lstm_dim = kwargs.get(\\\"lstm_dim\\\", 256)\\n self.__h_activation = kwargs.get(\\\"h_activation\\\", \\\"relu\\\")\\n self.__bn = kwargs.get(\\\"bn\\\", True)\\n self.__bn_momentum = kwargs.get(\\\"bn_momentum\\\", 0.9)\\n self.__noise_std = kwargs.get(\\\"noise_std\\\", 0.01)\\n self.__td_dense_dim = kwargs.get(\\n \\\"td_dense_dim\\\", 0\\n ) # >0 squeezes RNN connections with Dense sandwiches\\n self.__batch_size = kwargs.get(\\\"batch_size\\\", 256)\\n self.__dec_layers = kwargs.get(\\\"dec_layers\\\", 2)\\n\\n if self.input_type == \\\"descriptors\\\":\\n self.__codelayer_dim = x.shape[1] # features\\n if \\\"codelayer_dim\\\" in kwargs:\\n print(\\n \\\"Ignoring requested codelayer_dim because it is inferred from the cardinality of the descriptors.\\\"\\n )\\n else:\\n self.__codelayer_dim = kwargs.get(\\\"codelayer_dim\\\", 128)\\n \\n # Create the left/right-padding vectorizers\\n self.__smilesvec1 = SmilesVectorizer(\\n canonical=False,\\n augment=True,\\n maxlength=self.maxlen,\\n charset=self.charset,\\n binary=True,\\n )\\n\\n self.__smilesvec2 = SmilesVectorizer(\\n canonical=False,\\n augment=True,\\n maxlength=self.maxlen,\\n charset=self.charset,\\n binary=True,\\n leftpad=False,\\n )\\n\\n # self.train_gen.next() #This line is needed to set train_gen.dims (to be fixed in HetSmilesGenerator)\\n self.__input_shape = self.smilesvec1.dims\\n self.__dec_dims = list(self.smilesvec1.dims)\\n self.__dec_dims[0] = self.dec_dims[0] - 1\\n self.__dec_input_shape = self.dec_dims\\n self.__output_len = self.smilesvec1.dims[0] - 1\\n self.__output_dims = self.smilesvec1.dims[-1]\\n\\n # Build all sub-models as untrained models\\n if self.input_type == \\\"mols\\\":\\n self.__build_mol_to_latent_model()\\n else:\\n self.__mol_to_latent_model = None\\n\\n self.__build_latent_to_states_model()\\n self.__build_batch_model()\\n\\n # Build data generators\\n self.__build_generators(x, y)\\n\\n # Retrain or Test mode\\n else:\\n self.__model_name = kwargs.get(\\\"model_name\\\")\\n\\n # Load the model\\n self.__load(self.model_name)\\n \\n if self.mode == \\\"retrain\\\":\\n # If scaling is required\\n if self.scaler is not None:\\n print(\\\"Applying scaling on input.\\\")\\n x = self.scaler.transform(x)\\n\\n # If PCA is required\\n if self.pca is not None:\\n print(\\\"Applying PCA on input.\\\")\\n x = self.pca.transform(x)\\n \\n # Build data generators\\n self.__build_generators(x, y)\\n\\n # Build full model out of the sub-models\\n self.__build_model()\\n\\n # Show the resulting full model\\n print(self.model.summary())\",\n \"def main():\\n if sys.argv[1] == 'train':\\n build_training_data()\\n main_trainer()\\n\\n if sys.argv[1] == 'predict' and len(sys.argv) > 2:\\n from predict import classification\\n from AdaboostPredict import decision_stumps\\n input_file = open(sys.argv[2])\\n data = input_file.readlines()\\n print(\\\"Decision Tree prediction\\\")\\n for i in data:\\n print(classification(i, i.strip().split()))\\n\\n print(\\\"\\\\nAdaboost prediction\\\")\\n\\n for i in data:\\n print(decision_stumps(i, i.strip().split()))\\n\\n elif sys.argv[1] == 'predict':\\n print('Wrong usage for prediction. Please supply a file after predict')\",\n \"def main(parameters_file, no_parameters_file, initialise, iterations, scenario, data_dir, output, output_every_iteration,\\n debug, repetitions, lockdown_file, use_cache, opencl, opencl_gui, opencl_gpu):\\n\\n # If we are running with opencl_gui then set opencl to True, so you only need to pass one flag\\n if opencl_gui:\\n opencl = True\\n\\n # First see if we're reading a parameters file or using command-line arguments.\\n if no_parameters_file:\\n print(\\\"Not reading a parameters file\\\")\\n else:\\n print(f\\\"Reading parameters file: {parameters_file}. \\\"\\n f\\\"Any other model-related command-line arguments are being ignored\\\")\\n with open(parameters_file, 'r') as f:\\n parameters = load(f, Loader=SafeLoader)\\n sim_params = parameters[\\\"microsim\\\"] # Parameters for the dynamic microsim (python)\\n calibration_params = parameters[\\\"microsim_calibration\\\"]\\n disease_params = parameters[\\\"disease\\\"] # Parameters for the disease model (r)\\n # TODO Implement a more elegant way to set the parameters and pass them to the model. E.g.:\\n # self.params, self.params_changed = Model._init_kwargs(params, kwargs)\\n # [setattr(self, key, value) for key, value in self.params.items()]\\n # Utility parameters\\n scenario = sim_params[\\\"scenario\\\"]\\n iterations = sim_params[\\\"iterations\\\"]\\n data_dir = sim_params[\\\"data-dir\\\"]\\n output = sim_params[\\\"output\\\"]\\n output_every_iteration = sim_params[\\\"output-every-iteration\\\"]\\n debug = sim_params[\\\"debug\\\"]\\n repetitions = sim_params[\\\"repetitions\\\"]\\n lockdown_file = sim_params[\\\"lockdown-file\\\"]\\n\\n # Check the parameters are sensible\\n if iterations < 1:\\n raise ValueError(\\\"Iterations must be > 1. If you want to just initialise the model and then exit, use\\\"\\n \\\"the --initialise flag\\\")\\n if repetitions < 1:\\n raise ValueError(\\\"Repetitions must be greater than 0\\\")\\n if (not output) and output_every_iteration:\\n raise ValueError(\\\"Can't choose to not output any data (output=False) but also write the data at every \\\"\\n \\\"iteration (output_every_iteration=True)\\\")\\n\\n print(f\\\"Running model with the following parameters:\\\\n\\\"\\n f\\\"\\\\tParameters file: {parameters_file}\\\\n\\\"\\n f\\\"\\\\tScenario directory: {scenario}\\\\n\\\"\\n f\\\"\\\\tInitialise (and then exit?): {initialise}\\\\n\\\"\\n f\\\"\\\\tNumber of iterations: {iterations}\\\\n\\\"\\n f\\\"\\\\tData dir: {data_dir}\\\\n\\\"\\n f\\\"\\\\tOutputting results?: {output}\\\\n\\\"\\n f\\\"\\\\tOutputting results at every iteration?: {output_every_iteration}\\\\n\\\"\\n f\\\"\\\\tDebug mode?: {debug}\\\\n\\\"\\n f\\\"\\\\tNumber of repetitions: {repetitions}\\\\n\\\"\\n f\\\"\\\\tLockdown file: {lockdown_file}\\\\n\\\",\\n f\\\"\\\\tUse cache?: {use_cache}\\\\n\\\",\\n f\\\"\\\\tUse OpenCL version?: {opencl}\\\\n\\\",\\n f\\\"\\\\tUse OpenCL GUI?: {opencl_gui}\\\\n\\\",\\n f\\\"\\\\tUse OpenCL GPU for processing?: {opencl_gpu}\\\\n\\\",\\n f\\\"\\\\tCalibration parameters: {'N/A (not reading parameters file)' if no_parameters_file else str(calibration_params)}\\\\n\\\",\\n f\\\"\\\\tDisease parameters: {'N/A (not reading parameters file)' if no_parameters_file else str(disease_params)}\\\\n\\\")\\n\\n # To fix file path issues, use absolute/full path at all times\\n # Pick either: get working directory (if user starts this script in place, or set working directory\\n # Option A: copy current working directory:\\n base_dir = os.getcwd() # get current directory\\n data_dir = os.path.join(base_dir, data_dir)\\n r_script_dir = os.path.join(base_dir, \\\"R\\\", \\\"py_int\\\")\\n\\n ### section for fetching data\\n if not os.path.isdir(data_dir):\\n\\n print(f\\\"No data directory detected.\\\")\\n\\n if os.path.isfile(data_dir + \\\".tar.gz\\\"):\\n print(f\\\"An archive file matching the name of the data directory has been detected!\\\")\\n print(f\\\"Unpacking this archive file now.\\\")\\n unpack_data(data_dir + \\\".tar.gz\\\")\\n \\n else:\\n print(f\\\"{data_dir} does not exist. Downloading devon_data.\\\")\\n data_setup()\\n\\n # Temporarily only want to use Devon MSOAs\\n # devon_msoas = pd.read_csv(os.path.join(data_dir, \\\"devon_msoas.csv\\\"), header=None,\\n # names=[\\\"x\\\", \\\"y\\\", \\\"Num\\\", \\\"Code\\\", \\\"Desc\\\"])\\n\\n # Prepare the QUANT api (for estimating school and retail destinations)\\n # we only need 1 QuantRampAPI object even if we do multiple iterations\\n # the quant_object object will be called by each microsim object\\n quant_path = os.path.join(data_dir, \\\"QUANT_RAMP\\\")\\n if not os.path.isdir(quant_path):\\n raise Exception(\\\"QUANT directory does not exist, please check input\\\")\\n quant_object = QuantRampAPI(quant_path)\\n\\n # args for population initialisation\\n population_args = {\\\"data_dir\\\": data_dir, \\\"debug\\\": debug,\\n \\\"quant_object\\\": quant_object}\\n\\n # args for Python/R Microsim. Use same arguments whether running 1 repetition or many\\n msim_args = {\\\"data_dir\\\": data_dir, \\\"r_script_dir\\\": r_script_dir, \\\"scen_dir\\\": scenario, \\\"output\\\": output,\\n \\\"output_every_iteration\\\": output_every_iteration}\\n\\n if not no_parameters_file: # When using a parameters file, include the calibration parameters\\n msim_args.update(**calibration_params) # python calibration parameters are unpacked now\\n # Also read the R calibration parameters (this is a separate section in the .yml file)\\n if disease_params is not None:\\n # (If the 'disease_params' section is included but has no calibration variables then we want to ignore it -\\n # it will be turned into an empty dictionary by the Microsim constructor)\\n msim_args[\\\"disease_params\\\"] = disease_params # R parameters kept as a dictionary and unpacked later\\n\\n # Temporarily use dummy data for testing\\n # data_dir = os.path.join(base_dir, \\\"dummy_data\\\")\\n # m = Microsim(data_dir=data_dir, testing=True, output=output)\\n\\n # cache to hold previously calculate population data\\n cache = InitialisationCache(cache_dir=os.path.join(data_dir, \\\"caches\\\"))\\n\\n # generate new population dataframes if we aren't using the cache, or if the cache is empty\\n if not use_cache or cache.is_empty():\\n print(f'Reading population data because {\\\"caching is disabled\\\" if not use_cache else \\\"the cache is empty\\\"}')\\n population = PopulationInitialisation(**population_args)\\n individuals = population.individuals\\n activity_locations = population.activity_locations\\n\\n # store in cache so we can load later\\n cache.store_in_cache(individuals, activity_locations)\\n else: # load from cache\\n print(\\\"Loading data from previous cache\\\")\\n individuals, activity_locations = cache.read_from_cache()\\n\\n # Calculate the time-activity multiplier (this is for implementing lockdown)\\n time_activity_multiplier = None\\n if lockdown_file != \\\"\\\":\\n print(f\\\"Implementing a lockdown with time activities from {lockdown_file}\\\")\\n time_activity_multiplier: pd.DataFrame = \\\\\\n PopulationInitialisation.read_time_activity_multiplier(os.path.join(data_dir, lockdown_file))\\n\\n # Select which model implementation to run\\n if opencl:\\n run_opencl_model(individuals, activity_locations, time_activity_multiplier, iterations, data_dir, base_dir,\\n opencl_gui, opencl_gpu, use_cache, initialise, calibration_params, disease_params)\\n else:\\n # If -init flag set the don't run the model. Note for the opencl model this check needs to happen\\n # after the snapshots have been created in run_opencl_model\\n if initialise:\\n print(\\\"Have finished initialising model. -init flag is set so not running it. Exitting\\\")\\n return\\n run_python_model(individuals, activity_locations, time_activity_multiplier, msim_args, iterations,\\n repetitions, parameters_file)\",\n \"def setup_args():\\n parser = ParlaiParser()\\n parser.add_argument(\\n '-n',\\n '--num-episodes',\\n default=-1,\\n type=int,\\n help='Total number of episodes to convert, -1 to convert all examples',\\n )\\n parser.add_argument(\\n '-of',\\n '--outfile',\\n default=None,\\n type=str,\\n help='Output file where to save, by default will be created in /tmp',\\n )\\n parser.add_argument(\\n '-s1id', '--speaker-0-id', type=str, help='Speaker id of agent who speaks first'\\n )\\n parser.add_argument(\\n '-s1id',\\n '--speaker-1-id',\\n type=str,\\n help='Speaker id of agent who speaks second',\\n )\\n parser.add_argument(\\n '--prepended-context',\\n type='bool',\\n default=False,\\n help='specify if the context is prepended to the first act',\\n )\\n parser.add_argument('-ltim', '--log-every-n-secs', type=float, default=10)\\n parser.set_defaults(datatype='train:ordered')\\n\\n return parser\",\n \"def add_train_args(parser):\\n\\n # Runtime environment\\n runtime = parser.add_argument_group('Environment')\\n runtime.add_argument('--dataset', type=str, default=\\\"searchqa\\\",\\n help='Dataset: searchqa, quasart or unftriviaqa')\\n runtime.add_argument('--base_dir', type=str, default=\\\".\\\",\\n help='base_dir of the pre-processing')\",\n \"def main():\\n\\n downloadData()\\n\\n parser = argparse.ArgumentParser(description=\\\"Train model or test model (default)\\\")\\n parser.add_argument(\\\"--train-model\\\", action=\\\"store_true\\\", default=False)\\n parser.add_argument(\\\"--num-channels\\\", type=int, help=\\\"Number of channels in lowest dimension\\\", default=8)\\n\\n arg_parser = parser.parse_args()\\n\\n if arg_parser.train_model:\\n encoder, generator = train(channels=arg_parser.num_channels)\\n torch.save(encoder.state_dict(), f\\\"../models/encoder_{arg_parser.num_channels}.model\\\")\\n torch.save(generator.state_dict(), f\\\"../models/generator_{arg_parser.num_channels}.model\\\")\\n else:\\n validate_models(VALIDATE_CHANNELS)\",\n \"def train(args):\\n print(args)\\n\\n # Run a training job\\n configs = LuxMatchConfigs_Default\\n\\n # Create a default opponent agent\\n opponent = Agent()\\n\\n # Create a RL agent in training mode\\n player = AgentPolicy(mode=\\\"train\\\")\\n\\n # Train the model\\n num_cpu = 1\\n if num_cpu == 1:\\n env = LuxEnvironment(configs=configs,\\n learning_agent=player,\\n opponent_agent=opponent)\\n else:\\n env = SubprocVecEnv([make_env(LuxEnvironment(configs=configs,\\n learning_agent=AgentPolicy(mode=\\\"train\\\"),\\n opponent_agent=opponent), i) for i in range(num_cpu)])\\n run_id = args.id\\n print(\\\"Run id %s\\\" % run_id)\\n\\n if args.path:\\n # by default previous model params are used (lr, batch size, gamma...)\\n model = PPO.load(args.path)\\n model.set_env(env=env)\\n\\n # Update the learning rate\\n model.lr_schedule = get_schedule_fn(args.learning_rate)\\n\\n # TODO: Update other training parameters\\n else:\\n model = PPO(\\\"MlpPolicy\\\",\\n env,\\n verbose=1,\\n tensorboard_log=\\\"./lux_tensorboard/\\\",\\n learning_rate=args.learning_rate,\\n gamma=args.gamma,\\n gae_lambda=args.gae_lambda,\\n batch_size=args.batch_size,\\n n_steps=args.n_steps\\n )\\n\\n print(\\\"Training model...\\\")\\n # Save a checkpoint every 1M steps\\n checkpoint_callback = CheckpointCallback(save_freq=1000000,\\n save_path='./models/',\\n name_prefix=f'rl_model_{run_id}')\\n model.learn(total_timesteps=args.step_count,\\n callback=checkpoint_callback) # 20M steps\\n if not os.path.exists(f'models/rl_model_{run_id}_{args.step_count}_steps.zip'):\\n model.save(path=f'models/rl_model_{run_id}_{args.step_count}_steps.zip')\\n print(\\\"Done training model.\\\")\\n\\n # Inference the model\\n print(\\\"Inference model policy with rendering...\\\")\\n saves = glob.glob(f'models/rl_model_{run_id}_*_steps.zip')\\n latest_save = sorted(saves, key=lambda x: int(x.split('_')[-2]), reverse=True)[0]\\n model.load(path=latest_save)\\n obs = env.reset()\\n for i in range(600):\\n action_code, _states = model.predict(obs, deterministic=True)\\n obs, rewards, done, info = env.step(action_code)\\n if i % 5 == 0:\\n print(\\\"Turn %i\\\" % i)\\n env.render()\\n\\n if done:\\n print(\\\"Episode done, resetting.\\\")\\n obs = env.reset()\\n print(\\\"Done\\\")\\n\\n '''\\n # Learn with self-play against the learned model as an opponent now\\n print(\\\"Training model with self-play against last version of model...\\\")\\n player = AgentPolicy(mode=\\\"train\\\")\\n opponent = AgentPolicy(mode=\\\"inference\\\", model=model)\\n env = LuxEnvironment(configs, player, opponent)\\n model = PPO(\\\"MlpPolicy\\\",\\n env,\\n verbose=1,\\n tensorboard_log=\\\"./lux_tensorboard/\\\",\\n learning_rate = 0.0003,\\n gamma=0.999,\\n gae_lambda = 0.95\\n )\\n\\n model.learn(total_timesteps=2000)\\n env.close()\\n print(\\\"Done\\\")\\n '''\",\n \"def main(args):\\r\\n # Parse inputs\\r\\n parser = _argparse()\\r\\n argp = parser.parse_args(args[1:])\\r\\n # Read training data\\r\\n sparse_training = sp.sparse.load_npz( argp.training_data )\\r\\n training_data = np.array( sparse_training.todense() )\\r\\n training_labels = np.array(pd.read_csv(argp.training_labels,index_col = 0 ))\\r\\n\\r\\n # Train classifier \\r\\n classifier = train_classifier.train_LR( training_data, training_labels, num_genes = argp.num_genes, pct_var = argp.pca_variance/100, save_results = False )\\r\\n\\r\\n training_predictions, training_probabilities = predict_cell_types( training_data, classifier )\\r\\n confusion_mat = pd.DataFrame(confusion_matrix( training_labels, training_predictions ),\\r\\n index = np.unique(training_labels), columns = np.unique(training_labels)).to_csv(\\r\\n \\\"results/classification/confusion_matrix.csv\\\")\\r\\n # Make predictions for all cells\\r\\n sparse_scRNA_expression = sp.sparse.load_npz( argp.test_data )\\r\\n scRNA_expression = np.array( sparse_scRNA_expression.todense() )\\r\\n predicted_cell_types, prediction_probabilities = predict_cell_types( scRNA_expression, classifier ) \\r\\n \\r\\n sequencing_metrics = pd.read_csv(\\\"data/combined/processed_metrics.csv\\\",index_col = 0)\\r\\n # Save outputs\\r\\n pd.DataFrame(prediction_probabilities, \\r\\n index = sequencing_metrics.index.values,\\r\\n columns = np.unique(predicted_cell_types) ).to_csv(\\\"results/classification/prediction_probabilities.csv\\\")\\r\\n pd.DataFrame(predicted_cell_types, \\r\\n index = sequencing_metrics.index.values,\\r\\n columns = [\\\"predicted_cell_type\\\"] ).to_csv(\\\"results/classification/predicted_cell_types.csv\\\")\",\n \"def main(_config, _run):\\n sacred.commands.print_config(_run)\\n dump_config_and_makefile()\\n prepare_and_train()\",\n \"def initialize_model_from_cfg(args, gpu_id=0):\\n model = model_builder.Generalized_RCNN()\\n model.eval()\\n\\n if args.cuda:\\n model.cuda()\\n\\n if args.load_ckpt:\\n load_name = args.load_ckpt\\n logger.info(\\\"loading checkpoint %s\\\", load_name)\\n checkpoint = torch.load(load_name, map_location=lambda storage, loc: storage)\\n net_utils.load_ckpt(model, checkpoint['model'])\\n\\n if args.load_detectron:\\n logger.info(\\\"loading detectron weights %s\\\", args.load_detectron)\\n load_caffe2_detectron_weights(model, args.load_detectron)\\n\\n model = mynn.DataParallel(model, cpu_keywords=['im_info', 'roidb'], minibatch=True)\\n\\n return model\",\n \"def __init__(self, args):\\n self.train_img_file = os.path.join(args.data_dir, args.train_img_file)\\n self.train_lbl_file = os.path.join(args.data_dir, args.train_lbl_file)\\n self.test_img_file = os.path.join(args.data_dir, args.test_img_file)\\n self.test_lbl_file = os.path.join(args.data_dir, args.test_lbl_file)\\n self.batch_size = args.batch_size\\n self.num_workers = args.data_workders\\n self.shuffle = True\\n self.dataset_name = args.dataset_name\\n self.pin_memory = False #args.cuda\\n\\n # check dataset files exist\\n files = [self.train_img_file, self.train_lbl_file,\\n self.test_img_file, self.test_lbl_file]\\n for file in files:\\n if not os.path.isfile(file):\\n msg = \\\"Data file not found. Please check the path \\\" +\\\\\\n \\\"or download files using scripts/download_files.py \\\"\\n raise IOError(msg)\",\n \"def main():\\n parser = argparse.ArgumentParser(description='Paperboy deep learning launcher')\\n\\n parser.add_argument('config', metavar='FILENAME', help='Configuration file for the run')\\n parser.add_argument('command', metavar='COMMAND', help='A command to run')\\n parser.add_argument('varargs', nargs='*', metavar='VARARGS', help='Extra options to the command')\\n parser.add_argument('-r', '--run_number', type=int, default=0, help=\\\"A run number\\\")\\n parser.add_argument('-d', '--device', default='cuda', help=\\\"A device to run the model on\\\")\\n parser.add_argument('-s', '--seed', type=int, default=None, help=\\\"Random seed for the project\\\")\\n parser.add_argument(\\n '-p', '--param', type=str, metavar='NAME=VALUE', action='append', default=[],\\n help=\\\"Configuration parameters\\\"\\n )\\n parser.add_argument(\\n '--continue', action='store_true', default=False, help=\\\"Continue previously started learning process\\\"\\n )\\n parser.add_argument(\\n '--profile', type=str, default=None, help=\\\"Profiler output\\\"\\n )\\n\\n args = parser.parse_args()\\n\\n model_config = ModelConfig.from_file(\\n args.config, args.run_number, continue_training=getattr(args, 'continue'), device=args.device, seed=args.seed,\\n params={k: v for (k, v) in (Parser.parse_equality(eq) for eq in args.param)}\\n )\\n\\n if model_config.project_dir not in sys.path:\\n sys.path.append(model_config.project_dir)\\n\\n multiprocessing_setting = model_config.provide_with_default('multiprocessing', default=None)\\n\\n if multiprocessing_setting:\\n # This needs to be called before any of PyTorch module is imported\\n multiprocessing.set_start_method(multiprocessing_setting)\\n\\n # Set seed already in the launcher\\n from vel.util.random import set_seed\\n set_seed(model_config.seed)\\n\\n model_config.banner(args.command)\\n\\n if args.profile:\\n print(\\\"[PROFILER] Running Vel in profiling mode, output filename={}\\\".format(args.profile))\\n import cProfile\\n import pstats\\n profiler = cProfile.Profile()\\n profiler.enable()\\n model_config.run_command(args.command, args.varargs)\\n profiler.disable()\\n\\n profiler.dump_stats(args.profile)\\n profiler.print_stats(sort='tottime')\\n\\n print(\\\"======================================================================\\\")\\n pstats.Stats(profiler).strip_dirs().sort_stats('tottime').print_stats(30)\\n print(\\\"======================================================================\\\")\\n pstats.Stats(profiler).strip_dirs().sort_stats('cumtime').print_stats(30)\\n else:\\n model_config.run_command(args.command, args.varargs)\\n\\n model_config.quit_banner()\",\n \"def main(args):\\n\\n print(now(), \\\"test_model.py main() running.\\\")\\n\\n test_log = \\\"clean_test_log.txt\\\"\\n to_log_file(args, args.output, test_log)\\n\\n # Set device\\n device = \\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\"\\n\\n ####################################################\\n # Dataset\\n if args.dataset.lower() == \\\"cifar10\\\":\\n transform_train = get_transform(args.normalize, args.train_augment)\\n transform_test = get_transform(args.normalize, False)\\n trainset = torchvision.datasets.CIFAR10(\\n root=\\\"./data\\\", train=True, download=True, transform=transform_train\\n )\\n trainloader = torch.utils.data.DataLoader(trainset, batch_size=128)\\n testset = torchvision.datasets.CIFAR10(\\n root=\\\"./data\\\", train=False, download=True, transform=transform_test\\n )\\n testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False)\\n elif args.dataset.lower() == \\\"cifar100\\\":\\n transform_train = get_transform(args.normalize, args.train_augment)\\n transform_test = get_transform(args.normalize, False)\\n trainset = torchvision.datasets.CIFAR100(\\n root=\\\"./data\\\", train=True, download=True, transform=transform_train\\n )\\n trainloader = torch.utils.data.DataLoader(trainset, batch_size=128)\\n testset = torchvision.datasets.CIFAR100(\\n root=\\\"./data\\\", train=False, download=True, transform=transform_test\\n )\\n testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False)\\n\\n elif args.dataset.lower() == \\\"tinyimagenet_first\\\":\\n transform_train = get_transform(\\n args.normalize, args.train_augment, dataset=args.dataset\\n )\\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\\n trainset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"train\\\",\\n transform=transform_train,\\n classes=\\\"firsthalf\\\",\\n )\\n trainloader = torch.utils.data.DataLoader(\\n trainset, batch_size=64, num_workers=1, shuffle=True\\n )\\n testset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"val\\\",\\n transform=transform_test,\\n classes=\\\"firsthalf\\\",\\n )\\n testloader = torch.utils.data.DataLoader(\\n testset, batch_size=64, num_workers=1, shuffle=False\\n )\\n\\n elif args.dataset.lower() == \\\"tinyimagenet_last\\\":\\n transform_train = get_transform(\\n args.normalize, args.train_augment, dataset=args.dataset\\n )\\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\\n trainset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"train\\\",\\n transform=transform_train,\\n classes=\\\"lasthalf\\\",\\n )\\n trainloader = torch.utils.data.DataLoader(\\n trainset, batch_size=64, num_workers=1, shuffle=True\\n )\\n testset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"val\\\",\\n transform=transform_test,\\n classes=\\\"lasthalf\\\",\\n )\\n testloader = torch.utils.data.DataLoader(\\n testset, batch_size=64, num_workers=1, shuffle=False\\n )\\n\\n elif args.dataset.lower() == \\\"tinyimagenet_all\\\":\\n transform_train = get_transform(\\n args.normalize, args.train_augment, dataset=args.dataset\\n )\\n transform_test = get_transform(args.normalize, False, dataset=args.dataset)\\n trainset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"train\\\",\\n transform=transform_train,\\n classes=\\\"all\\\",\\n )\\n trainloader = torch.utils.data.DataLoader(\\n trainset, batch_size=64, num_workers=1, shuffle=True\\n )\\n testset = TinyImageNet(\\n TINYIMAGENET_ROOT,\\n split=\\\"val\\\",\\n transform=transform_test,\\n classes=\\\"all\\\",\\n )\\n testloader = torch.utils.data.DataLoader(\\n testset, batch_size=64, num_workers=1, shuffle=False\\n )\\n\\n else:\\n print(\\\"Dataset not yet implemented. Exiting from test_model.py.\\\")\\n sys.exit()\\n\\n ####################################################\\n\\n ####################################################\\n # Network and Optimizer\\n net = get_model(args.model, args.dataset)\\n\\n # load model from path if a path is provided\\n if args.model_path is not None:\\n net = load_model_from_checkpoint(args.model, args.model_path, args.dataset)\\n else:\\n print(\\\"No model path provided, continuing test with untrained network.\\\")\\n net = net.to(device)\\n ####################################################\\n\\n ####################################################\\n # Test Model\\n training_acc = test(net, trainloader, device)\\n natural_acc = test(net, testloader, device)\\n print(now(), \\\" Training accuracy: \\\", training_acc)\\n print(now(), \\\" Natural accuracy: \\\", natural_acc)\\n stats = OrderedDict(\\n [\\n (\\\"model path\\\", args.model_path),\\n (\\\"model\\\", args.model),\\n (\\\"normalize\\\", args.normalize),\\n (\\\"augment\\\", args.train_augment),\\n (\\\"training_acc\\\", training_acc),\\n (\\\"natural_acc\\\", natural_acc),\\n ]\\n )\\n to_results_table(stats, args.output, \\\"clean_performance.csv\\\")\\n ####################################################\\n\\n return\",\n \"def main():\\n parser = make_argument_parser()\\n args = parser.parse_args()\\n\\n input_dirs = args.inputdirs\\n tf = args.factor\\n valid_chroms = args.validchroms\\n valid_input_dirs = args.validinputdirs\\n test_chroms = args.testchroms\\n epochs = args.epochs\\n patience = args.patience\\n learningrate = args.learningrate\\n seed = args.seed\\n utils.set_seed(seed)\\n dropout_rate = args.dropout\\n L = args.seqlen\\n w = args.motifwidth\\n utils.L = L\\n utils.w = w\\n utils.w2 = w/2\\n negatives = args.negatives\\n assert negatives > 0\\n meta = args.meta\\n gencode = args.gencode\\n motif = args.motif\\n\\n num_motifs = args.kernels\\n num_recurrent = args.recurrent\\n num_dense = args.dense\\n \\n features = ['bigwig'] \\n\\n if tf:\\n print 'Single-task training:', tf\\n singleTask = True\\n if meta:\\n print 'Including metadata features'\\n features.append('meta')\\n if gencode:\\n print 'Including genome annotations'\\n features.append('gencode')\\n else:\\n print 'Multi-task training'\\n singleTask = False\\n #Cannot use any metadata features\\n assert not meta\\n assert not gencode\\n\\n if args.outputdir is None:\\n clobber = True\\n output_dir = args.outputdirc\\n else:\\n clobber = False\\n output_dir = args.outputdir\\n\\n try: # adapted from dreme.py by T. Bailey\\n os.makedirs(output_dir)\\n except OSError as exc:\\n if exc.errno == errno.EEXIST:\\n if not clobber:\\n print >> sys.stderr, ('output directory (%s) already exists '\\n 'but you specified not to clobber it') % output_dir\\n sys.exit(1)\\n else:\\n print >> sys.stderr, ('output directory (%s) already exists '\\n 'so it will be clobbered') % output_dir\\n\\n print 'Loading genome'\\n genome = utils.load_genome()\\n if valid_input_dirs:\\n print 'You specified at least one validation input directory'\\n assert singleTask # This option only works for single-task training\\n print 'Loading ChIP labels'\\n if singleTask:\\n chip_bed_list, nonnegative_regions_bed_list = \\\\\\n utils.load_chip_singleTask(input_dirs, tf)\\n if valid_input_dirs:\\n valid_chip_bed_list, valid_nonnegative_regions_bed_list = \\\\\\n utils.load_chip_singleTask(valid_input_dirs, tf)\\n num_tfs = 1\\n else:\\n assert len(input_dirs) == 1 # multi-task training only supports one cell line\\n input_dir = input_dirs[0]\\n tfs, positive_windows, y_positive, nonnegative_regions_bed = \\\\\\n utils.load_chip_multiTask(input_dir)\\n num_tfs = len(tfs)\\n print 'Loading bigWig data'\\n bigwig_names, bigwig_files_list = utils.load_bigwigs(input_dirs)\\n num_bigwigs = len(bigwig_names)\\n if valid_input_dirs:\\n valid_bigwig_names, valid_bigwig_files_list = utils.load_bigwigs(valid_input_dirs)\\n assert valid_bigwig_names == bigwig_names\\n if not singleTask:\\n bigwig_files = bigwig_files_list[0]\\n if meta:\\n print 'Loading metadata features'\\n meta_names, meta_list = utils.load_meta(input_dirs)\\n if valid_input_dirs:\\n valid_meta_names, valid_meta_list = utils.load_load(valid_input_dirs)\\n assert valid_meta_names == meta_names\\n else:# meta option was not selected, pass empty metadata features to the functions\\n meta_list = [[] for bigwig_files in bigwig_files_list]\\n if valid_input_dirs:\\n valid_meta_list = [[] for bigwig_files in valid_bigwig_files_list]\\n \\n print 'Making features'\\n if singleTask:\\n if not valid_input_dirs: #validation directories not used, must pass placeholder values\\n valid_chip_bed_list = None\\n valid_nonnegative_regions_bed_list = None\\n valid_bigwig_files_list = None\\n valid_meta_list = None \\n datagen_train, datagen_valid = \\\\\\n utils.make_features_singleTask(chip_bed_list,\\n nonnegative_regions_bed_list, bigwig_files_list, bigwig_names,\\n meta_list, gencode, genome, epochs, negatives, valid_chroms, test_chroms, \\n valid_chip_bed_list, valid_nonnegative_regions_bed_list, \\n valid_bigwig_files_list, valid_meta_list)\\n else:\\n datagen_train, datagen_valid = \\\\\\n utils.make_features_multiTask(positive_windows, y_positive,\\n nonnegative_regions_bed, bigwig_files, bigwig_names,\\n genome, epochs, valid_chroms, test_chroms)\\n print 'Building model'\\n if num_recurrent == 0:\\n print 'You specified 0 LSTM units. Omitting BLSTM layer'\\n if num_recurrent < 0:\\n print 'You specified less than 0 LSTM units. Replacing BLSTM layer with global max-pooling layer'\\n if meta or gencode:\\n num_meta = 0\\n if meta:\\n num_meta = len(meta_names)\\n if gencode:\\n num_meta += 6\\n model = utils.make_meta_model(num_tfs, num_bigwigs, num_meta, num_motifs, num_recurrent, num_dense, dropout_rate)\\n else:\\n model = utils.make_model(num_tfs, num_bigwigs, num_motifs, num_recurrent, num_dense, dropout_rate)\\n\\n if motif:\\n assert singleTask # This option only works with single-task training\\n motifs_db = utils.load_motif_db('resources/HOCOMOCOv9.meme')\\n if tf in motifs_db:\\n print 'Injecting canonical motif'\\n pwm = motifs_db[tf]\\n pwm += 0.001\\n pwm = pwm / pwm.sum(axis=1)[:, np.newaxis]\\n pwm = np.log2(pwm/0.25)\\n utils.inject_pwm(model, pwm)\\n output_tf_file = open(output_dir + '/chip.txt', 'w')\\n if singleTask:\\n output_tf_file.write(\\\"%s\\\\n\\\" % tf)\\n else:\\n for tf in tfs:\\n output_tf_file.write(\\\"%s\\\\n\\\" % tf)\\n output_tf_file.close()\\n output_feature_file = open(output_dir + '/feature.txt', 'w')\\n for feature in features:\\n output_feature_file.write(\\\"%s\\\\n\\\" % feature)\\n output_feature_file.close()\\n output_bw_file = open(output_dir + '/bigwig.txt', 'w')\\n for bw in bigwig_names:\\n output_bw_file.write(\\\"%s\\\\n\\\" % bw)\\n output_bw_file.close()\\n if meta:\\n output_meta_file = open(output_dir + '/meta.txt', 'w')\\n for meta_name in meta_names:\\n output_meta_file.write(\\\"%s\\\\n\\\" % meta_name)\\n output_meta_file.close()\\n model_json = model.to_json()\\n output_json_file = open(output_dir + '/model.json', 'w')\\n output_json_file.write(model_json)\\n output_json_file.close()\\n train(datagen_train, datagen_valid, model, epochs, patience, learningrate, output_dir)\",\n \"def add_args(parser):\\n parser.add_argument(\\\"data\\\", metavar=\\\"FILE\\\", help=\\\"file prefix for data\\\")\\n parser.add_argument(\\n \\\"--num-classes0\\\",\\n type=int,\\n default=-1,\\n help=\\\"number of classes0\\\",\\n )\\n parser.add_argument(\\\"--no-shuffle\\\", action=\\\"store_true\\\", default=False)\",\n \"def add_args(parser):\\n # fmt: off\\n parser.add_argument('data', help='colon separated path to data directories list, \\\\\\n will be iterated upon during epochs in round-robin manner')\\n parser.add_argument('-s', '--source-lang', default=None, metavar='SRC',\\n help='source language')\\n parser.add_argument('-t', '--target-lang', default=None, metavar='TARGET',\\n help='target language')\\n parser.add_argument('--lazy-load', action='store_true',\\n help='load the dataset lazily')\\n parser.add_argument('--raw-text', action='store_true',\\n help='load raw text dataset')\\n parser.add_argument('--left-pad-source', default='True', type=str, metavar='BOOL',\\n help='pad the source on the left')\\n parser.add_argument('--left-pad-target', default='False', type=str, metavar='BOOL',\\n help='pad the target on the left')\\n parser.add_argument('--max-source-positions', default=1024, type=int, metavar='N',\\n help='max number of tokens in the source sequence')\\n parser.add_argument('--max-target-positions', default=1024, type=int, metavar='N',\\n help='max number of tokens in the target sequence')\\n parser.add_argument('--upsample-primary', default=1, type=int,\\n help='amount to upsample primary dataset')\\n # fmt: on\\n parser.add_argument('--main-src-wordfreq', default=None, type=str,\\n help='word frequency file of the main train source')\\n parser.add_argument('--dialect-src-wordfreq', default=None, type=str,\\n help='word frequency file of the dialect train source')\\n parser.add_argument('--dialect-tau', default=1., type=float)\\n parser.add_argument('--src-gradnorm-tau', default=1., type=float)\\n parser.add_argument('--lm-path', default=None, type=str)\\n parser.add_argument('--lm-dict-path', default=None, type=str)\\n parser.add_argument('--lm-topk', default=0, type=int)\\n parser.add_argument('--src-gradnorm-path', default=None, type=str)\\n parser.add_argument('--src-gradnorm-nosoftmax', action='store_true')\\n parser.add_argument('--exclude-self', action='store_true')\",\n \"def load(self):\\n self.classifier = joblib.load(\\\"data/models/repeatsfinder/repeatsfinder.joblib\\\")\",\n \"def add_train_arguments(self):\\n parser = self.parser\\n parser.add_argument(\\\"source_dir\\\", help=\\\"Directory containing test source images.\\\")\\n parser.add_argument(\\\"target_dir\\\", help=\\\"Directory containing test target images.\\\")\\n parser.add_argument(\\\"--batch_size\\\", \\\"-bs\\\", default=1, type=int, help=\\\"Batch size.\\\")\\n parser.add_argument(\\\"--cycle_loss_weight\\\", \\\"-clw\\\", default=0, type=int, help=\\\"Cycle loss weight.\\\")\\n parser.add_argument(\\n \\\"--discriminator_architecture\\\", \\\"-d\\\", default=\\\"basic\\\",\\n help=\\\"architecture of the discriminator ('basic' | 'N_layers')\\\"\\n )\\n parser.add_argument(\\n \\\"--discriminator_filters\\\", \\\"-df\\\", type=int, default=64,\\n help=\\\"Number of filters in the last conv layer of the discriminator.\\\"\\n )\\n parser.add_argument(\\n \\\"--n_frames_discriminator\\\", \\\"-dn\\\", type=int, default=0,\\n help=\\\"Number of frames the sequence discriminators discriminate.\\\"\\n )\\n parser.add_argument(\\n \\\"--discriminator_temporal_scales\\\", \\\"-dts\\\", type=int, default=1,\\n help=\\\"Number of temporal scales in framerate sampling (= number of sequence discriminators).\\\"\\n )\\n parser.add_argument(\\n \\\"--feature_matching_loss_weight\\\", \\\"-fmlw\\\", default=0, type=int, help=\\\"Loss weight of feature matching.\\\"\\n )\\n parser.add_argument(\\n \\\"--flow_loss_weight\\\", \\\"-flw\\\", default=0, type=int, help=\\\"Loss weight of flow loss in vid2vid.\\\"\\n )\\n parser.add_argument(\\n \\\"--gan_mode\\\", \\\"-gan\\\", default=\\\"lsgan\\\", help=\\\"type of the gan loss ('vanilla' | 'lsgan' | 'wgangp').\\\"\\n )\\n parser.add_argument(\\n \\\"--init_epoch\\\", \\\"-ie\\\", default=0, type=int, help=\\\"If set, load models saved at a specific epoch.\\\"\\n )\\n parser.add_argument(\\n \\\"--init_checkpoint_dir\\\", \\\"-i\\\",\\n help=\\\"If set, initialize models from saved checkpoints in init_checkpoint_dir.\\\"\\n )\\n parser.add_argument(\\n \\\"--log_every\\\", \\\"-le\\\", default=100, type=int, help=\\\"Log losses and images every log_every iterations.\\\"\\n )\\n parser.add_argument(\\n \\\"--log_images_every\\\", \\\"-lie\\\", default=0, type=int,\\n help=\\\"If specified, log images every log_images_every iterations, instead of every log_every iterations.\\\"\\n )\\n parser.add_argument(\\\"--load_height\\\", \\\"-lh\\\", type=int, default=0, help=\\\"image load height (before cropping).\\\")\\n parser.add_argument(\\\"--l1_loss_weight\\\", \\\"-llw\\\", default=0, type=int, help=\\\"L1 loss weight.\\\")\\n parser.add_argument(\\\"--learning_rate\\\", \\\"-lr\\\", default=0.0002, type=float, help=\\\"Learning rate.\\\")\\n parser.add_argument(\\\"--load_width\\\", \\\"-lw\\\", type=int, default=0, help=\\\"Image load width (before cropping).\\\")\\n parser.add_argument(\\n \\\"--mask_loss_weight\\\", \\\"-mlw\\\", default=0, type=int, help=\\\"Loss weight of mask loss (weight loss) in vid2vid.\\\"\\n )\\n parser.add_argument(\\\"--num_epochs\\\", \\\"-ne\\\", default=10, type=int, help=\\\"Number of training epochs.\\\")\\n parser.add_argument(\\n \\\"--perceptual_loss_weight\\\", \\\"-plw\\\", default=0, type=int, help=\\\"Loss weight of perceptual (VGG19) loss.\\\"\\n )\\n parser.add_argument(\\n \\\"--recycle_loss_weight\\\", \\\"-rclw\\\", default=0, type=int, help=\\\"Loss weight of recycle in RecycleGAN.\\\"\\n )\\n parser.add_argument(\\n \\\"--recycle_predictor_architecture\\\", \\\"-rcp\\\", default=\\\"resnet_6blocks\\\",\\n help=\\\"Architecture of RecycleGAN predictor. See generator_architecture for options.\\\"\\n )\\n parser.add_argument(\\n \\\"--recycle_predictor_filters\\\", \\\"-rcpf\\\", type=int, default=64,\\n help=\\\"Number of filters in the last conv layer of the RecycleGAN predictor.\\\"\\n )\\n parser.add_argument(\\n \\\"--save_every\\\", \\\"-se\\\", default=1, type=int, help=\\\"Save model checkpoints every save_every epochs.\\\"\\n )\\n parser.add_argument(\\n \\\"--spatial_scaling\\\", \\\"-ss\\\", default=[1], type=float, nargs='+',\\n help=\\\"Set steps for spatial scaling.\\\\n\\\"\\n \\\"I.e. [0.25, 0.5, 1] to train a model with width and height 256 on 64 > 128 > 256 images.\\\"\\n )\\n parser.add_argument(\\\"--timecycle_loss\\\", \\\"-tcl\\\", default=\\\"l1\\\", help=\\\"Timecycle loss ('l1' | 'l2')\\\")\\n parser.add_argument(\\\"--timecycle_loss_weight\\\", \\\"-tclw\\\", default=0, type=int, help=\\\"Timecycle loss weight.\\\")\\n parser.add_argument(\\n \\\"--timecycle_motion_model_architecture\\\", \\\"-tcmm\\\", default=\\\"resnet_1blocks\\\",\\n help=\\\"Architecture of Timecycle motion model. See generator_architecture for options.\\\"\\n )\\n parser.add_argument(\\n \\\"--timecycle_motion_model_filters\\\", \\\"-tcmmf\\\", type=int, default=64,\\n help=\\\"Number of filters in the last conv layer of the Timecycle motion model.\\\"\\n )\\n parser.add_argument(\\n \\\"--timecycle_separate_motion_models\\\", \\\"-tcsmm\\\", action=\\\"store_true\\\",\\n help=\\\"Set to use separate motion models for forward/backward predictions.\\\"\\n )\\n parser.add_argument(\\n \\\"--timecycle_type\\\", \\\"-tct\\\", default=\\\"conditional\\\",\\n help=\\\"Type of Timecycle ('conditional' | 'pingpong').\\\"\\n )\\n parser.add_argument(\\n \\\"--timecycle_warp_loss_weight\\\", \\\"-tcwlw\\\", default=0, type=int, help=\\\"Timecycle warp loss weight.\\\"\\n )\\n parser.add_argument(\\n \\\"--temporal_scaling\\\", \\\"-ts\\\", default=[1], type=float, nargs='+',\\n help=\\\"Set steps for temporal scaling.\\\\n\\\"\\n \\\"I.e. [0.2, 0.6, 1] to train a model with block_size 5 on 1 -> 3 -> 5 frames.\\\"\\n )\\n parser.add_argument(\\n \\\"--warp_loss_weight\\\", \\\"-wlw\\\", default=0, type=int, help=\\\"Loss weight of warp loss in vid2vid.\\\"\\n )\",\n \"def train(args):\\n print(args)\\n\\n # Run a training job\\n configs = LuxMatchConfigs_Default\\n\\n # Create a default opponent agent\\n opponent = Agent()\\n\\n # Create a RL agent in training mode\\n player = AgentPolicy(mode=\\\"train\\\")\\n\\n # Train the model\\n env_eval = None\\n if args.n_envs == 1:\\n env = LuxEnvironment(configs=configs,\\n learning_agent=player,\\n opponent_agent=opponent)\\n else:\\n env = SubprocVecEnv([make_env(LuxEnvironment(configs=configs,\\n learning_agent=AgentPolicy(mode=\\\"train\\\"),\\n opponent_agent=opponent), i) for i in range(args.n_envs)])\\n \\n run_id = args.id\\n print(\\\"Run id %s\\\" % run_id)\\n\\n if args.path:\\n # by default previous model params are used (lr, batch size, gamma...)\\n model = PPO.load(args.path)\\n model.set_env(env=env)\\n\\n # Update the learning rate\\n model.lr_schedule = get_schedule_fn(args.learning_rate)\\n\\n # TODO: Update other training parameters\\n else:\\n model = PPO(\\\"MlpPolicy\\\",\\n env,\\n verbose=1,\\n tensorboard_log=\\\"./lux_tensorboard/\\\",\\n learning_rate=args.learning_rate,\\n gamma=args.gamma,\\n gae_lambda=args.gae_lambda,\\n batch_size=args.batch_size,\\n n_steps=args.n_steps\\n )\\n\\n \\n \\n callbacks = []\\n\\n # Save a checkpoint and 5 match replay files every 100K steps\\n player_replay = AgentPolicy(mode=\\\"inference\\\", model=model)\\n callbacks.append(\\n SaveReplayAndModelCallback(\\n save_freq=100000,\\n save_path='./models/',\\n name_prefix=f'model{run_id}',\\n replay_env=LuxEnvironment(\\n configs=configs,\\n learning_agent=player_replay,\\n opponent_agent=Agent()\\n ),\\n replay_num_episodes=5\\n )\\n )\\n \\n # Since reward metrics don't work for multi-environment setups, we add an evaluation logger\\n # for metrics.\\n if args.n_envs > 1:\\n # An evaluation environment is needed to measure multi-env setups. Use a fixed 4 envs.\\n env_eval = SubprocVecEnv([make_env(LuxEnvironment(configs=configs,\\n learning_agent=AgentPolicy(mode=\\\"train\\\"),\\n opponent_agent=opponent), i) for i in range(4)])\\n\\n callbacks.append(\\n EvalCallback(env_eval, best_model_save_path=f'./logs_{run_id}/',\\n log_path=f'./logs_{run_id}/',\\n eval_freq=args.n_steps*2, # Run it every 2 training iterations\\n n_eval_episodes=30, # Run 30 games\\n deterministic=False, render=False)\\n )\\n\\n print(\\\"Training model...\\\")\\n model.learn(total_timesteps=args.step_count,\\n callback=callbacks)\\n if not os.path.exists(f'models/rl_model_{run_id}_{args.step_count}_steps.zip'):\\n model.save(path=f'models/rl_model_{run_id}_{args.step_count}_steps.zip')\\n print(\\\"Done training model.\\\")\\n\\n # Inference the model\\n print(\\\"Inference model policy with rendering...\\\")\\n saves = glob.glob(f'models/rl_model_{run_id}_*_steps.zip')\\n latest_save = sorted(saves, key=lambda x: int(x.split('_')[-2]), reverse=True)[0]\\n model.load(path=latest_save)\\n obs = env.reset()\\n for i in range(600):\\n action_code, _states = model.predict(obs, deterministic=True)\\n obs, rewards, done, info = env.step(action_code)\\n if i % 5 == 0:\\n print(\\\"Turn %i\\\" % i)\\n env.render()\\n\\n if done:\\n print(\\\"Episode done, resetting.\\\")\\n obs = env.reset()\\n print(\\\"Done\\\")\\n\\n '''\\n # Learn with self-play against the learned model as an opponent now\\n print(\\\"Training model with self-play against last version of model...\\\")\\n player = AgentPolicy(mode=\\\"train\\\")\\n opponent = AgentPolicy(mode=\\\"inference\\\", model=model)\\n env = LuxEnvironment(configs, player, opponent)\\n model = PPO(\\\"MlpPolicy\\\",\\n env,\\n verbose=1,\\n tensorboard_log=\\\"./lux_tensorboard/\\\",\\n learning_rate = 0.0003,\\n gamma=0.999,\\n gae_lambda = 0.95\\n )\\n model.learn(total_timesteps=2000)\\n env.close()\\n print(\\\"Done\\\")\\n '''\",\n \"def main() -> None:\\n parser = ArgumentParser(description=\\\"SoccerPredictor:\\\", formatter_class=ArgumentDefaultsHelpFormatter)\\n subparsers = parser.add_subparsers(title=\\\"Modes to run\\\", dest=\\\"command\\\")\\n\\n # Trainer args\\n trainer_parser = subparsers.add_parser(RunMode.Train.value, help=\\\"Trains model and makes predictions.\\\",\\n formatter_class=ArgumentDefaultsHelpFormatter)\\n trainer_parser.add_argument(\\\"--resume\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"Resumes training of previously saved model. \\\"\\n \\\"Tries to load the latest model saved if no name or prefix specified via --name.\\\")\\n trainer_parser.add_argument(\\\"--epochs\\\", type=int, action=\\\"store\\\", default=1,\\n help=\\\"Number of epochs to train model for.\\\")\\n trainer_parser.add_argument(\\\"--ntest\\\", type=int, action=\\\"store\\\", default=10,\\n help=\\\"Number of last samples used for testing for each team.\\\")\\n trainer_parser.add_argument(\\\"--ndiscard\\\", type=int, action=\\\"store\\\", default=0,\\n help=\\\"Number of last samples to discard for each team.\\\")\\n trainer_parser.add_argument(\\\"--timesteps\\\", type=int, action=\\\"store\\\", default=40,\\n help=\\\"Number of timesteps to use as data window size for input to network.\\\")\\n trainer_parser.add_argument(\\\"--predict\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"Whether to rerun predictions without any training.\\\")\\n trainer_parser.add_argument(\\\"--lrpatience\\\", type=int, action=\\\"store\\\", default=20,\\n help=\\\"How many epochs to tolerate before decaying learning rate if no improvement. \\\"\\n \\\"Turned off if 0.\\\")\\n trainer_parser.add_argument(\\\"--lrdecay\\\", type=float, action=\\\"store\\\", default=0.95,\\n help=\\\"How much to decay learning rate after patience exceeded.\\\")\\n trainer_parser.add_argument(\\\"--seed\\\", type=int, action=\\\"store\\\",\\n help=\\\"Specifies seed for rng.\\\")\\n trainer_parser.add_argument(\\\"--savefreq\\\", type=int, action=\\\"store\\\", default=50,\\n help=\\\"How often (number of epochs) to save models. No intermediate saving if 0.\\\")\\n trainer_parser.add_argument(\\\"--printfreq\\\", type=int, action=\\\"store\\\", default=10,\\n help=\\\"How often (number of epochs) to print current summaries. \\\"\\n \\\"No intermediate printing if 0.\\\")\\n trainer_parser.add_argument(\\\"--verbose\\\", type=int, action=\\\"store\\\", choices=VERBOSITY_LEVELS, default=1,\\n help=\\\"Level of verbosity.\\\")\\n\\n # Visualizer args\\n visualizer_parser = subparsers.add_parser(RunMode.Vis.value, help=\\\"Runs visualization of predictions.\\\",\\n formatter_class=ArgumentDefaultsHelpFormatter)\\n visualizer_parser.add_argument(\\\"--port\\\", type=int, action=\\\"store\\\", default=8050,\\n help=\\\"Custom port for Dash visualization.\\\")\\n visualizer_parser.add_argument(\\\"--host\\\", type=str, action=\\\"store\\\", default=\\\"127.0.0.1\\\",\\n help=\\\"Custom host for Dash visualization. Can use 0 for 0.0.0.0 shortcut.\\\")\\n\\n # Backtester args\\n backtester_parser = subparsers.add_parser(RunMode.Backtest.value, help=\\\"Runs backtesting on trained models.\\\",\\n formatter_class=ArgumentDefaultsHelpFormatter)\\n backtester_parser.add_argument(\\\"--path\\\", type=str, action=\\\"store\\\", default=f\\\"{DATA_DIR}{MODEL_DIR}\\\",\\n help=\\\"Path to folder where the trained models are saved.\\\")\\n\\n # common args for trainer and visualizer\\n for p in [trainer_parser, visualizer_parser]:\\n p.add_argument(\\\"--name\\\", type=str, action=\\\"store\\\",\\n help=\\\"Tries to load the latest saved model with given name prefix. \\\"\\n \\\"Loads exact model if exact dir name specified.\\\")\\n\\n # Common args for visualizer and backtester\\n for p in [visualizer_parser, backtester_parser]:\\n p.add_argument(\\\"--ignoreodds\\\", type=float, action=\\\"store\\\", default=1.10,\\n help=\\\"Ignores odds less than given amount when predicting which team to bet on.\\\")\\n\\n args = parser.parse_args()\\n\\n if args.command is None:\\n parser.print_help()\\n return\\n elif args.command == RunMode.Vis.value:\\n print(\\\"Visualizing...\\\")\\n vis_args, _ = visualizer_parser.parse_known_args()\\n check_visualizer_args(visualizer_parser, vis_args)\\n print(vis_args)\\n\\n from soccerpredictor.visualizer import visualizer\\n try:\\n visualizer.run(vis_args.name, vis_args.host, vis_args.port, vis_args.ignoreodds)\\n except KeyboardInterrupt:\\n print(\\\"> Received CTRL+C command. Exiting.\\\")\\n elif args.command == RunMode.Backtest.value:\\n print(\\\"Backtesting...\\\")\\n backtest_args, _ = backtester_parser.parse_known_args()\\n check_backtester_args(backtester_parser, backtest_args)\\n print(backtest_args)\\n\\n from soccerpredictor.backtester import backtester\\n try:\\n backtester.run(backtest_args.path, backtest_args.ignoreodds)\\n except KeyboardInterrupt:\\n print(\\\"> Received CTRL+C command. Exiting.\\\")\\n elif args.command == RunMode.Train.value:\\n print(\\\"Running model...\\\")\\n train_args, _ = trainer_parser.parse_known_args()\\n config = SPConfig()\\n\\n # Implicitly set resume to true if we are predicting only\\n if train_args.predict and not train_args.resume:\\n train_args.resume = True\\n\\n check_trainer_args(trainer_parser, train_args)\\n config.set_args(train_args)\\n print(train_args)\\n\\n dbmanager = SPDBManager()\\n try:\\n dbmanager.connect()\\n\\n # Load previous settings if we resume training\\n if train_args.resume:\\n print(\\\"Resuming training, loading previous settings... \\\"\\n \\\"Any conflicting parameters will be ignored.\\\")\\n\\n # Load previous settings\\n folder = get_latest_models_dir(train_args.name)\\n model_settings = get_model_settings_file(folder)\\n # Restore original config\\n config.restore_args(model_settings)\\n set_rng_seed(config.seed)\\n\\n from soccerpredictor.trainer.trainer import SPTrainer\\n trainer = SPTrainer(dbmanager, model_settings=model_settings, folder=folder)\\n else:\\n # Need to generate folder prefix before seeding random number generators\\n import random\\n generated_folder_prefix = \\\"\\\".join(random.choices(ascii_uppercase, k=FOLDER_PREFIX_LEN))\\n print(f\\\"New generated folder prefix: '{generated_folder_prefix}'\\\")\\n set_rng_seed(train_args.seed)\\n\\n from soccerpredictor.trainer.trainer import SPTrainer\\n trainer = SPTrainer(dbmanager, generated_folder_prefix=generated_folder_prefix)\\n\\n try:\\n trainer.run()\\n finally:\\n trainer.cleanup()\\n\\n except KeyboardInterrupt:\\n print(\\\"> Received CTRL+C command. Exiting.\\\")\\n except (FileNotFoundError, ValueError, OperationalError) as e:\\n print(e)\\n sys.exit(1)\\n finally:\\n dbmanager.disconnect()\",\n \"def get_args():\\r\\n # Default root directory will be the directory in which this file is located\\r\\n default_root_dir = Path(__file__).parent\\r\\n\\r\\n parser = argparse.ArgumentParser(description='Predict image classification based on existing pretrained model')\\r\\n parser.add_argument('checkpoint', type=lambda p: train.path_exists(p, replace_keyword=\\\"checkpoint=\\\", is_file=True),\\r\\n metavar='<path to checkpoint file>', nargs='?',\\r\\n help='file path to torch checkpoint of the existing pretrained model')\\r\\n group = parser.add_mutually_exclusive_group(required=True)\\r\\n group.add_argument('-f', '--image_file', type=lambda p: train.path_exists(p, is_file=True),\\r\\n metavar='<path to image file>', nargs='?', help='use path to image file')\\r\\n group.add_argument('-i', '--image_dir', type=lambda p: train.path_exists(p), metavar='<path to images dir>',\\r\\n nargs='?', help='use directory containing image files; can be used as alternative to specifying'\\r\\n ' just a single image file path')\\r\\n group.add_argument('-t', '--test_mode', action='store_true', help='use test image dataset instead of '\\r\\n 'image file or directory; defaults to False')\\r\\n parser.add_argument('-d', '--test_data_dir', type=lambda p: train.path_exists(p),\\r\\n metavar='<path to test data dir>', nargs='?',\\r\\n default=default_root_dir.joinpath('flowers', 'test'),\\r\\n help='Will be used only when test_mode is enabled. Directory containing the test data '\\r\\n 'as expected by torchvision.datasets.ImageFolder; defaults to <script_dir>/flowers/test')\\r\\n parser.add_argument('-k', '--top_k', type=int, metavar='<integer>', nargs='?', default=5,\\r\\n help='number of top k most likely classes to be returned')\\r\\n parser.add_argument('-g', '--gpu', action='store_true', help='use gpu, if available; defaults to False')\\r\\n parser.add_argument('-c', '--category_names', type=lambda p: train.path_exists(p, is_file=True),\\r\\n metavar='<path to json file>', nargs='?', default=default_root_dir.joinpath('cat_to_name.json'),\\r\\n help='JSON file containing a mapping of categories and label names for targets'\\r\\n 'defaults to cat_to_name.json')\\r\\n parser.add_argument('-v', '--verbosity', action='count', default=0, help='increase output verbosity; defaults to 0')\\r\\n\\r\\n try:\\r\\n # vars returns dictionary\\r\\n return vars(parser.parse_args())\\r\\n except IOError as msg:\\r\\n parser.error(str(msg))\",\n \"def do_start(self, arg):\\n args = arg.split(\\\" \\\")\\n self.model.initialise(args[0])\\n self.model.run()\",\n \"def setup():\\n load_from_pretrain = args.pretrained is not None and os.path.exists(args.pretrained)\\n\\n if load_from_pretrain and not args.finetune:\\n cfg_folder = args.pretrained\\n cfg_from_file(os.path.join(cfg_folder, \\\"config.yaml\\\"), reset_model_spec=False)\\n cfg.RL_MODEL_SPEC = os.path.join(cfg_folder, cfg.RL_MODEL_SPEC.split(\\\"/\\\")[-1])\\n dt_string = args.pretrained.split(\\\"/\\\")[-1]\\n \\n else:\\n if args.fix_output_time is None:\\n dt_string = datetime.datetime.now().strftime(\\\"%d_%m_%Y_%H:%M:%S\\\")\\n else:\\n dt_string = args.fix_output_time\\n\\n model_output_dir = os.path.join(cfg.OUTPUT_DIR, dt_string)\\n print(\\\"Output will be saved to `{:s}`\\\".format(model_output_dir))\\n new_output_dir = not os.path.exists(model_output_dir) and not args.test\\n print(\\\"Using config:\\\")\\n pprint.pprint(cfg)\\n net_dict = make_nets_opts_schedulers(cfg.RL_MODEL_SPEC, cfg.RL_TRAIN)\\n print(\\\"Output will be saved to `{:s}`\\\".format(model_output_dir))\\n return net_dict, dt_string\",\n \"def launch(self, force_prep=False):\\n #TODO process upploaded csv\\n assert self.ready()\\n self.launch_progress = 0\\n self.set_status(\\\"Gathering data\\\")\\n if 'O' not in set(self.labels.dict.values()):\\n self.add_labels({max(list(self.labels.dict.keys()))+1:'O'})\\n\\n processed_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.csv')\\n bert_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.bert')\\n elmo_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.elmo')\\n nlp_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.nlp')\\n sbert_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.sbert')\\n if os.path.exists(processed_file_path) and not force_prep:\\n df = pd.read_csv(processed_file_path)\\n if 'span_label' in df.columns:\\n df['span_label']=df['span_label'].apply(eval)\\n # Let's say loading the file is ~half the launch time\\n # (if the file already exists)\\n self.total = 2\\n self.update(1)\\n else:\\n datafiles = [os.path.join(DATASETS_PATH, self.dataset_uuid, d) \\\\\\n for d in os.listdir(os.path.join(DATASETS_PATH, self.dataset_uuid))]\\n df = concat_dataset(datafiles)\\n # expand total to account for time it takes to initialize the model\\n self.total = len(df)*(1.1) \\n self.set_status(\\\"Preprocessing data\\\")\\n df = self.process_data(df, processed_file_path)\\n\\n # load list of 'allennlp.data.instance's. allennlp.data.instance can store true labels and tag info internally.\\n if os.path.exists(nlp_file_path) and not force_prep:\\n with open(nlp_file_path, 'rb') as f:\\n sentences = pickle.load(f)\\n else:\\n #TODO define a universal reader for certain format\\n # reader = RestaurantsDatasetReader()\\n # data = reader.read(processed_file_path)\\n #TODO handle when aux files do not exist\\n pass\\n bert_emb = np.load(bert_file_path, allow_pickle=True)\\n elmo_emb = np.load(elmo_file_path, allow_pickle=True)\\n sbert_emb = np.load(sbert_file_path, allow_pickle=True)\\n for s, b, e, sb in zip(sentences, bert_emb, elmo_emb, sbert_emb):\\n s.fields['bert'] = b\\n s.fields['sbert'] = sb\\n s.fields['elmo'] = e\\n\\n df['bert'] = bert_emb\\n df['sbert'] = [sb for sb in sbert_emb]\\n df['elmo'] = elmo_emb\\n df['text_nlp'] = sentences\\n\\n columns_to_drop = list(\\n set(df.columns).intersection(set(['span_label','file','label'])))\\n df = df.drop(columns=columns_to_drop).reset_index()\\n # since df['text_nlp'] contains true label info, drop 'labels' column.\\n columns_to_drop = list(set(df.columns).difference(set(['index', 'Unnamed: 0', 'text', 'labels', 'split', 'bert', 'sbert',\\n 'elmo', 'text_nlp'])))\\n if len(columns_to_drop) > 0:\\n df = df.drop(columns=columns_to_drop)\\n df_train = df[df['split']=='train']\\n df_dev = df[df['split'] == 'dev']\\n df_valid = df[df['split'] == 'valid']\\n df_test = df[df['split'] == 'test']\\n\\n self.text_inv_dict = dict(\\n zip(list(df['text']),list(df.index))\\n )\\n\\n # TODO split heldout set if necessary\\n # for now, passing empty df as heldout set\\n df_heldout = df_test\\n\\n self.emb_dict = Embeddings(df)\\n\\n self.set_status(\\\"Initializing modeler\\\")\\n self.modeler = Modeler(df_train, df_dev, df_valid, df_test, df_heldout, self.labels, emb_dict=self.emb_dict)\\n\\n self.launch_progress = 1.0\\n self.set_status(\\\"Finished\\\")\\n return self.modeler\",\n \"def setup(args):\\n cfg = get_cfg()\\n add_imaterialist_config(cfg)\\n cfg.merge_from_file(model_zoo.get_config_file(\\\"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml\\\"))\\n cfg.merge_from_file(args.config_file)\\n \\n cfg.merge_from_list(args.opts)\\n cfg.freeze()\\n default_setup(cfg, args)\\n # Setup logger for \\\"imaterialist\\\" module\\n setup_logger(output=cfg.OUTPUT_DIR, distributed_rank=comm.get_rank(), name=\\\"imaterialist\\\")\\n return cfg\",\n \"def parse_args(evaluation=False):\\n parser = argparse.ArgumentParser(description='Referring Relationships.')\\n\\n # Session parameters.\\n parser.add_argument('--batch-size', type=int, default=128,\\n help='The batch size used in training.')\\n parser.add_argument('--seed', type=int, default=1234,\\n help='The random seed used to reproduce results.')\\n parser.add_argument('--workers', type=int, default=1,\\n help='Number workers used to load the data.')\\n\\n # Eval parameters.\\n parser.add_argument('--heatmap-threshold', type=float, nargs='+',\\n default=[0.3, 0.5, 0.6],\\n help='The thresholds above which we consider '\\n 'a heatmap to contain an object.')\\n\\n # Discovery Experiment.\\n parser.add_argument('--discovery', action='store_true', default=False,\\n help='Used when we run the discovery experinent '\\n 'where objects are dropped during training.')\\n parser.add_argument('--always-drop-file', type=str, default=None,\\n help='Location of list of objects that should always '\\n 'be dropped.')\\n parser.add_argument('--subject-droprate', type=float, default=0.3,\\n help='Rate at which subjects are dropped.')\\n parser.add_argument('--object-droprate', type=float, default=0.3,\\n help='Rate at which objects are dropped.')\\n\\n\\n # Grab the other parameters.\\n if evaluation:\\n parse_evaluation_args(parser)\\n else:\\n parse_training_args(parser)\\n\\n args = parser.parse_args()\\n\\n if not evaluation:\\n # Verify that we have at least one of the following flags set:\\n args.use_subject = args.use_subject > 0\\n args.use_predicate = args.use_predicate > 0\\n args.use_object = args.use_object > 0\\n if not (args.use_subject or args.use_predicate or args.use_object):\\n raise ValueError('At least one of the 3 components of the '\\n 'relationship should be included in training.')\\n\\n # set the random seed.\\n np.random.seed(args.seed)\\n\\n # Set flags for multiprocessing.\\n args.multiprocessing = args.workers > 1\\n\\n return args\",\n \"def parse_args(argv):\\n parser = argparse.ArgumentParser(\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n parser.add_argument('--config', required=True,\\n choices=configs.valid_configs(),\\n help='The config to use.')\\n parser.add_argument('--ckpt_dir', required=True,\\n help=('Path to the folder where checkpoints should be '\\n 'stored. Passing the same folder twice will resume '\\n 'training.'))\\n parser.add_argument('--num_steps', default='1M',\\n help=('Number of steps to train for. Supports M and k '\\n 'postfix for \\\"million\\\" and \\\"thousand\\\", resp.'))\\n parser.add_argument('--init_autoencoder_from_ckpt_dir',\\n metavar='AUTOENC_CKPT_DIR',\\n help=('If given, restore encoder, decoder, and '\\n 'probability model from the latest checkpoint in '\\n 'AUTOENC_CKPT_DIR. See README.md.'))\\n parser.add_argument('--batch_size', type=int, default=8,\\n help='Batch size for training.')\\n parser.add_argument('--crop_size', type=int, default=256,\\n help='Crop size for input pipeline.')\\n parser.add_argument('--lpips_weight_path',\\n help=('Where to store the LPIPS weights. Defaults to '\\n 'current directory'))\\n\\n helpers.add_tfds_arguments(parser)\\n\\n parser.add_argument(\\n '--no-image-summaries',\\n dest='image_summaries',\\n action='store_false',\\n help='Disable image summaries.')\\n parser.set_defaults(image_summaries=True)\\n\\n args = parser.parse_args(argv[1:])\\n if args.ckpt_dir == args.init_autoencoder_from_ckpt_dir:\\n raise ValueError('--init_autoencoder_from_ckpt_dir should not point to '\\n 'the same folder as --ckpt_dir. If you simply want to '\\n 'continue training the model in --ckpt_dir, you do not '\\n 'have to pass --init_autoencoder_from_ckpt_dir, as '\\n 'continuing training is the default.')\\n args.num_steps = _parse_num_steps(args.num_steps)\\n return args\",\n \"def add_train_args(parser: ArgumentParser):\\n # General arguments\\n parser.add_argument('--task', type=str, default='regression',\\n help='Regression or classification task')\\n parser.add_argument('--seed', type=int, default=0,\\n help='Random seed to use when splitting data into train/val/test sets.'\\n 'When `num_folds` > 1, the first fold uses this seed and all'\\n 'subsequent folds add 1 to the seed.')\\n parser.add_argument('--data_path', type=str,\\n help='Path to data CSV file')\\n parser.add_argument('--split_path', type=str,\\n help='Path to .npy file containing train/val/test split indices')\\n parser.add_argument('--log_dir', type=str, default=None,\\n help='Directory where model checkpoints will be saved')\\n parser.add_argument('--model_path', type=str, default=None,\\n help='Path to model file to load for evaluation time')\\n parser.add_argument('--eval_output_dir', type=str, default=None,\\n help='Directory to store outputs of evaluation, including predictions and attention visualization')\\n\\n\\n # Training arguments\\n parser.add_argument('--epoch', type=int, default=0,\\n help='Starting epoch')\\n parser.add_argument('--checkpoint_load_path', type=str,\\n help='Path to model to load as checkpoint when resuming training')\\n parser.add_argument('--checkpoint_dir', type=str,\\n help='Path to save checkpoint model')\\n parser.add_argument('--viz_dir', type=str,\\n help='Path to save attention visualization')\\n\\n parser.add_argument('--n_epochs', type=int, default=60,\\n help='Number of epochs to run')\\n parser.add_argument('--batch_size', type=int, default=50,\\n help='Batch size')\\n parser.add_argument('--warmup_epochs', type=float, default=2.0,\\n help='Number of epochs during which learning rate increases linearly from'\\n 'init_lr to max_lr. Afterwards, learning rate decreases exponentially'\\n 'from max_lr to final_lr.')\\n parser.add_argument('--lr', type=float, default=1e-4,\\n help='Learning rate')\\n parser.add_argument('--num_workers', type=int, default=5,\\n help='Number of workers to use in dataloader')\\n parser.add_argument('--no_shuffle', action='store_true', default=False,\\n help='Whether or not to retain default ordering during training')\\n parser.add_argument('--shuffle_pairs', action='store_true', default=False,\\n help='Whether or not to shuffle only pairs of stereoisomers')\\n\\n # Model arguments\\n parser.add_argument('--gnn_type', type=str,\\n choices=['gin', 'gcn', 'dmpnn', 'orig_dmpnn'],\\n help='Type of gnn to use')\\n parser.add_argument('--global_chiral_features', action='store_true', default=False,\\n help='Use global chiral atom features')\\n parser.add_argument('--chiral_features', action='store_true', default=False,\\n help='Use local chiral atom features')\\n parser.add_argument('--ft_boost', action='store_true', default=False, help='whether to concatenate R/S features after each MP layer')\\n parser.add_argument('--hidden_size', type=int, default=32,\\n help='Dimensionality of hidden layers')\\n parser.add_argument('--depth', type=int, default=2,\\n help='Number of message passing steps')\\n parser.add_argument('--dropout', type=float, default=0.,\\n help='Dropout probability')\\n parser.add_argument('--graph_pool', type=str, default='sum',\\n choices=['sum', 'mean', 'max', 'attn', 'set2set'],\\n help='How to aggregate atom representations to molecule representation')\\n parser.add_argument('--message', type=str, default='sum',\\n choices=['sum', 'tetra_pd', 'tetra_permute', 'tetra_permute_concat'],\\n help='How to pass neighbor messages')\\n parser.add_argument('--n_layers', type=int, default=2,\\n help='Number of final FFN layers')\\n parser.add_argument('--skip_coef', type=float, default=1.,\\n help='How much information retained in skip connections')\\n\\n # Attention arguments\\n parser.add_argument('--attn_type', type=str, default='gat', choices=['gat', 'tang'],\\n help='Attention type. GAT or that used in Tang 2020')\\n parser.add_argument('--gat_act', type=str, default='leakyrelu',\\n choices=['leakyrelu', 'relu'], help='Activation function used in GAT')\\n parser.add_argument('--alpha', type=float, default=0.01,\\n help='Alpha used in leakyReLU in GAT')\\n parser.add_argument('--gat_depth', type=int, default=2,\\n help='number of GAT attention layers')\\n parser.add_argument('--heads', type=int, default=3,\\n help='Number of attention heads')\\n parser.add_argument('--attn_dropout', type=float, default=0.,\\n help='Dropout probability for attention')\\n parser.add_argument('--concat', action='store_true', default=False,\\n help='concatenate heads or take average in multihead attention')\",\n \"def main(cli_args=None):\\n # build an arg parser\\n parser = get_arg_parser()\\n\\n # run the parser on cli args\\n args = parser.parse_args(cli_args)\\n\\n print(f\\\"Running script with arguments: {args}\\\")\\n test_input(args.raw_training_data)\\n test_input(args.raw_testing_data)\\n test_output(args.train_output)\\n test_output(args.test_output)\",\n \"def process_command_line():\\n\\n # Add the command lien arguments\\n parser = argparse.ArgumentParser(description=\\\"test autocontext\\\", formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n\\n # Arguments\\n parser.add_argument(\\\"--ilastik\\\", type=str, required=True,\\n help=\\\"path to the file run_ilastik.sh\\\")\\n\\n parser.add_argument(\\\"--train\\\", type=str,\\n help=\\\"path to the ilastik project that will be used for training\\\")\\n\\n parser.add_argument(\\\"--batch_predict\\\", type=str,\\n help=\\\"path of the cache folder of a previously trained autocontext that will be used for batch \\\"\\n \\\"prediction\\\")\",\n \"def main(args):\\r\\n\\r\\n # Logging info\\r\\n formatter = logging.Formatter('%(asctime)s %(levelname)s - '\\r\\n '%(funcName)s: %(message)s',\\r\\n '%H:%M:%S')\\r\\n logger = logging.getLogger(__name__)\\r\\n logger.setLevel('INFO')\\r\\n stream = logging.StreamHandler()\\r\\n stream.setLevel('INFO')\\r\\n stream.setFormatter(formatter)\\r\\n logger.addHandler(stream)\\r\\n\\r\\n set_seed(args.seed)\\r\\n device = torch.device(\\r\\n 'cuda' if torch.cuda.is_available() and args.cuda else 'cpu')\\r\\n model_name = f'{args.name}_lr{args.lr}_z{args.latent_dim}' \\\\\\r\\n + f'_h{args.hidden_dim}_p{args.p_dropout}'\\r\\n model_dir = os.path.join(args.results, model_name)\\r\\n logger.info(f'Directory for saving and loading models: {model_dir}')\\r\\n\\r\\n if not args.eval:\\r\\n # Model directory\\r\\n new_model_dir(model_dir, logger=logger)\\r\\n\\r\\n # Dataloaders\\r\\n train_loader, valid_loader = get_dataloaders(\\r\\n args.data, args.t_hours, args.n_bins,\\r\\n validation=True, dynamic=args.dynamic,\\r\\n batch_size=args.bs, logger=logger)\\r\\n logger.info(\\r\\n f'Train {args.model_type}-{args.t_hours} ' +\\r\\n f'with {len(train_loader.dataset)} samples')\\r\\n\\r\\n # Load model\\r\\n n_tokens = len(np.load(\\r\\n os.path.join(\\r\\n args.data, '_dicts', f'{args.t_hours}_{args.n_bins}.npy'),\\r\\n allow_pickle=True).item())\\r\\n model = init_model(\\r\\n args.model_type, n_tokens, args.latent_dim, args.hidden_dim,\\r\\n p_dropout=args.p_dropout, dt=args.dt,\\r\\n weighted=args.weighted, dynamic=args.dynamic)\\r\\n logger.info(f'#params in model: {get_n_param(model)}')\\r\\n\\r\\n # Optimizer\\r\\n optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\\r\\n loss_f = BCE()\\r\\n model = model.to(device)\\r\\n\\r\\n # Training\\r\\n trainer = Trainer(\\r\\n model, loss_f, optimizer,\\r\\n device=device, logger=logger, save_dir=model_dir, p_bar=args.p_bar)\\r\\n trainer.train(\\r\\n train_loader, valid_loader,\\r\\n epochs=args.epochs, early_stopping=args.early_stopping)\\r\\n\\r\\n # Save model\\r\\n metadata = vars(args)\\r\\n metadata['n_tokens'] = n_tokens\\r\\n save_model(trainer.model, model_dir, metadata=metadata)\\r\\n\\r\\n if args.test:\\r\\n # Load model\\r\\n model = load_model(model_dir, is_gpu=args.cuda)\\r\\n metadata = load_metadata(model_dir)\\r\\n\\r\\n # Dataloader\\r\\n test_loader, _ = get_dataloaders(\\r\\n metadata['data'], metadata['t_hours'], metadata['n_bins'],\\r\\n validation=False, dynamic=metadata['dynamic'], batch_size=128,\\r\\n shuffle=False, logger=logger)\\r\\n\\r\\n # Evaluate\\r\\n loss_f = BCE()\\r\\n evaluator = Trainer(\\r\\n model, loss_f,\\r\\n device=device, logger=logger, save_dir=model_dir, p_bar=args.p_bar)\\r\\n evaluator._valid_epoch(test_loader)\",\n \"def main():\\n\\n config = None\\n\\n try:\\n args = get_args()\\n config = process_config(args.config)\\n raise RuntimeError(\\\"Missing or invalid arguments\\\")\\n except Exception as e:\\n logging.error(\\\"Failed\\\", exc_info=e)\\n\\n print(\\\"Create the data generator.\\\")\\n # data_loader = MnistDataLoader(config=config)\\n data_loader = IrisDataLoader(config=config)\\n train_data = data_loader.get_train_data()\\n test_data = data_loader.get_test_data()\\n\\n print(\\\"Build the model\\\")\\n # cnn_model = ConvModel(config=config).build_model()\\n cnn_model = ANNModel(config=config).build_model()\\n\\n print(\\\"Load the best weights\\\")\\n cnn_model.load_weights(\\\"experiments/{}/{}/checkpoints/{}-weights.best.hdf5\\\".format(\\n config.evaluation.date, config.exp.name, config.exp.name))\\n\\n print(\\\"Evaluate the model\\\")\\n print(\\\"Training Metrics\\\")\\n evaluate(model=cnn_model, data=train_data)\\n print(\\\"Testing Metrics\\\")\\n evaluate(model=cnn_model, data=test_data)\\n\\n # print(\\\"Visualize loss and accuracy for Training and Validation data\\\")\\n # plot_history(config=config)\\n\\n # print(\\\"Plotting ROC Curve\\\")\\n # plot_roc(model=cnn_model, data=test_data)\\n\\n print(\\\"Classifcation Accuracy Report\\\")\\n classification_accuracy_report(model=cnn_model, data=test_data)\",\n \"def main_train(args):\\n if args.preprocessing is not None:\\n raise NotImplementedError(\\\"ASV Preprocessing is not yet supported\\\")\\n if args.output is None and args.snapshot_rate is not None:\\n raise RuntimeError(\\\"Can not save snapshots without output\\\")\\n\\n # Create and load cm network\\n cm_model, cm_feature_network = create_cm_network(args)\\n cm_state_dict = torch.load(args.cm_model)\\n # Remove the bonafide_average vector stored with\\n # CM models\\n average_bonafide = cm_state_dict.pop(\\\"average_bonafide\\\")\\n # Do not load parameters if so desired\\n if not args.from_scratch:\\n cm_model.load_state_dict(cm_state_dict)\\n # Get CM embedding size we are about to feed to ASV system\\n cm_embedding_size = average_bonafide.shape[0]\\n\\n # Create and load ASV network\\n asv_model, asv_feature_network = create_asv_network(XVECTOR_FEATURE_SIZE, args)\\n asv_state_dict = torch.load(args.asv_model)\\n # Remove any preprocessing steps\\n preprocessing_parameters = {\\n \\\"centering_mean\\\": asv_state_dict.pop(\\\"centering_mean\\\", None),\\n \\\"lda\\\": asv_state_dict.pop(\\\"lda\\\", None)\\n }\\n if not args.from_scratch:\\n asv_model.load_state_dict(asv_state_dict)\\n\\n asv_features, cm_features, speaker_labels, is_targets, is_spoofs = load_joint_train_data_asvspoof(\\n args.joint_filelist, args.joint_asv_directory, args.joint_cm_directory,\\n )\\n\\n # Move CM features to cuda already\\n numpy_to_torch_cuda = lambda arr: torch.from_numpy(arr).float().cuda()\\n cm_features = list(map(numpy_to_torch_cuda, cm_features))\\n\\n # Split bonafide spoof samples to a separate list for\\n # saving CM model\\n bonafide_cm_features = [cm_features[i] for i in range(len(cm_features)) if not is_spoofs[i]]\\n\\n # Preprocess data a little bit: Create a dictionary\\n # that maps speaker labels to indeces where speaker has\\n # bona fide samples\\n speaker_label_to_indeces = {}\\n for i, (speaker_label, is_target) in enumerate(zip(speaker_labels, is_targets)):\\n if is_target:\\n # Speaker label and input features match,\\n # add this index to list of valid samples for that\\n # speaker\\n speaker_label_to_indeces[speaker_label] = (\\n speaker_label_to_indeces.get(speaker_label, []) + [i]\\n )\\n\\n # Also separate indeces of nontarget/target trials\\n is_targets = np.array(is_targets)\\n target_indeces = np.where(is_targets)[0]\\n nontarget_indeces = np.where(~is_targets)[0]\\n\\n all_parameters = list(asv_model.parameters())\\n all_parameters.extend(list(cm_model.parameters()))\\n # SGD is stabler than Adam, but need to see how many epochs it takes to train\\n optimizer = None\\n if args.optimizer == \\\"adam\\\":\\n optimizer = torch.optim.Adam(all_parameters, weight_decay=args.l2_weight, lr=args.lr)\\n elif args.optimizer == \\\"sgd\\\":\\n optimizer = torch.optim.SGD(all_parameters, weight_decay=args.l2_weight, lr=args.lr)\\n\\n num_samples = len(asv_features)\\n total_iterations = int(args.epochs * (num_samples // BATCH_SIZE))\\n\\n progress_bar = tqdm(total=total_iterations)\\n loss_deque = deque(maxlen=100)\\n\\n loss_function = LOSS_FUNCTIONS[args.loss]\\n\\n for update_i in range(total_iterations):\\n (cm_inputs, asv_inputs), targets, is_spoof = create_joint_sample_batch(\\n asv_features,\\n cm_features,\\n speaker_label_to_indeces,\\n target_indeces,\\n nontarget_indeces,\\n is_spoofs,\\n BATCH_SIZE\\n )\\n\\n asv_predictions = asv_model(*asv_inputs)\\n cm_predictions = cm_model(*cm_inputs)\\n\\n # Predictions are logits, turn into probablities\\n asv_predictions = torch.sigmoid(asv_predictions)\\n cm_predictions = torch.sigmoid(cm_predictions)\\n\\n # Loss should return a scalar value we then backprop through\\n # and update parameters to minimize it\\n loss = loss_function(asv_predictions, cm_predictions, targets, is_spoof, args)\\n\\n optimizer.zero_grad()\\n loss.backward()\\n optimizer.step()\\n\\n loss_deque.append(loss.item())\\n average_loss = np.mean(loss_deque)\\n progress_bar.update(1)\\n progress_bar.set_description(\\\"Loss: {:2.5f}\\\".format(average_loss))\\n progress_bar.refresh()\\n\\n if args.snapshot_rate is not None and (update_i % args.snapshot_rate) == 0:\\n save_models(\\n args.output + \\\"_updates_{}\\\".format(update_i),\\n asv_model,\\n preprocessing_parameters,\\n cm_feature_network,\\n cm_model,\\n bonafide_cm_features\\n )\\n\\n\\n if args.output is not None:\\n save_models(\\n args.output,\\n asv_model,\\n preprocessing_parameters,\\n cm_feature_network,\\n cm_model,\\n bonafide_cm_features\\n )\",\n \"def argparser():\\n ap = argparse.ArgumentParser(fromfile_prefix_chars='@',\\n description='Train and deploy a deep-learned [Fe/H] estimator'\\n 'based on Gaia time-series photometry.',\\n epilog=\\\"\\\")\\n\\n # use custom line parser for the parameter file\\n ap.convert_arg_line_to_args = convert_arg_line_to_args\\n\\n ap.add_argument('-v',\\n '--verbose',\\n action='store_true', # assign True value if used\\n help='Generate verbose output.')\\n\\n ap.add_argument('--seed',\\n action='store',\\n type=int,\\n default=1,\\n help='Integer seed for reproducible results.')\\n\\n ap.add_argument('--rootdir',\\n action='store',\\n type=str,\\n default=os.path.expanduser('~'),\\n help='Full path of the root directory '\\n '(all other directory and file names will be relative to this, default: `~`).')\\n\\n ap.add_argument('--input_list',\\n action='store',\\n type=str,\\n default='lcfit_input.lst',\\n help='Name of the input list file (default: `lcfit_input.lst`)')\\n\\n ap.add_argument('--input_dir',\\n action='store',\\n type=str,\\n default='.',\\n help='Subdirectory of the input time series (default: `.`)')\\n\\n ap.add_argument('--gls_input_file',\\n action='store',\\n type=str,\\n default='gls_input.dat',\\n help='Name of the GLS input file (created by the external code `gls` and read by `lcfit`, '\\n 'default: `gls_input.dat`)')\\n\\n ap.add_argument('--input_lc_suffix',\\n action='store',\\n type=str,\\n default='.dat',\\n help='Suffix for the input time series file names (default: `.dat`).')\\n\\n ap.add_argument('--input_lc_prefix',\\n action='store',\\n type=str,\\n default='',\\n help='Prefix for the input time series file names (default: no prefix).')\\n\\n ap.add_argument('--output_dir',\\n action='store',\\n type=str,\\n default='data',\\n help='If specified, the clipped, phased, phase-sorted light curves will be written to '\\n 'this directory, into a separate file for each time series (default: `data`).')\\n\\n ap.add_argument('--output_syn_dir',\\n action='store',\\n type=str,\\n default=None,\\n help='If specified, the synthetic output time series will be written to '\\n 'this directory (separate file for each time series).')\\n\\n ap.add_argument('--plot_dir',\\n action='store',\\n type=str,\\n default='plots',\\n help='Subdirectory of the output figures.')\\n\\n ap.add_argument('--plot_suffix',\\n action='store',\\n type=str,\\n default='',\\n help='Suffix for the output figures.')\\n\\n ap.add_argument('--syn_suffix',\\n action='store',\\n type=str,\\n default='_syn',\\n help='Suffix for the synthetic output time series.')\\n\\n ap.add_argument('--output_gpr_dir',\\n action='store',\\n type=str,\\n default=None,\\n help='Subdirectory (if specified) of the output Gaussian Process models.')\\n\\n ap.add_argument('--output_param_file',\\n action='store',\\n type=str,\\n default='lcfit.out',\\n help='Name of the output parameter file.')\\n\\n ap.add_argument('--output_data_dir',\\n action='store',\\n type=str,\\n default='.',\\n help='Subdirectory for output data files.')\\n\\n ap.add_argument('--merged_output_datafile',\\n action='store',\\n type=str,\\n default=None,\\n help='Name of the data file for writing all output time series, appended one after the other.')\\n\\n ap.add_argument('--degrade_lc',\\n action='store_true',\\n help='Degrade the light curve (see the source code for the corresponding parameters).')\\n\\n ap.add_argument('--compute_errors',\\n action='store_true', # assign True value if used\\n help='If `gpr_fit` is `True`, then `n_gpr_sample` random samples will be drawn from '\\n 'the fitted GPR model at the original (or if the >maxn_gpr, then the '\\n 'binned) phases, and each sample will be fitted with a Fourier series. '\\n 'The errors of Fourier parameters will be estimated therefrom.')\\n\\n ap.add_argument('--pca_model_file',\\n action='store',\\n type=str,\\n default=None,\\n help='Apply the specified PCA transformation to the Fourier parameters.')\\n\\n ap.add_argument('--feh_model_file',\\n action='store',\\n type=str,\\n default=None,\\n help='Apply the specified model to predict the [Fe/H] from the Fourier parameters.')\\n\\n ap.add_argument('--fold_double_period',\\n action='store_true', # assign True value if used\\n help='Fold the time series also with twice the period, and create the corresponding output files.')\\n\\n ap.add_argument('--loss',\\n action='store',\\n type=str,\\n choices=['linear', 'soft_l1', 'huber', 'cauchy', 'arctan'],\\n default='huber',\\n help='Type of regression loss.')\\n\\n ap.add_argument('--sigma_clip_threshold',\\n action='store',\\n type=float,\\n default=None,\\n help='If specified, outliers beyond `sigma_clip_threshold` * residual std. dev. '\\n 'will be iteratively omitted.')\\n\\n ap.add_argument('--align_phi1',\\n action='store_true',\\n help='The time series will be phase-aligned by the first Fourier phase defined to be at zero.')\\n\\n ap.add_argument('--null_epoch',\\n action='store',\\n type=float,\\n default=None,\\n help='Reference epoch that will be subtracted from the time values. '\\n 'If None (default), then the time of the first measurement will be used '\\n 'for every time series.')\\n\\n ap.add_argument('--gpr_fit',\\n action='store_true',\\n help='Perform Gaussian Process Regression (GPR) on the phase-folded time series.')\\n\\n ap.add_argument('--kernel',\\n action='store',\\n type=str,\\n choices=['matern', 'expsine2'],\\n default='matern',\\n help='Kernel type for the GPR. Available options: `matern`, `expsine2`. Default: `matern`.')\\n\\n ap.add_argument('--lower_length_scale_bound',\\n action='store',\\n type=float,\\n default=0.1,\\n help='Lower length scale bound for the GPR kernel. '\\n 'Used if the --gpr_fit option is selected. Default: 0.1')\\n\\n ap.add_argument('--upper_length_scale_bound',\\n action='store',\\n type=float,\\n default=10.0,\\n help='Upper length scale bound for the GPR kernel. '\\n 'Used if the --gpr_fit option is selected. Default: 10.0')\\n\\n ap.add_argument('--gpr_hparam_optimization',\\n action='store',\\n type=str,\\n choices=['mle', 'cv'],\\n default='mle',\\n help='Method for hyperparameter optimization of the Gaussian Process Regression. '\\n 'If `mle`, then the hyperparameters will be optimized by maximizing the log-likelihood '\\n '(this is the widely-used standard method for GPR). '\\n 'If `cv`, then the hyperparameters will be optimized by maximizing the R2 cross-validation '\\n 'score. The hyperparameter-space will be searched using a Bayesian approach as implemented in '\\n 'the `scikit-optimize` API, and 10-fold CV will be used for evaluation.')\\n\\n ap.add_argument('--gpr_cv_n_init',\\n action='store',\\n type=int,\\n default=10,\\n help='The number of initial estimates for Bayesian hyperparameter optimization if '\\n '`gpr_hparam_optimization` is `cv`.')\\n\\n ap.add_argument('--gpr_cv_n_calls',\\n action='store',\\n type=int,\\n default=10,\\n help='The number of iterations for Bayesian hyperparameter optimization if '\\n '`gpr_hparam_optimization` is `cv`.')\\n\\n ap.add_argument('--fourier_from_gpr',\\n action='store_true',\\n help='Infer the Fourier parameters from the best-fitting Gaussian Process Regression model.')\\n\\n ap.add_argument('--n_augment_data',\\n action='store',\\n type=int,\\n default=None,\\n help='If specified, the input time series will be augmented by drawing `n_augment_data` new '\\n 'time series from the GPR model at the original phase points.')\\n\\n ap.add_argument('--plot_augmented',\\n action='store_true',\\n help='Plot the augmented time series.')\\n\\n ap.add_argument('--k_fold',\\n action='store',\\n type=int,\\n default=10,\\n help='Number of cross-validation folds.')\\n\\n ap.add_argument('--fourier_order_min',\\n action='store',\\n type=int,\\n default=3,\\n help='Minimum Fourier order to consider.')\\n\\n ap.add_argument('--fourier_order_max',\\n action='store',\\n type=int,\\n default=8,\\n help='Maximum Fourier order to consider.')\\n\\n ap.add_argument('--is_err_col',\\n action='store_true',\\n help='The input contains (a) column(s) with the magnitudes\\\\' uncertainties.')\\n\\n ap.add_argument('--is_zperr_col',\\n action='store_true',\\n help='The input contains (a) column(s) with zero-point uncertainties.')\\n\\n ap.add_argument('--n_data_cols',\\n action='store',\\n type=int,\\n default=1,\\n help='Number of data columns per input file.')\\n\\n ap.add_argument('--use_data_cols',\\n action='store',\\n nargs='*',\\n type=int,\\n default='1',\\n help='List of data columns to use.')\\n\\n ap.add_argument('--known_data_cols',\\n action='store_true',\\n help='If set, the input list file is expected to contain an extra column with header name \\\\'col\\\\' '\\n 'containing the number of the data column to be used for regression.')\\n\\n ap.add_argument('--known_phaseshift',\\n action='store_true',\\n help='If set, the input list file is expected to contain an extra column with header name '\\n '\\\\'phaseshift\\\\', containing the phase shift to be applied to the time series.')\\n\\n ap.add_argument('--min_snr',\\n action='store',\\n type=float,\\n default=None,\\n help='If specified, a column with S/N is expected to follow each magnitude column '\\n '(or magnitude error column if included). Data points with values below `min_snr` '\\n 'will be rejected.')\\n\\n ap.add_argument('--flag_omit',\\n action='store',\\n type=str,\\n default=None,\\n help='If specified, a column with string flags is expected to follow each magnitude column '\\n '(or magnitude error column / S/N column if included). Data points with values `flag_omit` '\\n 'will be rejected.')\\n\\n ap.add_argument('--mean_phase2',\\n action='store',\\n type=float,\\n default=None,\\n help='Population mean of the phi2 Fourier parameter.')\\n\\n ap.add_argument('--mean_phase3',\\n action='store',\\n type=float,\\n default=None,\\n help='Population mean of the phi3 Fourier parameter.')\\n\\n ap.add_argument('--mean_phase21',\\n action='store',\\n type=float,\\n default=None,\\n help='Population mean of the phi21 Fourier parameter.')\\n\\n ap.add_argument('--mean_phase31',\\n action='store',\\n type=float,\\n default=None,\\n help='Population mean of the phi31 Fourier parameter.')\\n\\n ap.add_argument('--waveband',\\n action='store',\\n type=str,\\n default=None,\\n help='Name of the waveband (filter) of the input time series.')\\n\\n ap.add_argument('--plot_data',\\n action='store_true',\\n help='Plot the time series.')\\n\\n ap.add_argument('--save_figures',\\n action='store_true',\\n help='Save output plots into files.')\\n\\n ap.add_argument('--plot_gpr',\\n action='store_true',\\n help='Plot the results of the Gaussian Process Regression.')\\n\\n ap.add_argument('--plot_all_datasets',\\n action='store_true',\\n help='Create plots for all datasets.')\\n\\n ap.add_argument('--fit_period',\\n action='store_true',\\n help='Fit the period to the dataset (by non-linear least squares regression).')\\n\\n ap.add_argument('--do_gls',\\n action='store_true',\\n help='Compute an initial period estimate by the Generalized Lomb-Scargle Periodogram '\\n 'method. Otherwise an initial period value is expected in the input file.')\\n\\n ap.add_argument('--redo_gls',\\n action='store_true',\\n help='Recompute the initial period estimate by the Generalized Lomb-Scargle Periodogram '\\n 'method in the outlier rejection iterations.')\\n\\n ap.add_argument('--weighted_fit',\\n action='store_true',\\n help='Use squared inverse of the errors as weights in the regression.')\\n\\n ap.add_argument('--nsyn',\\n action='store',\\n type=int,\\n default=120,\\n help='Number of equidistant phase points for the output synthetic data '\\n '(i.e., points of evaluation of the regression model.)')\\n\\n ap.add_argument('--min_ndata',\\n action='store',\\n type=int,\\n default=20,\\n help='Minimum number of data points in the time series to be considered for analysis.')\\n\\n ap.add_argument('--n_jobs',\\n action='store',\\n type=int,\\n default=None,\\n help='The number parallel threads. If not specified, n_jobs=max(n_cores, k_fold)')\\n\\n return ap\",\n \"def init_model(config, program, exe):\\n checkpoints = config['Global'].get('checkpoints')\\n if checkpoints:\\n if os.path.exists(checkpoints + '.pdparams'):\\n path = checkpoints\\n fluid.load(program, path, exe)\\n logger.info(\\\"Finish initing model from {}\\\".format(path))\\n else:\\n raise ValueError(\\\"Model checkpoints {} does not exists,\\\"\\n \\\"check if you lost the file prefix.\\\".format(\\n checkpoints + '.pdparams'))\\n else:\\n pretrain_weights = config['Global'].get('pretrain_weights')\\n if pretrain_weights:\\n path = pretrain_weights\\n load_params(exe, program, path)\\n logger.info(\\\"Finish initing model from {}\\\".format(path))\",\n \"def main(_):\\n if not FLAGS.model_output_dir:\\n raise ValueError(\\n \\\"Undefined model output directory. Perhaps you forgot to set the --model_output_dir flag?\\\")\\n \\n if FLAGS.predict_input_file:\\n decode()\\n else:\\n train()\",\n \"def main():\\n parser = argparse.ArgumentParser(description=\\\"Convert a checkpoint file into a support sets and a reconstructor \\\"\\n \\\"weights files\\\")\\n parser.add_argument('--exp', type=str, required=True, help=\\\"set experiment's model dir (created by `train.py`)\\\")\\n\\n # Parse given arguments\\n args = parser.parse_args()\\n\\n # Check structure of `args.exp`\\n if not osp.isdir(args.exp):\\n raise NotADirectoryError(\\\"Invalid given directory: {}\\\".format(args.exp))\\n models_dir = osp.join(args.exp, 'models')\\n if not osp.isdir(models_dir):\\n raise NotADirectoryError(\\\"Invalid models directory: {}\\\".format(models_dir))\\n checkpoint_file = osp.join(models_dir, 'checkpoint.pt')\\n if not osp.isfile(checkpoint_file):\\n raise FileNotFoundError(\\\"Checkpoint file not found: {}\\\".format(checkpoint_file))\\n\\n print(\\\"#. Convert checkpoint file into support sets and reconstructor weight files...\\\")\\n\\n # Load checkpoint file\\n checkpoint_dict = torch.load(checkpoint_file)\\n\\n # Get checkpoint iteration\\n checkpoint_iter = checkpoint_dict['iter']\\n print(\\\" \\\\\\\\__Checkpoint iteration: {}\\\".format(checkpoint_iter))\\n\\n # Save support sets weights file\\n print(\\\" \\\\\\\\__Save checkpoint support sets weights file...\\\")\\n torch.save(checkpoint_dict['support_sets'], osp.join(models_dir, 'support_sets-{}.pt'.format(checkpoint_iter)))\\n\\n # Save reconstructor weights file\\n print(\\\" \\\\\\\\__Save checkpoint reconstructor weights file...\\\")\\n torch.save(checkpoint_dict['reconstructor'], osp.join(models_dir, 'reconstructor-{}.pt'.format(checkpoint_iter)))\",\n \"def train_setup(additional_arg_parser=None, args=None):\\n if args is None:\\n args = parse_input_arguments(additional_arg_parser)\\n if args.do_eval or args.do_test:\\n args.load_pretrained = True\\n if args.load_pretrained and args.pretrained_checkpoint == '':\\n raise ValueError('Must provide --pretrained_checkpoint when using --load_pretrained')\\n if args.eval_batch_size == 0:\\n args.eval_batch_size = args.train_batch_size\\n if args.load_pretrained:\\n args.save_dir = \\\"/\\\".join(args.pretrained_checkpoint.split('/')[:-1])\\n else:\\n args.save_dir = get_save_dir(args.save_dir, args.run_name)\\n if not os.path.exists(args.save_dir):\\n os.makedirs(args.save_dir)\\n args.start_epoch = 0\\n args.start_step = 0\\n\\n split_name = 'train' if args.do_train else 'validation' if args.do_eval else 'test'\\n logger = get_logger(args.save_dir, 'log_train')\\n\\n logger.info(\\\"local_rank: %d, node_index: %d, gpu_per_node: %d\\\"%(args.local_rank, args.node_index, args.gpu_per_node))\\n # Setup CUDA, GPU & distributed training\\n if args.local_rank == -1 or args.no_cuda:\\n device = torch.device(\\\"cuda\\\" if torch.cuda.is_available() and not args.no_cuda else \\\"cpu\\\")\\n args.n_gpu = torch.cuda.device_count()\\n else: # Initializes the distributed backend which will take care of sychronizing nodes/GPUs\\n torch.cuda.set_device(args.local_rank)\\n device = torch.device(\\\"cuda\\\", args.local_rank)\\n torch.distributed.init_process_group(backend='nccl')\\n args.local_rank += args.node_index * args.gpu_per_node\\n args.n_gpu = 1\\n args.device = device\\n\\n logger.info(\\\"Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s, world size: %s\\\",\\n args.local_rank, device, args.n_gpu, bool(args.local_rank != -1), args.fp16,\\n torch.distributed.get_world_size() if args.local_rank != -1 else 1)\\n\\n set_seed(args)\\n\\n return args, logger\",\n \"def __init__(self, classification, extras=[]):\\n self.model_list = []\\n self._generate_model_list(classification)\\n self.model_list.extend(extras)\\n self.classification = classification\",\n \"def load_seq_model():\\n model = joblib.load(os.path.join(os.path.dirname(__file__), 'RuleSet3.pkl'))\\n return model\",\n \"def setup(args):\\n cfg = get_cfg()\\n cfg.merge_from_file(args.config_file)\\n cfg.merge_from_list(args.opts)\\n # customize reszied parameters\\n # cfg['INPUT']['MIN_SIZE_TRAIN'] = (20,)\\n # cfg['INPUT']['MAX_SIZE_TRAIN'] = 50\\n cfg.freeze()\\n default_setup(\\n cfg, args\\n ) # if you don't like any of the default setup, write your own setup code\\n return cfg\",\n \"def main():\\n\\n ############################ variable settings #################################\\n parser = argparse.ArgumentParser(description='Run Subtask C of GermEval 2017 Using Pre-Trained Language Model.')\\n parser.add_argument('--seed', type=int, default=42, help='Random seed.')\\n parser.add_argument('--lang_model', type=str, default='bert-base-german-dbmdz-uncased', help='The pre-trained language model.')\\n parser.add_argument('--epochs', type=int, default=4, help='Number of epochs for training.')\\n parser.add_argument('--lr', type=float, default=5e-5, help='The learning rate.')\\n parser.add_argument('--max_len', type=int, default=256, help='The maximum sequence length of the input text.')\\n parser.add_argument('--batch_size', type=int, default=32, help='Your train set batch size.')\\n parser.add_argument('--df_path', type=str, default='./data/', help='The data directory.') \\n parser.add_argument('--train_data', type=str, default='train_df_cat.tsv', help='The filename of the input train data.')\\n parser.add_argument('--dev_data', type=str, default='dev_df_cat.tsv', help='The filename of the input development data.')\\n parser.add_argument('--test_data1', type=str, default='test_syn_df_cat.tsv', help='The filename of the first input test data (synchronic).')\\n parser.add_argument('--test_data2', type=str, default='test_dia_df_cat.tsv', help='The filename of the second input test data (diachronic).')\\n parser.add_argument('--output_path', type=str, default='./output/subtaskC/', help='The output directory of the model and predictions.')\\n parser.add_argument(\\\"--train\\\", default=True, action=\\\"store_true\\\", help=\\\"Flag for training.\\\")\\n parser.add_argument(\\\"--save_prediction\\\", default=False, action=\\\"store_true\\\", help=\\\"Flag for saving predictions.\\\")\\n parser.add_argument(\\\"--save_cr\\\", default=False, action=\\\"store_true\\\", help=\\\"Flag for saving confusion matrix.\\\")\\n parser.add_argument(\\\"--exclude_general\\\", default=False, action=\\\"store_true\\\", help=\\\"Flag for excluding category Allgemein.\\\")\\n parser.add_argument(\\\"--exclude_neutral\\\", default=False, action=\\\"store_true\\\", help=\\\"Flag for excluding neutral polarity.\\\")\\n parser.add_argument(\\\"--exclude_general_neutral\\\", default=False, action=\\\"store_true\\\", help=\\\"Flag for excluding category Allgemein:neutral.\\\")\\n args = parser.parse_args()\\n ################################################################################\\n set_all_seeds(args.seed)\\n device, n_gpu = initialize_device_settings(use_cuda=True)\\n \\n # Load data\\n train_df = pd.read_csv(args.df_path + args.train_data, delimiter = '\\\\t')\\n dev_df = pd.read_csv(args.df_path + args.dev_data, delimiter = '\\\\t')\\n test_syn_df = pd.read_csv(args.df_path + args.test_data1, delimiter = '\\\\t')\\n test_dia_df = pd.read_csv(args.df_path + args.test_data2, delimiter = '\\\\t')\\n \\n # Create a tokenizer\\n lower_case = False\\n if args.lang_model[-7:] == \\\"uncased\\\":\\n lower_case = True\\n\\n if args.lang_model[:4] == \\\"bert\\\":\\n model_class = \\\"BERT\\\"\\n tokenizer = BertTokenizer.from_pretrained(args.lang_model, do_lower_case=lower_case, max_length=args.max_len)\\n \\n if args.lang_model[:10] == \\\"distilbert\\\":\\n model_class = \\\"DistilBERT\\\"\\n tokenizer = DistilBertTokenizer.from_pretrained(args.lang_model, do_lower_case=lower_case, max_length=args.max_len)\\n \\n\\n # get training features\\n cats = train_df.columns[5:]\\n end = \\\"full\\\"\\n # exclude categories if required\\n if (args.exclude_general):\\n cats = [i for i in list(cats) if \\\"Allgemein\\\" not in i]\\n end = \\\"excl_gen\\\"\\n if (args.exclude_neutral):\\n cats = [i for i in list(cats) if \\\"neutral\\\" not in i]\\n end = \\\"excl_neu\\\"\\n if (args.exclude_general_neutral):\\n cats = [i for i in list(cats) if \\\"Allgemein:neutral\\\" not in i]\\n end = \\\"excl_genneu\\\"\\n \\n num_labels = len(list(cats))\\n\\n # create one hot labels\\n train_df['one_hot_labels'] = list(train_df[list(cats)].values)\\n dev_df['one_hot_labels'] = list(dev_df[list(cats)].values)\\n test_syn_df['one_hot_labels'] = list(test_syn_df[list(cats)].values)\\n test_dia_df['one_hot_labels'] = list(test_dia_df[list(cats)].values)\\n\\n # retrieve sentences and labels\\n df = pd.concat([train_df, dev_df])\\n sentences = df.text.values\\n labels = list(df.one_hot_labels.values) \\n\\n sentences_syn = test_syn_df.text.values\\n labels_syn = list(test_syn_df.one_hot_labels.values)\\n\\n sentences_dia = test_dia_df.text.values\\n labels_dia = list(test_dia_df.one_hot_labels.values)\\n \\n print(\\\"number of categories:\\\", len(list(cats)))\\n\\n # Tokenize all of the sentences and map the tokens to their word IDs. \\n input_ids = [tokenizer.encode(sent, add_special_tokens=True, truncation=True, \\n max_length=args.max_len) for sent in sentences]\\n input_ids = pad_sequences(input_ids, maxlen=args.max_len, dtype=\\\"long\\\", \\n value=0.0, truncating=\\\"post\\\", padding=\\\"post\\\")\\n # Create attention masks\\n attention_masks = [[int(token_id > 0) for token_id in sent] for sent in input_ids]\\n \\n # synchronic test data\\n input_ids_syn = [tokenizer.encode(sent, add_special_tokens=True, truncation=True) for sent in sentences_syn]\\n input_ids_syn = pad_sequences(input_ids_syn, maxlen=args.max_len, dtype=\\\"long\\\", \\n value=0.0, truncating=\\\"post\\\", padding=\\\"post\\\")\\n attention_masks_syn = [[int(token_id > 0) for token_id in sent] for sent in input_ids_syn]\\n \\n # diachronic test data\\n input_ids_dia = [tokenizer.encode(sent, add_special_tokens=True, truncation=True) for sent in sentences_dia]\\n input_ids_dia = pad_sequences(input_ids_dia, maxlen=args.max_len, dtype=\\\"long\\\", \\n value=0.0, truncating=\\\"post\\\", padding=\\\"post\\\")\\n attention_masks_dia = [[int(token_id > 0) for token_id in sent] for sent in input_ids_dia]\\n\\n # split train, dev\\n train_inputs, train_labels, dev_inputs, dev_labels, train_masks, dev_masks = split_train_dev(\\n train_df, dev_df, attention_masks, input_ids, labels)\\n \\n # transform to torch tensor\\n train_inputs = torch.tensor(train_inputs)\\n dev_inputs = torch.tensor(dev_inputs)\\n\\n train_labels = torch.tensor(train_labels)\\n dev_labels = torch.tensor(dev_labels)\\n\\n train_masks = torch.tensor(train_masks)\\n dev_masks = torch.tensor(dev_masks)\\n\\n test_syn_inputs = torch.tensor(input_ids_syn)\\n test_syn_masks = torch.tensor(attention_masks_syn)\\n test_syn_labels = torch.tensor(labels_syn)\\n\\n test_dia_inputs = torch.tensor(input_ids_dia)\\n test_dia_masks = torch.tensor(attention_masks_dia)\\n test_dia_labels = torch.tensor(labels_dia)\\n\\n # Create the DataLoader\\n train_dataloader = create_dataloader(train_inputs, train_masks, \\n train_labels, args.batch_size, train = True)\\n\\n dev_dataloader = create_dataloader(dev_inputs, dev_masks, \\n dev_labels, args.batch_size, train = False)\\n\\n test_syn_dataloader = create_dataloader(test_syn_inputs, test_syn_masks, \\n test_syn_labels, args.batch_size, \\n train = False)\\n\\n test_dia_dataloader = create_dataloader(test_dia_inputs, test_dia_masks, \\n test_dia_labels, args.batch_size, \\n train = False)\\n\\n # Create model\\n if args.train:\\n if model_class == \\\"BERT\\\":\\n config = BertConfig.from_pretrained(args.lang_model, num_labels=num_labels) \\n config.hidden_dropout_prob = 0.1 \\n model = BertForSequenceClassification.from_pretrained(\\n args.lang_model,\\n num_labels = num_labels,\\n output_attentions = False,\\n output_hidden_states = False\\n )\\n\\n if model_class == \\\"DistilBERT\\\":\\n config = DistilBertConfig.from_pretrained(args.lang_model, num_labels=num_labels) \\n config.hidden_dropout_prob = 0.1 \\n model = DistilBertForSequenceClassification.from_pretrained(\\n args.lang_model,\\n num_labels = num_labels,\\n output_attentions = False,\\n output_hidden_states = False\\n )\\n model.cuda()\\n\\n\\n # Create an optimizer\\n param_optimizer = list(model.named_parameters())\\n no_decay = ['bias', 'LayerNorm.weight']\\n optimizer_grouped_parameters = [\\n {'params': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],\\n 'weight_decay_rate': 0.01},\\n {'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)],\\n 'weight_decay_rate': 0.0}\\n ]\\n optimizer = AdamW(\\n optimizer_grouped_parameters,\\n lr=args.lr,\\n eps = 1e-8\\n )\\n # Total number of training steps = number of batches * number of epochs\\n total_steps = len(train_dataloader) * args.epochs\\n # Create the learning rate scheduler\\n scheduler = get_linear_schedule_with_warmup(\\n optimizer,\\n num_warmup_steps=0,\\n num_training_steps=total_steps\\n )\\n \\n # train model\\n # Main Loop\\n print(\\\"=================== Train ================\\\")\\n print(\\\"##### Language Model:\\\", args.lang_model, \\\",\\\", \\\"learning rate:\\\", args.lr)\\n print()\\n\\n track_time = time.time()\\n # trange is a tqdm wrapper around the normal python range\\n for epoch in trange(args.epochs, desc=\\\"Epoch\\\"):\\n print(\\\"Epoch: %4i\\\"%epoch, dt.datetime.now())\\n\\n model, optimizer, scheduler, tr_loss = train_multilabel(\\n train_dataloader=train_dataloader, \\n model=model, \\n device=device, \\n optimizer=optimizer, \\n scheduler=scheduler, \\n num_labels=num_labels\\n )\\n # EVALUATION: TRAIN SET\\n pred_bools_train, true_bools_train, f1_train = eval_multilabel(\\n train_dataloader, model=model, device=device)\\n print(\\\"TRAIN: micro F1 %.3f\\\"%(f1_train))\\n \\n # EVALUATION: DEV SET\\n pred_bools_dev, true_bools_dev, f1_dev = eval_multilabel(\\n dev_dataloader, model=model, device=device)\\n print(\\\"EVAL: micro F1 %.3f\\\"%(f1_dev))\\n \\n\\n print(\\\" Training and validation took in total: {:}\\\".format(format_time(time.time()-track_time)))\\n\\n # EVALUATION: TEST SYN SET\\n pred_bools_syn, true_bools_syn, f1_test_syn = eval_multilabel(\\n test_syn_dataloader, model=model, device=device)\\n print(\\\"TEST SYN: micro F1 %.4f\\\"%(f1_test_syn))\\n\\n # classification report\\n clf_report_syn = classification_report(true_bools_syn, pred_bools_syn, target_names=cats, digits=3)\\n print(clf_report_syn)\\n\\n\\n # EVALUATION: TEST DIA SET\\n pred_bools_dia, true_bools_dia, f1_test_dia = eval_multilabel(\\n test_dia_dataloader, model=model, device=device\\n )\\n print(\\\"TEST DIA: micro F1 %.4f\\\"%(f1_test_dia))\\n\\n # classification report\\n clf_report_dia = classification_report(true_bools_dia, pred_bools_dia, target_names=cats, digits=3)\\n print(clf_report_dia)\\n \\n if args.save_cr:\\n pickle.dump(clf_report_syn, open(args.output_path+'clf_report_'+args.lang_model+'_test_syn_'+str(num_labels)+end+'.txt','wb'))\\n pickle.dump(clf_report_dia, open(args.output_path+'clf_report_'+args.lang_model+'_test_dia_'+str(num_labels)+end+'.txt','wb'))\\n\\n\\n if args.save_prediction:\\n test_syn_df[\\\"category_pred\\\"] = pred_bools_syn\\n test_dia_df[\\\"category_pred\\\"] = pred_bools_dia\\n test_syn_df.category_pred.to_csv(args.output_path+args.lang_model+'_test_syn_'+str(num_labels)+end+\\\".tsv\\\", \\n sep=\\\"\\\\t\\\", index = False, header = True, encoding = \\\"utf-8-sig\\\")\\n test_dia_df.category_pred.to_csv(args.output_path+args.lang_model+'_test_dia_'+str(num_labels)+end+\\\".tsv\\\", \\n sep=\\\"\\\\t\\\", index = False, header = True, encoding = \\\"utf-8-sig\\\")\",\n \"def main(unused_argv):\\n\\n # Create tokenizer based on the training files.\\n logging.info(\\\"Step 1: Loading tokenizer\\\")\\n train_en = FLAGS.data_dir+'/EN_TRAIN_CORPUS_NAME'\\n val_en = FLAGS.data_dir+'/EN_VAL_CORPUS_NAME'\\n\\n VOCAB_FILE = \\\"VOCAB_NAME\\\" \\n vocab_file = os.path.join(FLAGS.data_dir, VOCAB_FILE)\\n subtokenizer = tokenizer.Subtokenizer.init_from_files(\\n vocab_file, [train_en], _TARGET_VOCAB_SIZE, _TARGET_THRESHOLD,\\n min_count=None if FLAGS.search else _TRAIN_DATA_MIN_COUNT)\\n\\n compiled_train_files = (train_en, train_en)\\n compiled_eval_files = (val_en, val_en)\\n\\n # Tokenize and save data as Examples in the TFRecord format.\\n logging.info(\\\"Step 3: Preprocessing and saving data\\\")\\n train_tfrecord_files = encode_and_save_files(\\n subtokenizer, FLAGS.data_dir, compiled_train_files, _TRAIN_TAG,\\n _TRAIN_SHARDS)\\n encode_and_save_files(\\n subtokenizer, FLAGS.data_dir, compiled_eval_files, _EVAL_TAG,\\n _EVAL_SHARDS)\\n\\n for fname in train_tfrecord_files:\\n shuffle_records(fname)\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"--model\\\",\\n dest=\\\"model\\\",\\n help=\\\"Model to train\\\",\\n choices=[\\\"lstm\\\", \\\"bi-lstm\\\", \\\"lstm-attention\\\", \\\"bi-lstm-attention\\\"],\\n required=True,\\n )\\n parser.add_argument(\\n \\\"--units\\\", dest=\\\"units\\\", help=\\\"Num of LSTM units\\\", default=256, type=int\\n )\\n parser.add_argument(\\n \\\"--epochs\\\",\\n dest=\\\"epochs\\\",\\n help=\\\"Num of epochs to train for\\\",\\n default=100,\\n type=int,\\n )\\n parser.add_argument(\\n \\\"--sequence-length\\\",\\n dest=\\\"sequence_length\\\",\\n help=\\\"Sequence length\\\",\\n default=100,\\n type=int,\\n )\\n args = parser.parse_args()\\n train_network(\\n args.model,\\n batch_size=64,\\n epochs=args.epochs,\\n num_units=args.units,\\n sequence_length=args.sequence_length,\\n )\",\n \"def batch_mode(args):\\n ui_mode = False\\n extloader = ExtensionLoader()\\n pipeline = Pipeline(extloader.cats_container, ui_mode)\\n # processing args values\\n if args.pipeline:\\n # load the specified pipeline file\\n # default url\\n pipeline.load_pipeline_json(args.pipeline)\\n if args.dir:\\n # load the images from the specified source dir\\n pipeline.set_input(args.dir)\\n elif args.file:\\n # load a single image\\n pipeline.set_input(args.file)\\n if args.out:\\n pipeline.set_output_dir(args.out)\\n pipeline.process()\",\n \"def from_args(args, verbose=False, unhandled=None):\\n\\n # Create a list for unhandled arguments\\n if unhandled is None:\\n unhandled = []\\n\\n experiments = ExperimentList()\\n ## First try as image files\\n # experiments = ExperimentListFactory.from_datablock(\\n # DataBlockFactory.from_args(args, verbose, unhandled1))\\n\\n # Try to load from serialized formats\\n for filename in args:\\n try:\\n experiments.extend(\\n ExperimentListFactory.from_serialized_format(filename)\\n )\\n if verbose:\\n print(\\\"Loaded experiments from %s\\\" % filename)\\n except Exception as e:\\n if verbose:\\n print(\\\"Could not load experiments from %s: %s\\\" % (filename, str(e)))\\n unhandled.append(filename)\\n\\n # Return the experiments\\n return experiments\",\n \"def get_args():\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument('--training', type=argparse.FileType(), default='./data/cdt.epe',\\n help='epe file with training sentences.')\\n parser.add_argument('--validation', type=argparse.FileType(), default='./data/cdd.epe',\\n help='epe file with validation sentences.')\\n parser.add_argument('--metrics', type=argparse.FileType(\\\"w\\\"), default=sys.stdout,\\n help='where to output metrics computed on validation.')\\n parser.add_argument('--mode', choices=['BASELINE', 'BASELINE_C', 'BASELINE_C_POS'], default='BASELINE',\\n help='mode in which model is trained, C adds cue information, POS adds pos tags.')\\n parser.add_argument('--arch', choices=['LSTM', 'GRU'], default='LSTM',\\n help='which recurrent network architecture to use.')\\n parser.add_argument('--word_vectors', default=None,\\n help='file with word embeddings')\\n parser.add_argument('--epochs', type=int, default=10,\\n help='number of epochs to train the model.')\\n parser.add_argument('--lr', type=float, default=1e-4,\\n help='learning rate used in adam optimizer.')\\n parser.add_argument('--max_len', type=int, default=100,\\n help='maximum length of sentence.')\\n parser.add_argument('--hidden_size', type=int, default=200,\\n help='memory size of recurrent neural network.')\\n parser.add_argument('--negations_only', action='store_true', default=False,\\n help='if present, only sentences with at least one negation are used.')\\n parser.add_argument('--tensorboard', action='store_true', default=False)\\n parser.add_argument('--save', default=None, help='directory where to save model.')\\n\\n return parser.parse_args()\",\n \"def add_cmdline_args(argparser):\\n DictionaryAgent.add_cmdline_args(argparser)\\n agent = argparser.add_argument_group('Fairseq Arguments')\\n agent.add_argument(\\n '-tr', '--truncate',\\n type=int, default=-1,\\n help='truncate input & output lengths to speed up training (may '\\n 'reduce accuracy). This fixes all input and output to have a '\\n 'maximum length. This reduces the total amount of padding in '\\n 'the batches.')\\n agent.add_argument(\\n '--max-positions',\\n default=1024,\\n type=int,\\n metavar='N',\\n help='max number of tokens in the sequence')\\n agent.add_argument(\\n '--seed',\\n default=1,\\n type=int,\\n metavar='N',\\n help='pseudo random number generator seed')\\n options.add_optimization_args(argparser)\\n options.add_generation_args(argparser)\\n options.add_model_args(argparser)\",\n \"def main() -> None:\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--model-artm\\\", required=True,\\n help=\\\"Path to directory with BigARTM model\\\")\\n args = parser.parse_args()\\n model_artm = artm.load_artm_model(args.model_artm)\\n\\n with open('topic_issue_model.pickle', 'rb') as issue_pickle_file:\\n topic_issue_model: TopicIssueModel = pickle.load(issue_pickle_file)\\n predict_topics(topic_issue_model, model_artm)\",\n \"def main():\\n\\n parser = argparse.ArgumentParser(description='Duolingo shared task baseline model')\\n parser.add_argument('--train', help='Training file name', required=True)\\n parser.add_argument('--test', help='Test file name, to make predictions on', required=True)\\n parser.add_argument('--pred', help='Output file name for predictions, defaults to test_name.pred')\\n args = parser.parse_args()\\n\\n if not args.pred:\\n args.pred = args.test + '.pred'\\n\\n assert os.path.isfile(args.train)\\n assert os.path.isfile(args.test)\\n\\n # Assert that the train course matches the test course\\n assert os.path.basename(args.train)[:5] == os.path.basename(args.test)[:5]\\n\\n training_data, training_labels = load_data(args.train)\\n test_data = load_data(args.test)\\n\\n ####################################################################################\\n # Here is the delineation between loading the data and running the baseline model. #\\n # Replace the code between this and the next comment block with your own. #\\n ####################################################################################\\n\\n\\n vectorizer = DictVectorizer()\\n X_train = [instance_data.to_features() for instance_data in training_data]\\n Y_train = [training_labels[instance_data.instance_id] for instance_data in training_data]\\n ids_train = [instance_data.instance_id for instance_data in training_data]\\n\\n X_test = [instance_data.to_features() for instance_data in test_data]\\n ids_test = [instance_data.instance_id for instance_data in test_data]\\n\\n\\n X_train = vectorizer.fit_transform(X_train)\\n clf = LogisticRegression()\\n clf.fit(X_train,Y_train)\\n\\n X_test = vectorizer.transform(X_test)\\n preds_scores = [x[0] for x in clf.predict_proba(X_test)]\\n predictions = dict([(instance_id,pred_score) for instance_id,pred_score in zip(ids_test,preds_scores)])\\n\\n ####################################################################################\\n # This ends the baseline model code; now we just write predictions. #\\n ####################################################################################\\n\\n with open(args.pred, 'wt') as f:\\n for instance_id, prediction in iteritems(predictions):\\n f.write(instance_id + ' ' + str(prediction) + '\\\\n')\",\n \"def predict_input_args():\\n # Create Parse using ArgumentParser\\n parser = argparse.ArgumentParser()\\n parser.add_argument('image', type = str, help = 'Path to the folder and file name of image to be checked') \\n parser.add_argument('checkpoint', type = str, help = 'Checkpoint folder name') \\n parser.add_argument('--gpu', type = bool, default = False, help = 'True = GPU enabled, False = GPU disabled') \\n parser.add_argument('--topk', type = int, default = 5, help = 'Top number of class predicitions') \\n parser.add_argument('--json', type = str, default = 'cat_to_name.json', help = 'Path to the folder and file name of JSON map used') \\n return parser.parse_args()\",\n \"def main(args):\\n bad_words_file = codecs.open(args.language + \\\"/feature_files/bad_words\\\", \\\"r\\\", \\\"utf-8\\\").readlines()\\n bad_words = read_known_words(bad_words_file)\\n \\n good_words_file = codecs.open(args.language + \\\"/feature_files/good_words\\\", \\\"r\\\", \\\"utf-8\\\").readlines()\\n good_words = read_known_words(good_words_file)\\n\\n curse_words_file = codecs.open(args.language + \\\"/feature_files/curse_words\\\", \\\"r\\\", \\\"utf-8\\\").readlines()\\n curse_words = read_known_words(curse_words_file)\\n\\n prepositions_file = codecs.open(args.language + \\\"/feature_files/prepositions\\\", \\\"r\\\", \\\"utf-8\\\").readlines()\\n prepositions = read_known_words(prepositions_file)\\n\\n determiners_file = codecs.open(args.language + \\\"/feature_files/determiners\\\", \\\"r\\\", \\\"utf-8\\\").readlines()\\n determiners = read_known_words(determiners_file)\\n\\n syllables_file = codecs.open(args.language + \\\"/feature_files/syllables\\\", \\\"r\\\", \\\"utf-8\\\").readlines()\\n syllable_structure = read_syllables_file(syllables_file)\\n\\n other_feature_files = glob.glob(args.language + \\\"/feature_files/*.txt\\\")\\n other_features = set_features_from_files(other_feature_files)\\n \\n ermaObj = ConllToErma(args, bad_words, good_words, curse_words, prepositions, \\\\\\n determiners, syllable_structure, other_features)\\n\\n if not args.just_test:\\n # Input training file.\\n train_id = open(args.train, \\\"r\\\")\\n train = train_id.readlines()\\n train_id.close()\\n sys.stdout.write(\\\"Reading training file...\\\\n\\\")\\n (train_features, train_skip_chains) = ermaObj.read_conll_file(train)\\n sys.stdout.write(\\\"Building model...\\\\n\\\")\\n train_hash = ermaObj.make_nodes(train_features)\\n # Freeze the known features based on what's seen in the training data\\n ermaObj.cutoff_features()\\n else:\\n train_hash = {}\\n train_skip_chains = {}\\n # Input testing file.\\n test_id = open(args.test, \\\"r\\\")\\n test = test_id.readlines()\\n test_id.close()\\n sys.stdout.write(\\\"Reading test file...\\\\n\\\")\\n (test_features, test_skip_chains) = ermaObj.read_conll_file(test)\\n sys.stdout.write(\\\"Building model...\\\\n\\\")\\n test_hash = ermaObj.make_nodes(test_features, test=True)\\n ermaObj.write_out(train_hash, train_skip_chains, test_hash, test_skip_chains)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser('Reading Comprehension on BaiduRC dataset')\\n parser.add_argument('--prepare', action='store_true',\\n help='create the directories, prepare the vocabulary and embeddings')\\n parser.add_argument('--train', action='store_true',\\n help='train the model')\\n parser.add_argument('--generate', action='store_true',\\n help='predict the answers for test set with trained model')\\n parser.add_argument('--gentest', action='store_true',\\n help='predict the answers for test set with trained model')\\n parser.add_argument('--gpu', type=str, default='0',\\n help='specify gpu device')\\n\\n train_settings = parser.add_argument_group('train settings')\\n train_settings.add_argument('--optim', default='Adam',\\n help='optimizer type')\\n train_settings.add_argument('--learning_rate', type=float, default=0.001,\\n help='learning rate')\\n train_settings.add_argument('--weight_decay', type=float, default=0,\\n help='weight decay')\\n train_settings.add_argument('--dropout', type=float, default=0,\\n help='dropout keep rate')\\n train_settings.add_argument('--batch_size', type=int, default=128,\\n help='train batch size')\\n train_settings.add_argument('--epochs', type=int, default=10,\\n help='train epochs')\\n\\n model_settings = parser.add_argument_group('model settings')\\n model_settings.add_argument('--embed_size', type=int, default=128,\\n help='size of the embeddings')\\n model_settings.add_argument('--hidden_size', type=int, default=256,\\n help='size of LSTM hidden units')\\n model_settings.add_argument('--max_seq_len', type=int, default=50,\\n help='max passage num in one sample')\\n model_settings.add_argument('--max_gen_len', type=int, default=50,\\n help='max length of passage')\\n\\n path_settings = parser.add_argument_group('path settings')\\n path_settings.add_argument('--vocab_dir', default='../data/vocab/',\\n help='the dir to save vocabulary')\\n path_settings.add_argument('--model_dir', default='../data/models/',\\n help='the dir to store models')\\n path_settings.add_argument('--result_dir', default='../data/results/',\\n help='the dir to output the results')\\n path_settings.add_argument('--summary_dir', default='../data/summary/',\\n help='the dir to write tensorboard summary')\\n path_settings.add_argument('--log_path',\\n help='path of the log file. If not set, logs are printed to console')\\n return parser.parse_args()\",\n \"def process_args():\\n\\n parser = argparse.ArgumentParser()\\n\\n # argument group for parameters related to input/output\\n # (e.g. filenames, logging/verbosity options, target genes)\\n #\\n # these don't affect the model output, and thus don't need to be saved\\n # with the results of the experiment\\n io = parser.add_argument_group('io',\\n 'arguments related to script input/output, '\\n 'note these will *not* be saved in metadata ')\\n io.add_argument('--custom_genes', nargs='*', default=None,\\n help='currently this needs to be a subset of top_50')\\n io.add_argument('--gene_set', type=str,\\n choices=['top_50', 'vogelstein', 'custom'],\\n default='top_50',\\n help='choose which gene set to use. top_50 and vogelstein are '\\n 'predefined gene sets (see data_utilities), and custom allows '\\n 'any gene or set of genes in TCGA, specified in --custom_genes')\\n io.add_argument('--log_file', default=None,\\n help='name of file to log skipped genes to')\\n io.add_argument('--results_dir', default=cfg.results_dirs['multimodal'],\\n help='where to write results to')\\n io.add_argument('--verbose', action='store_true')\\n\\n # argument group for parameters related to model training/evaluation\\n # (e.g. model hyperparameters, preprocessing options)\\n #\\n # these affect the output of the model, so we want to save them in the\\n # same directory as the experiment results\\n opts = parser.add_argument_group('model_options',\\n 'parameters for training/evaluating model, '\\n 'these will affect output and are saved as '\\n 'experiment metadata ')\\n opts.add_argument('--debug', action='store_true',\\n help='use subset of data for fast debugging')\\n opts.add_argument('--n_dim', nargs='*', default=None,\\n help='list of compressed dimensions to use, defaults to '\\n 'uncompressed data for all data types')\\n opts.add_argument('--num_folds', type=int, default=4,\\n help='number of folds of cross-validation to run')\\n opts.add_argument('--overlap_data_types', nargs='*',\\n default=['expression'],\\n help='data types to define set of samples to use; e.g. '\\n 'set of data types for a model comparison, use only '\\n 'overlapping samples from these data types')\\n opts.add_argument('--seed', type=int, default=cfg.default_seed)\\n opts.add_argument('--subset_mad_genes', type=int, default=cfg.num_features_raw,\\n help='if included, subset gene features to this number of '\\n 'features having highest mean absolute deviation')\\n opts.add_argument('--training_data', nargs='*', default=['expression'],\\n help='which data types to train model on')\\n\\n args = parser.parse_args()\\n\\n args.results_dir = Path(args.results_dir).resolve()\\n\\n if args.log_file is None:\\n args.log_file = Path(args.results_dir, 'log_skipped.tsv').resolve()\\n\\n if args.gene_set == 'custom':\\n if args.custom_genes is None:\\n parser.error('must include --custom_genes when --gene_set=\\\\'custom\\\\'')\\n args.gene_set = args.custom_genes\\n del args.custom_genes\\n elif (args.gene_set != 'custom' and args.custom_genes is not None):\\n parser.error('must use option --gene_set=\\\\'custom\\\\' if custom genes are included')\\n\\n # check that all training data types are defined in config\\n if (len(set(args.training_data).intersection(set(cfg.data_types.keys()))) !=\\n len(set(args.training_data))):\\n parser.error('training_data data types must be in config.data_types')\\n\\n # check that all data types in overlap_data_types are valid\\n #\\n # here I'm just checking this argument against the non-compressed data types,\\n # downstream code will check if data types we request compressed data for\\n # really have compressed data, but don't need to catch that here\\n check_all_data_types(parser, args.overlap_data_types, args.debug)\\n\\n # split args into defined argument groups, since we'll use them differently\\n arg_groups = du.split_argument_groups(args, parser)\\n io_args, model_options = arg_groups['io'], arg_groups['model_options']\\n\\n # if no n_dim argument provided, set all to None\\n if model_options.n_dim is None:\\n model_options.n_dim = [None] * len(model_options.training_data)\\n else:\\n # convert None strings from argparse to python Nones\\n model_options.n_dim = (\\n [None if n == 'None' else n for n in model_options.n_dim]\\n )\\n\\n # add some additional hyperparameters/ranges from config file to model options\\n # these shouldn't be changed by the user, so they aren't added as arguments\\n model_options.alphas = cfg.alphas\\n model_options.l1_ratios = cfg.l1_ratios\\n\\n # for these experiments, we need to standardize all data types that are not\\n # already PCA compressed\\n model_options.standardize_data_types = (\\n [t for ix, t in enumerate(model_options.training_data)\\n if model_options.n_dim[ix] == None]\\n )\\n\\n return io_args, model_options\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6719115","0.64597875","0.64026177","0.6383858","0.6353411","0.6342971","0.6329676","0.62917","0.61846244","0.6178162","0.61706626","0.6156029","0.61509514","0.61228794","0.61039567","0.6080009","0.6074509","0.60659707","0.603283","0.602758","0.59777206","0.5972045","0.5971415","0.5943919","0.59110254","0.5908065","0.58988625","0.58962274","0.5891677","0.58914775","0.58809155","0.58713543","0.5862393","0.58304065","0.5830212","0.58200264","0.5814785","0.5810352","0.5809035","0.58063924","0.5794066","0.5787346","0.57841694","0.5782497","0.5781083","0.5779232","0.5778258","0.5773134","0.57474554","0.5746061","0.5738586","0.5735646","0.57296664","0.57284623","0.572379","0.57216066","0.5714478","0.57113254","0.57087725","0.5707023","0.56977206","0.568389","0.5673887","0.56725353","0.565732","0.5655358","0.56514615","0.5650234","0.5647127","0.56468076","0.56430674","0.5640362","0.5639865","0.5630111","0.5628509","0.56239295","0.5622899","0.5622108","0.56169975","0.5615554","0.56116813","0.5604258","0.5595336","0.55884576","0.55856556","0.5582913","0.55805296","0.5577146","0.55717456","0.5566454","0.5565541","0.55613065","0.5559047","0.5547459","0.55462813","0.5542417","0.55386674","0.5537096","0.5531154","0.55302256"],"string":"[\n \"0.6719115\",\n \"0.64597875\",\n \"0.64026177\",\n \"0.6383858\",\n \"0.6353411\",\n \"0.6342971\",\n \"0.6329676\",\n \"0.62917\",\n \"0.61846244\",\n \"0.6178162\",\n \"0.61706626\",\n \"0.6156029\",\n \"0.61509514\",\n \"0.61228794\",\n \"0.61039567\",\n \"0.6080009\",\n \"0.6074509\",\n \"0.60659707\",\n \"0.603283\",\n \"0.602758\",\n \"0.59777206\",\n \"0.5972045\",\n \"0.5971415\",\n \"0.5943919\",\n \"0.59110254\",\n \"0.5908065\",\n \"0.58988625\",\n \"0.58962274\",\n \"0.5891677\",\n \"0.58914775\",\n \"0.58809155\",\n \"0.58713543\",\n \"0.5862393\",\n \"0.58304065\",\n \"0.5830212\",\n \"0.58200264\",\n \"0.5814785\",\n \"0.5810352\",\n \"0.5809035\",\n \"0.58063924\",\n \"0.5794066\",\n \"0.5787346\",\n \"0.57841694\",\n \"0.5782497\",\n \"0.5781083\",\n \"0.5779232\",\n \"0.5778258\",\n \"0.5773134\",\n \"0.57474554\",\n \"0.5746061\",\n \"0.5738586\",\n \"0.5735646\",\n \"0.57296664\",\n \"0.57284623\",\n \"0.572379\",\n \"0.57216066\",\n \"0.5714478\",\n \"0.57113254\",\n \"0.57087725\",\n \"0.5707023\",\n \"0.56977206\",\n \"0.568389\",\n \"0.5673887\",\n \"0.56725353\",\n \"0.565732\",\n \"0.5655358\",\n \"0.56514615\",\n \"0.5650234\",\n \"0.5647127\",\n \"0.56468076\",\n \"0.56430674\",\n \"0.5640362\",\n \"0.5639865\",\n \"0.5630111\",\n \"0.5628509\",\n \"0.56239295\",\n \"0.5622899\",\n \"0.5622108\",\n \"0.56169975\",\n \"0.5615554\",\n \"0.56116813\",\n \"0.5604258\",\n \"0.5595336\",\n \"0.55884576\",\n \"0.55856556\",\n \"0.5582913\",\n \"0.55805296\",\n \"0.5577146\",\n \"0.55717456\",\n \"0.5566454\",\n \"0.5565541\",\n \"0.55613065\",\n \"0.5559047\",\n \"0.5547459\",\n \"0.55462813\",\n \"0.5542417\",\n \"0.55386674\",\n \"0.5537096\",\n \"0.5531154\",\n \"0.55302256\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67100024"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":92875,"cells":{"query":{"kind":"string","value":"Load the iPET config from the given command line arguments."},"document":{"kind":"string","value":"def load_ipet_config(args) -> pet.IPetConfig:\n ipet_cfg = pet.IPetConfig(generations=args.ipet_generations, logits_percentage=args.ipet_logits_percentage,\n scale_factor=args.ipet_scale_factor, n_most_likely=args.ipet_n_most_likely)\n return ipet_cfg"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_config(args):\n load_args={}\n with open(args.config, 'r') as f:\n for line in f:\n key, value = line.strip().split('=')\n try:\n value = int(value)\n except ValueError:\n try:\n value = float(value)\n except ValueError:\n value = value\n load_args[key] = value\n args.__dict__.update(load_args)","def setup_config(self, args=None):\n self.config_parse(args=args)","def cli_load_config(self, args) -> str:\n path = args.config_path\n if not os.path.isfile(path):\n return error(\"Path {} DNE\".format(path))\n\n try:\n self.config = config.from_file(path)\n return ok(\"Configuration loaded from {}\".format(path))\n except FileNotFoundError as err:\n return error(\"Could not load file: {}\".format(err))\n except json.JSONDecodeError as json_err:\n return error(\"Could not parse json file {}\".format(json_err))","def _load_config(self, args: argparse.Namespace):\n #\n # Load a config, filename may or may-not be provided...\n #\n try:\n self._config = TortugaScriptConfig.load(args.config)\n\n except ConfigException as ex:\n print(str(ex))\n sys.exit(0)\n\n #\n # Override the config with any provided argument values\n #\n if args.url:\n self._config.url = args.url\n if args.username:\n self._config.username = args.username\n if args.password:\n self._config.password = args.password\n if args.token:\n self._config.token = args.token\n self._config.verify = args.verify","def load_config(args):\n cfg=get_cfg()\n # load from yaml\n if args.cfg_file is not None:\n cfg.merge_from_file(args.cfg_file)\n\n #load from cmd\n # print(args.opts)\n # if args.opts is not None:\n # cfg.merge_from_file(args.opts)\n\n # make a checkpoint dir\n # cu.make_checkpoint_dir(cfg.OUTPUT_DIR,cfg)\n return cfg","def load_config(args):\n # Setup cfg.\n cfg = get_cfg()\n # Load config from cfg.\n if args.cfg_file is not None:\n cfg.merge_from_file(args.cfg_file)\n # Load config from command line, overwrite config from opts.\n if args.opts is not None:\n cfg.merge_from_list(args.opts)\n\n # Inherit parameters from args.\n if hasattr(args, \"num_shards\") and hasattr(args, \"shard_id\"):\n cfg.NUM_SHARDS = args.num_shards\n cfg.SHARD_ID = args.shard_id\n if hasattr(args, \"rng_seed\"):\n cfg.RNG_SEED = args.rng_seed\n if hasattr(args, \"output_dir\"):\n cfg.OUTPUT_DIR = args.output_dir\n\n # Create the checkpoint dir.\n # cu.make_checkpoint_dir(cfg.OUTPUT_DIR)\n\n return cfg","def init(self, args, **kwargs):\n # Retrieve configuration file and directory or set defaults.\n conf_file = os.path.expanduser(\n args._get('conf_file', kwargs.pop('conf_file', DEFAULT_CONF_FILE)))\n conf_dir = os.path.expanduser(\n args._get('conf_dir', kwargs.pop('conf_dir', DEFAULT_CONF_DIR)))\n commands = [value for (arg, value) in sorted(args) if arg.startswith('command')]\n\n # Load main configuration file.\n if os.path.exists(conf_file):\n self.load_cmd_file(conf_file)\n\n # Load intermediary configuration files.\n if os.path.isdir(conf_dir):\n self.load_dir(conf_dir, clg.config, commands)","def setup_config(args):\n # Set the default configuration file\n f = pkgutil.get_data(__package__, 'dnstap.conf')\n cfg = load_yaml(f)\n\n # Overwrites then with the external file ? \n if args.c:\n cfg_ext = load_yaml(open(args.c, 'r'))\n merge_cfg(u=cfg_ext,o=cfg)\n\n # Or searches for a file named dnstap.conf in /etc/dnstap_receiver/ \n else:\n etc_conf = \"/etc/dnstap_receiver/dnstap.conf\"\n f = pathlib.Path(etc_conf)\n if f.exists():\n cfg_etc = load_yaml(open(etc_conf, 'r'))\n merge_cfg(u=cfg_etc,o=cfg)\n \n # update default config with command line arguments\n if args.v:\n cfg[\"trace\"][\"verbose\"] = args.v \n if args.u is not None:\n cfg[\"input\"][\"unix-socket\"][\"enable\"] = True\n cfg[\"input\"][\"unix-socket\"][\"path\"] = args.u\n if args.l != DFLT_LISTEN_IP:\n cfg[\"input\"][\"tcp-socket\"][\"local-address\"] = args.l\n if args.l != DFLT_LISTEN_PORT:\n cfg[\"input\"][\"tcp-socket\"][\"local-port\"] = args.p\n\n return cfg","def load_config(args, path=\".\"):\n with open(path + \"/config/\" + args.config, 'r') as f:\n config = yaml.safe_load(f)\n\n for key, value in config.items():\n args.__dict__[key] = value","def LoadConfig(self, *args, **kwargs):\n # type: (*Any, **Any) -> None\n payload = {}\n for i in range(len(args)):\n payload[\"Arg%s\" % (i + 1)] = args[i]\n for item in kwargs.items():\n payload[item[0]] = item[1]\n return self._execute(\"loadConfig\", payload=payload, response_object=None)","def load_args(self):\n\n # retrieve module path\n dir_path = os.path.dirname(os.path.abspath(__file__))\n dir_path = os.path.split(dir_path)[0]\n # get all the default yaml configs with glob\n dir_path = os.path.join(dir_path, 'configs', '*.yml')\n\n # -- From default yapt configuration\n self._defaults_path = {}\n self._defaults_yapt = OmegaConf.create(dict())\n for file in glob.glob(dir_path):\n # split filename from path to create key and val\n key = os.path.splitext(os.path.split(file)[1])[0]\n self._defaults_path[key] = file\n # parse default args\n self._defaults_yapt = OmegaConf.merge(\n self._defaults_yapt, OmegaConf.load(file))\n\n # -- From command line\n self._cli_args = OmegaConf.from_cli()\n if self._cli_args.config is not None:\n self.default_config = self._cli_args.config\n del self._cli_args['config']\n self.console_log.warning(\"override default config with: %s\", self.default_config)\n\n # -- From experiment default config file\n self._default_config_args = OmegaConf.create(dict())\n if self.default_config is not None:\n self._default_config_args = OmegaConf.load(self.default_config)\n\n # -- Merge default args\n self._args = OmegaConf.merge(\n self._defaults_yapt,\n self._default_config_args)\n\n # -- Resolve interpolations to be sure all nodes are explicit\n # self._args = OmegaConf.to_container(self._args, resolve=True)\n # self._args = OmegaConf.create(self._args)\n\n # -- make args structured: it fails if accessing a missing key\n OmegaConf.set_struct(self._args, True)","def load_config(args):\n config = dict()\n #loc = [conf, os.curdir+\"config.json\", ]\n locations = [ os.curdir, os.path.expanduser(\"~\"), \"/etc/failhadoop\",\n os.environ.get(\"FAILHADOOP_ROOT\") ]\n# if args.conf:\n# locations.append(args.conf)\n\n for loc in locations:\n try:\n with open(os.path.join(loc,\"config.json\")) as source:\n conf = json.load(source)\n config.update(conf)\n except IOError:\n pass\n except:\n print(\"Cannot load config from any of the locations {0}\".format(locations))\n try:\n with open(args.conf) as source:\n conf = json.load(source)\n config.update(conf)\n except IOError:\n print(\"Cannot load config from any of the locations {0}\".format(locations))\n\n # Override config elements from command line\n for a in vars(args):\n config[a] = getattr(args,a)\n\n return config","def get_config_params(args):\n configParseObj = configparser.ConfigParser()\n configParseObj.read(args)\n return configParseObj","def load():\n global tinyConfig\n if not tinyConfig:\n tinyConfig = CmdArgs()\n return tinyConfig","def read_configuration(args):\n config = configparser.ConfigParser()\n my_config = expand_dir(vars(args)['config'])\n try:\n config.read(my_config)\n except configparser.Error:\n print(\"Config file {} couldn't be parsed\\n\\n\".format(my_config))\n return None\n # Create the internal sections\n i = \"install\"\n d = \"DEFAULT\"\n if i not in config:\n config[i] = {}\n m = i\n if \"sections\" in config[i]:\n m = d\n exc_exts = \"\"\n # Add the args to the config\n for k,v in vars(args).items():\n if k == \"extensions_local_dir\" and v is not None:\n # Args has a list, but config has only strings\n if k not in config[d] and k in config[i]:\n config[d][k] = config[i][k]\n elif k not in config[d] and k not in config[i]:\n config[m][k] = \"\"\n x = v\n x.extend(config[m][k].split(\",\"))\n config[m][k] = \",\".join(x)\n elif k == \"exclusive_extensions_local_dir\" and v is not None:\n config[m][k] = \",\".join(v)\n exc_exts = config[m][k]\n elif v is not None:\n config[m][k] = str(v)\n\n if exc_exts is None or exc_exts == \"\":\n exc_exts = \"\"\n config[m][\"exclusive_extensions_local_dir\"] = exc_exts\n else:\n config[m][\"extensions_local_dir\"] = exc_exts\n\n # Update TC kernel and info if needed\n tc_release = '/usr/share/doc/tc/release.txt'\n if (\"tinycore_version\" not in config[m] or\n config[m][\"tinycore_version\"] is None\n ):\n # Default to TC 7.x\n config[m][\"tinycore_version\"] = \"7\"\n if os.path.isfile(tc_release):\n with open(tc_release) as f:\n for line in f:\n tc_version = line.strip()\n if tc_version == \"\":\n continue\n config[m][\"tinycore_version\"] = tc_version.split('.')[0]\n if (\"tinycore_arch\" not in config[m] or\n config[m][\"tinycore_arch\"] is None\n ):\n # Default to x86 (over x86_64)\n config[m][\"tinycore_arch\"] = \"x86\"\n if os.path.isfile(tc_release):\n shell = expand_dir('/bin/sh')\n rfile = subprocess.run(['file', shell],\n check=True, stdout=subprocess.PIPE\n )\n rcut = subprocess.run(['cut','-d,','-f1'],\n input=rfile.stdout, stdout=subprocess.PIPE\n )\n rgrep = subprocess.run(['egrep','-o','[0-9]{2}'],\n input=rcut.stdout, stdout=subprocess.PIPE\n )\n my_arch = str(rgrep.stdout, 'utf-8').strip()\n if my_arch == \"64\":\n my_arch = \"x86_64\"\n else:\n my_arch = \"x86\"\n config[m][\"tinycore_arch\"] = my_arch\n kernel = ExtensionList.tc_kernel(\n config[m][\"tinycore_version\"], config[m][\"tinycore_arch\"])\n if os.path.isfile(tc_release) and (kernel is None or kernel == \"\"):\n kernel = str(\n subprocess.run(['uname', '-r'],\n check=True, stdout=subprocess.PIPE\n ).stdout, 'utf-8').strip()\n\n if ((kernel is None or kernel == \"\") and\n (\"tinycore_kernel\" not in config[m] or\n config[m][\"tinycore_kernel\"] is None)\n ):\n print(\"\\nCouldn't determine kernel version\\n\\n\")\n return None\n config[m][\"tinycore_kernel\"] = kernel\n\n if \"tinycore_mirror\" not in config[m] or config[m][\"tinycore_mirror\"] is None:\n config[m][\"tinycore_mirror\"] = \"http://tinycorelinux.net\"\n if os.path.isfile(\"/opt/tcemirror\"):\n with open(\"/opt/tcemirror\") as f:\n for line in f:\n tc_mirror = line.strip()\n if tc_mirror == \"\":\n continue\n config[m][\"tinycore_mirror\"] = tc_mirror\n\n config_name = os.path.splitext(\n os.path.basename(config[m][\"config\"]))[0]\n sections = [i]\n if \"sections\" in config[i]:\n sections = config[i][\"sections\"].split(\",\")\n config_name = None\n for s in sections.copy():\n s = s.strip()\n # if no output, base off config filename|section name, tc-version & arch, and curdir\n out_file = config_name\n if out_file is None:\n out_file = s\n d = datetime.date.today()\n ver = \"\"\n if (\n \"version_output\" in config[m] and\n config[m][\"version_output\"] is not None and\n config[m][\"version_output\"] != \"\"\n ):\n ver = \"-\".join([\n \"\",\n config[m][\"version_output\"].replace(\" \", \"-\")\n ])\n out_file = \"\".join([\n out_file,\n ver,\"_\",\n config[m][\"tinycore_version\"],\n config[m][\"tinycore_arch\"],\n d.strftime(\"_%y%m%d\"),\n \".gz\"\n ])\n out_dir = \"\"\n if \"output\" in config[s]:\n out_dir = expand_dir(config[s][\"output\"])\n if out_dir == \"\":\n new_path = expand_dir(\"./\")\n new_out = os.path.join(new_path, out_file)\n config[s][\"output\"] = new_out\n elif os.path.isdir(out_dir):\n # just update the file-name\n new_out = os.path.join(out_dir, out_file)\n config[s][\"output\"] = new_out\n else:\n # otherwise, just make sure it's a full absolute path\n config[s][\"output\"] = out_dir\n out_dir = os.path.dirname(config[s][\"output\"])\n if not os.path.isdir(out_dir):\n print(\"Config directory {} doesn't exist\\n\\n\".format(out_dir))\n return None\n # Setup the exclusive local extensions directory in each section\n config[s][\"exclusive_extensions_local_dir\"] = exc_exts\n if exc_exts != \"\":\n config[s][\"extensions_local_dir\"] = exc_exts\n\n\n # TODO: Verify we have all the required fields if they weren't specified\n if (\"install_root\" not in config[m] or\n config[m][\"install_root\"] is None or\n config[m][\"install_root\"] == \"\"\n ):\n config[m][\"install_root\"] = \"/tmp/tce\"\n\n return config","def read_arguments(argv):\n\tif argv[0] in ('1', '2'):\n\t\tconos_config['endpoint'] = endpoint[argv[0]]\n\telse:\n\t\tusage()\n\n\tif argv[1] in ('dev', 'test', 'int', 'prod'):\n\t\tconos_config['environment'] = argv[1]\n\t\tconos_config['sts_url'] = eval(argv[1] + '_sts_url')\n\t\tconos_config['aicuu_url'] = eval(argv[1] + '_aicuu_url')\n\telse:\n\t\tusage()\n\n\tif len(argv) == 6:\n\t\tconos_config['number_threads'] = '1'\n\telse:\n\t\tif argv[6] in ('1', '2', '3', '4', '5', '6', '7', '8'):\n\t\t\tconos_config['number_threads'] = argv[6]\n\t\telse:\n\t\t\tusage()\n\n\tconos_config['client_id'] = argv[2]\n\tconos_config['client_secret'] = argv[3]\n\tconos_config['input_file'] = argv[4]\n\tconos_config['output_file'] = argv[5]","def config_from_args(args):\n \n config = copy.deepcopy(default_config)\n \n for i in xrange(1, len(args)):\n arg = args[i]\n \n if arg.startswith('--'):\n if arg == '--help':\n # TODO: autogenerate help\n pass\n else:\n # Split each argument\n meta_pair = arg.replace('--', '').split('-')\n attr = meta_pair[0]\n key = meta_pair[1].split('=', 2)[0]\n \n value = arg.split('=', 2)[1]\n \n if not hasattr(config, attr):\n print 'Warning: invalid argument attribute %s : %s' % (attr, arg)\n elif not key in getattr(config, attr).keys():\n print 'Warning: invalid argument key %s : %s' % (key, arg)\n else:\n # Set the configuration value\n getattr(config, attr)[key] = value\n else:\n print 'Warning: invalid argument %s' % (arg)\n \n config.purify()\n \n return config","def parse_config(cmdline_opts):\n cmdline_opts.add_argument(\n '-p', '--port', help='Enter port number', default=8001)\n cmdline_opts.add_argument(\n '--host', help='Enter host name', default='localhost')\n cmdline_opts.add_argument(\n '-c', '--config', help='Enter config file', default='config.json')","def setup(args):\n cfg = get_cfg()\n add_imaterialist_config(cfg)\n cfg.merge_from_file(model_zoo.get_config_file(\"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml\"))\n cfg.merge_from_file(args.config_file)\n \n cfg.merge_from_list(args.opts)\n cfg.freeze()\n default_setup(cfg, args)\n # Setup logger for \"imaterialist\" module\n setup_logger(output=cfg.OUTPUT_DIR, distributed_rank=comm.get_rank(), name=\"imaterialist\")\n return cfg","def load(args):\n subprocess.check_call([\"/bin/launchctl\", \"load\"] + values.get(args))","def init_config(args=None):\n if args is None:\n args = parser_args()\n\n # Set the experiment directory\n exp_dir = args.exp_dir\n if exp_dir is None:\n exp_dir = 'experiment/' + args.model_name + '/' + osp.splitext(osp.basename(args.default_config_path))[0]\n\n # copy file\n dst_config_path = osp.join(exp_dir, osp.basename(args.default_config_path))\n src_copy_to_dst(args.default_config_path, dst_config_path)\n\n # overwrite\n if args.ow_config_path != 'None':\n print('ow_config_path is: {}'.format(args.ow_config_path))\n overwrite_config_file(dst_config_path, ow_file=args.ow_config_path)\n if args.ow_str != 'None':\n print('ow_str is: {}'.format(args.ow_str))\n overwrite_config_file(dst_config_path, ow_str=args.ow_str)\n\n # import config\n cfg = import_file(dst_config_path).cfg\n\n # Set log experiment dir\n cfg.log.exp_dir = exp_dir\n return cfg","def load_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--batchsize\",\n help=\"the batch size of the dataloader\",\n type=int,\n default=2,\n required=False)\n parser.add_argument(\"--validsize\",\n help=\"percentage that training set split into validation set\",\n type=float,\n default=1/6,\n required=False)\n parser.add_argument(\"--input-prefix\",\n help=\"file for saving the data (.gz file)\",\n type=str,\n default=\"../mnistPC\",\n required=False)\n parser.add_argument(\"--demo\",\n help=\"if demo is true, then only load small number of images\",\n type=bool,\n default=False,\n required=False)\n parser.add_argument(\"--test\",\n help=\"if test is true, then load data from test dataset\",\n type=bool,\n default=False,\n required=False)\n parser.add_argument(\"--epochs\",\n help=\"number of epochs\",\n type=int,\n default=5,\n required=False)\n parser.add_argument(\"--learning_rate\",\n help=\"learning rate of the model\",\n type=float,\n default=1e-2,\n required=False)\n parser.add_argument(\"--num_classes\",\n help=\"number of classes for classification\",\n type=int,\n default=10,\n required=False)\n parser.add_argument(\"--num_neighbors\",\n help=\"num of neighbors for the network\",\n type=int,\n default=15,\n required=False)\n parser.add_argument(\"--cudas\",\n help=\"cuda numbera to use, if use cpu, please enter -1\",\n type=str,\n default=\"0/1/2/3\",\n required=False)\n args = parser.parse_args()\n return args","def load_args():\n parser = argparse.ArgumentParser(description=\"Classify and predict digits using the mnist dataset\")\n parser.add_argument('mode', help='the mode to run in: fit, model or predict')\n parser.add_argument('--algo', help='which algorithm to use: RandomForest, KNN')\n return parser.parse_args()","def configure(self, args):\n pass","def load_args(altconf=None):\n config = kaptan.Kaptan(handler='yaml')\n mkconfig()\n\n # If an alternate config file has been specified\n if altconf is not None:\n if not os.path.isfile(altconf):\n abort(\"File not found: {}\".format(altconf))\n try:\n config.import_config(altconf)\n except (ValueError, ParserError):\n abort(\"{} is not a valid yaml file.\".format(altconf))\n\n # Default\n else:\n conf_dir = os.path.join(os.path.expanduser('~'), '.strikepackage')\n\n # Look for conf file in default locations\n for loc in [os.curdir, conf_dir]:\n configpath = os.path.join(loc, 'config.yaml')\n try:\n if os.path.isfile(configpath):\n config.import_config(configpath)\n break\n except (ValueError, ParserError):\n abort(\"{} is not a valid yaml file.\".format(configpath))\n if not config.configuration_data:\n abort(\"Config file not found. See README for help.\")\n\n # Validate conf file\n return validate_conf(config.configuration_data)","def load_config():\n parser = argparse.ArgumentParser(description='LTHNet_PyTorch_LinearLoss')\n parser.add_argument('--dataset', default='imagenet-100-IF1', type=str,\n help='Dataset name.')\n parser.add_argument('--root', default='C:\\\\Users\\\\dell\\\\Desktop\\\\LTH_linearloss\\\\data\\\\imagenet100\\\\', type=str,\n help='Path of dataset')\n # parser.add_argument('--root', default='/home/13810427976/notespace/cifar-100/cifar-100-IF20/', type=str,\n # help='Path of dataset')\n parser.add_argument('--code-length', default='32,48,64,96', type=str,\n help='Binary hash code length.(default: 32,48,64,96)')\n parser.add_argument('--arch', default='resnet34', type=str,\n help='CNN model name.(default: alexnet)')\n parser.add_argument('--feature-dim', default=2000, type=int,\n help='number of classes.(default: 2000)')\n parser.add_argument('--num-classes', default=100, type=int,\n help='number of classes.(default: 100)')\n parser.add_argument('--num-prototypes', default=100, type=int,\n help='number of prototypes.(default: 100)')\n parser.add_argument('--batch-size', default=128, type=int,\n help='Batch size.(default: 128)')\n parser.add_argument('--lr', default=1e-5, type=float,\n help='Learning rate.(default: 1e-5)')\n parser.add_argument('--max-iter', default=100, type=int,\n help='Number of iterations.(default: 300)')\n parser.add_argument('--num-workers', default=6, type=int,\n help='Number of loading data threads.(default: 6)')\n parser.add_argument('--dynamic-meta-embedding', default=True, type=bool,\n help='dynamic meta embedding.(default: True)')\n parser.add_argument('--topk', default=-1, type=int,\n help='Calculate map of top k.(default: all)')\n parser.add_argument('--gpu', default=None, type=int,\n help='Using gpu.(default: False)')\n parser.add_argument('--beta', default=0.0, type=float,\n help='Hyper-parameter: class-balanced factor.(default: 0.99)')\n parser.add_argument('--gamma', default=1.0, type=float,\n help='Hyper-parameter: balance between pointwise and pairwise loss.(default: 1.0)')\n parser.add_argument('--seed', default=3367, type=int,\n help='Random seed.(default: 3367)')\n parser.add_argument('--evaluate-interval', default=1, type=int,\n help='Evaluation interval.(default: 10)')\n\n args = parser.parse_args()\n\n # GPU\n if args.gpu is None:\n args.device = torch.device(\"cpu\")\n else:\n os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)\n args.device = torch.device(\"cuda:%d\" % 0)\n\n # Hash code length\n args.code_length = list(map(int, args.code_length.split(',')))\n\n return args","def main():\n args = parse_command_line()\n expt_config = load_config(args.experiment_config_path)\n run_cli(RunOptions.from_dict(expt_config))","def setup(args):\n cfg = get_cfg()\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n # customize reszied parameters\n # cfg['INPUT']['MIN_SIZE_TRAIN'] = (20,)\n # cfg['INPUT']['MAX_SIZE_TRAIN'] = 50\n cfg.freeze()\n default_setup(\n cfg, args\n ) # if you don't like any of the default setup, write your own setup code\n return cfg","def load_arguments(config_file= None ):\n if config_file is None :\n cur_path = os.path.dirname(os.path.realpath(__file__))\n config_file = os.path.join(cur_path, \"config.toml\")\n print(config_file)\n\n p = argparse.ArgumentParser()\n p.add_argument(\"--config_file\", default=config_file, help=\"Params File\")\n p.add_argument(\"--config_mode\", default=\"test\", help=\"test/ prod /uat\")\n p.add_argument(\"--log_file\", help=\"File to save the logging\") \n\n p.add_argument(\"--do\", default=\"test\", help=\"what to do test or search\") \n p.add_argument(\"--ntrials\", default=100, help='number of trials during the hyperparameters tuning')\n p.add_argument(\"--modelname\", default=\"model_dl.1_lstm.py\", help=\"name of the model to be tuned this name will be used to save the model\") \n p.add_argument(\"--data_path\", default=\"dataset/GOOG-year_small.csv\", help=\"path of the training file\") \n p.add_argument('--optim_engine', default='optuna',help='Optimization engine') \n p.add_argument('--optim_method', default='normal/prune',help='Optimization method') \n p.add_argument('--save_folder', default='model_save',help='folder that will contain saved version of best model') \n \n args = p.parse_args()\n args = load_config(args, args.config_file, args.config_mode, verbose=0)\n return args","def config(*subconfig):\n\n with open('configure.yaml', 'r') as stream:\n args = yaml.load(stream)\n\n # Parse command line arguments\n parser = argparse.ArgumentParser(description='')\n parser.add_argument(\n '--node',\n '-n',\n help='The node ID.'\n )\n parser.add_argument(\n '--processes',\n '-p',\n help='The total number of processes.'\n )\n # Store command line arguments in a dict\n cl_args = parser.parse_args()\n cl_args_dict = vars(cl_args)\n # Combine\n args.update(cl_args_dict)\n # Find subconfig if argument is passed\n for s in subconfig:\n try:\n args = args[s]\n except:\n pass\n # Return\n return args","def setup(args):\n cfg = get_cfg()\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n cfg.freeze()\n default_setup(cfg, args)\n return cfg","def setup(args):\n cfg = get_cfg()\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n cfg.freeze()\n default_setup(cfg, args)\n return cfg","def setup(args):\n cfg = get_cfg()\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n cfg.freeze()\n default_setup(cfg, args)\n return cfg","def load_config(config_arg):\n if config_arg.startswith(\"{\"):\n return json.loads(config_arg)\n elif config_arg == \"-\":\n return json.loads(sys.stdin.read())\n else:\n with open(config_arg) as config_file:\n return json.load(config_file)","def read_config(filename, args):\n # Initial vars\n config = defaultdict(dict)\n splitter = operator.methodcaller('split', ' ')\n\n converters = {\n __script__: {\n 'env': safe_path,\n 'pre_requirements': splitter,\n },\n 'pip': {\n 'allow_external': splitter,\n 'allow_unverified': splitter,\n }\n }\n default = copy.deepcopy(CONFIG)\n sections = set(iterkeys(default))\n\n # Expand user and environ vars in config filename\n filename = os.path.expandvars(os.path.expanduser(filename))\n\n # Read config if it exists on disk\n if os.path.isfile(filename):\n parser = SafeConfigParser()\n\n try:\n parser.read(filename)\n except ConfigParserError:\n error('Cannot parse config file at {0!r}'.format(filename))\n\n # Apply config for each possible section\n for section in sections:\n if not parser.has_section(section):\n continue\n\n items = parser.items(section)\n\n # Make auto convert here for integers and boolean values\n for key, value in items:\n try:\n value = int(value)\n except (TypeError, ValueError):\n try:\n value = bool(strtobool(value))\n except ValueError:\n pass\n\n if section in converters and key in converters[section]:\n value = converters[section][key](value)\n\n config[section][key] = value\n\n # Update config with default values if necessary\n for section, data in iteritems(default):\n if section not in config:\n config[section] = data\n else:\n for key, value in iteritems(data):\n config[section].setdefault(key, value)\n\n # Update bootstrap config from parsed args\n keys = set((\n 'env', 'hook', 'pre_requirements', 'quiet', 'recreate', 'requirements'\n ))\n\n for key in keys:\n value = getattr(args, key)\n config[__script__].setdefault(key, value)\n\n if key == 'pre_requirements' and not value:\n continue\n\n if value is not None:\n config[__script__][key] = value\n\n return config","def load_config(default_config: str, silent=False):\n if len(sys.argv) == 1:\n # Then the file being called is the only argument so return the default configuration\n config_file = default_config\n elif len(sys.argv) == 2:\n # Then a specific configuration file has been used so load it\n config_file = str(sys.argv[1])\n elif all([len(sys.argv) == 3, sys.argv[1] == '-f']):\n config_file = default_config\n else:\n print(sys.argv)\n raise ValueError('CLI only accepts 0 args (default) or 1 arg (path/to/config).')\n\n with open(str(config_file), 'r') as f:\n y = yaml.full_load(f)\n if not silent:\n print(f'Experimental parameters\\n------')\n pprint(y)\n return y","def cli(configfile):\n if path.exists(configfile):\n load_config(\"aplet.yml\")\n pass","def load_config(cls, config_file = None):\n config = ConfigParser()\n \n files = [\"/etc/imp.cfg\", os.path.expanduser(\"~/.imp.cfg\"), \".wm\", \".imp\"]\n if config_file is not None:\n files.append(config_file)\n \n config.read(files)\n cls.__instance = config","def grab_config():\n parser = argparse.ArgumentParser(description=\"NoisyCLIP\")\n\n parser.add_argument('--config_file')\n parser.add_argument('--ckpt_file')\n\n config = yaml_config_hook(parser.parse_args().config_file)\n for k, v in config.items():\n parser.add_argument(f\"--{k}\", default=v, type=type(v))\n\n args = parser.parse_args()\n\n return args","def init_args():\n parser = argparse.ArgumentParser(\n description=\"DeltaSherlock Client software.\")\n parser.add_argument('-v', '--version', action='version', version=VERSION)\n parser.add_argument('-c', '--config', action='store', dest='config_file',\n default='./config.ini', help=\"Path to config file. [default: \\\n %(default)s]\")\n parser.add_argument('-d', '--daemon', action='store_true', dest='daemon',\n default=False, help=\"Run in daemon mode. [default: \\\n %(default)s]\")\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description='Eval')\n parser.add_argument(\n '--cfg', help='experiment configure file path', type=str, \\\n default=\"validation.config.Config\")\n return parser.parse_args()","def load_config():\n model_type, run_name, run_comment, epoch, verbose = get_args()\n name = run_name + '-' + run_comment\n if model_type == \"s2s\": \n run_title = \"seq2seq\"\n else:\n run_title = \"def2vec\"\n path = \"outputs/{}/logs/{}/config.json\".format(run_title, name)\n config = None\n with open(path) as f:\n config = dict(json.load(f))\n config = load_config(eval=True)\n return (config, name, model_type)","def parse_args():\n\n parser = argparse.ArgumentParser(description='CLI to store Actisense-NGT Gateway values to InfluxDB and publish via MQTT')\n parser.add_argument('--config', '-c', type=str, required=True, help='JSON configuraton file with path')\n return parser.parse_args()","def load_configuration():\n argparser = ArgumentParser(description=\"Zoe application tester - Container Analytics as a Service core component\",\n default_config_files=CONFIG_PATHS,\n auto_env_var_prefix=\"ZOE_MASTER_\",\n args_for_setting_config_path=[\"--config\"],\n args_for_writing_out_config_file=[\"--write-config\"])\n\n argparser.add_argument('--debug', action='store_true', help='Enable debug output')\n argparser.add_argument('--swarm', help='Swarm/Docker API endpoint (ex.: zk://zk1:2181,zk2:2181 or http://swarm:2380)', default='http://localhost:2375')\n argparser.add_argument('--deployment-name', help='name of this Zoe deployment', default='prod')\n\n argparser.add_argument('--dbname', help='DB name', default='zoe')\n argparser.add_argument('--dbuser', help='DB user', default='zoe')\n argparser.add_argument('--dbpass', help='DB password', default='')\n argparser.add_argument('--dbhost', help='DB hostname', default='localhost')\n argparser.add_argument('--dbport', type=int, help='DB port', default=5432)\n\n # Master options\n argparser.add_argument('--api-listen-uri', help='ZMQ API listen address', default='tcp://*:4850')\n argparser.add_argument('--influxdb-dbname', help='Name of the InfluxDB database to use for storing metrics', default='zoe')\n argparser.add_argument('--influxdb-url', help='URL of the InfluxDB service (ex. http://localhost:8086)', default='http://localhost:8086')\n argparser.add_argument('--influxdb-enable', action=\"store_true\", help='Enable metric output toward influxDB')\n argparser.add_argument('--gelf-address', help='Enable Docker GELF log output to this destination (ex. udp://1.2.3.4:1234)', default='')\n argparser.add_argument('--workspace-base-path', help='Path where user workspaces will be created by Zoe. Must be visible at this path on all Swarm hosts.', default='/mnt/zoe-workspaces')\n argparser.add_argument('--overlay-network-name', help='Name of the Swarm overlay network Zoe should use', default='zoe')\n\n # API options\n argparser.add_argument('--listen-address', type=str, help='Address to listen to for incoming connections', default=\"0.0.0.0\")\n argparser.add_argument('--listen-port', type=int, help='Port to listen to for incoming connections', default=5001)\n argparser.add_argument('--master-url', help='URL of the Zoe master process', default='tcp://127.0.0.1:4850')\n\n # API auth options\n argparser.add_argument('--auth-type', help='Authentication type (text or ldap)', default='text')\n\n argparser.add_argument('--auth-file', help='Path to the CSV file containing user,pass,role lines for text authentication', default='zoepass.csv')\n\n argparser.add_argument('--ldap-server-uri', help='LDAP server to use for authentication', default='ldap://localhost')\n argparser.add_argument('--ldap-base-dn', help='LDAP base DN for users', default='ou=something,dc=any,dc=local')\n argparser.add_argument('--ldap-admin-gid', type=int, help='LDAP group ID for admins', default=5000)\n argparser.add_argument('--ldap-user-gid', type=int, help='LDAP group ID for users', default=5001)\n argparser.add_argument('--ldap-guest-gid', type=int, help='LDAP group ID for guests', default=5002)\n\n argparser.add_argument('jsonfile', type=FileType(\"r\"), help='Application description')\n\n opts = argparser.parse_args()\n\n opts.gelf_address = '' # For debugging we want to easily look at logs with 'docker logs'\n opts.influxdb_enable = False # don't send metrics for these test runs\n opts.deployment_name = 'zapp-test'\n\n if opts.debug:\n argparser.print_values()\n\n return opts","def load_config():\n config = configparser.ConfigParser()\n config.read('config.ini')\n return config","def load_configuration() -> argparse.Namespace:\n h = 24\n days = 5\n\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--age\", help=\"Patient age (years).\",\n default=20, required=False, type=int)\n parser.add_argument(\"--infection\", help=\"Whether the patient has a SARS infection or not.\",\n default=True, required=False, type=bool)\n parser.add_argument(\"--dose\", help=\"Drug dose (mg). 5 is nominal dose for Benazepril and 1.25 for Cilazapril.\",\n default=0, required=False, type=int)\n parser.add_argument(\"--renal-function\", help=\"Type of renal function.\", default=\"normal\",\n required=False, choices=[\"normal\", \"impaired\"], nargs=1, type=str)\n parser.add_argument(\"--glu\", help=\"Glucose concentration (mmol/L). \"\n \"To have normal subject glucose dyanmics as input,\"\n \"use glu = 1; for diabetic subjects, glu = 2. Rest all values will be\"\n \"used directly in mmol/L as steady state glucose input.\",\n default=1, required=False, type=float)\n parser.add_argument(\"--drug-name\", help=\"Drug name.\", default=\"benazepril\",\n required=False)\n\n parser.add_argument(\"--n-dose\", help=\"Number of doses per day (cannot be zero).\", default=1, required=False,\n type=int)\n parser.add_argument(\"--tstart-dosing\", help=\"Initial dosing time.\", default=h * 0, required=False, type=int)\n parser.add_argument(\"--tfinal-dosing\", help=\"Final dosing time.\", default=h * days, required=False, type=int)\n parser.add_argument(\"--sim-time-end\", help=\"Simulation end time.\", default=h * days, required=False, type=int)\n\n parser.add_argument(\"--show-plots\", help=\"Show plots.\", default=True, required=False, type=bool)\n parser.add_argument(\"--linestyle\", help=\"Plot line style.\", default=\"-\", required=False, type=str)\n parser.add_argument(\"--linewidth\", help=\"Plot line width.\", default=2, required=False, type=int)\n parser.add_argument(\"--legendloc\", help=\"Plot legend location.\", default=\"NorthEast\", required=False, type=str)\n args = parser.parse_args()\n\n return args","def __init__(self):\n self.argus = docopt(__doc__, version = 'Deployments 1.0')\n print(self.argus)\n if not self.argus['reservation']:\n try:\n with open(self.argus['--conf']) as config_file:\n self.config = json.load(config_file)\n print(self.config)\n\n except Exception as e:\n t, value, tb = sys.exc_info()\n print str(t) + \" \" + str(value)\n traceback.print_tb(tb)\n print(\"Config file not working\")","def load_conf(filename: str,\n args: Union[None, 'argparse.Namespace'] = None) -> m.Image:\n # Get the configuration from the file.\n with open(filename, 'r') as fh:\n conf_json = fh.read()\n conf = json.loads(conf_json)\n\n # Deserialize configuration based on the given version.\n if (conf['Version'] == '0.2.0'\n or conf['Version'] == '0.3.0'\n or conf['Version'] == '0.3.1'):\n # Allow CLI arguments to change or override values in the\n # loaded config.\n if args and args.filename:\n conf['Image']['filename'] = args.filename\n conf['Image']['format'] = get_format(args.filename)\n if args and args.size:\n conf['Image']['size'] = args.size[::-1]\n if args and args.location:\n _update_location(conf['Image'], args.location[::-1])\n\n # Deserialize and return the configuration object.\n return m.Image(**conf['Image'])\n\n # Otherwise, the version isn't recognized, so throw an error.\n else:\n raise ValueError(f'Version {conf[\"Version\"]} not supported.')","def get_config_params():\n configParser = configparser.ConfigParser()\n configParser.read(os.path.splitext(sys.argv[0])[0]+'.ini')\n return configParser","def get_config():\n\n parser = argparse.ArgumentParser(\n description='ZoomingSloMo or only Slo-Mo training argument parser')\n parser.add_argument('--cfg', default=\"./config.yaml\")\n args, _ = parser.parse_known_args()\n conf = read_yaml(args.cfg)\n\n parser.add_argument('--lmdb-data-gt', type=str, default=\"datasets/\",\n help='Path to HR frames lmdb for training')\n\n parser.add_argument('--lmdb-data-lq', type=str, default=\"datasets/\",\n help='Path to LR frames lmdb for training')\n\n parser.add_argument('--output-dir', type=str, default=\"models/\",\n help='Path to store trained models')\n\n parser.add_argument('--batch-size', type=int, default=\"12\",\n help='Maximum number of iterations for training')\n\n parser.add_argument('--gt-size', type=int, default=128,\n help='Ground truth frame size')\n\n parser.add_argument('--only-slomo', action='store_true', default=False,\n help='If True, network will train for Slo-Mo only (No Zooming)')\n\n args = parser.parse_args()\n\n # Refine config file variables\n conf.data.lmdb_data_gt = args.lmdb_data_gt\n conf.data.lmdb_data_lq = args.lmdb_data_lq\n conf.data.output_dir = args.output_dir\n conf.train.batch_size = args.batch_size\n conf.train.only_slomo = args.only_slomo\n conf.data.gt_size = args.gt_size if not args.only_slomo else args.gt_size // 4\n conf.data.lr_size = args.gt_size // 4\n\n return conf","def parser():\n description = \"\"\"\n Use docker or local setup to import files:\n ``python import_files_to_postgres.py config.ini docker``\n\n \"\"\"\n\n parser = argparse.ArgumentParser(\n description=description)\n parser.add_argument('config_path',\n type=str,\n help=\"Full Location of config.ini file\")\n parser.add_argument('config_name',\n type=str,\n help=\"Define the running env: 'docker' or 'dev' when running locally\")\n return parser","def load_config():\n config = ConfigParser()\n config.read(os.path.join(os.path.dirname(__file__), 'config.ini'))\n return config","def cmd_entry():\n import argparse\n\n parser = argparse.ArgumentParser(\n description=\"Web based frontend to the health record system databaser\"\n )\n parser.add_argument('-c', '--config', required=True, help=\"Config file to load\")\n args = parser.parse_args()\n\n main(args.config)","def parse_args(self, argv):\n super(UpdaterDaemon, self).parse_args(argv)\n\n self.stdout = self.options.log_file\n self.stderr = self.options.error_log\n\n config = self.options.config\n if config is None:\n config = os.path.join(os.path.dirname(__file__), 'config.py')\n config = os.path.normpath(os.path.abspath(config))\n configdir, configfile = os.path.split(config)\n configfile, ext = os.path.splitext(configfile)\n if configdir not in sys.path:\n sys.path.insert(0, configdir)\n self.config = __import__(configfile)","def initialize_command(parser):\n parser.add_argument('--config', dest='config',\n help='the pyramid config file')\n args = parser.parse_args()\n assert args.config,\\\n 'You must have a --config config.ini, or we can\\'t run the command'\n # load the pyramid config env\n env = bootstrap(args.config)\n # load the database\n initialize_sql(\n env['registry'].settings.get('sqlalchemy.url'))\n # return the args and the pyramid env for later use\n return args, env","def configure():\n parser = argparse.ArgumentParser(description=\"welcome to AutomateBGP!\")\n parser.add_argument('-u', '--username', dest='username',\n help='username to login to nodes')\n parser.add_argument('-p', '--password', dest='password',\n help='password to login to nodes')\n parser.add_argument('-f', '--filename', dest='filename',\n help='text file containing the node data (expected format...)')\n return parser.parse_args()","def load_config(options):\n if not os.path.exists(options.config_file):\n logging.info(\"%s does not exist - initializing with an example configuration\" % CRANKD_OPTIONS.config_file)\n print >>sys.stderr, 'Creating %s with default options for you to customize' % options.config_file\n print >>sys.stderr, '%s --list-events will list the events you can monitor on this system' % sys.argv[0]\n example_config = {\n 'SystemConfiguration': {\n 'State:/Network/Global/IPv4': {\n 'command': '/bin/echo \"Global IPv4 config changed\"'\n }\n },\n 'NSWorkspace': {\n 'NSWorkspaceDidMountNotification': {\n 'command': '/bin/echo \"A new volume was mounted!\"'\n },\n 'NSWorkspaceDidWakeNotification': {\n 'command': '/bin/echo \"The system woke from sleep!\"'\n },\n 'NSWorkspaceWillSleepNotification': {\n 'command': '/bin/echo \"The system is about to go to sleep!\"'\n }\n }\n }\n writePlist(example_config, options.config_file)\n sys.exit(1)\n\n logging.info(\"Loading configuration from %s\" % CRANKD_OPTIONS.config_file)\n\n plist = readPlist(options.config_file)\n\n if \"imports\" in plist:\n for module in plist['imports']:\n try:\n __import__(module)\n except ImportError, exc:\n print >> sys.stderr, \"Unable to import %s: %s\" % (module, exc)\n sys.exit(1)\n return plist","def readConfig(self, config_file):\n parser = ConfigParser.RawConfigParser()\n parser.read(config_file)\n self.NUM_PROCESSES = parser.getint('loader', 'NUM_PROCESSES')\n self.EXEC = parser.get('loader', 'EXECUTABLE')\n self.TILE_LOADER_JSON = parser.get('loader', 'TILE_LOADER_JSON')\n # If the load request was to a single tile db instance then\n # we can skip details on MPI, else MPI fields are required\n if self.NUM_PROCESSES == 1:\n return\n self.MPIRUN = parser.get('mpi', 'MPIRUN')\n self.HOSTS = parser.get('mpi', 'HOSTS')\n self.HOSTFLAG = parser.get('mpi', 'HOSTFLAG')\n\n if parser.has_option('mpi', 'BTL_TCP_IF_INCLUDE'):\n self.IF_INCLUDE = parser.get('mpi', 'BTL_TCP_IF_INCLUDE')\n if parser.has_option('mpi', 'INCLUDE_ENV'):\n self.ENV = parser.get('mpi', 'INCLUDE_ENV')","def load_configuration(self, config, load_args):\n try:\n if config is not None:\n self.config.load(config, **load_args)\n else:\n self.queue_message(\"log\", \"Load args %s.\", str(load_args))\n self.config.load(**load_args)\n self.queue_message(\"log\", \"Configuration loaded.\")\n except (self.pyez_exception.RpcError,\n self.pyez_exception.ConnectError) as ex:\n raise AnsibleError('Failure loading the configuraton: %s' %\n (str(ex)))","def load_params():\n # start arg parser\n parser = argparse.ArgumentParser(description='Apero Copy')\n # add arguments\n parser.add_argument('yaml', help='yaml file to use', type=str,\n default=None)\n parser.add_argument('--overwrite', help='overwrite existing files',\n action='store_true', default=False)\n parser.add_argument('--test', help='run in test mode (no copy or remove)',\n action='store_true', default=False)\n parser.add_argument('--symlinks', action='store_true', default=False,\n help='Copy in symlink mode (not recommended)')\n # get arguments\n args = vars(parser.parse_args())\n # ------------------------------------------------------------------\n # deal with getting yaml file\n # ------------------------------------------------------------------\n # deal with no yaml file set\n if args['yaml'] is None:\n emsg = 'yaml file must be set'\n raise AperoCopyError(emsg)\n # deal with bad path\n if not os.path.exists(args['yaml']):\n emsg = 'yaml file {0} does not exist'\n eargs = [args['yaml']]\n raise AperoCopyError(emsg.format(*eargs))\n # otherwise we read the yaml file\n params = read_yaml(args['yaml'])\n # add args to params\n for arg in args:\n if arg not in params:\n params[arg] = args[arg]\n # ------------------------------------------------------------------\n # return the parameters\n return params","def parse_args():\n hpo_warning = 'Flag overwrites config value if set, used for HPO and PBT runs primarily'\n parser = argparse.ArgumentParser('train.py')\n add_arg = parser.add_argument\n add_arg('config', nargs='?', default='configs/hello.yaml')\n add_arg('-d', '--distributed', choices=['ddp-file', 'ddp-mpi', 'cray'])\n add_arg('-v', '--verbose', action='store_true')\n add_arg('--ranks-per-node', default=8)\n add_arg('--gpu', type=int)\n add_arg('--rank-gpu', action='store_true')\n add_arg('--resume', action='store_true', help='Resume from last checkpoint')\n add_arg('--show-config', action='store_true')\n add_arg('--interactive', action='store_true')\n add_arg('--output-dir', help='override output_dir setting')\n add_arg('--seed', type=int, default=0, help='random seed')\n add_arg('--fom', default=None, choices=['last', 'best'],\n help='Print figure of merit for HPO/PBT')\n add_arg('--n-train', type=int, help='Override number of training samples')\n add_arg('--n-valid', type=int, help='Override number of validation samples')\n add_arg('--batch-size', type=int, help='Override batch size. %s' % hpo_warning)\n add_arg('--n-epochs', type=int, help='Specify subset of total epochs to run')\n add_arg('--real-weight', type=float, default=None,\n help='class weight of real to fake edges for the loss. %s' % hpo_warning)\n add_arg('--lr', type=float, default=None,\n help='Learning rate. %s' % hpo_warning)\n add_arg('--hidden-dim', type=int, default=None,\n help='Hidden layer dimension size. %s' % hpo_warning)\n add_arg('--n-graph-iters', type=int, default=None,\n help='Number of graph iterations. %s' % hpo_warning)\n add_arg('--weight-decay', type=float)\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser('train.py')\n add_arg = parser.add_argument\n add_arg('config', nargs='?', default='configs/hello.yaml')\n add_arg('-d', '--distributed', choices=['ddp-file', 'ddp-mpi', 'cray'])\n add_arg('-v', '--verbose', action='store_true')\n add_arg('--ranks-per-node', default=8)\n add_arg('--gpu', type=int)\n add_arg('--rank-gpu', action='store_true')\n add_arg('--resume', action='store_true', help='Resume from last checkpoint')\n add_arg('--show-config', action='store_true')\n add_arg('--interactive', action='store_true')\n add_arg('--output-dir', help='override output_dir setting')\n add_arg('--seed', type=int, default=0, help='random seed')\n return parser.parse_args()","def _parse_config(self, args, experiment_id):\r\n if not args:\r\n if experiment_id:\r\n config = importlib.import_module('configs.config_' + experiment_id)\r\n args = config.load_config()\r\n else:\r\n raise ValueError('No arguments or configuration data given')\r\n # Mandatory parameters for all architectures\r\n self.network_type = args.net\r\n self.is_training = args.training_mode\r\n self.train_data_file = args.train_data_file\r\n self.valid_data_file = args.valid_data_file\r\n self.test_data_file = args.test_data_file\r\n self.checkpoint_dir = args.checkpoint_dir\r\n self.trainlog_dir = args.trainlog_dir\r\n self.lr = args.lr\r\n self.batch_size = args.batch_size\r\n self.num_epochs = args.num_epochs\r\n self.loss_type = args.loss\r\n self.accuracy_type = args.accuracy\r\n self.optimizer = args.optimizer\r\n self.dropout = args.dropout\r\n self.gpu_load = args.gpu_load\r\n self.num_filters = args.num_filters\r\n self.nonlin = args.nonlin\r\n self.loss_type = args.loss\r\n self.task_type = args.task_type\r\n self.long_summary = args.long_summary\r\n self.experiment_path = args.experiment_path\r\n self.chpnt2load = args.chpnt2load\r\n self.lr_mode = args.lr_mode\r\n\r\n if not self.is_training:\r\n self.class_labels = args.class_labels\r\n if args.image_size:\r\n self.img_size = args.image_size\r\n else:\r\n self.img_size = None\r\n if args.num_classes:\r\n self.num_classes = args.num_classes\r\n else:\r\n self.num_classes = None\r\n if args.augmentation:\r\n self.augmentation_dict = args.augmentation\r\n else:\r\n self.augmentation_dict = None\r\n if args.normalize:\r\n self.normalize = args.normalize\r\n else:\r\n self.normalize = None\r\n if args.zero_center:\r\n self.zero_center = args.zero_center\r\n else:\r\n self.zero_center = None\r\n\r\n\r\n self._initialize_data()","def __init__(self, default_cfg='default.ini', argv=None):\n\n # Read the default settings\n self.config = configparser.ConfigParser()\n self.config.read(default_cfg)\n # Check for a command line config argument\n if argv is not None and '--config_fn' in argv:\n # Get the config filename\n config_fn = argv[argv.index('--config_fn') + 1]\n argv.remove('--config_fn')\n argv.remove(config_fn)\n # Read the new config file\n new_cfg = configparser.ConfigParser()\n new_cfg.read(config_fn)\n # Overwrite the default values\n self._overwrite_with_config(new_cfg)\n if argv is not None:\n self._parse_arguments(argv)\n self._update()","def load(args, optargs = None, defaults = '%{_sbdir}/defaults.mc', logfile = True):\n\n global host_windows\n global host_posix\n\n #\n # The path to this command.\n #\n command_path = path.dirname(path.abspath(args[0]))\n if len(command_path) == 0:\n command_path = '.'\n\n #\n # The command line contains the base defaults object all build objects copy\n # and modify by loading a configuration.\n #\n o = command_line(args,\n optargs,\n macros.macros(name = defaults,\n sbdir = command_path),\n command_path)\n\n overrides = None\n if os.name == 'nt':\n try:\n from . import windows\n overrides = windows.load()\n host_windows = True\n host_posix = False\n except:\n raise error.general('failed to load Windows host support')\n elif os.name == 'posix':\n uname = os.uname()\n try:\n if uname[0].startswith('MINGW64_NT'):\n from . import windows\n overrides = windows.load()\n host_windows = True\n elif uname[0].startswith('CYGWIN_NT'):\n from . import windows\n overrides = windows.load()\n elif uname[0] == 'Darwin':\n from . import darwin\n overrides = darwin.load()\n elif uname[0] == 'FreeBSD':\n from . import freebsd\n overrides = freebsd.load()\n elif uname[0] == 'NetBSD':\n from . import netbsd\n overrides = netbsd.load()\n elif uname[0] == 'Linux':\n from . import linux\n overrides = linux.load()\n elif uname[0] == 'SunOS':\n from . import solaris\n overrides = solaris.load()\n except error.general as ge:\n raise error.general('failed to load %s host support: %s' % (uname[0], ge))\n except:\n raise error.general('failed to load %s host support' % (uname[0]))\n else:\n raise error.general('unsupported host type; please add')\n if overrides is None:\n raise error.general('no hosts defaults found; please add')\n for k in overrides:\n o.defaults[k] = overrides[k]\n\n o.sb_released()\n o.sb_git()\n o.rtems_options()\n o.pre_process()\n o.process()\n o.post_process(logfile)\n\n #\n # Load the release settings\n #\n def setting_error(msg):\n raise error.general(msg)\n hashes = version.load_release_settings('hashes')\n for hash in hashes:\n hs = hash[1].split()\n if len(hs) != 2:\n raise error.general('invalid release hash in VERSION')\n sources.hash((hs[0], hash[0], hs[1]), o.defaults, setting_error)\n release_path = version.load_release_setting('version', 'release_path',\n raw = True)\n if release_path is not None:\n try:\n release_path = ','.join([rp.strip() for rp in release_path.split(',')])\n except:\n raise error.general('invalid release path in VERSION')\n download.set_release_path(release_path, o.defaults)\n return o","def from_cli_args(cls, args: dict):\n params_str = args.pop(\"user_params\", None)\n params_file = args.pop(\"user_params_file\", None)\n\n if params_str:\n user_params = util.read_yaml(params_str, cls.user_params_schema)\n elif params_file:\n user_params = util.read_yaml_from_file_path(params_file, cls.user_params_schema)\n else:\n raise ValueError(\"Did not receive user params. User params are currently required.\")\n\n return cls(**args, user_params=user_params)","def parse_args():\n parser = ArgumentParser(\n description=\"This is a script for auto apply ipex optimization.\"\n \"\\n################################# Basic usage ############################# \\n\"\n \"\\n 1. Apply ipex optimization with fp32 data type\\n\"\n \"\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex python_script args \\n\"\n \"\\n 2. Apply ipex optimization with bf16 data type\\n\"\n \"\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex --dtype bfloat16 python_script args \\n\",\n formatter_class=RawTextHelpFormatter,\n )\n\n add_auto_ipex_params(parser, auto_ipex_default_enabled=True)\n\n # positional\n parser.add_argument(\n \"program\",\n type=str,\n help=\"The full path to the proram/script to be launched. \"\n \"followed by all the arguments for the script\",\n )\n # rest from the training program\n parser.add_argument(\"program_args\", nargs=REMAINDER)\n return parser.parse_args()","def get_configuration(args):\n\n #------------------------------------------------------------------------\n # If configfile is not specified, dump a configfile on screen\n default_config, required_config = get_default_configuration()\n if args.configfile is None:\n write_configuration(parser.prog, version, default_config, required_config)\n raise SystemExit\n\n #------------------------------------------------------------------------\n # If you are here, then a configfile was given. Try to parse it\n userconf = ConfigParser.SafeConfigParser()\n userconf.read(args.configfile)\n runconf = {}\n\n if userconf.has_option('Config', 'verbose'): \n runconf['verbose'] = userconf.getboolean('Config', 'verbose')\n else:\n runconf['verbose'] = default_config['verbose']\n\n if runconf['verbose']: print \"Configuration for this run: \"\n for key in required_config.keys():\n try:\n runconf[key] = userconf.getfloat('Config', key)\n if runconf['verbose']: print \" > {key} = {val}\".format(key=key, val=runconf[key])\n except ConfigParser.NoOptionError:\n if runconf['verbose']: print \"\\nError: Required parameter {key} missing from config file!!\".format(key=key)\n if runconf['verbose']: print \"Update the file {configfile} and try again\\n\".format(configfile=args.configfile)\n raise SystemExit\n except ValueError:\n runconf[key] = userconf.get('Config', key)\n if runconf['verbose']: print \" > {key} = {val}\".format(key=key, val=runconf[key])\n\n for key in default_config.keys():\n if key == 'verbose': continue\n try:\n runconf[key] = userconf.getfloat('Config', key)\n except ConfigParser.NoOptionError:\n runconf[key] = default_config[key]\n if runconf['verbose']: print \"Using default value for {key}\".format(key=key)\n except ValueError:\n runconf[key] = userconf.get('Config', key)\n if runconf['verbose']: print \" > {key} = {val}\".format(key=key, val=runconf[key])\n\n # Now convert the bool values: verbose is already processed\n boolkeys = ['auto', 'do_fit']\n for b_key in boolkeys:\n #print b_key, runconf[b_key]\n test_string = \"{b_key}\".format(b_key = runconf[b_key])\n #print test_string\n if (test_string[0].upper() == 'T') or (test_string[0] == '1'):\n runconf[b_key] = True\n else:\n runconf[b_key] = False\n #print b_key, runconf[b_key]\n\n # Configuaration finally parsed!\n # At some future time, I should validate it...\n return runconf","def config_parse(conf=None, args=None):\n if args is None:\n args = []\n args += ['--config-file', etcdir('neutron.conf')]\n if conf is None:\n config.init(args=args)\n else:\n conf(args)","def load_default_user_configs(args):\n # Skip any imported keys from future\n import __future__ as ff\n future_keys = dir(ff)\n # Load default settings\n import pythiaplotter.default_config as dc\n default_settings = {k: getattr(dc, k) for k in dir(dc)\n if k not in future_keys and not k.startswith(\"_\")}\n args.__dict__.update(default_settings) # argparse.Namespace doesn't like update() or new keys\n # Load user config\n if args.configFile:\n if not helpr.check_file_exists(args.configFile):\n raise IOError(\"Configuration file %s does not exist\" % args.configFile)\n cc = load_source(\"cc\", args.configFile)\n custom_settings = {k: getattr(cc, k) for k in dir(cc)\n if k not in future_keys and not k.startswith(\"_\")}\n args.__dict__.update(custom_settings)","def parse_args():\n hpo_warning = 'Flag overwrites config value if set, used for HPO and PBT runs primarily'\n parser = argparse.ArgumentParser('train.py')\n add_arg = parser.add_argument\n add_arg('config', nargs='?', default='GraphLearning/configs/myconfig.yaml')\n add_arg('results_dir', nargs='?', default='GraphLearning/results/withnoise')\n \n return parser.parse_args()","def main():\n cli = CommandLineInterface(NAME, package=\"nemo_nowcast\", description=__doc__)\n cli.build_parser()\n parsed_args = cli.parser.parse_args()\n config = Config()\n config.load(parsed_args.config_file)\n msg = _configure_logging(config)\n logger.info(f\"running in process {os.getpid()}\")\n logger.info(f\"read config from {config.file}\")\n logger.info(msg)\n run(config)","def _load_config():\n\tcfg = configparser.ConfigParser()\n\tcfg.read(os.path.join(get_current_directory(), 'citi.config'))\n\treturn cfg","def parse_args(args: Namespace) -> None:\n if os.path.exists(DEFAULT_CONFIG):\n Parameter.load_config(DEFAULT_CONFIG)\n for path in args.config or []:\n Parameter.load_config(path)\n\n for name, parameter in Parameter.by_name.items():\n value = vars(args).get(name)\n if value is not None:\n if parameter.parser is None:\n assert isinstance(value, bool)\n parameter.value = value\n else:\n try:\n parameter.value = parameter.parser(value)\n except BaseException:\n raise RuntimeError( # pylint: disable=raise-missing-from\n f\"Invalid value: {vars(args)[name]} for the parameter: {name}\"\n )\n\n name = sys.argv[0].split(\"/\")[-1]","def load():\n # get (or create) config path\n p = initialize()\n return load_config(open(p['config']))","def cmd_config(args):\n \n remote.show_config(_get_current_project_name())","def read_config(*args):\n\n ret = {}\n if _TRAFFICCTL:\n cmd = _traffic_ctl(\"config\", \"get\")\n else:\n cmd = _traffic_line(\"-r\")\n\n try:\n for arg in args:\n log.debug(\"Querying: %s\", arg)\n ret[arg] = _subprocess(cmd + [arg])\n except KeyError:\n pass\n\n return ret","def parse_config(parser):\n parser.add_argument('--config-file', '-c', help='config filename',\n default='config.yaml')\n return parser","def parse_args():\n parser = argparse.ArgumentParser(\"generate_scenarios.py\")\n add_arg = parser.add_argument\n add_arg(\"config\", nargs=\"?\", default=\"config.yaml\")\n # add_arg('-d', '--distributed', action='store_true')\n add_arg(\"-v\", \"--verbose\", action=\"store_true\")\n # parameters which override the YAML file, if needed\n #\n return parser.parse_args()","def main(args):\n cli = CLI()\n # Check arguments\n cli.parse_arguments(args)","def read_inputs(argn=1):\n if len(sys.argv) < argn+1:\n raise IOError(\"Hey, no input file was passed as argument to\"\n \" the program!!\")\n if not os.path.exists(sys.argv[argn]):\n raise FileNotFoundError(\"Input file '{}' not found.\".\n format(sys.argv[argn]))\n return read_config_file(sys.argv[argn], attribution_char='=')","def read_cli_args(argv):\n\n # Working defaults\n cur_dir = os.getcwd()\n config_file = os.path.normpath(os.path.join(cur_dir, \"config.yaml\"))\n override_file = os.path.normpath(os.path.join(cur_dir, \"overrides.yaml\"))\n merged_file = os.path.normpath(os.path.join(cur_dir, \"build\", \"config.yaml\"))\n # Parse the args\n parser = argparse.ArgumentParser()\n parser.add_argument('-c', '--config-file',\n action='store', type=str, dest=\"config_file\",\n help='Path to Config file to read. Default:'\n + config_file,\n default=config_file)\n parser.add_argument('-o', '--override-file',\n action='store', type=str, dest=\"override_file\",\n help='Path to override file. Default:'\n + override_file,\n default=override_file)\n parser.add_argument('-m', '--merged-file',\n action='store', type=str, dest=\"merged_file\",\n help='Path to output of this script. Default:'\n + merged_file,\n default=merged_file)\n args = parser.parse_args()\n return args","def analysis_config():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-g\", \"--ground-truth\", type=str, default=\"./BRUTE_FORCE_near_duplicates.tsv\")\n parser.add_argument(\"-p\", \"--pred\", type=str, default=\"./PRED_near_duplicates.tsv\")\n\n return parser.parse_args()","def load_configuration_or_abort(app, environ_variable, mandatory_config_keys=[]):\n\n try:\n config_file = load_config_file(environ_variable)\n app.config.from_pyfile(config_file, silent=False)\n except Exception as e:\n print(str(e))\n exit(-1)\n\n assert_configs(app.config, mandatory_config_keys, config_file)\n\n print((\"ZEEGUU: Loaded {0} config from {1}\".format(app.name, config_file)))","def main(argv):\n config_options = parse_config(CONFIG_FILE_NAME)\n arguments_options = parse_args(argv, **config_options)\n playgame.main(arguments_options)","def config_argparser(parser):\n parser.set_defaults(func=main)","def load_config(filename):\n AS[\"config\"] = load_yaml_file(filename)","def main(args=None):\n args = args or sys.argv[1:]\n parser = parse_options()\n common.main_cli(experiment_parse_and_run, parser, args)","def parse_commandline_args():\n\n epilog = \"\"\"\n The configuration file must contained a JSON-encoded map. Example: \"{\"name\":\"foo\"}\".\n \"\"\"\n\n parser = utils.ConnectionArgumentParser(\n description=\"Update config (key/value pairs) on a board\", epilog=epilog\n )\n parser.add_argument(\n \"-c\",\n \"--config\",\n help=\"JSON file to load config from (default stdin)\",\n type=open,\n default=sys.stdin,\n dest=\"file\",\n )\n parser.add_argument(\n \"ids\", metavar=\"DEVICEID\", nargs=\"+\", type=int, help=\"Device IDs to flash\"\n )\n\n return parser.parse_args()","def init(subparsers):\n parser = subparsers.add_parser('generate-config', help='Generate the WebRPG configuration file')\n parser.add_argument('--filename', default='production.ini', help='Configuration file name')\n parser.add_argument('--sqla-connection-string', default=None, help='SQLAlchemy database connection string')\n parser.set_defaults(func=generate_config)","def parse_arguments(args=sys.argv[1:]):\n \n parser = argparse.ArgumentParser()\n \n parser.add_argument('-i', '--input',\n help=\"Path of input file to read. Default: {d}\".format(d=INPUT_FILE),\n default=INPUT_FILE)\n \n return parser.parse_args(args)","def init_config(filename):\n config = configparser.ConfigParser()\n try:\n with open(filename, 'r') as config_file:\n config.read(config_file)\n except EnvironmentError:\n print(\"FATAL ERROR: Failed to open config file at \" + filename)\n sys.exit(1)\n return config","def init_argparser() -> ArgumentParser:\n parser = ArgumentParser()\n from_config = parser.add_argument_group('From config file', 'Provide full experiment setup via config file')\n from_config.add_argument('-c', '--config', help='Path to json file containing classification config.')\n from_cmd = parser.add_argument_group('From commandline', 'Specify experiment setup via commandline arguments')\n\n # Model options\n from_cmd.add_argument(\"--recoding_type\", type=str, default=None,\n choices=[\"mc_dropout\", \"surprisal\", \"ensemble\"],\n help=\"Recoding model type used for trainign. Choices include recoding based on MC Dropout,\"\n \"perplexity and anchored ensembles. If not specified, a vanilla model without recoding\"\n \"is used.\")\n from_cmd.add_argument(\"--step_type\", type=str, default=None, choices=[\"fixed\", \"mlp\", \"learned\"],\n help=\"Specifies the way the step size is determined when using a recoding model.\")\n from_cmd.add_argument(\"--step_size\", type=float,\n help=\"Step size for recoding in case the fixed step predictor is used.\")\n from_cmd.add_argument(\"--embedding_size\", type=int, help=\"Dimensionality of word embeddings.\")\n from_cmd.add_argument(\"--hidden_size\", type=int, help=\"Dimensionality of hidden states.\")\n from_cmd.add_argument(\"--num_layers\", type=int, help=\"Number of network layers.\")\n from_cmd.add_argument(\"--mc_dropout\", type=float, help=\"Dropout probability when estimating uncertainty.\")\n from_cmd.add_argument(\"--dropout\", type=float, help=\"Dropout probability for model in general.\")\n from_cmd.add_argument(\"--num_samples\", type=int, help=\"Number of samples used when estimating uncertainty.\")\n\n # Training options\n from_cmd.add_argument(\"--weight_decay\", type=float, help=\"Weight decay parameter when estimating uncertainty.\")\n from_cmd.add_argument(\"--prior_scale\", type=float,\n help=\"Prior length scale. A lower scale signifies a prior belief that the input data is \"\n \"distributed infrequently, a higher scale does the opposite.\")\n from_cmd.add_argument(\"--learning_rate\", type=float, help=\"Learning rate during training.\")\n from_cmd.add_argument(\"--batch_size\", type=int, help=\"Batch size during training.\")\n from_cmd.add_argument(\"--num_epochs\", type=int, help=\"Number of training epochs.\")\n from_cmd.add_argument(\"--clip\", type=float, help=\"Threshold for gradient clipping.\")\n\n # Corpus options\n from_cmd.add_argument(\"--corpus_dir\", type=str, help=\"Directory to corpus files.\")\n from_cmd.add_argument(\"--max_seq_len\", type=int, help=\"Maximum sentence length when reading in the corpora.\")\n\n # Screen output optins\n from_cmd.add_argument(\"--print_every\", type=int, help=\"Batch interval at which training info should be printed.\")\n from_cmd.add_argument(\"--eval_every\", type=int,\n help=\"Epoch interval at which the model should be evaluated on validation set.\")\n\n # Model saving and logging options\n from_cmd.add_argument(\"--model_name\", type=str, help=\"Model identifier.\")\n from_cmd.add_argument(\"--model_save_path\", type=str,\n help=\"Directory to which current best model should be saved to.\")\n from_cmd.add_argument(\"--device\", type=str, default=\"cpu\", help=\"Device used for training.\")\n from_cmd.add_argument(\"--log_dir\", type=str, help=\"Directory to write (tensorboard) logs to.\")\n\n return parser","def load_ini_file(ini_file_path):\n config = configparser.ConfigParser()\n config.read(ini_file_path)\n cfg = {}\n\n # Load hyperparameters\n cfg[\"hyperparameters\"] = {}\n cfg[\"hyperparameters\"][\"gpu_id\"] = config.getint(\"hyperparameters\", \"gpu_id\")\n cfg[\"hyperparameters\"][\"seed\"] = config.getint(\"hyperparameters\", \"seed\")\n cfg[\"hyperparameters\"][\"optimizer\"] = config.get(\"hyperparameters\", \"optimizer\")\n cfg[\"hyperparameters\"][\"lr\"] = config.getfloat(\"hyperparameters\", \"lr\")\n cfg[\"hyperparameters\"][\"momentum\"] = config.getfloat(\"hyperparameters\", \"momentum\")\n cfg[\"hyperparameters\"][\"clip\"] = config.getfloat(\"hyperparameters\", \"clip\")\n cfg[\"hyperparameters\"][\"dropout\"] = config.getfloat(\"hyperparameters\", \"dropout\")\n cfg[\"hyperparameters\"][\"batch_size\"] = config.getint(\"hyperparameters\", \"batch_size\")\n cfg[\"hyperparameters\"][\"embedding_dim\"] = config.getint(\"hyperparameters\", \"embedding_dim\")\n cfg[\"hyperparameters\"][\"commun_embed_size\"] = config.getint(\"hyperparameters\", \"commun_embed_size\")\n cfg[\"hyperparameters\"][\"num_epochs\"] = config.getint(\"hyperparameters\", \"num_epochs\")\n cfg[\"hyperparameters\"][\"use_one_hot\"] = config.getboolean(\"hyperparameters\", \"use_one_hot\")\n cfg[\"hyperparameters\"][\"max_input_length\"] = config.getint(\"hyperparameters\", \"max_input_length\")\n cfg[\"hyperparameters\"][\"max_num_answers\"] = config.getint(\"hyperparameters\", \"max_num_answers\")\n cfg[\"hyperparameters\"][\"use_dnc_c\"] = config.getboolean(\"hyperparameters\", \"use_dnc_c\") \n cfg[\"hyperparameters\"][\"use_dnc_q\"] = config.getboolean(\"hyperparameters\", \"use_dnc_q\")\n cfg[\"hyperparameters\"][\"share_memory\"] = config.getboolean(\"hyperparameters\", \"share_memory\")\n cfg[\"hyperparameters\"][\"weight_decay\"] = config.getfloat(\"hyperparameters\", \"weight_decay\")\n cfg[\"hyperparameters\"][\"use_clip_grad\"] = config.getboolean(\"hyperparameters\", \"use_clip_grad\")\n cfg[\"hyperparameters\"][\"clip_value\"] = config.getfloat(\"hyperparameters\", \"clip_value\")\n cfg[\"hyperparameters\"][\"lr_reduce_after\"] = config.getint(\"hyperparameters\", \"lr_reduce_after\")\n cfg[\"hyperparameters\"][\"lr_decay_rate\"] = config.getfloat(\"hyperparameters\", \"lr_decay_rate\")\n cfg[\"hyperparameters\"][\"grad_flow_interval\"] = config.getfloat(\"hyperparameters\", \"grad_flow_interval\")\n cfg[\"hyperparameters\"][\"add_noise\"] = config.getboolean(\"hyperparameters\", \"add_noise\")\n cfg[\"hyperparameters\"][\"finetune\"] = config.getboolean(\"hyperparameters\", \"finetune\")\n cfg[\"hyperparameters\"][\"fc_flag\"] = config.getboolean(\"hyperparameters\", \"fc_flag\")\n\n # Load lstm parameters\n cfg[\"lstm\"] = {}\n cfg[\"lstm\"][\"hidden_dim\"] = config.getint(\"lstm\", \"hidden_dim\")\n cfg[\"lstm\"][\"num_layers\"] = config.getint(\"lstm\", \"num_layers\")\n cfg[\"lstm\"][\"dropout\"] = config.getfloat(\"lstm\", \"dropout\")\n\n # Load dnc_q parameters\n cfg[\"dnc_q\"] = {}\n cfg[\"dnc_q\"][\"input_size\"] = config.getint(\"dnc_q\", \"input_size\")\n cfg[\"dnc_q\"][\"output_size\"] = config.getint(\"dnc_q\", \"output_size\")\n cfg[\"dnc_q\"][\"rnn_type\"] = config.get(\"dnc_q\", \"rnn_type\")\n cfg[\"dnc_q\"][\"hidden_dim\"] = config.getint(\"dnc_q\", \"hidden_dim\")\n cfg[\"dnc_q\"][\"memory_type\"] = config.get(\"dnc_q\", \"memory_type\")\n cfg[\"dnc_q\"][\"num_layers\"] = config.getint(\"dnc_q\", \"num_layers\")\n cfg[\"dnc_q\"][\"num_layers_hidden\"] = config.getint(\"dnc_q\", \"num_layers_hidden\")\n cfg[\"dnc_q\"][\"n\"] = config.getint(\"dnc_q\", \"n\")\n cfg[\"dnc_q\"][\"w\"] = config.getint(\"dnc_q\", \"w\")\n cfg[\"dnc_q\"][\"r\"] = config.getint(\"dnc_q\", \"r\")\n cfg[\"dnc_q\"][\"s_r\"] = config.getint(\"dnc_q\", \"t_r\")\n cfg[\"dnc_q\"][\"t_r\"] = config.getint(\"dnc_q\", \"s_r\")\n cfg[\"dnc_q\"][\"pass_through_mem\"] = config.getboolean(\"dnc_q\", \"pass_through_mem\")\n cfg[\"dnc_q\"][\"reset_experience\"] = config.getboolean(\"dnc_q\", \"reset_experience\")\n cfg[\"dnc_q\"][\"debug\"] = config.getboolean(\"dnc_q\", \"debug\")\n cfg[\"dnc_q\"][\"lr\"] = config.getfloat(\"dnc_q\", \"lr\")\n cfg[\"dnc_q\"][\"dropout\"] = config.getfloat(\"dnc_q\", \"dropout\")\n\n # Load dnc_c parameters\n cfg[\"dnc_c\"] = {}\n cfg[\"dnc_c\"][\"output_size\"] = config.getint(\"dnc_c\", \"output_size\")\n cfg[\"dnc_c\"][\"rnn_type\"] = config.get(\"dnc_c\", \"rnn_type\")\n cfg[\"dnc_c\"][\"hidden_dim\"] = config.getint(\"dnc_c\", \"hidden_dim\")\n cfg[\"dnc_c\"][\"memory_type\"] = config.get(\"dnc_c\", \"memory_type\")\n cfg[\"dnc_c\"][\"num_layers\"] = config.getint(\"dnc_c\", \"num_layers\")\n cfg[\"dnc_c\"][\"num_layers_hidden\"] = config.getint(\"dnc_c\", \"num_layers_hidden\")\n cfg[\"dnc_c\"][\"n\"] = config.getint(\"dnc_c\", \"n\")\n cfg[\"dnc_c\"][\"w\"] = config.getint(\"dnc_c\", \"w\")\n cfg[\"dnc_c\"][\"r\"] = config.getint(\"dnc_c\", \"r\")\n cfg[\"dnc_c\"][\"s_r\"] = config.getint(\"dnc_c\", \"t_r\")\n cfg[\"dnc_c\"][\"t_r\"] = config.getint(\"dnc_c\", \"s_r\")\n cfg[\"dnc_c\"][\"pass_through_mem\"] = config.getboolean(\"dnc_c\", \"pass_through_mem\")\n cfg[\"dnc_c\"][\"reset_experience\"] = config.getboolean(\"dnc_c\", \"reset_experience\")\n cfg[\"dnc_c\"][\"debug\"] = config.getboolean(\"dnc_c\", \"debug\")\n cfg[\"dnc_c\"][\"lr\"] = config.getfloat(\"dnc_c\", \"lr\")\n cfg[\"dnc_c\"][\"dropout\"] = config.getfloat(\"dnc_c\", \"dropout\")\n cfg[\"dnc_c\"][\"type\"] = config.get(\"dnc_c\", \"type\")\n cfg[\"dnc_c\"][\"nonlinearity\"] = config.get(\"dnc_c\", \"nonlinearity\")\n cfg[\"dnc_c\"][\"concat_out_rv\"] = config.getboolean(\"dnc_c\", \"concat_out_rv\")\n cfg[\"dnc_c\"][\"bidirectional\"] = config.getboolean(\"dnc_c\", \"bidirectional\")\n\n # Load logging paths\n cfg[\"logging\"] = {}\n cfg[\"logging\"][\"tensorboard_dir\"] = config.get(\"logging\", \"tensorboard_dir\")\n cfg[\"logging\"][\"checkpoints_dir\"] = config.get(\"logging\", \"checkpoints_dir\")\n cfg[\"logging\"][\"results_dir\"] = config.get(\"logging\", \"results_dir\")\n cfg[\"logging\"][\"grad_flow_dir\"] = config.get(\"logging\", \"grad_flow_dir\")\n\n # Load paths\n cfg[\"paths\"] = {}\n cfg[\"paths\"][\"input\"] = config.get(\"paths\", \"input\")\n cfg[\"paths\"][\"json_q_path_tr\"] = config.get(\"paths\", \"json_q_path_tr\")\n cfg[\"paths\"][\"json_q_path_val\"] = config.get(\"paths\", \"json_q_path_val\")\n cfg[\"paths\"][\"json_a_path_tr\"] = config.get(\"paths\", \"json_a_path_tr\")\n cfg[\"paths\"][\"json_a_path_val\"] = config.get(\"paths\", \"json_a_path_val\")\n cfg[\"paths\"][\"json_q_path_test\"] = config.get(\"paths\", \"json_q_path_test\")\n cfg[\"paths\"][\"dnc_q\"] = config.get(\"paths\", \"dnc_q\")\n cfg[\"paths\"][\"dnc_c\"] = config.get(\"paths\", \"dnc_c\")\n return cfg","def load_config(self):\n pass","def setup_args():\n parser = ParlaiParser()\n parser.add_argument(\n '-n',\n '--num-episodes',\n default=-1,\n type=int,\n help='Total number of episodes to convert, -1 to convert all examples',\n )\n parser.add_argument(\n '-of',\n '--outfile',\n default=None,\n type=str,\n help='Output file where to save, by default will be created in /tmp',\n )\n parser.add_argument(\n '-s1id', '--speaker-0-id', type=str, help='Speaker id of agent who speaks first'\n )\n parser.add_argument(\n '-s1id',\n '--speaker-1-id',\n type=str,\n help='Speaker id of agent who speaks second',\n )\n parser.add_argument(\n '--prepended-context',\n type='bool',\n default=False,\n help='specify if the context is prepended to the first act',\n )\n parser.add_argument('-ltim', '--log-every-n-secs', type=float, default=10)\n parser.set_defaults(datatype='train:ordered')\n\n return parser","def init(args):\n # reading existing config file, convert to configparser object\n config = config_from_file()\n config_ = configparser.ConfigParser()\n config_.add_section('osf')\n if 'username' not in config.keys():\n config_.set('osf', 'username', '')\n else:\n config_.set('osf', 'username', config['username'])\n if 'project' not in config.keys():\n config_.set('osf', 'project', '')\n else:\n config_.set('osf', 'project', config['project'])\n\n # now we can start asking for new values\n print('Provide a username for the config file [current username: {}]:'.format(\n config_.get('osf', 'username')))\n username = input()\n if username:\n config_.set('osf', 'username', username)\n\n print('Provide a project for the config file [current project: {}]:'.format(\n config_.get('osf', 'project')))\n project = input()\n if project:\n config_.set('osf', 'project', project)\n\n cfgfile = open(\".osfcli.config\", \"w\")\n config_.write(cfgfile)\n cfgfile.close()","def from_args(args, verbose=False, unhandled=None):\n\n # Create a list for unhandled arguments\n if unhandled is None:\n unhandled = []\n\n experiments = ExperimentList()\n ## First try as image files\n # experiments = ExperimentListFactory.from_datablock(\n # DataBlockFactory.from_args(args, verbose, unhandled1))\n\n # Try to load from serialized formats\n for filename in args:\n try:\n experiments.extend(\n ExperimentListFactory.from_serialized_format(filename)\n )\n if verbose:\n print(\"Loaded experiments from %s\" % filename)\n except Exception as e:\n if verbose:\n print(\"Could not load experiments from %s: %s\" % (filename, str(e)))\n unhandled.append(filename)\n\n # Return the experiments\n return experiments","def __init__(self, app_name, file=\"~/.redshovel\"):\r\n usage = \"usage: %prog [options]\"\r\n self.optp = optparse.OptionParser(usage=usage)\r\n self.app_name = app_name\r\n self.opts = None\r\n self.args = None\r\n\r\n self.config = ConfigParser.RawConfigParser()\r\n self.config.read(os.path.expanduser(file))\r\n\r\n # Add the common options.\r\n self.default_section = set(('api_key', 'url', 'verbose'))\r\n self.required = set()\r\n self.add_option(\"-a\", \"--api\", dest=\"api_key\", required=True,\r\n help=\"The api key to connect to redmine with\")\r\n self.add_option(\"-u\", \"--url\", dest=\"url\", required=True,\r\n help=\"The url to redmine.\")\r\n self.add_option(\"-v\", \"--verbose\",\r\n action=\"count\", dest=\"verbose\",\r\n help=\"verbosity the more v's the more verbose.\")","def get_config():\n try:\n config_file_path = sys.argv[2]\n except IndexError:\n config_file_path = \"config.yml\"\n if os.path.exists(config_file_path):\n with open(config_file_path, 'r') as stream:\n try:\n return yaml.load(stream)\n except yaml.YAMLError as yml_error:\n print(yml_error)\n else:\n print(\"%s does not exist\" % config_file_path)\n print(\"ERROR:\\nUSAGE: python strap.py \\\"keyword1, keyword2, keyword3, keyword4\\\" [path/to/config.yml]\")\n exit(0)"],"string":"[\n \"def get_config(args):\\n load_args={}\\n with open(args.config, 'r') as f:\\n for line in f:\\n key, value = line.strip().split('=')\\n try:\\n value = int(value)\\n except ValueError:\\n try:\\n value = float(value)\\n except ValueError:\\n value = value\\n load_args[key] = value\\n args.__dict__.update(load_args)\",\n \"def setup_config(self, args=None):\\n self.config_parse(args=args)\",\n \"def cli_load_config(self, args) -> str:\\n path = args.config_path\\n if not os.path.isfile(path):\\n return error(\\\"Path {} DNE\\\".format(path))\\n\\n try:\\n self.config = config.from_file(path)\\n return ok(\\\"Configuration loaded from {}\\\".format(path))\\n except FileNotFoundError as err:\\n return error(\\\"Could not load file: {}\\\".format(err))\\n except json.JSONDecodeError as json_err:\\n return error(\\\"Could not parse json file {}\\\".format(json_err))\",\n \"def _load_config(self, args: argparse.Namespace):\\n #\\n # Load a config, filename may or may-not be provided...\\n #\\n try:\\n self._config = TortugaScriptConfig.load(args.config)\\n\\n except ConfigException as ex:\\n print(str(ex))\\n sys.exit(0)\\n\\n #\\n # Override the config with any provided argument values\\n #\\n if args.url:\\n self._config.url = args.url\\n if args.username:\\n self._config.username = args.username\\n if args.password:\\n self._config.password = args.password\\n if args.token:\\n self._config.token = args.token\\n self._config.verify = args.verify\",\n \"def load_config(args):\\n cfg=get_cfg()\\n # load from yaml\\n if args.cfg_file is not None:\\n cfg.merge_from_file(args.cfg_file)\\n\\n #load from cmd\\n # print(args.opts)\\n # if args.opts is not None:\\n # cfg.merge_from_file(args.opts)\\n\\n # make a checkpoint dir\\n # cu.make_checkpoint_dir(cfg.OUTPUT_DIR,cfg)\\n return cfg\",\n \"def load_config(args):\\n # Setup cfg.\\n cfg = get_cfg()\\n # Load config from cfg.\\n if args.cfg_file is not None:\\n cfg.merge_from_file(args.cfg_file)\\n # Load config from command line, overwrite config from opts.\\n if args.opts is not None:\\n cfg.merge_from_list(args.opts)\\n\\n # Inherit parameters from args.\\n if hasattr(args, \\\"num_shards\\\") and hasattr(args, \\\"shard_id\\\"):\\n cfg.NUM_SHARDS = args.num_shards\\n cfg.SHARD_ID = args.shard_id\\n if hasattr(args, \\\"rng_seed\\\"):\\n cfg.RNG_SEED = args.rng_seed\\n if hasattr(args, \\\"output_dir\\\"):\\n cfg.OUTPUT_DIR = args.output_dir\\n\\n # Create the checkpoint dir.\\n # cu.make_checkpoint_dir(cfg.OUTPUT_DIR)\\n\\n return cfg\",\n \"def init(self, args, **kwargs):\\n # Retrieve configuration file and directory or set defaults.\\n conf_file = os.path.expanduser(\\n args._get('conf_file', kwargs.pop('conf_file', DEFAULT_CONF_FILE)))\\n conf_dir = os.path.expanduser(\\n args._get('conf_dir', kwargs.pop('conf_dir', DEFAULT_CONF_DIR)))\\n commands = [value for (arg, value) in sorted(args) if arg.startswith('command')]\\n\\n # Load main configuration file.\\n if os.path.exists(conf_file):\\n self.load_cmd_file(conf_file)\\n\\n # Load intermediary configuration files.\\n if os.path.isdir(conf_dir):\\n self.load_dir(conf_dir, clg.config, commands)\",\n \"def setup_config(args):\\n # Set the default configuration file\\n f = pkgutil.get_data(__package__, 'dnstap.conf')\\n cfg = load_yaml(f)\\n\\n # Overwrites then with the external file ? \\n if args.c:\\n cfg_ext = load_yaml(open(args.c, 'r'))\\n merge_cfg(u=cfg_ext,o=cfg)\\n\\n # Or searches for a file named dnstap.conf in /etc/dnstap_receiver/ \\n else:\\n etc_conf = \\\"/etc/dnstap_receiver/dnstap.conf\\\"\\n f = pathlib.Path(etc_conf)\\n if f.exists():\\n cfg_etc = load_yaml(open(etc_conf, 'r'))\\n merge_cfg(u=cfg_etc,o=cfg)\\n \\n # update default config with command line arguments\\n if args.v:\\n cfg[\\\"trace\\\"][\\\"verbose\\\"] = args.v \\n if args.u is not None:\\n cfg[\\\"input\\\"][\\\"unix-socket\\\"][\\\"enable\\\"] = True\\n cfg[\\\"input\\\"][\\\"unix-socket\\\"][\\\"path\\\"] = args.u\\n if args.l != DFLT_LISTEN_IP:\\n cfg[\\\"input\\\"][\\\"tcp-socket\\\"][\\\"local-address\\\"] = args.l\\n if args.l != DFLT_LISTEN_PORT:\\n cfg[\\\"input\\\"][\\\"tcp-socket\\\"][\\\"local-port\\\"] = args.p\\n\\n return cfg\",\n \"def load_config(args, path=\\\".\\\"):\\n with open(path + \\\"/config/\\\" + args.config, 'r') as f:\\n config = yaml.safe_load(f)\\n\\n for key, value in config.items():\\n args.__dict__[key] = value\",\n \"def LoadConfig(self, *args, **kwargs):\\n # type: (*Any, **Any) -> None\\n payload = {}\\n for i in range(len(args)):\\n payload[\\\"Arg%s\\\" % (i + 1)] = args[i]\\n for item in kwargs.items():\\n payload[item[0]] = item[1]\\n return self._execute(\\\"loadConfig\\\", payload=payload, response_object=None)\",\n \"def load_args(self):\\n\\n # retrieve module path\\n dir_path = os.path.dirname(os.path.abspath(__file__))\\n dir_path = os.path.split(dir_path)[0]\\n # get all the default yaml configs with glob\\n dir_path = os.path.join(dir_path, 'configs', '*.yml')\\n\\n # -- From default yapt configuration\\n self._defaults_path = {}\\n self._defaults_yapt = OmegaConf.create(dict())\\n for file in glob.glob(dir_path):\\n # split filename from path to create key and val\\n key = os.path.splitext(os.path.split(file)[1])[0]\\n self._defaults_path[key] = file\\n # parse default args\\n self._defaults_yapt = OmegaConf.merge(\\n self._defaults_yapt, OmegaConf.load(file))\\n\\n # -- From command line\\n self._cli_args = OmegaConf.from_cli()\\n if self._cli_args.config is not None:\\n self.default_config = self._cli_args.config\\n del self._cli_args['config']\\n self.console_log.warning(\\\"override default config with: %s\\\", self.default_config)\\n\\n # -- From experiment default config file\\n self._default_config_args = OmegaConf.create(dict())\\n if self.default_config is not None:\\n self._default_config_args = OmegaConf.load(self.default_config)\\n\\n # -- Merge default args\\n self._args = OmegaConf.merge(\\n self._defaults_yapt,\\n self._default_config_args)\\n\\n # -- Resolve interpolations to be sure all nodes are explicit\\n # self._args = OmegaConf.to_container(self._args, resolve=True)\\n # self._args = OmegaConf.create(self._args)\\n\\n # -- make args structured: it fails if accessing a missing key\\n OmegaConf.set_struct(self._args, True)\",\n \"def load_config(args):\\n config = dict()\\n #loc = [conf, os.curdir+\\\"config.json\\\", ]\\n locations = [ os.curdir, os.path.expanduser(\\\"~\\\"), \\\"/etc/failhadoop\\\",\\n os.environ.get(\\\"FAILHADOOP_ROOT\\\") ]\\n# if args.conf:\\n# locations.append(args.conf)\\n\\n for loc in locations:\\n try:\\n with open(os.path.join(loc,\\\"config.json\\\")) as source:\\n conf = json.load(source)\\n config.update(conf)\\n except IOError:\\n pass\\n except:\\n print(\\\"Cannot load config from any of the locations {0}\\\".format(locations))\\n try:\\n with open(args.conf) as source:\\n conf = json.load(source)\\n config.update(conf)\\n except IOError:\\n print(\\\"Cannot load config from any of the locations {0}\\\".format(locations))\\n\\n # Override config elements from command line\\n for a in vars(args):\\n config[a] = getattr(args,a)\\n\\n return config\",\n \"def get_config_params(args):\\n configParseObj = configparser.ConfigParser()\\n configParseObj.read(args)\\n return configParseObj\",\n \"def load():\\n global tinyConfig\\n if not tinyConfig:\\n tinyConfig = CmdArgs()\\n return tinyConfig\",\n \"def read_configuration(args):\\n config = configparser.ConfigParser()\\n my_config = expand_dir(vars(args)['config'])\\n try:\\n config.read(my_config)\\n except configparser.Error:\\n print(\\\"Config file {} couldn't be parsed\\\\n\\\\n\\\".format(my_config))\\n return None\\n # Create the internal sections\\n i = \\\"install\\\"\\n d = \\\"DEFAULT\\\"\\n if i not in config:\\n config[i] = {}\\n m = i\\n if \\\"sections\\\" in config[i]:\\n m = d\\n exc_exts = \\\"\\\"\\n # Add the args to the config\\n for k,v in vars(args).items():\\n if k == \\\"extensions_local_dir\\\" and v is not None:\\n # Args has a list, but config has only strings\\n if k not in config[d] and k in config[i]:\\n config[d][k] = config[i][k]\\n elif k not in config[d] and k not in config[i]:\\n config[m][k] = \\\"\\\"\\n x = v\\n x.extend(config[m][k].split(\\\",\\\"))\\n config[m][k] = \\\",\\\".join(x)\\n elif k == \\\"exclusive_extensions_local_dir\\\" and v is not None:\\n config[m][k] = \\\",\\\".join(v)\\n exc_exts = config[m][k]\\n elif v is not None:\\n config[m][k] = str(v)\\n\\n if exc_exts is None or exc_exts == \\\"\\\":\\n exc_exts = \\\"\\\"\\n config[m][\\\"exclusive_extensions_local_dir\\\"] = exc_exts\\n else:\\n config[m][\\\"extensions_local_dir\\\"] = exc_exts\\n\\n # Update TC kernel and info if needed\\n tc_release = '/usr/share/doc/tc/release.txt'\\n if (\\\"tinycore_version\\\" not in config[m] or\\n config[m][\\\"tinycore_version\\\"] is None\\n ):\\n # Default to TC 7.x\\n config[m][\\\"tinycore_version\\\"] = \\\"7\\\"\\n if os.path.isfile(tc_release):\\n with open(tc_release) as f:\\n for line in f:\\n tc_version = line.strip()\\n if tc_version == \\\"\\\":\\n continue\\n config[m][\\\"tinycore_version\\\"] = tc_version.split('.')[0]\\n if (\\\"tinycore_arch\\\" not in config[m] or\\n config[m][\\\"tinycore_arch\\\"] is None\\n ):\\n # Default to x86 (over x86_64)\\n config[m][\\\"tinycore_arch\\\"] = \\\"x86\\\"\\n if os.path.isfile(tc_release):\\n shell = expand_dir('/bin/sh')\\n rfile = subprocess.run(['file', shell],\\n check=True, stdout=subprocess.PIPE\\n )\\n rcut = subprocess.run(['cut','-d,','-f1'],\\n input=rfile.stdout, stdout=subprocess.PIPE\\n )\\n rgrep = subprocess.run(['egrep','-o','[0-9]{2}'],\\n input=rcut.stdout, stdout=subprocess.PIPE\\n )\\n my_arch = str(rgrep.stdout, 'utf-8').strip()\\n if my_arch == \\\"64\\\":\\n my_arch = \\\"x86_64\\\"\\n else:\\n my_arch = \\\"x86\\\"\\n config[m][\\\"tinycore_arch\\\"] = my_arch\\n kernel = ExtensionList.tc_kernel(\\n config[m][\\\"tinycore_version\\\"], config[m][\\\"tinycore_arch\\\"])\\n if os.path.isfile(tc_release) and (kernel is None or kernel == \\\"\\\"):\\n kernel = str(\\n subprocess.run(['uname', '-r'],\\n check=True, stdout=subprocess.PIPE\\n ).stdout, 'utf-8').strip()\\n\\n if ((kernel is None or kernel == \\\"\\\") and\\n (\\\"tinycore_kernel\\\" not in config[m] or\\n config[m][\\\"tinycore_kernel\\\"] is None)\\n ):\\n print(\\\"\\\\nCouldn't determine kernel version\\\\n\\\\n\\\")\\n return None\\n config[m][\\\"tinycore_kernel\\\"] = kernel\\n\\n if \\\"tinycore_mirror\\\" not in config[m] or config[m][\\\"tinycore_mirror\\\"] is None:\\n config[m][\\\"tinycore_mirror\\\"] = \\\"http://tinycorelinux.net\\\"\\n if os.path.isfile(\\\"/opt/tcemirror\\\"):\\n with open(\\\"/opt/tcemirror\\\") as f:\\n for line in f:\\n tc_mirror = line.strip()\\n if tc_mirror == \\\"\\\":\\n continue\\n config[m][\\\"tinycore_mirror\\\"] = tc_mirror\\n\\n config_name = os.path.splitext(\\n os.path.basename(config[m][\\\"config\\\"]))[0]\\n sections = [i]\\n if \\\"sections\\\" in config[i]:\\n sections = config[i][\\\"sections\\\"].split(\\\",\\\")\\n config_name = None\\n for s in sections.copy():\\n s = s.strip()\\n # if no output, base off config filename|section name, tc-version & arch, and curdir\\n out_file = config_name\\n if out_file is None:\\n out_file = s\\n d = datetime.date.today()\\n ver = \\\"\\\"\\n if (\\n \\\"version_output\\\" in config[m] and\\n config[m][\\\"version_output\\\"] is not None and\\n config[m][\\\"version_output\\\"] != \\\"\\\"\\n ):\\n ver = \\\"-\\\".join([\\n \\\"\\\",\\n config[m][\\\"version_output\\\"].replace(\\\" \\\", \\\"-\\\")\\n ])\\n out_file = \\\"\\\".join([\\n out_file,\\n ver,\\\"_\\\",\\n config[m][\\\"tinycore_version\\\"],\\n config[m][\\\"tinycore_arch\\\"],\\n d.strftime(\\\"_%y%m%d\\\"),\\n \\\".gz\\\"\\n ])\\n out_dir = \\\"\\\"\\n if \\\"output\\\" in config[s]:\\n out_dir = expand_dir(config[s][\\\"output\\\"])\\n if out_dir == \\\"\\\":\\n new_path = expand_dir(\\\"./\\\")\\n new_out = os.path.join(new_path, out_file)\\n config[s][\\\"output\\\"] = new_out\\n elif os.path.isdir(out_dir):\\n # just update the file-name\\n new_out = os.path.join(out_dir, out_file)\\n config[s][\\\"output\\\"] = new_out\\n else:\\n # otherwise, just make sure it's a full absolute path\\n config[s][\\\"output\\\"] = out_dir\\n out_dir = os.path.dirname(config[s][\\\"output\\\"])\\n if not os.path.isdir(out_dir):\\n print(\\\"Config directory {} doesn't exist\\\\n\\\\n\\\".format(out_dir))\\n return None\\n # Setup the exclusive local extensions directory in each section\\n config[s][\\\"exclusive_extensions_local_dir\\\"] = exc_exts\\n if exc_exts != \\\"\\\":\\n config[s][\\\"extensions_local_dir\\\"] = exc_exts\\n\\n\\n # TODO: Verify we have all the required fields if they weren't specified\\n if (\\\"install_root\\\" not in config[m] or\\n config[m][\\\"install_root\\\"] is None or\\n config[m][\\\"install_root\\\"] == \\\"\\\"\\n ):\\n config[m][\\\"install_root\\\"] = \\\"/tmp/tce\\\"\\n\\n return config\",\n \"def read_arguments(argv):\\n\\tif argv[0] in ('1', '2'):\\n\\t\\tconos_config['endpoint'] = endpoint[argv[0]]\\n\\telse:\\n\\t\\tusage()\\n\\n\\tif argv[1] in ('dev', 'test', 'int', 'prod'):\\n\\t\\tconos_config['environment'] = argv[1]\\n\\t\\tconos_config['sts_url'] = eval(argv[1] + '_sts_url')\\n\\t\\tconos_config['aicuu_url'] = eval(argv[1] + '_aicuu_url')\\n\\telse:\\n\\t\\tusage()\\n\\n\\tif len(argv) == 6:\\n\\t\\tconos_config['number_threads'] = '1'\\n\\telse:\\n\\t\\tif argv[6] in ('1', '2', '3', '4', '5', '6', '7', '8'):\\n\\t\\t\\tconos_config['number_threads'] = argv[6]\\n\\t\\telse:\\n\\t\\t\\tusage()\\n\\n\\tconos_config['client_id'] = argv[2]\\n\\tconos_config['client_secret'] = argv[3]\\n\\tconos_config['input_file'] = argv[4]\\n\\tconos_config['output_file'] = argv[5]\",\n \"def config_from_args(args):\\n \\n config = copy.deepcopy(default_config)\\n \\n for i in xrange(1, len(args)):\\n arg = args[i]\\n \\n if arg.startswith('--'):\\n if arg == '--help':\\n # TODO: autogenerate help\\n pass\\n else:\\n # Split each argument\\n meta_pair = arg.replace('--', '').split('-')\\n attr = meta_pair[0]\\n key = meta_pair[1].split('=', 2)[0]\\n \\n value = arg.split('=', 2)[1]\\n \\n if not hasattr(config, attr):\\n print 'Warning: invalid argument attribute %s : %s' % (attr, arg)\\n elif not key in getattr(config, attr).keys():\\n print 'Warning: invalid argument key %s : %s' % (key, arg)\\n else:\\n # Set the configuration value\\n getattr(config, attr)[key] = value\\n else:\\n print 'Warning: invalid argument %s' % (arg)\\n \\n config.purify()\\n \\n return config\",\n \"def parse_config(cmdline_opts):\\n cmdline_opts.add_argument(\\n '-p', '--port', help='Enter port number', default=8001)\\n cmdline_opts.add_argument(\\n '--host', help='Enter host name', default='localhost')\\n cmdline_opts.add_argument(\\n '-c', '--config', help='Enter config file', default='config.json')\",\n \"def setup(args):\\n cfg = get_cfg()\\n add_imaterialist_config(cfg)\\n cfg.merge_from_file(model_zoo.get_config_file(\\\"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml\\\"))\\n cfg.merge_from_file(args.config_file)\\n \\n cfg.merge_from_list(args.opts)\\n cfg.freeze()\\n default_setup(cfg, args)\\n # Setup logger for \\\"imaterialist\\\" module\\n setup_logger(output=cfg.OUTPUT_DIR, distributed_rank=comm.get_rank(), name=\\\"imaterialist\\\")\\n return cfg\",\n \"def load(args):\\n subprocess.check_call([\\\"/bin/launchctl\\\", \\\"load\\\"] + values.get(args))\",\n \"def init_config(args=None):\\n if args is None:\\n args = parser_args()\\n\\n # Set the experiment directory\\n exp_dir = args.exp_dir\\n if exp_dir is None:\\n exp_dir = 'experiment/' + args.model_name + '/' + osp.splitext(osp.basename(args.default_config_path))[0]\\n\\n # copy file\\n dst_config_path = osp.join(exp_dir, osp.basename(args.default_config_path))\\n src_copy_to_dst(args.default_config_path, dst_config_path)\\n\\n # overwrite\\n if args.ow_config_path != 'None':\\n print('ow_config_path is: {}'.format(args.ow_config_path))\\n overwrite_config_file(dst_config_path, ow_file=args.ow_config_path)\\n if args.ow_str != 'None':\\n print('ow_str is: {}'.format(args.ow_str))\\n overwrite_config_file(dst_config_path, ow_str=args.ow_str)\\n\\n # import config\\n cfg = import_file(dst_config_path).cfg\\n\\n # Set log experiment dir\\n cfg.log.exp_dir = exp_dir\\n return cfg\",\n \"def load_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--batchsize\\\",\\n help=\\\"the batch size of the dataloader\\\",\\n type=int,\\n default=2,\\n required=False)\\n parser.add_argument(\\\"--validsize\\\",\\n help=\\\"percentage that training set split into validation set\\\",\\n type=float,\\n default=1/6,\\n required=False)\\n parser.add_argument(\\\"--input-prefix\\\",\\n help=\\\"file for saving the data (.gz file)\\\",\\n type=str,\\n default=\\\"../mnistPC\\\",\\n required=False)\\n parser.add_argument(\\\"--demo\\\",\\n help=\\\"if demo is true, then only load small number of images\\\",\\n type=bool,\\n default=False,\\n required=False)\\n parser.add_argument(\\\"--test\\\",\\n help=\\\"if test is true, then load data from test dataset\\\",\\n type=bool,\\n default=False,\\n required=False)\\n parser.add_argument(\\\"--epochs\\\",\\n help=\\\"number of epochs\\\",\\n type=int,\\n default=5,\\n required=False)\\n parser.add_argument(\\\"--learning_rate\\\",\\n help=\\\"learning rate of the model\\\",\\n type=float,\\n default=1e-2,\\n required=False)\\n parser.add_argument(\\\"--num_classes\\\",\\n help=\\\"number of classes for classification\\\",\\n type=int,\\n default=10,\\n required=False)\\n parser.add_argument(\\\"--num_neighbors\\\",\\n help=\\\"num of neighbors for the network\\\",\\n type=int,\\n default=15,\\n required=False)\\n parser.add_argument(\\\"--cudas\\\",\\n help=\\\"cuda numbera to use, if use cpu, please enter -1\\\",\\n type=str,\\n default=\\\"0/1/2/3\\\",\\n required=False)\\n args = parser.parse_args()\\n return args\",\n \"def load_args():\\n parser = argparse.ArgumentParser(description=\\\"Classify and predict digits using the mnist dataset\\\")\\n parser.add_argument('mode', help='the mode to run in: fit, model or predict')\\n parser.add_argument('--algo', help='which algorithm to use: RandomForest, KNN')\\n return parser.parse_args()\",\n \"def configure(self, args):\\n pass\",\n \"def load_args(altconf=None):\\n config = kaptan.Kaptan(handler='yaml')\\n mkconfig()\\n\\n # If an alternate config file has been specified\\n if altconf is not None:\\n if not os.path.isfile(altconf):\\n abort(\\\"File not found: {}\\\".format(altconf))\\n try:\\n config.import_config(altconf)\\n except (ValueError, ParserError):\\n abort(\\\"{} is not a valid yaml file.\\\".format(altconf))\\n\\n # Default\\n else:\\n conf_dir = os.path.join(os.path.expanduser('~'), '.strikepackage')\\n\\n # Look for conf file in default locations\\n for loc in [os.curdir, conf_dir]:\\n configpath = os.path.join(loc, 'config.yaml')\\n try:\\n if os.path.isfile(configpath):\\n config.import_config(configpath)\\n break\\n except (ValueError, ParserError):\\n abort(\\\"{} is not a valid yaml file.\\\".format(configpath))\\n if not config.configuration_data:\\n abort(\\\"Config file not found. See README for help.\\\")\\n\\n # Validate conf file\\n return validate_conf(config.configuration_data)\",\n \"def load_config():\\n parser = argparse.ArgumentParser(description='LTHNet_PyTorch_LinearLoss')\\n parser.add_argument('--dataset', default='imagenet-100-IF1', type=str,\\n help='Dataset name.')\\n parser.add_argument('--root', default='C:\\\\\\\\Users\\\\\\\\dell\\\\\\\\Desktop\\\\\\\\LTH_linearloss\\\\\\\\data\\\\\\\\imagenet100\\\\\\\\', type=str,\\n help='Path of dataset')\\n # parser.add_argument('--root', default='/home/13810427976/notespace/cifar-100/cifar-100-IF20/', type=str,\\n # help='Path of dataset')\\n parser.add_argument('--code-length', default='32,48,64,96', type=str,\\n help='Binary hash code length.(default: 32,48,64,96)')\\n parser.add_argument('--arch', default='resnet34', type=str,\\n help='CNN model name.(default: alexnet)')\\n parser.add_argument('--feature-dim', default=2000, type=int,\\n help='number of classes.(default: 2000)')\\n parser.add_argument('--num-classes', default=100, type=int,\\n help='number of classes.(default: 100)')\\n parser.add_argument('--num-prototypes', default=100, type=int,\\n help='number of prototypes.(default: 100)')\\n parser.add_argument('--batch-size', default=128, type=int,\\n help='Batch size.(default: 128)')\\n parser.add_argument('--lr', default=1e-5, type=float,\\n help='Learning rate.(default: 1e-5)')\\n parser.add_argument('--max-iter', default=100, type=int,\\n help='Number of iterations.(default: 300)')\\n parser.add_argument('--num-workers', default=6, type=int,\\n help='Number of loading data threads.(default: 6)')\\n parser.add_argument('--dynamic-meta-embedding', default=True, type=bool,\\n help='dynamic meta embedding.(default: True)')\\n parser.add_argument('--topk', default=-1, type=int,\\n help='Calculate map of top k.(default: all)')\\n parser.add_argument('--gpu', default=None, type=int,\\n help='Using gpu.(default: False)')\\n parser.add_argument('--beta', default=0.0, type=float,\\n help='Hyper-parameter: class-balanced factor.(default: 0.99)')\\n parser.add_argument('--gamma', default=1.0, type=float,\\n help='Hyper-parameter: balance between pointwise and pairwise loss.(default: 1.0)')\\n parser.add_argument('--seed', default=3367, type=int,\\n help='Random seed.(default: 3367)')\\n parser.add_argument('--evaluate-interval', default=1, type=int,\\n help='Evaluation interval.(default: 10)')\\n\\n args = parser.parse_args()\\n\\n # GPU\\n if args.gpu is None:\\n args.device = torch.device(\\\"cpu\\\")\\n else:\\n os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)\\n args.device = torch.device(\\\"cuda:%d\\\" % 0)\\n\\n # Hash code length\\n args.code_length = list(map(int, args.code_length.split(',')))\\n\\n return args\",\n \"def main():\\n args = parse_command_line()\\n expt_config = load_config(args.experiment_config_path)\\n run_cli(RunOptions.from_dict(expt_config))\",\n \"def setup(args):\\n cfg = get_cfg()\\n cfg.merge_from_file(args.config_file)\\n cfg.merge_from_list(args.opts)\\n # customize reszied parameters\\n # cfg['INPUT']['MIN_SIZE_TRAIN'] = (20,)\\n # cfg['INPUT']['MAX_SIZE_TRAIN'] = 50\\n cfg.freeze()\\n default_setup(\\n cfg, args\\n ) # if you don't like any of the default setup, write your own setup code\\n return cfg\",\n \"def load_arguments(config_file= None ):\\n if config_file is None :\\n cur_path = os.path.dirname(os.path.realpath(__file__))\\n config_file = os.path.join(cur_path, \\\"config.toml\\\")\\n print(config_file)\\n\\n p = argparse.ArgumentParser()\\n p.add_argument(\\\"--config_file\\\", default=config_file, help=\\\"Params File\\\")\\n p.add_argument(\\\"--config_mode\\\", default=\\\"test\\\", help=\\\"test/ prod /uat\\\")\\n p.add_argument(\\\"--log_file\\\", help=\\\"File to save the logging\\\") \\n\\n p.add_argument(\\\"--do\\\", default=\\\"test\\\", help=\\\"what to do test or search\\\") \\n p.add_argument(\\\"--ntrials\\\", default=100, help='number of trials during the hyperparameters tuning')\\n p.add_argument(\\\"--modelname\\\", default=\\\"model_dl.1_lstm.py\\\", help=\\\"name of the model to be tuned this name will be used to save the model\\\") \\n p.add_argument(\\\"--data_path\\\", default=\\\"dataset/GOOG-year_small.csv\\\", help=\\\"path of the training file\\\") \\n p.add_argument('--optim_engine', default='optuna',help='Optimization engine') \\n p.add_argument('--optim_method', default='normal/prune',help='Optimization method') \\n p.add_argument('--save_folder', default='model_save',help='folder that will contain saved version of best model') \\n \\n args = p.parse_args()\\n args = load_config(args, args.config_file, args.config_mode, verbose=0)\\n return args\",\n \"def config(*subconfig):\\n\\n with open('configure.yaml', 'r') as stream:\\n args = yaml.load(stream)\\n\\n # Parse command line arguments\\n parser = argparse.ArgumentParser(description='')\\n parser.add_argument(\\n '--node',\\n '-n',\\n help='The node ID.'\\n )\\n parser.add_argument(\\n '--processes',\\n '-p',\\n help='The total number of processes.'\\n )\\n # Store command line arguments in a dict\\n cl_args = parser.parse_args()\\n cl_args_dict = vars(cl_args)\\n # Combine\\n args.update(cl_args_dict)\\n # Find subconfig if argument is passed\\n for s in subconfig:\\n try:\\n args = args[s]\\n except:\\n pass\\n # Return\\n return args\",\n \"def setup(args):\\n cfg = get_cfg()\\n cfg.merge_from_file(args.config_file)\\n cfg.merge_from_list(args.opts)\\n cfg.freeze()\\n default_setup(cfg, args)\\n return cfg\",\n \"def setup(args):\\n cfg = get_cfg()\\n cfg.merge_from_file(args.config_file)\\n cfg.merge_from_list(args.opts)\\n cfg.freeze()\\n default_setup(cfg, args)\\n return cfg\",\n \"def setup(args):\\n cfg = get_cfg()\\n cfg.merge_from_file(args.config_file)\\n cfg.merge_from_list(args.opts)\\n cfg.freeze()\\n default_setup(cfg, args)\\n return cfg\",\n \"def load_config(config_arg):\\n if config_arg.startswith(\\\"{\\\"):\\n return json.loads(config_arg)\\n elif config_arg == \\\"-\\\":\\n return json.loads(sys.stdin.read())\\n else:\\n with open(config_arg) as config_file:\\n return json.load(config_file)\",\n \"def read_config(filename, args):\\n # Initial vars\\n config = defaultdict(dict)\\n splitter = operator.methodcaller('split', ' ')\\n\\n converters = {\\n __script__: {\\n 'env': safe_path,\\n 'pre_requirements': splitter,\\n },\\n 'pip': {\\n 'allow_external': splitter,\\n 'allow_unverified': splitter,\\n }\\n }\\n default = copy.deepcopy(CONFIG)\\n sections = set(iterkeys(default))\\n\\n # Expand user and environ vars in config filename\\n filename = os.path.expandvars(os.path.expanduser(filename))\\n\\n # Read config if it exists on disk\\n if os.path.isfile(filename):\\n parser = SafeConfigParser()\\n\\n try:\\n parser.read(filename)\\n except ConfigParserError:\\n error('Cannot parse config file at {0!r}'.format(filename))\\n\\n # Apply config for each possible section\\n for section in sections:\\n if not parser.has_section(section):\\n continue\\n\\n items = parser.items(section)\\n\\n # Make auto convert here for integers and boolean values\\n for key, value in items:\\n try:\\n value = int(value)\\n except (TypeError, ValueError):\\n try:\\n value = bool(strtobool(value))\\n except ValueError:\\n pass\\n\\n if section in converters and key in converters[section]:\\n value = converters[section][key](value)\\n\\n config[section][key] = value\\n\\n # Update config with default values if necessary\\n for section, data in iteritems(default):\\n if section not in config:\\n config[section] = data\\n else:\\n for key, value in iteritems(data):\\n config[section].setdefault(key, value)\\n\\n # Update bootstrap config from parsed args\\n keys = set((\\n 'env', 'hook', 'pre_requirements', 'quiet', 'recreate', 'requirements'\\n ))\\n\\n for key in keys:\\n value = getattr(args, key)\\n config[__script__].setdefault(key, value)\\n\\n if key == 'pre_requirements' and not value:\\n continue\\n\\n if value is not None:\\n config[__script__][key] = value\\n\\n return config\",\n \"def load_config(default_config: str, silent=False):\\n if len(sys.argv) == 1:\\n # Then the file being called is the only argument so return the default configuration\\n config_file = default_config\\n elif len(sys.argv) == 2:\\n # Then a specific configuration file has been used so load it\\n config_file = str(sys.argv[1])\\n elif all([len(sys.argv) == 3, sys.argv[1] == '-f']):\\n config_file = default_config\\n else:\\n print(sys.argv)\\n raise ValueError('CLI only accepts 0 args (default) or 1 arg (path/to/config).')\\n\\n with open(str(config_file), 'r') as f:\\n y = yaml.full_load(f)\\n if not silent:\\n print(f'Experimental parameters\\\\n------')\\n pprint(y)\\n return y\",\n \"def cli(configfile):\\n if path.exists(configfile):\\n load_config(\\\"aplet.yml\\\")\\n pass\",\n \"def load_config(cls, config_file = None):\\n config = ConfigParser()\\n \\n files = [\\\"/etc/imp.cfg\\\", os.path.expanduser(\\\"~/.imp.cfg\\\"), \\\".wm\\\", \\\".imp\\\"]\\n if config_file is not None:\\n files.append(config_file)\\n \\n config.read(files)\\n cls.__instance = config\",\n \"def grab_config():\\n parser = argparse.ArgumentParser(description=\\\"NoisyCLIP\\\")\\n\\n parser.add_argument('--config_file')\\n parser.add_argument('--ckpt_file')\\n\\n config = yaml_config_hook(parser.parse_args().config_file)\\n for k, v in config.items():\\n parser.add_argument(f\\\"--{k}\\\", default=v, type=type(v))\\n\\n args = parser.parse_args()\\n\\n return args\",\n \"def init_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"DeltaSherlock Client software.\\\")\\n parser.add_argument('-v', '--version', action='version', version=VERSION)\\n parser.add_argument('-c', '--config', action='store', dest='config_file',\\n default='./config.ini', help=\\\"Path to config file. [default: \\\\\\n %(default)s]\\\")\\n parser.add_argument('-d', '--daemon', action='store_true', dest='daemon',\\n default=False, help=\\\"Run in daemon mode. [default: \\\\\\n %(default)s]\\\")\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='Eval')\\n parser.add_argument(\\n '--cfg', help='experiment configure file path', type=str, \\\\\\n default=\\\"validation.config.Config\\\")\\n return parser.parse_args()\",\n \"def load_config():\\n model_type, run_name, run_comment, epoch, verbose = get_args()\\n name = run_name + '-' + run_comment\\n if model_type == \\\"s2s\\\": \\n run_title = \\\"seq2seq\\\"\\n else:\\n run_title = \\\"def2vec\\\"\\n path = \\\"outputs/{}/logs/{}/config.json\\\".format(run_title, name)\\n config = None\\n with open(path) as f:\\n config = dict(json.load(f))\\n config = load_config(eval=True)\\n return (config, name, model_type)\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser(description='CLI to store Actisense-NGT Gateway values to InfluxDB and publish via MQTT')\\n parser.add_argument('--config', '-c', type=str, required=True, help='JSON configuraton file with path')\\n return parser.parse_args()\",\n \"def load_configuration():\\n argparser = ArgumentParser(description=\\\"Zoe application tester - Container Analytics as a Service core component\\\",\\n default_config_files=CONFIG_PATHS,\\n auto_env_var_prefix=\\\"ZOE_MASTER_\\\",\\n args_for_setting_config_path=[\\\"--config\\\"],\\n args_for_writing_out_config_file=[\\\"--write-config\\\"])\\n\\n argparser.add_argument('--debug', action='store_true', help='Enable debug output')\\n argparser.add_argument('--swarm', help='Swarm/Docker API endpoint (ex.: zk://zk1:2181,zk2:2181 or http://swarm:2380)', default='http://localhost:2375')\\n argparser.add_argument('--deployment-name', help='name of this Zoe deployment', default='prod')\\n\\n argparser.add_argument('--dbname', help='DB name', default='zoe')\\n argparser.add_argument('--dbuser', help='DB user', default='zoe')\\n argparser.add_argument('--dbpass', help='DB password', default='')\\n argparser.add_argument('--dbhost', help='DB hostname', default='localhost')\\n argparser.add_argument('--dbport', type=int, help='DB port', default=5432)\\n\\n # Master options\\n argparser.add_argument('--api-listen-uri', help='ZMQ API listen address', default='tcp://*:4850')\\n argparser.add_argument('--influxdb-dbname', help='Name of the InfluxDB database to use for storing metrics', default='zoe')\\n argparser.add_argument('--influxdb-url', help='URL of the InfluxDB service (ex. http://localhost:8086)', default='http://localhost:8086')\\n argparser.add_argument('--influxdb-enable', action=\\\"store_true\\\", help='Enable metric output toward influxDB')\\n argparser.add_argument('--gelf-address', help='Enable Docker GELF log output to this destination (ex. udp://1.2.3.4:1234)', default='')\\n argparser.add_argument('--workspace-base-path', help='Path where user workspaces will be created by Zoe. Must be visible at this path on all Swarm hosts.', default='/mnt/zoe-workspaces')\\n argparser.add_argument('--overlay-network-name', help='Name of the Swarm overlay network Zoe should use', default='zoe')\\n\\n # API options\\n argparser.add_argument('--listen-address', type=str, help='Address to listen to for incoming connections', default=\\\"0.0.0.0\\\")\\n argparser.add_argument('--listen-port', type=int, help='Port to listen to for incoming connections', default=5001)\\n argparser.add_argument('--master-url', help='URL of the Zoe master process', default='tcp://127.0.0.1:4850')\\n\\n # API auth options\\n argparser.add_argument('--auth-type', help='Authentication type (text or ldap)', default='text')\\n\\n argparser.add_argument('--auth-file', help='Path to the CSV file containing user,pass,role lines for text authentication', default='zoepass.csv')\\n\\n argparser.add_argument('--ldap-server-uri', help='LDAP server to use for authentication', default='ldap://localhost')\\n argparser.add_argument('--ldap-base-dn', help='LDAP base DN for users', default='ou=something,dc=any,dc=local')\\n argparser.add_argument('--ldap-admin-gid', type=int, help='LDAP group ID for admins', default=5000)\\n argparser.add_argument('--ldap-user-gid', type=int, help='LDAP group ID for users', default=5001)\\n argparser.add_argument('--ldap-guest-gid', type=int, help='LDAP group ID for guests', default=5002)\\n\\n argparser.add_argument('jsonfile', type=FileType(\\\"r\\\"), help='Application description')\\n\\n opts = argparser.parse_args()\\n\\n opts.gelf_address = '' # For debugging we want to easily look at logs with 'docker logs'\\n opts.influxdb_enable = False # don't send metrics for these test runs\\n opts.deployment_name = 'zapp-test'\\n\\n if opts.debug:\\n argparser.print_values()\\n\\n return opts\",\n \"def load_config():\\n config = configparser.ConfigParser()\\n config.read('config.ini')\\n return config\",\n \"def load_configuration() -> argparse.Namespace:\\n h = 24\\n days = 5\\n\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--age\\\", help=\\\"Patient age (years).\\\",\\n default=20, required=False, type=int)\\n parser.add_argument(\\\"--infection\\\", help=\\\"Whether the patient has a SARS infection or not.\\\",\\n default=True, required=False, type=bool)\\n parser.add_argument(\\\"--dose\\\", help=\\\"Drug dose (mg). 5 is nominal dose for Benazepril and 1.25 for Cilazapril.\\\",\\n default=0, required=False, type=int)\\n parser.add_argument(\\\"--renal-function\\\", help=\\\"Type of renal function.\\\", default=\\\"normal\\\",\\n required=False, choices=[\\\"normal\\\", \\\"impaired\\\"], nargs=1, type=str)\\n parser.add_argument(\\\"--glu\\\", help=\\\"Glucose concentration (mmol/L). \\\"\\n \\\"To have normal subject glucose dyanmics as input,\\\"\\n \\\"use glu = 1; for diabetic subjects, glu = 2. Rest all values will be\\\"\\n \\\"used directly in mmol/L as steady state glucose input.\\\",\\n default=1, required=False, type=float)\\n parser.add_argument(\\\"--drug-name\\\", help=\\\"Drug name.\\\", default=\\\"benazepril\\\",\\n required=False)\\n\\n parser.add_argument(\\\"--n-dose\\\", help=\\\"Number of doses per day (cannot be zero).\\\", default=1, required=False,\\n type=int)\\n parser.add_argument(\\\"--tstart-dosing\\\", help=\\\"Initial dosing time.\\\", default=h * 0, required=False, type=int)\\n parser.add_argument(\\\"--tfinal-dosing\\\", help=\\\"Final dosing time.\\\", default=h * days, required=False, type=int)\\n parser.add_argument(\\\"--sim-time-end\\\", help=\\\"Simulation end time.\\\", default=h * days, required=False, type=int)\\n\\n parser.add_argument(\\\"--show-plots\\\", help=\\\"Show plots.\\\", default=True, required=False, type=bool)\\n parser.add_argument(\\\"--linestyle\\\", help=\\\"Plot line style.\\\", default=\\\"-\\\", required=False, type=str)\\n parser.add_argument(\\\"--linewidth\\\", help=\\\"Plot line width.\\\", default=2, required=False, type=int)\\n parser.add_argument(\\\"--legendloc\\\", help=\\\"Plot legend location.\\\", default=\\\"NorthEast\\\", required=False, type=str)\\n args = parser.parse_args()\\n\\n return args\",\n \"def __init__(self):\\n self.argus = docopt(__doc__, version = 'Deployments 1.0')\\n print(self.argus)\\n if not self.argus['reservation']:\\n try:\\n with open(self.argus['--conf']) as config_file:\\n self.config = json.load(config_file)\\n print(self.config)\\n\\n except Exception as e:\\n t, value, tb = sys.exc_info()\\n print str(t) + \\\" \\\" + str(value)\\n traceback.print_tb(tb)\\n print(\\\"Config file not working\\\")\",\n \"def load_conf(filename: str,\\n args: Union[None, 'argparse.Namespace'] = None) -> m.Image:\\n # Get the configuration from the file.\\n with open(filename, 'r') as fh:\\n conf_json = fh.read()\\n conf = json.loads(conf_json)\\n\\n # Deserialize configuration based on the given version.\\n if (conf['Version'] == '0.2.0'\\n or conf['Version'] == '0.3.0'\\n or conf['Version'] == '0.3.1'):\\n # Allow CLI arguments to change or override values in the\\n # loaded config.\\n if args and args.filename:\\n conf['Image']['filename'] = args.filename\\n conf['Image']['format'] = get_format(args.filename)\\n if args and args.size:\\n conf['Image']['size'] = args.size[::-1]\\n if args and args.location:\\n _update_location(conf['Image'], args.location[::-1])\\n\\n # Deserialize and return the configuration object.\\n return m.Image(**conf['Image'])\\n\\n # Otherwise, the version isn't recognized, so throw an error.\\n else:\\n raise ValueError(f'Version {conf[\\\"Version\\\"]} not supported.')\",\n \"def get_config_params():\\n configParser = configparser.ConfigParser()\\n configParser.read(os.path.splitext(sys.argv[0])[0]+'.ini')\\n return configParser\",\n \"def get_config():\\n\\n parser = argparse.ArgumentParser(\\n description='ZoomingSloMo or only Slo-Mo training argument parser')\\n parser.add_argument('--cfg', default=\\\"./config.yaml\\\")\\n args, _ = parser.parse_known_args()\\n conf = read_yaml(args.cfg)\\n\\n parser.add_argument('--lmdb-data-gt', type=str, default=\\\"datasets/\\\",\\n help='Path to HR frames lmdb for training')\\n\\n parser.add_argument('--lmdb-data-lq', type=str, default=\\\"datasets/\\\",\\n help='Path to LR frames lmdb for training')\\n\\n parser.add_argument('--output-dir', type=str, default=\\\"models/\\\",\\n help='Path to store trained models')\\n\\n parser.add_argument('--batch-size', type=int, default=\\\"12\\\",\\n help='Maximum number of iterations for training')\\n\\n parser.add_argument('--gt-size', type=int, default=128,\\n help='Ground truth frame size')\\n\\n parser.add_argument('--only-slomo', action='store_true', default=False,\\n help='If True, network will train for Slo-Mo only (No Zooming)')\\n\\n args = parser.parse_args()\\n\\n # Refine config file variables\\n conf.data.lmdb_data_gt = args.lmdb_data_gt\\n conf.data.lmdb_data_lq = args.lmdb_data_lq\\n conf.data.output_dir = args.output_dir\\n conf.train.batch_size = args.batch_size\\n conf.train.only_slomo = args.only_slomo\\n conf.data.gt_size = args.gt_size if not args.only_slomo else args.gt_size // 4\\n conf.data.lr_size = args.gt_size // 4\\n\\n return conf\",\n \"def parser():\\n description = \\\"\\\"\\\"\\n Use docker or local setup to import files:\\n ``python import_files_to_postgres.py config.ini docker``\\n\\n \\\"\\\"\\\"\\n\\n parser = argparse.ArgumentParser(\\n description=description)\\n parser.add_argument('config_path',\\n type=str,\\n help=\\\"Full Location of config.ini file\\\")\\n parser.add_argument('config_name',\\n type=str,\\n help=\\\"Define the running env: 'docker' or 'dev' when running locally\\\")\\n return parser\",\n \"def load_config():\\n config = ConfigParser()\\n config.read(os.path.join(os.path.dirname(__file__), 'config.ini'))\\n return config\",\n \"def cmd_entry():\\n import argparse\\n\\n parser = argparse.ArgumentParser(\\n description=\\\"Web based frontend to the health record system databaser\\\"\\n )\\n parser.add_argument('-c', '--config', required=True, help=\\\"Config file to load\\\")\\n args = parser.parse_args()\\n\\n main(args.config)\",\n \"def parse_args(self, argv):\\n super(UpdaterDaemon, self).parse_args(argv)\\n\\n self.stdout = self.options.log_file\\n self.stderr = self.options.error_log\\n\\n config = self.options.config\\n if config is None:\\n config = os.path.join(os.path.dirname(__file__), 'config.py')\\n config = os.path.normpath(os.path.abspath(config))\\n configdir, configfile = os.path.split(config)\\n configfile, ext = os.path.splitext(configfile)\\n if configdir not in sys.path:\\n sys.path.insert(0, configdir)\\n self.config = __import__(configfile)\",\n \"def initialize_command(parser):\\n parser.add_argument('--config', dest='config',\\n help='the pyramid config file')\\n args = parser.parse_args()\\n assert args.config,\\\\\\n 'You must have a --config config.ini, or we can\\\\'t run the command'\\n # load the pyramid config env\\n env = bootstrap(args.config)\\n # load the database\\n initialize_sql(\\n env['registry'].settings.get('sqlalchemy.url'))\\n # return the args and the pyramid env for later use\\n return args, env\",\n \"def configure():\\n parser = argparse.ArgumentParser(description=\\\"welcome to AutomateBGP!\\\")\\n parser.add_argument('-u', '--username', dest='username',\\n help='username to login to nodes')\\n parser.add_argument('-p', '--password', dest='password',\\n help='password to login to nodes')\\n parser.add_argument('-f', '--filename', dest='filename',\\n help='text file containing the node data (expected format...)')\\n return parser.parse_args()\",\n \"def load_config(options):\\n if not os.path.exists(options.config_file):\\n logging.info(\\\"%s does not exist - initializing with an example configuration\\\" % CRANKD_OPTIONS.config_file)\\n print >>sys.stderr, 'Creating %s with default options for you to customize' % options.config_file\\n print >>sys.stderr, '%s --list-events will list the events you can monitor on this system' % sys.argv[0]\\n example_config = {\\n 'SystemConfiguration': {\\n 'State:/Network/Global/IPv4': {\\n 'command': '/bin/echo \\\"Global IPv4 config changed\\\"'\\n }\\n },\\n 'NSWorkspace': {\\n 'NSWorkspaceDidMountNotification': {\\n 'command': '/bin/echo \\\"A new volume was mounted!\\\"'\\n },\\n 'NSWorkspaceDidWakeNotification': {\\n 'command': '/bin/echo \\\"The system woke from sleep!\\\"'\\n },\\n 'NSWorkspaceWillSleepNotification': {\\n 'command': '/bin/echo \\\"The system is about to go to sleep!\\\"'\\n }\\n }\\n }\\n writePlist(example_config, options.config_file)\\n sys.exit(1)\\n\\n logging.info(\\\"Loading configuration from %s\\\" % CRANKD_OPTIONS.config_file)\\n\\n plist = readPlist(options.config_file)\\n\\n if \\\"imports\\\" in plist:\\n for module in plist['imports']:\\n try:\\n __import__(module)\\n except ImportError, exc:\\n print >> sys.stderr, \\\"Unable to import %s: %s\\\" % (module, exc)\\n sys.exit(1)\\n return plist\",\n \"def readConfig(self, config_file):\\n parser = ConfigParser.RawConfigParser()\\n parser.read(config_file)\\n self.NUM_PROCESSES = parser.getint('loader', 'NUM_PROCESSES')\\n self.EXEC = parser.get('loader', 'EXECUTABLE')\\n self.TILE_LOADER_JSON = parser.get('loader', 'TILE_LOADER_JSON')\\n # If the load request was to a single tile db instance then\\n # we can skip details on MPI, else MPI fields are required\\n if self.NUM_PROCESSES == 1:\\n return\\n self.MPIRUN = parser.get('mpi', 'MPIRUN')\\n self.HOSTS = parser.get('mpi', 'HOSTS')\\n self.HOSTFLAG = parser.get('mpi', 'HOSTFLAG')\\n\\n if parser.has_option('mpi', 'BTL_TCP_IF_INCLUDE'):\\n self.IF_INCLUDE = parser.get('mpi', 'BTL_TCP_IF_INCLUDE')\\n if parser.has_option('mpi', 'INCLUDE_ENV'):\\n self.ENV = parser.get('mpi', 'INCLUDE_ENV')\",\n \"def load_configuration(self, config, load_args):\\n try:\\n if config is not None:\\n self.config.load(config, **load_args)\\n else:\\n self.queue_message(\\\"log\\\", \\\"Load args %s.\\\", str(load_args))\\n self.config.load(**load_args)\\n self.queue_message(\\\"log\\\", \\\"Configuration loaded.\\\")\\n except (self.pyez_exception.RpcError,\\n self.pyez_exception.ConnectError) as ex:\\n raise AnsibleError('Failure loading the configuraton: %s' %\\n (str(ex)))\",\n \"def load_params():\\n # start arg parser\\n parser = argparse.ArgumentParser(description='Apero Copy')\\n # add arguments\\n parser.add_argument('yaml', help='yaml file to use', type=str,\\n default=None)\\n parser.add_argument('--overwrite', help='overwrite existing files',\\n action='store_true', default=False)\\n parser.add_argument('--test', help='run in test mode (no copy or remove)',\\n action='store_true', default=False)\\n parser.add_argument('--symlinks', action='store_true', default=False,\\n help='Copy in symlink mode (not recommended)')\\n # get arguments\\n args = vars(parser.parse_args())\\n # ------------------------------------------------------------------\\n # deal with getting yaml file\\n # ------------------------------------------------------------------\\n # deal with no yaml file set\\n if args['yaml'] is None:\\n emsg = 'yaml file must be set'\\n raise AperoCopyError(emsg)\\n # deal with bad path\\n if not os.path.exists(args['yaml']):\\n emsg = 'yaml file {0} does not exist'\\n eargs = [args['yaml']]\\n raise AperoCopyError(emsg.format(*eargs))\\n # otherwise we read the yaml file\\n params = read_yaml(args['yaml'])\\n # add args to params\\n for arg in args:\\n if arg not in params:\\n params[arg] = args[arg]\\n # ------------------------------------------------------------------\\n # return the parameters\\n return params\",\n \"def parse_args():\\n hpo_warning = 'Flag overwrites config value if set, used for HPO and PBT runs primarily'\\n parser = argparse.ArgumentParser('train.py')\\n add_arg = parser.add_argument\\n add_arg('config', nargs='?', default='configs/hello.yaml')\\n add_arg('-d', '--distributed', choices=['ddp-file', 'ddp-mpi', 'cray'])\\n add_arg('-v', '--verbose', action='store_true')\\n add_arg('--ranks-per-node', default=8)\\n add_arg('--gpu', type=int)\\n add_arg('--rank-gpu', action='store_true')\\n add_arg('--resume', action='store_true', help='Resume from last checkpoint')\\n add_arg('--show-config', action='store_true')\\n add_arg('--interactive', action='store_true')\\n add_arg('--output-dir', help='override output_dir setting')\\n add_arg('--seed', type=int, default=0, help='random seed')\\n add_arg('--fom', default=None, choices=['last', 'best'],\\n help='Print figure of merit for HPO/PBT')\\n add_arg('--n-train', type=int, help='Override number of training samples')\\n add_arg('--n-valid', type=int, help='Override number of validation samples')\\n add_arg('--batch-size', type=int, help='Override batch size. %s' % hpo_warning)\\n add_arg('--n-epochs', type=int, help='Specify subset of total epochs to run')\\n add_arg('--real-weight', type=float, default=None,\\n help='class weight of real to fake edges for the loss. %s' % hpo_warning)\\n add_arg('--lr', type=float, default=None,\\n help='Learning rate. %s' % hpo_warning)\\n add_arg('--hidden-dim', type=int, default=None,\\n help='Hidden layer dimension size. %s' % hpo_warning)\\n add_arg('--n-graph-iters', type=int, default=None,\\n help='Number of graph iterations. %s' % hpo_warning)\\n add_arg('--weight-decay', type=float)\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser('train.py')\\n add_arg = parser.add_argument\\n add_arg('config', nargs='?', default='configs/hello.yaml')\\n add_arg('-d', '--distributed', choices=['ddp-file', 'ddp-mpi', 'cray'])\\n add_arg('-v', '--verbose', action='store_true')\\n add_arg('--ranks-per-node', default=8)\\n add_arg('--gpu', type=int)\\n add_arg('--rank-gpu', action='store_true')\\n add_arg('--resume', action='store_true', help='Resume from last checkpoint')\\n add_arg('--show-config', action='store_true')\\n add_arg('--interactive', action='store_true')\\n add_arg('--output-dir', help='override output_dir setting')\\n add_arg('--seed', type=int, default=0, help='random seed')\\n return parser.parse_args()\",\n \"def _parse_config(self, args, experiment_id):\\r\\n if not args:\\r\\n if experiment_id:\\r\\n config = importlib.import_module('configs.config_' + experiment_id)\\r\\n args = config.load_config()\\r\\n else:\\r\\n raise ValueError('No arguments or configuration data given')\\r\\n # Mandatory parameters for all architectures\\r\\n self.network_type = args.net\\r\\n self.is_training = args.training_mode\\r\\n self.train_data_file = args.train_data_file\\r\\n self.valid_data_file = args.valid_data_file\\r\\n self.test_data_file = args.test_data_file\\r\\n self.checkpoint_dir = args.checkpoint_dir\\r\\n self.trainlog_dir = args.trainlog_dir\\r\\n self.lr = args.lr\\r\\n self.batch_size = args.batch_size\\r\\n self.num_epochs = args.num_epochs\\r\\n self.loss_type = args.loss\\r\\n self.accuracy_type = args.accuracy\\r\\n self.optimizer = args.optimizer\\r\\n self.dropout = args.dropout\\r\\n self.gpu_load = args.gpu_load\\r\\n self.num_filters = args.num_filters\\r\\n self.nonlin = args.nonlin\\r\\n self.loss_type = args.loss\\r\\n self.task_type = args.task_type\\r\\n self.long_summary = args.long_summary\\r\\n self.experiment_path = args.experiment_path\\r\\n self.chpnt2load = args.chpnt2load\\r\\n self.lr_mode = args.lr_mode\\r\\n\\r\\n if not self.is_training:\\r\\n self.class_labels = args.class_labels\\r\\n if args.image_size:\\r\\n self.img_size = args.image_size\\r\\n else:\\r\\n self.img_size = None\\r\\n if args.num_classes:\\r\\n self.num_classes = args.num_classes\\r\\n else:\\r\\n self.num_classes = None\\r\\n if args.augmentation:\\r\\n self.augmentation_dict = args.augmentation\\r\\n else:\\r\\n self.augmentation_dict = None\\r\\n if args.normalize:\\r\\n self.normalize = args.normalize\\r\\n else:\\r\\n self.normalize = None\\r\\n if args.zero_center:\\r\\n self.zero_center = args.zero_center\\r\\n else:\\r\\n self.zero_center = None\\r\\n\\r\\n\\r\\n self._initialize_data()\",\n \"def __init__(self, default_cfg='default.ini', argv=None):\\n\\n # Read the default settings\\n self.config = configparser.ConfigParser()\\n self.config.read(default_cfg)\\n # Check for a command line config argument\\n if argv is not None and '--config_fn' in argv:\\n # Get the config filename\\n config_fn = argv[argv.index('--config_fn') + 1]\\n argv.remove('--config_fn')\\n argv.remove(config_fn)\\n # Read the new config file\\n new_cfg = configparser.ConfigParser()\\n new_cfg.read(config_fn)\\n # Overwrite the default values\\n self._overwrite_with_config(new_cfg)\\n if argv is not None:\\n self._parse_arguments(argv)\\n self._update()\",\n \"def load(args, optargs = None, defaults = '%{_sbdir}/defaults.mc', logfile = True):\\n\\n global host_windows\\n global host_posix\\n\\n #\\n # The path to this command.\\n #\\n command_path = path.dirname(path.abspath(args[0]))\\n if len(command_path) == 0:\\n command_path = '.'\\n\\n #\\n # The command line contains the base defaults object all build objects copy\\n # and modify by loading a configuration.\\n #\\n o = command_line(args,\\n optargs,\\n macros.macros(name = defaults,\\n sbdir = command_path),\\n command_path)\\n\\n overrides = None\\n if os.name == 'nt':\\n try:\\n from . import windows\\n overrides = windows.load()\\n host_windows = True\\n host_posix = False\\n except:\\n raise error.general('failed to load Windows host support')\\n elif os.name == 'posix':\\n uname = os.uname()\\n try:\\n if uname[0].startswith('MINGW64_NT'):\\n from . import windows\\n overrides = windows.load()\\n host_windows = True\\n elif uname[0].startswith('CYGWIN_NT'):\\n from . import windows\\n overrides = windows.load()\\n elif uname[0] == 'Darwin':\\n from . import darwin\\n overrides = darwin.load()\\n elif uname[0] == 'FreeBSD':\\n from . import freebsd\\n overrides = freebsd.load()\\n elif uname[0] == 'NetBSD':\\n from . import netbsd\\n overrides = netbsd.load()\\n elif uname[0] == 'Linux':\\n from . import linux\\n overrides = linux.load()\\n elif uname[0] == 'SunOS':\\n from . import solaris\\n overrides = solaris.load()\\n except error.general as ge:\\n raise error.general('failed to load %s host support: %s' % (uname[0], ge))\\n except:\\n raise error.general('failed to load %s host support' % (uname[0]))\\n else:\\n raise error.general('unsupported host type; please add')\\n if overrides is None:\\n raise error.general('no hosts defaults found; please add')\\n for k in overrides:\\n o.defaults[k] = overrides[k]\\n\\n o.sb_released()\\n o.sb_git()\\n o.rtems_options()\\n o.pre_process()\\n o.process()\\n o.post_process(logfile)\\n\\n #\\n # Load the release settings\\n #\\n def setting_error(msg):\\n raise error.general(msg)\\n hashes = version.load_release_settings('hashes')\\n for hash in hashes:\\n hs = hash[1].split()\\n if len(hs) != 2:\\n raise error.general('invalid release hash in VERSION')\\n sources.hash((hs[0], hash[0], hs[1]), o.defaults, setting_error)\\n release_path = version.load_release_setting('version', 'release_path',\\n raw = True)\\n if release_path is not None:\\n try:\\n release_path = ','.join([rp.strip() for rp in release_path.split(',')])\\n except:\\n raise error.general('invalid release path in VERSION')\\n download.set_release_path(release_path, o.defaults)\\n return o\",\n \"def from_cli_args(cls, args: dict):\\n params_str = args.pop(\\\"user_params\\\", None)\\n params_file = args.pop(\\\"user_params_file\\\", None)\\n\\n if params_str:\\n user_params = util.read_yaml(params_str, cls.user_params_schema)\\n elif params_file:\\n user_params = util.read_yaml_from_file_path(params_file, cls.user_params_schema)\\n else:\\n raise ValueError(\\\"Did not receive user params. User params are currently required.\\\")\\n\\n return cls(**args, user_params=user_params)\",\n \"def parse_args():\\n parser = ArgumentParser(\\n description=\\\"This is a script for auto apply ipex optimization.\\\"\\n \\\"\\\\n################################# Basic usage ############################# \\\\n\\\"\\n \\\"\\\\n 1. Apply ipex optimization with fp32 data type\\\\n\\\"\\n \\\"\\\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex python_script args \\\\n\\\"\\n \\\"\\\\n 2. Apply ipex optimization with bf16 data type\\\\n\\\"\\n \\\"\\\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex --dtype bfloat16 python_script args \\\\n\\\",\\n formatter_class=RawTextHelpFormatter,\\n )\\n\\n add_auto_ipex_params(parser, auto_ipex_default_enabled=True)\\n\\n # positional\\n parser.add_argument(\\n \\\"program\\\",\\n type=str,\\n help=\\\"The full path to the proram/script to be launched. \\\"\\n \\\"followed by all the arguments for the script\\\",\\n )\\n # rest from the training program\\n parser.add_argument(\\\"program_args\\\", nargs=REMAINDER)\\n return parser.parse_args()\",\n \"def get_configuration(args):\\n\\n #------------------------------------------------------------------------\\n # If configfile is not specified, dump a configfile on screen\\n default_config, required_config = get_default_configuration()\\n if args.configfile is None:\\n write_configuration(parser.prog, version, default_config, required_config)\\n raise SystemExit\\n\\n #------------------------------------------------------------------------\\n # If you are here, then a configfile was given. Try to parse it\\n userconf = ConfigParser.SafeConfigParser()\\n userconf.read(args.configfile)\\n runconf = {}\\n\\n if userconf.has_option('Config', 'verbose'): \\n runconf['verbose'] = userconf.getboolean('Config', 'verbose')\\n else:\\n runconf['verbose'] = default_config['verbose']\\n\\n if runconf['verbose']: print \\\"Configuration for this run: \\\"\\n for key in required_config.keys():\\n try:\\n runconf[key] = userconf.getfloat('Config', key)\\n if runconf['verbose']: print \\\" > {key} = {val}\\\".format(key=key, val=runconf[key])\\n except ConfigParser.NoOptionError:\\n if runconf['verbose']: print \\\"\\\\nError: Required parameter {key} missing from config file!!\\\".format(key=key)\\n if runconf['verbose']: print \\\"Update the file {configfile} and try again\\\\n\\\".format(configfile=args.configfile)\\n raise SystemExit\\n except ValueError:\\n runconf[key] = userconf.get('Config', key)\\n if runconf['verbose']: print \\\" > {key} = {val}\\\".format(key=key, val=runconf[key])\\n\\n for key in default_config.keys():\\n if key == 'verbose': continue\\n try:\\n runconf[key] = userconf.getfloat('Config', key)\\n except ConfigParser.NoOptionError:\\n runconf[key] = default_config[key]\\n if runconf['verbose']: print \\\"Using default value for {key}\\\".format(key=key)\\n except ValueError:\\n runconf[key] = userconf.get('Config', key)\\n if runconf['verbose']: print \\\" > {key} = {val}\\\".format(key=key, val=runconf[key])\\n\\n # Now convert the bool values: verbose is already processed\\n boolkeys = ['auto', 'do_fit']\\n for b_key in boolkeys:\\n #print b_key, runconf[b_key]\\n test_string = \\\"{b_key}\\\".format(b_key = runconf[b_key])\\n #print test_string\\n if (test_string[0].upper() == 'T') or (test_string[0] == '1'):\\n runconf[b_key] = True\\n else:\\n runconf[b_key] = False\\n #print b_key, runconf[b_key]\\n\\n # Configuaration finally parsed!\\n # At some future time, I should validate it...\\n return runconf\",\n \"def config_parse(conf=None, args=None):\\n if args is None:\\n args = []\\n args += ['--config-file', etcdir('neutron.conf')]\\n if conf is None:\\n config.init(args=args)\\n else:\\n conf(args)\",\n \"def load_default_user_configs(args):\\n # Skip any imported keys from future\\n import __future__ as ff\\n future_keys = dir(ff)\\n # Load default settings\\n import pythiaplotter.default_config as dc\\n default_settings = {k: getattr(dc, k) for k in dir(dc)\\n if k not in future_keys and not k.startswith(\\\"_\\\")}\\n args.__dict__.update(default_settings) # argparse.Namespace doesn't like update() or new keys\\n # Load user config\\n if args.configFile:\\n if not helpr.check_file_exists(args.configFile):\\n raise IOError(\\\"Configuration file %s does not exist\\\" % args.configFile)\\n cc = load_source(\\\"cc\\\", args.configFile)\\n custom_settings = {k: getattr(cc, k) for k in dir(cc)\\n if k not in future_keys and not k.startswith(\\\"_\\\")}\\n args.__dict__.update(custom_settings)\",\n \"def parse_args():\\n hpo_warning = 'Flag overwrites config value if set, used for HPO and PBT runs primarily'\\n parser = argparse.ArgumentParser('train.py')\\n add_arg = parser.add_argument\\n add_arg('config', nargs='?', default='GraphLearning/configs/myconfig.yaml')\\n add_arg('results_dir', nargs='?', default='GraphLearning/results/withnoise')\\n \\n return parser.parse_args()\",\n \"def main():\\n cli = CommandLineInterface(NAME, package=\\\"nemo_nowcast\\\", description=__doc__)\\n cli.build_parser()\\n parsed_args = cli.parser.parse_args()\\n config = Config()\\n config.load(parsed_args.config_file)\\n msg = _configure_logging(config)\\n logger.info(f\\\"running in process {os.getpid()}\\\")\\n logger.info(f\\\"read config from {config.file}\\\")\\n logger.info(msg)\\n run(config)\",\n \"def _load_config():\\n\\tcfg = configparser.ConfigParser()\\n\\tcfg.read(os.path.join(get_current_directory(), 'citi.config'))\\n\\treturn cfg\",\n \"def parse_args(args: Namespace) -> None:\\n if os.path.exists(DEFAULT_CONFIG):\\n Parameter.load_config(DEFAULT_CONFIG)\\n for path in args.config or []:\\n Parameter.load_config(path)\\n\\n for name, parameter in Parameter.by_name.items():\\n value = vars(args).get(name)\\n if value is not None:\\n if parameter.parser is None:\\n assert isinstance(value, bool)\\n parameter.value = value\\n else:\\n try:\\n parameter.value = parameter.parser(value)\\n except BaseException:\\n raise RuntimeError( # pylint: disable=raise-missing-from\\n f\\\"Invalid value: {vars(args)[name]} for the parameter: {name}\\\"\\n )\\n\\n name = sys.argv[0].split(\\\"/\\\")[-1]\",\n \"def load():\\n # get (or create) config path\\n p = initialize()\\n return load_config(open(p['config']))\",\n \"def cmd_config(args):\\n \\n remote.show_config(_get_current_project_name())\",\n \"def read_config(*args):\\n\\n ret = {}\\n if _TRAFFICCTL:\\n cmd = _traffic_ctl(\\\"config\\\", \\\"get\\\")\\n else:\\n cmd = _traffic_line(\\\"-r\\\")\\n\\n try:\\n for arg in args:\\n log.debug(\\\"Querying: %s\\\", arg)\\n ret[arg] = _subprocess(cmd + [arg])\\n except KeyError:\\n pass\\n\\n return ret\",\n \"def parse_config(parser):\\n parser.add_argument('--config-file', '-c', help='config filename',\\n default='config.yaml')\\n return parser\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\\"generate_scenarios.py\\\")\\n add_arg = parser.add_argument\\n add_arg(\\\"config\\\", nargs=\\\"?\\\", default=\\\"config.yaml\\\")\\n # add_arg('-d', '--distributed', action='store_true')\\n add_arg(\\\"-v\\\", \\\"--verbose\\\", action=\\\"store_true\\\")\\n # parameters which override the YAML file, if needed\\n #\\n return parser.parse_args()\",\n \"def main(args):\\n cli = CLI()\\n # Check arguments\\n cli.parse_arguments(args)\",\n \"def read_inputs(argn=1):\\n if len(sys.argv) < argn+1:\\n raise IOError(\\\"Hey, no input file was passed as argument to\\\"\\n \\\" the program!!\\\")\\n if not os.path.exists(sys.argv[argn]):\\n raise FileNotFoundError(\\\"Input file '{}' not found.\\\".\\n format(sys.argv[argn]))\\n return read_config_file(sys.argv[argn], attribution_char='=')\",\n \"def read_cli_args(argv):\\n\\n # Working defaults\\n cur_dir = os.getcwd()\\n config_file = os.path.normpath(os.path.join(cur_dir, \\\"config.yaml\\\"))\\n override_file = os.path.normpath(os.path.join(cur_dir, \\\"overrides.yaml\\\"))\\n merged_file = os.path.normpath(os.path.join(cur_dir, \\\"build\\\", \\\"config.yaml\\\"))\\n # Parse the args\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-c', '--config-file',\\n action='store', type=str, dest=\\\"config_file\\\",\\n help='Path to Config file to read. Default:'\\n + config_file,\\n default=config_file)\\n parser.add_argument('-o', '--override-file',\\n action='store', type=str, dest=\\\"override_file\\\",\\n help='Path to override file. Default:'\\n + override_file,\\n default=override_file)\\n parser.add_argument('-m', '--merged-file',\\n action='store', type=str, dest=\\\"merged_file\\\",\\n help='Path to output of this script. Default:'\\n + merged_file,\\n default=merged_file)\\n args = parser.parse_args()\\n return args\",\n \"def analysis_config():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-g\\\", \\\"--ground-truth\\\", type=str, default=\\\"./BRUTE_FORCE_near_duplicates.tsv\\\")\\n parser.add_argument(\\\"-p\\\", \\\"--pred\\\", type=str, default=\\\"./PRED_near_duplicates.tsv\\\")\\n\\n return parser.parse_args()\",\n \"def load_configuration_or_abort(app, environ_variable, mandatory_config_keys=[]):\\n\\n try:\\n config_file = load_config_file(environ_variable)\\n app.config.from_pyfile(config_file, silent=False)\\n except Exception as e:\\n print(str(e))\\n exit(-1)\\n\\n assert_configs(app.config, mandatory_config_keys, config_file)\\n\\n print((\\\"ZEEGUU: Loaded {0} config from {1}\\\".format(app.name, config_file)))\",\n \"def main(argv):\\n config_options = parse_config(CONFIG_FILE_NAME)\\n arguments_options = parse_args(argv, **config_options)\\n playgame.main(arguments_options)\",\n \"def config_argparser(parser):\\n parser.set_defaults(func=main)\",\n \"def load_config(filename):\\n AS[\\\"config\\\"] = load_yaml_file(filename)\",\n \"def main(args=None):\\n args = args or sys.argv[1:]\\n parser = parse_options()\\n common.main_cli(experiment_parse_and_run, parser, args)\",\n \"def parse_commandline_args():\\n\\n epilog = \\\"\\\"\\\"\\n The configuration file must contained a JSON-encoded map. Example: \\\"{\\\"name\\\":\\\"foo\\\"}\\\".\\n \\\"\\\"\\\"\\n\\n parser = utils.ConnectionArgumentParser(\\n description=\\\"Update config (key/value pairs) on a board\\\", epilog=epilog\\n )\\n parser.add_argument(\\n \\\"-c\\\",\\n \\\"--config\\\",\\n help=\\\"JSON file to load config from (default stdin)\\\",\\n type=open,\\n default=sys.stdin,\\n dest=\\\"file\\\",\\n )\\n parser.add_argument(\\n \\\"ids\\\", metavar=\\\"DEVICEID\\\", nargs=\\\"+\\\", type=int, help=\\\"Device IDs to flash\\\"\\n )\\n\\n return parser.parse_args()\",\n \"def init(subparsers):\\n parser = subparsers.add_parser('generate-config', help='Generate the WebRPG configuration file')\\n parser.add_argument('--filename', default='production.ini', help='Configuration file name')\\n parser.add_argument('--sqla-connection-string', default=None, help='SQLAlchemy database connection string')\\n parser.set_defaults(func=generate_config)\",\n \"def parse_arguments(args=sys.argv[1:]):\\n \\n parser = argparse.ArgumentParser()\\n \\n parser.add_argument('-i', '--input',\\n help=\\\"Path of input file to read. Default: {d}\\\".format(d=INPUT_FILE),\\n default=INPUT_FILE)\\n \\n return parser.parse_args(args)\",\n \"def init_config(filename):\\n config = configparser.ConfigParser()\\n try:\\n with open(filename, 'r') as config_file:\\n config.read(config_file)\\n except EnvironmentError:\\n print(\\\"FATAL ERROR: Failed to open config file at \\\" + filename)\\n sys.exit(1)\\n return config\",\n \"def init_argparser() -> ArgumentParser:\\n parser = ArgumentParser()\\n from_config = parser.add_argument_group('From config file', 'Provide full experiment setup via config file')\\n from_config.add_argument('-c', '--config', help='Path to json file containing classification config.')\\n from_cmd = parser.add_argument_group('From commandline', 'Specify experiment setup via commandline arguments')\\n\\n # Model options\\n from_cmd.add_argument(\\\"--recoding_type\\\", type=str, default=None,\\n choices=[\\\"mc_dropout\\\", \\\"surprisal\\\", \\\"ensemble\\\"],\\n help=\\\"Recoding model type used for trainign. Choices include recoding based on MC Dropout,\\\"\\n \\\"perplexity and anchored ensembles. If not specified, a vanilla model without recoding\\\"\\n \\\"is used.\\\")\\n from_cmd.add_argument(\\\"--step_type\\\", type=str, default=None, choices=[\\\"fixed\\\", \\\"mlp\\\", \\\"learned\\\"],\\n help=\\\"Specifies the way the step size is determined when using a recoding model.\\\")\\n from_cmd.add_argument(\\\"--step_size\\\", type=float,\\n help=\\\"Step size for recoding in case the fixed step predictor is used.\\\")\\n from_cmd.add_argument(\\\"--embedding_size\\\", type=int, help=\\\"Dimensionality of word embeddings.\\\")\\n from_cmd.add_argument(\\\"--hidden_size\\\", type=int, help=\\\"Dimensionality of hidden states.\\\")\\n from_cmd.add_argument(\\\"--num_layers\\\", type=int, help=\\\"Number of network layers.\\\")\\n from_cmd.add_argument(\\\"--mc_dropout\\\", type=float, help=\\\"Dropout probability when estimating uncertainty.\\\")\\n from_cmd.add_argument(\\\"--dropout\\\", type=float, help=\\\"Dropout probability for model in general.\\\")\\n from_cmd.add_argument(\\\"--num_samples\\\", type=int, help=\\\"Number of samples used when estimating uncertainty.\\\")\\n\\n # Training options\\n from_cmd.add_argument(\\\"--weight_decay\\\", type=float, help=\\\"Weight decay parameter when estimating uncertainty.\\\")\\n from_cmd.add_argument(\\\"--prior_scale\\\", type=float,\\n help=\\\"Prior length scale. A lower scale signifies a prior belief that the input data is \\\"\\n \\\"distributed infrequently, a higher scale does the opposite.\\\")\\n from_cmd.add_argument(\\\"--learning_rate\\\", type=float, help=\\\"Learning rate during training.\\\")\\n from_cmd.add_argument(\\\"--batch_size\\\", type=int, help=\\\"Batch size during training.\\\")\\n from_cmd.add_argument(\\\"--num_epochs\\\", type=int, help=\\\"Number of training epochs.\\\")\\n from_cmd.add_argument(\\\"--clip\\\", type=float, help=\\\"Threshold for gradient clipping.\\\")\\n\\n # Corpus options\\n from_cmd.add_argument(\\\"--corpus_dir\\\", type=str, help=\\\"Directory to corpus files.\\\")\\n from_cmd.add_argument(\\\"--max_seq_len\\\", type=int, help=\\\"Maximum sentence length when reading in the corpora.\\\")\\n\\n # Screen output optins\\n from_cmd.add_argument(\\\"--print_every\\\", type=int, help=\\\"Batch interval at which training info should be printed.\\\")\\n from_cmd.add_argument(\\\"--eval_every\\\", type=int,\\n help=\\\"Epoch interval at which the model should be evaluated on validation set.\\\")\\n\\n # Model saving and logging options\\n from_cmd.add_argument(\\\"--model_name\\\", type=str, help=\\\"Model identifier.\\\")\\n from_cmd.add_argument(\\\"--model_save_path\\\", type=str,\\n help=\\\"Directory to which current best model should be saved to.\\\")\\n from_cmd.add_argument(\\\"--device\\\", type=str, default=\\\"cpu\\\", help=\\\"Device used for training.\\\")\\n from_cmd.add_argument(\\\"--log_dir\\\", type=str, help=\\\"Directory to write (tensorboard) logs to.\\\")\\n\\n return parser\",\n \"def load_ini_file(ini_file_path):\\n config = configparser.ConfigParser()\\n config.read(ini_file_path)\\n cfg = {}\\n\\n # Load hyperparameters\\n cfg[\\\"hyperparameters\\\"] = {}\\n cfg[\\\"hyperparameters\\\"][\\\"gpu_id\\\"] = config.getint(\\\"hyperparameters\\\", \\\"gpu_id\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"seed\\\"] = config.getint(\\\"hyperparameters\\\", \\\"seed\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"optimizer\\\"] = config.get(\\\"hyperparameters\\\", \\\"optimizer\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"lr\\\"] = config.getfloat(\\\"hyperparameters\\\", \\\"lr\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"momentum\\\"] = config.getfloat(\\\"hyperparameters\\\", \\\"momentum\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"clip\\\"] = config.getfloat(\\\"hyperparameters\\\", \\\"clip\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"dropout\\\"] = config.getfloat(\\\"hyperparameters\\\", \\\"dropout\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"batch_size\\\"] = config.getint(\\\"hyperparameters\\\", \\\"batch_size\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"embedding_dim\\\"] = config.getint(\\\"hyperparameters\\\", \\\"embedding_dim\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"commun_embed_size\\\"] = config.getint(\\\"hyperparameters\\\", \\\"commun_embed_size\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"num_epochs\\\"] = config.getint(\\\"hyperparameters\\\", \\\"num_epochs\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"use_one_hot\\\"] = config.getboolean(\\\"hyperparameters\\\", \\\"use_one_hot\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"max_input_length\\\"] = config.getint(\\\"hyperparameters\\\", \\\"max_input_length\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"max_num_answers\\\"] = config.getint(\\\"hyperparameters\\\", \\\"max_num_answers\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"use_dnc_c\\\"] = config.getboolean(\\\"hyperparameters\\\", \\\"use_dnc_c\\\") \\n cfg[\\\"hyperparameters\\\"][\\\"use_dnc_q\\\"] = config.getboolean(\\\"hyperparameters\\\", \\\"use_dnc_q\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"share_memory\\\"] = config.getboolean(\\\"hyperparameters\\\", \\\"share_memory\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"weight_decay\\\"] = config.getfloat(\\\"hyperparameters\\\", \\\"weight_decay\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"use_clip_grad\\\"] = config.getboolean(\\\"hyperparameters\\\", \\\"use_clip_grad\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"clip_value\\\"] = config.getfloat(\\\"hyperparameters\\\", \\\"clip_value\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"lr_reduce_after\\\"] = config.getint(\\\"hyperparameters\\\", \\\"lr_reduce_after\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"lr_decay_rate\\\"] = config.getfloat(\\\"hyperparameters\\\", \\\"lr_decay_rate\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"grad_flow_interval\\\"] = config.getfloat(\\\"hyperparameters\\\", \\\"grad_flow_interval\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"add_noise\\\"] = config.getboolean(\\\"hyperparameters\\\", \\\"add_noise\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"finetune\\\"] = config.getboolean(\\\"hyperparameters\\\", \\\"finetune\\\")\\n cfg[\\\"hyperparameters\\\"][\\\"fc_flag\\\"] = config.getboolean(\\\"hyperparameters\\\", \\\"fc_flag\\\")\\n\\n # Load lstm parameters\\n cfg[\\\"lstm\\\"] = {}\\n cfg[\\\"lstm\\\"][\\\"hidden_dim\\\"] = config.getint(\\\"lstm\\\", \\\"hidden_dim\\\")\\n cfg[\\\"lstm\\\"][\\\"num_layers\\\"] = config.getint(\\\"lstm\\\", \\\"num_layers\\\")\\n cfg[\\\"lstm\\\"][\\\"dropout\\\"] = config.getfloat(\\\"lstm\\\", \\\"dropout\\\")\\n\\n # Load dnc_q parameters\\n cfg[\\\"dnc_q\\\"] = {}\\n cfg[\\\"dnc_q\\\"][\\\"input_size\\\"] = config.getint(\\\"dnc_q\\\", \\\"input_size\\\")\\n cfg[\\\"dnc_q\\\"][\\\"output_size\\\"] = config.getint(\\\"dnc_q\\\", \\\"output_size\\\")\\n cfg[\\\"dnc_q\\\"][\\\"rnn_type\\\"] = config.get(\\\"dnc_q\\\", \\\"rnn_type\\\")\\n cfg[\\\"dnc_q\\\"][\\\"hidden_dim\\\"] = config.getint(\\\"dnc_q\\\", \\\"hidden_dim\\\")\\n cfg[\\\"dnc_q\\\"][\\\"memory_type\\\"] = config.get(\\\"dnc_q\\\", \\\"memory_type\\\")\\n cfg[\\\"dnc_q\\\"][\\\"num_layers\\\"] = config.getint(\\\"dnc_q\\\", \\\"num_layers\\\")\\n cfg[\\\"dnc_q\\\"][\\\"num_layers_hidden\\\"] = config.getint(\\\"dnc_q\\\", \\\"num_layers_hidden\\\")\\n cfg[\\\"dnc_q\\\"][\\\"n\\\"] = config.getint(\\\"dnc_q\\\", \\\"n\\\")\\n cfg[\\\"dnc_q\\\"][\\\"w\\\"] = config.getint(\\\"dnc_q\\\", \\\"w\\\")\\n cfg[\\\"dnc_q\\\"][\\\"r\\\"] = config.getint(\\\"dnc_q\\\", \\\"r\\\")\\n cfg[\\\"dnc_q\\\"][\\\"s_r\\\"] = config.getint(\\\"dnc_q\\\", \\\"t_r\\\")\\n cfg[\\\"dnc_q\\\"][\\\"t_r\\\"] = config.getint(\\\"dnc_q\\\", \\\"s_r\\\")\\n cfg[\\\"dnc_q\\\"][\\\"pass_through_mem\\\"] = config.getboolean(\\\"dnc_q\\\", \\\"pass_through_mem\\\")\\n cfg[\\\"dnc_q\\\"][\\\"reset_experience\\\"] = config.getboolean(\\\"dnc_q\\\", \\\"reset_experience\\\")\\n cfg[\\\"dnc_q\\\"][\\\"debug\\\"] = config.getboolean(\\\"dnc_q\\\", \\\"debug\\\")\\n cfg[\\\"dnc_q\\\"][\\\"lr\\\"] = config.getfloat(\\\"dnc_q\\\", \\\"lr\\\")\\n cfg[\\\"dnc_q\\\"][\\\"dropout\\\"] = config.getfloat(\\\"dnc_q\\\", \\\"dropout\\\")\\n\\n # Load dnc_c parameters\\n cfg[\\\"dnc_c\\\"] = {}\\n cfg[\\\"dnc_c\\\"][\\\"output_size\\\"] = config.getint(\\\"dnc_c\\\", \\\"output_size\\\")\\n cfg[\\\"dnc_c\\\"][\\\"rnn_type\\\"] = config.get(\\\"dnc_c\\\", \\\"rnn_type\\\")\\n cfg[\\\"dnc_c\\\"][\\\"hidden_dim\\\"] = config.getint(\\\"dnc_c\\\", \\\"hidden_dim\\\")\\n cfg[\\\"dnc_c\\\"][\\\"memory_type\\\"] = config.get(\\\"dnc_c\\\", \\\"memory_type\\\")\\n cfg[\\\"dnc_c\\\"][\\\"num_layers\\\"] = config.getint(\\\"dnc_c\\\", \\\"num_layers\\\")\\n cfg[\\\"dnc_c\\\"][\\\"num_layers_hidden\\\"] = config.getint(\\\"dnc_c\\\", \\\"num_layers_hidden\\\")\\n cfg[\\\"dnc_c\\\"][\\\"n\\\"] = config.getint(\\\"dnc_c\\\", \\\"n\\\")\\n cfg[\\\"dnc_c\\\"][\\\"w\\\"] = config.getint(\\\"dnc_c\\\", \\\"w\\\")\\n cfg[\\\"dnc_c\\\"][\\\"r\\\"] = config.getint(\\\"dnc_c\\\", \\\"r\\\")\\n cfg[\\\"dnc_c\\\"][\\\"s_r\\\"] = config.getint(\\\"dnc_c\\\", \\\"t_r\\\")\\n cfg[\\\"dnc_c\\\"][\\\"t_r\\\"] = config.getint(\\\"dnc_c\\\", \\\"s_r\\\")\\n cfg[\\\"dnc_c\\\"][\\\"pass_through_mem\\\"] = config.getboolean(\\\"dnc_c\\\", \\\"pass_through_mem\\\")\\n cfg[\\\"dnc_c\\\"][\\\"reset_experience\\\"] = config.getboolean(\\\"dnc_c\\\", \\\"reset_experience\\\")\\n cfg[\\\"dnc_c\\\"][\\\"debug\\\"] = config.getboolean(\\\"dnc_c\\\", \\\"debug\\\")\\n cfg[\\\"dnc_c\\\"][\\\"lr\\\"] = config.getfloat(\\\"dnc_c\\\", \\\"lr\\\")\\n cfg[\\\"dnc_c\\\"][\\\"dropout\\\"] = config.getfloat(\\\"dnc_c\\\", \\\"dropout\\\")\\n cfg[\\\"dnc_c\\\"][\\\"type\\\"] = config.get(\\\"dnc_c\\\", \\\"type\\\")\\n cfg[\\\"dnc_c\\\"][\\\"nonlinearity\\\"] = config.get(\\\"dnc_c\\\", \\\"nonlinearity\\\")\\n cfg[\\\"dnc_c\\\"][\\\"concat_out_rv\\\"] = config.getboolean(\\\"dnc_c\\\", \\\"concat_out_rv\\\")\\n cfg[\\\"dnc_c\\\"][\\\"bidirectional\\\"] = config.getboolean(\\\"dnc_c\\\", \\\"bidirectional\\\")\\n\\n # Load logging paths\\n cfg[\\\"logging\\\"] = {}\\n cfg[\\\"logging\\\"][\\\"tensorboard_dir\\\"] = config.get(\\\"logging\\\", \\\"tensorboard_dir\\\")\\n cfg[\\\"logging\\\"][\\\"checkpoints_dir\\\"] = config.get(\\\"logging\\\", \\\"checkpoints_dir\\\")\\n cfg[\\\"logging\\\"][\\\"results_dir\\\"] = config.get(\\\"logging\\\", \\\"results_dir\\\")\\n cfg[\\\"logging\\\"][\\\"grad_flow_dir\\\"] = config.get(\\\"logging\\\", \\\"grad_flow_dir\\\")\\n\\n # Load paths\\n cfg[\\\"paths\\\"] = {}\\n cfg[\\\"paths\\\"][\\\"input\\\"] = config.get(\\\"paths\\\", \\\"input\\\")\\n cfg[\\\"paths\\\"][\\\"json_q_path_tr\\\"] = config.get(\\\"paths\\\", \\\"json_q_path_tr\\\")\\n cfg[\\\"paths\\\"][\\\"json_q_path_val\\\"] = config.get(\\\"paths\\\", \\\"json_q_path_val\\\")\\n cfg[\\\"paths\\\"][\\\"json_a_path_tr\\\"] = config.get(\\\"paths\\\", \\\"json_a_path_tr\\\")\\n cfg[\\\"paths\\\"][\\\"json_a_path_val\\\"] = config.get(\\\"paths\\\", \\\"json_a_path_val\\\")\\n cfg[\\\"paths\\\"][\\\"json_q_path_test\\\"] = config.get(\\\"paths\\\", \\\"json_q_path_test\\\")\\n cfg[\\\"paths\\\"][\\\"dnc_q\\\"] = config.get(\\\"paths\\\", \\\"dnc_q\\\")\\n cfg[\\\"paths\\\"][\\\"dnc_c\\\"] = config.get(\\\"paths\\\", \\\"dnc_c\\\")\\n return cfg\",\n \"def load_config(self):\\n pass\",\n \"def setup_args():\\n parser = ParlaiParser()\\n parser.add_argument(\\n '-n',\\n '--num-episodes',\\n default=-1,\\n type=int,\\n help='Total number of episodes to convert, -1 to convert all examples',\\n )\\n parser.add_argument(\\n '-of',\\n '--outfile',\\n default=None,\\n type=str,\\n help='Output file where to save, by default will be created in /tmp',\\n )\\n parser.add_argument(\\n '-s1id', '--speaker-0-id', type=str, help='Speaker id of agent who speaks first'\\n )\\n parser.add_argument(\\n '-s1id',\\n '--speaker-1-id',\\n type=str,\\n help='Speaker id of agent who speaks second',\\n )\\n parser.add_argument(\\n '--prepended-context',\\n type='bool',\\n default=False,\\n help='specify if the context is prepended to the first act',\\n )\\n parser.add_argument('-ltim', '--log-every-n-secs', type=float, default=10)\\n parser.set_defaults(datatype='train:ordered')\\n\\n return parser\",\n \"def init(args):\\n # reading existing config file, convert to configparser object\\n config = config_from_file()\\n config_ = configparser.ConfigParser()\\n config_.add_section('osf')\\n if 'username' not in config.keys():\\n config_.set('osf', 'username', '')\\n else:\\n config_.set('osf', 'username', config['username'])\\n if 'project' not in config.keys():\\n config_.set('osf', 'project', '')\\n else:\\n config_.set('osf', 'project', config['project'])\\n\\n # now we can start asking for new values\\n print('Provide a username for the config file [current username: {}]:'.format(\\n config_.get('osf', 'username')))\\n username = input()\\n if username:\\n config_.set('osf', 'username', username)\\n\\n print('Provide a project for the config file [current project: {}]:'.format(\\n config_.get('osf', 'project')))\\n project = input()\\n if project:\\n config_.set('osf', 'project', project)\\n\\n cfgfile = open(\\\".osfcli.config\\\", \\\"w\\\")\\n config_.write(cfgfile)\\n cfgfile.close()\",\n \"def from_args(args, verbose=False, unhandled=None):\\n\\n # Create a list for unhandled arguments\\n if unhandled is None:\\n unhandled = []\\n\\n experiments = ExperimentList()\\n ## First try as image files\\n # experiments = ExperimentListFactory.from_datablock(\\n # DataBlockFactory.from_args(args, verbose, unhandled1))\\n\\n # Try to load from serialized formats\\n for filename in args:\\n try:\\n experiments.extend(\\n ExperimentListFactory.from_serialized_format(filename)\\n )\\n if verbose:\\n print(\\\"Loaded experiments from %s\\\" % filename)\\n except Exception as e:\\n if verbose:\\n print(\\\"Could not load experiments from %s: %s\\\" % (filename, str(e)))\\n unhandled.append(filename)\\n\\n # Return the experiments\\n return experiments\",\n \"def __init__(self, app_name, file=\\\"~/.redshovel\\\"):\\r\\n usage = \\\"usage: %prog [options]\\\"\\r\\n self.optp = optparse.OptionParser(usage=usage)\\r\\n self.app_name = app_name\\r\\n self.opts = None\\r\\n self.args = None\\r\\n\\r\\n self.config = ConfigParser.RawConfigParser()\\r\\n self.config.read(os.path.expanduser(file))\\r\\n\\r\\n # Add the common options.\\r\\n self.default_section = set(('api_key', 'url', 'verbose'))\\r\\n self.required = set()\\r\\n self.add_option(\\\"-a\\\", \\\"--api\\\", dest=\\\"api_key\\\", required=True,\\r\\n help=\\\"The api key to connect to redmine with\\\")\\r\\n self.add_option(\\\"-u\\\", \\\"--url\\\", dest=\\\"url\\\", required=True,\\r\\n help=\\\"The url to redmine.\\\")\\r\\n self.add_option(\\\"-v\\\", \\\"--verbose\\\",\\r\\n action=\\\"count\\\", dest=\\\"verbose\\\",\\r\\n help=\\\"verbosity the more v's the more verbose.\\\")\",\n \"def get_config():\\n try:\\n config_file_path = sys.argv[2]\\n except IndexError:\\n config_file_path = \\\"config.yml\\\"\\n if os.path.exists(config_file_path):\\n with open(config_file_path, 'r') as stream:\\n try:\\n return yaml.load(stream)\\n except yaml.YAMLError as yml_error:\\n print(yml_error)\\n else:\\n print(\\\"%s does not exist\\\" % config_file_path)\\n print(\\\"ERROR:\\\\nUSAGE: python strap.py \\\\\\\"keyword1, keyword2, keyword3, keyword4\\\\\\\" [path/to/config.yml]\\\")\\n exit(0)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6620625","0.65885556","0.65620697","0.6530543","0.65282035","0.65250957","0.63654464","0.63244563","0.62861556","0.6278691","0.62023723","0.6184847","0.61702293","0.61346585","0.6072536","0.6040853","0.6028272","0.6002226","0.5997254","0.59311545","0.5927755","0.59256035","0.59216464","0.5904285","0.58903664","0.5883658","0.58663756","0.5864889","0.5854725","0.583158","0.5801012","0.5801012","0.5801012","0.576099","0.57435876","0.57364947","0.57265544","0.57213235","0.5716739","0.56940913","0.56921315","0.5689463","0.565576","0.5649463","0.56262475","0.5604461","0.55911964","0.5580069","0.5561418","0.5559764","0.5558275","0.55452996","0.5542462","0.5526923","0.55267394","0.55210847","0.55108654","0.5509205","0.5505741","0.5497208","0.5493977","0.54759467","0.54737854","0.54662836","0.54658824","0.5464816","0.545777","0.5452108","0.54464996","0.5443121","0.5442698","0.54383886","0.5436972","0.54330575","0.543198","0.54209024","0.54180574","0.5416852","0.5405922","0.5404378","0.5403234","0.53967667","0.5393612","0.5392924","0.53929156","0.5372483","0.53688645","0.5366035","0.5348431","0.5343909","0.53281987","0.53221667","0.5318719","0.5312239","0.53101325","0.53063405","0.530616","0.5301751","0.52969396","0.5296785"],"string":"[\n \"0.6620625\",\n \"0.65885556\",\n \"0.65620697\",\n \"0.6530543\",\n \"0.65282035\",\n \"0.65250957\",\n \"0.63654464\",\n \"0.63244563\",\n \"0.62861556\",\n \"0.6278691\",\n \"0.62023723\",\n \"0.6184847\",\n \"0.61702293\",\n \"0.61346585\",\n \"0.6072536\",\n \"0.6040853\",\n \"0.6028272\",\n \"0.6002226\",\n \"0.5997254\",\n \"0.59311545\",\n \"0.5927755\",\n \"0.59256035\",\n \"0.59216464\",\n \"0.5904285\",\n \"0.58903664\",\n \"0.5883658\",\n \"0.58663756\",\n \"0.5864889\",\n \"0.5854725\",\n \"0.583158\",\n \"0.5801012\",\n \"0.5801012\",\n \"0.5801012\",\n \"0.576099\",\n \"0.57435876\",\n \"0.57364947\",\n \"0.57265544\",\n \"0.57213235\",\n \"0.5716739\",\n \"0.56940913\",\n \"0.56921315\",\n \"0.5689463\",\n \"0.565576\",\n \"0.5649463\",\n \"0.56262475\",\n \"0.5604461\",\n \"0.55911964\",\n \"0.5580069\",\n \"0.5561418\",\n \"0.5559764\",\n \"0.5558275\",\n \"0.55452996\",\n \"0.5542462\",\n \"0.5526923\",\n \"0.55267394\",\n \"0.55210847\",\n \"0.55108654\",\n \"0.5509205\",\n \"0.5505741\",\n \"0.5497208\",\n \"0.5493977\",\n \"0.54759467\",\n \"0.54737854\",\n \"0.54662836\",\n \"0.54658824\",\n \"0.5464816\",\n \"0.545777\",\n \"0.5452108\",\n \"0.54464996\",\n \"0.5443121\",\n \"0.5442698\",\n \"0.54383886\",\n \"0.5436972\",\n \"0.54330575\",\n \"0.543198\",\n \"0.54209024\",\n \"0.54180574\",\n \"0.5416852\",\n \"0.5405922\",\n \"0.5404378\",\n \"0.5403234\",\n \"0.53967667\",\n \"0.5393612\",\n \"0.5392924\",\n \"0.53929156\",\n \"0.5372483\",\n \"0.53688645\",\n \"0.5366035\",\n \"0.5348431\",\n \"0.5343909\",\n \"0.53281987\",\n \"0.53221667\",\n \"0.5318719\",\n \"0.5312239\",\n \"0.53101325\",\n \"0.53063405\",\n \"0.530616\",\n \"0.5301751\",\n \"0.52969396\",\n \"0.5296785\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6928259"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92876,"cells":{"query":{"kind":"string","value":"Generate result lists (image names and list with scores)"},"document":{"kind":"string","value":"def build_retrieved_list(self, scores):\n\n res = self.index.rank(scores)\n tmp_res = []\n # keep scores too\n tmp_scores = []\n\n # build the list\n tmp_res = []\n #print rank, \"<--\"\n for i, k in res:\n tmp_res.append( self.indices[i] )\n tmp_scores.append( k )\n\n\n # compute the difference with the difference\n diff = list(set(self.indices.values())-set(tmp_res))\n\n # shuffle to fill the rest of the list\n np.random.shuffle(diff)\n\n scores_diff = np.zeros( (len(diff,)) )\n\n final = []\n final_scores = []\n\n final.extend(tmp_res)\n final.extend(diff)\n\n final_scores.extend(tmp_scores)\n final_scores.extend(scores_diff)\n\n # remove extension for evaluation\n f = lambda x: x.split('.')[0]\n final = map(f, final)\n\n return final, final_scores"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def yolo_show(image_path_list, batch_list):\n font = cv2.FONT_HERSHEY_SIMPLEX\n for img_path, batch in zip(image_path_list, batch_list):\n result_list = batch.tolist()\n img = cv2.imread(img_path)\n for result in result_list:\n cls = int(result[0])\n bbox = result[1:-1]\n score = result[-1]\n print('img_file:', img_path)\n print('cls:', cls)\n print('bbox:', bbox)\n c = ((int(bbox[0]) + int(bbox[2])) / 2, (int(bbox[1] + int(bbox[3])) / 2))\n cv2.rectangle(img, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), (0, 255, 255), 1)\n cv2.putText(img, str(cls), (int(c[0]), int(c[1])), font, 1, (0, 0, 255), 1)\n result_name = img_path.split('/')[-1]\n cv2.imwrite(\"constant/results/\" + result_name, img)","def painting_matching_ml(imgs, db_imgs, method_list, text_masks, author_text, gt_text, metrics, weights, splits=30, max_rank=10):\n descriptor_extractors = [get_descriptor_extractor(method_name) for method_name in method_list]\n tmp_img_format = []\n tmp_mask_format = []\n tmp_text_format = []\n for i in range(len(imgs)):\n for j in range(len(imgs[i])):\n tmp_img_format.append(imgs[i][j])\n tmp_mask_format.append(text_masks[i][j])\n tmp_text_format.append(author_text[i][j])\n\n #db_imgs = [img[0] for img in db_imgs]\n db_img_splits = [i*len(db_imgs)//splits for i in range(splits-1)]\n \n scores = []\n query_descriptors = extract_descriptors(tmp_img_format, descriptor_extractors, method_list, tmp_text_format, tmp_mask_format) \n #np.array([extract_descriptors(img, matching_methods, mask) for img, mask in zip(tmp_img_format, tmp_mask_format)])\n print(\"Starting db extraction + matching\")\n for split in tqdm(range(splits-2)):\n db_descriptors = extract_descriptors(db_imgs[db_img_splits[split]:db_img_splits[split+1]], descriptor_extractors, method_list, gt_text[db_img_splits[split]:db_img_splits[split+1]], None) #np.array([mrhm(db_img) for db_img in db_imgs[db_img_splits[split]:db_img_splits[split+1]]])\n scores.append(compare_descriptors(query_descriptors, db_descriptors, metrics, method_list, weights))\n # compare_descriptors(query_descriptors, db_descriptors, descriptor_comp_methods, descriptor_names, weights)\n db_descriptors = extract_descriptors(db_imgs[db_img_splits[-1]:], descriptor_extractors, method_list, gt_text[db_img_splits[-1]:], None)\n scores.append(compare_descriptors(query_descriptors, db_descriptors, metrics, method_list, weights))\n \n # concatenate all the results\n scores = np.concatenate(scores, 1)\n \n top_k_matches = np.argpartition(scores, list(range(max_rank)))[:, :max_rank]\n return top_k_matches","def generate_results(img_name, note_names, note_durations):\n construct_output(indent_level=\"block\",\n message=\"Matching the elements of the image ({}) with the values given by the networks.\"\n .format(img_name))\n\n results = [] # A list that will be returned.\n\n # Path that contains the information about the original image.\n image_path = os.path.abspath(os.path.join(str(Path(__file__).parent.parent.parent), 'resources', 'input_images'))\n image_path = os.path.join(image_path, 'input_images_individual_elements')\n image_path = os.path.join(image_path, img_name[:-4])\n\n # Find all the unrecognized elements and their names.\n unrecognized_elements_path = os.path.join(image_path, \"unrecognized\")\n unrecognized_elements = os.listdir(unrecognized_elements_path)\n\n results_and_positions = []\n for el in unrecognized_elements:\n row_number = el[(el.index(\"_row\") + len(\"_row\")):(el.index(\"_slice\"))]\n el_number = el[(el.index(\"slice\") + len(\"slice\")):]\n el_number = el_number[:el_number.index(\"_\")]\n results_and_positions.append((el, row_number, el_number))\n results_and_positions.sort(key=lambda k: (int(k[1]), int(k[2])))\n if len(note_names) != len(note_durations) != len(unrecognized_elements):\n print(\"generator.py = Not enough elements were recognized!\")\n\n for index, el in enumerate(results_and_positions):\n el = el[0]\n if el.endswith(\".png\"):\n results.append((el[len(\"img02_\"):-len(\".png\")], note_names[index], note_durations[index]))\n\n # Find all the recognized elements and their names.\n recognized_elements_path = os.path.join(image_path, \"recognized\", img_name[:-4] + \".txt\")\n\n with open(recognized_elements_path, 'r') as file:\n recognized_elements = file.readlines()\n if len(recognized_elements) == 0:\n print(\"generator.py = Error in reading image file info!\")\n exit(-1)\n for index, content in enumerate(recognized_elements):\n if content.endswith(\"\\n\"):\n recognized_elements[index] = content[:-1]\n for index, el in enumerate(recognized_elements):\n el_name = el[(el.find(\"template_\") + len(\"template_\")):el.find(\".png\")]\n if el_name.startswith(\"Z_barline\"):\n el_name = \"barline\"\n results.append((el[len(\"img02_\"):-len(\".png\")], el_name, \"-\"))\n\n # Join the individual elements with their descriptions.\n results_and_positions = []\n for result in results:\n x = result[0]\n row_number = x[(x.index(\"row\") + len(\"row\")):x.index(\"_slice\")]\n el_number = x[(x.index(\"slice\") + len(\"slice\")):]\n el_number = el_number[:el_number.index(\"_\")]\n results_and_positions.append((result, row_number, el_number))\n\n # Sort the elements with the order found in the original image.\n results_and_positions.sort(key=lambda k: (int(k[1]), int(k[2])))\n\n results = []\n for x in results_and_positions:\n results.append(x[0])\n\n construct_output(indent_level=\"block\",\n message=\"Results generated.\"\n .format(img_name))\n\n return results","def calculate_score(label_dict, queries, results):\n\n total_score = 0.0\n\n log_header('Individual image scores')\n\n # Calculate score for all images\n for image_id in queries:\n if image_id in results.keys():\n # Run the score function\n image_score = score(\n label_dict=label_dict, target=image_id, selection=results[image_id]\n )\n else:\n logging.error('No result generated for %s' % image_id)\n\n image_score = 0.0\n\n total_score += image_score\n\n logging.info('%s: %8.6f' % (image_id, image_score))\n\n log_header('Average score over %d images: %10.8f' % (\n len(queries), total_score / len(queries)\n ))\n\n return total_score","def get_results(self):\n result = [round(self.mr / self.test_size, 1), round(self.mrr / self.test_size, 3),\n round(self.hits1 / self.test_size, 3), round(self.hits3 / self.test_size, 3),\n round(self.hits5 / self.test_size, 3), round(self.hits10 / self.test_size, 3)]\n return result","def getimgs():","def get_all_results(pred_root, meta_results):\r\n results_all = {}\r\n for key in tqdm(meta_results, desc='Generating results ..'):\r\n persons = meta_results[key]\r\n\r\n global_seg = cv2.imread(pred_root + 'global_seg/{}.png'.format(key),\r\n cv2.IMREAD_UNCHANGED)\r\n global_tag = cv2.imread(pred_root + 'global_tag/{}.png'.format(key),\r\n cv2.IMREAD_UNCHANGED)\r\n\r\n results = {}\r\n dets, masks = [], []\r\n for p_id, score in persons:\r\n mask = (global_tag == p_id)\r\n if np.sum(mask) == 0:\r\n continue\r\n seg = mask * global_seg\r\n ys, xs = np.where(mask > 0)\r\n x1, y1, x2, y2 = xs.min(), ys.min(), xs.max(), ys.max()\r\n dets.append((x1, y1, x2, y2, score))\r\n masks.append(seg)\r\n\r\n # Reuiqred Field of each result: a list of masks,\r\n # each is a multi-class masks for one person.\r\n # It can also be sparsified to\r\n # [scipy.sparse.csr_matrix(mask) for mask in masks]\r\n # to save memory cost\r\n results['MASKS'] = masks if not Sparse \\\r\n else [scipy.sparse.csr_matrix(m) for m in masks]\r\n # Reuiqred Field of each result,\r\n # a list of detections corresponding to results['MASKS'].\r\n results['DETS'] = dets\r\n\r\n if cache_pkl:\r\n results_cache_add = cache_pkl_path + key + '.pklz'\r\n pickle.dump(results, gzip.open(results_cache_add, 'w'))\r\n results_all[key] = results_cache_add\r\n else:\r\n results_all[key] = results\r\n\r\n if PLOT:\r\n import pylab as plt\r\n plt.figure('seg')\r\n plt.imshow(global_seg)\r\n print('Seg unique:' + str(np.unique(global_seg)))\r\n plt.figure('tag')\r\n plt.imshow(global_tag)\r\n print('Tag unique:' + str(np.unique(global_tag)))\r\n plt.show()\r\n\r\n return results_all","def get_score_and_geo(images, labels, data_iter_type='ImageDetIter'):\n for i, image in enumerate(images):\n height, width = image.shape[1], image.shape[2]\n poly_mask = np.zeros((height, width), dtype=np.uint8)\n score_map = np.zeros((images.shape[0], height, width), dtype=np.uint8)\n geo_map = np.zeros((images.shape[0], height, width, 5), dtype=np.float32)\n if data_iter_type == 'MXDataIter':\n label = labels[i].asnumpy() # 1-D Array\n label = np.delete(label, np.where(label == -1)) # Delete all -1 padding\n c, h, w, label_width, header_length, bbox_label_width, orig_h, orig_w = label[:8]\n polys = np.reshape(label[8:], (int(len(label[8:]) / bbox_label_width), -1)) # (Num_of_polys, bbox_label_width)\n vocab_idx = polys[:, 1]\n polys = polys[:, 1:]\n\n elif data_iter_type == 'ImageDetIter':\n label = labels[i].asnumpy() # 1-D Array\n polys = np.delete(label, np.where(label[:, 0] == -1), axis=0)\n vocab_idx = polys[:, 1]\n polys = polys[:, 1:]\n\n # For each polygon (bounding box) in the label\n for poly in polys:\n poly = np.reshape(poly, (4, 2))\n poly[:, 0] = np.round(poly[:, 0] * height, 0)\n poly[:, 1] = np.round(poly[:, 1] * width, 0)\n\n poly = np.array(poly).astype(np.int32)\n # Draw polygon on the score mask (binary map)\n cv2.fillPoly(score_map[i], [poly], (1))\n # Draw polygon on the poly_mask (binary map) that will be used to create geo_map\n cv2.fillPoly(poly_mask, [poly], (1))\n\n fitted_parallelograms = []\n # For the number of sides (4) in the polygon\n for j in range(4):\n # Rotate the orientation at each iter\n p0 = poly[j]\n p1 = poly[(j + 1) % 4]\n p2 = poly[(j + 2) % 4]\n p3 = poly[(j + 3) % 4]\n\n edge = fit_line([p0[0], p1[0]], [p0[1], p1[1]])\n if point_dist_to_line(p0, p1, p2) > point_dist_to_line(p0, p1, p3):\n if edge[1] == 0:\n edge_opposite = [1, 0, -p2[0]]\n else:\n edge_opposite = [edge[0], -1, p2[1] - edge[0] * p2[0]]\n else:\n if edge[1] == 0:\n edge_opposite = [1, 0, -p3[0]]\n else:\n edge_opposite = [edge[0], -1, p3[1] - edge[0] * p3[0]]\n\n # move forward edge\n new_p0 = p0\n new_p1 = p1\n new_p2 = p2\n new_p3 = p3\n forward_edge = fit_line([p1[0], p2[0]], [p1[1], p2[1]])\n new_p2 = line_cross_point(forward_edge, edge_opposite)\n if point_dist_to_line(p1, new_p2, p0) > point_dist_to_line(p1, new_p2, p3):\n # across p0\n if forward_edge[1] == 0:\n forward_opposite = [1, 0, -p0[0]]\n else:\n forward_opposite = [forward_edge[0], -1, p0[1] - forward_edge[0] * p0[0]]\n else:\n # across p3\n if forward_edge[1] == 0:\n forward_opposite = [1, 0, -p3[0]]\n else:\n forward_opposite = [forward_edge[0], -1, p3[1] - forward_edge[0] * p3[0]]\n new_p0 = line_cross_point(forward_opposite, edge)\n new_p3 = line_cross_point(forward_opposite, edge_opposite)\n fitted_parallelograms.append([new_p0, new_p1, new_p2, new_p3, new_p0])\n\n # or move backward edge\n new_p0 = p0\n new_p1 = p1\n new_p2 = p2\n new_p3 = p3\n backward_edge = fit_line([p0[0], p3[0]], [p0[1], p3[1]])\n new_p3 = line_cross_point(backward_edge, edge_opposite)\n if point_dist_to_line(p0, p3, p1) > point_dist_to_line(p0, p3, p2):\n # across p1\n if backward_edge[1] == 0:\n backward_opposite = [1, 0, -p1[0]]\n else:\n backward_opposite = [backward_edge[0], -1, p1[1] - backward_edge[0] * p1[0]]\n else:\n # across p2\n if backward_edge[1] == 0:\n backward_opposite = [1, 0, -p2[0]]\n else:\n backward_opposite = [backward_edge[0], -1, p2[1] - backward_edge[0] * p2[0]]\n new_p1 = line_cross_point(backward_opposite, edge)\n new_p2 = line_cross_point(backward_opposite, edge_opposite)\n fitted_parallelograms.append([new_p0, new_p1, new_p2, new_p3, new_p0])\n\n areas = [Polygon(t).area for t in fitted_parallelograms]\n parallelogram = np.array(fitted_parallelograms[np.argmin(areas)][:-1], dtype=np.float32)\n\n # sort thie polygon\n parallelogram_coord_sum = np.sum(parallelogram, axis=1)\n min_coord_idx = np.argmin(parallelogram_coord_sum)\n parallelogram = parallelogram[\n [min_coord_idx, (min_coord_idx + 1) % 4, (min_coord_idx + 2) % 4, (min_coord_idx + 3) % 4]]\n\n rectangle = rectangle_from_parallelogram(parallelogram)\n rectangle, rotate_angle = sort_rectangle(rectangle)\n r0, r1, r2, r3 = rectangle\n\n # For all points of the polygon (bounding box), calculate geometric geo map\n Y, X = np.where(poly_mask == 1)\n for y, x in zip(Y, X):\n point = np.array([x, y], dtype=np.float32)\n # top\n geo_map[i, y, x, 0] = point_dist_to_line(r0, r1, point)\n # right\n geo_map[i, y, x, 1] = point_dist_to_line(r1, r2, point)\n # down\n geo_map[i, y, x, 2] = point_dist_to_line(r2, r3, point)\n # left\n geo_map[i, y, x, 3] = point_dist_to_line(r3, r0, point)\n # angle\n geo_map[i, y, x, 4] = rotate_angle\n\n print (geo_map.shape)\n exit()\n\n return score_map, geo_map","def annotate_image(self, image, results):\n predictedObjects = []\n for i in range(len(results)):\n objectParameters = []\n x = int(results[i][1])\n y = int(results[i][2])\n w = int(results[i][3])\n h = int(results[i][4])\n # print(x, y, w, h, results[i][0])\n imageHeight, imageWidth, _ = image.shape\n w = w // 2\n h = h // 2\n # change to truncate boxes which go outside the image\n xmin, xmax, ymin, ymax = 0, 0, 0, 0\n xmin = 3 if not max(x - w, 0) else (x - w)\n xmax = imageWidth - 3 if not min(x + w - imageWidth, 0) \\\n else (x + w)\n ymin = 1 if not max(y - h, 0) else (y - h)\n ymax = imageHeight - 3 if not min(y + h - imageHeight, 0) \\\n else (y + h)\n if self.verbose:\n print('Class : ' + results[i][0] + ', [x, y, w, h] [' +\n str(x) + ', ' + str(y) + ', ' + str(w) + ', ' + str(h) +\n '] Confidence : ' + str(results[i][5]))\n \n # Each class must have a unique color\n color = tuple([(j * (1+self.classes.index(results[i][0])) % 255) \\\n for j in self.seed])\n cv2.rectangle(image, (xmin, ymin), (xmax, ymax), color, 2)\n if ymin <= 20:\n cv2.rectangle(\n image, (xmin, ymin), (xmax, ymin + 20), color, -1\n )\n cv2.putText(\n image, results[i][0] + ': %.2f' % results[i][5],\n (xmin+5, ymin+15), cv2.FONT_HERSHEY_SIMPLEX, 0.5,\n (255, 255, 255), 2\n )\n else:\n cv2.rectangle(image, (xmin, ymin), (xmax, ymin-20), color, -1)\n cv2.putText(\n image, results[i][0] + ': %.2f' % results[i][5],\n (xmin+5, ymin-8), cv2.FONT_HERSHEY_SIMPLEX, 0.5,\n (255, 255, 255), 2\n )\n objectParameters = [\n results[i][0], xmin, ymin, xmax, ymax, results[i][5]\n ]\n predictedObjects.append(objectParameters)\n return image, predictedObjects\n # if self.outputFile:\n # cv2.imwrite(self.outputFile,image)","def search(self, query_image, list_images):\n\t\tresult = {}\n\t\t# Get variables from query image\n\t\tquery_kps, query_descriptor = query_image.key_points_and_descriptors()\n\t\t# Loop in the list of images\n\t\tfor image in list_images:\n\t\t\t# Varuables of the current image\n\t\t\tkps, descriptor = image.key_points_and_descriptors()\n\t\t\t# Get the score of the current image compared with the query image\n\t\t\tscore = self.get_score(query_kps, query_descriptor, kps, descriptor)\n\t\t\tresult[image.name()] = score\n\n\t\t# Sort results by score\n\t\tif len(result) > 0:\n\t\t\tresult = sorted([(v, k) for (k, v) in result.items() if v > 0],\n\t\t\t\treverse = True)\n\t\treturn result","def get_image_list(im, dic):\n lst = list(im.getdata())\n tiles = []\n for i in range(len(lst)):\n #print find_similar(lst[i], dic)[random.randrange(10)][1]\n tiles.append(find_similar(lst[i], dic)[random.randrange(10)][1])\n return tiles","def draw_all_result(self, image):\n for facebox, conf in self.detection_result:\n cv2.rectangle(image, (facebox[0], facebox[1]),\n (facebox[2], facebox[3]), (0, 255, 0))\n label = \"face: %.4f\" % conf\n label_size, base_line = cv2.getTextSize(\n label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)\n\n cv2.rectangle(image, (facebox[0], facebox[1] - label_size[1]),\n (facebox[0] + label_size[0],\n facebox[1] + base_line),\n (0, 255, 0), cv2.FILLED)\n cv2.putText(image, label, (facebox[0], facebox[1]),\n cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0))","def draw_all_result(self, image):\r\n for facebox, conf in self.detection_result:\r\n cv2.rectangle(image, (facebox[0], facebox[1]),\r\n (facebox[2], facebox[3]), (0, 255, 0))\r\n label = \"face: %.4f\" % conf\r\n label_size, base_line = cv2.getTextSize(\r\n label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)\r\n\r\n cv2.rectangle(image, (facebox[0], facebox[1] - label_size[1]),\r\n (facebox[0] + label_size[0],\r\n facebox[1] + base_line),\r\n (0, 255, 0), cv2.FILLED)\r\n cv2.putText(image, label, (facebox[0], facebox[1]),\r\n cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0))","def renderResultOnImage(self, result, img ):\n \n for currFace in result:\n faceRectangle = currFace['faceRectangle']\n currEmotion = max(currFace['scores'].items(), key=operator.itemgetter(1))[0]\n '''if currEmotion == 'anger':\n logo = cv2.imread('/home/chang/图片/anger.jpg')\n elif currEmotion == 'contempt':\n logo = cv2.imread('/home/chang/图片/contempt.jpg')\n elif currEmotion == 'disgust':\n logo = cv2.imread('/home/chang/图片/disgust.jpg')\n elif currEmotion == 'fear':\n logo = cv2.imread('/home/chang/图片/fear.jpg')\n elif currEmotion == 'happiness':\n logo = cv2.imread('/home/chang/图片/happiness.jpg')\n elif currEmotion == 'neutral':\n logo = cv2.imread('/home/chang/图片/neutral.jpg')\n elif currEmotion == 'sadness':\n logo = cv2.imread('/home/chang/图片/sadness.jpg')\n elif currEmotion == 'surprise':\n logo = cv2.imread('/home/chang/图片/surprise.jpg')\n width=faceRectangle['width']#171\n top=faceRectangle['top']#130\n left=faceRectangle['left']#101\n height=faceRectangle['height']#169\n\n\n logo=cv2.resize(logo,((width-10),(height-10)),interpolation=cv2.INTER_CUBIC)#rows=189 cols=191\n\n logo_gray = cv2.cvtColor(logo, cv2.COLOR_BGR2GRAY)\n rows, cols, channels = logo.shape#\n \n roi = img[(top):(top+rows),(left):(cols+left)]#row:188 col:190\n \n # binary & mask\n ret, mask = cv2.threshold(logo_gray, 220, 255, cv2.THRESH_BINARY)\n # dst\n dst = roi\n re_row,re_col,re_channel = dst.shape\n \n\n for r in xrange(re_row):#0-188\n for c in xrange(re_col):#0-190\n if mask[r, c] == 0:\n dst[r, c, :] = logo[r, c, :]\n #img[(top):(top+rows),(left):(cols+left)] = dst\n #textToWrite = \"%s\" % ( currEmotion )\n #cv2.putText( img, textToWrite, (faceRectangle['left'],faceRectangle['top']-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,0,0), 1 )\n '''\n return currEmotion","def get_img_index(pred_result: List) -> List:\n img_index = []\n\n for i, line in enumerate(pred_result):\n match = re.search(\"\\./test_pics/\", line)\n if match:\n img_index.append(i)\n if i == len(pred_result) - 1:\n img_index.append(i)\n return img_index","def test(label_dict, image_ids, args):\n\n log_header('Starting image retrieval preparations')\n\n queries = []\n\n if args.test_image is not None:\n queries.append(args.test_image)\n else:\n logging.info('Generating random test queries')\n\n number_of_images = len(image_ids)\n\n # Generate random queries to use in the test procedure\n for i in range(args.k):\n queries.append(image_ids[random.randint(0, number_of_images - 1)])\n\n # Calculate score for the retrieved images\n calculate_score(\n label_dict, queries, retrieve_similar_images(queries, args)\n )","def draw_detections(self, img, yolo_results):\n\n _, height, _ = img.shape\n for yolo_result in yolo_results:\n class_index = yolo_result.class_index\n obj_name = yolo_result.obj_name\n x = yolo_result.x_min\n y = yolo_result.y_min\n w = yolo_result.width\n h = yolo_result.height\n\n offset = class_index * 123457 % self.meta.classes\n\n red = self._get_color(2, offset, self.meta.classes)\n green = self._get_color(1, offset, self.meta.classes)\n blue = self._get_color(0, offset, self.meta.classes)\n box_width = int(height * 0.006)\n cv2.rectangle(img, (int(x), int(y)), (int(x+w)+1, int(y+h)+1), (red, green, blue), box_width)\n cv2.putText(img, obj_name, (int(x) -1, int(y) -1), cv2.FONT_HERSHEY_PLAIN, 2, (red, green, blue), 2)\n\n return img","def fetch_images(self, images, depth_level):\r\n image_results = {}\r\n initial_area = float(0.0)\r\n total_score = float(0.0)\r\n cnt = float(1.0)\r\n MIN_WIDTH = 50\r\n for image in images[:30]:\r\n src = self.parser.getAttribute(image, attr='src')\r\n src = self.build_image_path(src)\r\n local_image = self.get_local_image(src)\r\n width = local_image.width\r\n height = local_image.height\r\n src = local_image.src\r\n file_extension = local_image.file_extension\r\n\r\n if file_extension != '.gif' or file_extension != 'NA':\r\n if (depth_level >= 1 and local_image.width > 300) or depth_level < 1:\r\n if not self.is_banner_dimensions(width, height):\r\n if width > MIN_WIDTH:\r\n sequence_score = float(1.0 / cnt)\r\n area = float(width * height)\r\n total_score = float(0.0)\r\n\r\n if initial_area == 0:\r\n initial_area = area * float(1.48)\r\n total_score = 1\r\n else:\r\n area_difference = float(area / initial_area)\r\n total_score = sequence_score * area_difference\r\n\r\n image_results.update({local_image: total_score})\r\n cnt += 1\r\n cnt += 1\r\n return image_results","def ingest_results(self, results, isCsv=False):\n \n for r in results:\n image = Image()\n if isCsv:\n image.parse_row(r)\n else:\n image.parse_record(r)\n # print(\"metadata: %s\" % image.metadata)\n # answer = input(\"Press enter...\")\n self.img_lst.append(image)","def evaluate(self):\n scores = []\n scores.append(self.word_analogy())\n print(\"Word Analogy (acc): \", scores[0])\n scores.append(self.word_similarity())\n print(\"Word Similarity (MSE): \", scores[1])\n scores.append(self.concept_categorization())\n print(\"Concept Categorization (purity): \", scores[2])\n scores.append(self.sentiment_analysis())\n print(\"Sentiment Analysis (acc): \", scores[3])\n return scores","def getResults():","def print_images_in_statistics(self):\n self._print_images_statistics(self._images_in_folder, self._pose_class_names)","def im_list_detections(model, im_list):\n _t = Timer()\n num_images = len(im_list)\n im_list_boxes = [[] for _ in range(num_images)]\n im_list_scores = [[] for _ in range(num_images)]\n im_list_ids = [[] for _ in range(num_images)]\n im_list_classes = [[] for _ in range(num_images)]\n # create anchors for each level\n anchors = create_cell_anchors()\n for i in range(num_images):\n im_list_ids[i] = im_list[i]['id']\n im = cv2.imread(im_list[i]['image'])\n with c2_utils.NamedCudaScope(0):\n _t.tic()\n im_list_boxes[i], im_list_scores[i], im_list_classes[i] = \\\n im_detections(model, im, anchors)\n _t.toc()\n logger.info(\n 'im_detections: {:d}/{:d} {:.3f}s'.format(\n i + 1, num_images, _t.average_time))\n return im_list_boxes, im_list_scores, im_list_classes, im_list_ids","def detect_objects(self, image):\n # Feed the input image to the model\n self.set_input_tensor(image)\n self.model.invoke()\n\n # Get all outputs from the model\n boxes = self.get_output_tensor(0)\n classes = self.get_output_tensor(1)\n scores = self.get_output_tensor(2)\n count = int(self.get_output_tensor(3))\n\n results = []\n for i in range(count):\n result = {\n 'bounding_box': boxes[i],\n 'class_id': int(classes[i]),\n 'score': scores[i]\n }\n results.append(result)\n return results","def generate_labels(pics):\r\n return []","def convert_predictions_to_image_summaries(hook_args):\n decode_hparams = hook_args.decode_hparams\n if not decode_hparams.display_decoded_images:\n return []\n predictions = hook_args.predictions[0]\n\n # Display ten random inputs and outputs so that tensorboard does not hang.\n all_summaries = []\n rand_predictions = np.random.choice(predictions, size=10)\n for ind, prediction in enumerate(rand_predictions):\n output_summary = image_to_tf_summary_value(\n prediction[\"outputs\"], tag=\"%d_output\" % ind)\n input_summary = image_to_tf_summary_value(\n prediction[\"inputs\"], tag=\"%d_input\" % ind)\n all_summaries.append(input_summary)\n all_summaries.append(output_summary)\n return all_summaries","def format_results(self, results, imgfile_prefix=None, to_label_id=True):\n\n assert isinstance(results, list), 'results must be a list'\n\n imgfile_prefix = osp.join(imgfile_prefix, 'vis')\n if not osp.exists(imgfile_prefix):\n os.makedirs(imgfile_prefix)\n print_log('\\n Start formatting the result')\n\n for id in trange(len(results)):\n pred, gt, img_path = results[id]\n b,c,h,w = pred.shape\n assert pred.shape[0]==1 and gt.shape[0]==1\n pred = pred[0]\n gt = gt[0]\n gt[-1, ...] = np.invert(gt[-1, ...])\n pred = np.concatenate([pred, gt[-1,...][None,...]], axis=0)\n pred_vis = visualize_map_mask(pred)\n gt_vis = visualize_map_mask(gt)\n img = mmcv.imread(img_path, backend='cv2')\n img = mmcv.imresize(img,(int(float(img.shape[1])*h/float(img.shape[0])), h))\n vis = np.concatenate([img, pred_vis[::-1,...], gt_vis[::-1,]], axis=1)\n save_path = osp.join(imgfile_prefix, os.path.basename(img_path))\n mmcv.imwrite(vis, save_path)","def format_multiple_results(results, features_to_show=[]):\n best_score_array = np.array([])\n for r in results:\n print r\n print r[-1]\n best_score_array = np.append(best_score_array, r[-1])\n\n print \"BEST SCORE ARRAY\", best_score_array\n print \"Best Score\"\n print \"Mean: \", best_score_array.mean()\n print \"Std: \", best_score_array.std()","def _fetch_labels(self, list_fams, no_imgs, num_samples) -> Tuple[np.ndarray, List]:\n y_train = np.zeros(num_samples)\n pos = 0\n label = 0\n indexes = []\n for i in no_imgs:\n indexes.append(i)\n print(\"Label:%2d\\tFamily: %15s\\tNumber of images: %d\" % (label, list_fams[label], i))\n for j in range(i):\n y_train[pos] = label\n pos += 1\n label += 1\n return y_train, indexes","def get_output(interpreter, score_threshold, top_k, image_scale=1.0):\n boxes = common.output_tensor(interpreter, 0)\n class_ids = common.output_tensor(interpreter, 1)\n scores = common.output_tensor(interpreter, 2)\n count = int(common.output_tensor(interpreter, 3))\n\n def make(i):\n ymin, xmin, ymax, xmax = boxes[i]\n return Object(\n id=int(class_ids[i]),\n score=scores[i],\n bbox=BBox(xmin=np.maximum(0.0, xmin),\n ymin=np.maximum(0.0, ymin),\n xmax=np.minimum(1.0, xmax),\n ymax=np.minimum(1.0, ymax)))\n\n return [make(i) for i in range(top_k) if scores[i] >= score_threshold]","def get_output(interpreter, score_threshold, top_k, image_scale=1.0):\n boxes = common.output_tensor(interpreter, 0)\n class_ids = common.output_tensor(interpreter, 1)\n scores = common.output_tensor(interpreter, 2)\n count = int(common.output_tensor(interpreter, 3))\n\n def make(i):\n ymin, xmin, ymax, xmax = boxes[i]\n return Object(\n id=int(class_ids[i]),\n score=scores[i],\n bbox=BBox(xmin=np.maximum(0.0, xmin),\n ymin=np.maximum(0.0, ymin),\n xmax=np.minimum(1.0, xmax),\n ymax=np.minimum(1.0, ymax)))\n\n return [make(i) for i in range(top_k) if scores[i] >= score_threshold]","def get_output(interpreter, score_threshold, top_k, image_scale=1.0):\n boxes = common.output_tensor(interpreter, 0)\n class_ids = common.output_tensor(interpreter, 1)\n scores = common.output_tensor(interpreter, 2)\n count = int(common.output_tensor(interpreter, 3))\n\n def make(i):\n ymin, xmin, ymax, xmax = boxes[i]\n return Object(\n id=int(class_ids[i]),\n score=scores[i],\n bbox=BBox(xmin=np.maximum(0.0, xmin),\n ymin=np.maximum(0.0, ymin),\n xmax=np.minimum(1.0, xmax),\n ymax=np.minimum(1.0, ymax)))\n\n return [make(i) for i in range(top_k) if scores[i] >= score_threshold]","def main():\n \n # for inserting other images, add tem to /input folder and list them here\n images = (\n 'image-0',\n 'image-1',\n 'image-2'\n )\n\n for image_name in images:\n print(image_name, \"image:\")\n\n image = open_image(image_name)\n display_image(image, \"Original input \" + image_name)\n\n grayscale_v = transform_colors(image)\n display_image(grayscale_v[:,:,0], \"Grayscale \" + image_name)\n save_image(image_name + \"-grayscale\", grayscale_v[:,:,0])\n\n contours_v, contours = get_contours(grayscale_v)\n display_image(contours_v, \"Contours \" + image_name)\n save_image(image_name + \"-contours\", contours_v)\n\n labeled_img, areas = get_measures(image, contours[1:])\n display_image(labeled_img, \"Labeled \" + image_name)\n save_image(image_name + \"-labeled\", labeled_img)\n\n areas_histogram(areas, image_name)","def test_image_at_levels(image_name, percentages, blur=False, blur_amount=10):\n # img = skimage.io.imread(os.path.join(IMAGE_DIR, image_name[:-3]+'JPEG'))\n img = cv2.imread(os.path.join(IMAGE_DIR, image_name[:-3]+'JPEG'))\n # mask_img = skimage.io.imread(os.path.join(MASK_DIR, image_name))\n mask_img = cv2.imread(os.path.join(MASK_DIR, image_name))\n results = []\n level_list = get_ntiles_for_img(mask_img, percentages)\n print(level_list)\n for level in level_list:\n masked_image = make_masked_image(img, mask_img, level, blur, blur_amount)\n cv2.imshow('img',masked_image)\n cv2.waitKey(0)\n cv2.destroyAllWindows()\n # Transform image for VGG\n masked_image = cv2.resize(masked_image, (224,224)).astype(np.float32)\n masked_image[:,:,0] -= 103.939\n masked_image[:,:,1] -= 116.779\n masked_image[:,:,2] -= 123.68\n masked_image = masked_image.transpose((1,0,2))\n masked_image = np.expand_dims(masked_image, axis=0)\n out = model.predict(masked_image)\n ordered_idx = np.argsort(-out)\n print(out.max(), ordered_idx[0][0])\n result = (CallResult.lines[int(ordered_idx[0][0])], out[0][ordered_idx[0]][0])\n results.append(result)\n\n return results","def main():\n stats = []\n start = timer()\n\n for file_name in get_dataset():\n\n # load image and ground truth detection mask\n img = cv2.imread(settings.PATH + file_name)\n ground_truth_mask = cv2.imread(settings.PATH_GT_MASKS + file_name)\n\n # Find list of barcode regions (rotated rectangle) within image\n barcode_regions, debug_img = find_barcodes(img)\n barcode_regions_mask = np.zeros(img.shape, np.uint8)\n barcode_images = None\n result = []\n\n # Decode barcode regions\n for barcode_region in barcode_regions:\n\n # Decode barcode image\n barcode_img = barcode_region.extract_from(img)\n barcode_mask = barcode_region.get_mask(img)\n debug_img = barcode_region.draw(debug_img)\n\n # Combine masks from multiple detected regions\n barcode_regions_mask += barcode_mask\n\n # Decode barcode\n decoded = pyzbar.decode(barcode_img)\n\n # Keep result for logging\n data = \", \".join([d.data.decode(\"utf-8\") for d in decoded])\n result.append({\"data\": data, \"region\": barcode_region.json()})\n\n if settings.SHOW_IMAGE:\n barcode_images = img_concat(barcode_images, barcode_img)\n\n # Jaccard_accuracy = intersection over union of the two binary masks\n jaccard_accuracy = 0\n if ground_truth_mask is not None:\n r = barcode_regions_mask.max(axis=-1).astype(bool)\n u = ground_truth_mask.max(axis=-1).astype(bool)\n jaccard_accuracy = float((r & u).sum()) / (r | u).sum()\n stats.append(jaccard_accuracy)\n\n # Log result\n logger.info(\n \"Image processed\",\n file_name=file_name,\n jaccard_accuracy=jaccard_accuracy,\n success=jaccard_accuracy > 0.5,\n result=result,\n )\n\n # In debug mode show visualization of detection algorithm\n if settings.SHOW_IMAGE:\n\n # Add alpha channel\n debug_img = cv2.cvtColor(debug_img, cv2.COLOR_BGR2BGRA)\n if barcode_images is not None:\n barcode_images = cv2.cvtColor(barcode_images, cv2.COLOR_BGR2BGRA)\n\n # Overlay error mask\n # Pixel-wise difference between ground truth and detected barcodes\n if ground_truth_mask is not None:\n error_img = np.zeros(debug_img.shape, np.uint8)\n error_img[r & u] = np.array([0, 0, 0, 0], dtype=np.uint8)\n error_img[np.logical_xor(r, u)] = np.array(\n [0, 0, 255, 1], dtype=np.uint8\n )\n debug_img = cv2.addWeighted(debug_img, 1, error_img, 0.5, 0)\n\n # Append barcode pictures to the right\n debug_img = img_concat(debug_img, barcode_images, axis=1)\n\n # Show visualization\n cv2.namedWindow(\"img\", cv2.WINDOW_NORMAL)\n cv2.imshow(\"img\", debug_img)\n cv2.waitKey(0)\n\n # Calculate final stats\n end = timer()\n accuracy = np.array(stats).mean()\n successes = np.where(np.array(stats) > 0.5)[0]\n logger.info(\n \"Final stats\",\n accuracy=accuracy,\n detection_rate=float(len(successes)) / len(stats),\n fps=len(stats) / (end - start),\n )","def test_measurement_on_images(file_list):\n test_details_list = []\n for idx, file in enumerate(file_list):\n dict_results = {}\n image = cv2.imread(file)\n FaceDetector().run(image, dict_results)\n file_name = ntpath.basename(file)\n is_there_face = \"True\" in file_name\n test_details_list.append([file_name, is_there_face, dict_results[\"FaceDetector\"],\n is_there_face == dict_results[\"FaceDetector\"]])\n\n # print test results in a readable table format\n headers = ['File Name', 'Face Exist', 'Measurement Result', 'Test Result']\n print(tabulate(test_details_list, headers))","def get_images(image_folder_root, image_label_list):\n file_dcm=[]\n X_test = []\n y_test = []\n for file_name,label in image_label_list:\n try:\n current_file = pydicom.dcmread(image_folder_root + file_name + '.dcm')\n pixel_array = current_file.pixel_array\n if (pixel_array.shape != (512,512)):\n continue\n file_dcm.append((file_name,label,brain_window(current_file)))\n y_test.append(label)\n X_test.append(pydicom.dcmread(image_folder_root + file_name + '.dcm').pixel_array)\n except ValueError:\n continue\n return X_test,y_test","def prepare_images(images):\n images = color.rgb2lab(images)\n\n l = images[:,:,:,:1]/100.\n ab = images[:,:,:,1:]/200. + 0.5\n\n return l, ab","def get_images(path_list):\n images = []\n labels = []\n names = []\n i = 0\n for path in path_list:\n for fruit_dir_path in glob.glob(path):\n fruit_label = fruit_dir_path.split(\"/\")[-1]\n for image_path in glob.glob(os.path.join(fruit_dir_path, \"*.jpg\")):\n image = cv2.imread(image_path, cv2.IMREAD_COLOR)\n\n image = cv2.resize(image, (45, 45))\n image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n\n images.append(image)\n names.append(fruit_label)\n labels.append(i)\n i += 1\n\n images = np.array(images)\n print(images.shape)\n # add a new dimension here\n with np.nditer(images, op_flags=['readwrite']) as it:\n for x in it:\n x = np.expand_dims(x, axis=0)\n labels = np.array(labels)\n return images, labels, i","def class_imgs(list_img):\n numberimg = len(list_img)\n resize(net, numberimg, cursize)\n i = 0\n for img in list_img:\n image = caffe.io.load_image(img)\n transformed_image = transformer.preprocess('data', image)\n net.blobs['data'].data[i] = transformed_image\n i = i + 1\n\n output = net.forward()\n\n results = []\n for n in range(0, numberimg):\n themax = output['prob'][n].argmax()\n results.append({'filename':list_img[n], 'class': themax, 'prob': output['prob'][n].tolist()})\n\n return results","def generate_imgs(self, count, threshold, modifier):\n self.build_gan()\n\n\n imgs = []\n for i in range(count):\n score = [0]\n while not(threshold[0] < score[0] < threshold[1]):\n img = self.gene_imgs(1)\n score = self.discriminator.predict(img)\n print(\"Image found: \", score[0])\n imgs.append(img)\n\n imgs = np.asarray(imgs).squeeze()\n imgs = 0.5 * imgs + 0.5\n\n print(imgs.shape)\n for i, img_array in enumerate(imgs):\n path = f\"{self.output_directory}/generated_{threshold[0]}_{threshold[1]}\"\n if not os.path.exists(path):\n os.makedirs(path)\n imsave(path + f\"/{modifier}_{i}.png\", self.pix_array_convert(img_array))","def classify_images(images_dir, results_dic, model):\n \n # None \n\n first_filename_list = listdir(\"pet_images/\")\n filename_list = []\n for idx in range(0, len(first_filename_list), 1):\n if not first_filename_list[idx].startswith('.'):\n filename_list.append(first_filename_list[idx])\n\n idx = 0\n for key in results_dic:\n # print(\"---------------\")\n\n value=results_dic[key]\n # print(\"\\t-----key={}\".format(key))\n # print(\"\\t-----value={}\".format(value))\n \n path = images_dir + filename_list[idx]\n # print(\"\\t-----path={}\".format(path))\n \n model_label = classifier(path, model)\n model_label = model_label.lower()\n model_label = model_label.strip()\n # print(\"\\t-----model_label={}\".format(model_label))\n \n truth = 0\n if value in model_label:\n truth = 1\n\n results_dic[key] = [ value, model_label, truth ]\n # print(\"\\t-----truth={}\".format(truth))\n idx = idx + 1","def detect_objects(self, image, threshold):\n self.set_input_tensor(image)\n self.interpreter.invoke()\n\n # Get all output details\n boxes = self.get_output_tensor(0)\n classes = self.get_output_tensor(1)\n scores = self.get_output_tensor(2)\n count = int(self.get_output_tensor(3))\n\n results = []\n for i in range(count):\n if scores[i] >= threshold:\n result = {\n 'bounding_box': boxes[i],\n 'class_id': classes[i],\n 'score': scores[i]\n }\n results.append(result)\n return results","def _plot_results(results, labels, score):\n \n labels_dict = {k: i for i, k in enumerate(labels)}\n rmin, rmax = min(results)[0], max(results)[0]\n to_color = lambda x : 0.8 * (x - rmax) / (rmin - rmax) + 0.5\n\n result_matrix = np.zeros((8, len(labels_dict)))\n labels_dict = {k: i for i, k in enumerate(labels)}\n for i, (v, r_labels) in enumerate(results):\n for k in r_labels:\n result_matrix[i, labels_dict[k]] = to_color(v)\n \n plt.figure(figsize=(11, 6))\n plt.imshow(result_matrix, cmap='Greys', aspect='auto')\n plt.xticks(np.arange(0, len(labels)), labels, rotation=90)\n plt.yticks(np.arange(0, len(results)), [round(x[0]) for x in results])\n plt.ylabel(score)\n plt.show()","def _get_X_and_names(self, list_fams, num_samples, property_alias: str) -> Tuple[np.ndarray, List[str]]:\n width, height, channels = (self.IMAGE_WIDTH, self.IMAGE_HEIGHT, self.IMAGE_CHANNELS)\n X_train = np.zeros((num_samples, width, height, channels))\n cnt = 0\n samples_names = []\n print(\"Processing images ...\")\n for i in range(len(list_fams)):\n print('current fam: ', i)\n for index, img_file in enumerate(self._fetch_all_images(join(list_fams[i], property_alias))):\n img = image.load_img(img_file, target_size=(self.IMAGE_WIDTH, self.IMAGE_HEIGHT))\n x = image.img_to_array(img)\n x = np.expand_dims(x, axis=0)\n x = preprocess_input(x)\n X_train[cnt] = x\n\n cnt += 1\n index = img_file.find(self.frame_delimiter)\n samples_names.append(img_file[0:index])\n return X_train, samples_names","def detect_objects(interpreter, image):\n set_input_tensor(interpreter, image)\n interpreter.invoke()\n\n # Get all output details\n boxes = get_output_tensor(interpreter, 0)\n classes = get_output_tensor(interpreter, 1)\n scores = get_output_tensor(interpreter, 2)\n count = int(get_output_tensor(interpreter, 3))\n\n results = []\n for i in range(count):\n # Only check for people that meet the threshold\n if classes[i] == 0.0 and scores[i] >= THRESHOLD:\n result = {\n \"bounding_box\": boxes[i],\n \"class_id\": classes[i],\n \"score\": scores[i],\n }\n results.append(result)\n return results","def runClassifier(interpreter, image, threshold):\n set_input_tensor(interpreter, image)\n interpreter.invoke()\n\n # Get all output details\n boxes = get_output_tensor(interpreter, 0)\n classes = get_output_tensor(interpreter, 1)\n scores = get_output_tensor(interpreter, 2)\n count = int(get_output_tensor(interpreter, 3))\n\n results = []\n for i in range(count):\n if scores[i] >= threshold:\n result = {\n \"bounding_box\": boxes[i],\n \"class_id\": classes[i],\n \"score\": scores[i],\n }\n results.append(result)\n return results","def create_image_lists(image_dir):\n if not gfile.Exists(image_dir):\n print(\"Image directory '\" + image_dir + \"' not found.\")\n return None\n result = {}\n sub_dirs = [x[0] for x in os.walk(image_dir)]\n # The root directory comes first, so skip it.\n is_root_dir = True\n for sub_dir in sub_dirs:\n print('in sub loop')\n extensions = ['jpg', 'jpeg', 'JPG', 'JPEG']\n file_list = []\n dir_name = os.path.basename(image_dir)\n print(\"Looking for images in '\" + image_dir + \"'\")\n for extension in extensions:\n file_glob = os.path.join(image_dir, dir_name, '*.' + extension)\n file_list.extend(glob.glob(file_glob))\n if not file_list:\n print('No files found')\n continue\n if len(file_list) < 20:\n print('WARNING: Folder has less than 20 images, which may cause issues.')\n label_name = re.sub(r'[^a-z0-9]+', ' ', dir_name.lower())\n testing_images = []\n for file_name in file_list:\n base_name = os.path.basename(file_name)\n # We want to ignore anything after '_nohash_' in the file name when\n # deciding which set to put an image in, the data set creator has a way of\n # grouping photos that are close variations of each other. For example\n # this is used in the plant disease data set to group multiple pictures of\n # the same leaf.\n hash_name = re.sub(r'_nohash_.*$', '', file_name)\n # This looks a bit magical, but we need to decide whether this file should\n # go into the training, testing, or validation sets, and we want to keep\n # existing files in the same set even if more files are subsequently\n # added.\n # To do that, we need a stable way of deciding based on just the file name\n # itself, so we do a hash of that and then use that to generate a\n # probability value that we use to assign it.\n testing_images.append(base_name)\n return testing_images","def write_results(input_dict):\n out_imgs = {}\n for mol in input_dict:\n mols = []\n for new_mols in input_dict[mol]:\n m = Chem.MolFromSmiles(new_mols)\n mols.append(m)\n if len(mols) > 2:\n p = Chem.MolFromSmarts(MCS.FindMCS(mols).smarts)\n AllChem.Compute2DCoords(p)\n for m in mols:\n AllChem.GenerateDepictionMatching2DStructure(m, p)\n out_imgs[mol] = Draw.MolsToGridImage(mols, useSVG=True)\n # Write out the image\n return out_imgs","def score_all(results):\n Y = np.concatenate([results['%dtest'%n] for n in range(10)])\n print score(np.concatenate([results['%dtrain'%n] for n in range(10)]))\n print score(np.concatenate([results['%dtest'%n] for n in range(10)]))\n class_counts = np.asarray([(Y[:,0]==n).sum() for n in range(10)])\n return confusion_matrix(Y[:,0],Y[:,1]), class_counts","def calculates_results_stats(results_dic): \n # Creates empty dictionary for results_stats_dic\n results_stats_dic = dict()\n \n # Sets all counters to initial values of zero so that they can \n # be incremented while processing through the images in results_dic \n results_stats_dic['n_dogs_img'] = 0\n results_stats_dic['n_match'] = 0\n results_stats_dic['n_correct_dogs'] = 0\n results_stats_dic['n_correct_notdogs'] = 0\n results_stats_dic['n_correct_breed'] = 0\n \n # process through the results dictionary\n for key in results_dic:\n \n # Labels Match Exactly\n if results_dic[key][2] == 1:\n results_stats_dic['n_match'] += 1\n\n # TODO: 5a. REPLACE pass with CODE that counts how many pet images of\n # dogs had their breed correctly classified. This happens \n # when the pet image label indicates the image is-a-dog AND \n # the pet image label and the classifier label match. You \n # will need to write a conditional statement that determines\n # when the dog breed is correctly classified and then \n # increments 'n_correct_breed' by 1. Recall 'n_correct_breed' \n # is a key in the results_stats_dic dictionary with it's value \n # representing the number of correctly classified dog breeds.\n # \n # Pet Image Label is a Dog AND Labels match- counts Correct Breed\n if results_dic[key][3] == 1 and results_dic[key][2] == 1:\n results_stats_dic['n_correct_breed'] += 1\n \n # Pet Image Label is a Dog - counts number of dog images\n if results_dic[key][3] == 1:\n results_stats_dic['n_dogs_img'] += 1\n \n # Classifier classifies image as Dog (& pet image is a dog)\n # counts number of correct dog classifications\n if results_dic[key][4] == 1:\n results_stats_dic['n_correct_dogs'] += 1\n\n # TODO: 5b. REPLACE pass with CODE that counts how many pet images \n # that are NOT dogs were correctly classified. This happens \n # when the pet image label indicates the image is-NOT-a-dog \n # AND the classifier label indicates the images is-NOT-a-dog.\n # You will need to write a conditional statement that \n # determines when the classifier label indicates the image \n # is-NOT-a-dog and then increments 'n_correct_notdogs' by 1. \n # Recall the 'else:' above 'pass' already indicates that the \n # pet image label indicates the image is-NOT-a-dog and \n # 'n_correct_notdogs' is a key in the results_stats_dic dictionary \n # with it's value representing the number of correctly \n # classified NOT-a-dog images.\n # \n # Pet Image Label is NOT a Dog\n else:\n # Classifier classifies image as NOT a Dog(& pet image isn't a dog)\n # counts number of correct NOT dog clasifications.\n if results_dic[key][3] == 0 and results_dic[key][4] == 0:\n results_stats_dic['n_correct_notdogs'] += 1\n\n\n # Calculates run statistics (counts & percentages) below that are calculated\n # using the counters from above.\n\n # calculates number of total images\n results_stats_dic['n_images'] = len(results_dic)\n\n # calculates number of not-a-dog images using - images & dog images counts\n results_stats_dic['n_notdogs_img'] = (results_stats_dic['n_images'] - \n results_stats_dic['n_dogs_img']) \n\n # TODO: 5c. REPLACE zero(0.0) with CODE that calculates the % of correctly\n # matched images. Recall that this can be calculated by the\n # number of correctly matched images ('n_match') divided by the \n # number of images('n_images'). This result will need to be \n # multiplied by 100.0 to provide the percentage.\n # \n # Calculates % correct for matches\n results_stats_dic['pct_match'] = (results_stats_dic['n_match'] / results_stats_dic['n_images']) * 100\n\n # TODO: 5d. REPLACE zero(0.0) with CODE that calculates the % of correctly\n # classified dog images. Recall that this can be calculated by \n # the number of correctly classified dog images('n_correct_dogs')\n # divided by the number of dog images('n_dogs_img'). This result \n # will need to be multiplied by 100.0 to provide the percentage.\n # \n # Calculates % correct dogs\n results_stats_dic['pct_correct_dogs'] = (results_stats_dic['n_correct_dogs'] / results_stats_dic['n_dogs_img']) * 100\n\n # TODO: 5e. REPLACE zero(0.0) with CODE that calculates the % of correctly\n # classified breeds of dogs. Recall that this can be calculated \n # by the number of correctly classified breeds of dog('n_correct_breed') \n # divided by the number of dog images('n_dogs_img'). This result \n # will need to be multiplied by 100.0 to provide the percentage.\n # \n # Calculates % correct breed of dog\n results_stats_dic['pct_correct_breed'] = (results_stats_dic['n_correct_breed'] / results_stats_dic['n_dogs_img']) * 100\n\n # Calculates % correct not-a-dog images\n # Uses conditional statement for when no 'not a dog' images were submitted \n if results_stats_dic['n_notdogs_img'] > 0:\n results_stats_dic['pct_correct_notdogs'] = (results_stats_dic['n_correct_notdogs'] /\n results_stats_dic['n_notdogs_img']) * 100.0\n else:\n results_stats_dic['pct_correct_notdogs'] = 0.0\n\n \n # TODO 5f. REPLACE None with the results_stats_dic dictionary that you \n # created with this function \n return results_stats_dic","def _update_result(self, results, clf_numbers):\n # ToDo make results of scoring values dynamic\n names_results = ['Accuracy']\n for number in clf_numbers:\n for name in names_results:\n if name not in self.results:\n self.results[name] = [results[number][name + \"_test_score_\" + str(number)]]\n else:\n self.results[name].append(results[number][name + \"_test_score_\" + str(number)])","def display_results(self, metrics):\n\n for k, v in self.cv_results_.items():\n# sorted_results = sort_results(v)\n print(f'Results for {k} metric:')\n print()\n print(v.sort_values(by=['Metric mean'], ascending=False))\n print()","def get_img_list(self):\n if self.list_flag == \"train\":\n train_list_all = [line.rstrip('\\n')[:-4] for line in open(os.path.join(self.dataset_dir, 'split', self.list_flag + '-list.txt'))]\n train_list_delete = [line.rstrip('\\n') for line in open(os.path.join(self.dataset_dir, 'split', 'Mesh_overlay_train_error_delete.txt'))]\n print(\"Train delete %d images\" % len(train_list_delete))\n\n self.img_list_all = [x for x in train_list_all if x not in train_list_delete]\n elif self.list_flag == \"val\":\n valid_list_all = [line.rstrip('\\n')[:-4] for line in open(os.path.join(self.dataset_dir, 'split', 'validation-list.txt'))]\n val_list_delete = [line.rstrip('\\n') for line in open(os.path.join(self.dataset_dir, 'split', 'Mesh_overlay_val_error_delete.txt'))]\n self.img_list_all = [x for x in valid_list_all if x not in val_list_delete]\n print(\"Val delete %d images.\" % len(val_list_delete))\n\n elif self.list_flag == 'test':\n im_list = os.listdir(os.path.join(self.dataset_dir, 'images'))\n self.img_list_all = [x[:-4] for x in im_list]\n\n return self.img_list_all","def image_generator(img_list):\n while True:\n img = random.choice(img_list)\n label = os.path.basename(os.path.dirname(img)) # add label function according to the dataset tree\n img = preprocess_image(img)\n yield img, label","def draw_boxes(image, results, min_score=0.2, max_boxes=10):\n results = sorted(results, key=lambda x: x['score'])\n results = results[0:max_boxes]\n for r in results:\n if r['score'] < min_score:\n continue\n draw_box(image, r['bounding_box'], labels[r['class_id']], r['score'])","def get_scores(self):\n hist = self.confusion_matrix\n # hist = [TN,FP;FN,TP]\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n # iou = iu.sum() / self.n_classes\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n cls_iou = dict(zip(range(self.n_classes), iu))\n\n ##############################################\n tn = hist[0, 0]\n tp = np.diag(hist).sum() - tn\n fp = np.triu(hist, 1).sum()\n fn = np.tril(hist, -1).sum()\n precision = tp / (tp + fp)\n recall = tp / (tp + fn)\n f1 = 2 * precision * recall / (precision + recall)\n\n # for medical img, img_seg \\in [0,1]\n dice = 2 * tp / (tp + tp + fn + fp)\n # dice = f1-score\n dsc = 2 * tp / (tp + fn + fp)\n # dsc = jaccard\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\n # voe = 1 - dsc\n\n k2 = {\n # \"Overall Acc: \\t\": acc,\n 'Mean Acc': float(judge_nan(acc_cls)),\n # \"FreqW Acc : \\t\": fwavacc,\n 'Mean IoU': float(judge_nan(mean_iou)),\n 'F1-score': float(judge_nan(f1)),\n 'DSC': float(judge_nan(dsc)),\n 'Precision': float(judge_nan(precision)),\n 'Recall': float(judge_nan(recall)),\n }\n\n return k2","def allYandPred(self):\n y = []\n pred = []\n if self.use_dic:\n pb = progressbar.ProgressBar(self.n)\n for data in sorted(self.dic):\n for activity in sorted(self.dic[data]):\n for imsize in sorted(self.dic[data][activity]):\n for img in self.dic[data][activity][imsize]:\n labels = self.dic[data][activity][imsize][img]\n if len(labels) == 2:\n y.append(labels[0])\n pred.append(labels[1])\n else:\n return None\n pb.update()\n else:\n y, pred = self.getYandPred()\n return y, pred","def __getitem__(self, index):\r\n if self.is_train:\r\n image_names,labels = self.sample_train_batch()\r\n # get sampled order image_file names and corresponding label\r\n image_list,label_list=[],[]\r\n for img,label in zip(image_names,labels):\r\n image = imread(img,flag=1,to_rgb=True)\r\n x,y,w,h = self.boxes[img]\r\n image = image[y:min(y+h,image.shape[0]),x:min(x+w,image.shape[1])]\r\n if image.shape[2]==1:\r\n print(\"has gray file\",img)\r\n image = nd.tile(image,(1,1,3))\r\n image =self._transform(image) # for rgb same value\r\n image_list.append(image)\r\n label_list.append(label)\r\n batch_data = nd.stack(*image_list,axis=0)\r\n batch_label = nd.array(label_list)\r\n return batch_data,batch_label\r\n else:\r\n img = self.test_images_files[index] # get the file name full path\r\n image = imread(img,flag=1,to_rgb=1)\r\n x,y,w,h = self.boxes[img]\r\n image = image[y:min(y+h,image.shape[0]),x:min(x+w,image.shape[1])]\r\n image = self._transform(image)\r\n\r\n return image,self.test_labels[index]","def PostProcessing(image, resultList, threshold=0.6):\n\tnum_detections = resultList[0][0].astype(np.int)\n\tscores = resultList[2]\n\tboxes = resultList[3]\n\tbbox_num = 0\n\t\n\t# loop through all the detections and get the confidence and bbox coordinates\n\tfor i in range(num_detections):\n\t\tdet_conf = scores[0, i]\n\t\tdet_ymin = boxes[0, i, 0]\n\t\tdet_xmin = boxes[0, i, 1]\n\t\tdet_ymax = boxes[0, i, 2]\n\t\tdet_xmax = boxes[0, i, 3]\n\n\t\tbbox_width = det_xmax - det_xmin\n\t\tbbox_height = det_ymax - det_ymin\n\t\t# the detection confidence and bbox dimensions must be greater than a minimum value to be a valid detection\n\t\tif threshold <= det_conf and 1 >= det_conf and bbox_width > 0 and bbox_height > 0:\n\t\t\tbbox_num += 1\n\t\t\txmin = int(round(det_xmin * image.shape[1]))\n\t\t\tymin = int(round(det_ymin * image.shape[0]))\n\t\t\txmax = int(round(det_xmax * image.shape[1]))\n\t\t\tymax = int(round(det_ymax * image.shape[0]))\n\t\t\t\n\t\t\tcv2.rectangle(image, (xmin, ymin), (xmax, ymax), (0, 255, 0), 2)\n\t\telse:\n\t\t\tcontinue\n\n\tprint(\"detected bbox num:\", bbox_num)\n\tSRC_PATH = os.path.realpath(__file__).rsplit(\"/\", 1)[0]\n\tOutput_PATH = os.path.join(SRC_PATH, \"../output/output.jpg\")\n\ttry:\n\t\tos.mkdir(os.path.join(SRC_PATH, \"../output/\"))\n\texcept Exception as e:\n\t\tprint(\"Output Path already exists\")\n\tcv2.imwrite(Output_PATH, image)","def score_aggregate(results):\n scores = []\n truth_count = detected_count = segment_count = 0\n\n for res in results:\n scores.append(res[\"scores\"])\n truth_count += len(res[\"labels\"])\n detected_count += len(res[\"detected\"])\n segment_count += len(res[\"scores\"][\"segments\"])\n\n ret = dict()\n ret[\"scores\"] = sum_scores(scores)\n ret[\"stats\"] = dict(truth_count=truth_count, detected_count=detected_count, segment_count=segment_count)\n return ret","def __getListOfActualOutput(imgFiles):\n actualList = []\n for f in imgFiles:\n actual = ocr.recognizeCharacters(f)\n actualList.append(actual)\n return actualList","def _get_detections(args, generator, model, score_threshold=0.05, max_detections=100, save_path=None):\n all_detections = [[None for i in range(generator.num_classes()) if generator.has_label(i)] for j in range(generator.size())]\n\n detection_out = np.zeros([generator.size(),512,512,3])\n # detection_out = np.zeros([generator.size(),512,512])\n attention_out = np.zeros([generator.size(),512,512])\n mask_out = np.zeros([generator.size(),512,512])\n\n for i in tqdm(range(generator.size()), desc='Running network: '):\n raw_image = generator.load_image(i)\n # image = np.expand_dims(raw_image.copy(), axis=-1)\n # image = np.repeat(image, 3, axis=-1)\n # image = generator.preprocess_image(image)\n image = generator.preprocess_image(raw_image.copy())\n image, scale = generator.resize_image(image)\n\n if keras.backend.image_data_format() == 'channels_first':\n image = image.transpose((2, 0, 1))\n\n # run network\n # boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))[:3]\n boxes, scores, labels, masks, attention_map = model.predict_on_batch(np.expand_dims(image, axis=0))\n # print('scores:', scores.shape)\n # print('labels',labels.shape)\n\n # correct boxes for image scale\n boxes /= scale\n\n # select indices which have a score above the threshold\n indices = np.where(scores[0, :] > score_threshold)[0]\n # print('indices', indices)\n scores = scores.numpy()\n boxes = boxes.numpy()\n labels = labels.numpy()\n masks = masks.numpy()\n attention_map = attention_map.numpy()\n # select those scores\n scores = scores[0][indices]\n\n # find the order with which to sort the scores\n scores_sort = np.argsort(-scores)[:max_detections]\n # print(scores_sort)\n\n # select detections\n image_boxes = boxes[0, indices[scores_sort], :]\n image_scores = scores[scores_sort]\n image_labels = labels[0, indices[scores_sort]]\n image_detections = np.concatenate([image_boxes, np.expand_dims(image_scores, axis=1), np.expand_dims(image_labels, axis=1)], axis=1)\n\n if save_path is not None:\n draw_annotations(raw_image, generator.load_annotations(i), label_to_name=generator.label_to_name)\n draw_detections(raw_image, image_boxes, image_scores, image_labels, score_threshold=args.detection_threshold, label_to_name=generator.label_to_name)\n\n\n detection_out[i, :, :] = raw_image\n\n attention_map[np.where(attention_map < args.attention_threshold)] = 0\n # attention_out[i, :, :] = cv2.flip( cv2.resize(np.squeeze(np.uint8(attention_map * 255)), (origin_shape[1], origin_shape[0])), 0)\n attention_out[i, :, :] = cv2.resize(np.squeeze(np.uint8(attention_map * 255)), (512, 512))\n\n masks[masks < args.segmentation_threshold] = 0\n masks = cv2.resize(np.squeeze(np.uint8(masks * 255)), (512, 512))\n\n mask_out[i, :, :] = masks\n\n # copy detections to all_detections\n for label in range(generator.num_classes()):\n if not generator.has_label(label):\n continue\n\n all_detections[i][label] = image_detections[image_detections[:, -1] == label, :-1]\n if save_path is not None:\n detection_out = sitk.GetImageFromArray(detection_out)\n sitk.WriteImage(detection_out, os.path.join(save_path, 'detection_result.nii.gz'))\n\n attention_out = sitk.GetImageFromArray(attention_out)\n sitk.WriteImage(attention_out, os.path.join(save_path, 'attention_result.nii.gz'))\n\n mask_out = sitk.GetImageFromArray(mask_out)\n sitk.WriteImage(mask_out, os.path.join(save_path, 'masks_result.nii.gz'))\n\n return all_detections","def print_scores(result_collector):\n # print(\"\\n# Metric: Cohen's kappa\")\n # result_collector.set_metric(['k_cohen', 'k'])\n # result_collector.print_all_results()\n print(\"\\n# Metric: Macro avg. F1\")\n result_collector.set_metric([\"macro_avg\", \"fscore\"])\n # result_collector.print_all_results()\n result_collector.print_result_for_level(\"cc\")\n result_collector.print_result_for_level(\"ro\", print_header=False)\n result_collector.print_result_for_level(\"fu\", print_header=False)\n result_collector.print_result_for_level(\"at\", print_header=False)\n\n # print(\"\\nMetric: Positive attachment F1\")\n # result_collector.set_metric(['classwise', '1', 'fscore'])\n # result_collector.print_result_for_level('at')\n print(\"\\n# Metric: Labelled attachment score\")\n result_collector.set_metric([\"accuracy\"])\n result_collector.print_result_for_level(\"lat\")","def save_results(self, save_data, score=None, data_name='none'):\n img_paths = self.get_image_paths()\n\n for i in range(save_data.size(0)):\n print('process image ...... %s' % img_paths[i])\n short_path = ntpath.basename(img_paths[i]) # get image path\n name = os.path.splitext(short_path)[0]\n if type(score) == type(None):\n img_name = '%s_%s.png' % (name, data_name)\n else:\n # d_score = score[i].mean()\n # img_name = '%s_%s_%s.png' % (name, data_name, str(round(d_score.item(), 3)))\n img_name = '%s_%s_%s.png' % (name, data_name, str(score))\n # save predicted image with discriminator score\n util.mkdir(self.opt.results_dir)\n img_path = os.path.join(self.opt.results_dir, img_name)\n img_numpy = util.tensor2im(save_data[i].data)\n util.save_image(img_numpy, img_path)\n return img_path","def place_images(self, final_list, points):\n\t\tfor i in range(8): \n # Please change this (8) into a class-level variable --KOH\n\t\t\timage_object = final_list[i]\n#\t\tif type(image_object) == 'CorrectImage':\n#\t\t\t\tself.correct = [i, points[i]]\n\t\t\timage = pygame.image.load(image_object.file_path)\n # Why can't these be stored as a property of the class --KOH\n\t\t\timagerect = image.get_rect()\n\t\t\treimage = pygame.transform.scale(image, image_object.size)\n\t\t\tself.screen.blit(reimage, points[i])","def print_images_out_statistics(self):\n self._print_images_statistics(self._images_out_folder, self._pose_class_names)","def _get_images(self):\n raw_outputs = self.interface.get_data(self.target_charge,\n self.charge_deviation,\n n_samples=self.n_samples)\n\n # apply roi to images\n roi_images = []\n for i in range(self.n_samples):\n roi_images += [apply_roi(raw_outputs['raw_images'][i], raw_outputs['ROI'])]\n\n # process and identify blobs in image\n min_size = 100\n outputs = {}\n for ele in self.output_keys:\n outputs[ele] = []\n\n for i in range(len(roi_images)):\n processed_image_data = image_processing.process_and_fit(roi_images[i],\n min_size)\n\n for ele in self.output_keys:\n if ele == 'image_check':\n outputs[ele] += [image_processing.check_image(processed_image_data['binary_image'],\n processed_image_data['smoothed_image'])]\n elif ele == 'processed_images':\n outputs[ele] += [processed_image_data['smoothed_image']]\n else:\n outputs[ele] += [processed_image_data[ele]]\n\n for ele in self.output_keys:\n outputs[ele] = np.array(outputs[ele])\n\n # add in raw data\n outputs.update(raw_outputs)\n\n # if we need to, get averaged results\n if self.average_measurements:\n avg_keys = ['rms_x', 'rms_y', 'CX', 'CY', 'n_blobs', 'FWHMX', 'FWHMY', 'centroid_offset']\n for key in avg_keys:\n outputs[key] = np.nanmean(outputs[key])\n\n return outputs","def __getitem__(self, index):\n\n #get the image name \n image_names = self.image_names[index]\n\n #make single name a list\n if(type(image_names) is not list):\n image_names = [image_names]\n\n image_target_list = []\n for image_name in image_names:\n\n #build the path to the image and annotation file\n #see format tab on Get Data page on AVD dataset website\n if image_name[0] == '0':\n scene_type = 'Home'\n else:\n scene_type = 'Office'\n scene_name = scene_type + \"_\" + image_name[1:4] + \"_\" + image_name[4]\n \n #read the image and bounding boxes for this image\n #(doesn't get the movement pointers) \n img = (Image.open(os.path.join(self.root,scene_name, \n images_dir,image_name)))\n with open(os.path.join(self.root,scene_name,annotation_filename)) as f:\n annotations = json.load(f)\n target = annotations[image_name]['bounding_boxes'] \n \n #apply target transform\n if self.target_transform is not None:\n target = self.target_transform(target)\n\n #crop images for classification if flag is set\n if self.classification:\n img = np.asarray(img)\n images = []\n ids = []\n for box in target:\n cur_img = Image.fromarray(img[box[1]:box[3],\n box[0]:box[2],\n :])\n if self.transform is not None:\n cur_img = self.transform(cur_img)\n images.append(cur_img)\n ids.append(box[4])\n\n img = images\n target = ids\n \n #apply image transform \n if self.transform is not None:\n img = self.transform(img)\n\n image_target_list.append([img,target])\n\n #special case for single image/label\n if(len(image_target_list) == 1):\n image_target_list = image_target_list[0]\n\n return image_target_list","def detect_objects(self, image):\n preprocessed_image = self._preprocess_image(image)\n\n # Feed the input image to the model\n self._set_input_tensor(preprocessed_image)\n self._interpreter.invoke()\n\n # Get all outputs from the model\n boxes = self._get_output_tensor(0)\n classes = self._get_output_tensor(1)\n scores = self._get_output_tensor(2)\n count = int(self._get_output_tensor(3))\n\n results = []\n for i in range(count):\n if scores[i] >= self.THRESHOLD:\n result = {\n 'bounding_box': boxes[i],\n 'class_id': classes[i],\n 'score': scores[i]\n }\n results.append(result)\n return results","def load_images(self, target = \"standard\", path=OMNIGLOT_DATAPATH):\n X = []\n Y = []\n folderName = {}\n if target == \"standard\":\n trainFolders = [\"images_background\"]\n testFolders = [\"images_evaluation\"]\n elif target == \"minimal\":\n trainFolders = [\"images_background_small1\", \"images_background_small2\"]\n testFolders = [\"images_evaluation\"]\n \n if self.train:\n for trainFolder in trainFolders:\n folderPath = os.path.join(path, trainFolder)\n imgAllCount = 0 # this is counted for the whole images in all alphabet\n chaAllCount = 0 # this is counted for the whole characters in all alphabet\n\n for alphabet in sorted(os.listdir(folderPath)):\n alphabetPath = os.path.join(folderPath, alphabet)\n folderName[alphabet] = {'totalChar': 0, 'charIndex': [], 'totalImg': 0, 'imgIndex': []}\n \n imgAlphabetCount = 0 # this is counted for the number of images in this alphabet\n chaAlphabetCount = 0 # this is counted for the number of character in this alphabet\n\n folderName[alphabet]['charIndex'].append(chaAllCount)\n folderName[alphabet]['imgIndex'].append(imgAllCount)\n \n for letter in sorted(os.listdir(alphabetPath)):\n letterPath = os.path.join(alphabetPath, letter)\n \n for letterImage in os.listdir(letterPath):\n imagePath = os.path.join(letterPath, letterImage)\n image = mpimg.imread(imagePath)\n X.append(image)\n Y.append(chaAllCount)\n \n imgAlphabetCount += 1\n imgAllCount += 1\n\n chaAlphabetCount += 1\n chaAllCount += 1\n \n folderName[alphabet]['totalChar'] = chaAlphabetCount\n folderName[alphabet]['totalImg'] = imgAlphabetCount\n folderName[alphabet]['charIndex'].append(chaAllCount-1)\n folderName[alphabet]['imgIndex'].append(imgAllCount-1)\n \n X = np.stack(X) \n X = X.reshape(-1, IMAGES_PER_CHARACTER, X.shape[1], X.shape[2])\n return X, np.stack(Y), folderName","def detect_objects(interpreter, image):\n set_input_tensor(interpreter, image)\n interpreter.invoke()\n\n # Get all output details\n #boxes = get_output_tensor(interpreter, 0)\n classes = get_output_tensor(interpreter, 1)\n scores = get_output_tensor(interpreter, 2)\n #count = int(get_output_tensor(interpreter, 3))\n\n #results = []\n #for i in range(count):\n # if scores[i] >= threshold:\n # result = {\n # #'bounding_box': boxes[i],\n # 'class_id': classes[i],\n # 'score': scores[i]\n # }\n # results.append(result)\n \n \n #print(\"detection results:\\n\" + str(results))\n #return results\n return np.array([int(_class) for _class in classes]), np.array(scores)","def results_aggregator(self, names):\n\t\tfor name in names:\n\t\t\tresult = self.main(name)\n\t\t\tself.results.append(result)\n\t\t\tprint(\"'%s' has been written to the file.\" % result[0])\n\t\t\t\"\"\"result is formatted name, number, rating, review count\"\"\"","def get_images(image_folder_root, image_label_list):\n file_dcm=[]\n X = []\n y = []\n for file_name,label in image_label_list:\n try:\n current_file = pydicom.dcmread(image_folder_root + file_name + '.dcm')\n pixel_array = current_file.pixel_array\n if (pixel_array.shape != (512,512)):\n continue\n file_dcm.append((file_name,label,brain_window(current_file)))\n y.append(label)\n X.append(pydicom.dcmread(image_folder_root + file_name + '.dcm').pixel_array)\n except ValueError:\n continue\n return X,y","def get_img_list(self):\n if self.list_flag == \"train\":\n self.img_list_all = [line.rstrip('\\n') for line in open(os.path.join(self.dataset_dir, 'Image_sets/car_imagenet_' + self.list_flag + '.txt'))]\n print(\"Number of Train image: %d.\" % len(self.img_list_all))\n\n elif self.list_flag == \"val\":\n self.img_list_all = [line.rstrip('\\n') for line in open(os.path.join(self.dataset_dir, 'Image_sets/car_imagenet_' + self.list_flag + '.txt'))]\n print(\"Number of val image: %d.\" % len(self.img_list_all))\n\n return self.img_list_all","def analyze_results(results): #, result_nonprivate):\n res_dimensions = zip(*results)\n mean, std = [], []\n \n for resdim in res_dimensions:\n mean.append ( numpy.average(resdim) )\n std.append ( numpy.std(resdim) )\n\n return mean, std","def evaluate(self, test_data):\n test_results = [(self.decide(self.feedforward(x)), y)\n for (x, y) in test_data]\n\n # Check for and keep track of TP's FP's and FN's\n # Write FP's and FN's to a special directories\n TP = FP = FN = count = 0\n TN = 0\n # what you got = x, what should be = y\n for ((x, y), (image, gt)) in zip(test_results, test_data):\n count += 1\n if x == 1 and y == 1:\n TP += 1\n elif x == 1 and y == 0:\n FP += 1\n if not self.validating: self.save_Image(FP_PATH, count, image)\n elif x == 0 and y == 1:\n FN += 1\n if not self.validating: self.save_Image(FN_PATH, count, image)\n \n if (TP + FP ) == 0:\n return TP, FP, FN, '---------', '---------','---------'\n else:\n false_rate = float(FP) / float(TP + FP)\n\n if (TP + FN ) == 0:\n return TP, FP, FN, '---------', '---------', false_rate\n else:\n detect_rate = float(TP) / float(TP + FN)\n\n if (TP + FP + FN ) == 0:\n return TP, FP, FN, '---------', detect_rate, false_rate\n else:\n quality_rate = float(TP) / float(TP+FP+FN)\n \n return TP, FP, FN, quality_rate, detect_rate, false_rate","def transform(self, imgList):\n res = []\n for img in tqdm(imgList):\n y_mean = np.mean(img, axis=1)\n self.get_filtration(y_mean)\n seg = self.get_segments()\n seg = sorted(seg, key=lambda x:x[0])\n res.append(seg)\n return res","def get_results(nres, pres):\n # for the average accuracy at the end\n tot_acc = 0.0\n\n # for each iteration display the results\n for i in range(3):\n\n accuracy = float(nres[i][2]+pres[i][2]) / (nres[i][0]+pres[i][0])\n tot_acc += accuracy\n\n print \"iteration %d\" % (i+1)\n print \"num_neg_test_docs: %d\" % nres[i][0]\n print \"num_neg_training_docs: %d\" % nres[i][1]\n print \"num_neg_correct_docs: %d\" % nres[i][2]\n print \"num_pos_test_docs: %d\" % pres[i][0]\n print \"num_pos_training_docs: %d\" % pres[i][1]\n print \"num_pos_correct_docs: %d\" % pres[i][2]\n print \"accuracy: \", \"{:.2%}\".format(accuracy)\n print \"---------------------------------\"\n\n ave_acc = tot_acc / 3.0\n print \"ave_accuracy: \", \"{:.2%}\".format(ave_acc)","def explore_data():\n labels = [\"vehicles\", \"non-vehicles\"]\n labelmap = {0: \"vehicles\", 1: \"non-vehicles\"}\n vehicles_glob = os.path.join(data_dir, \"vehicles\", \"**\", \"*.png\")\n nonvehicles_glob = os.path.join(data_dir, \"non-vehicles\", \"**\", \"*.png\")\n class_fnames = [\n glob.glob(vehicles_glob, recursive = True),\n glob.glob(nonvehicles_glob, recursive = True)]\n n_samples = [len(fnames) for fnames in class_fnames]\n shapes = []\n samples = []\n print(table_format([\"label\", \"size\", \"shape\"], header = True))\n for label, fnames in enumerate(class_fnames):\n indices = np.random.choice(len(fnames), 4*10, replace = False)\n for i in indices:\n fname = fnames[i]\n img = cv2.imread(fname)\n samples.append(img)\n shape = img.shape\n shapes.append(shape)\n print(table_format([labels[label], n_samples[label], shapes[label]]))\n\n samples = np.stack(samples)\n samples = tile(samples, 2*4, 10)\n cv2.imwrite(os.path.join(out_dir, \"datasamples.png\"), samples)\n\n return class_fnames, labelmap","def test(self, C, W, sigma, label_list, H_list):\n\n for a_dir_test in os.listdir(self.path_test_dir):\n\n num_data, data_array = self.exfile_manager.get_data(os.path.join(self.path_test_dir, a_dir_test))\n estimated_labels = self.post_process_manager.estimate_data_category(C, W, sigma, label_list, H_list,\n data_array)\n for (index, data), estimated_label in zip(enumerate(data_array), estimated_labels):\n path_to_file = os.path.join(self.dir_for_saving_result, '%s_%d.jpg' % (a_dir_test, index))\n\n data = (data / np.max(data)) * 255\n\n Image.fromarray(np.uint8(\n (np.reshape(data, (self.width, self.height))))).save(\n path_to_file)\n self.line_ui_manager.send_line(\n 'RBM: %s\\nTRUE: %s\\n' % (estimated_label, a_dir_test,),\n path_to_file)","def compute_scores(self):\n if self.num_classes == 2:\n score_1 = self.competition_metric(\n helmet_threshold=0.5,\n impact_threshold=0.5,\n )[1]\n\n score_2 = self.competition_metric(\n helmet_threshold=0.5,\n impact_threshold_ratio=0.5,\n )[1]\n\n score_3 = self.competition_metric(\n impact_threshold=0.5,\n )[1]\n else:\n score_1 = self.detection_metric(threshold=0.1)\n score_2 = self.detection_metric(threshold=0.25)\n score_3 = self.detection_metric(threshold=0.5)\n\n return score_1, score_2, score_3","def get_list(self):\n for match in self.matches:\n img_pixel = [int(self.featureA[match.queryIdx].pt[0]), int(self.featureA[match.queryIdx].pt[1])]\n depth = aligned_depth_frame.get_distance(img_pixel[0], img_pixel[1])\n point_a = rs.rs2_deproject_pixel_to_point(self.intrin, img_pixel, depth)\n point_a = [point_a[0], point_a[2], 1]\n img_pixel = [int(self.featureB[match.trainIdx].pt[0]), int(self.featureB[match.trainIdx].pt[1])]\n depth = aligned_depth_frame.get_distance(img_pixel[0], img_pixel[1])\n point_b = rs.rs2_deproject_pixel_to_point(self.intrin, img_pixel, depth)\n point_b = [point_b[0], point_b[2], 1]\n self.listA.append(point_a)\n self.listB.append(point_b)","def __call__(self, results):\r\n if isinstance(results['img'], str):\r\n results['filename'] = results['img']\r\n results['ori_filename'] = results['img']\r\n else:\r\n results['filename'] = None\r\n results['ori_filename'] = None\r\n img = mmcv.imread(results['img'])\r\n results['img'] = img\r\n results['img_fields'] = ['img']\r\n results['img_shape'] = img.shape\r\n results['ori_shape'] = img.shape\r\n return results","def inception_score(images):\n height, width = 90, 90\n\n images = np.array([np.array(Image.fromarray(x, mode=\"RGB\").resize((height, width))) for x in np.reshape(images, (-1, 28, 28, 3))]) / 255. # Transform images to a suitable form\n\n with loaded_model[0].as_default():\n predictions = loaded_model[1].predict(images)\n preds = np.argmax(predictions, axis=1)\n aux_preds = np.zeros(10)\n unique, counts = np.unique(preds, return_counts=True)\n for number, appearances in zip(unique, counts):\n aux_preds[number] = appearances\n aux_preds = aux_preds / predictions.shape[0]\n predictions = np.sort(predictions, axis=1)\n predictions = np.mean(predictions, axis=0)\n\n sam_error = np.sum([aux_preds[w] * np.log(aux_preds[w] / predictions[w]) if aux_preds[w] > 0 else 0 for w in range(predictions.shape[0])])\n\n return sam_error","def load_labeled_data():\n\n images = []\n labels = []\n\n for i in range(1, 10):\n path = (\"selflabeled\", str(i), \"*.jpg\")\n filenames = glob.glob(\"/\".join(path))\n images_one_type = [cv2.imread(img) for img in filenames]\n labels_one_type = [i] * len(images_one_type)\n images += images_one_type\n labels += labels_one_type\n\n return images, labels","def load_defects(self, val_dir):\n \n img_list_1 = os.listdir(val_dir+'/'+'1')\n img_list_2 = os.listdir(val_dir+'/'+'2')\n img_list_3 = os.listdir(val_dir+'/'+'3')\n img_list_4 = os.listdir(val_dir+'/'+'4')\n\n\n\n img_list_1 = self.make_imgs_list(val_dir + '/' + '1', img_list_1)\n img_list_2 = self.make_imgs_list(val_dir + '/' + '2', img_list_2)\n img_list_3 = self.make_imgs_list(val_dir + '/' + '3', img_list_3)\n img_list_4 = self.make_imgs_list(val_dir + '/' + '4', img_list_4)\n\n\n img_list_1 = self.load_imgsLabels(img_list_1)\n img_list_2 = self.load_imgsLabels(img_list_2)\n img_list_3 = self.load_imgsLabels(img_list_3)\n img_list_4 = self.load_imgsLabels(img_list_4)\n\n\n img_list_1 = self.features_to_np_array(img_list_1)\n img_list_2 = self.features_to_np_array(img_list_2)\n img_list_3 = self.features_to_np_array(img_list_3)\n img_list_4 = self.features_to_np_array(img_list_4)\n\n lbl_list_1 = img_list_1.shape[0]*[1]\n lbl_list_2 = img_list_2.shape[0]*[2]\n lbl_list_3 = img_list_3.shape[0]*[3]\n lbl_list_4 = img_list_4.shape[0]*[4]\n\n\n imgs = np.concatenate((img_list_1, img_list_2, img_list_3, img_list_4))\n lbls = lbl_list_1 + lbl_list_2 + lbl_list_3 + lbl_list_4\n\n\n lbls = np.array(lbls)\n \n lbls = lbls - 1\n \n lbls = to_categorical(lbls)\n \n return imgs, lbls","def display_imgs(img_dir,img_list):\n for img in img_list:\n display_img(img_dir, img)","def stim_generate(params,stim_list,train):\n if train:\n stim = list(stim_list.keys())\n shuffled_stim = shuffled_images = []\n #for each run get equal amounts of stim and shuffle\n #can only work if 'trials_per_run' is divisible by number of stims\n for run in range(params['runs']):\n temp_list = stim * int(params['trials_per_run']/len(stim))\n random.shuffle(temp_list)\n shuffled_stim = shuffled_stim + temp_list\n for stim in shuffled_stim:\n shuffled_images.append(stim_list[stim])\n else:\n #open the test stim images\n images = []\n for each in os.listdir(stim_list):\n if '.DS_Store' not in each:\n img = os.path.join(stim_list,each)\n images.append([img,img])\n\n #randomize images\n random.shuffle(images)\n\n #split images into matches and not matches\n matches,not_matches = images[:len(images)//2],images[len(images)//2:]\n\n #shift the image list so that the pictures dont match\n not_matches = shift_list(not_matches)\n\n #combine matches and not matches and randomize order\n shuffled_images = matches + not_matches\n random.shuffle(shuffled_images)\n\n #get category labels\n shuffled_stim = []\n for img in shuffled_images:\n if img[0] == img[1]:\n shuffled_stim.append(\"match\")\n else:\n shuffled_stim.append(\"not match\")\n\n return(shuffled_stim,shuffled_images)","def get_all_image_names(self):\n\n # for RD analysis ...\n\n result = []\n for sweep in self._sweeps:\n result.extend(sweep.get_all_image_names())\n return result","def getImgList(id_classe):\n f=open('csv_files/test-annotations-bbox.csv',\"r\",encoding='utf8')\n img_list0 = []\n img_list = []\n a = 0\n nb_img = parser_arguments().limit\n for l in f:\n if id_classe in l:\n mots = l.split(\",\")\n id_img = mots[0]\n img_list0.append(id_img)\n # lists all the identifiers of the images present in the requested class\n\n while a < nb_img:\n img_list.append(random.choice(img_list0))\n a = a+1\n return img_list\n # select randomly in the previous list the required number (requested in the terminal) of image identifiers and store them in a new list","def compute_score(self, gts, res):\n\n assert(gts.keys() == res.keys())\n imgIds = gts.keys()\n\n cider_scorer = CiderScorer(n=self._n, sigma=self._sigma, \n document_frequency=self._doucument_frequency, \n ref_len=self._ref_len)\n\n for id in imgIds:\n hypo = res[id]\n ref = gts[id]\n\n # Sanity check.\n assert(type(hypo) is list)\n assert(len(hypo) == 1)\n assert(type(ref) is list)\n assert(len(ref) > 0)\n\n cider_scorer += (hypo[0], ref)\n\n (score, scores) = cider_scorer.compute_score()\n\n return score, scores","def __getitem__(self, index):\n\n #get the image name and box\n #image_name,box_index = self.name_and_box_index[index]\n name_and_index = self.name_and_box_index[index]\n #name_and_index needs to be alist of lists\n if(len(name_and_index) >0 and type(name_and_index[0]) is not list): \n name_and_index = [name_and_index] \n \n image_target_list = []\n\n for image_name,box_index in name_and_index:\n #build the path to the image and annotation file\n #see format tab on Get Data page on AVD dataset website\n if image_name[0] == '0':\n scene_type = 'Home'\n else:\n scene_type = 'Office'\n scene_name = scene_type + \"_\" + image_name[1:4] + \"_\" + image_name[4]\n \n #read the image and bounding boxes for this image\n #(doesn't get the movement pointers) \n img = (Image.open(os.path.join(self.root,scene_name, \n images_dir,image_name)))\n with open(os.path.join(self.root,scene_name,annotation_filename)) as f:\n annotations = json.load(f)\n target = annotations[image_name]['bounding_boxes'] \n \n #apply target transform\n if self.target_transform is not None:\n target = self.target_transform(target)\n\n #get the single box\n target = target[box_index]\n\n #crop images for classification if flag is set\n if self.classification:\n img = np.asarray(img)\n img = img[target[1]:target[3],target[0]:target[2],:]\n img = Image.fromarray(img)\n target = target[4] \n \n \n #apply image transform \n if self.transform is not None:\n img = self.transform(img)\n\n image_target_list.append([img,target])\n\n #special case for single image/label\n if(len(image_target_list) == 1):\n image_target_list = image_target_list[0]\n\n return image_target_list","def _yield_testing(self, batch_index):\n samples_start = batch_index % self.num_samples\n samples_end = (batch_index+1) % self.num_samples\n if samples_start < samples_end:\n batch_samples = self.test_data[samples_start:samples_end]\n else:\n batch_samples = self.test_data[samples_start:]\n batch_samples.extend(self.test_data[:samples_end])\n images = []\n rois = []\n for sample in batch_samples:\n # 'sample' has this structure:\n # {path: {\n # 'roi_origin_x': test_sample[1]['roi_origin_x'],\n # 'roi_origin_y': test_sample[1]['roi_origin_y'],\n # 'roi_width': test_sample[1]['roi_width'],\n # 'roi_height': test_sample[1]['roi_height'] \n # } \n # }\n img_path = os.path.join(self.dataset_root_path, list(sample.keys())[0])\n img = cv2.imread(img_path) # watch out for slashes (/)\n # if the path does not exist or there are problems while reading the image\n if img is None:\n print('[DATA LOADER ERROR] cannot find image at path: ', img_path)\n continue\n roi_data = list(sample.values())[0]\n roi = {\n 'upper_left_x': roi_data['roi_origin_x'],\n 'upper_left_y': roi_data['roi_origin_y'],\n 'width': roi_data['roi_width'],\n 'height': roi_data['roi_height']\n }\n img = img.astype('float32')\n images.append(img)\n rois.append(roi)\n return images, rois","def translate_images(estimator, test_images_list, label, checkpoint_path, num_domains):\n img_rows = []\n\n def test_input_fn():\n dataset_lbls = [tf.one_hot([label], num_domains)] * len(test_images_list)\n\n # Make into a dataset.\n dataset_imgs = np.stack(test_images_list)\n dataset_imgs = np.expand_dims(dataset_imgs, 1)\n dataset_lbls = tf.stack(dataset_lbls)\n unused_tensor = tf.zeros(len(test_images_list))\n return tf.data.Dataset.from_tensor_slices(((dataset_imgs, dataset_lbls),\n unused_tensor))\n\n prediction_iterable = estimator.predict(test_input_fn, checkpoint_path=checkpoint_path)\n predictions = [next(prediction_iterable) for _ in range(len(test_images_list))] # range(len(test_images_list))]\n normalized_summary = [(result + 1.0) / 2.0 for result in predictions]\n return normalized_summary","def classify_images():\n\n # Load the desired image\n img_path = 'dataset/colorize_images/n02085782_919.jpg'\n img = image.load_img(img_path, target_size=(299, 299))\n x = image.img_to_array(img)\n x = np.expand_dims(x, axis=0)\n x = preprocess_input(x)\n\n model = InceptionV3(weights=\"imagenet\")\n preds = model.predict(x)\n # decode the results into a list of tuples (class, description, probability)\n # (one such list for each sample in the batch)\n print('Predicted:', decode_predictions(preds, top=3)[0])","def classify_all_images(cc):\n print 'Classify images'\n images = cc.d.images\n for img_idx in range(comm_rank, len(images), comm_size): # PARALLEL\n print 'classify image %d/%d at %d'%(img_idx/comm_size, len(images)/comm_size, comm_rank)\n img = images[img_idx]\n scores = classify_image(cc, img_idx)\n savefile = config.get_classifier_score_name(img, cc.L)\n cPickle.dump(scores, open(savefile,'w'))","def report_result(args, model, imgs, poses, hwf, bound):\n ray_origins, ray_directions = get_rays_shapenet(hwf, poses)\n\n view_psnrs = []\n for img, rays_o, rays_d in zip(imgs, ray_origins, ray_directions):\n rays_o, rays_d = rays_o.reshape(-1, 3), rays_d.reshape(-1, 3)\n t_vals, xyz = sample_points(rays_o, rays_d, bound[0], bound[1],\n args.num_samples, perturb=False)\n \n synth = []\n num_rays = rays_d.shape[0]\n with torch.no_grad():\n for i in range(0, num_rays, args.test_batchsize):\n rgbs_batch, sigmas_batch = model(xyz[i:i+args.test_batchsize])\n color_batch = volume_render(rgbs_batch, sigmas_batch,\n t_vals[i:i+args.test_batchsize],\n white_bkgd=True)\n synth.append(color_batch)\n synth = torch.cat(synth, dim=0).reshape_as(img)\n error = F.mse_loss(img, synth)\n psnr = -10*torch.log10(error)\n view_psnrs.append(psnr)\n \n scene_psnr = torch.stack(view_psnrs).mean()\n return scene_psnr","def returnImages(input_data):\r\n if type(input_data) is list:\r\n return [returnImages(element) for element in input_data]\r\n else:\r\n return cv.imread(input_data, 0)","def parse(self):\n imset = []\n imdir = remkdir(os.path.join(self._datadir, 'images'))\n csv_actors = readcsv(os.path.join(self._datadir, 'facescrub_actors.txt'), separator='\\t')\n for (subjectname, imageid, faceid, url, bbox, sha256) in csv_actors[1:]:\n categoryname = subjectname.replace(' ', '_')\n (xmin,ymin,xmax,ymax) = bbox.split(',')\n imset.append(ImageDetection(url=url, filename=os.path.join(imdir, '%s_%s.jpg' % (categoryname, imageid)), category=categoryname, xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax, attributes={'GENDER':'male'}))\n\n csv_actresses = readcsv(os.path.join(self._datadir, 'facescrub_actresses.txt'), separator='\\t')\n for (subjectname, imageid, faceid, url, bbox, sha256) in csv_actresses[1:]:\n categoryname = subjectname.replace(' ', '_')\n (xmin,ymin,xmax,ymax) = bbox.split(',')\n imset.append(ImageDetection(url=url, filename=os.path.join(imdir, '%s_%s.jpg' % (categoryname, imageid)), category=categoryname, xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax, attributes={'GENDER':'female'}))\n\n return imset"],"string":"[\n \"def yolo_show(image_path_list, batch_list):\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n for img_path, batch in zip(image_path_list, batch_list):\\n result_list = batch.tolist()\\n img = cv2.imread(img_path)\\n for result in result_list:\\n cls = int(result[0])\\n bbox = result[1:-1]\\n score = result[-1]\\n print('img_file:', img_path)\\n print('cls:', cls)\\n print('bbox:', bbox)\\n c = ((int(bbox[0]) + int(bbox[2])) / 2, (int(bbox[1] + int(bbox[3])) / 2))\\n cv2.rectangle(img, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), (0, 255, 255), 1)\\n cv2.putText(img, str(cls), (int(c[0]), int(c[1])), font, 1, (0, 0, 255), 1)\\n result_name = img_path.split('/')[-1]\\n cv2.imwrite(\\\"constant/results/\\\" + result_name, img)\",\n \"def painting_matching_ml(imgs, db_imgs, method_list, text_masks, author_text, gt_text, metrics, weights, splits=30, max_rank=10):\\n descriptor_extractors = [get_descriptor_extractor(method_name) for method_name in method_list]\\n tmp_img_format = []\\n tmp_mask_format = []\\n tmp_text_format = []\\n for i in range(len(imgs)):\\n for j in range(len(imgs[i])):\\n tmp_img_format.append(imgs[i][j])\\n tmp_mask_format.append(text_masks[i][j])\\n tmp_text_format.append(author_text[i][j])\\n\\n #db_imgs = [img[0] for img in db_imgs]\\n db_img_splits = [i*len(db_imgs)//splits for i in range(splits-1)]\\n \\n scores = []\\n query_descriptors = extract_descriptors(tmp_img_format, descriptor_extractors, method_list, tmp_text_format, tmp_mask_format) \\n #np.array([extract_descriptors(img, matching_methods, mask) for img, mask in zip(tmp_img_format, tmp_mask_format)])\\n print(\\\"Starting db extraction + matching\\\")\\n for split in tqdm(range(splits-2)):\\n db_descriptors = extract_descriptors(db_imgs[db_img_splits[split]:db_img_splits[split+1]], descriptor_extractors, method_list, gt_text[db_img_splits[split]:db_img_splits[split+1]], None) #np.array([mrhm(db_img) for db_img in db_imgs[db_img_splits[split]:db_img_splits[split+1]]])\\n scores.append(compare_descriptors(query_descriptors, db_descriptors, metrics, method_list, weights))\\n # compare_descriptors(query_descriptors, db_descriptors, descriptor_comp_methods, descriptor_names, weights)\\n db_descriptors = extract_descriptors(db_imgs[db_img_splits[-1]:], descriptor_extractors, method_list, gt_text[db_img_splits[-1]:], None)\\n scores.append(compare_descriptors(query_descriptors, db_descriptors, metrics, method_list, weights))\\n \\n # concatenate all the results\\n scores = np.concatenate(scores, 1)\\n \\n top_k_matches = np.argpartition(scores, list(range(max_rank)))[:, :max_rank]\\n return top_k_matches\",\n \"def generate_results(img_name, note_names, note_durations):\\n construct_output(indent_level=\\\"block\\\",\\n message=\\\"Matching the elements of the image ({}) with the values given by the networks.\\\"\\n .format(img_name))\\n\\n results = [] # A list that will be returned.\\n\\n # Path that contains the information about the original image.\\n image_path = os.path.abspath(os.path.join(str(Path(__file__).parent.parent.parent), 'resources', 'input_images'))\\n image_path = os.path.join(image_path, 'input_images_individual_elements')\\n image_path = os.path.join(image_path, img_name[:-4])\\n\\n # Find all the unrecognized elements and their names.\\n unrecognized_elements_path = os.path.join(image_path, \\\"unrecognized\\\")\\n unrecognized_elements = os.listdir(unrecognized_elements_path)\\n\\n results_and_positions = []\\n for el in unrecognized_elements:\\n row_number = el[(el.index(\\\"_row\\\") + len(\\\"_row\\\")):(el.index(\\\"_slice\\\"))]\\n el_number = el[(el.index(\\\"slice\\\") + len(\\\"slice\\\")):]\\n el_number = el_number[:el_number.index(\\\"_\\\")]\\n results_and_positions.append((el, row_number, el_number))\\n results_and_positions.sort(key=lambda k: (int(k[1]), int(k[2])))\\n if len(note_names) != len(note_durations) != len(unrecognized_elements):\\n print(\\\"generator.py = Not enough elements were recognized!\\\")\\n\\n for index, el in enumerate(results_and_positions):\\n el = el[0]\\n if el.endswith(\\\".png\\\"):\\n results.append((el[len(\\\"img02_\\\"):-len(\\\".png\\\")], note_names[index], note_durations[index]))\\n\\n # Find all the recognized elements and their names.\\n recognized_elements_path = os.path.join(image_path, \\\"recognized\\\", img_name[:-4] + \\\".txt\\\")\\n\\n with open(recognized_elements_path, 'r') as file:\\n recognized_elements = file.readlines()\\n if len(recognized_elements) == 0:\\n print(\\\"generator.py = Error in reading image file info!\\\")\\n exit(-1)\\n for index, content in enumerate(recognized_elements):\\n if content.endswith(\\\"\\\\n\\\"):\\n recognized_elements[index] = content[:-1]\\n for index, el in enumerate(recognized_elements):\\n el_name = el[(el.find(\\\"template_\\\") + len(\\\"template_\\\")):el.find(\\\".png\\\")]\\n if el_name.startswith(\\\"Z_barline\\\"):\\n el_name = \\\"barline\\\"\\n results.append((el[len(\\\"img02_\\\"):-len(\\\".png\\\")], el_name, \\\"-\\\"))\\n\\n # Join the individual elements with their descriptions.\\n results_and_positions = []\\n for result in results:\\n x = result[0]\\n row_number = x[(x.index(\\\"row\\\") + len(\\\"row\\\")):x.index(\\\"_slice\\\")]\\n el_number = x[(x.index(\\\"slice\\\") + len(\\\"slice\\\")):]\\n el_number = el_number[:el_number.index(\\\"_\\\")]\\n results_and_positions.append((result, row_number, el_number))\\n\\n # Sort the elements with the order found in the original image.\\n results_and_positions.sort(key=lambda k: (int(k[1]), int(k[2])))\\n\\n results = []\\n for x in results_and_positions:\\n results.append(x[0])\\n\\n construct_output(indent_level=\\\"block\\\",\\n message=\\\"Results generated.\\\"\\n .format(img_name))\\n\\n return results\",\n \"def calculate_score(label_dict, queries, results):\\n\\n total_score = 0.0\\n\\n log_header('Individual image scores')\\n\\n # Calculate score for all images\\n for image_id in queries:\\n if image_id in results.keys():\\n # Run the score function\\n image_score = score(\\n label_dict=label_dict, target=image_id, selection=results[image_id]\\n )\\n else:\\n logging.error('No result generated for %s' % image_id)\\n\\n image_score = 0.0\\n\\n total_score += image_score\\n\\n logging.info('%s: %8.6f' % (image_id, image_score))\\n\\n log_header('Average score over %d images: %10.8f' % (\\n len(queries), total_score / len(queries)\\n ))\\n\\n return total_score\",\n \"def get_results(self):\\n result = [round(self.mr / self.test_size, 1), round(self.mrr / self.test_size, 3),\\n round(self.hits1 / self.test_size, 3), round(self.hits3 / self.test_size, 3),\\n round(self.hits5 / self.test_size, 3), round(self.hits10 / self.test_size, 3)]\\n return result\",\n \"def getimgs():\",\n \"def get_all_results(pred_root, meta_results):\\r\\n results_all = {}\\r\\n for key in tqdm(meta_results, desc='Generating results ..'):\\r\\n persons = meta_results[key]\\r\\n\\r\\n global_seg = cv2.imread(pred_root + 'global_seg/{}.png'.format(key),\\r\\n cv2.IMREAD_UNCHANGED)\\r\\n global_tag = cv2.imread(pred_root + 'global_tag/{}.png'.format(key),\\r\\n cv2.IMREAD_UNCHANGED)\\r\\n\\r\\n results = {}\\r\\n dets, masks = [], []\\r\\n for p_id, score in persons:\\r\\n mask = (global_tag == p_id)\\r\\n if np.sum(mask) == 0:\\r\\n continue\\r\\n seg = mask * global_seg\\r\\n ys, xs = np.where(mask > 0)\\r\\n x1, y1, x2, y2 = xs.min(), ys.min(), xs.max(), ys.max()\\r\\n dets.append((x1, y1, x2, y2, score))\\r\\n masks.append(seg)\\r\\n\\r\\n # Reuiqred Field of each result: a list of masks,\\r\\n # each is a multi-class masks for one person.\\r\\n # It can also be sparsified to\\r\\n # [scipy.sparse.csr_matrix(mask) for mask in masks]\\r\\n # to save memory cost\\r\\n results['MASKS'] = masks if not Sparse \\\\\\r\\n else [scipy.sparse.csr_matrix(m) for m in masks]\\r\\n # Reuiqred Field of each result,\\r\\n # a list of detections corresponding to results['MASKS'].\\r\\n results['DETS'] = dets\\r\\n\\r\\n if cache_pkl:\\r\\n results_cache_add = cache_pkl_path + key + '.pklz'\\r\\n pickle.dump(results, gzip.open(results_cache_add, 'w'))\\r\\n results_all[key] = results_cache_add\\r\\n else:\\r\\n results_all[key] = results\\r\\n\\r\\n if PLOT:\\r\\n import pylab as plt\\r\\n plt.figure('seg')\\r\\n plt.imshow(global_seg)\\r\\n print('Seg unique:' + str(np.unique(global_seg)))\\r\\n plt.figure('tag')\\r\\n plt.imshow(global_tag)\\r\\n print('Tag unique:' + str(np.unique(global_tag)))\\r\\n plt.show()\\r\\n\\r\\n return results_all\",\n \"def get_score_and_geo(images, labels, data_iter_type='ImageDetIter'):\\n for i, image in enumerate(images):\\n height, width = image.shape[1], image.shape[2]\\n poly_mask = np.zeros((height, width), dtype=np.uint8)\\n score_map = np.zeros((images.shape[0], height, width), dtype=np.uint8)\\n geo_map = np.zeros((images.shape[0], height, width, 5), dtype=np.float32)\\n if data_iter_type == 'MXDataIter':\\n label = labels[i].asnumpy() # 1-D Array\\n label = np.delete(label, np.where(label == -1)) # Delete all -1 padding\\n c, h, w, label_width, header_length, bbox_label_width, orig_h, orig_w = label[:8]\\n polys = np.reshape(label[8:], (int(len(label[8:]) / bbox_label_width), -1)) # (Num_of_polys, bbox_label_width)\\n vocab_idx = polys[:, 1]\\n polys = polys[:, 1:]\\n\\n elif data_iter_type == 'ImageDetIter':\\n label = labels[i].asnumpy() # 1-D Array\\n polys = np.delete(label, np.where(label[:, 0] == -1), axis=0)\\n vocab_idx = polys[:, 1]\\n polys = polys[:, 1:]\\n\\n # For each polygon (bounding box) in the label\\n for poly in polys:\\n poly = np.reshape(poly, (4, 2))\\n poly[:, 0] = np.round(poly[:, 0] * height, 0)\\n poly[:, 1] = np.round(poly[:, 1] * width, 0)\\n\\n poly = np.array(poly).astype(np.int32)\\n # Draw polygon on the score mask (binary map)\\n cv2.fillPoly(score_map[i], [poly], (1))\\n # Draw polygon on the poly_mask (binary map) that will be used to create geo_map\\n cv2.fillPoly(poly_mask, [poly], (1))\\n\\n fitted_parallelograms = []\\n # For the number of sides (4) in the polygon\\n for j in range(4):\\n # Rotate the orientation at each iter\\n p0 = poly[j]\\n p1 = poly[(j + 1) % 4]\\n p2 = poly[(j + 2) % 4]\\n p3 = poly[(j + 3) % 4]\\n\\n edge = fit_line([p0[0], p1[0]], [p0[1], p1[1]])\\n if point_dist_to_line(p0, p1, p2) > point_dist_to_line(p0, p1, p3):\\n if edge[1] == 0:\\n edge_opposite = [1, 0, -p2[0]]\\n else:\\n edge_opposite = [edge[0], -1, p2[1] - edge[0] * p2[0]]\\n else:\\n if edge[1] == 0:\\n edge_opposite = [1, 0, -p3[0]]\\n else:\\n edge_opposite = [edge[0], -1, p3[1] - edge[0] * p3[0]]\\n\\n # move forward edge\\n new_p0 = p0\\n new_p1 = p1\\n new_p2 = p2\\n new_p3 = p3\\n forward_edge = fit_line([p1[0], p2[0]], [p1[1], p2[1]])\\n new_p2 = line_cross_point(forward_edge, edge_opposite)\\n if point_dist_to_line(p1, new_p2, p0) > point_dist_to_line(p1, new_p2, p3):\\n # across p0\\n if forward_edge[1] == 0:\\n forward_opposite = [1, 0, -p0[0]]\\n else:\\n forward_opposite = [forward_edge[0], -1, p0[1] - forward_edge[0] * p0[0]]\\n else:\\n # across p3\\n if forward_edge[1] == 0:\\n forward_opposite = [1, 0, -p3[0]]\\n else:\\n forward_opposite = [forward_edge[0], -1, p3[1] - forward_edge[0] * p3[0]]\\n new_p0 = line_cross_point(forward_opposite, edge)\\n new_p3 = line_cross_point(forward_opposite, edge_opposite)\\n fitted_parallelograms.append([new_p0, new_p1, new_p2, new_p3, new_p0])\\n\\n # or move backward edge\\n new_p0 = p0\\n new_p1 = p1\\n new_p2 = p2\\n new_p3 = p3\\n backward_edge = fit_line([p0[0], p3[0]], [p0[1], p3[1]])\\n new_p3 = line_cross_point(backward_edge, edge_opposite)\\n if point_dist_to_line(p0, p3, p1) > point_dist_to_line(p0, p3, p2):\\n # across p1\\n if backward_edge[1] == 0:\\n backward_opposite = [1, 0, -p1[0]]\\n else:\\n backward_opposite = [backward_edge[0], -1, p1[1] - backward_edge[0] * p1[0]]\\n else:\\n # across p2\\n if backward_edge[1] == 0:\\n backward_opposite = [1, 0, -p2[0]]\\n else:\\n backward_opposite = [backward_edge[0], -1, p2[1] - backward_edge[0] * p2[0]]\\n new_p1 = line_cross_point(backward_opposite, edge)\\n new_p2 = line_cross_point(backward_opposite, edge_opposite)\\n fitted_parallelograms.append([new_p0, new_p1, new_p2, new_p3, new_p0])\\n\\n areas = [Polygon(t).area for t in fitted_parallelograms]\\n parallelogram = np.array(fitted_parallelograms[np.argmin(areas)][:-1], dtype=np.float32)\\n\\n # sort thie polygon\\n parallelogram_coord_sum = np.sum(parallelogram, axis=1)\\n min_coord_idx = np.argmin(parallelogram_coord_sum)\\n parallelogram = parallelogram[\\n [min_coord_idx, (min_coord_idx + 1) % 4, (min_coord_idx + 2) % 4, (min_coord_idx + 3) % 4]]\\n\\n rectangle = rectangle_from_parallelogram(parallelogram)\\n rectangle, rotate_angle = sort_rectangle(rectangle)\\n r0, r1, r2, r3 = rectangle\\n\\n # For all points of the polygon (bounding box), calculate geometric geo map\\n Y, X = np.where(poly_mask == 1)\\n for y, x in zip(Y, X):\\n point = np.array([x, y], dtype=np.float32)\\n # top\\n geo_map[i, y, x, 0] = point_dist_to_line(r0, r1, point)\\n # right\\n geo_map[i, y, x, 1] = point_dist_to_line(r1, r2, point)\\n # down\\n geo_map[i, y, x, 2] = point_dist_to_line(r2, r3, point)\\n # left\\n geo_map[i, y, x, 3] = point_dist_to_line(r3, r0, point)\\n # angle\\n geo_map[i, y, x, 4] = rotate_angle\\n\\n print (geo_map.shape)\\n exit()\\n\\n return score_map, geo_map\",\n \"def annotate_image(self, image, results):\\n predictedObjects = []\\n for i in range(len(results)):\\n objectParameters = []\\n x = int(results[i][1])\\n y = int(results[i][2])\\n w = int(results[i][3])\\n h = int(results[i][4])\\n # print(x, y, w, h, results[i][0])\\n imageHeight, imageWidth, _ = image.shape\\n w = w // 2\\n h = h // 2\\n # change to truncate boxes which go outside the image\\n xmin, xmax, ymin, ymax = 0, 0, 0, 0\\n xmin = 3 if not max(x - w, 0) else (x - w)\\n xmax = imageWidth - 3 if not min(x + w - imageWidth, 0) \\\\\\n else (x + w)\\n ymin = 1 if not max(y - h, 0) else (y - h)\\n ymax = imageHeight - 3 if not min(y + h - imageHeight, 0) \\\\\\n else (y + h)\\n if self.verbose:\\n print('Class : ' + results[i][0] + ', [x, y, w, h] [' +\\n str(x) + ', ' + str(y) + ', ' + str(w) + ', ' + str(h) +\\n '] Confidence : ' + str(results[i][5]))\\n \\n # Each class must have a unique color\\n color = tuple([(j * (1+self.classes.index(results[i][0])) % 255) \\\\\\n for j in self.seed])\\n cv2.rectangle(image, (xmin, ymin), (xmax, ymax), color, 2)\\n if ymin <= 20:\\n cv2.rectangle(\\n image, (xmin, ymin), (xmax, ymin + 20), color, -1\\n )\\n cv2.putText(\\n image, results[i][0] + ': %.2f' % results[i][5],\\n (xmin+5, ymin+15), cv2.FONT_HERSHEY_SIMPLEX, 0.5,\\n (255, 255, 255), 2\\n )\\n else:\\n cv2.rectangle(image, (xmin, ymin), (xmax, ymin-20), color, -1)\\n cv2.putText(\\n image, results[i][0] + ': %.2f' % results[i][5],\\n (xmin+5, ymin-8), cv2.FONT_HERSHEY_SIMPLEX, 0.5,\\n (255, 255, 255), 2\\n )\\n objectParameters = [\\n results[i][0], xmin, ymin, xmax, ymax, results[i][5]\\n ]\\n predictedObjects.append(objectParameters)\\n return image, predictedObjects\\n # if self.outputFile:\\n # cv2.imwrite(self.outputFile,image)\",\n \"def search(self, query_image, list_images):\\n\\t\\tresult = {}\\n\\t\\t# Get variables from query image\\n\\t\\tquery_kps, query_descriptor = query_image.key_points_and_descriptors()\\n\\t\\t# Loop in the list of images\\n\\t\\tfor image in list_images:\\n\\t\\t\\t# Varuables of the current image\\n\\t\\t\\tkps, descriptor = image.key_points_and_descriptors()\\n\\t\\t\\t# Get the score of the current image compared with the query image\\n\\t\\t\\tscore = self.get_score(query_kps, query_descriptor, kps, descriptor)\\n\\t\\t\\tresult[image.name()] = score\\n\\n\\t\\t# Sort results by score\\n\\t\\tif len(result) > 0:\\n\\t\\t\\tresult = sorted([(v, k) for (k, v) in result.items() if v > 0],\\n\\t\\t\\t\\treverse = True)\\n\\t\\treturn result\",\n \"def get_image_list(im, dic):\\n lst = list(im.getdata())\\n tiles = []\\n for i in range(len(lst)):\\n #print find_similar(lst[i], dic)[random.randrange(10)][1]\\n tiles.append(find_similar(lst[i], dic)[random.randrange(10)][1])\\n return tiles\",\n \"def draw_all_result(self, image):\\n for facebox, conf in self.detection_result:\\n cv2.rectangle(image, (facebox[0], facebox[1]),\\n (facebox[2], facebox[3]), (0, 255, 0))\\n label = \\\"face: %.4f\\\" % conf\\n label_size, base_line = cv2.getTextSize(\\n label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)\\n\\n cv2.rectangle(image, (facebox[0], facebox[1] - label_size[1]),\\n (facebox[0] + label_size[0],\\n facebox[1] + base_line),\\n (0, 255, 0), cv2.FILLED)\\n cv2.putText(image, label, (facebox[0], facebox[1]),\\n cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0))\",\n \"def draw_all_result(self, image):\\r\\n for facebox, conf in self.detection_result:\\r\\n cv2.rectangle(image, (facebox[0], facebox[1]),\\r\\n (facebox[2], facebox[3]), (0, 255, 0))\\r\\n label = \\\"face: %.4f\\\" % conf\\r\\n label_size, base_line = cv2.getTextSize(\\r\\n label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)\\r\\n\\r\\n cv2.rectangle(image, (facebox[0], facebox[1] - label_size[1]),\\r\\n (facebox[0] + label_size[0],\\r\\n facebox[1] + base_line),\\r\\n (0, 255, 0), cv2.FILLED)\\r\\n cv2.putText(image, label, (facebox[0], facebox[1]),\\r\\n cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0))\",\n \"def renderResultOnImage(self, result, img ):\\n \\n for currFace in result:\\n faceRectangle = currFace['faceRectangle']\\n currEmotion = max(currFace['scores'].items(), key=operator.itemgetter(1))[0]\\n '''if currEmotion == 'anger':\\n logo = cv2.imread('/home/chang/图片/anger.jpg')\\n elif currEmotion == 'contempt':\\n logo = cv2.imread('/home/chang/图片/contempt.jpg')\\n elif currEmotion == 'disgust':\\n logo = cv2.imread('/home/chang/图片/disgust.jpg')\\n elif currEmotion == 'fear':\\n logo = cv2.imread('/home/chang/图片/fear.jpg')\\n elif currEmotion == 'happiness':\\n logo = cv2.imread('/home/chang/图片/happiness.jpg')\\n elif currEmotion == 'neutral':\\n logo = cv2.imread('/home/chang/图片/neutral.jpg')\\n elif currEmotion == 'sadness':\\n logo = cv2.imread('/home/chang/图片/sadness.jpg')\\n elif currEmotion == 'surprise':\\n logo = cv2.imread('/home/chang/图片/surprise.jpg')\\n width=faceRectangle['width']#171\\n top=faceRectangle['top']#130\\n left=faceRectangle['left']#101\\n height=faceRectangle['height']#169\\n\\n\\n logo=cv2.resize(logo,((width-10),(height-10)),interpolation=cv2.INTER_CUBIC)#rows=189 cols=191\\n\\n logo_gray = cv2.cvtColor(logo, cv2.COLOR_BGR2GRAY)\\n rows, cols, channels = logo.shape#\\n \\n roi = img[(top):(top+rows),(left):(cols+left)]#row:188 col:190\\n \\n # binary & mask\\n ret, mask = cv2.threshold(logo_gray, 220, 255, cv2.THRESH_BINARY)\\n # dst\\n dst = roi\\n re_row,re_col,re_channel = dst.shape\\n \\n\\n for r in xrange(re_row):#0-188\\n for c in xrange(re_col):#0-190\\n if mask[r, c] == 0:\\n dst[r, c, :] = logo[r, c, :]\\n #img[(top):(top+rows),(left):(cols+left)] = dst\\n #textToWrite = \\\"%s\\\" % ( currEmotion )\\n #cv2.putText( img, textToWrite, (faceRectangle['left'],faceRectangle['top']-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,0,0), 1 )\\n '''\\n return currEmotion\",\n \"def get_img_index(pred_result: List) -> List:\\n img_index = []\\n\\n for i, line in enumerate(pred_result):\\n match = re.search(\\\"\\\\./test_pics/\\\", line)\\n if match:\\n img_index.append(i)\\n if i == len(pred_result) - 1:\\n img_index.append(i)\\n return img_index\",\n \"def test(label_dict, image_ids, args):\\n\\n log_header('Starting image retrieval preparations')\\n\\n queries = []\\n\\n if args.test_image is not None:\\n queries.append(args.test_image)\\n else:\\n logging.info('Generating random test queries')\\n\\n number_of_images = len(image_ids)\\n\\n # Generate random queries to use in the test procedure\\n for i in range(args.k):\\n queries.append(image_ids[random.randint(0, number_of_images - 1)])\\n\\n # Calculate score for the retrieved images\\n calculate_score(\\n label_dict, queries, retrieve_similar_images(queries, args)\\n )\",\n \"def draw_detections(self, img, yolo_results):\\n\\n _, height, _ = img.shape\\n for yolo_result in yolo_results:\\n class_index = yolo_result.class_index\\n obj_name = yolo_result.obj_name\\n x = yolo_result.x_min\\n y = yolo_result.y_min\\n w = yolo_result.width\\n h = yolo_result.height\\n\\n offset = class_index * 123457 % self.meta.classes\\n\\n red = self._get_color(2, offset, self.meta.classes)\\n green = self._get_color(1, offset, self.meta.classes)\\n blue = self._get_color(0, offset, self.meta.classes)\\n box_width = int(height * 0.006)\\n cv2.rectangle(img, (int(x), int(y)), (int(x+w)+1, int(y+h)+1), (red, green, blue), box_width)\\n cv2.putText(img, obj_name, (int(x) -1, int(y) -1), cv2.FONT_HERSHEY_PLAIN, 2, (red, green, blue), 2)\\n\\n return img\",\n \"def fetch_images(self, images, depth_level):\\r\\n image_results = {}\\r\\n initial_area = float(0.0)\\r\\n total_score = float(0.0)\\r\\n cnt = float(1.0)\\r\\n MIN_WIDTH = 50\\r\\n for image in images[:30]:\\r\\n src = self.parser.getAttribute(image, attr='src')\\r\\n src = self.build_image_path(src)\\r\\n local_image = self.get_local_image(src)\\r\\n width = local_image.width\\r\\n height = local_image.height\\r\\n src = local_image.src\\r\\n file_extension = local_image.file_extension\\r\\n\\r\\n if file_extension != '.gif' or file_extension != 'NA':\\r\\n if (depth_level >= 1 and local_image.width > 300) or depth_level < 1:\\r\\n if not self.is_banner_dimensions(width, height):\\r\\n if width > MIN_WIDTH:\\r\\n sequence_score = float(1.0 / cnt)\\r\\n area = float(width * height)\\r\\n total_score = float(0.0)\\r\\n\\r\\n if initial_area == 0:\\r\\n initial_area = area * float(1.48)\\r\\n total_score = 1\\r\\n else:\\r\\n area_difference = float(area / initial_area)\\r\\n total_score = sequence_score * area_difference\\r\\n\\r\\n image_results.update({local_image: total_score})\\r\\n cnt += 1\\r\\n cnt += 1\\r\\n return image_results\",\n \"def ingest_results(self, results, isCsv=False):\\n \\n for r in results:\\n image = Image()\\n if isCsv:\\n image.parse_row(r)\\n else:\\n image.parse_record(r)\\n # print(\\\"metadata: %s\\\" % image.metadata)\\n # answer = input(\\\"Press enter...\\\")\\n self.img_lst.append(image)\",\n \"def evaluate(self):\\n scores = []\\n scores.append(self.word_analogy())\\n print(\\\"Word Analogy (acc): \\\", scores[0])\\n scores.append(self.word_similarity())\\n print(\\\"Word Similarity (MSE): \\\", scores[1])\\n scores.append(self.concept_categorization())\\n print(\\\"Concept Categorization (purity): \\\", scores[2])\\n scores.append(self.sentiment_analysis())\\n print(\\\"Sentiment Analysis (acc): \\\", scores[3])\\n return scores\",\n \"def getResults():\",\n \"def print_images_in_statistics(self):\\n self._print_images_statistics(self._images_in_folder, self._pose_class_names)\",\n \"def im_list_detections(model, im_list):\\n _t = Timer()\\n num_images = len(im_list)\\n im_list_boxes = [[] for _ in range(num_images)]\\n im_list_scores = [[] for _ in range(num_images)]\\n im_list_ids = [[] for _ in range(num_images)]\\n im_list_classes = [[] for _ in range(num_images)]\\n # create anchors for each level\\n anchors = create_cell_anchors()\\n for i in range(num_images):\\n im_list_ids[i] = im_list[i]['id']\\n im = cv2.imread(im_list[i]['image'])\\n with c2_utils.NamedCudaScope(0):\\n _t.tic()\\n im_list_boxes[i], im_list_scores[i], im_list_classes[i] = \\\\\\n im_detections(model, im, anchors)\\n _t.toc()\\n logger.info(\\n 'im_detections: {:d}/{:d} {:.3f}s'.format(\\n i + 1, num_images, _t.average_time))\\n return im_list_boxes, im_list_scores, im_list_classes, im_list_ids\",\n \"def detect_objects(self, image):\\n # Feed the input image to the model\\n self.set_input_tensor(image)\\n self.model.invoke()\\n\\n # Get all outputs from the model\\n boxes = self.get_output_tensor(0)\\n classes = self.get_output_tensor(1)\\n scores = self.get_output_tensor(2)\\n count = int(self.get_output_tensor(3))\\n\\n results = []\\n for i in range(count):\\n result = {\\n 'bounding_box': boxes[i],\\n 'class_id': int(classes[i]),\\n 'score': scores[i]\\n }\\n results.append(result)\\n return results\",\n \"def generate_labels(pics):\\r\\n return []\",\n \"def convert_predictions_to_image_summaries(hook_args):\\n decode_hparams = hook_args.decode_hparams\\n if not decode_hparams.display_decoded_images:\\n return []\\n predictions = hook_args.predictions[0]\\n\\n # Display ten random inputs and outputs so that tensorboard does not hang.\\n all_summaries = []\\n rand_predictions = np.random.choice(predictions, size=10)\\n for ind, prediction in enumerate(rand_predictions):\\n output_summary = image_to_tf_summary_value(\\n prediction[\\\"outputs\\\"], tag=\\\"%d_output\\\" % ind)\\n input_summary = image_to_tf_summary_value(\\n prediction[\\\"inputs\\\"], tag=\\\"%d_input\\\" % ind)\\n all_summaries.append(input_summary)\\n all_summaries.append(output_summary)\\n return all_summaries\",\n \"def format_results(self, results, imgfile_prefix=None, to_label_id=True):\\n\\n assert isinstance(results, list), 'results must be a list'\\n\\n imgfile_prefix = osp.join(imgfile_prefix, 'vis')\\n if not osp.exists(imgfile_prefix):\\n os.makedirs(imgfile_prefix)\\n print_log('\\\\n Start formatting the result')\\n\\n for id in trange(len(results)):\\n pred, gt, img_path = results[id]\\n b,c,h,w = pred.shape\\n assert pred.shape[0]==1 and gt.shape[0]==1\\n pred = pred[0]\\n gt = gt[0]\\n gt[-1, ...] = np.invert(gt[-1, ...])\\n pred = np.concatenate([pred, gt[-1,...][None,...]], axis=0)\\n pred_vis = visualize_map_mask(pred)\\n gt_vis = visualize_map_mask(gt)\\n img = mmcv.imread(img_path, backend='cv2')\\n img = mmcv.imresize(img,(int(float(img.shape[1])*h/float(img.shape[0])), h))\\n vis = np.concatenate([img, pred_vis[::-1,...], gt_vis[::-1,]], axis=1)\\n save_path = osp.join(imgfile_prefix, os.path.basename(img_path))\\n mmcv.imwrite(vis, save_path)\",\n \"def format_multiple_results(results, features_to_show=[]):\\n best_score_array = np.array([])\\n for r in results:\\n print r\\n print r[-1]\\n best_score_array = np.append(best_score_array, r[-1])\\n\\n print \\\"BEST SCORE ARRAY\\\", best_score_array\\n print \\\"Best Score\\\"\\n print \\\"Mean: \\\", best_score_array.mean()\\n print \\\"Std: \\\", best_score_array.std()\",\n \"def _fetch_labels(self, list_fams, no_imgs, num_samples) -> Tuple[np.ndarray, List]:\\n y_train = np.zeros(num_samples)\\n pos = 0\\n label = 0\\n indexes = []\\n for i in no_imgs:\\n indexes.append(i)\\n print(\\\"Label:%2d\\\\tFamily: %15s\\\\tNumber of images: %d\\\" % (label, list_fams[label], i))\\n for j in range(i):\\n y_train[pos] = label\\n pos += 1\\n label += 1\\n return y_train, indexes\",\n \"def get_output(interpreter, score_threshold, top_k, image_scale=1.0):\\n boxes = common.output_tensor(interpreter, 0)\\n class_ids = common.output_tensor(interpreter, 1)\\n scores = common.output_tensor(interpreter, 2)\\n count = int(common.output_tensor(interpreter, 3))\\n\\n def make(i):\\n ymin, xmin, ymax, xmax = boxes[i]\\n return Object(\\n id=int(class_ids[i]),\\n score=scores[i],\\n bbox=BBox(xmin=np.maximum(0.0, xmin),\\n ymin=np.maximum(0.0, ymin),\\n xmax=np.minimum(1.0, xmax),\\n ymax=np.minimum(1.0, ymax)))\\n\\n return [make(i) for i in range(top_k) if scores[i] >= score_threshold]\",\n \"def get_output(interpreter, score_threshold, top_k, image_scale=1.0):\\n boxes = common.output_tensor(interpreter, 0)\\n class_ids = common.output_tensor(interpreter, 1)\\n scores = common.output_tensor(interpreter, 2)\\n count = int(common.output_tensor(interpreter, 3))\\n\\n def make(i):\\n ymin, xmin, ymax, xmax = boxes[i]\\n return Object(\\n id=int(class_ids[i]),\\n score=scores[i],\\n bbox=BBox(xmin=np.maximum(0.0, xmin),\\n ymin=np.maximum(0.0, ymin),\\n xmax=np.minimum(1.0, xmax),\\n ymax=np.minimum(1.0, ymax)))\\n\\n return [make(i) for i in range(top_k) if scores[i] >= score_threshold]\",\n \"def get_output(interpreter, score_threshold, top_k, image_scale=1.0):\\n boxes = common.output_tensor(interpreter, 0)\\n class_ids = common.output_tensor(interpreter, 1)\\n scores = common.output_tensor(interpreter, 2)\\n count = int(common.output_tensor(interpreter, 3))\\n\\n def make(i):\\n ymin, xmin, ymax, xmax = boxes[i]\\n return Object(\\n id=int(class_ids[i]),\\n score=scores[i],\\n bbox=BBox(xmin=np.maximum(0.0, xmin),\\n ymin=np.maximum(0.0, ymin),\\n xmax=np.minimum(1.0, xmax),\\n ymax=np.minimum(1.0, ymax)))\\n\\n return [make(i) for i in range(top_k) if scores[i] >= score_threshold]\",\n \"def main():\\n \\n # for inserting other images, add tem to /input folder and list them here\\n images = (\\n 'image-0',\\n 'image-1',\\n 'image-2'\\n )\\n\\n for image_name in images:\\n print(image_name, \\\"image:\\\")\\n\\n image = open_image(image_name)\\n display_image(image, \\\"Original input \\\" + image_name)\\n\\n grayscale_v = transform_colors(image)\\n display_image(grayscale_v[:,:,0], \\\"Grayscale \\\" + image_name)\\n save_image(image_name + \\\"-grayscale\\\", grayscale_v[:,:,0])\\n\\n contours_v, contours = get_contours(grayscale_v)\\n display_image(contours_v, \\\"Contours \\\" + image_name)\\n save_image(image_name + \\\"-contours\\\", contours_v)\\n\\n labeled_img, areas = get_measures(image, contours[1:])\\n display_image(labeled_img, \\\"Labeled \\\" + image_name)\\n save_image(image_name + \\\"-labeled\\\", labeled_img)\\n\\n areas_histogram(areas, image_name)\",\n \"def test_image_at_levels(image_name, percentages, blur=False, blur_amount=10):\\n # img = skimage.io.imread(os.path.join(IMAGE_DIR, image_name[:-3]+'JPEG'))\\n img = cv2.imread(os.path.join(IMAGE_DIR, image_name[:-3]+'JPEG'))\\n # mask_img = skimage.io.imread(os.path.join(MASK_DIR, image_name))\\n mask_img = cv2.imread(os.path.join(MASK_DIR, image_name))\\n results = []\\n level_list = get_ntiles_for_img(mask_img, percentages)\\n print(level_list)\\n for level in level_list:\\n masked_image = make_masked_image(img, mask_img, level, blur, blur_amount)\\n cv2.imshow('img',masked_image)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\\n # Transform image for VGG\\n masked_image = cv2.resize(masked_image, (224,224)).astype(np.float32)\\n masked_image[:,:,0] -= 103.939\\n masked_image[:,:,1] -= 116.779\\n masked_image[:,:,2] -= 123.68\\n masked_image = masked_image.transpose((1,0,2))\\n masked_image = np.expand_dims(masked_image, axis=0)\\n out = model.predict(masked_image)\\n ordered_idx = np.argsort(-out)\\n print(out.max(), ordered_idx[0][0])\\n result = (CallResult.lines[int(ordered_idx[0][0])], out[0][ordered_idx[0]][0])\\n results.append(result)\\n\\n return results\",\n \"def main():\\n stats = []\\n start = timer()\\n\\n for file_name in get_dataset():\\n\\n # load image and ground truth detection mask\\n img = cv2.imread(settings.PATH + file_name)\\n ground_truth_mask = cv2.imread(settings.PATH_GT_MASKS + file_name)\\n\\n # Find list of barcode regions (rotated rectangle) within image\\n barcode_regions, debug_img = find_barcodes(img)\\n barcode_regions_mask = np.zeros(img.shape, np.uint8)\\n barcode_images = None\\n result = []\\n\\n # Decode barcode regions\\n for barcode_region in barcode_regions:\\n\\n # Decode barcode image\\n barcode_img = barcode_region.extract_from(img)\\n barcode_mask = barcode_region.get_mask(img)\\n debug_img = barcode_region.draw(debug_img)\\n\\n # Combine masks from multiple detected regions\\n barcode_regions_mask += barcode_mask\\n\\n # Decode barcode\\n decoded = pyzbar.decode(barcode_img)\\n\\n # Keep result for logging\\n data = \\\", \\\".join([d.data.decode(\\\"utf-8\\\") for d in decoded])\\n result.append({\\\"data\\\": data, \\\"region\\\": barcode_region.json()})\\n\\n if settings.SHOW_IMAGE:\\n barcode_images = img_concat(barcode_images, barcode_img)\\n\\n # Jaccard_accuracy = intersection over union of the two binary masks\\n jaccard_accuracy = 0\\n if ground_truth_mask is not None:\\n r = barcode_regions_mask.max(axis=-1).astype(bool)\\n u = ground_truth_mask.max(axis=-1).astype(bool)\\n jaccard_accuracy = float((r & u).sum()) / (r | u).sum()\\n stats.append(jaccard_accuracy)\\n\\n # Log result\\n logger.info(\\n \\\"Image processed\\\",\\n file_name=file_name,\\n jaccard_accuracy=jaccard_accuracy,\\n success=jaccard_accuracy > 0.5,\\n result=result,\\n )\\n\\n # In debug mode show visualization of detection algorithm\\n if settings.SHOW_IMAGE:\\n\\n # Add alpha channel\\n debug_img = cv2.cvtColor(debug_img, cv2.COLOR_BGR2BGRA)\\n if barcode_images is not None:\\n barcode_images = cv2.cvtColor(barcode_images, cv2.COLOR_BGR2BGRA)\\n\\n # Overlay error mask\\n # Pixel-wise difference between ground truth and detected barcodes\\n if ground_truth_mask is not None:\\n error_img = np.zeros(debug_img.shape, np.uint8)\\n error_img[r & u] = np.array([0, 0, 0, 0], dtype=np.uint8)\\n error_img[np.logical_xor(r, u)] = np.array(\\n [0, 0, 255, 1], dtype=np.uint8\\n )\\n debug_img = cv2.addWeighted(debug_img, 1, error_img, 0.5, 0)\\n\\n # Append barcode pictures to the right\\n debug_img = img_concat(debug_img, barcode_images, axis=1)\\n\\n # Show visualization\\n cv2.namedWindow(\\\"img\\\", cv2.WINDOW_NORMAL)\\n cv2.imshow(\\\"img\\\", debug_img)\\n cv2.waitKey(0)\\n\\n # Calculate final stats\\n end = timer()\\n accuracy = np.array(stats).mean()\\n successes = np.where(np.array(stats) > 0.5)[0]\\n logger.info(\\n \\\"Final stats\\\",\\n accuracy=accuracy,\\n detection_rate=float(len(successes)) / len(stats),\\n fps=len(stats) / (end - start),\\n )\",\n \"def test_measurement_on_images(file_list):\\n test_details_list = []\\n for idx, file in enumerate(file_list):\\n dict_results = {}\\n image = cv2.imread(file)\\n FaceDetector().run(image, dict_results)\\n file_name = ntpath.basename(file)\\n is_there_face = \\\"True\\\" in file_name\\n test_details_list.append([file_name, is_there_face, dict_results[\\\"FaceDetector\\\"],\\n is_there_face == dict_results[\\\"FaceDetector\\\"]])\\n\\n # print test results in a readable table format\\n headers = ['File Name', 'Face Exist', 'Measurement Result', 'Test Result']\\n print(tabulate(test_details_list, headers))\",\n \"def get_images(image_folder_root, image_label_list):\\n file_dcm=[]\\n X_test = []\\n y_test = []\\n for file_name,label in image_label_list:\\n try:\\n current_file = pydicom.dcmread(image_folder_root + file_name + '.dcm')\\n pixel_array = current_file.pixel_array\\n if (pixel_array.shape != (512,512)):\\n continue\\n file_dcm.append((file_name,label,brain_window(current_file)))\\n y_test.append(label)\\n X_test.append(pydicom.dcmread(image_folder_root + file_name + '.dcm').pixel_array)\\n except ValueError:\\n continue\\n return X_test,y_test\",\n \"def prepare_images(images):\\n images = color.rgb2lab(images)\\n\\n l = images[:,:,:,:1]/100.\\n ab = images[:,:,:,1:]/200. + 0.5\\n\\n return l, ab\",\n \"def get_images(path_list):\\n images = []\\n labels = []\\n names = []\\n i = 0\\n for path in path_list:\\n for fruit_dir_path in glob.glob(path):\\n fruit_label = fruit_dir_path.split(\\\"/\\\")[-1]\\n for image_path in glob.glob(os.path.join(fruit_dir_path, \\\"*.jpg\\\")):\\n image = cv2.imread(image_path, cv2.IMREAD_COLOR)\\n\\n image = cv2.resize(image, (45, 45))\\n image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\\n\\n images.append(image)\\n names.append(fruit_label)\\n labels.append(i)\\n i += 1\\n\\n images = np.array(images)\\n print(images.shape)\\n # add a new dimension here\\n with np.nditer(images, op_flags=['readwrite']) as it:\\n for x in it:\\n x = np.expand_dims(x, axis=0)\\n labels = np.array(labels)\\n return images, labels, i\",\n \"def class_imgs(list_img):\\n numberimg = len(list_img)\\n resize(net, numberimg, cursize)\\n i = 0\\n for img in list_img:\\n image = caffe.io.load_image(img)\\n transformed_image = transformer.preprocess('data', image)\\n net.blobs['data'].data[i] = transformed_image\\n i = i + 1\\n\\n output = net.forward()\\n\\n results = []\\n for n in range(0, numberimg):\\n themax = output['prob'][n].argmax()\\n results.append({'filename':list_img[n], 'class': themax, 'prob': output['prob'][n].tolist()})\\n\\n return results\",\n \"def generate_imgs(self, count, threshold, modifier):\\n self.build_gan()\\n\\n\\n imgs = []\\n for i in range(count):\\n score = [0]\\n while not(threshold[0] < score[0] < threshold[1]):\\n img = self.gene_imgs(1)\\n score = self.discriminator.predict(img)\\n print(\\\"Image found: \\\", score[0])\\n imgs.append(img)\\n\\n imgs = np.asarray(imgs).squeeze()\\n imgs = 0.5 * imgs + 0.5\\n\\n print(imgs.shape)\\n for i, img_array in enumerate(imgs):\\n path = f\\\"{self.output_directory}/generated_{threshold[0]}_{threshold[1]}\\\"\\n if not os.path.exists(path):\\n os.makedirs(path)\\n imsave(path + f\\\"/{modifier}_{i}.png\\\", self.pix_array_convert(img_array))\",\n \"def classify_images(images_dir, results_dic, model):\\n \\n # None \\n\\n first_filename_list = listdir(\\\"pet_images/\\\")\\n filename_list = []\\n for idx in range(0, len(first_filename_list), 1):\\n if not first_filename_list[idx].startswith('.'):\\n filename_list.append(first_filename_list[idx])\\n\\n idx = 0\\n for key in results_dic:\\n # print(\\\"---------------\\\")\\n\\n value=results_dic[key]\\n # print(\\\"\\\\t-----key={}\\\".format(key))\\n # print(\\\"\\\\t-----value={}\\\".format(value))\\n \\n path = images_dir + filename_list[idx]\\n # print(\\\"\\\\t-----path={}\\\".format(path))\\n \\n model_label = classifier(path, model)\\n model_label = model_label.lower()\\n model_label = model_label.strip()\\n # print(\\\"\\\\t-----model_label={}\\\".format(model_label))\\n \\n truth = 0\\n if value in model_label:\\n truth = 1\\n\\n results_dic[key] = [ value, model_label, truth ]\\n # print(\\\"\\\\t-----truth={}\\\".format(truth))\\n idx = idx + 1\",\n \"def detect_objects(self, image, threshold):\\n self.set_input_tensor(image)\\n self.interpreter.invoke()\\n\\n # Get all output details\\n boxes = self.get_output_tensor(0)\\n classes = self.get_output_tensor(1)\\n scores = self.get_output_tensor(2)\\n count = int(self.get_output_tensor(3))\\n\\n results = []\\n for i in range(count):\\n if scores[i] >= threshold:\\n result = {\\n 'bounding_box': boxes[i],\\n 'class_id': classes[i],\\n 'score': scores[i]\\n }\\n results.append(result)\\n return results\",\n \"def _plot_results(results, labels, score):\\n \\n labels_dict = {k: i for i, k in enumerate(labels)}\\n rmin, rmax = min(results)[0], max(results)[0]\\n to_color = lambda x : 0.8 * (x - rmax) / (rmin - rmax) + 0.5\\n\\n result_matrix = np.zeros((8, len(labels_dict)))\\n labels_dict = {k: i for i, k in enumerate(labels)}\\n for i, (v, r_labels) in enumerate(results):\\n for k in r_labels:\\n result_matrix[i, labels_dict[k]] = to_color(v)\\n \\n plt.figure(figsize=(11, 6))\\n plt.imshow(result_matrix, cmap='Greys', aspect='auto')\\n plt.xticks(np.arange(0, len(labels)), labels, rotation=90)\\n plt.yticks(np.arange(0, len(results)), [round(x[0]) for x in results])\\n plt.ylabel(score)\\n plt.show()\",\n \"def _get_X_and_names(self, list_fams, num_samples, property_alias: str) -> Tuple[np.ndarray, List[str]]:\\n width, height, channels = (self.IMAGE_WIDTH, self.IMAGE_HEIGHT, self.IMAGE_CHANNELS)\\n X_train = np.zeros((num_samples, width, height, channels))\\n cnt = 0\\n samples_names = []\\n print(\\\"Processing images ...\\\")\\n for i in range(len(list_fams)):\\n print('current fam: ', i)\\n for index, img_file in enumerate(self._fetch_all_images(join(list_fams[i], property_alias))):\\n img = image.load_img(img_file, target_size=(self.IMAGE_WIDTH, self.IMAGE_HEIGHT))\\n x = image.img_to_array(img)\\n x = np.expand_dims(x, axis=0)\\n x = preprocess_input(x)\\n X_train[cnt] = x\\n\\n cnt += 1\\n index = img_file.find(self.frame_delimiter)\\n samples_names.append(img_file[0:index])\\n return X_train, samples_names\",\n \"def detect_objects(interpreter, image):\\n set_input_tensor(interpreter, image)\\n interpreter.invoke()\\n\\n # Get all output details\\n boxes = get_output_tensor(interpreter, 0)\\n classes = get_output_tensor(interpreter, 1)\\n scores = get_output_tensor(interpreter, 2)\\n count = int(get_output_tensor(interpreter, 3))\\n\\n results = []\\n for i in range(count):\\n # Only check for people that meet the threshold\\n if classes[i] == 0.0 and scores[i] >= THRESHOLD:\\n result = {\\n \\\"bounding_box\\\": boxes[i],\\n \\\"class_id\\\": classes[i],\\n \\\"score\\\": scores[i],\\n }\\n results.append(result)\\n return results\",\n \"def runClassifier(interpreter, image, threshold):\\n set_input_tensor(interpreter, image)\\n interpreter.invoke()\\n\\n # Get all output details\\n boxes = get_output_tensor(interpreter, 0)\\n classes = get_output_tensor(interpreter, 1)\\n scores = get_output_tensor(interpreter, 2)\\n count = int(get_output_tensor(interpreter, 3))\\n\\n results = []\\n for i in range(count):\\n if scores[i] >= threshold:\\n result = {\\n \\\"bounding_box\\\": boxes[i],\\n \\\"class_id\\\": classes[i],\\n \\\"score\\\": scores[i],\\n }\\n results.append(result)\\n return results\",\n \"def create_image_lists(image_dir):\\n if not gfile.Exists(image_dir):\\n print(\\\"Image directory '\\\" + image_dir + \\\"' not found.\\\")\\n return None\\n result = {}\\n sub_dirs = [x[0] for x in os.walk(image_dir)]\\n # The root directory comes first, so skip it.\\n is_root_dir = True\\n for sub_dir in sub_dirs:\\n print('in sub loop')\\n extensions = ['jpg', 'jpeg', 'JPG', 'JPEG']\\n file_list = []\\n dir_name = os.path.basename(image_dir)\\n print(\\\"Looking for images in '\\\" + image_dir + \\\"'\\\")\\n for extension in extensions:\\n file_glob = os.path.join(image_dir, dir_name, '*.' + extension)\\n file_list.extend(glob.glob(file_glob))\\n if not file_list:\\n print('No files found')\\n continue\\n if len(file_list) < 20:\\n print('WARNING: Folder has less than 20 images, which may cause issues.')\\n label_name = re.sub(r'[^a-z0-9]+', ' ', dir_name.lower())\\n testing_images = []\\n for file_name in file_list:\\n base_name = os.path.basename(file_name)\\n # We want to ignore anything after '_nohash_' in the file name when\\n # deciding which set to put an image in, the data set creator has a way of\\n # grouping photos that are close variations of each other. For example\\n # this is used in the plant disease data set to group multiple pictures of\\n # the same leaf.\\n hash_name = re.sub(r'_nohash_.*$', '', file_name)\\n # This looks a bit magical, but we need to decide whether this file should\\n # go into the training, testing, or validation sets, and we want to keep\\n # existing files in the same set even if more files are subsequently\\n # added.\\n # To do that, we need a stable way of deciding based on just the file name\\n # itself, so we do a hash of that and then use that to generate a\\n # probability value that we use to assign it.\\n testing_images.append(base_name)\\n return testing_images\",\n \"def write_results(input_dict):\\n out_imgs = {}\\n for mol in input_dict:\\n mols = []\\n for new_mols in input_dict[mol]:\\n m = Chem.MolFromSmiles(new_mols)\\n mols.append(m)\\n if len(mols) > 2:\\n p = Chem.MolFromSmarts(MCS.FindMCS(mols).smarts)\\n AllChem.Compute2DCoords(p)\\n for m in mols:\\n AllChem.GenerateDepictionMatching2DStructure(m, p)\\n out_imgs[mol] = Draw.MolsToGridImage(mols, useSVG=True)\\n # Write out the image\\n return out_imgs\",\n \"def score_all(results):\\n Y = np.concatenate([results['%dtest'%n] for n in range(10)])\\n print score(np.concatenate([results['%dtrain'%n] for n in range(10)]))\\n print score(np.concatenate([results['%dtest'%n] for n in range(10)]))\\n class_counts = np.asarray([(Y[:,0]==n).sum() for n in range(10)])\\n return confusion_matrix(Y[:,0],Y[:,1]), class_counts\",\n \"def calculates_results_stats(results_dic): \\n # Creates empty dictionary for results_stats_dic\\n results_stats_dic = dict()\\n \\n # Sets all counters to initial values of zero so that they can \\n # be incremented while processing through the images in results_dic \\n results_stats_dic['n_dogs_img'] = 0\\n results_stats_dic['n_match'] = 0\\n results_stats_dic['n_correct_dogs'] = 0\\n results_stats_dic['n_correct_notdogs'] = 0\\n results_stats_dic['n_correct_breed'] = 0\\n \\n # process through the results dictionary\\n for key in results_dic:\\n \\n # Labels Match Exactly\\n if results_dic[key][2] == 1:\\n results_stats_dic['n_match'] += 1\\n\\n # TODO: 5a. REPLACE pass with CODE that counts how many pet images of\\n # dogs had their breed correctly classified. This happens \\n # when the pet image label indicates the image is-a-dog AND \\n # the pet image label and the classifier label match. You \\n # will need to write a conditional statement that determines\\n # when the dog breed is correctly classified and then \\n # increments 'n_correct_breed' by 1. Recall 'n_correct_breed' \\n # is a key in the results_stats_dic dictionary with it's value \\n # representing the number of correctly classified dog breeds.\\n # \\n # Pet Image Label is a Dog AND Labels match- counts Correct Breed\\n if results_dic[key][3] == 1 and results_dic[key][2] == 1:\\n results_stats_dic['n_correct_breed'] += 1\\n \\n # Pet Image Label is a Dog - counts number of dog images\\n if results_dic[key][3] == 1:\\n results_stats_dic['n_dogs_img'] += 1\\n \\n # Classifier classifies image as Dog (& pet image is a dog)\\n # counts number of correct dog classifications\\n if results_dic[key][4] == 1:\\n results_stats_dic['n_correct_dogs'] += 1\\n\\n # TODO: 5b. REPLACE pass with CODE that counts how many pet images \\n # that are NOT dogs were correctly classified. This happens \\n # when the pet image label indicates the image is-NOT-a-dog \\n # AND the classifier label indicates the images is-NOT-a-dog.\\n # You will need to write a conditional statement that \\n # determines when the classifier label indicates the image \\n # is-NOT-a-dog and then increments 'n_correct_notdogs' by 1. \\n # Recall the 'else:' above 'pass' already indicates that the \\n # pet image label indicates the image is-NOT-a-dog and \\n # 'n_correct_notdogs' is a key in the results_stats_dic dictionary \\n # with it's value representing the number of correctly \\n # classified NOT-a-dog images.\\n # \\n # Pet Image Label is NOT a Dog\\n else:\\n # Classifier classifies image as NOT a Dog(& pet image isn't a dog)\\n # counts number of correct NOT dog clasifications.\\n if results_dic[key][3] == 0 and results_dic[key][4] == 0:\\n results_stats_dic['n_correct_notdogs'] += 1\\n\\n\\n # Calculates run statistics (counts & percentages) below that are calculated\\n # using the counters from above.\\n\\n # calculates number of total images\\n results_stats_dic['n_images'] = len(results_dic)\\n\\n # calculates number of not-a-dog images using - images & dog images counts\\n results_stats_dic['n_notdogs_img'] = (results_stats_dic['n_images'] - \\n results_stats_dic['n_dogs_img']) \\n\\n # TODO: 5c. REPLACE zero(0.0) with CODE that calculates the % of correctly\\n # matched images. Recall that this can be calculated by the\\n # number of correctly matched images ('n_match') divided by the \\n # number of images('n_images'). This result will need to be \\n # multiplied by 100.0 to provide the percentage.\\n # \\n # Calculates % correct for matches\\n results_stats_dic['pct_match'] = (results_stats_dic['n_match'] / results_stats_dic['n_images']) * 100\\n\\n # TODO: 5d. REPLACE zero(0.0) with CODE that calculates the % of correctly\\n # classified dog images. Recall that this can be calculated by \\n # the number of correctly classified dog images('n_correct_dogs')\\n # divided by the number of dog images('n_dogs_img'). This result \\n # will need to be multiplied by 100.0 to provide the percentage.\\n # \\n # Calculates % correct dogs\\n results_stats_dic['pct_correct_dogs'] = (results_stats_dic['n_correct_dogs'] / results_stats_dic['n_dogs_img']) * 100\\n\\n # TODO: 5e. REPLACE zero(0.0) with CODE that calculates the % of correctly\\n # classified breeds of dogs. Recall that this can be calculated \\n # by the number of correctly classified breeds of dog('n_correct_breed') \\n # divided by the number of dog images('n_dogs_img'). This result \\n # will need to be multiplied by 100.0 to provide the percentage.\\n # \\n # Calculates % correct breed of dog\\n results_stats_dic['pct_correct_breed'] = (results_stats_dic['n_correct_breed'] / results_stats_dic['n_dogs_img']) * 100\\n\\n # Calculates % correct not-a-dog images\\n # Uses conditional statement for when no 'not a dog' images were submitted \\n if results_stats_dic['n_notdogs_img'] > 0:\\n results_stats_dic['pct_correct_notdogs'] = (results_stats_dic['n_correct_notdogs'] /\\n results_stats_dic['n_notdogs_img']) * 100.0\\n else:\\n results_stats_dic['pct_correct_notdogs'] = 0.0\\n\\n \\n # TODO 5f. REPLACE None with the results_stats_dic dictionary that you \\n # created with this function \\n return results_stats_dic\",\n \"def _update_result(self, results, clf_numbers):\\n # ToDo make results of scoring values dynamic\\n names_results = ['Accuracy']\\n for number in clf_numbers:\\n for name in names_results:\\n if name not in self.results:\\n self.results[name] = [results[number][name + \\\"_test_score_\\\" + str(number)]]\\n else:\\n self.results[name].append(results[number][name + \\\"_test_score_\\\" + str(number)])\",\n \"def display_results(self, metrics):\\n\\n for k, v in self.cv_results_.items():\\n# sorted_results = sort_results(v)\\n print(f'Results for {k} metric:')\\n print()\\n print(v.sort_values(by=['Metric mean'], ascending=False))\\n print()\",\n \"def get_img_list(self):\\n if self.list_flag == \\\"train\\\":\\n train_list_all = [line.rstrip('\\\\n')[:-4] for line in open(os.path.join(self.dataset_dir, 'split', self.list_flag + '-list.txt'))]\\n train_list_delete = [line.rstrip('\\\\n') for line in open(os.path.join(self.dataset_dir, 'split', 'Mesh_overlay_train_error_delete.txt'))]\\n print(\\\"Train delete %d images\\\" % len(train_list_delete))\\n\\n self.img_list_all = [x for x in train_list_all if x not in train_list_delete]\\n elif self.list_flag == \\\"val\\\":\\n valid_list_all = [line.rstrip('\\\\n')[:-4] for line in open(os.path.join(self.dataset_dir, 'split', 'validation-list.txt'))]\\n val_list_delete = [line.rstrip('\\\\n') for line in open(os.path.join(self.dataset_dir, 'split', 'Mesh_overlay_val_error_delete.txt'))]\\n self.img_list_all = [x for x in valid_list_all if x not in val_list_delete]\\n print(\\\"Val delete %d images.\\\" % len(val_list_delete))\\n\\n elif self.list_flag == 'test':\\n im_list = os.listdir(os.path.join(self.dataset_dir, 'images'))\\n self.img_list_all = [x[:-4] for x in im_list]\\n\\n return self.img_list_all\",\n \"def image_generator(img_list):\\n while True:\\n img = random.choice(img_list)\\n label = os.path.basename(os.path.dirname(img)) # add label function according to the dataset tree\\n img = preprocess_image(img)\\n yield img, label\",\n \"def draw_boxes(image, results, min_score=0.2, max_boxes=10):\\n results = sorted(results, key=lambda x: x['score'])\\n results = results[0:max_boxes]\\n for r in results:\\n if r['score'] < min_score:\\n continue\\n draw_box(image, r['bounding_box'], labels[r['class_id']], r['score'])\",\n \"def get_scores(self):\\n hist = self.confusion_matrix\\n # hist = [TN,FP;FN,TP]\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n # iou = iu.sum() / self.n_classes\\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n cls_iou = dict(zip(range(self.n_classes), iu))\\n\\n ##############################################\\n tn = hist[0, 0]\\n tp = np.diag(hist).sum() - tn\\n fp = np.triu(hist, 1).sum()\\n fn = np.tril(hist, -1).sum()\\n precision = tp / (tp + fp)\\n recall = tp / (tp + fn)\\n f1 = 2 * precision * recall / (precision + recall)\\n\\n # for medical img, img_seg \\\\in [0,1]\\n dice = 2 * tp / (tp + tp + fn + fp)\\n # dice = f1-score\\n dsc = 2 * tp / (tp + fn + fp)\\n # dsc = jaccard\\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\\n # voe = 1 - dsc\\n\\n k2 = {\\n # \\\"Overall Acc: \\\\t\\\": acc,\\n 'Mean Acc': float(judge_nan(acc_cls)),\\n # \\\"FreqW Acc : \\\\t\\\": fwavacc,\\n 'Mean IoU': float(judge_nan(mean_iou)),\\n 'F1-score': float(judge_nan(f1)),\\n 'DSC': float(judge_nan(dsc)),\\n 'Precision': float(judge_nan(precision)),\\n 'Recall': float(judge_nan(recall)),\\n }\\n\\n return k2\",\n \"def allYandPred(self):\\n y = []\\n pred = []\\n if self.use_dic:\\n pb = progressbar.ProgressBar(self.n)\\n for data in sorted(self.dic):\\n for activity in sorted(self.dic[data]):\\n for imsize in sorted(self.dic[data][activity]):\\n for img in self.dic[data][activity][imsize]:\\n labels = self.dic[data][activity][imsize][img]\\n if len(labels) == 2:\\n y.append(labels[0])\\n pred.append(labels[1])\\n else:\\n return None\\n pb.update()\\n else:\\n y, pred = self.getYandPred()\\n return y, pred\",\n \"def __getitem__(self, index):\\r\\n if self.is_train:\\r\\n image_names,labels = self.sample_train_batch()\\r\\n # get sampled order image_file names and corresponding label\\r\\n image_list,label_list=[],[]\\r\\n for img,label in zip(image_names,labels):\\r\\n image = imread(img,flag=1,to_rgb=True)\\r\\n x,y,w,h = self.boxes[img]\\r\\n image = image[y:min(y+h,image.shape[0]),x:min(x+w,image.shape[1])]\\r\\n if image.shape[2]==1:\\r\\n print(\\\"has gray file\\\",img)\\r\\n image = nd.tile(image,(1,1,3))\\r\\n image =self._transform(image) # for rgb same value\\r\\n image_list.append(image)\\r\\n label_list.append(label)\\r\\n batch_data = nd.stack(*image_list,axis=0)\\r\\n batch_label = nd.array(label_list)\\r\\n return batch_data,batch_label\\r\\n else:\\r\\n img = self.test_images_files[index] # get the file name full path\\r\\n image = imread(img,flag=1,to_rgb=1)\\r\\n x,y,w,h = self.boxes[img]\\r\\n image = image[y:min(y+h,image.shape[0]),x:min(x+w,image.shape[1])]\\r\\n image = self._transform(image)\\r\\n\\r\\n return image,self.test_labels[index]\",\n \"def PostProcessing(image, resultList, threshold=0.6):\\n\\tnum_detections = resultList[0][0].astype(np.int)\\n\\tscores = resultList[2]\\n\\tboxes = resultList[3]\\n\\tbbox_num = 0\\n\\t\\n\\t# loop through all the detections and get the confidence and bbox coordinates\\n\\tfor i in range(num_detections):\\n\\t\\tdet_conf = scores[0, i]\\n\\t\\tdet_ymin = boxes[0, i, 0]\\n\\t\\tdet_xmin = boxes[0, i, 1]\\n\\t\\tdet_ymax = boxes[0, i, 2]\\n\\t\\tdet_xmax = boxes[0, i, 3]\\n\\n\\t\\tbbox_width = det_xmax - det_xmin\\n\\t\\tbbox_height = det_ymax - det_ymin\\n\\t\\t# the detection confidence and bbox dimensions must be greater than a minimum value to be a valid detection\\n\\t\\tif threshold <= det_conf and 1 >= det_conf and bbox_width > 0 and bbox_height > 0:\\n\\t\\t\\tbbox_num += 1\\n\\t\\t\\txmin = int(round(det_xmin * image.shape[1]))\\n\\t\\t\\tymin = int(round(det_ymin * image.shape[0]))\\n\\t\\t\\txmax = int(round(det_xmax * image.shape[1]))\\n\\t\\t\\tymax = int(round(det_ymax * image.shape[0]))\\n\\t\\t\\t\\n\\t\\t\\tcv2.rectangle(image, (xmin, ymin), (xmax, ymax), (0, 255, 0), 2)\\n\\t\\telse:\\n\\t\\t\\tcontinue\\n\\n\\tprint(\\\"detected bbox num:\\\", bbox_num)\\n\\tSRC_PATH = os.path.realpath(__file__).rsplit(\\\"/\\\", 1)[0]\\n\\tOutput_PATH = os.path.join(SRC_PATH, \\\"../output/output.jpg\\\")\\n\\ttry:\\n\\t\\tos.mkdir(os.path.join(SRC_PATH, \\\"../output/\\\"))\\n\\texcept Exception as e:\\n\\t\\tprint(\\\"Output Path already exists\\\")\\n\\tcv2.imwrite(Output_PATH, image)\",\n \"def score_aggregate(results):\\n scores = []\\n truth_count = detected_count = segment_count = 0\\n\\n for res in results:\\n scores.append(res[\\\"scores\\\"])\\n truth_count += len(res[\\\"labels\\\"])\\n detected_count += len(res[\\\"detected\\\"])\\n segment_count += len(res[\\\"scores\\\"][\\\"segments\\\"])\\n\\n ret = dict()\\n ret[\\\"scores\\\"] = sum_scores(scores)\\n ret[\\\"stats\\\"] = dict(truth_count=truth_count, detected_count=detected_count, segment_count=segment_count)\\n return ret\",\n \"def __getListOfActualOutput(imgFiles):\\n actualList = []\\n for f in imgFiles:\\n actual = ocr.recognizeCharacters(f)\\n actualList.append(actual)\\n return actualList\",\n \"def _get_detections(args, generator, model, score_threshold=0.05, max_detections=100, save_path=None):\\n all_detections = [[None for i in range(generator.num_classes()) if generator.has_label(i)] for j in range(generator.size())]\\n\\n detection_out = np.zeros([generator.size(),512,512,3])\\n # detection_out = np.zeros([generator.size(),512,512])\\n attention_out = np.zeros([generator.size(),512,512])\\n mask_out = np.zeros([generator.size(),512,512])\\n\\n for i in tqdm(range(generator.size()), desc='Running network: '):\\n raw_image = generator.load_image(i)\\n # image = np.expand_dims(raw_image.copy(), axis=-1)\\n # image = np.repeat(image, 3, axis=-1)\\n # image = generator.preprocess_image(image)\\n image = generator.preprocess_image(raw_image.copy())\\n image, scale = generator.resize_image(image)\\n\\n if keras.backend.image_data_format() == 'channels_first':\\n image = image.transpose((2, 0, 1))\\n\\n # run network\\n # boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))[:3]\\n boxes, scores, labels, masks, attention_map = model.predict_on_batch(np.expand_dims(image, axis=0))\\n # print('scores:', scores.shape)\\n # print('labels',labels.shape)\\n\\n # correct boxes for image scale\\n boxes /= scale\\n\\n # select indices which have a score above the threshold\\n indices = np.where(scores[0, :] > score_threshold)[0]\\n # print('indices', indices)\\n scores = scores.numpy()\\n boxes = boxes.numpy()\\n labels = labels.numpy()\\n masks = masks.numpy()\\n attention_map = attention_map.numpy()\\n # select those scores\\n scores = scores[0][indices]\\n\\n # find the order with which to sort the scores\\n scores_sort = np.argsort(-scores)[:max_detections]\\n # print(scores_sort)\\n\\n # select detections\\n image_boxes = boxes[0, indices[scores_sort], :]\\n image_scores = scores[scores_sort]\\n image_labels = labels[0, indices[scores_sort]]\\n image_detections = np.concatenate([image_boxes, np.expand_dims(image_scores, axis=1), np.expand_dims(image_labels, axis=1)], axis=1)\\n\\n if save_path is not None:\\n draw_annotations(raw_image, generator.load_annotations(i), label_to_name=generator.label_to_name)\\n draw_detections(raw_image, image_boxes, image_scores, image_labels, score_threshold=args.detection_threshold, label_to_name=generator.label_to_name)\\n\\n\\n detection_out[i, :, :] = raw_image\\n\\n attention_map[np.where(attention_map < args.attention_threshold)] = 0\\n # attention_out[i, :, :] = cv2.flip( cv2.resize(np.squeeze(np.uint8(attention_map * 255)), (origin_shape[1], origin_shape[0])), 0)\\n attention_out[i, :, :] = cv2.resize(np.squeeze(np.uint8(attention_map * 255)), (512, 512))\\n\\n masks[masks < args.segmentation_threshold] = 0\\n masks = cv2.resize(np.squeeze(np.uint8(masks * 255)), (512, 512))\\n\\n mask_out[i, :, :] = masks\\n\\n # copy detections to all_detections\\n for label in range(generator.num_classes()):\\n if not generator.has_label(label):\\n continue\\n\\n all_detections[i][label] = image_detections[image_detections[:, -1] == label, :-1]\\n if save_path is not None:\\n detection_out = sitk.GetImageFromArray(detection_out)\\n sitk.WriteImage(detection_out, os.path.join(save_path, 'detection_result.nii.gz'))\\n\\n attention_out = sitk.GetImageFromArray(attention_out)\\n sitk.WriteImage(attention_out, os.path.join(save_path, 'attention_result.nii.gz'))\\n\\n mask_out = sitk.GetImageFromArray(mask_out)\\n sitk.WriteImage(mask_out, os.path.join(save_path, 'masks_result.nii.gz'))\\n\\n return all_detections\",\n \"def print_scores(result_collector):\\n # print(\\\"\\\\n# Metric: Cohen's kappa\\\")\\n # result_collector.set_metric(['k_cohen', 'k'])\\n # result_collector.print_all_results()\\n print(\\\"\\\\n# Metric: Macro avg. F1\\\")\\n result_collector.set_metric([\\\"macro_avg\\\", \\\"fscore\\\"])\\n # result_collector.print_all_results()\\n result_collector.print_result_for_level(\\\"cc\\\")\\n result_collector.print_result_for_level(\\\"ro\\\", print_header=False)\\n result_collector.print_result_for_level(\\\"fu\\\", print_header=False)\\n result_collector.print_result_for_level(\\\"at\\\", print_header=False)\\n\\n # print(\\\"\\\\nMetric: Positive attachment F1\\\")\\n # result_collector.set_metric(['classwise', '1', 'fscore'])\\n # result_collector.print_result_for_level('at')\\n print(\\\"\\\\n# Metric: Labelled attachment score\\\")\\n result_collector.set_metric([\\\"accuracy\\\"])\\n result_collector.print_result_for_level(\\\"lat\\\")\",\n \"def save_results(self, save_data, score=None, data_name='none'):\\n img_paths = self.get_image_paths()\\n\\n for i in range(save_data.size(0)):\\n print('process image ...... %s' % img_paths[i])\\n short_path = ntpath.basename(img_paths[i]) # get image path\\n name = os.path.splitext(short_path)[0]\\n if type(score) == type(None):\\n img_name = '%s_%s.png' % (name, data_name)\\n else:\\n # d_score = score[i].mean()\\n # img_name = '%s_%s_%s.png' % (name, data_name, str(round(d_score.item(), 3)))\\n img_name = '%s_%s_%s.png' % (name, data_name, str(score))\\n # save predicted image with discriminator score\\n util.mkdir(self.opt.results_dir)\\n img_path = os.path.join(self.opt.results_dir, img_name)\\n img_numpy = util.tensor2im(save_data[i].data)\\n util.save_image(img_numpy, img_path)\\n return img_path\",\n \"def place_images(self, final_list, points):\\n\\t\\tfor i in range(8): \\n # Please change this (8) into a class-level variable --KOH\\n\\t\\t\\timage_object = final_list[i]\\n#\\t\\tif type(image_object) == 'CorrectImage':\\n#\\t\\t\\t\\tself.correct = [i, points[i]]\\n\\t\\t\\timage = pygame.image.load(image_object.file_path)\\n # Why can't these be stored as a property of the class --KOH\\n\\t\\t\\timagerect = image.get_rect()\\n\\t\\t\\treimage = pygame.transform.scale(image, image_object.size)\\n\\t\\t\\tself.screen.blit(reimage, points[i])\",\n \"def print_images_out_statistics(self):\\n self._print_images_statistics(self._images_out_folder, self._pose_class_names)\",\n \"def _get_images(self):\\n raw_outputs = self.interface.get_data(self.target_charge,\\n self.charge_deviation,\\n n_samples=self.n_samples)\\n\\n # apply roi to images\\n roi_images = []\\n for i in range(self.n_samples):\\n roi_images += [apply_roi(raw_outputs['raw_images'][i], raw_outputs['ROI'])]\\n\\n # process and identify blobs in image\\n min_size = 100\\n outputs = {}\\n for ele in self.output_keys:\\n outputs[ele] = []\\n\\n for i in range(len(roi_images)):\\n processed_image_data = image_processing.process_and_fit(roi_images[i],\\n min_size)\\n\\n for ele in self.output_keys:\\n if ele == 'image_check':\\n outputs[ele] += [image_processing.check_image(processed_image_data['binary_image'],\\n processed_image_data['smoothed_image'])]\\n elif ele == 'processed_images':\\n outputs[ele] += [processed_image_data['smoothed_image']]\\n else:\\n outputs[ele] += [processed_image_data[ele]]\\n\\n for ele in self.output_keys:\\n outputs[ele] = np.array(outputs[ele])\\n\\n # add in raw data\\n outputs.update(raw_outputs)\\n\\n # if we need to, get averaged results\\n if self.average_measurements:\\n avg_keys = ['rms_x', 'rms_y', 'CX', 'CY', 'n_blobs', 'FWHMX', 'FWHMY', 'centroid_offset']\\n for key in avg_keys:\\n outputs[key] = np.nanmean(outputs[key])\\n\\n return outputs\",\n \"def __getitem__(self, index):\\n\\n #get the image name \\n image_names = self.image_names[index]\\n\\n #make single name a list\\n if(type(image_names) is not list):\\n image_names = [image_names]\\n\\n image_target_list = []\\n for image_name in image_names:\\n\\n #build the path to the image and annotation file\\n #see format tab on Get Data page on AVD dataset website\\n if image_name[0] == '0':\\n scene_type = 'Home'\\n else:\\n scene_type = 'Office'\\n scene_name = scene_type + \\\"_\\\" + image_name[1:4] + \\\"_\\\" + image_name[4]\\n \\n #read the image and bounding boxes for this image\\n #(doesn't get the movement pointers) \\n img = (Image.open(os.path.join(self.root,scene_name, \\n images_dir,image_name)))\\n with open(os.path.join(self.root,scene_name,annotation_filename)) as f:\\n annotations = json.load(f)\\n target = annotations[image_name]['bounding_boxes'] \\n \\n #apply target transform\\n if self.target_transform is not None:\\n target = self.target_transform(target)\\n\\n #crop images for classification if flag is set\\n if self.classification:\\n img = np.asarray(img)\\n images = []\\n ids = []\\n for box in target:\\n cur_img = Image.fromarray(img[box[1]:box[3],\\n box[0]:box[2],\\n :])\\n if self.transform is not None:\\n cur_img = self.transform(cur_img)\\n images.append(cur_img)\\n ids.append(box[4])\\n\\n img = images\\n target = ids\\n \\n #apply image transform \\n if self.transform is not None:\\n img = self.transform(img)\\n\\n image_target_list.append([img,target])\\n\\n #special case for single image/label\\n if(len(image_target_list) == 1):\\n image_target_list = image_target_list[0]\\n\\n return image_target_list\",\n \"def detect_objects(self, image):\\n preprocessed_image = self._preprocess_image(image)\\n\\n # Feed the input image to the model\\n self._set_input_tensor(preprocessed_image)\\n self._interpreter.invoke()\\n\\n # Get all outputs from the model\\n boxes = self._get_output_tensor(0)\\n classes = self._get_output_tensor(1)\\n scores = self._get_output_tensor(2)\\n count = int(self._get_output_tensor(3))\\n\\n results = []\\n for i in range(count):\\n if scores[i] >= self.THRESHOLD:\\n result = {\\n 'bounding_box': boxes[i],\\n 'class_id': classes[i],\\n 'score': scores[i]\\n }\\n results.append(result)\\n return results\",\n \"def load_images(self, target = \\\"standard\\\", path=OMNIGLOT_DATAPATH):\\n X = []\\n Y = []\\n folderName = {}\\n if target == \\\"standard\\\":\\n trainFolders = [\\\"images_background\\\"]\\n testFolders = [\\\"images_evaluation\\\"]\\n elif target == \\\"minimal\\\":\\n trainFolders = [\\\"images_background_small1\\\", \\\"images_background_small2\\\"]\\n testFolders = [\\\"images_evaluation\\\"]\\n \\n if self.train:\\n for trainFolder in trainFolders:\\n folderPath = os.path.join(path, trainFolder)\\n imgAllCount = 0 # this is counted for the whole images in all alphabet\\n chaAllCount = 0 # this is counted for the whole characters in all alphabet\\n\\n for alphabet in sorted(os.listdir(folderPath)):\\n alphabetPath = os.path.join(folderPath, alphabet)\\n folderName[alphabet] = {'totalChar': 0, 'charIndex': [], 'totalImg': 0, 'imgIndex': []}\\n \\n imgAlphabetCount = 0 # this is counted for the number of images in this alphabet\\n chaAlphabetCount = 0 # this is counted for the number of character in this alphabet\\n\\n folderName[alphabet]['charIndex'].append(chaAllCount)\\n folderName[alphabet]['imgIndex'].append(imgAllCount)\\n \\n for letter in sorted(os.listdir(alphabetPath)):\\n letterPath = os.path.join(alphabetPath, letter)\\n \\n for letterImage in os.listdir(letterPath):\\n imagePath = os.path.join(letterPath, letterImage)\\n image = mpimg.imread(imagePath)\\n X.append(image)\\n Y.append(chaAllCount)\\n \\n imgAlphabetCount += 1\\n imgAllCount += 1\\n\\n chaAlphabetCount += 1\\n chaAllCount += 1\\n \\n folderName[alphabet]['totalChar'] = chaAlphabetCount\\n folderName[alphabet]['totalImg'] = imgAlphabetCount\\n folderName[alphabet]['charIndex'].append(chaAllCount-1)\\n folderName[alphabet]['imgIndex'].append(imgAllCount-1)\\n \\n X = np.stack(X) \\n X = X.reshape(-1, IMAGES_PER_CHARACTER, X.shape[1], X.shape[2])\\n return X, np.stack(Y), folderName\",\n \"def detect_objects(interpreter, image):\\n set_input_tensor(interpreter, image)\\n interpreter.invoke()\\n\\n # Get all output details\\n #boxes = get_output_tensor(interpreter, 0)\\n classes = get_output_tensor(interpreter, 1)\\n scores = get_output_tensor(interpreter, 2)\\n #count = int(get_output_tensor(interpreter, 3))\\n\\n #results = []\\n #for i in range(count):\\n # if scores[i] >= threshold:\\n # result = {\\n # #'bounding_box': boxes[i],\\n # 'class_id': classes[i],\\n # 'score': scores[i]\\n # }\\n # results.append(result)\\n \\n \\n #print(\\\"detection results:\\\\n\\\" + str(results))\\n #return results\\n return np.array([int(_class) for _class in classes]), np.array(scores)\",\n \"def results_aggregator(self, names):\\n\\t\\tfor name in names:\\n\\t\\t\\tresult = self.main(name)\\n\\t\\t\\tself.results.append(result)\\n\\t\\t\\tprint(\\\"'%s' has been written to the file.\\\" % result[0])\\n\\t\\t\\t\\\"\\\"\\\"result is formatted name, number, rating, review count\\\"\\\"\\\"\",\n \"def get_images(image_folder_root, image_label_list):\\n file_dcm=[]\\n X = []\\n y = []\\n for file_name,label in image_label_list:\\n try:\\n current_file = pydicom.dcmread(image_folder_root + file_name + '.dcm')\\n pixel_array = current_file.pixel_array\\n if (pixel_array.shape != (512,512)):\\n continue\\n file_dcm.append((file_name,label,brain_window(current_file)))\\n y.append(label)\\n X.append(pydicom.dcmread(image_folder_root + file_name + '.dcm').pixel_array)\\n except ValueError:\\n continue\\n return X,y\",\n \"def get_img_list(self):\\n if self.list_flag == \\\"train\\\":\\n self.img_list_all = [line.rstrip('\\\\n') for line in open(os.path.join(self.dataset_dir, 'Image_sets/car_imagenet_' + self.list_flag + '.txt'))]\\n print(\\\"Number of Train image: %d.\\\" % len(self.img_list_all))\\n\\n elif self.list_flag == \\\"val\\\":\\n self.img_list_all = [line.rstrip('\\\\n') for line in open(os.path.join(self.dataset_dir, 'Image_sets/car_imagenet_' + self.list_flag + '.txt'))]\\n print(\\\"Number of val image: %d.\\\" % len(self.img_list_all))\\n\\n return self.img_list_all\",\n \"def analyze_results(results): #, result_nonprivate):\\n res_dimensions = zip(*results)\\n mean, std = [], []\\n \\n for resdim in res_dimensions:\\n mean.append ( numpy.average(resdim) )\\n std.append ( numpy.std(resdim) )\\n\\n return mean, std\",\n \"def evaluate(self, test_data):\\n test_results = [(self.decide(self.feedforward(x)), y)\\n for (x, y) in test_data]\\n\\n # Check for and keep track of TP's FP's and FN's\\n # Write FP's and FN's to a special directories\\n TP = FP = FN = count = 0\\n TN = 0\\n # what you got = x, what should be = y\\n for ((x, y), (image, gt)) in zip(test_results, test_data):\\n count += 1\\n if x == 1 and y == 1:\\n TP += 1\\n elif x == 1 and y == 0:\\n FP += 1\\n if not self.validating: self.save_Image(FP_PATH, count, image)\\n elif x == 0 and y == 1:\\n FN += 1\\n if not self.validating: self.save_Image(FN_PATH, count, image)\\n \\n if (TP + FP ) == 0:\\n return TP, FP, FN, '---------', '---------','---------'\\n else:\\n false_rate = float(FP) / float(TP + FP)\\n\\n if (TP + FN ) == 0:\\n return TP, FP, FN, '---------', '---------', false_rate\\n else:\\n detect_rate = float(TP) / float(TP + FN)\\n\\n if (TP + FP + FN ) == 0:\\n return TP, FP, FN, '---------', detect_rate, false_rate\\n else:\\n quality_rate = float(TP) / float(TP+FP+FN)\\n \\n return TP, FP, FN, quality_rate, detect_rate, false_rate\",\n \"def transform(self, imgList):\\n res = []\\n for img in tqdm(imgList):\\n y_mean = np.mean(img, axis=1)\\n self.get_filtration(y_mean)\\n seg = self.get_segments()\\n seg = sorted(seg, key=lambda x:x[0])\\n res.append(seg)\\n return res\",\n \"def get_results(nres, pres):\\n # for the average accuracy at the end\\n tot_acc = 0.0\\n\\n # for each iteration display the results\\n for i in range(3):\\n\\n accuracy = float(nres[i][2]+pres[i][2]) / (nres[i][0]+pres[i][0])\\n tot_acc += accuracy\\n\\n print \\\"iteration %d\\\" % (i+1)\\n print \\\"num_neg_test_docs: %d\\\" % nres[i][0]\\n print \\\"num_neg_training_docs: %d\\\" % nres[i][1]\\n print \\\"num_neg_correct_docs: %d\\\" % nres[i][2]\\n print \\\"num_pos_test_docs: %d\\\" % pres[i][0]\\n print \\\"num_pos_training_docs: %d\\\" % pres[i][1]\\n print \\\"num_pos_correct_docs: %d\\\" % pres[i][2]\\n print \\\"accuracy: \\\", \\\"{:.2%}\\\".format(accuracy)\\n print \\\"---------------------------------\\\"\\n\\n ave_acc = tot_acc / 3.0\\n print \\\"ave_accuracy: \\\", \\\"{:.2%}\\\".format(ave_acc)\",\n \"def explore_data():\\n labels = [\\\"vehicles\\\", \\\"non-vehicles\\\"]\\n labelmap = {0: \\\"vehicles\\\", 1: \\\"non-vehicles\\\"}\\n vehicles_glob = os.path.join(data_dir, \\\"vehicles\\\", \\\"**\\\", \\\"*.png\\\")\\n nonvehicles_glob = os.path.join(data_dir, \\\"non-vehicles\\\", \\\"**\\\", \\\"*.png\\\")\\n class_fnames = [\\n glob.glob(vehicles_glob, recursive = True),\\n glob.glob(nonvehicles_glob, recursive = True)]\\n n_samples = [len(fnames) for fnames in class_fnames]\\n shapes = []\\n samples = []\\n print(table_format([\\\"label\\\", \\\"size\\\", \\\"shape\\\"], header = True))\\n for label, fnames in enumerate(class_fnames):\\n indices = np.random.choice(len(fnames), 4*10, replace = False)\\n for i in indices:\\n fname = fnames[i]\\n img = cv2.imread(fname)\\n samples.append(img)\\n shape = img.shape\\n shapes.append(shape)\\n print(table_format([labels[label], n_samples[label], shapes[label]]))\\n\\n samples = np.stack(samples)\\n samples = tile(samples, 2*4, 10)\\n cv2.imwrite(os.path.join(out_dir, \\\"datasamples.png\\\"), samples)\\n\\n return class_fnames, labelmap\",\n \"def test(self, C, W, sigma, label_list, H_list):\\n\\n for a_dir_test in os.listdir(self.path_test_dir):\\n\\n num_data, data_array = self.exfile_manager.get_data(os.path.join(self.path_test_dir, a_dir_test))\\n estimated_labels = self.post_process_manager.estimate_data_category(C, W, sigma, label_list, H_list,\\n data_array)\\n for (index, data), estimated_label in zip(enumerate(data_array), estimated_labels):\\n path_to_file = os.path.join(self.dir_for_saving_result, '%s_%d.jpg' % (a_dir_test, index))\\n\\n data = (data / np.max(data)) * 255\\n\\n Image.fromarray(np.uint8(\\n (np.reshape(data, (self.width, self.height))))).save(\\n path_to_file)\\n self.line_ui_manager.send_line(\\n 'RBM: %s\\\\nTRUE: %s\\\\n' % (estimated_label, a_dir_test,),\\n path_to_file)\",\n \"def compute_scores(self):\\n if self.num_classes == 2:\\n score_1 = self.competition_metric(\\n helmet_threshold=0.5,\\n impact_threshold=0.5,\\n )[1]\\n\\n score_2 = self.competition_metric(\\n helmet_threshold=0.5,\\n impact_threshold_ratio=0.5,\\n )[1]\\n\\n score_3 = self.competition_metric(\\n impact_threshold=0.5,\\n )[1]\\n else:\\n score_1 = self.detection_metric(threshold=0.1)\\n score_2 = self.detection_metric(threshold=0.25)\\n score_3 = self.detection_metric(threshold=0.5)\\n\\n return score_1, score_2, score_3\",\n \"def get_list(self):\\n for match in self.matches:\\n img_pixel = [int(self.featureA[match.queryIdx].pt[0]), int(self.featureA[match.queryIdx].pt[1])]\\n depth = aligned_depth_frame.get_distance(img_pixel[0], img_pixel[1])\\n point_a = rs.rs2_deproject_pixel_to_point(self.intrin, img_pixel, depth)\\n point_a = [point_a[0], point_a[2], 1]\\n img_pixel = [int(self.featureB[match.trainIdx].pt[0]), int(self.featureB[match.trainIdx].pt[1])]\\n depth = aligned_depth_frame.get_distance(img_pixel[0], img_pixel[1])\\n point_b = rs.rs2_deproject_pixel_to_point(self.intrin, img_pixel, depth)\\n point_b = [point_b[0], point_b[2], 1]\\n self.listA.append(point_a)\\n self.listB.append(point_b)\",\n \"def __call__(self, results):\\r\\n if isinstance(results['img'], str):\\r\\n results['filename'] = results['img']\\r\\n results['ori_filename'] = results['img']\\r\\n else:\\r\\n results['filename'] = None\\r\\n results['ori_filename'] = None\\r\\n img = mmcv.imread(results['img'])\\r\\n results['img'] = img\\r\\n results['img_fields'] = ['img']\\r\\n results['img_shape'] = img.shape\\r\\n results['ori_shape'] = img.shape\\r\\n return results\",\n \"def inception_score(images):\\n height, width = 90, 90\\n\\n images = np.array([np.array(Image.fromarray(x, mode=\\\"RGB\\\").resize((height, width))) for x in np.reshape(images, (-1, 28, 28, 3))]) / 255. # Transform images to a suitable form\\n\\n with loaded_model[0].as_default():\\n predictions = loaded_model[1].predict(images)\\n preds = np.argmax(predictions, axis=1)\\n aux_preds = np.zeros(10)\\n unique, counts = np.unique(preds, return_counts=True)\\n for number, appearances in zip(unique, counts):\\n aux_preds[number] = appearances\\n aux_preds = aux_preds / predictions.shape[0]\\n predictions = np.sort(predictions, axis=1)\\n predictions = np.mean(predictions, axis=0)\\n\\n sam_error = np.sum([aux_preds[w] * np.log(aux_preds[w] / predictions[w]) if aux_preds[w] > 0 else 0 for w in range(predictions.shape[0])])\\n\\n return sam_error\",\n \"def load_labeled_data():\\n\\n images = []\\n labels = []\\n\\n for i in range(1, 10):\\n path = (\\\"selflabeled\\\", str(i), \\\"*.jpg\\\")\\n filenames = glob.glob(\\\"/\\\".join(path))\\n images_one_type = [cv2.imread(img) for img in filenames]\\n labels_one_type = [i] * len(images_one_type)\\n images += images_one_type\\n labels += labels_one_type\\n\\n return images, labels\",\n \"def load_defects(self, val_dir):\\n \\n img_list_1 = os.listdir(val_dir+'/'+'1')\\n img_list_2 = os.listdir(val_dir+'/'+'2')\\n img_list_3 = os.listdir(val_dir+'/'+'3')\\n img_list_4 = os.listdir(val_dir+'/'+'4')\\n\\n\\n\\n img_list_1 = self.make_imgs_list(val_dir + '/' + '1', img_list_1)\\n img_list_2 = self.make_imgs_list(val_dir + '/' + '2', img_list_2)\\n img_list_3 = self.make_imgs_list(val_dir + '/' + '3', img_list_3)\\n img_list_4 = self.make_imgs_list(val_dir + '/' + '4', img_list_4)\\n\\n\\n img_list_1 = self.load_imgsLabels(img_list_1)\\n img_list_2 = self.load_imgsLabels(img_list_2)\\n img_list_3 = self.load_imgsLabels(img_list_3)\\n img_list_4 = self.load_imgsLabels(img_list_4)\\n\\n\\n img_list_1 = self.features_to_np_array(img_list_1)\\n img_list_2 = self.features_to_np_array(img_list_2)\\n img_list_3 = self.features_to_np_array(img_list_3)\\n img_list_4 = self.features_to_np_array(img_list_4)\\n\\n lbl_list_1 = img_list_1.shape[0]*[1]\\n lbl_list_2 = img_list_2.shape[0]*[2]\\n lbl_list_3 = img_list_3.shape[0]*[3]\\n lbl_list_4 = img_list_4.shape[0]*[4]\\n\\n\\n imgs = np.concatenate((img_list_1, img_list_2, img_list_3, img_list_4))\\n lbls = lbl_list_1 + lbl_list_2 + lbl_list_3 + lbl_list_4\\n\\n\\n lbls = np.array(lbls)\\n \\n lbls = lbls - 1\\n \\n lbls = to_categorical(lbls)\\n \\n return imgs, lbls\",\n \"def display_imgs(img_dir,img_list):\\n for img in img_list:\\n display_img(img_dir, img)\",\n \"def stim_generate(params,stim_list,train):\\n if train:\\n stim = list(stim_list.keys())\\n shuffled_stim = shuffled_images = []\\n #for each run get equal amounts of stim and shuffle\\n #can only work if 'trials_per_run' is divisible by number of stims\\n for run in range(params['runs']):\\n temp_list = stim * int(params['trials_per_run']/len(stim))\\n random.shuffle(temp_list)\\n shuffled_stim = shuffled_stim + temp_list\\n for stim in shuffled_stim:\\n shuffled_images.append(stim_list[stim])\\n else:\\n #open the test stim images\\n images = []\\n for each in os.listdir(stim_list):\\n if '.DS_Store' not in each:\\n img = os.path.join(stim_list,each)\\n images.append([img,img])\\n\\n #randomize images\\n random.shuffle(images)\\n\\n #split images into matches and not matches\\n matches,not_matches = images[:len(images)//2],images[len(images)//2:]\\n\\n #shift the image list so that the pictures dont match\\n not_matches = shift_list(not_matches)\\n\\n #combine matches and not matches and randomize order\\n shuffled_images = matches + not_matches\\n random.shuffle(shuffled_images)\\n\\n #get category labels\\n shuffled_stim = []\\n for img in shuffled_images:\\n if img[0] == img[1]:\\n shuffled_stim.append(\\\"match\\\")\\n else:\\n shuffled_stim.append(\\\"not match\\\")\\n\\n return(shuffled_stim,shuffled_images)\",\n \"def get_all_image_names(self):\\n\\n # for RD analysis ...\\n\\n result = []\\n for sweep in self._sweeps:\\n result.extend(sweep.get_all_image_names())\\n return result\",\n \"def getImgList(id_classe):\\n f=open('csv_files/test-annotations-bbox.csv',\\\"r\\\",encoding='utf8')\\n img_list0 = []\\n img_list = []\\n a = 0\\n nb_img = parser_arguments().limit\\n for l in f:\\n if id_classe in l:\\n mots = l.split(\\\",\\\")\\n id_img = mots[0]\\n img_list0.append(id_img)\\n # lists all the identifiers of the images present in the requested class\\n\\n while a < nb_img:\\n img_list.append(random.choice(img_list0))\\n a = a+1\\n return img_list\\n # select randomly in the previous list the required number (requested in the terminal) of image identifiers and store them in a new list\",\n \"def compute_score(self, gts, res):\\n\\n assert(gts.keys() == res.keys())\\n imgIds = gts.keys()\\n\\n cider_scorer = CiderScorer(n=self._n, sigma=self._sigma, \\n document_frequency=self._doucument_frequency, \\n ref_len=self._ref_len)\\n\\n for id in imgIds:\\n hypo = res[id]\\n ref = gts[id]\\n\\n # Sanity check.\\n assert(type(hypo) is list)\\n assert(len(hypo) == 1)\\n assert(type(ref) is list)\\n assert(len(ref) > 0)\\n\\n cider_scorer += (hypo[0], ref)\\n\\n (score, scores) = cider_scorer.compute_score()\\n\\n return score, scores\",\n \"def __getitem__(self, index):\\n\\n #get the image name and box\\n #image_name,box_index = self.name_and_box_index[index]\\n name_and_index = self.name_and_box_index[index]\\n #name_and_index needs to be alist of lists\\n if(len(name_and_index) >0 and type(name_and_index[0]) is not list): \\n name_and_index = [name_and_index] \\n \\n image_target_list = []\\n\\n for image_name,box_index in name_and_index:\\n #build the path to the image and annotation file\\n #see format tab on Get Data page on AVD dataset website\\n if image_name[0] == '0':\\n scene_type = 'Home'\\n else:\\n scene_type = 'Office'\\n scene_name = scene_type + \\\"_\\\" + image_name[1:4] + \\\"_\\\" + image_name[4]\\n \\n #read the image and bounding boxes for this image\\n #(doesn't get the movement pointers) \\n img = (Image.open(os.path.join(self.root,scene_name, \\n images_dir,image_name)))\\n with open(os.path.join(self.root,scene_name,annotation_filename)) as f:\\n annotations = json.load(f)\\n target = annotations[image_name]['bounding_boxes'] \\n \\n #apply target transform\\n if self.target_transform is not None:\\n target = self.target_transform(target)\\n\\n #get the single box\\n target = target[box_index]\\n\\n #crop images for classification if flag is set\\n if self.classification:\\n img = np.asarray(img)\\n img = img[target[1]:target[3],target[0]:target[2],:]\\n img = Image.fromarray(img)\\n target = target[4] \\n \\n \\n #apply image transform \\n if self.transform is not None:\\n img = self.transform(img)\\n\\n image_target_list.append([img,target])\\n\\n #special case for single image/label\\n if(len(image_target_list) == 1):\\n image_target_list = image_target_list[0]\\n\\n return image_target_list\",\n \"def _yield_testing(self, batch_index):\\n samples_start = batch_index % self.num_samples\\n samples_end = (batch_index+1) % self.num_samples\\n if samples_start < samples_end:\\n batch_samples = self.test_data[samples_start:samples_end]\\n else:\\n batch_samples = self.test_data[samples_start:]\\n batch_samples.extend(self.test_data[:samples_end])\\n images = []\\n rois = []\\n for sample in batch_samples:\\n # 'sample' has this structure:\\n # {path: {\\n # 'roi_origin_x': test_sample[1]['roi_origin_x'],\\n # 'roi_origin_y': test_sample[1]['roi_origin_y'],\\n # 'roi_width': test_sample[1]['roi_width'],\\n # 'roi_height': test_sample[1]['roi_height'] \\n # } \\n # }\\n img_path = os.path.join(self.dataset_root_path, list(sample.keys())[0])\\n img = cv2.imread(img_path) # watch out for slashes (/)\\n # if the path does not exist or there are problems while reading the image\\n if img is None:\\n print('[DATA LOADER ERROR] cannot find image at path: ', img_path)\\n continue\\n roi_data = list(sample.values())[0]\\n roi = {\\n 'upper_left_x': roi_data['roi_origin_x'],\\n 'upper_left_y': roi_data['roi_origin_y'],\\n 'width': roi_data['roi_width'],\\n 'height': roi_data['roi_height']\\n }\\n img = img.astype('float32')\\n images.append(img)\\n rois.append(roi)\\n return images, rois\",\n \"def translate_images(estimator, test_images_list, label, checkpoint_path, num_domains):\\n img_rows = []\\n\\n def test_input_fn():\\n dataset_lbls = [tf.one_hot([label], num_domains)] * len(test_images_list)\\n\\n # Make into a dataset.\\n dataset_imgs = np.stack(test_images_list)\\n dataset_imgs = np.expand_dims(dataset_imgs, 1)\\n dataset_lbls = tf.stack(dataset_lbls)\\n unused_tensor = tf.zeros(len(test_images_list))\\n return tf.data.Dataset.from_tensor_slices(((dataset_imgs, dataset_lbls),\\n unused_tensor))\\n\\n prediction_iterable = estimator.predict(test_input_fn, checkpoint_path=checkpoint_path)\\n predictions = [next(prediction_iterable) for _ in range(len(test_images_list))] # range(len(test_images_list))]\\n normalized_summary = [(result + 1.0) / 2.0 for result in predictions]\\n return normalized_summary\",\n \"def classify_images():\\n\\n # Load the desired image\\n img_path = 'dataset/colorize_images/n02085782_919.jpg'\\n img = image.load_img(img_path, target_size=(299, 299))\\n x = image.img_to_array(img)\\n x = np.expand_dims(x, axis=0)\\n x = preprocess_input(x)\\n\\n model = InceptionV3(weights=\\\"imagenet\\\")\\n preds = model.predict(x)\\n # decode the results into a list of tuples (class, description, probability)\\n # (one such list for each sample in the batch)\\n print('Predicted:', decode_predictions(preds, top=3)[0])\",\n \"def classify_all_images(cc):\\n print 'Classify images'\\n images = cc.d.images\\n for img_idx in range(comm_rank, len(images), comm_size): # PARALLEL\\n print 'classify image %d/%d at %d'%(img_idx/comm_size, len(images)/comm_size, comm_rank)\\n img = images[img_idx]\\n scores = classify_image(cc, img_idx)\\n savefile = config.get_classifier_score_name(img, cc.L)\\n cPickle.dump(scores, open(savefile,'w'))\",\n \"def report_result(args, model, imgs, poses, hwf, bound):\\n ray_origins, ray_directions = get_rays_shapenet(hwf, poses)\\n\\n view_psnrs = []\\n for img, rays_o, rays_d in zip(imgs, ray_origins, ray_directions):\\n rays_o, rays_d = rays_o.reshape(-1, 3), rays_d.reshape(-1, 3)\\n t_vals, xyz = sample_points(rays_o, rays_d, bound[0], bound[1],\\n args.num_samples, perturb=False)\\n \\n synth = []\\n num_rays = rays_d.shape[0]\\n with torch.no_grad():\\n for i in range(0, num_rays, args.test_batchsize):\\n rgbs_batch, sigmas_batch = model(xyz[i:i+args.test_batchsize])\\n color_batch = volume_render(rgbs_batch, sigmas_batch,\\n t_vals[i:i+args.test_batchsize],\\n white_bkgd=True)\\n synth.append(color_batch)\\n synth = torch.cat(synth, dim=0).reshape_as(img)\\n error = F.mse_loss(img, synth)\\n psnr = -10*torch.log10(error)\\n view_psnrs.append(psnr)\\n \\n scene_psnr = torch.stack(view_psnrs).mean()\\n return scene_psnr\",\n \"def returnImages(input_data):\\r\\n if type(input_data) is list:\\r\\n return [returnImages(element) for element in input_data]\\r\\n else:\\r\\n return cv.imread(input_data, 0)\",\n \"def parse(self):\\n imset = []\\n imdir = remkdir(os.path.join(self._datadir, 'images'))\\n csv_actors = readcsv(os.path.join(self._datadir, 'facescrub_actors.txt'), separator='\\\\t')\\n for (subjectname, imageid, faceid, url, bbox, sha256) in csv_actors[1:]:\\n categoryname = subjectname.replace(' ', '_')\\n (xmin,ymin,xmax,ymax) = bbox.split(',')\\n imset.append(ImageDetection(url=url, filename=os.path.join(imdir, '%s_%s.jpg' % (categoryname, imageid)), category=categoryname, xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax, attributes={'GENDER':'male'}))\\n\\n csv_actresses = readcsv(os.path.join(self._datadir, 'facescrub_actresses.txt'), separator='\\\\t')\\n for (subjectname, imageid, faceid, url, bbox, sha256) in csv_actresses[1:]:\\n categoryname = subjectname.replace(' ', '_')\\n (xmin,ymin,xmax,ymax) = bbox.split(',')\\n imset.append(ImageDetection(url=url, filename=os.path.join(imdir, '%s_%s.jpg' % (categoryname, imageid)), category=categoryname, xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax, attributes={'GENDER':'female'}))\\n\\n return imset\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6683602","0.65201557","0.64013934","0.6362181","0.62997663","0.62602174","0.6209405","0.6145581","0.61233777","0.61121494","0.6098388","0.60845476","0.60814047","0.6066887","0.6045889","0.6020761","0.5991178","0.598916","0.5951274","0.5938158","0.59363616","0.5929103","0.59076095","0.5901992","0.59004587","0.58971906","0.58938557","0.5870434","0.58702666","0.586709","0.586709","0.586709","0.586686","0.586337","0.5850347","0.5840211","0.5830322","0.5825426","0.58038616","0.5798246","0.57800937","0.57726973","0.5772504","0.5772214","0.57714695","0.57686335","0.5760015","0.5748457","0.57311976","0.57237756","0.5722667","0.5720937","0.57182527","0.5690669","0.56879723","0.56873155","0.5680207","0.56736094","0.56731254","0.5663605","0.5661032","0.5657643","0.5656952","0.5655583","0.56507844","0.5641541","0.56372905","0.56364405","0.5635153","0.5634857","0.5630973","0.562463","0.5622105","0.56201077","0.56180507","0.5615507","0.56047","0.56043386","0.56000316","0.55976796","0.5596146","0.55825686","0.5581697","0.55748266","0.55707675","0.55697346","0.55647784","0.55364615","0.55243415","0.55242026","0.5518288","0.55054295","0.5505078","0.5504884","0.55004984","0.5500424","0.5500119","0.5498462","0.54981107","0.5498039"],"string":"[\n \"0.6683602\",\n \"0.65201557\",\n \"0.64013934\",\n \"0.6362181\",\n \"0.62997663\",\n \"0.62602174\",\n \"0.6209405\",\n \"0.6145581\",\n \"0.61233777\",\n \"0.61121494\",\n \"0.6098388\",\n \"0.60845476\",\n \"0.60814047\",\n \"0.6066887\",\n \"0.6045889\",\n \"0.6020761\",\n \"0.5991178\",\n \"0.598916\",\n \"0.5951274\",\n \"0.5938158\",\n \"0.59363616\",\n \"0.5929103\",\n \"0.59076095\",\n \"0.5901992\",\n \"0.59004587\",\n \"0.58971906\",\n \"0.58938557\",\n \"0.5870434\",\n \"0.58702666\",\n \"0.586709\",\n \"0.586709\",\n \"0.586709\",\n \"0.586686\",\n \"0.586337\",\n \"0.5850347\",\n \"0.5840211\",\n \"0.5830322\",\n \"0.5825426\",\n \"0.58038616\",\n \"0.5798246\",\n \"0.57800937\",\n \"0.57726973\",\n \"0.5772504\",\n \"0.5772214\",\n \"0.57714695\",\n \"0.57686335\",\n \"0.5760015\",\n \"0.5748457\",\n \"0.57311976\",\n \"0.57237756\",\n \"0.5722667\",\n \"0.5720937\",\n \"0.57182527\",\n \"0.5690669\",\n \"0.56879723\",\n \"0.56873155\",\n \"0.5680207\",\n \"0.56736094\",\n \"0.56731254\",\n \"0.5663605\",\n \"0.5661032\",\n \"0.5657643\",\n \"0.5656952\",\n \"0.5655583\",\n \"0.56507844\",\n \"0.5641541\",\n \"0.56372905\",\n \"0.56364405\",\n \"0.5635153\",\n \"0.5634857\",\n \"0.5630973\",\n \"0.562463\",\n \"0.5622105\",\n \"0.56201077\",\n \"0.56180507\",\n \"0.5615507\",\n \"0.56047\",\n \"0.56043386\",\n \"0.56000316\",\n \"0.55976796\",\n \"0.5596146\",\n \"0.55825686\",\n \"0.5581697\",\n \"0.55748266\",\n \"0.55707675\",\n \"0.55697346\",\n \"0.55647784\",\n \"0.55364615\",\n \"0.55243415\",\n \"0.55242026\",\n \"0.5518288\",\n \"0.55054295\",\n \"0.5505078\",\n \"0.5504884\",\n \"0.55004984\",\n \"0.5500424\",\n \"0.5500119\",\n \"0.5498462\",\n \"0.54981107\",\n \"0.5498039\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5793339"},"document_rank":{"kind":"string","value":"40"}}},{"rowIdx":92877,"cells":{"query":{"kind":"string","value":"Load the STS Benchmark csv format."},"document":{"kind":"string","value":"def load_file(fpath):\n sick_data = {'X_A': [], 'X_B': [], 'y': []}\n with open(fpath, 'r', encoding='utf-8') as f:\n for line in f:\n text = line.strip().split('\\t')\n sick_data['X_A'].append(text[5].split())\n sick_data['X_B'].append(text[6].split())\n sick_data['y'].append(float(text[4]))\n return sick_data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def runs_loader(path):\n files = sorted(glob.glob(f\"{path}/*_runs.csv\"))\n df_lis = list(range(len(files)))\n for i, f in enumerate(files):\n try:\n df_lis[i] = pd.read_csv(f, sep=\",\", header=0)\n print('Read runs.csv\\n', f, df_lis[i].shape,\n df_lis[i]['dataset__id'][0], df_lis[i]['pipeline__id'][0])\n except Exception as e:\n print(e)\n continue\n df = pd.concat(df_lis, axis=0, sort=False).reset_index()\n # with pd.option_context('display.max_rows', None,\n # 'display.max_columns', None):\n # msg = tabulate.tabulate(df, headers='keys', tablefmt='psql')\n # print(msg)\n return df","def loadCSV(input_file):","def test_load_csv_file():\n data = loader.load_csv_file(\"buildup/reference/comsol_solution/lofi/voltage.csv.bz2\")\n\n assert data.any()","def load_file(name):\n return pd.read_csv(join(path_here, \"syserol/data/\" + name + \".csv\"), delimiter=\",\", comment=\"#\")","def CSV_Load_File( self, infilename ):\n print( 'Loading \"{}\"'.format(infilename) )\n IN = open( infilename, 'r' )\n standname = None\n laststand = None\n for L in IN:\n if( L[0:9] == 'Site/Plot' ): continue\n col = L.split( ',' )\n standname = col[0]\n year = int(col[1])\n #if( re.search( '-', standname ) != None ):\n # loc = re.search( '-', standname )\n # year = int(standname[loc.start()+1:])\n # standname = standname[0:loc.start()]\n #print standname, year\n if( (standname != None ) & (standname != laststand) ): self.Data.Stand[standname] = StandData( standname )\n (treeno, species, dbh, ht, live, status, cclass, tpa) = \\\n (int(col[2]), col[3], float(col[4]), float(col[5]), col[6], col[7], int(float(col[8])), float(col[9]))\n if( OPT['d'] ):\n if( dbh > 10.0 ): dbh *= 1.25\n if( dbh > 15.0 ): dbh *= 1.50\n for t in range( 1, int( math.ceil( tpa ))+1, 1 ):\n ntree = len( self.Data.Stand[standname].Tree ) + 1\n self.Data.Stand[standname].Tree[ntree] = TreeData( species, TreeNumber=treeno )\n self.Data.Stand[standname].Tree[ntree].Year[year] = MeasurementData( dbh, ht, '', 1, live, status, cclass )\n laststand = standname\n IN.close()","def run(args):\n with open(args.config, \"r\") as f:\n config = yaml.load(f)\n\n how = config[\"load_data\"][\"how\"]\n\n if how == \"load_csvs\":\n df = load_csvs(**config[\"load_data\"][\"load_csvs\"])\n\n if args.save is not None:\n df.to_csv(args.save)","def load(self, path):\n self.df = pd.read_csv(path)\n print(\"Loaded data from {}\".format(path))","def _load(self):\n op_type_file_path = os.path.join(\n self._profiling_dir,\n self._csv_file_to_analyse.format(self._device_id)\n )\n op_type_file_path = validate_and_normalize_path(\n op_type_file_path, raise_key=\"Invalid op_type_file_path\")\n if not os.path.isfile(op_type_file_path):\n log.warning('The file <%s> does not exist.', op_type_file_path)\n return\n\n with open(op_type_file_path, 'r') as file:\n csv_reader = csv.reader(file)\n _ = next(csv_reader)\n for info in csv_reader:\n self._data.append(self._convert_field_type(info))","def download_stsb(dataset_path=\"\"):\n stsb_dataset_path = os.path.join(dataset_path, \"stsb.tar.gz\")\n csv_fieldnames = [\"sect\", \"dataset\", \"year\", \"id\", \"score\", \"sentence1\", \"sentence2\"]\n url = \"http://ixa2.si.ehu.es/stswiki/images/4/48/Stsbenchmark.tar.gz\"\n urllib.request.urlretrieve(url, stsb_dataset_path)\n\n train_samples = []\n dev_samples = []\n test_samples = []\n\n with tarfile.open(stsb_dataset_path, \"r:gz\", encoding=\"utf-8\") as tar:\n for split in [\"train\", \"dev\", \"test\"]:\n with tar.extractfile(f\"stsbenchmark/sts-{split}.csv\") as f:\n ft = codecs.getreader(\"utf-8\")(f)\n reader = csv.DictReader(ft,\n delimiter=\"\\t\",\n quoting=csv.QUOTE_NONE,\n fieldnames=csv_fieldnames)\n for row in reader:\n # Normalize scores to range [0,1]\n score = float(row['score']) / 5.0\n sample = {\n \"sentence1\": row[\"sentence1\"],\n \"sentence2\": row[\"sentence2\"],\n \"score\": score\n }\n\n if split == \"train\":\n train_samples.append(sample)\n elif split == \"dev\":\n dev_samples.append(sample)\n elif split == \"test\":\n test_samples.append(sample)\n\n keys = [\"sentence1\", \"sentence2\", \"score\"]\n\n output_path = os.path.join(dataset_path, \"stsb_train.csv\")\n with open(output_path, \"w\", newline=\"\") as out:\n dict_writer = csv.DictWriter(out, keys)\n dict_writer.writeheader()\n dict_writer.writerows(train_samples)\n\n output_path = os.path.join(dataset_path, \"stsb_dev.csv\")\n with open(output_path, \"w\", newline=\"\") as out:\n dict_writer = csv.DictWriter(out, keys)\n dict_writer.writeheader()\n dict_writer.writerows(dev_samples)\n\n output_path = os.path.join(dataset_path, \"stsb_test.csv\")\n with open(output_path, \"w\", newline=\"\") as out:\n dict_writer = csv.DictWriter(out, keys)\n dict_writer.writeheader()\n dict_writer.writerows(test_samples)","def load():\n filepath = dirname(abspath(__file__))\n##### EDIT THE FOLLOWING TO POINT TO DatasetName.csv #####\n data = recfromtxt(open(filepath + '/spector.csv',\"rb\"), delimiter=\" \",\n names=True, dtype=float, usecols=(1,2,3,4))\n names = list(data.dtype.names)\n endog = array(data[names[3]], dtype=float)\n endog_name = names[3]\n exog = column_stack(data[i] for i in names[:3]).astype(float)\n exog_name = names[:3]\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\n endog_name = endog_name, exog_name=exog_name)\n return dataset","def _read_csvs(self):\n self.data = pd.read_csv(self.path+self.name, index_col=0)","def LoadBatch(filename):","def load_stir_tracer(tracer_id, model):\n filepath = paths.stir_filepath(tracer_id, model=model)\n table = pd.read_csv(filepath, header=None, skiprows=2, delim_whitespace=True)\n table.columns = tables_config.stir_columns\n return table","def dataLoad():\n try:\n try: #Python3\n f = open(__file__ + \".csv\",\"rt\")\n except: #Python2\n f = open(__file__ + \".csv\",\"rb\")\n data = f.read().split(',')\n entryCol.entry0.delete(0,END)\n entryCol.entry0.insert(0,data[0])\n entryCol.entry1.delete(0,END)\n entryCol.entry1.insert(0,data[1])\n entryCol.entry2.delete(0,END)\n entryCol.entry2.insert(0,data[2])\n entryCol.entry3.delete(0,END)\n entryCol.entry3.insert(0,data[3])\n botWind.writeN(\"DataLoad: File\")\n except:\n botWind.writeN(\"DataLoad: Default\")","def __loaddata(filename, datatype='flightcsv', minprob=0.001, maxprob=0.20):\n if datatype is 'flightcsv':\n return extract_flight_csv(filename, minprob=minprob, maxprob=maxprob)\n else:\n raise Exception('unknown datatype %s' % datatype)","def read_csv():","def load_csv(self):\n self.database = pd.read_csv(\n self.settings['database_path'],\n encoding='utf-8')","def load_steels():\n path = os.path.join(DATA_DIR, \"yieldstrength-citrination-312.csv\")\n df = pd.read_csv(path, index_col=False)\n return df","def load_database(self, fsp='Species'):\n self.df_species = pd.read_csv(fsp + '.csv', header=0,\n index_col=0)","def import_scores_from_csv(f):\n print(f)\n with open(os.path.join(STATIC_ROOT, 'dataset.csv'), 'wb+') as destination:\n for chunk in f.chunks():\n destination.write(chunk)\n return None","def load_CSV_data(path):\n return np.genfromtxt(os.path.join('data/traffic_data', path))","def load_gt(path):\n train_results = []\n with open(path) as csv_file:\n reader = csv.reader(csv_file, delimiter=\",\")\n next(reader)\n for row in reader:\n train_results.append(int(row[1]))\n return np.array(train_results)","def run_load(rootpath):\n global CSV_PATH\n CSV_PATH = rootpath+'/csv_files/'\n load_movies_details()\n load_movies_cast()\n load_movies_reviews()","def _load_table(table: Model, directory: Path, format_: str):\n\n if directory is not None:\n print(f\" Loading {table.table_name()}...\")\n in_file = Path(directory) / f\"{table.table_name()}.{format_}\"\n dataset = tablib.Dataset(headers=table.fields()).load(in_file.read_text())\n print(f\" Importing {table.table_name()} into the database...\")\n table.insert_many(dataset.dict).execute()\n print(\" Done.\")\n print(\"=====================\")\n else:\n pass\n # print(dataset.export(\"csv\"))","def _loadCSVFile(self):\n self._df = pd.read_csv(\n self._pathfile, sep=CSV_SEPARATOR, index_col=CSV_INDEX_COL)","def pd_load_performance_csv(performance_path, **kwargs):\n\n cols = [\n \"loan_id\", \"monthly_reporting_period\", \"servicer\", \"interest_rate\", \"current_actual_upb\",\n \"loan_age\", \"remaining_months_to_legal_maturity\", \"adj_remaining_months_to_maturity\",\n \"maturity_date\", \"msa\", \"current_loan_delinquency_status\", \"mod_flag\", \"zero_balance_code\",\n \"zero_balance_effective_date\", \"last_paid_installment_date\", \"foreclosed_after\",\n \"disposition_date\", \"foreclosure_costs\", \"prop_preservation_and_repair_costs\",\n \"asset_recovery_costs\", \"misc_holding_expenses\", \"holding_taxes\", \"net_sale_proceeds\",\n \"credit_enhancement_proceeds\", \"repurchase_make_whole_proceeds\", \"other_foreclosure_proceeds\",\n \"non_interest_bearing_upb\", \"principal_forgiveness_upb\", \"repurchase_make_whole_proceeds_flag\",\n \"foreclosure_principal_write_off_amount\", \"servicing_activity_indicator\"\n ]\n dtypes = {\n \"loan_id\": np.int64,\n \"monthly_reporting_period\": str,\n \"servicer\": str,\n \"interest_rate\": np.float64,\n \"current_actual_upb\": np.float64,\n \"loan_age\": np.float64,\n \"remaining_months_to_legal_maturity\": np.float64,\n \"adj_remaining_months_to_maturity\": np.float64,\n \"maturity_date\": str,\n \"msa\": np.float64,\n \"current_loan_delinquency_status\": np.int32,\n \"mod_flag\": CategoricalDtype(['N', 'Y']),\n \"zero_balance_code\": CategoricalDtype(['01', '02', '06', '09', '03', '15', '16']),\n \"zero_balance_effective_date\": str,\n \"last_paid_installment_date\": str,\n \"foreclosed_after\": str,\n \"disposition_date\": str,\n \"foreclosure_costs\": np.float64,\n \"prop_preservation_and_repair_costs\": np.float64,\n \"asset_recovery_costs\": np.float64,\n \"misc_holding_expenses\": np.float64,\n \"holding_taxes\": np.float64,\n \"net_sale_proceeds\": np.float64,\n \"credit_enhancement_proceeds\": np.float64,\n \"repurchase_make_whole_proceeds\": np.float64,\n \"other_foreclosure_proceeds\": np.float64,\n \"non_interest_bearing_upb\": np.float64,\n \"principal_forgiveness_upb\": np.float64,\n \"repurchase_make_whole_proceeds_flag\": CategoricalDtype(['N', 'Y']),\n \"foreclosure_principal_write_off_amount\": np.float64,\n \"servicing_activity_indicator\": CategoricalDtype(['N', 'Y']),\n }\n\n return pd.read_csv(performance_path, names=cols, delimiter='|', dtype=dtypes, parse_dates=[1,8,13,14,15,16])","def csv_data_loader(path):\n\n logging.info(\"Loading file using SparkSession\")\n csvload = Spark.instance.spark() \\\n .read \\\n .format(\"csv\") \\\n .options(header=True) \\\n .options(mode=\"DROPMALFORMED\")\n\n return csvload.option(\"inferSchema\", \"true\").load(path)","def pd_load_performance_csv(performance_path, **kwargs):\n\n cols = [\n \"loan_id\", \"monthly_reporting_period\", \"servicer\", \"interest_rate\", \"current_actual_upb\",\n \"loan_age\", \"remaining_months_to_legal_maturity\", \"adj_remaining_months_to_maturity\",\n \"maturity_date\", \"msa\", \"current_loan_delinquency_status\", \"mod_flag\", \"zero_balance_code\",\n \"zero_balance_effective_date\", \"last_paid_installment_date\", \"foreclosed_after\",\n \"disposition_date\", \"foreclosure_costs\", \"prop_preservation_and_repair_costs\",\n \"asset_recovery_costs\", \"misc_holding_expenses\", \"holding_taxes\", \"net_sale_proceeds\",\n \"credit_enhancement_proceeds\", \"repurchase_make_whole_proceeds\", \"other_foreclosure_proceeds\",\n \"non_interest_bearing_upb\", \"principal_forgiveness_upb\", \"repurchase_make_whole_proceeds_flag\",\n \"foreclosure_principal_write_off_amount\", \"servicing_activity_indicator\"\n ]\n dtypes = {\n \"loan_id\": np.int64,\n \"orig_channel\": CategoricalDtype(['B', 'C', 'R']),\n \"seller_name\": str,\n \"orig_interest_rate\": np.float64,\n \"orig_upb\": np.int64,\n \"orig_loan_term\": np.int64,\n \"orig_date\": str,\n \"first_pay_date\": str,\n \"orig_ltv\": np.float64,\n \"orig_cltv\": np.float64,\n \"num_borrowers\": np.float64,\n \"dti\": np.float64,\n \"borrower_credit_score\": np.float64,\n \"first_home_buyer\": CategoricalDtype(['N', 'U', 'Y']),\n \"loan_purpose\": CategoricalDtype(['C', 'P', 'R', 'U']),\n \"property_type\": CategoricalDtype(['CO', 'CP', 'MH', 'PU', 'SF']),\n \"num_units\": np.int64,\n \"occupancy_status\": CategoricalDtype(['I', 'P', 'S']),\n \"property_state\": CategoricalDtype(\n ['AK', 'AL', 'AR', 'AZ', 'CA', 'CO', 'CT', 'DC', 'DE', 'FL', 'GA', 'HI',\n 'IA', 'ID', 'IL', 'IN', 'KS', 'KY', 'LA', 'MA', 'MD', 'ME', 'MI', 'MN',\n 'MO', 'MS', 'MT', 'NC', 'ND', 'NE', 'NH', 'NJ', 'NM', 'NV', 'NY', 'OH',\n 'OK', 'OR', 'PA', 'PR', 'RI', 'SC', 'SD', 'TN', 'TX', 'UT', 'VA', 'VI',\n 'VT', 'WA', 'WI', 'WV', 'WY']),\n \"zip\": np.int64,\n \"mortgage_insurance_percent\": np.float64,\n \"product_type\": CategoricalDtype(['FRM']),\n \"coborrow_credit_score\": np.float64,\n \"mortgage_insurance_type\": np.float64,\n \"relocation_mortgage_indicator\": CategoricalDtype(['N', 'Y']),\n }\n\n print(performance_path)\n\n #return pd.read_csv(performance_path, names=cols, delimiter='|', dtype=dtypes, parse_dates=[1,8,13,14,15,16])\n return pd.read_csv('perf.csv', names=cols, delimiter='|', dtype=dtypes, parse_dates=[1,8,13,14,15,16])","def load_file(self):\n\n self.df = self.sqlContext.read.csv(self.source, sep=self.sep, header=True, inferSchema=True)","def __init__(self,\n\t\toutputDir,\n\t\tbtDataset,\n\t\tbtDatasetPath,\n\t\tconfigList):\n\n\t\tself.btDataset = btDataset if btDataset is not None else pandas.read_csv(btDatasetPath)\n\n\t\tself.outFileName = 'Tesseract_blocktime.csv'\n\t\tself.testName = self.outFileName\n\n\t\tself.recList = [[d, int(d * ETH_EXPECTED_TIME), n, 0, 0] for (d, n) in configList]\n\n\t\tself.outFile = open(os.path.join(outputDir, self.outFileName), 'w')\n\t\tself.outFile.write('\\\"Delta\\\",\\\"Time_Limit\\\", \\\"N\\\",\\\"Counts\\\"\\n')\n\t\tself.outFile.flush()\n\n\t\tself.totalSteps = len(self.btDataset.index)\n\t\tself.currentStep = 0;","def load_data(path):\n train = pd.read_csv(os.path.join(path,'train.csv'))\n test = pd.read_csv(os.path.join(path,'test.csv'))\n \n return train, test","def __init__(self):\n with open(\"sat.json\", \"r\") as infile:\n self._sat = json.load(infile)[\"data\"]\n #Define the headers for the csv\n self._headers = [\"DBN\", \"School Name\", \"Number of Test Takers\", \"Critical Reading Mean\", \"Mathematics Mean\", \"Writing Mean\"]","def __init__(self, perf_location=\"../performances/\", verbose=True):\n self.verbose = verbose\n performance_dict = {}\n self.logs = []\n self.log_arrays = []\n if self.verbose:\n print(\"Loading tiny performances...\")\n for local_file in os.listdir(perf_location):\n if local_file.endswith(\".csv\"):\n perf_data = {\n \"title\": local_file[:-4],\n \"performer\": local_file.split(\"-\")[1],\n \"instrument\": local_file.split(\"-\")[2],\n \"filename\": perf_location + local_file}\n # parse performance\n perf_log = pd.DataFrame.from_csv(perf_data[\"filename\"], parse_dates=False)\n # calculate velocity\n perf_log[\"velocity\"] = self.create_velocity_column(perf_log)\n # arrange time\n perf_log['time'] = perf_log.index\n perf_log['delta_t'] = perf_log.time.diff()\n perf_log.delta_t = perf_log.delta_t.fillna(0)\n # add to archive\n self.logs.append(perf_log)\n self.log_arrays.append(np.array(perf_log[['x', 'y', 'delta_t', 'moving']]))\n\n # Centroid\n perf_data[\"centroid_X\"] = perf_log[\"x\"].mean()\n perf_data[\"centroid_Y\"] = perf_log[\"y\"].mean()\n\n # Centroid S.D.\n perf_data[\"centroid_X_SD\"] = perf_log[\"x\"].std()\n perf_data[\"centroid_Y_SD\"] = perf_log[\"y\"].std()\n\n # Starting/Ending coordinate\n perf_data[\"first_X\"] = perf_log[\"x\"].iloc[0]\n perf_data[\"first_Y\"] = perf_log[\"y\"].iloc[0]\n perf_data[\"last_X\"] = perf_log[\"x\"].iloc[-1]\n perf_data[\"last_Y\"] = perf_log[\"y\"].iloc[-1]\n\n # Length\n perf_data[\"duration\"] = perf_log.index[-1] - perf_log.index[0]\n\n # Percentage of moving touches\n perf_data[\"percent_moving\"] = perf_log[\"moving\"].mean()\n\n # Mean Velocity\n perf_data[\"mean_velocity\"] = perf_log[\"velocity\"].mean()\n performance_dict.update({perf_data[\"title\"]: perf_data})\n\n # Number of records\n perf_data[\"total\"] = perf_log[\"x\"].count()\n\n self.performances = pd.DataFrame.from_dict(performance_dict, orient='index')\n # self.performances.instrument = performances.instrument.astype('category')\n if self.verbose:\n print(\"Finished loading performances:\")\n print(self.performances.describe())","def import_data():\n data = pd.read_csv('partA/bikes_October18.csv', ',')\n return data","def import_experiments_table(path):\n return pd.read_csv(path, sep=\"\\t\", skiprows=1, header=0)","def test_load_coinbasettr(self):\n with open(self.filename) as f:\n coinbasettr.CoinbaseTTRParser(csv_content=f)\n parser = coinbasettr.CoinbaseTTRParser(filename=self.filename)\n parser.cleanup()","def test_load_success_small_dataset(self, mock_class):\n\n # ARRANGE\n input_data = \"\"\"\n CHILDRENS HOSPITAL DIALYSIS,012306,013300,1600 7TH AVENUE SOUTH,-,BIRMINGHAM,AL,35233,99\n GADSDEN DIALYSIS,012501,-,409 SOUTH FIRST STREET,-,GADSDEN,AL,35901,100\n TUSCALOOSA UNIVERSITY DIALYSIS,012502,-,220 15TH STREET,-,TUSCALOOSA,AL,35401,0\n DOTHAN DIALYSIS,012506,-,216 GRACELAND DR.,-,DOTHAN,AL,36305,88\n \"\"\"\n input_df: DataFrame = self.create_data_frame_from_csv_string(input_data)\n\n # ACT\n loader: LoaderCsv = LoaderCsv({'path': TestLoaderCsv.output_file})\n loader.load(TestLoaderCsv.spark, input_df)\n\n # ASSERT\n path = f'file://{TestLoaderCsv.output_file}'\n df_from_loaded_csv: DataFrame = \\\n TestLoaderCsv.spark.read.csv(path, header=True)\n\n assert df_from_loaded_csv.columns == [\n 'facility_name', 'cms_certification_number_ccn', 'alternate_ccn_1', 'address_1',\n 'address_2', 'city', 'state', 'zip_code', 'total_performance_score'\n ]\n self.assert_dataframe_contents(df_from_loaded_csv, [\n ['CHILDRENS HOSPITAL DIALYSIS', '012306', '013300', '1600 7TH AVENUE SOUTH', '-', 'BIRMINGHAM', 'AL', '35233', '99'],\n ['GADSDEN DIALYSIS', '012501', '-', '409 SOUTH FIRST STREET', '-', 'GADSDEN', 'AL', '35901', '100'],\n ['TUSCALOOSA UNIVERSITY DIALYSIS', '012502', '-', '220 15TH STREET', '-', 'TUSCALOOSA', 'AL', '35401', '0'],\n ['DOTHAN DIALYSIS', '012506', '-', '216 GRACELAND DR.', '-', 'DOTHAN', 'AL', '36305', '88'],\n ])","def load_testset(filename):\n pickle_name = filename + \".pickle\"\n try:\n print(\"trying to load \" + filename + \" from pickle\")\n dataset = pickle.load(open(pickle_name, \"rb\"))\n except:\n with open(filename, 'r') as csv_file:\n print(\"no pickle exists. parsing file \" + filename)\n dataset = [DataPoint(item[0:], \" \")\n for item\n in csv.reader(csv_file, delimiter=',')]\n pickle.dump(dataset, open(pickle_name, \"wb\"))\n print(\"loaded \" + filename)\n return dataset","def read_csv_file(self):\n pass","def load_susy(trainsize=500, testsize=1000):\n filename = 'datasets/susysubset.csv'\n dataset = loadcsv(filename)\n trainset, testset = splitdataset(dataset, trainsize, testsize)\n return trainset, testset","def load_bank_data():\n print(\"\\n\" * 8)\n print(\" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\", \"\\n\")\n csvpath = questionary.text(\"Enter a file path to a rate-sheet (.csv):\").ask()\n print(\"\\n\",\"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\", \"\\n\")\n csvpath = Path(csvpath)\n if not csvpath.exists():\n sys.exit(\"Oops! Can't find this path: \", csvpath)\n\n return load_csv(csvpath)","def load_swc(file_name):\n\n df = pd.read_csv(file_name, delimiter=' ', header=None, comment='#',\n names=['sample', 'identifier', 'x', 'y', 'z', 'r', 'parent'],\n skipinitialspace=True).astype({'sample':int,'identifier':int,'x':float,'y':float,'z':float,'r':float,'parent':int})\n return df","def load_bhav_data_csv(self, filepath: str) -> None:\n # create redis pipeline\n pipeline = self.redis.pipeline(transaction=True)\n pipeline.flushdb()\n total_items_counter = 0\n with open(filepath, \"r\") as csv_file:\n csv_dict_reader = csv.DictReader(csv_file)\n for row in csv_dict_reader:\n prefixed_sc_name = f'BHAV:{row[\"SC_NAME\"].strip()}'\n data = {\n \"SC_CODE\": row[\"SC_CODE\"],\n \"OPEN\": row[\"OPEN\"],\n \"CLOSE\": row[\"CLOSE\"],\n \"HIGH\": row[\"HIGH\"],\n \"LOW\": row[\"LOW\"],\n }\n\n pipeline.hset(\n name=self.sc_name_hash_stored,\n key=prefixed_sc_name,\n value=json.dumps(data),\n )\n pipeline.zadd(\n self.sc_name_sorted_set,\n {prefixed_sc_name: 0},\n )\n total_items_counter += 1\n pipeline.set(self.last_updated, str(timezone.now().date()))\n pipeline.set(self.total_items_count, total_items_counter)\n\n # Execute\n pipeline.execute()\n return","def _load_sample_table(self):\n self.sampleTable = pd.read_table(self.config['sampletable'], sep='\\t', dtype=str)\n self.sampleTable.set_index('sampleID', inplace=True)\n self.samples = self.sampleTable.reset_index().to_dict('records')","def load_data(loc='./data/', sp=None):\n trainA, trainB, devA, devB, testA, testB = [],[],[],[],[],[]\n trainS, devS, testS = [],[],[]\n print('loc', loc)\n with codecs.open(os.path.join(loc, 'SICK_train.txt'), mode='rb', encoding='utf-8') as f:\n for line in f:\n text = unicode_tr(line).lower().strip().split('\\t')\n trainA.append(encode_sentence(text[1], sp))\n trainB.append(encode_sentence(text[2], sp))\n trainS.append(text[3])\n with codecs.open(os.path.join(loc, 'SICK_trial.txt'), mode='rb', encoding='utf-8') as f:\n for line in f:\n text = unicode_tr(line).lower().strip().split('\\t')\n devA.append(encode_sentence(text[1], sp))\n devB.append(encode_sentence(text[2], sp))\n devS.append(text[3])\n with codecs.open(os.path.join(loc, 'SICK_test_annotated.txt'), mode='rb', encoding='utf-8') as f:\n for line in f:\n text = unicode_tr(line).lower().strip().split('\\t')\n testA.append(encode_sentence(text[1], sp))\n testB.append(encode_sentence(text[2], sp))\n testS.append(text[3])\n\n trainS = [float(s) for s in trainS[1:]]\n devS = [float(s) for s in devS[1:]]\n testS = [float(s) for s in testS[1:]]\n\n return [trainA[1:], trainB[1:]], [devA[1:], devB[1:]], [testA[1:], testB[1:]], [trainS, devS, testS]","def import_csv_data(cr, registry):\n files = ['data/sc.info.csv']\n for file in files:\n tools.convert_file(cr, 'prospects_app', file, None,\n mode='init', noupdate=True, kind='init')","def load_csv(fname):\n data = []\n tools = {}\n tool_names = []\n version_stripper = {}\n line_num = 0\n print >> sys.stderr, (\"\\n\"),\n for line in open(fname):\n print >> sys.stderr, (\"\\rReading line: %i\") % (line_num),\n line_num += 1\n # parse file line\n dataset1, dataset2, tool = line.rstrip('\\n').split(',')[:3]\n # check if our tool has been stripped of version before\n if tool not in version_stripper:\n tool_split = tool.split('/')\n if len(tool_split) > 1:\n stripped = '/'.join(tool_split[:-1])\n else:\n stripped = tool\n version_stripper[tool] = stripped\n # check if tool exists in our tool list yet. If not, add it\n if stripped not in tools:\n tools[stripped] = len(tools)\n tool_names.append(stripped)\n # add datasets and tool index to data\n data.append([int(dataset1), int(dataset2), tools[version_stripper[tool]]])\n data = numpy.array(data, dtype=numpy.int32)\n print >> sys.stderr, (\"\\rFinished reading csv file\\n\"),\n return [data, tool_names]","def loadRawData():\n samples = []\n with open('Sample_data/driving_log.csv') as csvfile:\n reader = csv.reader(csvfile)\n for line in reader:\n # skip the first line, which is the title line\n if line[0] != 'center':\n samples.append(line)\n # for testing implementation only, commented for GPU training\n #if len(samples)>100:\n # break\n train_samples, validation_samples = train_test_split(samples, test_size=0.2)\n return train_samples, validation_samples","def _read_csv(self):\n self.function_name = '_read_csv'\n with open(os.path.join(self.task.downloads, self.csv_name)) as csv_file:\n reader = csv.reader(csv_file, dialect='excel')\n for row in reader:\n self.input_data.append(row)","def load_benchmark(directory: str,\n source_url: Optional[str] = None,\n validation: bool = False) -> np.ndarray:\n path = f'{directory}/m5/datasets'\n if source_url is not None:\n filename = source_url.split('/')[-1].replace('.rar', '.csv')\n filepath = f'{path}/{filename}'\n if not os.path.exists(filepath):\n download_file(path, source_url, decompress=True)\n\n else:\n source_url = 'https://github.com/Nixtla/m5-forecasts/raw/main/forecasts/0001 YJ_STU.zip'\n return M5Evaluation.load_benchmark(directory, source_url, validation)\n\n benchmark = pd.read_csv(filepath)\n mask = benchmark['id'].str.endswith('validation')\n if validation:\n benchmark = benchmark[mask]\n benchmark['id'] = benchmark['id'].str.replace('_validation', '')\n else:\n benchmark = benchmark[~mask]\n benchmark['id'] = benchmark['id'].str.replace('_evaluation', '')\n\n benchmark = benchmark.sort_values('id', ignore_index=True)\n benchmark.rename(columns={'id': 'unique_id'}, inplace=True)\n *_, s_df = M5.load(directory)\n benchmark = benchmark.merge(s_df, how='left',\n on=['unique_id'])\n\n return benchmark","def load_results_runs(filename):\n # Load the necessary columns from the csv into panda\n data = pd.read_csv(filename)\n\n # Cleans the data\n data = data[['Run', 'Total Distance']]\n data['Run'] = pd.to_numeric(data['Run'])\n data['Total Distance'] = pd.to_numeric(data['Total Distance'])\n\n return data","def from_csv(cls, load_folder: Path) -> \"Parameters\":\n serializer = serializer_factory(fmt=SerializerEnum.CSV)\n return serializer.load(class_obj=cls, folder_path=load_folder)","def load_data(loc='../data/SICK/'):\n trainA, trainB, testA, testB = [],[],[],[]\n trainS, testS = [],[]\n\n with open(loc + 'SICK_train.txt', 'rb') as f:\n for line in f:\n text = line.strip().split('\\t')\n trainA.append(text[1])\n trainB.append(text[2])\n trainS.append(text[3])\n with open(loc + 'SICK_test_annotated.txt', 'rb') as f:\n for line in f:\n text = line.strip().split('\\t')\n testA.append(text[1])\n testB.append(text[2])\n testS.append(text[3])\n\n trainS = [float(s) for s in trainS[1:]]\n testS = [float(s) for s in testS[1:]]\n\n return [trainA[1:], trainB[1:]], [testA[1:], testB[1:]], [trainS, testS]","def _load_csv(self, file_path):\n csv_ds = tf.data.experimental.CsvDataset(\n file_path, self._default_csv_values,\n header=True,\n field_delim=CsvFilesDataset.CSV_SEPARATOR,\n use_quote_delim=False,\n select_cols=self._feature_column_indices\n )\n\n # Map to dictionary with column names\n if self.debug_columns:\n csv_ds = csv_ds.enumerate()\n csv_ds = csv_ds.map(lambda *row: self._map_csv_row_to_dict_with_debug(file_path, row))\n else:\n csv_ds = csv_ds.map(\n lambda *row: { feature_column_name: csv_column_values for feature_column_name, csv_column_values in zip(self._feature_column_names, row) }\n )\n\n # Get CSV file sequences\n csv_ds = self._map_csv_file_to_sequences(csv_ds, file_path)\n\n # Remove train column (avoid keras warning about unused inputs)\n if self._data_definition.trainable_column:\n csv_ds = csv_ds.map(self.remove_trainable_column)\n\n return csv_ds","def load_utlization(path):\n df = pd.read_csv(f\"{raw_data}\\\\{path}\", parse_dates=[\"AdmissionDate\"])\n\n df.rename(\n columns={\"MemberID\": \"member_id\", \"LOSDays\": \"los\", \"FacilityName\": \"facility\"},\n inplace=True,\n )\n\n df.columns = clean_table_columns(df.columns)\n\n facility_col = [col for col in df.columns if \"facility\" in col][0]\n\n df = cognify_facility_changes(df, facility_col)\n\n df = df[df.member_id != 1003]\n return df","def __init__(self, benchmark_dir):\n self.__benchmark_dir = benchmark_dir\n self.__load_configs()\n self.__load_results()","def setup(self):\n self.rows = test_helpers.fetch_sample_teradata_rows()\n self.csv_path = 'not/a/real/path'","def read_data(self):\n print 'Reading Data ...'\n fname = self.wpath + 'Data/' + self.city[2] + '-' + self.application + '.csv.bz2'\n self.dataset = loadtxt(fname, skiprows=1,\n dtype=[('lat', 'f8'), ('lng', 'f8'), ('time', 'i4'), ('user', 'S20')],\n usecols=(0, 1, 2, 3), delimiter=';', comments='#')","def test_load_from_long_to_dataframe(tmpdir):\n # create and save a example long-format file to csv\n test_dataframe = generate_example_long_table()\n dataframe_path = tmpdir.join(\"data.csv\")\n test_dataframe.to_csv(dataframe_path, index=False)\n # load and convert the csv to sktime-formatted data\n nested_dataframe = load_from_long_to_dataframe(dataframe_path)\n assert isinstance(nested_dataframe, pd.DataFrame)","def test_load_success_large_dataset(self, mock_class):\n\n # ARRANGE\n input_data = \"\"\"\n CHILDRENS HOSPITAL DIALYSIS,012306,013300,1600 7TH AVENUE SOUTH,-,BIRMINGHAM,AL,35233,99\n GADSDEN DIALYSIS,012501,-,409 SOUTH FIRST STREET,-,GADSDEN,AL,35901,100\n TUSCALOOSA UNIVERSITY DIALYSIS,012502,-,220 15TH STREET,-,TUSCALOOSA,AL,35401,0\n DOTHAN DIALYSIS,012506,-,216 GRACELAND DR.,-,DOTHAN,AL,36305,88\n \"\"\"\n input_df: DataFrame = self.create_data_frame_from_csv_string(input_data)\n\n # ACT\n loader: LoaderCsv = LoaderCsv({'path': TestLoaderCsv.output_file})\n loader.load(TestLoaderCsv.spark, input_df)\n\n # ASSERT\n path = f'file://{TestLoaderCsv.output_file}'\n df: DataFrame = TestLoaderCsv.spark.read.csv(path, header=True)\n # TODO: you can replace the above statement with code to read from\n # a database table; see case_study/etl/extract/extractor_db.py\n\n assert df.columns == [\n 'facility_name', 'cms_certification_number_ccn', 'alternate_ccn_1', 'address_1',\n 'address_2', 'city', 'state', 'zip_code', 'total_performance_score'\n ]\n assert df.count() == 4\n\n df.createOrReplaceTempView('loaded_data') # used in SQL queries below\n\n # verify one value of one row\n result: Row = self.spark.sql(\"\"\"\n select total_performance_score score \n from loaded_data\n where cms_certification_number_ccn == '012306'\n \"\"\").collect()[0]\n assert result.score == '99'\n\n # assert df.select(df.total_performance_score) \\\n # .where(df.cms_certification_number_ccn == '012306')\\\n # .collect()[0] == '99'\n\n # verify that a record is not present (i.e., it should have been\n # filtered out by the tranform operation)\n assert not self.spark.sql(\"\"\"\n select * \n from loaded_data\n where cms_certification_number_ccn == '012307'\n \"\"\").collect()","def load(*args):\r\n\r\n #args[0].to_csv(str(PATH.joinpath('./data/{}.csv'.format(args[1]))),index=False)\r\n\r\n try: # it will fail if duplicates\r\n args[0].to_sql('cmf', con=engine, if_exists='append', index=False)\r\n except:\r\n pass","def load_dataset_test():\n df_test = load_csv_file(\"31_test.csv\")\n return df_test.values","def load_data(y_name='Species'):\n train_path = tf.keras.utils.get_file(args.TRAIN_URL.split('/')[-1], args.TRAIN_URL)\n test_path = tf.keras.utils.get_file(args.TEST_URL.split('/')[-1], args.TEST_URL)\n\n train = pd.read_csv(train_path, names=args.CSV_COLUMN_NAMES, header=0)\n train_x, train_y = train, train.pop(y_name)\n\n test = pd.read_csv(test_path, names=args.CSV_COLUMN_NAMES, header=0)\n test_x, test_y = test, test.pop(y_name)\n\n return (train_x, train_y), (test_x, test_y)","def main():\n # Load and parse json object from file with specific\n file_name = \"./benchmark.log\"\n doc = re.sub(\"[\\n|\\t]\", \"\", \"\".join(benchmark.read_text_file(file_name)))\n json_object = json.loads(\"\".join(doc))\n\n intervals = json_object[\"intervals\"]\n\n socket_keys = benchmark.get_socket_keys(intervals)\n\n result = benchmark.get_result_dictionary(intervals, socket_keys)\n\n print_to_csv(result, socket_keys)","def read_csv(spark: SparkSession, config, log: Log4j):\n data = spark.read.schema(boston_schema).option(\"header\", \"true\").csv(config[\"boston_dataset_csv_path\"])\n log.warn(\"CSV Files Read Completed\")\n return data","def load_from_csv(self, file_name, parameters_size):\n \n with open(file_name) as csvDataFile:\n csvReader = csv.reader(csvDataFile)\n for row in csvReader:\n simulation_name = str(row[0:1])[2:-2] # Remove brakets and quotation marks \n result_name = str(row[1:2])[2:-2] # Remove brakets and quotation marks \n params = np.float64(row[2:parameters_size+2])\n res = np.float64(row[parameters_size+2:])\n self.add_sample(parameters = params, simulation_name = simulation_name, result = res, result_name = result_name)","def load_dataset(path):\n training_data = []\n with open(path) as csv_file:\n reader = csv.reader(csv_file, delimiter=\",\")\n next(reader)\n for row in reader:\n training_data.append(row[1])\n return training_data","def loader():\n bucket = data_load_variables[\"bucket\"]\n\n if data_load_variables[\"use_lite_dataset\"]:\n dataset_name = data_load_variables[\"lite_dataset_name\"]\n else:\n dataset_name = data_load_variables[\"dataset_name\"]\n\n s3 = boto3.client('s3')\n\n obj = s3.get_object(Bucket=bucket, Key=dataset_name)\n # get object and file (key) from bucket\n\n df = pd.read_csv(obj['Body'])\n return df","def load(cls, conf, regex=None):\n try:\n path = cls.get_benchmark_file_path(conf.results_dir)\n if not os.path.isfile(path):\n raise util.UserError(f\"Benchmark list file {path} missing!\")\n d = util.load_json(path, api_version=cls.api_version)\n benchmarks = d.values()\n return cls(conf, benchmarks, regex=regex)\n except util.UserError as err:\n if \"asv update\" in str(err):\n # Don't give conflicting instructions\n raise\n raise util.UserError(\"{}\\nUse `asv run --bench just-discover` to \"\n \"regenerate benchmarks.json\".format(str(err)))","def test_valid_csv(self):\n url=\"http://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data\"\n readerobject=requester.url_to_csv(url, fname='wine2')\n self.assertTrue(str(type(readerobject)),\"_csv.reader\")","def loadStats(stafil, returnmeta=False):\n meta = collections.namedtuple('meta', 'comment, starttime, startdate, stopwatchtime, exported')\n meta_ = {}\n data = None\n \n with open(stafil, 'r') as fIn:\n start = False\n for line in fIn:\n if line:\n lline = line.strip()\n try:\n splitLine = lline.split(None)\n \n # I don't feel great about hard-coding this, but time *should* be first...\n if len(splitLine) > 0:\n if splitLine[0] == '\"Time' and start is False:\n # print(lline)\n data = {lline.split('\"')[u]: [] for u in [1,3,5,7,9,11]}\n order = [lline.split('\"')[u] for u in [1,3,5,7,9,11] ]\n start = True\n elif len(splitLine) > 3 and start is True:\n for j in range(len(splitLine)):\n data[order[j]].append(splitLine[j])\n except:\n pass\n # Now the whole dictionary should be populated\n \n if data is None:\n print('Nothing found for %s' %stafil)\n return None\n \n if returnmeta:\n return pd.DataFrame(data=data), meta_\n return pd.DataFrame(data=data,)","def load_test_data(batch_size=32):\n log = logging.getLogger(__name__)\n\n log.info('Reading TEST csv file...')\n # read csv data file\n\n samples = []\n with open('./test_driving_log.csv') as f:\n csv_reader = csv.reader(f)\n next(csv_reader) #just skip the header line for test data set provided by Udacity\n\n for row in csv_reader:\n samples.append(row)\n\n generator = input_generator(samples, batch_size, is_for_validation=True, drop_zero_samples=True)\n return generator, math.ceil(len(samples) / batch_size)","def test_sbml_import_works(self):\n ## create sbml file for import\n sbml_filename = self.mod.to_sbml()\n assert os.path.isfile(sbml_filename)\n\n ## remove the existing copasi file\n if os.path.isfile(self.copasi_file1):\n os.remove(self.copasi_file1)\n\n ## import sbml\n mod = model.ImportSBML(sbml_filename).model\n self.assertIsInstance(mod, model.Model)\n # TC = tasks.TimeCourse(mod, end=100, intervals=100, step_size=1)\n # plotted_time_course = viz.PlotTimeCourse(TC, savefig=True)\n # self.assertEqual(\n # 3,\n # len(\n # glob.glob(\n # os.path.join(plotted_time_course.results_directory, '*')\n # )\n # )\n # )","def load_crawl():\n\n\tmodule_path = dirname(__file__)\n\twith open(join(module_path, 'data', 'train2.csv')) as csv_file:\n\t\tdata_file = csv.reader(csv_file)\n\t\ttemp = next(data_file)\n\t\tglobal n_samples\n\t\tn_samples = int(temp[0])\n\t\tglobal n_features\n\t\tn_features = int(temp[1])\n\t\tprint \"n samples \" + str((n_samples))\n\t\tprint \"n_features\" + str((n_features))\n\t\ttarget_names = np.array(temp[2:4])\n\t\tdata = np.empty((n_samples, n_features))\n\t\ttarget = np.empty((n_samples,), dtype=np.int)\n\n\t\tfor count, value in enumerate(data_file):\n\t\t\tdata[count] = np.asarray(value[:-1], dtype=np.float)\n\t\t\ttarget[count] = np.asarray(value[-1], dtype=np.int)\n\t\t\t#print \"data is \" + str(data[count])\n\t\t\t#print \"target is \" + str(target[count])\n\t\tprint \"Number of target records is \" + str(len(target))\n\t#with open(join(module_path, 'descr', 'train.rst')) as rst_file:\n\t#\tfdescr = rst_file.read()\n\n\treturn Bunch(data=data, target=target,\n\t\t\t target_names=target_names,\n\t\t\t DESCR=None,\n\t\t\t feature_names = ['evalCount', 'setInterval', 'setTimeout', 'link', \n\t\t\t\t\t\t\t 'search', 'exec','escape', 'unescape', 'ratio', \n\t\t\t\t\t\t\t 'emtropyAvg', 'entropyScript', 'longStrings', \n\t\t\t\t\t\t\t 'maxEntropy', 'stringAvg', 'maxLength', 'longVarFunc', \n\t\t\t\t\t\t\t 'stringAssignments', 'stringModFuncsCount', 'eventFuncsCount', \n\t\t\t\t\t\t\t 'domModFuncsCounter', 'suspStrings', 'whiteSpaceRatio', \n\t\t\t\t\t\t\t 'hexaStrings', 'maxNonPrintableCharactersinString', 'lineAvg', \n\t\t\t\t\t\t\t 'iframeCount', 'malTagCount', 'jsLength'])","def download_datasets_csv(url):\n # dataset = pd.read_csv(url, sep='\\t')\n dataset = pd.read_csv(url, sep=\",\")\n dataset.columns = dataset.columns.str.replace(\" \", \"_\")\n return dataset","def get_data(fpath):\n\n visits = ['SC', 'BL', 'V01', 'V02', 'V03', 'V04', 'V05', 'V06', 'V07',\n 'V08', 'V09', 'V10', 'V11', 'V12', 'V13', 'V14', 'V15']\n dtype = dict(PATNO=str,\n CLINICAL_EVENT=cdtype(visits, ordered=True),\n TESTNAME=str,\n TESTVALUE=str)\n\n fname = op.join(fpath, 'Current_Biospecimen_Analysis_Results.csv')\n data = pd.read_csv(fname, dtype=dtype)\n\n data['TESTVALUE'] = pd.to_numeric(data.TESTVALUE, errors='coerce')\n data = data.rename(columns=RENAME_COLS).assign(**ASSIGN_COLS)[RETAIN_COLS]\n data = data.dropna(axis=0, subset=['SCORE'])\n\n return data","def _load(self, config: Dict):\n return pd.read_csv(config['path'])","def _load_test_data(self):\n\n self.test_loader = data.Test_loader(self.N_max, self.n_per_conn,\n self.data_path, self.device)\n\n self.test_loader.load_data()\n\n # load mean and std from train\n scc_mean_std = np.loadtxt(\n os.path.join(self.data_path, 'scc_mean_std.csv'), delimiter=',')\n self.mean = torch.Tensor(scc_mean_std[0])\n self.std = torch.Tensor(scc_mean_std[1])","def load_swc(file_name):\n df = pd.read_csv(file_name, sep = ' ', header=None, comment='#', index_col = False,\n names=['sample', 'identifier', 'x', 'y', 'z', 'r', 'parent'],\n skipinitialspace=True)\n return df","def get_data(self, csv_file):\n pass","def load(self):\n\t\t# save self.dfAnalysis\n\t\tcsvPath = self._getSavePath()\n\t\tif os.path.isfile(csvPath):\n\t\t\tprint('todo: load from', csvPath)\n\t\t\tself.dfAnalysis = pd.read_csv(csvPath, header=0)\n\t\t\tself.updateAnalysisPlot()\n\t\telse:\n\t\t\tprint('did not find saved file csvPath:', csvPath)","def load_scatter_table(self, fn):\n with open(fn, 'rb') as f:\n data = pickle.load(f)\n\n if (\"version\" not in data) or (data[\"version\"]!=tmatrix_aux.VERSION):\n warnings.warn(\"Loading data saved with another version.\", Warning)\n\n (self.num_points, self.D_max, self._psd_D, self._S_table, \n self._Z_table, self._angular_table, self._m_table, \n self.geometries) = data[\"psd_scatter\"]\n return (data[\"time\"], data[\"description\"])","def data_import(path):\n train_path = os.path.join(path, \"train.csv\")\n test_path = os.path.join(path, \"test.csv\")\n df_train = pd.read_csv(train_path)\n df_test = pd.read_csv(test_path)\n return df_train, df_test","def load(self):\n\t\tprint('bSlabList.load()')","def load_step_data(self, subject_id:str) -> pd.DataFrame:\n sp_fp = os.path.join(self.steps_dir, subject_id+self.steps_file_suffix)\n df_sp = pd.read_csv(sp_fp, sep=\",\", header=None, names=[\"sec\",\"step_count\"])\n df_sp = df_sp.sort_values(by=\"sec\")\n df_sp = df_sp.drop_duplicates(subset=\"sec\")\n df_sp = df_sp.reset_index(drop=True)\n return df_sp","def load_dataset(file_name, model_ver):\n\n print 'Loading dataset ...'\n\n if model_ver == 'dmspline':\n file_path = join(DATA_DIR, file_name)\n id_field = Field(sequential=False, use_vocab=False, dtype=torch.int)\n text_field = Field(pad_token=None, tokenize=_tokenize_str)\n attr_field = Field(sequential=False, use_vocab=False, dtype=torch.float)\n standardzed_attr_field = Field(sequential=False, use_vocab=False, dtype=torch.float)\n\n dataset = TabularDataset(\n path=file_path,\n format='csv',\n fields=[('attr', attr_field), ('id', id_field), ('standardized_attr', standardzed_attr_field), ('text', text_field)],\n skip_header=True)\n\n else:\n file_path = join(DATA_DIR, file_name)\n id_field = Field(sequential=False, use_vocab=False, dtype=torch.int)\n text_field = Field(pad_token=None, tokenize=_tokenize_str)\n\n dataset = TabularDataset(\n path=file_path,\n format='csv',\n fields=[('id', id_field), ('text', text_field)],\n skip_header=True)\n\n text_field.build_vocab(dataset, min_freq=10)\n return dataset","def load_data():\n directories=[\"./track1/\",\n \"./track1_recovery/\",\n \"./track2/\",\n \"./track1_reverse/\",\n \"./track2_reverse/\",#Additional data for model built on top of lenet.h5\n \"./track2_recovery/\",#Additions data for model built on top of lenet.h5\n ]\n lines=[]\n for directory in directories:\n with open(directory+\"driving_log.csv\") as csvfile:\n reader=csv.reader(csvfile)\n for line in reader:\n lines.append(line)\n train_samples, validation_samples = train_test_split(lines, test_size=0.2)\n return train_samples, validation_samples","def load_from_table(filename: str) -> List[Sample]:\n with open(filename, \"r+\", newline=\"\") as f:\n reader = csv.reader(f)\n return samples_from_iterator(reader)","def main():\n # openfile allows for CSV files with stored data of two columns\n # data = openfile(\"filename\")\n data = get_data()\n abtest = AB_test(data)\n abtest.stats()\n abtest.print_stats()","def main():\n manager = S3Manager(\n bucket_name=\"introtodatascience5\",\n key=\"'open_data/emergency_medical_service/origin/csv/응급의료기관현황(2014.5).csv'\"\n )\n df = manager.load_csv_to_df()\n print(df)","def load_data(params):\n train_df = pd.read_csv(os.path.join(*[dataset_path, params['tokenizer'] + '_train_' + params['stemming'] + '.csv']))\n dev_df = pd.read_csv(os.path.join(*[dataset_path, params['tokenizer'] + '_dev_' + params['stemming'] + '.csv']))\n train_data, label_encode = data_prep(train_df, params, if_resample=True)\n dev_data, _ = data_prep(dev_df, params)\n return train_data, dev_data, label_encode","def main():\r\n run_processes('tests.csv', 'labs.csv')","def load_dataset(input_path):\n with open(input_path, \"r\") as f:\n smiles_list = f.read().strip().split(\"\\n\")\n return smiles_list","def load_all_trades():\n trades = []\n\n kraken_trades_filename = \"data_private/kraken-trades.csv\"\n if Path(kraken_trades_filename).exists():\n print(\"Found kraken trades!\")\n trades_kraken_csv = _load_csv(kraken_trades_filename)\n trades.extend(_format_csv_from_kraken(trades_kraken_csv))\n\n polo_trades_filename = \"data_private/poloniex-trades.csv\"\n if Path(polo_trades_filename).exists():\n print(\"Found poloniex trades!\")\n trades_polo_csv = _load_csv(polo_trades_filename)\n trades.extend(_format_csv_from_poloniex(trades_polo_csv))\n\n bitstamp_trades_filename = \"data_private/bitstamp-trades.csv\"\n if Path(bitstamp_trades_filename).exists():\n print(\"Found bitstamp trades!\")\n trades_bitstamp_csv = _load_csv(bitstamp_trades_filename)\n trades.extend(_format_csv_from_bitstamp(trades_bitstamp_csv))\n\n lbtc_trades_filename = \"data_private/lbtc-trades.csv\"\n if Path(lbtc_trades_filename).exists():\n print(\"Found lbtc trades!\")\n trades_lbtc_csv = _load_csv(lbtc_trades_filename)\n trades.extend(_format_csv_from_lbtc(trades_lbtc_csv))\n\n return list(sorted(trades, key=lambda t: t[\"time\"]))","def from_csv(self, path_to_load):\n import pandas as pd\n\n df = pd.read_csv(path_to_load)\n df = df.loc[:, ~df.columns.str.contains('^Unnamed')] # Remove unnnamed\n\n self.results['cids'] = list()\n self.results['differences'] = list()\n self.results['experimental_values'] = list()\n\n pd_dict = df.to_dict()\n length = len(pd_dict['cids'])\n for cid in [pd_dict['cids'][i] for i in range(0, length)]:\n self._results['cids'].append(cid)\n for cid in [pd_dict['differences'][i] for i in range(0, length)]:\n self._results['differences'].append(cid)\n for cid in [pd_dict['experimental_values'][i]\n for i in range(0, length)]:\n self._results['experimental_values'].append(cid)","def load_data_to_db(self, path):\n table_names = ['train_transaction', 'train_identity', 'test_transaction', 'test_identity']\n for table_name in table_names:\n pat = self.TRANSACTION_NON_NUMBER_PATTERN if 'transaction' in table_name else self.IDENTITY_NON_NUMBER_PATTERN\n print(\"Loading table: \" + table_name)\n fn = os.path.join(path, table_name + '.csv')\n self.dbinstance.build_table_from_csv(fn, pat, table_name)\n print(\"Loaded table \" + table_name)","def load(name):\n if name in datasets:\n\n return pd.read_csv(os.path.join(datasets_path, \"%s.csv\" % name))\n else:\n raise ValueError(\"Dataset not found!\")","def import_data():\n import pandas as pd\n \n df = pd.read_csv('Company_Bankruptcy_Prediction.csv')\n return df","def load_tweets(fp):\r\n ans = pd.read_csv(fp, sep='\\t')\r\n return ans","def read_csv(self, file: str, table: str, libref: str =\"\", nosub: bool =False, opts: dict = None) -> '<SASdata object>':\n opts = opts if opts is not None else {}\n\n code = \"filename x \"\n\n if file.lower().startswith(\"http\"):\n code += \"url \"\n\n code += \"\\\"\"+file+\"\\\";\\n\"\n code += \"proc import datafile=x out=\"\n if len(libref):\n code += libref+\".\"\n code += \"'\"+table.strip()+\"'n dbms=csv replace; \"+self._sb._impopts(opts)+\" run;\"\n\n if nosub:\n print(code)\n else:\n ll = self.submit(code, \"text\")","def load_dataset(path, test_or_train):\n senta_batch, sentb_batch, scores_batch = [], [], []\n with open(path, encoding='utf-8') as f:\n for i, line in enumerate(f):\n items = line.strip().split('\\t')\n if test_or_train == 'train':\n senta, sentb, score = items[-2], items[-1], float(items[-3])\n elif test_or_train in ['dev', 'test']:\n senta, sentb, score = items[-2], items[-1], float(items[-3])\n else:\n raise Exception(\"{} error\".format(test_or_train))\n senta_batch.append(senta)\n sentb_batch.append(sentb)\n scores_batch.append(score)\n return senta_batch, sentb_batch, scores_batch"],"string":"[\n \"def runs_loader(path):\\n files = sorted(glob.glob(f\\\"{path}/*_runs.csv\\\"))\\n df_lis = list(range(len(files)))\\n for i, f in enumerate(files):\\n try:\\n df_lis[i] = pd.read_csv(f, sep=\\\",\\\", header=0)\\n print('Read runs.csv\\\\n', f, df_lis[i].shape,\\n df_lis[i]['dataset__id'][0], df_lis[i]['pipeline__id'][0])\\n except Exception as e:\\n print(e)\\n continue\\n df = pd.concat(df_lis, axis=0, sort=False).reset_index()\\n # with pd.option_context('display.max_rows', None,\\n # 'display.max_columns', None):\\n # msg = tabulate.tabulate(df, headers='keys', tablefmt='psql')\\n # print(msg)\\n return df\",\n \"def loadCSV(input_file):\",\n \"def test_load_csv_file():\\n data = loader.load_csv_file(\\\"buildup/reference/comsol_solution/lofi/voltage.csv.bz2\\\")\\n\\n assert data.any()\",\n \"def load_file(name):\\n return pd.read_csv(join(path_here, \\\"syserol/data/\\\" + name + \\\".csv\\\"), delimiter=\\\",\\\", comment=\\\"#\\\")\",\n \"def CSV_Load_File( self, infilename ):\\n print( 'Loading \\\"{}\\\"'.format(infilename) )\\n IN = open( infilename, 'r' )\\n standname = None\\n laststand = None\\n for L in IN:\\n if( L[0:9] == 'Site/Plot' ): continue\\n col = L.split( ',' )\\n standname = col[0]\\n year = int(col[1])\\n #if( re.search( '-', standname ) != None ):\\n # loc = re.search( '-', standname )\\n # year = int(standname[loc.start()+1:])\\n # standname = standname[0:loc.start()]\\n #print standname, year\\n if( (standname != None ) & (standname != laststand) ): self.Data.Stand[standname] = StandData( standname )\\n (treeno, species, dbh, ht, live, status, cclass, tpa) = \\\\\\n (int(col[2]), col[3], float(col[4]), float(col[5]), col[6], col[7], int(float(col[8])), float(col[9]))\\n if( OPT['d'] ):\\n if( dbh > 10.0 ): dbh *= 1.25\\n if( dbh > 15.0 ): dbh *= 1.50\\n for t in range( 1, int( math.ceil( tpa ))+1, 1 ):\\n ntree = len( self.Data.Stand[standname].Tree ) + 1\\n self.Data.Stand[standname].Tree[ntree] = TreeData( species, TreeNumber=treeno )\\n self.Data.Stand[standname].Tree[ntree].Year[year] = MeasurementData( dbh, ht, '', 1, live, status, cclass )\\n laststand = standname\\n IN.close()\",\n \"def run(args):\\n with open(args.config, \\\"r\\\") as f:\\n config = yaml.load(f)\\n\\n how = config[\\\"load_data\\\"][\\\"how\\\"]\\n\\n if how == \\\"load_csvs\\\":\\n df = load_csvs(**config[\\\"load_data\\\"][\\\"load_csvs\\\"])\\n\\n if args.save is not None:\\n df.to_csv(args.save)\",\n \"def load(self, path):\\n self.df = pd.read_csv(path)\\n print(\\\"Loaded data from {}\\\".format(path))\",\n \"def _load(self):\\n op_type_file_path = os.path.join(\\n self._profiling_dir,\\n self._csv_file_to_analyse.format(self._device_id)\\n )\\n op_type_file_path = validate_and_normalize_path(\\n op_type_file_path, raise_key=\\\"Invalid op_type_file_path\\\")\\n if not os.path.isfile(op_type_file_path):\\n log.warning('The file <%s> does not exist.', op_type_file_path)\\n return\\n\\n with open(op_type_file_path, 'r') as file:\\n csv_reader = csv.reader(file)\\n _ = next(csv_reader)\\n for info in csv_reader:\\n self._data.append(self._convert_field_type(info))\",\n \"def download_stsb(dataset_path=\\\"\\\"):\\n stsb_dataset_path = os.path.join(dataset_path, \\\"stsb.tar.gz\\\")\\n csv_fieldnames = [\\\"sect\\\", \\\"dataset\\\", \\\"year\\\", \\\"id\\\", \\\"score\\\", \\\"sentence1\\\", \\\"sentence2\\\"]\\n url = \\\"http://ixa2.si.ehu.es/stswiki/images/4/48/Stsbenchmark.tar.gz\\\"\\n urllib.request.urlretrieve(url, stsb_dataset_path)\\n\\n train_samples = []\\n dev_samples = []\\n test_samples = []\\n\\n with tarfile.open(stsb_dataset_path, \\\"r:gz\\\", encoding=\\\"utf-8\\\") as tar:\\n for split in [\\\"train\\\", \\\"dev\\\", \\\"test\\\"]:\\n with tar.extractfile(f\\\"stsbenchmark/sts-{split}.csv\\\") as f:\\n ft = codecs.getreader(\\\"utf-8\\\")(f)\\n reader = csv.DictReader(ft,\\n delimiter=\\\"\\\\t\\\",\\n quoting=csv.QUOTE_NONE,\\n fieldnames=csv_fieldnames)\\n for row in reader:\\n # Normalize scores to range [0,1]\\n score = float(row['score']) / 5.0\\n sample = {\\n \\\"sentence1\\\": row[\\\"sentence1\\\"],\\n \\\"sentence2\\\": row[\\\"sentence2\\\"],\\n \\\"score\\\": score\\n }\\n\\n if split == \\\"train\\\":\\n train_samples.append(sample)\\n elif split == \\\"dev\\\":\\n dev_samples.append(sample)\\n elif split == \\\"test\\\":\\n test_samples.append(sample)\\n\\n keys = [\\\"sentence1\\\", \\\"sentence2\\\", \\\"score\\\"]\\n\\n output_path = os.path.join(dataset_path, \\\"stsb_train.csv\\\")\\n with open(output_path, \\\"w\\\", newline=\\\"\\\") as out:\\n dict_writer = csv.DictWriter(out, keys)\\n dict_writer.writeheader()\\n dict_writer.writerows(train_samples)\\n\\n output_path = os.path.join(dataset_path, \\\"stsb_dev.csv\\\")\\n with open(output_path, \\\"w\\\", newline=\\\"\\\") as out:\\n dict_writer = csv.DictWriter(out, keys)\\n dict_writer.writeheader()\\n dict_writer.writerows(dev_samples)\\n\\n output_path = os.path.join(dataset_path, \\\"stsb_test.csv\\\")\\n with open(output_path, \\\"w\\\", newline=\\\"\\\") as out:\\n dict_writer = csv.DictWriter(out, keys)\\n dict_writer.writeheader()\\n dict_writer.writerows(test_samples)\",\n \"def load():\\n filepath = dirname(abspath(__file__))\\n##### EDIT THE FOLLOWING TO POINT TO DatasetName.csv #####\\n data = recfromtxt(open(filepath + '/spector.csv',\\\"rb\\\"), delimiter=\\\" \\\",\\n names=True, dtype=float, usecols=(1,2,3,4))\\n names = list(data.dtype.names)\\n endog = array(data[names[3]], dtype=float)\\n endog_name = names[3]\\n exog = column_stack(data[i] for i in names[:3]).astype(float)\\n exog_name = names[:3]\\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\\n endog_name = endog_name, exog_name=exog_name)\\n return dataset\",\n \"def _read_csvs(self):\\n self.data = pd.read_csv(self.path+self.name, index_col=0)\",\n \"def LoadBatch(filename):\",\n \"def load_stir_tracer(tracer_id, model):\\n filepath = paths.stir_filepath(tracer_id, model=model)\\n table = pd.read_csv(filepath, header=None, skiprows=2, delim_whitespace=True)\\n table.columns = tables_config.stir_columns\\n return table\",\n \"def dataLoad():\\n try:\\n try: #Python3\\n f = open(__file__ + \\\".csv\\\",\\\"rt\\\")\\n except: #Python2\\n f = open(__file__ + \\\".csv\\\",\\\"rb\\\")\\n data = f.read().split(',')\\n entryCol.entry0.delete(0,END)\\n entryCol.entry0.insert(0,data[0])\\n entryCol.entry1.delete(0,END)\\n entryCol.entry1.insert(0,data[1])\\n entryCol.entry2.delete(0,END)\\n entryCol.entry2.insert(0,data[2])\\n entryCol.entry3.delete(0,END)\\n entryCol.entry3.insert(0,data[3])\\n botWind.writeN(\\\"DataLoad: File\\\")\\n except:\\n botWind.writeN(\\\"DataLoad: Default\\\")\",\n \"def __loaddata(filename, datatype='flightcsv', minprob=0.001, maxprob=0.20):\\n if datatype is 'flightcsv':\\n return extract_flight_csv(filename, minprob=minprob, maxprob=maxprob)\\n else:\\n raise Exception('unknown datatype %s' % datatype)\",\n \"def read_csv():\",\n \"def load_csv(self):\\n self.database = pd.read_csv(\\n self.settings['database_path'],\\n encoding='utf-8')\",\n \"def load_steels():\\n path = os.path.join(DATA_DIR, \\\"yieldstrength-citrination-312.csv\\\")\\n df = pd.read_csv(path, index_col=False)\\n return df\",\n \"def load_database(self, fsp='Species'):\\n self.df_species = pd.read_csv(fsp + '.csv', header=0,\\n index_col=0)\",\n \"def import_scores_from_csv(f):\\n print(f)\\n with open(os.path.join(STATIC_ROOT, 'dataset.csv'), 'wb+') as destination:\\n for chunk in f.chunks():\\n destination.write(chunk)\\n return None\",\n \"def load_CSV_data(path):\\n return np.genfromtxt(os.path.join('data/traffic_data', path))\",\n \"def load_gt(path):\\n train_results = []\\n with open(path) as csv_file:\\n reader = csv.reader(csv_file, delimiter=\\\",\\\")\\n next(reader)\\n for row in reader:\\n train_results.append(int(row[1]))\\n return np.array(train_results)\",\n \"def run_load(rootpath):\\n global CSV_PATH\\n CSV_PATH = rootpath+'/csv_files/'\\n load_movies_details()\\n load_movies_cast()\\n load_movies_reviews()\",\n \"def _load_table(table: Model, directory: Path, format_: str):\\n\\n if directory is not None:\\n print(f\\\" Loading {table.table_name()}...\\\")\\n in_file = Path(directory) / f\\\"{table.table_name()}.{format_}\\\"\\n dataset = tablib.Dataset(headers=table.fields()).load(in_file.read_text())\\n print(f\\\" Importing {table.table_name()} into the database...\\\")\\n table.insert_many(dataset.dict).execute()\\n print(\\\" Done.\\\")\\n print(\\\"=====================\\\")\\n else:\\n pass\\n # print(dataset.export(\\\"csv\\\"))\",\n \"def _loadCSVFile(self):\\n self._df = pd.read_csv(\\n self._pathfile, sep=CSV_SEPARATOR, index_col=CSV_INDEX_COL)\",\n \"def pd_load_performance_csv(performance_path, **kwargs):\\n\\n cols = [\\n \\\"loan_id\\\", \\\"monthly_reporting_period\\\", \\\"servicer\\\", \\\"interest_rate\\\", \\\"current_actual_upb\\\",\\n \\\"loan_age\\\", \\\"remaining_months_to_legal_maturity\\\", \\\"adj_remaining_months_to_maturity\\\",\\n \\\"maturity_date\\\", \\\"msa\\\", \\\"current_loan_delinquency_status\\\", \\\"mod_flag\\\", \\\"zero_balance_code\\\",\\n \\\"zero_balance_effective_date\\\", \\\"last_paid_installment_date\\\", \\\"foreclosed_after\\\",\\n \\\"disposition_date\\\", \\\"foreclosure_costs\\\", \\\"prop_preservation_and_repair_costs\\\",\\n \\\"asset_recovery_costs\\\", \\\"misc_holding_expenses\\\", \\\"holding_taxes\\\", \\\"net_sale_proceeds\\\",\\n \\\"credit_enhancement_proceeds\\\", \\\"repurchase_make_whole_proceeds\\\", \\\"other_foreclosure_proceeds\\\",\\n \\\"non_interest_bearing_upb\\\", \\\"principal_forgiveness_upb\\\", \\\"repurchase_make_whole_proceeds_flag\\\",\\n \\\"foreclosure_principal_write_off_amount\\\", \\\"servicing_activity_indicator\\\"\\n ]\\n dtypes = {\\n \\\"loan_id\\\": np.int64,\\n \\\"monthly_reporting_period\\\": str,\\n \\\"servicer\\\": str,\\n \\\"interest_rate\\\": np.float64,\\n \\\"current_actual_upb\\\": np.float64,\\n \\\"loan_age\\\": np.float64,\\n \\\"remaining_months_to_legal_maturity\\\": np.float64,\\n \\\"adj_remaining_months_to_maturity\\\": np.float64,\\n \\\"maturity_date\\\": str,\\n \\\"msa\\\": np.float64,\\n \\\"current_loan_delinquency_status\\\": np.int32,\\n \\\"mod_flag\\\": CategoricalDtype(['N', 'Y']),\\n \\\"zero_balance_code\\\": CategoricalDtype(['01', '02', '06', '09', '03', '15', '16']),\\n \\\"zero_balance_effective_date\\\": str,\\n \\\"last_paid_installment_date\\\": str,\\n \\\"foreclosed_after\\\": str,\\n \\\"disposition_date\\\": str,\\n \\\"foreclosure_costs\\\": np.float64,\\n \\\"prop_preservation_and_repair_costs\\\": np.float64,\\n \\\"asset_recovery_costs\\\": np.float64,\\n \\\"misc_holding_expenses\\\": np.float64,\\n \\\"holding_taxes\\\": np.float64,\\n \\\"net_sale_proceeds\\\": np.float64,\\n \\\"credit_enhancement_proceeds\\\": np.float64,\\n \\\"repurchase_make_whole_proceeds\\\": np.float64,\\n \\\"other_foreclosure_proceeds\\\": np.float64,\\n \\\"non_interest_bearing_upb\\\": np.float64,\\n \\\"principal_forgiveness_upb\\\": np.float64,\\n \\\"repurchase_make_whole_proceeds_flag\\\": CategoricalDtype(['N', 'Y']),\\n \\\"foreclosure_principal_write_off_amount\\\": np.float64,\\n \\\"servicing_activity_indicator\\\": CategoricalDtype(['N', 'Y']),\\n }\\n\\n return pd.read_csv(performance_path, names=cols, delimiter='|', dtype=dtypes, parse_dates=[1,8,13,14,15,16])\",\n \"def csv_data_loader(path):\\n\\n logging.info(\\\"Loading file using SparkSession\\\")\\n csvload = Spark.instance.spark() \\\\\\n .read \\\\\\n .format(\\\"csv\\\") \\\\\\n .options(header=True) \\\\\\n .options(mode=\\\"DROPMALFORMED\\\")\\n\\n return csvload.option(\\\"inferSchema\\\", \\\"true\\\").load(path)\",\n \"def pd_load_performance_csv(performance_path, **kwargs):\\n\\n cols = [\\n \\\"loan_id\\\", \\\"monthly_reporting_period\\\", \\\"servicer\\\", \\\"interest_rate\\\", \\\"current_actual_upb\\\",\\n \\\"loan_age\\\", \\\"remaining_months_to_legal_maturity\\\", \\\"adj_remaining_months_to_maturity\\\",\\n \\\"maturity_date\\\", \\\"msa\\\", \\\"current_loan_delinquency_status\\\", \\\"mod_flag\\\", \\\"zero_balance_code\\\",\\n \\\"zero_balance_effective_date\\\", \\\"last_paid_installment_date\\\", \\\"foreclosed_after\\\",\\n \\\"disposition_date\\\", \\\"foreclosure_costs\\\", \\\"prop_preservation_and_repair_costs\\\",\\n \\\"asset_recovery_costs\\\", \\\"misc_holding_expenses\\\", \\\"holding_taxes\\\", \\\"net_sale_proceeds\\\",\\n \\\"credit_enhancement_proceeds\\\", \\\"repurchase_make_whole_proceeds\\\", \\\"other_foreclosure_proceeds\\\",\\n \\\"non_interest_bearing_upb\\\", \\\"principal_forgiveness_upb\\\", \\\"repurchase_make_whole_proceeds_flag\\\",\\n \\\"foreclosure_principal_write_off_amount\\\", \\\"servicing_activity_indicator\\\"\\n ]\\n dtypes = {\\n \\\"loan_id\\\": np.int64,\\n \\\"orig_channel\\\": CategoricalDtype(['B', 'C', 'R']),\\n \\\"seller_name\\\": str,\\n \\\"orig_interest_rate\\\": np.float64,\\n \\\"orig_upb\\\": np.int64,\\n \\\"orig_loan_term\\\": np.int64,\\n \\\"orig_date\\\": str,\\n \\\"first_pay_date\\\": str,\\n \\\"orig_ltv\\\": np.float64,\\n \\\"orig_cltv\\\": np.float64,\\n \\\"num_borrowers\\\": np.float64,\\n \\\"dti\\\": np.float64,\\n \\\"borrower_credit_score\\\": np.float64,\\n \\\"first_home_buyer\\\": CategoricalDtype(['N', 'U', 'Y']),\\n \\\"loan_purpose\\\": CategoricalDtype(['C', 'P', 'R', 'U']),\\n \\\"property_type\\\": CategoricalDtype(['CO', 'CP', 'MH', 'PU', 'SF']),\\n \\\"num_units\\\": np.int64,\\n \\\"occupancy_status\\\": CategoricalDtype(['I', 'P', 'S']),\\n \\\"property_state\\\": CategoricalDtype(\\n ['AK', 'AL', 'AR', 'AZ', 'CA', 'CO', 'CT', 'DC', 'DE', 'FL', 'GA', 'HI',\\n 'IA', 'ID', 'IL', 'IN', 'KS', 'KY', 'LA', 'MA', 'MD', 'ME', 'MI', 'MN',\\n 'MO', 'MS', 'MT', 'NC', 'ND', 'NE', 'NH', 'NJ', 'NM', 'NV', 'NY', 'OH',\\n 'OK', 'OR', 'PA', 'PR', 'RI', 'SC', 'SD', 'TN', 'TX', 'UT', 'VA', 'VI',\\n 'VT', 'WA', 'WI', 'WV', 'WY']),\\n \\\"zip\\\": np.int64,\\n \\\"mortgage_insurance_percent\\\": np.float64,\\n \\\"product_type\\\": CategoricalDtype(['FRM']),\\n \\\"coborrow_credit_score\\\": np.float64,\\n \\\"mortgage_insurance_type\\\": np.float64,\\n \\\"relocation_mortgage_indicator\\\": CategoricalDtype(['N', 'Y']),\\n }\\n\\n print(performance_path)\\n\\n #return pd.read_csv(performance_path, names=cols, delimiter='|', dtype=dtypes, parse_dates=[1,8,13,14,15,16])\\n return pd.read_csv('perf.csv', names=cols, delimiter='|', dtype=dtypes, parse_dates=[1,8,13,14,15,16])\",\n \"def load_file(self):\\n\\n self.df = self.sqlContext.read.csv(self.source, sep=self.sep, header=True, inferSchema=True)\",\n \"def __init__(self,\\n\\t\\toutputDir,\\n\\t\\tbtDataset,\\n\\t\\tbtDatasetPath,\\n\\t\\tconfigList):\\n\\n\\t\\tself.btDataset = btDataset if btDataset is not None else pandas.read_csv(btDatasetPath)\\n\\n\\t\\tself.outFileName = 'Tesseract_blocktime.csv'\\n\\t\\tself.testName = self.outFileName\\n\\n\\t\\tself.recList = [[d, int(d * ETH_EXPECTED_TIME), n, 0, 0] for (d, n) in configList]\\n\\n\\t\\tself.outFile = open(os.path.join(outputDir, self.outFileName), 'w')\\n\\t\\tself.outFile.write('\\\\\\\"Delta\\\\\\\",\\\\\\\"Time_Limit\\\\\\\", \\\\\\\"N\\\\\\\",\\\\\\\"Counts\\\\\\\"\\\\n')\\n\\t\\tself.outFile.flush()\\n\\n\\t\\tself.totalSteps = len(self.btDataset.index)\\n\\t\\tself.currentStep = 0;\",\n \"def load_data(path):\\n train = pd.read_csv(os.path.join(path,'train.csv'))\\n test = pd.read_csv(os.path.join(path,'test.csv'))\\n \\n return train, test\",\n \"def __init__(self):\\n with open(\\\"sat.json\\\", \\\"r\\\") as infile:\\n self._sat = json.load(infile)[\\\"data\\\"]\\n #Define the headers for the csv\\n self._headers = [\\\"DBN\\\", \\\"School Name\\\", \\\"Number of Test Takers\\\", \\\"Critical Reading Mean\\\", \\\"Mathematics Mean\\\", \\\"Writing Mean\\\"]\",\n \"def __init__(self, perf_location=\\\"../performances/\\\", verbose=True):\\n self.verbose = verbose\\n performance_dict = {}\\n self.logs = []\\n self.log_arrays = []\\n if self.verbose:\\n print(\\\"Loading tiny performances...\\\")\\n for local_file in os.listdir(perf_location):\\n if local_file.endswith(\\\".csv\\\"):\\n perf_data = {\\n \\\"title\\\": local_file[:-4],\\n \\\"performer\\\": local_file.split(\\\"-\\\")[1],\\n \\\"instrument\\\": local_file.split(\\\"-\\\")[2],\\n \\\"filename\\\": perf_location + local_file}\\n # parse performance\\n perf_log = pd.DataFrame.from_csv(perf_data[\\\"filename\\\"], parse_dates=False)\\n # calculate velocity\\n perf_log[\\\"velocity\\\"] = self.create_velocity_column(perf_log)\\n # arrange time\\n perf_log['time'] = perf_log.index\\n perf_log['delta_t'] = perf_log.time.diff()\\n perf_log.delta_t = perf_log.delta_t.fillna(0)\\n # add to archive\\n self.logs.append(perf_log)\\n self.log_arrays.append(np.array(perf_log[['x', 'y', 'delta_t', 'moving']]))\\n\\n # Centroid\\n perf_data[\\\"centroid_X\\\"] = perf_log[\\\"x\\\"].mean()\\n perf_data[\\\"centroid_Y\\\"] = perf_log[\\\"y\\\"].mean()\\n\\n # Centroid S.D.\\n perf_data[\\\"centroid_X_SD\\\"] = perf_log[\\\"x\\\"].std()\\n perf_data[\\\"centroid_Y_SD\\\"] = perf_log[\\\"y\\\"].std()\\n\\n # Starting/Ending coordinate\\n perf_data[\\\"first_X\\\"] = perf_log[\\\"x\\\"].iloc[0]\\n perf_data[\\\"first_Y\\\"] = perf_log[\\\"y\\\"].iloc[0]\\n perf_data[\\\"last_X\\\"] = perf_log[\\\"x\\\"].iloc[-1]\\n perf_data[\\\"last_Y\\\"] = perf_log[\\\"y\\\"].iloc[-1]\\n\\n # Length\\n perf_data[\\\"duration\\\"] = perf_log.index[-1] - perf_log.index[0]\\n\\n # Percentage of moving touches\\n perf_data[\\\"percent_moving\\\"] = perf_log[\\\"moving\\\"].mean()\\n\\n # Mean Velocity\\n perf_data[\\\"mean_velocity\\\"] = perf_log[\\\"velocity\\\"].mean()\\n performance_dict.update({perf_data[\\\"title\\\"]: perf_data})\\n\\n # Number of records\\n perf_data[\\\"total\\\"] = perf_log[\\\"x\\\"].count()\\n\\n self.performances = pd.DataFrame.from_dict(performance_dict, orient='index')\\n # self.performances.instrument = performances.instrument.astype('category')\\n if self.verbose:\\n print(\\\"Finished loading performances:\\\")\\n print(self.performances.describe())\",\n \"def import_data():\\n data = pd.read_csv('partA/bikes_October18.csv', ',')\\n return data\",\n \"def import_experiments_table(path):\\n return pd.read_csv(path, sep=\\\"\\\\t\\\", skiprows=1, header=0)\",\n \"def test_load_coinbasettr(self):\\n with open(self.filename) as f:\\n coinbasettr.CoinbaseTTRParser(csv_content=f)\\n parser = coinbasettr.CoinbaseTTRParser(filename=self.filename)\\n parser.cleanup()\",\n \"def test_load_success_small_dataset(self, mock_class):\\n\\n # ARRANGE\\n input_data = \\\"\\\"\\\"\\n CHILDRENS HOSPITAL DIALYSIS,012306,013300,1600 7TH AVENUE SOUTH,-,BIRMINGHAM,AL,35233,99\\n GADSDEN DIALYSIS,012501,-,409 SOUTH FIRST STREET,-,GADSDEN,AL,35901,100\\n TUSCALOOSA UNIVERSITY DIALYSIS,012502,-,220 15TH STREET,-,TUSCALOOSA,AL,35401,0\\n DOTHAN DIALYSIS,012506,-,216 GRACELAND DR.,-,DOTHAN,AL,36305,88\\n \\\"\\\"\\\"\\n input_df: DataFrame = self.create_data_frame_from_csv_string(input_data)\\n\\n # ACT\\n loader: LoaderCsv = LoaderCsv({'path': TestLoaderCsv.output_file})\\n loader.load(TestLoaderCsv.spark, input_df)\\n\\n # ASSERT\\n path = f'file://{TestLoaderCsv.output_file}'\\n df_from_loaded_csv: DataFrame = \\\\\\n TestLoaderCsv.spark.read.csv(path, header=True)\\n\\n assert df_from_loaded_csv.columns == [\\n 'facility_name', 'cms_certification_number_ccn', 'alternate_ccn_1', 'address_1',\\n 'address_2', 'city', 'state', 'zip_code', 'total_performance_score'\\n ]\\n self.assert_dataframe_contents(df_from_loaded_csv, [\\n ['CHILDRENS HOSPITAL DIALYSIS', '012306', '013300', '1600 7TH AVENUE SOUTH', '-', 'BIRMINGHAM', 'AL', '35233', '99'],\\n ['GADSDEN DIALYSIS', '012501', '-', '409 SOUTH FIRST STREET', '-', 'GADSDEN', 'AL', '35901', '100'],\\n ['TUSCALOOSA UNIVERSITY DIALYSIS', '012502', '-', '220 15TH STREET', '-', 'TUSCALOOSA', 'AL', '35401', '0'],\\n ['DOTHAN DIALYSIS', '012506', '-', '216 GRACELAND DR.', '-', 'DOTHAN', 'AL', '36305', '88'],\\n ])\",\n \"def load_testset(filename):\\n pickle_name = filename + \\\".pickle\\\"\\n try:\\n print(\\\"trying to load \\\" + filename + \\\" from pickle\\\")\\n dataset = pickle.load(open(pickle_name, \\\"rb\\\"))\\n except:\\n with open(filename, 'r') as csv_file:\\n print(\\\"no pickle exists. parsing file \\\" + filename)\\n dataset = [DataPoint(item[0:], \\\" \\\")\\n for item\\n in csv.reader(csv_file, delimiter=',')]\\n pickle.dump(dataset, open(pickle_name, \\\"wb\\\"))\\n print(\\\"loaded \\\" + filename)\\n return dataset\",\n \"def read_csv_file(self):\\n pass\",\n \"def load_susy(trainsize=500, testsize=1000):\\n filename = 'datasets/susysubset.csv'\\n dataset = loadcsv(filename)\\n trainset, testset = splitdataset(dataset, trainsize, testsize)\\n return trainset, testset\",\n \"def load_bank_data():\\n print(\\\"\\\\n\\\" * 8)\\n print(\\\" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\\\", \\\"\\\\n\\\")\\n csvpath = questionary.text(\\\"Enter a file path to a rate-sheet (.csv):\\\").ask()\\n print(\\\"\\\\n\\\",\\\"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\\\", \\\"\\\\n\\\")\\n csvpath = Path(csvpath)\\n if not csvpath.exists():\\n sys.exit(\\\"Oops! Can't find this path: \\\", csvpath)\\n\\n return load_csv(csvpath)\",\n \"def load_swc(file_name):\\n\\n df = pd.read_csv(file_name, delimiter=' ', header=None, comment='#',\\n names=['sample', 'identifier', 'x', 'y', 'z', 'r', 'parent'],\\n skipinitialspace=True).astype({'sample':int,'identifier':int,'x':float,'y':float,'z':float,'r':float,'parent':int})\\n return df\",\n \"def load_bhav_data_csv(self, filepath: str) -> None:\\n # create redis pipeline\\n pipeline = self.redis.pipeline(transaction=True)\\n pipeline.flushdb()\\n total_items_counter = 0\\n with open(filepath, \\\"r\\\") as csv_file:\\n csv_dict_reader = csv.DictReader(csv_file)\\n for row in csv_dict_reader:\\n prefixed_sc_name = f'BHAV:{row[\\\"SC_NAME\\\"].strip()}'\\n data = {\\n \\\"SC_CODE\\\": row[\\\"SC_CODE\\\"],\\n \\\"OPEN\\\": row[\\\"OPEN\\\"],\\n \\\"CLOSE\\\": row[\\\"CLOSE\\\"],\\n \\\"HIGH\\\": row[\\\"HIGH\\\"],\\n \\\"LOW\\\": row[\\\"LOW\\\"],\\n }\\n\\n pipeline.hset(\\n name=self.sc_name_hash_stored,\\n key=prefixed_sc_name,\\n value=json.dumps(data),\\n )\\n pipeline.zadd(\\n self.sc_name_sorted_set,\\n {prefixed_sc_name: 0},\\n )\\n total_items_counter += 1\\n pipeline.set(self.last_updated, str(timezone.now().date()))\\n pipeline.set(self.total_items_count, total_items_counter)\\n\\n # Execute\\n pipeline.execute()\\n return\",\n \"def _load_sample_table(self):\\n self.sampleTable = pd.read_table(self.config['sampletable'], sep='\\\\t', dtype=str)\\n self.sampleTable.set_index('sampleID', inplace=True)\\n self.samples = self.sampleTable.reset_index().to_dict('records')\",\n \"def load_data(loc='./data/', sp=None):\\n trainA, trainB, devA, devB, testA, testB = [],[],[],[],[],[]\\n trainS, devS, testS = [],[],[]\\n print('loc', loc)\\n with codecs.open(os.path.join(loc, 'SICK_train.txt'), mode='rb', encoding='utf-8') as f:\\n for line in f:\\n text = unicode_tr(line).lower().strip().split('\\\\t')\\n trainA.append(encode_sentence(text[1], sp))\\n trainB.append(encode_sentence(text[2], sp))\\n trainS.append(text[3])\\n with codecs.open(os.path.join(loc, 'SICK_trial.txt'), mode='rb', encoding='utf-8') as f:\\n for line in f:\\n text = unicode_tr(line).lower().strip().split('\\\\t')\\n devA.append(encode_sentence(text[1], sp))\\n devB.append(encode_sentence(text[2], sp))\\n devS.append(text[3])\\n with codecs.open(os.path.join(loc, 'SICK_test_annotated.txt'), mode='rb', encoding='utf-8') as f:\\n for line in f:\\n text = unicode_tr(line).lower().strip().split('\\\\t')\\n testA.append(encode_sentence(text[1], sp))\\n testB.append(encode_sentence(text[2], sp))\\n testS.append(text[3])\\n\\n trainS = [float(s) for s in trainS[1:]]\\n devS = [float(s) for s in devS[1:]]\\n testS = [float(s) for s in testS[1:]]\\n\\n return [trainA[1:], trainB[1:]], [devA[1:], devB[1:]], [testA[1:], testB[1:]], [trainS, devS, testS]\",\n \"def import_csv_data(cr, registry):\\n files = ['data/sc.info.csv']\\n for file in files:\\n tools.convert_file(cr, 'prospects_app', file, None,\\n mode='init', noupdate=True, kind='init')\",\n \"def load_csv(fname):\\n data = []\\n tools = {}\\n tool_names = []\\n version_stripper = {}\\n line_num = 0\\n print >> sys.stderr, (\\\"\\\\n\\\"),\\n for line in open(fname):\\n print >> sys.stderr, (\\\"\\\\rReading line: %i\\\") % (line_num),\\n line_num += 1\\n # parse file line\\n dataset1, dataset2, tool = line.rstrip('\\\\n').split(',')[:3]\\n # check if our tool has been stripped of version before\\n if tool not in version_stripper:\\n tool_split = tool.split('/')\\n if len(tool_split) > 1:\\n stripped = '/'.join(tool_split[:-1])\\n else:\\n stripped = tool\\n version_stripper[tool] = stripped\\n # check if tool exists in our tool list yet. If not, add it\\n if stripped not in tools:\\n tools[stripped] = len(tools)\\n tool_names.append(stripped)\\n # add datasets and tool index to data\\n data.append([int(dataset1), int(dataset2), tools[version_stripper[tool]]])\\n data = numpy.array(data, dtype=numpy.int32)\\n print >> sys.stderr, (\\\"\\\\rFinished reading csv file\\\\n\\\"),\\n return [data, tool_names]\",\n \"def loadRawData():\\n samples = []\\n with open('Sample_data/driving_log.csv') as csvfile:\\n reader = csv.reader(csvfile)\\n for line in reader:\\n # skip the first line, which is the title line\\n if line[0] != 'center':\\n samples.append(line)\\n # for testing implementation only, commented for GPU training\\n #if len(samples)>100:\\n # break\\n train_samples, validation_samples = train_test_split(samples, test_size=0.2)\\n return train_samples, validation_samples\",\n \"def _read_csv(self):\\n self.function_name = '_read_csv'\\n with open(os.path.join(self.task.downloads, self.csv_name)) as csv_file:\\n reader = csv.reader(csv_file, dialect='excel')\\n for row in reader:\\n self.input_data.append(row)\",\n \"def load_benchmark(directory: str,\\n source_url: Optional[str] = None,\\n validation: bool = False) -> np.ndarray:\\n path = f'{directory}/m5/datasets'\\n if source_url is not None:\\n filename = source_url.split('/')[-1].replace('.rar', '.csv')\\n filepath = f'{path}/{filename}'\\n if not os.path.exists(filepath):\\n download_file(path, source_url, decompress=True)\\n\\n else:\\n source_url = 'https://github.com/Nixtla/m5-forecasts/raw/main/forecasts/0001 YJ_STU.zip'\\n return M5Evaluation.load_benchmark(directory, source_url, validation)\\n\\n benchmark = pd.read_csv(filepath)\\n mask = benchmark['id'].str.endswith('validation')\\n if validation:\\n benchmark = benchmark[mask]\\n benchmark['id'] = benchmark['id'].str.replace('_validation', '')\\n else:\\n benchmark = benchmark[~mask]\\n benchmark['id'] = benchmark['id'].str.replace('_evaluation', '')\\n\\n benchmark = benchmark.sort_values('id', ignore_index=True)\\n benchmark.rename(columns={'id': 'unique_id'}, inplace=True)\\n *_, s_df = M5.load(directory)\\n benchmark = benchmark.merge(s_df, how='left',\\n on=['unique_id'])\\n\\n return benchmark\",\n \"def load_results_runs(filename):\\n # Load the necessary columns from the csv into panda\\n data = pd.read_csv(filename)\\n\\n # Cleans the data\\n data = data[['Run', 'Total Distance']]\\n data['Run'] = pd.to_numeric(data['Run'])\\n data['Total Distance'] = pd.to_numeric(data['Total Distance'])\\n\\n return data\",\n \"def from_csv(cls, load_folder: Path) -> \\\"Parameters\\\":\\n serializer = serializer_factory(fmt=SerializerEnum.CSV)\\n return serializer.load(class_obj=cls, folder_path=load_folder)\",\n \"def load_data(loc='../data/SICK/'):\\n trainA, trainB, testA, testB = [],[],[],[]\\n trainS, testS = [],[]\\n\\n with open(loc + 'SICK_train.txt', 'rb') as f:\\n for line in f:\\n text = line.strip().split('\\\\t')\\n trainA.append(text[1])\\n trainB.append(text[2])\\n trainS.append(text[3])\\n with open(loc + 'SICK_test_annotated.txt', 'rb') as f:\\n for line in f:\\n text = line.strip().split('\\\\t')\\n testA.append(text[1])\\n testB.append(text[2])\\n testS.append(text[3])\\n\\n trainS = [float(s) for s in trainS[1:]]\\n testS = [float(s) for s in testS[1:]]\\n\\n return [trainA[1:], trainB[1:]], [testA[1:], testB[1:]], [trainS, testS]\",\n \"def _load_csv(self, file_path):\\n csv_ds = tf.data.experimental.CsvDataset(\\n file_path, self._default_csv_values,\\n header=True,\\n field_delim=CsvFilesDataset.CSV_SEPARATOR,\\n use_quote_delim=False,\\n select_cols=self._feature_column_indices\\n )\\n\\n # Map to dictionary with column names\\n if self.debug_columns:\\n csv_ds = csv_ds.enumerate()\\n csv_ds = csv_ds.map(lambda *row: self._map_csv_row_to_dict_with_debug(file_path, row))\\n else:\\n csv_ds = csv_ds.map(\\n lambda *row: { feature_column_name: csv_column_values for feature_column_name, csv_column_values in zip(self._feature_column_names, row) }\\n )\\n\\n # Get CSV file sequences\\n csv_ds = self._map_csv_file_to_sequences(csv_ds, file_path)\\n\\n # Remove train column (avoid keras warning about unused inputs)\\n if self._data_definition.trainable_column:\\n csv_ds = csv_ds.map(self.remove_trainable_column)\\n\\n return csv_ds\",\n \"def load_utlization(path):\\n df = pd.read_csv(f\\\"{raw_data}\\\\\\\\{path}\\\", parse_dates=[\\\"AdmissionDate\\\"])\\n\\n df.rename(\\n columns={\\\"MemberID\\\": \\\"member_id\\\", \\\"LOSDays\\\": \\\"los\\\", \\\"FacilityName\\\": \\\"facility\\\"},\\n inplace=True,\\n )\\n\\n df.columns = clean_table_columns(df.columns)\\n\\n facility_col = [col for col in df.columns if \\\"facility\\\" in col][0]\\n\\n df = cognify_facility_changes(df, facility_col)\\n\\n df = df[df.member_id != 1003]\\n return df\",\n \"def __init__(self, benchmark_dir):\\n self.__benchmark_dir = benchmark_dir\\n self.__load_configs()\\n self.__load_results()\",\n \"def setup(self):\\n self.rows = test_helpers.fetch_sample_teradata_rows()\\n self.csv_path = 'not/a/real/path'\",\n \"def read_data(self):\\n print 'Reading Data ...'\\n fname = self.wpath + 'Data/' + self.city[2] + '-' + self.application + '.csv.bz2'\\n self.dataset = loadtxt(fname, skiprows=1,\\n dtype=[('lat', 'f8'), ('lng', 'f8'), ('time', 'i4'), ('user', 'S20')],\\n usecols=(0, 1, 2, 3), delimiter=';', comments='#')\",\n \"def test_load_from_long_to_dataframe(tmpdir):\\n # create and save a example long-format file to csv\\n test_dataframe = generate_example_long_table()\\n dataframe_path = tmpdir.join(\\\"data.csv\\\")\\n test_dataframe.to_csv(dataframe_path, index=False)\\n # load and convert the csv to sktime-formatted data\\n nested_dataframe = load_from_long_to_dataframe(dataframe_path)\\n assert isinstance(nested_dataframe, pd.DataFrame)\",\n \"def test_load_success_large_dataset(self, mock_class):\\n\\n # ARRANGE\\n input_data = \\\"\\\"\\\"\\n CHILDRENS HOSPITAL DIALYSIS,012306,013300,1600 7TH AVENUE SOUTH,-,BIRMINGHAM,AL,35233,99\\n GADSDEN DIALYSIS,012501,-,409 SOUTH FIRST STREET,-,GADSDEN,AL,35901,100\\n TUSCALOOSA UNIVERSITY DIALYSIS,012502,-,220 15TH STREET,-,TUSCALOOSA,AL,35401,0\\n DOTHAN DIALYSIS,012506,-,216 GRACELAND DR.,-,DOTHAN,AL,36305,88\\n \\\"\\\"\\\"\\n input_df: DataFrame = self.create_data_frame_from_csv_string(input_data)\\n\\n # ACT\\n loader: LoaderCsv = LoaderCsv({'path': TestLoaderCsv.output_file})\\n loader.load(TestLoaderCsv.spark, input_df)\\n\\n # ASSERT\\n path = f'file://{TestLoaderCsv.output_file}'\\n df: DataFrame = TestLoaderCsv.spark.read.csv(path, header=True)\\n # TODO: you can replace the above statement with code to read from\\n # a database table; see case_study/etl/extract/extractor_db.py\\n\\n assert df.columns == [\\n 'facility_name', 'cms_certification_number_ccn', 'alternate_ccn_1', 'address_1',\\n 'address_2', 'city', 'state', 'zip_code', 'total_performance_score'\\n ]\\n assert df.count() == 4\\n\\n df.createOrReplaceTempView('loaded_data') # used in SQL queries below\\n\\n # verify one value of one row\\n result: Row = self.spark.sql(\\\"\\\"\\\"\\n select total_performance_score score \\n from loaded_data\\n where cms_certification_number_ccn == '012306'\\n \\\"\\\"\\\").collect()[0]\\n assert result.score == '99'\\n\\n # assert df.select(df.total_performance_score) \\\\\\n # .where(df.cms_certification_number_ccn == '012306')\\\\\\n # .collect()[0] == '99'\\n\\n # verify that a record is not present (i.e., it should have been\\n # filtered out by the tranform operation)\\n assert not self.spark.sql(\\\"\\\"\\\"\\n select * \\n from loaded_data\\n where cms_certification_number_ccn == '012307'\\n \\\"\\\"\\\").collect()\",\n \"def load(*args):\\r\\n\\r\\n #args[0].to_csv(str(PATH.joinpath('./data/{}.csv'.format(args[1]))),index=False)\\r\\n\\r\\n try: # it will fail if duplicates\\r\\n args[0].to_sql('cmf', con=engine, if_exists='append', index=False)\\r\\n except:\\r\\n pass\",\n \"def load_dataset_test():\\n df_test = load_csv_file(\\\"31_test.csv\\\")\\n return df_test.values\",\n \"def load_data(y_name='Species'):\\n train_path = tf.keras.utils.get_file(args.TRAIN_URL.split('/')[-1], args.TRAIN_URL)\\n test_path = tf.keras.utils.get_file(args.TEST_URL.split('/')[-1], args.TEST_URL)\\n\\n train = pd.read_csv(train_path, names=args.CSV_COLUMN_NAMES, header=0)\\n train_x, train_y = train, train.pop(y_name)\\n\\n test = pd.read_csv(test_path, names=args.CSV_COLUMN_NAMES, header=0)\\n test_x, test_y = test, test.pop(y_name)\\n\\n return (train_x, train_y), (test_x, test_y)\",\n \"def main():\\n # Load and parse json object from file with specific\\n file_name = \\\"./benchmark.log\\\"\\n doc = re.sub(\\\"[\\\\n|\\\\t]\\\", \\\"\\\", \\\"\\\".join(benchmark.read_text_file(file_name)))\\n json_object = json.loads(\\\"\\\".join(doc))\\n\\n intervals = json_object[\\\"intervals\\\"]\\n\\n socket_keys = benchmark.get_socket_keys(intervals)\\n\\n result = benchmark.get_result_dictionary(intervals, socket_keys)\\n\\n print_to_csv(result, socket_keys)\",\n \"def read_csv(spark: SparkSession, config, log: Log4j):\\n data = spark.read.schema(boston_schema).option(\\\"header\\\", \\\"true\\\").csv(config[\\\"boston_dataset_csv_path\\\"])\\n log.warn(\\\"CSV Files Read Completed\\\")\\n return data\",\n \"def load_from_csv(self, file_name, parameters_size):\\n \\n with open(file_name) as csvDataFile:\\n csvReader = csv.reader(csvDataFile)\\n for row in csvReader:\\n simulation_name = str(row[0:1])[2:-2] # Remove brakets and quotation marks \\n result_name = str(row[1:2])[2:-2] # Remove brakets and quotation marks \\n params = np.float64(row[2:parameters_size+2])\\n res = np.float64(row[parameters_size+2:])\\n self.add_sample(parameters = params, simulation_name = simulation_name, result = res, result_name = result_name)\",\n \"def load_dataset(path):\\n training_data = []\\n with open(path) as csv_file:\\n reader = csv.reader(csv_file, delimiter=\\\",\\\")\\n next(reader)\\n for row in reader:\\n training_data.append(row[1])\\n return training_data\",\n \"def loader():\\n bucket = data_load_variables[\\\"bucket\\\"]\\n\\n if data_load_variables[\\\"use_lite_dataset\\\"]:\\n dataset_name = data_load_variables[\\\"lite_dataset_name\\\"]\\n else:\\n dataset_name = data_load_variables[\\\"dataset_name\\\"]\\n\\n s3 = boto3.client('s3')\\n\\n obj = s3.get_object(Bucket=bucket, Key=dataset_name)\\n # get object and file (key) from bucket\\n\\n df = pd.read_csv(obj['Body'])\\n return df\",\n \"def load(cls, conf, regex=None):\\n try:\\n path = cls.get_benchmark_file_path(conf.results_dir)\\n if not os.path.isfile(path):\\n raise util.UserError(f\\\"Benchmark list file {path} missing!\\\")\\n d = util.load_json(path, api_version=cls.api_version)\\n benchmarks = d.values()\\n return cls(conf, benchmarks, regex=regex)\\n except util.UserError as err:\\n if \\\"asv update\\\" in str(err):\\n # Don't give conflicting instructions\\n raise\\n raise util.UserError(\\\"{}\\\\nUse `asv run --bench just-discover` to \\\"\\n \\\"regenerate benchmarks.json\\\".format(str(err)))\",\n \"def test_valid_csv(self):\\n url=\\\"http://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data\\\"\\n readerobject=requester.url_to_csv(url, fname='wine2')\\n self.assertTrue(str(type(readerobject)),\\\"_csv.reader\\\")\",\n \"def loadStats(stafil, returnmeta=False):\\n meta = collections.namedtuple('meta', 'comment, starttime, startdate, stopwatchtime, exported')\\n meta_ = {}\\n data = None\\n \\n with open(stafil, 'r') as fIn:\\n start = False\\n for line in fIn:\\n if line:\\n lline = line.strip()\\n try:\\n splitLine = lline.split(None)\\n \\n # I don't feel great about hard-coding this, but time *should* be first...\\n if len(splitLine) > 0:\\n if splitLine[0] == '\\\"Time' and start is False:\\n # print(lline)\\n data = {lline.split('\\\"')[u]: [] for u in [1,3,5,7,9,11]}\\n order = [lline.split('\\\"')[u] for u in [1,3,5,7,9,11] ]\\n start = True\\n elif len(splitLine) > 3 and start is True:\\n for j in range(len(splitLine)):\\n data[order[j]].append(splitLine[j])\\n except:\\n pass\\n # Now the whole dictionary should be populated\\n \\n if data is None:\\n print('Nothing found for %s' %stafil)\\n return None\\n \\n if returnmeta:\\n return pd.DataFrame(data=data), meta_\\n return pd.DataFrame(data=data,)\",\n \"def load_test_data(batch_size=32):\\n log = logging.getLogger(__name__)\\n\\n log.info('Reading TEST csv file...')\\n # read csv data file\\n\\n samples = []\\n with open('./test_driving_log.csv') as f:\\n csv_reader = csv.reader(f)\\n next(csv_reader) #just skip the header line for test data set provided by Udacity\\n\\n for row in csv_reader:\\n samples.append(row)\\n\\n generator = input_generator(samples, batch_size, is_for_validation=True, drop_zero_samples=True)\\n return generator, math.ceil(len(samples) / batch_size)\",\n \"def test_sbml_import_works(self):\\n ## create sbml file for import\\n sbml_filename = self.mod.to_sbml()\\n assert os.path.isfile(sbml_filename)\\n\\n ## remove the existing copasi file\\n if os.path.isfile(self.copasi_file1):\\n os.remove(self.copasi_file1)\\n\\n ## import sbml\\n mod = model.ImportSBML(sbml_filename).model\\n self.assertIsInstance(mod, model.Model)\\n # TC = tasks.TimeCourse(mod, end=100, intervals=100, step_size=1)\\n # plotted_time_course = viz.PlotTimeCourse(TC, savefig=True)\\n # self.assertEqual(\\n # 3,\\n # len(\\n # glob.glob(\\n # os.path.join(plotted_time_course.results_directory, '*')\\n # )\\n # )\\n # )\",\n \"def load_crawl():\\n\\n\\tmodule_path = dirname(__file__)\\n\\twith open(join(module_path, 'data', 'train2.csv')) as csv_file:\\n\\t\\tdata_file = csv.reader(csv_file)\\n\\t\\ttemp = next(data_file)\\n\\t\\tglobal n_samples\\n\\t\\tn_samples = int(temp[0])\\n\\t\\tglobal n_features\\n\\t\\tn_features = int(temp[1])\\n\\t\\tprint \\\"n samples \\\" + str((n_samples))\\n\\t\\tprint \\\"n_features\\\" + str((n_features))\\n\\t\\ttarget_names = np.array(temp[2:4])\\n\\t\\tdata = np.empty((n_samples, n_features))\\n\\t\\ttarget = np.empty((n_samples,), dtype=np.int)\\n\\n\\t\\tfor count, value in enumerate(data_file):\\n\\t\\t\\tdata[count] = np.asarray(value[:-1], dtype=np.float)\\n\\t\\t\\ttarget[count] = np.asarray(value[-1], dtype=np.int)\\n\\t\\t\\t#print \\\"data is \\\" + str(data[count])\\n\\t\\t\\t#print \\\"target is \\\" + str(target[count])\\n\\t\\tprint \\\"Number of target records is \\\" + str(len(target))\\n\\t#with open(join(module_path, 'descr', 'train.rst')) as rst_file:\\n\\t#\\tfdescr = rst_file.read()\\n\\n\\treturn Bunch(data=data, target=target,\\n\\t\\t\\t target_names=target_names,\\n\\t\\t\\t DESCR=None,\\n\\t\\t\\t feature_names = ['evalCount', 'setInterval', 'setTimeout', 'link', \\n\\t\\t\\t\\t\\t\\t\\t 'search', 'exec','escape', 'unescape', 'ratio', \\n\\t\\t\\t\\t\\t\\t\\t 'emtropyAvg', 'entropyScript', 'longStrings', \\n\\t\\t\\t\\t\\t\\t\\t 'maxEntropy', 'stringAvg', 'maxLength', 'longVarFunc', \\n\\t\\t\\t\\t\\t\\t\\t 'stringAssignments', 'stringModFuncsCount', 'eventFuncsCount', \\n\\t\\t\\t\\t\\t\\t\\t 'domModFuncsCounter', 'suspStrings', 'whiteSpaceRatio', \\n\\t\\t\\t\\t\\t\\t\\t 'hexaStrings', 'maxNonPrintableCharactersinString', 'lineAvg', \\n\\t\\t\\t\\t\\t\\t\\t 'iframeCount', 'malTagCount', 'jsLength'])\",\n \"def download_datasets_csv(url):\\n # dataset = pd.read_csv(url, sep='\\\\t')\\n dataset = pd.read_csv(url, sep=\\\",\\\")\\n dataset.columns = dataset.columns.str.replace(\\\" \\\", \\\"_\\\")\\n return dataset\",\n \"def get_data(fpath):\\n\\n visits = ['SC', 'BL', 'V01', 'V02', 'V03', 'V04', 'V05', 'V06', 'V07',\\n 'V08', 'V09', 'V10', 'V11', 'V12', 'V13', 'V14', 'V15']\\n dtype = dict(PATNO=str,\\n CLINICAL_EVENT=cdtype(visits, ordered=True),\\n TESTNAME=str,\\n TESTVALUE=str)\\n\\n fname = op.join(fpath, 'Current_Biospecimen_Analysis_Results.csv')\\n data = pd.read_csv(fname, dtype=dtype)\\n\\n data['TESTVALUE'] = pd.to_numeric(data.TESTVALUE, errors='coerce')\\n data = data.rename(columns=RENAME_COLS).assign(**ASSIGN_COLS)[RETAIN_COLS]\\n data = data.dropna(axis=0, subset=['SCORE'])\\n\\n return data\",\n \"def _load(self, config: Dict):\\n return pd.read_csv(config['path'])\",\n \"def _load_test_data(self):\\n\\n self.test_loader = data.Test_loader(self.N_max, self.n_per_conn,\\n self.data_path, self.device)\\n\\n self.test_loader.load_data()\\n\\n # load mean and std from train\\n scc_mean_std = np.loadtxt(\\n os.path.join(self.data_path, 'scc_mean_std.csv'), delimiter=',')\\n self.mean = torch.Tensor(scc_mean_std[0])\\n self.std = torch.Tensor(scc_mean_std[1])\",\n \"def load_swc(file_name):\\n df = pd.read_csv(file_name, sep = ' ', header=None, comment='#', index_col = False,\\n names=['sample', 'identifier', 'x', 'y', 'z', 'r', 'parent'],\\n skipinitialspace=True)\\n return df\",\n \"def get_data(self, csv_file):\\n pass\",\n \"def load(self):\\n\\t\\t# save self.dfAnalysis\\n\\t\\tcsvPath = self._getSavePath()\\n\\t\\tif os.path.isfile(csvPath):\\n\\t\\t\\tprint('todo: load from', csvPath)\\n\\t\\t\\tself.dfAnalysis = pd.read_csv(csvPath, header=0)\\n\\t\\t\\tself.updateAnalysisPlot()\\n\\t\\telse:\\n\\t\\t\\tprint('did not find saved file csvPath:', csvPath)\",\n \"def load_scatter_table(self, fn):\\n with open(fn, 'rb') as f:\\n data = pickle.load(f)\\n\\n if (\\\"version\\\" not in data) or (data[\\\"version\\\"]!=tmatrix_aux.VERSION):\\n warnings.warn(\\\"Loading data saved with another version.\\\", Warning)\\n\\n (self.num_points, self.D_max, self._psd_D, self._S_table, \\n self._Z_table, self._angular_table, self._m_table, \\n self.geometries) = data[\\\"psd_scatter\\\"]\\n return (data[\\\"time\\\"], data[\\\"description\\\"])\",\n \"def data_import(path):\\n train_path = os.path.join(path, \\\"train.csv\\\")\\n test_path = os.path.join(path, \\\"test.csv\\\")\\n df_train = pd.read_csv(train_path)\\n df_test = pd.read_csv(test_path)\\n return df_train, df_test\",\n \"def load(self):\\n\\t\\tprint('bSlabList.load()')\",\n \"def load_step_data(self, subject_id:str) -> pd.DataFrame:\\n sp_fp = os.path.join(self.steps_dir, subject_id+self.steps_file_suffix)\\n df_sp = pd.read_csv(sp_fp, sep=\\\",\\\", header=None, names=[\\\"sec\\\",\\\"step_count\\\"])\\n df_sp = df_sp.sort_values(by=\\\"sec\\\")\\n df_sp = df_sp.drop_duplicates(subset=\\\"sec\\\")\\n df_sp = df_sp.reset_index(drop=True)\\n return df_sp\",\n \"def load_dataset(file_name, model_ver):\\n\\n print 'Loading dataset ...'\\n\\n if model_ver == 'dmspline':\\n file_path = join(DATA_DIR, file_name)\\n id_field = Field(sequential=False, use_vocab=False, dtype=torch.int)\\n text_field = Field(pad_token=None, tokenize=_tokenize_str)\\n attr_field = Field(sequential=False, use_vocab=False, dtype=torch.float)\\n standardzed_attr_field = Field(sequential=False, use_vocab=False, dtype=torch.float)\\n\\n dataset = TabularDataset(\\n path=file_path,\\n format='csv',\\n fields=[('attr', attr_field), ('id', id_field), ('standardized_attr', standardzed_attr_field), ('text', text_field)],\\n skip_header=True)\\n\\n else:\\n file_path = join(DATA_DIR, file_name)\\n id_field = Field(sequential=False, use_vocab=False, dtype=torch.int)\\n text_field = Field(pad_token=None, tokenize=_tokenize_str)\\n\\n dataset = TabularDataset(\\n path=file_path,\\n format='csv',\\n fields=[('id', id_field), ('text', text_field)],\\n skip_header=True)\\n\\n text_field.build_vocab(dataset, min_freq=10)\\n return dataset\",\n \"def load_data():\\n directories=[\\\"./track1/\\\",\\n \\\"./track1_recovery/\\\",\\n \\\"./track2/\\\",\\n \\\"./track1_reverse/\\\",\\n \\\"./track2_reverse/\\\",#Additional data for model built on top of lenet.h5\\n \\\"./track2_recovery/\\\",#Additions data for model built on top of lenet.h5\\n ]\\n lines=[]\\n for directory in directories:\\n with open(directory+\\\"driving_log.csv\\\") as csvfile:\\n reader=csv.reader(csvfile)\\n for line in reader:\\n lines.append(line)\\n train_samples, validation_samples = train_test_split(lines, test_size=0.2)\\n return train_samples, validation_samples\",\n \"def load_from_table(filename: str) -> List[Sample]:\\n with open(filename, \\\"r+\\\", newline=\\\"\\\") as f:\\n reader = csv.reader(f)\\n return samples_from_iterator(reader)\",\n \"def main():\\n # openfile allows for CSV files with stored data of two columns\\n # data = openfile(\\\"filename\\\")\\n data = get_data()\\n abtest = AB_test(data)\\n abtest.stats()\\n abtest.print_stats()\",\n \"def main():\\n manager = S3Manager(\\n bucket_name=\\\"introtodatascience5\\\",\\n key=\\\"'open_data/emergency_medical_service/origin/csv/응급의료기관현황(2014.5).csv'\\\"\\n )\\n df = manager.load_csv_to_df()\\n print(df)\",\n \"def load_data(params):\\n train_df = pd.read_csv(os.path.join(*[dataset_path, params['tokenizer'] + '_train_' + params['stemming'] + '.csv']))\\n dev_df = pd.read_csv(os.path.join(*[dataset_path, params['tokenizer'] + '_dev_' + params['stemming'] + '.csv']))\\n train_data, label_encode = data_prep(train_df, params, if_resample=True)\\n dev_data, _ = data_prep(dev_df, params)\\n return train_data, dev_data, label_encode\",\n \"def main():\\r\\n run_processes('tests.csv', 'labs.csv')\",\n \"def load_dataset(input_path):\\n with open(input_path, \\\"r\\\") as f:\\n smiles_list = f.read().strip().split(\\\"\\\\n\\\")\\n return smiles_list\",\n \"def load_all_trades():\\n trades = []\\n\\n kraken_trades_filename = \\\"data_private/kraken-trades.csv\\\"\\n if Path(kraken_trades_filename).exists():\\n print(\\\"Found kraken trades!\\\")\\n trades_kraken_csv = _load_csv(kraken_trades_filename)\\n trades.extend(_format_csv_from_kraken(trades_kraken_csv))\\n\\n polo_trades_filename = \\\"data_private/poloniex-trades.csv\\\"\\n if Path(polo_trades_filename).exists():\\n print(\\\"Found poloniex trades!\\\")\\n trades_polo_csv = _load_csv(polo_trades_filename)\\n trades.extend(_format_csv_from_poloniex(trades_polo_csv))\\n\\n bitstamp_trades_filename = \\\"data_private/bitstamp-trades.csv\\\"\\n if Path(bitstamp_trades_filename).exists():\\n print(\\\"Found bitstamp trades!\\\")\\n trades_bitstamp_csv = _load_csv(bitstamp_trades_filename)\\n trades.extend(_format_csv_from_bitstamp(trades_bitstamp_csv))\\n\\n lbtc_trades_filename = \\\"data_private/lbtc-trades.csv\\\"\\n if Path(lbtc_trades_filename).exists():\\n print(\\\"Found lbtc trades!\\\")\\n trades_lbtc_csv = _load_csv(lbtc_trades_filename)\\n trades.extend(_format_csv_from_lbtc(trades_lbtc_csv))\\n\\n return list(sorted(trades, key=lambda t: t[\\\"time\\\"]))\",\n \"def from_csv(self, path_to_load):\\n import pandas as pd\\n\\n df = pd.read_csv(path_to_load)\\n df = df.loc[:, ~df.columns.str.contains('^Unnamed')] # Remove unnnamed\\n\\n self.results['cids'] = list()\\n self.results['differences'] = list()\\n self.results['experimental_values'] = list()\\n\\n pd_dict = df.to_dict()\\n length = len(pd_dict['cids'])\\n for cid in [pd_dict['cids'][i] for i in range(0, length)]:\\n self._results['cids'].append(cid)\\n for cid in [pd_dict['differences'][i] for i in range(0, length)]:\\n self._results['differences'].append(cid)\\n for cid in [pd_dict['experimental_values'][i]\\n for i in range(0, length)]:\\n self._results['experimental_values'].append(cid)\",\n \"def load_data_to_db(self, path):\\n table_names = ['train_transaction', 'train_identity', 'test_transaction', 'test_identity']\\n for table_name in table_names:\\n pat = self.TRANSACTION_NON_NUMBER_PATTERN if 'transaction' in table_name else self.IDENTITY_NON_NUMBER_PATTERN\\n print(\\\"Loading table: \\\" + table_name)\\n fn = os.path.join(path, table_name + '.csv')\\n self.dbinstance.build_table_from_csv(fn, pat, table_name)\\n print(\\\"Loaded table \\\" + table_name)\",\n \"def load(name):\\n if name in datasets:\\n\\n return pd.read_csv(os.path.join(datasets_path, \\\"%s.csv\\\" % name))\\n else:\\n raise ValueError(\\\"Dataset not found!\\\")\",\n \"def import_data():\\n import pandas as pd\\n \\n df = pd.read_csv('Company_Bankruptcy_Prediction.csv')\\n return df\",\n \"def load_tweets(fp):\\r\\n ans = pd.read_csv(fp, sep='\\\\t')\\r\\n return ans\",\n \"def read_csv(self, file: str, table: str, libref: str =\\\"\\\", nosub: bool =False, opts: dict = None) -> '<SASdata object>':\\n opts = opts if opts is not None else {}\\n\\n code = \\\"filename x \\\"\\n\\n if file.lower().startswith(\\\"http\\\"):\\n code += \\\"url \\\"\\n\\n code += \\\"\\\\\\\"\\\"+file+\\\"\\\\\\\";\\\\n\\\"\\n code += \\\"proc import datafile=x out=\\\"\\n if len(libref):\\n code += libref+\\\".\\\"\\n code += \\\"'\\\"+table.strip()+\\\"'n dbms=csv replace; \\\"+self._sb._impopts(opts)+\\\" run;\\\"\\n\\n if nosub:\\n print(code)\\n else:\\n ll = self.submit(code, \\\"text\\\")\",\n \"def load_dataset(path, test_or_train):\\n senta_batch, sentb_batch, scores_batch = [], [], []\\n with open(path, encoding='utf-8') as f:\\n for i, line in enumerate(f):\\n items = line.strip().split('\\\\t')\\n if test_or_train == 'train':\\n senta, sentb, score = items[-2], items[-1], float(items[-3])\\n elif test_or_train in ['dev', 'test']:\\n senta, sentb, score = items[-2], items[-1], float(items[-3])\\n else:\\n raise Exception(\\\"{} error\\\".format(test_or_train))\\n senta_batch.append(senta)\\n sentb_batch.append(sentb)\\n scores_batch.append(score)\\n return senta_batch, sentb_batch, scores_batch\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61960995","0.6105455","0.5986365","0.5912232","0.58732283","0.5808441","0.57353777","0.5726986","0.5686586","0.568514","0.5670385","0.56530213","0.5645176","0.5643989","0.56404597","0.5638081","0.562153","0.5615256","0.5598542","0.5506595","0.550397","0.5502456","0.5498616","0.5497663","0.5488738","0.54865706","0.5484853","0.5482967","0.54734844","0.5452148","0.54364187","0.543349","0.541907","0.54095286","0.5403607","0.5403327","0.54022527","0.53949624","0.5390832","0.5384125","0.53690153","0.5348841","0.5338616","0.5334266","0.5322431","0.53122884","0.5308573","0.5295654","0.5294313","0.52930087","0.52697104","0.5260993","0.525996","0.5255876","0.52408916","0.5240882","0.5236138","0.52333164","0.52266335","0.5224932","0.520685","0.52046007","0.51999676","0.5199597","0.5196405","0.51963305","0.51924527","0.51870143","0.5180206","0.5179425","0.5175914","0.5172578","0.51722676","0.51721853","0.5171752","0.51679957","0.5165513","0.5164584","0.51613295","0.5155855","0.51553005","0.51550305","0.51541483","0.5150259","0.51364285","0.51342046","0.513296","0.51316243","0.51299304","0.51295763","0.51233244","0.5122521","0.5121331","0.51115185","0.5102237","0.5100995","0.5098296","0.50979185","0.50964785","0.50962293","0.50962114"],"string":"[\n \"0.61960995\",\n \"0.6105455\",\n \"0.5986365\",\n \"0.5912232\",\n \"0.58732283\",\n \"0.5808441\",\n \"0.57353777\",\n \"0.5726986\",\n \"0.5686586\",\n \"0.568514\",\n \"0.5670385\",\n \"0.56530213\",\n \"0.5645176\",\n \"0.5643989\",\n \"0.56404597\",\n \"0.5638081\",\n \"0.562153\",\n \"0.5615256\",\n \"0.5598542\",\n \"0.5506595\",\n \"0.550397\",\n \"0.5502456\",\n \"0.5498616\",\n \"0.5497663\",\n \"0.5488738\",\n \"0.54865706\",\n \"0.5484853\",\n \"0.5482967\",\n \"0.54734844\",\n \"0.5452148\",\n \"0.54364187\",\n \"0.543349\",\n \"0.541907\",\n \"0.54095286\",\n \"0.5403607\",\n \"0.5403327\",\n \"0.54022527\",\n \"0.53949624\",\n \"0.5390832\",\n \"0.5384125\",\n \"0.53690153\",\n \"0.5348841\",\n \"0.5338616\",\n \"0.5334266\",\n \"0.5322431\",\n \"0.53122884\",\n \"0.5308573\",\n \"0.5295654\",\n \"0.5294313\",\n \"0.52930087\",\n \"0.52697104\",\n \"0.5260993\",\n \"0.525996\",\n \"0.5255876\",\n \"0.52408916\",\n \"0.5240882\",\n \"0.5236138\",\n \"0.52333164\",\n \"0.52266335\",\n \"0.5224932\",\n \"0.520685\",\n \"0.52046007\",\n \"0.51999676\",\n \"0.5199597\",\n \"0.5196405\",\n \"0.51963305\",\n \"0.51924527\",\n \"0.51870143\",\n \"0.5180206\",\n \"0.5179425\",\n \"0.5175914\",\n \"0.5172578\",\n \"0.51722676\",\n \"0.51721853\",\n \"0.5171752\",\n \"0.51679957\",\n \"0.5165513\",\n \"0.5164584\",\n \"0.51613295\",\n \"0.5155855\",\n \"0.51553005\",\n \"0.51550305\",\n \"0.51541483\",\n \"0.5150259\",\n \"0.51364285\",\n \"0.51342046\",\n \"0.513296\",\n \"0.51316243\",\n \"0.51299304\",\n \"0.51295763\",\n \"0.51233244\",\n \"0.5122521\",\n \"0.5121331\",\n \"0.51115185\",\n \"0.5102237\",\n \"0.5100995\",\n \"0.5098296\",\n \"0.50979185\",\n \"0.50964785\",\n \"0.50962293\",\n \"0.50962114\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":92878,"cells":{"query":{"kind":"string","value":"Label encoding from Tree LSTM paper (Tai, Socher, Manning)."},"document":{"kind":"string","value":"def encode_labels(labels, nclass=5):\n y = np.zeros((len(labels), nclass)).astype('float32')\n for j, yj in enumerate(labels):\n for i in range(nclass):\n if i+1 == np.floor(yj) + 1:\n y[j, i] = yj - np.floor(yj)\n if i+1 == np.floor(yj):\n y[j, i] = np.floor(yj) - yj + 1\n return y"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getLabelEncoder():\n classes = list(string.letters + string.digits)\n classes.append('')\n le = LabelEncoder()\n le.fit(classes)\n\n return le","def build_label_transform():\n\n return NALabelEncoder()","def lblencoder(self):\n for i in self.data.columns:\n if self.data[i].dtype=='object':\n lbl = preprocessing.LabelEncoder()\n lbl.fit(list(self.data[i].values))\n self.data[i] = lbl.transform(list(self.data[i].values))\n \n self.X = self.data.drop(self.target, axis =1)\n self.y = self.data[self.target]","def train_le(self):\n\n lisa = [self.get_prev_word(i, orignal=True) for i in range(len(self.df))]\n lisb = [self.get_next_word(i, orignal=True) for i in range(len(self.df))]\n lis = lisa + lisb\n lis.append(\"<NAP>\")\n lis.append(\"<START>\")\n return self.label_encoder.fit(lis)","def build_label_transform():\n\n return RobustLabelEncoder(\n labels=['0'], fill_label_value='1', include_unseen_class=True\n )","def predict_label(self, src): # real signature unknown; restored from __doc__\n pass","def encode_label(label: np.array, nb_classes: int):\n encoded = np.zeros(nb_classes)\n encoded[int(label)] = 1.\n return encoded","def prepareLabel(Y):\n\t\n\tdef approximate(inp,w_len):\n\t\t\"\"\"\n\t\tDownsamples using taking mean over window\n\t\t\n\t\tArguments:\n\t\t\tinp {array} -- signal\n\t\t\tw_len {int} -- length of window\n\t\t\n\t\tReturns:\n\t\t\tarray -- downsampled signal\n\t\t\"\"\"\n\t\t\n\t\top = []\n\t\t\n\t\tfor i in range(0,len(inp),w_len):\n\t\t\n\t\t\top.append(np.mean(inp[i:i+w_len]))\n\t\t\t\n\t\treturn np.array(op)\n\t\n\tout = {}\n\tout['out'] = []\n\tout['level1'] = []\n\tout['level2'] = []\n\tout['level3'] = []\n\tout['level4'] = []\n\t\n\t\n\tfor y in tqdm(Y,desc='Preparing Label for DS'):\n\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t# computing approximations\n\t\tcA1 = approximate(np.array(y).reshape(length), 2)\n\t\t\n\t\tcA2 = approximate(np.array(y).reshape(length), 4)\n\t\t\n\t\tcA3 = approximate(np.array(y).reshape(length), 8)\n\t\t\n\t\tcA4 = approximate(np.array(y).reshape(length), 16)\n\t\t\n\t\t\n\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t# populating the labels for different labels\n\t\tout['out'].append(np.array(y.reshape(length,1)))\n\t\tout['level1'].append(np.array(cA1.reshape(length//2,1)))\n\t\tout['level2'].append(np.array(cA2.reshape(length//4,1)))\n\t\tout['level3'].append(np.array(cA3.reshape(length//8,1)))\n\t\tout['level4'].append(np.array(cA4.reshape(length//16,1)))\n\t\t\n\tout['out'] = np.array(out['out']) # converting to numpy array\n\tout['level1'] = np.array(out['level1'])\n\tout['level2'] = np.array(out['level2'])\n\tout['level3'] = np.array(out['level3'])\n\tout['level4'] = np.array(out['level4'])\n\t\n\t\n\treturn out","def encode(y):\n le = LabelEncoder()\n le.fit(y)\n print(list(le.classes_))\n y = le.transform(y)\n return y","def _label_encoding(self):\n for feat in self.cat_feats:\n if self.train:\n lbl = preprocessing.LabelEncoder()\n lbl.fit(self.dataframe[feat].values)\n self.dataframe_d_copy.loc[:,feat] = lbl.transform(self.dataframe[feat].values)\n self.label_encoders[feat] = lbl\n else:\n lbl = self.encoders[feat]\n self.dataframe_d_copy.loc[:,feat] = lbl.transform(self.dataframe[feat].values)\n \n if self.train:\n encoder_path = f\"{self.output_path}/_label_encoder.pkl\"\n self.cat_feats_cfg['encoder_path'] = encoder_path\n joblib.dump(self.label_encoders, encoder_path)\n \n return self.dataframe_d_copy","def prepare_labels(state_mapping, sequences):\n encoded_labels = [[state_mapping[state] for state in label] for label in sequences]\n \n depth = len(state_mapping)\n one_hot_labels = [[one_hot_encode(label, depth) for label in sequence] for sequence in encoded_labels]\n one_hot_labels = [np.asarray(ls) for ls in one_hot_labels]\n return one_hot_labels","def encode_labels(labels, nclass=5):\n Y = np.zeros((len(labels), nclass)).astype('float32')\n for j, y in enumerate(labels):\n for i in range(nclass):\n if i+1 == np.floor(y) + 1:\n Y[j,i] = y - np.floor(y)\n if i+1 == np.floor(y):\n Y[j,i] = np.floor(y) - y + 1\n return Y","def label_encode(data: List) -> [np.ndarray, List[LabelEncoder]]:\n labels_encoded = []\n data_encoded = np.array(data)\n for i in range(data_encoded.shape[1]):\n le = preprocessing.LabelEncoder()\n le.fit(data_encoded[:, i])\n labels_encoded.append(le)\n data_encoded[:, i] = le.transform(data_encoded[:, i])\n\n data_encoded = data_encoded.astype(int)\n return data_encoded, labels_encoded","def label_encode(var, values):\n\n le = preprocessing.LabelEncoder()\n le.fit(values)\n var_encoded = le.transform(var)\n\n return var_encoded","def encode_labels(y_train, y_test):\n le = LabelEncoder()\n le.fit(y_train)\n y_train = le.transform(y_train)\n y_test = le.transform(y_test)\n return y_train, y_test","def _extract_labels(self, samples: List):\n targets = [\n self.sp_model.encode(sample[2].lower().replace(\"<unk>\", \"<garbage>\").replace(\"\\n\", \"\"))\n for sample in samples\n ]\n targets = [\n [ele if ele != 4 else self.sp_model.unk_id() for ele in target] for target in targets\n ] # map id of <unk> token to unk_id\n lengths = torch.tensor([len(elem) for elem in targets]).to(dtype=torch.int32)\n targets = torch.nn.utils.rnn.pad_sequence(\n [torch.tensor(elem) for elem in targets],\n batch_first=True,\n padding_value=1.0,\n ).to(dtype=torch.int32)\n return targets, lengths","def label_extraction(self) -> None:\n self.df[\"label\"] = self.df[\"y\"]","def encode_sequential_labels(dataframe, variable_to_encode):\n # set name of encoded variable in dataframe \n encoded_variable_name = 'encoded_' + variable_to_encode\n # initialize encoder\n encoder = sklearn.preprocessing.LabelEncoder()\n # encode variable and add it to dataframe\n dataframe[encoded_variable_name] = encoder.fit_transform(dataframe[variable_to_encode].values)\n return encoder, dataframe","def one_hot_encoding(data):\r\n encoder = LabelEncoder()\r\n y = encoder.fit_transform(data)\r\n return(y)","def label(filenames, train_path='../data/train_molecules_30.mat'):\n unlabeled = [scipy.io.loadmat(fname) for fname in filenames]\n unlabeled_X = np.vstack([data['X'] for data in unlabeled])\n X, Y = load_data(train_path, shape=(-1, 30, 30, 30))\n\n num_unlabeled = unlabeled_X.shape[0]\n unlabeled_Y = np.zeros(num_unlabeled) - 1\n unlabeled_Y = unlabeled_Y.reshape((-1, 1))\n Y = Y.reshape((-1, 1))\n Y_all = np.vstack((Y, unlabeled_Y))\n\n X_all = np.vstack((X, unlabeled_X))\n X_all = X_all.reshape((-1, 27000))\n\n label_prop_model = LabelSpreading()\n label_prop_model.fit(X_all, Y_all)\n Y_all = label_prop_model.transduction_\n unlabeled_Y = Y_all[num_unlabeled:]\n return (unlabeled_X, unlabeled_Y), (X_all, Y_all)","def encode_ST_labels(labels):\n return np.array([1 if sentiment == 'bullish' else 0 for sentiment in labels])","def encode_labels(self):\n normalized_encoder = {}\n normalized_decoder = {}\n decoder = dict(self.tree.nodes(data=\"name\"))\n encoder = dict([(value, key) for key, value in decoder.items()])\n\n leaf_nodes = [node[0] for node in self.tree.out_degree(self.tree.nodes()) if node[1] == 0]\n leaf_nodes = [decoder[node] for node in leaf_nodes]\n\n counter = 0\n longest_path = 0\n for key in encoder:\n if key in leaf_nodes:\n path = self.determine_path_to_root([encoder[key]])\n if 'exploit_hierarchy' in self.parameter and self.parameter['exploit_hierarchy']:\n path = self.normalize_path_from_root_per_parent(path)\n\n normalized_encoder[key] = {'original_key': encoder[key], 'derived_key': counter,\n 'derived_path': path}\n normalized_decoder[counter] = {'original_key': encoder[key], 'value': key}\n if len(path) > longest_path:\n longest_path = len(path)\n\n counter += 1\n\n # Align path length\n fill_up_category = len(self.tree)\n\n for key in normalized_encoder:\n while len(normalized_encoder[key]['derived_path']) < longest_path:\n normalized_encoder[key]['derived_path'].append(fill_up_category)\n\n # Total number of labels is determined by the number of labels in the tree + 1 for out of category\n number_of_labels = len(self.tree) + 1\n\n return normalized_encoder, normalized_decoder, number_of_labels","def labeler(self, labels, tokens):\n encoded = []\n for idx, document in enumerate(tqdm(tokens)):\n tmp = [0 for char in range(len(document))]\n for name in labels[idx]:\n if re.match(r\"[^a-zA-Z]\", name):\n pattern = list(name)\n else:\n pattern = name\n # for indexes in re.finditer(name, document):\n # tmp[indexes.span()[0]:indexes.span()[1]] = [1 for _ in range(indexes.span()[1] - indexes.span()[0])]\n for i in range(len(document)):\n if document[i] == pattern[0] and document[i:i+len(pattern)] == pattern:\n tmp[i:i+len(pattern)] = [1 for _ in range(len(pattern))]\n encoded.append(tmp)\n\n # # Sanity check\n # for doc, enc in zip(tokens, encoded):\n # print(f\"{len(doc)}, {len(enc)}\")\n\n return encoded","def label_encode(self, directory):\n\n dataframe = 'df_' + str(self.line) + '/'\n\n line_encodings_path = os.path.join(directory, dataframe)\n\n month_source = line_encodings_path + 'MONTH_encode_map.json'\n stop_id_source = line_encodings_path + 'STOPPOINTID_encode_map.json'\n cluster_source = line_encodings_path + 'cluster_encode_map.json'\n\n features = [self.month, self.stop_id, self.cluster]\n dict_sources = [month_source, stop_id_source, cluster_source]\n\n for i in range(len(dict_sources)):\n json_obj = open(dict_sources[i])\n json_obj = json_obj.read()\n dictionary = json.loads(json_obj)\n key = features[i]\n features[i] = dictionary[str(key)]","def label(tree):\n return tree[0]","def create_encoding(df):\n vocab = []\n vocab_df = df[\"company\"] + df[\"address\"] + df[\"date\"] + df[\"total\"]\n [vocab.extend(row) for row in vocab_df]\n enc = LabelEncoder()\n enc.fit(vocab)\n return enc","def decode_strong(self, labels):\n result_labels = []\n for i, label_column in enumerate(labels.T):\n change_indices = DecisionEncoder().find_contiguous_regions(label_column)\n\n # append [label, onset, offset] in the result list\n for row in change_indices:\n result_labels.append(\n [\n self.labels[i],\n self._frame_to_time(row[0]),\n self._frame_to_time(row[1]),\n ]\n )\n return result_labels","def set_lm_labels(dataset, vocab, stm_lex, stm_win=3):\n n_records = len(dataset)\n for i in range(n_records):\n words = dataset[i]['words']\n # labels of language modeling and sentiment aware language modeling\n lm_labels_f, lm_labels_b = [], []\n n_w = len(words)\n # language modeling in forward direction\n for j in range(n_w):\n if j == n_w - 1:\n next_word = -1\n else:\n if words[j+1] in stm_lex:\n next_word = stm_lex[words[j+1]]\n else:\n next_word = -1\n next_word = -1* next_word + 1\n lm_labels_f.append(next_word)\n for j in range(n_w-1, -1, -1):\n if j == 0:\n next_word = -1\n else:\n if words[j-1] in stm_lex:\n next_word = stm_lex[words[j-1]]\n else:\n next_word = -1\n next_word = -1* next_word + 1\n lm_labels_b.append(next_word)\n dataset[i]['lm_labels_f'] = list(lm_labels_f)\n dataset[i]['lm_labels_b'] = list(lm_labels_b)[::-1]\n # sentiment aware language modeling\n stm_lm_labels = []\n opn_labels = []\n for j in range(n_w):\n if words[j] in stm_lex:\n opn_labels.append(1)\n else:\n opn_labels.append(0)\n # left boundary of sentimental context\n stm_ctx_lb = j - stm_win\n if stm_ctx_lb < 0:\n stm_ctx_lb = 0\n stm_ctx_rb = j + stm_win + 1\n left_ctx = words[stm_ctx_lb:j]\n right_ctx = words[j+1:stm_ctx_rb]\n stm_ctx = left_ctx + right_ctx\n flag = False\n for w in stm_ctx:\n if w in stm_lex:\n flag = True\n break\n if flag:\n stm_lm_labels.append(1)\n else:\n stm_lm_labels.append(0)\n dataset[i]['stm_lm_labels'] = list(stm_lm_labels)\n dataset[i]['opn_labels'] = list(opn_labels)\n return dataset","def get_train_labels(self, window, scene):\n pass","def one_hot_encoding((uri, label), all_labels):\n labels = [0]*NUM_LABELS\n for i, l in enumerate(all_labels):\n if label == l:\n labels[i] = 1\n yield uri, labels","def encode_data(column: str, data):\n return label.fit_transform(data[column])","def encode_labels(Y, le=None, enc=None):\n\n # initialize encoders\n N = Y.shape[0]\n\n # Encode the labels\n if le is None:\n le = LabelEncoder()\n Y_le = le.fit_transform(Y).reshape(N, 1)\n else:\n Y_le = le.transform(Y).reshape(N, 1)\n\n # convert into one hot encoding\n if enc is None:\n enc = OneHotEncoder()\n Y_enc = enc.fit_transform(Y_le).toarray()\n else:\n Y_enc = enc.transform(Y_le).toarray()\n\n return Y_enc, le, enc","def encode(text_tensor, label_tensor):\n # encode text\n encoded_text = encoder.encode(text_tensor.numpy())\n label = tf.where(label_tensor > 3, 1, 0)\n return encoded_text, label","def predLabel(self, DataMatrix):\n self.predict(DataMatrix)\n # Calculamos el valor mas alto, y a partir de este obtenemos el nombre de la etiqueta\n tags = [[self.classes[np.argmax(subrow)] for subrow in row] for row in self.data]\n return tags","def prepare_dense_label(input_batch, new_size, one_hot=True):\n with tf.name_scope('label_encode'):\n print(input_batch)\n # input_batch = tf.image.resize_nearest_neighbor(input_batch, new_size) # as labels are integer numbers, need to use NN interpolation\n # input_batch = tf.squeeze(input_batch, squeeze_dims=[3]) # reducing the channel dimension.\n # if one_hot:\n # input_batch = tf.one_hot(input_batch, depth=n_classes, axis=2)\n return input_batch","def y_to_label(self, data, Y):\n pass","def predLabel(self, DataMatrix):\n self.predict(DataMatrix)\n # Calculamos el valor mas alto, y a partir de este obtenemos el nombre de la etiqueta\n tags = [self.classes[np.argmax(elem)] for elem in self.data]\n return tags","def encode_labels(self, lilabs):\n\n y = []\n for lab in lilabs:\n y.append([1 if l in lab else 0 for l in self.labels])\n\n return np.array(y, dtype=float)","def get_label(self, label):\n\n return torch.from_numpy(np.array(label)).long()","def __label__(self, sdfg, state):\n if self.data is None:\n return self._label(None)\n return self._label(sdfg.arrays[self.data].shape)","def get_encoded_label_from_example(example):\n return example.features.feature['label/encoded'].bytes_list.value[0]","def add_label_encoding(df, categoricals_to_encode, line_name):\n label_encode_dir = '/Users/davidodwyer/Documents/studyCS/Semester_3/models_label_encodings'\n line_name = line_name\n\n # iterate through features list\n # label-encode their values\n\n try:\n \n for feature in categoricals_to_encode:\n le = LabelEncoder()\n name = feature + '_label'\n df[name] = le.fit_transform(df[feature])\n \n # create a mapping of original to labelled\n # values\n\n encoding = df[name].tolist()\n original = le.inverse_transform(df[name]).tolist()\n \n dictionary = dict(zip(original, encoding))\n\n\n # save the mapping to disk, as json\n\n line_encode_dir = label_encode_dir + '/' + line_name\n \n # line_encode_dir = os.path.join(label_encode_dir, line_name)\n\n if not os.path.isdir(line_encode_dir):\n os.mkdir(line_encode_dir)\n\n\n dict_name = feature + '_encode_map.json'\n save_target = os.path.join(line_encode_dir, dict_name)\n \n with open(save_target, 'w') as json_file:\n json.dump(dictionary, json_file)\n \n\n\n # drop the original, unencoded features \n \n for feature in categoricals_to_encode:\n df.drop(feature, axis=1, inplace=True)\n\n print('— features label encoded')\n \n return df\n\n except:\n\n print(\"Problem with label encoding function\")","def get_labels(self):\n return [\"A轮\", \"B轮\",\"C轮\",\"天使轮\",\"战略融资\"]","def labels_to_labels(class_labels, num_classes =4):\n levels = []\n for label in class_labels:\n levels_from_label = label_to_levels(int(label), num_classes=num_classes)\n levels.append(levels_from_label)\n return torch.stack(levels).cuda()","def encode_weak(self, labels):\n # useful for tensor empty labels\n if type(labels) is str:\n if labels == \"empty\":\n y = np.zeros(len(self.labels)) - 1\n return y\n else:\n labels = labels.split(\",\")\n if type(labels) is pd.DataFrame:\n if labels.empty:\n labels = []\n elif \"event_label\" in labels.columns:\n labels = labels[\"event_label\"]\n y = np.zeros(len(self.labels))\n for label in labels:\n if not pd.isna(label):\n i = self.labels.index(label)\n y[i] = 1\n return y","def _labels_of_sentence(self, sentence, split):\n #print(self.label_vocab)\n self.category_int_of_label_string('O')\n bioes_tags = self._string_labels_of_sentence(sentence)\n labels = torch.zeros(len(sentence))\n for index, label in enumerate(bioes_tags):\n labels[index] = self.category_int_of_label_string(label)\n return labels","def convert(df: pd.DataFrame, outpath):\n labels = df['source'].apply(lambda x: LABEL_XINHUA if x == '新华社' else LABEL_NON_XINHUA)\n labels.to_pickle(outpath)","def _labels_of_sentence(self, sentence, split):\n labels = torch.ones(1)\n labels[0] = self.category_int_of_label_string(sentence[0][self.name_to_index_dict['label']]) #\n return labels","def get_label_matrix(matrix):\n linked_matrix = get_linked_matrix(matrix)\n labelled_matrix = get_labelled_matrix(linked_matrix)\n\n return [[c[2] for c in r] for r in labelled_matrix]","def read_label(self):\r\n # label = str(self.parse_binary())#!!BAD\r\n label = ''\r\n while True:\r\n c = self.eat_char()\r\n if c=='n':\r\n #terminal char\r\n break\r\n else:\r\n label += c\r\n\r\n self.log += \"'\" + label + \"'\"\r\n return label","def encode_label(label: str) -> int:\n\tif not label:\n\t\treturn 0\n\t# part after letter if it has a number, otherwise 1\n\tindex = int(label[1:]) if len(label) > 1 else 1\n\t# A = 1, B = 2, ... E = 5\n\toffset = ord(label[0]) - ord(\"A\") + 1\n\t# compute label number\n\treturn (index - 1) * 5 + offset","def createLabels(edge):\n k = removeLabel(edge)\n return k + \"_L\", k + \"_R\"","def encode_labels(self, y_str, needs_fit=True):\n y_str = np.asarray(y_str[:]).reshape(-1, 1)\n if needs_fit is True:\n y_vec = self.labelEncoder.fit_transform(y_str)\n else:\n y_vec = self.labelEncoder.transform(y_str)\n return [y_vec, self.labelEncoder]","def _model2short_label(self, m):\n return str(self._get_model_sequence()[m])","def predict_label(self, x):\n best_path_ids, label_col = [], []\n for i in range(len(x)):\n # forward_var denote end this step each node will get max score\n forward_var = np.log(self.init_probability)\n\n for j in range(len(x[i])):\n if j == 0:\n forward_var += np.log(self.emission[x[i][j]].reshape(-1, 1))\n\n else:\n current_score, current_ids = np.zeros((self.n_classes, 1)), np.zeros(self.n_classes, dtype=int)\n for next_tag in range(self.n_classes):\n next_score = forward_var + np.log(self.transition[next_tag].reshape(-1, 1))\n max_score_id = np.argmax(next_score.reshape(-1))\n\n current_score[next_tag] = np.max(next_score)\n current_ids[next_tag] = max_score_id\n\n # update forward_var with each step\n forward_var = current_score + np.log(self.emission[x[i][j]].reshape(-1, 1))\n best_path_ids.append(current_ids.tolist())\n\n start_node = np.argmax(forward_var)\n label_col.append(self.find_path(start_node, best_path_ids))\n best_path_ids = []\n\n return label_col","def _preprocess(self, txt_seq):\n input = []\n label = []\n punc = \" \"\n for token in txt_seq.split():\n if token in self.punc2id:\n punc = token\n else:\n input.append(self.word2id.get(token, self.word2id[\"<UNK>\"]))\n label.append(self.punc2id[punc])\n punc = \" \"\n input.append(self.word2id[\"<END>\"])\n label.append(self.punc2id[punc])\n input = torch.LongTensor(input)\n label = torch.LongTensor(label)\n # input = np.array(input)\n # label = np.array(label)\n return input, label","def cvpr2018_labels():\n\n return {\n 0: 'others',\n 33: 'car',\n 34: 'motorcycle',\n 35: 'bicycle',\n 36: 'pedestrian',\n 38: 'truck',\n 39: 'bus',\n 40: 'tricycle'\n }","def reduceLabel(T):\n if not T.isLeaf():\n T.label = T.label[:1]\n for t,w in T.children:\n reduceLabel(t)","def _convert_to_onehot_labels(seg_label, num_classes):\n\n batch_size = seg_label.size(0)\n onehot_labels = seg_label.new_zeros((batch_size, num_classes))\n for i in range(batch_size):\n hist = seg_label[i].float().histc(\n bins=num_classes, min=0, max=num_classes - 1)\n onehot_labels[i] = hist > 0\n return onehot_labels","def one_hot_encode(x):\n # TODO: Implement Function\n lb = preprocessing.LabelBinarizer()\n lb.fit([0,1,2,3,4,5,6,7,8,9])\n \n return lb.transform(x)","def encodeLabels(XTrain, XTest):\n trainSize = XTrain.shape[0]\n X = XTrain.append(XTest)\n\n Xobj = X.select_dtypes(include=['object']).astype(str).copy()\n Xval = X.select_dtypes(exclude=['object']).copy()\n\n le = LabelEncoder()\n for column in Xobj:\n le.fit(Xobj[column])\n Xobj[column] = le.transform(Xobj[column])\n X = pd.concat([Xval, Xobj], axis=1)\n XTrain = X.loc[0:trainSize]\n XTest = X.loc[trainSize+1:]\n\n return XTrain, XTest","def one_hot_encoding(sequence):\n\n mydict = {\n \"A\": np.asarray([1, 0, 0, 0]),\n \"a\": np.asarray([1, 0, 0, 0]),\n \"C\": np.asarray([0, 1, 0, 0]),\n \"c\": np.asarray([0, 1, 0, 0]),\n \"G\": np.asarray([0, 0, 1, 0]),\n \"g\": np.asarray([0, 0, 1, 0]),\n \"T\": np.asarray([0, 0, 0, 1]),\n \"t\": np.asarray([0, 0, 0, 1]),\n \"Y\": np.asarray([0, 1, 0, 1]),\n \"y\": np.asarray([0, 1, 0, 1]),\n \"R\": np.asarray([1, 0, 1, 0]),\n \"r\": np.asarray([1, 0, 1, 0]),\n \"S\": np.asarray([0, 1, 1, 0]),\n \"s\": np.asarray([0, 1, 1, 0]),\n \"W\": np.asarray([1, 0, 0, 1]),\n \"w\": np.asarray([1, 0, 0, 1]),\n \"K\": np.asarray([0, 0, 1, 1]),\n \"k\": np.asarray([0, 0, 1, 1]),\n \"M\": np.asarray([1, 1, 0, 0]),\n \"m\": np.asarray([1, 1, 0, 0]),\n \"B\": np.asarray([0, 1, 1, 1]),\n \"b\": np.asarray([0, 1, 1, 1]),\n \"D\": np.asarray([1, 0, 1, 1]),\n \"d\": np.asarray([1, 0, 1, 1]),\n \"H\": np.asarray([1, 1, 0, 1]),\n \"h\": np.asarray([1, 1, 0, 1]),\n \"V\": np.asarray([1, 1, 1, 0]),\n \"v\": np.asarray([1, 1, 1, 0]),\n \"N\": np.asarray([0, 0, 0, 0]),\n \"n\": np.asarray([0, 0, 0, 0]),\n \"-\": np.asarray([0, 0, 0, 0]),\n }\n print(f\"Seq: {sequence}\")\n if len(sequence) > 0:\n nuc_list = list()\n for nuc in list(sequence):\n nuc_list.append(mydict[nuc])\n result = np.stack(np.asarray(nuc_list, dtype=\"int8\"))\n return result\n else: \n print(\"ERROR! sequence is too short\")","def create_TargetLabel(dataset):\n label_Array = dataset['close_-1_r'].shift(-1)\n label_Array = label_Array.apply(lambda x:1 if x>0.0000 else 0)\n return label_Array","def read_stanford_labels():\n # First get the hardi data\n fetch_stanford_hardi()\n hard_img, gtab = read_stanford_hardi()\n\n # Fetch and load\n files, folder = fetch_stanford_labels()\n labels_file = pjoin(folder, \"aparc-reduced.nii.gz\")\n labels_img = nib.load(labels_file)\n return hard_img, gtab, labels_img","def labelingLVQ(self):\n numLabels = len(np.unique(self.y))\n for i, x in enumerate(self.x):\n w = self.find_closest(x)[0]\n for nl in range(numLabels):\n if self.y[i] == nl:\n self.labels[nl, w[0], w[1]] += 1\n return self.labels","def _get_labels(self, ind):\n pass","def get_train_labels(self, window: Box, scene: Scene) -> Labels:\n raise NotImplementedError()","def lyft_labels():\n\n return {\n 0: 'None',\n 7: 'Roads',\n 10: 'Vehicles'\n }","def _setup_labels(self):\n self._labels = self.get_labels()\n self._labels = self.get_predefined_labels() + list(self._labels)\n self._labels = sorted(self._labels)\n\n self._labels_2_index = {label.lower(): i for i, label in enumerate([self._unknown_label] + self._labels)}\n self._index_2_labels = {i: label for label, i in self._labels_2_index.items()}\n\n self._labels_dim = len(self._labels_2_index)\n return None","def get_train_labels(self):\n raise NotImplementedError","def assign_labels_first_left(document, label_encoder):\n for sentence in document.sentences:\n for word in sentence.words:\n sorted_probs = sorted(word.tokens[0].predictions)\n label_idx = np.argmax(sorted_probs[0][1], axis=-1)\n word.predicted_label = label_encoder.inv_label_map[label_idx]","def _labels_of_sentence(self, sentence, esplit):\n\n labels = torch.zeros(len(sentence))\n for token_index, token_attribute_list in enumerate(sentence):\n label_string = token_attribute_list[self.task_label_index]\n labels[token_index] = self.category_int_of_label_string(label_string)\n return labels","def decodeLabels(predictions, vocab):\n\n decoded_labels =[]\n for sequence in predictions:\n temp = []\n for label in list(sequence):\n if label in vocab:\n temp.append(vocab[label])\n else:\n temp.append(label)\n decoded_labels.append(temp)\n \n return decoded_labels","def _fit_teams_names_lencoder(self) -> LabelEncoder:\n df = self._dbmanager.query_teams_names()\n values = [\"\"] + df[\"name\"].values.tolist()\n return LabelEncoder().fit(values)","def _string_labels_of_sentence(self, sentence):\n label_strings = []\n ongoing_label = 'O'\n for token_index, token_attribute_list in enumerate(sentence):\n raw_label_string = token_attribute_list[self.task_label_index].strip('*')\n if '(' in raw_label_string:\n ongoing_label = raw_label_string.strip('(').strip(')')\n beginning = True\n #labels[token_index] = self.category_int_of_label_string(ongoing_label)\n if ongoing_label == 'O':\n label_strings.append(ongoing_label)\n else:\n label_strings.append('{}-{}'.format('B' if beginning else 'I', ongoing_label))\n beginning = False\n if ')' in raw_label_string:\n ongoing_label = 'O'\n #bioes_tags = bio2_to_bioes(label_strings)\n bioes_tags = label_strings\n return bioes_tags","def test_basic_labeling(self):\n # data with only 1 feature\n data = array([[-1], [1], [0.5], [0.25], [-0.33], [0]])\n # give 1 if feature value >= 0; otherwise 0\n labels = array([0, 1, 1, 1, 0, 1])\n cdata = LabeledCData(data, labels)\n\n # ensure that labelling is correct\n assert array_equal(cdata.labels, labels)","def prepare_label(input_batch, new_size, num_classes, one_hot=True, task='seg'):\n with tf.name_scope('label_encode'):\n input_batch = tf.image.resize_nearest_neighbor(input_batch, new_size) # as labels are integer numbers, need to use NN interp.\n if task == 'seg':\n input_batch = tf.squeeze(input_batch, squeeze_dims=[3]) # reducing the channel dimension.\n if one_hot:\n input_batch = tf.one_hot(input_batch, depth=num_classes)\n return input_batch","def label_to_name(label):\n return \"Tree\"","def label_encode(self, col_need):\r\n assert isinstance(col_need, list) and len(col_need) == 1\r\n self.label_code = LabelEncoder()\r\n array_label_code = self.label_code.fit_transform(self.df.loc[:, col_need])\r\n\r\n label_list = list(self.label_code.classes_)\r\n for i, x in enumerate(label_list):\r\n self.col_label_dict[col_need[0] + \"_\" + str(i)] = col_need[0] + \"_\" + x\r\n\r\n self.df.drop(col_need, axis=1, inplace=True)\r\n\r\n df_label_code = pd.DataFrame(array_label_code, columns=col_need, index=self.df.index)\r\n self.df = pd.concat([self.df, df_label_code], axis=1)","def load_label(self, idx):\n im = open('{}/GTTXT/{}.txt'.format(root_dir, idx))\n\t#print(type(im.readlines()[0].rstrip(\"\\n\")))\n rgb_label = [i.rstrip(\"\\n\").split(\" \") for i in im.readlines()]\n\tlabel=[]\t\n\tfor i in rgb_label:\n\t\tlabel+=[int(j) for j in i]\n\tlabel=np.array(label).reshape(720,960)\n\tlabel[label==-1]=12\n\t#print(np.unique(label))\n #label = label[np.newaxis, ...]\n return label","def load_labels(labels_dir, trial_name):\n labels_path = labels_dir + trial_name + \".txt\"\n raw_labels_data = np.genfromtxt(labels_path, dtype=np.int,\n converters=LABELS_CONVERTERS,\n usecols=LABELS_USECOLS)\n #print(\"rawlabelsdata: \", raw_labels_data)\n #print(get_first_frame(labels_path))\n frames = np.arange(get_first_frame(labels_path), get_last_frame(labels_path)+1, dtype=np.int)\n #print(\"frames: \", frames)\n #print(frames.shape)\n #labels = np.zeros(frames.shape, dtype=np.int)\n labels1 = []\n #print(labels)\n for start, end, label in raw_labels_data:\n #mask = (frames >= start) & (frames <= end)\n #print(start)\n #print(end)\n i = start\n while(i<end):\n if(i%6 == 0):\n labels1.append(label)\n i = i+1\n\n #labels[mask] = label\n #print(\"labels[mask]: \",labels[mask])\n labels1 = np.array(labels1)\n #print(labels1)\n labels_data = labels1.reshape(-1,1)\n #print(labels1.shape)\n #print(\"labels: \", labels_data)\n \n return labels_data","def one_hot_to_label(one_hot=None):\n if np.where(one_hot == 1)[0][0] == 0:\n return 'Store'\n elif np.where(one_hot == 1)[0][0] == 1:\n return 'Home'\n elif np.where(one_hot == 1)[0][0] == 2:\n return 'Public spaces'\n elif np.where(one_hot == 1)[0][0] == 3:\n return 'Leisure'\n elif np.where(one_hot == 1)[0][0] == 4:\n return 'Working place'\n else:\n raise Exception('The one-hot representation \"' + str(one_hot) + '\" cant be transform to a label')","def label_names(self) -> Strings:\n\n try:\n if self._le:\n return self._le.classes_.tolist()\n except AttributeError:\n self.logger.warning('AttributeError: LabelEncoder was not found.')\n self.logger.warning('No LabelEncoder. Please call label_encoder first.')\n return None","def predict_label(img, net_model, label):\n img1 = cv2.resize(img, (80, 80))\n predict = net_model.predict(img1.reshape(1, 80, 80, 3))\n maxi = predict[0][0]\n curs = 0\n test = 0\n for i, pred in enumerate(predict[0]):\n test += pred\n if pred > maxi:\n maxi = pred\n curs = i\n return label[curs]","def forward(self, input):\n label=np.dot(input,self.w)+self.b\n return label","def fix_label(self, label):\n if label is None:\n return None\n assert len(label) == len(self.data)\n fixed_labels = []\n for y, x in zip(label, self.data):\n assert len(y) == len(x)\n encode = self.transform_function(' '.join(x))\n fixed_label = list(chain(*[\n [label] + [PAD_TOKEN_LABEL_ID] * (len(self.transform_function.tokenize(word)) - 1)\n for label, word in zip(y, x)]))\n if encode['input_ids'][0] in self.transform_function.all_special_ids:\n fixed_label = [PAD_TOKEN_LABEL_ID] + fixed_label\n fixed_label += [PAD_TOKEN_LABEL_ID] * (len(encode['input_ids']) - len(fixed_label))\n fixed_label = fixed_label[:self.transform_function.max_seq_length]\n fixed_labels.append(fixed_label)\n return fixed_labels","def label_encode(df):\n\n X = df.copy()\n for colname in X.select_dtypes([\"category\"]):\n X[colname] = X[colname].cat.codes\n return X","def pp_labels(y_train, y_dev, y_test):\n\n lb = LabelBinarizer()\n ym_train = lb.fit_transform(y_train).T\n ym_dev = lb.fit_transform(y_dev).T\n ym_test = lb.fit_transform(y_test).T\n\n return ym_train, ym_dev, ym_test","def label(d, X, ind_class0, ind_class1, N, V, binary):\n if binary == True:\n K = 1\n C = torch.zeros(N + V, K)\n C[ind_class0, :] = 0.0\n C[ind_class1, :] = 1.0\n else:\n K = 2\n C = torch.zeros(N + V, K)\n C[ind_class0, :] = torch.tensor([1.0, 0.0])\n C[ind_class1, :] = torch.tensor([0.0, 1.0])\n\n X_train = X[:N, :]\n X_val = X[N:, :]\n C_train = C[:N, :]\n C_val = C[N:, :]\n\n return [X_train, C_train, X_val, C_val, d, K]","def generate_labels():\n label_set = set([])\n for data in load_data():\n label = data.split(' ', 1)[0]\n label_set.add(label)\n labels = list(label_set)\n labels.sort()\n return labels","def test_decode_labels_from_strings(self):\n classes = np.array([\"a\", \"b\", \"c\", \"d\", \"e\"])\n decoded = classes[np.random.randint(0, 5, 100)]\n y = np.array([v.upper() for v in decoded])\n\n oz = ClassificationScoreVisualizer(GaussianNB, classes=classes)\n npt.assert_array_equal(oz._decode_labels(y), decoded)\n\n encoder = {c.upper(): c for c in classes}\n oz = ClassificationScoreVisualizer(GaussianNB, encoder=encoder)\n npt.assert_array_equal(oz._decode_labels(y), decoded)\n\n class L2UTransformer(object):\n def transform(self, y):\n return np.array([yi.upper() for yi in y])\n\n def inverse_transform(self, y):\n return np.array([yi.lower() for yi in y])\n\n oz = ClassificationScoreVisualizer(GaussianNB, encoder=L2UTransformer())\n npt.assert_array_equal(oz._decode_labels(y), decoded)","def preprocess_labels(y):\n\n y = tf.keras.utils.to_categorical(y, nclasses)\n\n return y","def _annotations_to_targets(self, labels):\n roots = ['A','B','C','D','E','F','G']\n natural = zip(roots, [0, 2, 3, 5, 7, 8, 10])\n root_note_map = {}\n for chord, num in natural:\n root_note_map[chord] = num\n root_note_map[chord + '#'] = (num + 1) % 12\n root_note_map[chord + 'b'] = (num - 1) % 12\n\n root_note_map['N'] = 24\n root_note_map['X'] = 24\n \n labels = [c.decode('UTF-8') for c in labels]\n chord_root_notes = [c.split(':')[0].split('/')[0] for c in labels]\n chord_root_note_ids = np.array([root_note_map[crn] for crn in chord_root_notes])\n \n chord_type = [c.split(':')[1] if ':' in c else '' for c in labels]\n chord_type_shift = np.array([12 if 'min' in chord_t or 'dim' in chord_t else 0 for chord_t in chord_type])\n return one_hot(chord_root_note_ids + chord_type_shift, self.num_classes)","def _labels(path):\r\n with gzip.open(path) as f:\r\n # First 8 bytes are magic_number, n_labels\r\n integer_labels = np.frombuffer(f.read(), 'B', offset=8)\r\n\r\n def _onehot(integer_labels):\r\n \"\"\"Return matrix whose rows are onehot encodings of integers.\"\"\"\r\n n_rows = len(integer_labels)\r\n n_cols = integer_labels.max() + 1\r\n onehot = np.zeros((n_rows, n_cols), dtype='uint8')\r\n onehot[np.arange(n_rows), integer_labels] = 1\r\n return onehot\r\n\r\n return _onehot(integer_labels)","def fluxes_to_labels(fluxes: np.ndarray) -> np.ndarray:\n return ((1 - fluxes) // 2).astype(np.int8)","def onehot_encode_labels(y):\n\treturn OneHotEncoder(categories=\"auto\", sparse=False).fit_transform(y.reshape(y.shape[0],1))","def data_labels(data):\n\n # The data consists of a equal number of benign and deleterious samples\n # The first part of the data are the benign samples (label 0), and the second part the deleterious ones (label 1)\n n_samples = data.shape[0]\n n_class_samples = int(n_samples / 2)\n\n # Get a numpy array of the labels\n labels_ben = [0] * n_class_samples\n labels_del = [1] * n_class_samples\n labels = np.array(labels_ben + labels_del)\n\n # Convert the data into one hot encoded data\n labels = initialization_based(labels)\n\n return labels","def one_hot_encoder(self, DNA_string):\n\n if self.selex_predict_str_adaptor != 0:\n DNA_string = \"A\" * self.selex_predict_str_adaptor + DNA_string + 'A' * self.selex_predict_str_adaptor\n\n trantab = DNA_string.maketrans('ACGT', '0123')\n str_arr = [\"\" for x in range(self.num_of_str)]\n for i in range(0, self.num_of_str): ##each substring goes to different element array\n str_arr[i] = DNA_string[i: i + self.selex_str_len]\n\n # if the \"ACGT\"\n # won't be added it will be impossible to convert sequnces which miss one of the letters\n str_arr[self.num_of_str - 1] = str_arr[self.num_of_str - 1] + \"ACGT\"\n\n final_str = list(\"\")\n for i in range(0, self.num_of_str):\n final_str += list(str_arr[i].translate(trantab))\n\n return to_categorical(final_str)[0:-4] # returns the matrix without the \"ACGT\"","def generate_labels(n_samples):\n return np.ones([n_samples, 1]), np.zeros([n_samples, 1])","def addLabels(t):\n if not t.label:\n t.label = \"\".join([choice(\"abcdefghijklmnopqrstuvwxyz\") for i in range(4)])\n for r,w in t.children:\n addLabels(r)"],"string":"[\n \"def getLabelEncoder():\\n classes = list(string.letters + string.digits)\\n classes.append('')\\n le = LabelEncoder()\\n le.fit(classes)\\n\\n return le\",\n \"def build_label_transform():\\n\\n return NALabelEncoder()\",\n \"def lblencoder(self):\\n for i in self.data.columns:\\n if self.data[i].dtype=='object':\\n lbl = preprocessing.LabelEncoder()\\n lbl.fit(list(self.data[i].values))\\n self.data[i] = lbl.transform(list(self.data[i].values))\\n \\n self.X = self.data.drop(self.target, axis =1)\\n self.y = self.data[self.target]\",\n \"def train_le(self):\\n\\n lisa = [self.get_prev_word(i, orignal=True) for i in range(len(self.df))]\\n lisb = [self.get_next_word(i, orignal=True) for i in range(len(self.df))]\\n lis = lisa + lisb\\n lis.append(\\\"<NAP>\\\")\\n lis.append(\\\"<START>\\\")\\n return self.label_encoder.fit(lis)\",\n \"def build_label_transform():\\n\\n return RobustLabelEncoder(\\n labels=['0'], fill_label_value='1', include_unseen_class=True\\n )\",\n \"def predict_label(self, src): # real signature unknown; restored from __doc__\\n pass\",\n \"def encode_label(label: np.array, nb_classes: int):\\n encoded = np.zeros(nb_classes)\\n encoded[int(label)] = 1.\\n return encoded\",\n \"def prepareLabel(Y):\\n\\t\\n\\tdef approximate(inp,w_len):\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tDownsamples using taking mean over window\\n\\t\\t\\n\\t\\tArguments:\\n\\t\\t\\tinp {array} -- signal\\n\\t\\t\\tw_len {int} -- length of window\\n\\t\\t\\n\\t\\tReturns:\\n\\t\\t\\tarray -- downsampled signal\\n\\t\\t\\\"\\\"\\\"\\n\\t\\t\\n\\t\\top = []\\n\\t\\t\\n\\t\\tfor i in range(0,len(inp),w_len):\\n\\t\\t\\n\\t\\t\\top.append(np.mean(inp[i:i+w_len]))\\n\\t\\t\\t\\n\\t\\treturn np.array(op)\\n\\t\\n\\tout = {}\\n\\tout['out'] = []\\n\\tout['level1'] = []\\n\\tout['level2'] = []\\n\\tout['level3'] = []\\n\\tout['level4'] = []\\n\\t\\n\\t\\n\\tfor y in tqdm(Y,desc='Preparing Label for DS'):\\n\\t\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# computing approximations\\n\\t\\tcA1 = approximate(np.array(y).reshape(length), 2)\\n\\t\\t\\n\\t\\tcA2 = approximate(np.array(y).reshape(length), 4)\\n\\t\\t\\n\\t\\tcA3 = approximate(np.array(y).reshape(length), 8)\\n\\t\\t\\n\\t\\tcA4 = approximate(np.array(y).reshape(length), 16)\\n\\t\\t\\n\\t\\t\\n\\t\\t\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# populating the labels for different labels\\n\\t\\tout['out'].append(np.array(y.reshape(length,1)))\\n\\t\\tout['level1'].append(np.array(cA1.reshape(length//2,1)))\\n\\t\\tout['level2'].append(np.array(cA2.reshape(length//4,1)))\\n\\t\\tout['level3'].append(np.array(cA3.reshape(length//8,1)))\\n\\t\\tout['level4'].append(np.array(cA4.reshape(length//16,1)))\\n\\t\\t\\n\\tout['out'] = np.array(out['out']) # converting to numpy array\\n\\tout['level1'] = np.array(out['level1'])\\n\\tout['level2'] = np.array(out['level2'])\\n\\tout['level3'] = np.array(out['level3'])\\n\\tout['level4'] = np.array(out['level4'])\\n\\t\\n\\t\\n\\treturn out\",\n \"def encode(y):\\n le = LabelEncoder()\\n le.fit(y)\\n print(list(le.classes_))\\n y = le.transform(y)\\n return y\",\n \"def _label_encoding(self):\\n for feat in self.cat_feats:\\n if self.train:\\n lbl = preprocessing.LabelEncoder()\\n lbl.fit(self.dataframe[feat].values)\\n self.dataframe_d_copy.loc[:,feat] = lbl.transform(self.dataframe[feat].values)\\n self.label_encoders[feat] = lbl\\n else:\\n lbl = self.encoders[feat]\\n self.dataframe_d_copy.loc[:,feat] = lbl.transform(self.dataframe[feat].values)\\n \\n if self.train:\\n encoder_path = f\\\"{self.output_path}/_label_encoder.pkl\\\"\\n self.cat_feats_cfg['encoder_path'] = encoder_path\\n joblib.dump(self.label_encoders, encoder_path)\\n \\n return self.dataframe_d_copy\",\n \"def prepare_labels(state_mapping, sequences):\\n encoded_labels = [[state_mapping[state] for state in label] for label in sequences]\\n \\n depth = len(state_mapping)\\n one_hot_labels = [[one_hot_encode(label, depth) for label in sequence] for sequence in encoded_labels]\\n one_hot_labels = [np.asarray(ls) for ls in one_hot_labels]\\n return one_hot_labels\",\n \"def encode_labels(labels, nclass=5):\\n Y = np.zeros((len(labels), nclass)).astype('float32')\\n for j, y in enumerate(labels):\\n for i in range(nclass):\\n if i+1 == np.floor(y) + 1:\\n Y[j,i] = y - np.floor(y)\\n if i+1 == np.floor(y):\\n Y[j,i] = np.floor(y) - y + 1\\n return Y\",\n \"def label_encode(data: List) -> [np.ndarray, List[LabelEncoder]]:\\n labels_encoded = []\\n data_encoded = np.array(data)\\n for i in range(data_encoded.shape[1]):\\n le = preprocessing.LabelEncoder()\\n le.fit(data_encoded[:, i])\\n labels_encoded.append(le)\\n data_encoded[:, i] = le.transform(data_encoded[:, i])\\n\\n data_encoded = data_encoded.astype(int)\\n return data_encoded, labels_encoded\",\n \"def label_encode(var, values):\\n\\n le = preprocessing.LabelEncoder()\\n le.fit(values)\\n var_encoded = le.transform(var)\\n\\n return var_encoded\",\n \"def encode_labels(y_train, y_test):\\n le = LabelEncoder()\\n le.fit(y_train)\\n y_train = le.transform(y_train)\\n y_test = le.transform(y_test)\\n return y_train, y_test\",\n \"def _extract_labels(self, samples: List):\\n targets = [\\n self.sp_model.encode(sample[2].lower().replace(\\\"<unk>\\\", \\\"<garbage>\\\").replace(\\\"\\\\n\\\", \\\"\\\"))\\n for sample in samples\\n ]\\n targets = [\\n [ele if ele != 4 else self.sp_model.unk_id() for ele in target] for target in targets\\n ] # map id of <unk> token to unk_id\\n lengths = torch.tensor([len(elem) for elem in targets]).to(dtype=torch.int32)\\n targets = torch.nn.utils.rnn.pad_sequence(\\n [torch.tensor(elem) for elem in targets],\\n batch_first=True,\\n padding_value=1.0,\\n ).to(dtype=torch.int32)\\n return targets, lengths\",\n \"def label_extraction(self) -> None:\\n self.df[\\\"label\\\"] = self.df[\\\"y\\\"]\",\n \"def encode_sequential_labels(dataframe, variable_to_encode):\\n # set name of encoded variable in dataframe \\n encoded_variable_name = 'encoded_' + variable_to_encode\\n # initialize encoder\\n encoder = sklearn.preprocessing.LabelEncoder()\\n # encode variable and add it to dataframe\\n dataframe[encoded_variable_name] = encoder.fit_transform(dataframe[variable_to_encode].values)\\n return encoder, dataframe\",\n \"def one_hot_encoding(data):\\r\\n encoder = LabelEncoder()\\r\\n y = encoder.fit_transform(data)\\r\\n return(y)\",\n \"def label(filenames, train_path='../data/train_molecules_30.mat'):\\n unlabeled = [scipy.io.loadmat(fname) for fname in filenames]\\n unlabeled_X = np.vstack([data['X'] for data in unlabeled])\\n X, Y = load_data(train_path, shape=(-1, 30, 30, 30))\\n\\n num_unlabeled = unlabeled_X.shape[0]\\n unlabeled_Y = np.zeros(num_unlabeled) - 1\\n unlabeled_Y = unlabeled_Y.reshape((-1, 1))\\n Y = Y.reshape((-1, 1))\\n Y_all = np.vstack((Y, unlabeled_Y))\\n\\n X_all = np.vstack((X, unlabeled_X))\\n X_all = X_all.reshape((-1, 27000))\\n\\n label_prop_model = LabelSpreading()\\n label_prop_model.fit(X_all, Y_all)\\n Y_all = label_prop_model.transduction_\\n unlabeled_Y = Y_all[num_unlabeled:]\\n return (unlabeled_X, unlabeled_Y), (X_all, Y_all)\",\n \"def encode_ST_labels(labels):\\n return np.array([1 if sentiment == 'bullish' else 0 for sentiment in labels])\",\n \"def encode_labels(self):\\n normalized_encoder = {}\\n normalized_decoder = {}\\n decoder = dict(self.tree.nodes(data=\\\"name\\\"))\\n encoder = dict([(value, key) for key, value in decoder.items()])\\n\\n leaf_nodes = [node[0] for node in self.tree.out_degree(self.tree.nodes()) if node[1] == 0]\\n leaf_nodes = [decoder[node] for node in leaf_nodes]\\n\\n counter = 0\\n longest_path = 0\\n for key in encoder:\\n if key in leaf_nodes:\\n path = self.determine_path_to_root([encoder[key]])\\n if 'exploit_hierarchy' in self.parameter and self.parameter['exploit_hierarchy']:\\n path = self.normalize_path_from_root_per_parent(path)\\n\\n normalized_encoder[key] = {'original_key': encoder[key], 'derived_key': counter,\\n 'derived_path': path}\\n normalized_decoder[counter] = {'original_key': encoder[key], 'value': key}\\n if len(path) > longest_path:\\n longest_path = len(path)\\n\\n counter += 1\\n\\n # Align path length\\n fill_up_category = len(self.tree)\\n\\n for key in normalized_encoder:\\n while len(normalized_encoder[key]['derived_path']) < longest_path:\\n normalized_encoder[key]['derived_path'].append(fill_up_category)\\n\\n # Total number of labels is determined by the number of labels in the tree + 1 for out of category\\n number_of_labels = len(self.tree) + 1\\n\\n return normalized_encoder, normalized_decoder, number_of_labels\",\n \"def labeler(self, labels, tokens):\\n encoded = []\\n for idx, document in enumerate(tqdm(tokens)):\\n tmp = [0 for char in range(len(document))]\\n for name in labels[idx]:\\n if re.match(r\\\"[^a-zA-Z]\\\", name):\\n pattern = list(name)\\n else:\\n pattern = name\\n # for indexes in re.finditer(name, document):\\n # tmp[indexes.span()[0]:indexes.span()[1]] = [1 for _ in range(indexes.span()[1] - indexes.span()[0])]\\n for i in range(len(document)):\\n if document[i] == pattern[0] and document[i:i+len(pattern)] == pattern:\\n tmp[i:i+len(pattern)] = [1 for _ in range(len(pattern))]\\n encoded.append(tmp)\\n\\n # # Sanity check\\n # for doc, enc in zip(tokens, encoded):\\n # print(f\\\"{len(doc)}, {len(enc)}\\\")\\n\\n return encoded\",\n \"def label_encode(self, directory):\\n\\n dataframe = 'df_' + str(self.line) + '/'\\n\\n line_encodings_path = os.path.join(directory, dataframe)\\n\\n month_source = line_encodings_path + 'MONTH_encode_map.json'\\n stop_id_source = line_encodings_path + 'STOPPOINTID_encode_map.json'\\n cluster_source = line_encodings_path + 'cluster_encode_map.json'\\n\\n features = [self.month, self.stop_id, self.cluster]\\n dict_sources = [month_source, stop_id_source, cluster_source]\\n\\n for i in range(len(dict_sources)):\\n json_obj = open(dict_sources[i])\\n json_obj = json_obj.read()\\n dictionary = json.loads(json_obj)\\n key = features[i]\\n features[i] = dictionary[str(key)]\",\n \"def label(tree):\\n return tree[0]\",\n \"def create_encoding(df):\\n vocab = []\\n vocab_df = df[\\\"company\\\"] + df[\\\"address\\\"] + df[\\\"date\\\"] + df[\\\"total\\\"]\\n [vocab.extend(row) for row in vocab_df]\\n enc = LabelEncoder()\\n enc.fit(vocab)\\n return enc\",\n \"def decode_strong(self, labels):\\n result_labels = []\\n for i, label_column in enumerate(labels.T):\\n change_indices = DecisionEncoder().find_contiguous_regions(label_column)\\n\\n # append [label, onset, offset] in the result list\\n for row in change_indices:\\n result_labels.append(\\n [\\n self.labels[i],\\n self._frame_to_time(row[0]),\\n self._frame_to_time(row[1]),\\n ]\\n )\\n return result_labels\",\n \"def set_lm_labels(dataset, vocab, stm_lex, stm_win=3):\\n n_records = len(dataset)\\n for i in range(n_records):\\n words = dataset[i]['words']\\n # labels of language modeling and sentiment aware language modeling\\n lm_labels_f, lm_labels_b = [], []\\n n_w = len(words)\\n # language modeling in forward direction\\n for j in range(n_w):\\n if j == n_w - 1:\\n next_word = -1\\n else:\\n if words[j+1] in stm_lex:\\n next_word = stm_lex[words[j+1]]\\n else:\\n next_word = -1\\n next_word = -1* next_word + 1\\n lm_labels_f.append(next_word)\\n for j in range(n_w-1, -1, -1):\\n if j == 0:\\n next_word = -1\\n else:\\n if words[j-1] in stm_lex:\\n next_word = stm_lex[words[j-1]]\\n else:\\n next_word = -1\\n next_word = -1* next_word + 1\\n lm_labels_b.append(next_word)\\n dataset[i]['lm_labels_f'] = list(lm_labels_f)\\n dataset[i]['lm_labels_b'] = list(lm_labels_b)[::-1]\\n # sentiment aware language modeling\\n stm_lm_labels = []\\n opn_labels = []\\n for j in range(n_w):\\n if words[j] in stm_lex:\\n opn_labels.append(1)\\n else:\\n opn_labels.append(0)\\n # left boundary of sentimental context\\n stm_ctx_lb = j - stm_win\\n if stm_ctx_lb < 0:\\n stm_ctx_lb = 0\\n stm_ctx_rb = j + stm_win + 1\\n left_ctx = words[stm_ctx_lb:j]\\n right_ctx = words[j+1:stm_ctx_rb]\\n stm_ctx = left_ctx + right_ctx\\n flag = False\\n for w in stm_ctx:\\n if w in stm_lex:\\n flag = True\\n break\\n if flag:\\n stm_lm_labels.append(1)\\n else:\\n stm_lm_labels.append(0)\\n dataset[i]['stm_lm_labels'] = list(stm_lm_labels)\\n dataset[i]['opn_labels'] = list(opn_labels)\\n return dataset\",\n \"def get_train_labels(self, window, scene):\\n pass\",\n \"def one_hot_encoding((uri, label), all_labels):\\n labels = [0]*NUM_LABELS\\n for i, l in enumerate(all_labels):\\n if label == l:\\n labels[i] = 1\\n yield uri, labels\",\n \"def encode_data(column: str, data):\\n return label.fit_transform(data[column])\",\n \"def encode_labels(Y, le=None, enc=None):\\n\\n # initialize encoders\\n N = Y.shape[0]\\n\\n # Encode the labels\\n if le is None:\\n le = LabelEncoder()\\n Y_le = le.fit_transform(Y).reshape(N, 1)\\n else:\\n Y_le = le.transform(Y).reshape(N, 1)\\n\\n # convert into one hot encoding\\n if enc is None:\\n enc = OneHotEncoder()\\n Y_enc = enc.fit_transform(Y_le).toarray()\\n else:\\n Y_enc = enc.transform(Y_le).toarray()\\n\\n return Y_enc, le, enc\",\n \"def encode(text_tensor, label_tensor):\\n # encode text\\n encoded_text = encoder.encode(text_tensor.numpy())\\n label = tf.where(label_tensor > 3, 1, 0)\\n return encoded_text, label\",\n \"def predLabel(self, DataMatrix):\\n self.predict(DataMatrix)\\n # Calculamos el valor mas alto, y a partir de este obtenemos el nombre de la etiqueta\\n tags = [[self.classes[np.argmax(subrow)] for subrow in row] for row in self.data]\\n return tags\",\n \"def prepare_dense_label(input_batch, new_size, one_hot=True):\\n with tf.name_scope('label_encode'):\\n print(input_batch)\\n # input_batch = tf.image.resize_nearest_neighbor(input_batch, new_size) # as labels are integer numbers, need to use NN interpolation\\n # input_batch = tf.squeeze(input_batch, squeeze_dims=[3]) # reducing the channel dimension.\\n # if one_hot:\\n # input_batch = tf.one_hot(input_batch, depth=n_classes, axis=2)\\n return input_batch\",\n \"def y_to_label(self, data, Y):\\n pass\",\n \"def predLabel(self, DataMatrix):\\n self.predict(DataMatrix)\\n # Calculamos el valor mas alto, y a partir de este obtenemos el nombre de la etiqueta\\n tags = [self.classes[np.argmax(elem)] for elem in self.data]\\n return tags\",\n \"def encode_labels(self, lilabs):\\n\\n y = []\\n for lab in lilabs:\\n y.append([1 if l in lab else 0 for l in self.labels])\\n\\n return np.array(y, dtype=float)\",\n \"def get_label(self, label):\\n\\n return torch.from_numpy(np.array(label)).long()\",\n \"def __label__(self, sdfg, state):\\n if self.data is None:\\n return self._label(None)\\n return self._label(sdfg.arrays[self.data].shape)\",\n \"def get_encoded_label_from_example(example):\\n return example.features.feature['label/encoded'].bytes_list.value[0]\",\n \"def add_label_encoding(df, categoricals_to_encode, line_name):\\n label_encode_dir = '/Users/davidodwyer/Documents/studyCS/Semester_3/models_label_encodings'\\n line_name = line_name\\n\\n # iterate through features list\\n # label-encode their values\\n\\n try:\\n \\n for feature in categoricals_to_encode:\\n le = LabelEncoder()\\n name = feature + '_label'\\n df[name] = le.fit_transform(df[feature])\\n \\n # create a mapping of original to labelled\\n # values\\n\\n encoding = df[name].tolist()\\n original = le.inverse_transform(df[name]).tolist()\\n \\n dictionary = dict(zip(original, encoding))\\n\\n\\n # save the mapping to disk, as json\\n\\n line_encode_dir = label_encode_dir + '/' + line_name\\n \\n # line_encode_dir = os.path.join(label_encode_dir, line_name)\\n\\n if not os.path.isdir(line_encode_dir):\\n os.mkdir(line_encode_dir)\\n\\n\\n dict_name = feature + '_encode_map.json'\\n save_target = os.path.join(line_encode_dir, dict_name)\\n \\n with open(save_target, 'w') as json_file:\\n json.dump(dictionary, json_file)\\n \\n\\n\\n # drop the original, unencoded features \\n \\n for feature in categoricals_to_encode:\\n df.drop(feature, axis=1, inplace=True)\\n\\n print('— features label encoded')\\n \\n return df\\n\\n except:\\n\\n print(\\\"Problem with label encoding function\\\")\",\n \"def get_labels(self):\\n return [\\\"A轮\\\", \\\"B轮\\\",\\\"C轮\\\",\\\"天使轮\\\",\\\"战略融资\\\"]\",\n \"def labels_to_labels(class_labels, num_classes =4):\\n levels = []\\n for label in class_labels:\\n levels_from_label = label_to_levels(int(label), num_classes=num_classes)\\n levels.append(levels_from_label)\\n return torch.stack(levels).cuda()\",\n \"def encode_weak(self, labels):\\n # useful for tensor empty labels\\n if type(labels) is str:\\n if labels == \\\"empty\\\":\\n y = np.zeros(len(self.labels)) - 1\\n return y\\n else:\\n labels = labels.split(\\\",\\\")\\n if type(labels) is pd.DataFrame:\\n if labels.empty:\\n labels = []\\n elif \\\"event_label\\\" in labels.columns:\\n labels = labels[\\\"event_label\\\"]\\n y = np.zeros(len(self.labels))\\n for label in labels:\\n if not pd.isna(label):\\n i = self.labels.index(label)\\n y[i] = 1\\n return y\",\n \"def _labels_of_sentence(self, sentence, split):\\n #print(self.label_vocab)\\n self.category_int_of_label_string('O')\\n bioes_tags = self._string_labels_of_sentence(sentence)\\n labels = torch.zeros(len(sentence))\\n for index, label in enumerate(bioes_tags):\\n labels[index] = self.category_int_of_label_string(label)\\n return labels\",\n \"def convert(df: pd.DataFrame, outpath):\\n labels = df['source'].apply(lambda x: LABEL_XINHUA if x == '新华社' else LABEL_NON_XINHUA)\\n labels.to_pickle(outpath)\",\n \"def _labels_of_sentence(self, sentence, split):\\n labels = torch.ones(1)\\n labels[0] = self.category_int_of_label_string(sentence[0][self.name_to_index_dict['label']]) #\\n return labels\",\n \"def get_label_matrix(matrix):\\n linked_matrix = get_linked_matrix(matrix)\\n labelled_matrix = get_labelled_matrix(linked_matrix)\\n\\n return [[c[2] for c in r] for r in labelled_matrix]\",\n \"def read_label(self):\\r\\n # label = str(self.parse_binary())#!!BAD\\r\\n label = ''\\r\\n while True:\\r\\n c = self.eat_char()\\r\\n if c=='n':\\r\\n #terminal char\\r\\n break\\r\\n else:\\r\\n label += c\\r\\n\\r\\n self.log += \\\"'\\\" + label + \\\"'\\\"\\r\\n return label\",\n \"def encode_label(label: str) -> int:\\n\\tif not label:\\n\\t\\treturn 0\\n\\t# part after letter if it has a number, otherwise 1\\n\\tindex = int(label[1:]) if len(label) > 1 else 1\\n\\t# A = 1, B = 2, ... E = 5\\n\\toffset = ord(label[0]) - ord(\\\"A\\\") + 1\\n\\t# compute label number\\n\\treturn (index - 1) * 5 + offset\",\n \"def createLabels(edge):\\n k = removeLabel(edge)\\n return k + \\\"_L\\\", k + \\\"_R\\\"\",\n \"def encode_labels(self, y_str, needs_fit=True):\\n y_str = np.asarray(y_str[:]).reshape(-1, 1)\\n if needs_fit is True:\\n y_vec = self.labelEncoder.fit_transform(y_str)\\n else:\\n y_vec = self.labelEncoder.transform(y_str)\\n return [y_vec, self.labelEncoder]\",\n \"def _model2short_label(self, m):\\n return str(self._get_model_sequence()[m])\",\n \"def predict_label(self, x):\\n best_path_ids, label_col = [], []\\n for i in range(len(x)):\\n # forward_var denote end this step each node will get max score\\n forward_var = np.log(self.init_probability)\\n\\n for j in range(len(x[i])):\\n if j == 0:\\n forward_var += np.log(self.emission[x[i][j]].reshape(-1, 1))\\n\\n else:\\n current_score, current_ids = np.zeros((self.n_classes, 1)), np.zeros(self.n_classes, dtype=int)\\n for next_tag in range(self.n_classes):\\n next_score = forward_var + np.log(self.transition[next_tag].reshape(-1, 1))\\n max_score_id = np.argmax(next_score.reshape(-1))\\n\\n current_score[next_tag] = np.max(next_score)\\n current_ids[next_tag] = max_score_id\\n\\n # update forward_var with each step\\n forward_var = current_score + np.log(self.emission[x[i][j]].reshape(-1, 1))\\n best_path_ids.append(current_ids.tolist())\\n\\n start_node = np.argmax(forward_var)\\n label_col.append(self.find_path(start_node, best_path_ids))\\n best_path_ids = []\\n\\n return label_col\",\n \"def _preprocess(self, txt_seq):\\n input = []\\n label = []\\n punc = \\\" \\\"\\n for token in txt_seq.split():\\n if token in self.punc2id:\\n punc = token\\n else:\\n input.append(self.word2id.get(token, self.word2id[\\\"<UNK>\\\"]))\\n label.append(self.punc2id[punc])\\n punc = \\\" \\\"\\n input.append(self.word2id[\\\"<END>\\\"])\\n label.append(self.punc2id[punc])\\n input = torch.LongTensor(input)\\n label = torch.LongTensor(label)\\n # input = np.array(input)\\n # label = np.array(label)\\n return input, label\",\n \"def cvpr2018_labels():\\n\\n return {\\n 0: 'others',\\n 33: 'car',\\n 34: 'motorcycle',\\n 35: 'bicycle',\\n 36: 'pedestrian',\\n 38: 'truck',\\n 39: 'bus',\\n 40: 'tricycle'\\n }\",\n \"def reduceLabel(T):\\n if not T.isLeaf():\\n T.label = T.label[:1]\\n for t,w in T.children:\\n reduceLabel(t)\",\n \"def _convert_to_onehot_labels(seg_label, num_classes):\\n\\n batch_size = seg_label.size(0)\\n onehot_labels = seg_label.new_zeros((batch_size, num_classes))\\n for i in range(batch_size):\\n hist = seg_label[i].float().histc(\\n bins=num_classes, min=0, max=num_classes - 1)\\n onehot_labels[i] = hist > 0\\n return onehot_labels\",\n \"def one_hot_encode(x):\\n # TODO: Implement Function\\n lb = preprocessing.LabelBinarizer()\\n lb.fit([0,1,2,3,4,5,6,7,8,9])\\n \\n return lb.transform(x)\",\n \"def encodeLabels(XTrain, XTest):\\n trainSize = XTrain.shape[0]\\n X = XTrain.append(XTest)\\n\\n Xobj = X.select_dtypes(include=['object']).astype(str).copy()\\n Xval = X.select_dtypes(exclude=['object']).copy()\\n\\n le = LabelEncoder()\\n for column in Xobj:\\n le.fit(Xobj[column])\\n Xobj[column] = le.transform(Xobj[column])\\n X = pd.concat([Xval, Xobj], axis=1)\\n XTrain = X.loc[0:trainSize]\\n XTest = X.loc[trainSize+1:]\\n\\n return XTrain, XTest\",\n \"def one_hot_encoding(sequence):\\n\\n mydict = {\\n \\\"A\\\": np.asarray([1, 0, 0, 0]),\\n \\\"a\\\": np.asarray([1, 0, 0, 0]),\\n \\\"C\\\": np.asarray([0, 1, 0, 0]),\\n \\\"c\\\": np.asarray([0, 1, 0, 0]),\\n \\\"G\\\": np.asarray([0, 0, 1, 0]),\\n \\\"g\\\": np.asarray([0, 0, 1, 0]),\\n \\\"T\\\": np.asarray([0, 0, 0, 1]),\\n \\\"t\\\": np.asarray([0, 0, 0, 1]),\\n \\\"Y\\\": np.asarray([0, 1, 0, 1]),\\n \\\"y\\\": np.asarray([0, 1, 0, 1]),\\n \\\"R\\\": np.asarray([1, 0, 1, 0]),\\n \\\"r\\\": np.asarray([1, 0, 1, 0]),\\n \\\"S\\\": np.asarray([0, 1, 1, 0]),\\n \\\"s\\\": np.asarray([0, 1, 1, 0]),\\n \\\"W\\\": np.asarray([1, 0, 0, 1]),\\n \\\"w\\\": np.asarray([1, 0, 0, 1]),\\n \\\"K\\\": np.asarray([0, 0, 1, 1]),\\n \\\"k\\\": np.asarray([0, 0, 1, 1]),\\n \\\"M\\\": np.asarray([1, 1, 0, 0]),\\n \\\"m\\\": np.asarray([1, 1, 0, 0]),\\n \\\"B\\\": np.asarray([0, 1, 1, 1]),\\n \\\"b\\\": np.asarray([0, 1, 1, 1]),\\n \\\"D\\\": np.asarray([1, 0, 1, 1]),\\n \\\"d\\\": np.asarray([1, 0, 1, 1]),\\n \\\"H\\\": np.asarray([1, 1, 0, 1]),\\n \\\"h\\\": np.asarray([1, 1, 0, 1]),\\n \\\"V\\\": np.asarray([1, 1, 1, 0]),\\n \\\"v\\\": np.asarray([1, 1, 1, 0]),\\n \\\"N\\\": np.asarray([0, 0, 0, 0]),\\n \\\"n\\\": np.asarray([0, 0, 0, 0]),\\n \\\"-\\\": np.asarray([0, 0, 0, 0]),\\n }\\n print(f\\\"Seq: {sequence}\\\")\\n if len(sequence) > 0:\\n nuc_list = list()\\n for nuc in list(sequence):\\n nuc_list.append(mydict[nuc])\\n result = np.stack(np.asarray(nuc_list, dtype=\\\"int8\\\"))\\n return result\\n else: \\n print(\\\"ERROR! sequence is too short\\\")\",\n \"def create_TargetLabel(dataset):\\n label_Array = dataset['close_-1_r'].shift(-1)\\n label_Array = label_Array.apply(lambda x:1 if x>0.0000 else 0)\\n return label_Array\",\n \"def read_stanford_labels():\\n # First get the hardi data\\n fetch_stanford_hardi()\\n hard_img, gtab = read_stanford_hardi()\\n\\n # Fetch and load\\n files, folder = fetch_stanford_labels()\\n labels_file = pjoin(folder, \\\"aparc-reduced.nii.gz\\\")\\n labels_img = nib.load(labels_file)\\n return hard_img, gtab, labels_img\",\n \"def labelingLVQ(self):\\n numLabels = len(np.unique(self.y))\\n for i, x in enumerate(self.x):\\n w = self.find_closest(x)[0]\\n for nl in range(numLabels):\\n if self.y[i] == nl:\\n self.labels[nl, w[0], w[1]] += 1\\n return self.labels\",\n \"def _get_labels(self, ind):\\n pass\",\n \"def get_train_labels(self, window: Box, scene: Scene) -> Labels:\\n raise NotImplementedError()\",\n \"def lyft_labels():\\n\\n return {\\n 0: 'None',\\n 7: 'Roads',\\n 10: 'Vehicles'\\n }\",\n \"def _setup_labels(self):\\n self._labels = self.get_labels()\\n self._labels = self.get_predefined_labels() + list(self._labels)\\n self._labels = sorted(self._labels)\\n\\n self._labels_2_index = {label.lower(): i for i, label in enumerate([self._unknown_label] + self._labels)}\\n self._index_2_labels = {i: label for label, i in self._labels_2_index.items()}\\n\\n self._labels_dim = len(self._labels_2_index)\\n return None\",\n \"def get_train_labels(self):\\n raise NotImplementedError\",\n \"def assign_labels_first_left(document, label_encoder):\\n for sentence in document.sentences:\\n for word in sentence.words:\\n sorted_probs = sorted(word.tokens[0].predictions)\\n label_idx = np.argmax(sorted_probs[0][1], axis=-1)\\n word.predicted_label = label_encoder.inv_label_map[label_idx]\",\n \"def _labels_of_sentence(self, sentence, esplit):\\n\\n labels = torch.zeros(len(sentence))\\n for token_index, token_attribute_list in enumerate(sentence):\\n label_string = token_attribute_list[self.task_label_index]\\n labels[token_index] = self.category_int_of_label_string(label_string)\\n return labels\",\n \"def decodeLabels(predictions, vocab):\\n\\n decoded_labels =[]\\n for sequence in predictions:\\n temp = []\\n for label in list(sequence):\\n if label in vocab:\\n temp.append(vocab[label])\\n else:\\n temp.append(label)\\n decoded_labels.append(temp)\\n \\n return decoded_labels\",\n \"def _fit_teams_names_lencoder(self) -> LabelEncoder:\\n df = self._dbmanager.query_teams_names()\\n values = [\\\"\\\"] + df[\\\"name\\\"].values.tolist()\\n return LabelEncoder().fit(values)\",\n \"def _string_labels_of_sentence(self, sentence):\\n label_strings = []\\n ongoing_label = 'O'\\n for token_index, token_attribute_list in enumerate(sentence):\\n raw_label_string = token_attribute_list[self.task_label_index].strip('*')\\n if '(' in raw_label_string:\\n ongoing_label = raw_label_string.strip('(').strip(')')\\n beginning = True\\n #labels[token_index] = self.category_int_of_label_string(ongoing_label)\\n if ongoing_label == 'O':\\n label_strings.append(ongoing_label)\\n else:\\n label_strings.append('{}-{}'.format('B' if beginning else 'I', ongoing_label))\\n beginning = False\\n if ')' in raw_label_string:\\n ongoing_label = 'O'\\n #bioes_tags = bio2_to_bioes(label_strings)\\n bioes_tags = label_strings\\n return bioes_tags\",\n \"def test_basic_labeling(self):\\n # data with only 1 feature\\n data = array([[-1], [1], [0.5], [0.25], [-0.33], [0]])\\n # give 1 if feature value >= 0; otherwise 0\\n labels = array([0, 1, 1, 1, 0, 1])\\n cdata = LabeledCData(data, labels)\\n\\n # ensure that labelling is correct\\n assert array_equal(cdata.labels, labels)\",\n \"def prepare_label(input_batch, new_size, num_classes, one_hot=True, task='seg'):\\n with tf.name_scope('label_encode'):\\n input_batch = tf.image.resize_nearest_neighbor(input_batch, new_size) # as labels are integer numbers, need to use NN interp.\\n if task == 'seg':\\n input_batch = tf.squeeze(input_batch, squeeze_dims=[3]) # reducing the channel dimension.\\n if one_hot:\\n input_batch = tf.one_hot(input_batch, depth=num_classes)\\n return input_batch\",\n \"def label_to_name(label):\\n return \\\"Tree\\\"\",\n \"def label_encode(self, col_need):\\r\\n assert isinstance(col_need, list) and len(col_need) == 1\\r\\n self.label_code = LabelEncoder()\\r\\n array_label_code = self.label_code.fit_transform(self.df.loc[:, col_need])\\r\\n\\r\\n label_list = list(self.label_code.classes_)\\r\\n for i, x in enumerate(label_list):\\r\\n self.col_label_dict[col_need[0] + \\\"_\\\" + str(i)] = col_need[0] + \\\"_\\\" + x\\r\\n\\r\\n self.df.drop(col_need, axis=1, inplace=True)\\r\\n\\r\\n df_label_code = pd.DataFrame(array_label_code, columns=col_need, index=self.df.index)\\r\\n self.df = pd.concat([self.df, df_label_code], axis=1)\",\n \"def load_label(self, idx):\\n im = open('{}/GTTXT/{}.txt'.format(root_dir, idx))\\n\\t#print(type(im.readlines()[0].rstrip(\\\"\\\\n\\\")))\\n rgb_label = [i.rstrip(\\\"\\\\n\\\").split(\\\" \\\") for i in im.readlines()]\\n\\tlabel=[]\\t\\n\\tfor i in rgb_label:\\n\\t\\tlabel+=[int(j) for j in i]\\n\\tlabel=np.array(label).reshape(720,960)\\n\\tlabel[label==-1]=12\\n\\t#print(np.unique(label))\\n #label = label[np.newaxis, ...]\\n return label\",\n \"def load_labels(labels_dir, trial_name):\\n labels_path = labels_dir + trial_name + \\\".txt\\\"\\n raw_labels_data = np.genfromtxt(labels_path, dtype=np.int,\\n converters=LABELS_CONVERTERS,\\n usecols=LABELS_USECOLS)\\n #print(\\\"rawlabelsdata: \\\", raw_labels_data)\\n #print(get_first_frame(labels_path))\\n frames = np.arange(get_first_frame(labels_path), get_last_frame(labels_path)+1, dtype=np.int)\\n #print(\\\"frames: \\\", frames)\\n #print(frames.shape)\\n #labels = np.zeros(frames.shape, dtype=np.int)\\n labels1 = []\\n #print(labels)\\n for start, end, label in raw_labels_data:\\n #mask = (frames >= start) & (frames <= end)\\n #print(start)\\n #print(end)\\n i = start\\n while(i<end):\\n if(i%6 == 0):\\n labels1.append(label)\\n i = i+1\\n\\n #labels[mask] = label\\n #print(\\\"labels[mask]: \\\",labels[mask])\\n labels1 = np.array(labels1)\\n #print(labels1)\\n labels_data = labels1.reshape(-1,1)\\n #print(labels1.shape)\\n #print(\\\"labels: \\\", labels_data)\\n \\n return labels_data\",\n \"def one_hot_to_label(one_hot=None):\\n if np.where(one_hot == 1)[0][0] == 0:\\n return 'Store'\\n elif np.where(one_hot == 1)[0][0] == 1:\\n return 'Home'\\n elif np.where(one_hot == 1)[0][0] == 2:\\n return 'Public spaces'\\n elif np.where(one_hot == 1)[0][0] == 3:\\n return 'Leisure'\\n elif np.where(one_hot == 1)[0][0] == 4:\\n return 'Working place'\\n else:\\n raise Exception('The one-hot representation \\\"' + str(one_hot) + '\\\" cant be transform to a label')\",\n \"def label_names(self) -> Strings:\\n\\n try:\\n if self._le:\\n return self._le.classes_.tolist()\\n except AttributeError:\\n self.logger.warning('AttributeError: LabelEncoder was not found.')\\n self.logger.warning('No LabelEncoder. Please call label_encoder first.')\\n return None\",\n \"def predict_label(img, net_model, label):\\n img1 = cv2.resize(img, (80, 80))\\n predict = net_model.predict(img1.reshape(1, 80, 80, 3))\\n maxi = predict[0][0]\\n curs = 0\\n test = 0\\n for i, pred in enumerate(predict[0]):\\n test += pred\\n if pred > maxi:\\n maxi = pred\\n curs = i\\n return label[curs]\",\n \"def forward(self, input):\\n label=np.dot(input,self.w)+self.b\\n return label\",\n \"def fix_label(self, label):\\n if label is None:\\n return None\\n assert len(label) == len(self.data)\\n fixed_labels = []\\n for y, x in zip(label, self.data):\\n assert len(y) == len(x)\\n encode = self.transform_function(' '.join(x))\\n fixed_label = list(chain(*[\\n [label] + [PAD_TOKEN_LABEL_ID] * (len(self.transform_function.tokenize(word)) - 1)\\n for label, word in zip(y, x)]))\\n if encode['input_ids'][0] in self.transform_function.all_special_ids:\\n fixed_label = [PAD_TOKEN_LABEL_ID] + fixed_label\\n fixed_label += [PAD_TOKEN_LABEL_ID] * (len(encode['input_ids']) - len(fixed_label))\\n fixed_label = fixed_label[:self.transform_function.max_seq_length]\\n fixed_labels.append(fixed_label)\\n return fixed_labels\",\n \"def label_encode(df):\\n\\n X = df.copy()\\n for colname in X.select_dtypes([\\\"category\\\"]):\\n X[colname] = X[colname].cat.codes\\n return X\",\n \"def pp_labels(y_train, y_dev, y_test):\\n\\n lb = LabelBinarizer()\\n ym_train = lb.fit_transform(y_train).T\\n ym_dev = lb.fit_transform(y_dev).T\\n ym_test = lb.fit_transform(y_test).T\\n\\n return ym_train, ym_dev, ym_test\",\n \"def label(d, X, ind_class0, ind_class1, N, V, binary):\\n if binary == True:\\n K = 1\\n C = torch.zeros(N + V, K)\\n C[ind_class0, :] = 0.0\\n C[ind_class1, :] = 1.0\\n else:\\n K = 2\\n C = torch.zeros(N + V, K)\\n C[ind_class0, :] = torch.tensor([1.0, 0.0])\\n C[ind_class1, :] = torch.tensor([0.0, 1.0])\\n\\n X_train = X[:N, :]\\n X_val = X[N:, :]\\n C_train = C[:N, :]\\n C_val = C[N:, :]\\n\\n return [X_train, C_train, X_val, C_val, d, K]\",\n \"def generate_labels():\\n label_set = set([])\\n for data in load_data():\\n label = data.split(' ', 1)[0]\\n label_set.add(label)\\n labels = list(label_set)\\n labels.sort()\\n return labels\",\n \"def test_decode_labels_from_strings(self):\\n classes = np.array([\\\"a\\\", \\\"b\\\", \\\"c\\\", \\\"d\\\", \\\"e\\\"])\\n decoded = classes[np.random.randint(0, 5, 100)]\\n y = np.array([v.upper() for v in decoded])\\n\\n oz = ClassificationScoreVisualizer(GaussianNB, classes=classes)\\n npt.assert_array_equal(oz._decode_labels(y), decoded)\\n\\n encoder = {c.upper(): c for c in classes}\\n oz = ClassificationScoreVisualizer(GaussianNB, encoder=encoder)\\n npt.assert_array_equal(oz._decode_labels(y), decoded)\\n\\n class L2UTransformer(object):\\n def transform(self, y):\\n return np.array([yi.upper() for yi in y])\\n\\n def inverse_transform(self, y):\\n return np.array([yi.lower() for yi in y])\\n\\n oz = ClassificationScoreVisualizer(GaussianNB, encoder=L2UTransformer())\\n npt.assert_array_equal(oz._decode_labels(y), decoded)\",\n \"def preprocess_labels(y):\\n\\n y = tf.keras.utils.to_categorical(y, nclasses)\\n\\n return y\",\n \"def _annotations_to_targets(self, labels):\\n roots = ['A','B','C','D','E','F','G']\\n natural = zip(roots, [0, 2, 3, 5, 7, 8, 10])\\n root_note_map = {}\\n for chord, num in natural:\\n root_note_map[chord] = num\\n root_note_map[chord + '#'] = (num + 1) % 12\\n root_note_map[chord + 'b'] = (num - 1) % 12\\n\\n root_note_map['N'] = 24\\n root_note_map['X'] = 24\\n \\n labels = [c.decode('UTF-8') for c in labels]\\n chord_root_notes = [c.split(':')[0].split('/')[0] for c in labels]\\n chord_root_note_ids = np.array([root_note_map[crn] for crn in chord_root_notes])\\n \\n chord_type = [c.split(':')[1] if ':' in c else '' for c in labels]\\n chord_type_shift = np.array([12 if 'min' in chord_t or 'dim' in chord_t else 0 for chord_t in chord_type])\\n return one_hot(chord_root_note_ids + chord_type_shift, self.num_classes)\",\n \"def _labels(path):\\r\\n with gzip.open(path) as f:\\r\\n # First 8 bytes are magic_number, n_labels\\r\\n integer_labels = np.frombuffer(f.read(), 'B', offset=8)\\r\\n\\r\\n def _onehot(integer_labels):\\r\\n \\\"\\\"\\\"Return matrix whose rows are onehot encodings of integers.\\\"\\\"\\\"\\r\\n n_rows = len(integer_labels)\\r\\n n_cols = integer_labels.max() + 1\\r\\n onehot = np.zeros((n_rows, n_cols), dtype='uint8')\\r\\n onehot[np.arange(n_rows), integer_labels] = 1\\r\\n return onehot\\r\\n\\r\\n return _onehot(integer_labels)\",\n \"def fluxes_to_labels(fluxes: np.ndarray) -> np.ndarray:\\n return ((1 - fluxes) // 2).astype(np.int8)\",\n \"def onehot_encode_labels(y):\\n\\treturn OneHotEncoder(categories=\\\"auto\\\", sparse=False).fit_transform(y.reshape(y.shape[0],1))\",\n \"def data_labels(data):\\n\\n # The data consists of a equal number of benign and deleterious samples\\n # The first part of the data are the benign samples (label 0), and the second part the deleterious ones (label 1)\\n n_samples = data.shape[0]\\n n_class_samples = int(n_samples / 2)\\n\\n # Get a numpy array of the labels\\n labels_ben = [0] * n_class_samples\\n labels_del = [1] * n_class_samples\\n labels = np.array(labels_ben + labels_del)\\n\\n # Convert the data into one hot encoded data\\n labels = initialization_based(labels)\\n\\n return labels\",\n \"def one_hot_encoder(self, DNA_string):\\n\\n if self.selex_predict_str_adaptor != 0:\\n DNA_string = \\\"A\\\" * self.selex_predict_str_adaptor + DNA_string + 'A' * self.selex_predict_str_adaptor\\n\\n trantab = DNA_string.maketrans('ACGT', '0123')\\n str_arr = [\\\"\\\" for x in range(self.num_of_str)]\\n for i in range(0, self.num_of_str): ##each substring goes to different element array\\n str_arr[i] = DNA_string[i: i + self.selex_str_len]\\n\\n # if the \\\"ACGT\\\"\\n # won't be added it will be impossible to convert sequnces which miss one of the letters\\n str_arr[self.num_of_str - 1] = str_arr[self.num_of_str - 1] + \\\"ACGT\\\"\\n\\n final_str = list(\\\"\\\")\\n for i in range(0, self.num_of_str):\\n final_str += list(str_arr[i].translate(trantab))\\n\\n return to_categorical(final_str)[0:-4] # returns the matrix without the \\\"ACGT\\\"\",\n \"def generate_labels(n_samples):\\n return np.ones([n_samples, 1]), np.zeros([n_samples, 1])\",\n \"def addLabels(t):\\n if not t.label:\\n t.label = \\\"\\\".join([choice(\\\"abcdefghijklmnopqrstuvwxyz\\\") for i in range(4)])\\n for r,w in t.children:\\n addLabels(r)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70767474","0.702532","0.6875088","0.6661352","0.6608816","0.651388","0.64687127","0.6330287","0.63131607","0.62710196","0.6238585","0.62264204","0.62100923","0.620349","0.6152642","0.61374915","0.60997736","0.60554326","0.601872","0.6012537","0.59937024","0.598586","0.59593034","0.59503424","0.5947715","0.5900269","0.58786565","0.5878577","0.587463","0.584945","0.58434093","0.58233136","0.5794112","0.5777246","0.57765704","0.57672244","0.5754414","0.5753029","0.5745042","0.57340693","0.5734004","0.57103974","0.5710042","0.5709077","0.57066035","0.57040125","0.57027966","0.5696031","0.5675914","0.56716806","0.5660953","0.5660545","0.56527257","0.5650257","0.5649087","0.5645651","0.5642405","0.56310403","0.5628231","0.56261927","0.56260926","0.56257695","0.56242913","0.5614544","0.5604431","0.55651","0.55577064","0.5557475","0.55552673","0.5555243","0.55522734","0.5536259","0.55338854","0.55314547","0.5528631","0.55271983","0.5526423","0.55165887","0.5515925","0.55154496","0.5514441","0.5508784","0.54830325","0.5481122","0.5480233","0.54791266","0.5464715","0.5458948","0.54523575","0.54496944","0.54447573","0.5440196","0.5437942","0.5435044","0.5431046","0.5424122","0.5423935","0.5419353","0.54190487","0.5417964"],"string":"[\n \"0.70767474\",\n \"0.702532\",\n \"0.6875088\",\n \"0.6661352\",\n \"0.6608816\",\n \"0.651388\",\n \"0.64687127\",\n \"0.6330287\",\n \"0.63131607\",\n \"0.62710196\",\n \"0.6238585\",\n \"0.62264204\",\n \"0.62100923\",\n \"0.620349\",\n \"0.6152642\",\n \"0.61374915\",\n \"0.60997736\",\n \"0.60554326\",\n \"0.601872\",\n \"0.6012537\",\n \"0.59937024\",\n \"0.598586\",\n \"0.59593034\",\n \"0.59503424\",\n \"0.5947715\",\n \"0.5900269\",\n \"0.58786565\",\n \"0.5878577\",\n \"0.587463\",\n \"0.584945\",\n \"0.58434093\",\n \"0.58233136\",\n \"0.5794112\",\n \"0.5777246\",\n \"0.57765704\",\n \"0.57672244\",\n \"0.5754414\",\n \"0.5753029\",\n \"0.5745042\",\n \"0.57340693\",\n \"0.5734004\",\n \"0.57103974\",\n \"0.5710042\",\n \"0.5709077\",\n \"0.57066035\",\n \"0.57040125\",\n \"0.57027966\",\n \"0.5696031\",\n \"0.5675914\",\n \"0.56716806\",\n \"0.5660953\",\n \"0.5660545\",\n \"0.56527257\",\n \"0.5650257\",\n \"0.5649087\",\n \"0.5645651\",\n \"0.5642405\",\n \"0.56310403\",\n \"0.5628231\",\n \"0.56261927\",\n \"0.56260926\",\n \"0.56257695\",\n \"0.56242913\",\n \"0.5614544\",\n \"0.5604431\",\n \"0.55651\",\n \"0.55577064\",\n \"0.5557475\",\n \"0.55552673\",\n \"0.5555243\",\n \"0.55522734\",\n \"0.5536259\",\n \"0.55338854\",\n \"0.55314547\",\n \"0.5528631\",\n \"0.55271983\",\n \"0.5526423\",\n \"0.55165887\",\n \"0.5515925\",\n \"0.55154496\",\n \"0.5514441\",\n \"0.5508784\",\n \"0.54830325\",\n \"0.5481122\",\n \"0.5480233\",\n \"0.54791266\",\n \"0.5464715\",\n \"0.5458948\",\n \"0.54523575\",\n \"0.54496944\",\n \"0.54447573\",\n \"0.5440196\",\n \"0.5437942\",\n \"0.5435044\",\n \"0.5431046\",\n \"0.5424122\",\n \"0.5423935\",\n \"0.5419353\",\n \"0.54190487\",\n \"0.5417964\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62131274"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":92879,"cells":{"query":{"kind":"string","value":"Transform probs to logprobs for KLdivergence."},"document":{"kind":"string","value":"def prepare_data(train_x, train_y, dev_x, dev_y, test_x, testy):\n train_x = torch.FloatTensor(train_x).cuda()\n train_y = torch.FloatTensor(train_y).cuda()\n dev_x = torch.FloatTensor(dev_x).cuda()\n dev_y = torch.FloatTensor(dev_y).cuda()\n test_x = torch.FloatTensor(test_x).cuda()\n test_y = torch.FloatTensor(testy).cuda()\n return train_x, train_y, dev_x, dev_y, test_x, test_y"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def log_probs(self):\n return np.array([m['log_probs'] for m in self.model_outs], dtype=np.float32)","def to_logprobs(x):\n N = x.size(0)\n sid_bins = x.size(1)//2\n H, W = x.size()[-2:]\n A = x[:, ::2, :, :].clone()\n B = x[:, 1::2, :, :].clone()\n\n A = A.view(N, 1, -1)\n B = B.view(N, 1, -1)\n\n C = torch.cat((A, B), dim=1)\n # C = torch.clamp(C, min=1e-8, max=1e8) # prevent nans\n log_ord_c = F.log_softmax(C, dim=1)\n log_ord_c0 = log_ord_c[:, 0, :].clone()\n log_ord_c0 = log_ord_c0.view(-1, sid_bins, H, W)\n log_ord_c1 = log_ord_c[:, 1, :].clone()\n log_ord_c1 = log_ord_c1.view(-1, sid_bins, H, W)\n return log_ord_c0, log_ord_c1","def _update_logprobs(self):\n #self._logp_src = self._log_lim(self.p_source)\n self._logp_I0 = self._log_lim(self.p_source)\n self._logp_R0 = self._log_lim(self.p_source/(self.p_rec_div))\n self._logp_S_fin = self._log_lim(self.p_S_fin)\n self._logp_inf_fin = self._log_lim(self.p_infect_fin)","def logprob(predictions, labels):\n # prevent negative probability\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]","def setLogprobs(self, value):\n return self._set(logprobs=value)","def logprob(predictions, labels):\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]","def logprob(predictions, labels):\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]","def nll_logprobs(self, input, target_idx):\n raise NotImplementedError()","def logits_to_log_prob(self, logits):\n\n reduction_indices = len(logits.shape.as_list()) - 1\n max_logits = tf.math.reduce_max(\n logits, axis=reduction_indices, keepdims=True)\n safe_logits = tf.subtract(logits, max_logits)\n sum_exp = tf.math.reduce_sum(\n tf.exp(safe_logits), axis=reduction_indices, keepdims=True)\n log_probs = tf.math.subtract(safe_logits, tf.math.log(sum_exp))\n return log_probs","def logprob(predictions, labels):\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions)))","def log_prob(self):","def __logprob__(self, cv, vsense):\n return 1.0 / (1.0 + np.exp(-np.dot(cv, vsense)))","def relative_probs_from_log_probs(log_probs):\n probs = np.exp(log_probs - log_probs.mean())\n assert not np.any(probs <= 0), 'choose a smaller power'\n return probs","def _calculate_batched_logprob(self, mu, std, x):\n # Set up lower bound of std, since zero std can lead to NaN log-probability\n # Used for: torch.clamp(std_i, min=min_std...)\n # min_std = 1e-12\n \n log_probs = []\n \n # Iterate over all density components\n for i in range(self.num_densities):\n # Retrieve means and stds\n mu_i = mu[:, i, :]\n std_i = std[:, i, :]\n # Thresholding std, if std is 0, it leads to NaN loss. \n # std_i = torch.clamp(std_i, min=min_std, max=std_i.max().item())\n # Create Gaussian distribution\n dist = Normal(loc=mu_i, scale=std_i)\n # Calculate the log-probability\n logp = dist.log_prob(x)\n # Record the log probability for current density\n log_probs.append(logp)\n \n # Stack log-probabilities with shape [N, K, D]\n log_probs = torch.stack(log_probs, dim=1)\n \n return log_probs","def predict_log_proba(self, X: np.ndarray) -> np.ndarray:\n\n self._check_input_data(X=X)\n self._check_support(X=X, k=self.k)\n\n if self.prob.ndim == 1:\n log_proba = stats.multinomial.logpmf(\n to_categorical(X, num_classes=self.k), n=1, p=self.prob\n )\n else:\n n_samples = X.shape[0]\n n_classes = len(self.prob) # type: ignore\n log_proba = np.zeros((n_samples, n_classes))\n\n for cls in range(n_classes):\n log_proba[:, cls] = stats.multinomial.logpmf(\n to_categorical(X, num_classes=self.k), n=1, p=self.prob[cls]\n ) # type: ignore\n\n return log_proba","def kl_divergence_bern_bern(z_pres_logits, prior_pres_prob, eps=1e-15):\n z_pres_probs = torch.sigmoid(z_pres_logits)\n kl = z_pres_probs * (torch.log(z_pres_probs + eps) - torch.log(prior_pres_prob + eps)) + \\\n (1 - z_pres_probs) * (torch.log(1 - z_pres_probs + eps) - torch.log(1 - prior_pres_prob + eps))\n\n return kl","def log_m_probs(self):\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\n return self._prob_inverse_transform(m)","def _logprob_X(self, X, **kwargs):\n pass","def predict_log_proba(self, X):\n proba = self.predict_proba(X)\n return np.log(proba)","def log_prob_easier(self, x):\n normalization_const = -0.5 * tf.math.log(2 * np.pi) - tf.math.log(self.stddev)\n sq_term = - 0.5 * ((x - self.mean) / self.stddev) ** 2\n l_prob = tf.math.reduce_sum(normalization_const + sq_term, axis=1)\n return l_prob","def get_normalized_probs(self, net_output, log_probs):\n logits = net_output\n if log_probs:\n return F.log_softmax(logits, dim=1)\n else:\n return F.softmax(logits, dim=1)","def predict_log_proba(self, X):\n proba = self.predict_proba(X)\n\n if self.n_outputs_ == 1:\n return np.log(proba)\n\n else:\n for k in range(self.n_outputs_):\n proba[k] = np.log(proba[k])\n\n return proba","def log_prob(sentence, LM, smoothing=False, delta=0, vocabSize=0):\n word_list = sentence.split()\n log_prob = 0\n for i in range(len(word_list)-1):\n print(word_list[i], word_list[i+1])\n bi_count = LM['bi'][word_list[i]][word_list[i+1]]\n uni_count = LM['uni'][word_list[i]]\n if uni_count == 0 and smoothing:\n return float('-inf')\n log_prob += log(((bi_count + delta)/(uni_count + delta * vocabSize)))\n return log_prob","def predict_log_proba(self, X):\n proba = self.predict_proba(X)\n\n if self.n_outputs_ == 1:\n return np.log(proba)\n\n else:\n for k in xrange(self.n_outputs_):\n proba[k] = np.log(proba[k])\n\n return proba","def predict_log_proba(self, X: np.ndarray) -> np.ndarray:\n\n self._check_input_data(X=X)\n self._check_support(X=X)\n\n if not isinstance(self.prob, np.ndarray):\n log_proba = stats.bernoulli.logpmf(X, p=self.prob)\n else:\n n_samples = X.shape[0]\n n_classes = len(self.prob) # type: ignore\n log_proba = np.zeros((n_samples, n_classes))\n\n for cls in range(n_classes):\n log_proba[:, cls] = stats.bernoulli.logpmf(X, p=self.prob[cls]) # type: ignore\n\n return log_proba","def get_KL_divergence(self):\n KL_loss_W = Vil.get_KL_divergence_Samples(self.mu_weight, Vil.softplus(self.rho_weight), self.weight, self.prior)\n KL_loss_b = 0\n if self.bias is not None:\n KL_loss_b = Vil.get_KL_divergence_Samples(self.mu_bias, Vil.softplus(self.rho_bias), self.bias, self.prior)\n \n KL_loss = KL_loss_W + KL_loss_b\n \n return KL_loss","def log_u_probs(self):\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\n return self._prob_inverse_transform(u)","def KL(P,Q):\n epsilon = 0.00001\n \n #You may want to instead make copies to avoid changing the np arrays.\n P = P+epsilon\n Q = Q+epsilon\n \n divergence = np.sum(P*np.log(P/Q))\n return divergence","def h(self, probs):\n\n return np.sum(-p*np.log2(p) if p > 0 else 0 for p in np.nditer(probs))","def BernoulliGaussianLoss(mu_kl, log_var_kl) :\n def bgl(x, p) :\n N = K.int_shape(p)[1]\n recon = N*metrics.binary_crossentropy(x, p)\n dkl = -0.5 * K.sum(-K.exp(log_var_kl) - K.square(mu_kl) + 1. + log_var_kl, axis=-1)\n return dkl + recon\n return bgl","def kl_divergence(mu, logvar):\n klds = -0.5*(1 + logvar - mu.pow(2) - logvar.exp())\n total_kld = klds.sum(1).mean(0, True)\n dimension_wise_kld = klds.mean(0)\n mean_kld = klds.mean(1).mean(0, True)\n\n return total_kld, dimension_wise_kld, mean_kld","def _logp(self, trace, **inputs):\n def calc_log(step):\n exp_pred = np.dot(inputs['gwas_gen'],\n step['beta_med'].T).ravel()\n phen_pred = step['alpha'] * exp_pred\n phen_prob = norm.logpdf(x=inputs['gwas_phen'],\n loc=phen_pred,\n scale=step['phenotype_sigma'])\n return phen_prob\n\n phen_probs = [calc_log(trace[idx])\n for idx in np.random.randint(0, len(self.trace), 500)]\n phen_probs = np.asmatrix(phen_probs)\n mc_logp = phen_probs.sum(axis=1).mean()\n return mc_logp","def log_prob_from_logits(x):\n axis = len(x.shape) - 1\n m = x.max(dim=axis, keepdim=True)[0]\n return x - m - torch.log(torch.exp(x - m).sum(dim=axis, keepdim=True))","def _graph_fn_get_distribution_log_probs(self, key, parameters, actions):\n # For bounded continuous action spaces, need to unscale (0.0 to 1.0 for beta distribution).\n if self.bounded_action_space[key] is True:\n actions = (actions - self.action_space.low) / (self.action_space.high - self.action_space.low)\n return self.distributions[key].log_prob(parameters, actions)","def logpdf(self, X, pool=None):\n logpdfs = []\n for logweight, space, kde in zip(self._logweights,\n self._spaces,\n self._kdes):\n # Calculate the probability for each parameter space individually\n if np.all(space == ~X.mask) and np.isfinite(logweight):\n logpdfs.append(logweight + kde(X[space], pool=pool))\n\n return logsumexp(logpdfs, axis=0)","def log_probability(self, samples):\n pass","def predict_log_proba(self, X: np.ndarray) -> np.ndarray:\n\n self._check_input_data(X=X)\n self._check_support(X=X, n=self.n)\n\n if not isinstance(self.prob, np.ndarray):\n log_proba = stats.binom.logpmf(X, n=self.n, p=self.prob)\n else:\n n_samples = X.shape[0]\n n_classes = len(self.prob) # type: ignore\n log_proba = np.zeros((n_samples, n_classes))\n\n for cls in range(n_classes):\n log_proba[:, cls] = stats.binom.logpmf(X, n=self.n, p=self.prob[cls]) # type: ignore\n\n return log_proba","def uncertain_logits_to_probs(logits):\n b, n_times_d = logits.size()\n d = 3\n if n_times_d % d:\n raise ValueError('Expected logits dimension to be divisible by {}, got size {}.'.format(d, n_times_d))\n n = n_times_d // d\n\n logits = logits.view(b, n, d)\n probs = F.softmax(logits[:, :, 1:], dim=-1)\n probs = probs[:, :, 1]\n\n return probs","def log_likelihood(data, probs):\n # Assume data is given as counts\n return _np.sum([nlogp(n, p) for n, p in zip(data, probs) if n > 0])","def predict_log_proba(self, X: np.ndarray) -> np.ndarray:\n\n self._check_input_data(X=X)\n self._check_support(X=X)\n\n if not isinstance(self.prob, np.ndarray):\n log_proba = stats.geom.logpmf(X, p=self.prob)\n else:\n n_samples = X.shape[0]\n n_classes = len(self.prob) # type: ignore\n log_proba = np.zeros((n_samples, n_classes))\n\n for cls in range(n_classes):\n log_proba[:, cls] = stats.geom.logpmf(X, p=self.prob[cls]) # type: ignore\n\n return log_proba","def log_loss(self):\n probabilities = self.probability_array().copy()\n # need to flip the probabilities for p < 0.5 with this binary case.\n # 1 - old_val is same as oldval*-1 + 1. Do in 2 steps:\n probabilities[np.equal(0, self.y)] *= -1\n probabilities[np.equal(0, self.y)] += 1\n # when multiclass: np.amax(probabilities, 1)\n return np.log(probabilities).sum()","def log_prob(self, sents):\n log_prob = 0\n for sent in sents:\n log_prob += self.sent_log_prob(sent)\n return log_prob","def kl_divergence(means: Tensor, logvars: Tensor) ->Tensor:\n kl_cost = -0.5 * (logvars - means ** 2 - torch.exp(logvars) + 1.0)\n kl_cost = torch.mean(kl_cost, 0)\n return torch.sum(kl_cost)","def compute_log_prob(self,params: ndarray) -> float:\n return self.compute_log_prior(params) + self.compute_log_likelihood(params)","def calc_probs(log_p):\n\n N = log_p.shape[0]\n\n log_Z_per_N = np.zeros(shape=(N, 1))\n\n for i in range(N):\n\n log_Z_per_N[i] = log_norm(log_p[i])\n\n log_p_new = log_p - log_Z_per_N\n\n p = np.exp(log_p_new)\n\n # log_Z = log_norm(log_p)\n\n # p = np.exp(log_p - log_Z)\n\n return p","def gmmloglik(log_emlik, weights):","def gmmloglik(log_emlik, weights):","def compute_KL_divergence_from_logits(logits_p, logits_q, mask):\r\n #suppose p and q are both tensors with shape [batch, seq_len, #class]\r\n #suppose mask is a tensor with shape [batch, seq_len]\r\n p = tf.nn.softmax(logits_p)\r\n q = tf.nn.softmax(logits_q)\r\n mask = tf.expand_dims(mask, -1)\r\n total_kl = mask*p*tf.log(p/q)\r\n return tf.reduce_mean(total_kl)","def log_prob(self, th):\n\n\t\tif len(th.shape) == 2:\n\t\t\tth0, th1 = th[:,0], th[:,1]\n\t\t\tmask = (th0 > 0.) * (th1 > 0.)\n\t\telif len(th.shape) == 1:\n\t\t\tth0, th1 = float(th[0]), float(th[1])\n\t\t\tmask = torch.tensor([th0 > 0., th1 > 0.])\n\t\telse:\n\t\t\traise IndexError(\"This class is only for 2D Gamma prior for GSE model\")\n\t\tth0, th1 = torch.as_tensor(th0), torch.as_tensor(th1)\n\t\tvals = (self.beta_prior.log_prob(th0) + self.gamma_prior.log_prob(th1)).reshape(-1)\n\t\tvals = vals.numpy()\n\t\tvals[~mask] = -float('inf')\n\t\treturn vals","def log_prob(sentence, LM, smoothing=False, delta=0, vocabSize=0):\n\tlog_prob = 0\n\tdenominator = 0\n\tnumerator = 0\n\tword_list = sentence.split()\n\tlength_w = len(word_list) -1\n\tfor i in range(length_w):\n\t\tword = word_list[i]\n\t\tif word in LM['uni'].keys():\n\t\t\tdenominator = LM['uni'][word]\n\t\telse:\n\t\t\tdenominator = 0\n\t\tnext_word = word_list[i+1]\n\t\tif word in LM['bi'].keys() and next_word in LM['bi'][word].keys():\n\t\t\tnumerator = LM['bi'][word][next_word]\n\t\telse:\n\t\t\tnumerator = 0\n\t\t# case when numerator/denominator = 0/0 and if it is not smoothing the log_prob will be -infinite\n\t\tif (numerator == 0 or denominator == 0) and (not smoothing):\n\t\t\treturn float('-inf')\n\t\telse:\n\t\t\tnumerator += delta\n\t\t\tdenominator += delta*vocabSize\n\t\t\tprob = (numerator) / (denominator)\n\t\t\tlog_prob+= log(prob, 2)\n\treturn log_prob","def get_normalized_probs(self, net_output, log_probs, sample=None):\n encoder_out = net_output[\"encoder_out\"]\n if torch.is_tensor(encoder_out):\n logits = encoder_out.float()\n if log_probs:\n return F.log_softmax(logits, dim=-1)\n else:\n return F.softmax(logits, dim=-1)\n raise NotImplementedError","def get_log_prob(self, X, target=None):\n\n # We don't support the target argument for now.\n assert target is None\n\n batch_size, seq_len, dim = X.size()\n X = X.contiguous().view(-1, dim)\n\n head_y = self.head(X)\n # log_probs = head_y.new_zeros(X.size(0), self.vocab_size)\n\n head_size = self.cutoff[0] + len(self.tail)\n head_log_probs = self.lsm(head_y)\n log_probs_list = [head_log_probs[:, :self.cutoff[0]]]\n\n if len(self.tail) > 0:\n tail_priors = head_log_probs[:, self.cutoff[0]:head_size]\n\n for i in range(len(self.tail)):\n tail_i = self.lsm(self.tail[i](X))\n tail_i = tail_i + tail_priors[:, i, None]\n log_probs_list.append(tail_i)\n\n log_probs = torch.cat(log_probs_list, dim=1)\n log_probs = log_probs.view(batch_size, seq_len, self.vocab_size)\n return log_probs","def _LL(state, effects, observed_frequencies) -> float:\n observed_frequencies = np.array(observed_frequencies)\n predicted_probs = np.array([np.real(np.trace(state.dot(effect))) for effect in effects])\n return sum(np.log10(predicted_probs) * observed_frequencies)","def log_poisson(k, l):\n return k*np.log(l) -l - gammaln(k+1)","def _kl_divergence(p, p_logits, q):\n for tensor in [p, p_logits, q]:\n if not tensor.dtype.is_floating:\n raise ValueError('Input %s must be floating type.', tensor.name)\n p.shape.assert_has_rank(2)\n p_logits.shape.assert_has_rank(2)\n q.shape.assert_has_rank(1)\n return math_ops.reduce_sum(\n p * (nn_ops.log_softmax(p_logits) - math_ops.log(q)), axis=1)","def logdprior(parameters, hyperparameters):\n sigma_w_part = parameters[0] + invgamma_logpdf(parameters[0],\n hyperparameters[\"sigma_w_shape\"], hyperparameters[\"sigma_w_scale\"])\n sigma_v_part = parameters[1] + invgamma_logpdf(parameters[1], hyperparameters[\"sigma_v_shape\"], hyperparameters[\"sigma_v_scale\"])\n return sigma_w_part + sigma_v_part","def _logprob(self, sample):\n return 0, 0","def log_probabilities(self, logger):\n if not self.model_trained:\n return\n\n pool_idx = get_pool_idx(self.X, self.train_idx)\n\n # Log the probabilities of samples in the pool being included.\n pred_proba = self.query_kwargs.get('pred_proba', np.array([]))\n if len(pred_proba) == 0:\n pred_proba = self.learner.predict_proba(self.X)\n proba_1 = np.array([x[1] for x in pred_proba])\n logger.add_proba(pool_idx, self.train_idx, proba_1, self.query_i)","def logloss_mc(y_true, y_prob, epsilon=1e-15):\n # normalize\n y_prob = y_prob / y_prob.sum(axis=1).reshape(-1, 1)\n y_prob = np.maximum(epsilon, y_prob)\n y_prob = np.minimum(1 - epsilon, y_prob)\n # get probabilities\n y = [y_prob[i, j] for (i, j) in enumerate(y_true)]\n ll = - np.mean(np.log(y))\n return ll","def sentence_logprob(self, sentence):\n line = get_ngrams(sentence,3)\n log_por = 0.0\n for item in line:\n raw_por = self.smoothed_trigram_probability(item)\n log_por = log_por+math.log2(raw_por)\n\n return float(log_por)","def prob_to_llre(meth_prob):\n return math.log((meth_prob + EPSLONG) / (1 - meth_prob + EPSLONG))","def logprobs(self, inputs, max_decode_len, seled_idxes):\n\n (encoder_hx, encoder_cx) = self.encoder.enc_init_state\n encoder_hx = encoder_hx.unsqueeze(0).repeat(\n inputs.size(1), 1).unsqueeze(0)\n encoder_cx = encoder_cx.unsqueeze(0).repeat(\n inputs.size(1), 1).unsqueeze(0)\n\n enc_h, (enc_h_t, enc_c_t) = self.encoder(\n inputs, (encoder_hx, encoder_cx))\n\n dec_init_state = (enc_h_t[-1], enc_c_t[-1])\n\n decoder_input = self.decoder_in_0.unsqueeze(\n 0).repeat(inputs.size(1), 1)\n\n (pointer_probs, probs), _ = self.decoder.logprobs(\n decoder_input, inputs, dec_init_state,\n enc_h, max_decode_len, seled_idxes\n )\n logprob = self._prob_to_logp(probs)\n\n pointer_probs_list = [pointer_prob.cpu().detach()\n for pointer_prob in pointer_probs]\n return pointer_probs_list, logprob","def print_log_probs(expt, outstr=sys.stdout):\n if isinstance(expt, str):\n expt = get_experiment(expt)\n\n results = collect_log_probs(expt)\n\n for it, avg in sorted(results.keys()):\n r = results[it, avg]\n\n if avg:\n print >> outstr, 'Iteration {} (averaged)'.format(it)\n else:\n print >> outstr, 'Iteration {}'.format(it)\n print >> outstr, 'Train log-likelihood: {:1.3f}'.format(r.train_logprob())\n if hasattr(r, 'train_logprob_interval'):\n print >> outstr, ' CI: [{:1.3f}, {:1.3f}]'.format(*r.train_logprob_interval())\n\n try:\n print >> outstr, 'Moment matching objective: {:1.3f}'.format(r.moment_matching_objective())\n if hasattr(r, 'moment_matching_objective_interval'):\n print >> outstr, ' CI: [{:1.3f}, {:1.3f}]'.format(*r.moment_matching_objective_interval())\n except:\n pass\n\n print >> outstr","def kl_div_label_smoothing(logits, label_smoothing_prob,\n distribution='uniform', size_average=False):\n batch_size, label_num, num_classes = logits.size()\n if distribution == 'uniform':\n dist = Variable(torch.FloatTensor(\n batch_size, label_num, num_classes).fill_(1 / num_classes * label_smoothing_prob))\n elif distribution == 'normal':\n raise NotImplementedError\n else:\n raise NotImplementedError\n\n if logits.is_cuda:\n dist = dist.cuda()\n\n kl_loss = F.kl_div(F.softmax(logits, dim=-1), dist,\n size_average=False, reduce=True)\n # kl_loss = F.kl_div(F.log_softmax(logits, dim=-1), torch.log(dist),\n # size_average=False, reduce=True)\n # TODO: compute at log-space?\n\n if size_average:\n kl_loss /= batch_size\n\n return kl_loss","def __convert_to_log(self):\n for i in range(self.nStates):\n if self.pi[i]>0:\n self.pi[i]=log(self.pi[i])\n else:\n self.pi[i]=float('-inf')\n for j in range(self.nStates):\n if self.t[i][j]>0:\n self.t[i][j]=log(self.t[i][j])\n else:\n self.t[i][j]=float('-inf')\n for j in range(self.nObs):\n if self.e[i][j]>0:\n self.e[i][j]=log(self.e[i][j])\n else:\n self.e[i][j]=float('-inf')\n self.logdomain=True","def get_ngramlogprobs(freqdict):\n return","def nce_logprobs(self, logit_target_in_model, logit_noise_in_model, logit_noise_in_noise, logit_target_in_noise):\n\n # NOTE: prob <= 1 is not guaranteed\n logit_model = torch.cat([logit_target_in_model.unsqueeze(2), logit_noise_in_model], dim=2)\n logit_noise = torch.cat([logit_target_in_noise.unsqueeze(2), logit_noise_in_noise], dim=2)\n\n # predicted probability of the word comes from true data distribution\n # The posterior can be computed as following\n # p_true = logit_model.exp() / (logit_model.exp() + self.noise_ratio * logit_noise.exp())\n # For numeric stability we compute the logits of true label and\n # directly use bce_with_logits.\n # Ref https://pytorch.org/docs/stable/nn.html?highlight=bce#torch.nn.BCEWithLogitsLoss\n #logit_true = logit_model - logit_noise - math.log(self.noise_ratio)\n p_true = logit_model.exp() / (logit_model.exp() + self.noise_ratio * logit_noise.exp())\n \n label = torch.zeros_like(logit_model)\n label[:, :, 0] = 1\n\n #logprobs = -self.bce_with_logits(logit_true, label)\n logprobs = -nn.BCELoss(reduction='none')(p_true, label)\n logprobs = torch.sum(logprobs.view(logprobs.size(0), -1), dim=1)\n \n return logprobs","def loss_with_kl_constraint(avg_probs, current_log_probs,\n model, original_loss, delta, optimizer, args):\n\n # Compute g: a direction to minimize the original loss\n optimizer.zero_grad()\n original_loss.backward(retain_graph=True)\n g = [Variable(p.grad.data.clone()) if p.grad is not None else Variable(torch.zeros(1)) for p in model.parameters()]\n\n # Compute k: a direction to increase KL div.\n optimizer.zero_grad()\n kl = kl_div(avg_probs, current_log_probs, args)\n (-kl).backward(retain_graph=True)\n k = [Variable(p.grad.data.clone()) if p.grad is not None else Variable(torch.zeros(1)) for p in model.parameters()]\n\n optimizer.zero_grad()\n\n kg_dot = sum(torch.sum(k_p * g_p) for k_p, g_p in zip(k, g))\n kk_dot = sum(torch.sum(k_p ** 2) for k_p in k)\n\n if kk_dot.data.numpy()[0] > 0:\n k_factor = torch.clamp((kg_dot-delta)/kk_dot, min=0)\n else:\n k_factor = Variable(torch.zeros(1))\n\n z = [gp - k_factor.expand_as(kp) * kp for kp, gp in zip(k, g)]\n loss = 0\n\n for p, zp in zip(model.parameters(), z):\n if p.size() == zp.size():\n loss += torch.sum(p * zp)\n return loss, kl.data","def log_prob(self, value, avg=False):\n value = self._validate_sample(value, avg)\n\n # Unsqueeze the parameters at location -2 to allow for an arbitrary\n # number of sample locations.\n tmp_f = (self.f_avg if avg else self.f).unsqueeze(-2)\n tmp_alpha = (self.alpha_avg if avg else self.alpha).unsqueeze(-2)\n tmp_beta = (self.beta_avg if avg else self.beta).unsqueeze(-2)\n tmp_Z = (self.Z_avg if avg else self.Z).unsqueeze(-1)\n\n res = value - tmp_f\n assert res.shape[-1] == self.N\n ll_terms = -(res) * t.where(res > 0, tmp_alpha, -tmp_beta)\n lls = ll_terms.sum(-1) - t.log(tmp_Z)\n return lls","def prob_to_llr2(prob):\n return math.log2((prob + EPSLONG) / (1 - prob + EPSLONG))","def predict_log_proba(self, X):\n X = _validate_X(X)\n return self.best_estimator_.predict_log_proba(X)","def log_prob(self):\n res = -self.L_h/2*np.log(2*np.pi*self.la)\n res = res + self.L_h*(self.L_h-1)/2*self.a\n\n\n res = res - 1/(2*self.la)*np.square(np.linalg.norm(self.e*self.pie))\n\n res = res - 1/(2*self.la)*np.sum(self.e2*self.pie_var)\n\n res = res - self.L_h/2*np.log(2*np.pi*self.sigma2)\n res = res - 1/(2*self.sigma2)*(np.square(np.linalg.norm(self.w))+np.trace(self.R))\n\n print(\"Log-probability difference = {}\".format(res - self.LP), file=self.logfile)\n self.LP = res\n return res","def log_prob(self, x):\n z, log_det = self.backward_p(x)\n return self.prior.log_prob(z) + log_det","def predict_log_proba(self, X):\n self._check_is_fitted('predict_log_proba')\n return self.best_estimator_.predict_log_proba(X)","def log_gamma_unnormalised_lpdf(x, alpha, beta):\n return alpha * x - beta * tf.exp(x)","def sentence_logprob(self, sentence):\n grams = get_ngrams(sentence, 3)\n p = 1\n\n for gram in grams:\n p *= np.longfloat(self.smoothed_trigram_probability(gram))\n\n return np.log2(p)","def prob_logit(x):\n try:\n if len(x.shape) != 1:\n raise ValueError(\"unexpected shape of input vector\\nexpected:\" + str(1) + \", actual: \" + str(len(x.shape)))\n except ValueError as e:\n print(e)\n print()\n raise\n\n x = 1.0 * np.exp(-x)\n\n probability = np.concatenate(\n (\n (x / (1.0 + x)).reshape(x.shape[0], 1),\n (1.0 / (1.0 + x)).reshape(x.shape[0], 1)\n ),\n axis=1\n )\n\n return probability","def log_prob(self, th):\n\n\t\tmask = self.__low <= th <= self.__high\n\t\tif len(th.shape) == 1:\n\t\t\tlength = 1\n\t\telif len(th.shape) == 2:\n\t\t\tlength = th.shape[0]\n\t\telse:\n\t\t\traise RuntimeError(\"th must be either (d,) or (n_samples, d)\")\n\t\tlogprobs = np.empty(length)\n\t\tlogprobs[mask] = 0.\n\t\tlogprobs[~mask] = -float('inf')\n\t\treturn logprobs","def log_prob_from_logits(x):\n axis = len(x.get_shape()) - 1\n m = tf.reduce_max(x, axis, keep_dims=True)\n return x - m - tf.log(tf.reduce_sum(tf.exp(x - m), axis, keep_dims=True))","def kl_divergence(self, logits_q, logits_p):\n return (torch.exp(logits_q) * (logits_q - logits_p)).sum(1, keepdim=True)","def prior(training_data, label_list):\n\n smooth = 1 # smoothing factor\n logprob = {}\n # TODO: add your code here\n numfile1 = 0\n numfile2 = 0\n for dic in training_data:\n if(dic[\"label\"] == label_list[0]):\n numfile1 += 1\n elif(dic[\"label\"] == label_list[1]):\n numfile2 += 1\n numtotal = numfile1 + numfile2\n\n prob1 = (numfile1+smooth)/(numtotal+2)\n prob2 = (numfile2 + smooth) / (numtotal + 2)\n\n logprob[label_list[0]] = math.log(prob1)\n logprob[label_list[1]] = math.log(prob2)\n\n\n return logprob","def logit_to_prob(logits: Tensor, criterion):\n logits = logits.detach()\n\n if logits.size(1) == 2:\n # return logits.softmax()[:, 0:1, ...] # Take probabilities of the first class (salt)\n return logits.argmax(dim=1).float()\n elif logits.size(1) == 1:\n if isinstance(criterion, LovaszHingeLoss) or criterion == 'lovasz':\n return (logits > 0).float()\n else:\n return logits.sigmoid()\n\n raise ValueError('Unsupported number of channels')","def logloss_mc(y_true, y_prob, epsilon=10e-15):\r\n # normalize\r\n y_prob = y_prob / y_prob.sum(axis=1).reshape(-1, 1)\r\n print 'y_prob: ' + str(y_prob[1])\r\n print 'y_true: ' + str(y_true[1])\r\n y_prob = np.maximum(epsilon, y_prob)\r\n y_prob = np.minimum(1 - epsilon, y_prob)\r\n print 'y_prob: ' + str(y_prob[1])\r\n print 'y_true: ' + str(y_true[1])\r\n # get probabilities\r\n y = [y_prob[i, j] for (i, j) in enumerate(y_true)]\r\n print 'y: ' + str(y[1])\r\n print 'y_true: ' + str(y_true[1])\r\n ll = - np.mean(np.log(y))\r\n return ll","def gmmloglik(log_emlik, weights):\n N,_ = log_emlik.shape;\n ll = 0;\n for i in range(N):\n ll += logsumexp(log_emlik[i, :] + np.log(weights));\n return ll","def calculateLogJointProbabilities(self, datum):\n\tlogJoint = util.Counter()\n\t#want to calculate log(P(y)) + log(sum(P(fi|y)))\n\t#where y is a label\n\tfor label in self.legalLabels:\n\t\tlogJoint[label] = math.log(self.prior_distribution_prob[label])\n\t\tfor feature, value in datum.items():\n\t\t\tcp = self.conditional_prob[label][feature][value]\n\t\t\tif cp > 0: #condition check for values < 0 because log(0) is undefined and math domain error occurs\n\t\t\t\tlogJoint[label] += math.log(cp) #summing up\n\t\t\t\t\n\treturn logJoint","def log_prob(self, x_scaled):\n predictions = self.likelihood(x_scaled)\n # this function transform the gp mean back to \"real\" space\n mean_with_negatives = scale_inverse_transform(self.y_scaler, predictions[0])\n # this function replaces negative numbers with zero\n mean = tf.nn.relu(mean_with_negatives)\n log_mean = tf.math.log(mean)\n tensor_log_prior = self.log_prior(x_scaled)\n prob = tf.reshape(log_mean, shape=tensor_log_prior.shape) + tensor_log_prior\n return prob","def predict_log_likelihood_ratio(self, X):\n Xs = self.scaler.transform(X)\n class_probs = np.maximum(self.model.predict_proba(Xs)[:, 1], self.class_min)\n return np.log(class_probs / (1 - class_probs))","def get_log_prob(self, latent, obs):\n return self.get_log_prob_from_latent_dist(self.get_latent_dist(obs), latent)","def _logprobratio(prob1, prob2):\n return log(prob1) / log(prob2)","def _compute_log_type_probabilities(df, optim_paras, options):\n x_betas = _compute_x_beta_for_type_probabilities(\n df, optim_paras=optim_paras, options=options\n )\n\n log_probabilities = x_betas - special.logsumexp(x_betas, axis=1, keepdims=True)\n log_probabilities = np.clip(log_probabilities, MIN_FLOAT, MAX_FLOAT)\n\n return log_probabilities","def sampled_softmax_logprobs(self, logit_target_in_model, logit_noise_in_model, logit_noise_in_noise, logit_target_in_noise):\n logits = torch.cat([logit_target_in_model.unsqueeze(2), logit_noise_in_model], dim=2)\n q_logits = torch.cat([logit_target_in_noise.unsqueeze(2), logit_noise_in_noise], dim=2)\n # subtract Q for correction of biased sampling\n logits = logits - q_logits\n logproba = torch.nn.LogSoftmax(dim=-1)(logits)\n \n labels = torch.zeros_like(logits.narrow(2, 0, 1)).squeeze(2).long()\n \n logprobs = -torch.nn.NLLLoss(reduction='none')(logproba.view(-1, logproba.size(-1)), labels.view(-1)).view_as(labels)\n logprobs = torch.sum(logprobs, dim=1)\n \n return logprobs","def GSM_log_likelihood(X, model):\n D, M = X.shape\n k = model.mix.shape[0]\n log_likelihood = 0\n for i in range(M):\n logpdf_X = 0\n for j in range(k):\n mvn = multivariate_normal(cov=model.cov[j, :])\n logpdf_X = mvn.logpdf(x=X[:, i]) * model.mix[j]\n log_likelihood += logpdf_X\n return log_likelihood","def calc_entropy_tuning_loss(self, log_probs):\n with torch.no_grad():\n inner_prod = (log_probs + self.target_entropy).detach()\n alpha_loss = -(self.log_alpha * inner_prod).mean()\n return alpha_loss","def m_probs(self):\n log_m = self.kernel.feature_log_prob_[self._match_class_pos()]\n\n return self._prob_inverse_transform(numpy.exp(log_m))","def log_prob(self, scores : torch.Tensor, permutations):\n s = torch.log(select_indices(scores, permutations))\n n = len(scores)\n p = self.upto if self.upto is not None else n - 1\n return -sum(\n torch.log(torch.exp((s[k:] - s[k]) * self.shape).sum(dim=0))\n for k in range(p))","def _normal_log_prob(self, r, scale_log):\n return -(r**2) / 2 - scale_log - self.const","def log_prob_from_logits(x):\n axis = len(x.get_shape())-1\n m = tf.reduce_max(x, axis, keep_dims=True)\n return x - m - tf.log(tf.reduce_sum(tf.exp(x-m), axis, keep_dims=True))","def KLDiv(P, Q):\n divergence = 0.0\n sump, sumq = float(sum(P)), float(sum(Q))\n probP, probQ = [float(p)/sump for p in P], [float(q)/sumq for q in Q]\n\n for i in xrange(len(probP)):\n if probP[i] < Params.PRECISION or probQ[i] < Params.PRECISION: continue\n divergence += probP[i] * math.log(probP[i]/probQ[i], Params.base)\n return divergence","def compute_log_probs(self, phrases, save_to_file=None):\n # Co-ocurrence for source and target phrase\n tgt_src_cnt = defaultdict(lambda: defaultdict(int))\n \n # ocurrence for target (English)\n tgt_cnt = defaultdict(int)\n\n # Compute frequency and co-occurence\n for phrase_pair in phrases:\n\n assert len(phrase_pair) == 2\n src_p, tgt_p = phrase_pair\n # defaultdict[target_phrase][source_phrase]\n tgt_src_cnt[tgt_p][src_p]+=1\n # defaultdict[target_phrase]\n tgt_cnt[tgt_p]+=1\n\n\n # Calculate log prob of translation model p(f|e)\n log_prob_lst = list()\n for tgt_phrase in tgt_src_cnt:\n for src_phrase in tgt_src_cnt[tgt_phrase]:\n # count(source, target) / count(target)\n prob = float(tgt_src_cnt[tgt_phrase][src_phrase])/tgt_cnt[tgt_phrase]\n log_prob = math.log(prob)\n\n log_prob_str = f\"{src_phrase} ||| {tgt_phrase} ||| {str(log_prob)}\"\n log_prob_lst.append(log_prob_str)\n \n # Save to file \n if save_to_file is not None:\n with Path(save_to_file).open(\"w\") as wf:\n wf.write('\\n'.join(log_prob_lst))\n sys.stdout.write(f\"Saving phrase log probability file to path: {save_to_file}.\\n\")\n \n # List of log probability for phrase pair\n return log_prob_lst","def logprob(self, word, context):\n\n return -log(self.prob(word, context), 2)","def predict_log_proba(self, X: np.ndarray) -> np.ndarray:\n\n self._check_input_data(X=X)\n self._check_support(X=X)\n\n if not isinstance(self.lambda_, np.ndarray):\n log_proba = stats.poisson.logpmf(X, mu=self.lambda_)\n else:\n n_samples = X.shape[0]\n n_classes = len(self.lambda_) # type: ignore\n log_proba = np.zeros((n_samples, n_classes))\n\n for cls in range(n_classes):\n log_proba[:, cls] = stats.poisson.logpmf(X, mu=self.lambda_[cls]) # type: ignore\n\n return log_proba"],"string":"[\n \"def log_probs(self):\\n return np.array([m['log_probs'] for m in self.model_outs], dtype=np.float32)\",\n \"def to_logprobs(x):\\n N = x.size(0)\\n sid_bins = x.size(1)//2\\n H, W = x.size()[-2:]\\n A = x[:, ::2, :, :].clone()\\n B = x[:, 1::2, :, :].clone()\\n\\n A = A.view(N, 1, -1)\\n B = B.view(N, 1, -1)\\n\\n C = torch.cat((A, B), dim=1)\\n # C = torch.clamp(C, min=1e-8, max=1e8) # prevent nans\\n log_ord_c = F.log_softmax(C, dim=1)\\n log_ord_c0 = log_ord_c[:, 0, :].clone()\\n log_ord_c0 = log_ord_c0.view(-1, sid_bins, H, W)\\n log_ord_c1 = log_ord_c[:, 1, :].clone()\\n log_ord_c1 = log_ord_c1.view(-1, sid_bins, H, W)\\n return log_ord_c0, log_ord_c1\",\n \"def _update_logprobs(self):\\n #self._logp_src = self._log_lim(self.p_source)\\n self._logp_I0 = self._log_lim(self.p_source)\\n self._logp_R0 = self._log_lim(self.p_source/(self.p_rec_div))\\n self._logp_S_fin = self._log_lim(self.p_S_fin)\\n self._logp_inf_fin = self._log_lim(self.p_infect_fin)\",\n \"def logprob(predictions, labels):\\n # prevent negative probability\\n predictions[predictions < 1e-10] = 1e-10\\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]\",\n \"def setLogprobs(self, value):\\n return self._set(logprobs=value)\",\n \"def logprob(predictions, labels):\\n predictions[predictions < 1e-10] = 1e-10\\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]\",\n \"def logprob(predictions, labels):\\n predictions[predictions < 1e-10] = 1e-10\\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]\",\n \"def nll_logprobs(self, input, target_idx):\\n raise NotImplementedError()\",\n \"def logits_to_log_prob(self, logits):\\n\\n reduction_indices = len(logits.shape.as_list()) - 1\\n max_logits = tf.math.reduce_max(\\n logits, axis=reduction_indices, keepdims=True)\\n safe_logits = tf.subtract(logits, max_logits)\\n sum_exp = tf.math.reduce_sum(\\n tf.exp(safe_logits), axis=reduction_indices, keepdims=True)\\n log_probs = tf.math.subtract(safe_logits, tf.math.log(sum_exp))\\n return log_probs\",\n \"def logprob(predictions, labels):\\n predictions[predictions < 1e-10] = 1e-10\\n return np.sum(np.multiply(labels, -np.log(predictions)))\",\n \"def log_prob(self):\",\n \"def __logprob__(self, cv, vsense):\\n return 1.0 / (1.0 + np.exp(-np.dot(cv, vsense)))\",\n \"def relative_probs_from_log_probs(log_probs):\\n probs = np.exp(log_probs - log_probs.mean())\\n assert not np.any(probs <= 0), 'choose a smaller power'\\n return probs\",\n \"def _calculate_batched_logprob(self, mu, std, x):\\n # Set up lower bound of std, since zero std can lead to NaN log-probability\\n # Used for: torch.clamp(std_i, min=min_std...)\\n # min_std = 1e-12\\n \\n log_probs = []\\n \\n # Iterate over all density components\\n for i in range(self.num_densities):\\n # Retrieve means and stds\\n mu_i = mu[:, i, :]\\n std_i = std[:, i, :]\\n # Thresholding std, if std is 0, it leads to NaN loss. \\n # std_i = torch.clamp(std_i, min=min_std, max=std_i.max().item())\\n # Create Gaussian distribution\\n dist = Normal(loc=mu_i, scale=std_i)\\n # Calculate the log-probability\\n logp = dist.log_prob(x)\\n # Record the log probability for current density\\n log_probs.append(logp)\\n \\n # Stack log-probabilities with shape [N, K, D]\\n log_probs = torch.stack(log_probs, dim=1)\\n \\n return log_probs\",\n \"def predict_log_proba(self, X: np.ndarray) -> np.ndarray:\\n\\n self._check_input_data(X=X)\\n self._check_support(X=X, k=self.k)\\n\\n if self.prob.ndim == 1:\\n log_proba = stats.multinomial.logpmf(\\n to_categorical(X, num_classes=self.k), n=1, p=self.prob\\n )\\n else:\\n n_samples = X.shape[0]\\n n_classes = len(self.prob) # type: ignore\\n log_proba = np.zeros((n_samples, n_classes))\\n\\n for cls in range(n_classes):\\n log_proba[:, cls] = stats.multinomial.logpmf(\\n to_categorical(X, num_classes=self.k), n=1, p=self.prob[cls]\\n ) # type: ignore\\n\\n return log_proba\",\n \"def kl_divergence_bern_bern(z_pres_logits, prior_pres_prob, eps=1e-15):\\n z_pres_probs = torch.sigmoid(z_pres_logits)\\n kl = z_pres_probs * (torch.log(z_pres_probs + eps) - torch.log(prior_pres_prob + eps)) + \\\\\\n (1 - z_pres_probs) * (torch.log(1 - z_pres_probs + eps) - torch.log(1 - prior_pres_prob + eps))\\n\\n return kl\",\n \"def log_m_probs(self):\\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n return self._prob_inverse_transform(m)\",\n \"def _logprob_X(self, X, **kwargs):\\n pass\",\n \"def predict_log_proba(self, X):\\n proba = self.predict_proba(X)\\n return np.log(proba)\",\n \"def log_prob_easier(self, x):\\n normalization_const = -0.5 * tf.math.log(2 * np.pi) - tf.math.log(self.stddev)\\n sq_term = - 0.5 * ((x - self.mean) / self.stddev) ** 2\\n l_prob = tf.math.reduce_sum(normalization_const + sq_term, axis=1)\\n return l_prob\",\n \"def get_normalized_probs(self, net_output, log_probs):\\n logits = net_output\\n if log_probs:\\n return F.log_softmax(logits, dim=1)\\n else:\\n return F.softmax(logits, dim=1)\",\n \"def predict_log_proba(self, X):\\n proba = self.predict_proba(X)\\n\\n if self.n_outputs_ == 1:\\n return np.log(proba)\\n\\n else:\\n for k in range(self.n_outputs_):\\n proba[k] = np.log(proba[k])\\n\\n return proba\",\n \"def log_prob(sentence, LM, smoothing=False, delta=0, vocabSize=0):\\n word_list = sentence.split()\\n log_prob = 0\\n for i in range(len(word_list)-1):\\n print(word_list[i], word_list[i+1])\\n bi_count = LM['bi'][word_list[i]][word_list[i+1]]\\n uni_count = LM['uni'][word_list[i]]\\n if uni_count == 0 and smoothing:\\n return float('-inf')\\n log_prob += log(((bi_count + delta)/(uni_count + delta * vocabSize)))\\n return log_prob\",\n \"def predict_log_proba(self, X):\\n proba = self.predict_proba(X)\\n\\n if self.n_outputs_ == 1:\\n return np.log(proba)\\n\\n else:\\n for k in xrange(self.n_outputs_):\\n proba[k] = np.log(proba[k])\\n\\n return proba\",\n \"def predict_log_proba(self, X: np.ndarray) -> np.ndarray:\\n\\n self._check_input_data(X=X)\\n self._check_support(X=X)\\n\\n if not isinstance(self.prob, np.ndarray):\\n log_proba = stats.bernoulli.logpmf(X, p=self.prob)\\n else:\\n n_samples = X.shape[0]\\n n_classes = len(self.prob) # type: ignore\\n log_proba = np.zeros((n_samples, n_classes))\\n\\n for cls in range(n_classes):\\n log_proba[:, cls] = stats.bernoulli.logpmf(X, p=self.prob[cls]) # type: ignore\\n\\n return log_proba\",\n \"def get_KL_divergence(self):\\n KL_loss_W = Vil.get_KL_divergence_Samples(self.mu_weight, Vil.softplus(self.rho_weight), self.weight, self.prior)\\n KL_loss_b = 0\\n if self.bias is not None:\\n KL_loss_b = Vil.get_KL_divergence_Samples(self.mu_bias, Vil.softplus(self.rho_bias), self.bias, self.prior)\\n \\n KL_loss = KL_loss_W + KL_loss_b\\n \\n return KL_loss\",\n \"def log_u_probs(self):\\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\\n return self._prob_inverse_transform(u)\",\n \"def KL(P,Q):\\n epsilon = 0.00001\\n \\n #You may want to instead make copies to avoid changing the np arrays.\\n P = P+epsilon\\n Q = Q+epsilon\\n \\n divergence = np.sum(P*np.log(P/Q))\\n return divergence\",\n \"def h(self, probs):\\n\\n return np.sum(-p*np.log2(p) if p > 0 else 0 for p in np.nditer(probs))\",\n \"def BernoulliGaussianLoss(mu_kl, log_var_kl) :\\n def bgl(x, p) :\\n N = K.int_shape(p)[1]\\n recon = N*metrics.binary_crossentropy(x, p)\\n dkl = -0.5 * K.sum(-K.exp(log_var_kl) - K.square(mu_kl) + 1. + log_var_kl, axis=-1)\\n return dkl + recon\\n return bgl\",\n \"def kl_divergence(mu, logvar):\\n klds = -0.5*(1 + logvar - mu.pow(2) - logvar.exp())\\n total_kld = klds.sum(1).mean(0, True)\\n dimension_wise_kld = klds.mean(0)\\n mean_kld = klds.mean(1).mean(0, True)\\n\\n return total_kld, dimension_wise_kld, mean_kld\",\n \"def _logp(self, trace, **inputs):\\n def calc_log(step):\\n exp_pred = np.dot(inputs['gwas_gen'],\\n step['beta_med'].T).ravel()\\n phen_pred = step['alpha'] * exp_pred\\n phen_prob = norm.logpdf(x=inputs['gwas_phen'],\\n loc=phen_pred,\\n scale=step['phenotype_sigma'])\\n return phen_prob\\n\\n phen_probs = [calc_log(trace[idx])\\n for idx in np.random.randint(0, len(self.trace), 500)]\\n phen_probs = np.asmatrix(phen_probs)\\n mc_logp = phen_probs.sum(axis=1).mean()\\n return mc_logp\",\n \"def log_prob_from_logits(x):\\n axis = len(x.shape) - 1\\n m = x.max(dim=axis, keepdim=True)[0]\\n return x - m - torch.log(torch.exp(x - m).sum(dim=axis, keepdim=True))\",\n \"def _graph_fn_get_distribution_log_probs(self, key, parameters, actions):\\n # For bounded continuous action spaces, need to unscale (0.0 to 1.0 for beta distribution).\\n if self.bounded_action_space[key] is True:\\n actions = (actions - self.action_space.low) / (self.action_space.high - self.action_space.low)\\n return self.distributions[key].log_prob(parameters, actions)\",\n \"def logpdf(self, X, pool=None):\\n logpdfs = []\\n for logweight, space, kde in zip(self._logweights,\\n self._spaces,\\n self._kdes):\\n # Calculate the probability for each parameter space individually\\n if np.all(space == ~X.mask) and np.isfinite(logweight):\\n logpdfs.append(logweight + kde(X[space], pool=pool))\\n\\n return logsumexp(logpdfs, axis=0)\",\n \"def log_probability(self, samples):\\n pass\",\n \"def predict_log_proba(self, X: np.ndarray) -> np.ndarray:\\n\\n self._check_input_data(X=X)\\n self._check_support(X=X, n=self.n)\\n\\n if not isinstance(self.prob, np.ndarray):\\n log_proba = stats.binom.logpmf(X, n=self.n, p=self.prob)\\n else:\\n n_samples = X.shape[0]\\n n_classes = len(self.prob) # type: ignore\\n log_proba = np.zeros((n_samples, n_classes))\\n\\n for cls in range(n_classes):\\n log_proba[:, cls] = stats.binom.logpmf(X, n=self.n, p=self.prob[cls]) # type: ignore\\n\\n return log_proba\",\n \"def uncertain_logits_to_probs(logits):\\n b, n_times_d = logits.size()\\n d = 3\\n if n_times_d % d:\\n raise ValueError('Expected logits dimension to be divisible by {}, got size {}.'.format(d, n_times_d))\\n n = n_times_d // d\\n\\n logits = logits.view(b, n, d)\\n probs = F.softmax(logits[:, :, 1:], dim=-1)\\n probs = probs[:, :, 1]\\n\\n return probs\",\n \"def log_likelihood(data, probs):\\n # Assume data is given as counts\\n return _np.sum([nlogp(n, p) for n, p in zip(data, probs) if n > 0])\",\n \"def predict_log_proba(self, X: np.ndarray) -> np.ndarray:\\n\\n self._check_input_data(X=X)\\n self._check_support(X=X)\\n\\n if not isinstance(self.prob, np.ndarray):\\n log_proba = stats.geom.logpmf(X, p=self.prob)\\n else:\\n n_samples = X.shape[0]\\n n_classes = len(self.prob) # type: ignore\\n log_proba = np.zeros((n_samples, n_classes))\\n\\n for cls in range(n_classes):\\n log_proba[:, cls] = stats.geom.logpmf(X, p=self.prob[cls]) # type: ignore\\n\\n return log_proba\",\n \"def log_loss(self):\\n probabilities = self.probability_array().copy()\\n # need to flip the probabilities for p < 0.5 with this binary case.\\n # 1 - old_val is same as oldval*-1 + 1. Do in 2 steps:\\n probabilities[np.equal(0, self.y)] *= -1\\n probabilities[np.equal(0, self.y)] += 1\\n # when multiclass: np.amax(probabilities, 1)\\n return np.log(probabilities).sum()\",\n \"def log_prob(self, sents):\\n log_prob = 0\\n for sent in sents:\\n log_prob += self.sent_log_prob(sent)\\n return log_prob\",\n \"def kl_divergence(means: Tensor, logvars: Tensor) ->Tensor:\\n kl_cost = -0.5 * (logvars - means ** 2 - torch.exp(logvars) + 1.0)\\n kl_cost = torch.mean(kl_cost, 0)\\n return torch.sum(kl_cost)\",\n \"def compute_log_prob(self,params: ndarray) -> float:\\n return self.compute_log_prior(params) + self.compute_log_likelihood(params)\",\n \"def calc_probs(log_p):\\n\\n N = log_p.shape[0]\\n\\n log_Z_per_N = np.zeros(shape=(N, 1))\\n\\n for i in range(N):\\n\\n log_Z_per_N[i] = log_norm(log_p[i])\\n\\n log_p_new = log_p - log_Z_per_N\\n\\n p = np.exp(log_p_new)\\n\\n # log_Z = log_norm(log_p)\\n\\n # p = np.exp(log_p - log_Z)\\n\\n return p\",\n \"def gmmloglik(log_emlik, weights):\",\n \"def gmmloglik(log_emlik, weights):\",\n \"def compute_KL_divergence_from_logits(logits_p, logits_q, mask):\\r\\n #suppose p and q are both tensors with shape [batch, seq_len, #class]\\r\\n #suppose mask is a tensor with shape [batch, seq_len]\\r\\n p = tf.nn.softmax(logits_p)\\r\\n q = tf.nn.softmax(logits_q)\\r\\n mask = tf.expand_dims(mask, -1)\\r\\n total_kl = mask*p*tf.log(p/q)\\r\\n return tf.reduce_mean(total_kl)\",\n \"def log_prob(self, th):\\n\\n\\t\\tif len(th.shape) == 2:\\n\\t\\t\\tth0, th1 = th[:,0], th[:,1]\\n\\t\\t\\tmask = (th0 > 0.) * (th1 > 0.)\\n\\t\\telif len(th.shape) == 1:\\n\\t\\t\\tth0, th1 = float(th[0]), float(th[1])\\n\\t\\t\\tmask = torch.tensor([th0 > 0., th1 > 0.])\\n\\t\\telse:\\n\\t\\t\\traise IndexError(\\\"This class is only for 2D Gamma prior for GSE model\\\")\\n\\t\\tth0, th1 = torch.as_tensor(th0), torch.as_tensor(th1)\\n\\t\\tvals = (self.beta_prior.log_prob(th0) + self.gamma_prior.log_prob(th1)).reshape(-1)\\n\\t\\tvals = vals.numpy()\\n\\t\\tvals[~mask] = -float('inf')\\n\\t\\treturn vals\",\n \"def log_prob(sentence, LM, smoothing=False, delta=0, vocabSize=0):\\n\\tlog_prob = 0\\n\\tdenominator = 0\\n\\tnumerator = 0\\n\\tword_list = sentence.split()\\n\\tlength_w = len(word_list) -1\\n\\tfor i in range(length_w):\\n\\t\\tword = word_list[i]\\n\\t\\tif word in LM['uni'].keys():\\n\\t\\t\\tdenominator = LM['uni'][word]\\n\\t\\telse:\\n\\t\\t\\tdenominator = 0\\n\\t\\tnext_word = word_list[i+1]\\n\\t\\tif word in LM['bi'].keys() and next_word in LM['bi'][word].keys():\\n\\t\\t\\tnumerator = LM['bi'][word][next_word]\\n\\t\\telse:\\n\\t\\t\\tnumerator = 0\\n\\t\\t# case when numerator/denominator = 0/0 and if it is not smoothing the log_prob will be -infinite\\n\\t\\tif (numerator == 0 or denominator == 0) and (not smoothing):\\n\\t\\t\\treturn float('-inf')\\n\\t\\telse:\\n\\t\\t\\tnumerator += delta\\n\\t\\t\\tdenominator += delta*vocabSize\\n\\t\\t\\tprob = (numerator) / (denominator)\\n\\t\\t\\tlog_prob+= log(prob, 2)\\n\\treturn log_prob\",\n \"def get_normalized_probs(self, net_output, log_probs, sample=None):\\n encoder_out = net_output[\\\"encoder_out\\\"]\\n if torch.is_tensor(encoder_out):\\n logits = encoder_out.float()\\n if log_probs:\\n return F.log_softmax(logits, dim=-1)\\n else:\\n return F.softmax(logits, dim=-1)\\n raise NotImplementedError\",\n \"def get_log_prob(self, X, target=None):\\n\\n # We don't support the target argument for now.\\n assert target is None\\n\\n batch_size, seq_len, dim = X.size()\\n X = X.contiguous().view(-1, dim)\\n\\n head_y = self.head(X)\\n # log_probs = head_y.new_zeros(X.size(0), self.vocab_size)\\n\\n head_size = self.cutoff[0] + len(self.tail)\\n head_log_probs = self.lsm(head_y)\\n log_probs_list = [head_log_probs[:, :self.cutoff[0]]]\\n\\n if len(self.tail) > 0:\\n tail_priors = head_log_probs[:, self.cutoff[0]:head_size]\\n\\n for i in range(len(self.tail)):\\n tail_i = self.lsm(self.tail[i](X))\\n tail_i = tail_i + tail_priors[:, i, None]\\n log_probs_list.append(tail_i)\\n\\n log_probs = torch.cat(log_probs_list, dim=1)\\n log_probs = log_probs.view(batch_size, seq_len, self.vocab_size)\\n return log_probs\",\n \"def _LL(state, effects, observed_frequencies) -> float:\\n observed_frequencies = np.array(observed_frequencies)\\n predicted_probs = np.array([np.real(np.trace(state.dot(effect))) for effect in effects])\\n return sum(np.log10(predicted_probs) * observed_frequencies)\",\n \"def log_poisson(k, l):\\n return k*np.log(l) -l - gammaln(k+1)\",\n \"def _kl_divergence(p, p_logits, q):\\n for tensor in [p, p_logits, q]:\\n if not tensor.dtype.is_floating:\\n raise ValueError('Input %s must be floating type.', tensor.name)\\n p.shape.assert_has_rank(2)\\n p_logits.shape.assert_has_rank(2)\\n q.shape.assert_has_rank(1)\\n return math_ops.reduce_sum(\\n p * (nn_ops.log_softmax(p_logits) - math_ops.log(q)), axis=1)\",\n \"def logdprior(parameters, hyperparameters):\\n sigma_w_part = parameters[0] + invgamma_logpdf(parameters[0],\\n hyperparameters[\\\"sigma_w_shape\\\"], hyperparameters[\\\"sigma_w_scale\\\"])\\n sigma_v_part = parameters[1] + invgamma_logpdf(parameters[1], hyperparameters[\\\"sigma_v_shape\\\"], hyperparameters[\\\"sigma_v_scale\\\"])\\n return sigma_w_part + sigma_v_part\",\n \"def _logprob(self, sample):\\n return 0, 0\",\n \"def log_probabilities(self, logger):\\n if not self.model_trained:\\n return\\n\\n pool_idx = get_pool_idx(self.X, self.train_idx)\\n\\n # Log the probabilities of samples in the pool being included.\\n pred_proba = self.query_kwargs.get('pred_proba', np.array([]))\\n if len(pred_proba) == 0:\\n pred_proba = self.learner.predict_proba(self.X)\\n proba_1 = np.array([x[1] for x in pred_proba])\\n logger.add_proba(pool_idx, self.train_idx, proba_1, self.query_i)\",\n \"def logloss_mc(y_true, y_prob, epsilon=1e-15):\\n # normalize\\n y_prob = y_prob / y_prob.sum(axis=1).reshape(-1, 1)\\n y_prob = np.maximum(epsilon, y_prob)\\n y_prob = np.minimum(1 - epsilon, y_prob)\\n # get probabilities\\n y = [y_prob[i, j] for (i, j) in enumerate(y_true)]\\n ll = - np.mean(np.log(y))\\n return ll\",\n \"def sentence_logprob(self, sentence):\\n line = get_ngrams(sentence,3)\\n log_por = 0.0\\n for item in line:\\n raw_por = self.smoothed_trigram_probability(item)\\n log_por = log_por+math.log2(raw_por)\\n\\n return float(log_por)\",\n \"def prob_to_llre(meth_prob):\\n return math.log((meth_prob + EPSLONG) / (1 - meth_prob + EPSLONG))\",\n \"def logprobs(self, inputs, max_decode_len, seled_idxes):\\n\\n (encoder_hx, encoder_cx) = self.encoder.enc_init_state\\n encoder_hx = encoder_hx.unsqueeze(0).repeat(\\n inputs.size(1), 1).unsqueeze(0)\\n encoder_cx = encoder_cx.unsqueeze(0).repeat(\\n inputs.size(1), 1).unsqueeze(0)\\n\\n enc_h, (enc_h_t, enc_c_t) = self.encoder(\\n inputs, (encoder_hx, encoder_cx))\\n\\n dec_init_state = (enc_h_t[-1], enc_c_t[-1])\\n\\n decoder_input = self.decoder_in_0.unsqueeze(\\n 0).repeat(inputs.size(1), 1)\\n\\n (pointer_probs, probs), _ = self.decoder.logprobs(\\n decoder_input, inputs, dec_init_state,\\n enc_h, max_decode_len, seled_idxes\\n )\\n logprob = self._prob_to_logp(probs)\\n\\n pointer_probs_list = [pointer_prob.cpu().detach()\\n for pointer_prob in pointer_probs]\\n return pointer_probs_list, logprob\",\n \"def print_log_probs(expt, outstr=sys.stdout):\\n if isinstance(expt, str):\\n expt = get_experiment(expt)\\n\\n results = collect_log_probs(expt)\\n\\n for it, avg in sorted(results.keys()):\\n r = results[it, avg]\\n\\n if avg:\\n print >> outstr, 'Iteration {} (averaged)'.format(it)\\n else:\\n print >> outstr, 'Iteration {}'.format(it)\\n print >> outstr, 'Train log-likelihood: {:1.3f}'.format(r.train_logprob())\\n if hasattr(r, 'train_logprob_interval'):\\n print >> outstr, ' CI: [{:1.3f}, {:1.3f}]'.format(*r.train_logprob_interval())\\n\\n try:\\n print >> outstr, 'Moment matching objective: {:1.3f}'.format(r.moment_matching_objective())\\n if hasattr(r, 'moment_matching_objective_interval'):\\n print >> outstr, ' CI: [{:1.3f}, {:1.3f}]'.format(*r.moment_matching_objective_interval())\\n except:\\n pass\\n\\n print >> outstr\",\n \"def kl_div_label_smoothing(logits, label_smoothing_prob,\\n distribution='uniform', size_average=False):\\n batch_size, label_num, num_classes = logits.size()\\n if distribution == 'uniform':\\n dist = Variable(torch.FloatTensor(\\n batch_size, label_num, num_classes).fill_(1 / num_classes * label_smoothing_prob))\\n elif distribution == 'normal':\\n raise NotImplementedError\\n else:\\n raise NotImplementedError\\n\\n if logits.is_cuda:\\n dist = dist.cuda()\\n\\n kl_loss = F.kl_div(F.softmax(logits, dim=-1), dist,\\n size_average=False, reduce=True)\\n # kl_loss = F.kl_div(F.log_softmax(logits, dim=-1), torch.log(dist),\\n # size_average=False, reduce=True)\\n # TODO: compute at log-space?\\n\\n if size_average:\\n kl_loss /= batch_size\\n\\n return kl_loss\",\n \"def __convert_to_log(self):\\n for i in range(self.nStates):\\n if self.pi[i]>0:\\n self.pi[i]=log(self.pi[i])\\n else:\\n self.pi[i]=float('-inf')\\n for j in range(self.nStates):\\n if self.t[i][j]>0:\\n self.t[i][j]=log(self.t[i][j])\\n else:\\n self.t[i][j]=float('-inf')\\n for j in range(self.nObs):\\n if self.e[i][j]>0:\\n self.e[i][j]=log(self.e[i][j])\\n else:\\n self.e[i][j]=float('-inf')\\n self.logdomain=True\",\n \"def get_ngramlogprobs(freqdict):\\n return\",\n \"def nce_logprobs(self, logit_target_in_model, logit_noise_in_model, logit_noise_in_noise, logit_target_in_noise):\\n\\n # NOTE: prob <= 1 is not guaranteed\\n logit_model = torch.cat([logit_target_in_model.unsqueeze(2), logit_noise_in_model], dim=2)\\n logit_noise = torch.cat([logit_target_in_noise.unsqueeze(2), logit_noise_in_noise], dim=2)\\n\\n # predicted probability of the word comes from true data distribution\\n # The posterior can be computed as following\\n # p_true = logit_model.exp() / (logit_model.exp() + self.noise_ratio * logit_noise.exp())\\n # For numeric stability we compute the logits of true label and\\n # directly use bce_with_logits.\\n # Ref https://pytorch.org/docs/stable/nn.html?highlight=bce#torch.nn.BCEWithLogitsLoss\\n #logit_true = logit_model - logit_noise - math.log(self.noise_ratio)\\n p_true = logit_model.exp() / (logit_model.exp() + self.noise_ratio * logit_noise.exp())\\n \\n label = torch.zeros_like(logit_model)\\n label[:, :, 0] = 1\\n\\n #logprobs = -self.bce_with_logits(logit_true, label)\\n logprobs = -nn.BCELoss(reduction='none')(p_true, label)\\n logprobs = torch.sum(logprobs.view(logprobs.size(0), -1), dim=1)\\n \\n return logprobs\",\n \"def loss_with_kl_constraint(avg_probs, current_log_probs,\\n model, original_loss, delta, optimizer, args):\\n\\n # Compute g: a direction to minimize the original loss\\n optimizer.zero_grad()\\n original_loss.backward(retain_graph=True)\\n g = [Variable(p.grad.data.clone()) if p.grad is not None else Variable(torch.zeros(1)) for p in model.parameters()]\\n\\n # Compute k: a direction to increase KL div.\\n optimizer.zero_grad()\\n kl = kl_div(avg_probs, current_log_probs, args)\\n (-kl).backward(retain_graph=True)\\n k = [Variable(p.grad.data.clone()) if p.grad is not None else Variable(torch.zeros(1)) for p in model.parameters()]\\n\\n optimizer.zero_grad()\\n\\n kg_dot = sum(torch.sum(k_p * g_p) for k_p, g_p in zip(k, g))\\n kk_dot = sum(torch.sum(k_p ** 2) for k_p in k)\\n\\n if kk_dot.data.numpy()[0] > 0:\\n k_factor = torch.clamp((kg_dot-delta)/kk_dot, min=0)\\n else:\\n k_factor = Variable(torch.zeros(1))\\n\\n z = [gp - k_factor.expand_as(kp) * kp for kp, gp in zip(k, g)]\\n loss = 0\\n\\n for p, zp in zip(model.parameters(), z):\\n if p.size() == zp.size():\\n loss += torch.sum(p * zp)\\n return loss, kl.data\",\n \"def log_prob(self, value, avg=False):\\n value = self._validate_sample(value, avg)\\n\\n # Unsqueeze the parameters at location -2 to allow for an arbitrary\\n # number of sample locations.\\n tmp_f = (self.f_avg if avg else self.f).unsqueeze(-2)\\n tmp_alpha = (self.alpha_avg if avg else self.alpha).unsqueeze(-2)\\n tmp_beta = (self.beta_avg if avg else self.beta).unsqueeze(-2)\\n tmp_Z = (self.Z_avg if avg else self.Z).unsqueeze(-1)\\n\\n res = value - tmp_f\\n assert res.shape[-1] == self.N\\n ll_terms = -(res) * t.where(res > 0, tmp_alpha, -tmp_beta)\\n lls = ll_terms.sum(-1) - t.log(tmp_Z)\\n return lls\",\n \"def prob_to_llr2(prob):\\n return math.log2((prob + EPSLONG) / (1 - prob + EPSLONG))\",\n \"def predict_log_proba(self, X):\\n X = _validate_X(X)\\n return self.best_estimator_.predict_log_proba(X)\",\n \"def log_prob(self):\\n res = -self.L_h/2*np.log(2*np.pi*self.la)\\n res = res + self.L_h*(self.L_h-1)/2*self.a\\n\\n\\n res = res - 1/(2*self.la)*np.square(np.linalg.norm(self.e*self.pie))\\n\\n res = res - 1/(2*self.la)*np.sum(self.e2*self.pie_var)\\n\\n res = res - self.L_h/2*np.log(2*np.pi*self.sigma2)\\n res = res - 1/(2*self.sigma2)*(np.square(np.linalg.norm(self.w))+np.trace(self.R))\\n\\n print(\\\"Log-probability difference = {}\\\".format(res - self.LP), file=self.logfile)\\n self.LP = res\\n return res\",\n \"def log_prob(self, x):\\n z, log_det = self.backward_p(x)\\n return self.prior.log_prob(z) + log_det\",\n \"def predict_log_proba(self, X):\\n self._check_is_fitted('predict_log_proba')\\n return self.best_estimator_.predict_log_proba(X)\",\n \"def log_gamma_unnormalised_lpdf(x, alpha, beta):\\n return alpha * x - beta * tf.exp(x)\",\n \"def sentence_logprob(self, sentence):\\n grams = get_ngrams(sentence, 3)\\n p = 1\\n\\n for gram in grams:\\n p *= np.longfloat(self.smoothed_trigram_probability(gram))\\n\\n return np.log2(p)\",\n \"def prob_logit(x):\\n try:\\n if len(x.shape) != 1:\\n raise ValueError(\\\"unexpected shape of input vector\\\\nexpected:\\\" + str(1) + \\\", actual: \\\" + str(len(x.shape)))\\n except ValueError as e:\\n print(e)\\n print()\\n raise\\n\\n x = 1.0 * np.exp(-x)\\n\\n probability = np.concatenate(\\n (\\n (x / (1.0 + x)).reshape(x.shape[0], 1),\\n (1.0 / (1.0 + x)).reshape(x.shape[0], 1)\\n ),\\n axis=1\\n )\\n\\n return probability\",\n \"def log_prob(self, th):\\n\\n\\t\\tmask = self.__low <= th <= self.__high\\n\\t\\tif len(th.shape) == 1:\\n\\t\\t\\tlength = 1\\n\\t\\telif len(th.shape) == 2:\\n\\t\\t\\tlength = th.shape[0]\\n\\t\\telse:\\n\\t\\t\\traise RuntimeError(\\\"th must be either (d,) or (n_samples, d)\\\")\\n\\t\\tlogprobs = np.empty(length)\\n\\t\\tlogprobs[mask] = 0.\\n\\t\\tlogprobs[~mask] = -float('inf')\\n\\t\\treturn logprobs\",\n \"def log_prob_from_logits(x):\\n axis = len(x.get_shape()) - 1\\n m = tf.reduce_max(x, axis, keep_dims=True)\\n return x - m - tf.log(tf.reduce_sum(tf.exp(x - m), axis, keep_dims=True))\",\n \"def kl_divergence(self, logits_q, logits_p):\\n return (torch.exp(logits_q) * (logits_q - logits_p)).sum(1, keepdim=True)\",\n \"def prior(training_data, label_list):\\n\\n smooth = 1 # smoothing factor\\n logprob = {}\\n # TODO: add your code here\\n numfile1 = 0\\n numfile2 = 0\\n for dic in training_data:\\n if(dic[\\\"label\\\"] == label_list[0]):\\n numfile1 += 1\\n elif(dic[\\\"label\\\"] == label_list[1]):\\n numfile2 += 1\\n numtotal = numfile1 + numfile2\\n\\n prob1 = (numfile1+smooth)/(numtotal+2)\\n prob2 = (numfile2 + smooth) / (numtotal + 2)\\n\\n logprob[label_list[0]] = math.log(prob1)\\n logprob[label_list[1]] = math.log(prob2)\\n\\n\\n return logprob\",\n \"def logit_to_prob(logits: Tensor, criterion):\\n logits = logits.detach()\\n\\n if logits.size(1) == 2:\\n # return logits.softmax()[:, 0:1, ...] # Take probabilities of the first class (salt)\\n return logits.argmax(dim=1).float()\\n elif logits.size(1) == 1:\\n if isinstance(criterion, LovaszHingeLoss) or criterion == 'lovasz':\\n return (logits > 0).float()\\n else:\\n return logits.sigmoid()\\n\\n raise ValueError('Unsupported number of channels')\",\n \"def logloss_mc(y_true, y_prob, epsilon=10e-15):\\r\\n # normalize\\r\\n y_prob = y_prob / y_prob.sum(axis=1).reshape(-1, 1)\\r\\n print 'y_prob: ' + str(y_prob[1])\\r\\n print 'y_true: ' + str(y_true[1])\\r\\n y_prob = np.maximum(epsilon, y_prob)\\r\\n y_prob = np.minimum(1 - epsilon, y_prob)\\r\\n print 'y_prob: ' + str(y_prob[1])\\r\\n print 'y_true: ' + str(y_true[1])\\r\\n # get probabilities\\r\\n y = [y_prob[i, j] for (i, j) in enumerate(y_true)]\\r\\n print 'y: ' + str(y[1])\\r\\n print 'y_true: ' + str(y_true[1])\\r\\n ll = - np.mean(np.log(y))\\r\\n return ll\",\n \"def gmmloglik(log_emlik, weights):\\n N,_ = log_emlik.shape;\\n ll = 0;\\n for i in range(N):\\n ll += logsumexp(log_emlik[i, :] + np.log(weights));\\n return ll\",\n \"def calculateLogJointProbabilities(self, datum):\\n\\tlogJoint = util.Counter()\\n\\t#want to calculate log(P(y)) + log(sum(P(fi|y)))\\n\\t#where y is a label\\n\\tfor label in self.legalLabels:\\n\\t\\tlogJoint[label] = math.log(self.prior_distribution_prob[label])\\n\\t\\tfor feature, value in datum.items():\\n\\t\\t\\tcp = self.conditional_prob[label][feature][value]\\n\\t\\t\\tif cp > 0: #condition check for values < 0 because log(0) is undefined and math domain error occurs\\n\\t\\t\\t\\tlogJoint[label] += math.log(cp) #summing up\\n\\t\\t\\t\\t\\n\\treturn logJoint\",\n \"def log_prob(self, x_scaled):\\n predictions = self.likelihood(x_scaled)\\n # this function transform the gp mean back to \\\"real\\\" space\\n mean_with_negatives = scale_inverse_transform(self.y_scaler, predictions[0])\\n # this function replaces negative numbers with zero\\n mean = tf.nn.relu(mean_with_negatives)\\n log_mean = tf.math.log(mean)\\n tensor_log_prior = self.log_prior(x_scaled)\\n prob = tf.reshape(log_mean, shape=tensor_log_prior.shape) + tensor_log_prior\\n return prob\",\n \"def predict_log_likelihood_ratio(self, X):\\n Xs = self.scaler.transform(X)\\n class_probs = np.maximum(self.model.predict_proba(Xs)[:, 1], self.class_min)\\n return np.log(class_probs / (1 - class_probs))\",\n \"def get_log_prob(self, latent, obs):\\n return self.get_log_prob_from_latent_dist(self.get_latent_dist(obs), latent)\",\n \"def _logprobratio(prob1, prob2):\\n return log(prob1) / log(prob2)\",\n \"def _compute_log_type_probabilities(df, optim_paras, options):\\n x_betas = _compute_x_beta_for_type_probabilities(\\n df, optim_paras=optim_paras, options=options\\n )\\n\\n log_probabilities = x_betas - special.logsumexp(x_betas, axis=1, keepdims=True)\\n log_probabilities = np.clip(log_probabilities, MIN_FLOAT, MAX_FLOAT)\\n\\n return log_probabilities\",\n \"def sampled_softmax_logprobs(self, logit_target_in_model, logit_noise_in_model, logit_noise_in_noise, logit_target_in_noise):\\n logits = torch.cat([logit_target_in_model.unsqueeze(2), logit_noise_in_model], dim=2)\\n q_logits = torch.cat([logit_target_in_noise.unsqueeze(2), logit_noise_in_noise], dim=2)\\n # subtract Q for correction of biased sampling\\n logits = logits - q_logits\\n logproba = torch.nn.LogSoftmax(dim=-1)(logits)\\n \\n labels = torch.zeros_like(logits.narrow(2, 0, 1)).squeeze(2).long()\\n \\n logprobs = -torch.nn.NLLLoss(reduction='none')(logproba.view(-1, logproba.size(-1)), labels.view(-1)).view_as(labels)\\n logprobs = torch.sum(logprobs, dim=1)\\n \\n return logprobs\",\n \"def GSM_log_likelihood(X, model):\\n D, M = X.shape\\n k = model.mix.shape[0]\\n log_likelihood = 0\\n for i in range(M):\\n logpdf_X = 0\\n for j in range(k):\\n mvn = multivariate_normal(cov=model.cov[j, :])\\n logpdf_X = mvn.logpdf(x=X[:, i]) * model.mix[j]\\n log_likelihood += logpdf_X\\n return log_likelihood\",\n \"def calc_entropy_tuning_loss(self, log_probs):\\n with torch.no_grad():\\n inner_prod = (log_probs + self.target_entropy).detach()\\n alpha_loss = -(self.log_alpha * inner_prod).mean()\\n return alpha_loss\",\n \"def m_probs(self):\\n log_m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n\\n return self._prob_inverse_transform(numpy.exp(log_m))\",\n \"def log_prob(self, scores : torch.Tensor, permutations):\\n s = torch.log(select_indices(scores, permutations))\\n n = len(scores)\\n p = self.upto if self.upto is not None else n - 1\\n return -sum(\\n torch.log(torch.exp((s[k:] - s[k]) * self.shape).sum(dim=0))\\n for k in range(p))\",\n \"def _normal_log_prob(self, r, scale_log):\\n return -(r**2) / 2 - scale_log - self.const\",\n \"def log_prob_from_logits(x):\\n axis = len(x.get_shape())-1\\n m = tf.reduce_max(x, axis, keep_dims=True)\\n return x - m - tf.log(tf.reduce_sum(tf.exp(x-m), axis, keep_dims=True))\",\n \"def KLDiv(P, Q):\\n divergence = 0.0\\n sump, sumq = float(sum(P)), float(sum(Q))\\n probP, probQ = [float(p)/sump for p in P], [float(q)/sumq for q in Q]\\n\\n for i in xrange(len(probP)):\\n if probP[i] < Params.PRECISION or probQ[i] < Params.PRECISION: continue\\n divergence += probP[i] * math.log(probP[i]/probQ[i], Params.base)\\n return divergence\",\n \"def compute_log_probs(self, phrases, save_to_file=None):\\n # Co-ocurrence for source and target phrase\\n tgt_src_cnt = defaultdict(lambda: defaultdict(int))\\n \\n # ocurrence for target (English)\\n tgt_cnt = defaultdict(int)\\n\\n # Compute frequency and co-occurence\\n for phrase_pair in phrases:\\n\\n assert len(phrase_pair) == 2\\n src_p, tgt_p = phrase_pair\\n # defaultdict[target_phrase][source_phrase]\\n tgt_src_cnt[tgt_p][src_p]+=1\\n # defaultdict[target_phrase]\\n tgt_cnt[tgt_p]+=1\\n\\n\\n # Calculate log prob of translation model p(f|e)\\n log_prob_lst = list()\\n for tgt_phrase in tgt_src_cnt:\\n for src_phrase in tgt_src_cnt[tgt_phrase]:\\n # count(source, target) / count(target)\\n prob = float(tgt_src_cnt[tgt_phrase][src_phrase])/tgt_cnt[tgt_phrase]\\n log_prob = math.log(prob)\\n\\n log_prob_str = f\\\"{src_phrase} ||| {tgt_phrase} ||| {str(log_prob)}\\\"\\n log_prob_lst.append(log_prob_str)\\n \\n # Save to file \\n if save_to_file is not None:\\n with Path(save_to_file).open(\\\"w\\\") as wf:\\n wf.write('\\\\n'.join(log_prob_lst))\\n sys.stdout.write(f\\\"Saving phrase log probability file to path: {save_to_file}.\\\\n\\\")\\n \\n # List of log probability for phrase pair\\n return log_prob_lst\",\n \"def logprob(self, word, context):\\n\\n return -log(self.prob(word, context), 2)\",\n \"def predict_log_proba(self, X: np.ndarray) -> np.ndarray:\\n\\n self._check_input_data(X=X)\\n self._check_support(X=X)\\n\\n if not isinstance(self.lambda_, np.ndarray):\\n log_proba = stats.poisson.logpmf(X, mu=self.lambda_)\\n else:\\n n_samples = X.shape[0]\\n n_classes = len(self.lambda_) # type: ignore\\n log_proba = np.zeros((n_samples, n_classes))\\n\\n for cls in range(n_classes):\\n log_proba[:, cls] = stats.poisson.logpmf(X, mu=self.lambda_[cls]) # type: ignore\\n\\n return log_proba\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69283354","0.66957754","0.65397966","0.637631","0.6367839","0.63648623","0.63648623","0.63457084","0.63122123","0.6291868","0.62705356","0.61518747","0.6108963","0.6101549","0.6047805","0.6036303","0.6034293","0.59642345","0.5948823","0.5943543","0.59343046","0.5901243","0.58998895","0.5899886","0.5882327","0.5872356","0.5862196","0.58551365","0.58392775","0.58371025","0.58316797","0.58272535","0.58254784","0.58160865","0.5814891","0.5813423","0.5807898","0.57954794","0.57939947","0.5785931","0.5771055","0.5764725","0.5762176","0.5760207","0.57451797","0.5737324","0.5737324","0.57373047","0.57315063","0.57273936","0.57136476","0.57080495","0.57077223","0.5704922","0.57024115","0.56985503","0.56734604","0.56588095","0.56566274","0.5652643","0.5646047","0.5629109","0.562586","0.56215686","0.56171185","0.5608313","0.5605068","0.5593978","0.5589113","0.5575239","0.55737853","0.5563528","0.5547939","0.5544806","0.55394983","0.5539119","0.5528804","0.55243635","0.55224174","0.55186","0.5513687","0.5507706","0.55071473","0.5506797","0.550322","0.55019855","0.550074","0.54995465","0.54935294","0.5492426","0.54875183","0.5485176","0.54851615","0.54720634","0.54698646","0.5468775","0.5467996","0.54617685","0.54602814","0.5460142","0.5448083"],"string":"[\n \"0.69283354\",\n \"0.66957754\",\n \"0.65397966\",\n \"0.637631\",\n \"0.6367839\",\n \"0.63648623\",\n \"0.63648623\",\n \"0.63457084\",\n \"0.63122123\",\n \"0.6291868\",\n \"0.62705356\",\n \"0.61518747\",\n \"0.6108963\",\n \"0.6101549\",\n \"0.6047805\",\n \"0.6036303\",\n \"0.6034293\",\n \"0.59642345\",\n \"0.5948823\",\n \"0.5943543\",\n \"0.59343046\",\n \"0.5901243\",\n \"0.58998895\",\n \"0.5899886\",\n \"0.5882327\",\n \"0.5872356\",\n \"0.5862196\",\n \"0.58551365\",\n \"0.58392775\",\n \"0.58371025\",\n \"0.58316797\",\n \"0.58272535\",\n \"0.58254784\",\n \"0.58160865\",\n \"0.5814891\",\n \"0.5813423\",\n \"0.5807898\",\n \"0.57954794\",\n \"0.57939947\",\n \"0.5785931\",\n \"0.5771055\",\n \"0.5764725\",\n \"0.5762176\",\n \"0.5760207\",\n \"0.57451797\",\n \"0.5737324\",\n \"0.5737324\",\n \"0.57373047\",\n \"0.57315063\",\n \"0.57273936\",\n \"0.57136476\",\n \"0.57080495\",\n \"0.57077223\",\n \"0.5704922\",\n \"0.57024115\",\n \"0.56985503\",\n \"0.56734604\",\n \"0.56588095\",\n \"0.56566274\",\n \"0.5652643\",\n \"0.5646047\",\n \"0.5629109\",\n \"0.562586\",\n \"0.56215686\",\n \"0.56171185\",\n \"0.5608313\",\n \"0.5605068\",\n \"0.5593978\",\n \"0.5589113\",\n \"0.5575239\",\n \"0.55737853\",\n \"0.5563528\",\n \"0.5547939\",\n \"0.5544806\",\n \"0.55394983\",\n \"0.5539119\",\n \"0.5528804\",\n \"0.55243635\",\n \"0.55224174\",\n \"0.55186\",\n \"0.5513687\",\n \"0.5507706\",\n \"0.55071473\",\n \"0.5506797\",\n \"0.550322\",\n \"0.55019855\",\n \"0.550074\",\n \"0.54995465\",\n \"0.54935294\",\n \"0.5492426\",\n \"0.54875183\",\n \"0.5485176\",\n \"0.54851615\",\n \"0.54720634\",\n \"0.54698646\",\n \"0.5468775\",\n \"0.5467996\",\n \"0.54617685\",\n \"0.54602814\",\n \"0.5460142\",\n \"0.5448083\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":92880,"cells":{"query":{"kind":"string","value":"Assumes that 'hand' has all the letters in word. In other words, this assumes that however many times a letter appears in 'word', 'hand' has at least as many of that letter in it."},"document":{"kind":"string","value":"def updateHand(hand, word):\n # TO DO ... <-- Remove this comment when you code this function\n handCopy = hand.copy()\n for l in word:\n if handCopy[l] >= 1:\n handCopy[l] -= 1\n \n print handCopy"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def isValidWord(word, hand, wordList):\n myHand = hand.copy() \n for letter in word:\n if letter not in hand or myHand[letter] <= 0:\n return False\n else:\n myHand[letter] -= 1 \n if word not in wordList:\n return False\n else:\n return True","def isValidWord(word, hand, wordList):\n tempHand = hand.copy()\n if len(word) > 0 and word in wordList:\n for letter in word:\n if letter not in tempHand or tempHand[letter] <= 0:\n return False\n else:\n tempHand[letter] = tempHand.get(letter, 0) - 1\n return True\n return False","def isValidWord(word, hand, wordList):\r\n \r\n \r\n if type(word) != str:\r\n return False\r\n \r\n if word not in wordList:\r\n return False\r\n \r\n for letter in word:\r\n if letter not in hand:\r\n return False\r\n \r\n updatedHand = hand.copy()\r\n # copy hand as to not mutate the hand passed in\r\n \r\n for letter in word:\r\n if letter in updatedHand:\r\n updatedHand[letter] -= 1\r\n \r\n for letter in word:\r\n if updatedHand[letter] < 0:\r\n return False\r\n \r\n return True","def isValidWord(word, hand, wordList):\n if word not in wordList:\n print('word not in wordList')\n return False\n else:\n for letter in word:\n if letter not in hand:\n print('letter not in hand')\n return False\n else:\n newHand = hand.copy()\n for letter in word:\n if letter not in newHand: # this if statement is here to prevent keyError\n print('letter not in newHand')\n return False\n else:\n newHand[letter] = newHand[letter] - 1\n if newHand[letter] < 0:\n print('no letter left')\n return False\n return True","def isValidWord(word, hand, wordList):\n # TO DO ... <-- Remove this comment when you code this function\n if word not in wordList:\n return False\n dic={}\n for k in hand:\n dic[k]=hand[k] \n for w in word:\n a=dic.get(w,0)\n if a > 0:\n dic[w]=a-1\n else:\n return False\n return True","def is_valid_word(word, hand, word_list):\n h = dict(hand)\n if word.lower() in word_list:\n for letter in word:\n if h.get(letter, 0) == 0:\n return False\n else:\n h[letter] -= 1\n else:\n return False\n return True","def isValidWord(word, hand, wordList):\n output = hand.copy()\n word_check = False\n if word in wordList:\n word_check = True\n \n letter_check = set(list(word)) <= set(output.keys())\n \n for letter in word:\n if letter in output.keys():\n output[letter] -= 1\n \n value_check = all(i >= 0 for i in output.values())\n \n if word_check == True and letter_check == True and value_check == True:\n return True\n else:\n return False","def is_validword(word, hand, word_list1):\n # TO DO ... <-- Remove this comment when you code this function\n word_list = []\n cnt_1 = 0\n for i in word:\n word_list += i.split(\",\")\n for i in word_list:\n if i in hand.keys():\n cnt_1 += 1\n if cnt_1 == len(word) and word in word_list1:\n score = get_word_score(word, n_num)\n update_hand(hand, word)\n else:\n print(\"Invalid Word\")","def isValidWord(word, hand, wordList):\n status = []\n status2 = []\n\n # check if the input is valid\n if not word in wordList:\n return False\n \n for letter in word:\n \n ## commented out bc global var not available for the individual exercise\n # if not letter in SCRABBLE_LETTER_VALUES.keys():\n # status.append(False)\n \n if not letter in hand.keys():\n status.append(False)\n \n if False in status:\n return False\n \n # check if there are enough values in hand for the guess\n for key, value in getFrequencyDict(word).items():\n \n if not key in hand or value > hand[key]:\n status2.append(False)\n\n if False in status2:\n return False\n \n return True","def isValidWord(word, hand, wordList):\n # TO DO ... <-- Remove this comment when you code this function\n #for line in fil:\n # print line\n if word not in w:\n w.append(word)\n #print w\n else:\n #print \"already have a word inside\"\n return False\n for z in word:\n print z\n if z in hand:\n #if p != word:\n #print hand[c]\n if hand[z] > 0:\n hand[z] -= 1\n \n else:\n return False\n else:\n return False\n if word in wordList:\n print \"here is true\"\n return True\n else:\n return False","def is_valid_word(word, hand, word_list):\r\n # TO DO ...\r\n word_freq_dict = get_frequency_dict(word)\r\n for letter in word_freq_dict:\r\n if letter not in hand or hand[letter] - word_freq_dict[letter] < 0:\r\n return False\r\n return word in word_list","def isValidWord(word: str, hand: Dict[str, int], wordList: List[str]) -> bool:\n cp_hand = hand.copy()\n\n if word not in wordList:\n return False\n\n for char in word:\n if cp_hand.get(char, 0) < 1:\n return False\n else:\n cp_hand[char] = cp_hand.get(char,0) - 1\n\n return True\n # one line:\n # return word in wordList and all(word.count(c) <= hand.get(c, 0) \n # for c in word) # Kiwitrader","def isValidWord(word, hand, wordList):\n wordTest = word.lower()\n handcopy = hand.copy()\n for i in wordTest:\n if i not in 'abcdefghijklmnopqrstuvwxyz':\n return False\n if wordTest not in wordList:\n return False\n else:\n for i in word:\n if i not in handcopy:\n return False\n else:\n if handcopy[i]==0:\n return False\n if handcopy.get(i,0) !=0:\n handcopy[i]-=1\n if handcopy.get(i,0)<0:\n return False\n return True","def is_valid_word(word, hand, word_list):\n failure=True\n word=word.lower()\n if word not in word_list:\n failure=False\n for i in word:\n w=hand.get(i,0)\n if w==0:\n failure=False\n break\n return failure","def updateHand(hand, word):\n tempHand = hand.copy()\n for letters in word:\n if letters in tempHand:\n tempHand[letters] -= 1\n return tempHand","def isValidWord(word, hand, wordList):\r\n # TO DO ... <-- Remove this comment when you code this function\r\n \r\n newword = {}\r\n for x in word:\r\n newword[x] = newword.get(x,0) + 1\r\n \r\n for l in newword:\r\n if newword.get(l,0) > hand.get(l, 0):\r\n return False\r\n \r\n is_valid = False\r\n for n in wordList:\r\n if word == n:\r\n return True\r\n \r\n return False","def isValidWords(word, hand, wordList):\n #tothand = 0\n #w = []\n # TO DO ... <-- Remove this comment when you code this function\n #for line in fil:\n # print line\n #if word not in w:\n # w.append(word)\n #print word\n #for h in hand:\n # global tothand\n # tothand += hand[h]\n #print tothand\n # if tothand == 0:\n if word in wordList:\n #print wordList\n print \"word found\"\n return True\n else:\n print \"Not a word\"\n return False\n \n #else:\n # return True","def updateHand(hand, word):\n output = hand.copy()\n for letter in word:\n if letter in output.keys():\n output[letter] -= 1\n return output","def can_make_word(word, letters):\n grouped_chars = group_input(word)\n for char in letters:\n\n if is_empty(grouped_chars):\n return True\n\n if char in grouped_chars and grouped_chars[char] > 0:\n grouped_chars[char] -= 1\n\n return is_empty(grouped_chars)","def is_valid_word(word_test, hand_word, word_list):\n count = 0\n word_test = list(word_test)\n for i_1 in word_test:\n if i_1 in hand_word:\n count += count\n if count == len(word_test) and word_test[i_1] == word_list[i_1]:\n return True\n return False","def dealHand():\n import random\n import string\n \n vowels = 'aeiou'\n constant = 'bcdfghjklmnpqrstvwxyz'\n \n maxint = max(list(map(len, wordlist)))\n \n n = random.randint(5, maxint) \n \n # 1/3 vowls\n n_vowl = n // 3\n n_constant = n - n//3\n \n get_vowl = random.choices(vowels, k = n_vowl)\n get_constant = random.choices(constant, k = n_constant)\n \n strings = ''.join(get_vowl + get_constant)\n \n hand = getFreqDict(strings)\n \n return hand","def comp_choose_word(hand, word_list):\n hand_length = 0\n for v in hand.values():\n hand_length += v\n\n word_choices = []\n\n for num in range(1, hand_length + 1):\n num_perms = get_perms(hand, num)\n for perm in num_perms:\n if perm in word_list:\n word_choices.append(perm)\n\n comp_word = ''\n\n for word in word_choices:\n score = get_word_score(word, hand_length)\n if score > get_word_score(comp_word, hand_length):\n comp_word = word\n\n return comp_word","def updateHand(hand: d_si, word: str) -> d_si:\n cp_hand = hand.copy()\n\n for char in word:\n cp_hand[char] = cp_hand.get(char, 0) - 1\n return cp_hand\n # One line:\n # return {char: hand[char] - word.count(char) for char in hand} # Kiwitrade","def count_words(word, words):\n same_words_in_message = 0\n for element in words:\n if element == word:\n same_words_in_message += 1\n return same_words_in_message","def isvalid_word1(word, hand, word_list1):\n # TO DO ... <-- Remove this comment when you code this function\n for i in word:\n if i not in hand:\n return False\n i = i\n return word in word_list1","def containing(letter, text):\n return([word for word in text if word.count(letter) >= 1])","def updateHand(hand, word):\r\n handTemp = dict(hand)\r\n for letter in word:\r\n handTemp[letter] -= 1\r\n return handTemp","def update_hand(hand, word):\n for i in word:\n hand[i] -= 1\n\n return hand","def comp_choose_word(hand, word_list):\n maxscore = 0\n maxword = \"\" \n for n in range(calculate_handlen(hand)):\n perms = get_perms(hand, n)\n for word in perms:\n wordscore = get_word_score(word, HAND_SIZE)\n if wordscore > maxscore:\n if word not in word_list:\n continue\n else:\n maxscore = wordscore\n maxword = word\n return maxword\n # TO DO...","def getWordScore(word, n):\n score = 0\n\n for letters in word:\n if letters in SCRABBLE_LETTER_VALUES:\n score += SCRABBLE_LETTER_VALUES[letters]\n\n if len(word) == n:\n return (score * len(word)) + 50\n else:\n return score * len(word)","def puzzle(word_list):\n \n multiple_stroke_letters = ['i','j','t','x']\n for word in word_list:\n if word.count('i')==1 and word.count('j')==1 and word.count('t')==1 \\\n and word.count('x')==1:\n print(word)\n break","def getWordScore(word, n):\n score=0\n for i in range(len(word)):\n addition=SCRABBLE_LETTER_VALUES[word[i]]\n score+=addition*(len(word))\n if len(word)==n:\n score+=50\n return score","def tell_me(self,secret,dashes):\n\n\n result=\"\"\n self.total=0\n for i in range(len(secret)):\n if secret[i] != dashes[i]:\n result=result+secret[i]\n\n\n self.total=self.total+String_Database.frequency.get(secret[i])\n\n self.status=\"Gave up\"\n\n print(\"The corect word is : \", secret,\", you missed :\",\"letters: \",result)\n self.finalScore=0-self.total\n\n\n return 1","def print_uses_all():\n str = input('Enter a string of letters, please:')\n\n count_uses_all = 0\n for line in fin:\n word = line.strip()\n if uses_all(word, str):\n print(word)\n count_uses_all += 1\n print('Number of words that use all letters in the string:', count_uses_all)","def get_word_score(word, n=7):\n score = 0\n\n for i in word:\n score += SCRABBLE_LETTER_VALUES[i]\n\n if len(word) == n:\n score += 50\n\n return score","def getWordScore(word: str, n: int) -> int:\n # (SCRABBLE_LETTER_VALUES[char]) rise a exception if char not in SCRABBL...\n ans = sum(SCRABBLE_LETTER_VALUES.get(char, 0) for char in word) * len(word)\n\n # [if False, if True] [condition] (ternary op)\n return [ans, ans + 50] [len(word) == n]","def find_all(letter_guess, generated_word):\n return [i for i, letter in enumerate(generated_word) if letter == letter_guess]","def comp_choose_word(hand, word_list):\n perms_list = []\n for i in range(1, HAND_SIZE+1):\n perms_list.extend(get_perms(hand, i))\n perms_valid = []\n for j in range(0, len(perms_list)):\n word = perms_list[j]\n if is_valid_word(word, hand, word_list):\n perms_valid.append(word)\n\n \n\n\n\n\n\n valid_scores = []\n for k in range(0, len(perms_valid)):\n valid_scores.append(get_word_score(perms_valid[k], HAND_SIZE))\n valid_words = perms_valid[k]\n\n # Compare first two scores and put highest score and corresponding word in seprate variables\n # respectively.\n max_score = 0\n max_word = ''\n for j in range(0, len(valid_scores)):\n if max_score < valid_scores[j]:\n max_score = valid_scores[j]\n max_word = perms_valid[j]\n return max_word","def check_win(secret_word, old_letters_guessed):\n j=len(secret_word)\n for i in secret_word:\n j -= 1\n if i in old_letters_guessed:\n if j == 0:\n return True\n else: \n continue\n else:\n return False","def try_to_guess(word):\n\n # set number of tries based on word length\n if 4 < len(word) < 7:\n tries = 4\n elif 7 < len(word) < 12:\n tries = 8\n else:\n tries = 12\n \n # create placeholder word eg: ---\n placeholder = ['-' for _ in range(len(word))]\n \n # list to check if letter was already guessed\n guesses = []\n\n while tries > 0:\n print('\\n' + ''.join(placeholder))\n letter = str(input(f\"Input a letter: \"))\n\n # only one lower case alphanum character\n if len(letter) > 1:\n print(\"You should input a single letter\")\n elif not letter.isalnum() or not letter.islower():\n print(\"It is not an ASCII lowercase letter\")\n \n elif letter in guesses:\n print(\"You already typed this letter\") \n elif letter not in word:\n print(\"No such letter in the word\")\n tries -= 1\n \n # we have a good letter\n else:\n for i, v in enumerate(word):\n \n if v == letter:\n placeholder[i] = letter\n \n if ''.join(placeholder) == word:\n print()\n print(''.join(placeholder))\n print(\"You guessed the word!\\nYou survived!\")\n return\n \n guesses.append(letter)\n \n else:\n print(\"You lost!\")\n print(f\"The word was {word}\")","def check_match(self, word_found,word): \r\n self.count = 0\r\n for char in self.word_found:\r\n if char != self.word[self.count]:\r\n return False\r\n self.count +=1\r\n #print(self.count)\r\n \r\n return True","def check_crossword(self, letter, space, cross):\n if cross == ('', ''):\n return 0\n\n pre, post = cross\n crossword = pre + letter + post\n if self.is_word(crossword):\n score = self.score_factory.make()\n score.add(letter, space)\n rest = pre + post\n for let in rest:\n score.add(let)\n return score.get_points()\n return None","def getWordScore(word, n):\n score = 0\n for letter in word:\n score += SCRABBLE_LETTER_VALUES[letter]\n score *= len(word)\n if len(word) == n:\n score += 50\n return score","def word_check(word):\n word1 = word[1:]\n if word1 not in word_dict: return False\n if not homophones (word, word1): return False\n \n \n word2 = word[0] + word[2:]\n if word2 not in word_dict: return False\n if not homophones(word, word2): return False\n\n return True","def most_repeating_letter_count(word):\n return Counter(word.lower()).most_common(1)[0][1]","def updateHand(hand, word):\r\n update_hand = hand.copy()\r\n for i in word:\r\n update_hand[i] -= 1\r\n return update_hand","def monkey_typing(text: str, words: set) -> int:\n # simple solution\n # counter = [chunk for chunk in words if chunk in text.lower()]\n\n # my solution\n text_split = text.lower().split(\" \")\n if not all(len(w) >= 3 and w.islower() and w.isalpha for w in words):\n return 0\n score = 0\n eliminated = []\n for text_chunk in text_split:\n words_to_count = words\n for word in words_to_count:\n if word.lower() in text_chunk and word.lower() not in eliminated:\n score += 1\n eliminated.append(word)\n return score","def basic_check(word):\n if word[-1] == \"b\" or word[-1] == \"g\":\n return False\n consonant_counter = 0\n for char in word:\n if char in VOWELS:\n consonant_counter = 0\n else:\n consonant_counter += 1\n if consonant_counter >= 3:\n return False\n return True","def is_word_guessed(secret_word, letters_guessed):\n for char in secret_word:\n flag = False\n for letter in letters_guessed:\n if char == letter:\n flag = True\n if flag == False:\n break\n\n return flag","def allPossibleWords(Rack):\n def checkWord(word):\n return stringInRack(word,Rack)\n return filter(checkWord, Dictionary)","def is_word_guessed(secret_word, letters_guessed):\n\n for letter in secret_word:\n if letter in letters_guessed:\n pass\n else:\n return False\n return True","def nextLetter(self):\r\n self.filterPossibleWords()\r\n \r\n letterCount = len(self.unusedLetters) * [0]\r\n\r\n # Count the number of words each letters appears in\r\n for word in self.wordList:\r\n for i in range(len(self.unusedLetters)):\r\n # Don't count letters already discovered\r\n if self.unusedLetters[i] not in self.currentBoard and self.unusedLetters[i] in word:\r\n letterCount[i] += 1\r\n \r\n # Determine which letter appeared in the most words\r\n highCount = max(letterCount)\r\n highCountIndexes = []\r\n \r\n # Gather all the letters that tied for the highest count\r\n for j in range(len(letterCount)):\r\n if letterCount[j] == highCount:\r\n highCountIndexes += [j]\r\n\r\n # Break any ties randomly\r\n choice = random.choice(highCountIndexes)\r\n\r\n chosenLetter = self.unusedLetters[choice]\r\n self.unusedLetters.remove(chosenLetter)\r\n return chosenLetter","def count(self, word):\n pass","def guess_word():\n words = [\"tom\", \"jerry\", \"apple\", \"banana\", \"peal\", \"water\", \"ice\", \"one\", \"tw0\", \"three\"]\n word = list(words[random.randint(0, len(words)-1)])\n print(word)\n length = len(word)\n underline = [\"_ \" for i in range(length)]\n count = 5\n while count > 0:\n # 输出当前状态\n output = \"\".join(underline)\n print(output)\n guess = input(\"guess a char(left guess %d times ):\" % (count))\n if guess in word:\n index = word.index(guess)\n underline[index] = guess\n word[index] = \" \"\n else:\n count -= 1\n # 跳出循环的条件\n if word.count(\" \") == length:\n break\n if count > 0:\n print(\"yur are right!\")\n else:\n print(\"游戏结束！你没有猜对。\")","def countCharacters(self, words, chars):\n chars_dict = self.count_to_dict(chars)\n chars_set = chars_dict.keys()\n len_chars_set = len(chars_set)\n \n good_string = ''\n for words_i in words:\n word_dict = self.count_to_dict(words_i)\n words_i_set = word_dict.keys()\n check = 0\n for i in words_i_set:\n if i not in chars_set:\n check+=1\n break\n if word_dict[i] > chars_dict[i]:\n check+=1\n break\n if check == 1:\n continue\n good_string = good_string+words_i\n return len(good_string)","def viableWord(self, word, filledInSpaces):\r\n \r\n # Check if it fits blanks\r\n for (index, letter) in filledInSpaces:\r\n if letter != word[index]:\r\n return False\r\n\r\n # Check if it fits unused\r\n for letter in word:\r\n if letter in self.wrongLetters:\r\n return False\r\n\r\n return True","def substitute_hand(hand, letter):\n copies = hand.get(letter,0)\n newHand = hand.copy()\n allletters = VOWELS+CONSONANTS \n if not copies:\n print ('You don\\'t have a '+letter+' in your hand.')\n return hand\n else:\n for c in newHand:\n if c =='*':\n pass\n elif allletters.find(c)==0: \n #print ('Removing '+c+'.')\n allletters = allletters[1:]\n elif allletters.find(c)==len(allletters):\n #print ('Removing '+c+'.')\n allletters = allletters[0:len(allletters)]\n else:\n #print ('Removing '+c+'.')\n allletters = allletters[0:allletters.find(c)] + allletters[allletters.find(c)+1:]\n #print ('Choice for newletter: '+allletters)\n for i in range (copies):\n newletter = random.choice(allletters)\n print ('Dealing new letter '+newletter)\n newHand[newletter] = newHand.get(newletter, 0)+1\n \n return newHand","def guessing():\r\n word = random_word()\r\n word_guess = ['_' for _ in word]\r\n letters = set()\r\n guesses = 6\r\n\r\n print('Your Word:')\r\n print(' '.join(word_guess) + '\\n')\r\n\r\n while '_' in word_guess and guesses > -1:\r\n guess = input('Guess your letter: ').upper()\r\n if guess == 'EXIT':\r\n print('\\nThe game had been ended.\\n')\r\n sys.exit()\r\n elif guess in string.ascii_uppercase:\r\n if guess == '':\r\n print('Not a letter!\\n')\r\n elif guess in letters:\r\n print('Letter already taken!\\n')\r\n elif guess in word:\r\n for i in range(len(word)):\r\n if word[i] == guess:\r\n word_guess[i] = guess\r\n print(' '.join(word_guess) + '\\n')\r\n if ''.join(word_guess) == word:\r\n print('You win!\\n')\r\n else:\r\n guesses -= 1\r\n print('Incorrect!')\r\n if guesses == -1:\r\n make_drawing(guesses)\r\n print('\\nYou hang!')\r\n print(f'The full word was: {\" \".join(list(word))}\\n')\r\n elif guesses == 1:\r\n make_drawing(guesses)\r\n print(f'You have {guesses} wrong guess left.\\n')\r\n else:\r\n make_drawing(guesses)\r\n print(f'You have {guesses} wrong guesses left.\\n')\r\n letters.add(guess)\r\n else:\r\n print('Not a letter!\\n')","async def words(self, ctx, *, message):\n doc = str(message)\n res = str(sum([i.strip(string.punctuation).isalpha() for i in doc.split()]))\n final = \"\"\n if res == \"1\":\n final += \"Your message is only **1** word.\"\n else:\n final += f'Your message is **{res}** words long.'\n await ctx.send(final)","def choose_letter_in_word(word,list_letter,pattern):\r\n for j in range(len(str(word))):\r\n if word[j] not in pattern:\r\n index= letter_to_index(word[j])\r\n list_letter[index] += 1\r\n return list_letter","def check_win(secret_word, old_letters_guessed):\n returned_list = list(secret_word)\n for i in range(len(secret_word)):\n if secret_word[i] in old_letters_guessed:\n returned_list[i] = secret_word[i] + ' '\n else:\n returned_list[i] = '_ '\n returned_str = ''.join(returned_list)\n\n string_no_spaces = returned_str.replace(\" \", \"\")\n if string_no_spaces == secret_word:\n return True\n else:\n return False","def letter_text_analyzer(text, letter):\n count = 0\n text_mod = \"\"\n for char in text:\n if char not in string.punctuation:\n text_mod += char\n text_split = text_mod.split()\n\n for word in text_split:\n if letter in word:\n count += 1\n result = \"Your text contains {0} words,of which {1} ({2:.1%}) contain an '{3}'\"\n\n return result.format(len(text_split), count, count / len(text_split), letter)","def is_word_complete(word, guesses):\n # go through each letter of the word\n # if the letter is not in guesses then False\n # if you don't get any false, then you can consider True\n\n for letter in word:\n if letter not in guesses:\n return False\n return True","def calculate_score(rack,word):\n score = 0\n\n for letter in word:\n score += SCORE_DICT[letter]\n if len(rack) < 7:\n score = score\n else:\n if len(word) >= len(rack):\n score = (score + 50)\n return score","def play_word(self):\n new_tiles = {}\n placed_tiles_computer = []\n\n # from the rack, get the word to be played, and add the score\n computer_rack = self.rack\n self.board.generate_moves(computer_rack)\n # tiles that make up the word in the board\n word_tiles = self.board.best_move_cell()\n self.board.cross_checks_sums(word_tiles)\n self.score += self.board.compute_score(word_tiles)\n self.board.placed_cell_cleanup(word_tiles)\n\n # from the tiles of the word formed on the board, retrieves the indices\n # of which tiles were the ones that were played from the rack\n for tile in word_tiles:\n for i in range(len(computer_rack)):\n if tile.letter == computer_rack[i]:\n if i in placed_tiles_computer:\n continue\n placed_tiles_computer.append(i)\n break\n\n # gets new tiles from the bag for every tile that was played\n for t in placed_tiles_computer:\n new_tile = self.board.draw_random_tile()\n if new_tile != None:\n new_tiles[t] = new_tile\n self.rack[t] = new_tiles[t]\n else:\n return False\n return True","def guess_word(ga, word, ch):\n flag = 0\n sd = stringDatabase\n gameword = list(word)\n gamewordlen = len(gameword)\n\n # Checks if the option/choice is 'l'\n if ch == 'l':\n gl = sd.StringDatabase.get_letter()\n if not gl:\n return\n # print('here')\n if gl in gameword:\n if gl in ga.guess_list:\n print('Already flipped the letter, Guess another letter')\n return\n n = gameword.count(gl)\n print('You found', n, 'letter/s')\n for i in range(gamewordlen):\n if gameword[i] == gl:\n ga.guess_list[i] = gl\n if ga.guess_list == gameword:\n flag = 1\n ga.status = 'Success'\n print('Correct Guess!!')\n ga.calculate_score()\n else:\n print('You found 0 new letter/s, Try Again')\n ga.missed_letter += 1\n if ga.score == 0:\n ga.score -= 1\n else:\n ga.score -= (ga.score/4)\n per = (ga.score*10)/100\n ga.score -= per\n\n # Checks if the option/choice is 'g'\n if ch == 'g':\n gl = list(sd.StringDatabase.get_word())\n # print('\\n')\n if gl == gameword:\n count = 0\n for i in range(gamewordlen):\n if gameword[i] != ga.guess_list:\n count += 1\n if count >= 1:\n ga.calculate_score()\n ga.score += 10\n ga.status = 'Success'\n print('Correct guess!!')\n flag = 1\n else:\n ga.bad_guess += 1\n print('Wrong guess, Try Again')\n per = (ga.score * 30) / 100\n ga.score -= per\n\n # Checks if the option/choice is 't'\n if ch == 't':\n ga.score = ga.score/2\n ga.calculate_minus_score()\n ga.status = 'Gave up'\n print('Correct word is: ' + word)\n flag = 1\n\n return flag","def get_pure_user_words(user_words, letters, words_from_dict):\n checked_user_words = []\n for each_user_word in user_words:\n if 4 <= len(each_user_word) <= 9:\n if letters[4] in each_user_word:\n count = 0\n for each_user_let in each_user_word:\n if each_user_let in letters:\n count += 1\n if count == len(each_user_word):\n checked_user_words.append(each_user_word)\n for each_word in checked_user_words:\n count_let = 0\n if each_word in words_from_dict:\n checked_user_words.remove(each_word)\n for each_word in checked_user_words:\n coun_me = 0\n for each_let in each_word:\n if each_word.count(each_let) <= letters.count(each_word):\n count_me += 1\n if count_me == len(each_word):\n checked_user_words.remove(each_word)\n return (checked_user_words)","def usedWord(afz, word, output=True):\n count = 0\n for msg in msgs:\n if msg.afz == afz:\n if word.lower() in msg.msg.lower():\n count = count + 1\n print afz, 'heeft', count, 'keer het woord', word, 'gebruikt.'","def word_length_check(self):\r\n \r\n for word in self.all_words:\r\n if len(word) == len(self.best_guess):\r\n self.valid_words.add(word)","def get_word_weight(words, word):\n weight = 0\n for w in words:\n if not any(c in word for c in w):\n weight += 1\n\n return weight","def is_isogram(word):\n word = [char.lower() for char in word if char.isalpha()]\n for char in word:\n if word.count(char) > 1:\n return False\n return True","def user_avoid_count():\n\tforbidden = input('Enter a string of forbidden letters.\\n> ')\n\tprint(len({w for w in word_set if avoids(w, forbidden)}))","def remove_letters(available, word):\n count_different_letters_in_word = 0\n\n for letter in available:\n if letter in word:\n count_different_letters_in_word += 1\n available = available.replace(letter, '')\n else:\n pass\n dic = {'count': count_different_letters_in_word, 'available': available}\n return dic","def computerWordPick(Length):\n for word in MakeMyDictionary('american-english.txt'):\n pick = random.choice(MakeMyDictionary('american-english.txt'))\n pickLength = len(pick) \n if pickLength != Length:\n pick\n else:\n return pick","def onlyuse(word, letters):\r\n truth = True\r\n for letter in word:\r\n truth = letter in letters and truth\r\n return truth","def uses_only(word, available):\n for letter in word:\n if letter not in available:\n return False\n return True","def guess_letter(self):\r\n letter = input(\"# Enter a Letter :\")\r\n if not letter:\r\n print(\"Please Enter a Valid Value\")\r\n else:\r\n result = game_instance.check_letter(letter)\r\n\r\n if result == \"NOT FOUND\":\r\n print(\"WRONG. No corresponding letters found in the word. Try Again!\")\r\n else:\r\n temp = list(self.current_word)\r\n count=0;\r\n for x in result:\r\n count+=1\r\n temp[x] = letter\r\n self.current_word = \"\".join(temp)\r\n print(\"Good Job. You Found \"+str(count)+\" Letters.\")","def test_wildcard(word_list):\n failure=False\n\n # test 1\n hand = {'a': 1, 'r': 1, 'e': 1, 'j': 2, 'm': 1, '*': 1}\n word = \"e*m\"\n\n if is_valid_word(word, hand, word_list):\n print(\"FAILURE: test_is_valid_word() with wildcards\")\n print(\"\\tExpected False, but got True for word: '\" + word + \"' and hand:\", hand)\n\n failure = True\n\n # test 2\n hand = {'n': 1, 'h': 1, '*': 1, 'y': 1, 'd':1, 'w':1, 'e': 2}\n word = \"honey\"\n\n if is_valid_word(word, hand, word_list):\n print(\"FAILURE: test_is_valid_word() with wildcards\")\n print(\"\\tExpected False, but got True for word: '\"+ word +\"' and hand:\", hand)\n\n failure = True\n\n # test 3\n hand = {'n': 1, 'h': 1, '*': 1, 'y': 1, 'd':1, 'w':1, 'e': 2}\n word = \"h*ney\"\n\n if not is_valid_word(word, hand, word_list):\n print(\"FAILURE: test_is_valid_word() with wildcards\")\n print(\"\\tExpected True, but got False for word: '\"+ word +\"' and hand:\", hand)\n\n failure = True\n\n # test 4\n hand = {'c': 1, 'o': 1, '*': 1, 'w': 1, 's':1, 'z':1, 'y': 2}\n word = \"c*wz\"\n\n if is_valid_word(word, hand, word_list):\n print(\"FAILURE: test_is_valid_word() with wildcards\")\n print(\"\\tExpected False, but got True for word: '\"+ word +\"' and hand:\", hand)\n\n failure = True \n\n # dictionary of words and scores WITH wildcards\n words = {(\"h*ney\", 7):290, (\"c*ws\", 6):176, (\"wa*ls\", 7):203}\n for (word, n) in words.keys():\n score = get_word_score(word, n)\n if score != words[(word, n)]:\n print(\"FAILURE: test_get_word_score() with wildcards\")\n print(\"\\tExpected\", words[(word, n)], \"points but got '\" + \\\n str(score) + \"' for word '\" + word + \"', n=\" + str(n))\n failure=True \n\n if not failure:\n print(\"SUCCESS: test_wildcard()\")","def check_letter(self, letter, random_word):\n if letter in random_word:\n for k in range(0, len(random_word)):\n if self.unsolved_word[k] == '_':\n self.unsolved_word[k] = letter if\\\n random_word[k] == letter else '_'\n return ''.join(self.unsolved_word)","def fuzz_word(word):\r\n res = []\r\n\r\n for c in word:\r\n for i in range(3):\r\n c += random.choice(symbols)\r\n res.append(c)\r\n\r\n return ''.join(res)","def is_a_word(self, word):\n word = word.lower()\n if word in self.data:\n return True\n else:\n # for char in word:\n # if char.isnumeric():\n # return True\n word = list(word)\n numbers = len([x for x in word if x.isnumeric()])\n # # letters = len([x for x in word if x.isalpha()])\n if numbers >= 2 or numbers/len(word) > 0.4:\n return True\n return False","def count_letters(word, letter):\n assert isinstance(word, str) == True, \"Please input a string!\"\n count = 0\n for char in word:\n if char == letter:\n count += 1\n\n return count","def word_is_solved(word, guesses):\n total = 0 # number of guessed characters in word\n\n for guess in guesses:\n # Number of guesses[i] in word\n num = word.count(guess)\n if num > 0:\n total += num\n if total == len(word):\n return True\n else:\n return False","def calc_word_score(word, letters_count, letters_score):\n\n output = 0\n # keep track of the used letters\n letters_remaining = dict(letters_count)\n\n for w in word:\n if w not in letters_count:\n # contains a letter outside the provided scope\n return 0\n if letters_remaining[w] == 0:\n # too many occurrences of that letter\n return 0\n output += letters_score[w]\n letters_remaining[w] -= 1\n\n return output","def words(word):\n new_list = []\n \n for i in word.split():\n new_list.append(i)\n return Counter(new_list)","def start_game(self, entered_word):\n if entered_word not in self._word_list:\n print \"Not a word\"\n return\n \n strings = self._substrs(entered_word)\n sorted_strings = self._merge_sort(strings)\n all_strings = self._remove_duplicates(sorted_strings)\n self._subset_strings = self._intersect(self._word_list, all_strings)\n self._guessed_strings = [] \n for word in self._subset_strings:\n self._guessed_strings.append(\"*\" * len(word))\n self.enter_guess(entered_word)","def letterFreq(words):\n dict = {}\n total = 0\n for word in words:#Iterate through words\n for letter in word:#Increment by letter\n count = 0\n for yearCount in words[word]:\n count += yearCount.count#Increment total instances of word\n total += count#Count total letters\n if letter in dict:\n dict[letter] += count#Add to existing entry\n else:\n dict[letter] = count#Create new entry\n \"\"\"CODE FOR THE WHOLE ALPHABET\"\"\"\n list = []\n for letter in ascii_lowercase:\n if letter in dict and dict[letter] != 0:\n list.append(dict[letter] / total)#Convert to relative\n else:\n list.append(0.0)#Fill alphabet\n return list","def keep_word(word, num_words, count_dict):\r\n try:\r\n z_wi = float(count_dict[word]) / (num_words)\r\n part1 = math.sqrt((z_wi / 0.001)) + 1\r\n part2 = 0.001 / z_wi\r\n total_prob = part1 * part2\r\n return random.uniform(0, 1) < total_prob\r\n except:\r\n return False","def wordscore(word):\n return sum(letterscore[l] for l in word)","def test_is_valid_word(word_list):\n failure=False\n\n # test 1\n word = \"hello\"\n handOrig = get_frequency_dict(word)\n handCopy = handOrig.copy()\n\n if not is_valid_word(word, handCopy, word_list):\n print(\"FAILURE: test_is_valid_word()\")\n print(\"\\tExpected True, but got False for word: '\" + word + \"' and hand:\", handOrig)\n\n failure = True\n\n # Test a second time to see if word_list or hand has been modified\n if not is_valid_word(word, handCopy, word_list):\n print(\"FAILURE: test_is_valid_word()\")\n\n if handCopy != handOrig:\n print(\"\\tTesting word\", word, \"for a second time - be sure you're not modifying hand.\")\n print(\"\\tAt this point, hand ought to be\", handOrig, \"but it is\", handCopy)\n\n else:\n print(\"\\tTesting word\", word, \"for a second time - have you modified word_list?\")\n wordInWL = word in word_list\n print(\"The word\", word, \"should be in word_list - is it?\", wordInWL)\n\n print(\"\\tExpected True, but got False for word: '\" + word + \"' and hand:\", handCopy)\n\n failure = True\n\n\n # test 2\n hand = {'r': 1, 'a': 3, 'p': 2, 'e': 1, 't': 1, 'u':1}\n word = \"Rapture\"\n\n if is_valid_word(word, hand, word_list):\n print(\"FAILURE: test_is_valid_word()\")\n print(\"\\tExpected False, but got True for word: '\" + word + \"' and hand:\", hand)\n\n failure = True \n\n # test 3\n hand = {'n': 1, 'h': 1, 'o': 1, 'y': 1, 'd':1, 'w':1, 'e': 2}\n word = \"honey\"\n\n if not is_valid_word(word, hand, word_list):\n print(\"FAILURE: test_is_valid_word()\")\n print(\"\\tExpected True, but got False for word: '\"+ word +\"' and hand:\", hand)\n\n failure = True \n\n # test 4\n hand = {'r': 1, 'a': 3, 'p': 2, 't': 1, 'u':2}\n word = \"honey\"\n\n if is_valid_word(word, hand, word_list):\n print(\"FAILURE: test_is_valid_word()\")\n print(\"\\tExpected False, but got True for word: '\" + word + \"' and hand:\", hand)\n \n failure = True\n\n # test 5\n hand = {'e':1, 'v':2, 'n':1, 'i':1, 'l':2}\n word = \"EVIL\"\n \n if not is_valid_word(word, hand, word_list):\n print(\"FAILURE: test_is_valid_word()\")\n print(\"\\tExpected True, but got False for word: '\" + word + \"' and hand:\", hand)\n \n failure = True\n \n # test 6\n word = \"Even\"\n\n if is_valid_word(word, hand, word_list):\n print(\"FAILURE: test_is_valid_word()\")\n print(\"\\tExpected False, but got True for word: '\" + word + \"' and hand:\", hand)\n print(\"\\t(If this is the only failure, make sure is_valid_word() isn't mutating its inputs)\") \n \n failure = True \n\n if not failure:\n print(\"SUCCESS: test_is_valid_word()\")","def words(self, word):\n pass","def simple_unique_characters(word):\n return len(set(word)) == len(word)","def play_game(word_list):\n # TO DO...\n print 'Welcome to the 6.00 Word Game!'\n hand = deal_hand(HAND_SIZE) \n while True:\n choice1 = raw_input('Enter \"n\" for a new hand, \"r\" to repeat the last hand, or \"e\" to exit the game: ')\n if choice1 not in ('ren'):\n print 'invalid choice'\n continue\n if choice1 == 'e': break\n while True:\n choice2 = raw_input('Enter \"u\" to play the hand yourself or \"c\" to let the computer play the hand: ') \n if choice2 not in ('uc'):\n print 'invalid choice'\n continue\n else: break \n if choice1 == 'r':\n if choice2 == 'u': play_hand(hand, word_list)\n else: comp_play_hand(hand, word_list)\n else: \n hand= deal_hand(HAND_SIZE) \n if choice2 == 'u': play_hand(hand, word_list)\n else: comp_play_hand(hand, word_list)","def word_count(text, word):\n \n #answer\n word_list = text.split(\" \")\n return (word_list.count(word))\n \n #return (text.count(word)) - deoesn't work","def find_letters_not_display(guess, secret_word):\n return set(secret_word) - set(guess)","def _internal_contains(self, letters):\n len_letters = len(letters)\n for word in self.words:\n len_word = len(word)\n word_with_letters_removed = WordUtils.remove_letters_from_word(word, letters)\n if len(word_with_letters_removed) == (len_word - len_letters):\n yield word","def letter_picker(self):\r\n \r\n self.letter_count = dict.fromkeys(string.ascii_lowercase, 0) # reset\r\n for word in self.valid_words:\r\n word = \"\".join(set(word)) # removes duplicate letters in valid words\r\n for letter in word:\r\n self.letter_count[letter] += 1\r\n for letter in self.guesses: # prevents repeating guesses\r\n self.letter_count[letter] = 0\r\n self.chosen_letter = max(self.letter_count, key=self.letter_count.get)\r\n self.guesses.append(self.chosen_letter)\r\n print(f\"{self.chosen_letter} is the letter I think is right\")","def phrase_guessed(self):\r\n count = 0\r\n\r\n for letter in self.phrase:\r\n if letter == ' ':\r\n count += 1\r\n else:\r\n if letter.was_guessed:\r\n count += 1\r\n if count == len(self.phrase):\r\n return True\r\n return False","def count(word):\n\n return len(word)","def check_win(secret_word, old_letters_guessed):\n for i in secret_word:\n if i not in old_letters_guessed:\n return False\n # all letters from secret_word are in old_letters_guessed - the player won\n return True"],"string":"[\n \"def isValidWord(word, hand, wordList):\\n myHand = hand.copy() \\n for letter in word:\\n if letter not in hand or myHand[letter] <= 0:\\n return False\\n else:\\n myHand[letter] -= 1 \\n if word not in wordList:\\n return False\\n else:\\n return True\",\n \"def isValidWord(word, hand, wordList):\\n tempHand = hand.copy()\\n if len(word) > 0 and word in wordList:\\n for letter in word:\\n if letter not in tempHand or tempHand[letter] <= 0:\\n return False\\n else:\\n tempHand[letter] = tempHand.get(letter, 0) - 1\\n return True\\n return False\",\n \"def isValidWord(word, hand, wordList):\\r\\n \\r\\n \\r\\n if type(word) != str:\\r\\n return False\\r\\n \\r\\n if word not in wordList:\\r\\n return False\\r\\n \\r\\n for letter in word:\\r\\n if letter not in hand:\\r\\n return False\\r\\n \\r\\n updatedHand = hand.copy()\\r\\n # copy hand as to not mutate the hand passed in\\r\\n \\r\\n for letter in word:\\r\\n if letter in updatedHand:\\r\\n updatedHand[letter] -= 1\\r\\n \\r\\n for letter in word:\\r\\n if updatedHand[letter] < 0:\\r\\n return False\\r\\n \\r\\n return True\",\n \"def isValidWord(word, hand, wordList):\\n if word not in wordList:\\n print('word not in wordList')\\n return False\\n else:\\n for letter in word:\\n if letter not in hand:\\n print('letter not in hand')\\n return False\\n else:\\n newHand = hand.copy()\\n for letter in word:\\n if letter not in newHand: # this if statement is here to prevent keyError\\n print('letter not in newHand')\\n return False\\n else:\\n newHand[letter] = newHand[letter] - 1\\n if newHand[letter] < 0:\\n print('no letter left')\\n return False\\n return True\",\n \"def isValidWord(word, hand, wordList):\\n # TO DO ... <-- Remove this comment when you code this function\\n if word not in wordList:\\n return False\\n dic={}\\n for k in hand:\\n dic[k]=hand[k] \\n for w in word:\\n a=dic.get(w,0)\\n if a > 0:\\n dic[w]=a-1\\n else:\\n return False\\n return True\",\n \"def is_valid_word(word, hand, word_list):\\n h = dict(hand)\\n if word.lower() in word_list:\\n for letter in word:\\n if h.get(letter, 0) == 0:\\n return False\\n else:\\n h[letter] -= 1\\n else:\\n return False\\n return True\",\n \"def isValidWord(word, hand, wordList):\\n output = hand.copy()\\n word_check = False\\n if word in wordList:\\n word_check = True\\n \\n letter_check = set(list(word)) <= set(output.keys())\\n \\n for letter in word:\\n if letter in output.keys():\\n output[letter] -= 1\\n \\n value_check = all(i >= 0 for i in output.values())\\n \\n if word_check == True and letter_check == True and value_check == True:\\n return True\\n else:\\n return False\",\n \"def is_validword(word, hand, word_list1):\\n # TO DO ... <-- Remove this comment when you code this function\\n word_list = []\\n cnt_1 = 0\\n for i in word:\\n word_list += i.split(\\\",\\\")\\n for i in word_list:\\n if i in hand.keys():\\n cnt_1 += 1\\n if cnt_1 == len(word) and word in word_list1:\\n score = get_word_score(word, n_num)\\n update_hand(hand, word)\\n else:\\n print(\\\"Invalid Word\\\")\",\n \"def isValidWord(word, hand, wordList):\\n status = []\\n status2 = []\\n\\n # check if the input is valid\\n if not word in wordList:\\n return False\\n \\n for letter in word:\\n \\n ## commented out bc global var not available for the individual exercise\\n # if not letter in SCRABBLE_LETTER_VALUES.keys():\\n # status.append(False)\\n \\n if not letter in hand.keys():\\n status.append(False)\\n \\n if False in status:\\n return False\\n \\n # check if there are enough values in hand for the guess\\n for key, value in getFrequencyDict(word).items():\\n \\n if not key in hand or value > hand[key]:\\n status2.append(False)\\n\\n if False in status2:\\n return False\\n \\n return True\",\n \"def isValidWord(word, hand, wordList):\\n # TO DO ... <-- Remove this comment when you code this function\\n #for line in fil:\\n # print line\\n if word not in w:\\n w.append(word)\\n #print w\\n else:\\n #print \\\"already have a word inside\\\"\\n return False\\n for z in word:\\n print z\\n if z in hand:\\n #if p != word:\\n #print hand[c]\\n if hand[z] > 0:\\n hand[z] -= 1\\n \\n else:\\n return False\\n else:\\n return False\\n if word in wordList:\\n print \\\"here is true\\\"\\n return True\\n else:\\n return False\",\n \"def is_valid_word(word, hand, word_list):\\r\\n # TO DO ...\\r\\n word_freq_dict = get_frequency_dict(word)\\r\\n for letter in word_freq_dict:\\r\\n if letter not in hand or hand[letter] - word_freq_dict[letter] < 0:\\r\\n return False\\r\\n return word in word_list\",\n \"def isValidWord(word: str, hand: Dict[str, int], wordList: List[str]) -> bool:\\n cp_hand = hand.copy()\\n\\n if word not in wordList:\\n return False\\n\\n for char in word:\\n if cp_hand.get(char, 0) < 1:\\n return False\\n else:\\n cp_hand[char] = cp_hand.get(char,0) - 1\\n\\n return True\\n # one line:\\n # return word in wordList and all(word.count(c) <= hand.get(c, 0) \\n # for c in word) # Kiwitrader\",\n \"def isValidWord(word, hand, wordList):\\n wordTest = word.lower()\\n handcopy = hand.copy()\\n for i in wordTest:\\n if i not in 'abcdefghijklmnopqrstuvwxyz':\\n return False\\n if wordTest not in wordList:\\n return False\\n else:\\n for i in word:\\n if i not in handcopy:\\n return False\\n else:\\n if handcopy[i]==0:\\n return False\\n if handcopy.get(i,0) !=0:\\n handcopy[i]-=1\\n if handcopy.get(i,0)<0:\\n return False\\n return True\",\n \"def is_valid_word(word, hand, word_list):\\n failure=True\\n word=word.lower()\\n if word not in word_list:\\n failure=False\\n for i in word:\\n w=hand.get(i,0)\\n if w==0:\\n failure=False\\n break\\n return failure\",\n \"def updateHand(hand, word):\\n tempHand = hand.copy()\\n for letters in word:\\n if letters in tempHand:\\n tempHand[letters] -= 1\\n return tempHand\",\n \"def isValidWord(word, hand, wordList):\\r\\n # TO DO ... <-- Remove this comment when you code this function\\r\\n \\r\\n newword = {}\\r\\n for x in word:\\r\\n newword[x] = newword.get(x,0) + 1\\r\\n \\r\\n for l in newword:\\r\\n if newword.get(l,0) > hand.get(l, 0):\\r\\n return False\\r\\n \\r\\n is_valid = False\\r\\n for n in wordList:\\r\\n if word == n:\\r\\n return True\\r\\n \\r\\n return False\",\n \"def isValidWords(word, hand, wordList):\\n #tothand = 0\\n #w = []\\n # TO DO ... <-- Remove this comment when you code this function\\n #for line in fil:\\n # print line\\n #if word not in w:\\n # w.append(word)\\n #print word\\n #for h in hand:\\n # global tothand\\n # tothand += hand[h]\\n #print tothand\\n # if tothand == 0:\\n if word in wordList:\\n #print wordList\\n print \\\"word found\\\"\\n return True\\n else:\\n print \\\"Not a word\\\"\\n return False\\n \\n #else:\\n # return True\",\n \"def updateHand(hand, word):\\n output = hand.copy()\\n for letter in word:\\n if letter in output.keys():\\n output[letter] -= 1\\n return output\",\n \"def can_make_word(word, letters):\\n grouped_chars = group_input(word)\\n for char in letters:\\n\\n if is_empty(grouped_chars):\\n return True\\n\\n if char in grouped_chars and grouped_chars[char] > 0:\\n grouped_chars[char] -= 1\\n\\n return is_empty(grouped_chars)\",\n \"def is_valid_word(word_test, hand_word, word_list):\\n count = 0\\n word_test = list(word_test)\\n for i_1 in word_test:\\n if i_1 in hand_word:\\n count += count\\n if count == len(word_test) and word_test[i_1] == word_list[i_1]:\\n return True\\n return False\",\n \"def dealHand():\\n import random\\n import string\\n \\n vowels = 'aeiou'\\n constant = 'bcdfghjklmnpqrstvwxyz'\\n \\n maxint = max(list(map(len, wordlist)))\\n \\n n = random.randint(5, maxint) \\n \\n # 1/3 vowls\\n n_vowl = n // 3\\n n_constant = n - n//3\\n \\n get_vowl = random.choices(vowels, k = n_vowl)\\n get_constant = random.choices(constant, k = n_constant)\\n \\n strings = ''.join(get_vowl + get_constant)\\n \\n hand = getFreqDict(strings)\\n \\n return hand\",\n \"def comp_choose_word(hand, word_list):\\n hand_length = 0\\n for v in hand.values():\\n hand_length += v\\n\\n word_choices = []\\n\\n for num in range(1, hand_length + 1):\\n num_perms = get_perms(hand, num)\\n for perm in num_perms:\\n if perm in word_list:\\n word_choices.append(perm)\\n\\n comp_word = ''\\n\\n for word in word_choices:\\n score = get_word_score(word, hand_length)\\n if score > get_word_score(comp_word, hand_length):\\n comp_word = word\\n\\n return comp_word\",\n \"def updateHand(hand: d_si, word: str) -> d_si:\\n cp_hand = hand.copy()\\n\\n for char in word:\\n cp_hand[char] = cp_hand.get(char, 0) - 1\\n return cp_hand\\n # One line:\\n # return {char: hand[char] - word.count(char) for char in hand} # Kiwitrade\",\n \"def count_words(word, words):\\n same_words_in_message = 0\\n for element in words:\\n if element == word:\\n same_words_in_message += 1\\n return same_words_in_message\",\n \"def isvalid_word1(word, hand, word_list1):\\n # TO DO ... <-- Remove this comment when you code this function\\n for i in word:\\n if i not in hand:\\n return False\\n i = i\\n return word in word_list1\",\n \"def containing(letter, text):\\n return([word for word in text if word.count(letter) >= 1])\",\n \"def updateHand(hand, word):\\r\\n handTemp = dict(hand)\\r\\n for letter in word:\\r\\n handTemp[letter] -= 1\\r\\n return handTemp\",\n \"def update_hand(hand, word):\\n for i in word:\\n hand[i] -= 1\\n\\n return hand\",\n \"def comp_choose_word(hand, word_list):\\n maxscore = 0\\n maxword = \\\"\\\" \\n for n in range(calculate_handlen(hand)):\\n perms = get_perms(hand, n)\\n for word in perms:\\n wordscore = get_word_score(word, HAND_SIZE)\\n if wordscore > maxscore:\\n if word not in word_list:\\n continue\\n else:\\n maxscore = wordscore\\n maxword = word\\n return maxword\\n # TO DO...\",\n \"def getWordScore(word, n):\\n score = 0\\n\\n for letters in word:\\n if letters in SCRABBLE_LETTER_VALUES:\\n score += SCRABBLE_LETTER_VALUES[letters]\\n\\n if len(word) == n:\\n return (score * len(word)) + 50\\n else:\\n return score * len(word)\",\n \"def puzzle(word_list):\\n \\n multiple_stroke_letters = ['i','j','t','x']\\n for word in word_list:\\n if word.count('i')==1 and word.count('j')==1 and word.count('t')==1 \\\\\\n and word.count('x')==1:\\n print(word)\\n break\",\n \"def getWordScore(word, n):\\n score=0\\n for i in range(len(word)):\\n addition=SCRABBLE_LETTER_VALUES[word[i]]\\n score+=addition*(len(word))\\n if len(word)==n:\\n score+=50\\n return score\",\n \"def tell_me(self,secret,dashes):\\n\\n\\n result=\\\"\\\"\\n self.total=0\\n for i in range(len(secret)):\\n if secret[i] != dashes[i]:\\n result=result+secret[i]\\n\\n\\n self.total=self.total+String_Database.frequency.get(secret[i])\\n\\n self.status=\\\"Gave up\\\"\\n\\n print(\\\"The corect word is : \\\", secret,\\\", you missed :\\\",\\\"letters: \\\",result)\\n self.finalScore=0-self.total\\n\\n\\n return 1\",\n \"def print_uses_all():\\n str = input('Enter a string of letters, please:')\\n\\n count_uses_all = 0\\n for line in fin:\\n word = line.strip()\\n if uses_all(word, str):\\n print(word)\\n count_uses_all += 1\\n print('Number of words that use all letters in the string:', count_uses_all)\",\n \"def get_word_score(word, n=7):\\n score = 0\\n\\n for i in word:\\n score += SCRABBLE_LETTER_VALUES[i]\\n\\n if len(word) == n:\\n score += 50\\n\\n return score\",\n \"def getWordScore(word: str, n: int) -> int:\\n # (SCRABBLE_LETTER_VALUES[char]) rise a exception if char not in SCRABBL...\\n ans = sum(SCRABBLE_LETTER_VALUES.get(char, 0) for char in word) * len(word)\\n\\n # [if False, if True] [condition] (ternary op)\\n return [ans, ans + 50] [len(word) == n]\",\n \"def find_all(letter_guess, generated_word):\\n return [i for i, letter in enumerate(generated_word) if letter == letter_guess]\",\n \"def comp_choose_word(hand, word_list):\\n perms_list = []\\n for i in range(1, HAND_SIZE+1):\\n perms_list.extend(get_perms(hand, i))\\n perms_valid = []\\n for j in range(0, len(perms_list)):\\n word = perms_list[j]\\n if is_valid_word(word, hand, word_list):\\n perms_valid.append(word)\\n\\n \\n\\n\\n\\n\\n\\n valid_scores = []\\n for k in range(0, len(perms_valid)):\\n valid_scores.append(get_word_score(perms_valid[k], HAND_SIZE))\\n valid_words = perms_valid[k]\\n\\n # Compare first two scores and put highest score and corresponding word in seprate variables\\n # respectively.\\n max_score = 0\\n max_word = ''\\n for j in range(0, len(valid_scores)):\\n if max_score < valid_scores[j]:\\n max_score = valid_scores[j]\\n max_word = perms_valid[j]\\n return max_word\",\n \"def check_win(secret_word, old_letters_guessed):\\n j=len(secret_word)\\n for i in secret_word:\\n j -= 1\\n if i in old_letters_guessed:\\n if j == 0:\\n return True\\n else: \\n continue\\n else:\\n return False\",\n \"def try_to_guess(word):\\n\\n # set number of tries based on word length\\n if 4 < len(word) < 7:\\n tries = 4\\n elif 7 < len(word) < 12:\\n tries = 8\\n else:\\n tries = 12\\n \\n # create placeholder word eg: ---\\n placeholder = ['-' for _ in range(len(word))]\\n \\n # list to check if letter was already guessed\\n guesses = []\\n\\n while tries > 0:\\n print('\\\\n' + ''.join(placeholder))\\n letter = str(input(f\\\"Input a letter: \\\"))\\n\\n # only one lower case alphanum character\\n if len(letter) > 1:\\n print(\\\"You should input a single letter\\\")\\n elif not letter.isalnum() or not letter.islower():\\n print(\\\"It is not an ASCII lowercase letter\\\")\\n \\n elif letter in guesses:\\n print(\\\"You already typed this letter\\\") \\n elif letter not in word:\\n print(\\\"No such letter in the word\\\")\\n tries -= 1\\n \\n # we have a good letter\\n else:\\n for i, v in enumerate(word):\\n \\n if v == letter:\\n placeholder[i] = letter\\n \\n if ''.join(placeholder) == word:\\n print()\\n print(''.join(placeholder))\\n print(\\\"You guessed the word!\\\\nYou survived!\\\")\\n return\\n \\n guesses.append(letter)\\n \\n else:\\n print(\\\"You lost!\\\")\\n print(f\\\"The word was {word}\\\")\",\n \"def check_match(self, word_found,word): \\r\\n self.count = 0\\r\\n for char in self.word_found:\\r\\n if char != self.word[self.count]:\\r\\n return False\\r\\n self.count +=1\\r\\n #print(self.count)\\r\\n \\r\\n return True\",\n \"def check_crossword(self, letter, space, cross):\\n if cross == ('', ''):\\n return 0\\n\\n pre, post = cross\\n crossword = pre + letter + post\\n if self.is_word(crossword):\\n score = self.score_factory.make()\\n score.add(letter, space)\\n rest = pre + post\\n for let in rest:\\n score.add(let)\\n return score.get_points()\\n return None\",\n \"def getWordScore(word, n):\\n score = 0\\n for letter in word:\\n score += SCRABBLE_LETTER_VALUES[letter]\\n score *= len(word)\\n if len(word) == n:\\n score += 50\\n return score\",\n \"def word_check(word):\\n word1 = word[1:]\\n if word1 not in word_dict: return False\\n if not homophones (word, word1): return False\\n \\n \\n word2 = word[0] + word[2:]\\n if word2 not in word_dict: return False\\n if not homophones(word, word2): return False\\n\\n return True\",\n \"def most_repeating_letter_count(word):\\n return Counter(word.lower()).most_common(1)[0][1]\",\n \"def updateHand(hand, word):\\r\\n update_hand = hand.copy()\\r\\n for i in word:\\r\\n update_hand[i] -= 1\\r\\n return update_hand\",\n \"def monkey_typing(text: str, words: set) -> int:\\n # simple solution\\n # counter = [chunk for chunk in words if chunk in text.lower()]\\n\\n # my solution\\n text_split = text.lower().split(\\\" \\\")\\n if not all(len(w) >= 3 and w.islower() and w.isalpha for w in words):\\n return 0\\n score = 0\\n eliminated = []\\n for text_chunk in text_split:\\n words_to_count = words\\n for word in words_to_count:\\n if word.lower() in text_chunk and word.lower() not in eliminated:\\n score += 1\\n eliminated.append(word)\\n return score\",\n \"def basic_check(word):\\n if word[-1] == \\\"b\\\" or word[-1] == \\\"g\\\":\\n return False\\n consonant_counter = 0\\n for char in word:\\n if char in VOWELS:\\n consonant_counter = 0\\n else:\\n consonant_counter += 1\\n if consonant_counter >= 3:\\n return False\\n return True\",\n \"def is_word_guessed(secret_word, letters_guessed):\\n for char in secret_word:\\n flag = False\\n for letter in letters_guessed:\\n if char == letter:\\n flag = True\\n if flag == False:\\n break\\n\\n return flag\",\n \"def allPossibleWords(Rack):\\n def checkWord(word):\\n return stringInRack(word,Rack)\\n return filter(checkWord, Dictionary)\",\n \"def is_word_guessed(secret_word, letters_guessed):\\n\\n for letter in secret_word:\\n if letter in letters_guessed:\\n pass\\n else:\\n return False\\n return True\",\n \"def nextLetter(self):\\r\\n self.filterPossibleWords()\\r\\n \\r\\n letterCount = len(self.unusedLetters) * [0]\\r\\n\\r\\n # Count the number of words each letters appears in\\r\\n for word in self.wordList:\\r\\n for i in range(len(self.unusedLetters)):\\r\\n # Don't count letters already discovered\\r\\n if self.unusedLetters[i] not in self.currentBoard and self.unusedLetters[i] in word:\\r\\n letterCount[i] += 1\\r\\n \\r\\n # Determine which letter appeared in the most words\\r\\n highCount = max(letterCount)\\r\\n highCountIndexes = []\\r\\n \\r\\n # Gather all the letters that tied for the highest count\\r\\n for j in range(len(letterCount)):\\r\\n if letterCount[j] == highCount:\\r\\n highCountIndexes += [j]\\r\\n\\r\\n # Break any ties randomly\\r\\n choice = random.choice(highCountIndexes)\\r\\n\\r\\n chosenLetter = self.unusedLetters[choice]\\r\\n self.unusedLetters.remove(chosenLetter)\\r\\n return chosenLetter\",\n \"def count(self, word):\\n pass\",\n \"def guess_word():\\n words = [\\\"tom\\\", \\\"jerry\\\", \\\"apple\\\", \\\"banana\\\", \\\"peal\\\", \\\"water\\\", \\\"ice\\\", \\\"one\\\", \\\"tw0\\\", \\\"three\\\"]\\n word = list(words[random.randint(0, len(words)-1)])\\n print(word)\\n length = len(word)\\n underline = [\\\"_ \\\" for i in range(length)]\\n count = 5\\n while count > 0:\\n # 输出当前状态\\n output = \\\"\\\".join(underline)\\n print(output)\\n guess = input(\\\"guess a char(left guess %d times ):\\\" % (count))\\n if guess in word:\\n index = word.index(guess)\\n underline[index] = guess\\n word[index] = \\\" \\\"\\n else:\\n count -= 1\\n # 跳出循环的条件\\n if word.count(\\\" \\\") == length:\\n break\\n if count > 0:\\n print(\\\"yur are right!\\\")\\n else:\\n print(\\\"游戏结束！你没有猜对。\\\")\",\n \"def countCharacters(self, words, chars):\\n chars_dict = self.count_to_dict(chars)\\n chars_set = chars_dict.keys()\\n len_chars_set = len(chars_set)\\n \\n good_string = ''\\n for words_i in words:\\n word_dict = self.count_to_dict(words_i)\\n words_i_set = word_dict.keys()\\n check = 0\\n for i in words_i_set:\\n if i not in chars_set:\\n check+=1\\n break\\n if word_dict[i] > chars_dict[i]:\\n check+=1\\n break\\n if check == 1:\\n continue\\n good_string = good_string+words_i\\n return len(good_string)\",\n \"def viableWord(self, word, filledInSpaces):\\r\\n \\r\\n # Check if it fits blanks\\r\\n for (index, letter) in filledInSpaces:\\r\\n if letter != word[index]:\\r\\n return False\\r\\n\\r\\n # Check if it fits unused\\r\\n for letter in word:\\r\\n if letter in self.wrongLetters:\\r\\n return False\\r\\n\\r\\n return True\",\n \"def substitute_hand(hand, letter):\\n copies = hand.get(letter,0)\\n newHand = hand.copy()\\n allletters = VOWELS+CONSONANTS \\n if not copies:\\n print ('You don\\\\'t have a '+letter+' in your hand.')\\n return hand\\n else:\\n for c in newHand:\\n if c =='*':\\n pass\\n elif allletters.find(c)==0: \\n #print ('Removing '+c+'.')\\n allletters = allletters[1:]\\n elif allletters.find(c)==len(allletters):\\n #print ('Removing '+c+'.')\\n allletters = allletters[0:len(allletters)]\\n else:\\n #print ('Removing '+c+'.')\\n allletters = allletters[0:allletters.find(c)] + allletters[allletters.find(c)+1:]\\n #print ('Choice for newletter: '+allletters)\\n for i in range (copies):\\n newletter = random.choice(allletters)\\n print ('Dealing new letter '+newletter)\\n newHand[newletter] = newHand.get(newletter, 0)+1\\n \\n return newHand\",\n \"def guessing():\\r\\n word = random_word()\\r\\n word_guess = ['_' for _ in word]\\r\\n letters = set()\\r\\n guesses = 6\\r\\n\\r\\n print('Your Word:')\\r\\n print(' '.join(word_guess) + '\\\\n')\\r\\n\\r\\n while '_' in word_guess and guesses > -1:\\r\\n guess = input('Guess your letter: ').upper()\\r\\n if guess == 'EXIT':\\r\\n print('\\\\nThe game had been ended.\\\\n')\\r\\n sys.exit()\\r\\n elif guess in string.ascii_uppercase:\\r\\n if guess == '':\\r\\n print('Not a letter!\\\\n')\\r\\n elif guess in letters:\\r\\n print('Letter already taken!\\\\n')\\r\\n elif guess in word:\\r\\n for i in range(len(word)):\\r\\n if word[i] == guess:\\r\\n word_guess[i] = guess\\r\\n print(' '.join(word_guess) + '\\\\n')\\r\\n if ''.join(word_guess) == word:\\r\\n print('You win!\\\\n')\\r\\n else:\\r\\n guesses -= 1\\r\\n print('Incorrect!')\\r\\n if guesses == -1:\\r\\n make_drawing(guesses)\\r\\n print('\\\\nYou hang!')\\r\\n print(f'The full word was: {\\\" \\\".join(list(word))}\\\\n')\\r\\n elif guesses == 1:\\r\\n make_drawing(guesses)\\r\\n print(f'You have {guesses} wrong guess left.\\\\n')\\r\\n else:\\r\\n make_drawing(guesses)\\r\\n print(f'You have {guesses} wrong guesses left.\\\\n')\\r\\n letters.add(guess)\\r\\n else:\\r\\n print('Not a letter!\\\\n')\",\n \"async def words(self, ctx, *, message):\\n doc = str(message)\\n res = str(sum([i.strip(string.punctuation).isalpha() for i in doc.split()]))\\n final = \\\"\\\"\\n if res == \\\"1\\\":\\n final += \\\"Your message is only **1** word.\\\"\\n else:\\n final += f'Your message is **{res}** words long.'\\n await ctx.send(final)\",\n \"def choose_letter_in_word(word,list_letter,pattern):\\r\\n for j in range(len(str(word))):\\r\\n if word[j] not in pattern:\\r\\n index= letter_to_index(word[j])\\r\\n list_letter[index] += 1\\r\\n return list_letter\",\n \"def check_win(secret_word, old_letters_guessed):\\n returned_list = list(secret_word)\\n for i in range(len(secret_word)):\\n if secret_word[i] in old_letters_guessed:\\n returned_list[i] = secret_word[i] + ' '\\n else:\\n returned_list[i] = '_ '\\n returned_str = ''.join(returned_list)\\n\\n string_no_spaces = returned_str.replace(\\\" \\\", \\\"\\\")\\n if string_no_spaces == secret_word:\\n return True\\n else:\\n return False\",\n \"def letter_text_analyzer(text, letter):\\n count = 0\\n text_mod = \\\"\\\"\\n for char in text:\\n if char not in string.punctuation:\\n text_mod += char\\n text_split = text_mod.split()\\n\\n for word in text_split:\\n if letter in word:\\n count += 1\\n result = \\\"Your text contains {0} words,of which {1} ({2:.1%}) contain an '{3}'\\\"\\n\\n return result.format(len(text_split), count, count / len(text_split), letter)\",\n \"def is_word_complete(word, guesses):\\n # go through each letter of the word\\n # if the letter is not in guesses then False\\n # if you don't get any false, then you can consider True\\n\\n for letter in word:\\n if letter not in guesses:\\n return False\\n return True\",\n \"def calculate_score(rack,word):\\n score = 0\\n\\n for letter in word:\\n score += SCORE_DICT[letter]\\n if len(rack) < 7:\\n score = score\\n else:\\n if len(word) >= len(rack):\\n score = (score + 50)\\n return score\",\n \"def play_word(self):\\n new_tiles = {}\\n placed_tiles_computer = []\\n\\n # from the rack, get the word to be played, and add the score\\n computer_rack = self.rack\\n self.board.generate_moves(computer_rack)\\n # tiles that make up the word in the board\\n word_tiles = self.board.best_move_cell()\\n self.board.cross_checks_sums(word_tiles)\\n self.score += self.board.compute_score(word_tiles)\\n self.board.placed_cell_cleanup(word_tiles)\\n\\n # from the tiles of the word formed on the board, retrieves the indices\\n # of which tiles were the ones that were played from the rack\\n for tile in word_tiles:\\n for i in range(len(computer_rack)):\\n if tile.letter == computer_rack[i]:\\n if i in placed_tiles_computer:\\n continue\\n placed_tiles_computer.append(i)\\n break\\n\\n # gets new tiles from the bag for every tile that was played\\n for t in placed_tiles_computer:\\n new_tile = self.board.draw_random_tile()\\n if new_tile != None:\\n new_tiles[t] = new_tile\\n self.rack[t] = new_tiles[t]\\n else:\\n return False\\n return True\",\n \"def guess_word(ga, word, ch):\\n flag = 0\\n sd = stringDatabase\\n gameword = list(word)\\n gamewordlen = len(gameword)\\n\\n # Checks if the option/choice is 'l'\\n if ch == 'l':\\n gl = sd.StringDatabase.get_letter()\\n if not gl:\\n return\\n # print('here')\\n if gl in gameword:\\n if gl in ga.guess_list:\\n print('Already flipped the letter, Guess another letter')\\n return\\n n = gameword.count(gl)\\n print('You found', n, 'letter/s')\\n for i in range(gamewordlen):\\n if gameword[i] == gl:\\n ga.guess_list[i] = gl\\n if ga.guess_list == gameword:\\n flag = 1\\n ga.status = 'Success'\\n print('Correct Guess!!')\\n ga.calculate_score()\\n else:\\n print('You found 0 new letter/s, Try Again')\\n ga.missed_letter += 1\\n if ga.score == 0:\\n ga.score -= 1\\n else:\\n ga.score -= (ga.score/4)\\n per = (ga.score*10)/100\\n ga.score -= per\\n\\n # Checks if the option/choice is 'g'\\n if ch == 'g':\\n gl = list(sd.StringDatabase.get_word())\\n # print('\\\\n')\\n if gl == gameword:\\n count = 0\\n for i in range(gamewordlen):\\n if gameword[i] != ga.guess_list:\\n count += 1\\n if count >= 1:\\n ga.calculate_score()\\n ga.score += 10\\n ga.status = 'Success'\\n print('Correct guess!!')\\n flag = 1\\n else:\\n ga.bad_guess += 1\\n print('Wrong guess, Try Again')\\n per = (ga.score * 30) / 100\\n ga.score -= per\\n\\n # Checks if the option/choice is 't'\\n if ch == 't':\\n ga.score = ga.score/2\\n ga.calculate_minus_score()\\n ga.status = 'Gave up'\\n print('Correct word is: ' + word)\\n flag = 1\\n\\n return flag\",\n \"def get_pure_user_words(user_words, letters, words_from_dict):\\n checked_user_words = []\\n for each_user_word in user_words:\\n if 4 <= len(each_user_word) <= 9:\\n if letters[4] in each_user_word:\\n count = 0\\n for each_user_let in each_user_word:\\n if each_user_let in letters:\\n count += 1\\n if count == len(each_user_word):\\n checked_user_words.append(each_user_word)\\n for each_word in checked_user_words:\\n count_let = 0\\n if each_word in words_from_dict:\\n checked_user_words.remove(each_word)\\n for each_word in checked_user_words:\\n coun_me = 0\\n for each_let in each_word:\\n if each_word.count(each_let) <= letters.count(each_word):\\n count_me += 1\\n if count_me == len(each_word):\\n checked_user_words.remove(each_word)\\n return (checked_user_words)\",\n \"def usedWord(afz, word, output=True):\\n count = 0\\n for msg in msgs:\\n if msg.afz == afz:\\n if word.lower() in msg.msg.lower():\\n count = count + 1\\n print afz, 'heeft', count, 'keer het woord', word, 'gebruikt.'\",\n \"def word_length_check(self):\\r\\n \\r\\n for word in self.all_words:\\r\\n if len(word) == len(self.best_guess):\\r\\n self.valid_words.add(word)\",\n \"def get_word_weight(words, word):\\n weight = 0\\n for w in words:\\n if not any(c in word for c in w):\\n weight += 1\\n\\n return weight\",\n \"def is_isogram(word):\\n word = [char.lower() for char in word if char.isalpha()]\\n for char in word:\\n if word.count(char) > 1:\\n return False\\n return True\",\n \"def user_avoid_count():\\n\\tforbidden = input('Enter a string of forbidden letters.\\\\n> ')\\n\\tprint(len({w for w in word_set if avoids(w, forbidden)}))\",\n \"def remove_letters(available, word):\\n count_different_letters_in_word = 0\\n\\n for letter in available:\\n if letter in word:\\n count_different_letters_in_word += 1\\n available = available.replace(letter, '')\\n else:\\n pass\\n dic = {'count': count_different_letters_in_word, 'available': available}\\n return dic\",\n \"def computerWordPick(Length):\\n for word in MakeMyDictionary('american-english.txt'):\\n pick = random.choice(MakeMyDictionary('american-english.txt'))\\n pickLength = len(pick) \\n if pickLength != Length:\\n pick\\n else:\\n return pick\",\n \"def onlyuse(word, letters):\\r\\n truth = True\\r\\n for letter in word:\\r\\n truth = letter in letters and truth\\r\\n return truth\",\n \"def uses_only(word, available):\\n for letter in word:\\n if letter not in available:\\n return False\\n return True\",\n \"def guess_letter(self):\\r\\n letter = input(\\\"# Enter a Letter :\\\")\\r\\n if not letter:\\r\\n print(\\\"Please Enter a Valid Value\\\")\\r\\n else:\\r\\n result = game_instance.check_letter(letter)\\r\\n\\r\\n if result == \\\"NOT FOUND\\\":\\r\\n print(\\\"WRONG. No corresponding letters found in the word. Try Again!\\\")\\r\\n else:\\r\\n temp = list(self.current_word)\\r\\n count=0;\\r\\n for x in result:\\r\\n count+=1\\r\\n temp[x] = letter\\r\\n self.current_word = \\\"\\\".join(temp)\\r\\n print(\\\"Good Job. You Found \\\"+str(count)+\\\" Letters.\\\")\",\n \"def test_wildcard(word_list):\\n failure=False\\n\\n # test 1\\n hand = {'a': 1, 'r': 1, 'e': 1, 'j': 2, 'm': 1, '*': 1}\\n word = \\\"e*m\\\"\\n\\n if is_valid_word(word, hand, word_list):\\n print(\\\"FAILURE: test_is_valid_word() with wildcards\\\")\\n print(\\\"\\\\tExpected False, but got True for word: '\\\" + word + \\\"' and hand:\\\", hand)\\n\\n failure = True\\n\\n # test 2\\n hand = {'n': 1, 'h': 1, '*': 1, 'y': 1, 'd':1, 'w':1, 'e': 2}\\n word = \\\"honey\\\"\\n\\n if is_valid_word(word, hand, word_list):\\n print(\\\"FAILURE: test_is_valid_word() with wildcards\\\")\\n print(\\\"\\\\tExpected False, but got True for word: '\\\"+ word +\\\"' and hand:\\\", hand)\\n\\n failure = True\\n\\n # test 3\\n hand = {'n': 1, 'h': 1, '*': 1, 'y': 1, 'd':1, 'w':1, 'e': 2}\\n word = \\\"h*ney\\\"\\n\\n if not is_valid_word(word, hand, word_list):\\n print(\\\"FAILURE: test_is_valid_word() with wildcards\\\")\\n print(\\\"\\\\tExpected True, but got False for word: '\\\"+ word +\\\"' and hand:\\\", hand)\\n\\n failure = True\\n\\n # test 4\\n hand = {'c': 1, 'o': 1, '*': 1, 'w': 1, 's':1, 'z':1, 'y': 2}\\n word = \\\"c*wz\\\"\\n\\n if is_valid_word(word, hand, word_list):\\n print(\\\"FAILURE: test_is_valid_word() with wildcards\\\")\\n print(\\\"\\\\tExpected False, but got True for word: '\\\"+ word +\\\"' and hand:\\\", hand)\\n\\n failure = True \\n\\n # dictionary of words and scores WITH wildcards\\n words = {(\\\"h*ney\\\", 7):290, (\\\"c*ws\\\", 6):176, (\\\"wa*ls\\\", 7):203}\\n for (word, n) in words.keys():\\n score = get_word_score(word, n)\\n if score != words[(word, n)]:\\n print(\\\"FAILURE: test_get_word_score() with wildcards\\\")\\n print(\\\"\\\\tExpected\\\", words[(word, n)], \\\"points but got '\\\" + \\\\\\n str(score) + \\\"' for word '\\\" + word + \\\"', n=\\\" + str(n))\\n failure=True \\n\\n if not failure:\\n print(\\\"SUCCESS: test_wildcard()\\\")\",\n \"def check_letter(self, letter, random_word):\\n if letter in random_word:\\n for k in range(0, len(random_word)):\\n if self.unsolved_word[k] == '_':\\n self.unsolved_word[k] = letter if\\\\\\n random_word[k] == letter else '_'\\n return ''.join(self.unsolved_word)\",\n \"def fuzz_word(word):\\r\\n res = []\\r\\n\\r\\n for c in word:\\r\\n for i in range(3):\\r\\n c += random.choice(symbols)\\r\\n res.append(c)\\r\\n\\r\\n return ''.join(res)\",\n \"def is_a_word(self, word):\\n word = word.lower()\\n if word in self.data:\\n return True\\n else:\\n # for char in word:\\n # if char.isnumeric():\\n # return True\\n word = list(word)\\n numbers = len([x for x in word if x.isnumeric()])\\n # # letters = len([x for x in word if x.isalpha()])\\n if numbers >= 2 or numbers/len(word) > 0.4:\\n return True\\n return False\",\n \"def count_letters(word, letter):\\n assert isinstance(word, str) == True, \\\"Please input a string!\\\"\\n count = 0\\n for char in word:\\n if char == letter:\\n count += 1\\n\\n return count\",\n \"def word_is_solved(word, guesses):\\n total = 0 # number of guessed characters in word\\n\\n for guess in guesses:\\n # Number of guesses[i] in word\\n num = word.count(guess)\\n if num > 0:\\n total += num\\n if total == len(word):\\n return True\\n else:\\n return False\",\n \"def calc_word_score(word, letters_count, letters_score):\\n\\n output = 0\\n # keep track of the used letters\\n letters_remaining = dict(letters_count)\\n\\n for w in word:\\n if w not in letters_count:\\n # contains a letter outside the provided scope\\n return 0\\n if letters_remaining[w] == 0:\\n # too many occurrences of that letter\\n return 0\\n output += letters_score[w]\\n letters_remaining[w] -= 1\\n\\n return output\",\n \"def words(word):\\n new_list = []\\n \\n for i in word.split():\\n new_list.append(i)\\n return Counter(new_list)\",\n \"def start_game(self, entered_word):\\n if entered_word not in self._word_list:\\n print \\\"Not a word\\\"\\n return\\n \\n strings = self._substrs(entered_word)\\n sorted_strings = self._merge_sort(strings)\\n all_strings = self._remove_duplicates(sorted_strings)\\n self._subset_strings = self._intersect(self._word_list, all_strings)\\n self._guessed_strings = [] \\n for word in self._subset_strings:\\n self._guessed_strings.append(\\\"*\\\" * len(word))\\n self.enter_guess(entered_word)\",\n \"def letterFreq(words):\\n dict = {}\\n total = 0\\n for word in words:#Iterate through words\\n for letter in word:#Increment by letter\\n count = 0\\n for yearCount in words[word]:\\n count += yearCount.count#Increment total instances of word\\n total += count#Count total letters\\n if letter in dict:\\n dict[letter] += count#Add to existing entry\\n else:\\n dict[letter] = count#Create new entry\\n \\\"\\\"\\\"CODE FOR THE WHOLE ALPHABET\\\"\\\"\\\"\\n list = []\\n for letter in ascii_lowercase:\\n if letter in dict and dict[letter] != 0:\\n list.append(dict[letter] / total)#Convert to relative\\n else:\\n list.append(0.0)#Fill alphabet\\n return list\",\n \"def keep_word(word, num_words, count_dict):\\r\\n try:\\r\\n z_wi = float(count_dict[word]) / (num_words)\\r\\n part1 = math.sqrt((z_wi / 0.001)) + 1\\r\\n part2 = 0.001 / z_wi\\r\\n total_prob = part1 * part2\\r\\n return random.uniform(0, 1) < total_prob\\r\\n except:\\r\\n return False\",\n \"def wordscore(word):\\n return sum(letterscore[l] for l in word)\",\n \"def test_is_valid_word(word_list):\\n failure=False\\n\\n # test 1\\n word = \\\"hello\\\"\\n handOrig = get_frequency_dict(word)\\n handCopy = handOrig.copy()\\n\\n if not is_valid_word(word, handCopy, word_list):\\n print(\\\"FAILURE: test_is_valid_word()\\\")\\n print(\\\"\\\\tExpected True, but got False for word: '\\\" + word + \\\"' and hand:\\\", handOrig)\\n\\n failure = True\\n\\n # Test a second time to see if word_list or hand has been modified\\n if not is_valid_word(word, handCopy, word_list):\\n print(\\\"FAILURE: test_is_valid_word()\\\")\\n\\n if handCopy != handOrig:\\n print(\\\"\\\\tTesting word\\\", word, \\\"for a second time - be sure you're not modifying hand.\\\")\\n print(\\\"\\\\tAt this point, hand ought to be\\\", handOrig, \\\"but it is\\\", handCopy)\\n\\n else:\\n print(\\\"\\\\tTesting word\\\", word, \\\"for a second time - have you modified word_list?\\\")\\n wordInWL = word in word_list\\n print(\\\"The word\\\", word, \\\"should be in word_list - is it?\\\", wordInWL)\\n\\n print(\\\"\\\\tExpected True, but got False for word: '\\\" + word + \\\"' and hand:\\\", handCopy)\\n\\n failure = True\\n\\n\\n # test 2\\n hand = {'r': 1, 'a': 3, 'p': 2, 'e': 1, 't': 1, 'u':1}\\n word = \\\"Rapture\\\"\\n\\n if is_valid_word(word, hand, word_list):\\n print(\\\"FAILURE: test_is_valid_word()\\\")\\n print(\\\"\\\\tExpected False, but got True for word: '\\\" + word + \\\"' and hand:\\\", hand)\\n\\n failure = True \\n\\n # test 3\\n hand = {'n': 1, 'h': 1, 'o': 1, 'y': 1, 'd':1, 'w':1, 'e': 2}\\n word = \\\"honey\\\"\\n\\n if not is_valid_word(word, hand, word_list):\\n print(\\\"FAILURE: test_is_valid_word()\\\")\\n print(\\\"\\\\tExpected True, but got False for word: '\\\"+ word +\\\"' and hand:\\\", hand)\\n\\n failure = True \\n\\n # test 4\\n hand = {'r': 1, 'a': 3, 'p': 2, 't': 1, 'u':2}\\n word = \\\"honey\\\"\\n\\n if is_valid_word(word, hand, word_list):\\n print(\\\"FAILURE: test_is_valid_word()\\\")\\n print(\\\"\\\\tExpected False, but got True for word: '\\\" + word + \\\"' and hand:\\\", hand)\\n \\n failure = True\\n\\n # test 5\\n hand = {'e':1, 'v':2, 'n':1, 'i':1, 'l':2}\\n word = \\\"EVIL\\\"\\n \\n if not is_valid_word(word, hand, word_list):\\n print(\\\"FAILURE: test_is_valid_word()\\\")\\n print(\\\"\\\\tExpected True, but got False for word: '\\\" + word + \\\"' and hand:\\\", hand)\\n \\n failure = True\\n \\n # test 6\\n word = \\\"Even\\\"\\n\\n if is_valid_word(word, hand, word_list):\\n print(\\\"FAILURE: test_is_valid_word()\\\")\\n print(\\\"\\\\tExpected False, but got True for word: '\\\" + word + \\\"' and hand:\\\", hand)\\n print(\\\"\\\\t(If this is the only failure, make sure is_valid_word() isn't mutating its inputs)\\\") \\n \\n failure = True \\n\\n if not failure:\\n print(\\\"SUCCESS: test_is_valid_word()\\\")\",\n \"def words(self, word):\\n pass\",\n \"def simple_unique_characters(word):\\n return len(set(word)) == len(word)\",\n \"def play_game(word_list):\\n # TO DO...\\n print 'Welcome to the 6.00 Word Game!'\\n hand = deal_hand(HAND_SIZE) \\n while True:\\n choice1 = raw_input('Enter \\\"n\\\" for a new hand, \\\"r\\\" to repeat the last hand, or \\\"e\\\" to exit the game: ')\\n if choice1 not in ('ren'):\\n print 'invalid choice'\\n continue\\n if choice1 == 'e': break\\n while True:\\n choice2 = raw_input('Enter \\\"u\\\" to play the hand yourself or \\\"c\\\" to let the computer play the hand: ') \\n if choice2 not in ('uc'):\\n print 'invalid choice'\\n continue\\n else: break \\n if choice1 == 'r':\\n if choice2 == 'u': play_hand(hand, word_list)\\n else: comp_play_hand(hand, word_list)\\n else: \\n hand= deal_hand(HAND_SIZE) \\n if choice2 == 'u': play_hand(hand, word_list)\\n else: comp_play_hand(hand, word_list)\",\n \"def word_count(text, word):\\n \\n #answer\\n word_list = text.split(\\\" \\\")\\n return (word_list.count(word))\\n \\n #return (text.count(word)) - deoesn't work\",\n \"def find_letters_not_display(guess, secret_word):\\n return set(secret_word) - set(guess)\",\n \"def _internal_contains(self, letters):\\n len_letters = len(letters)\\n for word in self.words:\\n len_word = len(word)\\n word_with_letters_removed = WordUtils.remove_letters_from_word(word, letters)\\n if len(word_with_letters_removed) == (len_word - len_letters):\\n yield word\",\n \"def letter_picker(self):\\r\\n \\r\\n self.letter_count = dict.fromkeys(string.ascii_lowercase, 0) # reset\\r\\n for word in self.valid_words:\\r\\n word = \\\"\\\".join(set(word)) # removes duplicate letters in valid words\\r\\n for letter in word:\\r\\n self.letter_count[letter] += 1\\r\\n for letter in self.guesses: # prevents repeating guesses\\r\\n self.letter_count[letter] = 0\\r\\n self.chosen_letter = max(self.letter_count, key=self.letter_count.get)\\r\\n self.guesses.append(self.chosen_letter)\\r\\n print(f\\\"{self.chosen_letter} is the letter I think is right\\\")\",\n \"def phrase_guessed(self):\\r\\n count = 0\\r\\n\\r\\n for letter in self.phrase:\\r\\n if letter == ' ':\\r\\n count += 1\\r\\n else:\\r\\n if letter.was_guessed:\\r\\n count += 1\\r\\n if count == len(self.phrase):\\r\\n return True\\r\\n return False\",\n \"def count(word):\\n\\n return len(word)\",\n \"def check_win(secret_word, old_letters_guessed):\\n for i in secret_word:\\n if i not in old_letters_guessed:\\n return False\\n # all letters from secret_word are in old_letters_guessed - the player won\\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7523875","0.7382198","0.7290641","0.7285861","0.7223651","0.72069925","0.7139263","0.7120952","0.70973337","0.70633984","0.6983601","0.6970582","0.69672215","0.69574076","0.6905207","0.6899507","0.68932843","0.6694957","0.66840017","0.66779584","0.6618564","0.65917504","0.65331244","0.647723","0.64675784","0.6458106","0.64159954","0.63547117","0.6350613","0.63365215","0.6327694","0.6309193","0.62840265","0.6251497","0.6229214","0.62005144","0.6188921","0.61734045","0.61501646","0.6138579","0.6135396","0.61316156","0.613044","0.61180174","0.61039686","0.60972685","0.60914034","0.6088916","0.60865086","0.6078454","0.60670334","0.60525197","0.60391736","0.6033412","0.602789","0.60194147","0.6017707","0.601081","0.6005495","0.59975684","0.59919035","0.59886295","0.5988621","0.59839267","0.5978825","0.59590364","0.5950231","0.59483624","0.5935931","0.5935008","0.5934001","0.5926385","0.5922732","0.5922515","0.5887832","0.58877397","0.5885966","0.58848184","0.5880042","0.5878792","0.5874455","0.5871273","0.5871191","0.5866834","0.5855928","0.58522797","0.58411014","0.5839353","0.58380705","0.5834951","0.5832177","0.5826072","0.5817408","0.5814724","0.58122903","0.5811912","0.5803857","0.58020276","0.58010226","0.5800165"],"string":"[\n \"0.7523875\",\n \"0.7382198\",\n \"0.7290641\",\n \"0.7285861\",\n \"0.7223651\",\n \"0.72069925\",\n \"0.7139263\",\n \"0.7120952\",\n \"0.70973337\",\n \"0.70633984\",\n \"0.6983601\",\n \"0.6970582\",\n \"0.69672215\",\n \"0.69574076\",\n \"0.6905207\",\n \"0.6899507\",\n \"0.68932843\",\n \"0.6694957\",\n \"0.66840017\",\n \"0.66779584\",\n \"0.6618564\",\n \"0.65917504\",\n \"0.65331244\",\n \"0.647723\",\n \"0.64675784\",\n \"0.6458106\",\n \"0.64159954\",\n \"0.63547117\",\n \"0.6350613\",\n \"0.63365215\",\n \"0.6327694\",\n \"0.6309193\",\n \"0.62840265\",\n \"0.6251497\",\n \"0.6229214\",\n \"0.62005144\",\n \"0.6188921\",\n \"0.61734045\",\n \"0.61501646\",\n \"0.6138579\",\n \"0.6135396\",\n \"0.61316156\",\n \"0.613044\",\n \"0.61180174\",\n \"0.61039686\",\n \"0.60972685\",\n \"0.60914034\",\n \"0.6088916\",\n \"0.60865086\",\n \"0.6078454\",\n \"0.60670334\",\n \"0.60525197\",\n \"0.60391736\",\n \"0.6033412\",\n \"0.602789\",\n \"0.60194147\",\n \"0.6017707\",\n \"0.601081\",\n \"0.6005495\",\n \"0.59975684\",\n \"0.59919035\",\n \"0.59886295\",\n \"0.5988621\",\n \"0.59839267\",\n \"0.5978825\",\n \"0.59590364\",\n \"0.5950231\",\n \"0.59483624\",\n \"0.5935931\",\n \"0.5935008\",\n \"0.5934001\",\n \"0.5926385\",\n \"0.5922732\",\n \"0.5922515\",\n \"0.5887832\",\n \"0.58877397\",\n \"0.5885966\",\n \"0.58848184\",\n \"0.5880042\",\n \"0.5878792\",\n \"0.5874455\",\n \"0.5871273\",\n \"0.5871191\",\n \"0.5866834\",\n \"0.5855928\",\n \"0.58522797\",\n \"0.58411014\",\n \"0.5839353\",\n \"0.58380705\",\n \"0.5834951\",\n \"0.5832177\",\n \"0.5826072\",\n \"0.5817408\",\n \"0.5814724\",\n \"0.58122903\",\n \"0.5811912\",\n \"0.5803857\",\n \"0.58020276\",\n \"0.58010226\",\n \"0.5800165\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59908813"},"document_rank":{"kind":"string","value":"61"}}},{"rowIdx":92881,"cells":{"query":{"kind":"string","value":"Train or update a spaCy model. Requires data to be formatted in spaCy's JSON format. To convert data from other formats, use the `spacy convert` command."},"document":{"kind":"string","value":"def train(\n # fmt: off\n lang: (\"Model language\", \"positional\", None, str),\n output_path: (\"Output directory to store model in\", \"positional\", None, Path),\n train_path: (\"Location of JSON-formatted training data\", \"positional\", None, Path),\n dev_path: (\"Location of JSON-formatted development data\", \"positional\", None, Path),\n raw_text: (\"Path to jsonl file with unlabelled text documents.\", \"option\", \"rt\", Path) = None,\n base_model: (\"Name of model to update (optional)\", \"option\", \"b\", str) = None,\n pipeline: (\"Comma-separated names of pipeline components\", \"option\", \"p\", str) = \"tagger,parser,ner\",\n vectors: (\"Model to load vectors from\", \"option\", \"v\", str) = None,\n replace_components: (\"Replace components from base model\", \"flag\", \"R\", bool) = False,\n n_iter: (\"Number of iterations\", \"option\", \"n\", int) = 30,\n n_early_stopping: (\"Maximum number of training epochs without dev accuracy improvement\", \"option\", \"ne\", int) = None,\n n_examples: (\"Number of examples\", \"option\", \"ns\", int) = 0,\n use_gpu: (\"Use GPU\", \"option\", \"g\", int) = -1,\n version: (\"Model version\", \"option\", \"V\", str) = \"0.0.0\",\n meta_path: (\"Optional path to meta.json to use as base.\", \"option\", \"m\", Path) = None,\n init_tok2vec: (\"Path to pretrained weights for the token-to-vector parts of the models. See 'spacy pretrain'. Experimental.\", \"option\", \"t2v\", Path) = None,\n parser_multitasks: (\"Side objectives for parser CNN, e.g. 'dep' or 'dep,tag'\", \"option\", \"pt\", str) = \"\",\n entity_multitasks: (\"Side objectives for NER CNN, e.g. 'dep' or 'dep,tag'\", \"option\", \"et\", str) = \"\",\n noise_level: (\"Amount of corruption for data augmentation\", \"option\", \"nl\", float) = 0.0,\n orth_variant_level: (\"Amount of orthography variation for data augmentation\", \"option\", \"ovl\", float) = 0.0,\n eval_beam_widths: (\"Beam widths to evaluate, e.g. 4,8\", \"option\", \"bw\", str) = \"\",\n gold_preproc: (\"Use gold preprocessing\", \"flag\", \"G\", bool) = False,\n learn_tokens: (\"Make parser learn gold-standard tokenization\", \"flag\", \"T\", bool) = False,\n textcat_multilabel: (\"Textcat classes aren't mutually exclusive (multilabel)\", \"flag\", \"TML\", bool) = False,\n textcat_arch: (\"Textcat model architecture\", \"option\", \"ta\", str) = \"bow\",\n textcat_positive_label: (\"Textcat positive label for binary classes with two labels\", \"option\", \"tpl\", str) = None,\n tag_map_path: (\"Location of JSON-formatted tag map\", \"option\", \"tm\", Path) = None,\n verbose: (\"Display more information for debug\", \"flag\", \"VV\", bool) = False,\n debug: (\"Run data diagnostics before training\", \"flag\", \"D\", bool) = False,\n # fmt: on\n):\n util.fix_random_seed()\n util.set_env_log(verbose)\n\n # Make sure all files and paths exists if they are needed\n train_path = util.ensure_path(train_path)\n dev_path = util.ensure_path(dev_path)\n meta_path = util.ensure_path(meta_path)\n output_path = util.ensure_path(output_path)\n if raw_text is not None:\n raw_text = list(srsly.read_jsonl(raw_text))\n if not train_path or not train_path.exists():\n msg.fail(\"Training data not found\", train_path, exits=1)\n if not dev_path or not dev_path.exists():\n msg.fail(\"Development data not found\", dev_path, exits=1)\n if meta_path is not None and not meta_path.exists():\n msg.fail(\"Can't find model meta.json\", meta_path, exits=1)\n meta = srsly.read_json(meta_path) if meta_path else {}\n if output_path.exists() and [p for p in output_path.iterdir() if p.is_dir()]:\n msg.warn(\n \"Output directory is not empty\",\n \"This can lead to unintended side effects when saving the model. \"\n \"Please use an empty directory or a different path instead. If \"\n \"the specified output path doesn't exist, the directory will be \"\n \"created for you.\",\n )\n if not output_path.exists():\n output_path.mkdir()\n msg.good(f\"Created output directory: {output_path}\")\n\n tag_map = {}\n if tag_map_path is not None:\n tag_map = srsly.read_json(tag_map_path)\n # Take dropout and batch size as generators of values -- dropout\n # starts high and decays sharply, to force the optimizer to explore.\n # Batch size starts at 1 and grows, so that we make updates quickly\n # at the beginning of training.\n dropout_rates = util.decaying(\n util.env_opt(\"dropout_from\", 0.2),\n util.env_opt(\"dropout_to\", 0.2),\n util.env_opt(\"dropout_decay\", 0.0),\n )\n batch_sizes = util.compounding(\n util.env_opt(\"batch_from\", 100.0),\n util.env_opt(\"batch_to\", 1000.0),\n util.env_opt(\"batch_compound\", 1.001),\n )\n\n if not eval_beam_widths:\n eval_beam_widths = [1]\n else:\n eval_beam_widths = [int(bw) for bw in eval_beam_widths.split(\",\")]\n if 1 not in eval_beam_widths:\n eval_beam_widths.append(1)\n eval_beam_widths.sort()\n has_beam_widths = eval_beam_widths != [1]\n\n default_dir = Path(__file__).parent.parent / \"ml\" / \"models\" / \"defaults\"\n\n # Set up the base model and pipeline. If a base model is specified, load\n # the model and make sure the pipeline matches the pipeline setting. If\n # training starts from a blank model, intitalize the language class.\n pipeline = [p.strip() for p in pipeline.split(\",\")]\n msg.text(f\"Training pipeline: {pipeline}\")\n disabled_pipes = None\n pipes_added = False\n if use_gpu >= 0:\n activated_gpu = None\n try:\n activated_gpu = set_gpu(use_gpu)\n except Exception as e:\n msg.warn(f\"Exception: {e}\")\n if activated_gpu is not None:\n msg.text(f\"Using GPU: {use_gpu}\")\n else:\n msg.warn(f\"Unable to activate GPU: {use_gpu}\")\n msg.text(\"Using CPU only\")\n use_gpu = -1\n if base_model:\n msg.text(f\"Starting with base model '{base_model}'\")\n nlp = util.load_model(base_model)\n if nlp.lang != lang:\n msg.fail(\n f\"Model language ('{nlp.lang}') doesn't match language \"\n f\"specified as `lang` argument ('{lang}') \",\n exits=1,\n )\n if vectors:\n msg.text(f\"Loading vectors from model '{vectors}'\")\n _load_vectors(nlp, vectors)\n\n nlp.select_pipes(disable=[p for p in nlp.pipe_names if p not in pipeline])\n for pipe in pipeline:\n # first, create the model.\n # Bit of a hack after the refactor to get the vectors into a default config\n # use train-from-config instead :-)\n if pipe == \"parser\":\n config_loc = default_dir / \"parser_defaults.cfg\"\n elif pipe == \"tagger\":\n config_loc = default_dir / \"tagger_defaults.cfg\"\n elif pipe == \"ner\":\n config_loc = default_dir / \"ner_defaults.cfg\"\n elif pipe == \"textcat\":\n config_loc = default_dir / \"textcat_defaults.cfg\"\n elif pipe == \"senter\":\n config_loc = default_dir / \"senter_defaults.cfg\"\n else:\n raise ValueError(f\"Component {pipe} currently not supported.\")\n pipe_cfg = util.load_config(config_loc, create_objects=False)\n if vectors:\n pretrained_config = {\n \"@architectures\": \"spacy.VocabVectors.v1\",\n \"name\": vectors,\n }\n pipe_cfg[\"model\"][\"tok2vec\"][\"pretrained_vectors\"] = pretrained_config\n\n if pipe == \"parser\":\n pipe_cfg[\"learn_tokens\"] = learn_tokens\n elif pipe == \"textcat\":\n pipe_cfg[\"exclusive_classes\"] = not textcat_multilabel\n pipe_cfg[\"architecture\"] = textcat_arch\n pipe_cfg[\"positive_label\"] = textcat_positive_label\n\n if pipe not in nlp.pipe_names:\n msg.text(f\"Adding component to base model '{pipe}'\")\n nlp.add_pipe(nlp.create_pipe(pipe, config=pipe_cfg))\n pipes_added = True\n elif replace_components:\n msg.text(f\"Replacing component from base model '{pipe}'\")\n nlp.replace_pipe(pipe, nlp.create_pipe(pipe, config=pipe_cfg))\n pipes_added = True\n else:\n if pipe == \"textcat\":\n textcat_cfg = nlp.get_pipe(\"textcat\").cfg\n base_cfg = {\n \"exclusive_classes\": textcat_cfg[\"exclusive_classes\"],\n \"architecture\": textcat_cfg[\"architecture\"],\n \"positive_label\": textcat_cfg[\"positive_label\"],\n }\n if base_cfg != pipe_cfg:\n msg.fail(\n f\"The base textcat model configuration does\"\n f\"not match the provided training options. \"\n f\"Existing cfg: {base_cfg}, provided cfg: {pipe_cfg}\",\n exits=1,\n )\n msg.text(f\"Extending component from base model '{pipe}'\")\n disabled_pipes = nlp.select_pipes(\n disable=[p for p in nlp.pipe_names if p not in pipeline]\n )\n else:\n msg.text(f\"Starting with blank model '{lang}'\")\n lang_cls = util.get_lang_class(lang)\n nlp = lang_cls()\n\n if vectors:\n msg.text(f\"Loading vectors from model '{vectors}'\")\n _load_vectors(nlp, vectors)\n\n for pipe in pipeline:\n # first, create the model.\n # Bit of a hack after the refactor to get the vectors into a default config\n # use train-from-config instead :-)\n if pipe == \"parser\":\n config_loc = default_dir / \"parser_defaults.cfg\"\n elif pipe == \"tagger\":\n config_loc = default_dir / \"tagger_defaults.cfg\"\n elif pipe == \"morphologizer\":\n config_loc = default_dir / \"morphologizer_defaults.cfg\"\n elif pipe == \"ner\":\n config_loc = default_dir / \"ner_defaults.cfg\"\n elif pipe == \"textcat\":\n config_loc = default_dir / \"textcat_defaults.cfg\"\n elif pipe == \"senter\":\n config_loc = default_dir / \"senter_defaults.cfg\"\n else:\n raise ValueError(f\"Component {pipe} currently not supported.\")\n pipe_cfg = util.load_config(config_loc, create_objects=False)\n if vectors:\n pretrained_config = {\n \"@architectures\": \"spacy.VocabVectors.v1\",\n \"name\": vectors,\n }\n pipe_cfg[\"model\"][\"tok2vec\"][\"pretrained_vectors\"] = pretrained_config\n\n if pipe == \"parser\":\n pipe_cfg[\"learn_tokens\"] = learn_tokens\n elif pipe == \"textcat\":\n pipe_cfg[\"exclusive_classes\"] = not textcat_multilabel\n pipe_cfg[\"architecture\"] = textcat_arch\n pipe_cfg[\"positive_label\"] = textcat_positive_label\n\n pipe = nlp.create_pipe(pipe, config=pipe_cfg)\n nlp.add_pipe(pipe)\n\n # Update tag map with provided mapping\n nlp.vocab.morphology.tag_map.update(tag_map)\n\n # Multitask objectives\n multitask_options = [(\"parser\", parser_multitasks), (\"ner\", entity_multitasks)]\n for pipe_name, multitasks in multitask_options:\n if multitasks:\n if pipe_name not in pipeline:\n msg.fail(\n f\"Can't use multitask objective without '{pipe_name}' in \"\n f\"the pipeline\"\n )\n pipe = nlp.get_pipe(pipe_name)\n for objective in multitasks.split(\",\"):\n pipe.add_multitask_objective(objective)\n\n # Prepare training corpus\n msg.text(f\"Counting training words (limit={n_examples})\")\n corpus = GoldCorpus(train_path, dev_path, limit=n_examples)\n n_train_words = corpus.count_train()\n\n if base_model and not pipes_added:\n # Start with an existing model, use default optimizer\n optimizer = create_default_optimizer()\n else:\n # Start with a blank model, call begin_training\n cfg = {\"device\": use_gpu}\n optimizer = nlp.begin_training(lambda: corpus.train_examples, **cfg)\n nlp._optimizer = None\n\n # Load in pretrained weights (TODO: this may be broken in the config rewrite)\n if init_tok2vec is not None:\n components = _load_pretrained_tok2vec(nlp, init_tok2vec)\n msg.text(f\"Loaded pretrained tok2vec for: {components}\")\n\n # Verify textcat config\n if \"textcat\" in pipeline:\n textcat_labels = nlp.get_pipe(\"textcat\").cfg.get(\"labels\", [])\n if textcat_positive_label and textcat_positive_label not in textcat_labels:\n msg.fail(\n f\"The textcat_positive_label (tpl) '{textcat_positive_label}' \"\n f\"does not match any label in the training data.\",\n exits=1,\n )\n if textcat_positive_label and len(textcat_labels) != 2:\n msg.fail(\n \"A textcat_positive_label (tpl) '{textcat_positive_label}' was \"\n \"provided for training data that does not appear to be a \"\n \"binary classification problem with two labels.\",\n exits=1,\n )\n train_data = corpus.train_data(\n nlp,\n noise_level=noise_level,\n gold_preproc=gold_preproc,\n max_length=0,\n ignore_misaligned=True,\n )\n train_labels = set()\n if textcat_multilabel:\n multilabel_found = False\n for ex in train_data:\n train_labels.update(ex.gold.cats.keys())\n if list(ex.gold.cats.values()).count(1.0) != 1:\n multilabel_found = True\n if not multilabel_found and not base_model:\n msg.warn(\n \"The textcat training instances look like they have \"\n \"mutually-exclusive classes. Remove the flag \"\n \"'--textcat-multilabel' to train a classifier with \"\n \"mutually-exclusive classes.\"\n )\n if not textcat_multilabel:\n for ex in train_data:\n train_labels.update(ex.gold.cats.keys())\n if list(ex.gold.cats.values()).count(1.0) != 1 and not base_model:\n msg.warn(\n \"Some textcat training instances do not have exactly \"\n \"one positive label. Modifying training options to \"\n \"include the flag '--textcat-multilabel' for classes \"\n \"that are not mutually exclusive.\"\n )\n nlp.get_pipe(\"textcat\").cfg[\"exclusive_classes\"] = False\n textcat_multilabel = True\n break\n if base_model and set(textcat_labels) != train_labels:\n msg.fail(\n f\"Cannot extend textcat model using data with different \"\n f\"labels. Base model labels: {textcat_labels}, training data \"\n f\"labels: {list(train_labels)}\",\n exits=1,\n )\n if textcat_multilabel:\n msg.text(\n f\"Textcat evaluation score: ROC AUC score macro-averaged across \"\n f\"the labels '{', '.join(textcat_labels)}'\"\n )\n elif textcat_positive_label and len(textcat_labels) == 2:\n msg.text(\n f\"Textcat evaluation score: F1-score for the \"\n f\"label '{textcat_positive_label}'\"\n )\n elif len(textcat_labels) > 1:\n if len(textcat_labels) == 2:\n msg.warn(\n \"If the textcat component is a binary classifier with \"\n \"exclusive classes, provide '--textcat_positive_label' for \"\n \"an evaluation on the positive class.\"\n )\n msg.text(\n f\"Textcat evaluation score: F1-score macro-averaged across \"\n f\"the labels '{', '.join(textcat_labels)}'\"\n )\n else:\n msg.fail(\n \"Unsupported textcat configuration. Use `spacy debug-data` \"\n \"for more information.\"\n )\n\n # fmt: off\n row_head, output_stats = _configure_training_output(pipeline, use_gpu, has_beam_widths)\n row_widths = [len(w) for w in row_head]\n row_settings = {\"widths\": row_widths, \"aligns\": tuple([\"r\" for i in row_head]), \"spacing\": 2}\n # fmt: on\n print(\"\")\n msg.row(row_head, **row_settings)\n msg.row([\"-\" * width for width in row_settings[\"widths\"]], **row_settings)\n try:\n iter_since_best = 0\n best_score = 0.0\n for i in range(n_iter):\n train_data = corpus.train_dataset(\n nlp,\n noise_level=noise_level,\n orth_variant_level=orth_variant_level,\n gold_preproc=gold_preproc,\n max_length=0,\n ignore_misaligned=True,\n )\n if raw_text:\n random.shuffle(raw_text)\n raw_batches = util.minibatch(\n (nlp.make_doc(rt[\"text\"]) for rt in raw_text), size=8\n )\n words_seen = 0\n with tqdm.tqdm(total=n_train_words, leave=False) as pbar:\n losses = {}\n for batch in util.minibatch_by_words(train_data, size=batch_sizes):\n if not batch:\n continue\n try:\n nlp.update(\n batch,\n sgd=optimizer,\n drop=next(dropout_rates),\n losses=losses,\n )\n except ValueError as e:\n err = \"Error during training\"\n if init_tok2vec:\n err += \" Did you provide the same parameters during 'train' as during 'pretrain'?\"\n msg.fail(err, f\"Original error message: {e}\", exits=1)\n if raw_text:\n # If raw text is available, perform 'rehearsal' updates,\n # which use unlabelled data to reduce overfitting.\n raw_batch = list(next(raw_batches))\n nlp.rehearse(raw_batch, sgd=optimizer, losses=losses)\n docs = [ex.doc for ex in batch]\n if not int(os.environ.get(\"LOG_FRIENDLY\", 0)):\n pbar.update(sum(len(doc) for doc in docs))\n words_seen += sum(len(doc) for doc in docs)\n with nlp.use_params(optimizer.averages):\n util.set_env_log(False)\n epoch_model_path = output_path / f\"model{i}\"\n nlp.to_disk(epoch_model_path)\n nlp_loaded = util.load_model_from_path(epoch_model_path)\n for beam_width in eval_beam_widths:\n for name, component in nlp_loaded.pipeline:\n if hasattr(component, \"cfg\"):\n component.cfg[\"beam_width\"] = beam_width\n dev_dataset = list(\n corpus.dev_dataset(\n nlp_loaded,\n gold_preproc=gold_preproc,\n ignore_misaligned=True,\n )\n )\n nwords = sum(len(ex.doc) for ex in dev_dataset)\n start_time = timer()\n scorer = nlp_loaded.evaluate(dev_dataset, verbose=verbose)\n end_time = timer()\n if use_gpu < 0:\n gpu_wps = None\n cpu_wps = nwords / (end_time - start_time)\n else:\n gpu_wps = nwords / (end_time - start_time)\n with use_ops(\"numpy\"):\n nlp_loaded = util.load_model_from_path(epoch_model_path)\n for name, component in nlp_loaded.pipeline:\n if hasattr(component, \"cfg\"):\n component.cfg[\"beam_width\"] = beam_width\n dev_dataset = list(\n corpus.dev_dataset(\n nlp_loaded,\n gold_preproc=gold_preproc,\n ignore_misaligned=True,\n )\n )\n start_time = timer()\n scorer = nlp_loaded.evaluate(dev_dataset, verbose=verbose)\n end_time = timer()\n cpu_wps = nwords / (end_time - start_time)\n acc_loc = output_path / f\"model{i}\" / \"accuracy.json\"\n srsly.write_json(acc_loc, scorer.scores)\n\n # Update model meta.json\n meta[\"lang\"] = nlp.lang\n meta[\"pipeline\"] = nlp.pipe_names\n meta[\"spacy_version\"] = f\">={about.__version__}\"\n if beam_width == 1:\n meta[\"speed\"] = {\n \"nwords\": nwords,\n \"cpu\": cpu_wps,\n \"gpu\": gpu_wps,\n }\n meta.setdefault(\"accuracy\", {})\n for component in nlp.pipe_names:\n for metric in _get_metrics(component):\n meta[\"accuracy\"][metric] = scorer.scores[metric]\n else:\n meta.setdefault(\"beam_accuracy\", {})\n meta.setdefault(\"beam_speed\", {})\n for component in nlp.pipe_names:\n for metric in _get_metrics(component):\n meta[\"beam_accuracy\"][metric] = scorer.scores[metric]\n meta[\"beam_speed\"][beam_width] = {\n \"nwords\": nwords,\n \"cpu\": cpu_wps,\n \"gpu\": gpu_wps,\n }\n meta[\"vectors\"] = {\n \"width\": nlp.vocab.vectors_length,\n \"vectors\": len(nlp.vocab.vectors),\n \"keys\": nlp.vocab.vectors.n_keys,\n \"name\": nlp.vocab.vectors.name,\n }\n meta.setdefault(\"name\", f\"model{i}\")\n meta.setdefault(\"version\", version)\n meta[\"labels\"] = nlp.meta[\"labels\"]\n meta_loc = output_path / f\"model{i}\" / \"meta.json\"\n srsly.write_json(meta_loc, meta)\n util.set_env_log(verbose)\n\n progress = _get_progress(\n i,\n losses,\n scorer.scores,\n output_stats,\n beam_width=beam_width if has_beam_widths else None,\n cpu_wps=cpu_wps,\n gpu_wps=gpu_wps,\n )\n if i == 0 and \"textcat\" in pipeline:\n textcats_per_cat = scorer.scores.get(\"textcats_per_cat\", {})\n for cat, cat_score in textcats_per_cat.items():\n if cat_score.get(\"roc_auc_score\", 0) < 0:\n msg.warn(\n f\"Textcat ROC AUC score is undefined due to \"\n f\"only one value in label '{cat}'.\"\n )\n msg.row(progress, **row_settings)\n # Early stopping\n if n_early_stopping is not None:\n current_score = _score_for_model(meta)\n if current_score < best_score:\n iter_since_best += 1\n else:\n iter_since_best = 0\n best_score = current_score\n if iter_since_best >= n_early_stopping:\n msg.text(\n f\"Early stopping, best iteration is: {i - iter_since_best}\"\n )\n msg.text(\n f\"Best score = {best_score}; Final iteration score = {current_score}\"\n )\n break\n except Exception as e:\n msg.warn(f\"Aborting and saving final best model. Encountered exception: {e}\")\n finally:\n best_pipes = nlp.pipe_names\n if disabled_pipes:\n disabled_pipes.restore()\n with nlp.use_params(optimizer.averages):\n final_model_path = output_path / \"model-final\"\n nlp.to_disk(final_model_path)\n meta_loc = output_path / \"model-final\" / \"meta.json\"\n final_meta = srsly.read_json(meta_loc)\n final_meta.setdefault(\"accuracy\", {})\n final_meta[\"accuracy\"].update(meta.get(\"accuracy\", {}))\n final_meta.setdefault(\"speed\", {})\n final_meta[\"speed\"].setdefault(\"cpu\", None)\n final_meta[\"speed\"].setdefault(\"gpu\", None)\n meta.setdefault(\"speed\", {})\n meta[\"speed\"].setdefault(\"cpu\", None)\n meta[\"speed\"].setdefault(\"gpu\", None)\n # combine cpu and gpu speeds with the base model speeds\n if final_meta[\"speed\"][\"cpu\"] and meta[\"speed\"][\"cpu\"]:\n speed = _get_total_speed(\n [final_meta[\"speed\"][\"cpu\"], meta[\"speed\"][\"cpu\"]]\n )\n final_meta[\"speed\"][\"cpu\"] = speed\n if final_meta[\"speed\"][\"gpu\"] and meta[\"speed\"][\"gpu\"]:\n speed = _get_total_speed(\n [final_meta[\"speed\"][\"gpu\"], meta[\"speed\"][\"gpu\"]]\n )\n final_meta[\"speed\"][\"gpu\"] = speed\n # if there were no speeds to update, overwrite with meta\n if (\n final_meta[\"speed\"][\"cpu\"] is None\n and final_meta[\"speed\"][\"gpu\"] is None\n ):\n final_meta[\"speed\"].update(meta[\"speed\"])\n # note: beam speeds are not combined with the base model\n if has_beam_widths:\n final_meta.setdefault(\"beam_accuracy\", {})\n final_meta[\"beam_accuracy\"].update(meta.get(\"beam_accuracy\", {}))\n final_meta.setdefault(\"beam_speed\", {})\n final_meta[\"beam_speed\"].update(meta.get(\"beam_speed\", {}))\n srsly.write_json(meta_loc, final_meta)\n msg.good(\"Saved model to output directory\", final_model_path)\n with msg.loading(\"Creating best model...\"):\n best_model_path = _collate_best_model(final_meta, output_path, best_pipes)\n msg.good(\"Created best model\", best_model_path)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def train_nlu(data, config, model_dir):\n # Read the config_spacy.json as JSON \n with open(config) as f: config = json.load(f)\n\n training_data = load_data(data)\n trainer = Trainer(RasaNLUModelConfig(config))\n trainer.train(training_data)\n\n model_directory = trainer.persist(model_dir, fixed_model_name= \"weathernlu\")","def train_ner(model, new_model_name, output_dir, n_iter, train_data):\r\n random.seed(0)\r\n if model is not None:\r\n nlp = spacy.load(model) # load existing spaCy model\r\n print(\"Loaded model '%s'\" % model)\r\n else:\r\n nlp = spacy.blank(\"en\") # create blank Language class\r\n print(\"Created blank 'en' model\")\r\n # Add entity recognizer to model if it's not in the pipeline\r\n # nlp.create_pipe works for built-ins that are registered with spaCy\r\n if \"ner\" not in nlp.pipe_names:\r\n ner = nlp.create_pipe(\"ner\")\r\n nlp.add_pipe(ner)\r\n # otherwise, get it, so we can add labels to it\r\n else:\r\n ner = nlp.get_pipe(\"ner\")\r\n\r\n ner.add_label(LABEL) # add new entity label to entity recognizer\r\n # Adding extraneous labels shouldn't mess anything up\r\n ner.add_label(\"EXTRA\")\r\n \r\n \r\n if model is None:\r\n optimizer = nlp.begin_training()\r\n else:\r\n optimizer = nlp.resume_training()\r\n move_names = list(ner.move_names)\r\n # get names of other pipes to disable them during training\r\n other_pipes = [pipe for pipe in nlp.pipe_names if pipe != \"ner\"]\r\n with nlp.disable_pipes(*other_pipes): # only train NER\r\n sizes = compounding(1.0, 4.0, 1.001)\r\n # batch up the examples using spaCy's minibatch\r\n for itn in range(n_iter):\r\n random.shuffle(train_data)\r\n batches = minibatch(train_data, size=sizes)\r\n losses = {}\r\n for batch in batches:\r\n texts, annotations = zip(*batch)\r\n nlp.update(texts, annotations, sgd=optimizer, drop=0.35, losses=losses)\r\n print(\"Losses\", losses)\r\n\r\n # save model to output directory\r\n if output_dir is not None:\r\n output_dir = Path(output_dir)\r\n if not output_dir.exists():\r\n output_dir.mkdir()\r\n nlp.meta[\"name\"] = new_model_name # rename model\r\n nlp.to_disk(output_dir)\r\n print(\"Saved model to\", output_dir)","def train_model(\n model, train_path, eval_path, n_iter=10, output=None, tok2vec=None,\n):\n spacy.util.fix_random_seed(0)\n with msg.loading(f\"Loading '{model}'...\"):\n if model.startswith(\"blank:\"):\n nlp = spacy.blank(model.replace(\"blank:\", \"\"))\n else:\n nlp = spacy.load(model)\n msg.good(f\"Loaded model '{model}'\")\n train_data, labels = format_data(srsly.read_jsonl(train_path))\n eval_data, _ = format_data(srsly.read_jsonl(eval_path))\n ner = nlp.create_pipe(\"ner\")\n for label in labels:\n ner.add_label(label)\n nlp.add_pipe(ner)\n t2v_cfg = {\n \"embed_rows\": 10000,\n \"token_vector_width\": 128,\n \"conv_depth\": 8,\n \"nr_feature_tokens\": 3,\n }\n optimizer = nlp.begin_training(component_cfg={\"ner\": t2v_cfg} if tok2vec else {})\n if tok2vec:\n _load_pretrained_tok2vec(nlp, Path(tok2vec))\n batch_size = spacy.util.compounding(1.0, 16.0, 1.001)\n best_acc = 0\n best_model = None\n row_widths = (2, 8, 8, 8, 8)\n msg.row((\"#\", \"L\", \"P\", \"R\", \"F\"), widths=row_widths)\n for i in range(n_iter):\n random.shuffle(train_data)\n losses = {}\n data = tqdm.tqdm(train_data, leave=False)\n for batch in spacy.util.minibatch(data, size=batch_size):\n texts, annots = zip(*batch)\n nlp.update(texts, annots, drop=0.2, losses=losses)\n with nlp.use_params(optimizer.averages):\n sc = nlp.evaluate(eval_data)\n if sc.ents_f > best_acc:\n best_acc = sc.ents_f\n if output:\n best_model = nlp.to_bytes()\n acc = (f\"{sc.ents_p:.3f}\", f\"{sc.ents_r:.3f}\", f\"{sc.ents_f:.3f}\")\n msg.row((i + 1, f\"{losses['ner']:.2f}\", *acc), widths=row_widths)\n msg.text(f\"Best F-Score: {best_acc:.3f}\")\n if output and best_model:\n with msg.loading(\"Saving model...\"):\n nlp.from_bytes(best_model).to_disk(output)\n msg.good(\"Saved model\", output)","def retrain_model(self, new_sentences, with_punctiations):\n if with_punctiations:\n model_ = Word2Vec.load('./model/model_word2vec.bin')\n else:\n model_ = Word2Vec.load('./model/model_no_punctuation_word2vec.bin')\n\n model_.build_vocab(new_sentences, update=True)\n model_.train(new_sentences, total_examples=model_.corpus_count, epochs=model_.iter)\n\n if with_punctiations:\n model_.save('./model/model_word2vec.bin')\n else:\n model_.save('./model/model_no_punctuation_word2vec.bin')\n\n\n pass","def train(pipetype, datapath):\n with open(datapath, 'r') as f:\n training_data = json.load(f)\n docs = ['{0} {1}'.format(d['title'], d['text']) for d in training_data]\n\n if pipetype == 'bow':\n vector.train(docs)\n\n if pipetype in ['stanford', 'spotlight', 'keyword']:\n concept.train(docs, pipetype=pipetype)","def train_model():\n if (not request.json \n or not 'data-format' in request.json\n or not 'ML-model' in request.json\n or not 'source-data-directory' in request.json\n or not 'source-data-repo' in request.json):\n abort(400)\n\n data_format = request.json['data-format']\n ML_model = request.json['ML-model']\n source_data_directory = request.json['source-data-directory']\n source_data_repo = request.json['source-data-repo']\n \n start = time.time()\n\n do_train(model_name=ML_model, \n repo_url=source_data_repo, \n repo_data_directory=source_data_directory, \n data_format=data_format)\n \n end = time.time()\n\n runningtime = (end - start)\n\n return f'Model {ML_model} trained using source data in directory {source_data_directory}, running time {runningtime} seconds', 201","def train_pipeline(nlp: spacy.language.Language) -> None:\n if TEXTCAT not in nlp.pipe_names:\n textcat = nlp.create_pipe(TEXTCAT, config={\"exclusive_classes\": False})\n nlp.add_pipe(textcat, last=True)\n else:\n textcat = nlp.get_pipe(TEXTCAT)\n\n for category in CATEGORIES:\n textcat.add_label(category.value)\n\n pipe_exceptions = {TEXTCAT, \"trf_wordpiecer\", \"trf_tok2vec\"}\n other_pipes = [pipe for pipe in nlp.pipe_names if pipe not in pipe_exceptions]\n with nlp.disable_pipes(*other_pipes): # only train textcat\n all_data = list(get_classification_training_data())\n random.shuffle(all_data)\n\n training_data = all_data[: len(all_data) - 2]\n validation_data = all_data[len(all_data) - 2 :]\n\n optimizer = nlp.begin_training()\n for itn in range(20):\n losses: Dict[str, Any] = {}\n random.shuffle(training_data)\n batches = minibatch(training_data, size=compounding(4.0, 32.0, 1.001))\n\n for batch in batches:\n texts, annotations = zip(*batch)\n nlp.update(texts, annotations, sgd=optimizer, drop=0.2, losses=losses)","def train_spm_model(config:SentencePieceConfig):\n spm.SentencePieceTrainer.train(str(config))\n return config","def train(self, training_data, model_name):\n dataset = []\n for example in training_data:\n entity_offsets = self._convert_example(example)\n dataset.append(self._from_json_to_crf(example, entity_offsets))\n\n features = [self._sentence_to_features(s) for s in dataset]\n labels = [self._sentence_to_labels(s) for s in dataset]\n trainer = sklearn_crfsuite.CRF(\n algorithm=\"lbfgs\",\n # coefficient for L1 penalty\n c1=0.1,\n # coefficient for L2 penalty\n c2=0.1,\n # stop earlier\n max_iterations=50,\n # include transitions that are possible, but not observed\n all_possible_transitions=True,\n )\n trainer.fit(features, labels)\n logger.info(\"Creating Model for Intent %s\",model_name)\n joblib.dump(trainer, 'core/agent/model_files/%s.model' % model_name)\n return True","def do_train(train_texts, train_labels, dev_texts, dev_labels, lstm_shape, lstm_settings,\n lstm_optimizer, batch_size=100,\n do_fit1=True, epochs1=5, model1_path=None, config1_path=None,\n do_fit2=False, epochs2=2, model2_path=None, config2_path=None,\n epoch_path=None, lstm_type=1):\n\n print('do_train: train_texts=%s dev_texts=%s' % (dim(train_texts), dim(dev_texts)))\n best_epoch_frozen, best_epoch_unfrozen = -1, -1\n\n n_train_sents = count_sentences(train_texts, batch_size, 'train')\n X_train, y_train = make_sentences(lstm_shape['max_length'], batch_size,\n train_texts, train_labels, 'train', n_train_sents)\n validation_data = None\n if dev_texts is not None:\n n_dev_sents = count_sentences(dev_texts, batch_size, 'dev')\n X_val, y_val = make_sentences(lstm_shape['max_length'], batch_size,\n dev_texts, dev_labels, 'dev', n_dev_sents)\n validation_data = (X_val, y_val)\n sentence_cache.flush()\n\n print(\"Loading spaCy\")\n nlp = sentence_cache._load_nlp()\n embeddings = get_embeddings(nlp.vocab)\n model = build_lstm[lstm_type](embeddings, lstm_shape, lstm_settings)\n compile_lstm(model, lstm_settings['lr'])\n\n callback_list = None\n\n if do_fit1:\n if validation_data is not None:\n ra_val = RocAucEvaluation(validation_data=validation_data, interval=1, frozen=True,\n model_path=model1_path, config_path=config1_path)\n early = EarlyStopping(monitor='val_auc', mode='max', patience=2, verbose=1)\n callback_list = [ra_val, early]\n else:\n sae = SaveAllEpochs(model1_path, config1_path, epoch_path, True)\n if sae.last_epoch1() > 0:\n xprint('Reloading partially built model 1')\n get_embeds = partial(get_embeddings, vocab=nlp.vocab)\n model = load_model(model1_path, config1_path, True, get_embeds)\n compile_lstm(model, lstm_settings['lr'])\n epochs1 -= sae.last_epoch1()\n callback_list = [sae]\n\n if epochs1 > 0:\n model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs1,\n validation_data=validation_data, callbacks=callback_list, verbose=1)\n if validation_data is not None:\n best_epoch_frozen = ra_val.best_epoch\n ra_val.best_epoch = -1\n else:\n save_model(model, model1_path, config1_path, True)\n\n if do_fit2:\n # Reload the best model so far, if it exists\n if os.path.exists(model1_path) and os.path.exists(config1_path):\n model = load_model(model1_path, config1_path, True,\n partial(get_embeddings, vocab=nlp.vocab))\n xprint(\"Unfreezing\")\n for layer in model.layers:\n layer.trainable = True\n compile_lstm(model, lstm_settings['lr'] / 10)\n if validation_data is not None:\n # Reset early stopping\n ra_val = RocAucEvaluation(validation_data=validation_data, interval=1,\n frozen=False, was_frozen=True,\n get_embeddings=partial(get_embeddings, vocab=nlp.vocab),\n do_prime=True, model_path=model1_path, config_path=config1_path)\n early = EarlyStopping(monitor='val_auc', mode='max', patience=2, verbose=1)\n callback_list = [ra_val, early]\n else:\n sae = SaveAllEpochs(model2_path, config2_path, epoch_path, False)\n if sae.last_epoch2() > 0:\n xprint('Reloading partially built model 2')\n get_embeds = partial(get_embeddings, vocab=nlp.vocab)\n model = load_model(model2_path, config2_path, False)\n compile_lstm(model, lstm_settings['lr'])\n epochs2 -= sae.last_epoch2()\n callback_list = [sae]\n\n if epochs2 > 0:\n model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs2,\n validation_data=validation_data, callbacks=callback_list, verbose=1)\n best_epoch_unfrozen = ra_val.best_epoch\n if validation_data is None:\n save_model(model, model2_path, config2_path, False)\n\n del nlp\n return model, (best_epoch_frozen, best_epoch_unfrozen)","def train_model_cross_validation(model, train_docs, test_docs, nb_iter, output_dir, spacy_type = True, nb_folds = 5):\n\n print(output_dir)\n os.mkdir(output_dir) # creating the output directory\n print(\" ============= TRAINING MODEL ===========================\")\n\n\n # tuple conversion (the tuple type is lost when dataframe -> excel -> dataframe)\n\n #docs['annotations'] = [[tuple(ann) for ann in annotations] for annotations in docs['annotations'].to_numpy()]\n\n\n # cross validation :\n\n models = []\n all_scores = []\n\n kf = KFold(n_splits=nb_folds)\n c = 0\n for train_index, val_index in kf.split(train_docs):\n\n train_data = train_docs.iloc[train_index, :]\n val_data = train_docs.iloc[val_index, :]\n\n # spacy_format\n TRAIN_DATA = [(text, {'entities': entities}) for [text, entities] in train_data[['text', 'annotations']].to_numpy()]\n\n # trim entities : leading whitespace make the model bug\n TRAIN_DATA = trim_entity_spans(TRAIN_DATA)\n\n # loading of the model\n nlp = model\n\n optimizer = nlp.begin_training()\n\n # get names of other pipes to disable them during training\n pipe_exceptions = [\"ner\" ] #\"trf_wordpiecer\", \"trf_tok2vec\"\n other_pipes = [pipe for pipe in nlp.pipe_names if pipe not in pipe_exceptions]\n\n scores = []\n\n # training\n with nlp.disable_pipes(*other_pipes): # only train NER\n\n if not spacy_type : # add the other labels\n ner = nlp.get_pipe(\"ner\")\n ner.add_label('AGE_RELATED')\n ner.add_label('DURATION')\n ner.add_label('FREQUENCY')\n ner.add_label('OTHER')\n\n for i in range(nb_iter):\n\n print('Iteration ', i)\n print()\n losses = {}\n random.shuffle(TRAIN_DATA) # ??\n\n path = ''\n if spacy_type:\n path = 'spacy_model_' + str(c) + '_fold'\n else:\n path = 'all_types_model_' + str(c) + '_fold'\n\n batches = minibatch(TRAIN_DATA, size=1) #compounding(4.0, 20.0, 1.001)\n\n for batch in batches:\n texts, annotations = zip(*batch)\n try:\n nlp.update(texts, annotations, sgd = optimizer, drop=0.5, losses = losses)\n print(\"Losses\", losses)\n except Exception as e:\n print(e)\n #print(text)\n\n tp_g, fp_g, fn_g, p, r, f, pt, rt, ft, type_dict = test_model(test_docs, nlp)\n scores += [(p, r, r, pt, rt, ft)]\n print()\n print()\n\n # test the trained model\n test_model(val_data, nlp)\n\n df_scores = pd.DataFrame(scores, columns = ['span_precision', 'span_recall', 'span_f1', 'type_precision', 'type_recall', 'type_f1'])\n df_scores.to_excel(output_dir + '/' + path + '.xlsx')\n\n\n models += [nlp]\n all_scores += [scores]\n # save model to output directory\n if output_dir is not None:\n nlp.to_disk(output_dir + '/' + path)\n print(\"Saved model to\", output_dir + '/' + path)\n\n c += 1\n\n return models, all_scores","def load_model(self):\n self._logger.debug(f\"Loading Spacy Data Model : {self._model}... Could take time.\")\n self._nlp = spacy.load(self._model)\n self._logger.debug(\"Successfully loaded Spacy Data !\")\n\n # === Load entities ===\n if PIPE_ENTITY not in self._nlp.pipe_names:\n self._nlp.add_pipe(PIPE_ENTITY, last=True)\n\n entity_pipe = self._nlp.get_pipe(PIPE_ENTITY)\n for entity in self._entities:\n entity_pipe.add_label(entity)\n\n # === Load categories ===\n if PIPE_INTENT not in self._nlp.pipe_names:\n self._nlp.add_pipe(PIPE_INTENT, last=True)\n\n intent_pipe = self._nlp.get_pipe(PIPE_INTENT)\n for intent in self._intents:\n intent_pipe.add_label(intent)","def train(\n model_path=\"./trained_model/\",\n model_file_name=\"model.h5\",\n training_data_path=\"./train.csv\",\n):\n config = SConfig(training_data_path=training_data_path)\n s2s = Seq2Seq(config)\n s2s.fit()\n s2s.save_model(path_to_model=model_path, model_file_name=model_file_name)","def main(model=None, output_dir=None, n_iter=10):\n if model is not None:\n nlp = spacy.load(model) # load existing spaCy model\n print(\"Loaded model '%s'\" % model)\n else:\n nlp = spacy.blank('en') # create blank Language class\n print(\"Created blank 'en' model\")\n\n # add the parser to the pipeline if it doesn't exist\n # nlp.create_pipe works for built-ins that are registered with spaCy\n if 'parser' not in nlp.pipe_names:\n parser = nlp.create_pipe('parser')\n nlp.add_pipe(parser, first=True)\n # otherwise, get it, so we can add labels to it\n else:\n parser = nlp.get_pipe('parser')\n\n # add labels to the parser\n for _, annotations in TRAIN_DATA:\n for dep in annotations.get('deps', []):\n parser.add_label(dep)\n\n # get names of other pipes to disable them during training\n other_pipes = [pipe for pipe in nlp.pipe_names if pipe != 'parser']\n with nlp.disable_pipes(*other_pipes): # only train parser\n optimizer = nlp.begin_training()\n for itn in range(n_iter):\n random.shuffle(TRAIN_DATA)\n losses = {}\n for text, annotations in TRAIN_DATA:\n nlp.update([text], [annotations], sgd=optimizer, losses=losses)\n print(losses)\n\n # test the trained model\n test_text = \"It was back in 2007 that hip-hop bible XXL launched its first ever Freshman Class, a list of ten up-and-coming artists poised to change the rap game for good. The last decade has seen more than a hundred stars spotlighted as part of the list and its accompanying annual cover feature, but this year features a history-making entry: Stefflon Don. The talented star has already built a strong reputation for herself in the UK; her unique blend of hard-hitting raps and smooth, dancehall beats has galvanized the scene, earning her critical acclaim and a series of impressive chart positions. Now, she seems ready to achieve the unthinkable: global stardom. Earlier this year, her infectious hit “Hurtin’ Me” – featuring former XXL Freshman French Montana – ascended the Billboard charts, peaking at no. 7 and confirming her US fanbase; but could she truly become the first artist to crack the US? And, more importantly, why has it taken so long for UK rappers to achieve Stateside success?\"\n doc = nlp(test_text)\n print('Dependencies', [(t.text, t.dep_, t.head.text) for t in doc])\n sentence_spans = list(doc.sents)\n displacy.serve(sentence_spans, style='dep')\n\n # save model to output directory\n if output_dir is not None:\n output_dir = Path(output_dir)\n if not output_dir.exists():\n output_dir.mkdir()\n nlp.to_disk(output_dir)\n print(\"Saved model to\", output_dir)\n\n # test the saved model\n print(\"Loading from\", output_dir)\n nlp2 = spacy.load(output_dir)\n doc = nlp2(test_text)\n print('Dependencies', [(t.text, t.dep_, t.head.text) for t in doc])","def train():\n \n ## check for request data\n if not request.json:\n print(\"ERROR: API (train): did not receive request data\")\n return jsonify(False)\n\n ## set the test flag\n test = False\n if 'mode' in request.json and request.json['mode'] == 'test':\n test = True\n\n print(\"... training model\")\n model = model_train(test=test)\n print(\"... training complete\")\n\n return(jsonify(True))","def train_model():\n # Decode the request\n data = request.data.decode(\"utf-8\")\n\n # Write data from the request in a local csv file\n train_csv = \"train_local.csv\"\n f = open(train_csv, \"w\", encoding=\"utf-8\")\n f.write(data)\n f.close()\n\n # Load the train csv file as a DataFrame\n train_df = pd.read_csv(train_csv)\n\n # Train model\n model.train_model(train_df)\n\n return jsonify({\"success\": \"The model was trained sucessfully\"})","def main(model=None, output_dir=None, n_iter=20):\n if model is not None:\n nlp = spacy.load(model) # load existing spaCy model\n print(\"Loaded model '%s'\" % model)\n else:\n nlp = spacy.blank('en') # create blank Language class\n print(\"Created blank 'en' model\")\n\n # create the built-in pipeline components and add them to the pipeline\n # nlp.create_pipe works for built-ins that are registered with spaCy\n if 'ner' not in nlp.pipe_names:\n ner = nlp.create_pipe('ner')\n nlp.add_pipe(ner, last=True)\n # otherwise, get it so we can add labels\n else:\n ner = nlp.get_pipe('ner')\n\n # add labels\n for _, annotations in TRAIN_DATA:\n for ent in annotations.get('entities'):\n ner.add_label(str(ent[2]))\n\n # get names of other pipes to disable them during training\n other_pipes = [pipe for pipe in nlp.pipe_names if pipe != 'ner']\n with nlp.disable_pipes(*other_pipes): # only train NER\n optimizer = nlp.begin_training()\n for itn in range(n_iter):\n random.shuffle(TRAIN_DATA)\n losses = {}\n for text, annotations in TRAIN_DATA:\n nlp.update(\n [text], # batch of texts\n [annotations], # batch of annotations\n drop=0.5, # dropout - make it harder to memorise data\n sgd=optimizer, # callable to update weights\n losses=losses)\n print(losses)\n \n # test the trained model\n for text, _ in TRAIN_DATA:\n doc = nlp(text)\n print('Entities', [(ent.text, ent.label_) for ent in doc.ents])\n print('Tokens', [(t.text, t.ent_type_, t.ent_iob) for t in doc])\n \n # save model to output directory\n if output_dir is not None:\n print(output_dir)\n output_dir = Path(output_dir)\n if not output_dir.exists():\n output_dir.mkdir()\n nlp.to_disk(output_dir)\n print(\"Saved model to\", output_dir)\n\n # test the saved model\n print(\"Loading from\", output_dir)\n nlp2 = spacy.load(output_dir)\n for text, _ in TRAIN_DATA:\n doc = nlp2(text)\n print('Entities', [(ent.text, ent.label_) for ent in doc.ents])\n print('Tokens', [(t.text, t.ent_type_, t.ent_iob) for t in doc])","def train():\n import training\n\n # Ensure output directories exist\n os.makedirs(os.path.dirname(cfg.scaler_path), exist_ok=True)\n os.makedirs(cfg.model_path, exist_ok=True)\n os.makedirs(cfg.log_path, exist_ok=True)\n\n # Load (standardized) input data and target values\n tr_x, tr_y, _ = _load_data(cfg.training_set, is_training=True)\n val_x, val_y, _ = _load_data(cfg.validation_set)\n\n # Try to create reproducible results\n np.random.seed(cfg.initial_seed)\n\n # Save free parameters to disk\n utils.log_parameters(cfg.training, os.path.join(cfg.model_path,\n 'parameters.json'))\n\n training.train(tr_x, tr_y, val_x, val_y)","def train_on_device(data_dir, dataset_id, model_path, ckpt_path, weight_updates_path):\r\n\r\n # Store pre-trained model and weights\r\n old_model = load_model(model_path)\r\n old_model.load_weights(ckpt_path)\r\n\r\n # Initialize model and checkpoint, which are obtained from server\r\n device_model = load_model(model_path)\r\n device_model.load_weights(ckpt_path)\r\n\r\n # print(device_model.summary())\r\n\r\n # load the vocabulary\r\n vocab_filename = os.path.join(data_dir, \"vocab.txt\")\r\n vocab = load_doc(vocab_filename)\r\n vocab = vocab.split()\r\n vocab = set(vocab)\r\n\r\n # create the tokenizer\r\n tokenizer = Tokenizer()\r\n\r\n # loading tokenizer from file\r\n tokenizer_filename = os.path.join(data_dir, \"tokenizer.pickle\")\r\n with open(tokenizer_filename, \"rb\") as handle:\r\n tokenizer = pickle.load(handle)\r\n\r\n # Get training data present on device\r\n X_train, y_train = get_data(data_dir, dataset_id, vocab, tokenizer, is_train=True)\r\n\r\n X_test, y_test = get_data(data_dir, dataset_id, vocab, tokenizer, is_train=False)\r\n\r\n scores = device_model.evaluate(X_test, y_test, verbose=0)\r\n print(\"Test Accuracy(before training): %.2f%%\" % (scores[1] * 100))\r\n\r\n # Train model\r\n device_model.fit(\r\n X_train, y_train, epochs=NUM_EPOCHS, batch_size=BATCH_SIZE,\r\n )\r\n\r\n scores = device_model.evaluate(X_test, y_test, verbose=0)\r\n print(\"Test Accuracy(after training): %.2f%%\" % (scores[1] * 100))\r\n\r\n # Load model to store weight updates\r\n weight_updates = load_model(model_path)\r\n\r\n # Number of batches trained on device\r\n num_batches = X_train.shape[0] // BATCH_SIZE\r\n\r\n # Calculate weight updates\r\n for i in range(len(device_model.layers)):\r\n\r\n # Pre-trained weights\r\n old_layer_weights = old_model.layers[i].get_weights()\r\n\r\n # Post-trained weights\r\n new_layer_weights = device_model.layers[i].get_weights()\r\n\r\n # Weight updates calculation\r\n weight_updates.layers[i].set_weights(\r\n num_batches\r\n * (np.asarray(new_layer_weights) - np.asarray(old_layer_weights)),\r\n )\r\n\r\n # print(\"old weights: \", old_layer_weights)\r\n # print(\"new weights: \", new_layer_weights)\r\n # print(\"weight updates: \", weight_updates.layers[i].get_weights())\r\n\r\n # Save weight updates\r\n weight_updates.save_weights(weight_updates_path)\r\n\r\n return (num_batches, weight_updates_path)","def train(\n self,\n training_data: TrainingData,\n config: Optional[RasaNLUModelConfig] = None,\n **kwargs: Any,\n ) -> None:\n pass","def train(\n self,\n training_data: TrainingData,\n config: Optional[RasaNLUModelConfig] = None,\n **kwargs: Any,\n ) -> None:\n pass","def train(self, data, beam_size=10, n_epochs=1, trunc_data=None):\n print(\"Training syntactic parser:\")\n for e in range(n_epochs):\n print(\"Epoch:\", e+1, \"/\", n_epochs)\n train_sentences_tags_trees = zip( get_sentences(data), \\\n get_tags(data), \\\n get_trees(data) )\n for i, (words, gold_tags, gold_tree) in \\\n enumerate(train_sentences_tags_trees):\n self.parse(words, gold_tree, beam_size=beam_size)\n print(\"\\rUpdated with sentence #{}\".format(i), end=\"\")\n if trunc_data and i >= trunc_data:\n break\n print(\"\")\n self.finalize()","def train(self, data):\n pass","def train(cleaner, data_source, save_to=\"../models/model.pkl\"):\n df = pd.read_csv(data_source)\n df = df[pd.notnull(df['tags'])]\n print(\"Start : Pre-cleaning process . . . \")\n print(\" HTML decoding . . . done\")\n print(\" lowercase text . . . done\")\n print(\" replace [/(){}\\[\\]\\|@,;] symbols by space . . . done\")\n print(\" remove remaining symbols . . . done\")\n print(\" remove stopwords . . . done\")\n df['post'] = df['post'].apply(cleaner)\n print(\"End : Pre-cleaning process\")\n x = df.post\n y = df.tags\n # no need for split data in final training stage\n # X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state = 42)\n print(\"Start : model creation process . . . \")\n sgd = Pipeline([('vect', CountVectorizer()),\n ('tfidf', TfidfTransformer()),\n ('clf', SGDClassifier(loss='hinge', penalty='l2', alpha=1e-3, random_state=42, max_iter=5,\n tol=None)),\n ])\n # sgd.fit(X_train, y_train)\n sgd.fit(x, y)\n print(\"End : model creation process\")\n model = open(save_to, 'wb')\n pickle.dump(sgd, model)\n model.close()\n print(\"Trained model saved to \" + save_to)\n return sgd","def train_nlp(model: ContinualModel, dataset: ContinualDataset,\n args: Namespace) -> None:\n model.net.to(model.device)\n results, results_mask_classes = [], []\n \n model_stash = create_stash(model, args, dataset)\n \n if args.csv_log:\n csv_logger = CsvLogger(dataset.SETTING, dataset.NAME, model.NAME)\n if args.tensorboard:\n tb_logger = TensorboardLogger(args, dataset.SETTING, model_stash)\n model_stash['tensorboard_name'] = tb_logger.get_name()\n \n dataset_copy = get_dataset(args)\n \n for t in range(dataset.N_TASKS):\n model.net.train()\n _, _ = dataset_copy.get_data_loaders()\n if model.NAME != 'icarl' and model.NAME != 'pnn':\n # for forward transfer calculation\n random_results_class, random_results_task = evaluate_nlp(model, dataset_copy)\n \n print(file=sys.stderr)\n # start time\n start_time = time.time()\n for t in range(dataset.N_TASKS):\n model.net.train()\n train_loader, test_loader = dataset.get_data_loaders()\n if hasattr(model, 'begin_task'):\n model.begin_task(dataset)\n if t:\n accs = evaluate_nlp(model, dataset, last=True)\n results[t - 1] = results[t - 1] + accs[0]\n if dataset.SETTING == 'class-il':\n results_mask_classes[t - 1] = results_mask_classes[t - 1] + accs[1]\n for epoch in range(args.n_epochs):\n for i, data in enumerate(train_loader):\n if hasattr(dataset.train_loader.dataset, 'logits'):\n # todo: to add logits\n pass\n else:\n xs, ys, x_token_idxs, x_token_masks, y_token_idxs, y_token_masks, y_idxs = data\n \n x_token_idxs = x_token_idxs.to(model.device)\n x_token_masks = x_token_masks.to(model.device)\n y_token_idxs = y_token_idxs.to(model.device)\n y_token_masks = y_token_masks.to(model.device)\n y_idxs = y_idxs.to(model.device)\n task_id = torch.tensor(t, dtype=torch.int64, requires_grad=False)\n task_id = task_id.to(model.device)\n \n if model.require_task_id:\n loss = model.observe(inputs=x_token_idxs, inputs_mask=x_token_masks, labels=y_idxs,\n labels_name=y_token_idxs, labels_mask=y_token_masks, task_labels=task_id)\n else:\n loss = model.observe(inputs=x_token_idxs, inputs_mask=x_token_masks, labels=y_idxs,\n labels_name=y_token_idxs, labels_mask=y_token_masks)\n \n progress_bar(i, len(train_loader), epoch, t, loss)\n \n if args.tensorboard:\n tb_logger.log_loss(loss, args, epoch, t, i)\n \n model_stash['batch_idx'] = i + 1\n model_stash['epoch_idx'] = epoch + 1\n model_stash['batch_idx'] = 0\n \n model_stash['task_idx'] = t + 1\n model_stash['epoch_idx'] = 0\n \n if hasattr(model, 'end_task'):\n model.end_task(dataset)\n \n # reduce the running freq\n # if (t+1) % args.eval_freq == 0:\n accs = evaluate_nlp(model, dataset)\n results.append(accs[0])\n results_mask_classes.append(accs[1])\n \n mean_acc = np.mean(accs, axis=1)\n print_mean_accuracy(mean_acc, t + 1, dataset.SETTING)\n \n # prob_model\n if args.prob_all_tasks:\n if args.prob_type != \"\":\n for prob_l in range(12):\n prob_l += 1\n if args.prob_type == \"proto\":\n p_accs = prob_proto_nlp(model, dataset, prob_l=prob_l)\n else:\n p_accs = prob_final_nlp(model, dataset, prob_l=prob_l)\n p_mean_acc = np.mean(p_accs, axis=1)\n print(\"task {} prob_l {}: mean_acc {}, masked_mean_acc {}\".format(t + 1,\n prob_l,\n round(p_mean_acc[0], 2),\n round(p_mean_acc[1], 2)))\n if args.csv_log:\n csv_logger.log_task_prob(p_mean_acc, t)\n \n model_stash['mean_accs'].append(mean_acc)\n if args.csv_log:\n csv_logger.log(mean_acc)\n if args.tensorboard:\n tb_logger.log_accuracy(np.array(accs), mean_acc, args, t)\n \n running_time = time.time() - start_time\n \n # prob_model\n if args.prob_type != \"\" and not args.prob_all_tasks:\n for prob_l in range(12):\n prob_l += 1\n if args.prob_type == \"proto\":\n accs = prob_proto_nlp(model, dataset, prob_l=prob_l)\n else:\n accs = prob_final_nlp(model, dataset, prob_l=prob_l)\n mean_acc = np.mean(accs, axis=1)\n print(\"prob_l {}: mean_acc {}, masked_mean_acc {}\".format(prob_l, mean_acc[0], mean_acc[1]))\n if args.csv_log:\n csv_logger.log_prob(mean_acc)\n \n if args.csv_log:\n csv_logger.add_bwt(results, results_mask_classes)\n csv_logger.add_running_time(running_time)\n csv_logger.add_forgetting(results, results_mask_classes)\n if model.NAME != 'icarl' and model.NAME != 'pnn':\n csv_logger.add_fwt(results, random_results_class,\n results_mask_classes, random_results_task)\n \n if args.tensorboard:\n tb_logger.close()\n if args.csv_log:\n csv_logger.write(vars(args))","def training(training_data, iterations):\n nlp = spacy.blank('en') # create blank Language class\n # create the built-in pipeline components and add them to the pipeline\n # nlp.create_pipe works for built-ins that are registered with spaCy\n if 'ner' not in nlp.pipe_names:\n ner = nlp.create_pipe('ner')\n nlp.add_pipe(ner, last=True)\n\n # add labels\n for _, annotations in training_data:\n for ent in annotations.get('entities'):\n ner.add_label(ent[2])\n\n # get names of other pipes to disable them during training\n other_pipes = [pipe for pipe in nlp.pipe_names if pipe != 'ner']\n with nlp.disable_pipes(*other_pipes): # only train NER\n optimizer = nlp.begin_training()\n for itn in range(iterations):\n print(\"Starting iteration \" + str(itn))\n random.shuffle(TRAIN_DATA)\n losses = {}\n for text, annotations in training_data:\n nlp.update(\n [text], # batch of texts\n [annotations], # batch of annotations\n drop=0.2, # dropout - make it harder to memorise data\n sgd=optimizer, # callable to update weights\n losses=losses)\n print(losses)\n return nlp","def train(self, train_data):\n with open(train_data, 'r') as train_data:\n while True:\n tokens = train_data.readline().split()\n pos = train_data.readline().split()\n labels = train_data.readline().split()\n if not tokens or not pos or not labels:\n break\n # Generate transition probabilities\n for i in range(0, len(labels) - self.N_VALUE + 1):\n self.add_label_sequence(labels[i:i + self.N_VALUE])\n # Generate lexical generation probabilities\n for i in range(0, len(tokens)):\n token = tokens[i].lower()\n label = labels[i]\n self.add_word_tag(token, label)\n self.handle_unknowns()","def train(self, training_data: TrainingData, config: RasaNLUModelConfig, **kwargs: Any) -> None:\n pass","def train(sess, env, Xdata, ydata, X_valid=None, y_valid=None, epochs=1,\n load=False, shuffle=True, batch_size=128, name='model'):\n if load:\n if not hasattr(env, 'saver'):\n return print('\\nError: cannot find saver op')\n print('\\nLoading saved model')\n return env.saver.restore(sess, 'model/{}'.format(name))\n\n print('\\nTrain model')\n n_sample = Xdata.shape[0]\n n_batch = int((n_sample+batch_size-1) / batch_size)\n for epoch in range(epochs):\n print('\\nEpoch {0}/{1}'.format(epoch + 1, epochs))\n\n if shuffle:\n print('\\nShuffling data')\n ind = np.arange(n_sample)\n np.random.shuffle(ind)\n Xdata = Xdata[ind]\n ydata = ydata[ind]\n\n for batch in range(n_batch):\n print(' batch {0}/{1}'.format(batch + 1, n_batch), end='\\r')\n begin = batch * batch_size\n ending = min(n_sample, begin + batch_size)\n sess.run(env.train_op, feed_dict={env.x: Xdata[begin:ending],\n env.y: ydata[begin:ending],\n env.training: True})\n if X_valid is not None:\n evaluate(sess, env, X_valid, y_valid)\n\n if hasattr(env, 'saver'):#在此处保存模型吧？\n print('\\n Saving model')\n os.makedirs('model', exist_ok=True)\n env.saver.save(sess, 'model/{}'.format(name))","def train(env, X_data, y_data, X_valid=None, y_valid=None, epochs=50,\n learning_rate=0.1, load=False, shuffle=True, batch_size=1, name='model'):\n if load:\n if not hasattr(env, 'saver'):\n print('\\nError: cannot find saver op')\n return\n print('\\nLoading saved model')\n return env.saver.restore(env.sess, 'model/{}'.format(name))\n print('\\nTrain model')\n n_sample = X_data.shape[0]\n n_batch = int((n_sample+batch_size-1) / batch_size)\n for epoch in range(epochs):\n print('\\nEpoch {0}/{1}'.format(epoch + 1, epochs))\n\n if (epochs == 30) | (epochs == 40) | (epochs == 50):\n learning_rate = learning_rate * 0.1\n\n if shuffle:\n print('\\nShuffling data')\n ind = np.arange(n_sample)\n np.random.shuffle(ind)\n X_data = X_data[ind]\n y_data = y_data[ind]\n for batch in range(n_batch):\n print(' batch {0}/{1}'.format(batch + 1, n_batch))\n print('\\r')\n start = batch * batch_size\n end = min(n_sample, start + batch_size)\n env.sess.run(env.train_op, feed_dict={env.x: X_data[start:end],\n env.y: y_data[start:end],\n env.training: True})\n if X_valid is not None:\n evaluate(env, X_valid, y_valid)\n if hasattr(env, 'saver'):\n print('\\n Saving model')\n if not os.path.exists('model'):\n os.mkdir('model')\n env.saver.save(env.sess, 'model/{}'.format(name))","def run(self) -> None:\n self.model = self.trainer.train_model(self.model, self.data)","def trainModel( self, featureTrain, classTrain):","def train(self, training_data):\n pass","def _train(args, pretrain_args):\n start_time = time.time()\n print('Training', ', '.join(args.speakers), '...')\n\n # randomly sample validation set monte_carlo_cv_num times\n for num in range(args.monte_carlo_cv_num):\n # get seed used to sub-sample validation dataset (use 42 for 1st run)\n seed = utils.get_seed(num)\n\n # get train/valid/test data and convert to sequences\n train_data, valid_data, test_data, id_to_word = data_reader.get_data(\n args, seed=seed)\n # set configurations/hyperparameters for model\n config, test_config = utils.set_config(args, id_to_word)\n\n # initialize word embeddings\n init_embed = utils.init_embedding(id_to_word, dim=args.embed_size,\n init_scale=args.init_scale,\n embed_path=args.embed_path)\n\n with tf.Graph().as_default():\n # initializer used to initialize TensorFlow variables\n initializer = tf.random_uniform_initializer(-config['init_scale'],\n config['init_scale'])\n # create Train model\n with tf.name_scope('Train'):\n with tf.variable_scope('Model', reuse=None,\n initializer=initializer):\n m_train = model.Model(args, is_training=True, config=config,\n init_embed=init_embed, name='Train')\n m_train.build_graph()\n\n # create Valid model\n with tf.name_scope('Valid'):\n with tf.variable_scope('Model', reuse=True,\n initializer=initializer):\n m_valid = model.Model(args, is_training=False, config=config,\n init_embed=init_embed, name='Valid')\n m_valid.build_graph()\n\n # create Test model\n with tf.name_scope('Test'):\n with tf.variable_scope('Model', reuse=True,\n initializer=initializer):\n m_test = model.Model(args, is_training=False, config=test_config,\n init_embed=init_embed, name='Test')\n m_test.build_graph()\n\n # create summaries to be viewed in TensorBoard\n tb_summaries = utils.TensorBoardSummaries()\n tb_summaries.create_ops()\n\n init = tf.global_variables_initializer()\n\n # if pretrained, must create dict to initialize TF Saver\n if bool(pretrain_args):\n # get trainable variables and convert to dict for Saver\n reuse_vars = tf.get_collection(\n tf.GraphKeys.TRAINABLE_VARIABLES)\n reuse_vars_dict = dict(\n [(var.op.name, var) for var in reuse_vars])\n # create saver for TF session (see function for addl details)\n saver = utils.create_tf_saver(args, pretrain_args,\n reuse_vars_dict)\n else:\n saver = tf.train.Saver()\n\n # ppls dict has perplexities that are stored in results database\n ppls = {}\n ppls, _ = _update_ppls(ppls, initialize=True)\n\n with tf.Session() as sess:\n sess.run(init)\n\n if args.load_path != '':\n print('Restoring model...')\n saver.restore(sess, args.load_path)\n\n for epoch in range(config['max_epoch']):\n print('Epoch: {0} Learning rate: {1:.3f}\\n'.format(\n epoch + 1, sess.run(m_train.lr)))\n for i, speaker in enumerate(args.speakers):\n print('Training {0} ...'.format(speaker))\n\n # run epoch on training data\n train_perplexity = _run_epoch(sess, m_train, args, train_data,\n i, tb_summaries, id_to_word,\n train_op=m_train.train_op,\n verbose=True)\n print('Epoch: {0} Train Perplexity: {1:.3f}'.format(\n epoch + 1, train_perplexity))\n ppls, _ = _update_ppls(ppls, epoch=epoch+1,\n speaker=speaker,\n ppl=train_perplexity,\n dataset='train')\n\n print('Validating...')\n # run epoch on validation data\n valid_perplexity = _run_epoch(sess, m_valid, args,\n valid_data, i, tb_summaries,\n id_to_word, verbose=True)\n print('Epoch: {0} Valid Perplexity: {1:.3f}'.format(\n epoch + 1, valid_perplexity))\n ppls, improved = _update_ppls(ppls, epoch=epoch+1,\n speaker=speaker,\n ppl=valid_perplexity,\n dataset='valid')\n\n if improved:\n # save model if valid ppl is lower than current\n # best valid ppl\n if args.save_path != '':\n print('Saving model to {0}.'.format(\n args.save_path))\n saver.save(sess, args.save_path)\n\n for i, speaker in enumerate(args.speakers):\n print('Testing {0} ...'.format(speaker))\n print('Restoring best model for testing...')\n saver.restore(sess, args.save_path)\n # run model on test data\n test_perplexity = _run_epoch(sess, m_test, args, test_data, i)\n ppls['test_ppl_' + speaker] = test_perplexity\n print('Test Perplexity: {0:.3f}'.format(test_perplexity))\n\n if args.insert_db == 'True':\n # write params/config/results to sql database\n results_db.insert_results(args, config, start_time, ppls)","def trainModel(data, labels, vData, vLabels, logger, params):\n\t#save the random seed\n\tlogger.logSeed()\n\n\t#create the model\n\tif params.emb:\n\t\t\n\t\tif params.useBothHalves:\n\t\t\tmodel = buildMultiEmbModel(params.numClasses(), params.windowSize, params.contextSize, params.wordWeights, params.eventMap)\n\t\telse:\n\t\t\tmodel = buildCNNEmbModel(params.numClasses(), params.windowSize, params.contextSize, params.wordWeights, params.eventMap)\n\n\telif params.split:\n\t\tmodel = buildSplitModel(params.numClasses(), params.windowSize, params.wordSize, params.contextSize, params.eventMap)\n\t\t#model = buildAttentionModel(params.numClasses(), params.windowSize, params.wordSize, params.contextSize, params.eventMap)\n\telse:\n\t\tmodel = buildModel(params.numClasses(), params.windowSize, params.wordSize, params.contextSize, params.eventMap)\n\n\t#fit the model\n\tmodel.fit(data, labels, nb_epoch=params.epochs, batch_size=params.batchSize, \n\t\tvalidation_data=(vData, vLabels), \n\t\tcallbacks=[logger], class_weight=params.weights)\n\n\tbest = logger.best()\n\n\tprint(\"Best Model round: {} val: {}\".format(logger.bestModel, logger.bestScore))\n\n\t#return the best\n\treturn best, logger.bestModel","def test_pyt_preprocess_train(self):\n # Second, check that the model will train\n defaults = parser_defaults.copy()\n defaults['datatype'] = 'train'\n defaults['pytorch_preprocess'] = True\n str_output, _, _ = testing_utils.train_model(defaults)\n self.assertTrue(\n solved_task(str_output),\n 'Teacher could not teach seq2seq with preprocessed obs, output: {}'\n .format(str_output)\n )","def main():\n # Read data for train set\n print('loading training data')\n train = read_datafile('../data/tsd_train.csv')\n\n # Read trial data for validation set\n validation = read_datafile('../data/tsd_trial.csv')\n\n # Read data for test set\n print('loading test data')\n test = read_datafile('../data/tsd_test.csv')\n\n # Convert training data to Spacy Entities\n nlp = spacy.load(\"en_core_web_sm\")\n print('preparing training data')\n training_data = []\n for n, (spans, text) in enumerate(train):\n doc = nlp(text)\n ents = spans_to_ents(doc, set(spans), 'TOXIC')\n training_data.append((doc.text, {'entities': ents}))\n\n toxic_tagging = spacy.blank('en')\n toxic_tagging.vocab.strings.add('TOXIC')\n ner = nlp.create_pipe(\"ner\")\n toxic_tagging.add_pipe(ner, last=True)\n ner.add_label('TOXIC')\n\n pipe_exceptions = [\"ner\", \"trf_wordpiecer\", \"trf_tok2vec\"]\n unaffected_pipes = [\n pipe for pipe in toxic_tagging.pipe_names\n if pipe not in pipe_exceptions]\n\n\n print('Training!')\n with toxic_tagging.disable_pipes(*unaffected_pipes):\n \n toxic_tagging.begin_training()\n for iteration in range(30):\n random.shuffle(training_data)\n losses = {}\n batches = spacy.util.minibatch(\n training_data, size=spacy.util.compounding(\n 4.0, 32.0, 1.001))\n for batch in batches:\n texts, annotations = zip(*batch)\n toxic_tagging.update(texts, annotations, drop=0.5, losses=losses)\n print(\"Losses\", losses)\n\n\n # Define helper function for evaluating datasets\n def evaluate(dateset):\n precision_recall_f1_scores = []\n for spans, text in dateset:\n pred_spans = []\n doc = toxic_tagging(text)\n for ent in doc.ents:\n pred_spans.extend(range(ent.start_char, ent.start_char + len(ent.text)))\n \n # score = semeval2021.f1(pred_spans, spans)\n precision_recall_f1_scores.append(per_post_precision_recall_f1(pred_spans, spans))\n\n # compute average precision, recall and f1 score of all posts\n return np.array(precision_recall_f1_scores).mean(axis=0)\n\n # Evaluate on dev and test sets\n print('Evaluation:')\n eval_precision, eval_recall, eval_f1 = evaluate(validation)\n test_precision, test_recall, test_f1 = evaluate(test)\n \n print(f'Dev set: Precision = {eval_precision}, Recall = {eval_recall}, F1 = {eval_f1}')\n print(f'Test set: Precision = {test_precision}, Recall = {test_recall}, F1 = {test_f1}')","def train(model, timeseries, indices, words, args):\n top = len(timeseries)-args.window_size-args.batch_size-int(len(timeseries)*0.05)\n print(\"--- Model Version: {} ---\".format(name))\n print(\"Number of words in training set: {}\".format(top))\n model.fit_generator(generator(timeseries, indices, words, args, 1, top), steps_per_epoch=args.epoch_steps, epochs=args.nb_epoch, validation_data=generator(timeseries, indices, words, args, top, len(timeseries)-args.window_size-args.batch_size), validation_steps=args.val_steps, callbacks=[lr_reducer, checkpointer], shuffle=True)","def train(net, train_data,\n dev_data_filepath, dev_preds_filepath, model_save_path,\n para_selector, # TODO sort these nicely\n ps_threshold=0.1,\n ner_device=torch.device('cpu'), training_device=torch.device('cpu'),\n text_length=250,\n fb_passes=1, coefs=(0.5, 0.5),\n epochs=3, batch_size=1, learning_rate=1e-4,\n eval_interval=None, verbose_evaluation=False, timed=False):\n timer = utils.Timer()\n\n tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n\n flair.device = torch.device(ner_device)\n ner_tagger = flair.models.SequenceTagger.load('ner') # this hard-codes flair tagging!\n\n optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)\n\n losses = []\n real_batch_sizes = [] # some data points are not usable; this logs the real sizes\n graph_logging = [0, 0, 0] # [total nodes, total connections, number of graphs]\n point_usage = [0, 0] # [used points, unused points]\n dev_scores = []\n\n # Set the network into train mode\n net.train()\n net = net.to(training_device)\n\n timer(\"training_preparation\")\n\n print(\"Training...\")\n\n best_score = 0\n eval_interval = eval_interval if eval_interval else float('inf') # interval in batches\n a_model_was_saved_at_some_point = False\n\n for epoch in range(epochs):\n # TODO take recurrent times for forward, evaluation saving etc.\n print('Epoch %d/%d' % (epoch + 1, epochs))\n batch_counter = 0\n\n for step, batch in enumerate(tqdm(train_data, desc=\"Iteration\")):\n\n \"\"\" DATA PROCESSING \"\"\"\n ids = []\n queries = []\n contexts = []\n graphs = []\n\n useless_datapoint_inds = []\n\n for i, point in enumerate(batch):\n\n # make a list[ list[str, list[str]] ] for each point in the batch\n context = para_selector.make_context(point,\n threshold=ps_threshold,\n context_length=text_length) # TODO add device and numerated arguments\n graph = EntityGraph.EntityGraph(context,\n context_length=text_length,\n tagger=ner_tagger)\n if graph.graph:\n ids.append(point[0])\n queries.append(point[2])\n contexts.append(context)\n graphs.append(graph)\n graph_logging = [a+b # [total nodes, total connections, number of graphs]\n for a,b in zip(graph_logging, [len(graph.graph),\n len(graph.relation_triplets()),\n 1])]\n point_usage[0] += 1\n else: # if the NER in EntityGraph doesn't find entities, the datapoint is useless.\n useless_datapoint_inds.append(i)\n point_usage[1] += 1\n\n batch = [point for point in batch if point[0] in ids] # update the batch to exclude useless data points\n\n real_batch_sizes.append(batch_size - len(useless_datapoint_inds)) #TODO track the batch sizes!\n\n # if our batch is completely useless, just continue with the next batch. :(\n if len(useless_datapoint_inds) == batch_size:\n continue\n\n # turn the texts into tensors in order to put them on the GPU\n qc_ids = [net.encoder.token_ids(q, c) for q, c in zip(queries, contexts)] # list[ (list[int], list[int]) ]\n q_ids, c_ids = list(zip(*qc_ids)) # tuple(list[int]), tuple(list[int])\n q_ids_list = [torch.tensor(q) for q in q_ids] # list[Tensor] #TODO? maybe put this into forward()?\n c_ids_list = [torch.tensor(c) for c in c_ids] # list[Tensor]\n\n \"\"\" MAKE TRAINING LABELS \"\"\"\n # replace the paragraphs in raw_point with their shortened versions (obtained from PS)\n for (i, p), c in zip(enumerate(batch), contexts):\n batch[i][3] = c\n\n # TODO? change utils.make_labeled_data_for_predictor() to process batches of data?\n labels = [utils.make_labeled_data_for_predictor(g,p,tokenizer) for g,p in zip(graphs, batch)] # list[(support, start, end, type)]\n # list[(Tensor, Tensor, Tensor, Tensor)] -> tuple(Tensor), tuple(Tensor), tuple(Tensor), tuple(Tensor)\n sup_labels, start_labels, end_labels, type_labels = list(zip(*labels))\n # print(f\"in train_dfgn.train(): shapes of labels:\\n{len(sup_labels)}, {len(start_labels)}, {len(end_labels)}, {len(type_labels)}\") #CLEANUP\n\n q_ids_list = [t.to(training_device) if t is not None else None for t in q_ids_list]\n c_ids_list = [t.to(training_device) if t is not None else None for t in c_ids_list]\n for i, g in enumerate(graphs):\n graphs[i].M = g.M.to(training_device) # work with enumerate to actually mutate the graph objects\n\n sup_labels = torch.stack(sup_labels).to(training_device) # (batch, M)\n start_labels = torch.stack(start_labels).to(training_device) # (batch, 1)\n end_labels = torch.stack(end_labels).to(training_device) # (batch, 1)\n type_labels = torch.stack(type_labels).to(training_device) # (batch)\n\n \"\"\" FORWARD PASSES \"\"\"\n optimizer.zero_grad()\n\n sups, starts, ends, types = [], [], [], []\n for query, context, graph in zip(q_ids_list, c_ids_list, graphs): # 'graph' is not a tensor -> for-loop instead of batch processing\n\n o_sup, o_start, o_end, o_type = net(query, context, graph, fb_passes=fb_passes) # (M, 2), (M), (M), (1, 3)\n sups.append(o_sup)\n starts.append(o_start)\n ends.append(o_end)\n types.append(o_type)\n\n sups = torch.stack(sups) # (batch, M, 2)\n starts = torch.stack(starts) # (batch, 1, M)\n ends = torch.stack(ends) # (batch, 1, M)\n types = torch.stack(types) # (batch, 1, 3)\n\n \"\"\" LOSSES & BACKPROP \"\"\"\n weights = torch.ones(2, device=training_device) #TODO maybe extract this to a tiny function?\n sup_label_batch = sup_labels.view(-1)\n weights[0] = sum(sup_label_batch)/float(sup_label_batch.shape[0])\n weights[1] -= weights[0] # assign the opposite weight\n\n sup_criterion = torch.nn.CrossEntropyLoss(weight=weights)\n criterion = torch.nn.CrossEntropyLoss() # for prediction of answer type\n\n # use .view(-1,...) to put points together (this is like summing the points' losses)\n sup_loss = sup_criterion(sups.view(-1,2), sup_label_batch) # (batch*M, 2), (batch*M)\n start_loss = sum([criterion(starts[i], start_labels[i]) for i in range(start_labels.shape[0])]) # batch * ( (1, M, 1), (1) )\n end_loss = sum([criterion(ends[i], end_labels[i]) for i in range(end_labels.shape[0])]) # batch * ( (1, M, 1), (1) )\n type_loss = criterion(types.view(-1,3), type_labels.view(-1)) # (batch, 1, 3), (batch, 1)\n\n # This doesn't have the weak supervision BFS mask stuff from section 3.5 of the paper\n # TODO? maybe start training with start/end loss only first, then train another model on all 4 losses?\n loss = start_loss + end_loss + coefs[0]*sup_loss + coefs[1]*type_loss # formula 15\n\n loss.backward(retain_graph=True)\n losses.append( (loss.item(),\n sup_loss.item(),\n start_loss.item(),\n end_loss.item(),\n type_loss.item())) # for logging purposes\n\n batch_counter += 1\n # Evaluate on validation set after some iterations\n if batch_counter % eval_interval == 0:\n\n # this calls the official evaluation script (altered to return metrics)\n metrics = evaluate(net, #TODO make this prettier\n tokenizer, ner_tagger,\n training_device, dev_data_filepath, dev_preds_filepath,\n fb_passes = fb_passes,\n text_length = text_length,\n verbose=verbose_evaluation)\n score = metrics[\"joint_f1\"]\n dev_scores.append(metrics) # appends the whole dict of metrics\n if score >= best_score:\n print(f\"Better eval found with accuracy {round(score, 3)} (+{round(score - best_score, 3)})\")\n best_score = score\n\n torch.save(net, model_save_path) #TODO make sure that this works (maybe, should we save each of the 3 parts indvidually?)\n a_model_was_saved_at_some_point = True\n else:\n print(f\"No improvement yet...\")\n timer(f\"training_evaluation_{batch_counter/eval_interval}\")\n\n optimizer.step()\n timer(f\"training_epoch_{epoch}\")\n\n #========= END OF TRAINING =============#\n metrics = evaluate(net, # TODO make this prettier\n tokenizer, ner_tagger,\n training_device, dev_data_filepath, dev_preds_filepath,\n fb_passes=fb_passes,\n text_length=text_length,\n verbose=verbose_evaluation)\n score = metrics[\"joint_f1\"]\n dev_scores.append(metrics) # appends the whole dict of metrics\n if score >= best_score:\n torch.save(net,\n model_save_path)\n\n if not a_model_was_saved_at_some_point: # make sure that there is a model file\n print(f\"saving model to {model_save_path}...\")\n torch.save(net, model_save_path)\n\n losses_with_batchsizes = [(b, t[0], t[1], t[2], t[3], t[4]) for b,t in zip(real_batch_sizes, losses)]\n\n if timed:\n return losses_with_batchsizes, dev_scores, graph_logging, point_usage, timer\n else:\n return losses_with_batchsizes, dev_scores, graph_logging, point_usage","def train(self, dataset, model_dir):\n raise NotImplementedError","def preprocess_sentences(train, val, test):\r\n tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True)\r\n\r\n train_data = convert_examples_to_features(train, tokenizer, pad_token_label_id=pad_id)\r\n val_data = convert_examples_to_features(val, tokenizer, pad_token_label_id=pad_id)\r\n test_data = convert_examples_to_features(test, tokenizer, pad_token_label_id=pad_id)\r\n\r\n train_dataloader = create_dataloader(train_data)\r\n val_dataloader = create_dataloader(val_data)\r\n test_dataloader = create_dataloader(test_data)\r\n\r\n return train_dataloader, val_dataloader, test_dataloader","def construct_NLP_model(self, df=None):\n import review_processing as rp\n # get words\n if df is not None:\n nitems = df.shape[0]\n col_names = df.columns.values\n if self.review_col_name not in col_names or \\\n self.sentiment_col_name not in col_names:\n sys.exit('construct_NL_model: The name {0}/{1} cannot be found'.\n format(self.review_col_name, self.sentiment_col_name))\n review_list = df[self.review_col_name].values.tolist()\n meaningful_words = map(self.review_to_meaningful_words,\n review_list)\n # Get training sentiment values\n self.sentiment = df[self.sentiment_col_name].values\n\n else:\n if self.training_file_name is None:\n sys.exit('construct_NLP_model: traning file name does not '\n 'exist')\n else:\n suffix = os.path.splitext(self.training_file_name)[1][1:]\n if suffix == 'csv':\n df = pd.read_csv(self.training_file_name)\n if self.review_col_name not in col_names or \\\n self.sentiment_col_name not in col_names::\n sys.exit('construct_NL_model: The name {0}/{1} cannot '\n ' be found'.format(self.review_col_name,\n self.sentiment_col_name))\n nitems = df.shape[0]\n review_list = df[review_col_name].values.tolist()\n meaningful_words = map(self.review_to_meaningful_words,\n review_list)\n elif suffix == 'json':\n data_dict_list = rp.load_data(self.training_file_name)\n if self.review_col_name not in data_dict_list.keys():\n sys.exit('construct_NL_model: The name {0} cannot be '\n 'found'.format(review_col_name))\n review_list = map(lambda x: x[review_col_name],\n data_dict_list)\n meaningful_words = map(self.review_to_meaningful_words,\n review_list)\n else:\n sys.exit('construct_NLP_model: file type not supported '\n 'yet!')\n\n # Training process of Bag of Worlds\n if self.NLP_model == 'BagofWords':\n print('construct_NLP_model: Creating bag of words...')\n self.vectorizer = CountVectorizer(analyzer='word',\n tokenizer=None,\n preprocessor=None,\n stop_words=None,\n max_features=self.maxfeature)\n self.train_data_features = vectorizer.fit_transform(\n meaningful_words)\n self.train_data_features = train_data_features.toarray()\n\n # vocab = vectorizer.get_feature_names()\n # dist = np.sum(train_data_features, axis=0)\n # for tag, count in zip(vocab, dist):\n # print(count, tag)\n\n else:\n sys.exit('construct_NLP_model: NLP_model type not supported yet!')","def train(self, training_data, chunk_size=100):\n # For some reason, for the SVM to work, the keys need to be in alphabetical order\n training_data = {k : training_data[k] for k in sorted(training_data)}\n\n # Compile all author texts into one large text to then be broken down\n for auth in training_data:\n training_data[auth] = '\\n\\n'.join(training_data[auth])\n\n self.auths = list(training_data.keys())\n self.chunk_size = chunk_size\n\n # Creates two lists, one of the texts and one of the corresponding author labels.\n labels = []\n texts = []\n for auth in training_data:\n lines = training_data[auth].split('\\n')\n for p in range( chunk_size, len(lines), chunk_size ):\n labels.append(auth) # authors per text in the training corpus\n texts.append('\\n'.join(lines[p-chunk_size : p])) # texts in the training corpus\n labels = array(labels)\n texts = array(texts)\n\n # Cleans the texts\n for i in range(len(texts)):\n texts[i] = self._clean(texts[i])\n\n # Generates the profiles from these tests\n profiles = zeros((len(texts), len(self.alph)**self.N))\n for i in range(len(texts)):\n profiles[i] = self._profile(texts[i])\n\n\n # Reduces the features and fits the model\n self.train_data = [profiles, labels]\n self._reduceFeatures()\n\n self.model = SVC(kernel='linear')\n self.model.probability = True\n self.model.fit(self.train_data[0], self.train_data[1])","def _preprocess_training_model(self, data):\n def _pre_process(raw_data):\n \"\"\" Pre-process raw data. \"\"\"\n pattern = re.compile(\n r\"((?<=')\\w\\d.*?(?=')|(?<=\\\")\\w\\d.*?(?=\\\")|[\\w\\d]+)\")\n words = re.findall(pattern, raw_data)\n return ' '.join(list(map(string_utils.snake_case_to_camel, words)))\n\n data_list = []\n # Preprocess the dataset with naming convention, etc.\n with Progress() as progress:\n preprocess_task = progress.add_task('Pre-processing dataset...',\n total=data.shape[0])\n for idx, row in data.iterrows():\n row_data = {}\n for column in ['text', 'key', 'value']:\n row_data[column] = _pre_process(row[column])\n data_list.append(row_data)\n progress.update(preprocess_task, advance=1)\n return pd.DataFrame(data=data_list)","def training(train_data, dev_data, param):\n text_to_vec = TextToVec(**param)\n\n # Fit with both train and dev data\n text_to_vec.fit(train_data['data'] + dev_data['data'])\n word_vec_map = text_to_vec.vectorizer.get_feature_names()\n train_vec = text_to_vec.transform(train_data['data'])\n dev_vec = text_to_vec.transform(dev_data['data'])\n logger.info(f\"train vec size:{train_vec.shape}, dev vec size:{dev_vec.shape}\")\n\n # # apply weights on tfidf based on whether the word appear in multiple classes\n # tt_occ = Counter(train_data['encoded_label'])\n # weight_list = []\n # for i in range(train_vec.shape[1]): # For every feature\n # occ = Counter(train_data['encoded_label'][train_vec[:, i] > 0.0])\n # for key, value in occ.items():\n # occ[key] = value/tt_occ[key]\n # weight_list.append(np.std(list(occ.values()))/0.35)\n # weight = np.array(weight_list).reshape(1, -1)\n # weight = weight/np.max(weight)\n # train_vec = np.multiply(train_vec, weight)\n\n # Perform oversampling on training data\n if param['balanced'] not in ['Bootstrap', 'Handsample']:\n logger.info(f\"class info before resampling: {sorted(Counter(train_data['encoded_label']).items())}\")\n train_vec, train_data['encoded_label'] = resample(X_train=train_vec, y_train=train_data['encoded_label'], balance=param['balanced'])\n logger.info(f\"class info after resampling:{sorted(Counter(train_data['encoded_label']).items())}\")\n\n # Fit model\n if param['classifier'] == 'MultinomialNB':\n clf = MultinomialNB()\n elif param['classifier'] == 'LDA':\n clf = LinearDiscriminantAnalysis()\n else:\n clf = svm.LinearSVC()\n\n if param['multiclass'] == 'OnevsOne':\n model = OneVsOneClassifier(clf)\n else:\n model = OneVsRestClassifier(clf)\n\n if param['classifier'] == 'LinearSVM' or param['multiclass'] == 'OnevsOne':\n logger.info(f'Fitting model: {param}')\n model = model.fit(train_vec, train_data['encoded_label'])\n train_prediction = model.predict(train_vec)\n dev_prediction = model.predict(dev_vec)\n else:\n logger.info(f'Fitting model: {param}')\n model = model.fit(train_vec, train_data['binary_label'])\n train_prediction = np.argmax(model.predict(train_vec), axis=1)\n dev_prediction = np.argmax(model.predict(dev_vec), axis=1)\n\n\n return train_prediction, dev_prediction, train_vec.shape, dev_vec.shape, model, word_vec_map","def _train(cls, ds):\n\n tf = TfidfVectorizer(analyzer='word',\n ngram_range=(1, 3),\n min_df=0,\n stop_words='english')\n tfidf_matrix = tf.fit_transform(ds['description'])\n with open('ds.pickle', 'wb') as fp:\n pickle.dump(ds, fp)\n\n with open('tfidf_matrix.pickle', 'wb') as fp:\n pickle.dump(tfidf_matrix, fp)\n\n with open('tf_model.pickle', 'wb') as fp:\n pickle.dump(tf, fp)","def train(self):\n\t\tself.model.fit(self.training_data, self.training_labels)","def preproc_doc(document):\n\n # Each document is a list of lines\n tokenizer = tokenization.FullTokenizer(\n vocab_file=FLAGS.vocab_file, do_lower_case=FLAGS.do_lower_case)\n\n # set a random seed for reproducability\n # since this function is run in parallel, if we hardcode a seed, all\n # documents will have the same permutations. Instead we use the hash of the\n # first sentence as the seed so it is different for each document and it\n # is still reproducible.\n hash_object = hashlib.md5(document[0])\n rng = random.Random(int(hash_object.hexdigest(), 16) % (10**8))\n\n # Each document is composed of a list of sentences. We create paragraphs\n # by keeping together sentences on the same line and adding adjacent sentences\n # if there are fewer than 5 to form the paragraph.\n # The utility functions below expect the document to be split by paragraphs.\n list_of_paragraphs = []\n paragraph = []\n for line in document:\n line = tokenization.convert_to_unicode(line)\n line = line.replace(u\"\\u2018\", \"'\").replace(u\"\\u2019\", \"'\")\n sents = split_line_by_sentences(line)\n for sent in sents:\n tokens = tokenizer.tokenize(sent)\n if tokens:\n paragraph.append(tokens)\n if len(paragraph) > 5:\n list_of_paragraphs.append(paragraph)\n paragraph = []\n\n # In case of any empty paragraphs, remove them.\n list_of_paragraphs = [x for x in list_of_paragraphs if x]\n\n # Convert the list of paragraphs into TrainingInstance object\n # See preprocessing_utils.py for definition\n if FLAGS.format == FORMAT_BINARY:\n instances = create_instances_from_document(list_of_paragraphs,\n FLAGS.max_seq_length, rng)\n elif FLAGS.format == FORMAT_PARAGRAPH:\n instances = create_paragraph_order_from_document(list_of_paragraphs,\n FLAGS.max_seq_length, rng)\n\n # Convert token lists into ids and add any needed tokens and padding for BERT\n tf_examples = [\n convert_instance_to_tf_example(tokenizer, instance,\n FLAGS.max_seq_length)[0]\n for instance in instances\n ]\n\n # Serialize TFExample for writing to file.\n tf_examples = [example.SerializeToString() for example in tf_examples]\n\n return tf_examples","def update_model(path_to_data, path_to_model):\r\n # Open the annotation files.\r\n with open(path_to_data + r'\\coco_annotation.json') as f:\r\n coco_d = json.load(f)\r\n # Get the categories.\r\n categories = []\r\n for cat in coco_d['categories']:\r\n categories.append(cat['name'])\r\n\r\n # Register the new data.\r\n register_coco_instances(\"coco_update\", {}, path_to_data + r\"\\coco_annotation.json\", path_to_data)\r\n MetadataCatalog.get(\"meta_update\").set(thing_classes=categories)\r\n # MetadataCatalog.get(\"meta_update\").set(thing_classes=[\"Bad\", \"Good\"], thing_colors=[(172, 0, 0), (229, 0, 0)])\r\n\r\n # Set the parameters.\r\n cfg = get_cfg()\r\n cfg.merge_from_file(model_zoo.get_config_file(\"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml\"))\r\n cfg.DATASETS.TRAIN = (\"coco_update\",)\r\n cfg.OUTPUT_DIR = path_to_model\r\n cfg.DATASETS.TEST = ()\r\n cfg.DATALOADER.NUM_WORKERS = 2\r\n cfg.MODEL.DEVICE = 'cpu'\r\n cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, \"model_final.pth\")\r\n cfg.SOLVER.IMS_PER_BATCH = 1\r\n cfg.SOLVER.BASE_LR = 0.00025\r\n cfg.SOLVER.MAX_ITER = 400\r\n cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 10\r\n cfg.MODEL.ROI_HEADS.NUM_CLASSES = len(categories)\r\n\r\n # Update the model.\r\n trainer = DefaultTrainer(cfg)\r\n trainer.resume_or_load(resume=False)\r\n trainer.train()","def train_model(model,\n dataset_info,\n steps_per_epoch,\n args):\n if args.mode not in ['train', 'finetune']:\n raise ValueError(\"train_model() called when in %s mode\" % args.mode)\n\n dataset_info, model_info = fill_info_dicts(dataset_info, args)\n\n train_batches = {name: model_info[name]['train_batch']\n for name in model_info}\n\n additional_encoder_kwargs = dict()\n\n for dataset_name in model_info:\n additional_encoder_kwargs[dataset_name] = dict()\n\n with open(args.encoder_config_file, 'r') as f:\n encoders = json.load(f)\n extract_fn = encoders[args.architecture][dataset_name]['extract_fn']\n embed_fn = encoders[args.architecture][dataset_name]['embed_fn']\n\n if embed_fn in ['embed_sequence', 'pretrained']:\n # TODO text_field_name ?\n if 'input_key' == 'weights':\n additional_encoder_kwargs[dataset_name]['weights'] = \\\n train_batches[\n dataset_name]['text_weights']\n elif embed_fn == 'pretrained':\n additional_encoder_kwargs[dataset_name]['is_training'] = True\n elif embed_fn == 'tokenized_embed':\n additional_encoder_kwargs[dataset_name][\n 'precompute_path'] = args.precompute_path\n else:\n pass\n\n if extract_fn == \"serial_lbirnn\":\n additional_encoder_kwargs[dataset_name]['is_training'] = True\n if args.experiment_name == \"RUDER_NAACL_18\":\n # use last token of last sequence as feature representation\n indices = train_batches[dataset_name][\n 'seq2_length']\n ones = tf.ones([tf.shape(indices)[0]], dtype=tf.int64)\n # last token is at pos. length-1\n indices = tf.subtract(indices, ones)\n additional_encoder_kwargs[dataset_name]['indices'] = indices\n elif extract_fn == \"lbirnn\":\n additional_encoder_kwargs[dataset_name]['is_training'] = True\n elif extract_fn == \"serial_lbirnn_stock\":\n additional_encoder_kwargs[dataset_name]['is_training'] = True\n elif extract_fn == \"dan\":\n additional_encoder_kwargs[dataset_name]['is_training'] = True\n else:\n pass\n\n # losses = model.get_multi_task_loss(train_batches,\n # is_training=True,\n # additional_encoder_kwargs=additional_encoder_kwargs)\n\n # TODO multi loss\n losses = dict()\n for dataset in args.datasets:\n # import pdb\n # sess = tf.Session()\n # sess.run(model_info[dataset_name]['train_iter'].initializer)\n # batch = model_info[dataset_name]['train_batch']\n losses[dataset] = model.get_loss(train_batches[dataset],\n dataset,\n dataset,\n additional_encoder_kwargs=additional_encoder_kwargs,\n # sequence in train mode\n is_training=True)\n\n # import pdb\n # sess.run(model_info[dataset_name]['pred_iter'].initializer)\n # batch = model_info[dataset_name]['pred_batch']\n # text, weights = sess.run([batch['text'], batch['text_weights']])\n # pdb.set_trace()\n\n # # see if dropout and is_training working\n # # by checking train loss with different is_training the same\n\n # Done building compute graph; set up training ops.\n\n # Training ops\n global_step_tensor = tf.train.get_or_create_global_step()\n\n train_ops = dict()\n optim = tf.train.RMSPropOptimizer(learning_rate=args.lr0)\n for dataset_name in model_info:\n # tvars, grads = get_var_grads(losses[dataset_name])\n # train_ops[dataset_name] = get_train_op(tvars, grads, lr, args.max_grad_norm,\n # global_step_tensor, args.optimizer, name='train_op_{}'.format(dataset_name))\n train_ops[dataset_name] = optim.minimize(losses[dataset_name],\n global_step=global_step_tensor)\n\n # tvars, grads = get_var_grads(loss)\n # train_op = get_train_op(tvars, grads, lr, args.max_grad_norm,\n # global_step_tensor, args.optimizer, name='train_op')\n init_ops = [tf.global_variables_initializer(),\n tf.local_variables_initializer()]\n config = get_proto_config(args)\n\n # Get training objective. The inputs are:\n # 1. A dict of { dataset_key: dataset_iterator }\n #\n\n fill_eval_loss_op(args, model, dataset_info, model_info)\n fill_pred_op_info(dataset_info, model, args, model_info)\n fill_topic_op(args, model_info)\n\n print(\"All the variables after defining valid/test accuracy:\")\n all_variables = tf.global_variables()\n trainable_variables = tf.trainable_variables()\n total_trainable_parameters = 0\n for var in all_variables:\n if var in trainable_variables:\n print('(t) {}'.format(var))\n shape = var.get_shape()\n var_params = 1\n for dim in shape:\n var_params *= dim.value\n total_trainable_parameters += var_params\n else:\n print('( ) {}'.format(var))\n\n print(\"Total trainable parameters in this model={}\\n\\n\\n\".format(\n total_trainable_parameters))\n\n # # Add ops to save and restore all the variables.\n\n # latest checkpoint\n # saves every several steps\n # automatically done by tf.train.SingularMonitorSession with\n # tf.train.CheckpoinSaverHook\n\n # TODO load from some checkpoint dif at the beginning(?)\n saver_hook = tf.train.CheckpointSaverHook(\n checkpoint_dir=os.path.join(args.checkpoint_dir, 'latest'),\n save_steps=100)\n\n # saved model builders for each model\n # builders = init_builders(args, model_info)\n\n saver = tf.train.Saver(max_to_keep=100)\n\n with tf.train.SingularMonitoredSession(hooks=[saver_hook],\n config=config) as sess:\n\n if args.mode == 'train':\n sess.run(init_ops)\n\n else:\n assert len(args.datasets) == 1\n checkpoint_path_load = model_info[args.datasets[0]][\n 'checkpoint_path_load']\n saver.restore(sess, checkpoint_path_load)\n\n if args.summaries_dir:\n train_file_writer = tf.summary.FileWriter(\n os.path.join(args.summaries_dir, 'train'), graph=sess.graph)\n valid_file_writer = tf.summary.FileWriter(\n os.path.join(args.summaries_dir, 'valid'), graph=sess.graph)\n\n best_eval_performance = dict()\n for dataset_name in model_info:\n _train_init_op = model_info[dataset_name]['train_init_op']\n _valid_init_op = model_info[dataset_name]['valid_init_op']\n\n sess.run([_train_init_op, _valid_init_op])\n\n init_value = float('-inf')\n if args.tuning_metric == 'MAE_MACRO':\n init_value = float('inf')\n best_eval_performance[dataset_name] = {\"epoch\": -1,\n args.tuning_metric: init_value,\n \"performance\": None\n }\n\n best_total_tuning_metric = init_value\n best_tuning_metric_epoch = -1\n\n main_task_dev_tuning_metric = []\n stopping_criterion_reached = False\n early_stopping_dev_results = \"\"\n\n # Do training\n make_dir(os.path.dirname(args.log_file))\n with open(args.log_file, 'a') as f:\n f.write('VALIDATION RESULTS\\n')\n for epoch in xrange(1, args.num_train_epochs + 1):\n\n start_time = time()\n\n total_tuning_metric = 0.0\n\n # Take steps_per_epoch gradient steps\n total_loss = 0\n num_iter = 0\n # for _ in tqdm(xrange(steps_per_epoch)):\n # step, loss_v, _ = sess.run(\n # [global_step_tensor, loss, train_op])\n # num_iter += 1\n # total_loss += loss_v\n #\n # # loss_v is sum over a batch from each dataset of the average loss *per\n # # training example*\n # assert num_iter > 0\n #\n # average loss per batch (which is in turn averaged across examples)\n # train_loss = float(total_loss) / float(num_iter)\n\n for _ in tqdm(xrange(steps_per_epoch)):\n for (dataset_name, alpha) in zip(*[args.datasets, args.alphas]):\n loss_v, _ = sess.run(\n [losses[dataset_name], train_ops[dataset_name]])\n total_loss += alpha * loss_v\n step = sess.run(global_step_tensor)\n num_iter += 1\n assert num_iter > 0\n\n train_loss = float(total_loss) / float(num_iter)\n\n if args.summaries_dir:\n train_loss_summary = tf.Summary(\n value=[\n tf.Summary.Value(tag=\"loss\", simple_value=train_loss)])\n train_file_writer.add_summary(\n train_loss_summary, global_step=step)\n\n # Evaluate held-out tuning metric\n # if not args.test: # Validation mode\n # Get performance metrics on each dataset\n for dataset_name in args.datasets:\n _pred_op = model_info[dataset_name]['valid_pred_op']\n _eval_labels = model_info[dataset_name]['valid_batch'][\n args.label_key]\n _eval_iter = model_info[dataset_name]['valid_iter']\n _get_topic_op = model_info[dataset_name]['valid_topic_op']\n _loss_op = model_info[dataset_name]['valid_loss_op']\n _metrics = compute_held_out_performance(sess,\n _pred_op,\n _eval_labels,\n _eval_iter,\n metrics=dataset_info[\n dataset_name][\n 'metrics'],\n labels=dataset_info[\n dataset_name][\n 'labels'],\n args=args,\n get_topic_op=_get_topic_op,\n topic_path=dataset_info[\n dataset_name][\n 'topic_path'],\n eval_loss_op=_loss_op)\n model_info[dataset_name]['valid_metrics'] = _metrics\n\n end_time = time()\n elapsed = end_time - start_time\n\n # Manually compute the validation loss since each dataset is iterated through once\n # in a serial manner and not \"in parallel\" (i.e., a batch from each)\n valid_loss = 0.0\n for (dataset_name, alpha) in zip(*[args.datasets, args.alphas]):\n valid_loss += float(alpha) * \\\n model_info[dataset_name]['valid_metrics'][\n 'eval_loss']\n\n main_task_tuning_metric = model_info[args.datasets[0]\n ]['valid_metrics'][args.tuning_metric]\n\n if args.summaries_dir:\n valid_loss_summary = tf.Summary(\n value=[\n tf.Summary.Value(tag=\"loss\", simple_value=valid_loss)])\n valid_file_writer.add_summary(\n valid_loss_summary, global_step=step)\n valid_main_task_tuning_metric_summary = tf.Summary(value=[\n tf.Summary.Value(tag=\"main-task-\" + args.tuning_metric,\n simple_value=main_task_tuning_metric)])\n valid_file_writer.add_summary(\n valid_main_task_tuning_metric_summary,\n global_step=step)\n\n if (\n main_task_tuning_metric >= args.early_stopping_acc_threshold) and (\n len(main_task_dev_tuning_metric) >= args.patience) and (\n main_task_tuning_metric < main_task_dev_tuning_metric[\n -args.patience]):\n print(\n \"Stopping early at epoch {} (patience={}, early stopping acc threshold={})\".format(\n epoch, args.patience,\n args.early_stopping_acc_threshold))\n stopping_criterion_reached = True\n\n main_task_dev_tuning_metric.append(main_task_tuning_metric)\n\n if args.reporting_metric != \"Acc\":\n main_task_performance = \\\n model_info[args.datasets[0]]['valid_metrics'][\n args.reporting_metric]\n if args.summaries_dir:\n valid_main_task_performance_summary = tf.Summary(value=[\n tf.Summary.Value(\n tag=\"main-task-{}\".format(args.reporting_metric),\n simple_value=main_task_performance)])\n valid_file_writer.add_summary(\n valid_main_task_performance_summary,\n global_step=step)\n\n # Log performance(s)\n str_ = '[epoch=%d/%d step=%d (%d s)] train_loss=%s valid_loss=%s (per batch)' % (\n epoch, args.num_train_epochs, np.asscalar(step), elapsed,\n train_loss, valid_loss)\n\n for dataset_name in args.datasets:\n _num_eval_total = model_info[dataset_name]['valid_metrics'][\n 'ntotal']\n # TODO use other metric here for tuning\n _eval_tuning_metric = model_info[dataset_name]['valid_metrics'][\n args.tuning_metric]\n # _eval_align_acc = model_info[dataset_name]['valid_metrics'][\n # 'aligned_accuracy']\n\n str_ += '\\n(%s) ' % dataset_name\n for m, s in model_info[dataset_name]['valid_metrics'].items():\n if (dataset_name == args.datasets[0]) and (\n m == args.reporting_metric): # main task\n str_ += '**%s=%f** ' % (m, s)\n elif m == args.tuning_metric:\n str_ += '*%s=%f* ' % (m, s)\n elif m == 'Confusion_Matrix':\n pass\n else:\n str_ += '%s=%f ' % (m, s)\n if 'Confusion_Matrix' in model_info[dataset_name][\n 'valid_metrics']:\n str_ += 'Confusion_Matrix:\\n'\n str_ += '\\n'.join(' '.join('%4d' % x for x in y) for y in\n model_info[dataset_name]['valid_metrics'][\n 'Confusion_Matrix'])\n\n # Track best-performing epoch for each dataset\n # use the newest best epoch for test\n if _eval_tuning_metric >= best_eval_performance[dataset_name][\n args.tuning_metric]:\n best_eval_performance[dataset_name][args.tuning_metric] = \\\n _eval_tuning_metric\n best_eval_performance[dataset_name][\"performance\"] = \\\n model_info[dataset_name]['valid_metrics'].copy()\n best_eval_performance[dataset_name][\"epoch\"] = epoch\n # save best model\n saver.save(sess.raw_session(),\n model_info[dataset_name]['checkpoint_path'])\n\n # # test\n # saver.save(sess.raw_session(), checkpoint_path)\n\n total_tuning_metric += _eval_tuning_metric\n\n # Track best-performing epoch for collection of datasets\n\n if total_tuning_metric >= best_total_tuning_metric:\n best_total_tuning_metric = total_tuning_metric\n best_tuning_metric_epoch = epoch\n best_epoch_results = str_\n if len(args.datasets) > 1:\n saver.save(sess.raw_session(),\n os.path.join(args.checkpoint_dir, 'MULT',\n 'model'))\n\n logging.info(str_)\n\n # Log dev results in a file\n with open(args.log_file, 'a') as f:\n f.write(str_ + '\\n')\n\n if stopping_criterion_reached:\n saver.save(sess.raw_session(),\n os.path.join(args.checkpoint_dir, 'early-stopping',\n 'model'))\n\n early_stopping_dev_results = str_\n # with open(args.log_file, 'a') as f:\n # f.write('\\nSTOPPED EARLY AFTER {} EPOCHS\\n'.format(epoch))\n # f.write(str_ + '\\n')\n break\n\n print(best_eval_performance)\n print(\n 'Best total {}: {} at epoch {}'.format(\n args.tuning_metric,\n best_total_tuning_metric,\n best_tuning_metric_epoch))\n print(best_epoch_results)\n\n with open(args.log_file, 'a') as f:\n # f.write(best_eval_acc + '\\n')\n # f.write('Best total accuracy: {} at epoch {}'.format(best_total_acc,\n # best_total_acc_epoch))\n f.write('\\nBest single-epoch performance across all datasets\\n')\n f.write(best_epoch_results + '\\n\\n')\n\n # Write (add) the result to a common report file\n with open(args.log_file, 'a') as f:\n for dataset in best_eval_performance.keys():\n f.write(str(dataset))\n f.write(\" \")\n f.write(\"\\n\")\n for dataset, values in best_eval_performance.items():\n f.write(\n 'Metrics on highest-{} epoch for dataset {}: {}\\n'.format(\n args.tuning_metric, dataset, values))\n\n f.write('Best total {}: {} at epoch {}\\n\\n'.format(\n args.tuning_metric, best_total_tuning_metric,\n best_tuning_metric_epoch))\n if stopping_criterion_reached:\n f.write('STOPPED EARLY AFTER {} EPOCHS\\n'.format(epoch))\n f.write(early_stopping_dev_results + '\\n\\n')\n\n if args.summaries_dir:\n train_file_writer.close()\n valid_file_writer.close()","def train_model(self,train_data,eval_data=None): # noqa: ignore flake8\"\n logger.info(\"Training model...\")\n os.makedirs(self.model_dir, exist_ok=True)\n source_texts, target_texts = create_dataset(train_data)\n\n self.src_2_ids = read_vocab(source_texts)\n self.trg_2_ids = read_vocab(target_texts)\n save_word_dict(self.src_2_ids, self.src_vocab_path)\n save_word_dict(self.trg_2_ids, self.trg_vocab_path)\n train_src, train_trg = one_hot(source_texts, target_texts, self.src_2_ids, self.trg_2_ids, sort_by_len=True)\n\n id_2_srcs = {v: k for k, v in self.src_2_ids.items()}\n id_2_trgs = {v: k for k, v in self.trg_2_ids.items()}\n logger.debug(f'train src: {[id_2_srcs[i] for i in train_src[0]]}')\n logger.debug(f'train trg: {[id_2_trgs[i] for i in train_trg[0]]}')\n\n self.model = Seq2Seq(\n encoder_vocab_size=len(self.src_2_ids),\n decoder_vocab_size=len(self.trg_2_ids),\n embed_size=self.embed_size,\n enc_hidden_size=self.hidden_size,\n dec_hidden_size=self.hidden_size,\n dropout=self.dropout\n )\n self.model.to(device)\n logger.debug(self.model)\n optimizer = torch.optim.Adam(self.model.parameters())\n\n train_data = gen_examples(train_src, train_trg, self.batch_size, self.max_length)\n train_losses = []\n best_loss = 1e3\n for epoch in range(self.epochs):\n self.model.train()\n total_num_words = 0.\n total_loss = 0.\n for it, (mb_x, mb_x_len, mb_y, mb_y_len) in enumerate(train_data):\n mb_x = torch.from_numpy(mb_x).to(device).long()\n mb_x_len = torch.from_numpy(mb_x_len).to(device).long()\n mb_input = torch.from_numpy(mb_y[:, :-1]).to(device).long()\n mb_output = torch.from_numpy(mb_y[:, 1:]).to(device).long()\n mb_y_len = torch.from_numpy(mb_y_len - 1).to(device).long()\n mb_y_len[mb_y_len <= 0] = 1\n\n mb_pred, attn = self.model(mb_x, mb_x_len, mb_input, mb_y_len)\n\n mb_out_mask = torch.arange(mb_y_len.max().item(), device=device)[None, :] < mb_y_len[:, None]\n mb_out_mask = mb_out_mask.float()\n\n loss = self.loss_fn(mb_pred, mb_output, mb_out_mask)\n\n num_words = torch.sum(mb_y_len).item()\n total_loss += loss.item() * num_words\n total_num_words += num_words\n\n # update optimizer\n optimizer.zero_grad()\n loss.backward()\n torch.nn.utils.clip_grad_norm_(self.model.parameters(), 5.)\n optimizer.step()\n\n if it % 100 == 0:\n logger.debug(\"Epoch :{}/{}, iteration :{}/{} loss:{:.4f}\".format(epoch, self.epochs,\n it, len(train_data),\n loss.item()))\n cur_loss = total_loss / total_num_words\n train_losses.append(cur_loss)\n logger.debug(\"Epoch :{}/{}, Training loss:{:.4f}\".format(epoch, self.epochs, cur_loss))\n if epoch % 1 == 0:\n # find best model\n is_best = cur_loss < best_loss\n best_loss = min(cur_loss, best_loss)\n if is_best:\n self.save_model()\n logger.info('Epoch:{}, save new bert model:{}'.format(epoch, self.model_path))\n if eval_data:\n self.eval_model(eval_data)\n\n\n return train_losses","def load_spacy_model(spacy_model_name: str) -> Optional[Language]:\n\n try:\n spacy_model = spacy.load(spacy_model_name)\n\n except OSError as exc:\n logger.info(f\"Unable to load spacy model {spacy_model_name}\")\n\n if \"E050\" in str(exc):\n # https://github.com/explosion/spaCy/blob/v2.1.6/spacy/errors.py#L207\n # Model not found, try installing it\n logger.info(f\"Downloading {spacy_model_name}\")\n\n from spacy.cli.download import msg as spacy_msg\n\n # Download quietly\n spacy_msg.no_print = True\n try:\n spacy.cli.download(spacy_model_name, False, False, \"--quiet\")\n except SystemExit:\n logger.error(f\"Unable to install spacy model {spacy_model_name}\")\n return None\n\n # Specific steps for transformer models (very brittle and likely not permanent)\n if spacy_model_name.endswith(\"_trf\"):\n\n # If we just installed a transformer model along with spacy-transformers in a child process\n # we need to set up an entry point for spacy-transformers in the current process.\n # This entry point will be registered as a pipeline factory function by the model's language class.\n load_entry_point(\"spacy-transformers\", \"spacy_factories\", \"transformer\")\n\n # If Pytorch was also just installed, certain modules that depend on it\n # may need reloading to work in the current process\n reload(thinc.util)\n reload(thinc.shims.pytorch)\n reload(thinc.shims.pytorch_grad_scaler)\n\n # Now try loading the model again\n spacy_model = spacy.load(spacy_model_name)\n\n else:\n logger.exception(exc)\n return None\n\n # Set text length limit for model\n spacy_model.max_length = RATOM_SPACY_MODEL_MAX_LENGTH\n\n return spacy_model","def train_model(args, train_exs: List[SentimentExample]) -> SentimentClassifier:\n # Initialize feature extractor\n nltk.download('stopwords')\n stop_words = set(stopwords.words('english'))\n\n if args.model == \"TRIVIAL\":\n feat_extractor = None\n elif args.feats == \"UNIGRAM\":\n feat_extractor = UnigramFeatureExtractor(Indexer(), train_exs, stop_words)\n elif args.feats == \"BIGRAM\":\n # Add additional preprocessing code here\n feat_extractor = BigramFeatureExtractor(Indexer(), train_exs, stop_words)\n elif args.feats == \"BETTER\":\n # Add additional preprocessing code here\n feat_extractor = BetterFeatureExtractor(Indexer(), train_exs, stop_words)\n else:\n raise Exception(\"Pass in UNIGRAM, BIGRAM, or BETTER to run the appropriate system\")\n\n # Train the model\n if args.model == \"TRIVIAL\":\n model = TrivialSentimentClassifier()\n elif args.model == \"PERCEPTRON\":\n model = train_perceptron(train_exs, feat_extractor)\n elif args.model == \"LR\":\n model = train_logistic_regression(train_exs, feat_extractor)\n else:\n raise Exception(\"Pass in TRIVIAL, PERCEPTRON, or LR to run the appropriate system\")\n return model","def convert_data(data):\n training_data = []\n for record in data:\n entities = record.get('entities')\n converted_entities = []\n for entity in entities:\n converted_entities.append((entity.get('start_offset'), entity.get('end_offset'),\n entity.get('entity_name')))\n\n training_data.append((record.get('text'), {'entities': converted_entities}))\n return training_data","def evaluate_model():\n\n # Get the processed data (in proper format to evaluate the NER model)\n data = get_json_from_file_path(PROCESSED_DATA_PATH)\n # Split the dataset for training and test as we did for training\n train_data, test_data = train_test_split(data, train_size=0.7, \n random_state=4)\n\n # Load the model trained\n try:\n ner_model = spacy.load(OUTPUT_MODEL_PATH)\n except Exception as err:\n msg = f'Could not load the model. Error: {err}'\n raise Exception(msg)\n\n # Compute evaluation scores\n print('Computing metrics...')\n scores = evaluate(ner_model, test_data)\n # General metrics of the model\n f_score = scores.get('ents_f')\n precision = scores.get('ents_p')\n recall = scores.get('ents_r')\n print('\\nScoring:')\n print(f'F-score: {f_score}')\n print(f'Precision: {precision}')\n print(f'Recall: {recall}')\n\n # Get the specific scores for each entity \n scores_per_entity = scores.get('ents_per_type')\n # Get the F-score of the entities\n f_scores_of_entities = []\n for entity_scores in scores_per_entity.values():\n f_scores_of_entities.append(entity_scores['f'])\n # Compute the macro averaged F-score\n macro_avg_f_score = sum(f_scores_of_entities)/len(f_scores_of_entities)\n print(f'Macro averaged F-score: {macro_avg_f_score}')\n \n print('\\nScores per entity;')\n print('{:<15} {:<10} {:<10} {:<10}'.format('Entity','F-score','Precision','Recall'))\n for key, value in scores_per_entity.items():\n entity = key\n f, p, r = value['f'], value['p'], value['r']\n print('{:<15} {:<10.2f} {:<10.2f} {:<10.2f}'.format(entity, f, p, r))","def debug_data(\n # fmt: off\n lang: (\"Model language\", \"positional\", None, str),\n train_path: (\"Location of JSON-formatted training data\", \"positional\", None, Path),\n dev_path: (\"Location of JSON-formatted development data\", \"positional\", None, Path),\n tag_map_path: (\"Location of JSON-formatted tag map\", \"option\", \"tm\", Path) = None,\n base_model: (\"Name of model to update (optional)\", \"option\", \"b\", str) = None,\n pipeline: (\"Comma-separated names of pipeline components to train\", \"option\", \"p\", str) = \"tagger,parser,ner\",\n ignore_warnings: (\"Ignore warnings, only show stats and errors\", \"flag\", \"IW\", bool) = False,\n verbose: (\"Print additional information and explanations\", \"flag\", \"V\", bool) = False,\n no_format: (\"Don't pretty-print the results\", \"flag\", \"NF\", bool) = False,\n # fmt: on\n):\n msg = Printer(pretty=not no_format, ignore_warnings=ignore_warnings)\n\n # Make sure all files and paths exists if they are needed\n if not train_path.exists():\n msg.fail(\"Training data not found\", train_path, exits=1)\n if not dev_path.exists():\n msg.fail(\"Development data not found\", dev_path, exits=1)\n\n tag_map = {}\n if tag_map_path is not None:\n tag_map = srsly.read_json(tag_map_path)\n\n # Initialize the model and pipeline\n pipeline = [p.strip() for p in pipeline.split(\",\")]\n if base_model:\n nlp = load_model(base_model)\n else:\n lang_cls = get_lang_class(lang)\n nlp = lang_cls()\n # Update tag map with provided mapping\n nlp.vocab.morphology.tag_map.update(tag_map)\n\n msg.divider(\"Data format validation\")\n\n # TODO: Validate data format using the JSON schema\n # TODO: update once the new format is ready\n # TODO: move validation to GoldCorpus in order to be able to load from dir\n\n # Create the gold corpus to be able to better analyze data\n loading_train_error_message = \"\"\n loading_dev_error_message = \"\"\n with msg.loading(\"Loading corpus...\"):\n corpus = GoldCorpus(train_path, dev_path)\n try:\n train_dataset = list(corpus.train_dataset(nlp))\n train_dataset_unpreprocessed = list(\n corpus.train_dataset_without_preprocessing(nlp)\n )\n except ValueError as e:\n loading_train_error_message = f\"Training data cannot be loaded: {e}\"\n try:\n dev_dataset = list(corpus.dev_dataset(nlp))\n except ValueError as e:\n loading_dev_error_message = f\"Development data cannot be loaded: {e}\"\n if loading_train_error_message or loading_dev_error_message:\n if loading_train_error_message:\n msg.fail(loading_train_error_message)\n if loading_dev_error_message:\n msg.fail(loading_dev_error_message)\n sys.exit(1)\n msg.good(\"Corpus is loadable\")\n\n # Create all gold data here to avoid iterating over the train_dataset constantly\n gold_train_data = _compile_gold(train_dataset, pipeline)\n gold_train_unpreprocessed_data = _compile_gold(\n train_dataset_unpreprocessed, pipeline\n )\n gold_dev_data = _compile_gold(dev_dataset, pipeline)\n\n train_texts = gold_train_data[\"texts\"]\n dev_texts = gold_dev_data[\"texts\"]\n\n msg.divider(\"Training stats\")\n msg.text(f\"Training pipeline: {', '.join(pipeline)}\")\n for pipe in [p for p in pipeline if p not in nlp.factories]:\n msg.fail(f\"Pipeline component '{pipe}' not available in factories\")\n if base_model:\n msg.text(f\"Starting with base model '{base_model}'\")\n else:\n msg.text(f\"Starting with blank model '{lang}'\")\n msg.text(f\"{len(train_dataset)} training docs\")\n msg.text(f\"{len(dev_dataset)} evaluation docs\")\n\n if not len(gold_dev_data):\n msg.fail(\"No evaluation docs\")\n overlap = len(train_texts.intersection(dev_texts))\n if overlap:\n msg.warn(f\"{overlap} training examples also in evaluation data\")\n else:\n msg.good(\"No overlap between training and evaluation data\")\n if not base_model and len(train_dataset) < BLANK_MODEL_THRESHOLD:\n text = (\n f\"Low number of examples to train from a blank model ({len(train_dataset)})\"\n )\n if len(train_dataset) < BLANK_MODEL_MIN_THRESHOLD:\n msg.fail(text)\n else:\n msg.warn(text)\n msg.text(\n f\"It's recommended to use at least {BLANK_MODEL_THRESHOLD} examples \"\n f\"(minimum {BLANK_MODEL_MIN_THRESHOLD})\",\n show=verbose,\n )\n\n msg.divider(\"Vocab & Vectors\")\n n_words = gold_train_data[\"n_words\"]\n msg.info(\n f\"{n_words} total word(s) in the data ({len(gold_train_data['words'])} unique)\"\n )\n if gold_train_data[\"n_misaligned_words\"] > 0:\n n_misaligned = gold_train_data[\"n_misaligned_words\"]\n msg.warn(f\"{n_misaligned} misaligned tokens in the training data\")\n if gold_dev_data[\"n_misaligned_words\"] > 0:\n n_misaligned = gold_dev_data[\"n_misaligned_words\"]\n msg.warn(f\"{n_misaligned} misaligned tokens in the dev data\")\n most_common_words = gold_train_data[\"words\"].most_common(10)\n msg.text(\n f\"10 most common words: {_format_labels(most_common_words, counts=True)}\",\n show=verbose,\n )\n if len(nlp.vocab.vectors):\n msg.info(\n f\"{len(nlp.vocab.vectors)} vectors ({nlp.vocab.vectors.n_keys} \"\n f\"unique keys, {nlp.vocab.vectors_length} dimensions)\"\n )\n else:\n msg.info(\"No word vectors present in the model\")\n\n if \"ner\" in pipeline:\n # Get all unique NER labels present in the data\n labels = set(\n label for label in gold_train_data[\"ner\"] if label not in (\"O\", \"-\", None)\n )\n label_counts = gold_train_data[\"ner\"]\n model_labels = _get_labels_from_model(nlp, \"ner\")\n new_labels = [l for l in labels if l not in model_labels]\n existing_labels = [l for l in labels if l in model_labels]\n has_low_data_warning = False\n has_no_neg_warning = False\n has_ws_ents_error = False\n has_punct_ents_warning = False\n\n msg.divider(\"Named Entity Recognition\")\n msg.info(\n f\"{len(new_labels)} new label(s), {len(existing_labels)} existing label(s)\"\n )\n missing_values = label_counts[\"-\"]\n msg.text(f\"{missing_values} missing value(s) (tokens with '-' label)\")\n for label in new_labels:\n if len(label) == 0:\n msg.fail(\"Empty label found in new labels\")\n if new_labels:\n labels_with_counts = [\n (label, count)\n for label, count in label_counts.most_common()\n if label != \"-\"\n ]\n labels_with_counts = _format_labels(labels_with_counts, counts=True)\n msg.text(f\"New: {labels_with_counts}\", show=verbose)\n if existing_labels:\n msg.text(f\"Existing: {_format_labels(existing_labels)}\", show=verbose)\n if gold_train_data[\"ws_ents\"]:\n msg.fail(f\"{gold_train_data['ws_ents']} invalid whitespace entity spans\")\n has_ws_ents_error = True\n\n if gold_train_data[\"punct_ents\"]:\n msg.warn(f\"{gold_train_data['punct_ents']} entity span(s) with punctuation\")\n has_punct_ents_warning = True\n\n for label in new_labels:\n if label_counts[label] <= NEW_LABEL_THRESHOLD:\n msg.warn(\n f\"Low number of examples for new label '{label}' ({label_counts[label]})\"\n )\n has_low_data_warning = True\n\n with msg.loading(\"Analyzing label distribution...\"):\n neg_docs = _get_examples_without_label(train_dataset, label)\n if neg_docs == 0:\n msg.warn(f\"No examples for texts WITHOUT new label '{label}'\")\n has_no_neg_warning = True\n\n if not has_low_data_warning:\n msg.good(\"Good amount of examples for all labels\")\n if not has_no_neg_warning:\n msg.good(\"Examples without occurrences available for all labels\")\n if not has_ws_ents_error:\n msg.good(\"No entities consisting of or starting/ending with whitespace\")\n if not has_punct_ents_warning:\n msg.good(\"No entities consisting of or starting/ending with punctuation\")\n\n if has_low_data_warning:\n msg.text(\n f\"To train a new entity type, your data should include at \"\n f\"least {NEW_LABEL_THRESHOLD} instances of the new label\",\n show=verbose,\n )\n if has_no_neg_warning:\n msg.text(\n \"Training data should always include examples of entities \"\n \"in context, as well as examples without a given entity \"\n \"type.\",\n show=verbose,\n )\n if has_ws_ents_error:\n msg.text(\n \"As of spaCy v2.1.0, entity spans consisting of or starting/ending \"\n \"with whitespace characters are considered invalid.\"\n )\n\n if has_punct_ents_warning:\n msg.text(\n \"Entity spans consisting of or starting/ending \"\n \"with punctuation can not be trained with a noise level > 0.\"\n )\n\n if \"textcat\" in pipeline:\n msg.divider(\"Text Classification\")\n labels = [label for label in gold_train_data[\"cats\"]]\n model_labels = _get_labels_from_model(nlp, \"textcat\")\n new_labels = [l for l in labels if l not in model_labels]\n existing_labels = [l for l in labels if l in model_labels]\n msg.info(\n f\"Text Classification: {len(new_labels)} new label(s), \"\n f\"{len(existing_labels)} existing label(s)\"\n )\n if new_labels:\n labels_with_counts = _format_labels(\n gold_train_data[\"cats\"].most_common(), counts=True\n )\n msg.text(f\"New: {labels_with_counts}\", show=verbose)\n if existing_labels:\n msg.text(f\"Existing: {_format_labels(existing_labels)}\", show=verbose)\n if set(gold_train_data[\"cats\"]) != set(gold_dev_data[\"cats\"]):\n msg.fail(\n f\"The train and dev labels are not the same. \"\n f\"Train labels: {_format_labels(gold_train_data['cats'])}. \"\n f\"Dev labels: {_format_labels(gold_dev_data['cats'])}.\"\n )\n if gold_train_data[\"n_cats_multilabel\"] > 0:\n msg.info(\n \"The train data contains instances without \"\n \"mutually-exclusive classes. Use '--textcat-multilabel' \"\n \"when training.\"\n )\n if gold_dev_data[\"n_cats_multilabel\"] == 0:\n msg.warn(\n \"Potential train/dev mismatch: the train data contains \"\n \"instances without mutually-exclusive classes while the \"\n \"dev data does not.\"\n )\n else:\n msg.info(\n \"The train data contains only instances with \"\n \"mutually-exclusive classes.\"\n )\n if gold_dev_data[\"n_cats_multilabel\"] > 0:\n msg.fail(\n \"Train/dev mismatch: the dev data contains instances \"\n \"without mutually-exclusive classes while the train data \"\n \"contains only instances with mutually-exclusive classes.\"\n )\n\n if \"tagger\" in pipeline:\n msg.divider(\"Part-of-speech Tagging\")\n labels = [label for label in gold_train_data[\"tags\"]]\n tag_map = nlp.vocab.morphology.tag_map\n msg.info(f\"{len(labels)} label(s) in data ({len(tag_map)} label(s) in tag map)\")\n labels_with_counts = _format_labels(\n gold_train_data[\"tags\"].most_common(), counts=True\n )\n msg.text(labels_with_counts, show=verbose)\n non_tagmap = [l for l in labels if l not in tag_map]\n if not non_tagmap:\n msg.good(f\"All labels present in tag map for language '{nlp.lang}'\")\n for label in non_tagmap:\n msg.fail(f\"Label '{label}' not found in tag map for language '{nlp.lang}'\")\n\n if \"parser\" in pipeline:\n has_low_data_warning = False\n msg.divider(\"Dependency Parsing\")\n\n # profile sentence length\n msg.info(\n f\"Found {gold_train_data['n_sents']} sentence(s) with an average \"\n f\"length of {gold_train_data['n_words'] / gold_train_data['n_sents']:.1f} words.\"\n )\n\n # check for documents with multiple sentences\n sents_per_doc = gold_train_data[\"n_sents\"] / len(gold_train_data[\"texts\"])\n if sents_per_doc < 1.1:\n msg.warn(\n f\"The training data contains {sents_per_doc:.2f} sentences per \"\n f\"document. When there are very few documents containing more \"\n f\"than one sentence, the parser will not learn how to segment \"\n f\"longer texts into sentences.\"\n )\n\n # profile labels\n labels_train = [label for label in gold_train_data[\"deps\"]]\n labels_train_unpreprocessed = [\n label for label in gold_train_unpreprocessed_data[\"deps\"]\n ]\n labels_dev = [label for label in gold_dev_data[\"deps\"]]\n\n if gold_train_unpreprocessed_data[\"n_nonproj\"] > 0:\n n_nonproj = gold_train_unpreprocessed_data[\"n_nonproj\"]\n msg.info(f\"Found {n_nonproj} nonprojective train sentence(s)\")\n if gold_dev_data[\"n_nonproj\"] > 0:\n n_nonproj = gold_dev_data[\"n_nonproj\"]\n msg.info(f\"Found {n_nonproj} nonprojective dev sentence(s)\")\n msg.info(f\"{labels_train_unpreprocessed} label(s) in train data\")\n msg.info(f\"{len(labels_train)} label(s) in projectivized train data\")\n labels_with_counts = _format_labels(\n gold_train_unpreprocessed_data[\"deps\"].most_common(), counts=True\n )\n msg.text(labels_with_counts, show=verbose)\n\n # rare labels in train\n for label in gold_train_unpreprocessed_data[\"deps\"]:\n if gold_train_unpreprocessed_data[\"deps\"][label] <= DEP_LABEL_THRESHOLD:\n msg.warn(\n f\"Low number of examples for label '{label}' \"\n f\"({gold_train_unpreprocessed_data['deps'][label]})\"\n )\n has_low_data_warning = True\n\n # rare labels in projectivized train\n rare_projectivized_labels = []\n for label in gold_train_data[\"deps\"]:\n if gold_train_data[\"deps\"][label] <= DEP_LABEL_THRESHOLD and \"||\" in label:\n rare_projectivized_labels.append(\n f\"{label}: {gold_train_data['deps'][label]}\"\n )\n\n if len(rare_projectivized_labels) > 0:\n msg.warn(\n f\"Low number of examples for {len(rare_projectivized_labels)} \"\n \"label(s) in the projectivized dependency trees used for \"\n \"training. You may want to projectivize labels such as punct \"\n \"before training in order to improve parser performance.\"\n )\n msg.warn(\n f\"Projectivized labels with low numbers of examples: \",\n \", \".join(rare_projectivized_labels),\n show=verbose,\n )\n has_low_data_warning = True\n\n # labels only in train\n if set(labels_train) - set(labels_dev):\n msg.warn(\n \"The following labels were found only in the train data:\",\n \", \".join(set(labels_train) - set(labels_dev)),\n show=verbose,\n )\n\n # labels only in dev\n if set(labels_dev) - set(labels_train):\n msg.warn(\n \"The following labels were found only in the dev data:\",\n \", \".join(set(labels_dev) - set(labels_train)),\n show=verbose,\n )\n\n if has_low_data_warning:\n msg.text(\n f\"To train a parser, your data should include at \"\n f\"least {DEP_LABEL_THRESHOLD} instances of each label.\",\n show=verbose,\n )\n\n # multiple root labels\n if len(gold_train_unpreprocessed_data[\"roots\"]) > 1:\n msg.warn(\n f\"Multiple root labels \"\n f\"({', '.join(gold_train_unpreprocessed_data['roots'])}) \"\n f\"found in training data. spaCy's parser uses a single root \"\n f\"label ROOT so this distinction will not be available.\"\n )\n\n # these should not happen, but just in case\n if gold_train_data[\"n_nonproj\"] > 0:\n msg.fail(\n f\"Found {gold_train_data['n_nonproj']} nonprojective \"\n f\"projectivized train sentence(s)\"\n )\n if gold_train_data[\"n_cycles\"] > 0:\n msg.fail(\n f\"Found {gold_train_data['n_cycles']} projectivized train sentence(s) with cycles\"\n )\n\n msg.divider(\"Summary\")\n good_counts = msg.counts[MESSAGES.GOOD]\n warn_counts = msg.counts[MESSAGES.WARN]\n fail_counts = msg.counts[MESSAGES.FAIL]\n if good_counts:\n msg.good(f\"{good_counts} {'check' if good_counts == 1 else 'checks'} passed\")\n if warn_counts:\n msg.warn(f\"{warn_counts} {'warning' if warn_counts == 1 else 'warnings'}\")\n if fail_counts:\n msg.fail(f\"{fail_counts} {'error' if fail_counts == 1 else 'errors'}\")\n sys.exit(1)","def train_model(args, train_exs: List[SentimentExample]) -> SentimentClassifier:\n indexer = Indexer()\n stop_words = set(stopwords.words('english'))\n punkt = (',', '.', '...', '?', '\\'', '\\'\\'', '!', ':', ';')\n # Initialize feature extractor\n if args.model == \"TRIVIAL\":\n feat_extractor = None\n elif args.feats == \"UNIGRAM\":\n # Generate vocabulary\n for ex in train_exs:\n for word in ex.words:\n if word.lower() not in stop_words and word.lower() not in punkt:\n indexer.add_and_get_index(word.lower())\n feat_extractor = UnigramFeatureExtractor(indexer)\n elif args.feats == \"BIGRAM\":\n # Generate vocabulary\n for ex in train_exs:\n for i in range(0, len(ex.words) - 1):\n if stop_words.__contains__(ex.words[i]) and stop_words.__contains__(ex.words[i + 1]) or (\n punkt.__contains__(ex.words[i]) or punkt.__contains__(ex.words[i + 1])):\n continue\n bigram = ex.words[i] + ' ' + ex.words[i + 1]\n indexer.add_and_get_index(bigram.lower())\n feat_extractor = BigramFeatureExtractor(indexer)\n elif args.feats == \"BETTER\":\n # Generate vocabulary\n cnt = Counter()\n for ex in train_exs:\n cnt.update(\n word.lower() for word in ex.words if word.lower() not in stop_words and word.lower() not in punkt)\n cnt = dict(cnt.most_common(int(cnt.__len__() * 0.75)))\n for keys in cnt.keys():\n indexer.add_and_get_index(keys)\n feat_extractor = BetterFeatureExtractor(indexer)\n else:\n raise Exception(\"Pass in UNIGRAM, BIGRAM, or BETTER to run the appropriate system\")\n\n # Train the model\n if args.model == \"TRIVIAL\":\n model = TrivialSentimentClassifier()\n elif args.model == \"PERCEPTRON\":\n model = train_perceptron(train_exs, feat_extractor)\n elif args.model == \"LR\":\n model = train_logistic_regression(train_exs, feat_extractor)\n else:\n raise Exception(\"Pass in TRIVIAL, PERCEPTRON, or LR to run the appropriate system\")\n return model","def create_train_model(self):\n st = LancasterStemmer()\n with open(self.data_path, encoding='utf8') as f_name:\n sentences = [[st.stem(w) for w, t in pos_tag(line.lower().split()) if 'N' in t] for line in f_name]\n sentences = [filter(lambda x: len(x) > 2, (word.strip(punctuation) for word in sentences)) for sent in sentences]\n model = Word2Vec(sentences,\n min_count=self.min_count,\n size=self.size,\n window=self.window,\n workers=4)\n model.save(self.model_path)","def put(self):\n training()\n return {\"message\" : \"the model trained\"}, 201","def load_spacy(model=\"nb_core_news_sm\", file=\"combined.jsonl\"):\n print(f\"Loading SPACY with model={model} from file={file}\")\n nlp = spacy.load(model)\n ruler = load_ruler_from_file(nlp, file)\n patterns = [\n {\"label\": \"LATERALITET\", \"pattern\": \"venstre\", \"id\": \"SIN\"},\n {\"label\": \"LATERALITET\", \"pattern\": \"høyre\", \"id\": \"DXT\"},\n {\"label\": \"SYMPTOM\", \"pattern\": \"Smerte\", \"id\": \"PAIN\"},\n {\"label\": \"OBSERVATION\", \"pattern\": \"BP\", \"id\": \"BLOOD_PRESSURE\"},\n {\"label\": \"OBSERVATION\", \"pattern\": \"BT\", \"id\": \"BLOOD_PRESSURE\"},\n {\"label\": \"OBSERVATION\", \"pattern\": \"puls\", \"id\": \"PULSE\"},\n {\"label\": \"OBSERVATION\", \"pattern\": \"Puls\", \"id\": \"PULSE\"},\n {\"label\": \"OBSERVATION\", \"pattern\": \"resp\", \"id\": \"RESP\"},\n {\"label\": \"OBSERVATION\", \"pattern\": \"Resp\", \"id\": \"RESP\"},\n {\"label\": \"OBSERVATION\", \"pattern\": \"temp\", \"id\": \"BODY_TEMP\"},\n {\"label\": \"OBSERVATION\", \"pattern\": \"Temp\", \"id\": \"BODY_TEMP\"},\n {\"label\": \"OBSERVATION\", \"pattern\": \"temperatur\", \"id\": \"BODY_TEMP\"},\n {\"label\": \"OBSERVATION\", \"pattern\": \"Temperatur\", \"id\": \"BODY_TEMP\"},\n\n {\"label\": \"LAB\", \"pattern\": \"hb\", \"id\": \"HB\"},\n {\"label\": \"LAB\", \"pattern\": \"Hb\", \"id\": \"HB\"},\n {\"label\": \"LAB\", \"pattern\": \"CRP\", \"id\": \"CRB\"},\n\n {\"label\": \"UNIT\", \"pattern\": \"C\", \"id\": \"CEL\"},\n {\"label\": \"UNIT\", \"pattern\": \"mmHg\", \"id\": \"MMHG\"}\n\n ]\n print(f\"Loading custom patterns of size={len(patterns)}\")\n ruler.add_patterns(patterns)\n\n nlp.add_pipe(ruler)\n print(\"Finished loading SPACY\")\n return nlp","def process_spacy(self):\n\n def prevent_sentence_boundary_detection(doc):\n for token in doc:\n # This will entirely disable spaCy's sentence detection\n token.is_sent_start = False\n return doc\n\n def process_sentence(sen_tokens):\n doc = spacy.tokens.Doc(nlp.vocab, words=sen_tokens)\n tagger(doc)\n prevent_sbd(doc)\n ner(doc)\n parser(doc)\n return doc\n\n # setup spacy nlp pipeline\n nlp = spacy.load(\"en_core_web_lg\")\n parser = nlp.get_pipe(\"parser\")\n nlp.add_pipe(\n prevent_sentence_boundary_detection, name=\"prevent-sbd\", before=\"parser\"\n )\n\n tagger = nlp.get_pipe(\"tagger\")\n prevent_sbd = nlp.get_pipe(\"prevent-sbd\")\n parser = nlp.get_pipe(\"parser\")\n ner = nlp.get_pipe(\"ner\")\n\n for doc in self.annotation_documents:\n doc.sentences_processed = []\n for sen in doc.sentences:\n sen_tokens = [t.text for t in sen.tokens]\n sen_proc = process_sentence(sen_tokens)\n # add processed sentence to doc\n doc.sentences_processed.append(sen_proc)\n\n print(f\"Processed with Spacy: {doc.document_id}\")","def dataset_to_spacy(db, entity_label):\n\n train_data = []\n try:\n #anyone missing context ??\n for word in db[entity_label]:\n if not db[entity_label][word]['context']:\n continue\n\n for contexted_example in db[entity_label][word]['context']:\n entities = []\n\n pure_word = word.replace(\"\\\\\",'')\n if len(word.split(\" \")) > 1 :\n\n start = contexted_example.lower().find(pure_word.lower())\n if start == -1:\n print(word)\n continue\n\n end = start+len(word)\n entities.append((start, end, entity_label))\n\n else:\n splits = list(split_with_indices(contexted_example))\n for touple in splits:\n if pure_word.lower() in contexted_example[touple[0]:touple[1]].lower():\n entities.append((touple[0], touple[0] + len(word), entity_label))\n\n train_data.append((contexted_example, {'entities': entities}))\n\n except Exception as e:\n print(e)\n return None\n\n return train_data","def train(self, params):\n for param in params:\n if param not in self.__info__['space']:\n print(\"Error: not supported parameters {}\".format(param))\n\n if self.dataset_type == PROBLEM.CLASSIFICATION:\n model = SVC(C=float(params[\"C\"]),\n kernel=params[\"Kernel\"],\n gamma=params[\"Gamma\"],\n coef0=float(params[\"Coef0\"]))\n else:\n model = SVR(C=float(params[\"C\"]),\n kernel=params['Kernel'],\n gamma=params[\"Gamma\"],\n coef0=float(params[\"Coef0\"]))\n\n # train\n model.fit(self.X_train, self.Y_train)\n return model","def train(self, x_data, y_data):\n for model in self.list_of_models:\n model.fit(x_data, y_data)\n self.trained_models.append(model)","def train(self, model, args):\n if model == self.WORD_DET_RFC:\n return self.train_rfc(args)\n elif model == self.REGRESSION_PARAMS:\n return self.train_bb_reg(args)\n else:\n raise Exception('No model %s exists to train' % model)","def cli(dataset_path, out_file):\n data = pd.read_csv(dataset_path)\n train_X, test_X, train_y, test_y = train_test_split(\n X, y, test_size=0.2, random_state=1\n )\n\n model = Predictor()\n model.fit(train_X, train_y)\n model.dump(out_file)","def train_single_model(conf):\n train_x, train_y, val_x, val_y = load_and_arrange_data(conf, conf['verbose'])\n if not os.path.exists(conf['models_dir']):\n os.makedirs(conf['models_dir'], exist_ok=True)\n\n model = create_model(train_x, train_y, conf['model_conf'])\n if conf['verbose']:\n model.summary()\n model_path = os.path.join(conf['models_dir'], '%s_%i_working%i.h5' % (\n conf['window'], conf['input_days'], int(conf['only_working_day'])))\n conf['train_conf']['model_path'] = model_path\n conf_path = model_path.replace('.h5', '.json')\n with open(conf_path, 'w') as f:\n json.dump(conf, f)\n\n model, ret = fit(model, train_x, train_y, [val_x, val_y], conf['train_conf'])\n _print_train_summary(conf, ret.history)","def use_model(model):\n st.set_page_config(page_title=\"MDNER\", layout=\"wide\")\n streamlit_style = \"\"\"\n\t\t<style>\n\t\t\thtml, body {\n\t\t\t font-family: 'Roboto', sans-serif;\n\t\t\t}\n\t\t</style>\n\t\"\"\"\n st.markdown(streamlit_style, unsafe_allow_html=True)\n st.markdown(\n \"<h1 style='text-align: center; color: dodgerBlue;'>📑 MDNER 🧬</h1>\",\n unsafe_allow_html=True,\n )\n text = st.text_area(\"Text to annotate\", height=300)\n run_button, export_button, _ = st.columns([1, 2, 10])\n with run_button:\n apply = st.button(\"Run\")\n if apply:\n # Load the best model\n nlp = spacy.load(f\"results/models/{model}/model-best\")\n # Define the colors for the entities\n colors = {\n \"TEMP\": \"#FF0000\",\n \"SOFT\": \"#FFA500\",\n \"STIME\": \"#FD6C9E\",\n \"FFM\": \"#00FFFF\",\n \"MOL\": \"#FFFF00\",\n }\n options = {\n \"ents\": [\n \"TEMP\",\n \"SOFT\",\n \"STIME\",\n \"FFM\",\n \"MOL\",\n ],\n \"colors\": colors,\n }\n # Apply the model to the text\n doc = nlp(text)\n # Visualize the entities in html\n html = displacy.render(doc, style=\"ent\", options=options)\n st.divider()\n st.write(html, unsafe_allow_html=True)\n st.divider()\n save_to_json(doc, text, export_button)","def train(self, data):\r\n pos_list = [\r\n \"adj\",\r\n \"adv\",\r\n \"adp\",\r\n \"conj\",\r\n \"det\",\r\n \"noun\",\r\n \"num\",\r\n \"pron\",\r\n \"prt\",\r\n \"verb\",\r\n \"x\",\r\n \".\",\r\n ]\r\n print(\"Train\")\r\n\r\n wordpos_list = [\r\n tuple([line[0][i], line[1][i]])\r\n for line in data\r\n for i in range(len(line[0]))\r\n ]\r\n\r\n pos_dict = {pos: {} for pos in pos_list}\r\n\r\n wordpos_count = Counter(wordpos_list)\r\n\r\n for w in wordpos_count:\r\n pos_dict[w[1]].update({w[0]: wordpos_count[w]})\r\n posterior_prob = {}\r\n emission_prob = {}\r\n for pos in pos_dict.keys():\r\n posterior_prob[pos] = float(sum(pos_dict[pos].values())) / len(wordpos_list)\r\n for pos in pos_dict.keys():\r\n emission_prob[pos] = {\r\n word: float(pos_dict[pos][word]) / sum(pos_dict[pos].values())\r\n for word in pos_dict[pos].keys()\r\n }\r\n\r\n trans_count = {}\r\n transition_prob = {}\r\n for pos in pos_list:\r\n trans_count[pos] = {}\r\n transition_prob[pos] = {}\r\n pair_list = [\r\n tuple([line[1][i], line[1][i + 1]])\r\n for line in data\r\n for i in range(len(line[1]) - 1)\r\n ]\r\n\r\n unique_list = list(set(pair_list))\r\n\r\n for element in unique_list:\r\n trans_count[element[0]].update({element[1]: pair_list.count(element)})\r\n\r\n for pos in pos_list:\r\n transition_prob[pos] = {pos: (1 / float(10 ** 8)) for pos in pos_list}\r\n for key, value in trans_count[pos].items():\r\n transition_prob[pos].update(\r\n {key: (value / float(sum(trans_count[pos].values())))}\r\n )\r\n initial_list = [line[1][0] for line in data]\r\n initial_count = Counter(initial_list)\r\n initial_prob = {\r\n pos: float(initial_count[pos]) / sum(initial_count.values())\r\n for pos in initial_count.keys()\r\n }\r\n self.position_list = pos_list\r\n self.emission_probability = emission_prob\r\n self.transition_probability = transition_prob\r\n self.initial_probability = initial_prob\r\n self.posterior_probability = posterior_prob","def make_submission(data, model, path):\n counter = 0\n length= len(data)\n test_predictions = []\n #Data has form of [(id,vec),(id,vec)....]\n for instance in data:\n print(\"Prog: \",(counter/length*100))\n counter+=1\n id = instance[0]\n vec = instance[1]\n res = model.predict(vec)\n print(\"Predicted: \",res)\n test_predictions.append({\"id\":id,\"prediction\":res})\n with open(path+\".json\", \"w\", encoding=\"utf-8\") as f:\n for doc in test_predictions:\n f.write(json.dumps(doc) + \"\\n\")","def train(self, trainfile):\r\n\r\n # We load the data and lower the text\r\n data_train = pd.read_csv(trainfile, sep = \"\\t\", names = [\"polarity\", \"category\", \"word\", \"offsets\", \"sentence\"])\r\n data_train['sentence_l'] = data_train['sentence'].apply(str.lower)\r\n data_train['word'] = data_train['word'].apply(str.lower)\r\n \r\n # We try to keep all the no/nor/not words as this changes radically the sentiment analysis\r\n data_train['sentence_l'] = data_train[\"sentence_l\"].apply(lambda sentence: sentence.replace(\"can\\'t\", \"can not\"))\r\n data_train['sentence_l'] = data_train[\"sentence_l\"].apply(lambda sentence: sentence.replace(\"n\\'t\", \" not\"))\r\n self.stopwords = stopwords.words(\"english\")\r\n self.stopwords.remove('nor')\r\n self.stopwords.remove('no')\r\n self.stopwords.remove('not')\r\n \r\n # We clean the train data and stem the words\r\n self.stemmer = nltk.porter.PorterStemmer()\r\n clean_sentences = []\r\n for row in data_train['sentence_l']:\r\n tokens = word_tokenize(row)\r\n tokens = [word for word in tokens if word.isalpha()]\r\n tokens = [w for w in tokens if not w in self.stopwords] \r\n tokens = [self.stemmer.stem(word) for word in tokens]\r\n clean_sentences.append(tokens)\r\n data_train['stems'] = clean_sentences\r\n \r\n # We also stem the target words to be coherent with the stemmed words in the sentences\r\n data_train['word'] = [self.stemmer.stem(word) for word in data_train['word']]\r\n \r\n # We recreate the sentences with the selected and cleaned words\r\n Classifier.create_sentence = staticmethod(Classifier.create_sentence)\r\n data_train.clean_sentence = Classifier.create_sentence(data_train.stems)\r\n \r\n # We create a BOW vector\r\n self.restaurant_vect = CountVectorizer(min_df=1, tokenizer=nltk.word_tokenize)\r\n reviews_counts = self.restaurant_vect.fit_transform(data_train.clean_sentence)\r\n \r\n # We transform the BOW vector with the tfidf scores\r\n self.tfidf_transformer = TfidfTransformer()\r\n reviews_tfidf = self.tfidf_transformer.fit_transform(reviews_counts)\r\n \r\n polarities = []\r\n for row in data_train['polarity']:\r\n if row == 'positive':\r\n polarities.append(1)\r\n if row == 'neutral':\r\n polarities.append(0)\r\n if row == 'negative':\r\n polarities.append(-1)\r\n data_train['polarity_floats'] = polarities\r\n \r\n # Split data into training and test sets\r\n test_size = 10\r\n X_train, X_test, y_train, y_test = train_test_split(reviews_tfidf, data_train.polarity_floats,\r\n test_size = test_size/100, random_state = None)\r\n \r\n ############# CNN MODEL ##############\r\n \r\n from keras.layers import Input, Dense, Embedding, Conv2D, MaxPool2D\r\n from keras.layers import Reshape, Flatten, Dropout, Concatenate\r\n from keras.callbacks import ModelCheckpoint\r\n from keras.optimizers import Adam\r\n from keras.models import Model\r\n \r\n sequence_length = X_train.shape[1] # 7\r\n vocabulary_size = X_train.shape[0] # 1503\r\n embedding_dim = 256\r\n filter_sizes = [3,4,5]\r\n num_filters = 512\r\n drop = 0.5\r\n \r\n epochs = 10\r\n batch_size = 50\r\n \r\n # this returns a tensor\r\n print(\"Creating Model...\")\r\n inputs = Input(shape=(sequence_length,), dtype='int32')\r\n embedding = Embedding(input_dim=vocabulary_size, output_dim=embedding_dim, input_length=sequence_length)(inputs)\r\n reshape = Reshape((sequence_length,embedding_dim,1))(embedding)\r\n \r\n conv_0 = Conv2D(num_filters, kernel_size=(filter_sizes[0], embedding_dim), padding='valid', kernel_initializer='normal', activation='relu')(reshape)\r\n conv_1 = Conv2D(num_filters, kernel_size=(filter_sizes[1], embedding_dim), padding='valid', kernel_initializer='normal', activation='relu')(reshape)\r\n conv_2 = Conv2D(num_filters, kernel_size=(filter_sizes[2], embedding_dim), padding='valid', kernel_initializer='normal', activation='relu')(reshape)\r\n \r\n maxpool_0 = MaxPool2D(pool_size=(sequence_length - filter_sizes[0] + 1, 1), strides=(1,1), padding='valid')(conv_0)\r\n maxpool_1 = MaxPool2D(pool_size=(sequence_length - filter_sizes[1] + 1, 1), strides=(1,1), padding='valid')(conv_1)\r\n maxpool_2 = MaxPool2D(pool_size=(sequence_length - filter_sizes[2] + 1, 1), strides=(1,1), padding='valid')(conv_2)\r\n \r\n concatenated_tensor = Concatenate(axis=1)([maxpool_0, maxpool_1, maxpool_2])\r\n flatten = Flatten()(concatenated_tensor)\r\n dropout = Dropout(drop)(flatten)\r\n output = Dense(units=1, activation='softmax')(dropout)\r\n \r\n # this creates a model that includes\r\n model = Model(inputs=inputs, outputs=output)\r\n \r\n checkpoint = ModelCheckpoint('weights.{epoch:03d}-{val_acc:.4f}.hdf5', monitor='val_acc', verbose=1, save_best_only=True, mode='auto')\r\n adam = Adam(lr=1e-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)\r\n \r\n model.compile(optimizer=adam, loss='binary_crossentropy', metrics=['accuracy'])\r\n print(\"Training Model...\")\r\n model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, callbacks=[checkpoint], validation_data=(X_test, y_test)) # starts training\r","def main():\n loader = MicrosoftDataloader()\n train,dev,test = loader.getData()\n sentences = []\n\n # Collect all the training sentences\n for i,row in pd.concat((train,test)).iterrows():\n if isinstance(row[\"sentence1\"], basestring) and isinstance(row[\"sentence2\"], basestring):\n sentences.append(row[\"sentence1\"])\n sentences.append(row[\"sentence2\"])\n\n # Get the mapping between sentences and their cotext vectors\n mapped = get_sentence_to_context_map(sentences)\n\n # At this stage we have a map between every sentence and its context vector\n # However the JSON file must contain sentences in the same order as in the MSR data file\n data = []\n for i,sentence in enumerate(sentences):\n embedding = mapped[sentence]\n data.append({'index':i, 'embedding':embedding, 'text':sentence})\n\n # Write the sentences and embeddings to JSON\n # The array index should corrospond to the sentence #\n print \"Saving embedded sentences to: {0}\".format(EMBED_FILE)\n with open(EMBED_FILE,'w') as outfile:\n json.dump(data,outfile,indent=2)","def train(self, lib, service, model_name, algorithm, dataset_url, label, train_percentage, features,\n save_model=True,\n params=None):\n url = self.base_url + '/ml-service/phoenix-ml/' + service + '/train'\n headers = {\"ApiKey\": self.api_key, \"Content-type\": \"application/json\"}\n if params is None:\n params = {}\n body = {\n \"library\": lib,\n \"task\": \"train\",\n \"config\": {\n \"name\": model_name,\n \"algorithm\": algorithm,\n \"datasetUrl\": dataset_url,\n \"label\": label,\n \"trainPercentage\": train_percentage,\n \"features\": features,\n \"saveModel\": save_model,\n \"params\": params\n }\n }\n response = requests.post(url=url, json=body, headers=headers)\n response = response.json()\n return response","def trainModels():\n\n # load actives from ChEMBL\n actives = {}\n if not os.path.exists(DATA_FOLDER_PATH):\n os.mkdir(DATA_FOLDER_PATH)\n actives_file = [x for x in os.listdir(DATA_FOLDER_PATH) if x.startswith('actives_chembl') and x.endswith('.p')]\n if not actives_file or RELOAD_DATA and not USE_DOWNLOADED_STRUCTS:\n actives = chembl.loadChEMBLData(ACCESSION, IC_50_THRESHOLD, DATA_FOLDER_PATH)\n else:\n actives = pickle.load(open(DATA_FOLDER_PATH + actives_file[0], 'rb'))\n\n if not actives_file or RELOAD_DATA and not USE_DOWNLOADED_STRUCTS:\n chembl.computeConsensualIC50(actives, DATA_FOLDER_PATH)\n chembl.appendRDKitMols(actives, DATA_FOLDER_PATH)\n\n # load decoys downloaded from DUD\n decoys = {}\n if os.path.exists(DECOYS_SDF_FILE_PATH[:-4] + \".p\"):\n decoys = pickle.load(open(DECOYS_SDF_FILE_PATH[:-4] + \".p\", 'rb'))\n else:\n if os.path.exists(DECOYS_SDF_FILE_PATH):\n decoys = dud.getDecoys(DECOYS_SDF_FILE_PATH)\n else:\n print \"Decoys not found in: \" + DECOYS_SDF_FILE_PATH\n print \"Make sure you set the right path.\"\n exit()\n\n # merge both data sets\n compounds_all = {}\n compounds_all.update(actives)\n compounds_all.update(decoys)\n\n # compute Morgan fingerprints\n if os.path.exists(MERGED_DATASET_PATH) and not RELOAD_DATA:\n print \"Loading previously created dataset...\"\n compounds_all = pickle.load(open(MERGED_DATASET_PATH, 'rb'))\n else:\n fingerprinter.appendMorganFingerprints(compounds_all)\n\n actives = { cmpndid : compounds_all[cmpndid] for cmpndid in compounds_all.keys() if compounds_all[cmpndid]['active']}\n pickle.dump(actives, open(ACTIVES_DUMP, 'wb'))\n decoys = { cmpndid : compounds_all[cmpndid] for cmpndid in compounds_all.keys() if not compounds_all[cmpndid]['active']}\n\n # train and cross-validate multiple Naive Bayes Classifiers\n classification_results = dict()\n if not os.path.exists(CLASS_RESULTS_SAVE_FILE_PATH) or RELOAD_DATA:\n classification_results = classification.naiveBayesClassifierTraining(compounds_all)\n print \"Saving results...\"\n pickle.dump(classification_results, open(CLASS_RESULTS_SAVE_FILE_PATH, 'wb'))\n print \"Finished analysis.\"\n else:\n print \"Loading previous results...\"\n classification_results = pickle.load(open(CLASS_RESULTS_SAVE_FILE_PATH, 'rb'))\n\n # have fun with the classification results\n print \"# CLASSIFICATION STATISTICS #\"\n classification.playWithResults(classification_results)\n\n # cluster actives according to their similarity and keep only the diverse molecules\n actives_testset = dict()\n if CLUSTER:\n clusters = utilities.clusterMols(actives)\n actives_kept = dict()\n for cluster in clusters:\n actives_kept[cluster[0]] = actives[cluster[0]]\n remains = cluster[1:]\n actives_filtered_out = {chmblid : actives[chmblid] for chmblid in remains}\n actives_testset.update(actives_filtered_out)\n actives = actives_kept\n\n # estimate maximum distances between active molecules to set threshold for the application domain\n # distance_actives = regression.estimateDistanceThreshold(actives) # median of distances between two actives\n # min_distance_decoys, max_distance_decoys = regression.compareDistances(actives, decoys) # average min/max distance of closest/farthest decoy from any of the actives\n # print \"median of distances between two actives: \" + str(distance_actives)\n # print \"average min/max distance of closest/farthest decoy from any of the actives: \" + str(min_distance_decoys) + \"/\" + str(max_distance_decoys)\n\n # Support vector regression\n regression_results = dict()\n if not os.path.exists(REGRESS_RESULTS_SAVE_FILE_PATH) or RELOAD_DATA:\n regression_results = regression.supportVectorRegression(actives)\n pickle.dump(regression_results, open(REGRESS_RESULTS_SAVE_FILE_PATH, 'wb'))\n else:\n regression_results = pickle.load(open(REGRESS_RESULTS_SAVE_FILE_PATH, 'rb'))\n\n\n # do something with the regression results\n print \"# REGRESSION STATISTICS #\"\n regression.playWithResults(regression_results, decoys, actives_testset)\n\n return classification_results['final_model'], regression_results['final_model']","def process_text(model_name: str, text: str) -> spacy.tokens.Doc:\r\n nlp = load_model(model_name)\r\n return nlp(text)","def train(self, trainData):\n pass","def retrain(datapath, model_version):\n df = get_df(datapath)\n X = df.drop(columns='target')\n y = df['target']\n fitted_model = fit(RF, X, y)\n\n with open(f'trained_models/model_{model_version}.joblib', 'wb') as file:\n joblib.dump(fitted_model, file)","def train(self, data, option, param_map):\n if option == \"lr\":\n md = self.logistic_regression(elastic_param=param_map[\"elastic_param\"],\n reg_param=param_map[\"reg_param\"],\n family=param_map[\"family\"])\n elif option == \"rf\":\n md = self.random_forest(max_depth=param_map[\"max_depth\"],\n max_num_tree=param_map[\"max_num_tree\"])\n elif option == \"gbdt\":\n md = self.gbdt(max_depth=param_map[\"max_depth\"],\n max_bins=param_map[\"max_bins\"])\n else:\n raise ValueError(\"ERROR | model %s does not support yet\" % option)\n\n self.model = md.fit(data)\n return self.model","def train(self):\n # >>> YOUR ANSWER HERE\n\n fake_docs = []\n fake_words = []\n fake_words_freq = {}\n real_docs = []\n real_words = []\n real_words_freq = {}\n\n # load fake data of the training dataset, store the docs and words\n fake_data = open(self.train_data['fake']).readlines()\n for sentence in fake_data:\n preprocess_sentence = sentence.strip()\n fake_docs.append(preprocess_sentence)\n fake_words.extend(preprocess_sentence.split())\n\n # load real data of the training dataset, store the docs, words and word frequencies.\n real_data = open(self.train_data['real']).readlines()\n for sentence in real_data:\n preprocess_sentence = sentence.strip()\n real_docs.append(preprocess_sentence)\n real_words.extend(preprocess_sentence.split())\n\n # remove stop words if necessary\n if self.REMOVE_STOPWORDS:\n fake_words = [word for word in fake_words if word not in self.stopwords]\n real_words = [word for word in real_words if word not in self.stopwords]\n\n # calculate all words' frequency\n for word in fake_words:\n self.vocabulary.add(word)\n fake_words_freq[word] = fake_words_freq.get(word, 0) + 1\n for word in real_words:\n self.vocabulary.add(word)\n real_words_freq[word] = real_words_freq.get(word, 0) + 1\n\n # pre-calculate the number of all docs, the number of docs per class and words frequency per class for\n # calculation in the training loop.\n n_doc = len(fake_docs) + len(real_docs)\n n_class = {'fake': len(fake_docs), 'real': len(real_docs)}\n big_doc_dict = {'fake': fake_words_freq, 'real': real_words_freq}\n fake_words_num = 0\n real_words_num = 0\n for w in self.vocabulary:\n fake_words_num += fake_words_freq.get(w, 0)\n real_words_num += real_words_freq.get(w, 0)\n words_frequency_per_class = {'fake': fake_words_num, 'real': real_words_num}\n\n # Training\n for c in self.classes:\n self.logprior[c] = math.log(n_class[c] / n_doc)\n for w in self.vocabulary:\n count_w_c = big_doc_dict[c].get(w, 0)\n log_likelihood = math.log((count_w_c + 1) / (len(self.vocabulary) + words_frequency_per_class[c]))\n self.loglikelihood[(w, c)] = log_likelihood\n # >>> END YOUR ANSWER","def main_strategy_2():\n en_text, de_text, train_iter, dev_iter, _ = clean_data_strategy_2()\n embedding_en, embedding_de = get_GloVe_embedding(en_text, de_text)\n model = Model(len(en_text.vocab), len(de_text.vocab), 300, embedding_en, embedding_de)\n train(model, train_iter, dev_iter)","def train_model(schema,fieldsToRead = None):\n\tif not fieldsToRead:\n\t\tfieldsToRead = schema[\"fields\"].keys()\n\n\tif(\"vector_size\" in schema):\n\t\tvectorSize = schema[\"vector_size\"]\n\telse:\n\t\tvectorSize = DEFAULT_VECTOR_SIZE\n\n\tsentences = []\n\t# build sentences:\n\tprint \"Building Feature vectors...\"\n\n\tread_sentences(schema, lambda x : sentences.append(merge_sentences_to_single_sentence(x, fieldsToRead)))\n\tprint \"Read \" + str(len(sentences)) + \" documents\"\n\tprint \"Training Model...\"\n\tmodelPath = model_path(schema)\n\tweightMatrixPath = weight_matrix_path(schema)\n\tsentences = transpose_sentences(sentences)\n\tmodel = Word2Vec(sentences, size=vectorSize, window=5, min_count=1, workers=4)\n\tmodel.save(modelPath)\n\tmodel.save_word2vec_format(weightMatrixPath)\n\tprint \"Finished training\"\n\treturn model","def train(self, args_hpo, index):\n\n PrintColors.prYellow(f'\\n===== training with: {args_hpo} index={index}')\n PrintColors.prGreen(f'---- in mode: {self.configurations.execution_mode}, tag: {self.configurations.tag} ----')\n ''' ============ LOAD DATA ================================================================================ '''\n starting_time = time.time()\n dataset_reader = self.dataset_reader(\n candidate_types=self.configurations.clustering_mode,\n word_indexer={'words': PretrainedTransformerIndexer(self.configurations.pretrained_model_name)},\n mode=self.configurations.loading_mode)\n ''' .read returns list of instances '''\n train_data, val_data, test_data = (dataset_reader.read(folder) for folder in\n [self.configurations.train_data_dir,\n self.configurations.val_data_dir,\n self.configurations.test_data_dir])\n\n # count state pairs\n preceeds = dict()\n\n for instance in train_data:\n for ind in range(len(instance.fields['squeezed_labels'].tokens) - 1):\n [event_1, event_2] = [instance.fields['squeezed_labels'].tokens[i].text for i in [ind, ind + 1]]\n scenario = self.dataset_reader.scenario_of_label(event_1)\n if scenario not in preceeds:\n preceeds[scenario] = dict()\n if (event_1, event_2) not in preceeds[scenario]:\n preceeds[scenario][(event_1, event_2)] = 0\n preceeds[scenario][(event_1, event_2)] += 1\n\n pretrained_tokenizer = PretrainedTransformerTokenizer(self.configurations.pretrained_model_name)\n supply_token_indices(train_data + val_data, 'story', pretrained_tokenizer)\n\n ''' build vocabulary and associate it with datasets '''\n vocabulary = Vocabulary.from_instances(train_data + val_data)\n train_data.index_with(vocabulary), val_data.index_with(vocabulary)\n\n train_data_loader = DataLoader(dataset=train_data, batch_size=args_hpo.batch_size)\n val_data_loader = DataLoader(dataset=val_data, batch_size=args_hpo.batch_size)\n\n ''' ============ DEFINE MODEL ============================================================================= '''\n ''' i keep .to() here instead of in model.__init__() to accomadate better abstraction '''\n event_labels = [i for i in range(vocabulary.get_vocab_size('scr_labels'))\n if '#' in vocabulary.get_token_from_index(i, 'scr_labels')]\n participant_labels = [i for i in range(vocabulary.get_vocab_size('scr_labels'))\n if '@' in vocabulary.get_token_from_index(i, 'scr_labels')]\n model = self.model(args_hpo, vocabulary, configurations=self.configurations,\n preceeds=preceeds,\n event_indices=event_labels,\n participant_indices=participant_labels).to(self.configurations.device)\n\n ''' ============ DEFINE TRAINER =========================================================================== '''\n ''' -- serialization --------------------------------------------------- '''\n if not os.path.exists(os.path.join(*['.', 'models'])):\n os.mkdir(os.path.join(*['.', 'models']))\n if index == 0:\n for file in os.listdir(os.path.join(*['.', 'models'])):\n path = os.path.join(*['.', 'models', file])\n if os.path.isfile(path):\n os.remove(path)\n else:\n shutil.rmtree(path)\n serialization_path = 'models_{}_{}'.format(self.configurations.tag, index)\n serialization_path_longer = os.path.join(*['.', 'models', serialization_path])\n vocab_path = 'vocab_{}_{}'.format(self.configurations.tag, index)\n vocab_dir_longer = os.path.join(*['.', 'models', vocab_path])\n if not os.path.exists(serialization_path_longer):\n os.mkdir(serialization_path_longer)\n model_checkpointer = Checkpointer(serialization_dir=serialization_path_longer, num_serialized_models_to_keep=1)\n ''' -- logging ---------------------------------------------------------- '''\n tensorboard_writer = TensorboardWriter(serialization_dir='tensorboard', summary_interval=1)\n if index == 0:\n shutil.rmtree(os.path.join(*['.', 'tensorboard', 'log']))\n\n optimizer = torch.optim.Adam(model.parameters(), lr=args_hpo.lr, weight_decay=args_hpo.l2)\n trainer = GradientDescentTrainer(\n model=model,\n optimizer=optimizer,\n data_loader=train_data_loader,\n validation_data_loader=val_data_loader,\n # note: this is the metric for early stopping\n validation_metric='-loss',\n patience=self.configurations.patience,\n num_epochs=self.configurations.max_epochs,\n serialization_dir=serialization_path_longer,\n checkpointer=model_checkpointer,\n cuda_device=self.configurations.device,\n grad_norm=args_hpo.clip,\n tensorboard_writer=tensorboard_writer,\n learning_rate_scheduler=ReduceOnPlateauLearningRateScheduler(optimizer=optimizer)\n )\n\n ''' trainer saves the model, but the vocabulary needs to be saved, too '''\n vocabulary.save_to_files(vocab_dir_longer)\n\n ''' check the metric names to synchronize with the class '''\n metrics = trainer.train()\n test_metrics = model.test(test_data=test_data, dataset_reader=dataset_reader)\n metrics.update(test_metrics)\n metrics['time_consumed(hrs)'] = round((time.time() - starting_time) / 3600, 4)\n\n return metrics","def train_model():\n print('Loading the dataset...')\n dataset = pd.read_csv('app/Sentiment_Reviews.csv',index_col=0)\n X = dataset[['Reviews']]\n y = dataset[['Sentiment']]\n le = preprocessing.LabelEncoder()\n le.fit(y)\n y = (le.transform(y))\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=38)\n\n print('Training the model...')\n text_clf_svm = Pipeline([('vect', CountVectorizer()), ('tfidf', TfidfTransformer(use_idf=False)), ('clf-svm', SGDClassifier(loss='modified_huber', penalty='l2', alpha=0.001, random_state=42, max_iter=20))])\n text_clf_svm = text_clf_svm.fit(X_train['Reviews'], y_train)\n\n print('Storing model to redis...')\n pickled_model = pickle.dumps(text_clf_svm)\n try:\n redis_client.set('ml_model', pickled_model)\n except RedisError as e:\n print('Storing the model was not successful and threw an error.')\n print(e)","def train_text_model(train_dir, num_steps):\n if tf.gfile.Exists(train_dir):\n # Delete old model\n tf.gfile.DeleteRecursively(train_dir)\n tf.gfile.MakeDirs(train_dir)\n\n with tf.Graph().as_default():\n model = TextModel(_CONFIG)\n # Specify the loss function:\n one_hot_labels = slim.one_hot_encoding(model.labels, model.nb_emotions)\n slim.losses.softmax_cross_entropy(model.logits, one_hot_labels)\n total_loss = slim.losses.get_total_loss()\n\n # Create some summaries to visualize the training process\n # Use tensorboard --logdir=train_dir, careful with path (add Documents/tumblr-sentiment in front of train_dir)\n # Different from the logs, because computed on different mini batch of data\n tf.summary.scalar('Loss', total_loss)\n \n # Specify the optimizer and create the train op:\n optimizer = tf.train.AdamOptimizer(learning_rate=model.learning_rate)\n train_op = slim.learning.create_train_op(total_loss, optimizer)\n\n batch_size = _CONFIG['batch_size']\n initial_lr = _CONFIG['initial_lr']\n decay_factor = _CONFIG['decay_factor']\n nb_batches = model.dataset.num_samples / batch_size\n def train_step_fn(session, *args, **kwargs):\n # Decaying learning rate every epoch\n if train_step_fn.step % (nb_batches) == 0:\n lr_decay = decay_factor ** train_step_fn.epoch\n session.run(model.lr_rate_assign, feed_dict={model.lr_rate_placeholder: initial_lr * lr_decay})\n print('New learning rate: {0}'. format(initial_lr * lr_decay))\n train_step_fn.epoch += 1\n\n # Initialise embedding weights\n if train_step_fn.step == 0:\n session.run(model.embedding_init, feed_dict={model.embedding_placeholder: model.embedding})\n total_loss, should_stop = train_step(session, *args, **kwargs)\n\n train_step_fn.step += 1\n return [total_loss, should_stop]\n \n train_step_fn.step = 0\n train_step_fn.epoch = 0\n\n # Run the training:\n final_loss = slim.learning.train(\n train_op,\n logdir=train_dir,\n save_interval_secs=600,\n save_summaries_secs=600,\n train_step_fn=train_step_fn,\n number_of_steps=num_steps)\n \n print('Finished training. Last batch loss {0:.3f}'.format(final_loss))","def train(self, request):\n model = request.get(\"model\")\n if not model:\n raise MONAILabelException(\n MONAILabelError.INVALID_INPUT,\n \"Model is not provided for Training Task\",\n )\n\n task = self._trainers.get(model)\n if not task:\n raise MONAILabelException(\n MONAILabelError.INVALID_INPUT,\n f\"Train Task is not Initialized. There is no model '{model}' available\",\n )\n\n request = copy.deepcopy(request)\n result = task(request, self.datastore())\n\n # Run all scoring methods\n if self._auto_update_scoring:\n self.async_scoring(None)\n return result","def train(fine_tuning):\n features = np.array([\"my first sentence\", \"my second sentence\"])\n labels = np.array([1, 0])\n dataset = tf.data.Dataset.from_tensor_slices((features, labels))\n\n module = tf.saved_model.load(FLAGS.model_dir)\n\n # Create the sequential keras model.\n l = tf.keras.layers\n model = tf.keras.Sequential()\n model.add(l.Reshape((), batch_input_shape=[None, 1], dtype=tf.string))\n # TODO(b/124219898): output_shape should be optional.\n model.add(hub.KerasLayer(module, output_shape=[10], trainable=fine_tuning))\n model.add(l.Dense(100, activation=\"relu\"))\n model.add(l.Dense(50, activation=\"relu\"))\n model.add(l.Dense(1, activation=\"sigmoid\"))\n\n model.compile(\n optimizer=\"adam\",\n loss=\"binary_crossentropy\",\n metrics=[\"accuracy\"],\n # TODO(b/124446120): Remove after fixed.\n run_eagerly=True)\n\n model.fit_generator(generator=dataset.batch(1), epochs=5)\n\n # This is testing that a model using a SavedModel can be re-exported again,\n # e.g. to catch issues such as b/142231881.\n tf.saved_model.save(model, tempfile.mkdtemp())","def train_model_for_shap(allFeatures, train_ml, test_ml, df_ml, classification_model, language_model, fold):\n # list of analyzed language models\n model = classification_model\n print(type(model).__name__)\n\n features = set(allFeatures[language_model][fold])\n preds = []\n trues = []\n\n train_index = train_ml[fold]\n test_index = test_ml[fold]\n\n train_data = df_ml[features].iloc[train_index]\n target_train_data = df_ml[\"target_ml\"].iloc[train_index]\n test_data = df_ml[features].iloc[test_index]\n target_test_data = df_ml.iloc[test_index][\"target_ml\"]\n model.fit(train_data, target_train_data)\n\n preds.append(model.predict(test_data).tolist())\n trues.append(target_test_data.tolist())\n\n print(language_model)\n mcc = metrics.matthews_corrcoef(y_true=sum(trues, []), y_pred=sum(preds, []))\n f1 = metrics.f1_score(y_true=sum(trues, []), y_pred=sum(preds, []), average=\"weighted\")\n print(\"MCC: \", round(mcc, 3))\n print(\"F1: \", round(f1, 3))\n return model, train_data, test_data","def train_model(x_data, y_data, model_type):\n # def lr model object\n clr = None\n try:\n clr = model_list[model_type]()\n except Exception as e:\n print(e)\n # fit model\n clr.fit(x_data, y_data)\n # save model in pkl file\n try:\n joblib.dump(clr, \"model/\" + model_type + \".pkl\")\n except Exception as e:\n print(e)\n return clr","def train_model(self, *args, **kwargs):\n raise NotImplementedError","def model_train(data_dir,test=False):\r\n \r\n if not os.path.isdir(MODEL_DIR):\r\n os.mkdir(MODEL_DIR)\r\n\r\n if test:\r\n print(\"... test flag on\")\r\n print(\"...... subsetting data\")\r\n print(\"...... subsetting countries\")\r\n \r\n ## fetch time-series formatted data\r\n ts_data = fetch_ts(data_dir)\r\n\r\n ## train a different model for each data sets\r\n for country,df in ts_data.items():\r\n if test and country not in ['all','united_kingdom']:\r\n continue\r\n model_name = re.sub(\"\\.\",\"_\",str(MODEL_VERSION))\r\n saved_model = os.path.join(MODEL_DIR,\r\n \"sl-{}-{}.joblib\".format(country,model_name))\r\n saved_test_model = os.path.join(MODEL_DIR,\r\n \"test-{}-{}.joblib\".format(country,model_name))\r\n saved_baseline = os.path.join(BASELINE_DIR,\r\n \"b-sl-{}-{}.joblib\".format(country,model_name))\r\n saved_test_baseline = os.path.join(BASELINE_DIR,\r\n \"b-test-{}-{}.joblib\".format(country,model_name))\r\n if (test and (not os.path.isfile(saved_test_model))) or ((not test) and (not os.path.isfile(saved_model))):\r\n _model_train(df,country,test=test)\r\n if (test and (not os.path.isfile(saved_test_baseline))) or ((not test) and (not os.path.isfile(saved_baseline))):\r\n _baseline_train(df,country,test=test)","def train(self) -> None:\n\n # Check if in the saved model path there is already a trained model\n if self.config.TRN_HYPERP[\"save_path\"]:\n if tf.saved_model.contains_saved_model(self.config.TRN_HYPERP[\"save_path\"]):\n print(\"INFO: An existing saved model will be used for inference\\n\")\n else:\n params = {**self.config.TRN_HYPERP, **self.config.DATASET_HYPERP}\n trainer = Trainer(**params)\n\n print(f\"INFO: Starting training ... \\n\")\n start_time = time.time()\n trainer.train()\n print(f\"\\nINFO: Training completed in {round((time.time() - start_time)/60, 2)} minutes.\\n\")\n\n # Instantiate the saved translator for inference\n saved_path = self.config.TRN_HYPERP[\"save_path\"]\n self.saved_translator = tf.saved_model.load(saved_path)\n else:\n print(\"INFO: Path to save model wasn't provided in config file. Can't train the model\\n\")","def _read_data_taskA(data_path: str=\"path\", tokenizer=None, \n bert: bool=False, \n mode: str=\"raw\", \n tagger=None, \n test: bool=False, \n test_samples=None\n ):\n print(f\"\\n[dataset]: Loading data from '{data_path}'...\")\n sentences = []\n labels = []\n tok_list = []\n words_list = []\n targets_list = []\n target_final = []\n\n data_dict = read_json_data(data_path) if not test else test_samples\n #print(\"data_dict:\", len(data_dict))\n\n for entry in data_dict:\n # tokenize data sentences\n if bert:\n tokens = tokenizer.tokenize(entry[\"text\"])\n tokens.insert(0, \"[CLS]\") # RoBERTa \"<s>\" <-> BERT \"[CLS]\" \n tokens.append(\"[SEP]\") # RoBERTa \"</s>\" <-> BERT \"[SEP]\"\n else:\n tokens = tokenizer(entry[\"text\"])\n \n words_list.extend(tokens)\n tok_list.append(tokens)\n\n if mode == \"tokenize\":\n sentences.append(tokens)\n elif mode == \"raw\":\n sentences.append(entry[\"text\"])\n\n # count target words\n t_list = []\n if not test:\n targets = entry[\"targets\"]\n tgt_list = []\n if len(targets) > 0:\n t_list.append(targets)\n for tgt in targets:\n targets_list.append(tgt[1])\n tgt_list.append(tgt[1])\n else:\n t_list.append([])\n\n # tag input tokens\n b_tok = tokenizer if bert else None\n tags = tagger(targets, tokens, bert_tokenizer=b_tok)\n #print(tags)\n\n labels.append(tags)\n target_final.append(tgt_list)\n\n else:\n labels.append(\"dummy\")\n target_final.append(0)\n \n if not test: \n assert len(sentences) == len(labels)\n print(\"sentences:\",len(sentences))\n print(\"labels:\",len(labels))\n\n # count words occurency and frequency \n word_counter = collections.Counter(words_list)\n distinct_words = len(word_counter)\n print(f\"Number of distinct words: {distinct_words}\")\n \n # count target words occurency and frequency\n tgts_counter = collections.Counter(targets_list)\n distinct_tgts = len(tgts_counter)\n print(f\"Number of distinct targets: {distinct_tgts}\")\n\n return sentences, labels, targets_list, word_counter\n else:\n return list(zip(sentences, labels, target_final, tok_list))","def train_txt(txt_path, model_path):\n\n vectors = svmlight_to_vectors(txt_path)\n MAXENT_LOG.info(\"Attempting to train classifier {}\".format(model_path))\n p = ProcessCommunicator([mallet_bin, 'train-classifier',\n '--input', vectors,\n '--trainer', 'MaxEntTrainer',\n '--output-classifier', model_path],\n stdout_func=MAXENT_LOG.info, stderr_func=MAXENT_LOG.info)\n\n if p.wait() == 0:\n MAXENT_LOG.debug(\"Success.\")\n os.unlink(vectors)\n return MalletMaxent(model_path)\n else:\n raise ClassifierException(\"Training the classifier did not complete. Check the logs.\")","def train(self, X, y):\n tf.logging.set_verbosity(\n tf.logging.INFO) # comment if you don't want to display the information during training/evaluation\n\n X_train, X_test, y_train, y_test = train_test_split(\n X, y, test_size=self.params[\"TEST_SIZE\"], random_state=42, stratify=y)\n\n self.label_list = y.unique()\n\n train_features = self.sentences_to_features(X_train, y_train)\n test_features = self.sentences_to_features(X_test, y_test)\n if DEBUG:\n print(\"Transformation to features completed\")\n\n num_train_steps = int(\n len(train_features) / self.params[\"BATCH_SIZE\"] * self.params[\"NUM_TRAIN_EPOCHS\"])\n num_warmup_steps = int(\n num_train_steps * self.params[\"WARMUP_PROPORTION\"])\n\n run_config = self.run_config_builder()\n model_fn = self.model_fn_builder(len(self.label_list), self.params[\"LEARNING_RATE\"], num_train_steps,\n num_warmup_steps)\n self.estimator = self.estimator_builder(model_fn, run_config)\n\n train_input_fn = bert.run_classifier.input_fn_builder(features=train_features,\n seq_length=self.params[\"MAX_SEQ_LENGTH\"],\n is_training=True, drop_remainder=False)\n if DEBUG:\n print(\"Beginning Training!\")\n current_time = time.time()\n self.estimator.train(input_fn=train_input_fn,\n max_steps=num_train_steps)\n if DEBUG:\n print(\"Training took time :\", time.time() - current_time,\n \"s, or \", (time.time() - current_time) / 60, \"min\")\n\n self.classifier_trained = True\n\n test_input_fn = run_classifier.input_fn_builder(features=test_features,\n seq_length=self.params[\"MAX_SEQ_LENGTH\"],\n is_training=False, drop_remainder=False)\n\n # apply model on test set and print all metrics\n if DEBUG:\n print(\"Evaluating\")\n self.estimator.evaluate(input_fn=test_input_fn, steps=None)","def training(self) -> None:\n self.compile_model()\n self.train_epoch()\n self.agent.save()","def train(\n self,\n train_processed_data_dir: Path,\n val_processed_data_dir: Path,\n force_retrain: bool = False,\n ) -> NoReturn:\n if force_retrain or not self.is_training_completed():\n self.logger.info(self.logging_prefix + f\"Training model at {self.model_dir}; train: {train_processed_data_dir}, val: {val_processed_data_dir}\")\n IOUtils.rm_dir(self.model_dir)\n IOUtils.mk_dir(self.model_dir)\n\n # Save spec & configs of this model\n IOUtils.dump(self.model_dir/\"config-dict.json\", IOUtils.jsonfy(self.config), IOUtils.Format.jsonPretty)\n IOUtils.dump(self.model_dir/\"spec.json\", IOUtils.jsonfy(self.spec), IOUtils.Format.jsonPretty)\n self.train_impl(train_processed_data_dir, val_processed_data_dir)\n IOUtils.dump(self.model_dir / self.TRAINING_COMPLETED_FILE_NAME, str(time.time_ns()), IOUtils.Format.txt)\n # end if\n return","def json2txt_for_corenlp(json_home, dataset, data_type, saved_home, fine_grad=True, use_orig_keys=False, variations=False, sort_keyphrases=False, match_ending_parenthesis=False, use_corenlp=True, separate_present_absent=False, find_redirections=False):\n keyphrase_stat = {'num_keyphrases_with_variations': 0, 'num_keyphrases': 0, 'num_variations': 0,\n 'num_keyphrases_with_match_disambiguation': 0, 'num_extracted_acronym': 0, 'num_keyphrases_with_redirections': 0,\n 'num_redirections': 0, 'num_matched_disambiguation': 0}\n #num_keyphrases_with_variations = 0\n #num_keyphrases = 0\n #num_variations = 0\n #num_keyphrases_with_match_disambiguation = 0\n\n if variations and sort_keyphrases:\n raise ValueError(\"You cannot use sort_keyphrases when you need to find the variations of each keyphrase\")\n\n print('\\nProcessing {} data...'.format(data_type))\n saved_data_dir = os.path.join(saved_home, 'data_for_corenlp')\n if not os.path.exists(saved_data_dir):\n os.makedirs(saved_data_dir)\n json_file_name = os.path.join(json_home, \"{}_{}.json\".format(dataset, data_type))\n json_file = open(json_file_name, encoding='utf-8')\n processed_files_suffix = \"\"\n if variations:\n processed_files_suffix += \"_variations\"\n if find_redirections:\n processed_files_suffix += \"_redirections\"\n if sort_keyphrases:\n processed_files_suffix += \"_sorted\"\n if match_ending_parenthesis:\n processed_files_suffix += \"_parenthesis\"\n if separate_present_absent:\n processed_files_suffix += \"_separated\"\n if fine_grad_digit_matching:\n processed_files_suffix += \"_digit\"\n if reverse_sorting:\n processed_files_suffix += \"_reversed\"\n if replace_with_space:\n processed_files_suffix += \"_space\"\n\n processed_keyword_file = open(os.path.join(saved_data_dir, \"{}_{}_keyword_for_corenlp{}.txt\".format(dataset, data_type, processed_files_suffix)),\n 'w', encoding='utf-8')\n # context = title + '.' + '<eos>' + abstract\n processed_context_file = open(os.path.join(saved_data_dir, \"{}_{}_context_for_corenlp{}.txt\".format(dataset, data_type, processed_files_suffix)),\n 'w', encoding='utf-8')\n lines = json_file.readlines()\n for line_idx in tqdm(range(len(lines))):\n line = lines[line_idx]\n line_dict = json.loads(line.strip())\n # tokenization, lowercasing, replace all digits with '<digit>' symbol\n title = line_dict['title'].strip()\n abstract = line_dict['abstract'].strip()\n keywords = line_dict['keyword'].strip()\n # lowercasing the text\n title = title.lower()\n abstract = abstract.lower()\n keywords = keywords.lower()\n # filter out no-title or no-abstract data\n if len(title) == 0 or len(abstract) == 0:\n continue\n # concatenate title and abstract\n context = title + ' . ' + ' <eos> ' + abstract\n\n # for fine granularity tokenization\n context_tokens = get_tokens(context, fine_grad=fine_grad, use_corenlp=use_corenlp)\n context = ' '.join(context_tokens)\n if not use_orig_keys:\n if data_type != 'testing':\n limit_num = True\n else:\n limit_num = False\n keywords = ';'.join(\n process_keyphrase(keywords, context_tokens, keyphrase_stat, variations=variations, limit_num=limit_num,\n fine_grad=fine_grad, sort_keyphrases=sort_keyphrases,\n match_ending_parenthesis=match_ending_parenthesis, use_corenlp=use_corenlp,\n separate_present_absent=separate_present_absent, find_redirections=find_redirections))\n else:\n keywords = ';'.join(keywords.strip().split(';'))\n\n context_line = context + '\\n'\n keywords_line = keywords + '\\n'\n\n processed_keyword_file.write(keywords_line)\n processed_context_file.write(context_line)\n\n processed_keyword_file.close()\n processed_context_file.close()\n print(\"# keyphrases: {}\".format(keyphrase_stat['num_keyphrases']))\n if variations:\n print(\"# variations: {}\".format(keyphrase_stat['num_variations']))\n print(\"# keyphrases with variations: {}\".format(keyphrase_stat['num_keyphrases_with_variations']))\n print(\"# keyphrases with match disambiguation: {}\".format(keyphrase_stat['num_keyphrases_with_match_disambiguation']))\n print(\"# matched disambiguation: {}\".format(keyphrase_stat['num_matched_disambiguation']))\n if match_ending_parenthesis:\n print(\"# extracted acronyms: {}\".format(keyphrase_stat['num_extracted_acronym']))\n if find_redirections:\n print('# redirections found: {}'.format(keyphrase_stat['num_redirections']))\n print('# keyphrases with redirections: {}'.format(keyphrase_stat['num_keyphrases_with_redirections']))\n # keyphrase_stat = {'num_keyphrases_with_variations': 0, 'num_keyphrases': 0, 'num_variations': 0, 'num_keyphrases_with_match_disambiguation': 0}","def train_model(self, data:List[np.ndarray]):\n d = np.vstack(data)\n np.random.shuffle(d)\n self.regressor.fit(\n X=self.input(d),\n y=self.output(d)\n )","def loadSavedModel(folder, spark_session, loadsp=False):\n from sparknlp.internal import _USELoader\n jModel = _USELoader(folder, spark_session._jsparkSession, loadsp)._java_obj\n return UniversalSentenceEncoder(java_model=jModel)","def train(self, x_data, y_data):\n self.model.fit(np.array(x_data), np.array(y_data),\n batch_size=2,\n epochs=3,\n verbose=1)\n self.model.save_weights(self.model_filename)"],"string":"[\n \"def train_nlu(data, config, model_dir):\\n # Read the config_spacy.json as JSON \\n with open(config) as f: config = json.load(f)\\n\\n training_data = load_data(data)\\n trainer = Trainer(RasaNLUModelConfig(config))\\n trainer.train(training_data)\\n\\n model_directory = trainer.persist(model_dir, fixed_model_name= \\\"weathernlu\\\")\",\n \"def train_ner(model, new_model_name, output_dir, n_iter, train_data):\\r\\n random.seed(0)\\r\\n if model is not None:\\r\\n nlp = spacy.load(model) # load existing spaCy model\\r\\n print(\\\"Loaded model '%s'\\\" % model)\\r\\n else:\\r\\n nlp = spacy.blank(\\\"en\\\") # create blank Language class\\r\\n print(\\\"Created blank 'en' model\\\")\\r\\n # Add entity recognizer to model if it's not in the pipeline\\r\\n # nlp.create_pipe works for built-ins that are registered with spaCy\\r\\n if \\\"ner\\\" not in nlp.pipe_names:\\r\\n ner = nlp.create_pipe(\\\"ner\\\")\\r\\n nlp.add_pipe(ner)\\r\\n # otherwise, get it, so we can add labels to it\\r\\n else:\\r\\n ner = nlp.get_pipe(\\\"ner\\\")\\r\\n\\r\\n ner.add_label(LABEL) # add new entity label to entity recognizer\\r\\n # Adding extraneous labels shouldn't mess anything up\\r\\n ner.add_label(\\\"EXTRA\\\")\\r\\n \\r\\n \\r\\n if model is None:\\r\\n optimizer = nlp.begin_training()\\r\\n else:\\r\\n optimizer = nlp.resume_training()\\r\\n move_names = list(ner.move_names)\\r\\n # get names of other pipes to disable them during training\\r\\n other_pipes = [pipe for pipe in nlp.pipe_names if pipe != \\\"ner\\\"]\\r\\n with nlp.disable_pipes(*other_pipes): # only train NER\\r\\n sizes = compounding(1.0, 4.0, 1.001)\\r\\n # batch up the examples using spaCy's minibatch\\r\\n for itn in range(n_iter):\\r\\n random.shuffle(train_data)\\r\\n batches = minibatch(train_data, size=sizes)\\r\\n losses = {}\\r\\n for batch in batches:\\r\\n texts, annotations = zip(*batch)\\r\\n nlp.update(texts, annotations, sgd=optimizer, drop=0.35, losses=losses)\\r\\n print(\\\"Losses\\\", losses)\\r\\n\\r\\n # save model to output directory\\r\\n if output_dir is not None:\\r\\n output_dir = Path(output_dir)\\r\\n if not output_dir.exists():\\r\\n output_dir.mkdir()\\r\\n nlp.meta[\\\"name\\\"] = new_model_name # rename model\\r\\n nlp.to_disk(output_dir)\\r\\n print(\\\"Saved model to\\\", output_dir)\",\n \"def train_model(\\n model, train_path, eval_path, n_iter=10, output=None, tok2vec=None,\\n):\\n spacy.util.fix_random_seed(0)\\n with msg.loading(f\\\"Loading '{model}'...\\\"):\\n if model.startswith(\\\"blank:\\\"):\\n nlp = spacy.blank(model.replace(\\\"blank:\\\", \\\"\\\"))\\n else:\\n nlp = spacy.load(model)\\n msg.good(f\\\"Loaded model '{model}'\\\")\\n train_data, labels = format_data(srsly.read_jsonl(train_path))\\n eval_data, _ = format_data(srsly.read_jsonl(eval_path))\\n ner = nlp.create_pipe(\\\"ner\\\")\\n for label in labels:\\n ner.add_label(label)\\n nlp.add_pipe(ner)\\n t2v_cfg = {\\n \\\"embed_rows\\\": 10000,\\n \\\"token_vector_width\\\": 128,\\n \\\"conv_depth\\\": 8,\\n \\\"nr_feature_tokens\\\": 3,\\n }\\n optimizer = nlp.begin_training(component_cfg={\\\"ner\\\": t2v_cfg} if tok2vec else {})\\n if tok2vec:\\n _load_pretrained_tok2vec(nlp, Path(tok2vec))\\n batch_size = spacy.util.compounding(1.0, 16.0, 1.001)\\n best_acc = 0\\n best_model = None\\n row_widths = (2, 8, 8, 8, 8)\\n msg.row((\\\"#\\\", \\\"L\\\", \\\"P\\\", \\\"R\\\", \\\"F\\\"), widths=row_widths)\\n for i in range(n_iter):\\n random.shuffle(train_data)\\n losses = {}\\n data = tqdm.tqdm(train_data, leave=False)\\n for batch in spacy.util.minibatch(data, size=batch_size):\\n texts, annots = zip(*batch)\\n nlp.update(texts, annots, drop=0.2, losses=losses)\\n with nlp.use_params(optimizer.averages):\\n sc = nlp.evaluate(eval_data)\\n if sc.ents_f > best_acc:\\n best_acc = sc.ents_f\\n if output:\\n best_model = nlp.to_bytes()\\n acc = (f\\\"{sc.ents_p:.3f}\\\", f\\\"{sc.ents_r:.3f}\\\", f\\\"{sc.ents_f:.3f}\\\")\\n msg.row((i + 1, f\\\"{losses['ner']:.2f}\\\", *acc), widths=row_widths)\\n msg.text(f\\\"Best F-Score: {best_acc:.3f}\\\")\\n if output and best_model:\\n with msg.loading(\\\"Saving model...\\\"):\\n nlp.from_bytes(best_model).to_disk(output)\\n msg.good(\\\"Saved model\\\", output)\",\n \"def retrain_model(self, new_sentences, with_punctiations):\\n if with_punctiations:\\n model_ = Word2Vec.load('./model/model_word2vec.bin')\\n else:\\n model_ = Word2Vec.load('./model/model_no_punctuation_word2vec.bin')\\n\\n model_.build_vocab(new_sentences, update=True)\\n model_.train(new_sentences, total_examples=model_.corpus_count, epochs=model_.iter)\\n\\n if with_punctiations:\\n model_.save('./model/model_word2vec.bin')\\n else:\\n model_.save('./model/model_no_punctuation_word2vec.bin')\\n\\n\\n pass\",\n \"def train(pipetype, datapath):\\n with open(datapath, 'r') as f:\\n training_data = json.load(f)\\n docs = ['{0} {1}'.format(d['title'], d['text']) for d in training_data]\\n\\n if pipetype == 'bow':\\n vector.train(docs)\\n\\n if pipetype in ['stanford', 'spotlight', 'keyword']:\\n concept.train(docs, pipetype=pipetype)\",\n \"def train_model():\\n if (not request.json \\n or not 'data-format' in request.json\\n or not 'ML-model' in request.json\\n or not 'source-data-directory' in request.json\\n or not 'source-data-repo' in request.json):\\n abort(400)\\n\\n data_format = request.json['data-format']\\n ML_model = request.json['ML-model']\\n source_data_directory = request.json['source-data-directory']\\n source_data_repo = request.json['source-data-repo']\\n \\n start = time.time()\\n\\n do_train(model_name=ML_model, \\n repo_url=source_data_repo, \\n repo_data_directory=source_data_directory, \\n data_format=data_format)\\n \\n end = time.time()\\n\\n runningtime = (end - start)\\n\\n return f'Model {ML_model} trained using source data in directory {source_data_directory}, running time {runningtime} seconds', 201\",\n \"def train_pipeline(nlp: spacy.language.Language) -> None:\\n if TEXTCAT not in nlp.pipe_names:\\n textcat = nlp.create_pipe(TEXTCAT, config={\\\"exclusive_classes\\\": False})\\n nlp.add_pipe(textcat, last=True)\\n else:\\n textcat = nlp.get_pipe(TEXTCAT)\\n\\n for category in CATEGORIES:\\n textcat.add_label(category.value)\\n\\n pipe_exceptions = {TEXTCAT, \\\"trf_wordpiecer\\\", \\\"trf_tok2vec\\\"}\\n other_pipes = [pipe for pipe in nlp.pipe_names if pipe not in pipe_exceptions]\\n with nlp.disable_pipes(*other_pipes): # only train textcat\\n all_data = list(get_classification_training_data())\\n random.shuffle(all_data)\\n\\n training_data = all_data[: len(all_data) - 2]\\n validation_data = all_data[len(all_data) - 2 :]\\n\\n optimizer = nlp.begin_training()\\n for itn in range(20):\\n losses: Dict[str, Any] = {}\\n random.shuffle(training_data)\\n batches = minibatch(training_data, size=compounding(4.0, 32.0, 1.001))\\n\\n for batch in batches:\\n texts, annotations = zip(*batch)\\n nlp.update(texts, annotations, sgd=optimizer, drop=0.2, losses=losses)\",\n \"def train_spm_model(config:SentencePieceConfig):\\n spm.SentencePieceTrainer.train(str(config))\\n return config\",\n \"def train(self, training_data, model_name):\\n dataset = []\\n for example in training_data:\\n entity_offsets = self._convert_example(example)\\n dataset.append(self._from_json_to_crf(example, entity_offsets))\\n\\n features = [self._sentence_to_features(s) for s in dataset]\\n labels = [self._sentence_to_labels(s) for s in dataset]\\n trainer = sklearn_crfsuite.CRF(\\n algorithm=\\\"lbfgs\\\",\\n # coefficient for L1 penalty\\n c1=0.1,\\n # coefficient for L2 penalty\\n c2=0.1,\\n # stop earlier\\n max_iterations=50,\\n # include transitions that are possible, but not observed\\n all_possible_transitions=True,\\n )\\n trainer.fit(features, labels)\\n logger.info(\\\"Creating Model for Intent %s\\\",model_name)\\n joblib.dump(trainer, 'core/agent/model_files/%s.model' % model_name)\\n return True\",\n \"def do_train(train_texts, train_labels, dev_texts, dev_labels, lstm_shape, lstm_settings,\\n lstm_optimizer, batch_size=100,\\n do_fit1=True, epochs1=5, model1_path=None, config1_path=None,\\n do_fit2=False, epochs2=2, model2_path=None, config2_path=None,\\n epoch_path=None, lstm_type=1):\\n\\n print('do_train: train_texts=%s dev_texts=%s' % (dim(train_texts), dim(dev_texts)))\\n best_epoch_frozen, best_epoch_unfrozen = -1, -1\\n\\n n_train_sents = count_sentences(train_texts, batch_size, 'train')\\n X_train, y_train = make_sentences(lstm_shape['max_length'], batch_size,\\n train_texts, train_labels, 'train', n_train_sents)\\n validation_data = None\\n if dev_texts is not None:\\n n_dev_sents = count_sentences(dev_texts, batch_size, 'dev')\\n X_val, y_val = make_sentences(lstm_shape['max_length'], batch_size,\\n dev_texts, dev_labels, 'dev', n_dev_sents)\\n validation_data = (X_val, y_val)\\n sentence_cache.flush()\\n\\n print(\\\"Loading spaCy\\\")\\n nlp = sentence_cache._load_nlp()\\n embeddings = get_embeddings(nlp.vocab)\\n model = build_lstm[lstm_type](embeddings, lstm_shape, lstm_settings)\\n compile_lstm(model, lstm_settings['lr'])\\n\\n callback_list = None\\n\\n if do_fit1:\\n if validation_data is not None:\\n ra_val = RocAucEvaluation(validation_data=validation_data, interval=1, frozen=True,\\n model_path=model1_path, config_path=config1_path)\\n early = EarlyStopping(monitor='val_auc', mode='max', patience=2, verbose=1)\\n callback_list = [ra_val, early]\\n else:\\n sae = SaveAllEpochs(model1_path, config1_path, epoch_path, True)\\n if sae.last_epoch1() > 0:\\n xprint('Reloading partially built model 1')\\n get_embeds = partial(get_embeddings, vocab=nlp.vocab)\\n model = load_model(model1_path, config1_path, True, get_embeds)\\n compile_lstm(model, lstm_settings['lr'])\\n epochs1 -= sae.last_epoch1()\\n callback_list = [sae]\\n\\n if epochs1 > 0:\\n model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs1,\\n validation_data=validation_data, callbacks=callback_list, verbose=1)\\n if validation_data is not None:\\n best_epoch_frozen = ra_val.best_epoch\\n ra_val.best_epoch = -1\\n else:\\n save_model(model, model1_path, config1_path, True)\\n\\n if do_fit2:\\n # Reload the best model so far, if it exists\\n if os.path.exists(model1_path) and os.path.exists(config1_path):\\n model = load_model(model1_path, config1_path, True,\\n partial(get_embeddings, vocab=nlp.vocab))\\n xprint(\\\"Unfreezing\\\")\\n for layer in model.layers:\\n layer.trainable = True\\n compile_lstm(model, lstm_settings['lr'] / 10)\\n if validation_data is not None:\\n # Reset early stopping\\n ra_val = RocAucEvaluation(validation_data=validation_data, interval=1,\\n frozen=False, was_frozen=True,\\n get_embeddings=partial(get_embeddings, vocab=nlp.vocab),\\n do_prime=True, model_path=model1_path, config_path=config1_path)\\n early = EarlyStopping(monitor='val_auc', mode='max', patience=2, verbose=1)\\n callback_list = [ra_val, early]\\n else:\\n sae = SaveAllEpochs(model2_path, config2_path, epoch_path, False)\\n if sae.last_epoch2() > 0:\\n xprint('Reloading partially built model 2')\\n get_embeds = partial(get_embeddings, vocab=nlp.vocab)\\n model = load_model(model2_path, config2_path, False)\\n compile_lstm(model, lstm_settings['lr'])\\n epochs2 -= sae.last_epoch2()\\n callback_list = [sae]\\n\\n if epochs2 > 0:\\n model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs2,\\n validation_data=validation_data, callbacks=callback_list, verbose=1)\\n best_epoch_unfrozen = ra_val.best_epoch\\n if validation_data is None:\\n save_model(model, model2_path, config2_path, False)\\n\\n del nlp\\n return model, (best_epoch_frozen, best_epoch_unfrozen)\",\n \"def train_model_cross_validation(model, train_docs, test_docs, nb_iter, output_dir, spacy_type = True, nb_folds = 5):\\n\\n print(output_dir)\\n os.mkdir(output_dir) # creating the output directory\\n print(\\\" ============= TRAINING MODEL ===========================\\\")\\n\\n\\n # tuple conversion (the tuple type is lost when dataframe -> excel -> dataframe)\\n\\n #docs['annotations'] = [[tuple(ann) for ann in annotations] for annotations in docs['annotations'].to_numpy()]\\n\\n\\n # cross validation :\\n\\n models = []\\n all_scores = []\\n\\n kf = KFold(n_splits=nb_folds)\\n c = 0\\n for train_index, val_index in kf.split(train_docs):\\n\\n train_data = train_docs.iloc[train_index, :]\\n val_data = train_docs.iloc[val_index, :]\\n\\n # spacy_format\\n TRAIN_DATA = [(text, {'entities': entities}) for [text, entities] in train_data[['text', 'annotations']].to_numpy()]\\n\\n # trim entities : leading whitespace make the model bug\\n TRAIN_DATA = trim_entity_spans(TRAIN_DATA)\\n\\n # loading of the model\\n nlp = model\\n\\n optimizer = nlp.begin_training()\\n\\n # get names of other pipes to disable them during training\\n pipe_exceptions = [\\\"ner\\\" ] #\\\"trf_wordpiecer\\\", \\\"trf_tok2vec\\\"\\n other_pipes = [pipe for pipe in nlp.pipe_names if pipe not in pipe_exceptions]\\n\\n scores = []\\n\\n # training\\n with nlp.disable_pipes(*other_pipes): # only train NER\\n\\n if not spacy_type : # add the other labels\\n ner = nlp.get_pipe(\\\"ner\\\")\\n ner.add_label('AGE_RELATED')\\n ner.add_label('DURATION')\\n ner.add_label('FREQUENCY')\\n ner.add_label('OTHER')\\n\\n for i in range(nb_iter):\\n\\n print('Iteration ', i)\\n print()\\n losses = {}\\n random.shuffle(TRAIN_DATA) # ??\\n\\n path = ''\\n if spacy_type:\\n path = 'spacy_model_' + str(c) + '_fold'\\n else:\\n path = 'all_types_model_' + str(c) + '_fold'\\n\\n batches = minibatch(TRAIN_DATA, size=1) #compounding(4.0, 20.0, 1.001)\\n\\n for batch in batches:\\n texts, annotations = zip(*batch)\\n try:\\n nlp.update(texts, annotations, sgd = optimizer, drop=0.5, losses = losses)\\n print(\\\"Losses\\\", losses)\\n except Exception as e:\\n print(e)\\n #print(text)\\n\\n tp_g, fp_g, fn_g, p, r, f, pt, rt, ft, type_dict = test_model(test_docs, nlp)\\n scores += [(p, r, r, pt, rt, ft)]\\n print()\\n print()\\n\\n # test the trained model\\n test_model(val_data, nlp)\\n\\n df_scores = pd.DataFrame(scores, columns = ['span_precision', 'span_recall', 'span_f1', 'type_precision', 'type_recall', 'type_f1'])\\n df_scores.to_excel(output_dir + '/' + path + '.xlsx')\\n\\n\\n models += [nlp]\\n all_scores += [scores]\\n # save model to output directory\\n if output_dir is not None:\\n nlp.to_disk(output_dir + '/' + path)\\n print(\\\"Saved model to\\\", output_dir + '/' + path)\\n\\n c += 1\\n\\n return models, all_scores\",\n \"def load_model(self):\\n self._logger.debug(f\\\"Loading Spacy Data Model : {self._model}... Could take time.\\\")\\n self._nlp = spacy.load(self._model)\\n self._logger.debug(\\\"Successfully loaded Spacy Data !\\\")\\n\\n # === Load entities ===\\n if PIPE_ENTITY not in self._nlp.pipe_names:\\n self._nlp.add_pipe(PIPE_ENTITY, last=True)\\n\\n entity_pipe = self._nlp.get_pipe(PIPE_ENTITY)\\n for entity in self._entities:\\n entity_pipe.add_label(entity)\\n\\n # === Load categories ===\\n if PIPE_INTENT not in self._nlp.pipe_names:\\n self._nlp.add_pipe(PIPE_INTENT, last=True)\\n\\n intent_pipe = self._nlp.get_pipe(PIPE_INTENT)\\n for intent in self._intents:\\n intent_pipe.add_label(intent)\",\n \"def train(\\n model_path=\\\"./trained_model/\\\",\\n model_file_name=\\\"model.h5\\\",\\n training_data_path=\\\"./train.csv\\\",\\n):\\n config = SConfig(training_data_path=training_data_path)\\n s2s = Seq2Seq(config)\\n s2s.fit()\\n s2s.save_model(path_to_model=model_path, model_file_name=model_file_name)\",\n \"def main(model=None, output_dir=None, n_iter=10):\\n if model is not None:\\n nlp = spacy.load(model) # load existing spaCy model\\n print(\\\"Loaded model '%s'\\\" % model)\\n else:\\n nlp = spacy.blank('en') # create blank Language class\\n print(\\\"Created blank 'en' model\\\")\\n\\n # add the parser to the pipeline if it doesn't exist\\n # nlp.create_pipe works for built-ins that are registered with spaCy\\n if 'parser' not in nlp.pipe_names:\\n parser = nlp.create_pipe('parser')\\n nlp.add_pipe(parser, first=True)\\n # otherwise, get it, so we can add labels to it\\n else:\\n parser = nlp.get_pipe('parser')\\n\\n # add labels to the parser\\n for _, annotations in TRAIN_DATA:\\n for dep in annotations.get('deps', []):\\n parser.add_label(dep)\\n\\n # get names of other pipes to disable them during training\\n other_pipes = [pipe for pipe in nlp.pipe_names if pipe != 'parser']\\n with nlp.disable_pipes(*other_pipes): # only train parser\\n optimizer = nlp.begin_training()\\n for itn in range(n_iter):\\n random.shuffle(TRAIN_DATA)\\n losses = {}\\n for text, annotations in TRAIN_DATA:\\n nlp.update([text], [annotations], sgd=optimizer, losses=losses)\\n print(losses)\\n\\n # test the trained model\\n test_text = \\\"It was back in 2007 that hip-hop bible XXL launched its first ever Freshman Class, a list of ten up-and-coming artists poised to change the rap game for good. The last decade has seen more than a hundred stars spotlighted as part of the list and its accompanying annual cover feature, but this year features a history-making entry: Stefflon Don. The talented star has already built a strong reputation for herself in the UK; her unique blend of hard-hitting raps and smooth, dancehall beats has galvanized the scene, earning her critical acclaim and a series of impressive chart positions. Now, she seems ready to achieve the unthinkable: global stardom. Earlier this year, her infectious hit “Hurtin’ Me” – featuring former XXL Freshman French Montana – ascended the Billboard charts, peaking at no. 7 and confirming her US fanbase; but could she truly become the first artist to crack the US? And, more importantly, why has it taken so long for UK rappers to achieve Stateside success?\\\"\\n doc = nlp(test_text)\\n print('Dependencies', [(t.text, t.dep_, t.head.text) for t in doc])\\n sentence_spans = list(doc.sents)\\n displacy.serve(sentence_spans, style='dep')\\n\\n # save model to output directory\\n if output_dir is not None:\\n output_dir = Path(output_dir)\\n if not output_dir.exists():\\n output_dir.mkdir()\\n nlp.to_disk(output_dir)\\n print(\\\"Saved model to\\\", output_dir)\\n\\n # test the saved model\\n print(\\\"Loading from\\\", output_dir)\\n nlp2 = spacy.load(output_dir)\\n doc = nlp2(test_text)\\n print('Dependencies', [(t.text, t.dep_, t.head.text) for t in doc])\",\n \"def train():\\n \\n ## check for request data\\n if not request.json:\\n print(\\\"ERROR: API (train): did not receive request data\\\")\\n return jsonify(False)\\n\\n ## set the test flag\\n test = False\\n if 'mode' in request.json and request.json['mode'] == 'test':\\n test = True\\n\\n print(\\\"... training model\\\")\\n model = model_train(test=test)\\n print(\\\"... training complete\\\")\\n\\n return(jsonify(True))\",\n \"def train_model():\\n # Decode the request\\n data = request.data.decode(\\\"utf-8\\\")\\n\\n # Write data from the request in a local csv file\\n train_csv = \\\"train_local.csv\\\"\\n f = open(train_csv, \\\"w\\\", encoding=\\\"utf-8\\\")\\n f.write(data)\\n f.close()\\n\\n # Load the train csv file as a DataFrame\\n train_df = pd.read_csv(train_csv)\\n\\n # Train model\\n model.train_model(train_df)\\n\\n return jsonify({\\\"success\\\": \\\"The model was trained sucessfully\\\"})\",\n \"def main(model=None, output_dir=None, n_iter=20):\\n if model is not None:\\n nlp = spacy.load(model) # load existing spaCy model\\n print(\\\"Loaded model '%s'\\\" % model)\\n else:\\n nlp = spacy.blank('en') # create blank Language class\\n print(\\\"Created blank 'en' model\\\")\\n\\n # create the built-in pipeline components and add them to the pipeline\\n # nlp.create_pipe works for built-ins that are registered with spaCy\\n if 'ner' not in nlp.pipe_names:\\n ner = nlp.create_pipe('ner')\\n nlp.add_pipe(ner, last=True)\\n # otherwise, get it so we can add labels\\n else:\\n ner = nlp.get_pipe('ner')\\n\\n # add labels\\n for _, annotations in TRAIN_DATA:\\n for ent in annotations.get('entities'):\\n ner.add_label(str(ent[2]))\\n\\n # get names of other pipes to disable them during training\\n other_pipes = [pipe for pipe in nlp.pipe_names if pipe != 'ner']\\n with nlp.disable_pipes(*other_pipes): # only train NER\\n optimizer = nlp.begin_training()\\n for itn in range(n_iter):\\n random.shuffle(TRAIN_DATA)\\n losses = {}\\n for text, annotations in TRAIN_DATA:\\n nlp.update(\\n [text], # batch of texts\\n [annotations], # batch of annotations\\n drop=0.5, # dropout - make it harder to memorise data\\n sgd=optimizer, # callable to update weights\\n losses=losses)\\n print(losses)\\n \\n # test the trained model\\n for text, _ in TRAIN_DATA:\\n doc = nlp(text)\\n print('Entities', [(ent.text, ent.label_) for ent in doc.ents])\\n print('Tokens', [(t.text, t.ent_type_, t.ent_iob) for t in doc])\\n \\n # save model to output directory\\n if output_dir is not None:\\n print(output_dir)\\n output_dir = Path(output_dir)\\n if not output_dir.exists():\\n output_dir.mkdir()\\n nlp.to_disk(output_dir)\\n print(\\\"Saved model to\\\", output_dir)\\n\\n # test the saved model\\n print(\\\"Loading from\\\", output_dir)\\n nlp2 = spacy.load(output_dir)\\n for text, _ in TRAIN_DATA:\\n doc = nlp2(text)\\n print('Entities', [(ent.text, ent.label_) for ent in doc.ents])\\n print('Tokens', [(t.text, t.ent_type_, t.ent_iob) for t in doc])\",\n \"def train():\\n import training\\n\\n # Ensure output directories exist\\n os.makedirs(os.path.dirname(cfg.scaler_path), exist_ok=True)\\n os.makedirs(cfg.model_path, exist_ok=True)\\n os.makedirs(cfg.log_path, exist_ok=True)\\n\\n # Load (standardized) input data and target values\\n tr_x, tr_y, _ = _load_data(cfg.training_set, is_training=True)\\n val_x, val_y, _ = _load_data(cfg.validation_set)\\n\\n # Try to create reproducible results\\n np.random.seed(cfg.initial_seed)\\n\\n # Save free parameters to disk\\n utils.log_parameters(cfg.training, os.path.join(cfg.model_path,\\n 'parameters.json'))\\n\\n training.train(tr_x, tr_y, val_x, val_y)\",\n \"def train_on_device(data_dir, dataset_id, model_path, ckpt_path, weight_updates_path):\\r\\n\\r\\n # Store pre-trained model and weights\\r\\n old_model = load_model(model_path)\\r\\n old_model.load_weights(ckpt_path)\\r\\n\\r\\n # Initialize model and checkpoint, which are obtained from server\\r\\n device_model = load_model(model_path)\\r\\n device_model.load_weights(ckpt_path)\\r\\n\\r\\n # print(device_model.summary())\\r\\n\\r\\n # load the vocabulary\\r\\n vocab_filename = os.path.join(data_dir, \\\"vocab.txt\\\")\\r\\n vocab = load_doc(vocab_filename)\\r\\n vocab = vocab.split()\\r\\n vocab = set(vocab)\\r\\n\\r\\n # create the tokenizer\\r\\n tokenizer = Tokenizer()\\r\\n\\r\\n # loading tokenizer from file\\r\\n tokenizer_filename = os.path.join(data_dir, \\\"tokenizer.pickle\\\")\\r\\n with open(tokenizer_filename, \\\"rb\\\") as handle:\\r\\n tokenizer = pickle.load(handle)\\r\\n\\r\\n # Get training data present on device\\r\\n X_train, y_train = get_data(data_dir, dataset_id, vocab, tokenizer, is_train=True)\\r\\n\\r\\n X_test, y_test = get_data(data_dir, dataset_id, vocab, tokenizer, is_train=False)\\r\\n\\r\\n scores = device_model.evaluate(X_test, y_test, verbose=0)\\r\\n print(\\\"Test Accuracy(before training): %.2f%%\\\" % (scores[1] * 100))\\r\\n\\r\\n # Train model\\r\\n device_model.fit(\\r\\n X_train, y_train, epochs=NUM_EPOCHS, batch_size=BATCH_SIZE,\\r\\n )\\r\\n\\r\\n scores = device_model.evaluate(X_test, y_test, verbose=0)\\r\\n print(\\\"Test Accuracy(after training): %.2f%%\\\" % (scores[1] * 100))\\r\\n\\r\\n # Load model to store weight updates\\r\\n weight_updates = load_model(model_path)\\r\\n\\r\\n # Number of batches trained on device\\r\\n num_batches = X_train.shape[0] // BATCH_SIZE\\r\\n\\r\\n # Calculate weight updates\\r\\n for i in range(len(device_model.layers)):\\r\\n\\r\\n # Pre-trained weights\\r\\n old_layer_weights = old_model.layers[i].get_weights()\\r\\n\\r\\n # Post-trained weights\\r\\n new_layer_weights = device_model.layers[i].get_weights()\\r\\n\\r\\n # Weight updates calculation\\r\\n weight_updates.layers[i].set_weights(\\r\\n num_batches\\r\\n * (np.asarray(new_layer_weights) - np.asarray(old_layer_weights)),\\r\\n )\\r\\n\\r\\n # print(\\\"old weights: \\\", old_layer_weights)\\r\\n # print(\\\"new weights: \\\", new_layer_weights)\\r\\n # print(\\\"weight updates: \\\", weight_updates.layers[i].get_weights())\\r\\n\\r\\n # Save weight updates\\r\\n weight_updates.save_weights(weight_updates_path)\\r\\n\\r\\n return (num_batches, weight_updates_path)\",\n \"def train(\\n self,\\n training_data: TrainingData,\\n config: Optional[RasaNLUModelConfig] = None,\\n **kwargs: Any,\\n ) -> None:\\n pass\",\n \"def train(\\n self,\\n training_data: TrainingData,\\n config: Optional[RasaNLUModelConfig] = None,\\n **kwargs: Any,\\n ) -> None:\\n pass\",\n \"def train(self, data, beam_size=10, n_epochs=1, trunc_data=None):\\n print(\\\"Training syntactic parser:\\\")\\n for e in range(n_epochs):\\n print(\\\"Epoch:\\\", e+1, \\\"/\\\", n_epochs)\\n train_sentences_tags_trees = zip( get_sentences(data), \\\\\\n get_tags(data), \\\\\\n get_trees(data) )\\n for i, (words, gold_tags, gold_tree) in \\\\\\n enumerate(train_sentences_tags_trees):\\n self.parse(words, gold_tree, beam_size=beam_size)\\n print(\\\"\\\\rUpdated with sentence #{}\\\".format(i), end=\\\"\\\")\\n if trunc_data and i >= trunc_data:\\n break\\n print(\\\"\\\")\\n self.finalize()\",\n \"def train(self, data):\\n pass\",\n \"def train(cleaner, data_source, save_to=\\\"../models/model.pkl\\\"):\\n df = pd.read_csv(data_source)\\n df = df[pd.notnull(df['tags'])]\\n print(\\\"Start : Pre-cleaning process . . . \\\")\\n print(\\\" HTML decoding . . . done\\\")\\n print(\\\" lowercase text . . . done\\\")\\n print(\\\" replace [/(){}\\\\[\\\\]\\\\|@,;] symbols by space . . . done\\\")\\n print(\\\" remove remaining symbols . . . done\\\")\\n print(\\\" remove stopwords . . . done\\\")\\n df['post'] = df['post'].apply(cleaner)\\n print(\\\"End : Pre-cleaning process\\\")\\n x = df.post\\n y = df.tags\\n # no need for split data in final training stage\\n # X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state = 42)\\n print(\\\"Start : model creation process . . . \\\")\\n sgd = Pipeline([('vect', CountVectorizer()),\\n ('tfidf', TfidfTransformer()),\\n ('clf', SGDClassifier(loss='hinge', penalty='l2', alpha=1e-3, random_state=42, max_iter=5,\\n tol=None)),\\n ])\\n # sgd.fit(X_train, y_train)\\n sgd.fit(x, y)\\n print(\\\"End : model creation process\\\")\\n model = open(save_to, 'wb')\\n pickle.dump(sgd, model)\\n model.close()\\n print(\\\"Trained model saved to \\\" + save_to)\\n return sgd\",\n \"def train_nlp(model: ContinualModel, dataset: ContinualDataset,\\n args: Namespace) -> None:\\n model.net.to(model.device)\\n results, results_mask_classes = [], []\\n \\n model_stash = create_stash(model, args, dataset)\\n \\n if args.csv_log:\\n csv_logger = CsvLogger(dataset.SETTING, dataset.NAME, model.NAME)\\n if args.tensorboard:\\n tb_logger = TensorboardLogger(args, dataset.SETTING, model_stash)\\n model_stash['tensorboard_name'] = tb_logger.get_name()\\n \\n dataset_copy = get_dataset(args)\\n \\n for t in range(dataset.N_TASKS):\\n model.net.train()\\n _, _ = dataset_copy.get_data_loaders()\\n if model.NAME != 'icarl' and model.NAME != 'pnn':\\n # for forward transfer calculation\\n random_results_class, random_results_task = evaluate_nlp(model, dataset_copy)\\n \\n print(file=sys.stderr)\\n # start time\\n start_time = time.time()\\n for t in range(dataset.N_TASKS):\\n model.net.train()\\n train_loader, test_loader = dataset.get_data_loaders()\\n if hasattr(model, 'begin_task'):\\n model.begin_task(dataset)\\n if t:\\n accs = evaluate_nlp(model, dataset, last=True)\\n results[t - 1] = results[t - 1] + accs[0]\\n if dataset.SETTING == 'class-il':\\n results_mask_classes[t - 1] = results_mask_classes[t - 1] + accs[1]\\n for epoch in range(args.n_epochs):\\n for i, data in enumerate(train_loader):\\n if hasattr(dataset.train_loader.dataset, 'logits'):\\n # todo: to add logits\\n pass\\n else:\\n xs, ys, x_token_idxs, x_token_masks, y_token_idxs, y_token_masks, y_idxs = data\\n \\n x_token_idxs = x_token_idxs.to(model.device)\\n x_token_masks = x_token_masks.to(model.device)\\n y_token_idxs = y_token_idxs.to(model.device)\\n y_token_masks = y_token_masks.to(model.device)\\n y_idxs = y_idxs.to(model.device)\\n task_id = torch.tensor(t, dtype=torch.int64, requires_grad=False)\\n task_id = task_id.to(model.device)\\n \\n if model.require_task_id:\\n loss = model.observe(inputs=x_token_idxs, inputs_mask=x_token_masks, labels=y_idxs,\\n labels_name=y_token_idxs, labels_mask=y_token_masks, task_labels=task_id)\\n else:\\n loss = model.observe(inputs=x_token_idxs, inputs_mask=x_token_masks, labels=y_idxs,\\n labels_name=y_token_idxs, labels_mask=y_token_masks)\\n \\n progress_bar(i, len(train_loader), epoch, t, loss)\\n \\n if args.tensorboard:\\n tb_logger.log_loss(loss, args, epoch, t, i)\\n \\n model_stash['batch_idx'] = i + 1\\n model_stash['epoch_idx'] = epoch + 1\\n model_stash['batch_idx'] = 0\\n \\n model_stash['task_idx'] = t + 1\\n model_stash['epoch_idx'] = 0\\n \\n if hasattr(model, 'end_task'):\\n model.end_task(dataset)\\n \\n # reduce the running freq\\n # if (t+1) % args.eval_freq == 0:\\n accs = evaluate_nlp(model, dataset)\\n results.append(accs[0])\\n results_mask_classes.append(accs[1])\\n \\n mean_acc = np.mean(accs, axis=1)\\n print_mean_accuracy(mean_acc, t + 1, dataset.SETTING)\\n \\n # prob_model\\n if args.prob_all_tasks:\\n if args.prob_type != \\\"\\\":\\n for prob_l in range(12):\\n prob_l += 1\\n if args.prob_type == \\\"proto\\\":\\n p_accs = prob_proto_nlp(model, dataset, prob_l=prob_l)\\n else:\\n p_accs = prob_final_nlp(model, dataset, prob_l=prob_l)\\n p_mean_acc = np.mean(p_accs, axis=1)\\n print(\\\"task {} prob_l {}: mean_acc {}, masked_mean_acc {}\\\".format(t + 1,\\n prob_l,\\n round(p_mean_acc[0], 2),\\n round(p_mean_acc[1], 2)))\\n if args.csv_log:\\n csv_logger.log_task_prob(p_mean_acc, t)\\n \\n model_stash['mean_accs'].append(mean_acc)\\n if args.csv_log:\\n csv_logger.log(mean_acc)\\n if args.tensorboard:\\n tb_logger.log_accuracy(np.array(accs), mean_acc, args, t)\\n \\n running_time = time.time() - start_time\\n \\n # prob_model\\n if args.prob_type != \\\"\\\" and not args.prob_all_tasks:\\n for prob_l in range(12):\\n prob_l += 1\\n if args.prob_type == \\\"proto\\\":\\n accs = prob_proto_nlp(model, dataset, prob_l=prob_l)\\n else:\\n accs = prob_final_nlp(model, dataset, prob_l=prob_l)\\n mean_acc = np.mean(accs, axis=1)\\n print(\\\"prob_l {}: mean_acc {}, masked_mean_acc {}\\\".format(prob_l, mean_acc[0], mean_acc[1]))\\n if args.csv_log:\\n csv_logger.log_prob(mean_acc)\\n \\n if args.csv_log:\\n csv_logger.add_bwt(results, results_mask_classes)\\n csv_logger.add_running_time(running_time)\\n csv_logger.add_forgetting(results, results_mask_classes)\\n if model.NAME != 'icarl' and model.NAME != 'pnn':\\n csv_logger.add_fwt(results, random_results_class,\\n results_mask_classes, random_results_task)\\n \\n if args.tensorboard:\\n tb_logger.close()\\n if args.csv_log:\\n csv_logger.write(vars(args))\",\n \"def training(training_data, iterations):\\n nlp = spacy.blank('en') # create blank Language class\\n # create the built-in pipeline components and add them to the pipeline\\n # nlp.create_pipe works for built-ins that are registered with spaCy\\n if 'ner' not in nlp.pipe_names:\\n ner = nlp.create_pipe('ner')\\n nlp.add_pipe(ner, last=True)\\n\\n # add labels\\n for _, annotations in training_data:\\n for ent in annotations.get('entities'):\\n ner.add_label(ent[2])\\n\\n # get names of other pipes to disable them during training\\n other_pipes = [pipe for pipe in nlp.pipe_names if pipe != 'ner']\\n with nlp.disable_pipes(*other_pipes): # only train NER\\n optimizer = nlp.begin_training()\\n for itn in range(iterations):\\n print(\\\"Starting iteration \\\" + str(itn))\\n random.shuffle(TRAIN_DATA)\\n losses = {}\\n for text, annotations in training_data:\\n nlp.update(\\n [text], # batch of texts\\n [annotations], # batch of annotations\\n drop=0.2, # dropout - make it harder to memorise data\\n sgd=optimizer, # callable to update weights\\n losses=losses)\\n print(losses)\\n return nlp\",\n \"def train(self, train_data):\\n with open(train_data, 'r') as train_data:\\n while True:\\n tokens = train_data.readline().split()\\n pos = train_data.readline().split()\\n labels = train_data.readline().split()\\n if not tokens or not pos or not labels:\\n break\\n # Generate transition probabilities\\n for i in range(0, len(labels) - self.N_VALUE + 1):\\n self.add_label_sequence(labels[i:i + self.N_VALUE])\\n # Generate lexical generation probabilities\\n for i in range(0, len(tokens)):\\n token = tokens[i].lower()\\n label = labels[i]\\n self.add_word_tag(token, label)\\n self.handle_unknowns()\",\n \"def train(self, training_data: TrainingData, config: RasaNLUModelConfig, **kwargs: Any) -> None:\\n pass\",\n \"def train(sess, env, Xdata, ydata, X_valid=None, y_valid=None, epochs=1,\\n load=False, shuffle=True, batch_size=128, name='model'):\\n if load:\\n if not hasattr(env, 'saver'):\\n return print('\\\\nError: cannot find saver op')\\n print('\\\\nLoading saved model')\\n return env.saver.restore(sess, 'model/{}'.format(name))\\n\\n print('\\\\nTrain model')\\n n_sample = Xdata.shape[0]\\n n_batch = int((n_sample+batch_size-1) / batch_size)\\n for epoch in range(epochs):\\n print('\\\\nEpoch {0}/{1}'.format(epoch + 1, epochs))\\n\\n if shuffle:\\n print('\\\\nShuffling data')\\n ind = np.arange(n_sample)\\n np.random.shuffle(ind)\\n Xdata = Xdata[ind]\\n ydata = ydata[ind]\\n\\n for batch in range(n_batch):\\n print(' batch {0}/{1}'.format(batch + 1, n_batch), end='\\\\r')\\n begin = batch * batch_size\\n ending = min(n_sample, begin + batch_size)\\n sess.run(env.train_op, feed_dict={env.x: Xdata[begin:ending],\\n env.y: ydata[begin:ending],\\n env.training: True})\\n if X_valid is not None:\\n evaluate(sess, env, X_valid, y_valid)\\n\\n if hasattr(env, 'saver'):#在此处保存模型吧？\\n print('\\\\n Saving model')\\n os.makedirs('model', exist_ok=True)\\n env.saver.save(sess, 'model/{}'.format(name))\",\n \"def train(env, X_data, y_data, X_valid=None, y_valid=None, epochs=50,\\n learning_rate=0.1, load=False, shuffle=True, batch_size=1, name='model'):\\n if load:\\n if not hasattr(env, 'saver'):\\n print('\\\\nError: cannot find saver op')\\n return\\n print('\\\\nLoading saved model')\\n return env.saver.restore(env.sess, 'model/{}'.format(name))\\n print('\\\\nTrain model')\\n n_sample = X_data.shape[0]\\n n_batch = int((n_sample+batch_size-1) / batch_size)\\n for epoch in range(epochs):\\n print('\\\\nEpoch {0}/{1}'.format(epoch + 1, epochs))\\n\\n if (epochs == 30) | (epochs == 40) | (epochs == 50):\\n learning_rate = learning_rate * 0.1\\n\\n if shuffle:\\n print('\\\\nShuffling data')\\n ind = np.arange(n_sample)\\n np.random.shuffle(ind)\\n X_data = X_data[ind]\\n y_data = y_data[ind]\\n for batch in range(n_batch):\\n print(' batch {0}/{1}'.format(batch + 1, n_batch))\\n print('\\\\r')\\n start = batch * batch_size\\n end = min(n_sample, start + batch_size)\\n env.sess.run(env.train_op, feed_dict={env.x: X_data[start:end],\\n env.y: y_data[start:end],\\n env.training: True})\\n if X_valid is not None:\\n evaluate(env, X_valid, y_valid)\\n if hasattr(env, 'saver'):\\n print('\\\\n Saving model')\\n if not os.path.exists('model'):\\n os.mkdir('model')\\n env.saver.save(env.sess, 'model/{}'.format(name))\",\n \"def run(self) -> None:\\n self.model = self.trainer.train_model(self.model, self.data)\",\n \"def trainModel( self, featureTrain, classTrain):\",\n \"def train(self, training_data):\\n pass\",\n \"def _train(args, pretrain_args):\\n start_time = time.time()\\n print('Training', ', '.join(args.speakers), '...')\\n\\n # randomly sample validation set monte_carlo_cv_num times\\n for num in range(args.monte_carlo_cv_num):\\n # get seed used to sub-sample validation dataset (use 42 for 1st run)\\n seed = utils.get_seed(num)\\n\\n # get train/valid/test data and convert to sequences\\n train_data, valid_data, test_data, id_to_word = data_reader.get_data(\\n args, seed=seed)\\n # set configurations/hyperparameters for model\\n config, test_config = utils.set_config(args, id_to_word)\\n\\n # initialize word embeddings\\n init_embed = utils.init_embedding(id_to_word, dim=args.embed_size,\\n init_scale=args.init_scale,\\n embed_path=args.embed_path)\\n\\n with tf.Graph().as_default():\\n # initializer used to initialize TensorFlow variables\\n initializer = tf.random_uniform_initializer(-config['init_scale'],\\n config['init_scale'])\\n # create Train model\\n with tf.name_scope('Train'):\\n with tf.variable_scope('Model', reuse=None,\\n initializer=initializer):\\n m_train = model.Model(args, is_training=True, config=config,\\n init_embed=init_embed, name='Train')\\n m_train.build_graph()\\n\\n # create Valid model\\n with tf.name_scope('Valid'):\\n with tf.variable_scope('Model', reuse=True,\\n initializer=initializer):\\n m_valid = model.Model(args, is_training=False, config=config,\\n init_embed=init_embed, name='Valid')\\n m_valid.build_graph()\\n\\n # create Test model\\n with tf.name_scope('Test'):\\n with tf.variable_scope('Model', reuse=True,\\n initializer=initializer):\\n m_test = model.Model(args, is_training=False, config=test_config,\\n init_embed=init_embed, name='Test')\\n m_test.build_graph()\\n\\n # create summaries to be viewed in TensorBoard\\n tb_summaries = utils.TensorBoardSummaries()\\n tb_summaries.create_ops()\\n\\n init = tf.global_variables_initializer()\\n\\n # if pretrained, must create dict to initialize TF Saver\\n if bool(pretrain_args):\\n # get trainable variables and convert to dict for Saver\\n reuse_vars = tf.get_collection(\\n tf.GraphKeys.TRAINABLE_VARIABLES)\\n reuse_vars_dict = dict(\\n [(var.op.name, var) for var in reuse_vars])\\n # create saver for TF session (see function for addl details)\\n saver = utils.create_tf_saver(args, pretrain_args,\\n reuse_vars_dict)\\n else:\\n saver = tf.train.Saver()\\n\\n # ppls dict has perplexities that are stored in results database\\n ppls = {}\\n ppls, _ = _update_ppls(ppls, initialize=True)\\n\\n with tf.Session() as sess:\\n sess.run(init)\\n\\n if args.load_path != '':\\n print('Restoring model...')\\n saver.restore(sess, args.load_path)\\n\\n for epoch in range(config['max_epoch']):\\n print('Epoch: {0} Learning rate: {1:.3f}\\\\n'.format(\\n epoch + 1, sess.run(m_train.lr)))\\n for i, speaker in enumerate(args.speakers):\\n print('Training {0} ...'.format(speaker))\\n\\n # run epoch on training data\\n train_perplexity = _run_epoch(sess, m_train, args, train_data,\\n i, tb_summaries, id_to_word,\\n train_op=m_train.train_op,\\n verbose=True)\\n print('Epoch: {0} Train Perplexity: {1:.3f}'.format(\\n epoch + 1, train_perplexity))\\n ppls, _ = _update_ppls(ppls, epoch=epoch+1,\\n speaker=speaker,\\n ppl=train_perplexity,\\n dataset='train')\\n\\n print('Validating...')\\n # run epoch on validation data\\n valid_perplexity = _run_epoch(sess, m_valid, args,\\n valid_data, i, tb_summaries,\\n id_to_word, verbose=True)\\n print('Epoch: {0} Valid Perplexity: {1:.3f}'.format(\\n epoch + 1, valid_perplexity))\\n ppls, improved = _update_ppls(ppls, epoch=epoch+1,\\n speaker=speaker,\\n ppl=valid_perplexity,\\n dataset='valid')\\n\\n if improved:\\n # save model if valid ppl is lower than current\\n # best valid ppl\\n if args.save_path != '':\\n print('Saving model to {0}.'.format(\\n args.save_path))\\n saver.save(sess, args.save_path)\\n\\n for i, speaker in enumerate(args.speakers):\\n print('Testing {0} ...'.format(speaker))\\n print('Restoring best model for testing...')\\n saver.restore(sess, args.save_path)\\n # run model on test data\\n test_perplexity = _run_epoch(sess, m_test, args, test_data, i)\\n ppls['test_ppl_' + speaker] = test_perplexity\\n print('Test Perplexity: {0:.3f}'.format(test_perplexity))\\n\\n if args.insert_db == 'True':\\n # write params/config/results to sql database\\n results_db.insert_results(args, config, start_time, ppls)\",\n \"def trainModel(data, labels, vData, vLabels, logger, params):\\n\\t#save the random seed\\n\\tlogger.logSeed()\\n\\n\\t#create the model\\n\\tif params.emb:\\n\\t\\t\\n\\t\\tif params.useBothHalves:\\n\\t\\t\\tmodel = buildMultiEmbModel(params.numClasses(), params.windowSize, params.contextSize, params.wordWeights, params.eventMap)\\n\\t\\telse:\\n\\t\\t\\tmodel = buildCNNEmbModel(params.numClasses(), params.windowSize, params.contextSize, params.wordWeights, params.eventMap)\\n\\n\\telif params.split:\\n\\t\\tmodel = buildSplitModel(params.numClasses(), params.windowSize, params.wordSize, params.contextSize, params.eventMap)\\n\\t\\t#model = buildAttentionModel(params.numClasses(), params.windowSize, params.wordSize, params.contextSize, params.eventMap)\\n\\telse:\\n\\t\\tmodel = buildModel(params.numClasses(), params.windowSize, params.wordSize, params.contextSize, params.eventMap)\\n\\n\\t#fit the model\\n\\tmodel.fit(data, labels, nb_epoch=params.epochs, batch_size=params.batchSize, \\n\\t\\tvalidation_data=(vData, vLabels), \\n\\t\\tcallbacks=[logger], class_weight=params.weights)\\n\\n\\tbest = logger.best()\\n\\n\\tprint(\\\"Best Model round: {} val: {}\\\".format(logger.bestModel, logger.bestScore))\\n\\n\\t#return the best\\n\\treturn best, logger.bestModel\",\n \"def test_pyt_preprocess_train(self):\\n # Second, check that the model will train\\n defaults = parser_defaults.copy()\\n defaults['datatype'] = 'train'\\n defaults['pytorch_preprocess'] = True\\n str_output, _, _ = testing_utils.train_model(defaults)\\n self.assertTrue(\\n solved_task(str_output),\\n 'Teacher could not teach seq2seq with preprocessed obs, output: {}'\\n .format(str_output)\\n )\",\n \"def main():\\n # Read data for train set\\n print('loading training data')\\n train = read_datafile('../data/tsd_train.csv')\\n\\n # Read trial data for validation set\\n validation = read_datafile('../data/tsd_trial.csv')\\n\\n # Read data for test set\\n print('loading test data')\\n test = read_datafile('../data/tsd_test.csv')\\n\\n # Convert training data to Spacy Entities\\n nlp = spacy.load(\\\"en_core_web_sm\\\")\\n print('preparing training data')\\n training_data = []\\n for n, (spans, text) in enumerate(train):\\n doc = nlp(text)\\n ents = spans_to_ents(doc, set(spans), 'TOXIC')\\n training_data.append((doc.text, {'entities': ents}))\\n\\n toxic_tagging = spacy.blank('en')\\n toxic_tagging.vocab.strings.add('TOXIC')\\n ner = nlp.create_pipe(\\\"ner\\\")\\n toxic_tagging.add_pipe(ner, last=True)\\n ner.add_label('TOXIC')\\n\\n pipe_exceptions = [\\\"ner\\\", \\\"trf_wordpiecer\\\", \\\"trf_tok2vec\\\"]\\n unaffected_pipes = [\\n pipe for pipe in toxic_tagging.pipe_names\\n if pipe not in pipe_exceptions]\\n\\n\\n print('Training!')\\n with toxic_tagging.disable_pipes(*unaffected_pipes):\\n \\n toxic_tagging.begin_training()\\n for iteration in range(30):\\n random.shuffle(training_data)\\n losses = {}\\n batches = spacy.util.minibatch(\\n training_data, size=spacy.util.compounding(\\n 4.0, 32.0, 1.001))\\n for batch in batches:\\n texts, annotations = zip(*batch)\\n toxic_tagging.update(texts, annotations, drop=0.5, losses=losses)\\n print(\\\"Losses\\\", losses)\\n\\n\\n # Define helper function for evaluating datasets\\n def evaluate(dateset):\\n precision_recall_f1_scores = []\\n for spans, text in dateset:\\n pred_spans = []\\n doc = toxic_tagging(text)\\n for ent in doc.ents:\\n pred_spans.extend(range(ent.start_char, ent.start_char + len(ent.text)))\\n \\n # score = semeval2021.f1(pred_spans, spans)\\n precision_recall_f1_scores.append(per_post_precision_recall_f1(pred_spans, spans))\\n\\n # compute average precision, recall and f1 score of all posts\\n return np.array(precision_recall_f1_scores).mean(axis=0)\\n\\n # Evaluate on dev and test sets\\n print('Evaluation:')\\n eval_precision, eval_recall, eval_f1 = evaluate(validation)\\n test_precision, test_recall, test_f1 = evaluate(test)\\n \\n print(f'Dev set: Precision = {eval_precision}, Recall = {eval_recall}, F1 = {eval_f1}')\\n print(f'Test set: Precision = {test_precision}, Recall = {test_recall}, F1 = {test_f1}')\",\n \"def train(model, timeseries, indices, words, args):\\n top = len(timeseries)-args.window_size-args.batch_size-int(len(timeseries)*0.05)\\n print(\\\"--- Model Version: {} ---\\\".format(name))\\n print(\\\"Number of words in training set: {}\\\".format(top))\\n model.fit_generator(generator(timeseries, indices, words, args, 1, top), steps_per_epoch=args.epoch_steps, epochs=args.nb_epoch, validation_data=generator(timeseries, indices, words, args, top, len(timeseries)-args.window_size-args.batch_size), validation_steps=args.val_steps, callbacks=[lr_reducer, checkpointer], shuffle=True)\",\n \"def train(net, train_data,\\n dev_data_filepath, dev_preds_filepath, model_save_path,\\n para_selector, # TODO sort these nicely\\n ps_threshold=0.1,\\n ner_device=torch.device('cpu'), training_device=torch.device('cpu'),\\n text_length=250,\\n fb_passes=1, coefs=(0.5, 0.5),\\n epochs=3, batch_size=1, learning_rate=1e-4,\\n eval_interval=None, verbose_evaluation=False, timed=False):\\n timer = utils.Timer()\\n\\n tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\\n\\n flair.device = torch.device(ner_device)\\n ner_tagger = flair.models.SequenceTagger.load('ner') # this hard-codes flair tagging!\\n\\n optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)\\n\\n losses = []\\n real_batch_sizes = [] # some data points are not usable; this logs the real sizes\\n graph_logging = [0, 0, 0] # [total nodes, total connections, number of graphs]\\n point_usage = [0, 0] # [used points, unused points]\\n dev_scores = []\\n\\n # Set the network into train mode\\n net.train()\\n net = net.to(training_device)\\n\\n timer(\\\"training_preparation\\\")\\n\\n print(\\\"Training...\\\")\\n\\n best_score = 0\\n eval_interval = eval_interval if eval_interval else float('inf') # interval in batches\\n a_model_was_saved_at_some_point = False\\n\\n for epoch in range(epochs):\\n # TODO take recurrent times for forward, evaluation saving etc.\\n print('Epoch %d/%d' % (epoch + 1, epochs))\\n batch_counter = 0\\n\\n for step, batch in enumerate(tqdm(train_data, desc=\\\"Iteration\\\")):\\n\\n \\\"\\\"\\\" DATA PROCESSING \\\"\\\"\\\"\\n ids = []\\n queries = []\\n contexts = []\\n graphs = []\\n\\n useless_datapoint_inds = []\\n\\n for i, point in enumerate(batch):\\n\\n # make a list[ list[str, list[str]] ] for each point in the batch\\n context = para_selector.make_context(point,\\n threshold=ps_threshold,\\n context_length=text_length) # TODO add device and numerated arguments\\n graph = EntityGraph.EntityGraph(context,\\n context_length=text_length,\\n tagger=ner_tagger)\\n if graph.graph:\\n ids.append(point[0])\\n queries.append(point[2])\\n contexts.append(context)\\n graphs.append(graph)\\n graph_logging = [a+b # [total nodes, total connections, number of graphs]\\n for a,b in zip(graph_logging, [len(graph.graph),\\n len(graph.relation_triplets()),\\n 1])]\\n point_usage[0] += 1\\n else: # if the NER in EntityGraph doesn't find entities, the datapoint is useless.\\n useless_datapoint_inds.append(i)\\n point_usage[1] += 1\\n\\n batch = [point for point in batch if point[0] in ids] # update the batch to exclude useless data points\\n\\n real_batch_sizes.append(batch_size - len(useless_datapoint_inds)) #TODO track the batch sizes!\\n\\n # if our batch is completely useless, just continue with the next batch. :(\\n if len(useless_datapoint_inds) == batch_size:\\n continue\\n\\n # turn the texts into tensors in order to put them on the GPU\\n qc_ids = [net.encoder.token_ids(q, c) for q, c in zip(queries, contexts)] # list[ (list[int], list[int]) ]\\n q_ids, c_ids = list(zip(*qc_ids)) # tuple(list[int]), tuple(list[int])\\n q_ids_list = [torch.tensor(q) for q in q_ids] # list[Tensor] #TODO? maybe put this into forward()?\\n c_ids_list = [torch.tensor(c) for c in c_ids] # list[Tensor]\\n\\n \\\"\\\"\\\" MAKE TRAINING LABELS \\\"\\\"\\\"\\n # replace the paragraphs in raw_point with their shortened versions (obtained from PS)\\n for (i, p), c in zip(enumerate(batch), contexts):\\n batch[i][3] = c\\n\\n # TODO? change utils.make_labeled_data_for_predictor() to process batches of data?\\n labels = [utils.make_labeled_data_for_predictor(g,p,tokenizer) for g,p in zip(graphs, batch)] # list[(support, start, end, type)]\\n # list[(Tensor, Tensor, Tensor, Tensor)] -> tuple(Tensor), tuple(Tensor), tuple(Tensor), tuple(Tensor)\\n sup_labels, start_labels, end_labels, type_labels = list(zip(*labels))\\n # print(f\\\"in train_dfgn.train(): shapes of labels:\\\\n{len(sup_labels)}, {len(start_labels)}, {len(end_labels)}, {len(type_labels)}\\\") #CLEANUP\\n\\n q_ids_list = [t.to(training_device) if t is not None else None for t in q_ids_list]\\n c_ids_list = [t.to(training_device) if t is not None else None for t in c_ids_list]\\n for i, g in enumerate(graphs):\\n graphs[i].M = g.M.to(training_device) # work with enumerate to actually mutate the graph objects\\n\\n sup_labels = torch.stack(sup_labels).to(training_device) # (batch, M)\\n start_labels = torch.stack(start_labels).to(training_device) # (batch, 1)\\n end_labels = torch.stack(end_labels).to(training_device) # (batch, 1)\\n type_labels = torch.stack(type_labels).to(training_device) # (batch)\\n\\n \\\"\\\"\\\" FORWARD PASSES \\\"\\\"\\\"\\n optimizer.zero_grad()\\n\\n sups, starts, ends, types = [], [], [], []\\n for query, context, graph in zip(q_ids_list, c_ids_list, graphs): # 'graph' is not a tensor -> for-loop instead of batch processing\\n\\n o_sup, o_start, o_end, o_type = net(query, context, graph, fb_passes=fb_passes) # (M, 2), (M), (M), (1, 3)\\n sups.append(o_sup)\\n starts.append(o_start)\\n ends.append(o_end)\\n types.append(o_type)\\n\\n sups = torch.stack(sups) # (batch, M, 2)\\n starts = torch.stack(starts) # (batch, 1, M)\\n ends = torch.stack(ends) # (batch, 1, M)\\n types = torch.stack(types) # (batch, 1, 3)\\n\\n \\\"\\\"\\\" LOSSES & BACKPROP \\\"\\\"\\\"\\n weights = torch.ones(2, device=training_device) #TODO maybe extract this to a tiny function?\\n sup_label_batch = sup_labels.view(-1)\\n weights[0] = sum(sup_label_batch)/float(sup_label_batch.shape[0])\\n weights[1] -= weights[0] # assign the opposite weight\\n\\n sup_criterion = torch.nn.CrossEntropyLoss(weight=weights)\\n criterion = torch.nn.CrossEntropyLoss() # for prediction of answer type\\n\\n # use .view(-1,...) to put points together (this is like summing the points' losses)\\n sup_loss = sup_criterion(sups.view(-1,2), sup_label_batch) # (batch*M, 2), (batch*M)\\n start_loss = sum([criterion(starts[i], start_labels[i]) for i in range(start_labels.shape[0])]) # batch * ( (1, M, 1), (1) )\\n end_loss = sum([criterion(ends[i], end_labels[i]) for i in range(end_labels.shape[0])]) # batch * ( (1, M, 1), (1) )\\n type_loss = criterion(types.view(-1,3), type_labels.view(-1)) # (batch, 1, 3), (batch, 1)\\n\\n # This doesn't have the weak supervision BFS mask stuff from section 3.5 of the paper\\n # TODO? maybe start training with start/end loss only first, then train another model on all 4 losses?\\n loss = start_loss + end_loss + coefs[0]*sup_loss + coefs[1]*type_loss # formula 15\\n\\n loss.backward(retain_graph=True)\\n losses.append( (loss.item(),\\n sup_loss.item(),\\n start_loss.item(),\\n end_loss.item(),\\n type_loss.item())) # for logging purposes\\n\\n batch_counter += 1\\n # Evaluate on validation set after some iterations\\n if batch_counter % eval_interval == 0:\\n\\n # this calls the official evaluation script (altered to return metrics)\\n metrics = evaluate(net, #TODO make this prettier\\n tokenizer, ner_tagger,\\n training_device, dev_data_filepath, dev_preds_filepath,\\n fb_passes = fb_passes,\\n text_length = text_length,\\n verbose=verbose_evaluation)\\n score = metrics[\\\"joint_f1\\\"]\\n dev_scores.append(metrics) # appends the whole dict of metrics\\n if score >= best_score:\\n print(f\\\"Better eval found with accuracy {round(score, 3)} (+{round(score - best_score, 3)})\\\")\\n best_score = score\\n\\n torch.save(net, model_save_path) #TODO make sure that this works (maybe, should we save each of the 3 parts indvidually?)\\n a_model_was_saved_at_some_point = True\\n else:\\n print(f\\\"No improvement yet...\\\")\\n timer(f\\\"training_evaluation_{batch_counter/eval_interval}\\\")\\n\\n optimizer.step()\\n timer(f\\\"training_epoch_{epoch}\\\")\\n\\n #========= END OF TRAINING =============#\\n metrics = evaluate(net, # TODO make this prettier\\n tokenizer, ner_tagger,\\n training_device, dev_data_filepath, dev_preds_filepath,\\n fb_passes=fb_passes,\\n text_length=text_length,\\n verbose=verbose_evaluation)\\n score = metrics[\\\"joint_f1\\\"]\\n dev_scores.append(metrics) # appends the whole dict of metrics\\n if score >= best_score:\\n torch.save(net,\\n model_save_path)\\n\\n if not a_model_was_saved_at_some_point: # make sure that there is a model file\\n print(f\\\"saving model to {model_save_path}...\\\")\\n torch.save(net, model_save_path)\\n\\n losses_with_batchsizes = [(b, t[0], t[1], t[2], t[3], t[4]) for b,t in zip(real_batch_sizes, losses)]\\n\\n if timed:\\n return losses_with_batchsizes, dev_scores, graph_logging, point_usage, timer\\n else:\\n return losses_with_batchsizes, dev_scores, graph_logging, point_usage\",\n \"def train(self, dataset, model_dir):\\n raise NotImplementedError\",\n \"def preprocess_sentences(train, val, test):\\r\\n tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True)\\r\\n\\r\\n train_data = convert_examples_to_features(train, tokenizer, pad_token_label_id=pad_id)\\r\\n val_data = convert_examples_to_features(val, tokenizer, pad_token_label_id=pad_id)\\r\\n test_data = convert_examples_to_features(test, tokenizer, pad_token_label_id=pad_id)\\r\\n\\r\\n train_dataloader = create_dataloader(train_data)\\r\\n val_dataloader = create_dataloader(val_data)\\r\\n test_dataloader = create_dataloader(test_data)\\r\\n\\r\\n return train_dataloader, val_dataloader, test_dataloader\",\n \"def construct_NLP_model(self, df=None):\\n import review_processing as rp\\n # get words\\n if df is not None:\\n nitems = df.shape[0]\\n col_names = df.columns.values\\n if self.review_col_name not in col_names or \\\\\\n self.sentiment_col_name not in col_names:\\n sys.exit('construct_NL_model: The name {0}/{1} cannot be found'.\\n format(self.review_col_name, self.sentiment_col_name))\\n review_list = df[self.review_col_name].values.tolist()\\n meaningful_words = map(self.review_to_meaningful_words,\\n review_list)\\n # Get training sentiment values\\n self.sentiment = df[self.sentiment_col_name].values\\n\\n else:\\n if self.training_file_name is None:\\n sys.exit('construct_NLP_model: traning file name does not '\\n 'exist')\\n else:\\n suffix = os.path.splitext(self.training_file_name)[1][1:]\\n if suffix == 'csv':\\n df = pd.read_csv(self.training_file_name)\\n if self.review_col_name not in col_names or \\\\\\n self.sentiment_col_name not in col_names::\\n sys.exit('construct_NL_model: The name {0}/{1} cannot '\\n ' be found'.format(self.review_col_name,\\n self.sentiment_col_name))\\n nitems = df.shape[0]\\n review_list = df[review_col_name].values.tolist()\\n meaningful_words = map(self.review_to_meaningful_words,\\n review_list)\\n elif suffix == 'json':\\n data_dict_list = rp.load_data(self.training_file_name)\\n if self.review_col_name not in data_dict_list.keys():\\n sys.exit('construct_NL_model: The name {0} cannot be '\\n 'found'.format(review_col_name))\\n review_list = map(lambda x: x[review_col_name],\\n data_dict_list)\\n meaningful_words = map(self.review_to_meaningful_words,\\n review_list)\\n else:\\n sys.exit('construct_NLP_model: file type not supported '\\n 'yet!')\\n\\n # Training process of Bag of Worlds\\n if self.NLP_model == 'BagofWords':\\n print('construct_NLP_model: Creating bag of words...')\\n self.vectorizer = CountVectorizer(analyzer='word',\\n tokenizer=None,\\n preprocessor=None,\\n stop_words=None,\\n max_features=self.maxfeature)\\n self.train_data_features = vectorizer.fit_transform(\\n meaningful_words)\\n self.train_data_features = train_data_features.toarray()\\n\\n # vocab = vectorizer.get_feature_names()\\n # dist = np.sum(train_data_features, axis=0)\\n # for tag, count in zip(vocab, dist):\\n # print(count, tag)\\n\\n else:\\n sys.exit('construct_NLP_model: NLP_model type not supported yet!')\",\n \"def train(self, training_data, chunk_size=100):\\n # For some reason, for the SVM to work, the keys need to be in alphabetical order\\n training_data = {k : training_data[k] for k in sorted(training_data)}\\n\\n # Compile all author texts into one large text to then be broken down\\n for auth in training_data:\\n training_data[auth] = '\\\\n\\\\n'.join(training_data[auth])\\n\\n self.auths = list(training_data.keys())\\n self.chunk_size = chunk_size\\n\\n # Creates two lists, one of the texts and one of the corresponding author labels.\\n labels = []\\n texts = []\\n for auth in training_data:\\n lines = training_data[auth].split('\\\\n')\\n for p in range( chunk_size, len(lines), chunk_size ):\\n labels.append(auth) # authors per text in the training corpus\\n texts.append('\\\\n'.join(lines[p-chunk_size : p])) # texts in the training corpus\\n labels = array(labels)\\n texts = array(texts)\\n\\n # Cleans the texts\\n for i in range(len(texts)):\\n texts[i] = self._clean(texts[i])\\n\\n # Generates the profiles from these tests\\n profiles = zeros((len(texts), len(self.alph)**self.N))\\n for i in range(len(texts)):\\n profiles[i] = self._profile(texts[i])\\n\\n\\n # Reduces the features and fits the model\\n self.train_data = [profiles, labels]\\n self._reduceFeatures()\\n\\n self.model = SVC(kernel='linear')\\n self.model.probability = True\\n self.model.fit(self.train_data[0], self.train_data[1])\",\n \"def _preprocess_training_model(self, data):\\n def _pre_process(raw_data):\\n \\\"\\\"\\\" Pre-process raw data. \\\"\\\"\\\"\\n pattern = re.compile(\\n r\\\"((?<=')\\\\w\\\\d.*?(?=')|(?<=\\\\\\\")\\\\w\\\\d.*?(?=\\\\\\\")|[\\\\w\\\\d]+)\\\")\\n words = re.findall(pattern, raw_data)\\n return ' '.join(list(map(string_utils.snake_case_to_camel, words)))\\n\\n data_list = []\\n # Preprocess the dataset with naming convention, etc.\\n with Progress() as progress:\\n preprocess_task = progress.add_task('Pre-processing dataset...',\\n total=data.shape[0])\\n for idx, row in data.iterrows():\\n row_data = {}\\n for column in ['text', 'key', 'value']:\\n row_data[column] = _pre_process(row[column])\\n data_list.append(row_data)\\n progress.update(preprocess_task, advance=1)\\n return pd.DataFrame(data=data_list)\",\n \"def training(train_data, dev_data, param):\\n text_to_vec = TextToVec(**param)\\n\\n # Fit with both train and dev data\\n text_to_vec.fit(train_data['data'] + dev_data['data'])\\n word_vec_map = text_to_vec.vectorizer.get_feature_names()\\n train_vec = text_to_vec.transform(train_data['data'])\\n dev_vec = text_to_vec.transform(dev_data['data'])\\n logger.info(f\\\"train vec size:{train_vec.shape}, dev vec size:{dev_vec.shape}\\\")\\n\\n # # apply weights on tfidf based on whether the word appear in multiple classes\\n # tt_occ = Counter(train_data['encoded_label'])\\n # weight_list = []\\n # for i in range(train_vec.shape[1]): # For every feature\\n # occ = Counter(train_data['encoded_label'][train_vec[:, i] > 0.0])\\n # for key, value in occ.items():\\n # occ[key] = value/tt_occ[key]\\n # weight_list.append(np.std(list(occ.values()))/0.35)\\n # weight = np.array(weight_list).reshape(1, -1)\\n # weight = weight/np.max(weight)\\n # train_vec = np.multiply(train_vec, weight)\\n\\n # Perform oversampling on training data\\n if param['balanced'] not in ['Bootstrap', 'Handsample']:\\n logger.info(f\\\"class info before resampling: {sorted(Counter(train_data['encoded_label']).items())}\\\")\\n train_vec, train_data['encoded_label'] = resample(X_train=train_vec, y_train=train_data['encoded_label'], balance=param['balanced'])\\n logger.info(f\\\"class info after resampling:{sorted(Counter(train_data['encoded_label']).items())}\\\")\\n\\n # Fit model\\n if param['classifier'] == 'MultinomialNB':\\n clf = MultinomialNB()\\n elif param['classifier'] == 'LDA':\\n clf = LinearDiscriminantAnalysis()\\n else:\\n clf = svm.LinearSVC()\\n\\n if param['multiclass'] == 'OnevsOne':\\n model = OneVsOneClassifier(clf)\\n else:\\n model = OneVsRestClassifier(clf)\\n\\n if param['classifier'] == 'LinearSVM' or param['multiclass'] == 'OnevsOne':\\n logger.info(f'Fitting model: {param}')\\n model = model.fit(train_vec, train_data['encoded_label'])\\n train_prediction = model.predict(train_vec)\\n dev_prediction = model.predict(dev_vec)\\n else:\\n logger.info(f'Fitting model: {param}')\\n model = model.fit(train_vec, train_data['binary_label'])\\n train_prediction = np.argmax(model.predict(train_vec), axis=1)\\n dev_prediction = np.argmax(model.predict(dev_vec), axis=1)\\n\\n\\n return train_prediction, dev_prediction, train_vec.shape, dev_vec.shape, model, word_vec_map\",\n \"def _train(cls, ds):\\n\\n tf = TfidfVectorizer(analyzer='word',\\n ngram_range=(1, 3),\\n min_df=0,\\n stop_words='english')\\n tfidf_matrix = tf.fit_transform(ds['description'])\\n with open('ds.pickle', 'wb') as fp:\\n pickle.dump(ds, fp)\\n\\n with open('tfidf_matrix.pickle', 'wb') as fp:\\n pickle.dump(tfidf_matrix, fp)\\n\\n with open('tf_model.pickle', 'wb') as fp:\\n pickle.dump(tf, fp)\",\n \"def train(self):\\n\\t\\tself.model.fit(self.training_data, self.training_labels)\",\n \"def preproc_doc(document):\\n\\n # Each document is a list of lines\\n tokenizer = tokenization.FullTokenizer(\\n vocab_file=FLAGS.vocab_file, do_lower_case=FLAGS.do_lower_case)\\n\\n # set a random seed for reproducability\\n # since this function is run in parallel, if we hardcode a seed, all\\n # documents will have the same permutations. Instead we use the hash of the\\n # first sentence as the seed so it is different for each document and it\\n # is still reproducible.\\n hash_object = hashlib.md5(document[0])\\n rng = random.Random(int(hash_object.hexdigest(), 16) % (10**8))\\n\\n # Each document is composed of a list of sentences. We create paragraphs\\n # by keeping together sentences on the same line and adding adjacent sentences\\n # if there are fewer than 5 to form the paragraph.\\n # The utility functions below expect the document to be split by paragraphs.\\n list_of_paragraphs = []\\n paragraph = []\\n for line in document:\\n line = tokenization.convert_to_unicode(line)\\n line = line.replace(u\\\"\\\\u2018\\\", \\\"'\\\").replace(u\\\"\\\\u2019\\\", \\\"'\\\")\\n sents = split_line_by_sentences(line)\\n for sent in sents:\\n tokens = tokenizer.tokenize(sent)\\n if tokens:\\n paragraph.append(tokens)\\n if len(paragraph) > 5:\\n list_of_paragraphs.append(paragraph)\\n paragraph = []\\n\\n # In case of any empty paragraphs, remove them.\\n list_of_paragraphs = [x for x in list_of_paragraphs if x]\\n\\n # Convert the list of paragraphs into TrainingInstance object\\n # See preprocessing_utils.py for definition\\n if FLAGS.format == FORMAT_BINARY:\\n instances = create_instances_from_document(list_of_paragraphs,\\n FLAGS.max_seq_length, rng)\\n elif FLAGS.format == FORMAT_PARAGRAPH:\\n instances = create_paragraph_order_from_document(list_of_paragraphs,\\n FLAGS.max_seq_length, rng)\\n\\n # Convert token lists into ids and add any needed tokens and padding for BERT\\n tf_examples = [\\n convert_instance_to_tf_example(tokenizer, instance,\\n FLAGS.max_seq_length)[0]\\n for instance in instances\\n ]\\n\\n # Serialize TFExample for writing to file.\\n tf_examples = [example.SerializeToString() for example in tf_examples]\\n\\n return tf_examples\",\n \"def update_model(path_to_data, path_to_model):\\r\\n # Open the annotation files.\\r\\n with open(path_to_data + r'\\\\coco_annotation.json') as f:\\r\\n coco_d = json.load(f)\\r\\n # Get the categories.\\r\\n categories = []\\r\\n for cat in coco_d['categories']:\\r\\n categories.append(cat['name'])\\r\\n\\r\\n # Register the new data.\\r\\n register_coco_instances(\\\"coco_update\\\", {}, path_to_data + r\\\"\\\\coco_annotation.json\\\", path_to_data)\\r\\n MetadataCatalog.get(\\\"meta_update\\\").set(thing_classes=categories)\\r\\n # MetadataCatalog.get(\\\"meta_update\\\").set(thing_classes=[\\\"Bad\\\", \\\"Good\\\"], thing_colors=[(172, 0, 0), (229, 0, 0)])\\r\\n\\r\\n # Set the parameters.\\r\\n cfg = get_cfg()\\r\\n cfg.merge_from_file(model_zoo.get_config_file(\\\"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml\\\"))\\r\\n cfg.DATASETS.TRAIN = (\\\"coco_update\\\",)\\r\\n cfg.OUTPUT_DIR = path_to_model\\r\\n cfg.DATASETS.TEST = ()\\r\\n cfg.DATALOADER.NUM_WORKERS = 2\\r\\n cfg.MODEL.DEVICE = 'cpu'\\r\\n cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, \\\"model_final.pth\\\")\\r\\n cfg.SOLVER.IMS_PER_BATCH = 1\\r\\n cfg.SOLVER.BASE_LR = 0.00025\\r\\n cfg.SOLVER.MAX_ITER = 400\\r\\n cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 10\\r\\n cfg.MODEL.ROI_HEADS.NUM_CLASSES = len(categories)\\r\\n\\r\\n # Update the model.\\r\\n trainer = DefaultTrainer(cfg)\\r\\n trainer.resume_or_load(resume=False)\\r\\n trainer.train()\",\n \"def train_model(model,\\n dataset_info,\\n steps_per_epoch,\\n args):\\n if args.mode not in ['train', 'finetune']:\\n raise ValueError(\\\"train_model() called when in %s mode\\\" % args.mode)\\n\\n dataset_info, model_info = fill_info_dicts(dataset_info, args)\\n\\n train_batches = {name: model_info[name]['train_batch']\\n for name in model_info}\\n\\n additional_encoder_kwargs = dict()\\n\\n for dataset_name in model_info:\\n additional_encoder_kwargs[dataset_name] = dict()\\n\\n with open(args.encoder_config_file, 'r') as f:\\n encoders = json.load(f)\\n extract_fn = encoders[args.architecture][dataset_name]['extract_fn']\\n embed_fn = encoders[args.architecture][dataset_name]['embed_fn']\\n\\n if embed_fn in ['embed_sequence', 'pretrained']:\\n # TODO text_field_name ?\\n if 'input_key' == 'weights':\\n additional_encoder_kwargs[dataset_name]['weights'] = \\\\\\n train_batches[\\n dataset_name]['text_weights']\\n elif embed_fn == 'pretrained':\\n additional_encoder_kwargs[dataset_name]['is_training'] = True\\n elif embed_fn == 'tokenized_embed':\\n additional_encoder_kwargs[dataset_name][\\n 'precompute_path'] = args.precompute_path\\n else:\\n pass\\n\\n if extract_fn == \\\"serial_lbirnn\\\":\\n additional_encoder_kwargs[dataset_name]['is_training'] = True\\n if args.experiment_name == \\\"RUDER_NAACL_18\\\":\\n # use last token of last sequence as feature representation\\n indices = train_batches[dataset_name][\\n 'seq2_length']\\n ones = tf.ones([tf.shape(indices)[0]], dtype=tf.int64)\\n # last token is at pos. length-1\\n indices = tf.subtract(indices, ones)\\n additional_encoder_kwargs[dataset_name]['indices'] = indices\\n elif extract_fn == \\\"lbirnn\\\":\\n additional_encoder_kwargs[dataset_name]['is_training'] = True\\n elif extract_fn == \\\"serial_lbirnn_stock\\\":\\n additional_encoder_kwargs[dataset_name]['is_training'] = True\\n elif extract_fn == \\\"dan\\\":\\n additional_encoder_kwargs[dataset_name]['is_training'] = True\\n else:\\n pass\\n\\n # losses = model.get_multi_task_loss(train_batches,\\n # is_training=True,\\n # additional_encoder_kwargs=additional_encoder_kwargs)\\n\\n # TODO multi loss\\n losses = dict()\\n for dataset in args.datasets:\\n # import pdb\\n # sess = tf.Session()\\n # sess.run(model_info[dataset_name]['train_iter'].initializer)\\n # batch = model_info[dataset_name]['train_batch']\\n losses[dataset] = model.get_loss(train_batches[dataset],\\n dataset,\\n dataset,\\n additional_encoder_kwargs=additional_encoder_kwargs,\\n # sequence in train mode\\n is_training=True)\\n\\n # import pdb\\n # sess.run(model_info[dataset_name]['pred_iter'].initializer)\\n # batch = model_info[dataset_name]['pred_batch']\\n # text, weights = sess.run([batch['text'], batch['text_weights']])\\n # pdb.set_trace()\\n\\n # # see if dropout and is_training working\\n # # by checking train loss with different is_training the same\\n\\n # Done building compute graph; set up training ops.\\n\\n # Training ops\\n global_step_tensor = tf.train.get_or_create_global_step()\\n\\n train_ops = dict()\\n optim = tf.train.RMSPropOptimizer(learning_rate=args.lr0)\\n for dataset_name in model_info:\\n # tvars, grads = get_var_grads(losses[dataset_name])\\n # train_ops[dataset_name] = get_train_op(tvars, grads, lr, args.max_grad_norm,\\n # global_step_tensor, args.optimizer, name='train_op_{}'.format(dataset_name))\\n train_ops[dataset_name] = optim.minimize(losses[dataset_name],\\n global_step=global_step_tensor)\\n\\n # tvars, grads = get_var_grads(loss)\\n # train_op = get_train_op(tvars, grads, lr, args.max_grad_norm,\\n # global_step_tensor, args.optimizer, name='train_op')\\n init_ops = [tf.global_variables_initializer(),\\n tf.local_variables_initializer()]\\n config = get_proto_config(args)\\n\\n # Get training objective. The inputs are:\\n # 1. A dict of { dataset_key: dataset_iterator }\\n #\\n\\n fill_eval_loss_op(args, model, dataset_info, model_info)\\n fill_pred_op_info(dataset_info, model, args, model_info)\\n fill_topic_op(args, model_info)\\n\\n print(\\\"All the variables after defining valid/test accuracy:\\\")\\n all_variables = tf.global_variables()\\n trainable_variables = tf.trainable_variables()\\n total_trainable_parameters = 0\\n for var in all_variables:\\n if var in trainable_variables:\\n print('(t) {}'.format(var))\\n shape = var.get_shape()\\n var_params = 1\\n for dim in shape:\\n var_params *= dim.value\\n total_trainable_parameters += var_params\\n else:\\n print('( ) {}'.format(var))\\n\\n print(\\\"Total trainable parameters in this model={}\\\\n\\\\n\\\\n\\\".format(\\n total_trainable_parameters))\\n\\n # # Add ops to save and restore all the variables.\\n\\n # latest checkpoint\\n # saves every several steps\\n # automatically done by tf.train.SingularMonitorSession with\\n # tf.train.CheckpoinSaverHook\\n\\n # TODO load from some checkpoint dif at the beginning(?)\\n saver_hook = tf.train.CheckpointSaverHook(\\n checkpoint_dir=os.path.join(args.checkpoint_dir, 'latest'),\\n save_steps=100)\\n\\n # saved model builders for each model\\n # builders = init_builders(args, model_info)\\n\\n saver = tf.train.Saver(max_to_keep=100)\\n\\n with tf.train.SingularMonitoredSession(hooks=[saver_hook],\\n config=config) as sess:\\n\\n if args.mode == 'train':\\n sess.run(init_ops)\\n\\n else:\\n assert len(args.datasets) == 1\\n checkpoint_path_load = model_info[args.datasets[0]][\\n 'checkpoint_path_load']\\n saver.restore(sess, checkpoint_path_load)\\n\\n if args.summaries_dir:\\n train_file_writer = tf.summary.FileWriter(\\n os.path.join(args.summaries_dir, 'train'), graph=sess.graph)\\n valid_file_writer = tf.summary.FileWriter(\\n os.path.join(args.summaries_dir, 'valid'), graph=sess.graph)\\n\\n best_eval_performance = dict()\\n for dataset_name in model_info:\\n _train_init_op = model_info[dataset_name]['train_init_op']\\n _valid_init_op = model_info[dataset_name]['valid_init_op']\\n\\n sess.run([_train_init_op, _valid_init_op])\\n\\n init_value = float('-inf')\\n if args.tuning_metric == 'MAE_MACRO':\\n init_value = float('inf')\\n best_eval_performance[dataset_name] = {\\\"epoch\\\": -1,\\n args.tuning_metric: init_value,\\n \\\"performance\\\": None\\n }\\n\\n best_total_tuning_metric = init_value\\n best_tuning_metric_epoch = -1\\n\\n main_task_dev_tuning_metric = []\\n stopping_criterion_reached = False\\n early_stopping_dev_results = \\\"\\\"\\n\\n # Do training\\n make_dir(os.path.dirname(args.log_file))\\n with open(args.log_file, 'a') as f:\\n f.write('VALIDATION RESULTS\\\\n')\\n for epoch in xrange(1, args.num_train_epochs + 1):\\n\\n start_time = time()\\n\\n total_tuning_metric = 0.0\\n\\n # Take steps_per_epoch gradient steps\\n total_loss = 0\\n num_iter = 0\\n # for _ in tqdm(xrange(steps_per_epoch)):\\n # step, loss_v, _ = sess.run(\\n # [global_step_tensor, loss, train_op])\\n # num_iter += 1\\n # total_loss += loss_v\\n #\\n # # loss_v is sum over a batch from each dataset of the average loss *per\\n # # training example*\\n # assert num_iter > 0\\n #\\n # average loss per batch (which is in turn averaged across examples)\\n # train_loss = float(total_loss) / float(num_iter)\\n\\n for _ in tqdm(xrange(steps_per_epoch)):\\n for (dataset_name, alpha) in zip(*[args.datasets, args.alphas]):\\n loss_v, _ = sess.run(\\n [losses[dataset_name], train_ops[dataset_name]])\\n total_loss += alpha * loss_v\\n step = sess.run(global_step_tensor)\\n num_iter += 1\\n assert num_iter > 0\\n\\n train_loss = float(total_loss) / float(num_iter)\\n\\n if args.summaries_dir:\\n train_loss_summary = tf.Summary(\\n value=[\\n tf.Summary.Value(tag=\\\"loss\\\", simple_value=train_loss)])\\n train_file_writer.add_summary(\\n train_loss_summary, global_step=step)\\n\\n # Evaluate held-out tuning metric\\n # if not args.test: # Validation mode\\n # Get performance metrics on each dataset\\n for dataset_name in args.datasets:\\n _pred_op = model_info[dataset_name]['valid_pred_op']\\n _eval_labels = model_info[dataset_name]['valid_batch'][\\n args.label_key]\\n _eval_iter = model_info[dataset_name]['valid_iter']\\n _get_topic_op = model_info[dataset_name]['valid_topic_op']\\n _loss_op = model_info[dataset_name]['valid_loss_op']\\n _metrics = compute_held_out_performance(sess,\\n _pred_op,\\n _eval_labels,\\n _eval_iter,\\n metrics=dataset_info[\\n dataset_name][\\n 'metrics'],\\n labels=dataset_info[\\n dataset_name][\\n 'labels'],\\n args=args,\\n get_topic_op=_get_topic_op,\\n topic_path=dataset_info[\\n dataset_name][\\n 'topic_path'],\\n eval_loss_op=_loss_op)\\n model_info[dataset_name]['valid_metrics'] = _metrics\\n\\n end_time = time()\\n elapsed = end_time - start_time\\n\\n # Manually compute the validation loss since each dataset is iterated through once\\n # in a serial manner and not \\\"in parallel\\\" (i.e., a batch from each)\\n valid_loss = 0.0\\n for (dataset_name, alpha) in zip(*[args.datasets, args.alphas]):\\n valid_loss += float(alpha) * \\\\\\n model_info[dataset_name]['valid_metrics'][\\n 'eval_loss']\\n\\n main_task_tuning_metric = model_info[args.datasets[0]\\n ]['valid_metrics'][args.tuning_metric]\\n\\n if args.summaries_dir:\\n valid_loss_summary = tf.Summary(\\n value=[\\n tf.Summary.Value(tag=\\\"loss\\\", simple_value=valid_loss)])\\n valid_file_writer.add_summary(\\n valid_loss_summary, global_step=step)\\n valid_main_task_tuning_metric_summary = tf.Summary(value=[\\n tf.Summary.Value(tag=\\\"main-task-\\\" + args.tuning_metric,\\n simple_value=main_task_tuning_metric)])\\n valid_file_writer.add_summary(\\n valid_main_task_tuning_metric_summary,\\n global_step=step)\\n\\n if (\\n main_task_tuning_metric >= args.early_stopping_acc_threshold) and (\\n len(main_task_dev_tuning_metric) >= args.patience) and (\\n main_task_tuning_metric < main_task_dev_tuning_metric[\\n -args.patience]):\\n print(\\n \\\"Stopping early at epoch {} (patience={}, early stopping acc threshold={})\\\".format(\\n epoch, args.patience,\\n args.early_stopping_acc_threshold))\\n stopping_criterion_reached = True\\n\\n main_task_dev_tuning_metric.append(main_task_tuning_metric)\\n\\n if args.reporting_metric != \\\"Acc\\\":\\n main_task_performance = \\\\\\n model_info[args.datasets[0]]['valid_metrics'][\\n args.reporting_metric]\\n if args.summaries_dir:\\n valid_main_task_performance_summary = tf.Summary(value=[\\n tf.Summary.Value(\\n tag=\\\"main-task-{}\\\".format(args.reporting_metric),\\n simple_value=main_task_performance)])\\n valid_file_writer.add_summary(\\n valid_main_task_performance_summary,\\n global_step=step)\\n\\n # Log performance(s)\\n str_ = '[epoch=%d/%d step=%d (%d s)] train_loss=%s valid_loss=%s (per batch)' % (\\n epoch, args.num_train_epochs, np.asscalar(step), elapsed,\\n train_loss, valid_loss)\\n\\n for dataset_name in args.datasets:\\n _num_eval_total = model_info[dataset_name]['valid_metrics'][\\n 'ntotal']\\n # TODO use other metric here for tuning\\n _eval_tuning_metric = model_info[dataset_name]['valid_metrics'][\\n args.tuning_metric]\\n # _eval_align_acc = model_info[dataset_name]['valid_metrics'][\\n # 'aligned_accuracy']\\n\\n str_ += '\\\\n(%s) ' % dataset_name\\n for m, s in model_info[dataset_name]['valid_metrics'].items():\\n if (dataset_name == args.datasets[0]) and (\\n m == args.reporting_metric): # main task\\n str_ += '**%s=%f** ' % (m, s)\\n elif m == args.tuning_metric:\\n str_ += '*%s=%f* ' % (m, s)\\n elif m == 'Confusion_Matrix':\\n pass\\n else:\\n str_ += '%s=%f ' % (m, s)\\n if 'Confusion_Matrix' in model_info[dataset_name][\\n 'valid_metrics']:\\n str_ += 'Confusion_Matrix:\\\\n'\\n str_ += '\\\\n'.join(' '.join('%4d' % x for x in y) for y in\\n model_info[dataset_name]['valid_metrics'][\\n 'Confusion_Matrix'])\\n\\n # Track best-performing epoch for each dataset\\n # use the newest best epoch for test\\n if _eval_tuning_metric >= best_eval_performance[dataset_name][\\n args.tuning_metric]:\\n best_eval_performance[dataset_name][args.tuning_metric] = \\\\\\n _eval_tuning_metric\\n best_eval_performance[dataset_name][\\\"performance\\\"] = \\\\\\n model_info[dataset_name]['valid_metrics'].copy()\\n best_eval_performance[dataset_name][\\\"epoch\\\"] = epoch\\n # save best model\\n saver.save(sess.raw_session(),\\n model_info[dataset_name]['checkpoint_path'])\\n\\n # # test\\n # saver.save(sess.raw_session(), checkpoint_path)\\n\\n total_tuning_metric += _eval_tuning_metric\\n\\n # Track best-performing epoch for collection of datasets\\n\\n if total_tuning_metric >= best_total_tuning_metric:\\n best_total_tuning_metric = total_tuning_metric\\n best_tuning_metric_epoch = epoch\\n best_epoch_results = str_\\n if len(args.datasets) > 1:\\n saver.save(sess.raw_session(),\\n os.path.join(args.checkpoint_dir, 'MULT',\\n 'model'))\\n\\n logging.info(str_)\\n\\n # Log dev results in a file\\n with open(args.log_file, 'a') as f:\\n f.write(str_ + '\\\\n')\\n\\n if stopping_criterion_reached:\\n saver.save(sess.raw_session(),\\n os.path.join(args.checkpoint_dir, 'early-stopping',\\n 'model'))\\n\\n early_stopping_dev_results = str_\\n # with open(args.log_file, 'a') as f:\\n # f.write('\\\\nSTOPPED EARLY AFTER {} EPOCHS\\\\n'.format(epoch))\\n # f.write(str_ + '\\\\n')\\n break\\n\\n print(best_eval_performance)\\n print(\\n 'Best total {}: {} at epoch {}'.format(\\n args.tuning_metric,\\n best_total_tuning_metric,\\n best_tuning_metric_epoch))\\n print(best_epoch_results)\\n\\n with open(args.log_file, 'a') as f:\\n # f.write(best_eval_acc + '\\\\n')\\n # f.write('Best total accuracy: {} at epoch {}'.format(best_total_acc,\\n # best_total_acc_epoch))\\n f.write('\\\\nBest single-epoch performance across all datasets\\\\n')\\n f.write(best_epoch_results + '\\\\n\\\\n')\\n\\n # Write (add) the result to a common report file\\n with open(args.log_file, 'a') as f:\\n for dataset in best_eval_performance.keys():\\n f.write(str(dataset))\\n f.write(\\\" \\\")\\n f.write(\\\"\\\\n\\\")\\n for dataset, values in best_eval_performance.items():\\n f.write(\\n 'Metrics on highest-{} epoch for dataset {}: {}\\\\n'.format(\\n args.tuning_metric, dataset, values))\\n\\n f.write('Best total {}: {} at epoch {}\\\\n\\\\n'.format(\\n args.tuning_metric, best_total_tuning_metric,\\n best_tuning_metric_epoch))\\n if stopping_criterion_reached:\\n f.write('STOPPED EARLY AFTER {} EPOCHS\\\\n'.format(epoch))\\n f.write(early_stopping_dev_results + '\\\\n\\\\n')\\n\\n if args.summaries_dir:\\n train_file_writer.close()\\n valid_file_writer.close()\",\n \"def train_model(self,train_data,eval_data=None): # noqa: ignore flake8\\\"\\n logger.info(\\\"Training model...\\\")\\n os.makedirs(self.model_dir, exist_ok=True)\\n source_texts, target_texts = create_dataset(train_data)\\n\\n self.src_2_ids = read_vocab(source_texts)\\n self.trg_2_ids = read_vocab(target_texts)\\n save_word_dict(self.src_2_ids, self.src_vocab_path)\\n save_word_dict(self.trg_2_ids, self.trg_vocab_path)\\n train_src, train_trg = one_hot(source_texts, target_texts, self.src_2_ids, self.trg_2_ids, sort_by_len=True)\\n\\n id_2_srcs = {v: k for k, v in self.src_2_ids.items()}\\n id_2_trgs = {v: k for k, v in self.trg_2_ids.items()}\\n logger.debug(f'train src: {[id_2_srcs[i] for i in train_src[0]]}')\\n logger.debug(f'train trg: {[id_2_trgs[i] for i in train_trg[0]]}')\\n\\n self.model = Seq2Seq(\\n encoder_vocab_size=len(self.src_2_ids),\\n decoder_vocab_size=len(self.trg_2_ids),\\n embed_size=self.embed_size,\\n enc_hidden_size=self.hidden_size,\\n dec_hidden_size=self.hidden_size,\\n dropout=self.dropout\\n )\\n self.model.to(device)\\n logger.debug(self.model)\\n optimizer = torch.optim.Adam(self.model.parameters())\\n\\n train_data = gen_examples(train_src, train_trg, self.batch_size, self.max_length)\\n train_losses = []\\n best_loss = 1e3\\n for epoch in range(self.epochs):\\n self.model.train()\\n total_num_words = 0.\\n total_loss = 0.\\n for it, (mb_x, mb_x_len, mb_y, mb_y_len) in enumerate(train_data):\\n mb_x = torch.from_numpy(mb_x).to(device).long()\\n mb_x_len = torch.from_numpy(mb_x_len).to(device).long()\\n mb_input = torch.from_numpy(mb_y[:, :-1]).to(device).long()\\n mb_output = torch.from_numpy(mb_y[:, 1:]).to(device).long()\\n mb_y_len = torch.from_numpy(mb_y_len - 1).to(device).long()\\n mb_y_len[mb_y_len <= 0] = 1\\n\\n mb_pred, attn = self.model(mb_x, mb_x_len, mb_input, mb_y_len)\\n\\n mb_out_mask = torch.arange(mb_y_len.max().item(), device=device)[None, :] < mb_y_len[:, None]\\n mb_out_mask = mb_out_mask.float()\\n\\n loss = self.loss_fn(mb_pred, mb_output, mb_out_mask)\\n\\n num_words = torch.sum(mb_y_len).item()\\n total_loss += loss.item() * num_words\\n total_num_words += num_words\\n\\n # update optimizer\\n optimizer.zero_grad()\\n loss.backward()\\n torch.nn.utils.clip_grad_norm_(self.model.parameters(), 5.)\\n optimizer.step()\\n\\n if it % 100 == 0:\\n logger.debug(\\\"Epoch :{}/{}, iteration :{}/{} loss:{:.4f}\\\".format(epoch, self.epochs,\\n it, len(train_data),\\n loss.item()))\\n cur_loss = total_loss / total_num_words\\n train_losses.append(cur_loss)\\n logger.debug(\\\"Epoch :{}/{}, Training loss:{:.4f}\\\".format(epoch, self.epochs, cur_loss))\\n if epoch % 1 == 0:\\n # find best model\\n is_best = cur_loss < best_loss\\n best_loss = min(cur_loss, best_loss)\\n if is_best:\\n self.save_model()\\n logger.info('Epoch:{}, save new bert model:{}'.format(epoch, self.model_path))\\n if eval_data:\\n self.eval_model(eval_data)\\n\\n\\n return train_losses\",\n \"def load_spacy_model(spacy_model_name: str) -> Optional[Language]:\\n\\n try:\\n spacy_model = spacy.load(spacy_model_name)\\n\\n except OSError as exc:\\n logger.info(f\\\"Unable to load spacy model {spacy_model_name}\\\")\\n\\n if \\\"E050\\\" in str(exc):\\n # https://github.com/explosion/spaCy/blob/v2.1.6/spacy/errors.py#L207\\n # Model not found, try installing it\\n logger.info(f\\\"Downloading {spacy_model_name}\\\")\\n\\n from spacy.cli.download import msg as spacy_msg\\n\\n # Download quietly\\n spacy_msg.no_print = True\\n try:\\n spacy.cli.download(spacy_model_name, False, False, \\\"--quiet\\\")\\n except SystemExit:\\n logger.error(f\\\"Unable to install spacy model {spacy_model_name}\\\")\\n return None\\n\\n # Specific steps for transformer models (very brittle and likely not permanent)\\n if spacy_model_name.endswith(\\\"_trf\\\"):\\n\\n # If we just installed a transformer model along with spacy-transformers in a child process\\n # we need to set up an entry point for spacy-transformers in the current process.\\n # This entry point will be registered as a pipeline factory function by the model's language class.\\n load_entry_point(\\\"spacy-transformers\\\", \\\"spacy_factories\\\", \\\"transformer\\\")\\n\\n # If Pytorch was also just installed, certain modules that depend on it\\n # may need reloading to work in the current process\\n reload(thinc.util)\\n reload(thinc.shims.pytorch)\\n reload(thinc.shims.pytorch_grad_scaler)\\n\\n # Now try loading the model again\\n spacy_model = spacy.load(spacy_model_name)\\n\\n else:\\n logger.exception(exc)\\n return None\\n\\n # Set text length limit for model\\n spacy_model.max_length = RATOM_SPACY_MODEL_MAX_LENGTH\\n\\n return spacy_model\",\n \"def train_model(args, train_exs: List[SentimentExample]) -> SentimentClassifier:\\n # Initialize feature extractor\\n nltk.download('stopwords')\\n stop_words = set(stopwords.words('english'))\\n\\n if args.model == \\\"TRIVIAL\\\":\\n feat_extractor = None\\n elif args.feats == \\\"UNIGRAM\\\":\\n feat_extractor = UnigramFeatureExtractor(Indexer(), train_exs, stop_words)\\n elif args.feats == \\\"BIGRAM\\\":\\n # Add additional preprocessing code here\\n feat_extractor = BigramFeatureExtractor(Indexer(), train_exs, stop_words)\\n elif args.feats == \\\"BETTER\\\":\\n # Add additional preprocessing code here\\n feat_extractor = BetterFeatureExtractor(Indexer(), train_exs, stop_words)\\n else:\\n raise Exception(\\\"Pass in UNIGRAM, BIGRAM, or BETTER to run the appropriate system\\\")\\n\\n # Train the model\\n if args.model == \\\"TRIVIAL\\\":\\n model = TrivialSentimentClassifier()\\n elif args.model == \\\"PERCEPTRON\\\":\\n model = train_perceptron(train_exs, feat_extractor)\\n elif args.model == \\\"LR\\\":\\n model = train_logistic_regression(train_exs, feat_extractor)\\n else:\\n raise Exception(\\\"Pass in TRIVIAL, PERCEPTRON, or LR to run the appropriate system\\\")\\n return model\",\n \"def convert_data(data):\\n training_data = []\\n for record in data:\\n entities = record.get('entities')\\n converted_entities = []\\n for entity in entities:\\n converted_entities.append((entity.get('start_offset'), entity.get('end_offset'),\\n entity.get('entity_name')))\\n\\n training_data.append((record.get('text'), {'entities': converted_entities}))\\n return training_data\",\n \"def evaluate_model():\\n\\n # Get the processed data (in proper format to evaluate the NER model)\\n data = get_json_from_file_path(PROCESSED_DATA_PATH)\\n # Split the dataset for training and test as we did for training\\n train_data, test_data = train_test_split(data, train_size=0.7, \\n random_state=4)\\n\\n # Load the model trained\\n try:\\n ner_model = spacy.load(OUTPUT_MODEL_PATH)\\n except Exception as err:\\n msg = f'Could not load the model. Error: {err}'\\n raise Exception(msg)\\n\\n # Compute evaluation scores\\n print('Computing metrics...')\\n scores = evaluate(ner_model, test_data)\\n # General metrics of the model\\n f_score = scores.get('ents_f')\\n precision = scores.get('ents_p')\\n recall = scores.get('ents_r')\\n print('\\\\nScoring:')\\n print(f'F-score: {f_score}')\\n print(f'Precision: {precision}')\\n print(f'Recall: {recall}')\\n\\n # Get the specific scores for each entity \\n scores_per_entity = scores.get('ents_per_type')\\n # Get the F-score of the entities\\n f_scores_of_entities = []\\n for entity_scores in scores_per_entity.values():\\n f_scores_of_entities.append(entity_scores['f'])\\n # Compute the macro averaged F-score\\n macro_avg_f_score = sum(f_scores_of_entities)/len(f_scores_of_entities)\\n print(f'Macro averaged F-score: {macro_avg_f_score}')\\n \\n print('\\\\nScores per entity;')\\n print('{:<15} {:<10} {:<10} {:<10}'.format('Entity','F-score','Precision','Recall'))\\n for key, value in scores_per_entity.items():\\n entity = key\\n f, p, r = value['f'], value['p'], value['r']\\n print('{:<15} {:<10.2f} {:<10.2f} {:<10.2f}'.format(entity, f, p, r))\",\n \"def debug_data(\\n # fmt: off\\n lang: (\\\"Model language\\\", \\\"positional\\\", None, str),\\n train_path: (\\\"Location of JSON-formatted training data\\\", \\\"positional\\\", None, Path),\\n dev_path: (\\\"Location of JSON-formatted development data\\\", \\\"positional\\\", None, Path),\\n tag_map_path: (\\\"Location of JSON-formatted tag map\\\", \\\"option\\\", \\\"tm\\\", Path) = None,\\n base_model: (\\\"Name of model to update (optional)\\\", \\\"option\\\", \\\"b\\\", str) = None,\\n pipeline: (\\\"Comma-separated names of pipeline components to train\\\", \\\"option\\\", \\\"p\\\", str) = \\\"tagger,parser,ner\\\",\\n ignore_warnings: (\\\"Ignore warnings, only show stats and errors\\\", \\\"flag\\\", \\\"IW\\\", bool) = False,\\n verbose: (\\\"Print additional information and explanations\\\", \\\"flag\\\", \\\"V\\\", bool) = False,\\n no_format: (\\\"Don't pretty-print the results\\\", \\\"flag\\\", \\\"NF\\\", bool) = False,\\n # fmt: on\\n):\\n msg = Printer(pretty=not no_format, ignore_warnings=ignore_warnings)\\n\\n # Make sure all files and paths exists if they are needed\\n if not train_path.exists():\\n msg.fail(\\\"Training data not found\\\", train_path, exits=1)\\n if not dev_path.exists():\\n msg.fail(\\\"Development data not found\\\", dev_path, exits=1)\\n\\n tag_map = {}\\n if tag_map_path is not None:\\n tag_map = srsly.read_json(tag_map_path)\\n\\n # Initialize the model and pipeline\\n pipeline = [p.strip() for p in pipeline.split(\\\",\\\")]\\n if base_model:\\n nlp = load_model(base_model)\\n else:\\n lang_cls = get_lang_class(lang)\\n nlp = lang_cls()\\n # Update tag map with provided mapping\\n nlp.vocab.morphology.tag_map.update(tag_map)\\n\\n msg.divider(\\\"Data format validation\\\")\\n\\n # TODO: Validate data format using the JSON schema\\n # TODO: update once the new format is ready\\n # TODO: move validation to GoldCorpus in order to be able to load from dir\\n\\n # Create the gold corpus to be able to better analyze data\\n loading_train_error_message = \\\"\\\"\\n loading_dev_error_message = \\\"\\\"\\n with msg.loading(\\\"Loading corpus...\\\"):\\n corpus = GoldCorpus(train_path, dev_path)\\n try:\\n train_dataset = list(corpus.train_dataset(nlp))\\n train_dataset_unpreprocessed = list(\\n corpus.train_dataset_without_preprocessing(nlp)\\n )\\n except ValueError as e:\\n loading_train_error_message = f\\\"Training data cannot be loaded: {e}\\\"\\n try:\\n dev_dataset = list(corpus.dev_dataset(nlp))\\n except ValueError as e:\\n loading_dev_error_message = f\\\"Development data cannot be loaded: {e}\\\"\\n if loading_train_error_message or loading_dev_error_message:\\n if loading_train_error_message:\\n msg.fail(loading_train_error_message)\\n if loading_dev_error_message:\\n msg.fail(loading_dev_error_message)\\n sys.exit(1)\\n msg.good(\\\"Corpus is loadable\\\")\\n\\n # Create all gold data here to avoid iterating over the train_dataset constantly\\n gold_train_data = _compile_gold(train_dataset, pipeline)\\n gold_train_unpreprocessed_data = _compile_gold(\\n train_dataset_unpreprocessed, pipeline\\n )\\n gold_dev_data = _compile_gold(dev_dataset, pipeline)\\n\\n train_texts = gold_train_data[\\\"texts\\\"]\\n dev_texts = gold_dev_data[\\\"texts\\\"]\\n\\n msg.divider(\\\"Training stats\\\")\\n msg.text(f\\\"Training pipeline: {', '.join(pipeline)}\\\")\\n for pipe in [p for p in pipeline if p not in nlp.factories]:\\n msg.fail(f\\\"Pipeline component '{pipe}' not available in factories\\\")\\n if base_model:\\n msg.text(f\\\"Starting with base model '{base_model}'\\\")\\n else:\\n msg.text(f\\\"Starting with blank model '{lang}'\\\")\\n msg.text(f\\\"{len(train_dataset)} training docs\\\")\\n msg.text(f\\\"{len(dev_dataset)} evaluation docs\\\")\\n\\n if not len(gold_dev_data):\\n msg.fail(\\\"No evaluation docs\\\")\\n overlap = len(train_texts.intersection(dev_texts))\\n if overlap:\\n msg.warn(f\\\"{overlap} training examples also in evaluation data\\\")\\n else:\\n msg.good(\\\"No overlap between training and evaluation data\\\")\\n if not base_model and len(train_dataset) < BLANK_MODEL_THRESHOLD:\\n text = (\\n f\\\"Low number of examples to train from a blank model ({len(train_dataset)})\\\"\\n )\\n if len(train_dataset) < BLANK_MODEL_MIN_THRESHOLD:\\n msg.fail(text)\\n else:\\n msg.warn(text)\\n msg.text(\\n f\\\"It's recommended to use at least {BLANK_MODEL_THRESHOLD} examples \\\"\\n f\\\"(minimum {BLANK_MODEL_MIN_THRESHOLD})\\\",\\n show=verbose,\\n )\\n\\n msg.divider(\\\"Vocab & Vectors\\\")\\n n_words = gold_train_data[\\\"n_words\\\"]\\n msg.info(\\n f\\\"{n_words} total word(s) in the data ({len(gold_train_data['words'])} unique)\\\"\\n )\\n if gold_train_data[\\\"n_misaligned_words\\\"] > 0:\\n n_misaligned = gold_train_data[\\\"n_misaligned_words\\\"]\\n msg.warn(f\\\"{n_misaligned} misaligned tokens in the training data\\\")\\n if gold_dev_data[\\\"n_misaligned_words\\\"] > 0:\\n n_misaligned = gold_dev_data[\\\"n_misaligned_words\\\"]\\n msg.warn(f\\\"{n_misaligned} misaligned tokens in the dev data\\\")\\n most_common_words = gold_train_data[\\\"words\\\"].most_common(10)\\n msg.text(\\n f\\\"10 most common words: {_format_labels(most_common_words, counts=True)}\\\",\\n show=verbose,\\n )\\n if len(nlp.vocab.vectors):\\n msg.info(\\n f\\\"{len(nlp.vocab.vectors)} vectors ({nlp.vocab.vectors.n_keys} \\\"\\n f\\\"unique keys, {nlp.vocab.vectors_length} dimensions)\\\"\\n )\\n else:\\n msg.info(\\\"No word vectors present in the model\\\")\\n\\n if \\\"ner\\\" in pipeline:\\n # Get all unique NER labels present in the data\\n labels = set(\\n label for label in gold_train_data[\\\"ner\\\"] if label not in (\\\"O\\\", \\\"-\\\", None)\\n )\\n label_counts = gold_train_data[\\\"ner\\\"]\\n model_labels = _get_labels_from_model(nlp, \\\"ner\\\")\\n new_labels = [l for l in labels if l not in model_labels]\\n existing_labels = [l for l in labels if l in model_labels]\\n has_low_data_warning = False\\n has_no_neg_warning = False\\n has_ws_ents_error = False\\n has_punct_ents_warning = False\\n\\n msg.divider(\\\"Named Entity Recognition\\\")\\n msg.info(\\n f\\\"{len(new_labels)} new label(s), {len(existing_labels)} existing label(s)\\\"\\n )\\n missing_values = label_counts[\\\"-\\\"]\\n msg.text(f\\\"{missing_values} missing value(s) (tokens with '-' label)\\\")\\n for label in new_labels:\\n if len(label) == 0:\\n msg.fail(\\\"Empty label found in new labels\\\")\\n if new_labels:\\n labels_with_counts = [\\n (label, count)\\n for label, count in label_counts.most_common()\\n if label != \\\"-\\\"\\n ]\\n labels_with_counts = _format_labels(labels_with_counts, counts=True)\\n msg.text(f\\\"New: {labels_with_counts}\\\", show=verbose)\\n if existing_labels:\\n msg.text(f\\\"Existing: {_format_labels(existing_labels)}\\\", show=verbose)\\n if gold_train_data[\\\"ws_ents\\\"]:\\n msg.fail(f\\\"{gold_train_data['ws_ents']} invalid whitespace entity spans\\\")\\n has_ws_ents_error = True\\n\\n if gold_train_data[\\\"punct_ents\\\"]:\\n msg.warn(f\\\"{gold_train_data['punct_ents']} entity span(s) with punctuation\\\")\\n has_punct_ents_warning = True\\n\\n for label in new_labels:\\n if label_counts[label] <= NEW_LABEL_THRESHOLD:\\n msg.warn(\\n f\\\"Low number of examples for new label '{label}' ({label_counts[label]})\\\"\\n )\\n has_low_data_warning = True\\n\\n with msg.loading(\\\"Analyzing label distribution...\\\"):\\n neg_docs = _get_examples_without_label(train_dataset, label)\\n if neg_docs == 0:\\n msg.warn(f\\\"No examples for texts WITHOUT new label '{label}'\\\")\\n has_no_neg_warning = True\\n\\n if not has_low_data_warning:\\n msg.good(\\\"Good amount of examples for all labels\\\")\\n if not has_no_neg_warning:\\n msg.good(\\\"Examples without occurrences available for all labels\\\")\\n if not has_ws_ents_error:\\n msg.good(\\\"No entities consisting of or starting/ending with whitespace\\\")\\n if not has_punct_ents_warning:\\n msg.good(\\\"No entities consisting of or starting/ending with punctuation\\\")\\n\\n if has_low_data_warning:\\n msg.text(\\n f\\\"To train a new entity type, your data should include at \\\"\\n f\\\"least {NEW_LABEL_THRESHOLD} instances of the new label\\\",\\n show=verbose,\\n )\\n if has_no_neg_warning:\\n msg.text(\\n \\\"Training data should always include examples of entities \\\"\\n \\\"in context, as well as examples without a given entity \\\"\\n \\\"type.\\\",\\n show=verbose,\\n )\\n if has_ws_ents_error:\\n msg.text(\\n \\\"As of spaCy v2.1.0, entity spans consisting of or starting/ending \\\"\\n \\\"with whitespace characters are considered invalid.\\\"\\n )\\n\\n if has_punct_ents_warning:\\n msg.text(\\n \\\"Entity spans consisting of or starting/ending \\\"\\n \\\"with punctuation can not be trained with a noise level > 0.\\\"\\n )\\n\\n if \\\"textcat\\\" in pipeline:\\n msg.divider(\\\"Text Classification\\\")\\n labels = [label for label in gold_train_data[\\\"cats\\\"]]\\n model_labels = _get_labels_from_model(nlp, \\\"textcat\\\")\\n new_labels = [l for l in labels if l not in model_labels]\\n existing_labels = [l for l in labels if l in model_labels]\\n msg.info(\\n f\\\"Text Classification: {len(new_labels)} new label(s), \\\"\\n f\\\"{len(existing_labels)} existing label(s)\\\"\\n )\\n if new_labels:\\n labels_with_counts = _format_labels(\\n gold_train_data[\\\"cats\\\"].most_common(), counts=True\\n )\\n msg.text(f\\\"New: {labels_with_counts}\\\", show=verbose)\\n if existing_labels:\\n msg.text(f\\\"Existing: {_format_labels(existing_labels)}\\\", show=verbose)\\n if set(gold_train_data[\\\"cats\\\"]) != set(gold_dev_data[\\\"cats\\\"]):\\n msg.fail(\\n f\\\"The train and dev labels are not the same. \\\"\\n f\\\"Train labels: {_format_labels(gold_train_data['cats'])}. \\\"\\n f\\\"Dev labels: {_format_labels(gold_dev_data['cats'])}.\\\"\\n )\\n if gold_train_data[\\\"n_cats_multilabel\\\"] > 0:\\n msg.info(\\n \\\"The train data contains instances without \\\"\\n \\\"mutually-exclusive classes. Use '--textcat-multilabel' \\\"\\n \\\"when training.\\\"\\n )\\n if gold_dev_data[\\\"n_cats_multilabel\\\"] == 0:\\n msg.warn(\\n \\\"Potential train/dev mismatch: the train data contains \\\"\\n \\\"instances without mutually-exclusive classes while the \\\"\\n \\\"dev data does not.\\\"\\n )\\n else:\\n msg.info(\\n \\\"The train data contains only instances with \\\"\\n \\\"mutually-exclusive classes.\\\"\\n )\\n if gold_dev_data[\\\"n_cats_multilabel\\\"] > 0:\\n msg.fail(\\n \\\"Train/dev mismatch: the dev data contains instances \\\"\\n \\\"without mutually-exclusive classes while the train data \\\"\\n \\\"contains only instances with mutually-exclusive classes.\\\"\\n )\\n\\n if \\\"tagger\\\" in pipeline:\\n msg.divider(\\\"Part-of-speech Tagging\\\")\\n labels = [label for label in gold_train_data[\\\"tags\\\"]]\\n tag_map = nlp.vocab.morphology.tag_map\\n msg.info(f\\\"{len(labels)} label(s) in data ({len(tag_map)} label(s) in tag map)\\\")\\n labels_with_counts = _format_labels(\\n gold_train_data[\\\"tags\\\"].most_common(), counts=True\\n )\\n msg.text(labels_with_counts, show=verbose)\\n non_tagmap = [l for l in labels if l not in tag_map]\\n if not non_tagmap:\\n msg.good(f\\\"All labels present in tag map for language '{nlp.lang}'\\\")\\n for label in non_tagmap:\\n msg.fail(f\\\"Label '{label}' not found in tag map for language '{nlp.lang}'\\\")\\n\\n if \\\"parser\\\" in pipeline:\\n has_low_data_warning = False\\n msg.divider(\\\"Dependency Parsing\\\")\\n\\n # profile sentence length\\n msg.info(\\n f\\\"Found {gold_train_data['n_sents']} sentence(s) with an average \\\"\\n f\\\"length of {gold_train_data['n_words'] / gold_train_data['n_sents']:.1f} words.\\\"\\n )\\n\\n # check for documents with multiple sentences\\n sents_per_doc = gold_train_data[\\\"n_sents\\\"] / len(gold_train_data[\\\"texts\\\"])\\n if sents_per_doc < 1.1:\\n msg.warn(\\n f\\\"The training data contains {sents_per_doc:.2f} sentences per \\\"\\n f\\\"document. When there are very few documents containing more \\\"\\n f\\\"than one sentence, the parser will not learn how to segment \\\"\\n f\\\"longer texts into sentences.\\\"\\n )\\n\\n # profile labels\\n labels_train = [label for label in gold_train_data[\\\"deps\\\"]]\\n labels_train_unpreprocessed = [\\n label for label in gold_train_unpreprocessed_data[\\\"deps\\\"]\\n ]\\n labels_dev = [label for label in gold_dev_data[\\\"deps\\\"]]\\n\\n if gold_train_unpreprocessed_data[\\\"n_nonproj\\\"] > 0:\\n n_nonproj = gold_train_unpreprocessed_data[\\\"n_nonproj\\\"]\\n msg.info(f\\\"Found {n_nonproj} nonprojective train sentence(s)\\\")\\n if gold_dev_data[\\\"n_nonproj\\\"] > 0:\\n n_nonproj = gold_dev_data[\\\"n_nonproj\\\"]\\n msg.info(f\\\"Found {n_nonproj} nonprojective dev sentence(s)\\\")\\n msg.info(f\\\"{labels_train_unpreprocessed} label(s) in train data\\\")\\n msg.info(f\\\"{len(labels_train)} label(s) in projectivized train data\\\")\\n labels_with_counts = _format_labels(\\n gold_train_unpreprocessed_data[\\\"deps\\\"].most_common(), counts=True\\n )\\n msg.text(labels_with_counts, show=verbose)\\n\\n # rare labels in train\\n for label in gold_train_unpreprocessed_data[\\\"deps\\\"]:\\n if gold_train_unpreprocessed_data[\\\"deps\\\"][label] <= DEP_LABEL_THRESHOLD:\\n msg.warn(\\n f\\\"Low number of examples for label '{label}' \\\"\\n f\\\"({gold_train_unpreprocessed_data['deps'][label]})\\\"\\n )\\n has_low_data_warning = True\\n\\n # rare labels in projectivized train\\n rare_projectivized_labels = []\\n for label in gold_train_data[\\\"deps\\\"]:\\n if gold_train_data[\\\"deps\\\"][label] <= DEP_LABEL_THRESHOLD and \\\"||\\\" in label:\\n rare_projectivized_labels.append(\\n f\\\"{label}: {gold_train_data['deps'][label]}\\\"\\n )\\n\\n if len(rare_projectivized_labels) > 0:\\n msg.warn(\\n f\\\"Low number of examples for {len(rare_projectivized_labels)} \\\"\\n \\\"label(s) in the projectivized dependency trees used for \\\"\\n \\\"training. You may want to projectivize labels such as punct \\\"\\n \\\"before training in order to improve parser performance.\\\"\\n )\\n msg.warn(\\n f\\\"Projectivized labels with low numbers of examples: \\\",\\n \\\", \\\".join(rare_projectivized_labels),\\n show=verbose,\\n )\\n has_low_data_warning = True\\n\\n # labels only in train\\n if set(labels_train) - set(labels_dev):\\n msg.warn(\\n \\\"The following labels were found only in the train data:\\\",\\n \\\", \\\".join(set(labels_train) - set(labels_dev)),\\n show=verbose,\\n )\\n\\n # labels only in dev\\n if set(labels_dev) - set(labels_train):\\n msg.warn(\\n \\\"The following labels were found only in the dev data:\\\",\\n \\\", \\\".join(set(labels_dev) - set(labels_train)),\\n show=verbose,\\n )\\n\\n if has_low_data_warning:\\n msg.text(\\n f\\\"To train a parser, your data should include at \\\"\\n f\\\"least {DEP_LABEL_THRESHOLD} instances of each label.\\\",\\n show=verbose,\\n )\\n\\n # multiple root labels\\n if len(gold_train_unpreprocessed_data[\\\"roots\\\"]) > 1:\\n msg.warn(\\n f\\\"Multiple root labels \\\"\\n f\\\"({', '.join(gold_train_unpreprocessed_data['roots'])}) \\\"\\n f\\\"found in training data. spaCy's parser uses a single root \\\"\\n f\\\"label ROOT so this distinction will not be available.\\\"\\n )\\n\\n # these should not happen, but just in case\\n if gold_train_data[\\\"n_nonproj\\\"] > 0:\\n msg.fail(\\n f\\\"Found {gold_train_data['n_nonproj']} nonprojective \\\"\\n f\\\"projectivized train sentence(s)\\\"\\n )\\n if gold_train_data[\\\"n_cycles\\\"] > 0:\\n msg.fail(\\n f\\\"Found {gold_train_data['n_cycles']} projectivized train sentence(s) with cycles\\\"\\n )\\n\\n msg.divider(\\\"Summary\\\")\\n good_counts = msg.counts[MESSAGES.GOOD]\\n warn_counts = msg.counts[MESSAGES.WARN]\\n fail_counts = msg.counts[MESSAGES.FAIL]\\n if good_counts:\\n msg.good(f\\\"{good_counts} {'check' if good_counts == 1 else 'checks'} passed\\\")\\n if warn_counts:\\n msg.warn(f\\\"{warn_counts} {'warning' if warn_counts == 1 else 'warnings'}\\\")\\n if fail_counts:\\n msg.fail(f\\\"{fail_counts} {'error' if fail_counts == 1 else 'errors'}\\\")\\n sys.exit(1)\",\n \"def train_model(args, train_exs: List[SentimentExample]) -> SentimentClassifier:\\n indexer = Indexer()\\n stop_words = set(stopwords.words('english'))\\n punkt = (',', '.', '...', '?', '\\\\'', '\\\\'\\\\'', '!', ':', ';')\\n # Initialize feature extractor\\n if args.model == \\\"TRIVIAL\\\":\\n feat_extractor = None\\n elif args.feats == \\\"UNIGRAM\\\":\\n # Generate vocabulary\\n for ex in train_exs:\\n for word in ex.words:\\n if word.lower() not in stop_words and word.lower() not in punkt:\\n indexer.add_and_get_index(word.lower())\\n feat_extractor = UnigramFeatureExtractor(indexer)\\n elif args.feats == \\\"BIGRAM\\\":\\n # Generate vocabulary\\n for ex in train_exs:\\n for i in range(0, len(ex.words) - 1):\\n if stop_words.__contains__(ex.words[i]) and stop_words.__contains__(ex.words[i + 1]) or (\\n punkt.__contains__(ex.words[i]) or punkt.__contains__(ex.words[i + 1])):\\n continue\\n bigram = ex.words[i] + ' ' + ex.words[i + 1]\\n indexer.add_and_get_index(bigram.lower())\\n feat_extractor = BigramFeatureExtractor(indexer)\\n elif args.feats == \\\"BETTER\\\":\\n # Generate vocabulary\\n cnt = Counter()\\n for ex in train_exs:\\n cnt.update(\\n word.lower() for word in ex.words if word.lower() not in stop_words and word.lower() not in punkt)\\n cnt = dict(cnt.most_common(int(cnt.__len__() * 0.75)))\\n for keys in cnt.keys():\\n indexer.add_and_get_index(keys)\\n feat_extractor = BetterFeatureExtractor(indexer)\\n else:\\n raise Exception(\\\"Pass in UNIGRAM, BIGRAM, or BETTER to run the appropriate system\\\")\\n\\n # Train the model\\n if args.model == \\\"TRIVIAL\\\":\\n model = TrivialSentimentClassifier()\\n elif args.model == \\\"PERCEPTRON\\\":\\n model = train_perceptron(train_exs, feat_extractor)\\n elif args.model == \\\"LR\\\":\\n model = train_logistic_regression(train_exs, feat_extractor)\\n else:\\n raise Exception(\\\"Pass in TRIVIAL, PERCEPTRON, or LR to run the appropriate system\\\")\\n return model\",\n \"def create_train_model(self):\\n st = LancasterStemmer()\\n with open(self.data_path, encoding='utf8') as f_name:\\n sentences = [[st.stem(w) for w, t in pos_tag(line.lower().split()) if 'N' in t] for line in f_name]\\n sentences = [filter(lambda x: len(x) > 2, (word.strip(punctuation) for word in sentences)) for sent in sentences]\\n model = Word2Vec(sentences,\\n min_count=self.min_count,\\n size=self.size,\\n window=self.window,\\n workers=4)\\n model.save(self.model_path)\",\n \"def put(self):\\n training()\\n return {\\\"message\\\" : \\\"the model trained\\\"}, 201\",\n \"def load_spacy(model=\\\"nb_core_news_sm\\\", file=\\\"combined.jsonl\\\"):\\n print(f\\\"Loading SPACY with model={model} from file={file}\\\")\\n nlp = spacy.load(model)\\n ruler = load_ruler_from_file(nlp, file)\\n patterns = [\\n {\\\"label\\\": \\\"LATERALITET\\\", \\\"pattern\\\": \\\"venstre\\\", \\\"id\\\": \\\"SIN\\\"},\\n {\\\"label\\\": \\\"LATERALITET\\\", \\\"pattern\\\": \\\"høyre\\\", \\\"id\\\": \\\"DXT\\\"},\\n {\\\"label\\\": \\\"SYMPTOM\\\", \\\"pattern\\\": \\\"Smerte\\\", \\\"id\\\": \\\"PAIN\\\"},\\n {\\\"label\\\": \\\"OBSERVATION\\\", \\\"pattern\\\": \\\"BP\\\", \\\"id\\\": \\\"BLOOD_PRESSURE\\\"},\\n {\\\"label\\\": \\\"OBSERVATION\\\", \\\"pattern\\\": \\\"BT\\\", \\\"id\\\": \\\"BLOOD_PRESSURE\\\"},\\n {\\\"label\\\": \\\"OBSERVATION\\\", \\\"pattern\\\": \\\"puls\\\", \\\"id\\\": \\\"PULSE\\\"},\\n {\\\"label\\\": \\\"OBSERVATION\\\", \\\"pattern\\\": \\\"Puls\\\", \\\"id\\\": \\\"PULSE\\\"},\\n {\\\"label\\\": \\\"OBSERVATION\\\", \\\"pattern\\\": \\\"resp\\\", \\\"id\\\": \\\"RESP\\\"},\\n {\\\"label\\\": \\\"OBSERVATION\\\", \\\"pattern\\\": \\\"Resp\\\", \\\"id\\\": \\\"RESP\\\"},\\n {\\\"label\\\": \\\"OBSERVATION\\\", \\\"pattern\\\": \\\"temp\\\", \\\"id\\\": \\\"BODY_TEMP\\\"},\\n {\\\"label\\\": \\\"OBSERVATION\\\", \\\"pattern\\\": \\\"Temp\\\", \\\"id\\\": \\\"BODY_TEMP\\\"},\\n {\\\"label\\\": \\\"OBSERVATION\\\", \\\"pattern\\\": \\\"temperatur\\\", \\\"id\\\": \\\"BODY_TEMP\\\"},\\n {\\\"label\\\": \\\"OBSERVATION\\\", \\\"pattern\\\": \\\"Temperatur\\\", \\\"id\\\": \\\"BODY_TEMP\\\"},\\n\\n {\\\"label\\\": \\\"LAB\\\", \\\"pattern\\\": \\\"hb\\\", \\\"id\\\": \\\"HB\\\"},\\n {\\\"label\\\": \\\"LAB\\\", \\\"pattern\\\": \\\"Hb\\\", \\\"id\\\": \\\"HB\\\"},\\n {\\\"label\\\": \\\"LAB\\\", \\\"pattern\\\": \\\"CRP\\\", \\\"id\\\": \\\"CRB\\\"},\\n\\n {\\\"label\\\": \\\"UNIT\\\", \\\"pattern\\\": \\\"C\\\", \\\"id\\\": \\\"CEL\\\"},\\n {\\\"label\\\": \\\"UNIT\\\", \\\"pattern\\\": \\\"mmHg\\\", \\\"id\\\": \\\"MMHG\\\"}\\n\\n ]\\n print(f\\\"Loading custom patterns of size={len(patterns)}\\\")\\n ruler.add_patterns(patterns)\\n\\n nlp.add_pipe(ruler)\\n print(\\\"Finished loading SPACY\\\")\\n return nlp\",\n \"def process_spacy(self):\\n\\n def prevent_sentence_boundary_detection(doc):\\n for token in doc:\\n # This will entirely disable spaCy's sentence detection\\n token.is_sent_start = False\\n return doc\\n\\n def process_sentence(sen_tokens):\\n doc = spacy.tokens.Doc(nlp.vocab, words=sen_tokens)\\n tagger(doc)\\n prevent_sbd(doc)\\n ner(doc)\\n parser(doc)\\n return doc\\n\\n # setup spacy nlp pipeline\\n nlp = spacy.load(\\\"en_core_web_lg\\\")\\n parser = nlp.get_pipe(\\\"parser\\\")\\n nlp.add_pipe(\\n prevent_sentence_boundary_detection, name=\\\"prevent-sbd\\\", before=\\\"parser\\\"\\n )\\n\\n tagger = nlp.get_pipe(\\\"tagger\\\")\\n prevent_sbd = nlp.get_pipe(\\\"prevent-sbd\\\")\\n parser = nlp.get_pipe(\\\"parser\\\")\\n ner = nlp.get_pipe(\\\"ner\\\")\\n\\n for doc in self.annotation_documents:\\n doc.sentences_processed = []\\n for sen in doc.sentences:\\n sen_tokens = [t.text for t in sen.tokens]\\n sen_proc = process_sentence(sen_tokens)\\n # add processed sentence to doc\\n doc.sentences_processed.append(sen_proc)\\n\\n print(f\\\"Processed with Spacy: {doc.document_id}\\\")\",\n \"def dataset_to_spacy(db, entity_label):\\n\\n train_data = []\\n try:\\n #anyone missing context ??\\n for word in db[entity_label]:\\n if not db[entity_label][word]['context']:\\n continue\\n\\n for contexted_example in db[entity_label][word]['context']:\\n entities = []\\n\\n pure_word = word.replace(\\\"\\\\\\\\\\\",'')\\n if len(word.split(\\\" \\\")) > 1 :\\n\\n start = contexted_example.lower().find(pure_word.lower())\\n if start == -1:\\n print(word)\\n continue\\n\\n end = start+len(word)\\n entities.append((start, end, entity_label))\\n\\n else:\\n splits = list(split_with_indices(contexted_example))\\n for touple in splits:\\n if pure_word.lower() in contexted_example[touple[0]:touple[1]].lower():\\n entities.append((touple[0], touple[0] + len(word), entity_label))\\n\\n train_data.append((contexted_example, {'entities': entities}))\\n\\n except Exception as e:\\n print(e)\\n return None\\n\\n return train_data\",\n \"def train(self, params):\\n for param in params:\\n if param not in self.__info__['space']:\\n print(\\\"Error: not supported parameters {}\\\".format(param))\\n\\n if self.dataset_type == PROBLEM.CLASSIFICATION:\\n model = SVC(C=float(params[\\\"C\\\"]),\\n kernel=params[\\\"Kernel\\\"],\\n gamma=params[\\\"Gamma\\\"],\\n coef0=float(params[\\\"Coef0\\\"]))\\n else:\\n model = SVR(C=float(params[\\\"C\\\"]),\\n kernel=params['Kernel'],\\n gamma=params[\\\"Gamma\\\"],\\n coef0=float(params[\\\"Coef0\\\"]))\\n\\n # train\\n model.fit(self.X_train, self.Y_train)\\n return model\",\n \"def train(self, x_data, y_data):\\n for model in self.list_of_models:\\n model.fit(x_data, y_data)\\n self.trained_models.append(model)\",\n \"def train(self, model, args):\\n if model == self.WORD_DET_RFC:\\n return self.train_rfc(args)\\n elif model == self.REGRESSION_PARAMS:\\n return self.train_bb_reg(args)\\n else:\\n raise Exception('No model %s exists to train' % model)\",\n \"def cli(dataset_path, out_file):\\n data = pd.read_csv(dataset_path)\\n train_X, test_X, train_y, test_y = train_test_split(\\n X, y, test_size=0.2, random_state=1\\n )\\n\\n model = Predictor()\\n model.fit(train_X, train_y)\\n model.dump(out_file)\",\n \"def train_single_model(conf):\\n train_x, train_y, val_x, val_y = load_and_arrange_data(conf, conf['verbose'])\\n if not os.path.exists(conf['models_dir']):\\n os.makedirs(conf['models_dir'], exist_ok=True)\\n\\n model = create_model(train_x, train_y, conf['model_conf'])\\n if conf['verbose']:\\n model.summary()\\n model_path = os.path.join(conf['models_dir'], '%s_%i_working%i.h5' % (\\n conf['window'], conf['input_days'], int(conf['only_working_day'])))\\n conf['train_conf']['model_path'] = model_path\\n conf_path = model_path.replace('.h5', '.json')\\n with open(conf_path, 'w') as f:\\n json.dump(conf, f)\\n\\n model, ret = fit(model, train_x, train_y, [val_x, val_y], conf['train_conf'])\\n _print_train_summary(conf, ret.history)\",\n \"def use_model(model):\\n st.set_page_config(page_title=\\\"MDNER\\\", layout=\\\"wide\\\")\\n streamlit_style = \\\"\\\"\\\"\\n\\t\\t<style>\\n\\t\\t\\thtml, body {\\n\\t\\t\\t font-family: 'Roboto', sans-serif;\\n\\t\\t\\t}\\n\\t\\t</style>\\n\\t\\\"\\\"\\\"\\n st.markdown(streamlit_style, unsafe_allow_html=True)\\n st.markdown(\\n \\\"<h1 style='text-align: center; color: dodgerBlue;'>📑 MDNER 🧬</h1>\\\",\\n unsafe_allow_html=True,\\n )\\n text = st.text_area(\\\"Text to annotate\\\", height=300)\\n run_button, export_button, _ = st.columns([1, 2, 10])\\n with run_button:\\n apply = st.button(\\\"Run\\\")\\n if apply:\\n # Load the best model\\n nlp = spacy.load(f\\\"results/models/{model}/model-best\\\")\\n # Define the colors for the entities\\n colors = {\\n \\\"TEMP\\\": \\\"#FF0000\\\",\\n \\\"SOFT\\\": \\\"#FFA500\\\",\\n \\\"STIME\\\": \\\"#FD6C9E\\\",\\n \\\"FFM\\\": \\\"#00FFFF\\\",\\n \\\"MOL\\\": \\\"#FFFF00\\\",\\n }\\n options = {\\n \\\"ents\\\": [\\n \\\"TEMP\\\",\\n \\\"SOFT\\\",\\n \\\"STIME\\\",\\n \\\"FFM\\\",\\n \\\"MOL\\\",\\n ],\\n \\\"colors\\\": colors,\\n }\\n # Apply the model to the text\\n doc = nlp(text)\\n # Visualize the entities in html\\n html = displacy.render(doc, style=\\\"ent\\\", options=options)\\n st.divider()\\n st.write(html, unsafe_allow_html=True)\\n st.divider()\\n save_to_json(doc, text, export_button)\",\n \"def train(self, data):\\r\\n pos_list = [\\r\\n \\\"adj\\\",\\r\\n \\\"adv\\\",\\r\\n \\\"adp\\\",\\r\\n \\\"conj\\\",\\r\\n \\\"det\\\",\\r\\n \\\"noun\\\",\\r\\n \\\"num\\\",\\r\\n \\\"pron\\\",\\r\\n \\\"prt\\\",\\r\\n \\\"verb\\\",\\r\\n \\\"x\\\",\\r\\n \\\".\\\",\\r\\n ]\\r\\n print(\\\"Train\\\")\\r\\n\\r\\n wordpos_list = [\\r\\n tuple([line[0][i], line[1][i]])\\r\\n for line in data\\r\\n for i in range(len(line[0]))\\r\\n ]\\r\\n\\r\\n pos_dict = {pos: {} for pos in pos_list}\\r\\n\\r\\n wordpos_count = Counter(wordpos_list)\\r\\n\\r\\n for w in wordpos_count:\\r\\n pos_dict[w[1]].update({w[0]: wordpos_count[w]})\\r\\n posterior_prob = {}\\r\\n emission_prob = {}\\r\\n for pos in pos_dict.keys():\\r\\n posterior_prob[pos] = float(sum(pos_dict[pos].values())) / len(wordpos_list)\\r\\n for pos in pos_dict.keys():\\r\\n emission_prob[pos] = {\\r\\n word: float(pos_dict[pos][word]) / sum(pos_dict[pos].values())\\r\\n for word in pos_dict[pos].keys()\\r\\n }\\r\\n\\r\\n trans_count = {}\\r\\n transition_prob = {}\\r\\n for pos in pos_list:\\r\\n trans_count[pos] = {}\\r\\n transition_prob[pos] = {}\\r\\n pair_list = [\\r\\n tuple([line[1][i], line[1][i + 1]])\\r\\n for line in data\\r\\n for i in range(len(line[1]) - 1)\\r\\n ]\\r\\n\\r\\n unique_list = list(set(pair_list))\\r\\n\\r\\n for element in unique_list:\\r\\n trans_count[element[0]].update({element[1]: pair_list.count(element)})\\r\\n\\r\\n for pos in pos_list:\\r\\n transition_prob[pos] = {pos: (1 / float(10 ** 8)) for pos in pos_list}\\r\\n for key, value in trans_count[pos].items():\\r\\n transition_prob[pos].update(\\r\\n {key: (value / float(sum(trans_count[pos].values())))}\\r\\n )\\r\\n initial_list = [line[1][0] for line in data]\\r\\n initial_count = Counter(initial_list)\\r\\n initial_prob = {\\r\\n pos: float(initial_count[pos]) / sum(initial_count.values())\\r\\n for pos in initial_count.keys()\\r\\n }\\r\\n self.position_list = pos_list\\r\\n self.emission_probability = emission_prob\\r\\n self.transition_probability = transition_prob\\r\\n self.initial_probability = initial_prob\\r\\n self.posterior_probability = posterior_prob\",\n \"def make_submission(data, model, path):\\n counter = 0\\n length= len(data)\\n test_predictions = []\\n #Data has form of [(id,vec),(id,vec)....]\\n for instance in data:\\n print(\\\"Prog: \\\",(counter/length*100))\\n counter+=1\\n id = instance[0]\\n vec = instance[1]\\n res = model.predict(vec)\\n print(\\\"Predicted: \\\",res)\\n test_predictions.append({\\\"id\\\":id,\\\"prediction\\\":res})\\n with open(path+\\\".json\\\", \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n for doc in test_predictions:\\n f.write(json.dumps(doc) + \\\"\\\\n\\\")\",\n \"def train(self, trainfile):\\r\\n\\r\\n # We load the data and lower the text\\r\\n data_train = pd.read_csv(trainfile, sep = \\\"\\\\t\\\", names = [\\\"polarity\\\", \\\"category\\\", \\\"word\\\", \\\"offsets\\\", \\\"sentence\\\"])\\r\\n data_train['sentence_l'] = data_train['sentence'].apply(str.lower)\\r\\n data_train['word'] = data_train['word'].apply(str.lower)\\r\\n \\r\\n # We try to keep all the no/nor/not words as this changes radically the sentiment analysis\\r\\n data_train['sentence_l'] = data_train[\\\"sentence_l\\\"].apply(lambda sentence: sentence.replace(\\\"can\\\\'t\\\", \\\"can not\\\"))\\r\\n data_train['sentence_l'] = data_train[\\\"sentence_l\\\"].apply(lambda sentence: sentence.replace(\\\"n\\\\'t\\\", \\\" not\\\"))\\r\\n self.stopwords = stopwords.words(\\\"english\\\")\\r\\n self.stopwords.remove('nor')\\r\\n self.stopwords.remove('no')\\r\\n self.stopwords.remove('not')\\r\\n \\r\\n # We clean the train data and stem the words\\r\\n self.stemmer = nltk.porter.PorterStemmer()\\r\\n clean_sentences = []\\r\\n for row in data_train['sentence_l']:\\r\\n tokens = word_tokenize(row)\\r\\n tokens = [word for word in tokens if word.isalpha()]\\r\\n tokens = [w for w in tokens if not w in self.stopwords] \\r\\n tokens = [self.stemmer.stem(word) for word in tokens]\\r\\n clean_sentences.append(tokens)\\r\\n data_train['stems'] = clean_sentences\\r\\n \\r\\n # We also stem the target words to be coherent with the stemmed words in the sentences\\r\\n data_train['word'] = [self.stemmer.stem(word) for word in data_train['word']]\\r\\n \\r\\n # We recreate the sentences with the selected and cleaned words\\r\\n Classifier.create_sentence = staticmethod(Classifier.create_sentence)\\r\\n data_train.clean_sentence = Classifier.create_sentence(data_train.stems)\\r\\n \\r\\n # We create a BOW vector\\r\\n self.restaurant_vect = CountVectorizer(min_df=1, tokenizer=nltk.word_tokenize)\\r\\n reviews_counts = self.restaurant_vect.fit_transform(data_train.clean_sentence)\\r\\n \\r\\n # We transform the BOW vector with the tfidf scores\\r\\n self.tfidf_transformer = TfidfTransformer()\\r\\n reviews_tfidf = self.tfidf_transformer.fit_transform(reviews_counts)\\r\\n \\r\\n polarities = []\\r\\n for row in data_train['polarity']:\\r\\n if row == 'positive':\\r\\n polarities.append(1)\\r\\n if row == 'neutral':\\r\\n polarities.append(0)\\r\\n if row == 'negative':\\r\\n polarities.append(-1)\\r\\n data_train['polarity_floats'] = polarities\\r\\n \\r\\n # Split data into training and test sets\\r\\n test_size = 10\\r\\n X_train, X_test, y_train, y_test = train_test_split(reviews_tfidf, data_train.polarity_floats,\\r\\n test_size = test_size/100, random_state = None)\\r\\n \\r\\n ############# CNN MODEL ##############\\r\\n \\r\\n from keras.layers import Input, Dense, Embedding, Conv2D, MaxPool2D\\r\\n from keras.layers import Reshape, Flatten, Dropout, Concatenate\\r\\n from keras.callbacks import ModelCheckpoint\\r\\n from keras.optimizers import Adam\\r\\n from keras.models import Model\\r\\n \\r\\n sequence_length = X_train.shape[1] # 7\\r\\n vocabulary_size = X_train.shape[0] # 1503\\r\\n embedding_dim = 256\\r\\n filter_sizes = [3,4,5]\\r\\n num_filters = 512\\r\\n drop = 0.5\\r\\n \\r\\n epochs = 10\\r\\n batch_size = 50\\r\\n \\r\\n # this returns a tensor\\r\\n print(\\\"Creating Model...\\\")\\r\\n inputs = Input(shape=(sequence_length,), dtype='int32')\\r\\n embedding = Embedding(input_dim=vocabulary_size, output_dim=embedding_dim, input_length=sequence_length)(inputs)\\r\\n reshape = Reshape((sequence_length,embedding_dim,1))(embedding)\\r\\n \\r\\n conv_0 = Conv2D(num_filters, kernel_size=(filter_sizes[0], embedding_dim), padding='valid', kernel_initializer='normal', activation='relu')(reshape)\\r\\n conv_1 = Conv2D(num_filters, kernel_size=(filter_sizes[1], embedding_dim), padding='valid', kernel_initializer='normal', activation='relu')(reshape)\\r\\n conv_2 = Conv2D(num_filters, kernel_size=(filter_sizes[2], embedding_dim), padding='valid', kernel_initializer='normal', activation='relu')(reshape)\\r\\n \\r\\n maxpool_0 = MaxPool2D(pool_size=(sequence_length - filter_sizes[0] + 1, 1), strides=(1,1), padding='valid')(conv_0)\\r\\n maxpool_1 = MaxPool2D(pool_size=(sequence_length - filter_sizes[1] + 1, 1), strides=(1,1), padding='valid')(conv_1)\\r\\n maxpool_2 = MaxPool2D(pool_size=(sequence_length - filter_sizes[2] + 1, 1), strides=(1,1), padding='valid')(conv_2)\\r\\n \\r\\n concatenated_tensor = Concatenate(axis=1)([maxpool_0, maxpool_1, maxpool_2])\\r\\n flatten = Flatten()(concatenated_tensor)\\r\\n dropout = Dropout(drop)(flatten)\\r\\n output = Dense(units=1, activation='softmax')(dropout)\\r\\n \\r\\n # this creates a model that includes\\r\\n model = Model(inputs=inputs, outputs=output)\\r\\n \\r\\n checkpoint = ModelCheckpoint('weights.{epoch:03d}-{val_acc:.4f}.hdf5', monitor='val_acc', verbose=1, save_best_only=True, mode='auto')\\r\\n adam = Adam(lr=1e-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)\\r\\n \\r\\n model.compile(optimizer=adam, loss='binary_crossentropy', metrics=['accuracy'])\\r\\n print(\\\"Training Model...\\\")\\r\\n model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, callbacks=[checkpoint], validation_data=(X_test, y_test)) # starts training\\r\",\n \"def main():\\n loader = MicrosoftDataloader()\\n train,dev,test = loader.getData()\\n sentences = []\\n\\n # Collect all the training sentences\\n for i,row in pd.concat((train,test)).iterrows():\\n if isinstance(row[\\\"sentence1\\\"], basestring) and isinstance(row[\\\"sentence2\\\"], basestring):\\n sentences.append(row[\\\"sentence1\\\"])\\n sentences.append(row[\\\"sentence2\\\"])\\n\\n # Get the mapping between sentences and their cotext vectors\\n mapped = get_sentence_to_context_map(sentences)\\n\\n # At this stage we have a map between every sentence and its context vector\\n # However the JSON file must contain sentences in the same order as in the MSR data file\\n data = []\\n for i,sentence in enumerate(sentences):\\n embedding = mapped[sentence]\\n data.append({'index':i, 'embedding':embedding, 'text':sentence})\\n\\n # Write the sentences and embeddings to JSON\\n # The array index should corrospond to the sentence #\\n print \\\"Saving embedded sentences to: {0}\\\".format(EMBED_FILE)\\n with open(EMBED_FILE,'w') as outfile:\\n json.dump(data,outfile,indent=2)\",\n \"def train(self, lib, service, model_name, algorithm, dataset_url, label, train_percentage, features,\\n save_model=True,\\n params=None):\\n url = self.base_url + '/ml-service/phoenix-ml/' + service + '/train'\\n headers = {\\\"ApiKey\\\": self.api_key, \\\"Content-type\\\": \\\"application/json\\\"}\\n if params is None:\\n params = {}\\n body = {\\n \\\"library\\\": lib,\\n \\\"task\\\": \\\"train\\\",\\n \\\"config\\\": {\\n \\\"name\\\": model_name,\\n \\\"algorithm\\\": algorithm,\\n \\\"datasetUrl\\\": dataset_url,\\n \\\"label\\\": label,\\n \\\"trainPercentage\\\": train_percentage,\\n \\\"features\\\": features,\\n \\\"saveModel\\\": save_model,\\n \\\"params\\\": params\\n }\\n }\\n response = requests.post(url=url, json=body, headers=headers)\\n response = response.json()\\n return response\",\n \"def trainModels():\\n\\n # load actives from ChEMBL\\n actives = {}\\n if not os.path.exists(DATA_FOLDER_PATH):\\n os.mkdir(DATA_FOLDER_PATH)\\n actives_file = [x for x in os.listdir(DATA_FOLDER_PATH) if x.startswith('actives_chembl') and x.endswith('.p')]\\n if not actives_file or RELOAD_DATA and not USE_DOWNLOADED_STRUCTS:\\n actives = chembl.loadChEMBLData(ACCESSION, IC_50_THRESHOLD, DATA_FOLDER_PATH)\\n else:\\n actives = pickle.load(open(DATA_FOLDER_PATH + actives_file[0], 'rb'))\\n\\n if not actives_file or RELOAD_DATA and not USE_DOWNLOADED_STRUCTS:\\n chembl.computeConsensualIC50(actives, DATA_FOLDER_PATH)\\n chembl.appendRDKitMols(actives, DATA_FOLDER_PATH)\\n\\n # load decoys downloaded from DUD\\n decoys = {}\\n if os.path.exists(DECOYS_SDF_FILE_PATH[:-4] + \\\".p\\\"):\\n decoys = pickle.load(open(DECOYS_SDF_FILE_PATH[:-4] + \\\".p\\\", 'rb'))\\n else:\\n if os.path.exists(DECOYS_SDF_FILE_PATH):\\n decoys = dud.getDecoys(DECOYS_SDF_FILE_PATH)\\n else:\\n print \\\"Decoys not found in: \\\" + DECOYS_SDF_FILE_PATH\\n print \\\"Make sure you set the right path.\\\"\\n exit()\\n\\n # merge both data sets\\n compounds_all = {}\\n compounds_all.update(actives)\\n compounds_all.update(decoys)\\n\\n # compute Morgan fingerprints\\n if os.path.exists(MERGED_DATASET_PATH) and not RELOAD_DATA:\\n print \\\"Loading previously created dataset...\\\"\\n compounds_all = pickle.load(open(MERGED_DATASET_PATH, 'rb'))\\n else:\\n fingerprinter.appendMorganFingerprints(compounds_all)\\n\\n actives = { cmpndid : compounds_all[cmpndid] for cmpndid in compounds_all.keys() if compounds_all[cmpndid]['active']}\\n pickle.dump(actives, open(ACTIVES_DUMP, 'wb'))\\n decoys = { cmpndid : compounds_all[cmpndid] for cmpndid in compounds_all.keys() if not compounds_all[cmpndid]['active']}\\n\\n # train and cross-validate multiple Naive Bayes Classifiers\\n classification_results = dict()\\n if not os.path.exists(CLASS_RESULTS_SAVE_FILE_PATH) or RELOAD_DATA:\\n classification_results = classification.naiveBayesClassifierTraining(compounds_all)\\n print \\\"Saving results...\\\"\\n pickle.dump(classification_results, open(CLASS_RESULTS_SAVE_FILE_PATH, 'wb'))\\n print \\\"Finished analysis.\\\"\\n else:\\n print \\\"Loading previous results...\\\"\\n classification_results = pickle.load(open(CLASS_RESULTS_SAVE_FILE_PATH, 'rb'))\\n\\n # have fun with the classification results\\n print \\\"# CLASSIFICATION STATISTICS #\\\"\\n classification.playWithResults(classification_results)\\n\\n # cluster actives according to their similarity and keep only the diverse molecules\\n actives_testset = dict()\\n if CLUSTER:\\n clusters = utilities.clusterMols(actives)\\n actives_kept = dict()\\n for cluster in clusters:\\n actives_kept[cluster[0]] = actives[cluster[0]]\\n remains = cluster[1:]\\n actives_filtered_out = {chmblid : actives[chmblid] for chmblid in remains}\\n actives_testset.update(actives_filtered_out)\\n actives = actives_kept\\n\\n # estimate maximum distances between active molecules to set threshold for the application domain\\n # distance_actives = regression.estimateDistanceThreshold(actives) # median of distances between two actives\\n # min_distance_decoys, max_distance_decoys = regression.compareDistances(actives, decoys) # average min/max distance of closest/farthest decoy from any of the actives\\n # print \\\"median of distances between two actives: \\\" + str(distance_actives)\\n # print \\\"average min/max distance of closest/farthest decoy from any of the actives: \\\" + str(min_distance_decoys) + \\\"/\\\" + str(max_distance_decoys)\\n\\n # Support vector regression\\n regression_results = dict()\\n if not os.path.exists(REGRESS_RESULTS_SAVE_FILE_PATH) or RELOAD_DATA:\\n regression_results = regression.supportVectorRegression(actives)\\n pickle.dump(regression_results, open(REGRESS_RESULTS_SAVE_FILE_PATH, 'wb'))\\n else:\\n regression_results = pickle.load(open(REGRESS_RESULTS_SAVE_FILE_PATH, 'rb'))\\n\\n\\n # do something with the regression results\\n print \\\"# REGRESSION STATISTICS #\\\"\\n regression.playWithResults(regression_results, decoys, actives_testset)\\n\\n return classification_results['final_model'], regression_results['final_model']\",\n \"def process_text(model_name: str, text: str) -> spacy.tokens.Doc:\\r\\n nlp = load_model(model_name)\\r\\n return nlp(text)\",\n \"def train(self, trainData):\\n pass\",\n \"def retrain(datapath, model_version):\\n df = get_df(datapath)\\n X = df.drop(columns='target')\\n y = df['target']\\n fitted_model = fit(RF, X, y)\\n\\n with open(f'trained_models/model_{model_version}.joblib', 'wb') as file:\\n joblib.dump(fitted_model, file)\",\n \"def train(self, data, option, param_map):\\n if option == \\\"lr\\\":\\n md = self.logistic_regression(elastic_param=param_map[\\\"elastic_param\\\"],\\n reg_param=param_map[\\\"reg_param\\\"],\\n family=param_map[\\\"family\\\"])\\n elif option == \\\"rf\\\":\\n md = self.random_forest(max_depth=param_map[\\\"max_depth\\\"],\\n max_num_tree=param_map[\\\"max_num_tree\\\"])\\n elif option == \\\"gbdt\\\":\\n md = self.gbdt(max_depth=param_map[\\\"max_depth\\\"],\\n max_bins=param_map[\\\"max_bins\\\"])\\n else:\\n raise ValueError(\\\"ERROR | model %s does not support yet\\\" % option)\\n\\n self.model = md.fit(data)\\n return self.model\",\n \"def train(self):\\n # >>> YOUR ANSWER HERE\\n\\n fake_docs = []\\n fake_words = []\\n fake_words_freq = {}\\n real_docs = []\\n real_words = []\\n real_words_freq = {}\\n\\n # load fake data of the training dataset, store the docs and words\\n fake_data = open(self.train_data['fake']).readlines()\\n for sentence in fake_data:\\n preprocess_sentence = sentence.strip()\\n fake_docs.append(preprocess_sentence)\\n fake_words.extend(preprocess_sentence.split())\\n\\n # load real data of the training dataset, store the docs, words and word frequencies.\\n real_data = open(self.train_data['real']).readlines()\\n for sentence in real_data:\\n preprocess_sentence = sentence.strip()\\n real_docs.append(preprocess_sentence)\\n real_words.extend(preprocess_sentence.split())\\n\\n # remove stop words if necessary\\n if self.REMOVE_STOPWORDS:\\n fake_words = [word for word in fake_words if word not in self.stopwords]\\n real_words = [word for word in real_words if word not in self.stopwords]\\n\\n # calculate all words' frequency\\n for word in fake_words:\\n self.vocabulary.add(word)\\n fake_words_freq[word] = fake_words_freq.get(word, 0) + 1\\n for word in real_words:\\n self.vocabulary.add(word)\\n real_words_freq[word] = real_words_freq.get(word, 0) + 1\\n\\n # pre-calculate the number of all docs, the number of docs per class and words frequency per class for\\n # calculation in the training loop.\\n n_doc = len(fake_docs) + len(real_docs)\\n n_class = {'fake': len(fake_docs), 'real': len(real_docs)}\\n big_doc_dict = {'fake': fake_words_freq, 'real': real_words_freq}\\n fake_words_num = 0\\n real_words_num = 0\\n for w in self.vocabulary:\\n fake_words_num += fake_words_freq.get(w, 0)\\n real_words_num += real_words_freq.get(w, 0)\\n words_frequency_per_class = {'fake': fake_words_num, 'real': real_words_num}\\n\\n # Training\\n for c in self.classes:\\n self.logprior[c] = math.log(n_class[c] / n_doc)\\n for w in self.vocabulary:\\n count_w_c = big_doc_dict[c].get(w, 0)\\n log_likelihood = math.log((count_w_c + 1) / (len(self.vocabulary) + words_frequency_per_class[c]))\\n self.loglikelihood[(w, c)] = log_likelihood\\n # >>> END YOUR ANSWER\",\n \"def main_strategy_2():\\n en_text, de_text, train_iter, dev_iter, _ = clean_data_strategy_2()\\n embedding_en, embedding_de = get_GloVe_embedding(en_text, de_text)\\n model = Model(len(en_text.vocab), len(de_text.vocab), 300, embedding_en, embedding_de)\\n train(model, train_iter, dev_iter)\",\n \"def train_model(schema,fieldsToRead = None):\\n\\tif not fieldsToRead:\\n\\t\\tfieldsToRead = schema[\\\"fields\\\"].keys()\\n\\n\\tif(\\\"vector_size\\\" in schema):\\n\\t\\tvectorSize = schema[\\\"vector_size\\\"]\\n\\telse:\\n\\t\\tvectorSize = DEFAULT_VECTOR_SIZE\\n\\n\\tsentences = []\\n\\t# build sentences:\\n\\tprint \\\"Building Feature vectors...\\\"\\n\\n\\tread_sentences(schema, lambda x : sentences.append(merge_sentences_to_single_sentence(x, fieldsToRead)))\\n\\tprint \\\"Read \\\" + str(len(sentences)) + \\\" documents\\\"\\n\\tprint \\\"Training Model...\\\"\\n\\tmodelPath = model_path(schema)\\n\\tweightMatrixPath = weight_matrix_path(schema)\\n\\tsentences = transpose_sentences(sentences)\\n\\tmodel = Word2Vec(sentences, size=vectorSize, window=5, min_count=1, workers=4)\\n\\tmodel.save(modelPath)\\n\\tmodel.save_word2vec_format(weightMatrixPath)\\n\\tprint \\\"Finished training\\\"\\n\\treturn model\",\n \"def train(self, args_hpo, index):\\n\\n PrintColors.prYellow(f'\\\\n===== training with: {args_hpo} index={index}')\\n PrintColors.prGreen(f'---- in mode: {self.configurations.execution_mode}, tag: {self.configurations.tag} ----')\\n ''' ============ LOAD DATA ================================================================================ '''\\n starting_time = time.time()\\n dataset_reader = self.dataset_reader(\\n candidate_types=self.configurations.clustering_mode,\\n word_indexer={'words': PretrainedTransformerIndexer(self.configurations.pretrained_model_name)},\\n mode=self.configurations.loading_mode)\\n ''' .read returns list of instances '''\\n train_data, val_data, test_data = (dataset_reader.read(folder) for folder in\\n [self.configurations.train_data_dir,\\n self.configurations.val_data_dir,\\n self.configurations.test_data_dir])\\n\\n # count state pairs\\n preceeds = dict()\\n\\n for instance in train_data:\\n for ind in range(len(instance.fields['squeezed_labels'].tokens) - 1):\\n [event_1, event_2] = [instance.fields['squeezed_labels'].tokens[i].text for i in [ind, ind + 1]]\\n scenario = self.dataset_reader.scenario_of_label(event_1)\\n if scenario not in preceeds:\\n preceeds[scenario] = dict()\\n if (event_1, event_2) not in preceeds[scenario]:\\n preceeds[scenario][(event_1, event_2)] = 0\\n preceeds[scenario][(event_1, event_2)] += 1\\n\\n pretrained_tokenizer = PretrainedTransformerTokenizer(self.configurations.pretrained_model_name)\\n supply_token_indices(train_data + val_data, 'story', pretrained_tokenizer)\\n\\n ''' build vocabulary and associate it with datasets '''\\n vocabulary = Vocabulary.from_instances(train_data + val_data)\\n train_data.index_with(vocabulary), val_data.index_with(vocabulary)\\n\\n train_data_loader = DataLoader(dataset=train_data, batch_size=args_hpo.batch_size)\\n val_data_loader = DataLoader(dataset=val_data, batch_size=args_hpo.batch_size)\\n\\n ''' ============ DEFINE MODEL ============================================================================= '''\\n ''' i keep .to() here instead of in model.__init__() to accomadate better abstraction '''\\n event_labels = [i for i in range(vocabulary.get_vocab_size('scr_labels'))\\n if '#' in vocabulary.get_token_from_index(i, 'scr_labels')]\\n participant_labels = [i for i in range(vocabulary.get_vocab_size('scr_labels'))\\n if '@' in vocabulary.get_token_from_index(i, 'scr_labels')]\\n model = self.model(args_hpo, vocabulary, configurations=self.configurations,\\n preceeds=preceeds,\\n event_indices=event_labels,\\n participant_indices=participant_labels).to(self.configurations.device)\\n\\n ''' ============ DEFINE TRAINER =========================================================================== '''\\n ''' -- serialization --------------------------------------------------- '''\\n if not os.path.exists(os.path.join(*['.', 'models'])):\\n os.mkdir(os.path.join(*['.', 'models']))\\n if index == 0:\\n for file in os.listdir(os.path.join(*['.', 'models'])):\\n path = os.path.join(*['.', 'models', file])\\n if os.path.isfile(path):\\n os.remove(path)\\n else:\\n shutil.rmtree(path)\\n serialization_path = 'models_{}_{}'.format(self.configurations.tag, index)\\n serialization_path_longer = os.path.join(*['.', 'models', serialization_path])\\n vocab_path = 'vocab_{}_{}'.format(self.configurations.tag, index)\\n vocab_dir_longer = os.path.join(*['.', 'models', vocab_path])\\n if not os.path.exists(serialization_path_longer):\\n os.mkdir(serialization_path_longer)\\n model_checkpointer = Checkpointer(serialization_dir=serialization_path_longer, num_serialized_models_to_keep=1)\\n ''' -- logging ---------------------------------------------------------- '''\\n tensorboard_writer = TensorboardWriter(serialization_dir='tensorboard', summary_interval=1)\\n if index == 0:\\n shutil.rmtree(os.path.join(*['.', 'tensorboard', 'log']))\\n\\n optimizer = torch.optim.Adam(model.parameters(), lr=args_hpo.lr, weight_decay=args_hpo.l2)\\n trainer = GradientDescentTrainer(\\n model=model,\\n optimizer=optimizer,\\n data_loader=train_data_loader,\\n validation_data_loader=val_data_loader,\\n # note: this is the metric for early stopping\\n validation_metric='-loss',\\n patience=self.configurations.patience,\\n num_epochs=self.configurations.max_epochs,\\n serialization_dir=serialization_path_longer,\\n checkpointer=model_checkpointer,\\n cuda_device=self.configurations.device,\\n grad_norm=args_hpo.clip,\\n tensorboard_writer=tensorboard_writer,\\n learning_rate_scheduler=ReduceOnPlateauLearningRateScheduler(optimizer=optimizer)\\n )\\n\\n ''' trainer saves the model, but the vocabulary needs to be saved, too '''\\n vocabulary.save_to_files(vocab_dir_longer)\\n\\n ''' check the metric names to synchronize with the class '''\\n metrics = trainer.train()\\n test_metrics = model.test(test_data=test_data, dataset_reader=dataset_reader)\\n metrics.update(test_metrics)\\n metrics['time_consumed(hrs)'] = round((time.time() - starting_time) / 3600, 4)\\n\\n return metrics\",\n \"def train_model():\\n print('Loading the dataset...')\\n dataset = pd.read_csv('app/Sentiment_Reviews.csv',index_col=0)\\n X = dataset[['Reviews']]\\n y = dataset[['Sentiment']]\\n le = preprocessing.LabelEncoder()\\n le.fit(y)\\n y = (le.transform(y))\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=38)\\n\\n print('Training the model...')\\n text_clf_svm = Pipeline([('vect', CountVectorizer()), ('tfidf', TfidfTransformer(use_idf=False)), ('clf-svm', SGDClassifier(loss='modified_huber', penalty='l2', alpha=0.001, random_state=42, max_iter=20))])\\n text_clf_svm = text_clf_svm.fit(X_train['Reviews'], y_train)\\n\\n print('Storing model to redis...')\\n pickled_model = pickle.dumps(text_clf_svm)\\n try:\\n redis_client.set('ml_model', pickled_model)\\n except RedisError as e:\\n print('Storing the model was not successful and threw an error.')\\n print(e)\",\n \"def train_text_model(train_dir, num_steps):\\n if tf.gfile.Exists(train_dir):\\n # Delete old model\\n tf.gfile.DeleteRecursively(train_dir)\\n tf.gfile.MakeDirs(train_dir)\\n\\n with tf.Graph().as_default():\\n model = TextModel(_CONFIG)\\n # Specify the loss function:\\n one_hot_labels = slim.one_hot_encoding(model.labels, model.nb_emotions)\\n slim.losses.softmax_cross_entropy(model.logits, one_hot_labels)\\n total_loss = slim.losses.get_total_loss()\\n\\n # Create some summaries to visualize the training process\\n # Use tensorboard --logdir=train_dir, careful with path (add Documents/tumblr-sentiment in front of train_dir)\\n # Different from the logs, because computed on different mini batch of data\\n tf.summary.scalar('Loss', total_loss)\\n \\n # Specify the optimizer and create the train op:\\n optimizer = tf.train.AdamOptimizer(learning_rate=model.learning_rate)\\n train_op = slim.learning.create_train_op(total_loss, optimizer)\\n\\n batch_size = _CONFIG['batch_size']\\n initial_lr = _CONFIG['initial_lr']\\n decay_factor = _CONFIG['decay_factor']\\n nb_batches = model.dataset.num_samples / batch_size\\n def train_step_fn(session, *args, **kwargs):\\n # Decaying learning rate every epoch\\n if train_step_fn.step % (nb_batches) == 0:\\n lr_decay = decay_factor ** train_step_fn.epoch\\n session.run(model.lr_rate_assign, feed_dict={model.lr_rate_placeholder: initial_lr * lr_decay})\\n print('New learning rate: {0}'. format(initial_lr * lr_decay))\\n train_step_fn.epoch += 1\\n\\n # Initialise embedding weights\\n if train_step_fn.step == 0:\\n session.run(model.embedding_init, feed_dict={model.embedding_placeholder: model.embedding})\\n total_loss, should_stop = train_step(session, *args, **kwargs)\\n\\n train_step_fn.step += 1\\n return [total_loss, should_stop]\\n \\n train_step_fn.step = 0\\n train_step_fn.epoch = 0\\n\\n # Run the training:\\n final_loss = slim.learning.train(\\n train_op,\\n logdir=train_dir,\\n save_interval_secs=600,\\n save_summaries_secs=600,\\n train_step_fn=train_step_fn,\\n number_of_steps=num_steps)\\n \\n print('Finished training. Last batch loss {0:.3f}'.format(final_loss))\",\n \"def train(self, request):\\n model = request.get(\\\"model\\\")\\n if not model:\\n raise MONAILabelException(\\n MONAILabelError.INVALID_INPUT,\\n \\\"Model is not provided for Training Task\\\",\\n )\\n\\n task = self._trainers.get(model)\\n if not task:\\n raise MONAILabelException(\\n MONAILabelError.INVALID_INPUT,\\n f\\\"Train Task is not Initialized. There is no model '{model}' available\\\",\\n )\\n\\n request = copy.deepcopy(request)\\n result = task(request, self.datastore())\\n\\n # Run all scoring methods\\n if self._auto_update_scoring:\\n self.async_scoring(None)\\n return result\",\n \"def train(fine_tuning):\\n features = np.array([\\\"my first sentence\\\", \\\"my second sentence\\\"])\\n labels = np.array([1, 0])\\n dataset = tf.data.Dataset.from_tensor_slices((features, labels))\\n\\n module = tf.saved_model.load(FLAGS.model_dir)\\n\\n # Create the sequential keras model.\\n l = tf.keras.layers\\n model = tf.keras.Sequential()\\n model.add(l.Reshape((), batch_input_shape=[None, 1], dtype=tf.string))\\n # TODO(b/124219898): output_shape should be optional.\\n model.add(hub.KerasLayer(module, output_shape=[10], trainable=fine_tuning))\\n model.add(l.Dense(100, activation=\\\"relu\\\"))\\n model.add(l.Dense(50, activation=\\\"relu\\\"))\\n model.add(l.Dense(1, activation=\\\"sigmoid\\\"))\\n\\n model.compile(\\n optimizer=\\\"adam\\\",\\n loss=\\\"binary_crossentropy\\\",\\n metrics=[\\\"accuracy\\\"],\\n # TODO(b/124446120): Remove after fixed.\\n run_eagerly=True)\\n\\n model.fit_generator(generator=dataset.batch(1), epochs=5)\\n\\n # This is testing that a model using a SavedModel can be re-exported again,\\n # e.g. to catch issues such as b/142231881.\\n tf.saved_model.save(model, tempfile.mkdtemp())\",\n \"def train_model_for_shap(allFeatures, train_ml, test_ml, df_ml, classification_model, language_model, fold):\\n # list of analyzed language models\\n model = classification_model\\n print(type(model).__name__)\\n\\n features = set(allFeatures[language_model][fold])\\n preds = []\\n trues = []\\n\\n train_index = train_ml[fold]\\n test_index = test_ml[fold]\\n\\n train_data = df_ml[features].iloc[train_index]\\n target_train_data = df_ml[\\\"target_ml\\\"].iloc[train_index]\\n test_data = df_ml[features].iloc[test_index]\\n target_test_data = df_ml.iloc[test_index][\\\"target_ml\\\"]\\n model.fit(train_data, target_train_data)\\n\\n preds.append(model.predict(test_data).tolist())\\n trues.append(target_test_data.tolist())\\n\\n print(language_model)\\n mcc = metrics.matthews_corrcoef(y_true=sum(trues, []), y_pred=sum(preds, []))\\n f1 = metrics.f1_score(y_true=sum(trues, []), y_pred=sum(preds, []), average=\\\"weighted\\\")\\n print(\\\"MCC: \\\", round(mcc, 3))\\n print(\\\"F1: \\\", round(f1, 3))\\n return model, train_data, test_data\",\n \"def train_model(x_data, y_data, model_type):\\n # def lr model object\\n clr = None\\n try:\\n clr = model_list[model_type]()\\n except Exception as e:\\n print(e)\\n # fit model\\n clr.fit(x_data, y_data)\\n # save model in pkl file\\n try:\\n joblib.dump(clr, \\\"model/\\\" + model_type + \\\".pkl\\\")\\n except Exception as e:\\n print(e)\\n return clr\",\n \"def train_model(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def model_train(data_dir,test=False):\\r\\n \\r\\n if not os.path.isdir(MODEL_DIR):\\r\\n os.mkdir(MODEL_DIR)\\r\\n\\r\\n if test:\\r\\n print(\\\"... test flag on\\\")\\r\\n print(\\\"...... subsetting data\\\")\\r\\n print(\\\"...... subsetting countries\\\")\\r\\n \\r\\n ## fetch time-series formatted data\\r\\n ts_data = fetch_ts(data_dir)\\r\\n\\r\\n ## train a different model for each data sets\\r\\n for country,df in ts_data.items():\\r\\n if test and country not in ['all','united_kingdom']:\\r\\n continue\\r\\n model_name = re.sub(\\\"\\\\.\\\",\\\"_\\\",str(MODEL_VERSION))\\r\\n saved_model = os.path.join(MODEL_DIR,\\r\\n \\\"sl-{}-{}.joblib\\\".format(country,model_name))\\r\\n saved_test_model = os.path.join(MODEL_DIR,\\r\\n \\\"test-{}-{}.joblib\\\".format(country,model_name))\\r\\n saved_baseline = os.path.join(BASELINE_DIR,\\r\\n \\\"b-sl-{}-{}.joblib\\\".format(country,model_name))\\r\\n saved_test_baseline = os.path.join(BASELINE_DIR,\\r\\n \\\"b-test-{}-{}.joblib\\\".format(country,model_name))\\r\\n if (test and (not os.path.isfile(saved_test_model))) or ((not test) and (not os.path.isfile(saved_model))):\\r\\n _model_train(df,country,test=test)\\r\\n if (test and (not os.path.isfile(saved_test_baseline))) or ((not test) and (not os.path.isfile(saved_baseline))):\\r\\n _baseline_train(df,country,test=test)\",\n \"def train(self) -> None:\\n\\n # Check if in the saved model path there is already a trained model\\n if self.config.TRN_HYPERP[\\\"save_path\\\"]:\\n if tf.saved_model.contains_saved_model(self.config.TRN_HYPERP[\\\"save_path\\\"]):\\n print(\\\"INFO: An existing saved model will be used for inference\\\\n\\\")\\n else:\\n params = {**self.config.TRN_HYPERP, **self.config.DATASET_HYPERP}\\n trainer = Trainer(**params)\\n\\n print(f\\\"INFO: Starting training ... \\\\n\\\")\\n start_time = time.time()\\n trainer.train()\\n print(f\\\"\\\\nINFO: Training completed in {round((time.time() - start_time)/60, 2)} minutes.\\\\n\\\")\\n\\n # Instantiate the saved translator for inference\\n saved_path = self.config.TRN_HYPERP[\\\"save_path\\\"]\\n self.saved_translator = tf.saved_model.load(saved_path)\\n else:\\n print(\\\"INFO: Path to save model wasn't provided in config file. Can't train the model\\\\n\\\")\",\n \"def _read_data_taskA(data_path: str=\\\"path\\\", tokenizer=None, \\n bert: bool=False, \\n mode: str=\\\"raw\\\", \\n tagger=None, \\n test: bool=False, \\n test_samples=None\\n ):\\n print(f\\\"\\\\n[dataset]: Loading data from '{data_path}'...\\\")\\n sentences = []\\n labels = []\\n tok_list = []\\n words_list = []\\n targets_list = []\\n target_final = []\\n\\n data_dict = read_json_data(data_path) if not test else test_samples\\n #print(\\\"data_dict:\\\", len(data_dict))\\n\\n for entry in data_dict:\\n # tokenize data sentences\\n if bert:\\n tokens = tokenizer.tokenize(entry[\\\"text\\\"])\\n tokens.insert(0, \\\"[CLS]\\\") # RoBERTa \\\"<s>\\\" <-> BERT \\\"[CLS]\\\" \\n tokens.append(\\\"[SEP]\\\") # RoBERTa \\\"</s>\\\" <-> BERT \\\"[SEP]\\\"\\n else:\\n tokens = tokenizer(entry[\\\"text\\\"])\\n \\n words_list.extend(tokens)\\n tok_list.append(tokens)\\n\\n if mode == \\\"tokenize\\\":\\n sentences.append(tokens)\\n elif mode == \\\"raw\\\":\\n sentences.append(entry[\\\"text\\\"])\\n\\n # count target words\\n t_list = []\\n if not test:\\n targets = entry[\\\"targets\\\"]\\n tgt_list = []\\n if len(targets) > 0:\\n t_list.append(targets)\\n for tgt in targets:\\n targets_list.append(tgt[1])\\n tgt_list.append(tgt[1])\\n else:\\n t_list.append([])\\n\\n # tag input tokens\\n b_tok = tokenizer if bert else None\\n tags = tagger(targets, tokens, bert_tokenizer=b_tok)\\n #print(tags)\\n\\n labels.append(tags)\\n target_final.append(tgt_list)\\n\\n else:\\n labels.append(\\\"dummy\\\")\\n target_final.append(0)\\n \\n if not test: \\n assert len(sentences) == len(labels)\\n print(\\\"sentences:\\\",len(sentences))\\n print(\\\"labels:\\\",len(labels))\\n\\n # count words occurency and frequency \\n word_counter = collections.Counter(words_list)\\n distinct_words = len(word_counter)\\n print(f\\\"Number of distinct words: {distinct_words}\\\")\\n \\n # count target words occurency and frequency\\n tgts_counter = collections.Counter(targets_list)\\n distinct_tgts = len(tgts_counter)\\n print(f\\\"Number of distinct targets: {distinct_tgts}\\\")\\n\\n return sentences, labels, targets_list, word_counter\\n else:\\n return list(zip(sentences, labels, target_final, tok_list))\",\n \"def train_txt(txt_path, model_path):\\n\\n vectors = svmlight_to_vectors(txt_path)\\n MAXENT_LOG.info(\\\"Attempting to train classifier {}\\\".format(model_path))\\n p = ProcessCommunicator([mallet_bin, 'train-classifier',\\n '--input', vectors,\\n '--trainer', 'MaxEntTrainer',\\n '--output-classifier', model_path],\\n stdout_func=MAXENT_LOG.info, stderr_func=MAXENT_LOG.info)\\n\\n if p.wait() == 0:\\n MAXENT_LOG.debug(\\\"Success.\\\")\\n os.unlink(vectors)\\n return MalletMaxent(model_path)\\n else:\\n raise ClassifierException(\\\"Training the classifier did not complete. Check the logs.\\\")\",\n \"def train(self, X, y):\\n tf.logging.set_verbosity(\\n tf.logging.INFO) # comment if you don't want to display the information during training/evaluation\\n\\n X_train, X_test, y_train, y_test = train_test_split(\\n X, y, test_size=self.params[\\\"TEST_SIZE\\\"], random_state=42, stratify=y)\\n\\n self.label_list = y.unique()\\n\\n train_features = self.sentences_to_features(X_train, y_train)\\n test_features = self.sentences_to_features(X_test, y_test)\\n if DEBUG:\\n print(\\\"Transformation to features completed\\\")\\n\\n num_train_steps = int(\\n len(train_features) / self.params[\\\"BATCH_SIZE\\\"] * self.params[\\\"NUM_TRAIN_EPOCHS\\\"])\\n num_warmup_steps = int(\\n num_train_steps * self.params[\\\"WARMUP_PROPORTION\\\"])\\n\\n run_config = self.run_config_builder()\\n model_fn = self.model_fn_builder(len(self.label_list), self.params[\\\"LEARNING_RATE\\\"], num_train_steps,\\n num_warmup_steps)\\n self.estimator = self.estimator_builder(model_fn, run_config)\\n\\n train_input_fn = bert.run_classifier.input_fn_builder(features=train_features,\\n seq_length=self.params[\\\"MAX_SEQ_LENGTH\\\"],\\n is_training=True, drop_remainder=False)\\n if DEBUG:\\n print(\\\"Beginning Training!\\\")\\n current_time = time.time()\\n self.estimator.train(input_fn=train_input_fn,\\n max_steps=num_train_steps)\\n if DEBUG:\\n print(\\\"Training took time :\\\", time.time() - current_time,\\n \\\"s, or \\\", (time.time() - current_time) / 60, \\\"min\\\")\\n\\n self.classifier_trained = True\\n\\n test_input_fn = run_classifier.input_fn_builder(features=test_features,\\n seq_length=self.params[\\\"MAX_SEQ_LENGTH\\\"],\\n is_training=False, drop_remainder=False)\\n\\n # apply model on test set and print all metrics\\n if DEBUG:\\n print(\\\"Evaluating\\\")\\n self.estimator.evaluate(input_fn=test_input_fn, steps=None)\",\n \"def training(self) -> None:\\n self.compile_model()\\n self.train_epoch()\\n self.agent.save()\",\n \"def train(\\n self,\\n train_processed_data_dir: Path,\\n val_processed_data_dir: Path,\\n force_retrain: bool = False,\\n ) -> NoReturn:\\n if force_retrain or not self.is_training_completed():\\n self.logger.info(self.logging_prefix + f\\\"Training model at {self.model_dir}; train: {train_processed_data_dir}, val: {val_processed_data_dir}\\\")\\n IOUtils.rm_dir(self.model_dir)\\n IOUtils.mk_dir(self.model_dir)\\n\\n # Save spec & configs of this model\\n IOUtils.dump(self.model_dir/\\\"config-dict.json\\\", IOUtils.jsonfy(self.config), IOUtils.Format.jsonPretty)\\n IOUtils.dump(self.model_dir/\\\"spec.json\\\", IOUtils.jsonfy(self.spec), IOUtils.Format.jsonPretty)\\n self.train_impl(train_processed_data_dir, val_processed_data_dir)\\n IOUtils.dump(self.model_dir / self.TRAINING_COMPLETED_FILE_NAME, str(time.time_ns()), IOUtils.Format.txt)\\n # end if\\n return\",\n \"def json2txt_for_corenlp(json_home, dataset, data_type, saved_home, fine_grad=True, use_orig_keys=False, variations=False, sort_keyphrases=False, match_ending_parenthesis=False, use_corenlp=True, separate_present_absent=False, find_redirections=False):\\n keyphrase_stat = {'num_keyphrases_with_variations': 0, 'num_keyphrases': 0, 'num_variations': 0,\\n 'num_keyphrases_with_match_disambiguation': 0, 'num_extracted_acronym': 0, 'num_keyphrases_with_redirections': 0,\\n 'num_redirections': 0, 'num_matched_disambiguation': 0}\\n #num_keyphrases_with_variations = 0\\n #num_keyphrases = 0\\n #num_variations = 0\\n #num_keyphrases_with_match_disambiguation = 0\\n\\n if variations and sort_keyphrases:\\n raise ValueError(\\\"You cannot use sort_keyphrases when you need to find the variations of each keyphrase\\\")\\n\\n print('\\\\nProcessing {} data...'.format(data_type))\\n saved_data_dir = os.path.join(saved_home, 'data_for_corenlp')\\n if not os.path.exists(saved_data_dir):\\n os.makedirs(saved_data_dir)\\n json_file_name = os.path.join(json_home, \\\"{}_{}.json\\\".format(dataset, data_type))\\n json_file = open(json_file_name, encoding='utf-8')\\n processed_files_suffix = \\\"\\\"\\n if variations:\\n processed_files_suffix += \\\"_variations\\\"\\n if find_redirections:\\n processed_files_suffix += \\\"_redirections\\\"\\n if sort_keyphrases:\\n processed_files_suffix += \\\"_sorted\\\"\\n if match_ending_parenthesis:\\n processed_files_suffix += \\\"_parenthesis\\\"\\n if separate_present_absent:\\n processed_files_suffix += \\\"_separated\\\"\\n if fine_grad_digit_matching:\\n processed_files_suffix += \\\"_digit\\\"\\n if reverse_sorting:\\n processed_files_suffix += \\\"_reversed\\\"\\n if replace_with_space:\\n processed_files_suffix += \\\"_space\\\"\\n\\n processed_keyword_file = open(os.path.join(saved_data_dir, \\\"{}_{}_keyword_for_corenlp{}.txt\\\".format(dataset, data_type, processed_files_suffix)),\\n 'w', encoding='utf-8')\\n # context = title + '.' + '<eos>' + abstract\\n processed_context_file = open(os.path.join(saved_data_dir, \\\"{}_{}_context_for_corenlp{}.txt\\\".format(dataset, data_type, processed_files_suffix)),\\n 'w', encoding='utf-8')\\n lines = json_file.readlines()\\n for line_idx in tqdm(range(len(lines))):\\n line = lines[line_idx]\\n line_dict = json.loads(line.strip())\\n # tokenization, lowercasing, replace all digits with '<digit>' symbol\\n title = line_dict['title'].strip()\\n abstract = line_dict['abstract'].strip()\\n keywords = line_dict['keyword'].strip()\\n # lowercasing the text\\n title = title.lower()\\n abstract = abstract.lower()\\n keywords = keywords.lower()\\n # filter out no-title or no-abstract data\\n if len(title) == 0 or len(abstract) == 0:\\n continue\\n # concatenate title and abstract\\n context = title + ' . ' + ' <eos> ' + abstract\\n\\n # for fine granularity tokenization\\n context_tokens = get_tokens(context, fine_grad=fine_grad, use_corenlp=use_corenlp)\\n context = ' '.join(context_tokens)\\n if not use_orig_keys:\\n if data_type != 'testing':\\n limit_num = True\\n else:\\n limit_num = False\\n keywords = ';'.join(\\n process_keyphrase(keywords, context_tokens, keyphrase_stat, variations=variations, limit_num=limit_num,\\n fine_grad=fine_grad, sort_keyphrases=sort_keyphrases,\\n match_ending_parenthesis=match_ending_parenthesis, use_corenlp=use_corenlp,\\n separate_present_absent=separate_present_absent, find_redirections=find_redirections))\\n else:\\n keywords = ';'.join(keywords.strip().split(';'))\\n\\n context_line = context + '\\\\n'\\n keywords_line = keywords + '\\\\n'\\n\\n processed_keyword_file.write(keywords_line)\\n processed_context_file.write(context_line)\\n\\n processed_keyword_file.close()\\n processed_context_file.close()\\n print(\\\"# keyphrases: {}\\\".format(keyphrase_stat['num_keyphrases']))\\n if variations:\\n print(\\\"# variations: {}\\\".format(keyphrase_stat['num_variations']))\\n print(\\\"# keyphrases with variations: {}\\\".format(keyphrase_stat['num_keyphrases_with_variations']))\\n print(\\\"# keyphrases with match disambiguation: {}\\\".format(keyphrase_stat['num_keyphrases_with_match_disambiguation']))\\n print(\\\"# matched disambiguation: {}\\\".format(keyphrase_stat['num_matched_disambiguation']))\\n if match_ending_parenthesis:\\n print(\\\"# extracted acronyms: {}\\\".format(keyphrase_stat['num_extracted_acronym']))\\n if find_redirections:\\n print('# redirections found: {}'.format(keyphrase_stat['num_redirections']))\\n print('# keyphrases with redirections: {}'.format(keyphrase_stat['num_keyphrases_with_redirections']))\\n # keyphrase_stat = {'num_keyphrases_with_variations': 0, 'num_keyphrases': 0, 'num_variations': 0, 'num_keyphrases_with_match_disambiguation': 0}\",\n \"def train_model(self, data:List[np.ndarray]):\\n d = np.vstack(data)\\n np.random.shuffle(d)\\n self.regressor.fit(\\n X=self.input(d),\\n y=self.output(d)\\n )\",\n \"def loadSavedModel(folder, spark_session, loadsp=False):\\n from sparknlp.internal import _USELoader\\n jModel = _USELoader(folder, spark_session._jsparkSession, loadsp)._java_obj\\n return UniversalSentenceEncoder(java_model=jModel)\",\n \"def train(self, x_data, y_data):\\n self.model.fit(np.array(x_data), np.array(y_data),\\n batch_size=2,\\n epochs=3,\\n verbose=1)\\n self.model.save_weights(self.model_filename)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6168623","0.60145473","0.59643066","0.59500396","0.59390277","0.5891947","0.58586216","0.58549035","0.5753519","0.569553","0.5639808","0.5621899","0.56205606","0.561257","0.56034636","0.55959255","0.559412","0.5584512","0.55254185","0.54839414","0.54839414","0.5473902","0.54411864","0.543377","0.54204756","0.5402436","0.5392237","0.5391893","0.537127","0.5369868","0.53673756","0.5364206","0.5340289","0.53391796","0.5328474","0.5306195","0.52807885","0.52762264","0.5271347","0.52684355","0.5261275","0.52506727","0.52379096","0.52260077","0.5221428","0.5218297","0.5212646","0.51987135","0.5196656","0.5189838","0.5183679","0.51822054","0.5178525","0.5178225","0.5177578","0.51717013","0.5169683","0.5162993","0.5152014","0.5146543","0.5144234","0.5141613","0.514139","0.5137404","0.51335764","0.5132262","0.51301205","0.5128389","0.51240385","0.51198006","0.51124537","0.5106372","0.5105392","0.510035","0.50992376","0.5091912","0.50873584","0.5086295","0.50717854","0.5069396","0.5062356","0.50605065","0.50519943","0.50461173","0.5032194","0.5030706","0.5030157","0.5029299","0.5024733","0.5020693","0.5017006","0.50151634","0.501385","0.49982968","0.49935892","0.4989529","0.49756604","0.49690038","0.49689364","0.49642554"],"string":"[\n \"0.6168623\",\n \"0.60145473\",\n \"0.59643066\",\n \"0.59500396\",\n \"0.59390277\",\n \"0.5891947\",\n \"0.58586216\",\n \"0.58549035\",\n \"0.5753519\",\n \"0.569553\",\n \"0.5639808\",\n \"0.5621899\",\n \"0.56205606\",\n \"0.561257\",\n \"0.56034636\",\n \"0.55959255\",\n \"0.559412\",\n \"0.5584512\",\n \"0.55254185\",\n \"0.54839414\",\n \"0.54839414\",\n \"0.5473902\",\n \"0.54411864\",\n \"0.543377\",\n \"0.54204756\",\n \"0.5402436\",\n \"0.5392237\",\n \"0.5391893\",\n \"0.537127\",\n \"0.5369868\",\n \"0.53673756\",\n \"0.5364206\",\n \"0.5340289\",\n \"0.53391796\",\n \"0.5328474\",\n \"0.5306195\",\n \"0.52807885\",\n \"0.52762264\",\n \"0.5271347\",\n \"0.52684355\",\n \"0.5261275\",\n \"0.52506727\",\n \"0.52379096\",\n \"0.52260077\",\n \"0.5221428\",\n \"0.5218297\",\n \"0.5212646\",\n \"0.51987135\",\n \"0.5196656\",\n \"0.5189838\",\n \"0.5183679\",\n \"0.51822054\",\n \"0.5178525\",\n \"0.5178225\",\n \"0.5177578\",\n \"0.51717013\",\n \"0.5169683\",\n \"0.5162993\",\n \"0.5152014\",\n \"0.5146543\",\n \"0.5144234\",\n \"0.5141613\",\n \"0.514139\",\n \"0.5137404\",\n \"0.51335764\",\n \"0.5132262\",\n \"0.51301205\",\n \"0.5128389\",\n \"0.51240385\",\n \"0.51198006\",\n \"0.51124537\",\n \"0.5106372\",\n \"0.5105392\",\n \"0.510035\",\n \"0.50992376\",\n \"0.5091912\",\n \"0.50873584\",\n \"0.5086295\",\n \"0.50717854\",\n \"0.5069396\",\n \"0.5062356\",\n \"0.50605065\",\n \"0.50519943\",\n \"0.50461173\",\n \"0.5032194\",\n \"0.5030706\",\n \"0.5030157\",\n \"0.5029299\",\n \"0.5024733\",\n \"0.5020693\",\n \"0.5017006\",\n \"0.50151634\",\n \"0.501385\",\n \"0.49982968\",\n \"0.49935892\",\n \"0.4989529\",\n \"0.49756604\",\n \"0.49690038\",\n \"0.49689364\",\n \"0.49642554\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7009214"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92882,"cells":{"query":{"kind":"string","value":"Returns mean score between tasks in pipeline that can be used for early stopping."},"document":{"kind":"string","value":"def _score_for_model(meta):\n mean_acc = list()\n pipes = meta[\"pipeline\"]\n acc = meta[\"accuracy\"]\n if \"tagger\" in pipes:\n mean_acc.append(acc[\"tags_acc\"])\n if \"morphologizer\" in pipes:\n mean_acc.append((acc[\"morphs_acc\"] + acc[\"pos_acc\"]) / 2)\n if \"parser\" in pipes:\n mean_acc.append((acc[\"uas\"] + acc[\"las\"]) / 2)\n if \"ner\" in pipes:\n mean_acc.append((acc[\"ents_p\"] + acc[\"ents_r\"] + acc[\"ents_f\"]) / 3)\n if \"textcat\" in pipes:\n mean_acc.append(acc[\"textcat_score\"])\n if \"senter\" in pipes:\n mean_acc.append((acc[\"sent_p\"] + acc[\"sent_r\"] + acc[\"sent_f\"]) / 3)\n return sum(mean_acc) / len(mean_acc)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def avgcpu(self):\n return (self._total_cpu['value'] / self._total_cpu['count']) if self._total_cpu['count'] else 0","def score(self, task):\n raise NotImplementedError(\"must subclass and implement score(task)\")","def getAverage(self):\n return sum(self.scores) / len(self.scores)","def get_mean_score(rating_scores):\n return sum(rating_scores) / len(rating_scores)","def calculate(self):\n avg = self.sum / self.n if self.n != 0 else 0\n self.running_avg.append(avg)\n return avg","def score( self ):\r\n result = 0.0\r\n for rr in self.ee.getRsrcs( ):\r\n value = self.scoreRsrc( rr )\r\n result += value\r\n print( \"INFO: Value for the schedule is %s \" % ( rr, result ) )\r\n return( result )","def calc_mean_score(movies: List[Movie]) -> float:\n return round(sum([m.score for m in movies]) / len(movies), 1)","def mean(self):\n return self.cond_proba.mean","def get_average(self) -> float:\n return sum(self._scores) / len(self._scores)","def average_waiting(self):\n return self._average_waiting","def data_flow_steps_avg(self) -> Optional[float]:\n if self.has_data_flow:\n return float(self.graph_tuple_stats.data_flow_steps_avg)","def get_mean(cls, data: tuple or list) -> float:\n cls._data_validation(data)\n sum_ = fsum(data)\n n = cls.get_n(data)\n try:\n return float(sum_ / n)\n except ZeroDivisionError as exc:\n # for hyp score calculation, n = 0 for empty set is useful\n return 0","def get_mean_cv_score(model, X, y, scoring, cv, n_jobs, verbose):\n \n mean_cv_score = cross_val_score_torch(model, X, y, scoring, cv, n_jobs, verbose).mean()\n return mean_cv_score","def get_runs_to_average(self):\n\n if Test.performance_params: return int(Test.performance_params[1])\n elif self._check_performance: return self._runs_to_average\n else: return None","def _get_mean(self, sums, step):\n\n return sums/step","def get_average_repro(self):\n return np.mean([agent.get_fledge_probability() for agent in self.agents])","def avg_e_score(self, entity):\n return float(entity['es']) / float(entity['count'])","def data_flow_positive_node_count_avg(self) -> Optional[int]:\n if self.has_data_flow:\n return int(self.graph_tuple_stats.data_flow_positive_node_count_avg or 0)","def avg(self):\n return sum(self.times) / len(self.times)","def avg(self):\n return sum(self.times) / len(self.times)","def avg(self):\n return sum(self.times) / len(self.times)","def avg_act(self) -> float:\n return torch.mean(self.units.act)","def average_pending(self):\n return self._average_pending","def avg(self):\n if not self.committed_together:\n return 0\n\n return round(statistics.mean(self.committed_together))","def get_average_progress(self, event=None):\n cnt_items = len(self)\n sum_progress = None\n\n if event == self.EVENT_TOTAL_PROGRESS:\n return self.get_average_complete_progress()\n\n if event is None:\n sum_progress = sum(map(lambda node: node.get_average_progress(), self.values()))\n else:\n sum_progress = self.get_sum_progress_event(event)\n\n if cnt_items > 0:\n return sum_progress * 1.0 / cnt_items\n\n return 0.0","def avg():\n\n # call sum method to add up the values in the collection & div by the num of items\n # call len method to compute the # of vals in collection which is divided by sum total \n mean = sum(inlist) / len(inlist)\n return mean \n\n # alternate method would be calling the reduce method with lamda \n # return reduce(lambda a, b: a + b, inlist) / len(inlist)","def calculate_score_vm(self, vm):\n vm_cpu_utilization = self.ceilometer. \\\n statistic_aggregation(\n resource_id=vm.uuid,\n meter_name=self.INSTANCE_CPU_USAGE_METRIC_NAME,\n period=\"7200\",\n aggregate='avg'\n )\n if vm_cpu_utilization is None:\n LOG.error(\n _LE(\"No values returned by %(resource_id)s \"\n \"for %(metric_name)s\"),\n resource_id=vm.uuid,\n metric_name=self.INSTANCE_CPU_USAGE_METRIC_NAME,\n )\n vm_cpu_utilization = 100\n\n cpu_capacity = self.model.get_resource_from_id(\n resource.ResourceType.cpu_cores).get_capacity(vm)\n\n total_cores_used = cpu_capacity * (vm_cpu_utilization / 100.0)\n\n return self.calculate_weight(vm, total_cores_used, 0, 0)","def score(self, input_fn=None, steps=None):\n return np.sum(\n self.evaluate(\n input_fn=input_fn, steps=steps)[KMeansClustering.SCORES])","def get_score(self):\n rewards, resets = self.runner.get_rewards_resets()\n self.runner.clear_rewards_resets()\n assert rewards.ndim == 1 and resets.ndim == 1, (rewards.ndim, resets.ndim)\n assert rewards.shape[0] == resets.shape[0], (rewards.shape, resets.shape)\n scores = [0]\n for t in reversed(range(rewards.shape[0])):\n if resets[t]:\n scores.append(0)\n scores[-1] += rewards[t]\n return np.mean(scores)","def get_multiple_align_score(self, seq : Seq, dna_sequences : numpy_array, tasks : list, pool : ThreadPool) -> float: \n def _calc_multiple_alignment_score(wrapped_data : tuple) -> int:\n \"\"\"return value is a sum of all alignment scores in input rangerange.\"\"\" \n (start, finish) = wrapped_data \n score_sum = 0.\n for dna_record in tqdm(dna_sequences[start : finish + 1], total=(finish + 1 - start), desc=\"Training process\"):\n score_sum += self.aligner.score(seq, dna_record.seq)\n return score_sum\n return sum(s for s in pool.map(_calc_multiple_alignment_score, tasks))","def average(self):\n return self.summation() / self.count()","def _compute_scores(self, triples):\n # compute scores as sum(s * p * o)\n scores = tf.reduce_sum(triples[0] * triples[1] * triples[2], 1)\n return scores","def avg_hops(self):\n return self._avg_hops","def _compute_mean(index, M, R, rake):\r\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\r\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\r\n\r\n return mean","def _compute_mean(index, M, R, rake):\r\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\r\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\r\n\r\n return mean","def get_netavg (values, var_names, robot_file, enemy_files, num_matches, cpu_count, seed_list):\n total_matches = 0\n total_all_scores = []\n \n variables = dict(zip(var_names, list(values)))\n robot_to_eval = make_variant(variables, robot_file)\n \n for enemy in enemy_files:\n wld, avg_scores, all_scores = versus(robot_to_eval, enemy, num_matches, cpu_count, seed_list)\n total_matches += sum(wld)\n total_all_scores.extend(all_scores)\n\n diff = [s[0] - s[1] for s in total_all_scores]\n avg, std = meanstd(diff)\n \n os.remove(robot_to_eval)\n \n return avg, std","def calculate_avg_score(state_score,state_count):\n\tfor state in state_score.keys():\n\t\tstate_score[state] = 1.*state_score[state]/state_count[state]\n\treturn state_score","def pc_throughput_avg(self) -> \"float\":\n return _beamforming_swig.beamformer_sptr_pc_throughput_avg(self)","def _eed_compute(sentence_level_scores: List[Tensor]) ->Tensor:\n if len(sentence_level_scores) == 0:\n return tensor(0.0)\n average = sum(sentence_level_scores) / tensor(len(sentence_level_scores))\n return average","def estimate(self):\n self.p_est = sum([t.estimate() for t in self.tasks])\n return self.p_est","def _mean(items):\n return sum(items) / len(items)","def average(self):\n total = 0\n for t in self.memory:\n total += t.reward\n return total/self.__len__()","def calculate_score_node(self, hypervisor):\n resource_id = \"%s_%s\" % (hypervisor.uuid, hypervisor.hostname)\n host_avg_cpu_util = self.ceilometer. \\\n statistic_aggregation(resource_id=resource_id,\n meter_name=self.HOST_CPU_USAGE_METRIC_NAME,\n period=\"7200\",\n aggregate='avg')\n\n if host_avg_cpu_util is None:\n LOG.error(\n _LE(\"No values returned by %(resource_id)s \"\n \"for %(metric_name)s\"),\n resource_id=resource_id,\n metric_name=self.HOST_CPU_USAGE_METRIC_NAME,\n )\n host_avg_cpu_util = 100\n\n cpu_capacity = self.model.get_resource_from_id(\n resource.ResourceType.cpu_cores).get_capacity(hypervisor)\n\n total_cores_used = cpu_capacity * (host_avg_cpu_util / 100)\n\n return self.calculate_weight(hypervisor, total_cores_used, 0, 0)","def get_average_complete_progress(self):\n cnt_events = len(self.get_events())\n if cnt_events > 0:\n return sum([self.get_average_progress(event) for event in self.get_events()]) * 1.0 / cnt_events\n return 0.0","def average(data, event):\n if len(data) == 0:\n return 0\n\n score = 0\n # scores = []\n count = 0\n for i in data:\n count += 1\n if event == 'Swim' or event == 'Run':\n num = time_seconds(i[event])\n #print(\"first if\")\n #Sprint(num)\n else:\n num = int(i[event])\n #print(\"second if\")\n #print(num)\n #scores[count] =\n #print(\"end of loop count\" + str(count))\n score += num\n #print (\"score\" + str(score))\n\n # total = 0\n # for x in range(0,len(scores)):\n # total += scores[x]\n score = float(score)\n\n return score / count","def mean(self):\n clean, total = self._prepare_for_stats()\n if not total:\n return None\n\n weighted_sum = sum(key * value for key, value in clean.items())\n return weighted_sum / total","def compute_mean_risk(risk, T_max: int, scenario_numbers):\r\n\r\n print(\"\\tComputing mean risk...\")\r\n # Init mean risk\r\n mean_risk = np.zeros(T_max)\r\n # compute mean\r\n for t in range(T_max):\r\n mean_risk[t] = sum(risk[t]) / scenario_numbers[t]\r\n print(\"\\tDone\")\r\n\r\n return mean_risk","async def averager():\n tasks = [ asyncio.create_task(worker_run(worker_id=worker_id,data={'x':worker_id*worker_id})) for worker_id in range(5) ]\n results = await asyncio.gather(*tasks)\n return np.mean(results)","def averageTime(self):\n \n pass","def get_avg_convergence_at_step(self, step=10, dynamic=False):\n sender_agents, sender_losses = self.sort_agents(dynamic=dynamic, k_shot=step)\n receiver_agents, receiver_losses = self.sort_agents(\n receiver=True, dynamic=False, k_shot=step\n )\n losses = sender_losses + receiver_losses\n return mean(losses)","def get_mean(self):\n try:\n return sum(self.speakers.values()) / len(self.speakers)\n except (ZeroDivisionError):\n return 0.0","def get_avg(self) -> float:\n if self._cur_elem_count < 1:\n return 0\n self._mtx.acquire()\n avg = self._sum / float(self._cur_elem_count)\n self._mtx.release()\n return avg","def with_sum_mean_reduction(self):\n return self.with_reduction(lambda x: x.sum(1).mean(0))","def _mean(images):\n try:\n total = next(images)\n except StopIteration:\n print(\"No images found. Use 0.\")\n return 0.\n num = 1\n for image in images:\n total += image\n mean = total / num\n if np.ndim(mean) == 3:\n mean = np.mean(mean, axis=0)\n return mean","def average(cls, points):\n return Point.sum(points) / len(points)","def compute_scores(self):\n if self.num_classes == 2:\n score_1 = self.competition_metric(\n helmet_threshold=0.5,\n impact_threshold=0.5,\n )[1]\n\n score_2 = self.competition_metric(\n helmet_threshold=0.5,\n impact_threshold_ratio=0.5,\n )[1]\n\n score_3 = self.competition_metric(\n impact_threshold=0.5,\n )[1]\n else:\n score_1 = self.detection_metric(threshold=0.1)\n score_2 = self.detection_metric(threshold=0.25)\n score_3 = self.detection_metric(threshold=0.5)\n\n return score_1, score_2, score_3","def getAvg(self):\r\n\t\tdata = self.pair.data\r\n\t\tif data['avg'] == None:\r\n\t\t\treturn None\r\n\t\treturn 1. / self.pair.data['avg']","def mean(self):\n\n return time_stat(self, stat=\"mean\")","def get_mean(self):\n return self.serie.mean()","def global_average_scores(self):\n\n return np.mean(self.average_scores_all_subjects(), axis=0)","def _ave(self):\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()","def get_avg_loss(self):\n if self.n_batches > 0:\n avg_loss = self.loss / self.n_batches\n self.loss = 0\n self.n_batches = 0\n return avg_loss\n else:\n return 0","def get_score(self, solution: np.array) -> float:\n pass","def mean(points):\r\n\t\treturn sum(points)/len(points)","def mean(items):\n return float(sum(items)) / len(items) if len(items) > 0 else 0","def compute_avg_reward(env, policy, num_episodes):\n total_return = 0.0\n for _ in range(num_episodes):\n state = env.reset()\n done = False\n episode_return = 0.0\n while not done:\n action = policy(state)\n next_state, reward, done, _ = env.step(action)\n if done:\n reward = -1.0\n episode_return += reward\n state = next_state\n total_return += episode_return\n avg_return = total_return / num_episodes\n return avg_return","def mean(numbers):\n return float(sum(numbers)) / float(len(numbers))","def get_means(self):\n if self.cv_method == 'fixed':\n perf = np.mean(self.evaluations, axis=0)\n perf = np.nanmean(perf, axis=-1)\n elif self.cv_method == 'crossvalidation':\n perf = np.mean(self.evaluations, axis=0)\n perf = np.nanmean(perf, axis=-1)\n else:\n perf = self.evaluations\n while len(perf.shape) > 2:\n perf = np.nanmean(perf, axis=-1)\n perf = perf[~np.isnan(perf[:, 0])]\n perf = np.mean(perf, axis=0)\n return perf","def mean(self):\r\n\t\treturn sum(self.sample)/len(self.sample)","def scoring(self):\n return -100 if self.loss_condition() else 0","def mean(self):\n return self._lift(\"mean\")","def avg_performance(env, policy):\n\n sum_reward = 0.\n episode = 100\n max_iteration = 6000\n for i in range(episode):\n done = False\n ob = env.reset()\n\n for j in range(max_iteration):\n a = policy[ob]\n ob, reward, done, _ = env.step(a)\n sum_reward += reward\n if done:\n break\n\n return sum_reward / i","def mean(self):\n return self.sum / self.sum_weights","def _ave(self):\n\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()","def mean(items):\n\n return float(sum(items)) / len(items)","def _get_mean(self):\n return self._get_conditional_negative_energy()","def x_run_average_pipeline(num: int, language: str):\n precision, recall, f1 = [], [], []\n for i in range(num):\n CRF = BaselineCRF(language)\n predicted, labels = CRF.pipeline()\n p, r, f = eval_morph_segments(predicted, labels)\n precision.append(p)\n recall.append(r)\n f1.append(f)\n\n recall = sum(recall) / len(recall)\n precision = sum(precision) / len(precision)\n f1 = sum(f1) / len(f1)\n return recall, precision, f1","def score(self, X, y):\n out = None\n ### YOUR CODE HERE\n pred = self.predict(X)\n assert pred.shape == y.shape\n out = ((pred-y)**2).mean()\n ### END CODE\n return out","def _find_average_score(self, sentenceValue):\n sumValues = 0\n for entry in sentenceValue: \n sumValues += sentenceValue[entry]\n \n try:\n average = (sumValues / len(sentenceValue))\n except:\n average = 0\n return average","def mean(self):\n return self._summarize(lambda c: c.mean)","def mean(self):\n return self._mean_func","def rule(model):\n ind_i = model.timeslots\n ind_j = model.tasks\n total = sum(self.task_willpower_load[j] * (\n model.A[i, j] + 2 * model.A2[i, j] + 3 * model.A3[i, j] + 4 *\n model.A4[i, j]) for i in ind_i for j in ind_j)\n return None, total, 0","def get_summarized_results(self):\n stats = [v.stats() for (k, v) in self.examples.items() if v.is_ready()]\n res = self.ExampleClass.average_stats(stats)\n\n res['loss'] = self.loss/self.loss_cnt\n res['recent_loss'] = sum(self.recent_loss_array) / sum(self.recent_loss_bs_array)\n\n return res","def mean():\n\n @sinks\n def _dagpype_internal_fn_act(target):\n s, n = 0, 0\n try:\n while True:\n s += (yield)\n n += 1\n except GeneratorExit:\n if n > 0:\n target.send(s / n)\n target.close()\n\n return _dagpype_internal_fn_act","def get_avg_points(self):\n pass","def compute_score_fast(verbose=1):\n res = []\n\n batch = math.ceil(len(train) / LINEAR_ASSIGNMENT_SEGMENT_SIZE)\n for start in range(0, len(train), batch):\n end = min(len(train), start + batch)\n train_batch = train[start:end]\n\n features = branch_model.predict_generator(FeatureGen(train_batch, verbose=verbose), max_queue_size=12, workers=6, verbose=0)\n score = head_model.predict_generator(ScoreGen(features, verbose=verbose), max_queue_size=12, workers=6, verbose=0)\n score = score_reshape(score, features)\n\n res.append(score)\n\n return res","def mean(self) -> typing.Tuple[float, float]:\r\n self.clean_window()\r\n return (\r\n (self.sum_frames_rec / self.window_size),\r\n (self.sum_frames_proc / self.window_size)\r\n )","def _mean_over_ts(self, l_ts):\n return sum([numpy.sum(ts) for ts in l_ts]) / len(l_ts)","def score_game(game_core):\n \n att_counter = [] \n np.random.seed(1) # fix RANDOM SEED so the experiment is reproducible \n random_array = np.random.randint(1,101, size=(1000))\n for number in random_array:\n att_counter.append(game_core(number))\n score = int(np.mean(att_counter))\n print(f\"Your algorithm guesses on average the number in {score} attempts.\")\n return(score)","def test_get_score_with_old_task_states(self):\r\n combinedoe = CombinedOpenEndedV1Module(self.test_system,\r\n self.location,\r\n self.definition,\r\n self.descriptor,\r\n static_data=self.static_data,\r\n metadata=self.metadata,\r\n instance_state=json.loads(INSTANCE_INCONSISTENT_STATE4))\r\n score_dict = combinedoe.get_score()\r\n self.assertEqual(score_dict['score'], 15.0)\r\n self.assertEqual(score_dict['total'], 5.0)","def score(self):\n return self.aggregate(Sum('score')).values()[0] or 0","def total_score(self):\n return _projected_site_total_score(self)","def average_checkpoints(inputs): #权值平均\r\n params_dict = collections.OrderedDict()\r\n params_keys = None\r\n new_state = None\r\n for f in inputs:\r\n state = torch.load(\r\n f,\r\n map_location=(\r\n lambda s, _: torch.serialization.default_restore_location(s, 'cpu')\r\n ),\r\n )\r\n # Copies over the settings from the first checkpoint\r\n if new_state is None:\r\n new_state = state\r\n\r\n model_params = state['model'] #注意model关键字key\r\n\r\n model_params_keys = list(model_params.keys())\r\n if params_keys is None:\r\n params_keys = model_params_keys\r\n elif params_keys != model_params_keys:\r\n raise KeyError(\r\n 'For checkpoint {}, expected list of params: {}, '\r\n 'but found: {}'.format(f, params_keys, model_params_keys)\r\n )\r\n\r\n for k in params_keys:\r\n if k not in params_dict:\r\n params_dict[k] = []\r\n params_dict[k].append(model_params[k])\r\n\r\n averaged_params = collections.OrderedDict()\r\n # v should be a list of torch Tensor.\r\n for k, v in params_dict.items():\r\n summed_v = None\r\n for x in v:\r\n summed_v = summed_v + x if summed_v is not None else x\r\n averaged_params[k] = summed_v / len(v)\r\n new_state['model'] = averaged_params\r\n return new_state","def mean(self):\n return self.aggregate(np.mean)","def average(self):\n return (self.current + self.last) / 2.0","def get_mean_and_std(dataset):\n dataloader = torch.utils.data.DataLoader(\n dataset, batch_size=1, shuffle=True, num_workers=2\n )\n mean = torch.zeros(3)\n std = torch.zeros(3)\n print(\"==> Computing mean and std..\")\n for inputs, targets in dataloader:\n for i in range(3):\n mean[i] += inputs[:, i, :, :].mean()\n std[i] += inputs[:, i, :, :].std()\n mean.div_(len(dataset))\n std.div_(len(dataset))\n return mean, std","def score(self, archi:ArchitectureNN):\n archi.fit_model(self.train_data, **self.train_params)\n \n return archi.compute_test_score(self.test_data)","def test_avg_mean(forecasters):\n y = make_forecasting_problem()\n forecaster = EnsembleForecaster(forecasters)\n forecaster.fit(y, fh=[1, 2, 3])\n mean_pred = forecaster.predict()\n\n forecaster_1 = EnsembleForecaster(forecasters, aggfunc=\"mean\", weights=[1, 1])\n forecaster_1.fit(y, fh=[1, 2, 3])\n avg_pred = forecaster_1.predict()\n\n pd.testing.assert_series_equal(mean_pred, avg_pred)","def average_score(self, sentenceValue):\r\n sumValues = 0\r\n for entry in sentenceValue:\r\n sumValues += sentenceValue[entry]\r\n\r\n # Average value of a sentence from original summary_text\r\n average = (sumValues / len(sentenceValue))\r\n\r\n return average","def getScore(self):\n tempscore = 1000 - 0.01*self.timeDriving \n tempscore -= 0.1*getDist(self.maze.checkpoints[self.checkpoint].getMid(),self.pos)\n tempscore += self.checkpoint *1000\n tempscore += self.laps * 1000 * len(self.maze.checkpoints)\n return tempscore"],"string":"[\n \"def avgcpu(self):\\n return (self._total_cpu['value'] / self._total_cpu['count']) if self._total_cpu['count'] else 0\",\n \"def score(self, task):\\n raise NotImplementedError(\\\"must subclass and implement score(task)\\\")\",\n \"def getAverage(self):\\n return sum(self.scores) / len(self.scores)\",\n \"def get_mean_score(rating_scores):\\n return sum(rating_scores) / len(rating_scores)\",\n \"def calculate(self):\\n avg = self.sum / self.n if self.n != 0 else 0\\n self.running_avg.append(avg)\\n return avg\",\n \"def score( self ):\\r\\n result = 0.0\\r\\n for rr in self.ee.getRsrcs( ):\\r\\n value = self.scoreRsrc( rr )\\r\\n result += value\\r\\n print( \\\"INFO: Value for the schedule is %s \\\" % ( rr, result ) )\\r\\n return( result )\",\n \"def calc_mean_score(movies: List[Movie]) -> float:\\n return round(sum([m.score for m in movies]) / len(movies), 1)\",\n \"def mean(self):\\n return self.cond_proba.mean\",\n \"def get_average(self) -> float:\\n return sum(self._scores) / len(self._scores)\",\n \"def average_waiting(self):\\n return self._average_waiting\",\n \"def data_flow_steps_avg(self) -> Optional[float]:\\n if self.has_data_flow:\\n return float(self.graph_tuple_stats.data_flow_steps_avg)\",\n \"def get_mean(cls, data: tuple or list) -> float:\\n cls._data_validation(data)\\n sum_ = fsum(data)\\n n = cls.get_n(data)\\n try:\\n return float(sum_ / n)\\n except ZeroDivisionError as exc:\\n # for hyp score calculation, n = 0 for empty set is useful\\n return 0\",\n \"def get_mean_cv_score(model, X, y, scoring, cv, n_jobs, verbose):\\n \\n mean_cv_score = cross_val_score_torch(model, X, y, scoring, cv, n_jobs, verbose).mean()\\n return mean_cv_score\",\n \"def get_runs_to_average(self):\\n\\n if Test.performance_params: return int(Test.performance_params[1])\\n elif self._check_performance: return self._runs_to_average\\n else: return None\",\n \"def _get_mean(self, sums, step):\\n\\n return sums/step\",\n \"def get_average_repro(self):\\n return np.mean([agent.get_fledge_probability() for agent in self.agents])\",\n \"def avg_e_score(self, entity):\\n return float(entity['es']) / float(entity['count'])\",\n \"def data_flow_positive_node_count_avg(self) -> Optional[int]:\\n if self.has_data_flow:\\n return int(self.graph_tuple_stats.data_flow_positive_node_count_avg or 0)\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def avg_act(self) -> float:\\n return torch.mean(self.units.act)\",\n \"def average_pending(self):\\n return self._average_pending\",\n \"def avg(self):\\n if not self.committed_together:\\n return 0\\n\\n return round(statistics.mean(self.committed_together))\",\n \"def get_average_progress(self, event=None):\\n cnt_items = len(self)\\n sum_progress = None\\n\\n if event == self.EVENT_TOTAL_PROGRESS:\\n return self.get_average_complete_progress()\\n\\n if event is None:\\n sum_progress = sum(map(lambda node: node.get_average_progress(), self.values()))\\n else:\\n sum_progress = self.get_sum_progress_event(event)\\n\\n if cnt_items > 0:\\n return sum_progress * 1.0 / cnt_items\\n\\n return 0.0\",\n \"def avg():\\n\\n # call sum method to add up the values in the collection & div by the num of items\\n # call len method to compute the # of vals in collection which is divided by sum total \\n mean = sum(inlist) / len(inlist)\\n return mean \\n\\n # alternate method would be calling the reduce method with lamda \\n # return reduce(lambda a, b: a + b, inlist) / len(inlist)\",\n \"def calculate_score_vm(self, vm):\\n vm_cpu_utilization = self.ceilometer. \\\\\\n statistic_aggregation(\\n resource_id=vm.uuid,\\n meter_name=self.INSTANCE_CPU_USAGE_METRIC_NAME,\\n period=\\\"7200\\\",\\n aggregate='avg'\\n )\\n if vm_cpu_utilization is None:\\n LOG.error(\\n _LE(\\\"No values returned by %(resource_id)s \\\"\\n \\\"for %(metric_name)s\\\"),\\n resource_id=vm.uuid,\\n metric_name=self.INSTANCE_CPU_USAGE_METRIC_NAME,\\n )\\n vm_cpu_utilization = 100\\n\\n cpu_capacity = self.model.get_resource_from_id(\\n resource.ResourceType.cpu_cores).get_capacity(vm)\\n\\n total_cores_used = cpu_capacity * (vm_cpu_utilization / 100.0)\\n\\n return self.calculate_weight(vm, total_cores_used, 0, 0)\",\n \"def score(self, input_fn=None, steps=None):\\n return np.sum(\\n self.evaluate(\\n input_fn=input_fn, steps=steps)[KMeansClustering.SCORES])\",\n \"def get_score(self):\\n rewards, resets = self.runner.get_rewards_resets()\\n self.runner.clear_rewards_resets()\\n assert rewards.ndim == 1 and resets.ndim == 1, (rewards.ndim, resets.ndim)\\n assert rewards.shape[0] == resets.shape[0], (rewards.shape, resets.shape)\\n scores = [0]\\n for t in reversed(range(rewards.shape[0])):\\n if resets[t]:\\n scores.append(0)\\n scores[-1] += rewards[t]\\n return np.mean(scores)\",\n \"def get_multiple_align_score(self, seq : Seq, dna_sequences : numpy_array, tasks : list, pool : ThreadPool) -> float: \\n def _calc_multiple_alignment_score(wrapped_data : tuple) -> int:\\n \\\"\\\"\\\"return value is a sum of all alignment scores in input rangerange.\\\"\\\"\\\" \\n (start, finish) = wrapped_data \\n score_sum = 0.\\n for dna_record in tqdm(dna_sequences[start : finish + 1], total=(finish + 1 - start), desc=\\\"Training process\\\"):\\n score_sum += self.aligner.score(seq, dna_record.seq)\\n return score_sum\\n return sum(s for s in pool.map(_calc_multiple_alignment_score, tasks))\",\n \"def average(self):\\n return self.summation() / self.count()\",\n \"def _compute_scores(self, triples):\\n # compute scores as sum(s * p * o)\\n scores = tf.reduce_sum(triples[0] * triples[1] * triples[2], 1)\\n return scores\",\n \"def avg_hops(self):\\n return self._avg_hops\",\n \"def _compute_mean(index, M, R, rake):\\r\\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\\r\\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\\r\\n\\r\\n return mean\",\n \"def _compute_mean(index, M, R, rake):\\r\\n mean = (a1[index] + _compute_linear_magnitude_term(index, M) + _compute_quadratic_magnitude_term(index, M) +\\r\\n _compute_logarithmic_distance_term(index, M, R) + _compute_faulting_style_term(index, rake))\\r\\n\\r\\n return mean\",\n \"def get_netavg (values, var_names, robot_file, enemy_files, num_matches, cpu_count, seed_list):\\n total_matches = 0\\n total_all_scores = []\\n \\n variables = dict(zip(var_names, list(values)))\\n robot_to_eval = make_variant(variables, robot_file)\\n \\n for enemy in enemy_files:\\n wld, avg_scores, all_scores = versus(robot_to_eval, enemy, num_matches, cpu_count, seed_list)\\n total_matches += sum(wld)\\n total_all_scores.extend(all_scores)\\n\\n diff = [s[0] - s[1] for s in total_all_scores]\\n avg, std = meanstd(diff)\\n \\n os.remove(robot_to_eval)\\n \\n return avg, std\",\n \"def calculate_avg_score(state_score,state_count):\\n\\tfor state in state_score.keys():\\n\\t\\tstate_score[state] = 1.*state_score[state]/state_count[state]\\n\\treturn state_score\",\n \"def pc_throughput_avg(self) -> \\\"float\\\":\\n return _beamforming_swig.beamformer_sptr_pc_throughput_avg(self)\",\n \"def _eed_compute(sentence_level_scores: List[Tensor]) ->Tensor:\\n if len(sentence_level_scores) == 0:\\n return tensor(0.0)\\n average = sum(sentence_level_scores) / tensor(len(sentence_level_scores))\\n return average\",\n \"def estimate(self):\\n self.p_est = sum([t.estimate() for t in self.tasks])\\n return self.p_est\",\n \"def _mean(items):\\n return sum(items) / len(items)\",\n \"def average(self):\\n total = 0\\n for t in self.memory:\\n total += t.reward\\n return total/self.__len__()\",\n \"def calculate_score_node(self, hypervisor):\\n resource_id = \\\"%s_%s\\\" % (hypervisor.uuid, hypervisor.hostname)\\n host_avg_cpu_util = self.ceilometer. \\\\\\n statistic_aggregation(resource_id=resource_id,\\n meter_name=self.HOST_CPU_USAGE_METRIC_NAME,\\n period=\\\"7200\\\",\\n aggregate='avg')\\n\\n if host_avg_cpu_util is None:\\n LOG.error(\\n _LE(\\\"No values returned by %(resource_id)s \\\"\\n \\\"for %(metric_name)s\\\"),\\n resource_id=resource_id,\\n metric_name=self.HOST_CPU_USAGE_METRIC_NAME,\\n )\\n host_avg_cpu_util = 100\\n\\n cpu_capacity = self.model.get_resource_from_id(\\n resource.ResourceType.cpu_cores).get_capacity(hypervisor)\\n\\n total_cores_used = cpu_capacity * (host_avg_cpu_util / 100)\\n\\n return self.calculate_weight(hypervisor, total_cores_used, 0, 0)\",\n \"def get_average_complete_progress(self):\\n cnt_events = len(self.get_events())\\n if cnt_events > 0:\\n return sum([self.get_average_progress(event) for event in self.get_events()]) * 1.0 / cnt_events\\n return 0.0\",\n \"def average(data, event):\\n if len(data) == 0:\\n return 0\\n\\n score = 0\\n # scores = []\\n count = 0\\n for i in data:\\n count += 1\\n if event == 'Swim' or event == 'Run':\\n num = time_seconds(i[event])\\n #print(\\\"first if\\\")\\n #Sprint(num)\\n else:\\n num = int(i[event])\\n #print(\\\"second if\\\")\\n #print(num)\\n #scores[count] =\\n #print(\\\"end of loop count\\\" + str(count))\\n score += num\\n #print (\\\"score\\\" + str(score))\\n\\n # total = 0\\n # for x in range(0,len(scores)):\\n # total += scores[x]\\n score = float(score)\\n\\n return score / count\",\n \"def mean(self):\\n clean, total = self._prepare_for_stats()\\n if not total:\\n return None\\n\\n weighted_sum = sum(key * value for key, value in clean.items())\\n return weighted_sum / total\",\n \"def compute_mean_risk(risk, T_max: int, scenario_numbers):\\r\\n\\r\\n print(\\\"\\\\tComputing mean risk...\\\")\\r\\n # Init mean risk\\r\\n mean_risk = np.zeros(T_max)\\r\\n # compute mean\\r\\n for t in range(T_max):\\r\\n mean_risk[t] = sum(risk[t]) / scenario_numbers[t]\\r\\n print(\\\"\\\\tDone\\\")\\r\\n\\r\\n return mean_risk\",\n \"async def averager():\\n tasks = [ asyncio.create_task(worker_run(worker_id=worker_id,data={'x':worker_id*worker_id})) for worker_id in range(5) ]\\n results = await asyncio.gather(*tasks)\\n return np.mean(results)\",\n \"def averageTime(self):\\n \\n pass\",\n \"def get_avg_convergence_at_step(self, step=10, dynamic=False):\\n sender_agents, sender_losses = self.sort_agents(dynamic=dynamic, k_shot=step)\\n receiver_agents, receiver_losses = self.sort_agents(\\n receiver=True, dynamic=False, k_shot=step\\n )\\n losses = sender_losses + receiver_losses\\n return mean(losses)\",\n \"def get_mean(self):\\n try:\\n return sum(self.speakers.values()) / len(self.speakers)\\n except (ZeroDivisionError):\\n return 0.0\",\n \"def get_avg(self) -> float:\\n if self._cur_elem_count < 1:\\n return 0\\n self._mtx.acquire()\\n avg = self._sum / float(self._cur_elem_count)\\n self._mtx.release()\\n return avg\",\n \"def with_sum_mean_reduction(self):\\n return self.with_reduction(lambda x: x.sum(1).mean(0))\",\n \"def _mean(images):\\n try:\\n total = next(images)\\n except StopIteration:\\n print(\\\"No images found. Use 0.\\\")\\n return 0.\\n num = 1\\n for image in images:\\n total += image\\n mean = total / num\\n if np.ndim(mean) == 3:\\n mean = np.mean(mean, axis=0)\\n return mean\",\n \"def average(cls, points):\\n return Point.sum(points) / len(points)\",\n \"def compute_scores(self):\\n if self.num_classes == 2:\\n score_1 = self.competition_metric(\\n helmet_threshold=0.5,\\n impact_threshold=0.5,\\n )[1]\\n\\n score_2 = self.competition_metric(\\n helmet_threshold=0.5,\\n impact_threshold_ratio=0.5,\\n )[1]\\n\\n score_3 = self.competition_metric(\\n impact_threshold=0.5,\\n )[1]\\n else:\\n score_1 = self.detection_metric(threshold=0.1)\\n score_2 = self.detection_metric(threshold=0.25)\\n score_3 = self.detection_metric(threshold=0.5)\\n\\n return score_1, score_2, score_3\",\n \"def getAvg(self):\\r\\n\\t\\tdata = self.pair.data\\r\\n\\t\\tif data['avg'] == None:\\r\\n\\t\\t\\treturn None\\r\\n\\t\\treturn 1. / self.pair.data['avg']\",\n \"def mean(self):\\n\\n return time_stat(self, stat=\\\"mean\\\")\",\n \"def get_mean(self):\\n return self.serie.mean()\",\n \"def global_average_scores(self):\\n\\n return np.mean(self.average_scores_all_subjects(), axis=0)\",\n \"def _ave(self):\\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()\",\n \"def get_avg_loss(self):\\n if self.n_batches > 0:\\n avg_loss = self.loss / self.n_batches\\n self.loss = 0\\n self.n_batches = 0\\n return avg_loss\\n else:\\n return 0\",\n \"def get_score(self, solution: np.array) -> float:\\n pass\",\n \"def mean(points):\\r\\n\\t\\treturn sum(points)/len(points)\",\n \"def mean(items):\\n return float(sum(items)) / len(items) if len(items) > 0 else 0\",\n \"def compute_avg_reward(env, policy, num_episodes):\\n total_return = 0.0\\n for _ in range(num_episodes):\\n state = env.reset()\\n done = False\\n episode_return = 0.0\\n while not done:\\n action = policy(state)\\n next_state, reward, done, _ = env.step(action)\\n if done:\\n reward = -1.0\\n episode_return += reward\\n state = next_state\\n total_return += episode_return\\n avg_return = total_return / num_episodes\\n return avg_return\",\n \"def mean(numbers):\\n return float(sum(numbers)) / float(len(numbers))\",\n \"def get_means(self):\\n if self.cv_method == 'fixed':\\n perf = np.mean(self.evaluations, axis=0)\\n perf = np.nanmean(perf, axis=-1)\\n elif self.cv_method == 'crossvalidation':\\n perf = np.mean(self.evaluations, axis=0)\\n perf = np.nanmean(perf, axis=-1)\\n else:\\n perf = self.evaluations\\n while len(perf.shape) > 2:\\n perf = np.nanmean(perf, axis=-1)\\n perf = perf[~np.isnan(perf[:, 0])]\\n perf = np.mean(perf, axis=0)\\n return perf\",\n \"def mean(self):\\r\\n\\t\\treturn sum(self.sample)/len(self.sample)\",\n \"def scoring(self):\\n return -100 if self.loss_condition() else 0\",\n \"def mean(self):\\n return self._lift(\\\"mean\\\")\",\n \"def avg_performance(env, policy):\\n\\n sum_reward = 0.\\n episode = 100\\n max_iteration = 6000\\n for i in range(episode):\\n done = False\\n ob = env.reset()\\n\\n for j in range(max_iteration):\\n a = policy[ob]\\n ob, reward, done, _ = env.step(a)\\n sum_reward += reward\\n if done:\\n break\\n\\n return sum_reward / i\",\n \"def mean(self):\\n return self.sum / self.sum_weights\",\n \"def _ave(self):\\n\\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()\",\n \"def mean(items):\\n\\n return float(sum(items)) / len(items)\",\n \"def _get_mean(self):\\n return self._get_conditional_negative_energy()\",\n \"def x_run_average_pipeline(num: int, language: str):\\n precision, recall, f1 = [], [], []\\n for i in range(num):\\n CRF = BaselineCRF(language)\\n predicted, labels = CRF.pipeline()\\n p, r, f = eval_morph_segments(predicted, labels)\\n precision.append(p)\\n recall.append(r)\\n f1.append(f)\\n\\n recall = sum(recall) / len(recall)\\n precision = sum(precision) / len(precision)\\n f1 = sum(f1) / len(f1)\\n return recall, precision, f1\",\n \"def score(self, X, y):\\n out = None\\n ### YOUR CODE HERE\\n pred = self.predict(X)\\n assert pred.shape == y.shape\\n out = ((pred-y)**2).mean()\\n ### END CODE\\n return out\",\n \"def _find_average_score(self, sentenceValue):\\n sumValues = 0\\n for entry in sentenceValue: \\n sumValues += sentenceValue[entry]\\n \\n try:\\n average = (sumValues / len(sentenceValue))\\n except:\\n average = 0\\n return average\",\n \"def mean(self):\\n return self._summarize(lambda c: c.mean)\",\n \"def mean(self):\\n return self._mean_func\",\n \"def rule(model):\\n ind_i = model.timeslots\\n ind_j = model.tasks\\n total = sum(self.task_willpower_load[j] * (\\n model.A[i, j] + 2 * model.A2[i, j] + 3 * model.A3[i, j] + 4 *\\n model.A4[i, j]) for i in ind_i for j in ind_j)\\n return None, total, 0\",\n \"def get_summarized_results(self):\\n stats = [v.stats() for (k, v) in self.examples.items() if v.is_ready()]\\n res = self.ExampleClass.average_stats(stats)\\n\\n res['loss'] = self.loss/self.loss_cnt\\n res['recent_loss'] = sum(self.recent_loss_array) / sum(self.recent_loss_bs_array)\\n\\n return res\",\n \"def mean():\\n\\n @sinks\\n def _dagpype_internal_fn_act(target):\\n s, n = 0, 0\\n try:\\n while True:\\n s += (yield)\\n n += 1\\n except GeneratorExit:\\n if n > 0:\\n target.send(s / n)\\n target.close()\\n\\n return _dagpype_internal_fn_act\",\n \"def get_avg_points(self):\\n pass\",\n \"def compute_score_fast(verbose=1):\\n res = []\\n\\n batch = math.ceil(len(train) / LINEAR_ASSIGNMENT_SEGMENT_SIZE)\\n for start in range(0, len(train), batch):\\n end = min(len(train), start + batch)\\n train_batch = train[start:end]\\n\\n features = branch_model.predict_generator(FeatureGen(train_batch, verbose=verbose), max_queue_size=12, workers=6, verbose=0)\\n score = head_model.predict_generator(ScoreGen(features, verbose=verbose), max_queue_size=12, workers=6, verbose=0)\\n score = score_reshape(score, features)\\n\\n res.append(score)\\n\\n return res\",\n \"def mean(self) -> typing.Tuple[float, float]:\\r\\n self.clean_window()\\r\\n return (\\r\\n (self.sum_frames_rec / self.window_size),\\r\\n (self.sum_frames_proc / self.window_size)\\r\\n )\",\n \"def _mean_over_ts(self, l_ts):\\n return sum([numpy.sum(ts) for ts in l_ts]) / len(l_ts)\",\n \"def score_game(game_core):\\n \\n att_counter = [] \\n np.random.seed(1) # fix RANDOM SEED so the experiment is reproducible \\n random_array = np.random.randint(1,101, size=(1000))\\n for number in random_array:\\n att_counter.append(game_core(number))\\n score = int(np.mean(att_counter))\\n print(f\\\"Your algorithm guesses on average the number in {score} attempts.\\\")\\n return(score)\",\n \"def test_get_score_with_old_task_states(self):\\r\\n combinedoe = CombinedOpenEndedV1Module(self.test_system,\\r\\n self.location,\\r\\n self.definition,\\r\\n self.descriptor,\\r\\n static_data=self.static_data,\\r\\n metadata=self.metadata,\\r\\n instance_state=json.loads(INSTANCE_INCONSISTENT_STATE4))\\r\\n score_dict = combinedoe.get_score()\\r\\n self.assertEqual(score_dict['score'], 15.0)\\r\\n self.assertEqual(score_dict['total'], 5.0)\",\n \"def score(self):\\n return self.aggregate(Sum('score')).values()[0] or 0\",\n \"def total_score(self):\\n return _projected_site_total_score(self)\",\n \"def average_checkpoints(inputs): #权值平均\\r\\n params_dict = collections.OrderedDict()\\r\\n params_keys = None\\r\\n new_state = None\\r\\n for f in inputs:\\r\\n state = torch.load(\\r\\n f,\\r\\n map_location=(\\r\\n lambda s, _: torch.serialization.default_restore_location(s, 'cpu')\\r\\n ),\\r\\n )\\r\\n # Copies over the settings from the first checkpoint\\r\\n if new_state is None:\\r\\n new_state = state\\r\\n\\r\\n model_params = state['model'] #注意model关键字key\\r\\n\\r\\n model_params_keys = list(model_params.keys())\\r\\n if params_keys is None:\\r\\n params_keys = model_params_keys\\r\\n elif params_keys != model_params_keys:\\r\\n raise KeyError(\\r\\n 'For checkpoint {}, expected list of params: {}, '\\r\\n 'but found: {}'.format(f, params_keys, model_params_keys)\\r\\n )\\r\\n\\r\\n for k in params_keys:\\r\\n if k not in params_dict:\\r\\n params_dict[k] = []\\r\\n params_dict[k].append(model_params[k])\\r\\n\\r\\n averaged_params = collections.OrderedDict()\\r\\n # v should be a list of torch Tensor.\\r\\n for k, v in params_dict.items():\\r\\n summed_v = None\\r\\n for x in v:\\r\\n summed_v = summed_v + x if summed_v is not None else x\\r\\n averaged_params[k] = summed_v / len(v)\\r\\n new_state['model'] = averaged_params\\r\\n return new_state\",\n \"def mean(self):\\n return self.aggregate(np.mean)\",\n \"def average(self):\\n return (self.current + self.last) / 2.0\",\n \"def get_mean_and_std(dataset):\\n dataloader = torch.utils.data.DataLoader(\\n dataset, batch_size=1, shuffle=True, num_workers=2\\n )\\n mean = torch.zeros(3)\\n std = torch.zeros(3)\\n print(\\\"==> Computing mean and std..\\\")\\n for inputs, targets in dataloader:\\n for i in range(3):\\n mean[i] += inputs[:, i, :, :].mean()\\n std[i] += inputs[:, i, :, :].std()\\n mean.div_(len(dataset))\\n std.div_(len(dataset))\\n return mean, std\",\n \"def score(self, archi:ArchitectureNN):\\n archi.fit_model(self.train_data, **self.train_params)\\n \\n return archi.compute_test_score(self.test_data)\",\n \"def test_avg_mean(forecasters):\\n y = make_forecasting_problem()\\n forecaster = EnsembleForecaster(forecasters)\\n forecaster.fit(y, fh=[1, 2, 3])\\n mean_pred = forecaster.predict()\\n\\n forecaster_1 = EnsembleForecaster(forecasters, aggfunc=\\\"mean\\\", weights=[1, 1])\\n forecaster_1.fit(y, fh=[1, 2, 3])\\n avg_pred = forecaster_1.predict()\\n\\n pd.testing.assert_series_equal(mean_pred, avg_pred)\",\n \"def average_score(self, sentenceValue):\\r\\n sumValues = 0\\r\\n for entry in sentenceValue:\\r\\n sumValues += sentenceValue[entry]\\r\\n\\r\\n # Average value of a sentence from original summary_text\\r\\n average = (sumValues / len(sentenceValue))\\r\\n\\r\\n return average\",\n \"def getScore(self):\\n tempscore = 1000 - 0.01*self.timeDriving \\n tempscore -= 0.1*getDist(self.maze.checkpoints[self.checkpoint].getMid(),self.pos)\\n tempscore += self.checkpoint *1000\\n tempscore += self.laps * 1000 * len(self.maze.checkpoints)\\n return tempscore\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6135161","0.60931313","0.60613865","0.5927177","0.5919117","0.59168655","0.58380854","0.58222544","0.5811924","0.57893497","0.5779506","0.57702696","0.5763837","0.5745407","0.57277334","0.5717946","0.571239","0.568665","0.567822","0.567822","0.567822","0.565646","0.563204","0.5631806","0.5624568","0.562341","0.56209874","0.5604458","0.5595695","0.5594914","0.5577402","0.5572562","0.5568053","0.55516624","0.55516624","0.5551151","0.5550497","0.5546859","0.5544933","0.55437165","0.5543175","0.55364114","0.55339766","0.5522943","0.55183125","0.5516683","0.5516339","0.5506228","0.5494966","0.54949224","0.5494274","0.5493655","0.5492084","0.5484917","0.5481125","0.5477106","0.5472629","0.54717916","0.5468196","0.54676497","0.54659647","0.5458963","0.5456265","0.545212","0.54446363","0.54425216","0.54386616","0.54369193","0.5432436","0.54322577","0.54294","0.5416687","0.5410187","0.54080856","0.54076576","0.5402836","0.54005533","0.53932774","0.53907377","0.5384116","0.53703386","0.53675383","0.536335","0.5357943","0.5357372","0.53520477","0.5345061","0.53378606","0.53354484","0.5328385","0.5327367","0.532273","0.53219897","0.53208196","0.53196806","0.53195304","0.53184354","0.53162897","0.5316203","0.53160906"],"string":"[\n \"0.6135161\",\n \"0.60931313\",\n \"0.60613865\",\n \"0.5927177\",\n \"0.5919117\",\n \"0.59168655\",\n \"0.58380854\",\n \"0.58222544\",\n \"0.5811924\",\n \"0.57893497\",\n \"0.5779506\",\n \"0.57702696\",\n \"0.5763837\",\n \"0.5745407\",\n \"0.57277334\",\n \"0.5717946\",\n \"0.571239\",\n \"0.568665\",\n \"0.567822\",\n \"0.567822\",\n \"0.567822\",\n \"0.565646\",\n \"0.563204\",\n \"0.5631806\",\n \"0.5624568\",\n \"0.562341\",\n \"0.56209874\",\n \"0.5604458\",\n \"0.5595695\",\n \"0.5594914\",\n \"0.5577402\",\n \"0.5572562\",\n \"0.5568053\",\n \"0.55516624\",\n \"0.55516624\",\n \"0.5551151\",\n \"0.5550497\",\n \"0.5546859\",\n \"0.5544933\",\n \"0.55437165\",\n \"0.5543175\",\n \"0.55364114\",\n \"0.55339766\",\n \"0.5522943\",\n \"0.55183125\",\n \"0.5516683\",\n \"0.5516339\",\n \"0.5506228\",\n \"0.5494966\",\n \"0.54949224\",\n \"0.5494274\",\n \"0.5493655\",\n \"0.5492084\",\n \"0.5484917\",\n \"0.5481125\",\n \"0.5477106\",\n \"0.5472629\",\n \"0.54717916\",\n \"0.5468196\",\n \"0.54676497\",\n \"0.54659647\",\n \"0.5458963\",\n \"0.5456265\",\n \"0.545212\",\n \"0.54446363\",\n \"0.54425216\",\n \"0.54386616\",\n \"0.54369193\",\n \"0.5432436\",\n \"0.54322577\",\n \"0.54294\",\n \"0.5416687\",\n \"0.5410187\",\n \"0.54080856\",\n \"0.54076576\",\n \"0.5402836\",\n \"0.54005533\",\n \"0.53932774\",\n \"0.53907377\",\n \"0.5384116\",\n \"0.53703386\",\n \"0.53675383\",\n \"0.536335\",\n \"0.5357943\",\n \"0.5357372\",\n \"0.53520477\",\n \"0.5345061\",\n \"0.53378606\",\n \"0.53354484\",\n \"0.5328385\",\n \"0.5327367\",\n \"0.532273\",\n \"0.53219897\",\n \"0.53208196\",\n \"0.53196806\",\n \"0.53195304\",\n \"0.53184354\",\n \"0.53162897\",\n \"0.5316203\",\n \"0.53160906\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6233691"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92883,"cells":{"query":{"kind":"string","value":"Load pretrained weights for the 'tokentovector' part of the component models, which is typically a CNN. See 'spacy pretrain'. Experimental."},"document":{"kind":"string","value":"def _load_pretrained_tok2vec(nlp, loc):\n with loc.open(\"rb\") as file_:\n weights_data = file_.read()\n loaded = []\n for name, component in nlp.pipeline:\n if hasattr(component, \"model\") and component.model.has_ref(\"tok2vec\"):\n component.get_ref(\"tok2vec\").from_bytes(weights_data)\n loaded.append(name)\n return loaded"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def load_model(self):\n if self.ckpt_flag:\n LOG('Skip Loading Pre-trained Model......')\n else:\n if self.params.pre_trained_from is not None and os.path.exists(self.params.pre_trained_from):\n try:\n LOG('Loading Pre-trained Model at %s' % self.params.pre_trained_from)\n pretrain = torch.load(self.params.pre_trained_from)\n self.network.load_state_dict(pretrain)\n LOG('Pre-trained Model Loaded!')\n except:\n WARNING('Cannot load pre-trained model. Start training......')\n else:\n WARNING('Pre-trained model do not exits. Start training......')","def init_pretrained_weights(model, key=''):\n import os\n import errno\n import gdown\n from collections import OrderedDict\n\n def _get_torch_home():\n ENV_TORCH_HOME = 'TORCH_HOME'\n ENV_XDG_CACHE_HOME = 'XDG_CACHE_HOME'\n DEFAULT_CACHE_DIR = '~/.cache'\n torch_home = os.path.expanduser(\n os.getenv(\n ENV_TORCH_HOME,\n os.path.join(\n os.getenv(ENV_XDG_CACHE_HOME, DEFAULT_CACHE_DIR), 'torch'\n )\n )\n )\n return torch_home\n\n torch_home = _get_torch_home()\n model_dir = os.path.join(torch_home, 'checkpoints')\n try:\n os.makedirs(model_dir)\n except OSError as e:\n if e.errno == errno.EEXIST:\n # Directory already exists, ignore.\n pass\n else:\n # Unexpected OSError, re-raise.\n raise\n filename = key + '_imagenet.pth'\n cached_file = os.path.join(model_dir, filename)\n\n if not os.path.exists(cached_file):\n gdown.download(pretrained_urls[key], cached_file, quiet=False)\n\n state_dict = torch.load(cached_file)\n model_dict = model.state_dict()\n new_state_dict = OrderedDict()\n matched_layers, discarded_layers = [], []\n\n for k, v in state_dict.items():\n if k.startswith('module.'):\n k = k[7:] # discard module.\n\n if k in model_dict and model_dict[k].size() == v.size():\n new_state_dict[k] = v\n matched_layers.append(k)\n else:\n discarded_layers.append(k)\n\n model_dict.update(new_state_dict)\n model.load_state_dict(model_dict)\n\n if len(matched_layers) == 0:\n warnings.warn(\n 'The pretrained weights from \"{}\" cannot be loaded, '\n 'please check the key names manually '\n '(** ignored and continue **)'.format(cached_file)\n )\n else:\n print(\n 'Successfully loaded imagenet pretrained weights from \"{}\"'.\n format(cached_file)\n )\n if len(discarded_layers) > 0:\n print(\n '** The following layers are discarded '\n 'due to unmatched keys or layer size: {}'.\n format(discarded_layers)\n )","def load_pretrained_model(self, load_from):\n print(\"loading model from %s\\n\" % (load_from))\n try:\n if self.use_cuda:\n pretrained_dict = torch.load(load_from)\n else:\n pretrained_dict = torch.load(load_from, map_location='cpu')\n\n model_dict = self.online_net.state_dict()\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}\n model_dict.update(pretrained_dict)\n self.online_net.load_state_dict(model_dict)\n print(\"The loaded parameters are:\")\n keys = [key for key in pretrained_dict]\n print(\", \".join(keys))\n print(\"--------------------------\")\n except Exception as e:\n print(\"Failed to load checkpoint...\")\n print(e)","def pretrained():\n launch_training_on_all_splits(experiment='full', splits=NAME_SPLIT, base_model='pretrained', dropout=0.7987, learning_rate=0.00009659)","def load_pretrained_net_weights(net, ckpt_path):\n print(\"Loading Model: \", ckpt_path)\n print('')\n\n net.load_weights(ckpt_path).expect_partial()","def _load_model_from_trained_params(self):\n self.ent_emb = tf.constant(self.trained_model_params[0])\n self.rel_emb = tf.constant(self.trained_model_params[1])","def load_tf_weights_in_bert(model, tf_checkpoint_path):\n try:\n import re\n import numpy as np\n import tensorflow as tf\n except ImportError:\n print(\"Loading a TensorFlow models in PyTorch, requires TensorFlow to be installed. Please see \"\n \"https://www.tensorflow.org/install/ for installation instructions.\")\n raise\n tf_path = os.path.abspath(tf_checkpoint_path)\n print(\"Converting TensorFlow checkpoint from {}\".format(tf_path))\n # Load weights from TF model\n init_vars = tf.train.list_variables(tf_path)\n names = []\n arrays = []\n for name, shape in init_vars:\n print(\"Loading TF weight {} with shape {}\".format(name, shape))\n array = tf.train.load_variable(tf_path, name)\n names.append(name)\n arrays.append(array)\n\n for name, array in zip(names, arrays):\n name = name.split('/')\n # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v\n # which are not required for using pretrained model\n if any(n in [\"adam_v\", \"adam_m\"] for n in name):\n print(\"Skipping {}\".format(\"/\".join(name)))\n continue\n pointer = model\n for m_name in name:\n if re.fullmatch(r'[A-Za-z]+_\\d+', m_name):\n l = re.split(r'_(\\d+)', m_name)\n else:\n l = [m_name]\n if l[0] == 'kernel' or l[0] == 'gamma':\n pointer = getattr(pointer, 'weight')\n elif l[0] == 'output_bias' or l[0] == 'beta':\n pointer = getattr(pointer, 'bias')\n elif l[0] == 'output_weights':\n pointer = getattr(pointer, 'weight')\n else:\n pointer = getattr(pointer, l[0])\n if len(l) >= 2:\n num = int(l[1])\n pointer = pointer[num]\n if m_name[-11:] == '_embeddings':\n pointer = getattr(pointer, 'weight')\n elif m_name == 'kernel':\n array = np.transpose(array)\n try:\n assert pointer.shape == array.shape\n except AssertionError as e:\n e.args += (pointer.shape, array.shape)\n raise\n print(\"Initialize PyTorch weight {}\".format(name))\n pointer.data = torch.from_numpy(array)\n return model","def load_feature_extractor(model_spec, device):\n\n model_type = model_spec['name']\n model_weights_fp = model_spec['weights']\n\n if model_type == 'imagenet_swav':\n # or could load from hub model\n # model = torch.hub.load('facebookresearch/swav', 'resnet50')\n\n model = models.resnet50(pretrained=False)\n model.fc = torch.nn.Identity()\n state_dict = torch.load(model_weights_fp, map_location=\"cpu\")\n\n state_dict = {k.replace(\"module.\", \"\"): v for k, v in state_dict.items()}\n for k in list(state_dict.keys()):\n if 'projection' in k or 'prototypes' in k:\n del state_dict[k]\n\n msg = model.load_state_dict(state_dict, strict=True)\n\n elif model_type == 'imagenet_moco_v2':\n model = models.resnet50(pretrained=False)\n model.fc = torch.nn.Identity()\n checkpoint = torch.load(model_weights_fp, map_location=\"cpu\")\n\n # rename moco pre-trained keys\n state_dict = checkpoint['state_dict']\n for k in list(state_dict.keys()):\n # retain only encoder_q up to before the embedding layer\n if k.startswith('module.encoder_q') and not k.startswith('module.encoder_q.fc'):\n # remove prefix\n state_dict[k[len(\"module.encoder_q.\"):]] = state_dict[k]\n # delete renamed or unused k\n del state_dict[k]\n\n msg = model.load_state_dict(state_dict, strict=True)\n\n elif model_type == 'imagenet_supervised':\n model = models.resnet50(pretrained=True)\n\n elif model_type == 'random':\n model = models.resnet50(pretrained=False)\n\n elif model_type == 'inat2018_supervised':\n model = models.resnet50(pretrained=False)\n # This model was actually trained with 10000 classes for the fc layer\n # but only 8142 (the number in inat2018) were actually updated\n model.fc = torch.nn.Linear(model.fc.in_features, 10000)\n checkpoint = torch.load(model_weights_fp, map_location=\"cpu\")\n msg = model.load_state_dict(checkpoint['state_dict'], strict=True)\n\n elif model_type == 'inat2021_mini_supervised':\n model = models.resnet50(pretrained=False)\n model.fc = torch.nn.Linear(model.fc.in_features, 10000)\n checkpoint = torch.load(model_weights_fp, map_location=\"cpu\")\n msg = model.load_state_dict(checkpoint['state_dict'], strict=True)\n\n elif model_type == 'inat2021_supervised':\n model = models.resnet50(pretrained=False)\n model.fc = torch.nn.Linear(model.fc.in_features, 10000)\n checkpoint = torch.load(model_weights_fp, map_location=\"cpu\")\n msg = model.load_state_dict(checkpoint['state_dict'], strict=True)\n\n elif model_type == 'inat2021_mini_supervised_from_scratch':\n model = models.resnet50(pretrained=False)\n model.fc = torch.nn.Linear(model.fc.in_features, 10000)\n checkpoint = torch.load(model_weights_fp, map_location=\"cpu\")\n state_dict = {k.replace(\"module.\", \"\"): v for k, v in checkpoint['state_dict'].items()}\n msg = model.load_state_dict(state_dict, strict=True)\n\n elif model_type == 'inat2021_supervised_from_scratch':\n model = models.resnet50(pretrained=False)\n model.fc = torch.nn.Linear(model.fc.in_features, 10000)\n checkpoint = torch.load(model_weights_fp, map_location=\"cpu\")\n msg = model.load_state_dict(checkpoint['state_dict'], strict=True)\n\n elif model_type == 'inat2021_mini_moco_v2':\n model = models.resnet50(pretrained=False)\n model.fc = torch.nn.Identity()\n checkpoint = torch.load(model_weights_fp, map_location=\"cpu\")\n\n # rename moco pre-trained keys\n state_dict = checkpoint['state_dict']\n for k in list(state_dict.keys()):\n # retain only encoder_q up to before the embedding layer\n if k.startswith('module.encoder_q') and not k.startswith('module.encoder_q.fc'):\n # remove prefix\n state_dict[k[len(\"module.encoder_q.\"):]] = state_dict[k]\n # delete renamed or unused k\n del state_dict[k]\n\n msg = model.load_state_dict(state_dict, strict=True)\n\n elif model_type == 'inat2021_mini_swav' or model_type == 'inat2021_mini_swav_1k':\n # or could load from hub model\n # model = torch.hub.load('facebookresearch/swav', 'resnet50')\n\n model = models.resnet50(pretrained=False)\n model.fc = torch.nn.Identity()\n state_dict = torch.load(model_weights_fp, map_location=\"cpu\")\n\n state_dict = {k.replace(\"module.\", \"\"): v for k, v in state_dict['state_dict'].items()}\n for k in list(state_dict.keys()):\n if 'projection' in k or 'prototypes' in k:\n del state_dict[k]\n\n msg = model.load_state_dict(state_dict, strict=True)\n\n else:\n raise ValueError(\"Unknown pytorch model: %s\" % model_type)\n\n\n # remove the final fully connected layer so the model only operates with post average pool features\n model = torch.nn.Sequential(*(list(model.children())[:-1]))\n model.to(device)\n model.eval()\n\n feature_extractor = PTResNet50FeatureExtractor(model, device)\n\n return feature_extractor","def load_pretrained_weights(self, model_dir):\n p_dict = torch.load(model_dir)\n s_dict = self.state_dict()\n for name in p_dict.keys():\n s_dict[name] = p_dict[name]\n self.load_state_dict(s_dict)","def init_pretrained_weights(model, model_url):\n pretrain_dict = model_zoo.load_url(model_url)\n model_dict = model.state_dict()\n pretrain_dict = {k: v for k, v in pretrain_dict.items() if k in model_dict and model_dict[k].size() == v.size()}\n model_dict.update(pretrain_dict)\n model.load_state_dict(model_dict)","def load_pretrained_weights(model, model_name, load_fc=True):\n state_dict = torch.load(url_map[model_name])\n if load_fc:\n model.load_state_dict(state_dict)\n else:\n state_dict.pop('_fc.weight')\n state_dict.pop('_fc.bias')\n res = model.load_state_dict(state_dict, strict=False)\n assert str(res.missing_keys) == str(['_fc.weight', '_fc.bias']), 'issue loading pretrained weights'\n print('Loaded pretrained weights for {}'.format(model_name))","def init_weights(self, pretrained=None):\n # Do not initialize the conv layers\n # to follow the original implementation\n if isinstance(pretrained, str):\n from mmdet3d.utils import get_root_logger\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)","def update_params(self):\n if self._hyper_params[\"pretrain_model_path\"] != \"\":\n model_path = self._hyper_params[\"pretrain_model_path\"]\n state_dict = torch.load(model_path,\n map_location=torch.device(\"cpu\"))\n if \"model_state_dict\" in state_dict:\n state_dict = state_dict[\"model_state_dict\"]\n try:\n self.load_state_dict(state_dict, strict=True)\n except:\n self.load_state_dict(state_dict, strict=False)\n logger.info(\"Pretrained weights loaded from {}\".format(model_path))\n logger.info(\"Check md5sum of Pretrained weights: %s\" %\n md5sum(model_path))","def init_weights(self):\n if isinstance(self.pretrained, str):\n logger = get_root_logger()\n logger.info(f'load model from: {self.pretrained}')\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\n elif self.pretrained is None:\n pass\n else:\n raise TypeError('pretrained must be a str or None')","def run_model_three():\n\n pos_map = pickle.load(open('pos_map.p', \"rb\"))\n vocab = build_vocab(training_directory)\n word2vec = get_w2vec(wordtovec)\n\n train_out_list = prep_data_lexsub(training_directory, \"mod3_train_prepped.txt\", 3, pos_map, vocab, word2vec)\n test_out_list = prep_data_lexsub(testing_directory, \"mod3_test_prepped.txt\", 3, pos_map, vocab, word2vec)\n\n posset = get_posset()\n vocab.add(\"<s>\")\n vocab.add(\"<UNK>\")\n convert_to_svm('mod3_train_prepped.txt', \"mod3_train.svm\", posset, vocab)\n convert_to_svm('mod3_test_prepped.txt', \"mod3_test.svm\", posset, vocab)\n\n p_labels, p_acc, p_vals = train_test_model(\"mod3_train.svm\", \"mod3_test.svm\")\n with open(\"modelscores.txt\", \"a\") as text_file:\n text_file.write(str(p_acc[0]))\n text_file.write(\"\\n\")\n pickle.dump(p_labels, open('mod3_p_labels.p', 'wb'))","def load_pre_trained_model_state(saved_state_file_name):\n saved_state_file_name = saved_state_file_name if saved_state_file_name else \"my_checkpoint.pth\"\n loaded_state = torch.load(saved_state_file_name)\n\n pre_trained_model = models.vgg16(pretrained=True)\n pre_trained_model.name = \"vgg16\"\n\n for param in pre_trained_model.parameters():\n param.requires_grad = False\n\n pre_trained_model.class_to_idx = loaded_state['class_to_idx']\n pre_trained_model.classifier = loaded_state['classifier']\n pre_trained_model.load_state_dict(loaded_state['state_dict'])\n \n return pre_trained_model","def init_pretrained_weights(model, model_url):\n pretrain_dict = model_zoo.load_url(model_url)\n model_dict = model.state_dict()\n pretrain_dict = {\n k: v\n for k, v in pretrain_dict.items()\n if k in model_dict and model_dict[k].size() == v.size()\n }\n model_dict.update(pretrain_dict)\n model.load_state_dict(model_dict)","def load_openai_pretrained_model(model, cfg, n_special, dir):\n n_ctx = cfg.n_ctx\n n_embd = cfg.n_embd\n n_transfer = cfg.n_layer\n # Load weights from TF model\n print(\"Loading weights...\")\n names = json.load(open(dir + 'parameters_names.json'))\n shapes = json.load(open(dir + 'params_shapes.json'))\n offsets = np.cumsum([np.prod(shape) for shape in shapes])\n init_params = [np.load(dir + 'params_{}.npy'.format(n)) for n in range(10)]\n init_params = np.split(np.concatenate(init_params, 0), offsets)[:-1]\n init_params = [param.reshape(shape) for param, shape in zip(init_params, shapes)]\n if n_ctx > 0:\n init_params[0] = init_params[0][:n_ctx]\n if n_special > 0:\n init_params[0] = np.concatenate(\n [init_params[1],\n (np.random.randn(n_special, n_embd) * 0.02).astype(np.float32),\n init_params[0]\n ], 0)\n else:\n init_params[0] = np.concatenate(\n [init_params[1],\n init_params[0]\n ], 0)\n del init_params[1]\n if n_transfer == -1:\n n_transfer = 0\n else:\n n_transfer = 1 + n_transfer * 12\n init_params = [arr.squeeze() for arr in init_params]\n\n try:\n assert model.embed.weight.shape == init_params[0].shape\n except AssertionError as e:\n e.args += (model.embed.weight.shape, init_params[0].shape)\n raise\n\n model.embed.weight.data = torch.from_numpy(init_params[0])\n\n for name, ip in zip(names[1:n_transfer], init_params[1:n_transfer]):\n name = name[6:] # skip \"model/\"\n assert name[-2:] == \":0\"\n name = name[:-2]\n name = name.split('/')\n pointer = model\n for m_name in name:\n if re.fullmatch(r'[A-Za-z]+\\d+', m_name):\n l = re.split(r'(\\d+)', m_name)\n else:\n l = [m_name]\n pointer = getattr(pointer, l[0])\n if len(l) >= 2:\n num = int(l[1])\n pointer = pointer[num]\n try:\n assert pointer.shape == ip.shape\n except AssertionError as e:\n e.args += (pointer.shape, ip.shape)\n raise\n pointer.data = torch.from_numpy(ip)","def load_pretrained_layers(self):\n # Current state of base\n state_dict = self.state_dict()\n param_names = list(state_dict.keys())\n\n # Pretrained VGG base\n pth = VGG_WEIGHT_PATH\n pretrained_state_dict = torch.load(pth)\n pretrained_param_names = list(pretrained_state_dict.keys())\n\n # Transfer conv. parameters from pretrained model to current model\n for i, param in enumerate(param_names[:-4]): # excluding conv6 and conv7 parameters\n state_dict[param] = pretrained_state_dict[pretrained_param_names[i]]\n\n self.load_state_dict(state_dict)","def load_model(self):\n saved_path = self.config.path_tmp / self.model.model_name\n if saved_path.exists():\n self.model.load_weights(str(saved_path / 'model.vec'))","def checkpoint_load(checkpoint_path, gpu):\n model_info = torch.load(checkpoint_path)\n model = models.vgg19(pretrained=True)\n for param in model.parameters():\n param.requires_grad = False\n \n model.class_to_idx = model_info['class_to_idx']\n\n model = classifier(model)\n model.load_state_dict(model_info[\"model_state_dict\"])\n return model, model.class_to_idx","def load_model():\n prepro = Prepro(PATH_STOPSWORD, PATH_ACRONYM)\n vectorizer = joblib.load(PATH_TFIDF)\n label_encoder = joblib.load(PATH_ENCODER)\n model_svm = joblib.load(PATH_SVM)\n model_nb = joblib.load(PATH_NB)\n model_lr = joblib.load(PATH_LR)\n return prepro, vectorizer, label_encoder, model_svm, model_nb, model_lr","def load_pretrained_weights(model, model_name, load_fc=True, advprop=False):\n # AutoAugment or Advprop (different preprocessing)\n url_map_ = url_map_advprop if advprop else url_map\n state_dict = model_zoo.load_url(url_map_[model_name], map_location=torch.device('cpu'))\n # state_dict = torch.load('../../weights/backbone_efficientnetb0.pth')\n if load_fc:\n ret = model.load_state_dict(state_dict, strict=False)\n print(ret)\n else:\n state_dict.pop('_fc.weight')\n state_dict.pop('_fc.bias')\n res = model.load_state_dict(state_dict, strict=False)\n assert set(res.missing_keys) == {'_fc.weight', '_fc.bias'}, 'issue loading pretrained weights'\n print('Loaded pretrained weights for {}'.format(model_name))","def from_pretrained(self, directory):\n\n if not os.path.exists(directory):\n print(\"The path does not exists\")\n\n self._vocab = Vocab().from_disk(os.path.join(directory, \"spacy_vocab\"))\n self._model = torch.load(os.path.join(directory, \"torch_model\"))","def load_model(self):\n if os.stat('code/lr-model.pt').st_size == 0:\n return\n params = torch.load('code/lr-model.pt')\n self.set_params(params)","def init_weight(self, pretrained_model=None):\n if pretrained_model is not None:\n if os.path.exists(pretrained_model):\n utils.load_pretrained_model(self.backbone, pretrained_model)\n utils.load_pretrained_model(self, pretrained_model)\n else:\n raise Exception('Pretrained model is not found: {}'.format(\n pretrained_model))","def load_ckpt(model,\n weight_path,\n **kargs):\n #model.set_state_dict(state_dict)\n\n if not osp.isfile(weight_path):\n raise IOError(f'{weight_path} is not a checkpoint file')\n #state_dicts = load(weight_path)\n\n logger = get_logger(\"paddlevideo\")\n state_dicts = paddle.load(weight_path)\n if \"VisionTransformer\" in str(model): # For TimeSformer case\n tmp = pretrain_vit_param_trans(model, state_dicts, kargs['num_patches'], kargs['seg_num'], kargs['attention_type'])\n else:\n tmp = {}\n total_len = len(model.state_dict())\n with tqdm(total=total_len, position=1, bar_format='{desc}', desc=\"Loading weights\") as desc:\n for item in tqdm(model.state_dict(), total=total_len, position=0):\n name = item\n desc.set_description('Loading %s' % name)\n if name not in state_dicts: # Convert from non-parallel model\n if str('backbone.' + name) in state_dicts:\n tmp[name] = state_dicts['backbone.' + name]\n else: # Convert from parallel model\n tmp[name] = state_dicts[name]\n time.sleep(0.01)\n ret_str = \"loading {:<20d} weights completed.\".format(len(model.state_dict()))\n desc.set_description(ret_str)\n model.set_state_dict(tmp)","def load_pretrained_model(self,model_dir):\n rnn_params = json.load(open(os.path.join(model_dir,\n \"./model.json\")))[\"rnn\"]\n\n logging.info(\"Loading model from: {}\".format(model_dir))\n self.create_training_model(model_dir = model_dir,\n **rnn_params)\n #从目录中读取神经网络参数\n self.set_model_from_file()","def load_model(self, directory):\n with tf.Session() as sess:\n tf.saved_model.loader.load(sess, [tf.saved_model.tag_constants.SERVING], directory)\n self.model = tf.contrib.predictor.from_saved_model(directory)","def load_embeddings_models():\n\n\t# ---LOADING WORD2VEC MODEL---\n\tmodel_load_path = os.path.join(ROOT_PATH, 'models', 'word2vec', 'NILC', 'nilc_cbow_s300_300k.txt')\n\t# model_load_path = os.path.join('models', 'word2vec', 'NILC', 'nilc_skip_s300.txt')\n\tstart_time = time.time()\n\tprint(\"Started loading the word2vec model\")\n\tword2vec_model = KeyedVectors.load_word2vec_format(model_load_path)\n\t# word2vec_model = None\n\tprint(\"Model loaded\")\n\tprint(\"--- %s seconds ---\" %(time.time() - start_time))\n\tprint('\\a')\n\n\t# ---LOADING FASTTEXT MODEL---\n\tmodel_path = os.path.join(ROOT_PATH, 'models', 'fastText', 'cc.pt.300_300k.vec')\n\tstart_time = time.time()\n\tprint(\"Started loading the fasttext model\")\n\tfasttext_model = KeyedVectors.load_word2vec_format(model_path)\n\t# fasttext_model = None\n\tprint(\"Model loaded\")\n\tprint(\"--- %s seconds ---\" %(time.time() - start_time))\n\tprint('\\a')\t\n\n\t# ---LOADING PT-LKB MODEL---\n\tmodel_load_path = os.path.join(ROOT_PATH, 'models', 'ontoPT', 'PT-LKB_embeddings_64', 'ptlkb_64_30_200_p_str.emb')\n\t# model_load_path = os.path.join('models', 'ontoPT', 'PT-LKB_embeddings_128', 'ptlkb_128_80_10_p_str.emb')\n\tstart_time = time.time()\n\tprint(\"Started loading the PT-LKB-64 model\")\n\tptlkb64_model = KeyedVectors.load_word2vec_format(model_load_path)\n\t# ptlkb64_model = None\n\tprint(\"Model loaded\")\n\tprint(\"--- %s seconds ---\" %(time.time() - start_time))\n\tprint('\\a')\n\n\t# ---LOADING GLOVE-300 MODEL---\n\tmodel_load_path = os.path.join(ROOT_PATH, 'models', 'glove', 'glove_s300_300k.txt')\n\t# model_load_path = os.path.join('models', 'glove', 'glove_s100.txt')\n\tstart_time = time.time()\n\tprint(\"Started loading the GLOVE 300 dimensions model\")\n\tglove300_model = KeyedVectors.load_word2vec_format(model_load_path)\n\t# glove300_model = None\n\tprint(\"Model loaded\")\n\tprint(\"--- %s seconds ---\" %(time.time() - start_time))\n\tprint('\\a')\n\n\t# ---LOADING NUMBERBATCH MODEL---\n\tmodel_load_path = os.path.join(ROOT_PATH, 'models', 'numberbatch', 'numberbatch-17.02_pt_tratado.txt')\n\tstart_time = time.time()\n\tprint(\"Started loading the NUMBERBATCH dimensions model\")\n\tnumberbatch_model = KeyedVectors.load_word2vec_format(model_load_path)\n\t# numberbatch_model = None\n\tprint(\"Model loaded\")\n\tprint(\"--- %s seconds ---\" %(time.time() - start_time))\n\tprint('\\a')\n\n\treturn word2vec_model, fasttext_model, ptlkb64_model, glove300_model, numberbatch_model","def load_pretrained_model(self, load_from, load_partial_graph=False):\n print(\"loading model from %s\\n\" % (load_from))\n try:\n if self.use_cuda:\n pretrained_dict = torch.load(load_from)\n else:\n pretrained_dict = torch.load(load_from, map_location='cpu')\n\n model_dict = self.online_net.state_dict()\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}\n if load_partial_graph and len(self.load_parameter_keywords) > 0:\n tmp_pretrained_dict = {}\n for k, v in pretrained_dict.items():\n for keyword in self.load_parameter_keywords:\n if keyword in k:\n tmp_pretrained_dict[k] = v\n break\n pretrained_dict = tmp_pretrained_dict\n model_dict.update(pretrained_dict)\n self.online_net.load_state_dict(model_dict)\n print(\"The loaded parameters are:\")\n keys = [key for key in pretrained_dict]\n print(\", \".join(keys))\n print(\"--------------------------\")\n except:\n print(\"Failed to load checkpoint...\")","def load_word2vec_en_pretrained():\r\n log.info(\"Load W2V Model\")\r\n model = api.load(\"glove-wiki-gigaword-50\")\r\n return PreTrainedGensimEN(model)","def init_weights(self):\n if isinstance(self.pretrained, str):\n logger = get_root_logger()\n logger.info(f'load model from: {self.pretrained}')\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\n elif self.pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n xavier_init(m, distribution='uniform')\n elif isinstance(m, nn.Linear):\n normal_init(m, std=0.01)\n else:\n raise TypeError('pretrained must be a str or None')","def get_pretrained_weights(idx_word):\n n = len(idx_word)\n embed_dim = 25\n weights = mx.ndarray.zeros((n, embed_dim))\n print('Start downloading pre-trained vectors, this will take some time')\n glov = api.load(\"glove-twitter-25\")\n print('Pre-trained vectors downloading complete')\n not_in_vocab = 0\n for i in range(n):\n word = idx_word[i]\n try:\n weights[i] = glov[word]\n except: #if not in glove vocabulary\n not_in_vocab += 1\n weights[i] = mx.nd.random.normal(0, 0.1, embed_dim)\n if not_in_vocab > 0:\n print('Warning: {} words not in vocab of pretrained embeddings (glove-twitter-25)'.format(not_in_vocab))\n return weights","def initialize_trained_model(cls, device):\n model = cls(device=device)\n model_path = os.path.join(_FILE_PREFIX, 'weights/translator_weights_16')\n model.load_state_dict(torch.load(model_path, map_location=device), strict=True)\n print('Loaded model from {}'.format(model_path))\n return model","def load_model(self):\n try:\n self.model = Word2Vec.load(self.config[\"model_path\"])\n self.model.init_sims(replace=True)\n except Exception as e:\n print(e)\n print(\"error in model loading!\")","def load_checkpoint(filepath):\n checkpoint = torch.load(filepath)\n \n arch = checkpoint['arch']\n if arch == 'vgg':\n model = models.vgg16(pretrained=True)\n elif arch == 'densenet':\n model = models.densenet121(pretrained=True) \n \n model.class_to_idx = checkpoint['class_to_idx']\n model.classifier = checkpoint['classifier']\n model.classifier.load_sate_dict = checkpoint['classifier_state_dict']\n model.optimizer = checkpoint['optimizer_state_dict']\n model.input_size = checkpoint['input_size']\n model.output_size = checkpoint['output_size']\n \n return model","def init_weights(self, pretrained=None):\n super(SingleTwoStageDetector176PRW, self).init_weights(pretrained)\n self.backbone.init_weights(pretrained=pretrained)\n if self.with_neck:\n if isinstance(self.neck, nn.Sequential):\n for m in self.neck:\n m.init_weights()\n else:\n self.neck.init_weights()\n if self.with_rpn:\n self.rpn_head.init_weights()\n if self.with_roi_head:\n self.roi_head.init_weights(pretrained)\n self.bbox_head.init_weights()","def load_and_fuse_pretrained_weights(model: torch.nn.Module, opt: argparse.ArgumentParser) -> torch.nn.Module:\n model.optimize_for_inference(fuse_all_layers=False)\n fused_state_dict = load_weights(opt.weights)\n fused_state_dict = map_key_names(fused_state_dict, model.state_dict())\n model.load_state_dict(fused_state_dict)\n return model","def load_trainer(self):\n super().load_trainer()\n\n logging.info(\"[Server #%d] Loading a pre-trained model.\", os.getpid())\n self.trainer.load_model()","def custom_model():\n\t# initialize the model\n\t# load weights from path\n\t# returns model\n\tmodel = mlp.get_training_model()\n\tmodel.load_state_dict(torch.load(\"model_wt.pth\"))\n\treturn model","def load_pretrained_model(model, pretrained_model_path, verbose=False):\n\n if isinstance(pretrained_model_path, str):\n if not os.path.exists(pretrained_model_path):\n raise IOError(\n \"Can't find pretrained model: {}\".format(pretrained_model_path)\n )\n\n print(\"Loading checkpoint from '{}'\".format(pretrained_model_path))\n pretrained_state = torch.load(pretrained_model_path)[\"state_dict\"]\n else:\n # incase pretrained model weights are given\n pretrained_state = pretrained_model_path\n\n print(len(pretrained_state), \" keys in pretrained model\")\n\n current_model_state = model.state_dict()\n print(len(current_model_state), \" keys in current model\")\n pretrained_state = {\n key: val\n for key, val in pretrained_state.items()\n if key in current_model_state and val.size() == current_model_state[key].size()\n }\n\n print(\n len(pretrained_state),\n \" keys in pretrained model are available in current model\",\n )\n current_model_state.update(pretrained_state)\n model.load_state_dict(current_model_state)\n\n if verbose:\n non_available_keys_in_pretrained = [\n key\n for key, val in pretrained_state.items()\n if key not in current_model_state\n or val.size() != current_model_state[key].size()\n ]\n non_available_keys_in_current = [\n key\n for key, val in current_model_state.items()\n if key not in pretrained_state or val.size() != pretrained_state[key].size()\n ]\n\n print(\n \"not available keys in pretrained model: \", non_available_keys_in_pretrained\n )\n print(\"not available keys in current model: \", non_available_keys_in_current)\n\n return model","def init_weights(self):\n if isinstance(self.pretrained, str):\n logger = get_root_logger()\n logger.info(f'load model from: {self.pretrained}')\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\n elif self.pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n xavier_init(m, distribution='uniform')\n elif isinstance(m, nn.Linear):\n normal_init(m, std=0.01)\n elif isinstance(m, nn.BatchNorm2d):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def load_pretrained_embeddings(self, embeddings):\r\n self.embedding.weight = nn.Parameter(embeddings)","def load_pretrained_weights(model, weight_path):\n checkpoint = load_checkpoint(weight_path)\n if 'state_dict' in checkpoint:\n state_dict = checkpoint['state_dict']\n else:\n state_dict = checkpoint\n\n model_dict = model.state_dict()\n new_state_dict = OrderedDict()\n matched_layers, discarded_layers = [], []\n\n for k, v in state_dict.items():\n if k.startswith('module.'):\n k = k[7:] # discard module.\n\n if k in model_dict and model_dict[k].size() == v.size():\n new_state_dict[k] = v\n matched_layers.append(k)\n else:\n discarded_layers.append(k)\n\n model_dict.update(new_state_dict)\n model.load_state_dict(model_dict)\n\n if len(matched_layers) == 0:\n warnings.warn(\n 'The pretrained weights \"{}\" cannot be loaded, '\n 'please check the key names manually '\n '(** ignored and continue **)'.format(weight_path)\n )\n #else:\n #print(\n # 'Successfully loaded pretrained weights from \"{}\"'.\n # format(weight_path)\n #)\n #if len(discarded_layers) > 0:\n # print(\n # '** The following layers are discarded '\n # 'due to unmatched keys or layer size: {}'.\n # format(discarded_layers)\n # )","def load_model_weights(self):\n raise NotImplementedError","def load_model(self):\n if torch.cuda.is_available():\n map_location=lambda storage, loc: storage.cuda()\n else:\n map_location='cpu'\n\n for index, agent in enumerate(self.agents):\n agent.actor_local.load_state_dict(torch.load('agent{}_checkpoint_actor.pth'.format(index + 1), map_location=map_location))\n agent.critic_local.load_state_dict(torch.load('agent{}_checkpoint_critic.pth'.format(index + 1), map_location=map_location))","def pre_dl_models():\n keras.applications.xception.Xception(include_top=True, weights='imagenet', input_tensor=None,\n input_shape=None, pooling=None, classes=1000)\n\n # keras.applications.vgg16.VGG16(include_top=True, weights='imagenet', input_tensor=None,\n # input_shape=None, pooling=None, classes=1000)\n\n # keras.applications.vgg19.VGG19(include_top=True, weights='imagenet', input_tensor=None,\n # input_shape=None, pooling=None, classes=1000)\n\n # keras.applications.resnet50.ResNet50(include_top=True, weights='imagenet', input_tensor=None,\n # input_shape=None, pooling=None, classes=1000)\n\n # keras.applications.inception_v3.InceptionV3(include_top=True, weights='imagenet', input_tensor=None,\n # input_shape=None, pooling=None, classes=1000)","def load_pretrained_model(model_name):\n if model_name==\"AlexNet\":\n print(\"Loading pretrained AlexNet Model\")\n model_ft = models.alexnet(pretrained=True)\n\n for param in model_ft.parameters():# Code for fixing the Conv Layer\n param.requires_grad = False\n num_ftrs = model_ft.classifier[6].in_features\n model_ft.classifier[6] = nn.Linear(num_ftrs, 100)\n elif model_name==\"ResNet18\":\n print(\"Loading pretrained ResNet18 Model\")\n model_ft = models.resnet18(pretrained=True)\n\n for param in model_ft.parameters(): # Code for fixing the Conv Layer\n param.requires_grad = False # During Training Conv layer does not learn.\n num_ftrs = model_ft.fc.in_features\n model_ft.fc = nn.Linear(num_ftrs, 100)\n elif model_name==\"ResNet50\":\n print(\"Loading pretrained ResNet50 Model\")\n\n model_ft = models.resnet50(pretrained=True)\n for param in model_ft.parameters():# Code for fixing the Conv Layer\n param.requires_grad = False\n\n num_ftrs = model_ft.fc.in_features\n model_ft.fc = nn.Linear(num_ftrs, 100)\n elif model_name==\"DenseNet\":\n print(\"Loading pretrained DenseNet161 Model\")\n model_ft = models.densenet161(pretrained=True)\n\n for param in model_ft.parameters():# Code for fixing the Conv Layer\n param.requires_grad = False\n num_ftrs = model_ft.classifier.in_features\n model_ft.classifier = nn.Linear(num_ftrs, 100)\n\n if cfg.load_model_true:\n model_ft.load_state_dict(torch.load(cfg.load_model_path))\n\n return model_ft","def load_pretrained_layers(self):\n # Current state of base\n state_dict = self.state_dict()\n param_names = list(state_dict.keys())\n\n # VGG base with pretrained weights\n pretrained_state_dict = torchvision.models.vgg16(pretrained=True).state_dict()\n pretrained_param_names = list(pretrained_state_dict.keys())\n\n # Copy pretrained weights to our current VGG model base\n for i, param in enumerate(param_names[:-4]): # excluding conv6 and conv7 parameters\n state_dict[param] = pretrained_state_dict[pretrained_param_names[i]]\n\n # Convert fc6, fc7 to convolutional layers, and subsample (by decimation) to sizes of conv6 and conv7\n # fc6\n conv_fc6_weight = pretrained_state_dict['classifier.0.weight'].view(4096, 512, 7, 7) # (4096, 512, 7, 7)\n conv_fc6_bias = pretrained_state_dict['classifier.0.bias'] # (4096)\n state_dict['conv6.weight'] = decimate(conv_fc6_weight, m=[4, None, 3, 3]) # (1024, 512, 3, 3)\n state_dict['conv6.bias'] = decimate(conv_fc6_bias, m=[4]) # (1024)\n # fc7\n conv_fc7_weight = pretrained_state_dict['classifier.3.weight'].view(4096, 4096, 1, 1) # (4096, 4096, 1, 1)\n conv_fc7_bias = pretrained_state_dict['classifier.3.bias'] # (4096)\n state_dict['conv7.weight'] = decimate(conv_fc7_weight, m=[4, 4, None, None]) # (1024, 1024, 1, 1)\n state_dict['conv7.bias'] = decimate(conv_fc7_bias, m=[4]) # (1024)\n\n self.load_state_dict(state_dict)\n\n print(\"\\nLoaded base model.\\n\")","def load_model(self, ):\n \n tf.keras.backend.clear_session()\n \n self.load_weights(os.path.join(self.weights_dir, \"countmodel_weights_\" + self.name_)).expect_partial()","def load_model(self, ckpt_name=\"best_model.pth\"):\n path = \"/\".join(ckpt_name.split(\"/\")[:-1])\n chkpt = torch.load(ckpt_name)\n self.start_epoch = chkpt['epoch']\n self.best_metric = chkpt['best_metric']\n\n # fix the DataParallel caused problem with keys names\n if self.multi_gpu_flag:\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=False)\n self.net.load_state_dict(new_state_dict)\n else:\n try:\n self.net.load_state_dict(chkpt['state_dict'])\n except:\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=True)\n self.net.load_state_dict(new_state_dict)\n\n if self.load_optimizer_state:\n self.optimizer.load_state_dict(chkpt['optimizer'])\n logging.info(\"******** State loaded ********\")\n\n training_meta = pickle.load(open(f\"{path}/training_meta.pickle.dat\", \"rb\"))\n for k, v in training_meta.items():\n if k in self.__class__.__params:\n setattr(self, k, v)\n logging.info(\"******** Training params loaded ********\")","def load_model_weights(sess, checkpoint_dir):\n\n init_fn = slim.assign_from_checkpoint_fn(\n checkpoint_dir, slim.get_model_variables(), ignore_missing_vars=True)\n init_fn(sess)","def load_pretrained_embeddings(self, embeddings):\n self.embedding.weight = nn.Parameter(embeddings)","def load_model_and_weights(self):\n \n with open(self.model_json) as file:\n m_json = file.read()\n \n self.tf_model = tf.keras.models.model_from_json(m_json) \n self.tf_model.load_weights(self.weights_file)\n \n self.Helpers.logger.info(\"Model loaded \")\n \n self.tf_model.summary()","def load_model():\n global obj\n obj = NutritionTableDetector()\n print(\"Weights Loaded!\")","def load_tf_weights_in_t5(model, config, tf_checkpoint_path):\n try:\n import re\n import numpy as np\n import tensorflow as tf\n except ImportError:\n logger.error(\n \"Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see \"\n \"https://www.tensorflow.org/install/ for installation instructions.\"\n )\n raise\n tf_path = os.path.abspath(tf_checkpoint_path)\n logger.info(\"Converting TensorFlow checkpoint from {}\".format(tf_path))\n # Load weights from TF model\n init_vars = tf.train.list_variables(tf_path)\n names = []\n tf_weights = {}\n for name, shape in init_vars:\n logger.info(\"Loading TF weight {} with shape {}\".format(name, shape))\n array = tf.train.load_variable(tf_path, name)\n names.append(name)\n tf_weights[name] = array\n\n for txt_name in names:\n name = txt_name.split(\"/\")\n # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v\n # which are not required for using pretrained model\n if any(\n n in [\"adam_v\", \"adam_m\", \"AdamWeightDecayOptimizer\", \"AdamWeightDecayOptimizer_1\", \"global_step\"]\n for n in name\n ):\n logger.info(\"Skipping {}\".format(\"/\".join(name)))\n tf_weights.pop(txt_name, None)\n continue\n if \"_slot_\" in name[-1]:\n logger.info(\"Skipping {}\".format(\"/\".join(name)))\n tf_weights.pop(txt_name, None)\n continue\n pointer = model\n array = tf_weights[txt_name]\n for m_name in name:\n if re.fullmatch(r\"[A-Za-z]+_\\d+\", m_name):\n scope_names = re.split(r\"_(\\d+)\", m_name)\n else:\n scope_names = [m_name]\n if scope_names[0] in [\"kernel\", \"scale\", \"embedding\"]:\n pointer = getattr(pointer, \"weight\")\n # elif scope_names[0] == 'scale':\n # pointer = getattr(pointer, 'weight')\n # elif scope_names[0] == 'output_bias' or scope_names[0] == 'beta':\n # pointer = getattr(pointer, 'bias')\n # elif scope_names[0] == 'squad':\n # pointer = getattr(pointer, 'classifier')\n else:\n try:\n pointer = getattr(pointer, scope_names[0])\n except AttributeError:\n logger.info(\"Skipping {}\".format(\"/\".join(name)))\n continue\n if len(scope_names) >= 2:\n num = int(scope_names[1])\n pointer = pointer[num]\n if scope_names[0] not in [\"kernel\", \"scale\", \"embedding\"]:\n pointer = getattr(pointer, \"weight\")\n if scope_names[0] != \"embedding\":\n logger.info(\"Transposing numpy weight of shape {} for {}\".format(array.shape, name))\n array = np.transpose(array)\n try:\n assert pointer.shape == array.shape\n except AssertionError as e:\n e.args += (pointer.shape, array.shape)\n raise\n logger.info(\"Initialize PyTorch weight {}\".format(name))\n pointer.data = torch.from_numpy(array.astype(np.float32))\n tf_weights.pop(txt_name, None)\n\n logger.info(\"Weights not copied to PyTorch model: {}\".format(\", \".join(tf_weights.keys())))\n # logger.info(\"Weights not copied to PyTorch model: {}\".format(', '.join(tf_weights.keys())))\n return model","def load_pretrained_model(self, model_path):\n # My eyes and my heart both hurt when writing this method\n\n # Only care about layer_types that have trainable parameters\n ltypes = ['BNData', 'ConvolutionData', 'HoleConvolutionData']\n\n def _get_layer_params(layer, ltype):\n\n if ltype == 'BNData': \n n_channels = layer.blobs[0].shape.dim[1]\n gamma = np.array(layer.blobs[0].data).reshape(n_channels)\n beta = np.array(layer.blobs[1].data).reshape(n_channels)\n mean = np.array(layer.blobs[2].data).reshape(n_channels)\n var = np.array(layer.blobs[3].data).reshape(n_channels)\n return [mean, var, gamma, beta]\n\n elif ltype in ['ConvolutionData', 'HoleConvolutionData']:\n is_bias = layer.convolution_param.bias_term\n shape = [int(d) for d in layer.blobs[0].shape.dim]\n weights = np.array(layer.blobs[0].data).reshape(shape)\n bias = []\n if is_bias:\n bias = np.array(layer.blobs[1].data).reshape(shape[0])\n return [weights, bias]\n \n elif ltype == 'InnerProduct':\n raise Exception(\"Fully connected layers {}, not supported\".format(ltype))\n\n else:\n raise Exception(\"Unkown layer type {}\".format(ltype))\n\n\n net = caffe_pb2.NetParameter()\n with open(model_path, 'rb') as model_file:\n net.MergeFromString(model_file.read())\n\n # dict formatted as -> key:<layer_name> :: value:<layer_type>\n layer_types = {}\n # dict formatted as -> key:<layer_name> :: value:[<list_of_params>]\n layer_params = {}\n\n for l in net.layer:\n lname = l.name\n ltype = l.type\n if ltype in ltypes:\n print(\"Processing layer {}\".format(lname))\n layer_types[lname] = ltype\n layer_params[lname] = _get_layer_params(l, ltype)\n\n # Set affine=False for all batchnorm modules\n def _no_affine_bn(module=None):\n if isinstance(module, nn.BatchNorm2d):\n module.affine = False\n\n if len([m for m in module.children()]) > 0:\n for child in module.children():\n _no_affine_bn(child)\n\n #_no_affine_bn(self)\n\n\n def _transfer_conv(layer_name, module):\n weights, bias = layer_params[layer_name]\n w_shape = np.array(module.weight.size())\n \n np.testing.assert_array_equal(weights.shape, w_shape)\n print(\"CONV: Original {} and trans weights {}\".format(w_shape,\n weights.shape))\n module.weight.data = torch.from_numpy(weights)\n\n if len(bias) != 0:\n b_shape = np.array(module.bias.size())\n np.testing.assert_array_equal(bias.shape, b_shape)\n print(\"CONV: Original {} and trans bias {}\".format(b_shape,\n bias.shape))\n module.bias.data = torch.from_numpy(bias)\n\n\n def _transfer_conv_bn(conv_layer_name, mother_module):\n conv_module = mother_module[0]\n bn_module = mother_module[1]\n \n _transfer_conv(conv_layer_name, conv_module)\n \n mean, var, gamma, beta = layer_params[conv_layer_name+'/bn']\n print(\"BN: Original {} and trans weights {}\".format(bn_module.running_mean.size(),\n mean.shape))\n bn_module.running_mean = torch.from_numpy(mean)\n bn_module.running_var = torch.from_numpy(var)\n bn_module.weight.data = torch.from_numpy(gamma)\n bn_module.bias.data = torch.from_numpy(beta)\n\n\n def _transfer_residual(prefix, block):\n block_module, n_layers = block[0], block[1]\n\n bottleneck = block_module.layers[0]\n bottleneck_conv_bn_dic = {prefix + '_1_1x1_reduce': bottleneck.cbr1.cbr_unit,\n prefix + '_1_3x3': bottleneck.cbr2.cbr_unit,\n prefix + '_1_1x1_proj': bottleneck.cb4.cb_unit,\n prefix + '_1_1x1_increase': bottleneck.cb3.cb_unit,}\n\n for k, v in bottleneck_conv_bn_dic.items():\n _transfer_conv_bn(k, v)\n\n for layer_idx in range(2, n_layers+1):\n residual_layer = block_module.layers[layer_idx-1]\n residual_conv_bn_dic = {'_'.join(map(str, [prefix, layer_idx, '1x1_reduce'])): residual_layer.cbr1.cbr_unit,\n '_'.join(map(str, [prefix, layer_idx, '3x3'])): residual_layer.cbr2.cbr_unit,\n '_'.join(map(str, [prefix, layer_idx, '1x1_increase'])): residual_layer.cb3.cb_unit,} \n \n for k, v in residual_conv_bn_dic.items():\n _transfer_conv_bn(k, v)\n\n\n convbn_layer_mapping = {'conv1_1_3x3_s2': self.convbnrelu1_1.cbr_unit,\n 'conv1_2_3x3': self.convbnrelu1_2.cbr_unit,\n 'conv1_3_3x3': self.convbnrelu1_3.cbr_unit,\n 'conv5_3_pool6_conv': self.pyramid_pooling.paths[0].cbr_unit, \n 'conv5_3_pool3_conv': self.pyramid_pooling.paths[1].cbr_unit,\n 'conv5_3_pool2_conv': self.pyramid_pooling.paths[2].cbr_unit,\n 'conv5_3_pool1_conv': self.pyramid_pooling.paths[3].cbr_unit,\n 'conv5_4': self.cbr_final.cbr_unit,}\n\n residual_layers = {'conv2': [self.res_block2, self.block_config[0]],\n 'conv3': [self.res_block3, self.block_config[1]],\n 'conv4': [self.res_block4, self.block_config[2]],\n 'conv5': [self.res_block5, self.block_config[3]],}\n\n # Transfer weights for all non-residual conv+bn layers\n for k, v in convbn_layer_mapping.items():\n _transfer_conv_bn(k, v)\n\n # Transfer weights for final non-bn conv layer\n _transfer_conv('conv6', self.classification)\n\n # Transfer weights for all residual layers\n for k, v in residual_layers.items():\n _transfer_residual(k, v)","def init_weights(self, pretrained=None):\n self.online_backbone.init_weights() # backbone\n for online_neck in self.online_necks:\n online_neck.init_weights(init_linear='kaiming') # projection\n\n for param_ol, param_tgt in zip(self.online_backbone.parameters(),\n self.target_backbone.parameters()):\n param_tgt.data.copy_(param_ol.data)\n for param_ol, param_tgt in zip(self.online_necks.parameters(),\n self.target_necks.parameters()):\n param_tgt.data.copy_(param_ol.data)\n # init the predictor in the head\n for head in self.heads:\n head.init_weights()","def load_pretrained_model(\n init_param: str,\n model: torch.nn.Module,\n map_location: str = \"cpu\",\n):\n sps = init_param.split(\":\", 4)\n if len(sps) == 4:\n path, src_key, dst_key, excludes = sps\n elif len(sps) == 3:\n path, src_key, dst_key = sps\n excludes = None\n elif len(sps) == 2:\n path, src_key = sps\n dst_key, excludes = None, None\n else:\n (path,) = sps\n src_key, dst_key, excludes = None, None, None\n if src_key == \"\":\n src_key = None\n if dst_key == \"\":\n dst_key = None\n\n if dst_key is None:\n obj = model\n else:\n\n def get_attr(obj: Any, key: str):\n \"\"\"Get an nested attribute.\n\n >>> class A(torch.nn.Module):\n ... def __init__(self):\n ... super().__init__()\n ... self.linear = torch.nn.Linear(10, 10)\n >>> a = A()\n >>> assert A.linear.weight is get_attr(A, 'linear.weight')\n\n \"\"\"\n if key.strip() == \"\":\n return obj\n for k in key.split(\".\"):\n obj = getattr(obj, k)\n return obj\n\n obj = get_attr(model, dst_key)\n\n src_state = torch.load(path, map_location=map_location)\n if excludes is not None:\n for e in excludes.split(\",\"):\n src_state = {k: v for k, v in src_state.items() if not k.startswith(e)}\n\n if src_key is not None:\n src_state = {\n k[len(src_key) + 1 :]: v\n for k, v in src_state.items()\n if k.startswith(src_key)\n }\n\n # tts.dec.feat_out,tts.dec.prob_out\n\n dst_state = obj.state_dict()\n\n for key in list(src_state.keys()):\n if src_state[key].shape != dst_state[key].shape:\n src_shape = src_state[key].shape\n dst_shape = dst_state[key].shape\n print(f'\"{key}\" shapes do not match:', src_shape, dst_shape)\n if src_shape[0] < dst_shape[0] and src_shape[1:] == dst_shape[1:]:\n print(f'doing partial override of \"{key}\"')\n dst_state[key][:src_shape[0]] = src_state[key]\n del src_state[key]\n\n dst_state.update(src_state)\n obj.load_state_dict(dst_state)","def training(self):\r\n self.model, self.voc = svm_clf_training('all', self.dataset)\r\n return 0","def load_model(exe, graph, dirname):\n assert graph is not None and dirname is not None\n graph = GraphWrapper(graph) if isinstance(graph,\n paddle.static.Program) else graph\n\n SHAPES_FILE = os.path.join(dirname, _SHAPES_FILE)\n with open(SHAPES_FILE, \"r\") as f:\n shapes = json.load(f)\n for param_name, shape in shapes.items():\n param = graph.var(param_name)\n if param is not None:\n param.set_shape(shape)\n else:\n _logger.info('{} is not loaded'.format(param_name))\n _logger.info(\"Load shapes of weights from {}\".format(SHAPES_FILE))\n\n GROUPS_FILE = os.path.join(dirname, _GROUPS_FILE)\n with open(GROUPS_FILE, \"r\") as f:\n groups = json.load(f)\n for op in graph.ops():\n if 'conv2d' in op.type():\n filter_name = op.inputs('Filter')[0].name()\n op.set_attr('groups', groups[filter_name])\n _logger.info(\"Load groups of conv2d from {}\".format(GROUPS_FILE))\n\n paddle.static.load(program=graph.program, model_path=dirname, executor=exe)\n graph.infer_shape()\n _logger.info(\"Load weights from {}\".format(dirname))","def _prepare_libsvm_data(self):\n logging.info('Preparing libsvm training data...')\n if self.clean or not (self.is_s3_file(self.s3_training_file) and self.is_s3_file(self.s3_validation_file)):\n logging.info('S3 libsvm files do not exist.')\n if self.clean or not (os.path.isfile(self.local_libsvm_training_file) and os.path.isfile(self.local_libsvm_validation_file)):\n logging.info('Local libsvm files do not exist.')\n logging.info('Generating local libsvm files...')\n dump_svmlight_file(X=self.training_x, y=self.training_y, f=self.local_libsvm_training_file)\n dump_svmlight_file(X=self.validation_x, y=self.validation_y, f=self.local_libsvm_validation_file)\n logging.info('Local libsvm files found. Uploading to S3...')\n upload_file_to_s3(self.local_libsvm_training_file, self.infra_s3['s3_bucket'], self.s3_training_file)\n upload_file_to_s3(self.local_libsvm_validation_file, self.infra_s3['s3_bucket'], self.s3_validation_file)\n else:\n logging.info('S3 libsvm files already exist. Skipping step.')","def load_model(self):\n for t in self.topic:\n if t != \"other\":\n print(\"Loading models of topic: \", t)\n for st in self.topic2sub_topic[t].keys():\n model = tf.keras.Sequential()\n model.add(tf.keras.layers.InputLayer(input_shape=[1024, ]))\n model.add(tf.keras.layers.Dense(64, activation='relu'))\n model.add(tf.keras.layers.Dense(64, activation='relu'))\n model.add(tf.keras.layers.Dense(1, activation='relu'))\n model.compile(loss='mean_squared_logarithmic_error', optimizer='adam', metrics=[metrics.mae, metrics.categorical_accuracy])\n\n if not os.path.exists(self.trained_w_folder+\"/%s/%s.h5\" %(t,st)):\n print(\"Now training the classsfier for topic: \", t, \" ; intent: \", st)\n print(64 * \"=\")\n X, y = self.get_data(t, st)\n print(\"data_loaded!\")\n X_train, X_dev, y_train, y_dev = self.my_train_test_split(X, y)\n model.fit(X_train, y_train, epochs=3, batch_size=128)\n model.save_weights(self.trained_w_folder+\"/%s/%s.h5\" %(t,st))\n print(\"f1_score on dev set: \")\n self.f1_score_model(model, X_dev, y_dev)\n print(64*\"=\")\n print()\n else:\n model.load_weights(self.trained_w_folder+\"/%s/%s.h5\" %(t,st))\n print(\"Loaded weights for model \" + t + \" : \" + st)\n self.model_zoo[t][st] = model","def load_opcodes_subnetwork_pretrained_weights(self, model):\n print(\"ToImplement\")","def load_pretrained_vectors(self, emb_file, fixed):\n if emb_file:\n pretrained = torch.load(emb_file)\n self.word_lut.weight.data.copy_(pretrained)\n if fixed:\n self.word_lut.weight.requires_grad = False","def __init__(self, load_model_dir=None):\n \n if load_model_dir:\n raise RuntimeError('Whoops. Not implemented yet')\n \n ## Load pickeled preprocessing function (applied to raw features)\n ## Load pickeled postprocessing function (applied to labels before output)\n ## Load tf model","def load_weights(self):\n stage1_weights = (\n self.cfg.get(\"STAGE1\", \"WEIGHTS\")\n if self.cfg.getboolean(\"STAGE1\", \"LOADPREV\")\n else None\n )\n\n stage2_weights = (\n self.cfg.get(\"STAGE2\", \"WEIGHTS\")\n if self.cfg.getboolean(\"STAGE1\", \"LOADPREV\")\n else None\n )\n\n self.cross_skip = self.cfg.getboolean(\"STAGE2\", \"CROSS_SKIP\")\n\n if self.cfg.get(\"STAGE1\", \"ENCODER\") != \"UNET\":\n raise NotImplementedError\n\n log.info(\"STAGE 1 UNET\")\n # Flow Computation Model\n self.stage1_model = unet.get_model(\n stage1_weights, 6, 4, self.cross_skip, stage=1, cfg=self.cfg\n )\n\n # Flow Interpolation Model\n log.info(\"STAGE 2 %s\", self.cfg.get(\"STAGE2\", \"ENCODER\"))\n self.stage2_model = unet.get_model(\n stage2_weights, 16, 5, self.cross_skip, stage=2, cfg=self.cfg\n )\n\n log.info(\"Cross stage Skip Connections Present? %s \", self.cross_skip)","def load_pretrained_graph_generation_model(self, load_from):\n print(\"loading pre-trained graph generation model from %s\\n\" % (load_from))\n try:\n if self.use_cuda:\n pretrained_dict = torch.load(load_from)\n else:\n pretrained_dict = torch.load(load_from, map_location='cpu')\n try:\n self.pretrained_graph_generation_net.load_state_dict(pretrained_dict)\n print(\"Successfully loaded pre-trained graph generation model...\")\n except:\n # graph generation net\n model_dict = self.pretrained_graph_generation_net.state_dict()\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if (k in model_dict and \"action_scorer\" not in k)}\n difference_pretrain_this = [k for k, _ in pretrained_dict.items() if k not in model_dict]\n difference_this_pretrain = [k for k, _ in model_dict.items() if k not in pretrained_dict]\n model_dict.update(pretrained_dict)\n self.pretrained_graph_generation_net.load_state_dict(model_dict)\n print(\"WARNING... Model dict is different with pretrained dict. I'm loading only the parameters with same labels now. Make sure you really want this...\")\n print(\"The loaded parameters are:\")\n keys = [key for key in pretrained_dict]\n print(\", \".join(keys))\n print(\"--------------------------\")\n print(\"Parameters in pre-trained model but not in the current model are:\")\n print(\", \".join(difference_pretrain_this))\n print(\"--------------------------\")\n print(\"Parameters in current model but not in the pre-trained model are:\")\n print(\", \".join(difference_this_pretrain))\n print(\"--------------------------\")\n except:\n print(\"Failed to load checkpoint...\")","def load_model(model_dir):\n if not osp.exists(model_dir):\n logging.error(\"model_dir '{}' does not exists!\".format(model_dir))\n if not osp.exists(osp.join(model_dir, \"model.yml\")):\n raise Exception(\"There's no model.yml in {}\".format(model_dir))\n with open(osp.join(model_dir, \"model.yml\")) as f:\n model_info = yaml.load(f.read(), Loader=yaml.Loader)\n f.close()\n\n version = model_info['version']\n if int(version.split('.')[0]) < 2:\n raise Exception(\n 'Current version is {}, a model trained by PaddleX={} cannot be load.'.\n format(paddlex.__version__, version))\n\n status = model_info['status']\n\n if not hasattr(paddlex.cv.models, model_info['Model']):\n raise Exception(\"There's no attribute {} in paddlex.cv.models\".format(\n model_info['Model']))\n if 'model_name' in model_info['_init_params']:\n del model_info['_init_params']['model_name']\n\n with paddle.utils.unique_name.guard():\n model = getattr(paddlex.cv.models, model_info['Model'])(\n **model_info['_init_params'])\n\n if 'Transforms' in model_info:\n model.test_transforms = build_transforms(model_info['Transforms'])\n\n if '_Attributes' in model_info:\n for k, v in model_info['_Attributes'].items():\n if k in model.__dict__:\n model.__dict__[k] = v\n\n if status == 'Pruned' or osp.exists(osp.join(model_dir, \"prune.yml\")):\n with open(osp.join(model_dir, \"prune.yml\")) as f:\n pruning_info = yaml.load(f.read(), Loader=yaml.Loader)\n inputs = pruning_info['pruner_inputs']\n if model.model_type == 'detector':\n inputs = [{\n k: paddle.to_tensor(v)\n for k, v in inputs.items()\n }]\n model.pruner = getattr(paddleslim, pruning_info['pruner'])(\n model.net, inputs=inputs)\n model.pruning_ratios = pruning_info['pruning_ratios']\n model.pruner.prune_vars(\n ratios=model.pruning_ratios,\n axis=paddleslim.dygraph.prune.filter_pruner.FILTER_DIM)\n\n if status == 'Quantized':\n with open(osp.join(model_dir, \"quant.yml\")) as f:\n quant_info = yaml.load(f.read(), Loader=yaml.Loader)\n quant_config = quant_info['quant_config']\n model.quantizer = paddleslim.QAT(quant_config)\n model.quantizer.quantize(model.net)\n\n if status == 'Infer':\n if model_info['Model'] in ['FasterRCNN', 'MaskRCNN']:\n net_state_dict = load_rcnn_inference_model(model_dir)\n else:\n net_state_dict = paddle.load(osp.join(model_dir, 'model'))\n else:\n net_state_dict = paddle.load(osp.join(model_dir, 'model.pdparams'))\n model.net.set_state_dict(net_state_dict)\n\n logging.info(\"Model[{}] loaded.\".format(model_info['Model']))\n model.status = status\n return model","def create_train_model(self):\n st = LancasterStemmer()\n with open(self.data_path, encoding='utf8') as f_name:\n sentences = [[st.stem(w) for w, t in pos_tag(line.lower().split()) if 'N' in t] for line in f_name]\n sentences = [filter(lambda x: len(x) > 2, (word.strip(punctuation) for word in sentences)) for sent in sentences]\n model = Word2Vec(sentences,\n min_count=self.min_count,\n size=self.size,\n window=self.window,\n workers=4)\n model.save(self.model_path)","def LoadTeacherModels(lang):\n\n # load Trained teacher model parameters\n log_dir = 'data/logs'\n with open(log_dir + '/' + lang + '_model_params', 'rb') as fp:\n params = pickle.load(fp)\n\n model_args = params['args']\n\n if model_args.use_colab is None:\n OUTPUT_DIR = 'ckpts/' + model_args.lang\n if not os.path.isdir(OUTPUT_DIR): os.mkdir(OUTPUT_DIR)\n else:\n from google.colab import drive\n\n drive.mount('/content/gdrive')\n OUTPUT_DIR = '/content/gdrive/My Drive/ckpts/' + model_args.lang\n if not os.path.isdir(OUTPUT_DIR): os.mkdir(OUTPUT_DIR)\n\n if model_args.enc_type == 'gat' and model_args.dec_type == 'transformer':\n models = {}\n OUTPUT_DIR += '/' + model_args.enc_type + '_' + model_args.dec_type\n\n # Load the vocabs\n with open('vocabs/' + model_args.model + '/' +\n lang + '/' + model_args.opt + '_src_vocab', 'rb') as fp:\n src_vocab = pickle.load(fp)\n # loading the target vocab\n model_args.sentencepiece = 'False'\n if model_args.sentencepiece == 'True':\n sp = spm.SentencePieceProcessor()\n sp.load('vocabs/' + model_args.model + '/' +\n lang + '/' + 'train_tgt.model')\n tgt_vocab = sp\n else:\n tgt_vocab = src_vocab\n\n print('Loaded ' + lang + ' Parameters..')\n model = TransGAT(params['args'], params['src_vocab_size'], src_vocab,\n params['tgt_vocab_size'], tgt_vocab)\n # Load the latest checkpoints\n optimizer = tf.train.AdamOptimizer(beta1=0.9, beta2=0.98,\n epsilon=1e-9)\n\n ckpt = tf.train.Checkpoint(\n model=model,\n optimizer=optimizer\n )\n\n ckpt_manager = tf.train.CheckpointManager(ckpt, OUTPUT_DIR, max_to_keep=5)\n if ckpt_manager.latest_checkpoint:\n ckpt.restore(ckpt_manager.latest_checkpoint).expect_partial()\n\n print('Loaded ' + lang + ' Teacher model !')\n\n return model","def load_model():\n \n _files = training_file()\n \n predictor_path = _files.model_file(LANDMARKS_WEIGHTS)\n face_rec_model_path = _files.model_file(RESNET_WEIGHTS)\n \n detector = dlib.get_frontal_face_detector()\n sp = dlib.shape_predictor(predictor_path)\n facerec = dlib.face_recognition_model_v1(face_rec_model_path)\n \n return (detector, sp, facerec)","def load_checkpoint(tag, params, model):\r\n file_name = os.path.join(\"saved_models\", params.path, tag + \".pt\")\r\n logger.info(\"Load checkpoint from %s\" % file_name)\r\n if os.path.exists(file_name):\r\n checkpoint = torch.load(file_name, map_location='cpu')\r\n params.training_id = checkpoint['training_id']\r\n logger.info(checkpoint['training_id'])\r\n model.global_step = checkpoint['global_step']\r\n model.load_state_dict(checkpoint['model'])\r\n for i, optimizer in enumerate(model.optimizers):\r\n optimizer.load_state_dict(checkpoint['optimizers'][i])\r\n else:\r\n raise Exception(\"Checkpoint not found.\")","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n normal_init(m, std=0.001)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n normal_init(m, std=0.001)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n normal_init(m, std=0.001)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=False, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n normal_init(m, std=0.001)\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n else:\n raise TypeError('pretrained must be a str or None')","def modify_weights_after_load(model):\n # Prune heads if needed\n if model.config.pruned_heads:\n model.prune_heads(model.config.pruned_heads)\n\n # Tie weights if needed\n model.tie_weights()","def load_model(self, ckpt_fn):\n checkpoint = torch.load(ckpt_fn)\n self.net_.load_state_dict(checkpoint[\"model\"])\n self.optimizer_.load_state_dict(checkpoint[\"optimizer\"])\n self.epoch_ = checkpoint[\"epoch\"]\n self.global_step_ = checkpoint[\"global_step\"]\n self.model_samples_ = deque(checkpoint[\"model_samples\"])\n self.sampler.load_state_dict(checkpoint[\"sampler_state\"])\n self.ais_loss.load_state_dict(checkpoint[\"ais_state\"])\n self.replay_prob = checkpoint[\"replay_prob\"]\n self.max_replay = checkpoint[\"max_replay\"]","def model_load(self, filename_actor, filename_critic):\r\n self.actor = tf.keras.models.load_model(filename_actor)\r\n self.critic = tf.keras.models.load_model(filename_critic)","def model(pretrained=False, **kwargs):\r\n\r\n layers = make_layers(cfg['O'], dilation=dilation['D1'])\r\n cnv = np.cumsum(cnvs['OI']) if kwargs['args'].IN or kwargs['args'].INL else np.cumsum(cnvs['O'])\r\n model = VGG(layers, cnvs=cnv, **kwargs)\r\n if pretrained:\r\n pre2local_keymap = [('features.{}.weight'.format(i), 'conv1_2.{}.weight'.format(i)) for i in range(10)]\r\n pre2local_keymap += [('features.{}.bias'.format(i), 'conv1_2.{}.bias'.format(i)) for i in range(10)]\r\n pre2local_keymap += [('features.{}.weight'.format(i + 10), 'conv3.{}.weight'.format(i)) for i in range(7)]\r\n pre2local_keymap += [('features.{}.bias'.format(i + 10), 'conv3.{}.bias'.format(i)) for i in range(7)]\r\n pre2local_keymap += [('features.{}.weight'.format(i + 17), 'conv4.{}.weight'.format(i)) for i in range(7)]\r\n pre2local_keymap += [('features.{}.bias'.format(i + 17), 'conv4.{}.bias'.format(i)) for i in range(7)]\r\n pre2local_keymap += [('features.{}.weight'.format(i + 24), 'conv5.{}.weight'.format(i)) for i in range(7)]\r\n pre2local_keymap += [('features.{}.bias'.format(i + 24), 'conv5.{}.bias'.format(i)) for i in range(7)]\r\n pre2local_keymap = dict(pre2local_keymap)\r\n\r\n\r\n model_dict = model.state_dict()\r\n pretrained_file = os.path.join(kwargs['args'].pretrained_model_dir, kwargs['args'].pretrained_model)\r\n if os.path.isfile(pretrained_file):\r\n pretrained_dict = torch.load(pretrained_file)\r\n print('load pretrained model from {}'.format(pretrained_file))\r\n else:\r\n pretrained_dict = model_zoo.load_url(model_urls['vgg16'])\r\n print('load pretrained model from {}'.format(model_urls['vgg16']))\r\n # 0. replace the key\r\n pretrained_dict = {pre2local_keymap[k] if k in pre2local_keymap.keys() else k: v for k, v in\r\n pretrained_dict.items()}\r\n # *. show the loading information\r\n for k in pretrained_dict.keys():\r\n if k not in model_dict:\r\n print('Key {} is removed from vgg16'.format(k))\r\n print(' ')\r\n for k in model_dict.keys():\r\n if k not in pretrained_dict:\r\n print('Key {} is new added for DA Net'.format(k))\r\n # 1. filter out unnecessary keys\r\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}\r\n # 2. overwrite entries in the existing state dict\r\n model_dict.update(pretrained_dict)\r\n # 3. load the new state dict\r\n model.load_state_dict(model_dict)\r\n return model","def load_pretrainedmodels(model_name):\n\n # Lazy import as torchvision may not be required.\n import pretrainedmodels\n\n model = getattr(pretrainedmodels, model_name)().float().eval()\n input_shape = [1, *model.input_size]\n input_data = torch.rand(input_shape).float() * 256\n for channel in range(3):\n input_data[:, channel] -= model.mean[channel]\n input_data[:, channel] /= model.std[channel]\n return model, [input_data]","def load_weights(self):\n try:\n print('loading weights from {}'.format(self.cfg.class_model_dir))\n self.load_state_dict(torch.load(self.cfg.class_model_dir + self.class_model_name + '.pth'))\n except Exception as e:\n print(\"load weights exception: {}\".format(e))","def load_bytes_subnetwork_pretrained_weights(self, model):\n print(\"ToImplement\")","def load(self):\r\n # self.model.load_state_dict(torch.load(os.path.join(self.ckpt_dir, 'best_model_state_dict.pt')))\r\n if torch.cuda.is_available():\r\n self.model = torch.load(os.path.join(self.ckpt_dir, 'best_model_INN.pt'))\r\n else:\r\n self.model = torch.load(os.path.join(self.ckpt_dir, 'best_model_INN.pt'), map_location=torch.device('cpu'))","def initiate(self):\n # if self.opt.checkpoint_encoder:\n # self.load(self.opt.checkpoint_encoder, self.opt.checkpoint_decoder)\n # else:\n # start fresh.\n self.model = Transformer(\n self.opt.src_vocab_size,\n self.opt.tgt_vocab_size,\n self.opt.max_token_seq_len,\n tgt_emb_prj_weight_sharing=self.opt.proj_share_weight,\n emb_src_tgt_weight_sharing=self.opt.embs_share_weight,\n d_k=self.opt.d_k,\n d_v=self.opt.d_v,\n d_model=self.opt.d_model,\n d_word_vec=self.opt.d_word_vec,\n d_inner=self.opt.d_inner_hid,\n n_layers=self.opt.layers,\n n_head=self.opt.n_head,\n dropout=self.opt.dropout).to(self.device)\n \n for p in self.model.parameters():\n if p.dim() > 1:\n nn.init.xavier_uniform_(p)","def load_ckpt(self):\n for name in [\"G\"]:\n if isinstance(name, str):\n # load_filename = '%s_net_%s.pth' % (epoch, name)\n # load_path = os.path.join(self.save_dir, load_filename)\n # ckpt_path =\n net = getattr(self.model, \"net\" + name)\n if isinstance(net, torch.nn.DataParallel):\n net = net.module\n print(\"loading the model from %s\" % self.option.ckpt_path)\n # if you are using PyTorch newer than 0.4 (e.g., built from\n # GitHub source), you can remove str() on self.device\n state_dict = torch.load(\n self.option.ckpt_path, map_location=str(self.model.device)\n )\n if hasattr(state_dict, \"_metadata\"):\n del state_dict._metadata\n\n # patch InstanceNorm checkpoints prior to 0.4\n # for key in list(state_dict.keys()): # need to copy keys here because we mutate in loop\n # self.__patch_instance_norm_state_dict(state_dict, net, key.split('.'))\n net.load_state_dict(state_dict)","def load_pretrained_xception(path, model):\n pretrained_dict = torch.load(path)\n pretrained_values = []\n\n for i in pretrained_dict.values():\n pretrained_values.append(i)\n new_state_dict = model.state_dict()\n\n cur = 0\n for k in new_state_dict:\n new_state_dict[k] = pretrained_values[cur]\n cur = cur + 1\n\n model.load_state_dict(new_state_dict)","def train(\n # fmt: off\n lang: (\"Model language\", \"positional\", None, str),\n output_path: (\"Output directory to store model in\", \"positional\", None, Path),\n train_path: (\"Location of JSON-formatted training data\", \"positional\", None, Path),\n dev_path: (\"Location of JSON-formatted development data\", \"positional\", None, Path),\n raw_text: (\"Path to jsonl file with unlabelled text documents.\", \"option\", \"rt\", Path) = None,\n base_model: (\"Name of model to update (optional)\", \"option\", \"b\", str) = None,\n pipeline: (\"Comma-separated names of pipeline components\", \"option\", \"p\", str) = \"tagger,parser,ner\",\n vectors: (\"Model to load vectors from\", \"option\", \"v\", str) = None,\n replace_components: (\"Replace components from base model\", \"flag\", \"R\", bool) = False,\n n_iter: (\"Number of iterations\", \"option\", \"n\", int) = 30,\n n_early_stopping: (\"Maximum number of training epochs without dev accuracy improvement\", \"option\", \"ne\", int) = None,\n n_examples: (\"Number of examples\", \"option\", \"ns\", int) = 0,\n use_gpu: (\"Use GPU\", \"option\", \"g\", int) = -1,\n version: (\"Model version\", \"option\", \"V\", str) = \"0.0.0\",\n meta_path: (\"Optional path to meta.json to use as base.\", \"option\", \"m\", Path) = None,\n init_tok2vec: (\"Path to pretrained weights for the token-to-vector parts of the models. See 'spacy pretrain'. Experimental.\", \"option\", \"t2v\", Path) = None,\n parser_multitasks: (\"Side objectives for parser CNN, e.g. 'dep' or 'dep,tag'\", \"option\", \"pt\", str) = \"\",\n entity_multitasks: (\"Side objectives for NER CNN, e.g. 'dep' or 'dep,tag'\", \"option\", \"et\", str) = \"\",\n noise_level: (\"Amount of corruption for data augmentation\", \"option\", \"nl\", float) = 0.0,\n orth_variant_level: (\"Amount of orthography variation for data augmentation\", \"option\", \"ovl\", float) = 0.0,\n eval_beam_widths: (\"Beam widths to evaluate, e.g. 4,8\", \"option\", \"bw\", str) = \"\",\n gold_preproc: (\"Use gold preprocessing\", \"flag\", \"G\", bool) = False,\n learn_tokens: (\"Make parser learn gold-standard tokenization\", \"flag\", \"T\", bool) = False,\n textcat_multilabel: (\"Textcat classes aren't mutually exclusive (multilabel)\", \"flag\", \"TML\", bool) = False,\n textcat_arch: (\"Textcat model architecture\", \"option\", \"ta\", str) = \"bow\",\n textcat_positive_label: (\"Textcat positive label for binary classes with two labels\", \"option\", \"tpl\", str) = None,\n tag_map_path: (\"Location of JSON-formatted tag map\", \"option\", \"tm\", Path) = None,\n verbose: (\"Display more information for debug\", \"flag\", \"VV\", bool) = False,\n debug: (\"Run data diagnostics before training\", \"flag\", \"D\", bool) = False,\n # fmt: on\n):\n util.fix_random_seed()\n util.set_env_log(verbose)\n\n # Make sure all files and paths exists if they are needed\n train_path = util.ensure_path(train_path)\n dev_path = util.ensure_path(dev_path)\n meta_path = util.ensure_path(meta_path)\n output_path = util.ensure_path(output_path)\n if raw_text is not None:\n raw_text = list(srsly.read_jsonl(raw_text))\n if not train_path or not train_path.exists():\n msg.fail(\"Training data not found\", train_path, exits=1)\n if not dev_path or not dev_path.exists():\n msg.fail(\"Development data not found\", dev_path, exits=1)\n if meta_path is not None and not meta_path.exists():\n msg.fail(\"Can't find model meta.json\", meta_path, exits=1)\n meta = srsly.read_json(meta_path) if meta_path else {}\n if output_path.exists() and [p for p in output_path.iterdir() if p.is_dir()]:\n msg.warn(\n \"Output directory is not empty\",\n \"This can lead to unintended side effects when saving the model. \"\n \"Please use an empty directory or a different path instead. If \"\n \"the specified output path doesn't exist, the directory will be \"\n \"created for you.\",\n )\n if not output_path.exists():\n output_path.mkdir()\n msg.good(f\"Created output directory: {output_path}\")\n\n tag_map = {}\n if tag_map_path is not None:\n tag_map = srsly.read_json(tag_map_path)\n # Take dropout and batch size as generators of values -- dropout\n # starts high and decays sharply, to force the optimizer to explore.\n # Batch size starts at 1 and grows, so that we make updates quickly\n # at the beginning of training.\n dropout_rates = util.decaying(\n util.env_opt(\"dropout_from\", 0.2),\n util.env_opt(\"dropout_to\", 0.2),\n util.env_opt(\"dropout_decay\", 0.0),\n )\n batch_sizes = util.compounding(\n util.env_opt(\"batch_from\", 100.0),\n util.env_opt(\"batch_to\", 1000.0),\n util.env_opt(\"batch_compound\", 1.001),\n )\n\n if not eval_beam_widths:\n eval_beam_widths = [1]\n else:\n eval_beam_widths = [int(bw) for bw in eval_beam_widths.split(\",\")]\n if 1 not in eval_beam_widths:\n eval_beam_widths.append(1)\n eval_beam_widths.sort()\n has_beam_widths = eval_beam_widths != [1]\n\n default_dir = Path(__file__).parent.parent / \"ml\" / \"models\" / \"defaults\"\n\n # Set up the base model and pipeline. If a base model is specified, load\n # the model and make sure the pipeline matches the pipeline setting. If\n # training starts from a blank model, intitalize the language class.\n pipeline = [p.strip() for p in pipeline.split(\",\")]\n msg.text(f\"Training pipeline: {pipeline}\")\n disabled_pipes = None\n pipes_added = False\n if use_gpu >= 0:\n activated_gpu = None\n try:\n activated_gpu = set_gpu(use_gpu)\n except Exception as e:\n msg.warn(f\"Exception: {e}\")\n if activated_gpu is not None:\n msg.text(f\"Using GPU: {use_gpu}\")\n else:\n msg.warn(f\"Unable to activate GPU: {use_gpu}\")\n msg.text(\"Using CPU only\")\n use_gpu = -1\n if base_model:\n msg.text(f\"Starting with base model '{base_model}'\")\n nlp = util.load_model(base_model)\n if nlp.lang != lang:\n msg.fail(\n f\"Model language ('{nlp.lang}') doesn't match language \"\n f\"specified as `lang` argument ('{lang}') \",\n exits=1,\n )\n if vectors:\n msg.text(f\"Loading vectors from model '{vectors}'\")\n _load_vectors(nlp, vectors)\n\n nlp.select_pipes(disable=[p for p in nlp.pipe_names if p not in pipeline])\n for pipe in pipeline:\n # first, create the model.\n # Bit of a hack after the refactor to get the vectors into a default config\n # use train-from-config instead :-)\n if pipe == \"parser\":\n config_loc = default_dir / \"parser_defaults.cfg\"\n elif pipe == \"tagger\":\n config_loc = default_dir / \"tagger_defaults.cfg\"\n elif pipe == \"ner\":\n config_loc = default_dir / \"ner_defaults.cfg\"\n elif pipe == \"textcat\":\n config_loc = default_dir / \"textcat_defaults.cfg\"\n elif pipe == \"senter\":\n config_loc = default_dir / \"senter_defaults.cfg\"\n else:\n raise ValueError(f\"Component {pipe} currently not supported.\")\n pipe_cfg = util.load_config(config_loc, create_objects=False)\n if vectors:\n pretrained_config = {\n \"@architectures\": \"spacy.VocabVectors.v1\",\n \"name\": vectors,\n }\n pipe_cfg[\"model\"][\"tok2vec\"][\"pretrained_vectors\"] = pretrained_config\n\n if pipe == \"parser\":\n pipe_cfg[\"learn_tokens\"] = learn_tokens\n elif pipe == \"textcat\":\n pipe_cfg[\"exclusive_classes\"] = not textcat_multilabel\n pipe_cfg[\"architecture\"] = textcat_arch\n pipe_cfg[\"positive_label\"] = textcat_positive_label\n\n if pipe not in nlp.pipe_names:\n msg.text(f\"Adding component to base model '{pipe}'\")\n nlp.add_pipe(nlp.create_pipe(pipe, config=pipe_cfg))\n pipes_added = True\n elif replace_components:\n msg.text(f\"Replacing component from base model '{pipe}'\")\n nlp.replace_pipe(pipe, nlp.create_pipe(pipe, config=pipe_cfg))\n pipes_added = True\n else:\n if pipe == \"textcat\":\n textcat_cfg = nlp.get_pipe(\"textcat\").cfg\n base_cfg = {\n \"exclusive_classes\": textcat_cfg[\"exclusive_classes\"],\n \"architecture\": textcat_cfg[\"architecture\"],\n \"positive_label\": textcat_cfg[\"positive_label\"],\n }\n if base_cfg != pipe_cfg:\n msg.fail(\n f\"The base textcat model configuration does\"\n f\"not match the provided training options. \"\n f\"Existing cfg: {base_cfg}, provided cfg: {pipe_cfg}\",\n exits=1,\n )\n msg.text(f\"Extending component from base model '{pipe}'\")\n disabled_pipes = nlp.select_pipes(\n disable=[p for p in nlp.pipe_names if p not in pipeline]\n )\n else:\n msg.text(f\"Starting with blank model '{lang}'\")\n lang_cls = util.get_lang_class(lang)\n nlp = lang_cls()\n\n if vectors:\n msg.text(f\"Loading vectors from model '{vectors}'\")\n _load_vectors(nlp, vectors)\n\n for pipe in pipeline:\n # first, create the model.\n # Bit of a hack after the refactor to get the vectors into a default config\n # use train-from-config instead :-)\n if pipe == \"parser\":\n config_loc = default_dir / \"parser_defaults.cfg\"\n elif pipe == \"tagger\":\n config_loc = default_dir / \"tagger_defaults.cfg\"\n elif pipe == \"morphologizer\":\n config_loc = default_dir / \"morphologizer_defaults.cfg\"\n elif pipe == \"ner\":\n config_loc = default_dir / \"ner_defaults.cfg\"\n elif pipe == \"textcat\":\n config_loc = default_dir / \"textcat_defaults.cfg\"\n elif pipe == \"senter\":\n config_loc = default_dir / \"senter_defaults.cfg\"\n else:\n raise ValueError(f\"Component {pipe} currently not supported.\")\n pipe_cfg = util.load_config(config_loc, create_objects=False)\n if vectors:\n pretrained_config = {\n \"@architectures\": \"spacy.VocabVectors.v1\",\n \"name\": vectors,\n }\n pipe_cfg[\"model\"][\"tok2vec\"][\"pretrained_vectors\"] = pretrained_config\n\n if pipe == \"parser\":\n pipe_cfg[\"learn_tokens\"] = learn_tokens\n elif pipe == \"textcat\":\n pipe_cfg[\"exclusive_classes\"] = not textcat_multilabel\n pipe_cfg[\"architecture\"] = textcat_arch\n pipe_cfg[\"positive_label\"] = textcat_positive_label\n\n pipe = nlp.create_pipe(pipe, config=pipe_cfg)\n nlp.add_pipe(pipe)\n\n # Update tag map with provided mapping\n nlp.vocab.morphology.tag_map.update(tag_map)\n\n # Multitask objectives\n multitask_options = [(\"parser\", parser_multitasks), (\"ner\", entity_multitasks)]\n for pipe_name, multitasks in multitask_options:\n if multitasks:\n if pipe_name not in pipeline:\n msg.fail(\n f\"Can't use multitask objective without '{pipe_name}' in \"\n f\"the pipeline\"\n )\n pipe = nlp.get_pipe(pipe_name)\n for objective in multitasks.split(\",\"):\n pipe.add_multitask_objective(objective)\n\n # Prepare training corpus\n msg.text(f\"Counting training words (limit={n_examples})\")\n corpus = GoldCorpus(train_path, dev_path, limit=n_examples)\n n_train_words = corpus.count_train()\n\n if base_model and not pipes_added:\n # Start with an existing model, use default optimizer\n optimizer = create_default_optimizer()\n else:\n # Start with a blank model, call begin_training\n cfg = {\"device\": use_gpu}\n optimizer = nlp.begin_training(lambda: corpus.train_examples, **cfg)\n nlp._optimizer = None\n\n # Load in pretrained weights (TODO: this may be broken in the config rewrite)\n if init_tok2vec is not None:\n components = _load_pretrained_tok2vec(nlp, init_tok2vec)\n msg.text(f\"Loaded pretrained tok2vec for: {components}\")\n\n # Verify textcat config\n if \"textcat\" in pipeline:\n textcat_labels = nlp.get_pipe(\"textcat\").cfg.get(\"labels\", [])\n if textcat_positive_label and textcat_positive_label not in textcat_labels:\n msg.fail(\n f\"The textcat_positive_label (tpl) '{textcat_positive_label}' \"\n f\"does not match any label in the training data.\",\n exits=1,\n )\n if textcat_positive_label and len(textcat_labels) != 2:\n msg.fail(\n \"A textcat_positive_label (tpl) '{textcat_positive_label}' was \"\n \"provided for training data that does not appear to be a \"\n \"binary classification problem with two labels.\",\n exits=1,\n )\n train_data = corpus.train_data(\n nlp,\n noise_level=noise_level,\n gold_preproc=gold_preproc,\n max_length=0,\n ignore_misaligned=True,\n )\n train_labels = set()\n if textcat_multilabel:\n multilabel_found = False\n for ex in train_data:\n train_labels.update(ex.gold.cats.keys())\n if list(ex.gold.cats.values()).count(1.0) != 1:\n multilabel_found = True\n if not multilabel_found and not base_model:\n msg.warn(\n \"The textcat training instances look like they have \"\n \"mutually-exclusive classes. Remove the flag \"\n \"'--textcat-multilabel' to train a classifier with \"\n \"mutually-exclusive classes.\"\n )\n if not textcat_multilabel:\n for ex in train_data:\n train_labels.update(ex.gold.cats.keys())\n if list(ex.gold.cats.values()).count(1.0) != 1 and not base_model:\n msg.warn(\n \"Some textcat training instances do not have exactly \"\n \"one positive label. Modifying training options to \"\n \"include the flag '--textcat-multilabel' for classes \"\n \"that are not mutually exclusive.\"\n )\n nlp.get_pipe(\"textcat\").cfg[\"exclusive_classes\"] = False\n textcat_multilabel = True\n break\n if base_model and set(textcat_labels) != train_labels:\n msg.fail(\n f\"Cannot extend textcat model using data with different \"\n f\"labels. Base model labels: {textcat_labels}, training data \"\n f\"labels: {list(train_labels)}\",\n exits=1,\n )\n if textcat_multilabel:\n msg.text(\n f\"Textcat evaluation score: ROC AUC score macro-averaged across \"\n f\"the labels '{', '.join(textcat_labels)}'\"\n )\n elif textcat_positive_label and len(textcat_labels) == 2:\n msg.text(\n f\"Textcat evaluation score: F1-score for the \"\n f\"label '{textcat_positive_label}'\"\n )\n elif len(textcat_labels) > 1:\n if len(textcat_labels) == 2:\n msg.warn(\n \"If the textcat component is a binary classifier with \"\n \"exclusive classes, provide '--textcat_positive_label' for \"\n \"an evaluation on the positive class.\"\n )\n msg.text(\n f\"Textcat evaluation score: F1-score macro-averaged across \"\n f\"the labels '{', '.join(textcat_labels)}'\"\n )\n else:\n msg.fail(\n \"Unsupported textcat configuration. Use `spacy debug-data` \"\n \"for more information.\"\n )\n\n # fmt: off\n row_head, output_stats = _configure_training_output(pipeline, use_gpu, has_beam_widths)\n row_widths = [len(w) for w in row_head]\n row_settings = {\"widths\": row_widths, \"aligns\": tuple([\"r\" for i in row_head]), \"spacing\": 2}\n # fmt: on\n print(\"\")\n msg.row(row_head, **row_settings)\n msg.row([\"-\" * width for width in row_settings[\"widths\"]], **row_settings)\n try:\n iter_since_best = 0\n best_score = 0.0\n for i in range(n_iter):\n train_data = corpus.train_dataset(\n nlp,\n noise_level=noise_level,\n orth_variant_level=orth_variant_level,\n gold_preproc=gold_preproc,\n max_length=0,\n ignore_misaligned=True,\n )\n if raw_text:\n random.shuffle(raw_text)\n raw_batches = util.minibatch(\n (nlp.make_doc(rt[\"text\"]) for rt in raw_text), size=8\n )\n words_seen = 0\n with tqdm.tqdm(total=n_train_words, leave=False) as pbar:\n losses = {}\n for batch in util.minibatch_by_words(train_data, size=batch_sizes):\n if not batch:\n continue\n try:\n nlp.update(\n batch,\n sgd=optimizer,\n drop=next(dropout_rates),\n losses=losses,\n )\n except ValueError as e:\n err = \"Error during training\"\n if init_tok2vec:\n err += \" Did you provide the same parameters during 'train' as during 'pretrain'?\"\n msg.fail(err, f\"Original error message: {e}\", exits=1)\n if raw_text:\n # If raw text is available, perform 'rehearsal' updates,\n # which use unlabelled data to reduce overfitting.\n raw_batch = list(next(raw_batches))\n nlp.rehearse(raw_batch, sgd=optimizer, losses=losses)\n docs = [ex.doc for ex in batch]\n if not int(os.environ.get(\"LOG_FRIENDLY\", 0)):\n pbar.update(sum(len(doc) for doc in docs))\n words_seen += sum(len(doc) for doc in docs)\n with nlp.use_params(optimizer.averages):\n util.set_env_log(False)\n epoch_model_path = output_path / f\"model{i}\"\n nlp.to_disk(epoch_model_path)\n nlp_loaded = util.load_model_from_path(epoch_model_path)\n for beam_width in eval_beam_widths:\n for name, component in nlp_loaded.pipeline:\n if hasattr(component, \"cfg\"):\n component.cfg[\"beam_width\"] = beam_width\n dev_dataset = list(\n corpus.dev_dataset(\n nlp_loaded,\n gold_preproc=gold_preproc,\n ignore_misaligned=True,\n )\n )\n nwords = sum(len(ex.doc) for ex in dev_dataset)\n start_time = timer()\n scorer = nlp_loaded.evaluate(dev_dataset, verbose=verbose)\n end_time = timer()\n if use_gpu < 0:\n gpu_wps = None\n cpu_wps = nwords / (end_time - start_time)\n else:\n gpu_wps = nwords / (end_time - start_time)\n with use_ops(\"numpy\"):\n nlp_loaded = util.load_model_from_path(epoch_model_path)\n for name, component in nlp_loaded.pipeline:\n if hasattr(component, \"cfg\"):\n component.cfg[\"beam_width\"] = beam_width\n dev_dataset = list(\n corpus.dev_dataset(\n nlp_loaded,\n gold_preproc=gold_preproc,\n ignore_misaligned=True,\n )\n )\n start_time = timer()\n scorer = nlp_loaded.evaluate(dev_dataset, verbose=verbose)\n end_time = timer()\n cpu_wps = nwords / (end_time - start_time)\n acc_loc = output_path / f\"model{i}\" / \"accuracy.json\"\n srsly.write_json(acc_loc, scorer.scores)\n\n # Update model meta.json\n meta[\"lang\"] = nlp.lang\n meta[\"pipeline\"] = nlp.pipe_names\n meta[\"spacy_version\"] = f\">={about.__version__}\"\n if beam_width == 1:\n meta[\"speed\"] = {\n \"nwords\": nwords,\n \"cpu\": cpu_wps,\n \"gpu\": gpu_wps,\n }\n meta.setdefault(\"accuracy\", {})\n for component in nlp.pipe_names:\n for metric in _get_metrics(component):\n meta[\"accuracy\"][metric] = scorer.scores[metric]\n else:\n meta.setdefault(\"beam_accuracy\", {})\n meta.setdefault(\"beam_speed\", {})\n for component in nlp.pipe_names:\n for metric in _get_metrics(component):\n meta[\"beam_accuracy\"][metric] = scorer.scores[metric]\n meta[\"beam_speed\"][beam_width] = {\n \"nwords\": nwords,\n \"cpu\": cpu_wps,\n \"gpu\": gpu_wps,\n }\n meta[\"vectors\"] = {\n \"width\": nlp.vocab.vectors_length,\n \"vectors\": len(nlp.vocab.vectors),\n \"keys\": nlp.vocab.vectors.n_keys,\n \"name\": nlp.vocab.vectors.name,\n }\n meta.setdefault(\"name\", f\"model{i}\")\n meta.setdefault(\"version\", version)\n meta[\"labels\"] = nlp.meta[\"labels\"]\n meta_loc = output_path / f\"model{i}\" / \"meta.json\"\n srsly.write_json(meta_loc, meta)\n util.set_env_log(verbose)\n\n progress = _get_progress(\n i,\n losses,\n scorer.scores,\n output_stats,\n beam_width=beam_width if has_beam_widths else None,\n cpu_wps=cpu_wps,\n gpu_wps=gpu_wps,\n )\n if i == 0 and \"textcat\" in pipeline:\n textcats_per_cat = scorer.scores.get(\"textcats_per_cat\", {})\n for cat, cat_score in textcats_per_cat.items():\n if cat_score.get(\"roc_auc_score\", 0) < 0:\n msg.warn(\n f\"Textcat ROC AUC score is undefined due to \"\n f\"only one value in label '{cat}'.\"\n )\n msg.row(progress, **row_settings)\n # Early stopping\n if n_early_stopping is not None:\n current_score = _score_for_model(meta)\n if current_score < best_score:\n iter_since_best += 1\n else:\n iter_since_best = 0\n best_score = current_score\n if iter_since_best >= n_early_stopping:\n msg.text(\n f\"Early stopping, best iteration is: {i - iter_since_best}\"\n )\n msg.text(\n f\"Best score = {best_score}; Final iteration score = {current_score}\"\n )\n break\n except Exception as e:\n msg.warn(f\"Aborting and saving final best model. Encountered exception: {e}\")\n finally:\n best_pipes = nlp.pipe_names\n if disabled_pipes:\n disabled_pipes.restore()\n with nlp.use_params(optimizer.averages):\n final_model_path = output_path / \"model-final\"\n nlp.to_disk(final_model_path)\n meta_loc = output_path / \"model-final\" / \"meta.json\"\n final_meta = srsly.read_json(meta_loc)\n final_meta.setdefault(\"accuracy\", {})\n final_meta[\"accuracy\"].update(meta.get(\"accuracy\", {}))\n final_meta.setdefault(\"speed\", {})\n final_meta[\"speed\"].setdefault(\"cpu\", None)\n final_meta[\"speed\"].setdefault(\"gpu\", None)\n meta.setdefault(\"speed\", {})\n meta[\"speed\"].setdefault(\"cpu\", None)\n meta[\"speed\"].setdefault(\"gpu\", None)\n # combine cpu and gpu speeds with the base model speeds\n if final_meta[\"speed\"][\"cpu\"] and meta[\"speed\"][\"cpu\"]:\n speed = _get_total_speed(\n [final_meta[\"speed\"][\"cpu\"], meta[\"speed\"][\"cpu\"]]\n )\n final_meta[\"speed\"][\"cpu\"] = speed\n if final_meta[\"speed\"][\"gpu\"] and meta[\"speed\"][\"gpu\"]:\n speed = _get_total_speed(\n [final_meta[\"speed\"][\"gpu\"], meta[\"speed\"][\"gpu\"]]\n )\n final_meta[\"speed\"][\"gpu\"] = speed\n # if there were no speeds to update, overwrite with meta\n if (\n final_meta[\"speed\"][\"cpu\"] is None\n and final_meta[\"speed\"][\"gpu\"] is None\n ):\n final_meta[\"speed\"].update(meta[\"speed\"])\n # note: beam speeds are not combined with the base model\n if has_beam_widths:\n final_meta.setdefault(\"beam_accuracy\", {})\n final_meta[\"beam_accuracy\"].update(meta.get(\"beam_accuracy\", {}))\n final_meta.setdefault(\"beam_speed\", {})\n final_meta[\"beam_speed\"].update(meta.get(\"beam_speed\", {}))\n srsly.write_json(meta_loc, final_meta)\n msg.good(\"Saved model to output directory\", final_model_path)\n with msg.loading(\"Creating best model...\"):\n best_model_path = _collate_best_model(final_meta, output_path, best_pipes)\n msg.good(\"Created best model\", best_model_path)","def soft_load_weights(model, weights):\n own_state = model.state_dict()\n for name, param in weights.items():\n if name not in own_state:\n continue\n if isinstance(param, torch.nn.Parameter):\n # backwards compatibility for serialized parameters\n param = param.data\n own_state[name].copy_(param)","def load_pretrained_layers(self):\n # Current state of base\n state_dict = self.state_dict()\n param_names = list(state_dict.keys())\n\n # Pretrained VGG base\n pretrained_state_dict = torchvision.models.vgg16(pretrained=True).state_dict()\n pretrained_param_names = list(pretrained_state_dict.keys())\n\n # Transfer conv. parameters from pretrained model to current model\n for i, param in enumerate(param_names[:-4]): # excluding conv6 and conv7 parameters\n state_dict[param] = pretrained_state_dict[pretrained_param_names[i]]\n\n # Convert fc6, fc7 to convolutional layers, and subsample (by decimation) to sizes of conv6 and conv7\n # fc6\n conv_fc6_weight = pretrained_state_dict['classifier.0.weight'].view(4096, 512, 7, 7) # (4096, 512, 7, 7)\n conv_fc6_bias = pretrained_state_dict['classifier.0.bias'] # (4096)\n state_dict['conv6.weight'] = decimate(conv_fc6_weight, m=[4, None, 3, 3]) # (1024, 512, 3, 3)\n state_dict['conv6.bias'] = decimate(conv_fc6_bias, m=[4]) # (1024)\n # fc7\n conv_fc7_weight = pretrained_state_dict['classifier.3.weight'].view(4096, 4096, 1, 1) # (4096, 4096, 1, 1)\n conv_fc7_bias = pretrained_state_dict['classifier.3.bias'] # (4096)\n state_dict['conv7.weight'] = decimate(conv_fc7_weight, m=[4, 4, None, None]) # (1024, 1024, 1, 1)\n state_dict['conv7.bias'] = decimate(conv_fc7_bias, m=[4]) # (1024)\n\n # Note: an FC layer of size (K) operating on a flattened version (C*H*W) of a 2D image of size (C, H, W)...\n # ...is equivalent to a convolutional layer with kernel size (H, W), input channels C, output channels K...\n # ...operating on the 2D image of size (C, H, W) without padding\n\n self.load_state_dict(state_dict)\n\n print(\"\\nLoaded base model.\\n\")","def load(model, name=\"store/base\"):\n if torch.cuda.is_available():\n pretrained_dict = torch.load(name + \".pt\")\n else:\n pretrained_dict = torch.load(name + \".pt\", map_location=torch.device('cpu'))\n print(\"Loaded\", name + \" model.\")\n model_dict = model.state_dict()\n model_dict.update(pretrained_dict)\n model.load_state_dict(model_dict)","def load_model():\r\n model = MobileNetV2(weights=\"imagenet\")\r\n print(\"Model loaded\")\r\n return model","def loadModel(self):\n self.model.load_state_dict(torch.load(os.path.join(self.model_save_dir, '{}_trained.pt'.format(self.model_name)), map_location=torch.device(device)))\n return self.model","def pretrained(name=\"pos_anc\", lang=\"en\", remote_loc=None):\n from sparknlp.pretrained import ResourceDownloader\n return ResourceDownloader.downloadModel(PerceptronModel, name, lang, remote_loc)","def load_model(model_path):\n nlp = spacy.blank('en') \n if 'ner' not in nlp.pipe_names:\n ner = nlp.create_pipe('ner')\n nlp.add_pipe(ner)\n #load pretrained model from the path\n ner = nlp.from_disk(model_path)\n return ner","def load_model():\n global clf\n mdl = joblib.load('model/chitchat.model')\n vec = joblib.load('model/tfidf.vectorizer')\n clf = ChitChatClassifier(mdl, vec)","def thundersvm_load_svm_model(input_svm_model_file):\n \n svm_model = SVC()\n svm_model.load_from_file(input_svm_model_file)\n \n return svm_model","def _load_training_data(self):\n self._save_training_data()"],"string":"[\n \"def load_model(self):\\n if self.ckpt_flag:\\n LOG('Skip Loading Pre-trained Model......')\\n else:\\n if self.params.pre_trained_from is not None and os.path.exists(self.params.pre_trained_from):\\n try:\\n LOG('Loading Pre-trained Model at %s' % self.params.pre_trained_from)\\n pretrain = torch.load(self.params.pre_trained_from)\\n self.network.load_state_dict(pretrain)\\n LOG('Pre-trained Model Loaded!')\\n except:\\n WARNING('Cannot load pre-trained model. Start training......')\\n else:\\n WARNING('Pre-trained model do not exits. Start training......')\",\n \"def init_pretrained_weights(model, key=''):\\n import os\\n import errno\\n import gdown\\n from collections import OrderedDict\\n\\n def _get_torch_home():\\n ENV_TORCH_HOME = 'TORCH_HOME'\\n ENV_XDG_CACHE_HOME = 'XDG_CACHE_HOME'\\n DEFAULT_CACHE_DIR = '~/.cache'\\n torch_home = os.path.expanduser(\\n os.getenv(\\n ENV_TORCH_HOME,\\n os.path.join(\\n os.getenv(ENV_XDG_CACHE_HOME, DEFAULT_CACHE_DIR), 'torch'\\n )\\n )\\n )\\n return torch_home\\n\\n torch_home = _get_torch_home()\\n model_dir = os.path.join(torch_home, 'checkpoints')\\n try:\\n os.makedirs(model_dir)\\n except OSError as e:\\n if e.errno == errno.EEXIST:\\n # Directory already exists, ignore.\\n pass\\n else:\\n # Unexpected OSError, re-raise.\\n raise\\n filename = key + '_imagenet.pth'\\n cached_file = os.path.join(model_dir, filename)\\n\\n if not os.path.exists(cached_file):\\n gdown.download(pretrained_urls[key], cached_file, quiet=False)\\n\\n state_dict = torch.load(cached_file)\\n model_dict = model.state_dict()\\n new_state_dict = OrderedDict()\\n matched_layers, discarded_layers = [], []\\n\\n for k, v in state_dict.items():\\n if k.startswith('module.'):\\n k = k[7:] # discard module.\\n\\n if k in model_dict and model_dict[k].size() == v.size():\\n new_state_dict[k] = v\\n matched_layers.append(k)\\n else:\\n discarded_layers.append(k)\\n\\n model_dict.update(new_state_dict)\\n model.load_state_dict(model_dict)\\n\\n if len(matched_layers) == 0:\\n warnings.warn(\\n 'The pretrained weights from \\\"{}\\\" cannot be loaded, '\\n 'please check the key names manually '\\n '(** ignored and continue **)'.format(cached_file)\\n )\\n else:\\n print(\\n 'Successfully loaded imagenet pretrained weights from \\\"{}\\\"'.\\n format(cached_file)\\n )\\n if len(discarded_layers) > 0:\\n print(\\n '** The following layers are discarded '\\n 'due to unmatched keys or layer size: {}'.\\n format(discarded_layers)\\n )\",\n \"def load_pretrained_model(self, load_from):\\n print(\\\"loading model from %s\\\\n\\\" % (load_from))\\n try:\\n if self.use_cuda:\\n pretrained_dict = torch.load(load_from)\\n else:\\n pretrained_dict = torch.load(load_from, map_location='cpu')\\n\\n model_dict = self.online_net.state_dict()\\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}\\n model_dict.update(pretrained_dict)\\n self.online_net.load_state_dict(model_dict)\\n print(\\\"The loaded parameters are:\\\")\\n keys = [key for key in pretrained_dict]\\n print(\\\", \\\".join(keys))\\n print(\\\"--------------------------\\\")\\n except Exception as e:\\n print(\\\"Failed to load checkpoint...\\\")\\n print(e)\",\n \"def pretrained():\\n launch_training_on_all_splits(experiment='full', splits=NAME_SPLIT, base_model='pretrained', dropout=0.7987, learning_rate=0.00009659)\",\n \"def load_pretrained_net_weights(net, ckpt_path):\\n print(\\\"Loading Model: \\\", ckpt_path)\\n print('')\\n\\n net.load_weights(ckpt_path).expect_partial()\",\n \"def _load_model_from_trained_params(self):\\n self.ent_emb = tf.constant(self.trained_model_params[0])\\n self.rel_emb = tf.constant(self.trained_model_params[1])\",\n \"def load_tf_weights_in_bert(model, tf_checkpoint_path):\\n try:\\n import re\\n import numpy as np\\n import tensorflow as tf\\n except ImportError:\\n print(\\\"Loading a TensorFlow models in PyTorch, requires TensorFlow to be installed. Please see \\\"\\n \\\"https://www.tensorflow.org/install/ for installation instructions.\\\")\\n raise\\n tf_path = os.path.abspath(tf_checkpoint_path)\\n print(\\\"Converting TensorFlow checkpoint from {}\\\".format(tf_path))\\n # Load weights from TF model\\n init_vars = tf.train.list_variables(tf_path)\\n names = []\\n arrays = []\\n for name, shape in init_vars:\\n print(\\\"Loading TF weight {} with shape {}\\\".format(name, shape))\\n array = tf.train.load_variable(tf_path, name)\\n names.append(name)\\n arrays.append(array)\\n\\n for name, array in zip(names, arrays):\\n name = name.split('/')\\n # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v\\n # which are not required for using pretrained model\\n if any(n in [\\\"adam_v\\\", \\\"adam_m\\\"] for n in name):\\n print(\\\"Skipping {}\\\".format(\\\"/\\\".join(name)))\\n continue\\n pointer = model\\n for m_name in name:\\n if re.fullmatch(r'[A-Za-z]+_\\\\d+', m_name):\\n l = re.split(r'_(\\\\d+)', m_name)\\n else:\\n l = [m_name]\\n if l[0] == 'kernel' or l[0] == 'gamma':\\n pointer = getattr(pointer, 'weight')\\n elif l[0] == 'output_bias' or l[0] == 'beta':\\n pointer = getattr(pointer, 'bias')\\n elif l[0] == 'output_weights':\\n pointer = getattr(pointer, 'weight')\\n else:\\n pointer = getattr(pointer, l[0])\\n if len(l) >= 2:\\n num = int(l[1])\\n pointer = pointer[num]\\n if m_name[-11:] == '_embeddings':\\n pointer = getattr(pointer, 'weight')\\n elif m_name == 'kernel':\\n array = np.transpose(array)\\n try:\\n assert pointer.shape == array.shape\\n except AssertionError as e:\\n e.args += (pointer.shape, array.shape)\\n raise\\n print(\\\"Initialize PyTorch weight {}\\\".format(name))\\n pointer.data = torch.from_numpy(array)\\n return model\",\n \"def load_feature_extractor(model_spec, device):\\n\\n model_type = model_spec['name']\\n model_weights_fp = model_spec['weights']\\n\\n if model_type == 'imagenet_swav':\\n # or could load from hub model\\n # model = torch.hub.load('facebookresearch/swav', 'resnet50')\\n\\n model = models.resnet50(pretrained=False)\\n model.fc = torch.nn.Identity()\\n state_dict = torch.load(model_weights_fp, map_location=\\\"cpu\\\")\\n\\n state_dict = {k.replace(\\\"module.\\\", \\\"\\\"): v for k, v in state_dict.items()}\\n for k in list(state_dict.keys()):\\n if 'projection' in k or 'prototypes' in k:\\n del state_dict[k]\\n\\n msg = model.load_state_dict(state_dict, strict=True)\\n\\n elif model_type == 'imagenet_moco_v2':\\n model = models.resnet50(pretrained=False)\\n model.fc = torch.nn.Identity()\\n checkpoint = torch.load(model_weights_fp, map_location=\\\"cpu\\\")\\n\\n # rename moco pre-trained keys\\n state_dict = checkpoint['state_dict']\\n for k in list(state_dict.keys()):\\n # retain only encoder_q up to before the embedding layer\\n if k.startswith('module.encoder_q') and not k.startswith('module.encoder_q.fc'):\\n # remove prefix\\n state_dict[k[len(\\\"module.encoder_q.\\\"):]] = state_dict[k]\\n # delete renamed or unused k\\n del state_dict[k]\\n\\n msg = model.load_state_dict(state_dict, strict=True)\\n\\n elif model_type == 'imagenet_supervised':\\n model = models.resnet50(pretrained=True)\\n\\n elif model_type == 'random':\\n model = models.resnet50(pretrained=False)\\n\\n elif model_type == 'inat2018_supervised':\\n model = models.resnet50(pretrained=False)\\n # This model was actually trained with 10000 classes for the fc layer\\n # but only 8142 (the number in inat2018) were actually updated\\n model.fc = torch.nn.Linear(model.fc.in_features, 10000)\\n checkpoint = torch.load(model_weights_fp, map_location=\\\"cpu\\\")\\n msg = model.load_state_dict(checkpoint['state_dict'], strict=True)\\n\\n elif model_type == 'inat2021_mini_supervised':\\n model = models.resnet50(pretrained=False)\\n model.fc = torch.nn.Linear(model.fc.in_features, 10000)\\n checkpoint = torch.load(model_weights_fp, map_location=\\\"cpu\\\")\\n msg = model.load_state_dict(checkpoint['state_dict'], strict=True)\\n\\n elif model_type == 'inat2021_supervised':\\n model = models.resnet50(pretrained=False)\\n model.fc = torch.nn.Linear(model.fc.in_features, 10000)\\n checkpoint = torch.load(model_weights_fp, map_location=\\\"cpu\\\")\\n msg = model.load_state_dict(checkpoint['state_dict'], strict=True)\\n\\n elif model_type == 'inat2021_mini_supervised_from_scratch':\\n model = models.resnet50(pretrained=False)\\n model.fc = torch.nn.Linear(model.fc.in_features, 10000)\\n checkpoint = torch.load(model_weights_fp, map_location=\\\"cpu\\\")\\n state_dict = {k.replace(\\\"module.\\\", \\\"\\\"): v for k, v in checkpoint['state_dict'].items()}\\n msg = model.load_state_dict(state_dict, strict=True)\\n\\n elif model_type == 'inat2021_supervised_from_scratch':\\n model = models.resnet50(pretrained=False)\\n model.fc = torch.nn.Linear(model.fc.in_features, 10000)\\n checkpoint = torch.load(model_weights_fp, map_location=\\\"cpu\\\")\\n msg = model.load_state_dict(checkpoint['state_dict'], strict=True)\\n\\n elif model_type == 'inat2021_mini_moco_v2':\\n model = models.resnet50(pretrained=False)\\n model.fc = torch.nn.Identity()\\n checkpoint = torch.load(model_weights_fp, map_location=\\\"cpu\\\")\\n\\n # rename moco pre-trained keys\\n state_dict = checkpoint['state_dict']\\n for k in list(state_dict.keys()):\\n # retain only encoder_q up to before the embedding layer\\n if k.startswith('module.encoder_q') and not k.startswith('module.encoder_q.fc'):\\n # remove prefix\\n state_dict[k[len(\\\"module.encoder_q.\\\"):]] = state_dict[k]\\n # delete renamed or unused k\\n del state_dict[k]\\n\\n msg = model.load_state_dict(state_dict, strict=True)\\n\\n elif model_type == 'inat2021_mini_swav' or model_type == 'inat2021_mini_swav_1k':\\n # or could load from hub model\\n # model = torch.hub.load('facebookresearch/swav', 'resnet50')\\n\\n model = models.resnet50(pretrained=False)\\n model.fc = torch.nn.Identity()\\n state_dict = torch.load(model_weights_fp, map_location=\\\"cpu\\\")\\n\\n state_dict = {k.replace(\\\"module.\\\", \\\"\\\"): v for k, v in state_dict['state_dict'].items()}\\n for k in list(state_dict.keys()):\\n if 'projection' in k or 'prototypes' in k:\\n del state_dict[k]\\n\\n msg = model.load_state_dict(state_dict, strict=True)\\n\\n else:\\n raise ValueError(\\\"Unknown pytorch model: %s\\\" % model_type)\\n\\n\\n # remove the final fully connected layer so the model only operates with post average pool features\\n model = torch.nn.Sequential(*(list(model.children())[:-1]))\\n model.to(device)\\n model.eval()\\n\\n feature_extractor = PTResNet50FeatureExtractor(model, device)\\n\\n return feature_extractor\",\n \"def load_pretrained_weights(self, model_dir):\\n p_dict = torch.load(model_dir)\\n s_dict = self.state_dict()\\n for name in p_dict.keys():\\n s_dict[name] = p_dict[name]\\n self.load_state_dict(s_dict)\",\n \"def init_pretrained_weights(model, model_url):\\n pretrain_dict = model_zoo.load_url(model_url)\\n model_dict = model.state_dict()\\n pretrain_dict = {k: v for k, v in pretrain_dict.items() if k in model_dict and model_dict[k].size() == v.size()}\\n model_dict.update(pretrain_dict)\\n model.load_state_dict(model_dict)\",\n \"def load_pretrained_weights(model, model_name, load_fc=True):\\n state_dict = torch.load(url_map[model_name])\\n if load_fc:\\n model.load_state_dict(state_dict)\\n else:\\n state_dict.pop('_fc.weight')\\n state_dict.pop('_fc.bias')\\n res = model.load_state_dict(state_dict, strict=False)\\n assert str(res.missing_keys) == str(['_fc.weight', '_fc.bias']), 'issue loading pretrained weights'\\n print('Loaded pretrained weights for {}'.format(model_name))\",\n \"def init_weights(self, pretrained=None):\\n # Do not initialize the conv layers\\n # to follow the original implementation\\n if isinstance(pretrained, str):\\n from mmdet3d.utils import get_root_logger\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\",\n \"def update_params(self):\\n if self._hyper_params[\\\"pretrain_model_path\\\"] != \\\"\\\":\\n model_path = self._hyper_params[\\\"pretrain_model_path\\\"]\\n state_dict = torch.load(model_path,\\n map_location=torch.device(\\\"cpu\\\"))\\n if \\\"model_state_dict\\\" in state_dict:\\n state_dict = state_dict[\\\"model_state_dict\\\"]\\n try:\\n self.load_state_dict(state_dict, strict=True)\\n except:\\n self.load_state_dict(state_dict, strict=False)\\n logger.info(\\\"Pretrained weights loaded from {}\\\".format(model_path))\\n logger.info(\\\"Check md5sum of Pretrained weights: %s\\\" %\\n md5sum(model_path))\",\n \"def init_weights(self):\\n if isinstance(self.pretrained, str):\\n logger = get_root_logger()\\n logger.info(f'load model from: {self.pretrained}')\\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\\n elif self.pretrained is None:\\n pass\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def run_model_three():\\n\\n pos_map = pickle.load(open('pos_map.p', \\\"rb\\\"))\\n vocab = build_vocab(training_directory)\\n word2vec = get_w2vec(wordtovec)\\n\\n train_out_list = prep_data_lexsub(training_directory, \\\"mod3_train_prepped.txt\\\", 3, pos_map, vocab, word2vec)\\n test_out_list = prep_data_lexsub(testing_directory, \\\"mod3_test_prepped.txt\\\", 3, pos_map, vocab, word2vec)\\n\\n posset = get_posset()\\n vocab.add(\\\"<s>\\\")\\n vocab.add(\\\"<UNK>\\\")\\n convert_to_svm('mod3_train_prepped.txt', \\\"mod3_train.svm\\\", posset, vocab)\\n convert_to_svm('mod3_test_prepped.txt', \\\"mod3_test.svm\\\", posset, vocab)\\n\\n p_labels, p_acc, p_vals = train_test_model(\\\"mod3_train.svm\\\", \\\"mod3_test.svm\\\")\\n with open(\\\"modelscores.txt\\\", \\\"a\\\") as text_file:\\n text_file.write(str(p_acc[0]))\\n text_file.write(\\\"\\\\n\\\")\\n pickle.dump(p_labels, open('mod3_p_labels.p', 'wb'))\",\n \"def load_pre_trained_model_state(saved_state_file_name):\\n saved_state_file_name = saved_state_file_name if saved_state_file_name else \\\"my_checkpoint.pth\\\"\\n loaded_state = torch.load(saved_state_file_name)\\n\\n pre_trained_model = models.vgg16(pretrained=True)\\n pre_trained_model.name = \\\"vgg16\\\"\\n\\n for param in pre_trained_model.parameters():\\n param.requires_grad = False\\n\\n pre_trained_model.class_to_idx = loaded_state['class_to_idx']\\n pre_trained_model.classifier = loaded_state['classifier']\\n pre_trained_model.load_state_dict(loaded_state['state_dict'])\\n \\n return pre_trained_model\",\n \"def init_pretrained_weights(model, model_url):\\n pretrain_dict = model_zoo.load_url(model_url)\\n model_dict = model.state_dict()\\n pretrain_dict = {\\n k: v\\n for k, v in pretrain_dict.items()\\n if k in model_dict and model_dict[k].size() == v.size()\\n }\\n model_dict.update(pretrain_dict)\\n model.load_state_dict(model_dict)\",\n \"def load_openai_pretrained_model(model, cfg, n_special, dir):\\n n_ctx = cfg.n_ctx\\n n_embd = cfg.n_embd\\n n_transfer = cfg.n_layer\\n # Load weights from TF model\\n print(\\\"Loading weights...\\\")\\n names = json.load(open(dir + 'parameters_names.json'))\\n shapes = json.load(open(dir + 'params_shapes.json'))\\n offsets = np.cumsum([np.prod(shape) for shape in shapes])\\n init_params = [np.load(dir + 'params_{}.npy'.format(n)) for n in range(10)]\\n init_params = np.split(np.concatenate(init_params, 0), offsets)[:-1]\\n init_params = [param.reshape(shape) for param, shape in zip(init_params, shapes)]\\n if n_ctx > 0:\\n init_params[0] = init_params[0][:n_ctx]\\n if n_special > 0:\\n init_params[0] = np.concatenate(\\n [init_params[1],\\n (np.random.randn(n_special, n_embd) * 0.02).astype(np.float32),\\n init_params[0]\\n ], 0)\\n else:\\n init_params[0] = np.concatenate(\\n [init_params[1],\\n init_params[0]\\n ], 0)\\n del init_params[1]\\n if n_transfer == -1:\\n n_transfer = 0\\n else:\\n n_transfer = 1 + n_transfer * 12\\n init_params = [arr.squeeze() for arr in init_params]\\n\\n try:\\n assert model.embed.weight.shape == init_params[0].shape\\n except AssertionError as e:\\n e.args += (model.embed.weight.shape, init_params[0].shape)\\n raise\\n\\n model.embed.weight.data = torch.from_numpy(init_params[0])\\n\\n for name, ip in zip(names[1:n_transfer], init_params[1:n_transfer]):\\n name = name[6:] # skip \\\"model/\\\"\\n assert name[-2:] == \\\":0\\\"\\n name = name[:-2]\\n name = name.split('/')\\n pointer = model\\n for m_name in name:\\n if re.fullmatch(r'[A-Za-z]+\\\\d+', m_name):\\n l = re.split(r'(\\\\d+)', m_name)\\n else:\\n l = [m_name]\\n pointer = getattr(pointer, l[0])\\n if len(l) >= 2:\\n num = int(l[1])\\n pointer = pointer[num]\\n try:\\n assert pointer.shape == ip.shape\\n except AssertionError as e:\\n e.args += (pointer.shape, ip.shape)\\n raise\\n pointer.data = torch.from_numpy(ip)\",\n \"def load_pretrained_layers(self):\\n # Current state of base\\n state_dict = self.state_dict()\\n param_names = list(state_dict.keys())\\n\\n # Pretrained VGG base\\n pth = VGG_WEIGHT_PATH\\n pretrained_state_dict = torch.load(pth)\\n pretrained_param_names = list(pretrained_state_dict.keys())\\n\\n # Transfer conv. parameters from pretrained model to current model\\n for i, param in enumerate(param_names[:-4]): # excluding conv6 and conv7 parameters\\n state_dict[param] = pretrained_state_dict[pretrained_param_names[i]]\\n\\n self.load_state_dict(state_dict)\",\n \"def load_model(self):\\n saved_path = self.config.path_tmp / self.model.model_name\\n if saved_path.exists():\\n self.model.load_weights(str(saved_path / 'model.vec'))\",\n \"def checkpoint_load(checkpoint_path, gpu):\\n model_info = torch.load(checkpoint_path)\\n model = models.vgg19(pretrained=True)\\n for param in model.parameters():\\n param.requires_grad = False\\n \\n model.class_to_idx = model_info['class_to_idx']\\n\\n model = classifier(model)\\n model.load_state_dict(model_info[\\\"model_state_dict\\\"])\\n return model, model.class_to_idx\",\n \"def load_model():\\n prepro = Prepro(PATH_STOPSWORD, PATH_ACRONYM)\\n vectorizer = joblib.load(PATH_TFIDF)\\n label_encoder = joblib.load(PATH_ENCODER)\\n model_svm = joblib.load(PATH_SVM)\\n model_nb = joblib.load(PATH_NB)\\n model_lr = joblib.load(PATH_LR)\\n return prepro, vectorizer, label_encoder, model_svm, model_nb, model_lr\",\n \"def load_pretrained_weights(model, model_name, load_fc=True, advprop=False):\\n # AutoAugment or Advprop (different preprocessing)\\n url_map_ = url_map_advprop if advprop else url_map\\n state_dict = model_zoo.load_url(url_map_[model_name], map_location=torch.device('cpu'))\\n # state_dict = torch.load('../../weights/backbone_efficientnetb0.pth')\\n if load_fc:\\n ret = model.load_state_dict(state_dict, strict=False)\\n print(ret)\\n else:\\n state_dict.pop('_fc.weight')\\n state_dict.pop('_fc.bias')\\n res = model.load_state_dict(state_dict, strict=False)\\n assert set(res.missing_keys) == {'_fc.weight', '_fc.bias'}, 'issue loading pretrained weights'\\n print('Loaded pretrained weights for {}'.format(model_name))\",\n \"def from_pretrained(self, directory):\\n\\n if not os.path.exists(directory):\\n print(\\\"The path does not exists\\\")\\n\\n self._vocab = Vocab().from_disk(os.path.join(directory, \\\"spacy_vocab\\\"))\\n self._model = torch.load(os.path.join(directory, \\\"torch_model\\\"))\",\n \"def load_model(self):\\n if os.stat('code/lr-model.pt').st_size == 0:\\n return\\n params = torch.load('code/lr-model.pt')\\n self.set_params(params)\",\n \"def init_weight(self, pretrained_model=None):\\n if pretrained_model is not None:\\n if os.path.exists(pretrained_model):\\n utils.load_pretrained_model(self.backbone, pretrained_model)\\n utils.load_pretrained_model(self, pretrained_model)\\n else:\\n raise Exception('Pretrained model is not found: {}'.format(\\n pretrained_model))\",\n \"def load_ckpt(model,\\n weight_path,\\n **kargs):\\n #model.set_state_dict(state_dict)\\n\\n if not osp.isfile(weight_path):\\n raise IOError(f'{weight_path} is not a checkpoint file')\\n #state_dicts = load(weight_path)\\n\\n logger = get_logger(\\\"paddlevideo\\\")\\n state_dicts = paddle.load(weight_path)\\n if \\\"VisionTransformer\\\" in str(model): # For TimeSformer case\\n tmp = pretrain_vit_param_trans(model, state_dicts, kargs['num_patches'], kargs['seg_num'], kargs['attention_type'])\\n else:\\n tmp = {}\\n total_len = len(model.state_dict())\\n with tqdm(total=total_len, position=1, bar_format='{desc}', desc=\\\"Loading weights\\\") as desc:\\n for item in tqdm(model.state_dict(), total=total_len, position=0):\\n name = item\\n desc.set_description('Loading %s' % name)\\n if name not in state_dicts: # Convert from non-parallel model\\n if str('backbone.' + name) in state_dicts:\\n tmp[name] = state_dicts['backbone.' + name]\\n else: # Convert from parallel model\\n tmp[name] = state_dicts[name]\\n time.sleep(0.01)\\n ret_str = \\\"loading {:<20d} weights completed.\\\".format(len(model.state_dict()))\\n desc.set_description(ret_str)\\n model.set_state_dict(tmp)\",\n \"def load_pretrained_model(self,model_dir):\\n rnn_params = json.load(open(os.path.join(model_dir,\\n \\\"./model.json\\\")))[\\\"rnn\\\"]\\n\\n logging.info(\\\"Loading model from: {}\\\".format(model_dir))\\n self.create_training_model(model_dir = model_dir,\\n **rnn_params)\\n #从目录中读取神经网络参数\\n self.set_model_from_file()\",\n \"def load_model(self, directory):\\n with tf.Session() as sess:\\n tf.saved_model.loader.load(sess, [tf.saved_model.tag_constants.SERVING], directory)\\n self.model = tf.contrib.predictor.from_saved_model(directory)\",\n \"def load_embeddings_models():\\n\\n\\t# ---LOADING WORD2VEC MODEL---\\n\\tmodel_load_path = os.path.join(ROOT_PATH, 'models', 'word2vec', 'NILC', 'nilc_cbow_s300_300k.txt')\\n\\t# model_load_path = os.path.join('models', 'word2vec', 'NILC', 'nilc_skip_s300.txt')\\n\\tstart_time = time.time()\\n\\tprint(\\\"Started loading the word2vec model\\\")\\n\\tword2vec_model = KeyedVectors.load_word2vec_format(model_load_path)\\n\\t# word2vec_model = None\\n\\tprint(\\\"Model loaded\\\")\\n\\tprint(\\\"--- %s seconds ---\\\" %(time.time() - start_time))\\n\\tprint('\\\\a')\\n\\n\\t# ---LOADING FASTTEXT MODEL---\\n\\tmodel_path = os.path.join(ROOT_PATH, 'models', 'fastText', 'cc.pt.300_300k.vec')\\n\\tstart_time = time.time()\\n\\tprint(\\\"Started loading the fasttext model\\\")\\n\\tfasttext_model = KeyedVectors.load_word2vec_format(model_path)\\n\\t# fasttext_model = None\\n\\tprint(\\\"Model loaded\\\")\\n\\tprint(\\\"--- %s seconds ---\\\" %(time.time() - start_time))\\n\\tprint('\\\\a')\\t\\n\\n\\t# ---LOADING PT-LKB MODEL---\\n\\tmodel_load_path = os.path.join(ROOT_PATH, 'models', 'ontoPT', 'PT-LKB_embeddings_64', 'ptlkb_64_30_200_p_str.emb')\\n\\t# model_load_path = os.path.join('models', 'ontoPT', 'PT-LKB_embeddings_128', 'ptlkb_128_80_10_p_str.emb')\\n\\tstart_time = time.time()\\n\\tprint(\\\"Started loading the PT-LKB-64 model\\\")\\n\\tptlkb64_model = KeyedVectors.load_word2vec_format(model_load_path)\\n\\t# ptlkb64_model = None\\n\\tprint(\\\"Model loaded\\\")\\n\\tprint(\\\"--- %s seconds ---\\\" %(time.time() - start_time))\\n\\tprint('\\\\a')\\n\\n\\t# ---LOADING GLOVE-300 MODEL---\\n\\tmodel_load_path = os.path.join(ROOT_PATH, 'models', 'glove', 'glove_s300_300k.txt')\\n\\t# model_load_path = os.path.join('models', 'glove', 'glove_s100.txt')\\n\\tstart_time = time.time()\\n\\tprint(\\\"Started loading the GLOVE 300 dimensions model\\\")\\n\\tglove300_model = KeyedVectors.load_word2vec_format(model_load_path)\\n\\t# glove300_model = None\\n\\tprint(\\\"Model loaded\\\")\\n\\tprint(\\\"--- %s seconds ---\\\" %(time.time() - start_time))\\n\\tprint('\\\\a')\\n\\n\\t# ---LOADING NUMBERBATCH MODEL---\\n\\tmodel_load_path = os.path.join(ROOT_PATH, 'models', 'numberbatch', 'numberbatch-17.02_pt_tratado.txt')\\n\\tstart_time = time.time()\\n\\tprint(\\\"Started loading the NUMBERBATCH dimensions model\\\")\\n\\tnumberbatch_model = KeyedVectors.load_word2vec_format(model_load_path)\\n\\t# numberbatch_model = None\\n\\tprint(\\\"Model loaded\\\")\\n\\tprint(\\\"--- %s seconds ---\\\" %(time.time() - start_time))\\n\\tprint('\\\\a')\\n\\n\\treturn word2vec_model, fasttext_model, ptlkb64_model, glove300_model, numberbatch_model\",\n \"def load_pretrained_model(self, load_from, load_partial_graph=False):\\n print(\\\"loading model from %s\\\\n\\\" % (load_from))\\n try:\\n if self.use_cuda:\\n pretrained_dict = torch.load(load_from)\\n else:\\n pretrained_dict = torch.load(load_from, map_location='cpu')\\n\\n model_dict = self.online_net.state_dict()\\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}\\n if load_partial_graph and len(self.load_parameter_keywords) > 0:\\n tmp_pretrained_dict = {}\\n for k, v in pretrained_dict.items():\\n for keyword in self.load_parameter_keywords:\\n if keyword in k:\\n tmp_pretrained_dict[k] = v\\n break\\n pretrained_dict = tmp_pretrained_dict\\n model_dict.update(pretrained_dict)\\n self.online_net.load_state_dict(model_dict)\\n print(\\\"The loaded parameters are:\\\")\\n keys = [key for key in pretrained_dict]\\n print(\\\", \\\".join(keys))\\n print(\\\"--------------------------\\\")\\n except:\\n print(\\\"Failed to load checkpoint...\\\")\",\n \"def load_word2vec_en_pretrained():\\r\\n log.info(\\\"Load W2V Model\\\")\\r\\n model = api.load(\\\"glove-wiki-gigaword-50\\\")\\r\\n return PreTrainedGensimEN(model)\",\n \"def init_weights(self):\\n if isinstance(self.pretrained, str):\\n logger = get_root_logger()\\n logger.info(f'load model from: {self.pretrained}')\\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\\n elif self.pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n xavier_init(m, distribution='uniform')\\n elif isinstance(m, nn.Linear):\\n normal_init(m, std=0.01)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def get_pretrained_weights(idx_word):\\n n = len(idx_word)\\n embed_dim = 25\\n weights = mx.ndarray.zeros((n, embed_dim))\\n print('Start downloading pre-trained vectors, this will take some time')\\n glov = api.load(\\\"glove-twitter-25\\\")\\n print('Pre-trained vectors downloading complete')\\n not_in_vocab = 0\\n for i in range(n):\\n word = idx_word[i]\\n try:\\n weights[i] = glov[word]\\n except: #if not in glove vocabulary\\n not_in_vocab += 1\\n weights[i] = mx.nd.random.normal(0, 0.1, embed_dim)\\n if not_in_vocab > 0:\\n print('Warning: {} words not in vocab of pretrained embeddings (glove-twitter-25)'.format(not_in_vocab))\\n return weights\",\n \"def initialize_trained_model(cls, device):\\n model = cls(device=device)\\n model_path = os.path.join(_FILE_PREFIX, 'weights/translator_weights_16')\\n model.load_state_dict(torch.load(model_path, map_location=device), strict=True)\\n print('Loaded model from {}'.format(model_path))\\n return model\",\n \"def load_model(self):\\n try:\\n self.model = Word2Vec.load(self.config[\\\"model_path\\\"])\\n self.model.init_sims(replace=True)\\n except Exception as e:\\n print(e)\\n print(\\\"error in model loading!\\\")\",\n \"def load_checkpoint(filepath):\\n checkpoint = torch.load(filepath)\\n \\n arch = checkpoint['arch']\\n if arch == 'vgg':\\n model = models.vgg16(pretrained=True)\\n elif arch == 'densenet':\\n model = models.densenet121(pretrained=True) \\n \\n model.class_to_idx = checkpoint['class_to_idx']\\n model.classifier = checkpoint['classifier']\\n model.classifier.load_sate_dict = checkpoint['classifier_state_dict']\\n model.optimizer = checkpoint['optimizer_state_dict']\\n model.input_size = checkpoint['input_size']\\n model.output_size = checkpoint['output_size']\\n \\n return model\",\n \"def init_weights(self, pretrained=None):\\n super(SingleTwoStageDetector176PRW, self).init_weights(pretrained)\\n self.backbone.init_weights(pretrained=pretrained)\\n if self.with_neck:\\n if isinstance(self.neck, nn.Sequential):\\n for m in self.neck:\\n m.init_weights()\\n else:\\n self.neck.init_weights()\\n if self.with_rpn:\\n self.rpn_head.init_weights()\\n if self.with_roi_head:\\n self.roi_head.init_weights(pretrained)\\n self.bbox_head.init_weights()\",\n \"def load_and_fuse_pretrained_weights(model: torch.nn.Module, opt: argparse.ArgumentParser) -> torch.nn.Module:\\n model.optimize_for_inference(fuse_all_layers=False)\\n fused_state_dict = load_weights(opt.weights)\\n fused_state_dict = map_key_names(fused_state_dict, model.state_dict())\\n model.load_state_dict(fused_state_dict)\\n return model\",\n \"def load_trainer(self):\\n super().load_trainer()\\n\\n logging.info(\\\"[Server #%d] Loading a pre-trained model.\\\", os.getpid())\\n self.trainer.load_model()\",\n \"def custom_model():\\n\\t# initialize the model\\n\\t# load weights from path\\n\\t# returns model\\n\\tmodel = mlp.get_training_model()\\n\\tmodel.load_state_dict(torch.load(\\\"model_wt.pth\\\"))\\n\\treturn model\",\n \"def load_pretrained_model(model, pretrained_model_path, verbose=False):\\n\\n if isinstance(pretrained_model_path, str):\\n if not os.path.exists(pretrained_model_path):\\n raise IOError(\\n \\\"Can't find pretrained model: {}\\\".format(pretrained_model_path)\\n )\\n\\n print(\\\"Loading checkpoint from '{}'\\\".format(pretrained_model_path))\\n pretrained_state = torch.load(pretrained_model_path)[\\\"state_dict\\\"]\\n else:\\n # incase pretrained model weights are given\\n pretrained_state = pretrained_model_path\\n\\n print(len(pretrained_state), \\\" keys in pretrained model\\\")\\n\\n current_model_state = model.state_dict()\\n print(len(current_model_state), \\\" keys in current model\\\")\\n pretrained_state = {\\n key: val\\n for key, val in pretrained_state.items()\\n if key in current_model_state and val.size() == current_model_state[key].size()\\n }\\n\\n print(\\n len(pretrained_state),\\n \\\" keys in pretrained model are available in current model\\\",\\n )\\n current_model_state.update(pretrained_state)\\n model.load_state_dict(current_model_state)\\n\\n if verbose:\\n non_available_keys_in_pretrained = [\\n key\\n for key, val in pretrained_state.items()\\n if key not in current_model_state\\n or val.size() != current_model_state[key].size()\\n ]\\n non_available_keys_in_current = [\\n key\\n for key, val in current_model_state.items()\\n if key not in pretrained_state or val.size() != pretrained_state[key].size()\\n ]\\n\\n print(\\n \\\"not available keys in pretrained model: \\\", non_available_keys_in_pretrained\\n )\\n print(\\\"not available keys in current model: \\\", non_available_keys_in_current)\\n\\n return model\",\n \"def init_weights(self):\\n if isinstance(self.pretrained, str):\\n logger = get_root_logger()\\n logger.info(f'load model from: {self.pretrained}')\\n load_checkpoint(self, self.pretrained, strict=False, logger=logger)\\n elif self.pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n xavier_init(m, distribution='uniform')\\n elif isinstance(m, nn.Linear):\\n normal_init(m, std=0.01)\\n elif isinstance(m, nn.BatchNorm2d):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def load_pretrained_embeddings(self, embeddings):\\r\\n self.embedding.weight = nn.Parameter(embeddings)\",\n \"def load_pretrained_weights(model, weight_path):\\n checkpoint = load_checkpoint(weight_path)\\n if 'state_dict' in checkpoint:\\n state_dict = checkpoint['state_dict']\\n else:\\n state_dict = checkpoint\\n\\n model_dict = model.state_dict()\\n new_state_dict = OrderedDict()\\n matched_layers, discarded_layers = [], []\\n\\n for k, v in state_dict.items():\\n if k.startswith('module.'):\\n k = k[7:] # discard module.\\n\\n if k in model_dict and model_dict[k].size() == v.size():\\n new_state_dict[k] = v\\n matched_layers.append(k)\\n else:\\n discarded_layers.append(k)\\n\\n model_dict.update(new_state_dict)\\n model.load_state_dict(model_dict)\\n\\n if len(matched_layers) == 0:\\n warnings.warn(\\n 'The pretrained weights \\\"{}\\\" cannot be loaded, '\\n 'please check the key names manually '\\n '(** ignored and continue **)'.format(weight_path)\\n )\\n #else:\\n #print(\\n # 'Successfully loaded pretrained weights from \\\"{}\\\"'.\\n # format(weight_path)\\n #)\\n #if len(discarded_layers) > 0:\\n # print(\\n # '** The following layers are discarded '\\n # 'due to unmatched keys or layer size: {}'.\\n # format(discarded_layers)\\n # )\",\n \"def load_model_weights(self):\\n raise NotImplementedError\",\n \"def load_model(self):\\n if torch.cuda.is_available():\\n map_location=lambda storage, loc: storage.cuda()\\n else:\\n map_location='cpu'\\n\\n for index, agent in enumerate(self.agents):\\n agent.actor_local.load_state_dict(torch.load('agent{}_checkpoint_actor.pth'.format(index + 1), map_location=map_location))\\n agent.critic_local.load_state_dict(torch.load('agent{}_checkpoint_critic.pth'.format(index + 1), map_location=map_location))\",\n \"def pre_dl_models():\\n keras.applications.xception.Xception(include_top=True, weights='imagenet', input_tensor=None,\\n input_shape=None, pooling=None, classes=1000)\\n\\n # keras.applications.vgg16.VGG16(include_top=True, weights='imagenet', input_tensor=None,\\n # input_shape=None, pooling=None, classes=1000)\\n\\n # keras.applications.vgg19.VGG19(include_top=True, weights='imagenet', input_tensor=None,\\n # input_shape=None, pooling=None, classes=1000)\\n\\n # keras.applications.resnet50.ResNet50(include_top=True, weights='imagenet', input_tensor=None,\\n # input_shape=None, pooling=None, classes=1000)\\n\\n # keras.applications.inception_v3.InceptionV3(include_top=True, weights='imagenet', input_tensor=None,\\n # input_shape=None, pooling=None, classes=1000)\",\n \"def load_pretrained_model(model_name):\\n if model_name==\\\"AlexNet\\\":\\n print(\\\"Loading pretrained AlexNet Model\\\")\\n model_ft = models.alexnet(pretrained=True)\\n\\n for param in model_ft.parameters():# Code for fixing the Conv Layer\\n param.requires_grad = False\\n num_ftrs = model_ft.classifier[6].in_features\\n model_ft.classifier[6] = nn.Linear(num_ftrs, 100)\\n elif model_name==\\\"ResNet18\\\":\\n print(\\\"Loading pretrained ResNet18 Model\\\")\\n model_ft = models.resnet18(pretrained=True)\\n\\n for param in model_ft.parameters(): # Code for fixing the Conv Layer\\n param.requires_grad = False # During Training Conv layer does not learn.\\n num_ftrs = model_ft.fc.in_features\\n model_ft.fc = nn.Linear(num_ftrs, 100)\\n elif model_name==\\\"ResNet50\\\":\\n print(\\\"Loading pretrained ResNet50 Model\\\")\\n\\n model_ft = models.resnet50(pretrained=True)\\n for param in model_ft.parameters():# Code for fixing the Conv Layer\\n param.requires_grad = False\\n\\n num_ftrs = model_ft.fc.in_features\\n model_ft.fc = nn.Linear(num_ftrs, 100)\\n elif model_name==\\\"DenseNet\\\":\\n print(\\\"Loading pretrained DenseNet161 Model\\\")\\n model_ft = models.densenet161(pretrained=True)\\n\\n for param in model_ft.parameters():# Code for fixing the Conv Layer\\n param.requires_grad = False\\n num_ftrs = model_ft.classifier.in_features\\n model_ft.classifier = nn.Linear(num_ftrs, 100)\\n\\n if cfg.load_model_true:\\n model_ft.load_state_dict(torch.load(cfg.load_model_path))\\n\\n return model_ft\",\n \"def load_pretrained_layers(self):\\n # Current state of base\\n state_dict = self.state_dict()\\n param_names = list(state_dict.keys())\\n\\n # VGG base with pretrained weights\\n pretrained_state_dict = torchvision.models.vgg16(pretrained=True).state_dict()\\n pretrained_param_names = list(pretrained_state_dict.keys())\\n\\n # Copy pretrained weights to our current VGG model base\\n for i, param in enumerate(param_names[:-4]): # excluding conv6 and conv7 parameters\\n state_dict[param] = pretrained_state_dict[pretrained_param_names[i]]\\n\\n # Convert fc6, fc7 to convolutional layers, and subsample (by decimation) to sizes of conv6 and conv7\\n # fc6\\n conv_fc6_weight = pretrained_state_dict['classifier.0.weight'].view(4096, 512, 7, 7) # (4096, 512, 7, 7)\\n conv_fc6_bias = pretrained_state_dict['classifier.0.bias'] # (4096)\\n state_dict['conv6.weight'] = decimate(conv_fc6_weight, m=[4, None, 3, 3]) # (1024, 512, 3, 3)\\n state_dict['conv6.bias'] = decimate(conv_fc6_bias, m=[4]) # (1024)\\n # fc7\\n conv_fc7_weight = pretrained_state_dict['classifier.3.weight'].view(4096, 4096, 1, 1) # (4096, 4096, 1, 1)\\n conv_fc7_bias = pretrained_state_dict['classifier.3.bias'] # (4096)\\n state_dict['conv7.weight'] = decimate(conv_fc7_weight, m=[4, 4, None, None]) # (1024, 1024, 1, 1)\\n state_dict['conv7.bias'] = decimate(conv_fc7_bias, m=[4]) # (1024)\\n\\n self.load_state_dict(state_dict)\\n\\n print(\\\"\\\\nLoaded base model.\\\\n\\\")\",\n \"def load_model(self, ):\\n \\n tf.keras.backend.clear_session()\\n \\n self.load_weights(os.path.join(self.weights_dir, \\\"countmodel_weights_\\\" + self.name_)).expect_partial()\",\n \"def load_model(self, ckpt_name=\\\"best_model.pth\\\"):\\n path = \\\"/\\\".join(ckpt_name.split(\\\"/\\\")[:-1])\\n chkpt = torch.load(ckpt_name)\\n self.start_epoch = chkpt['epoch']\\n self.best_metric = chkpt['best_metric']\\n\\n # fix the DataParallel caused problem with keys names\\n if self.multi_gpu_flag:\\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=False)\\n self.net.load_state_dict(new_state_dict)\\n else:\\n try:\\n self.net.load_state_dict(chkpt['state_dict'])\\n except:\\n new_state_dict = fix_multigpu_chkpt_names(chkpt['state_dict'], drop=True)\\n self.net.load_state_dict(new_state_dict)\\n\\n if self.load_optimizer_state:\\n self.optimizer.load_state_dict(chkpt['optimizer'])\\n logging.info(\\\"******** State loaded ********\\\")\\n\\n training_meta = pickle.load(open(f\\\"{path}/training_meta.pickle.dat\\\", \\\"rb\\\"))\\n for k, v in training_meta.items():\\n if k in self.__class__.__params:\\n setattr(self, k, v)\\n logging.info(\\\"******** Training params loaded ********\\\")\",\n \"def load_model_weights(sess, checkpoint_dir):\\n\\n init_fn = slim.assign_from_checkpoint_fn(\\n checkpoint_dir, slim.get_model_variables(), ignore_missing_vars=True)\\n init_fn(sess)\",\n \"def load_pretrained_embeddings(self, embeddings):\\n self.embedding.weight = nn.Parameter(embeddings)\",\n \"def load_model_and_weights(self):\\n \\n with open(self.model_json) as file:\\n m_json = file.read()\\n \\n self.tf_model = tf.keras.models.model_from_json(m_json) \\n self.tf_model.load_weights(self.weights_file)\\n \\n self.Helpers.logger.info(\\\"Model loaded \\\")\\n \\n self.tf_model.summary()\",\n \"def load_model():\\n global obj\\n obj = NutritionTableDetector()\\n print(\\\"Weights Loaded!\\\")\",\n \"def load_tf_weights_in_t5(model, config, tf_checkpoint_path):\\n try:\\n import re\\n import numpy as np\\n import tensorflow as tf\\n except ImportError:\\n logger.error(\\n \\\"Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see \\\"\\n \\\"https://www.tensorflow.org/install/ for installation instructions.\\\"\\n )\\n raise\\n tf_path = os.path.abspath(tf_checkpoint_path)\\n logger.info(\\\"Converting TensorFlow checkpoint from {}\\\".format(tf_path))\\n # Load weights from TF model\\n init_vars = tf.train.list_variables(tf_path)\\n names = []\\n tf_weights = {}\\n for name, shape in init_vars:\\n logger.info(\\\"Loading TF weight {} with shape {}\\\".format(name, shape))\\n array = tf.train.load_variable(tf_path, name)\\n names.append(name)\\n tf_weights[name] = array\\n\\n for txt_name in names:\\n name = txt_name.split(\\\"/\\\")\\n # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v\\n # which are not required for using pretrained model\\n if any(\\n n in [\\\"adam_v\\\", \\\"adam_m\\\", \\\"AdamWeightDecayOptimizer\\\", \\\"AdamWeightDecayOptimizer_1\\\", \\\"global_step\\\"]\\n for n in name\\n ):\\n logger.info(\\\"Skipping {}\\\".format(\\\"/\\\".join(name)))\\n tf_weights.pop(txt_name, None)\\n continue\\n if \\\"_slot_\\\" in name[-1]:\\n logger.info(\\\"Skipping {}\\\".format(\\\"/\\\".join(name)))\\n tf_weights.pop(txt_name, None)\\n continue\\n pointer = model\\n array = tf_weights[txt_name]\\n for m_name in name:\\n if re.fullmatch(r\\\"[A-Za-z]+_\\\\d+\\\", m_name):\\n scope_names = re.split(r\\\"_(\\\\d+)\\\", m_name)\\n else:\\n scope_names = [m_name]\\n if scope_names[0] in [\\\"kernel\\\", \\\"scale\\\", \\\"embedding\\\"]:\\n pointer = getattr(pointer, \\\"weight\\\")\\n # elif scope_names[0] == 'scale':\\n # pointer = getattr(pointer, 'weight')\\n # elif scope_names[0] == 'output_bias' or scope_names[0] == 'beta':\\n # pointer = getattr(pointer, 'bias')\\n # elif scope_names[0] == 'squad':\\n # pointer = getattr(pointer, 'classifier')\\n else:\\n try:\\n pointer = getattr(pointer, scope_names[0])\\n except AttributeError:\\n logger.info(\\\"Skipping {}\\\".format(\\\"/\\\".join(name)))\\n continue\\n if len(scope_names) >= 2:\\n num = int(scope_names[1])\\n pointer = pointer[num]\\n if scope_names[0] not in [\\\"kernel\\\", \\\"scale\\\", \\\"embedding\\\"]:\\n pointer = getattr(pointer, \\\"weight\\\")\\n if scope_names[0] != \\\"embedding\\\":\\n logger.info(\\\"Transposing numpy weight of shape {} for {}\\\".format(array.shape, name))\\n array = np.transpose(array)\\n try:\\n assert pointer.shape == array.shape\\n except AssertionError as e:\\n e.args += (pointer.shape, array.shape)\\n raise\\n logger.info(\\\"Initialize PyTorch weight {}\\\".format(name))\\n pointer.data = torch.from_numpy(array.astype(np.float32))\\n tf_weights.pop(txt_name, None)\\n\\n logger.info(\\\"Weights not copied to PyTorch model: {}\\\".format(\\\", \\\".join(tf_weights.keys())))\\n # logger.info(\\\"Weights not copied to PyTorch model: {}\\\".format(', '.join(tf_weights.keys())))\\n return model\",\n \"def load_pretrained_model(self, model_path):\\n # My eyes and my heart both hurt when writing this method\\n\\n # Only care about layer_types that have trainable parameters\\n ltypes = ['BNData', 'ConvolutionData', 'HoleConvolutionData']\\n\\n def _get_layer_params(layer, ltype):\\n\\n if ltype == 'BNData': \\n n_channels = layer.blobs[0].shape.dim[1]\\n gamma = np.array(layer.blobs[0].data).reshape(n_channels)\\n beta = np.array(layer.blobs[1].data).reshape(n_channels)\\n mean = np.array(layer.blobs[2].data).reshape(n_channels)\\n var = np.array(layer.blobs[3].data).reshape(n_channels)\\n return [mean, var, gamma, beta]\\n\\n elif ltype in ['ConvolutionData', 'HoleConvolutionData']:\\n is_bias = layer.convolution_param.bias_term\\n shape = [int(d) for d in layer.blobs[0].shape.dim]\\n weights = np.array(layer.blobs[0].data).reshape(shape)\\n bias = []\\n if is_bias:\\n bias = np.array(layer.blobs[1].data).reshape(shape[0])\\n return [weights, bias]\\n \\n elif ltype == 'InnerProduct':\\n raise Exception(\\\"Fully connected layers {}, not supported\\\".format(ltype))\\n\\n else:\\n raise Exception(\\\"Unkown layer type {}\\\".format(ltype))\\n\\n\\n net = caffe_pb2.NetParameter()\\n with open(model_path, 'rb') as model_file:\\n net.MergeFromString(model_file.read())\\n\\n # dict formatted as -> key:<layer_name> :: value:<layer_type>\\n layer_types = {}\\n # dict formatted as -> key:<layer_name> :: value:[<list_of_params>]\\n layer_params = {}\\n\\n for l in net.layer:\\n lname = l.name\\n ltype = l.type\\n if ltype in ltypes:\\n print(\\\"Processing layer {}\\\".format(lname))\\n layer_types[lname] = ltype\\n layer_params[lname] = _get_layer_params(l, ltype)\\n\\n # Set affine=False for all batchnorm modules\\n def _no_affine_bn(module=None):\\n if isinstance(module, nn.BatchNorm2d):\\n module.affine = False\\n\\n if len([m for m in module.children()]) > 0:\\n for child in module.children():\\n _no_affine_bn(child)\\n\\n #_no_affine_bn(self)\\n\\n\\n def _transfer_conv(layer_name, module):\\n weights, bias = layer_params[layer_name]\\n w_shape = np.array(module.weight.size())\\n \\n np.testing.assert_array_equal(weights.shape, w_shape)\\n print(\\\"CONV: Original {} and trans weights {}\\\".format(w_shape,\\n weights.shape))\\n module.weight.data = torch.from_numpy(weights)\\n\\n if len(bias) != 0:\\n b_shape = np.array(module.bias.size())\\n np.testing.assert_array_equal(bias.shape, b_shape)\\n print(\\\"CONV: Original {} and trans bias {}\\\".format(b_shape,\\n bias.shape))\\n module.bias.data = torch.from_numpy(bias)\\n\\n\\n def _transfer_conv_bn(conv_layer_name, mother_module):\\n conv_module = mother_module[0]\\n bn_module = mother_module[1]\\n \\n _transfer_conv(conv_layer_name, conv_module)\\n \\n mean, var, gamma, beta = layer_params[conv_layer_name+'/bn']\\n print(\\\"BN: Original {} and trans weights {}\\\".format(bn_module.running_mean.size(),\\n mean.shape))\\n bn_module.running_mean = torch.from_numpy(mean)\\n bn_module.running_var = torch.from_numpy(var)\\n bn_module.weight.data = torch.from_numpy(gamma)\\n bn_module.bias.data = torch.from_numpy(beta)\\n\\n\\n def _transfer_residual(prefix, block):\\n block_module, n_layers = block[0], block[1]\\n\\n bottleneck = block_module.layers[0]\\n bottleneck_conv_bn_dic = {prefix + '_1_1x1_reduce': bottleneck.cbr1.cbr_unit,\\n prefix + '_1_3x3': bottleneck.cbr2.cbr_unit,\\n prefix + '_1_1x1_proj': bottleneck.cb4.cb_unit,\\n prefix + '_1_1x1_increase': bottleneck.cb3.cb_unit,}\\n\\n for k, v in bottleneck_conv_bn_dic.items():\\n _transfer_conv_bn(k, v)\\n\\n for layer_idx in range(2, n_layers+1):\\n residual_layer = block_module.layers[layer_idx-1]\\n residual_conv_bn_dic = {'_'.join(map(str, [prefix, layer_idx, '1x1_reduce'])): residual_layer.cbr1.cbr_unit,\\n '_'.join(map(str, [prefix, layer_idx, '3x3'])): residual_layer.cbr2.cbr_unit,\\n '_'.join(map(str, [prefix, layer_idx, '1x1_increase'])): residual_layer.cb3.cb_unit,} \\n \\n for k, v in residual_conv_bn_dic.items():\\n _transfer_conv_bn(k, v)\\n\\n\\n convbn_layer_mapping = {'conv1_1_3x3_s2': self.convbnrelu1_1.cbr_unit,\\n 'conv1_2_3x3': self.convbnrelu1_2.cbr_unit,\\n 'conv1_3_3x3': self.convbnrelu1_3.cbr_unit,\\n 'conv5_3_pool6_conv': self.pyramid_pooling.paths[0].cbr_unit, \\n 'conv5_3_pool3_conv': self.pyramid_pooling.paths[1].cbr_unit,\\n 'conv5_3_pool2_conv': self.pyramid_pooling.paths[2].cbr_unit,\\n 'conv5_3_pool1_conv': self.pyramid_pooling.paths[3].cbr_unit,\\n 'conv5_4': self.cbr_final.cbr_unit,}\\n\\n residual_layers = {'conv2': [self.res_block2, self.block_config[0]],\\n 'conv3': [self.res_block3, self.block_config[1]],\\n 'conv4': [self.res_block4, self.block_config[2]],\\n 'conv5': [self.res_block5, self.block_config[3]],}\\n\\n # Transfer weights for all non-residual conv+bn layers\\n for k, v in convbn_layer_mapping.items():\\n _transfer_conv_bn(k, v)\\n\\n # Transfer weights for final non-bn conv layer\\n _transfer_conv('conv6', self.classification)\\n\\n # Transfer weights for all residual layers\\n for k, v in residual_layers.items():\\n _transfer_residual(k, v)\",\n \"def init_weights(self, pretrained=None):\\n self.online_backbone.init_weights() # backbone\\n for online_neck in self.online_necks:\\n online_neck.init_weights(init_linear='kaiming') # projection\\n\\n for param_ol, param_tgt in zip(self.online_backbone.parameters(),\\n self.target_backbone.parameters()):\\n param_tgt.data.copy_(param_ol.data)\\n for param_ol, param_tgt in zip(self.online_necks.parameters(),\\n self.target_necks.parameters()):\\n param_tgt.data.copy_(param_ol.data)\\n # init the predictor in the head\\n for head in self.heads:\\n head.init_weights()\",\n \"def load_pretrained_model(\\n init_param: str,\\n model: torch.nn.Module,\\n map_location: str = \\\"cpu\\\",\\n):\\n sps = init_param.split(\\\":\\\", 4)\\n if len(sps) == 4:\\n path, src_key, dst_key, excludes = sps\\n elif len(sps) == 3:\\n path, src_key, dst_key = sps\\n excludes = None\\n elif len(sps) == 2:\\n path, src_key = sps\\n dst_key, excludes = None, None\\n else:\\n (path,) = sps\\n src_key, dst_key, excludes = None, None, None\\n if src_key == \\\"\\\":\\n src_key = None\\n if dst_key == \\\"\\\":\\n dst_key = None\\n\\n if dst_key is None:\\n obj = model\\n else:\\n\\n def get_attr(obj: Any, key: str):\\n \\\"\\\"\\\"Get an nested attribute.\\n\\n >>> class A(torch.nn.Module):\\n ... def __init__(self):\\n ... super().__init__()\\n ... self.linear = torch.nn.Linear(10, 10)\\n >>> a = A()\\n >>> assert A.linear.weight is get_attr(A, 'linear.weight')\\n\\n \\\"\\\"\\\"\\n if key.strip() == \\\"\\\":\\n return obj\\n for k in key.split(\\\".\\\"):\\n obj = getattr(obj, k)\\n return obj\\n\\n obj = get_attr(model, dst_key)\\n\\n src_state = torch.load(path, map_location=map_location)\\n if excludes is not None:\\n for e in excludes.split(\\\",\\\"):\\n src_state = {k: v for k, v in src_state.items() if not k.startswith(e)}\\n\\n if src_key is not None:\\n src_state = {\\n k[len(src_key) + 1 :]: v\\n for k, v in src_state.items()\\n if k.startswith(src_key)\\n }\\n\\n # tts.dec.feat_out,tts.dec.prob_out\\n\\n dst_state = obj.state_dict()\\n\\n for key in list(src_state.keys()):\\n if src_state[key].shape != dst_state[key].shape:\\n src_shape = src_state[key].shape\\n dst_shape = dst_state[key].shape\\n print(f'\\\"{key}\\\" shapes do not match:', src_shape, dst_shape)\\n if src_shape[0] < dst_shape[0] and src_shape[1:] == dst_shape[1:]:\\n print(f'doing partial override of \\\"{key}\\\"')\\n dst_state[key][:src_shape[0]] = src_state[key]\\n del src_state[key]\\n\\n dst_state.update(src_state)\\n obj.load_state_dict(dst_state)\",\n \"def training(self):\\r\\n self.model, self.voc = svm_clf_training('all', self.dataset)\\r\\n return 0\",\n \"def load_model(exe, graph, dirname):\\n assert graph is not None and dirname is not None\\n graph = GraphWrapper(graph) if isinstance(graph,\\n paddle.static.Program) else graph\\n\\n SHAPES_FILE = os.path.join(dirname, _SHAPES_FILE)\\n with open(SHAPES_FILE, \\\"r\\\") as f:\\n shapes = json.load(f)\\n for param_name, shape in shapes.items():\\n param = graph.var(param_name)\\n if param is not None:\\n param.set_shape(shape)\\n else:\\n _logger.info('{} is not loaded'.format(param_name))\\n _logger.info(\\\"Load shapes of weights from {}\\\".format(SHAPES_FILE))\\n\\n GROUPS_FILE = os.path.join(dirname, _GROUPS_FILE)\\n with open(GROUPS_FILE, \\\"r\\\") as f:\\n groups = json.load(f)\\n for op in graph.ops():\\n if 'conv2d' in op.type():\\n filter_name = op.inputs('Filter')[0].name()\\n op.set_attr('groups', groups[filter_name])\\n _logger.info(\\\"Load groups of conv2d from {}\\\".format(GROUPS_FILE))\\n\\n paddle.static.load(program=graph.program, model_path=dirname, executor=exe)\\n graph.infer_shape()\\n _logger.info(\\\"Load weights from {}\\\".format(dirname))\",\n \"def _prepare_libsvm_data(self):\\n logging.info('Preparing libsvm training data...')\\n if self.clean or not (self.is_s3_file(self.s3_training_file) and self.is_s3_file(self.s3_validation_file)):\\n logging.info('S3 libsvm files do not exist.')\\n if self.clean or not (os.path.isfile(self.local_libsvm_training_file) and os.path.isfile(self.local_libsvm_validation_file)):\\n logging.info('Local libsvm files do not exist.')\\n logging.info('Generating local libsvm files...')\\n dump_svmlight_file(X=self.training_x, y=self.training_y, f=self.local_libsvm_training_file)\\n dump_svmlight_file(X=self.validation_x, y=self.validation_y, f=self.local_libsvm_validation_file)\\n logging.info('Local libsvm files found. Uploading to S3...')\\n upload_file_to_s3(self.local_libsvm_training_file, self.infra_s3['s3_bucket'], self.s3_training_file)\\n upload_file_to_s3(self.local_libsvm_validation_file, self.infra_s3['s3_bucket'], self.s3_validation_file)\\n else:\\n logging.info('S3 libsvm files already exist. Skipping step.')\",\n \"def load_model(self):\\n for t in self.topic:\\n if t != \\\"other\\\":\\n print(\\\"Loading models of topic: \\\", t)\\n for st in self.topic2sub_topic[t].keys():\\n model = tf.keras.Sequential()\\n model.add(tf.keras.layers.InputLayer(input_shape=[1024, ]))\\n model.add(tf.keras.layers.Dense(64, activation='relu'))\\n model.add(tf.keras.layers.Dense(64, activation='relu'))\\n model.add(tf.keras.layers.Dense(1, activation='relu'))\\n model.compile(loss='mean_squared_logarithmic_error', optimizer='adam', metrics=[metrics.mae, metrics.categorical_accuracy])\\n\\n if not os.path.exists(self.trained_w_folder+\\\"/%s/%s.h5\\\" %(t,st)):\\n print(\\\"Now training the classsfier for topic: \\\", t, \\\" ; intent: \\\", st)\\n print(64 * \\\"=\\\")\\n X, y = self.get_data(t, st)\\n print(\\\"data_loaded!\\\")\\n X_train, X_dev, y_train, y_dev = self.my_train_test_split(X, y)\\n model.fit(X_train, y_train, epochs=3, batch_size=128)\\n model.save_weights(self.trained_w_folder+\\\"/%s/%s.h5\\\" %(t,st))\\n print(\\\"f1_score on dev set: \\\")\\n self.f1_score_model(model, X_dev, y_dev)\\n print(64*\\\"=\\\")\\n print()\\n else:\\n model.load_weights(self.trained_w_folder+\\\"/%s/%s.h5\\\" %(t,st))\\n print(\\\"Loaded weights for model \\\" + t + \\\" : \\\" + st)\\n self.model_zoo[t][st] = model\",\n \"def load_opcodes_subnetwork_pretrained_weights(self, model):\\n print(\\\"ToImplement\\\")\",\n \"def load_pretrained_vectors(self, emb_file, fixed):\\n if emb_file:\\n pretrained = torch.load(emb_file)\\n self.word_lut.weight.data.copy_(pretrained)\\n if fixed:\\n self.word_lut.weight.requires_grad = False\",\n \"def __init__(self, load_model_dir=None):\\n \\n if load_model_dir:\\n raise RuntimeError('Whoops. Not implemented yet')\\n \\n ## Load pickeled preprocessing function (applied to raw features)\\n ## Load pickeled postprocessing function (applied to labels before output)\\n ## Load tf model\",\n \"def load_weights(self):\\n stage1_weights = (\\n self.cfg.get(\\\"STAGE1\\\", \\\"WEIGHTS\\\")\\n if self.cfg.getboolean(\\\"STAGE1\\\", \\\"LOADPREV\\\")\\n else None\\n )\\n\\n stage2_weights = (\\n self.cfg.get(\\\"STAGE2\\\", \\\"WEIGHTS\\\")\\n if self.cfg.getboolean(\\\"STAGE1\\\", \\\"LOADPREV\\\")\\n else None\\n )\\n\\n self.cross_skip = self.cfg.getboolean(\\\"STAGE2\\\", \\\"CROSS_SKIP\\\")\\n\\n if self.cfg.get(\\\"STAGE1\\\", \\\"ENCODER\\\") != \\\"UNET\\\":\\n raise NotImplementedError\\n\\n log.info(\\\"STAGE 1 UNET\\\")\\n # Flow Computation Model\\n self.stage1_model = unet.get_model(\\n stage1_weights, 6, 4, self.cross_skip, stage=1, cfg=self.cfg\\n )\\n\\n # Flow Interpolation Model\\n log.info(\\\"STAGE 2 %s\\\", self.cfg.get(\\\"STAGE2\\\", \\\"ENCODER\\\"))\\n self.stage2_model = unet.get_model(\\n stage2_weights, 16, 5, self.cross_skip, stage=2, cfg=self.cfg\\n )\\n\\n log.info(\\\"Cross stage Skip Connections Present? %s \\\", self.cross_skip)\",\n \"def load_pretrained_graph_generation_model(self, load_from):\\n print(\\\"loading pre-trained graph generation model from %s\\\\n\\\" % (load_from))\\n try:\\n if self.use_cuda:\\n pretrained_dict = torch.load(load_from)\\n else:\\n pretrained_dict = torch.load(load_from, map_location='cpu')\\n try:\\n self.pretrained_graph_generation_net.load_state_dict(pretrained_dict)\\n print(\\\"Successfully loaded pre-trained graph generation model...\\\")\\n except:\\n # graph generation net\\n model_dict = self.pretrained_graph_generation_net.state_dict()\\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if (k in model_dict and \\\"action_scorer\\\" not in k)}\\n difference_pretrain_this = [k for k, _ in pretrained_dict.items() if k not in model_dict]\\n difference_this_pretrain = [k for k, _ in model_dict.items() if k not in pretrained_dict]\\n model_dict.update(pretrained_dict)\\n self.pretrained_graph_generation_net.load_state_dict(model_dict)\\n print(\\\"WARNING... Model dict is different with pretrained dict. I'm loading only the parameters with same labels now. Make sure you really want this...\\\")\\n print(\\\"The loaded parameters are:\\\")\\n keys = [key for key in pretrained_dict]\\n print(\\\", \\\".join(keys))\\n print(\\\"--------------------------\\\")\\n print(\\\"Parameters in pre-trained model but not in the current model are:\\\")\\n print(\\\", \\\".join(difference_pretrain_this))\\n print(\\\"--------------------------\\\")\\n print(\\\"Parameters in current model but not in the pre-trained model are:\\\")\\n print(\\\", \\\".join(difference_this_pretrain))\\n print(\\\"--------------------------\\\")\\n except:\\n print(\\\"Failed to load checkpoint...\\\")\",\n \"def load_model(model_dir):\\n if not osp.exists(model_dir):\\n logging.error(\\\"model_dir '{}' does not exists!\\\".format(model_dir))\\n if not osp.exists(osp.join(model_dir, \\\"model.yml\\\")):\\n raise Exception(\\\"There's no model.yml in {}\\\".format(model_dir))\\n with open(osp.join(model_dir, \\\"model.yml\\\")) as f:\\n model_info = yaml.load(f.read(), Loader=yaml.Loader)\\n f.close()\\n\\n version = model_info['version']\\n if int(version.split('.')[0]) < 2:\\n raise Exception(\\n 'Current version is {}, a model trained by PaddleX={} cannot be load.'.\\n format(paddlex.__version__, version))\\n\\n status = model_info['status']\\n\\n if not hasattr(paddlex.cv.models, model_info['Model']):\\n raise Exception(\\\"There's no attribute {} in paddlex.cv.models\\\".format(\\n model_info['Model']))\\n if 'model_name' in model_info['_init_params']:\\n del model_info['_init_params']['model_name']\\n\\n with paddle.utils.unique_name.guard():\\n model = getattr(paddlex.cv.models, model_info['Model'])(\\n **model_info['_init_params'])\\n\\n if 'Transforms' in model_info:\\n model.test_transforms = build_transforms(model_info['Transforms'])\\n\\n if '_Attributes' in model_info:\\n for k, v in model_info['_Attributes'].items():\\n if k in model.__dict__:\\n model.__dict__[k] = v\\n\\n if status == 'Pruned' or osp.exists(osp.join(model_dir, \\\"prune.yml\\\")):\\n with open(osp.join(model_dir, \\\"prune.yml\\\")) as f:\\n pruning_info = yaml.load(f.read(), Loader=yaml.Loader)\\n inputs = pruning_info['pruner_inputs']\\n if model.model_type == 'detector':\\n inputs = [{\\n k: paddle.to_tensor(v)\\n for k, v in inputs.items()\\n }]\\n model.pruner = getattr(paddleslim, pruning_info['pruner'])(\\n model.net, inputs=inputs)\\n model.pruning_ratios = pruning_info['pruning_ratios']\\n model.pruner.prune_vars(\\n ratios=model.pruning_ratios,\\n axis=paddleslim.dygraph.prune.filter_pruner.FILTER_DIM)\\n\\n if status == 'Quantized':\\n with open(osp.join(model_dir, \\\"quant.yml\\\")) as f:\\n quant_info = yaml.load(f.read(), Loader=yaml.Loader)\\n quant_config = quant_info['quant_config']\\n model.quantizer = paddleslim.QAT(quant_config)\\n model.quantizer.quantize(model.net)\\n\\n if status == 'Infer':\\n if model_info['Model'] in ['FasterRCNN', 'MaskRCNN']:\\n net_state_dict = load_rcnn_inference_model(model_dir)\\n else:\\n net_state_dict = paddle.load(osp.join(model_dir, 'model'))\\n else:\\n net_state_dict = paddle.load(osp.join(model_dir, 'model.pdparams'))\\n model.net.set_state_dict(net_state_dict)\\n\\n logging.info(\\\"Model[{}] loaded.\\\".format(model_info['Model']))\\n model.status = status\\n return model\",\n \"def create_train_model(self):\\n st = LancasterStemmer()\\n with open(self.data_path, encoding='utf8') as f_name:\\n sentences = [[st.stem(w) for w, t in pos_tag(line.lower().split()) if 'N' in t] for line in f_name]\\n sentences = [filter(lambda x: len(x) > 2, (word.strip(punctuation) for word in sentences)) for sent in sentences]\\n model = Word2Vec(sentences,\\n min_count=self.min_count,\\n size=self.size,\\n window=self.window,\\n workers=4)\\n model.save(self.model_path)\",\n \"def LoadTeacherModels(lang):\\n\\n # load Trained teacher model parameters\\n log_dir = 'data/logs'\\n with open(log_dir + '/' + lang + '_model_params', 'rb') as fp:\\n params = pickle.load(fp)\\n\\n model_args = params['args']\\n\\n if model_args.use_colab is None:\\n OUTPUT_DIR = 'ckpts/' + model_args.lang\\n if not os.path.isdir(OUTPUT_DIR): os.mkdir(OUTPUT_DIR)\\n else:\\n from google.colab import drive\\n\\n drive.mount('/content/gdrive')\\n OUTPUT_DIR = '/content/gdrive/My Drive/ckpts/' + model_args.lang\\n if not os.path.isdir(OUTPUT_DIR): os.mkdir(OUTPUT_DIR)\\n\\n if model_args.enc_type == 'gat' and model_args.dec_type == 'transformer':\\n models = {}\\n OUTPUT_DIR += '/' + model_args.enc_type + '_' + model_args.dec_type\\n\\n # Load the vocabs\\n with open('vocabs/' + model_args.model + '/' +\\n lang + '/' + model_args.opt + '_src_vocab', 'rb') as fp:\\n src_vocab = pickle.load(fp)\\n # loading the target vocab\\n model_args.sentencepiece = 'False'\\n if model_args.sentencepiece == 'True':\\n sp = spm.SentencePieceProcessor()\\n sp.load('vocabs/' + model_args.model + '/' +\\n lang + '/' + 'train_tgt.model')\\n tgt_vocab = sp\\n else:\\n tgt_vocab = src_vocab\\n\\n print('Loaded ' + lang + ' Parameters..')\\n model = TransGAT(params['args'], params['src_vocab_size'], src_vocab,\\n params['tgt_vocab_size'], tgt_vocab)\\n # Load the latest checkpoints\\n optimizer = tf.train.AdamOptimizer(beta1=0.9, beta2=0.98,\\n epsilon=1e-9)\\n\\n ckpt = tf.train.Checkpoint(\\n model=model,\\n optimizer=optimizer\\n )\\n\\n ckpt_manager = tf.train.CheckpointManager(ckpt, OUTPUT_DIR, max_to_keep=5)\\n if ckpt_manager.latest_checkpoint:\\n ckpt.restore(ckpt_manager.latest_checkpoint).expect_partial()\\n\\n print('Loaded ' + lang + ' Teacher model !')\\n\\n return model\",\n \"def load_model():\\n \\n _files = training_file()\\n \\n predictor_path = _files.model_file(LANDMARKS_WEIGHTS)\\n face_rec_model_path = _files.model_file(RESNET_WEIGHTS)\\n \\n detector = dlib.get_frontal_face_detector()\\n sp = dlib.shape_predictor(predictor_path)\\n facerec = dlib.face_recognition_model_v1(face_rec_model_path)\\n \\n return (detector, sp, facerec)\",\n \"def load_checkpoint(tag, params, model):\\r\\n file_name = os.path.join(\\\"saved_models\\\", params.path, tag + \\\".pt\\\")\\r\\n logger.info(\\\"Load checkpoint from %s\\\" % file_name)\\r\\n if os.path.exists(file_name):\\r\\n checkpoint = torch.load(file_name, map_location='cpu')\\r\\n params.training_id = checkpoint['training_id']\\r\\n logger.info(checkpoint['training_id'])\\r\\n model.global_step = checkpoint['global_step']\\r\\n model.load_state_dict(checkpoint['model'])\\r\\n for i, optimizer in enumerate(model.optimizers):\\r\\n optimizer.load_state_dict(checkpoint['optimizers'][i])\\r\\n else:\\r\\n raise Exception(\\\"Checkpoint not found.\\\")\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n normal_init(m, std=0.001)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n normal_init(m, std=0.001)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n normal_init(m, std=0.001)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def init_weights(self, pretrained=None):\\n if isinstance(pretrained, str):\\n logger = get_root_logger()\\n load_checkpoint(self, pretrained, strict=False, logger=logger)\\n elif pretrained is None:\\n for m in self.modules():\\n if isinstance(m, nn.Conv2d):\\n normal_init(m, std=0.001)\\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\\n constant_init(m, 1)\\n else:\\n raise TypeError('pretrained must be a str or None')\",\n \"def modify_weights_after_load(model):\\n # Prune heads if needed\\n if model.config.pruned_heads:\\n model.prune_heads(model.config.pruned_heads)\\n\\n # Tie weights if needed\\n model.tie_weights()\",\n \"def load_model(self, ckpt_fn):\\n checkpoint = torch.load(ckpt_fn)\\n self.net_.load_state_dict(checkpoint[\\\"model\\\"])\\n self.optimizer_.load_state_dict(checkpoint[\\\"optimizer\\\"])\\n self.epoch_ = checkpoint[\\\"epoch\\\"]\\n self.global_step_ = checkpoint[\\\"global_step\\\"]\\n self.model_samples_ = deque(checkpoint[\\\"model_samples\\\"])\\n self.sampler.load_state_dict(checkpoint[\\\"sampler_state\\\"])\\n self.ais_loss.load_state_dict(checkpoint[\\\"ais_state\\\"])\\n self.replay_prob = checkpoint[\\\"replay_prob\\\"]\\n self.max_replay = checkpoint[\\\"max_replay\\\"]\",\n \"def model_load(self, filename_actor, filename_critic):\\r\\n self.actor = tf.keras.models.load_model(filename_actor)\\r\\n self.critic = tf.keras.models.load_model(filename_critic)\",\n \"def model(pretrained=False, **kwargs):\\r\\n\\r\\n layers = make_layers(cfg['O'], dilation=dilation['D1'])\\r\\n cnv = np.cumsum(cnvs['OI']) if kwargs['args'].IN or kwargs['args'].INL else np.cumsum(cnvs['O'])\\r\\n model = VGG(layers, cnvs=cnv, **kwargs)\\r\\n if pretrained:\\r\\n pre2local_keymap = [('features.{}.weight'.format(i), 'conv1_2.{}.weight'.format(i)) for i in range(10)]\\r\\n pre2local_keymap += [('features.{}.bias'.format(i), 'conv1_2.{}.bias'.format(i)) for i in range(10)]\\r\\n pre2local_keymap += [('features.{}.weight'.format(i + 10), 'conv3.{}.weight'.format(i)) for i in range(7)]\\r\\n pre2local_keymap += [('features.{}.bias'.format(i + 10), 'conv3.{}.bias'.format(i)) for i in range(7)]\\r\\n pre2local_keymap += [('features.{}.weight'.format(i + 17), 'conv4.{}.weight'.format(i)) for i in range(7)]\\r\\n pre2local_keymap += [('features.{}.bias'.format(i + 17), 'conv4.{}.bias'.format(i)) for i in range(7)]\\r\\n pre2local_keymap += [('features.{}.weight'.format(i + 24), 'conv5.{}.weight'.format(i)) for i in range(7)]\\r\\n pre2local_keymap += [('features.{}.bias'.format(i + 24), 'conv5.{}.bias'.format(i)) for i in range(7)]\\r\\n pre2local_keymap = dict(pre2local_keymap)\\r\\n\\r\\n\\r\\n model_dict = model.state_dict()\\r\\n pretrained_file = os.path.join(kwargs['args'].pretrained_model_dir, kwargs['args'].pretrained_model)\\r\\n if os.path.isfile(pretrained_file):\\r\\n pretrained_dict = torch.load(pretrained_file)\\r\\n print('load pretrained model from {}'.format(pretrained_file))\\r\\n else:\\r\\n pretrained_dict = model_zoo.load_url(model_urls['vgg16'])\\r\\n print('load pretrained model from {}'.format(model_urls['vgg16']))\\r\\n # 0. replace the key\\r\\n pretrained_dict = {pre2local_keymap[k] if k in pre2local_keymap.keys() else k: v for k, v in\\r\\n pretrained_dict.items()}\\r\\n # *. show the loading information\\r\\n for k in pretrained_dict.keys():\\r\\n if k not in model_dict:\\r\\n print('Key {} is removed from vgg16'.format(k))\\r\\n print(' ')\\r\\n for k in model_dict.keys():\\r\\n if k not in pretrained_dict:\\r\\n print('Key {} is new added for DA Net'.format(k))\\r\\n # 1. filter out unnecessary keys\\r\\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}\\r\\n # 2. overwrite entries in the existing state dict\\r\\n model_dict.update(pretrained_dict)\\r\\n # 3. load the new state dict\\r\\n model.load_state_dict(model_dict)\\r\\n return model\",\n \"def load_pretrainedmodels(model_name):\\n\\n # Lazy import as torchvision may not be required.\\n import pretrainedmodels\\n\\n model = getattr(pretrainedmodels, model_name)().float().eval()\\n input_shape = [1, *model.input_size]\\n input_data = torch.rand(input_shape).float() * 256\\n for channel in range(3):\\n input_data[:, channel] -= model.mean[channel]\\n input_data[:, channel] /= model.std[channel]\\n return model, [input_data]\",\n \"def load_weights(self):\\n try:\\n print('loading weights from {}'.format(self.cfg.class_model_dir))\\n self.load_state_dict(torch.load(self.cfg.class_model_dir + self.class_model_name + '.pth'))\\n except Exception as e:\\n print(\\\"load weights exception: {}\\\".format(e))\",\n \"def load_bytes_subnetwork_pretrained_weights(self, model):\\n print(\\\"ToImplement\\\")\",\n \"def load(self):\\r\\n # self.model.load_state_dict(torch.load(os.path.join(self.ckpt_dir, 'best_model_state_dict.pt')))\\r\\n if torch.cuda.is_available():\\r\\n self.model = torch.load(os.path.join(self.ckpt_dir, 'best_model_INN.pt'))\\r\\n else:\\r\\n self.model = torch.load(os.path.join(self.ckpt_dir, 'best_model_INN.pt'), map_location=torch.device('cpu'))\",\n \"def initiate(self):\\n # if self.opt.checkpoint_encoder:\\n # self.load(self.opt.checkpoint_encoder, self.opt.checkpoint_decoder)\\n # else:\\n # start fresh.\\n self.model = Transformer(\\n self.opt.src_vocab_size,\\n self.opt.tgt_vocab_size,\\n self.opt.max_token_seq_len,\\n tgt_emb_prj_weight_sharing=self.opt.proj_share_weight,\\n emb_src_tgt_weight_sharing=self.opt.embs_share_weight,\\n d_k=self.opt.d_k,\\n d_v=self.opt.d_v,\\n d_model=self.opt.d_model,\\n d_word_vec=self.opt.d_word_vec,\\n d_inner=self.opt.d_inner_hid,\\n n_layers=self.opt.layers,\\n n_head=self.opt.n_head,\\n dropout=self.opt.dropout).to(self.device)\\n \\n for p in self.model.parameters():\\n if p.dim() > 1:\\n nn.init.xavier_uniform_(p)\",\n \"def load_ckpt(self):\\n for name in [\\\"G\\\"]:\\n if isinstance(name, str):\\n # load_filename = '%s_net_%s.pth' % (epoch, name)\\n # load_path = os.path.join(self.save_dir, load_filename)\\n # ckpt_path =\\n net = getattr(self.model, \\\"net\\\" + name)\\n if isinstance(net, torch.nn.DataParallel):\\n net = net.module\\n print(\\\"loading the model from %s\\\" % self.option.ckpt_path)\\n # if you are using PyTorch newer than 0.4 (e.g., built from\\n # GitHub source), you can remove str() on self.device\\n state_dict = torch.load(\\n self.option.ckpt_path, map_location=str(self.model.device)\\n )\\n if hasattr(state_dict, \\\"_metadata\\\"):\\n del state_dict._metadata\\n\\n # patch InstanceNorm checkpoints prior to 0.4\\n # for key in list(state_dict.keys()): # need to copy keys here because we mutate in loop\\n # self.__patch_instance_norm_state_dict(state_dict, net, key.split('.'))\\n net.load_state_dict(state_dict)\",\n \"def load_pretrained_xception(path, model):\\n pretrained_dict = torch.load(path)\\n pretrained_values = []\\n\\n for i in pretrained_dict.values():\\n pretrained_values.append(i)\\n new_state_dict = model.state_dict()\\n\\n cur = 0\\n for k in new_state_dict:\\n new_state_dict[k] = pretrained_values[cur]\\n cur = cur + 1\\n\\n model.load_state_dict(new_state_dict)\",\n \"def train(\\n # fmt: off\\n lang: (\\\"Model language\\\", \\\"positional\\\", None, str),\\n output_path: (\\\"Output directory to store model in\\\", \\\"positional\\\", None, Path),\\n train_path: (\\\"Location of JSON-formatted training data\\\", \\\"positional\\\", None, Path),\\n dev_path: (\\\"Location of JSON-formatted development data\\\", \\\"positional\\\", None, Path),\\n raw_text: (\\\"Path to jsonl file with unlabelled text documents.\\\", \\\"option\\\", \\\"rt\\\", Path) = None,\\n base_model: (\\\"Name of model to update (optional)\\\", \\\"option\\\", \\\"b\\\", str) = None,\\n pipeline: (\\\"Comma-separated names of pipeline components\\\", \\\"option\\\", \\\"p\\\", str) = \\\"tagger,parser,ner\\\",\\n vectors: (\\\"Model to load vectors from\\\", \\\"option\\\", \\\"v\\\", str) = None,\\n replace_components: (\\\"Replace components from base model\\\", \\\"flag\\\", \\\"R\\\", bool) = False,\\n n_iter: (\\\"Number of iterations\\\", \\\"option\\\", \\\"n\\\", int) = 30,\\n n_early_stopping: (\\\"Maximum number of training epochs without dev accuracy improvement\\\", \\\"option\\\", \\\"ne\\\", int) = None,\\n n_examples: (\\\"Number of examples\\\", \\\"option\\\", \\\"ns\\\", int) = 0,\\n use_gpu: (\\\"Use GPU\\\", \\\"option\\\", \\\"g\\\", int) = -1,\\n version: (\\\"Model version\\\", \\\"option\\\", \\\"V\\\", str) = \\\"0.0.0\\\",\\n meta_path: (\\\"Optional path to meta.json to use as base.\\\", \\\"option\\\", \\\"m\\\", Path) = None,\\n init_tok2vec: (\\\"Path to pretrained weights for the token-to-vector parts of the models. See 'spacy pretrain'. Experimental.\\\", \\\"option\\\", \\\"t2v\\\", Path) = None,\\n parser_multitasks: (\\\"Side objectives for parser CNN, e.g. 'dep' or 'dep,tag'\\\", \\\"option\\\", \\\"pt\\\", str) = \\\"\\\",\\n entity_multitasks: (\\\"Side objectives for NER CNN, e.g. 'dep' or 'dep,tag'\\\", \\\"option\\\", \\\"et\\\", str) = \\\"\\\",\\n noise_level: (\\\"Amount of corruption for data augmentation\\\", \\\"option\\\", \\\"nl\\\", float) = 0.0,\\n orth_variant_level: (\\\"Amount of orthography variation for data augmentation\\\", \\\"option\\\", \\\"ovl\\\", float) = 0.0,\\n eval_beam_widths: (\\\"Beam widths to evaluate, e.g. 4,8\\\", \\\"option\\\", \\\"bw\\\", str) = \\\"\\\",\\n gold_preproc: (\\\"Use gold preprocessing\\\", \\\"flag\\\", \\\"G\\\", bool) = False,\\n learn_tokens: (\\\"Make parser learn gold-standard tokenization\\\", \\\"flag\\\", \\\"T\\\", bool) = False,\\n textcat_multilabel: (\\\"Textcat classes aren't mutually exclusive (multilabel)\\\", \\\"flag\\\", \\\"TML\\\", bool) = False,\\n textcat_arch: (\\\"Textcat model architecture\\\", \\\"option\\\", \\\"ta\\\", str) = \\\"bow\\\",\\n textcat_positive_label: (\\\"Textcat positive label for binary classes with two labels\\\", \\\"option\\\", \\\"tpl\\\", str) = None,\\n tag_map_path: (\\\"Location of JSON-formatted tag map\\\", \\\"option\\\", \\\"tm\\\", Path) = None,\\n verbose: (\\\"Display more information for debug\\\", \\\"flag\\\", \\\"VV\\\", bool) = False,\\n debug: (\\\"Run data diagnostics before training\\\", \\\"flag\\\", \\\"D\\\", bool) = False,\\n # fmt: on\\n):\\n util.fix_random_seed()\\n util.set_env_log(verbose)\\n\\n # Make sure all files and paths exists if they are needed\\n train_path = util.ensure_path(train_path)\\n dev_path = util.ensure_path(dev_path)\\n meta_path = util.ensure_path(meta_path)\\n output_path = util.ensure_path(output_path)\\n if raw_text is not None:\\n raw_text = list(srsly.read_jsonl(raw_text))\\n if not train_path or not train_path.exists():\\n msg.fail(\\\"Training data not found\\\", train_path, exits=1)\\n if not dev_path or not dev_path.exists():\\n msg.fail(\\\"Development data not found\\\", dev_path, exits=1)\\n if meta_path is not None and not meta_path.exists():\\n msg.fail(\\\"Can't find model meta.json\\\", meta_path, exits=1)\\n meta = srsly.read_json(meta_path) if meta_path else {}\\n if output_path.exists() and [p for p in output_path.iterdir() if p.is_dir()]:\\n msg.warn(\\n \\\"Output directory is not empty\\\",\\n \\\"This can lead to unintended side effects when saving the model. \\\"\\n \\\"Please use an empty directory or a different path instead. If \\\"\\n \\\"the specified output path doesn't exist, the directory will be \\\"\\n \\\"created for you.\\\",\\n )\\n if not output_path.exists():\\n output_path.mkdir()\\n msg.good(f\\\"Created output directory: {output_path}\\\")\\n\\n tag_map = {}\\n if tag_map_path is not None:\\n tag_map = srsly.read_json(tag_map_path)\\n # Take dropout and batch size as generators of values -- dropout\\n # starts high and decays sharply, to force the optimizer to explore.\\n # Batch size starts at 1 and grows, so that we make updates quickly\\n # at the beginning of training.\\n dropout_rates = util.decaying(\\n util.env_opt(\\\"dropout_from\\\", 0.2),\\n util.env_opt(\\\"dropout_to\\\", 0.2),\\n util.env_opt(\\\"dropout_decay\\\", 0.0),\\n )\\n batch_sizes = util.compounding(\\n util.env_opt(\\\"batch_from\\\", 100.0),\\n util.env_opt(\\\"batch_to\\\", 1000.0),\\n util.env_opt(\\\"batch_compound\\\", 1.001),\\n )\\n\\n if not eval_beam_widths:\\n eval_beam_widths = [1]\\n else:\\n eval_beam_widths = [int(bw) for bw in eval_beam_widths.split(\\\",\\\")]\\n if 1 not in eval_beam_widths:\\n eval_beam_widths.append(1)\\n eval_beam_widths.sort()\\n has_beam_widths = eval_beam_widths != [1]\\n\\n default_dir = Path(__file__).parent.parent / \\\"ml\\\" / \\\"models\\\" / \\\"defaults\\\"\\n\\n # Set up the base model and pipeline. If a base model is specified, load\\n # the model and make sure the pipeline matches the pipeline setting. If\\n # training starts from a blank model, intitalize the language class.\\n pipeline = [p.strip() for p in pipeline.split(\\\",\\\")]\\n msg.text(f\\\"Training pipeline: {pipeline}\\\")\\n disabled_pipes = None\\n pipes_added = False\\n if use_gpu >= 0:\\n activated_gpu = None\\n try:\\n activated_gpu = set_gpu(use_gpu)\\n except Exception as e:\\n msg.warn(f\\\"Exception: {e}\\\")\\n if activated_gpu is not None:\\n msg.text(f\\\"Using GPU: {use_gpu}\\\")\\n else:\\n msg.warn(f\\\"Unable to activate GPU: {use_gpu}\\\")\\n msg.text(\\\"Using CPU only\\\")\\n use_gpu = -1\\n if base_model:\\n msg.text(f\\\"Starting with base model '{base_model}'\\\")\\n nlp = util.load_model(base_model)\\n if nlp.lang != lang:\\n msg.fail(\\n f\\\"Model language ('{nlp.lang}') doesn't match language \\\"\\n f\\\"specified as `lang` argument ('{lang}') \\\",\\n exits=1,\\n )\\n if vectors:\\n msg.text(f\\\"Loading vectors from model '{vectors}'\\\")\\n _load_vectors(nlp, vectors)\\n\\n nlp.select_pipes(disable=[p for p in nlp.pipe_names if p not in pipeline])\\n for pipe in pipeline:\\n # first, create the model.\\n # Bit of a hack after the refactor to get the vectors into a default config\\n # use train-from-config instead :-)\\n if pipe == \\\"parser\\\":\\n config_loc = default_dir / \\\"parser_defaults.cfg\\\"\\n elif pipe == \\\"tagger\\\":\\n config_loc = default_dir / \\\"tagger_defaults.cfg\\\"\\n elif pipe == \\\"ner\\\":\\n config_loc = default_dir / \\\"ner_defaults.cfg\\\"\\n elif pipe == \\\"textcat\\\":\\n config_loc = default_dir / \\\"textcat_defaults.cfg\\\"\\n elif pipe == \\\"senter\\\":\\n config_loc = default_dir / \\\"senter_defaults.cfg\\\"\\n else:\\n raise ValueError(f\\\"Component {pipe} currently not supported.\\\")\\n pipe_cfg = util.load_config(config_loc, create_objects=False)\\n if vectors:\\n pretrained_config = {\\n \\\"@architectures\\\": \\\"spacy.VocabVectors.v1\\\",\\n \\\"name\\\": vectors,\\n }\\n pipe_cfg[\\\"model\\\"][\\\"tok2vec\\\"][\\\"pretrained_vectors\\\"] = pretrained_config\\n\\n if pipe == \\\"parser\\\":\\n pipe_cfg[\\\"learn_tokens\\\"] = learn_tokens\\n elif pipe == \\\"textcat\\\":\\n pipe_cfg[\\\"exclusive_classes\\\"] = not textcat_multilabel\\n pipe_cfg[\\\"architecture\\\"] = textcat_arch\\n pipe_cfg[\\\"positive_label\\\"] = textcat_positive_label\\n\\n if pipe not in nlp.pipe_names:\\n msg.text(f\\\"Adding component to base model '{pipe}'\\\")\\n nlp.add_pipe(nlp.create_pipe(pipe, config=pipe_cfg))\\n pipes_added = True\\n elif replace_components:\\n msg.text(f\\\"Replacing component from base model '{pipe}'\\\")\\n nlp.replace_pipe(pipe, nlp.create_pipe(pipe, config=pipe_cfg))\\n pipes_added = True\\n else:\\n if pipe == \\\"textcat\\\":\\n textcat_cfg = nlp.get_pipe(\\\"textcat\\\").cfg\\n base_cfg = {\\n \\\"exclusive_classes\\\": textcat_cfg[\\\"exclusive_classes\\\"],\\n \\\"architecture\\\": textcat_cfg[\\\"architecture\\\"],\\n \\\"positive_label\\\": textcat_cfg[\\\"positive_label\\\"],\\n }\\n if base_cfg != pipe_cfg:\\n msg.fail(\\n f\\\"The base textcat model configuration does\\\"\\n f\\\"not match the provided training options. \\\"\\n f\\\"Existing cfg: {base_cfg}, provided cfg: {pipe_cfg}\\\",\\n exits=1,\\n )\\n msg.text(f\\\"Extending component from base model '{pipe}'\\\")\\n disabled_pipes = nlp.select_pipes(\\n disable=[p for p in nlp.pipe_names if p not in pipeline]\\n )\\n else:\\n msg.text(f\\\"Starting with blank model '{lang}'\\\")\\n lang_cls = util.get_lang_class(lang)\\n nlp = lang_cls()\\n\\n if vectors:\\n msg.text(f\\\"Loading vectors from model '{vectors}'\\\")\\n _load_vectors(nlp, vectors)\\n\\n for pipe in pipeline:\\n # first, create the model.\\n # Bit of a hack after the refactor to get the vectors into a default config\\n # use train-from-config instead :-)\\n if pipe == \\\"parser\\\":\\n config_loc = default_dir / \\\"parser_defaults.cfg\\\"\\n elif pipe == \\\"tagger\\\":\\n config_loc = default_dir / \\\"tagger_defaults.cfg\\\"\\n elif pipe == \\\"morphologizer\\\":\\n config_loc = default_dir / \\\"morphologizer_defaults.cfg\\\"\\n elif pipe == \\\"ner\\\":\\n config_loc = default_dir / \\\"ner_defaults.cfg\\\"\\n elif pipe == \\\"textcat\\\":\\n config_loc = default_dir / \\\"textcat_defaults.cfg\\\"\\n elif pipe == \\\"senter\\\":\\n config_loc = default_dir / \\\"senter_defaults.cfg\\\"\\n else:\\n raise ValueError(f\\\"Component {pipe} currently not supported.\\\")\\n pipe_cfg = util.load_config(config_loc, create_objects=False)\\n if vectors:\\n pretrained_config = {\\n \\\"@architectures\\\": \\\"spacy.VocabVectors.v1\\\",\\n \\\"name\\\": vectors,\\n }\\n pipe_cfg[\\\"model\\\"][\\\"tok2vec\\\"][\\\"pretrained_vectors\\\"] = pretrained_config\\n\\n if pipe == \\\"parser\\\":\\n pipe_cfg[\\\"learn_tokens\\\"] = learn_tokens\\n elif pipe == \\\"textcat\\\":\\n pipe_cfg[\\\"exclusive_classes\\\"] = not textcat_multilabel\\n pipe_cfg[\\\"architecture\\\"] = textcat_arch\\n pipe_cfg[\\\"positive_label\\\"] = textcat_positive_label\\n\\n pipe = nlp.create_pipe(pipe, config=pipe_cfg)\\n nlp.add_pipe(pipe)\\n\\n # Update tag map with provided mapping\\n nlp.vocab.morphology.tag_map.update(tag_map)\\n\\n # Multitask objectives\\n multitask_options = [(\\\"parser\\\", parser_multitasks), (\\\"ner\\\", entity_multitasks)]\\n for pipe_name, multitasks in multitask_options:\\n if multitasks:\\n if pipe_name not in pipeline:\\n msg.fail(\\n f\\\"Can't use multitask objective without '{pipe_name}' in \\\"\\n f\\\"the pipeline\\\"\\n )\\n pipe = nlp.get_pipe(pipe_name)\\n for objective in multitasks.split(\\\",\\\"):\\n pipe.add_multitask_objective(objective)\\n\\n # Prepare training corpus\\n msg.text(f\\\"Counting training words (limit={n_examples})\\\")\\n corpus = GoldCorpus(train_path, dev_path, limit=n_examples)\\n n_train_words = corpus.count_train()\\n\\n if base_model and not pipes_added:\\n # Start with an existing model, use default optimizer\\n optimizer = create_default_optimizer()\\n else:\\n # Start with a blank model, call begin_training\\n cfg = {\\\"device\\\": use_gpu}\\n optimizer = nlp.begin_training(lambda: corpus.train_examples, **cfg)\\n nlp._optimizer = None\\n\\n # Load in pretrained weights (TODO: this may be broken in the config rewrite)\\n if init_tok2vec is not None:\\n components = _load_pretrained_tok2vec(nlp, init_tok2vec)\\n msg.text(f\\\"Loaded pretrained tok2vec for: {components}\\\")\\n\\n # Verify textcat config\\n if \\\"textcat\\\" in pipeline:\\n textcat_labels = nlp.get_pipe(\\\"textcat\\\").cfg.get(\\\"labels\\\", [])\\n if textcat_positive_label and textcat_positive_label not in textcat_labels:\\n msg.fail(\\n f\\\"The textcat_positive_label (tpl) '{textcat_positive_label}' \\\"\\n f\\\"does not match any label in the training data.\\\",\\n exits=1,\\n )\\n if textcat_positive_label and len(textcat_labels) != 2:\\n msg.fail(\\n \\\"A textcat_positive_label (tpl) '{textcat_positive_label}' was \\\"\\n \\\"provided for training data that does not appear to be a \\\"\\n \\\"binary classification problem with two labels.\\\",\\n exits=1,\\n )\\n train_data = corpus.train_data(\\n nlp,\\n noise_level=noise_level,\\n gold_preproc=gold_preproc,\\n max_length=0,\\n ignore_misaligned=True,\\n )\\n train_labels = set()\\n if textcat_multilabel:\\n multilabel_found = False\\n for ex in train_data:\\n train_labels.update(ex.gold.cats.keys())\\n if list(ex.gold.cats.values()).count(1.0) != 1:\\n multilabel_found = True\\n if not multilabel_found and not base_model:\\n msg.warn(\\n \\\"The textcat training instances look like they have \\\"\\n \\\"mutually-exclusive classes. Remove the flag \\\"\\n \\\"'--textcat-multilabel' to train a classifier with \\\"\\n \\\"mutually-exclusive classes.\\\"\\n )\\n if not textcat_multilabel:\\n for ex in train_data:\\n train_labels.update(ex.gold.cats.keys())\\n if list(ex.gold.cats.values()).count(1.0) != 1 and not base_model:\\n msg.warn(\\n \\\"Some textcat training instances do not have exactly \\\"\\n \\\"one positive label. Modifying training options to \\\"\\n \\\"include the flag '--textcat-multilabel' for classes \\\"\\n \\\"that are not mutually exclusive.\\\"\\n )\\n nlp.get_pipe(\\\"textcat\\\").cfg[\\\"exclusive_classes\\\"] = False\\n textcat_multilabel = True\\n break\\n if base_model and set(textcat_labels) != train_labels:\\n msg.fail(\\n f\\\"Cannot extend textcat model using data with different \\\"\\n f\\\"labels. Base model labels: {textcat_labels}, training data \\\"\\n f\\\"labels: {list(train_labels)}\\\",\\n exits=1,\\n )\\n if textcat_multilabel:\\n msg.text(\\n f\\\"Textcat evaluation score: ROC AUC score macro-averaged across \\\"\\n f\\\"the labels '{', '.join(textcat_labels)}'\\\"\\n )\\n elif textcat_positive_label and len(textcat_labels) == 2:\\n msg.text(\\n f\\\"Textcat evaluation score: F1-score for the \\\"\\n f\\\"label '{textcat_positive_label}'\\\"\\n )\\n elif len(textcat_labels) > 1:\\n if len(textcat_labels) == 2:\\n msg.warn(\\n \\\"If the textcat component is a binary classifier with \\\"\\n \\\"exclusive classes, provide '--textcat_positive_label' for \\\"\\n \\\"an evaluation on the positive class.\\\"\\n )\\n msg.text(\\n f\\\"Textcat evaluation score: F1-score macro-averaged across \\\"\\n f\\\"the labels '{', '.join(textcat_labels)}'\\\"\\n )\\n else:\\n msg.fail(\\n \\\"Unsupported textcat configuration. Use `spacy debug-data` \\\"\\n \\\"for more information.\\\"\\n )\\n\\n # fmt: off\\n row_head, output_stats = _configure_training_output(pipeline, use_gpu, has_beam_widths)\\n row_widths = [len(w) for w in row_head]\\n row_settings = {\\\"widths\\\": row_widths, \\\"aligns\\\": tuple([\\\"r\\\" for i in row_head]), \\\"spacing\\\": 2}\\n # fmt: on\\n print(\\\"\\\")\\n msg.row(row_head, **row_settings)\\n msg.row([\\\"-\\\" * width for width in row_settings[\\\"widths\\\"]], **row_settings)\\n try:\\n iter_since_best = 0\\n best_score = 0.0\\n for i in range(n_iter):\\n train_data = corpus.train_dataset(\\n nlp,\\n noise_level=noise_level,\\n orth_variant_level=orth_variant_level,\\n gold_preproc=gold_preproc,\\n max_length=0,\\n ignore_misaligned=True,\\n )\\n if raw_text:\\n random.shuffle(raw_text)\\n raw_batches = util.minibatch(\\n (nlp.make_doc(rt[\\\"text\\\"]) for rt in raw_text), size=8\\n )\\n words_seen = 0\\n with tqdm.tqdm(total=n_train_words, leave=False) as pbar:\\n losses = {}\\n for batch in util.minibatch_by_words(train_data, size=batch_sizes):\\n if not batch:\\n continue\\n try:\\n nlp.update(\\n batch,\\n sgd=optimizer,\\n drop=next(dropout_rates),\\n losses=losses,\\n )\\n except ValueError as e:\\n err = \\\"Error during training\\\"\\n if init_tok2vec:\\n err += \\\" Did you provide the same parameters during 'train' as during 'pretrain'?\\\"\\n msg.fail(err, f\\\"Original error message: {e}\\\", exits=1)\\n if raw_text:\\n # If raw text is available, perform 'rehearsal' updates,\\n # which use unlabelled data to reduce overfitting.\\n raw_batch = list(next(raw_batches))\\n nlp.rehearse(raw_batch, sgd=optimizer, losses=losses)\\n docs = [ex.doc for ex in batch]\\n if not int(os.environ.get(\\\"LOG_FRIENDLY\\\", 0)):\\n pbar.update(sum(len(doc) for doc in docs))\\n words_seen += sum(len(doc) for doc in docs)\\n with nlp.use_params(optimizer.averages):\\n util.set_env_log(False)\\n epoch_model_path = output_path / f\\\"model{i}\\\"\\n nlp.to_disk(epoch_model_path)\\n nlp_loaded = util.load_model_from_path(epoch_model_path)\\n for beam_width in eval_beam_widths:\\n for name, component in nlp_loaded.pipeline:\\n if hasattr(component, \\\"cfg\\\"):\\n component.cfg[\\\"beam_width\\\"] = beam_width\\n dev_dataset = list(\\n corpus.dev_dataset(\\n nlp_loaded,\\n gold_preproc=gold_preproc,\\n ignore_misaligned=True,\\n )\\n )\\n nwords = sum(len(ex.doc) for ex in dev_dataset)\\n start_time = timer()\\n scorer = nlp_loaded.evaluate(dev_dataset, verbose=verbose)\\n end_time = timer()\\n if use_gpu < 0:\\n gpu_wps = None\\n cpu_wps = nwords / (end_time - start_time)\\n else:\\n gpu_wps = nwords / (end_time - start_time)\\n with use_ops(\\\"numpy\\\"):\\n nlp_loaded = util.load_model_from_path(epoch_model_path)\\n for name, component in nlp_loaded.pipeline:\\n if hasattr(component, \\\"cfg\\\"):\\n component.cfg[\\\"beam_width\\\"] = beam_width\\n dev_dataset = list(\\n corpus.dev_dataset(\\n nlp_loaded,\\n gold_preproc=gold_preproc,\\n ignore_misaligned=True,\\n )\\n )\\n start_time = timer()\\n scorer = nlp_loaded.evaluate(dev_dataset, verbose=verbose)\\n end_time = timer()\\n cpu_wps = nwords / (end_time - start_time)\\n acc_loc = output_path / f\\\"model{i}\\\" / \\\"accuracy.json\\\"\\n srsly.write_json(acc_loc, scorer.scores)\\n\\n # Update model meta.json\\n meta[\\\"lang\\\"] = nlp.lang\\n meta[\\\"pipeline\\\"] = nlp.pipe_names\\n meta[\\\"spacy_version\\\"] = f\\\">={about.__version__}\\\"\\n if beam_width == 1:\\n meta[\\\"speed\\\"] = {\\n \\\"nwords\\\": nwords,\\n \\\"cpu\\\": cpu_wps,\\n \\\"gpu\\\": gpu_wps,\\n }\\n meta.setdefault(\\\"accuracy\\\", {})\\n for component in nlp.pipe_names:\\n for metric in _get_metrics(component):\\n meta[\\\"accuracy\\\"][metric] = scorer.scores[metric]\\n else:\\n meta.setdefault(\\\"beam_accuracy\\\", {})\\n meta.setdefault(\\\"beam_speed\\\", {})\\n for component in nlp.pipe_names:\\n for metric in _get_metrics(component):\\n meta[\\\"beam_accuracy\\\"][metric] = scorer.scores[metric]\\n meta[\\\"beam_speed\\\"][beam_width] = {\\n \\\"nwords\\\": nwords,\\n \\\"cpu\\\": cpu_wps,\\n \\\"gpu\\\": gpu_wps,\\n }\\n meta[\\\"vectors\\\"] = {\\n \\\"width\\\": nlp.vocab.vectors_length,\\n \\\"vectors\\\": len(nlp.vocab.vectors),\\n \\\"keys\\\": nlp.vocab.vectors.n_keys,\\n \\\"name\\\": nlp.vocab.vectors.name,\\n }\\n meta.setdefault(\\\"name\\\", f\\\"model{i}\\\")\\n meta.setdefault(\\\"version\\\", version)\\n meta[\\\"labels\\\"] = nlp.meta[\\\"labels\\\"]\\n meta_loc = output_path / f\\\"model{i}\\\" / \\\"meta.json\\\"\\n srsly.write_json(meta_loc, meta)\\n util.set_env_log(verbose)\\n\\n progress = _get_progress(\\n i,\\n losses,\\n scorer.scores,\\n output_stats,\\n beam_width=beam_width if has_beam_widths else None,\\n cpu_wps=cpu_wps,\\n gpu_wps=gpu_wps,\\n )\\n if i == 0 and \\\"textcat\\\" in pipeline:\\n textcats_per_cat = scorer.scores.get(\\\"textcats_per_cat\\\", {})\\n for cat, cat_score in textcats_per_cat.items():\\n if cat_score.get(\\\"roc_auc_score\\\", 0) < 0:\\n msg.warn(\\n f\\\"Textcat ROC AUC score is undefined due to \\\"\\n f\\\"only one value in label '{cat}'.\\\"\\n )\\n msg.row(progress, **row_settings)\\n # Early stopping\\n if n_early_stopping is not None:\\n current_score = _score_for_model(meta)\\n if current_score < best_score:\\n iter_since_best += 1\\n else:\\n iter_since_best = 0\\n best_score = current_score\\n if iter_since_best >= n_early_stopping:\\n msg.text(\\n f\\\"Early stopping, best iteration is: {i - iter_since_best}\\\"\\n )\\n msg.text(\\n f\\\"Best score = {best_score}; Final iteration score = {current_score}\\\"\\n )\\n break\\n except Exception as e:\\n msg.warn(f\\\"Aborting and saving final best model. Encountered exception: {e}\\\")\\n finally:\\n best_pipes = nlp.pipe_names\\n if disabled_pipes:\\n disabled_pipes.restore()\\n with nlp.use_params(optimizer.averages):\\n final_model_path = output_path / \\\"model-final\\\"\\n nlp.to_disk(final_model_path)\\n meta_loc = output_path / \\\"model-final\\\" / \\\"meta.json\\\"\\n final_meta = srsly.read_json(meta_loc)\\n final_meta.setdefault(\\\"accuracy\\\", {})\\n final_meta[\\\"accuracy\\\"].update(meta.get(\\\"accuracy\\\", {}))\\n final_meta.setdefault(\\\"speed\\\", {})\\n final_meta[\\\"speed\\\"].setdefault(\\\"cpu\\\", None)\\n final_meta[\\\"speed\\\"].setdefault(\\\"gpu\\\", None)\\n meta.setdefault(\\\"speed\\\", {})\\n meta[\\\"speed\\\"].setdefault(\\\"cpu\\\", None)\\n meta[\\\"speed\\\"].setdefault(\\\"gpu\\\", None)\\n # combine cpu and gpu speeds with the base model speeds\\n if final_meta[\\\"speed\\\"][\\\"cpu\\\"] and meta[\\\"speed\\\"][\\\"cpu\\\"]:\\n speed = _get_total_speed(\\n [final_meta[\\\"speed\\\"][\\\"cpu\\\"], meta[\\\"speed\\\"][\\\"cpu\\\"]]\\n )\\n final_meta[\\\"speed\\\"][\\\"cpu\\\"] = speed\\n if final_meta[\\\"speed\\\"][\\\"gpu\\\"] and meta[\\\"speed\\\"][\\\"gpu\\\"]:\\n speed = _get_total_speed(\\n [final_meta[\\\"speed\\\"][\\\"gpu\\\"], meta[\\\"speed\\\"][\\\"gpu\\\"]]\\n )\\n final_meta[\\\"speed\\\"][\\\"gpu\\\"] = speed\\n # if there were no speeds to update, overwrite with meta\\n if (\\n final_meta[\\\"speed\\\"][\\\"cpu\\\"] is None\\n and final_meta[\\\"speed\\\"][\\\"gpu\\\"] is None\\n ):\\n final_meta[\\\"speed\\\"].update(meta[\\\"speed\\\"])\\n # note: beam speeds are not combined with the base model\\n if has_beam_widths:\\n final_meta.setdefault(\\\"beam_accuracy\\\", {})\\n final_meta[\\\"beam_accuracy\\\"].update(meta.get(\\\"beam_accuracy\\\", {}))\\n final_meta.setdefault(\\\"beam_speed\\\", {})\\n final_meta[\\\"beam_speed\\\"].update(meta.get(\\\"beam_speed\\\", {}))\\n srsly.write_json(meta_loc, final_meta)\\n msg.good(\\\"Saved model to output directory\\\", final_model_path)\\n with msg.loading(\\\"Creating best model...\\\"):\\n best_model_path = _collate_best_model(final_meta, output_path, best_pipes)\\n msg.good(\\\"Created best model\\\", best_model_path)\",\n \"def soft_load_weights(model, weights):\\n own_state = model.state_dict()\\n for name, param in weights.items():\\n if name not in own_state:\\n continue\\n if isinstance(param, torch.nn.Parameter):\\n # backwards compatibility for serialized parameters\\n param = param.data\\n own_state[name].copy_(param)\",\n \"def load_pretrained_layers(self):\\n # Current state of base\\n state_dict = self.state_dict()\\n param_names = list(state_dict.keys())\\n\\n # Pretrained VGG base\\n pretrained_state_dict = torchvision.models.vgg16(pretrained=True).state_dict()\\n pretrained_param_names = list(pretrained_state_dict.keys())\\n\\n # Transfer conv. parameters from pretrained model to current model\\n for i, param in enumerate(param_names[:-4]): # excluding conv6 and conv7 parameters\\n state_dict[param] = pretrained_state_dict[pretrained_param_names[i]]\\n\\n # Convert fc6, fc7 to convolutional layers, and subsample (by decimation) to sizes of conv6 and conv7\\n # fc6\\n conv_fc6_weight = pretrained_state_dict['classifier.0.weight'].view(4096, 512, 7, 7) # (4096, 512, 7, 7)\\n conv_fc6_bias = pretrained_state_dict['classifier.0.bias'] # (4096)\\n state_dict['conv6.weight'] = decimate(conv_fc6_weight, m=[4, None, 3, 3]) # (1024, 512, 3, 3)\\n state_dict['conv6.bias'] = decimate(conv_fc6_bias, m=[4]) # (1024)\\n # fc7\\n conv_fc7_weight = pretrained_state_dict['classifier.3.weight'].view(4096, 4096, 1, 1) # (4096, 4096, 1, 1)\\n conv_fc7_bias = pretrained_state_dict['classifier.3.bias'] # (4096)\\n state_dict['conv7.weight'] = decimate(conv_fc7_weight, m=[4, 4, None, None]) # (1024, 1024, 1, 1)\\n state_dict['conv7.bias'] = decimate(conv_fc7_bias, m=[4]) # (1024)\\n\\n # Note: an FC layer of size (K) operating on a flattened version (C*H*W) of a 2D image of size (C, H, W)...\\n # ...is equivalent to a convolutional layer with kernel size (H, W), input channels C, output channels K...\\n # ...operating on the 2D image of size (C, H, W) without padding\\n\\n self.load_state_dict(state_dict)\\n\\n print(\\\"\\\\nLoaded base model.\\\\n\\\")\",\n \"def load(model, name=\\\"store/base\\\"):\\n if torch.cuda.is_available():\\n pretrained_dict = torch.load(name + \\\".pt\\\")\\n else:\\n pretrained_dict = torch.load(name + \\\".pt\\\", map_location=torch.device('cpu'))\\n print(\\\"Loaded\\\", name + \\\" model.\\\")\\n model_dict = model.state_dict()\\n model_dict.update(pretrained_dict)\\n model.load_state_dict(model_dict)\",\n \"def load_model():\\r\\n model = MobileNetV2(weights=\\\"imagenet\\\")\\r\\n print(\\\"Model loaded\\\")\\r\\n return model\",\n \"def loadModel(self):\\n self.model.load_state_dict(torch.load(os.path.join(self.model_save_dir, '{}_trained.pt'.format(self.model_name)), map_location=torch.device(device)))\\n return self.model\",\n \"def pretrained(name=\\\"pos_anc\\\", lang=\\\"en\\\", remote_loc=None):\\n from sparknlp.pretrained import ResourceDownloader\\n return ResourceDownloader.downloadModel(PerceptronModel, name, lang, remote_loc)\",\n \"def load_model(model_path):\\n nlp = spacy.blank('en') \\n if 'ner' not in nlp.pipe_names:\\n ner = nlp.create_pipe('ner')\\n nlp.add_pipe(ner)\\n #load pretrained model from the path\\n ner = nlp.from_disk(model_path)\\n return ner\",\n \"def load_model():\\n global clf\\n mdl = joblib.load('model/chitchat.model')\\n vec = joblib.load('model/tfidf.vectorizer')\\n clf = ChitChatClassifier(mdl, vec)\",\n \"def thundersvm_load_svm_model(input_svm_model_file):\\n \\n svm_model = SVC()\\n svm_model.load_from_file(input_svm_model_file)\\n \\n return svm_model\",\n \"def _load_training_data(self):\\n self._save_training_data()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6386861","0.63678175","0.6225031","0.62216717","0.61162937","0.6101295","0.6054075","0.6042603","0.6018365","0.59910965","0.59458715","0.5943918","0.59387076","0.5920058","0.5915071","0.59099936","0.59086907","0.5901546","0.59015244","0.58882916","0.5885137","0.5876208","0.586939","0.5843149","0.5838739","0.58280593","0.58076805","0.5801258","0.5787718","0.5779456","0.5749898","0.5729687","0.5725947","0.5723495","0.570162","0.5696127","0.5686809","0.568214","0.56805766","0.568035","0.56775045","0.5654988","0.5640914","0.5623718","0.56223696","0.5618027","0.56120276","0.55962723","0.5584135","0.55832434","0.5581473","0.55770147","0.5571401","0.55675995","0.5566235","0.5560213","0.55507934","0.55504775","0.5547394","0.5546386","0.554234","0.55414855","0.5541346","0.55402917","0.55381346","0.55356807","0.5532236","0.553127","0.553114","0.5522853","0.5508217","0.5501476","0.5485997","0.5483246","0.5472636","0.5472636","0.5472636","0.5472636","0.54636765","0.5459171","0.5458803","0.5452789","0.54448396","0.5441051","0.5438239","0.5434735","0.543188","0.54313004","0.5430266","0.5408105","0.5401976","0.5398024","0.5397937","0.53974026","0.5397254","0.53856367","0.5380126","0.5379851","0.536671","0.5363287"],"string":"[\n \"0.6386861\",\n \"0.63678175\",\n \"0.6225031\",\n \"0.62216717\",\n \"0.61162937\",\n \"0.6101295\",\n \"0.6054075\",\n \"0.6042603\",\n \"0.6018365\",\n \"0.59910965\",\n \"0.59458715\",\n \"0.5943918\",\n \"0.59387076\",\n \"0.5920058\",\n \"0.5915071\",\n \"0.59099936\",\n \"0.59086907\",\n \"0.5901546\",\n \"0.59015244\",\n \"0.58882916\",\n \"0.5885137\",\n \"0.5876208\",\n \"0.586939\",\n \"0.5843149\",\n \"0.5838739\",\n \"0.58280593\",\n \"0.58076805\",\n \"0.5801258\",\n \"0.5787718\",\n \"0.5779456\",\n \"0.5749898\",\n \"0.5729687\",\n \"0.5725947\",\n \"0.5723495\",\n \"0.570162\",\n \"0.5696127\",\n \"0.5686809\",\n \"0.568214\",\n \"0.56805766\",\n \"0.568035\",\n \"0.56775045\",\n \"0.5654988\",\n \"0.5640914\",\n \"0.5623718\",\n \"0.56223696\",\n \"0.5618027\",\n \"0.56120276\",\n \"0.55962723\",\n \"0.5584135\",\n \"0.55832434\",\n \"0.5581473\",\n \"0.55770147\",\n \"0.5571401\",\n \"0.55675995\",\n \"0.5566235\",\n \"0.5560213\",\n \"0.55507934\",\n \"0.55504775\",\n \"0.5547394\",\n \"0.5546386\",\n \"0.554234\",\n \"0.55414855\",\n \"0.5541346\",\n \"0.55402917\",\n \"0.55381346\",\n \"0.55356807\",\n \"0.5532236\",\n \"0.553127\",\n \"0.553114\",\n \"0.5522853\",\n \"0.5508217\",\n \"0.5501476\",\n \"0.5485997\",\n \"0.5483246\",\n \"0.5472636\",\n \"0.5472636\",\n \"0.5472636\",\n \"0.5472636\",\n \"0.54636765\",\n \"0.5459171\",\n \"0.5458803\",\n \"0.5452789\",\n \"0.54448396\",\n \"0.5441051\",\n \"0.5438239\",\n \"0.5434735\",\n \"0.543188\",\n \"0.54313004\",\n \"0.5430266\",\n \"0.5408105\",\n \"0.5401976\",\n \"0.5398024\",\n \"0.5397937\",\n \"0.53974026\",\n \"0.5397254\",\n \"0.53856367\",\n \"0.5380126\",\n \"0.5379851\",\n \"0.536671\",\n \"0.5363287\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6853876"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92884,"cells":{"query":{"kind":"string","value":"Check that t is a tree, with the correct interla structure. (Helper function not a unit test.)"},"document":{"kind":"string","value":"def isTree(self, t):\n\n if type(t) != tree:\n return False;\n if not hasattr(t, \"label\"):\n return False;\n if type(t.label) != str:\n return False;\n if not hasattr(t, \"children\"):\n return False;\n if type(t.children) != list:\n return False;\n return all([type(c) == tree for c in t.children])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def is_tree(t):\n if type(t) != list or len(t) < 1:\n return False\n elif is_leaf(t):\n return True\n else:\n return all([is_tree(b) for b in t[1:]])","def test01(self):\n\n t = tree(\"a\", [tree(\"b\"), tree(\"c\")]);\n self.assertTrue(self.isTree(t))","def test_tree_with_one_node_has_correct_value(one_t):\n assert one_t.root.value == 10","def check_tree_type(tree):\n return tree.type in ref","def is_tree(tree):\n\n if type(tree) != list or len(tree) < 1:\n return False\n for branch in branches(tree):\n if not is_tree(branch):\n return False\n return True","def testTree(self, valid):\n return testTreeF(self, valid)","def is_tree(tree):\n if type(tree) != list or len(tree) < 1:\n return False\n for branch in branches(tree):\n if not is_tree(branch):\n return False\n return True","def test_tree_with_one_node_root_exists(one_t):\n assert one_t.root","def is_tree(G: \"Graph\"):\n return len(G.edges) == len(G.vertices) - 1","def test_tree_with_one_node_root_no_children(one_t):\n assert not one_t.root.left\n assert not one_t.root.right","def test_Tree():","def test_tree_two_nodes_left_has_depth_one(one_t):\n one_t.insert(5)\n assert one_t.depth() == 1","def test_tree_initiates_with_empty_root(empty_t):\n assert not empty_t.root","def test04(self):\n\n s = \"a;\"\n t = parse_newick(s);\n self.assertTrue(self.isTree(t) and t.label == \"a\" and t.isLeaf())","def test_small_tree_has_no_root(small_tree):\n assert small_tree.root.left is None","def test_tree_two_nodes_right(one_t):\n one_t.insert(5)\n assert one_t.depth() == 1","def test_left_sided_tree_with_two_nodes_root_has_child(empty_t):\n empty_t.insert(10)\n empty_t.insert(5)\n assert empty_t.root.left\n assert not empty_t.root.right","def test_minimal_tree_creation():\n t = Tree(None)\n\n assert t.data is None\n assert t.parent is None\n assert len(t) == 0","def __is_tree_node(self, node):\n if not node.input:\n if len(node.output) > 1:\n return False\n\n if len(node.output) > 1:\n return False\n\n for input_node in node.input:\n cls = self.__is_tree_node(input_node)\n if not cls:\n return False\n return True","def test_small_tree_has_root_value(small_tree):\n assert small_tree.root.right.value == 11","def tree_contains(T, x):","def bad_tree():\n t = graph.oval_graph.OvalNode(\n 1, \"value\", \"true\", False, [\n graph.oval_graph.OvalNode(\n 2, \"operator\", \"and\", False, [\n graph.oval_graph.OvalNode(\n 3, \"value\", \"true\", False)])])\n return","def test_empty_tree_depth(empty_t):\n assert empty_t.depth() == \"Empty tree has no depth.\"","def test_tree_one_node_has_depth_zero(one_t):\n assert one_t.depth() == 0","def test_markAsTree(self):\n x = t.Rule(\"foo\", t.List(\n t.Exactly(\"x\")))\n g = t.Grammar(\"TestGrammar\", True, [x])\n self.assertIn(\"\\n tree = True\\n\", writePython(g))","def test_small_tree_has_right_child_child(small_tree):\n assert small_tree.root.right.right.value == 27","def tree_type_checker(*ref):\n ref = tuple(ref)\n if len(ref) == 1 and isinstance(ref[0], tuple):\n # if `ref` is passed as a tuple of types\n ref = ref[0]\n # validate that all values are of NeuriteType\n for t in ref:\n NeuriteType(t)\n if NeuriteType.all in ref:\n def check_tree_type(_):\n \"\"\"Always returns true.\"\"\"\n return True\n else:\n def check_tree_type(tree):\n \"\"\"Check whether tree has the same type as ref.\n\n Returns:\n True if ref in the same type as tree.type or ref is NeuriteType.all\n \"\"\"\n return tree.type in ref\n\n return check_tree_type","def validate_tree(self, treenum, tree, halonum=None):\n # Check size\n if treenum == -1:\n nhalos = self.totnhalos\n halonum = None\n else:\n if halonum is not None:\n nhalos = 1\n else:\n nhalos = self.nhalos_per_tree[treenum]\n fields = list(tree.keys())\n for k in fields:\n assert (len(tree[k]) == nhalos)\n # Check fields\n for k in self.raw_fields:\n assert (k in fields)\n # Don't check tree indices for a single halo\n if halonum is not None:\n return\n # For all trees get list of local nhalos for every halo\n if treenum == -1:\n treenum_arr = self.treenum_arr\n nhalos = self.nhalos_per_tree[treenum_arr]\n # Check that halos are within tree\n for k in halo_fields:\n assert ((tree[k] < nhalos).all())\n # Check FOF central exists and all subs in one snapshot\n central = tree['FirstHaloInFOFgroup']\n assert ((central >= 0).all())\n if treenum == -1:\n central = self.get_total_index(treenum_arr, central)\n assert ((tree['SnapNum'] == tree['SnapNum'][central]).all())\n # Check that progenitors/descendants are back/forward in time\n descend = tree['Descendant'].astype('i4')\n has_descend = (descend >= 0)\n not_descend = np.logical_not(has_descend)\n # Not strictly True\n # assert ((tree['SnapNum'][not_descend] ==\n # (len(self.scale_factors) - 1)).all())\n if treenum == -1:\n descend = self.get_total_index(treenum_arr, descend)\n assert ((tree['SnapNum'][descend[has_descend]] >\n tree['SnapNum'][has_descend]).all())\n # Check progenitors are back in time\n descend[not_descend] = np.where(not_descend)[0]\n progen1 = tree['FirstProgenitor']\n progen2 = tree['NextProgenitor']\n has_progen1 = (progen1 >= 0)\n has_progen2 = (progen2 >= 0)\n if treenum == -1:\n progen1 = self.get_total_index(treenum_arr, progen1)\n progen2 = self.get_total_index(treenum_arr, progen2)\n assert ((tree['SnapNum'][progen1[has_progen1]] <=\n tree['SnapNum'][descend[has_progen1]]).all())\n assert ((tree['SnapNum'][progen2[has_progen2]] <=\n tree['SnapNum'][descend[has_progen2]]).all())","def test_right_sided_tree_with_two_nodes_root_has_child(empty_t):\n empty_t.insert(10)\n empty_t.insert(15)\n assert empty_t.root.right\n assert not empty_t.root.left","def valid_tree(phi):\n q = deque([phi]) # queue of nodes to check\n visited = list() # already checked\n\n # save the indim of the root node, and make sure all the indims\n # of the children are the same\n indim = phi.indim\n retval = True\n varsfound = 0\n\n while len(q) > 0:\n # node to check\n node = q.popleft()\n\n # check outdim\n if isinstance(node, amnet.Variable):\n retval &= (node.outdim == node.indim)\n varsfound += 1\n elif isinstance(node, amnet.Linear):\n m, n = node.w.shape\n retval &= (node.outdim == m)\n retval &= (node.x.outdim == n)\n retval &= (all([bi == 0 for bi in node.b])) # check value\n elif isinstance(node, amnet.Constant):\n retval &= (node.outdim == len(node.b))\n retval &= (all([wij == 0 for wij in np.nditer(node.w)])) # check value\n elif isinstance(node, amnet.Affine):\n m, n = node.w.shape\n retval &= (node.outdim == m)\n retval &= (node.x.outdim == n)\n retval &= (m == len(node.b))\n elif isinstance(node, amnet.Mu):\n retval &= (node.outdim == node.x.outdim)\n retval &= (node.outdim == node.y.outdim)\n retval &= (node.z.outdim == 1)\n elif isinstance(node, amnet.Stack):\n retval &= (node.outdim == node.x.outdim + node.y.outdim)\n else:\n retval = False # unknown node type\n\n # check indim\n retval &= (node.indim == indim)\n\n # short-circuit if an inconsistency has been found\n if not retval:\n return False\n\n # add children to queue\n if not(any(node is e for e in visited)):\n visited.append(node)\n #q.extend(children(node))\n q.extend([c for c in children(node) if c not in visited])\n\n # finished iterating\n # TODO: also check if graph is cyclic\n return (varsfound == 1)","def test_list_passed_as_iterable():\n tree = Tree([10, 5, 100])\n assert tree.root.value == 10\n assert tree.root.left.value == 5\n assert tree.root.right.value == 100","def test_tree_support(self):\r\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\r\n \"\"\"\r\n /-------.5 /-a\r\n ---1| \\-b\r\n \\------.5 /-c\r\n \\-d\r\n \"\"\"\r\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\r\n\r\n tc.tree_support(master_tree, t2)\r\n assert_almost_equal(\r\n master_tree.getNodeMatchingName('rt').bootstrap_support, 1.0)","def test_children_tree(depth_one_tree):\n assert str(depth_one_tree.root.children) == str([1, 2, 3, 4])","def validate(tree):\n return rvalidate(tree.root, None, None, None, None, 0, set())","def is_tree(graph):\n ccs = connect_component_search(graph)\n edges = number_of_edges(graph)\n if ccs == 1 and edges == len(graph) - 1:\n return True\n return False","def test_root_value(small_tree):\n assert small_tree.root.value == 3","def test_empty_tree_contains(empty_t):\n empty_t.contains(1) == \"An empty tree has no values.\"","def is_valid_tree(node: TreeNode | None) -> bool:\n if node is None:\n return True\n\n if not isinstance(node, TreeNode):\n return False\n\n try:\n float(node.data)\n except (TypeError, ValueError):\n return False\n\n return is_valid_tree(node.left) and is_valid_tree(node.right)","def test_tuple_passed_as_iterable():\n tree = Tree((10, 5, 100))\n assert tree.root.value == 10\n assert tree.root.left.value == 5\n assert tree.root.right.value == 100","def complete(t):\n def cmplt(t):\n \"\"\"\n Helper func that is called recursively\n Calculates the height and checks for binary validity\n Pre-conditions:\n t: The tree to be checked\n Returns\n (Boolean, Int) Tuple representing the validity and height of the tree\n \"\"\"\n # Hit bottom of tree\n if t is None:\n return (True, 0)\n # Compare lengths of deeper segments\n else:\n bin1, ldepth = cmplt(t.left)\n bin2, rdepth = cmplt(t.right)\n if ldepth == rdepth and bin1 and bin2:\n return (True, rdepth + 1)\n else:\n return (False, rdepth + 1)\n\n # Run helper on tree, check for height\n bal, h = cmplt(t)\n if bal and h > 0:\n return True\n return False","def isNodeType(self, t):\n return isinstance(self, t)","def test02(self):\n\n t = tree(\"a\", [tree(\"b\"), tree(\"c\")]);\n self.assertEqual(len(t), 3)","def _validate_tree(self, base_node):\n if base_node.node_id not in self.nodes:\n print(\"Base node id %s not in nodes\" % base_node.node_id)\n return False, []\n if not base_node.is_valid():\n print(\"Base node %s not valid\" % base_node.node_id)\n return False, []\n if base_node.is_leaf():\n return True, [base_node.node_id]\n if (base_node.right_child is not None and\n base_node.right_child.node_id not in self.nodes.keys()):\n print(\n \"Right child id %s not in nodes\" % base_node.right_child.node_id\n + str(base_node)\n )\n return False, []\n if (base_node.left_child is not None and\n base_node.left_child.node_id not in self.nodes.keys()):\n print(\n \"Left child id %s not in nodes\" % base_node.left_child.node_id\n + str(base_node)\n )\n return False, []\n\n right_child = base_node.right_child\n left_child = base_node.left_child\n right_valid = True\n left_valid = True\n right_visited_nodes = []\n left_visited_nodes = []\n if right_child is not None:\n right_valid, right_visited_nodes = self._validate_tree(right_child)\n if not right_valid:\n print(\"At node %s right tree is invalid\" % base_node.node_id)\n return False, []\n\n if left_child is not None:\n left_valid, left_visited_nodes = self._validate_tree(left_child)\n if not left_valid:\n print(\"At node %s left tree is invalid\" % base_node.node_id)\n return False, []\n visited_nodes = ([base_node.node_id] + right_visited_nodes +\n left_visited_nodes)\n return True, visited_nodes","def test_tree_binary_tree() -> None:\n t = generate_binary_tree_resources(4, 3)\n field(t, (\"root\", \"ds\", \"f1\")).identity = \"email\"\n field(t, (\"root.0.1.0\", \"ds.0.1.0\", \"f1\")).identity = \"ssn\"\n field(t, (\"root.1.1\", \"ds.1.1\", \"f1\")).identity = \"user_id\"\n assert generate_traversal({\"email\": \"X\"}, *t)\n assert generate_traversal({\"ssn\": \"X\"}, *t)\n assert generate_traversal({\"user_id\": \"X\"}, *t)","def test_is_leaf(self):\n self.assertEqual(True, comparator.is_leaf(None))\n self.assertEqual(True, comparator.is_leaf(True))\n self.assertEqual(True, comparator.is_leaf(False))\n self.assertEqual(True, comparator.is_leaf(int()))\n self.assertEqual(True, comparator.is_leaf(str()))\n self.assertEqual(False, comparator.is_leaf(list()))\n self.assertEqual(False, comparator.is_leaf(dict()))","def check_subtree(node):\r\n if node:\r\n node_loc = node.location\r\n self.assertFalse(\r\n modulestore().has_item(node_loc.version_agnostic())\r\n )\r\n self.assertTrue(modulestore().has_item(node_loc.course_agnostic()))\r\n if node.has_children:\r\n for sub in node.get_children():\r\n check_subtree(sub)","def checkTree(bug, tree, pattern):\n\t\n\tname1, elems = tree\n\tif (callable(pattern[0]) and pattern[0](name1, elems)) or pattern[0] == name1:\n\t\tif 1 == len(pattern):\n\t\t\traise AssertionError(bug)\n\t\telif elems is not None:\n\t\t\tfor e in elems:\n\t\t\t\tcheckTree(bug, e, pattern[1:])\n\telif elems is not None:\n\t\tfor e in elems:\n\t\t\tif type(e) is tuple:\n\t\t\t\tcheckTree(bug, e, pattern)","def CheckLeafType(leaf):\n if leaf not in ['upper', 'lower', 'both']:\n raise ValueError()\n return leaf","def test_depth(known_bst):\n assert known_bst[0].depth() == 3","def test_render_tree(self) -> None:\n\n def get_children(node):\n return node.children\n\n node, expect, withtags = self.tree_case_1()\n actual = render_tree(node, get_children)\n assert expect == actual, (expect, actual)\n\n node, expect, withtags = self.tree_case_2()\n actual = render_tree(node, get_children, 1)\n assert expect == actual, (expect, actual)\n\n # Ensure that we can call render_tree on the same Node\n # again. This wasn't possible in version 2.4.1 and earlier\n # due to a bug in render_tree (visited was set to {} as default\n # parameter)\n actual = render_tree(node, get_children, 1)\n assert expect == actual, (expect, actual)","def test_binarytree_exists():\n assert BinaryTree","def test_inset(depth_one_tree):\n depth_one_tree.insert(2, 3)\n print(depth_one_tree.root.children[0].children)\n print(depth_one_tree.root.children[1].children)\n print(depth_one_tree.root.children[2].children)\n print(depth_one_tree.root.children[3].children)\n assert str(depth_one_tree.root.children[2].children) == str([2])","def assert_parse_tree (code, expected):\n tranql = TranQL ()\n tranql.resolve_names = False\n actual = tranql.parser.parse (code).parse_tree\n #print (f\"{actual}\")\n assert_lists_equal (\n actual,\n expected)","def is_leaf(tree):\n return not branches(tree)","def is_leaf(tree):\n\n return not branches(tree)","def is_root(self, p):\n return self.root() == p","def tree(xt, yt, t):\n green = (1, 50, 32) # leaf color\n\n rect(screen, (150, 75, 0), (xt, yt, 15 * t, 60 * t), 0) # tree's trunk\n circle(screen, green, (xt + 15 * t / 2, yt - 30 * t), 30 * t) # leaves\n circle(screen, green, (xt + 15 * t / 2 + 30 * t, yt - 30 * t + 15 * t), 30 * t) # leaves\n circle(screen, green, (xt + 15 * t / 2 - 30 * t, yt - 30 * t + 15 * t), 30 * t) # leaves\n circle(screen, green, (xt + 15 * t / 2 + 30 * t, yt - 30 * t - 20 * t), 30 * t) # leaves\n circle(screen, green, (xt + 15 * t / 2 - 30 * t, yt - 30 * t - 20 * t), 30 * t) # leaves\n circle(screen, green, (xt + 15 * t / 2, yt - 30 * t - 50 * t), 30 * t) # leaves","def test_tree_balace_root():\n result = balance.generate_tree('test_input.txt')\n expected = 'tknk'\n\n assert expected == result['root'][0]","def test_binarytree_instantiate_single_value():\n b = BinaryTree(42)\n assert isinstance(b, BinaryTree)","def test_empty_tree(height_one_tree):\n assert height_one_tree.root.val is 0","def test_tree_with_one_leaf_node_right_of_left_depth(balanced_3_nodes):\n balanced_3_nodes.insert(8)\n assert balanced_3_nodes.depth() == 2","def cast_ltree(s, cur):\n if s is not None:\n return Ltree(s)","def test_root_large_tree_value(large_tree):\n assert large_tree.root.value == 11","def test_bst_single_node():\n assert BST(1).root is None","def bad_tree():\n return OvalNode(\n node_id=1,\n node_type=\"value\",\n value=\"true\",\n children=[\n OvalNode(\n node_id=2,\n node_type=\"operator\",\n value=\"and\",\n children=[\n OvalNode(\n node_id=3,\n node_type=\"value\",\n value=\"true\",\n ),\n ]\n ),\n ]\n )","def is_leaf(node):\n return node.children == {}","def binary_tree():\n\n class Node(object):\n def __init__(self, data):\n self.left = None\n self.right = None\n self.data = data\n\n # Create a root\n root = Node(data=1)\n root.left = Node(data=2)\n root.right = Node(data=3)\n root.left.left = Node(data=4)\n \"\"\" Structure\n 1 <-- root\n / \\\n 2 3 \n / \n 4\n \"\"\"","def find_tree(sv, subtree, tree=Special):\r\n if tree is None: return False\r\n # scan all program\r\n if tree==Special:\r\n for nam in sv.Object_list: \r\n nod=sv.Object[nam]\r\n for c,v in nod.clauses: # scan clauses\r\n if find_tree(sv, subtree, c): return True # recurse on condition\r\n if find_tree(sv, subtree, v): return True # recurse on condition\r\n return False\r\n\r\n # explore a branch \r\n if tree==subtree: return True\r\n O,A,B=tree \r\n if O==Comma: # special case: list\r\n for x in A:\r\n if find_tree(sv, subtree, x): return True # recurse on each element\r\n else:\r\n if find_tree(sv, subtree, A): return True # recurse on first term\r\n if find_tree(sv, subtree, B): return True # recurse on second term\r\n return False","def test_buildTree(self):\r\n root = buildTree()\r\n assert root.getchildren()[0].getchildren()[0].attrib['id'] == 'c-test_crisis'\r\n assert root.getchildren()[1].getchildren()[0].attrib['id'] == 'o-test_org'\r\n assert root.getchildren()[2].getchildren()[0].attrib['id'] == 'p-algore'","def test_instantiate_gets_correct_root_and_root_pointers():\n input = [13, 42, 7]\n c = BinaryTree(input)\n root_repr = repr(c.root)\n expected_root_repr = '<Node | Val: 13 | Data: None | Left: 7 | Right: 42>'\n assert root_repr == expected_root_repr","def test_val_root_filled_tree(depth_one_tree):\n assert depth_one_tree.root.val is 0","def test_depth_returns_correct_value_left_balanced_tree(bst_all_to_left):\n assert bst_all_to_left.depth() == 3","def test_binarytree_instantiate_null():\n b = BinaryTree()\n assert isinstance(b, BinaryTree)","def test_left_rotation_three_node_tree_including_root():\n from bbst import Bst\n tree = Bst([3, 4, 5])\n assert tuple(tree.in_order()) == (3, 4, 5)\n assert tuple(tree.breadth_first()) == (4, 3, 5)\n assert tuple(tree.pre_order()) == (4, 3, 5)\n assert tuple(tree.post_order()) == (3, 5, 4)\n assert tree.depth() == 2\n assert tree.balance() == 0","def test_tree_with_one_leaf_node_left_of_right_depth(balanced_3_nodes):\n balanced_3_nodes.insert(13)\n assert balanced_3_nodes.depth() == 2","def print_tree(t):\r\n if (t==None):\r\n return \r\n else:\r\n print_tree(left(t))\r\n print(value(t),end=\" \")\r\n print_tree(right(t))","def test_address_to_tree(self):\n pass","def test_left_rotation_four_node_tree():\n from bbst import Bst\n tree = Bst([1, 2, 3, 4, 5])\n assert tuple(tree.in_order()) == (1, 2, 3, 4, 5)\n assert tuple(tree.breadth_first()) == (2, 1, 4, 3, 5)\n assert tuple(tree.pre_order()) == (2, 1, 4, 3, 5)\n assert tuple(tree.post_order()) == (1, 3, 5, 4, 2)\n assert tree.depth() == 3\n assert tree.balance() == 1","def IsLeaf(self):\n return not self.subtests","def test_TypicalTree(self):\n\n self.bst.insert(10,1)\n self.bst.insert(10,2)\n \n self.bst.insert(5,2)\n \n self.bst.insert(20,3)\n self.bst.insert(20,4)\n \n self.bst.insert(3,4)\n self.bst.insert(7,5)\n self.bst.insert(15,6)\n self.bst.insert(14,7)\n self.bst.insert(25,8)\n\n self.bst.insert(5,123)\n self.bst.insert(14,456)\n\n self.assertEqual(findMaxDepthDFS(self.bst.root), 3)\n self.assertEqual(findMaxDepthBFS(self.bst.root), 3)","def test_balanced_tree_with_3_nodes_has_depth_one(balanced_3_nodes):\n assert balanced_3_nodes.depth() == 1","def test_tree_2_nodes_left_unbalanced(one_t):\n one_t.insert(9)\n assert one_t.balance() == 1","def test_binarytree_instantiate_given(given_list):\n assert isinstance(given_list, BinaryTree)","def valid_field_in_tree(arch, **kwargs):\n return all(\n child.tag in ('field', 'button', 'control', 'groupby')\n for child in arch.xpath('/tree/*')\n )","def test_root():\n gnroot = 's51001'\n root = germanet_data.get_synset_by_id(gnroot)\n np.testing.assert_equal(root.is_root(), True)\n np.testing.assert_equal(root.is_leaf(), False)","def test_binarytree_in_order_exists():\n assert BinaryTree.in_order","def test_insert_no_parent(tree):\n with pytest.raises(ValueError):\n assert tree.insert(1)","def test_tree_mode2(self):\n xpb = XPathBuilder()\n xp = xpb.foo.bar\n xp.tree_mode(True, xp)\n bar = xpb.bar\n bar.tree_mode(True, xp)\n baz = xpb.baz\n baz.tree_mode(True, xp)\n foo_bar = xpb.foo.bar\n foo_bar.tree_mode(True, xp)\n self.assertTrue(xp.is_tree_mode())\n l = [bar, foo_bar, xp, baz]\n self.assertTrue(xp in l)\n l.remove(xp)\n self.assertTrue(len(l) == 3)\n self.assertFalse(xp in l)\n xp.tree_mode(False, xp)\n self.assertFalse(xp.is_tree_mode())","def __insert_tree(self, t):\n\t\tif not t:\n\t\t\treturn\n\t\tif t.value > self.value:\n\t\t\tif self.right == None:\n\t\t\t\tself.right = t\n\t\t\telse:\n\t\t\t\tself.right.__insert_tree(t)\n\t\telif t.value < self.value:\n\t\t\tif self.left == None:\n\t\t\t\tself.left = t\n\t\t\telse:\n\t\t\t\tself.left.__insert_tree(t)","def test03(self):\n\n t = tree(\"a\");\n s = str(t)\n self.assertEqual(re.sub(\"\\s+\", \"\", s), \"a;\") # Remove spaces and test equality","def test_tree_intersection_name_exists():\n assert tree_intersection","def test_leafs():\n leafs = ['s6675', 's136315', 's10765', 's106594', 's131']\n for leaf in leafs:\n synset = germanet_data.get_synset_by_id(leaf)\n np.testing.assert_equal(synset.is_root(), False)\n np.testing.assert_equal(synset.is_leaf(), True)","def test_set_passed_as_iterable():\n tree = Tree([10, 5, 100])\n assert tree.root.value == 10\n assert tree.root.left.value == 5\n assert tree.root.right.value == 100","def is_subtree(t1, t2):\r\n if t2.root is None:\r\n # Empty tree always a subtree.\r\n return True\r\n elif t1.root is None:\r\n return False\r\n return subtree(t1.root, t2.root)","def checkTree(self, root):\n\t\tif len(self.graph.nodes()) > 100: # TODO why this arbitrary limit on the size of the tree?\n\t\t\tNJTree.logger.debug(\"Too big graph detected and arbitrarly split\")\n\t\t\tself.OK = \"false\"\n\t\t\treturn self.OK\n\t\t# check species of root node neighbors\n\t\tedge = root[1]\n# \t\tloss = root[2]\n\t\tset_species = set([])\n\t\tspecies = []\n# \t\tedge_weight = self.graph[edge[0]][edge[1]]['homology_weight']\n\t\t# TODO what is the point of having twice the results?\n\t\tset_species.add(self.rootedTree.node[edge[0]]['species'])\n\t\tset_species.add(self.rootedTree.node[edge[1]]['species'])\n\t\tspecies.append(self.rootedTree.node[edge[0]]['species'])\n\t\tspecies.append(self.rootedTree.node[edge[1]]['species'])\n\t\tif len(species) == 1 or len(set_species) == 1 and (self.mrca not in set_species):\n\t\t\t# all leaf nodes get added to orphan pile\n\t\t\t# NJTree.logger.debug(\"Orphan in checkTree still happens\")\n\t\t\tself.OK = \"orphan\"\n\t\t\treturn self.OK\n\t\tif len(species) == 2:\n\t\t\tif self.mrca in species:\n\t\t\t\tself.OK = \"false\"\n\t\t\t\treturn self.OK\n\t\t\telse:\n\t\t\t\tself.OK = \"true\"\n\t\t\t\treturn self.OK\n\t\t# should add a verification that there are no more than 2 species","def test_validate_valid_person(self):\r\n assert self.person_tree != 0","def test_cannot_operate_on_rootless():\n builder = TreeBuilder()\n\n with pytest.raises(ValueError):\n builder.move_to_root()\n\n with pytest.raises(ValueError):\n builder.move_to_parent()\n\n with pytest.raises(ValueError):\n builder.build()","def isLeaf(node):\n\n return node.left is None and node.right is None","def test_on_copy_not_on_root():\n builder = TreeBuilder()\n builder.create_root(0)\n builder.add_child(5)\n builder.add_child(6, move=True)\n\n _ = builder.build()\n builder.add_child(7)\n\n t = builder.build()\n assert_tree_structure(t, {(): 0, (0, ): 5, (1, ): 6, (1, 0): 7})","def test_instantiate_six_nodes():\n input = [13, 42, 7, 3, 9, 99]\n six = BinaryTree(input)\n assert isinstance(six, BinaryTree)"],"string":"[\n \"def is_tree(t):\\n if type(t) != list or len(t) < 1:\\n return False\\n elif is_leaf(t):\\n return True\\n else:\\n return all([is_tree(b) for b in t[1:]])\",\n \"def test01(self):\\n\\n t = tree(\\\"a\\\", [tree(\\\"b\\\"), tree(\\\"c\\\")]);\\n self.assertTrue(self.isTree(t))\",\n \"def test_tree_with_one_node_has_correct_value(one_t):\\n assert one_t.root.value == 10\",\n \"def check_tree_type(tree):\\n return tree.type in ref\",\n \"def is_tree(tree):\\n\\n if type(tree) != list or len(tree) < 1:\\n return False\\n for branch in branches(tree):\\n if not is_tree(branch):\\n return False\\n return True\",\n \"def testTree(self, valid):\\n return testTreeF(self, valid)\",\n \"def is_tree(tree):\\n if type(tree) != list or len(tree) < 1:\\n return False\\n for branch in branches(tree):\\n if not is_tree(branch):\\n return False\\n return True\",\n \"def test_tree_with_one_node_root_exists(one_t):\\n assert one_t.root\",\n \"def is_tree(G: \\\"Graph\\\"):\\n return len(G.edges) == len(G.vertices) - 1\",\n \"def test_tree_with_one_node_root_no_children(one_t):\\n assert not one_t.root.left\\n assert not one_t.root.right\",\n \"def test_Tree():\",\n \"def test_tree_two_nodes_left_has_depth_one(one_t):\\n one_t.insert(5)\\n assert one_t.depth() == 1\",\n \"def test_tree_initiates_with_empty_root(empty_t):\\n assert not empty_t.root\",\n \"def test04(self):\\n\\n s = \\\"a;\\\"\\n t = parse_newick(s);\\n self.assertTrue(self.isTree(t) and t.label == \\\"a\\\" and t.isLeaf())\",\n \"def test_small_tree_has_no_root(small_tree):\\n assert small_tree.root.left is None\",\n \"def test_tree_two_nodes_right(one_t):\\n one_t.insert(5)\\n assert one_t.depth() == 1\",\n \"def test_left_sided_tree_with_two_nodes_root_has_child(empty_t):\\n empty_t.insert(10)\\n empty_t.insert(5)\\n assert empty_t.root.left\\n assert not empty_t.root.right\",\n \"def test_minimal_tree_creation():\\n t = Tree(None)\\n\\n assert t.data is None\\n assert t.parent is None\\n assert len(t) == 0\",\n \"def __is_tree_node(self, node):\\n if not node.input:\\n if len(node.output) > 1:\\n return False\\n\\n if len(node.output) > 1:\\n return False\\n\\n for input_node in node.input:\\n cls = self.__is_tree_node(input_node)\\n if not cls:\\n return False\\n return True\",\n \"def test_small_tree_has_root_value(small_tree):\\n assert small_tree.root.right.value == 11\",\n \"def tree_contains(T, x):\",\n \"def bad_tree():\\n t = graph.oval_graph.OvalNode(\\n 1, \\\"value\\\", \\\"true\\\", False, [\\n graph.oval_graph.OvalNode(\\n 2, \\\"operator\\\", \\\"and\\\", False, [\\n graph.oval_graph.OvalNode(\\n 3, \\\"value\\\", \\\"true\\\", False)])])\\n return\",\n \"def test_empty_tree_depth(empty_t):\\n assert empty_t.depth() == \\\"Empty tree has no depth.\\\"\",\n \"def test_tree_one_node_has_depth_zero(one_t):\\n assert one_t.depth() == 0\",\n \"def test_markAsTree(self):\\n x = t.Rule(\\\"foo\\\", t.List(\\n t.Exactly(\\\"x\\\")))\\n g = t.Grammar(\\\"TestGrammar\\\", True, [x])\\n self.assertIn(\\\"\\\\n tree = True\\\\n\\\", writePython(g))\",\n \"def test_small_tree_has_right_child_child(small_tree):\\n assert small_tree.root.right.right.value == 27\",\n \"def tree_type_checker(*ref):\\n ref = tuple(ref)\\n if len(ref) == 1 and isinstance(ref[0], tuple):\\n # if `ref` is passed as a tuple of types\\n ref = ref[0]\\n # validate that all values are of NeuriteType\\n for t in ref:\\n NeuriteType(t)\\n if NeuriteType.all in ref:\\n def check_tree_type(_):\\n \\\"\\\"\\\"Always returns true.\\\"\\\"\\\"\\n return True\\n else:\\n def check_tree_type(tree):\\n \\\"\\\"\\\"Check whether tree has the same type as ref.\\n\\n Returns:\\n True if ref in the same type as tree.type or ref is NeuriteType.all\\n \\\"\\\"\\\"\\n return tree.type in ref\\n\\n return check_tree_type\",\n \"def validate_tree(self, treenum, tree, halonum=None):\\n # Check size\\n if treenum == -1:\\n nhalos = self.totnhalos\\n halonum = None\\n else:\\n if halonum is not None:\\n nhalos = 1\\n else:\\n nhalos = self.nhalos_per_tree[treenum]\\n fields = list(tree.keys())\\n for k in fields:\\n assert (len(tree[k]) == nhalos)\\n # Check fields\\n for k in self.raw_fields:\\n assert (k in fields)\\n # Don't check tree indices for a single halo\\n if halonum is not None:\\n return\\n # For all trees get list of local nhalos for every halo\\n if treenum == -1:\\n treenum_arr = self.treenum_arr\\n nhalos = self.nhalos_per_tree[treenum_arr]\\n # Check that halos are within tree\\n for k in halo_fields:\\n assert ((tree[k] < nhalos).all())\\n # Check FOF central exists and all subs in one snapshot\\n central = tree['FirstHaloInFOFgroup']\\n assert ((central >= 0).all())\\n if treenum == -1:\\n central = self.get_total_index(treenum_arr, central)\\n assert ((tree['SnapNum'] == tree['SnapNum'][central]).all())\\n # Check that progenitors/descendants are back/forward in time\\n descend = tree['Descendant'].astype('i4')\\n has_descend = (descend >= 0)\\n not_descend = np.logical_not(has_descend)\\n # Not strictly True\\n # assert ((tree['SnapNum'][not_descend] ==\\n # (len(self.scale_factors) - 1)).all())\\n if treenum == -1:\\n descend = self.get_total_index(treenum_arr, descend)\\n assert ((tree['SnapNum'][descend[has_descend]] >\\n tree['SnapNum'][has_descend]).all())\\n # Check progenitors are back in time\\n descend[not_descend] = np.where(not_descend)[0]\\n progen1 = tree['FirstProgenitor']\\n progen2 = tree['NextProgenitor']\\n has_progen1 = (progen1 >= 0)\\n has_progen2 = (progen2 >= 0)\\n if treenum == -1:\\n progen1 = self.get_total_index(treenum_arr, progen1)\\n progen2 = self.get_total_index(treenum_arr, progen2)\\n assert ((tree['SnapNum'][progen1[has_progen1]] <=\\n tree['SnapNum'][descend[has_progen1]]).all())\\n assert ((tree['SnapNum'][progen2[has_progen2]] <=\\n tree['SnapNum'][descend[has_progen2]]).all())\",\n \"def test_right_sided_tree_with_two_nodes_root_has_child(empty_t):\\n empty_t.insert(10)\\n empty_t.insert(15)\\n assert empty_t.root.right\\n assert not empty_t.root.left\",\n \"def valid_tree(phi):\\n q = deque([phi]) # queue of nodes to check\\n visited = list() # already checked\\n\\n # save the indim of the root node, and make sure all the indims\\n # of the children are the same\\n indim = phi.indim\\n retval = True\\n varsfound = 0\\n\\n while len(q) > 0:\\n # node to check\\n node = q.popleft()\\n\\n # check outdim\\n if isinstance(node, amnet.Variable):\\n retval &= (node.outdim == node.indim)\\n varsfound += 1\\n elif isinstance(node, amnet.Linear):\\n m, n = node.w.shape\\n retval &= (node.outdim == m)\\n retval &= (node.x.outdim == n)\\n retval &= (all([bi == 0 for bi in node.b])) # check value\\n elif isinstance(node, amnet.Constant):\\n retval &= (node.outdim == len(node.b))\\n retval &= (all([wij == 0 for wij in np.nditer(node.w)])) # check value\\n elif isinstance(node, amnet.Affine):\\n m, n = node.w.shape\\n retval &= (node.outdim == m)\\n retval &= (node.x.outdim == n)\\n retval &= (m == len(node.b))\\n elif isinstance(node, amnet.Mu):\\n retval &= (node.outdim == node.x.outdim)\\n retval &= (node.outdim == node.y.outdim)\\n retval &= (node.z.outdim == 1)\\n elif isinstance(node, amnet.Stack):\\n retval &= (node.outdim == node.x.outdim + node.y.outdim)\\n else:\\n retval = False # unknown node type\\n\\n # check indim\\n retval &= (node.indim == indim)\\n\\n # short-circuit if an inconsistency has been found\\n if not retval:\\n return False\\n\\n # add children to queue\\n if not(any(node is e for e in visited)):\\n visited.append(node)\\n #q.extend(children(node))\\n q.extend([c for c in children(node) if c not in visited])\\n\\n # finished iterating\\n # TODO: also check if graph is cyclic\\n return (varsfound == 1)\",\n \"def test_list_passed_as_iterable():\\n tree = Tree([10, 5, 100])\\n assert tree.root.value == 10\\n assert tree.root.left.value == 5\\n assert tree.root.right.value == 100\",\n \"def test_tree_support(self):\\r\\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\\r\\n \\\"\\\"\\\"\\r\\n /-------.5 /-a\\r\\n ---1| \\\\-b\\r\\n \\\\------.5 /-c\\r\\n \\\\-d\\r\\n \\\"\\\"\\\"\\r\\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\\r\\n\\r\\n tc.tree_support(master_tree, t2)\\r\\n assert_almost_equal(\\r\\n master_tree.getNodeMatchingName('rt').bootstrap_support, 1.0)\",\n \"def test_children_tree(depth_one_tree):\\n assert str(depth_one_tree.root.children) == str([1, 2, 3, 4])\",\n \"def validate(tree):\\n return rvalidate(tree.root, None, None, None, None, 0, set())\",\n \"def is_tree(graph):\\n ccs = connect_component_search(graph)\\n edges = number_of_edges(graph)\\n if ccs == 1 and edges == len(graph) - 1:\\n return True\\n return False\",\n \"def test_root_value(small_tree):\\n assert small_tree.root.value == 3\",\n \"def test_empty_tree_contains(empty_t):\\n empty_t.contains(1) == \\\"An empty tree has no values.\\\"\",\n \"def is_valid_tree(node: TreeNode | None) -> bool:\\n if node is None:\\n return True\\n\\n if not isinstance(node, TreeNode):\\n return False\\n\\n try:\\n float(node.data)\\n except (TypeError, ValueError):\\n return False\\n\\n return is_valid_tree(node.left) and is_valid_tree(node.right)\",\n \"def test_tuple_passed_as_iterable():\\n tree = Tree((10, 5, 100))\\n assert tree.root.value == 10\\n assert tree.root.left.value == 5\\n assert tree.root.right.value == 100\",\n \"def complete(t):\\n def cmplt(t):\\n \\\"\\\"\\\"\\n Helper func that is called recursively\\n Calculates the height and checks for binary validity\\n Pre-conditions:\\n t: The tree to be checked\\n Returns\\n (Boolean, Int) Tuple representing the validity and height of the tree\\n \\\"\\\"\\\"\\n # Hit bottom of tree\\n if t is None:\\n return (True, 0)\\n # Compare lengths of deeper segments\\n else:\\n bin1, ldepth = cmplt(t.left)\\n bin2, rdepth = cmplt(t.right)\\n if ldepth == rdepth and bin1 and bin2:\\n return (True, rdepth + 1)\\n else:\\n return (False, rdepth + 1)\\n\\n # Run helper on tree, check for height\\n bal, h = cmplt(t)\\n if bal and h > 0:\\n return True\\n return False\",\n \"def isNodeType(self, t):\\n return isinstance(self, t)\",\n \"def test02(self):\\n\\n t = tree(\\\"a\\\", [tree(\\\"b\\\"), tree(\\\"c\\\")]);\\n self.assertEqual(len(t), 3)\",\n \"def _validate_tree(self, base_node):\\n if base_node.node_id not in self.nodes:\\n print(\\\"Base node id %s not in nodes\\\" % base_node.node_id)\\n return False, []\\n if not base_node.is_valid():\\n print(\\\"Base node %s not valid\\\" % base_node.node_id)\\n return False, []\\n if base_node.is_leaf():\\n return True, [base_node.node_id]\\n if (base_node.right_child is not None and\\n base_node.right_child.node_id not in self.nodes.keys()):\\n print(\\n \\\"Right child id %s not in nodes\\\" % base_node.right_child.node_id\\n + str(base_node)\\n )\\n return False, []\\n if (base_node.left_child is not None and\\n base_node.left_child.node_id not in self.nodes.keys()):\\n print(\\n \\\"Left child id %s not in nodes\\\" % base_node.left_child.node_id\\n + str(base_node)\\n )\\n return False, []\\n\\n right_child = base_node.right_child\\n left_child = base_node.left_child\\n right_valid = True\\n left_valid = True\\n right_visited_nodes = []\\n left_visited_nodes = []\\n if right_child is not None:\\n right_valid, right_visited_nodes = self._validate_tree(right_child)\\n if not right_valid:\\n print(\\\"At node %s right tree is invalid\\\" % base_node.node_id)\\n return False, []\\n\\n if left_child is not None:\\n left_valid, left_visited_nodes = self._validate_tree(left_child)\\n if not left_valid:\\n print(\\\"At node %s left tree is invalid\\\" % base_node.node_id)\\n return False, []\\n visited_nodes = ([base_node.node_id] + right_visited_nodes +\\n left_visited_nodes)\\n return True, visited_nodes\",\n \"def test_tree_binary_tree() -> None:\\n t = generate_binary_tree_resources(4, 3)\\n field(t, (\\\"root\\\", \\\"ds\\\", \\\"f1\\\")).identity = \\\"email\\\"\\n field(t, (\\\"root.0.1.0\\\", \\\"ds.0.1.0\\\", \\\"f1\\\")).identity = \\\"ssn\\\"\\n field(t, (\\\"root.1.1\\\", \\\"ds.1.1\\\", \\\"f1\\\")).identity = \\\"user_id\\\"\\n assert generate_traversal({\\\"email\\\": \\\"X\\\"}, *t)\\n assert generate_traversal({\\\"ssn\\\": \\\"X\\\"}, *t)\\n assert generate_traversal({\\\"user_id\\\": \\\"X\\\"}, *t)\",\n \"def test_is_leaf(self):\\n self.assertEqual(True, comparator.is_leaf(None))\\n self.assertEqual(True, comparator.is_leaf(True))\\n self.assertEqual(True, comparator.is_leaf(False))\\n self.assertEqual(True, comparator.is_leaf(int()))\\n self.assertEqual(True, comparator.is_leaf(str()))\\n self.assertEqual(False, comparator.is_leaf(list()))\\n self.assertEqual(False, comparator.is_leaf(dict()))\",\n \"def check_subtree(node):\\r\\n if node:\\r\\n node_loc = node.location\\r\\n self.assertFalse(\\r\\n modulestore().has_item(node_loc.version_agnostic())\\r\\n )\\r\\n self.assertTrue(modulestore().has_item(node_loc.course_agnostic()))\\r\\n if node.has_children:\\r\\n for sub in node.get_children():\\r\\n check_subtree(sub)\",\n \"def checkTree(bug, tree, pattern):\\n\\t\\n\\tname1, elems = tree\\n\\tif (callable(pattern[0]) and pattern[0](name1, elems)) or pattern[0] == name1:\\n\\t\\tif 1 == len(pattern):\\n\\t\\t\\traise AssertionError(bug)\\n\\t\\telif elems is not None:\\n\\t\\t\\tfor e in elems:\\n\\t\\t\\t\\tcheckTree(bug, e, pattern[1:])\\n\\telif elems is not None:\\n\\t\\tfor e in elems:\\n\\t\\t\\tif type(e) is tuple:\\n\\t\\t\\t\\tcheckTree(bug, e, pattern)\",\n \"def CheckLeafType(leaf):\\n if leaf not in ['upper', 'lower', 'both']:\\n raise ValueError()\\n return leaf\",\n \"def test_depth(known_bst):\\n assert known_bst[0].depth() == 3\",\n \"def test_render_tree(self) -> None:\\n\\n def get_children(node):\\n return node.children\\n\\n node, expect, withtags = self.tree_case_1()\\n actual = render_tree(node, get_children)\\n assert expect == actual, (expect, actual)\\n\\n node, expect, withtags = self.tree_case_2()\\n actual = render_tree(node, get_children, 1)\\n assert expect == actual, (expect, actual)\\n\\n # Ensure that we can call render_tree on the same Node\\n # again. This wasn't possible in version 2.4.1 and earlier\\n # due to a bug in render_tree (visited was set to {} as default\\n # parameter)\\n actual = render_tree(node, get_children, 1)\\n assert expect == actual, (expect, actual)\",\n \"def test_binarytree_exists():\\n assert BinaryTree\",\n \"def test_inset(depth_one_tree):\\n depth_one_tree.insert(2, 3)\\n print(depth_one_tree.root.children[0].children)\\n print(depth_one_tree.root.children[1].children)\\n print(depth_one_tree.root.children[2].children)\\n print(depth_one_tree.root.children[3].children)\\n assert str(depth_one_tree.root.children[2].children) == str([2])\",\n \"def assert_parse_tree (code, expected):\\n tranql = TranQL ()\\n tranql.resolve_names = False\\n actual = tranql.parser.parse (code).parse_tree\\n #print (f\\\"{actual}\\\")\\n assert_lists_equal (\\n actual,\\n expected)\",\n \"def is_leaf(tree):\\n return not branches(tree)\",\n \"def is_leaf(tree):\\n\\n return not branches(tree)\",\n \"def is_root(self, p):\\n return self.root() == p\",\n \"def tree(xt, yt, t):\\n green = (1, 50, 32) # leaf color\\n\\n rect(screen, (150, 75, 0), (xt, yt, 15 * t, 60 * t), 0) # tree's trunk\\n circle(screen, green, (xt + 15 * t / 2, yt - 30 * t), 30 * t) # leaves\\n circle(screen, green, (xt + 15 * t / 2 + 30 * t, yt - 30 * t + 15 * t), 30 * t) # leaves\\n circle(screen, green, (xt + 15 * t / 2 - 30 * t, yt - 30 * t + 15 * t), 30 * t) # leaves\\n circle(screen, green, (xt + 15 * t / 2 + 30 * t, yt - 30 * t - 20 * t), 30 * t) # leaves\\n circle(screen, green, (xt + 15 * t / 2 - 30 * t, yt - 30 * t - 20 * t), 30 * t) # leaves\\n circle(screen, green, (xt + 15 * t / 2, yt - 30 * t - 50 * t), 30 * t) # leaves\",\n \"def test_tree_balace_root():\\n result = balance.generate_tree('test_input.txt')\\n expected = 'tknk'\\n\\n assert expected == result['root'][0]\",\n \"def test_binarytree_instantiate_single_value():\\n b = BinaryTree(42)\\n assert isinstance(b, BinaryTree)\",\n \"def test_empty_tree(height_one_tree):\\n assert height_one_tree.root.val is 0\",\n \"def test_tree_with_one_leaf_node_right_of_left_depth(balanced_3_nodes):\\n balanced_3_nodes.insert(8)\\n assert balanced_3_nodes.depth() == 2\",\n \"def cast_ltree(s, cur):\\n if s is not None:\\n return Ltree(s)\",\n \"def test_root_large_tree_value(large_tree):\\n assert large_tree.root.value == 11\",\n \"def test_bst_single_node():\\n assert BST(1).root is None\",\n \"def bad_tree():\\n return OvalNode(\\n node_id=1,\\n node_type=\\\"value\\\",\\n value=\\\"true\\\",\\n children=[\\n OvalNode(\\n node_id=2,\\n node_type=\\\"operator\\\",\\n value=\\\"and\\\",\\n children=[\\n OvalNode(\\n node_id=3,\\n node_type=\\\"value\\\",\\n value=\\\"true\\\",\\n ),\\n ]\\n ),\\n ]\\n )\",\n \"def is_leaf(node):\\n return node.children == {}\",\n \"def binary_tree():\\n\\n class Node(object):\\n def __init__(self, data):\\n self.left = None\\n self.right = None\\n self.data = data\\n\\n # Create a root\\n root = Node(data=1)\\n root.left = Node(data=2)\\n root.right = Node(data=3)\\n root.left.left = Node(data=4)\\n \\\"\\\"\\\" Structure\\n 1 <-- root\\n / \\\\\\n 2 3 \\n / \\n 4\\n \\\"\\\"\\\"\",\n \"def find_tree(sv, subtree, tree=Special):\\r\\n if tree is None: return False\\r\\n # scan all program\\r\\n if tree==Special:\\r\\n for nam in sv.Object_list: \\r\\n nod=sv.Object[nam]\\r\\n for c,v in nod.clauses: # scan clauses\\r\\n if find_tree(sv, subtree, c): return True # recurse on condition\\r\\n if find_tree(sv, subtree, v): return True # recurse on condition\\r\\n return False\\r\\n\\r\\n # explore a branch \\r\\n if tree==subtree: return True\\r\\n O,A,B=tree \\r\\n if O==Comma: # special case: list\\r\\n for x in A:\\r\\n if find_tree(sv, subtree, x): return True # recurse on each element\\r\\n else:\\r\\n if find_tree(sv, subtree, A): return True # recurse on first term\\r\\n if find_tree(sv, subtree, B): return True # recurse on second term\\r\\n return False\",\n \"def test_buildTree(self):\\r\\n root = buildTree()\\r\\n assert root.getchildren()[0].getchildren()[0].attrib['id'] == 'c-test_crisis'\\r\\n assert root.getchildren()[1].getchildren()[0].attrib['id'] == 'o-test_org'\\r\\n assert root.getchildren()[2].getchildren()[0].attrib['id'] == 'p-algore'\",\n \"def test_instantiate_gets_correct_root_and_root_pointers():\\n input = [13, 42, 7]\\n c = BinaryTree(input)\\n root_repr = repr(c.root)\\n expected_root_repr = '<Node | Val: 13 | Data: None | Left: 7 | Right: 42>'\\n assert root_repr == expected_root_repr\",\n \"def test_val_root_filled_tree(depth_one_tree):\\n assert depth_one_tree.root.val is 0\",\n \"def test_depth_returns_correct_value_left_balanced_tree(bst_all_to_left):\\n assert bst_all_to_left.depth() == 3\",\n \"def test_binarytree_instantiate_null():\\n b = BinaryTree()\\n assert isinstance(b, BinaryTree)\",\n \"def test_left_rotation_three_node_tree_including_root():\\n from bbst import Bst\\n tree = Bst([3, 4, 5])\\n assert tuple(tree.in_order()) == (3, 4, 5)\\n assert tuple(tree.breadth_first()) == (4, 3, 5)\\n assert tuple(tree.pre_order()) == (4, 3, 5)\\n assert tuple(tree.post_order()) == (3, 5, 4)\\n assert tree.depth() == 2\\n assert tree.balance() == 0\",\n \"def test_tree_with_one_leaf_node_left_of_right_depth(balanced_3_nodes):\\n balanced_3_nodes.insert(13)\\n assert balanced_3_nodes.depth() == 2\",\n \"def print_tree(t):\\r\\n if (t==None):\\r\\n return \\r\\n else:\\r\\n print_tree(left(t))\\r\\n print(value(t),end=\\\" \\\")\\r\\n print_tree(right(t))\",\n \"def test_address_to_tree(self):\\n pass\",\n \"def test_left_rotation_four_node_tree():\\n from bbst import Bst\\n tree = Bst([1, 2, 3, 4, 5])\\n assert tuple(tree.in_order()) == (1, 2, 3, 4, 5)\\n assert tuple(tree.breadth_first()) == (2, 1, 4, 3, 5)\\n assert tuple(tree.pre_order()) == (2, 1, 4, 3, 5)\\n assert tuple(tree.post_order()) == (1, 3, 5, 4, 2)\\n assert tree.depth() == 3\\n assert tree.balance() == 1\",\n \"def IsLeaf(self):\\n return not self.subtests\",\n \"def test_TypicalTree(self):\\n\\n self.bst.insert(10,1)\\n self.bst.insert(10,2)\\n \\n self.bst.insert(5,2)\\n \\n self.bst.insert(20,3)\\n self.bst.insert(20,4)\\n \\n self.bst.insert(3,4)\\n self.bst.insert(7,5)\\n self.bst.insert(15,6)\\n self.bst.insert(14,7)\\n self.bst.insert(25,8)\\n\\n self.bst.insert(5,123)\\n self.bst.insert(14,456)\\n\\n self.assertEqual(findMaxDepthDFS(self.bst.root), 3)\\n self.assertEqual(findMaxDepthBFS(self.bst.root), 3)\",\n \"def test_balanced_tree_with_3_nodes_has_depth_one(balanced_3_nodes):\\n assert balanced_3_nodes.depth() == 1\",\n \"def test_tree_2_nodes_left_unbalanced(one_t):\\n one_t.insert(9)\\n assert one_t.balance() == 1\",\n \"def test_binarytree_instantiate_given(given_list):\\n assert isinstance(given_list, BinaryTree)\",\n \"def valid_field_in_tree(arch, **kwargs):\\n return all(\\n child.tag in ('field', 'button', 'control', 'groupby')\\n for child in arch.xpath('/tree/*')\\n )\",\n \"def test_root():\\n gnroot = 's51001'\\n root = germanet_data.get_synset_by_id(gnroot)\\n np.testing.assert_equal(root.is_root(), True)\\n np.testing.assert_equal(root.is_leaf(), False)\",\n \"def test_binarytree_in_order_exists():\\n assert BinaryTree.in_order\",\n \"def test_insert_no_parent(tree):\\n with pytest.raises(ValueError):\\n assert tree.insert(1)\",\n \"def test_tree_mode2(self):\\n xpb = XPathBuilder()\\n xp = xpb.foo.bar\\n xp.tree_mode(True, xp)\\n bar = xpb.bar\\n bar.tree_mode(True, xp)\\n baz = xpb.baz\\n baz.tree_mode(True, xp)\\n foo_bar = xpb.foo.bar\\n foo_bar.tree_mode(True, xp)\\n self.assertTrue(xp.is_tree_mode())\\n l = [bar, foo_bar, xp, baz]\\n self.assertTrue(xp in l)\\n l.remove(xp)\\n self.assertTrue(len(l) == 3)\\n self.assertFalse(xp in l)\\n xp.tree_mode(False, xp)\\n self.assertFalse(xp.is_tree_mode())\",\n \"def __insert_tree(self, t):\\n\\t\\tif not t:\\n\\t\\t\\treturn\\n\\t\\tif t.value > self.value:\\n\\t\\t\\tif self.right == None:\\n\\t\\t\\t\\tself.right = t\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.right.__insert_tree(t)\\n\\t\\telif t.value < self.value:\\n\\t\\t\\tif self.left == None:\\n\\t\\t\\t\\tself.left = t\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.left.__insert_tree(t)\",\n \"def test03(self):\\n\\n t = tree(\\\"a\\\");\\n s = str(t)\\n self.assertEqual(re.sub(\\\"\\\\s+\\\", \\\"\\\", s), \\\"a;\\\") # Remove spaces and test equality\",\n \"def test_tree_intersection_name_exists():\\n assert tree_intersection\",\n \"def test_leafs():\\n leafs = ['s6675', 's136315', 's10765', 's106594', 's131']\\n for leaf in leafs:\\n synset = germanet_data.get_synset_by_id(leaf)\\n np.testing.assert_equal(synset.is_root(), False)\\n np.testing.assert_equal(synset.is_leaf(), True)\",\n \"def test_set_passed_as_iterable():\\n tree = Tree([10, 5, 100])\\n assert tree.root.value == 10\\n assert tree.root.left.value == 5\\n assert tree.root.right.value == 100\",\n \"def is_subtree(t1, t2):\\r\\n if t2.root is None:\\r\\n # Empty tree always a subtree.\\r\\n return True\\r\\n elif t1.root is None:\\r\\n return False\\r\\n return subtree(t1.root, t2.root)\",\n \"def checkTree(self, root):\\n\\t\\tif len(self.graph.nodes()) > 100: # TODO why this arbitrary limit on the size of the tree?\\n\\t\\t\\tNJTree.logger.debug(\\\"Too big graph detected and arbitrarly split\\\")\\n\\t\\t\\tself.OK = \\\"false\\\"\\n\\t\\t\\treturn self.OK\\n\\t\\t# check species of root node neighbors\\n\\t\\tedge = root[1]\\n# \\t\\tloss = root[2]\\n\\t\\tset_species = set([])\\n\\t\\tspecies = []\\n# \\t\\tedge_weight = self.graph[edge[0]][edge[1]]['homology_weight']\\n\\t\\t# TODO what is the point of having twice the results?\\n\\t\\tset_species.add(self.rootedTree.node[edge[0]]['species'])\\n\\t\\tset_species.add(self.rootedTree.node[edge[1]]['species'])\\n\\t\\tspecies.append(self.rootedTree.node[edge[0]]['species'])\\n\\t\\tspecies.append(self.rootedTree.node[edge[1]]['species'])\\n\\t\\tif len(species) == 1 or len(set_species) == 1 and (self.mrca not in set_species):\\n\\t\\t\\t# all leaf nodes get added to orphan pile\\n\\t\\t\\t# NJTree.logger.debug(\\\"Orphan in checkTree still happens\\\")\\n\\t\\t\\tself.OK = \\\"orphan\\\"\\n\\t\\t\\treturn self.OK\\n\\t\\tif len(species) == 2:\\n\\t\\t\\tif self.mrca in species:\\n\\t\\t\\t\\tself.OK = \\\"false\\\"\\n\\t\\t\\t\\treturn self.OK\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.OK = \\\"true\\\"\\n\\t\\t\\t\\treturn self.OK\\n\\t\\t# should add a verification that there are no more than 2 species\",\n \"def test_validate_valid_person(self):\\r\\n assert self.person_tree != 0\",\n \"def test_cannot_operate_on_rootless():\\n builder = TreeBuilder()\\n\\n with pytest.raises(ValueError):\\n builder.move_to_root()\\n\\n with pytest.raises(ValueError):\\n builder.move_to_parent()\\n\\n with pytest.raises(ValueError):\\n builder.build()\",\n \"def isLeaf(node):\\n\\n return node.left is None and node.right is None\",\n \"def test_on_copy_not_on_root():\\n builder = TreeBuilder()\\n builder.create_root(0)\\n builder.add_child(5)\\n builder.add_child(6, move=True)\\n\\n _ = builder.build()\\n builder.add_child(7)\\n\\n t = builder.build()\\n assert_tree_structure(t, {(): 0, (0, ): 5, (1, ): 6, (1, 0): 7})\",\n \"def test_instantiate_six_nodes():\\n input = [13, 42, 7, 3, 9, 99]\\n six = BinaryTree(input)\\n assert isinstance(six, BinaryTree)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7773105","0.7650496","0.7045109","0.7035572","0.6966886","0.6953431","0.69326895","0.68154866","0.680478","0.6793031","0.66768706","0.6661258","0.6602542","0.6554972","0.6527791","0.6508529","0.65084046","0.65048134","0.64875036","0.6486214","0.64814633","0.6460768","0.64471906","0.6438607","0.6436119","0.6396226","0.63332444","0.63218683","0.63194776","0.63158107","0.6299398","0.62949854","0.6262381","0.621878","0.62093705","0.6208339","0.62061334","0.61869043","0.618593","0.61544585","0.6143208","0.61383337","0.6134273","0.6129439","0.612689","0.61209995","0.6120072","0.60394084","0.60161686","0.60109824","0.60029894","0.5982014","0.59613216","0.5947317","0.5939911","0.59397984","0.59172064","0.5913383","0.58939475","0.5886605","0.5857848","0.5852477","0.5840933","0.5839463","0.5836529","0.5831133","0.58310395","0.5821022","0.58206856","0.5820584","0.58185667","0.58092827","0.5798193","0.57947606","0.57740414","0.57682323","0.57617396","0.5752947","0.5748744","0.5746001","0.57437587","0.57230103","0.57223195","0.5720325","0.5720153","0.5715686","0.5715128","0.5714134","0.5710466","0.570933","0.57046527","0.5704316","0.56992286","0.569915","0.56986845","0.5691005","0.5670778","0.56688756","0.5657455","0.56552744"],"string":"[\n \"0.7773105\",\n \"0.7650496\",\n \"0.7045109\",\n \"0.7035572\",\n \"0.6966886\",\n \"0.6953431\",\n \"0.69326895\",\n \"0.68154866\",\n \"0.680478\",\n \"0.6793031\",\n \"0.66768706\",\n \"0.6661258\",\n \"0.6602542\",\n \"0.6554972\",\n \"0.6527791\",\n \"0.6508529\",\n \"0.65084046\",\n \"0.65048134\",\n \"0.64875036\",\n \"0.6486214\",\n \"0.64814633\",\n \"0.6460768\",\n \"0.64471906\",\n \"0.6438607\",\n \"0.6436119\",\n \"0.6396226\",\n \"0.63332444\",\n \"0.63218683\",\n \"0.63194776\",\n \"0.63158107\",\n \"0.6299398\",\n \"0.62949854\",\n \"0.6262381\",\n \"0.621878\",\n \"0.62093705\",\n \"0.6208339\",\n \"0.62061334\",\n \"0.61869043\",\n \"0.618593\",\n \"0.61544585\",\n \"0.6143208\",\n \"0.61383337\",\n \"0.6134273\",\n \"0.6129439\",\n \"0.612689\",\n \"0.61209995\",\n \"0.6120072\",\n \"0.60394084\",\n \"0.60161686\",\n \"0.60109824\",\n \"0.60029894\",\n \"0.5982014\",\n \"0.59613216\",\n \"0.5947317\",\n \"0.5939911\",\n \"0.59397984\",\n \"0.59172064\",\n \"0.5913383\",\n \"0.58939475\",\n \"0.5886605\",\n \"0.5857848\",\n \"0.5852477\",\n \"0.5840933\",\n \"0.5839463\",\n \"0.5836529\",\n \"0.5831133\",\n \"0.58310395\",\n \"0.5821022\",\n \"0.58206856\",\n \"0.5820584\",\n \"0.58185667\",\n \"0.58092827\",\n \"0.5798193\",\n \"0.57947606\",\n \"0.57740414\",\n \"0.57682323\",\n \"0.57617396\",\n \"0.5752947\",\n \"0.5748744\",\n \"0.5746001\",\n \"0.57437587\",\n \"0.57230103\",\n \"0.57223195\",\n \"0.5720325\",\n \"0.5720153\",\n \"0.5715686\",\n \"0.5715128\",\n \"0.5714134\",\n \"0.5710466\",\n \"0.570933\",\n \"0.57046527\",\n \"0.5704316\",\n \"0.56992286\",\n \"0.569915\",\n \"0.56986845\",\n \"0.5691005\",\n \"0.5670778\",\n \"0.56688756\",\n \"0.5657455\",\n \"0.56552744\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7827654"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92885,"cells":{"query":{"kind":"string","value":"Test that a tree has the correct internal structure"},"document":{"kind":"string","value":"def test01(self):\n\n t = tree(\"a\", [tree(\"b\"), tree(\"c\")]);\n self.assertTrue(self.isTree(t))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_Tree():","def test_tree_with_one_node_has_correct_value(one_t):\n assert one_t.root.value == 10","def test_small_tree_has_root_value(small_tree):\n assert small_tree.root.right.value == 11","def test_children_tree(depth_one_tree):\n assert str(depth_one_tree.root.children) == str([1, 2, 3, 4])","def testTree(self, valid):\n return testTreeF(self, valid)","def test_root_value(small_tree):\n assert small_tree.root.value == 3","def test_small_tree_has_right_child_child(small_tree):\n assert small_tree.root.right.right.value == 27","def test_binarytree_exists():\n assert BinaryTree","def test_minimal_tree_creation():\n t = Tree(None)\n\n assert t.data is None\n assert t.parent is None\n assert len(t) == 0","def test_tree_with_one_node_root_exists(one_t):\n assert one_t.root","def test_small_tree_has_no_root(small_tree):\n assert small_tree.root.left is None","def test_root_large_tree_value(large_tree):\n assert large_tree.root.value == 11","def test02(self):\n\n t = tree(\"a\", [tree(\"b\"), tree(\"c\")]);\n self.assertEqual(len(t), 3)","def test_buildTree(self):\r\n root = buildTree()\r\n assert root.getchildren()[0].getchildren()[0].attrib['id'] == 'c-test_crisis'\r\n assert root.getchildren()[1].getchildren()[0].attrib['id'] == 'o-test_org'\r\n assert root.getchildren()[2].getchildren()[0].attrib['id'] == 'p-algore'","def test_empty_tree(height_one_tree):\n assert height_one_tree.root.val is 0","def test_depth(known_bst):\n assert known_bst[0].depth() == 3","def test_tree_with_one_node_root_no_children(one_t):\n assert not one_t.root.left\n assert not one_t.root.right","def test_tree_one_node_has_depth_zero(one_t):\n assert one_t.depth() == 0","def test_val_root_filled_tree(depth_one_tree):\n assert depth_one_tree.root.val is 0","def test_empty_tree_depth(empty_t):\n assert empty_t.depth() == \"Empty tree has no depth.\"","def test_tree_two_nodes_left_has_depth_one(one_t):\n one_t.insert(5)\n assert one_t.depth() == 1","def test_binarytree_in_order_exists():\n assert BinaryTree.in_order","def test_tree_binary_tree() -> None:\n t = generate_binary_tree_resources(4, 3)\n field(t, (\"root\", \"ds\", \"f1\")).identity = \"email\"\n field(t, (\"root.0.1.0\", \"ds.0.1.0\", \"f1\")).identity = \"ssn\"\n field(t, (\"root.1.1\", \"ds.1.1\", \"f1\")).identity = \"user_id\"\n assert generate_traversal({\"email\": \"X\"}, *t)\n assert generate_traversal({\"ssn\": \"X\"}, *t)\n assert generate_traversal({\"user_id\": \"X\"}, *t)","def test_render_tree(self) -> None:\n\n def get_children(node):\n return node.children\n\n node, expect, withtags = self.tree_case_1()\n actual = render_tree(node, get_children)\n assert expect == actual, (expect, actual)\n\n node, expect, withtags = self.tree_case_2()\n actual = render_tree(node, get_children, 1)\n assert expect == actual, (expect, actual)\n\n # Ensure that we can call render_tree on the same Node\n # again. This wasn't possible in version 2.4.1 and earlier\n # due to a bug in render_tree (visited was set to {} as default\n # parameter)\n actual = render_tree(node, get_children, 1)\n assert expect == actual, (expect, actual)","def test_binarytree_pre_order_exists():\n assert BinaryTree.pre_order","def test_tree_initiates_with_empty_root(empty_t):\n assert not empty_t.root","def test_tree_two_nodes_right(one_t):\n one_t.insert(5)\n assert one_t.depth() == 1","def test_tree_support(self):\r\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\r\n \"\"\"\r\n /-------.5 /-a\r\n ---1| \\-b\r\n \\------.5 /-c\r\n \\-d\r\n \"\"\"\r\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\r\n\r\n tc.tree_support(master_tree, t2)\r\n assert_almost_equal(\r\n master_tree.getNodeMatchingName('rt').bootstrap_support, 1.0)","def test_on_copy_not_on_root():\n builder = TreeBuilder()\n builder.create_root(0)\n builder.add_child(5)\n builder.add_child(6, move=True)\n\n _ = builder.build()\n builder.add_child(7)\n\n t = builder.build()\n assert_tree_structure(t, {(): 0, (0, ): 5, (1, ): 6, (1, 0): 7})","def test_binarytree_post_order_exists():\n assert BinaryTree.post_order","def test_left_sided_tree_with_two_nodes_root_has_child(empty_t):\n empty_t.insert(10)\n empty_t.insert(5)\n assert empty_t.root.left\n assert not empty_t.root.right","def test_inset(depth_one_tree):\n depth_one_tree.insert(2, 3)\n print(depth_one_tree.root.children[0].children)\n print(depth_one_tree.root.children[1].children)\n print(depth_one_tree.root.children[2].children)\n print(depth_one_tree.root.children[3].children)\n assert str(depth_one_tree.root.children[2].children) == str([2])","def test_tree_balace_root():\n result = balance.generate_tree('test_input.txt')\n expected = 'tknk'\n\n assert expected == result['root'][0]","def test_address_to_tree(self):\n pass","def test_balanced_tree_7_nodes_has_depth_two(balanced_7_nodes):\n assert balanced_7_nodes.depth() == 2","def test_has_children_property(mock_amg):\n\n # split a cell so we can be sure it should have children\n mock_amg.cells[4].split()\n\n assert mock_amg.cells[4].has_children()\n assert not mock_amg.cells[1].has_children()\n assert not mock_amg.cells[4].children['bl'].has_children()","def test_balanced_tree_with_3_nodes_has_depth_one(balanced_3_nodes):\n assert balanced_3_nodes.depth() == 1","def test04(self):\n\n s = \"a;\"\n t = parse_newick(s);\n self.assertTrue(self.isTree(t) and t.label == \"a\" and t.isLeaf())","def test_list_passed_as_iterable():\n tree = Tree([10, 5, 100])\n assert tree.root.value == 10\n assert tree.root.left.value == 5\n assert tree.root.right.value == 100","def test_validate_valid_person(self):\r\n assert self.person_tree != 0","def test_bst_single_node():\n assert BST(1).root is None","def test_tree_intersection_name_exists():\n assert tree_intersection","def test_depth_returns_correct_value_left_balanced_tree(bst_all_to_left):\n assert bst_all_to_left.depth() == 3","def test_right_sided_tree_with_two_nodes_root_has_child(empty_t):\n empty_t.insert(10)\n empty_t.insert(15)\n assert empty_t.root.right\n assert not empty_t.root.left","def test_balanced_tree_with_7_nodes_is_correct(balanced_7_nodes):\n root = balanced_7_nodes.root\n assert root.value == 10\n assert root.left.value == 5\n assert root.right.value == 15\n assert root.left.left.value == 3\n assert root.left.right.value == 7\n assert root.right.right.value == 20\n assert root.right.left.value == 13","def check_subtree(node):\r\n if node:\r\n node_loc = node.location\r\n self.assertFalse(\r\n modulestore().has_item(node_loc.version_agnostic())\r\n )\r\n self.assertTrue(modulestore().has_item(node_loc.course_agnostic()))\r\n if node.has_children:\r\n for sub in node.get_children():\r\n check_subtree(sub)","def test_empty_tree_contains(empty_t):\n empty_t.contains(1) == \"An empty tree has no values.\"","def test_get_children():\n builder = TreeBuilder()\n builder.create_root(1)\n builder.add_child(7)\n builder.add_child(2, move=True)\n builder.add_child(13)\n t = builder.build()\n\n assert t[0].data == 7\n assert t[1].data == 2\n assert t[1][0].data == 13","def test_removing_root(item):\n item.root = None\n assert not item.has_root","def test_balance_known_tree(known_bst):\n assert known_bst[0].balance() == 0","def test_tree_with_one_leaf_node_right_of_left_depth(balanced_3_nodes):\n balanced_3_nodes.insert(8)\n assert balanced_3_nodes.depth() == 2","def test_tree_mode4(self):\n xpb = XPathBuilder()\n xp_1 = xpb.foo\n xp_2 = xpb.baz\n xp_and = xp_1 & xp_2\n self.assertTrue(xp_and._parent is None)\n self.assertTrue(len(xp_and._children) == 2)\n self.assertTrue(xp_and._children[0] is xp_1)\n self.assertTrue(xp_and._children[1] is xp_2)\n self.assertTrue(xp_1._parent is xp_and)\n self.assertTrue(len(xp_1._children) == 0)\n self.assertTrue(xp_2._parent is xp_and)\n self.assertTrue(len(xp_2._children) == 0)\n xp_2.reparent(None)\n # check references after remove\n self.assertTrue(xp_and._parent is None)\n self.assertTrue(len(xp_and._children) == 1)\n self.assertTrue(xp_and._children[0] is xp_1)\n self.assertTrue(xp_1._parent is xp_and)\n self.assertTrue(len(xp_1._children) == 0)\n # xp_2's references were changed\n self.assertTrue(xp_2._parent is None)\n self.assertTrue(len(xp_2._children) == 0)","def test_after_creation_copy():\n builder = TreeBuilder()\n builder.create_root(0)\n builder.add_child(2, move=True)\n builder.add_child(13)\n builder.move_to_parent()\n builder.add_child(7)\n\n t1 = builder.build()\n\n builder.move_to_root()\n builder.set_data(4)\n builder.add_child(3, move=True)\n builder.add_child(15)\n\n t2 = builder.build()\n\n assert t2 is not t1\n assert t2[0] is not t1[0]\n assert t2[0][0] is not t1[0][0]\n assert t2[1] is not t1[1]\n\n assert t2.data == 4\n assert t2[0].data == 2\n assert t2[0][0].data == 13\n assert t2[1].data == 7\n assert t2[2].data == 3\n assert t2[2][0].data == 15\n\n assert len(t2) == 3\n assert len(t2[0]) == 1\n assert len(t2[1]) == 0\n assert len(t2[2]) == 1","def test_depth_empty():\n bst = BST()\n assert bst.depth() == 0","def isTree(self, t):\n\n if type(t) != tree:\n return False;\n if not hasattr(t, \"label\"):\n return False;\n if type(t.label) != str:\n return False;\n if not hasattr(t, \"children\"):\n return False;\n if type(t.children) != list:\n return False;\n return all([type(c) == tree for c in t.children])","def test_simple_case(basic_tree):\n tree = red_black_tree.RBTree()\n assert tree.empty\n\n # 23, 4, 30, 11, 7, 34, 20, 24, 22, 15, 1\n for key, data in basic_tree:\n tree.insert(key=key, data=data)\n\n assert tree.empty is False\n\n with pytest.raises(tree_exceptions.DuplicateKeyError):\n tree.insert(key=23, data=\"23\")\n\n assert tree.get_height(node=tree.root) == 3\n assert tree.get_leftmost(tree.root).key == 1\n assert tree.get_leftmost(tree.root).data == \"1\"\n assert tree.get_rightmost(tree.root).key == 34\n assert tree.get_rightmost(tree.root).data == \"34\"\n assert tree.search(24).key == 24\n assert tree.search(24).data == \"24\"\n node = tree.search(7)\n assert tree.get_successor(node).key == 11\n assert tree.get_predecessor(node).key == 4\n node = tree.search(15)\n assert tree.get_successor(node).key == 20\n node = tree.search(22)\n assert tree.get_predecessor(node).key == 20\n\n tree.delete(15)\n\n assert tree.search(15) is None","def test_tree_with_one_leaf_node_left_of_right_depth(balanced_3_nodes):\n balanced_3_nodes.insert(13)\n assert balanced_3_nodes.depth() == 2","def test_instantiate_gets_correct_root_and_root_pointers():\n input = [13, 42, 7]\n c = BinaryTree(input)\n root_repr = repr(c.root)\n expected_root_repr = '<Node | Val: 13 | Data: None | Left: 7 | Right: 42>'\n assert root_repr == expected_root_repr","def test_value_in_tree_returns_true(balanced_7_nodes):\n assert balanced_7_nodes.contains(7)","def test_size_is_correct_on_filled_tree(bst_100_rand):\n assert bst_100_rand.size() == 100","def test_bst_root(bst_ten_values_random):\n assert bst_ten_values_random.root.val == 5","def assertStructure(self, root, dirDict):\n children = [each.basename() for each in root.children()]\n for pathSegment, expectation in dirDict.items():\n child = root.child(pathSegment)\n if callable(expectation):\n self.assertTrue(expectation(child))\n elif isinstance(expectation, dict):\n self.assertTrue(child.isdir(), \"{} is not a dir!\".format(child.path))\n self.assertStructure(child, expectation)\n else:\n actual = child.getContent().decode().replace(os.linesep, \"\\n\")\n self.assertEqual(actual, expectation)\n children.remove(pathSegment)\n if children:\n self.fail(\"There were extra children in {}: {}\".format(root.path, children))","def test_consistency(self):\n def compare_func(obj, node):\n # number of children must be consistent\n self.assertEqual(\n len(obj.children),\n len(obj._children)\n )\n\n # obj.html equals node\n self.assertEqual(obj._html, node)\n\n # coordinates\n self.assertEqual(\n obj._coordinates,\n obj.coordinates,\n self.expected[\"coordinates\"][obj.id or \"document\"]\n )\n\n # confidence\n self.assertAlmostEqual(\n obj.confidence,\n self.expected[\"confidence\"][obj.id or \"document\"]\n )\n\n self.recursively_compare_tree_against_html(compare_func)","def test_bst_empty_root(bst_empty):\n assert bst_empty.root == None","def test_validate_valid_org(self):\r\n assert self.org_tree != 0","def test_level_depth(chikin):\n assert chikin.depth == 0\n assert str(chikin.section) == 'Chikin Tales'\n assert chikin.section.depth == 1\n assert chikin.section.subsection.depth == 2","def is_tree(G: \"Graph\"):\n return len(G.edges) == len(G.vertices) - 1","def test_is_leaf(self):\n self.assertEqual(True, comparator.is_leaf(None))\n self.assertEqual(True, comparator.is_leaf(True))\n self.assertEqual(True, comparator.is_leaf(False))\n self.assertEqual(True, comparator.is_leaf(int()))\n self.assertEqual(True, comparator.is_leaf(str()))\n self.assertEqual(False, comparator.is_leaf(list()))\n self.assertEqual(False, comparator.is_leaf(dict()))","def test_parent_read_only():\n t = Tree(None)\n with pytest.raises(AttributeError):\n t.parent = None","def test_depth_known(our_bsts):\n assert our_bsts[0].depth() == our_bsts[1]","def test_leafs():\n leafs = ['s6675', 's136315', 's10765', 's106594', 's131']\n for leaf in leafs:\n synset = germanet_data.get_synset_by_id(leaf)\n np.testing.assert_equal(synset.is_root(), False)\n np.testing.assert_equal(synset.is_leaf(), True)","def assertStructure(self, root, dirDict):\n children = [x.basename() for x in root.children()]\n for x in dirDict:\n child = root.child(x)\n if isinstance(dirDict[x], dict):\n self.assertTrue(child.isdir(), \"%s is not a dir!\"\n % (child.path,))\n self.assertStructure(child, dirDict[x])\n else:\n a = child.getContent().replace(os.linesep, '\\n')\n self.assertEquals(a, dirDict[x], child.path)\n children.remove(x)\n if children:\n self.fail(\"There were extra children in %s: %s\"\n % (root.path, children))","def _gen_test_tree_6():\n tree = BinaryNode(20)\n tree.left = BinaryNode(10)\n tree.right = BinaryNode(30)\n tree.left.right = BinaryNode(25)\n return tree","def test_validate_valid_crisis(self):\r\n assert self.crisis_tree != 0","def test_data_read_only():\n t = Tree(None)\n with pytest.raises(AttributeError):\n t.data = 0","def assert_parse_tree (code, expected):\n tranql = TranQL ()\n tranql.resolve_names = False\n actual = tranql.parser.parse (code).parse_tree\n #print (f\"{actual}\")\n assert_lists_equal (\n actual,\n expected)","def test_compare_old_to_new_method_to_create_trees(self):\n nodes = util.generate_sequence_of_points(2, 2)\n tree1 = kdtree.createNewTree(nodes)\n kdtree.visualize(tree1)\n \n sel_axis = (lambda axis: axis)\n tree2 = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\n tree2.split2([0.25, 0.5], axis = 1)\n tree2.split2([0.75, 0.5], axis = 1)\n \n #left\n tree2.split2([0.25, 0.25], axis = 0, sel_axis = sel_axis)\n tree2.split2([0.25, 0.75], axis = 0, sel_axis = sel_axis)\n \n #right\n tree2.split2([0.75, 0.25], axis = 0, sel_axis = sel_axis)\n tree2.split2([0.75, 0.75], axis = 0, sel_axis = sel_axis)\n \n kdtree.visualize(tree2)\n \n for n in zip(kdtree.level_order(tree1), kdtree.level_order(tree2)):\n self.assertEqual(n[0].data, n[1].data, \"elements not equal\")\n \n if n[0].data is not None and n[1].data is not None:\n self.assertEqual(n[0].axis, n[1].axis, \"elements not equal\")","def test_tree_mode3(self):\n xpb = XPathBuilder()\n xp_1 = xpb.foo\n xp_2 = xpb.baz\n xp_and = xp_1 & xp_2\n self.assertTrue(xp_and._parent is None)\n self.assertTrue(len(xp_and._children) == 2)\n self.assertTrue(xp_and._children[0] is xp_1)\n self.assertTrue(xp_and._children[1] is xp_2)\n self.assertTrue(xp_1._parent is xp_and)\n self.assertTrue(len(xp_1._children) == 0)\n self.assertTrue(xp_2._parent is xp_and)\n self.assertTrue(len(xp_2._children) == 0)\n xp_and.remove_child(xp_2)\n # check references after remove\n self.assertTrue(xp_and._parent is None)\n self.assertTrue(len(xp_and._children) == 1)\n self.assertTrue(xp_and._children[0] is xp_1)\n self.assertTrue(xp_1._parent is xp_and)\n self.assertTrue(len(xp_1._children) == 0)\n # xp_2's references were changed\n self.assertTrue(xp_2._parent is None)\n self.assertTrue(len(xp_2._children) == 0)","def test_init(self):\r\n p = TreeBuilder({})\r\n self.assertEqual(p.Name, 'TreeBuilder')\r\n self.assertEqual(p.Params, {})","def test_contains_returns_false_on_empty_tree(bst_empty):\n assert bst_empty.contains(4) is False","def test_init_root():\n from bst import BST\n bst = BST()\n # import pdb; pdb.set_trace()\n assert bst.root is None","def validate_tree(self, treenum, tree, halonum=None):\n # Check size\n if treenum == -1:\n nhalos = self.totnhalos\n halonum = None\n else:\n if halonum is not None:\n nhalos = 1\n else:\n nhalos = self.nhalos_per_tree[treenum]\n fields = list(tree.keys())\n for k in fields:\n assert (len(tree[k]) == nhalos)\n # Check fields\n for k in self.raw_fields:\n assert (k in fields)\n # Don't check tree indices for a single halo\n if halonum is not None:\n return\n # For all trees get list of local nhalos for every halo\n if treenum == -1:\n treenum_arr = self.treenum_arr\n nhalos = self.nhalos_per_tree[treenum_arr]\n # Check that halos are within tree\n for k in halo_fields:\n assert ((tree[k] < nhalos).all())\n # Check FOF central exists and all subs in one snapshot\n central = tree['FirstHaloInFOFgroup']\n assert ((central >= 0).all())\n if treenum == -1:\n central = self.get_total_index(treenum_arr, central)\n assert ((tree['SnapNum'] == tree['SnapNum'][central]).all())\n # Check that progenitors/descendants are back/forward in time\n descend = tree['Descendant'].astype('i4')\n has_descend = (descend >= 0)\n not_descend = np.logical_not(has_descend)\n # Not strictly True\n # assert ((tree['SnapNum'][not_descend] ==\n # (len(self.scale_factors) - 1)).all())\n if treenum == -1:\n descend = self.get_total_index(treenum_arr, descend)\n assert ((tree['SnapNum'][descend[has_descend]] >\n tree['SnapNum'][has_descend]).all())\n # Check progenitors are back in time\n descend[not_descend] = np.where(not_descend)[0]\n progen1 = tree['FirstProgenitor']\n progen2 = tree['NextProgenitor']\n has_progen1 = (progen1 >= 0)\n has_progen2 = (progen2 >= 0)\n if treenum == -1:\n progen1 = self.get_total_index(treenum_arr, progen1)\n progen2 = self.get_total_index(treenum_arr, progen2)\n assert ((tree['SnapNum'][progen1[has_progen1]] <=\n tree['SnapNum'][descend[has_progen1]]).all())\n assert ((tree['SnapNum'][progen2[has_progen2]] <=\n tree['SnapNum'][descend[has_progen2]]).all())","def test_is_bst(tree: BSTNode) -> None:\n output = [n.value for n in tree.in_order(tree)]\n assert output == sorted(output)","def _gen_test_tree_3():\n tree = BinaryNode(5)\n tree.left = BinaryNode(1)\n tree.left.left = BinaryNode(2)\n tree.left.right = BinaryNode(3)\n tree.right = BinaryNode(7)\n tree.right.left = BinaryNode(8)\n tree.right.right = BinaryNode(9)\n return tree","def test_compiler_parse_tree(compiler, patch):\n patch.object(Compiler, 'subtree')\n tree = Tree('start', [Tree('command', ['token'])])\n compiler.parse_tree(tree)\n compiler.subtree.assert_called_with(Tree('command', ['token']),\n parent=None)","def test_tree_with_one_node_balance_is_zero(one_t):\n assert one_t.balance() == 0","def _gen_test_tree_4():\n tree = BinaryNode(5)\n tree.left = BinaryNode(3)\n tree.left.left = BinaryNode(2)\n tree.left.right = BinaryNode(10)\n tree.right = BinaryNode(9)\n tree.right.left = BinaryNode(6)\n tree.right.right = BinaryNode(8)\n return tree","def _gen_test_tree_2():\n tree = BinaryNode(5)\n tree.left = BinaryNode(3)\n tree.left.left = BinaryNode(2)\n tree.left.left.left = BinaryNode(1)\n tree.left.right = BinaryNode(4)\n tree.right = BinaryNode(7)\n tree.right.left = BinaryNode(6)\n tree.right.right = BinaryNode(8)\n tree.right.right.right = BinaryNode(9)\n return tree","def IsLeaf(self):\n return not self.subtests","def _gen_test_tree_1():\n tree = BinaryNode(5)\n tree.left = BinaryNode(5)\n return tree","def setUp(self):\n\n # Valid tree:\n self.valid_tree = Node(1)\n self.valid_tree.left = Node(2)\n self.valid_tree.right = Node(3)\n self.valid_tree.left.left = Node(4)\n self.valid_tree.left.right = Node(5)\n self.valid_tree.right.left = Node(6)\n self.valid_tree.right.right = Node(7)\n self.valid_tree.left.right.left = Node(8)\n self.valid_tree.right.right.right = Node(9)\n self.valid_tree.right.right.right.left = Node(10)\n\n # Empty tree\n\n self.empty_tree = None\n\n # Tree only consisting of root\n\n self.only_root = Node(1)\n\n # DAG example for Wikipedia\n # https://en.wikipedia.org/wiki/Directed_acyclic_graph#/media/File:Tred-G.svg\n\n self.dag_example = DAG(\n [\n # A B C D E\n [False, True, True, True, True], # A \n [False, False, False, True, False], # B\n [False, False, False, True, True], # C \n [False, False, False, False, True], # D \n [False, False, False, False, False] # E\n ]\n )\n\n # DAG example from Baeldung\n # https://www.baeldung.com/wp-content/uploads/sites/4/2021/01/Dag-3.jpg\n\n self.dag_complex = DAG(\n [\n # 0 1 2 3 4 5 6 7 8\n [False, True, True, False, False, False, False, False, False], # 0 \n [False, False, False, False, True, False, True, False, False], # 1\n [False, False, False, True, True, False, True, False, False], # 2 \n [False, False, False, False, False, False, True, False, False], # 3 \n [False, False, False, False, False, False, False, False, False], # 4\n [False, False, False, False, False, False, False, False, False], # 5 \n [False, False, False, False, False, True, False, True, False], # 6 \n [False, False, False, False, False, False, False, False, True ], # 7 \n [False, False, False, False, False, False, False, False, False] # 8\n ]\n )\n\n # DAG with multiple roots\n\n self.dag_multiple_roots = DAG(\n [\n # 0 1 2 3 4 5 6 7 8 9\n [False, False, False, False, False, False, False, True, False, False ], # 0\n [False, False, False, True, False, False, False, False, False, False ], # 1 \n [False, False, False, False, True, False, False, True, False, False ], # 2 \n [False, False, False, False, False, True, False, False, False, False ], # 3\n [False, False, False, False, False, True, True, False, False, False ], # 4\n [False, False, False, False, False, False, False, False, True, True ], # 5\n [False, False, False, False, False, False, False, False, False, True ], # 6 \n [False, False, False, False, False, False, True, False, False, False ], # 7\n [False, False, False, False, False, False, False, False, False, False ], # 8\n [False, False, False, False, False, False, False, False, False, False ], # 9\n ]\n )\n\n # Set up logging\n logging.basicConfig(filename=\"lca_test.log\",\n encoding=\"utf-8\", level=logging.INFO)","def test_depth_returns_correct_value_balanced_tree(bst_balanced):\n assert bst_balanced.depth() == 3","def test_tree_2_nodes_left_unbalanced(one_t):\n one_t.insert(9)\n assert one_t.balance() == 1","def test_print_tree(self) -> None:\n\n def get_children(node):\n return node.children\n\n save_stdout = sys.stdout\n\n try:\n node, expect, withtags = self.tree_case_1()\n\n IOStream = io.StringIO\n sys.stdout = IOStream()\n print_tree(node, get_children)\n actual = sys.stdout.getvalue()\n assert expect == actual, (expect, actual)\n\n sys.stdout = IOStream()\n print_tree(node, get_children, showtags=1)\n actual = sys.stdout.getvalue()\n assert withtags == actual, (withtags, actual)\n\n # Test that explicitly setting prune to zero works\n # the same as the default (see above)\n node, expect, withtags = self.tree_case_2(prune=0)\n\n sys.stdout = IOStream()\n print_tree(node, get_children, 0)\n actual = sys.stdout.getvalue()\n assert expect == actual, (expect, actual)\n\n sys.stdout = IOStream()\n print_tree(node, get_children, 0, showtags=1)\n actual = sys.stdout.getvalue()\n assert withtags == actual, (withtags, actual)\n\n # Test output with prune=1\n node, expect, withtags = self.tree_case_2(prune=1)\n\n sys.stdout = IOStream()\n print_tree(node, get_children, 1)\n actual = sys.stdout.getvalue()\n assert expect == actual, (expect, actual)\n\n # Ensure that we can call print_tree on the same Node\n # again. This wasn't possible in version 2.4.1 and earlier\n # due to a bug in print_tree (visited was set to {} as default\n # parameter)\n sys.stdout = IOStream()\n print_tree(node, get_children, 1)\n actual = sys.stdout.getvalue()\n assert expect == actual, (expect, actual)\n\n sys.stdout = IOStream()\n print_tree(node, get_children, 1, showtags=1)\n actual = sys.stdout.getvalue()\n assert withtags == actual, (withtags, actual)\n finally:\n sys.stdout = save_stdout","def valid_tree(phi):\n q = deque([phi]) # queue of nodes to check\n visited = list() # already checked\n\n # save the indim of the root node, and make sure all the indims\n # of the children are the same\n indim = phi.indim\n retval = True\n varsfound = 0\n\n while len(q) > 0:\n # node to check\n node = q.popleft()\n\n # check outdim\n if isinstance(node, amnet.Variable):\n retval &= (node.outdim == node.indim)\n varsfound += 1\n elif isinstance(node, amnet.Linear):\n m, n = node.w.shape\n retval &= (node.outdim == m)\n retval &= (node.x.outdim == n)\n retval &= (all([bi == 0 for bi in node.b])) # check value\n elif isinstance(node, amnet.Constant):\n retval &= (node.outdim == len(node.b))\n retval &= (all([wij == 0 for wij in np.nditer(node.w)])) # check value\n elif isinstance(node, amnet.Affine):\n m, n = node.w.shape\n retval &= (node.outdim == m)\n retval &= (node.x.outdim == n)\n retval &= (m == len(node.b))\n elif isinstance(node, amnet.Mu):\n retval &= (node.outdim == node.x.outdim)\n retval &= (node.outdim == node.y.outdim)\n retval &= (node.z.outdim == 1)\n elif isinstance(node, amnet.Stack):\n retval &= (node.outdim == node.x.outdim + node.y.outdim)\n else:\n retval = False # unknown node type\n\n # check indim\n retval &= (node.indim == indim)\n\n # short-circuit if an inconsistency has been found\n if not retval:\n return False\n\n # add children to queue\n if not(any(node is e for e in visited)):\n visited.append(node)\n #q.extend(children(node))\n q.extend([c for c in children(node) if c not in visited])\n\n # finished iterating\n # TODO: also check if graph is cyclic\n return (varsfound == 1)","def test_cannot_operate_on_rootless():\n builder = TreeBuilder()\n\n with pytest.raises(ValueError):\n builder.move_to_root()\n\n with pytest.raises(ValueError):\n builder.move_to_parent()\n\n with pytest.raises(ValueError):\n builder.build()","def test_root():\n gnroot = 's51001'\n root = germanet_data.get_synset_by_id(gnroot)\n np.testing.assert_equal(root.is_root(), True)\n np.testing.assert_equal(root.is_leaf(), False)","def test_print_level_order(depth_one_tree):\n assert print_level_order(depth_one_tree) == ['0', '1 2 3 4']","def test_equivalency(self):\n def compare_func(obj, node):\n # same id\n self.assertEqual(obj.id, node.get(\"id\"))\n\n # same html\n self.assertEqual(obj.html.prettify, node.prettify)\n\n # parents have same id (only for non-root elements)\n if not obj == self.document.root:\n self.assertEqual(obj.parent.id, node.parent.get(\"id\"))\n\n # same number of children\n child_nodes = self.get_children_of_node(node)\n self.assertEqual(len(obj.children), len(child_nodes))\n\n # children have same ids\n for (child_obj, child_node) in zip(obj.children, child_nodes):\n self.assertEqual(child_obj.id, child_node.get(\"id\"))\n\n self.recursively_compare_tree_against_html(compare_func)","def test_build_match_tree_with_empty():\n abbreviation_list = []\n expected_tree = {}\n tree = build_match_tree(abbreviation_list)\n assert repr(tree) == repr(expected_tree)"],"string":"[\n \"def test_Tree():\",\n \"def test_tree_with_one_node_has_correct_value(one_t):\\n assert one_t.root.value == 10\",\n \"def test_small_tree_has_root_value(small_tree):\\n assert small_tree.root.right.value == 11\",\n \"def test_children_tree(depth_one_tree):\\n assert str(depth_one_tree.root.children) == str([1, 2, 3, 4])\",\n \"def testTree(self, valid):\\n return testTreeF(self, valid)\",\n \"def test_root_value(small_tree):\\n assert small_tree.root.value == 3\",\n \"def test_small_tree_has_right_child_child(small_tree):\\n assert small_tree.root.right.right.value == 27\",\n \"def test_binarytree_exists():\\n assert BinaryTree\",\n \"def test_minimal_tree_creation():\\n t = Tree(None)\\n\\n assert t.data is None\\n assert t.parent is None\\n assert len(t) == 0\",\n \"def test_tree_with_one_node_root_exists(one_t):\\n assert one_t.root\",\n \"def test_small_tree_has_no_root(small_tree):\\n assert small_tree.root.left is None\",\n \"def test_root_large_tree_value(large_tree):\\n assert large_tree.root.value == 11\",\n \"def test02(self):\\n\\n t = tree(\\\"a\\\", [tree(\\\"b\\\"), tree(\\\"c\\\")]);\\n self.assertEqual(len(t), 3)\",\n \"def test_buildTree(self):\\r\\n root = buildTree()\\r\\n assert root.getchildren()[0].getchildren()[0].attrib['id'] == 'c-test_crisis'\\r\\n assert root.getchildren()[1].getchildren()[0].attrib['id'] == 'o-test_org'\\r\\n assert root.getchildren()[2].getchildren()[0].attrib['id'] == 'p-algore'\",\n \"def test_empty_tree(height_one_tree):\\n assert height_one_tree.root.val is 0\",\n \"def test_depth(known_bst):\\n assert known_bst[0].depth() == 3\",\n \"def test_tree_with_one_node_root_no_children(one_t):\\n assert not one_t.root.left\\n assert not one_t.root.right\",\n \"def test_tree_one_node_has_depth_zero(one_t):\\n assert one_t.depth() == 0\",\n \"def test_val_root_filled_tree(depth_one_tree):\\n assert depth_one_tree.root.val is 0\",\n \"def test_empty_tree_depth(empty_t):\\n assert empty_t.depth() == \\\"Empty tree has no depth.\\\"\",\n \"def test_tree_two_nodes_left_has_depth_one(one_t):\\n one_t.insert(5)\\n assert one_t.depth() == 1\",\n \"def test_binarytree_in_order_exists():\\n assert BinaryTree.in_order\",\n \"def test_tree_binary_tree() -> None:\\n t = generate_binary_tree_resources(4, 3)\\n field(t, (\\\"root\\\", \\\"ds\\\", \\\"f1\\\")).identity = \\\"email\\\"\\n field(t, (\\\"root.0.1.0\\\", \\\"ds.0.1.0\\\", \\\"f1\\\")).identity = \\\"ssn\\\"\\n field(t, (\\\"root.1.1\\\", \\\"ds.1.1\\\", \\\"f1\\\")).identity = \\\"user_id\\\"\\n assert generate_traversal({\\\"email\\\": \\\"X\\\"}, *t)\\n assert generate_traversal({\\\"ssn\\\": \\\"X\\\"}, *t)\\n assert generate_traversal({\\\"user_id\\\": \\\"X\\\"}, *t)\",\n \"def test_render_tree(self) -> None:\\n\\n def get_children(node):\\n return node.children\\n\\n node, expect, withtags = self.tree_case_1()\\n actual = render_tree(node, get_children)\\n assert expect == actual, (expect, actual)\\n\\n node, expect, withtags = self.tree_case_2()\\n actual = render_tree(node, get_children, 1)\\n assert expect == actual, (expect, actual)\\n\\n # Ensure that we can call render_tree on the same Node\\n # again. This wasn't possible in version 2.4.1 and earlier\\n # due to a bug in render_tree (visited was set to {} as default\\n # parameter)\\n actual = render_tree(node, get_children, 1)\\n assert expect == actual, (expect, actual)\",\n \"def test_binarytree_pre_order_exists():\\n assert BinaryTree.pre_order\",\n \"def test_tree_initiates_with_empty_root(empty_t):\\n assert not empty_t.root\",\n \"def test_tree_two_nodes_right(one_t):\\n one_t.insert(5)\\n assert one_t.depth() == 1\",\n \"def test_tree_support(self):\\r\\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\\r\\n \\\"\\\"\\\"\\r\\n /-------.5 /-a\\r\\n ---1| \\\\-b\\r\\n \\\\------.5 /-c\\r\\n \\\\-d\\r\\n \\\"\\\"\\\"\\r\\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\\r\\n\\r\\n tc.tree_support(master_tree, t2)\\r\\n assert_almost_equal(\\r\\n master_tree.getNodeMatchingName('rt').bootstrap_support, 1.0)\",\n \"def test_on_copy_not_on_root():\\n builder = TreeBuilder()\\n builder.create_root(0)\\n builder.add_child(5)\\n builder.add_child(6, move=True)\\n\\n _ = builder.build()\\n builder.add_child(7)\\n\\n t = builder.build()\\n assert_tree_structure(t, {(): 0, (0, ): 5, (1, ): 6, (1, 0): 7})\",\n \"def test_binarytree_post_order_exists():\\n assert BinaryTree.post_order\",\n \"def test_left_sided_tree_with_two_nodes_root_has_child(empty_t):\\n empty_t.insert(10)\\n empty_t.insert(5)\\n assert empty_t.root.left\\n assert not empty_t.root.right\",\n \"def test_inset(depth_one_tree):\\n depth_one_tree.insert(2, 3)\\n print(depth_one_tree.root.children[0].children)\\n print(depth_one_tree.root.children[1].children)\\n print(depth_one_tree.root.children[2].children)\\n print(depth_one_tree.root.children[3].children)\\n assert str(depth_one_tree.root.children[2].children) == str([2])\",\n \"def test_tree_balace_root():\\n result = balance.generate_tree('test_input.txt')\\n expected = 'tknk'\\n\\n assert expected == result['root'][0]\",\n \"def test_address_to_tree(self):\\n pass\",\n \"def test_balanced_tree_7_nodes_has_depth_two(balanced_7_nodes):\\n assert balanced_7_nodes.depth() == 2\",\n \"def test_has_children_property(mock_amg):\\n\\n # split a cell so we can be sure it should have children\\n mock_amg.cells[4].split()\\n\\n assert mock_amg.cells[4].has_children()\\n assert not mock_amg.cells[1].has_children()\\n assert not mock_amg.cells[4].children['bl'].has_children()\",\n \"def test_balanced_tree_with_3_nodes_has_depth_one(balanced_3_nodes):\\n assert balanced_3_nodes.depth() == 1\",\n \"def test04(self):\\n\\n s = \\\"a;\\\"\\n t = parse_newick(s);\\n self.assertTrue(self.isTree(t) and t.label == \\\"a\\\" and t.isLeaf())\",\n \"def test_list_passed_as_iterable():\\n tree = Tree([10, 5, 100])\\n assert tree.root.value == 10\\n assert tree.root.left.value == 5\\n assert tree.root.right.value == 100\",\n \"def test_validate_valid_person(self):\\r\\n assert self.person_tree != 0\",\n \"def test_bst_single_node():\\n assert BST(1).root is None\",\n \"def test_tree_intersection_name_exists():\\n assert tree_intersection\",\n \"def test_depth_returns_correct_value_left_balanced_tree(bst_all_to_left):\\n assert bst_all_to_left.depth() == 3\",\n \"def test_right_sided_tree_with_two_nodes_root_has_child(empty_t):\\n empty_t.insert(10)\\n empty_t.insert(15)\\n assert empty_t.root.right\\n assert not empty_t.root.left\",\n \"def test_balanced_tree_with_7_nodes_is_correct(balanced_7_nodes):\\n root = balanced_7_nodes.root\\n assert root.value == 10\\n assert root.left.value == 5\\n assert root.right.value == 15\\n assert root.left.left.value == 3\\n assert root.left.right.value == 7\\n assert root.right.right.value == 20\\n assert root.right.left.value == 13\",\n \"def check_subtree(node):\\r\\n if node:\\r\\n node_loc = node.location\\r\\n self.assertFalse(\\r\\n modulestore().has_item(node_loc.version_agnostic())\\r\\n )\\r\\n self.assertTrue(modulestore().has_item(node_loc.course_agnostic()))\\r\\n if node.has_children:\\r\\n for sub in node.get_children():\\r\\n check_subtree(sub)\",\n \"def test_empty_tree_contains(empty_t):\\n empty_t.contains(1) == \\\"An empty tree has no values.\\\"\",\n \"def test_get_children():\\n builder = TreeBuilder()\\n builder.create_root(1)\\n builder.add_child(7)\\n builder.add_child(2, move=True)\\n builder.add_child(13)\\n t = builder.build()\\n\\n assert t[0].data == 7\\n assert t[1].data == 2\\n assert t[1][0].data == 13\",\n \"def test_removing_root(item):\\n item.root = None\\n assert not item.has_root\",\n \"def test_balance_known_tree(known_bst):\\n assert known_bst[0].balance() == 0\",\n \"def test_tree_with_one_leaf_node_right_of_left_depth(balanced_3_nodes):\\n balanced_3_nodes.insert(8)\\n assert balanced_3_nodes.depth() == 2\",\n \"def test_tree_mode4(self):\\n xpb = XPathBuilder()\\n xp_1 = xpb.foo\\n xp_2 = xpb.baz\\n xp_and = xp_1 & xp_2\\n self.assertTrue(xp_and._parent is None)\\n self.assertTrue(len(xp_and._children) == 2)\\n self.assertTrue(xp_and._children[0] is xp_1)\\n self.assertTrue(xp_and._children[1] is xp_2)\\n self.assertTrue(xp_1._parent is xp_and)\\n self.assertTrue(len(xp_1._children) == 0)\\n self.assertTrue(xp_2._parent is xp_and)\\n self.assertTrue(len(xp_2._children) == 0)\\n xp_2.reparent(None)\\n # check references after remove\\n self.assertTrue(xp_and._parent is None)\\n self.assertTrue(len(xp_and._children) == 1)\\n self.assertTrue(xp_and._children[0] is xp_1)\\n self.assertTrue(xp_1._parent is xp_and)\\n self.assertTrue(len(xp_1._children) == 0)\\n # xp_2's references were changed\\n self.assertTrue(xp_2._parent is None)\\n self.assertTrue(len(xp_2._children) == 0)\",\n \"def test_after_creation_copy():\\n builder = TreeBuilder()\\n builder.create_root(0)\\n builder.add_child(2, move=True)\\n builder.add_child(13)\\n builder.move_to_parent()\\n builder.add_child(7)\\n\\n t1 = builder.build()\\n\\n builder.move_to_root()\\n builder.set_data(4)\\n builder.add_child(3, move=True)\\n builder.add_child(15)\\n\\n t2 = builder.build()\\n\\n assert t2 is not t1\\n assert t2[0] is not t1[0]\\n assert t2[0][0] is not t1[0][0]\\n assert t2[1] is not t1[1]\\n\\n assert t2.data == 4\\n assert t2[0].data == 2\\n assert t2[0][0].data == 13\\n assert t2[1].data == 7\\n assert t2[2].data == 3\\n assert t2[2][0].data == 15\\n\\n assert len(t2) == 3\\n assert len(t2[0]) == 1\\n assert len(t2[1]) == 0\\n assert len(t2[2]) == 1\",\n \"def test_depth_empty():\\n bst = BST()\\n assert bst.depth() == 0\",\n \"def isTree(self, t):\\n\\n if type(t) != tree:\\n return False;\\n if not hasattr(t, \\\"label\\\"):\\n return False;\\n if type(t.label) != str:\\n return False;\\n if not hasattr(t, \\\"children\\\"):\\n return False;\\n if type(t.children) != list:\\n return False;\\n return all([type(c) == tree for c in t.children])\",\n \"def test_simple_case(basic_tree):\\n tree = red_black_tree.RBTree()\\n assert tree.empty\\n\\n # 23, 4, 30, 11, 7, 34, 20, 24, 22, 15, 1\\n for key, data in basic_tree:\\n tree.insert(key=key, data=data)\\n\\n assert tree.empty is False\\n\\n with pytest.raises(tree_exceptions.DuplicateKeyError):\\n tree.insert(key=23, data=\\\"23\\\")\\n\\n assert tree.get_height(node=tree.root) == 3\\n assert tree.get_leftmost(tree.root).key == 1\\n assert tree.get_leftmost(tree.root).data == \\\"1\\\"\\n assert tree.get_rightmost(tree.root).key == 34\\n assert tree.get_rightmost(tree.root).data == \\\"34\\\"\\n assert tree.search(24).key == 24\\n assert tree.search(24).data == \\\"24\\\"\\n node = tree.search(7)\\n assert tree.get_successor(node).key == 11\\n assert tree.get_predecessor(node).key == 4\\n node = tree.search(15)\\n assert tree.get_successor(node).key == 20\\n node = tree.search(22)\\n assert tree.get_predecessor(node).key == 20\\n\\n tree.delete(15)\\n\\n assert tree.search(15) is None\",\n \"def test_tree_with_one_leaf_node_left_of_right_depth(balanced_3_nodes):\\n balanced_3_nodes.insert(13)\\n assert balanced_3_nodes.depth() == 2\",\n \"def test_instantiate_gets_correct_root_and_root_pointers():\\n input = [13, 42, 7]\\n c = BinaryTree(input)\\n root_repr = repr(c.root)\\n expected_root_repr = '<Node | Val: 13 | Data: None | Left: 7 | Right: 42>'\\n assert root_repr == expected_root_repr\",\n \"def test_value_in_tree_returns_true(balanced_7_nodes):\\n assert balanced_7_nodes.contains(7)\",\n \"def test_size_is_correct_on_filled_tree(bst_100_rand):\\n assert bst_100_rand.size() == 100\",\n \"def test_bst_root(bst_ten_values_random):\\n assert bst_ten_values_random.root.val == 5\",\n \"def assertStructure(self, root, dirDict):\\n children = [each.basename() for each in root.children()]\\n for pathSegment, expectation in dirDict.items():\\n child = root.child(pathSegment)\\n if callable(expectation):\\n self.assertTrue(expectation(child))\\n elif isinstance(expectation, dict):\\n self.assertTrue(child.isdir(), \\\"{} is not a dir!\\\".format(child.path))\\n self.assertStructure(child, expectation)\\n else:\\n actual = child.getContent().decode().replace(os.linesep, \\\"\\\\n\\\")\\n self.assertEqual(actual, expectation)\\n children.remove(pathSegment)\\n if children:\\n self.fail(\\\"There were extra children in {}: {}\\\".format(root.path, children))\",\n \"def test_consistency(self):\\n def compare_func(obj, node):\\n # number of children must be consistent\\n self.assertEqual(\\n len(obj.children),\\n len(obj._children)\\n )\\n\\n # obj.html equals node\\n self.assertEqual(obj._html, node)\\n\\n # coordinates\\n self.assertEqual(\\n obj._coordinates,\\n obj.coordinates,\\n self.expected[\\\"coordinates\\\"][obj.id or \\\"document\\\"]\\n )\\n\\n # confidence\\n self.assertAlmostEqual(\\n obj.confidence,\\n self.expected[\\\"confidence\\\"][obj.id or \\\"document\\\"]\\n )\\n\\n self.recursively_compare_tree_against_html(compare_func)\",\n \"def test_bst_empty_root(bst_empty):\\n assert bst_empty.root == None\",\n \"def test_validate_valid_org(self):\\r\\n assert self.org_tree != 0\",\n \"def test_level_depth(chikin):\\n assert chikin.depth == 0\\n assert str(chikin.section) == 'Chikin Tales'\\n assert chikin.section.depth == 1\\n assert chikin.section.subsection.depth == 2\",\n \"def is_tree(G: \\\"Graph\\\"):\\n return len(G.edges) == len(G.vertices) - 1\",\n \"def test_is_leaf(self):\\n self.assertEqual(True, comparator.is_leaf(None))\\n self.assertEqual(True, comparator.is_leaf(True))\\n self.assertEqual(True, comparator.is_leaf(False))\\n self.assertEqual(True, comparator.is_leaf(int()))\\n self.assertEqual(True, comparator.is_leaf(str()))\\n self.assertEqual(False, comparator.is_leaf(list()))\\n self.assertEqual(False, comparator.is_leaf(dict()))\",\n \"def test_parent_read_only():\\n t = Tree(None)\\n with pytest.raises(AttributeError):\\n t.parent = None\",\n \"def test_depth_known(our_bsts):\\n assert our_bsts[0].depth() == our_bsts[1]\",\n \"def test_leafs():\\n leafs = ['s6675', 's136315', 's10765', 's106594', 's131']\\n for leaf in leafs:\\n synset = germanet_data.get_synset_by_id(leaf)\\n np.testing.assert_equal(synset.is_root(), False)\\n np.testing.assert_equal(synset.is_leaf(), True)\",\n \"def assertStructure(self, root, dirDict):\\n children = [x.basename() for x in root.children()]\\n for x in dirDict:\\n child = root.child(x)\\n if isinstance(dirDict[x], dict):\\n self.assertTrue(child.isdir(), \\\"%s is not a dir!\\\"\\n % (child.path,))\\n self.assertStructure(child, dirDict[x])\\n else:\\n a = child.getContent().replace(os.linesep, '\\\\n')\\n self.assertEquals(a, dirDict[x], child.path)\\n children.remove(x)\\n if children:\\n self.fail(\\\"There were extra children in %s: %s\\\"\\n % (root.path, children))\",\n \"def _gen_test_tree_6():\\n tree = BinaryNode(20)\\n tree.left = BinaryNode(10)\\n tree.right = BinaryNode(30)\\n tree.left.right = BinaryNode(25)\\n return tree\",\n \"def test_validate_valid_crisis(self):\\r\\n assert self.crisis_tree != 0\",\n \"def test_data_read_only():\\n t = Tree(None)\\n with pytest.raises(AttributeError):\\n t.data = 0\",\n \"def assert_parse_tree (code, expected):\\n tranql = TranQL ()\\n tranql.resolve_names = False\\n actual = tranql.parser.parse (code).parse_tree\\n #print (f\\\"{actual}\\\")\\n assert_lists_equal (\\n actual,\\n expected)\",\n \"def test_compare_old_to_new_method_to_create_trees(self):\\n nodes = util.generate_sequence_of_points(2, 2)\\n tree1 = kdtree.createNewTree(nodes)\\n kdtree.visualize(tree1)\\n \\n sel_axis = (lambda axis: axis)\\n tree2 = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\\n tree2.split2([0.25, 0.5], axis = 1)\\n tree2.split2([0.75, 0.5], axis = 1)\\n \\n #left\\n tree2.split2([0.25, 0.25], axis = 0, sel_axis = sel_axis)\\n tree2.split2([0.25, 0.75], axis = 0, sel_axis = sel_axis)\\n \\n #right\\n tree2.split2([0.75, 0.25], axis = 0, sel_axis = sel_axis)\\n tree2.split2([0.75, 0.75], axis = 0, sel_axis = sel_axis)\\n \\n kdtree.visualize(tree2)\\n \\n for n in zip(kdtree.level_order(tree1), kdtree.level_order(tree2)):\\n self.assertEqual(n[0].data, n[1].data, \\\"elements not equal\\\")\\n \\n if n[0].data is not None and n[1].data is not None:\\n self.assertEqual(n[0].axis, n[1].axis, \\\"elements not equal\\\")\",\n \"def test_tree_mode3(self):\\n xpb = XPathBuilder()\\n xp_1 = xpb.foo\\n xp_2 = xpb.baz\\n xp_and = xp_1 & xp_2\\n self.assertTrue(xp_and._parent is None)\\n self.assertTrue(len(xp_and._children) == 2)\\n self.assertTrue(xp_and._children[0] is xp_1)\\n self.assertTrue(xp_and._children[1] is xp_2)\\n self.assertTrue(xp_1._parent is xp_and)\\n self.assertTrue(len(xp_1._children) == 0)\\n self.assertTrue(xp_2._parent is xp_and)\\n self.assertTrue(len(xp_2._children) == 0)\\n xp_and.remove_child(xp_2)\\n # check references after remove\\n self.assertTrue(xp_and._parent is None)\\n self.assertTrue(len(xp_and._children) == 1)\\n self.assertTrue(xp_and._children[0] is xp_1)\\n self.assertTrue(xp_1._parent is xp_and)\\n self.assertTrue(len(xp_1._children) == 0)\\n # xp_2's references were changed\\n self.assertTrue(xp_2._parent is None)\\n self.assertTrue(len(xp_2._children) == 0)\",\n \"def test_init(self):\\r\\n p = TreeBuilder({})\\r\\n self.assertEqual(p.Name, 'TreeBuilder')\\r\\n self.assertEqual(p.Params, {})\",\n \"def test_contains_returns_false_on_empty_tree(bst_empty):\\n assert bst_empty.contains(4) is False\",\n \"def test_init_root():\\n from bst import BST\\n bst = BST()\\n # import pdb; pdb.set_trace()\\n assert bst.root is None\",\n \"def validate_tree(self, treenum, tree, halonum=None):\\n # Check size\\n if treenum == -1:\\n nhalos = self.totnhalos\\n halonum = None\\n else:\\n if halonum is not None:\\n nhalos = 1\\n else:\\n nhalos = self.nhalos_per_tree[treenum]\\n fields = list(tree.keys())\\n for k in fields:\\n assert (len(tree[k]) == nhalos)\\n # Check fields\\n for k in self.raw_fields:\\n assert (k in fields)\\n # Don't check tree indices for a single halo\\n if halonum is not None:\\n return\\n # For all trees get list of local nhalos for every halo\\n if treenum == -1:\\n treenum_arr = self.treenum_arr\\n nhalos = self.nhalos_per_tree[treenum_arr]\\n # Check that halos are within tree\\n for k in halo_fields:\\n assert ((tree[k] < nhalos).all())\\n # Check FOF central exists and all subs in one snapshot\\n central = tree['FirstHaloInFOFgroup']\\n assert ((central >= 0).all())\\n if treenum == -1:\\n central = self.get_total_index(treenum_arr, central)\\n assert ((tree['SnapNum'] == tree['SnapNum'][central]).all())\\n # Check that progenitors/descendants are back/forward in time\\n descend = tree['Descendant'].astype('i4')\\n has_descend = (descend >= 0)\\n not_descend = np.logical_not(has_descend)\\n # Not strictly True\\n # assert ((tree['SnapNum'][not_descend] ==\\n # (len(self.scale_factors) - 1)).all())\\n if treenum == -1:\\n descend = self.get_total_index(treenum_arr, descend)\\n assert ((tree['SnapNum'][descend[has_descend]] >\\n tree['SnapNum'][has_descend]).all())\\n # Check progenitors are back in time\\n descend[not_descend] = np.where(not_descend)[0]\\n progen1 = tree['FirstProgenitor']\\n progen2 = tree['NextProgenitor']\\n has_progen1 = (progen1 >= 0)\\n has_progen2 = (progen2 >= 0)\\n if treenum == -1:\\n progen1 = self.get_total_index(treenum_arr, progen1)\\n progen2 = self.get_total_index(treenum_arr, progen2)\\n assert ((tree['SnapNum'][progen1[has_progen1]] <=\\n tree['SnapNum'][descend[has_progen1]]).all())\\n assert ((tree['SnapNum'][progen2[has_progen2]] <=\\n tree['SnapNum'][descend[has_progen2]]).all())\",\n \"def test_is_bst(tree: BSTNode) -> None:\\n output = [n.value for n in tree.in_order(tree)]\\n assert output == sorted(output)\",\n \"def _gen_test_tree_3():\\n tree = BinaryNode(5)\\n tree.left = BinaryNode(1)\\n tree.left.left = BinaryNode(2)\\n tree.left.right = BinaryNode(3)\\n tree.right = BinaryNode(7)\\n tree.right.left = BinaryNode(8)\\n tree.right.right = BinaryNode(9)\\n return tree\",\n \"def test_compiler_parse_tree(compiler, patch):\\n patch.object(Compiler, 'subtree')\\n tree = Tree('start', [Tree('command', ['token'])])\\n compiler.parse_tree(tree)\\n compiler.subtree.assert_called_with(Tree('command', ['token']),\\n parent=None)\",\n \"def test_tree_with_one_node_balance_is_zero(one_t):\\n assert one_t.balance() == 0\",\n \"def _gen_test_tree_4():\\n tree = BinaryNode(5)\\n tree.left = BinaryNode(3)\\n tree.left.left = BinaryNode(2)\\n tree.left.right = BinaryNode(10)\\n tree.right = BinaryNode(9)\\n tree.right.left = BinaryNode(6)\\n tree.right.right = BinaryNode(8)\\n return tree\",\n \"def _gen_test_tree_2():\\n tree = BinaryNode(5)\\n tree.left = BinaryNode(3)\\n tree.left.left = BinaryNode(2)\\n tree.left.left.left = BinaryNode(1)\\n tree.left.right = BinaryNode(4)\\n tree.right = BinaryNode(7)\\n tree.right.left = BinaryNode(6)\\n tree.right.right = BinaryNode(8)\\n tree.right.right.right = BinaryNode(9)\\n return tree\",\n \"def IsLeaf(self):\\n return not self.subtests\",\n \"def _gen_test_tree_1():\\n tree = BinaryNode(5)\\n tree.left = BinaryNode(5)\\n return tree\",\n \"def setUp(self):\\n\\n # Valid tree:\\n self.valid_tree = Node(1)\\n self.valid_tree.left = Node(2)\\n self.valid_tree.right = Node(3)\\n self.valid_tree.left.left = Node(4)\\n self.valid_tree.left.right = Node(5)\\n self.valid_tree.right.left = Node(6)\\n self.valid_tree.right.right = Node(7)\\n self.valid_tree.left.right.left = Node(8)\\n self.valid_tree.right.right.right = Node(9)\\n self.valid_tree.right.right.right.left = Node(10)\\n\\n # Empty tree\\n\\n self.empty_tree = None\\n\\n # Tree only consisting of root\\n\\n self.only_root = Node(1)\\n\\n # DAG example for Wikipedia\\n # https://en.wikipedia.org/wiki/Directed_acyclic_graph#/media/File:Tred-G.svg\\n\\n self.dag_example = DAG(\\n [\\n # A B C D E\\n [False, True, True, True, True], # A \\n [False, False, False, True, False], # B\\n [False, False, False, True, True], # C \\n [False, False, False, False, True], # D \\n [False, False, False, False, False] # E\\n ]\\n )\\n\\n # DAG example from Baeldung\\n # https://www.baeldung.com/wp-content/uploads/sites/4/2021/01/Dag-3.jpg\\n\\n self.dag_complex = DAG(\\n [\\n # 0 1 2 3 4 5 6 7 8\\n [False, True, True, False, False, False, False, False, False], # 0 \\n [False, False, False, False, True, False, True, False, False], # 1\\n [False, False, False, True, True, False, True, False, False], # 2 \\n [False, False, False, False, False, False, True, False, False], # 3 \\n [False, False, False, False, False, False, False, False, False], # 4\\n [False, False, False, False, False, False, False, False, False], # 5 \\n [False, False, False, False, False, True, False, True, False], # 6 \\n [False, False, False, False, False, False, False, False, True ], # 7 \\n [False, False, False, False, False, False, False, False, False] # 8\\n ]\\n )\\n\\n # DAG with multiple roots\\n\\n self.dag_multiple_roots = DAG(\\n [\\n # 0 1 2 3 4 5 6 7 8 9\\n [False, False, False, False, False, False, False, True, False, False ], # 0\\n [False, False, False, True, False, False, False, False, False, False ], # 1 \\n [False, False, False, False, True, False, False, True, False, False ], # 2 \\n [False, False, False, False, False, True, False, False, False, False ], # 3\\n [False, False, False, False, False, True, True, False, False, False ], # 4\\n [False, False, False, False, False, False, False, False, True, True ], # 5\\n [False, False, False, False, False, False, False, False, False, True ], # 6 \\n [False, False, False, False, False, False, True, False, False, False ], # 7\\n [False, False, False, False, False, False, False, False, False, False ], # 8\\n [False, False, False, False, False, False, False, False, False, False ], # 9\\n ]\\n )\\n\\n # Set up logging\\n logging.basicConfig(filename=\\\"lca_test.log\\\",\\n encoding=\\\"utf-8\\\", level=logging.INFO)\",\n \"def test_depth_returns_correct_value_balanced_tree(bst_balanced):\\n assert bst_balanced.depth() == 3\",\n \"def test_tree_2_nodes_left_unbalanced(one_t):\\n one_t.insert(9)\\n assert one_t.balance() == 1\",\n \"def test_print_tree(self) -> None:\\n\\n def get_children(node):\\n return node.children\\n\\n save_stdout = sys.stdout\\n\\n try:\\n node, expect, withtags = self.tree_case_1()\\n\\n IOStream = io.StringIO\\n sys.stdout = IOStream()\\n print_tree(node, get_children)\\n actual = sys.stdout.getvalue()\\n assert expect == actual, (expect, actual)\\n\\n sys.stdout = IOStream()\\n print_tree(node, get_children, showtags=1)\\n actual = sys.stdout.getvalue()\\n assert withtags == actual, (withtags, actual)\\n\\n # Test that explicitly setting prune to zero works\\n # the same as the default (see above)\\n node, expect, withtags = self.tree_case_2(prune=0)\\n\\n sys.stdout = IOStream()\\n print_tree(node, get_children, 0)\\n actual = sys.stdout.getvalue()\\n assert expect == actual, (expect, actual)\\n\\n sys.stdout = IOStream()\\n print_tree(node, get_children, 0, showtags=1)\\n actual = sys.stdout.getvalue()\\n assert withtags == actual, (withtags, actual)\\n\\n # Test output with prune=1\\n node, expect, withtags = self.tree_case_2(prune=1)\\n\\n sys.stdout = IOStream()\\n print_tree(node, get_children, 1)\\n actual = sys.stdout.getvalue()\\n assert expect == actual, (expect, actual)\\n\\n # Ensure that we can call print_tree on the same Node\\n # again. This wasn't possible in version 2.4.1 and earlier\\n # due to a bug in print_tree (visited was set to {} as default\\n # parameter)\\n sys.stdout = IOStream()\\n print_tree(node, get_children, 1)\\n actual = sys.stdout.getvalue()\\n assert expect == actual, (expect, actual)\\n\\n sys.stdout = IOStream()\\n print_tree(node, get_children, 1, showtags=1)\\n actual = sys.stdout.getvalue()\\n assert withtags == actual, (withtags, actual)\\n finally:\\n sys.stdout = save_stdout\",\n \"def valid_tree(phi):\\n q = deque([phi]) # queue of nodes to check\\n visited = list() # already checked\\n\\n # save the indim of the root node, and make sure all the indims\\n # of the children are the same\\n indim = phi.indim\\n retval = True\\n varsfound = 0\\n\\n while len(q) > 0:\\n # node to check\\n node = q.popleft()\\n\\n # check outdim\\n if isinstance(node, amnet.Variable):\\n retval &= (node.outdim == node.indim)\\n varsfound += 1\\n elif isinstance(node, amnet.Linear):\\n m, n = node.w.shape\\n retval &= (node.outdim == m)\\n retval &= (node.x.outdim == n)\\n retval &= (all([bi == 0 for bi in node.b])) # check value\\n elif isinstance(node, amnet.Constant):\\n retval &= (node.outdim == len(node.b))\\n retval &= (all([wij == 0 for wij in np.nditer(node.w)])) # check value\\n elif isinstance(node, amnet.Affine):\\n m, n = node.w.shape\\n retval &= (node.outdim == m)\\n retval &= (node.x.outdim == n)\\n retval &= (m == len(node.b))\\n elif isinstance(node, amnet.Mu):\\n retval &= (node.outdim == node.x.outdim)\\n retval &= (node.outdim == node.y.outdim)\\n retval &= (node.z.outdim == 1)\\n elif isinstance(node, amnet.Stack):\\n retval &= (node.outdim == node.x.outdim + node.y.outdim)\\n else:\\n retval = False # unknown node type\\n\\n # check indim\\n retval &= (node.indim == indim)\\n\\n # short-circuit if an inconsistency has been found\\n if not retval:\\n return False\\n\\n # add children to queue\\n if not(any(node is e for e in visited)):\\n visited.append(node)\\n #q.extend(children(node))\\n q.extend([c for c in children(node) if c not in visited])\\n\\n # finished iterating\\n # TODO: also check if graph is cyclic\\n return (varsfound == 1)\",\n \"def test_cannot_operate_on_rootless():\\n builder = TreeBuilder()\\n\\n with pytest.raises(ValueError):\\n builder.move_to_root()\\n\\n with pytest.raises(ValueError):\\n builder.move_to_parent()\\n\\n with pytest.raises(ValueError):\\n builder.build()\",\n \"def test_root():\\n gnroot = 's51001'\\n root = germanet_data.get_synset_by_id(gnroot)\\n np.testing.assert_equal(root.is_root(), True)\\n np.testing.assert_equal(root.is_leaf(), False)\",\n \"def test_print_level_order(depth_one_tree):\\n assert print_level_order(depth_one_tree) == ['0', '1 2 3 4']\",\n \"def test_equivalency(self):\\n def compare_func(obj, node):\\n # same id\\n self.assertEqual(obj.id, node.get(\\\"id\\\"))\\n\\n # same html\\n self.assertEqual(obj.html.prettify, node.prettify)\\n\\n # parents have same id (only for non-root elements)\\n if not obj == self.document.root:\\n self.assertEqual(obj.parent.id, node.parent.get(\\\"id\\\"))\\n\\n # same number of children\\n child_nodes = self.get_children_of_node(node)\\n self.assertEqual(len(obj.children), len(child_nodes))\\n\\n # children have same ids\\n for (child_obj, child_node) in zip(obj.children, child_nodes):\\n self.assertEqual(child_obj.id, child_node.get(\\\"id\\\"))\\n\\n self.recursively_compare_tree_against_html(compare_func)\",\n \"def test_build_match_tree_with_empty():\\n abbreviation_list = []\\n expected_tree = {}\\n tree = build_match_tree(abbreviation_list)\\n assert repr(tree) == repr(expected_tree)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8074132","0.75645053","0.75372213","0.75328934","0.7508595","0.74147695","0.7401527","0.73936456","0.7295448","0.7258387","0.72362375","0.7197044","0.7170132","0.71507156","0.7150426","0.71499306","0.71315193","0.70960915","0.708435","0.7022881","0.7012519","0.70121175","0.700324","0.698976","0.69815874","0.69684774","0.6904344","0.68346566","0.6824102","0.6817784","0.68162525","0.6799948","0.67894703","0.676631","0.675264","0.6746473","0.66836023","0.66707426","0.66701865","0.6632143","0.66293657","0.662556","0.6624462","0.66155756","0.6612412","0.660079","0.6580534","0.6579865","0.6576666","0.65737164","0.6571669","0.6546094","0.65401936","0.6524139","0.6517418","0.6513792","0.6500071","0.649968","0.64943343","0.6485505","0.6480562","0.64796513","0.64706665","0.6470477","0.64680445","0.64544916","0.6436716","0.6428801","0.64262295","0.64146394","0.64113754","0.640541","0.63888425","0.6386039","0.6374106","0.6349564","0.63383454","0.63222796","0.6322117","0.6321553","0.6320402","0.6311544","0.6305733","0.6304935","0.6304758","0.6304326","0.6303018","0.62932837","0.62896234","0.6286751","0.6285932","0.6278384","0.6275047","0.6271475","0.62709177","0.6264914","0.6243953","0.624366","0.624211","0.6239485"],"string":"[\n \"0.8074132\",\n \"0.75645053\",\n \"0.75372213\",\n \"0.75328934\",\n \"0.7508595\",\n \"0.74147695\",\n \"0.7401527\",\n \"0.73936456\",\n \"0.7295448\",\n \"0.7258387\",\n \"0.72362375\",\n \"0.7197044\",\n \"0.7170132\",\n \"0.71507156\",\n \"0.7150426\",\n \"0.71499306\",\n \"0.71315193\",\n \"0.70960915\",\n \"0.708435\",\n \"0.7022881\",\n \"0.7012519\",\n \"0.70121175\",\n \"0.700324\",\n \"0.698976\",\n \"0.69815874\",\n \"0.69684774\",\n \"0.6904344\",\n \"0.68346566\",\n \"0.6824102\",\n \"0.6817784\",\n \"0.68162525\",\n \"0.6799948\",\n \"0.67894703\",\n \"0.676631\",\n \"0.675264\",\n \"0.6746473\",\n \"0.66836023\",\n \"0.66707426\",\n \"0.66701865\",\n \"0.6632143\",\n \"0.66293657\",\n \"0.662556\",\n \"0.6624462\",\n \"0.66155756\",\n \"0.6612412\",\n \"0.660079\",\n \"0.6580534\",\n \"0.6579865\",\n \"0.6576666\",\n \"0.65737164\",\n \"0.6571669\",\n \"0.6546094\",\n \"0.65401936\",\n \"0.6524139\",\n \"0.6517418\",\n \"0.6513792\",\n \"0.6500071\",\n \"0.649968\",\n \"0.64943343\",\n \"0.6485505\",\n \"0.6480562\",\n \"0.64796513\",\n \"0.64706665\",\n \"0.6470477\",\n \"0.64680445\",\n \"0.64544916\",\n \"0.6436716\",\n \"0.6428801\",\n \"0.64262295\",\n \"0.64146394\",\n \"0.64113754\",\n \"0.640541\",\n \"0.63888425\",\n \"0.6386039\",\n \"0.6374106\",\n \"0.6349564\",\n \"0.63383454\",\n \"0.63222796\",\n \"0.6322117\",\n \"0.6321553\",\n \"0.6320402\",\n \"0.6311544\",\n \"0.6305733\",\n \"0.6304935\",\n \"0.6304758\",\n \"0.6304326\",\n \"0.6303018\",\n \"0.62932837\",\n \"0.62896234\",\n \"0.6286751\",\n \"0.6285932\",\n \"0.6278384\",\n \"0.6275047\",\n \"0.6271475\",\n \"0.62709177\",\n \"0.6264914\",\n \"0.6243953\",\n \"0.624366\",\n \"0.624211\",\n \"0.6239485\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.80878603"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92886,"cells":{"query":{"kind":"string","value":"Test __len__ on a threenode tree."},"document":{"kind":"string","value":"def test02(self):\n\n t = tree(\"a\", [tree(\"b\"), tree(\"c\")]);\n self.assertEqual(len(t), 3)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __len__(self):\n return len(self.subtrees())","def __len__(self):\n return len(self.node)","def __len__(self):\n return self.tree.filled_size()","def __len__(self) -> int:\n return len(self.nodes)","def __len__(self) -> int:\r\n return len(self._nodes)","def __len__(self):\n return self.count_of(CUBA.NODE)","def __len__(self):\n return len(self.nodes)","def __len__(self):\n if not self.has_been_iterated:\n self.has_been_iterated = True\n while True:\n try:\n self.next()\n except StopIteration:\n break\n\n return super(Tree, self).__len__()","def __len__(self):\n return 1 + sum([len(child) for child in self.children])","def test_len_children():\n builder = TreeBuilder()\n builder.create_root(0)\n\n data = list(range(2, 15, 3))\n subdata = [0, 1, 2, 3, 4]\n for datum in data:\n builder.add_child(datum, move=True)\n\n for subdatum in subdata:\n builder.add_child(subdatum)\n\n builder.move_to_parent()\n t = builder.build()\n\n assert len(t) == len(data)\n for child in t:\n assert len(child) == len(subdata)","def __len__(self):\n return len(self.subgraph_list)","def __len__(self) -> int:\n return 1 + sum(len(child) for child in self.children)","def __len__(self):\r\n return len(self.x) + sum(len(child) for child in self.children)","def n_trees(self):\n return len(self.data_kd)","def __len__():","def __len__():","def __len__():","def num_leaves(tree):\n return ((tree.n_node_samples > 0) & (tree.feature == INVALID_VALUE)).sum()","def __len__(self):\n # type: () -> int\n return len(self.data)","def num_actual_nodes(tree):\n return (tree.n_node_samples > 0).sum()","def __len__(self) -> int:\r\n return len(self._edges)","def __len__(self) -> int:\n return len(self.length)","def __len__(self) -> int:\n return len(self.__elements)","def size(self) -> int:\n return self.root.size if not self.empty() else 0","def __len__(self) -> float:\n return len(self.elements)","def num_children(self):\r\n return len(self.children)","def size(self):\n\t\treturn len(self.nodes)","def size(self) -> int:\n #binary search tree == empty\n if self.root is None:\n return 0\n\n #recursive helper count nodes\n return self.size_helper(self.root)","def num_trees(self) -> int:\n\n return len(self.nodes)","def total_len(BST):\r\n if isinstance(BST,tuple):\r\n return total_len(BST[0]) + total_len(BST[1])\r\n else:\r\n return len(BST)","def tree_size(self):\n if self._tree_size is not None:\n return self._tree_size\n if self.is_root:\n self.arbor._setup_tree(self)\n # pass back to the arbor to avoid calculating again\n self.arbor._store_node_info(self, '_tree_size')\n else:\n self._tree_size = len(list(self[\"tree\"]))\n return self._tree_size","def __len__(self):\n return len(self.top)","def len(self):\n L,R = 0,0\n if self.left is not None:\n L = self.left.len()\n if self.right is not None:\n R = self.right.len()\n return 1 + L + R","def __len__(self):\n return len(self.__parent)","def test_size_is_correct_on_filled_tree(bst_100_rand):\n assert bst_100_rand.size() == 100","def size(self):\n if len(self.children) == 0:\n return 1\n else:\n return 1 + sum([x.size() for x in self.children])","def __len__(self):\n return len(self.elements)","def __len__(self) -> int:\n return len(self.data)","def __len__(self) -> int:\n return len(self.data)","def __len__(self) -> int:\n return len(self.data)","def deep_len(lnk):\n \"*** YOUR CODE HERE ***\"\n if lnk == Link.empty:\n return 0\n elif type(lnk) is not Link:\n return 1\n else:\n return deep_len(lnk.first) + deep_len(lnk.rest)","def test_len(self):\n self.assertEqual(len(self.tester), 21)","def numNodes(T):\r\n n = 1\r\n if T.isLeaf:\r\n return n\r\n for i in range(len(T.child)):\r\n n += numNodes(T.child[i])\r\n return n","def test_level_width_1(self):\n root = Node(0)\n root.add(1)\n root.add(2)\n root.add(3)\n root.children[0].add(4)\n root.children[2].add(5)\n self.assertEqual(level_width(root), [1, 3, 2])","def __len__(self) -> int:","def __len__(self) -> int:","def test_len(self):\n self.assertEqual(len(self.tester), 30)","def sizeIsVlen(self):\n return self.rank > 0 and 'vlen' in self.tags","def __len__(self) -> int:\n return self._len","def get_tree_length(x):\n length = list(self.__plan_graph.objects(subject=x, predicate=AGORA.length)).pop()\n return length","def __len__(self): # pragma: no cover\n return self.size()","def size_node(node):\n if node is None:\n return 0\n return node.size","def __len__(self):\n return len(self.name_and_box_index)","def __len__(self):\n\t\treturn self.len","def _count_children(self, item):\n return len(self.tree.get_children(item))","def test_len(self):\n self.assertEqual(len(self.tester), 27)","def test_len(self):\n self.assertEqual(len(self.tester), 27)","def __len__(self) -> int:\n return self.length","def __len__(self):\n if self.altloc:\n return len(self.altloc)\n return 0","def _children_count(self):\n cnt = 0\n if self.left:\n cnt += 1\n if self.right:\n cnt += 1\n return cnt","def __len__(self) -> int:\n return len(self.targets)","def size(self) -> int:\n if self.root is None: # If tree is empty\n return 0\n\n return self.size_helper(self.root)","def __len__(self):\r\n return self.len","def __len__(self):\r\n return self.len","def __len__(self):\r\n return self.len","def __len__(self):\r\n return self.len","def __len__(self):\r\n return self.len","def num_trees(self):\n return self._ll_tree_sequence.get_num_trees()","def __len__(self):\n return len(self.data[self.name])","def __len__(self):\n return self.len","def __len__(self):\n return self.len","def __len__(self) -> int:\n return len(self._data)","def __len__(self) -> int:\n return len(self._data)","def get_num_children(self):\n return len(self.children)","def __len__(self):\n return self._len","def __len__(self):\n if self.path_is_string:\n if self.path:\n return 1\n else:\n return 0\n else:\n if self.path_type in (list, tuple):\n if not any(item for item in self.path):\n return 0\n return len(self.path)","def __len__(self):\n\t\treturn self.n","def __len__(self):\n return len(self.dtrs)","def __len__(self) -> int:\n return self.size","def __len__(self) -> int:\n return self.size","def __len__(self) -> int:\n return self.size","def tree_size(self) -> int:\n Q = Queue()\n count = 0\n Q.put(self.root)\n while not Q.empty():\n node = Q.get()\n count += 1\n for child in node.children.values():\n Q.put(child)\n return count","def test_len(self):\n l_list = DoubleLinkedList()\n l_list.push(12)\n l_list.push(123)\n l_list.push(1234)\n l_list.push(1234)\n l_list.pop()\n l_list.pop()\n self.assertEqual(l_list.len(), 2)","def __len__(self):\n len(self.data)","def __len__(self) -> int:\n return self._length","def test_len_when_empty(self):\n l_list = DoubleLinkedList()\n self.assertEqual(l_list.len(), 0)","def __len__(self):\n return self.length","def __len__(self):\n return self.length","def __len__(self):\n return self.length","def __len__(self):\n return self.length","def __len__(self):\n return self.length","def __len__(self):\n return self.length","def __len__(self) -> int:\n return len(self.value)","def test_empty_tree_size(empty_trie):\n assert empty_trie.size == 0","def __len__(self):\n return self.__length","def get_n_leaves(clf):\n leaves = clf.tree_.children_left == -1\n leaves = np.arange(0,clf.tree_.node_count)[leaves]\n return len(leaves)","def __len__(self):\n return len(self.stack)","def get_tree_size(self, node):\n\n # If the tree has not been created yet.\n if node == None:\n return 0\n n_nodes = 1\n for child in node.children:\n n_nodes += self.get_tree_size(node.children[child])\n return n_nodes","def len(self):\n return self.__len__()","def test_level_width_2(self):\n root = Node(0)\n root.add(1)\n root.children[0].add(2)\n root.children[0].add(3)\n root.children[0].children[0].add(4)\n self.assertEqual(level_width(root), [1, 1, 2, 1])"],"string":"[\n \"def __len__(self):\\n return len(self.subtrees())\",\n \"def __len__(self):\\n return len(self.node)\",\n \"def __len__(self):\\n return self.tree.filled_size()\",\n \"def __len__(self) -> int:\\n return len(self.nodes)\",\n \"def __len__(self) -> int:\\r\\n return len(self._nodes)\",\n \"def __len__(self):\\n return self.count_of(CUBA.NODE)\",\n \"def __len__(self):\\n return len(self.nodes)\",\n \"def __len__(self):\\n if not self.has_been_iterated:\\n self.has_been_iterated = True\\n while True:\\n try:\\n self.next()\\n except StopIteration:\\n break\\n\\n return super(Tree, self).__len__()\",\n \"def __len__(self):\\n return 1 + sum([len(child) for child in self.children])\",\n \"def test_len_children():\\n builder = TreeBuilder()\\n builder.create_root(0)\\n\\n data = list(range(2, 15, 3))\\n subdata = [0, 1, 2, 3, 4]\\n for datum in data:\\n builder.add_child(datum, move=True)\\n\\n for subdatum in subdata:\\n builder.add_child(subdatum)\\n\\n builder.move_to_parent()\\n t = builder.build()\\n\\n assert len(t) == len(data)\\n for child in t:\\n assert len(child) == len(subdata)\",\n \"def __len__(self):\\n return len(self.subgraph_list)\",\n \"def __len__(self) -> int:\\n return 1 + sum(len(child) for child in self.children)\",\n \"def __len__(self):\\r\\n return len(self.x) + sum(len(child) for child in self.children)\",\n \"def n_trees(self):\\n return len(self.data_kd)\",\n \"def __len__():\",\n \"def __len__():\",\n \"def __len__():\",\n \"def num_leaves(tree):\\n return ((tree.n_node_samples > 0) & (tree.feature == INVALID_VALUE)).sum()\",\n \"def __len__(self):\\n # type: () -> int\\n return len(self.data)\",\n \"def num_actual_nodes(tree):\\n return (tree.n_node_samples > 0).sum()\",\n \"def __len__(self) -> int:\\r\\n return len(self._edges)\",\n \"def __len__(self) -> int:\\n return len(self.length)\",\n \"def __len__(self) -> int:\\n return len(self.__elements)\",\n \"def size(self) -> int:\\n return self.root.size if not self.empty() else 0\",\n \"def __len__(self) -> float:\\n return len(self.elements)\",\n \"def num_children(self):\\r\\n return len(self.children)\",\n \"def size(self):\\n\\t\\treturn len(self.nodes)\",\n \"def size(self) -> int:\\n #binary search tree == empty\\n if self.root is None:\\n return 0\\n\\n #recursive helper count nodes\\n return self.size_helper(self.root)\",\n \"def num_trees(self) -> int:\\n\\n return len(self.nodes)\",\n \"def total_len(BST):\\r\\n if isinstance(BST,tuple):\\r\\n return total_len(BST[0]) + total_len(BST[1])\\r\\n else:\\r\\n return len(BST)\",\n \"def tree_size(self):\\n if self._tree_size is not None:\\n return self._tree_size\\n if self.is_root:\\n self.arbor._setup_tree(self)\\n # pass back to the arbor to avoid calculating again\\n self.arbor._store_node_info(self, '_tree_size')\\n else:\\n self._tree_size = len(list(self[\\\"tree\\\"]))\\n return self._tree_size\",\n \"def __len__(self):\\n return len(self.top)\",\n \"def len(self):\\n L,R = 0,0\\n if self.left is not None:\\n L = self.left.len()\\n if self.right is not None:\\n R = self.right.len()\\n return 1 + L + R\",\n \"def __len__(self):\\n return len(self.__parent)\",\n \"def test_size_is_correct_on_filled_tree(bst_100_rand):\\n assert bst_100_rand.size() == 100\",\n \"def size(self):\\n if len(self.children) == 0:\\n return 1\\n else:\\n return 1 + sum([x.size() for x in self.children])\",\n \"def __len__(self):\\n return len(self.elements)\",\n \"def __len__(self) -> int:\\n return len(self.data)\",\n \"def __len__(self) -> int:\\n return len(self.data)\",\n \"def __len__(self) -> int:\\n return len(self.data)\",\n \"def deep_len(lnk):\\n \\\"*** YOUR CODE HERE ***\\\"\\n if lnk == Link.empty:\\n return 0\\n elif type(lnk) is not Link:\\n return 1\\n else:\\n return deep_len(lnk.first) + deep_len(lnk.rest)\",\n \"def test_len(self):\\n self.assertEqual(len(self.tester), 21)\",\n \"def numNodes(T):\\r\\n n = 1\\r\\n if T.isLeaf:\\r\\n return n\\r\\n for i in range(len(T.child)):\\r\\n n += numNodes(T.child[i])\\r\\n return n\",\n \"def test_level_width_1(self):\\n root = Node(0)\\n root.add(1)\\n root.add(2)\\n root.add(3)\\n root.children[0].add(4)\\n root.children[2].add(5)\\n self.assertEqual(level_width(root), [1, 3, 2])\",\n \"def __len__(self) -> int:\",\n \"def __len__(self) -> int:\",\n \"def test_len(self):\\n self.assertEqual(len(self.tester), 30)\",\n \"def sizeIsVlen(self):\\n return self.rank > 0 and 'vlen' in self.tags\",\n \"def __len__(self) -> int:\\n return self._len\",\n \"def get_tree_length(x):\\n length = list(self.__plan_graph.objects(subject=x, predicate=AGORA.length)).pop()\\n return length\",\n \"def __len__(self): # pragma: no cover\\n return self.size()\",\n \"def size_node(node):\\n if node is None:\\n return 0\\n return node.size\",\n \"def __len__(self):\\n return len(self.name_and_box_index)\",\n \"def __len__(self):\\n\\t\\treturn self.len\",\n \"def _count_children(self, item):\\n return len(self.tree.get_children(item))\",\n \"def test_len(self):\\n self.assertEqual(len(self.tester), 27)\",\n \"def test_len(self):\\n self.assertEqual(len(self.tester), 27)\",\n \"def __len__(self) -> int:\\n return self.length\",\n \"def __len__(self):\\n if self.altloc:\\n return len(self.altloc)\\n return 0\",\n \"def _children_count(self):\\n cnt = 0\\n if self.left:\\n cnt += 1\\n if self.right:\\n cnt += 1\\n return cnt\",\n \"def __len__(self) -> int:\\n return len(self.targets)\",\n \"def size(self) -> int:\\n if self.root is None: # If tree is empty\\n return 0\\n\\n return self.size_helper(self.root)\",\n \"def __len__(self):\\r\\n return self.len\",\n \"def __len__(self):\\r\\n return self.len\",\n \"def __len__(self):\\r\\n return self.len\",\n \"def __len__(self):\\r\\n return self.len\",\n \"def __len__(self):\\r\\n return self.len\",\n \"def num_trees(self):\\n return self._ll_tree_sequence.get_num_trees()\",\n \"def __len__(self):\\n return len(self.data[self.name])\",\n \"def __len__(self):\\n return self.len\",\n \"def __len__(self):\\n return self.len\",\n \"def __len__(self) -> int:\\n return len(self._data)\",\n \"def __len__(self) -> int:\\n return len(self._data)\",\n \"def get_num_children(self):\\n return len(self.children)\",\n \"def __len__(self):\\n return self._len\",\n \"def __len__(self):\\n if self.path_is_string:\\n if self.path:\\n return 1\\n else:\\n return 0\\n else:\\n if self.path_type in (list, tuple):\\n if not any(item for item in self.path):\\n return 0\\n return len(self.path)\",\n \"def __len__(self):\\n\\t\\treturn self.n\",\n \"def __len__(self):\\n return len(self.dtrs)\",\n \"def __len__(self) -> int:\\n return self.size\",\n \"def __len__(self) -> int:\\n return self.size\",\n \"def __len__(self) -> int:\\n return self.size\",\n \"def tree_size(self) -> int:\\n Q = Queue()\\n count = 0\\n Q.put(self.root)\\n while not Q.empty():\\n node = Q.get()\\n count += 1\\n for child in node.children.values():\\n Q.put(child)\\n return count\",\n \"def test_len(self):\\n l_list = DoubleLinkedList()\\n l_list.push(12)\\n l_list.push(123)\\n l_list.push(1234)\\n l_list.push(1234)\\n l_list.pop()\\n l_list.pop()\\n self.assertEqual(l_list.len(), 2)\",\n \"def __len__(self):\\n len(self.data)\",\n \"def __len__(self) -> int:\\n return self._length\",\n \"def test_len_when_empty(self):\\n l_list = DoubleLinkedList()\\n self.assertEqual(l_list.len(), 0)\",\n \"def __len__(self):\\n return self.length\",\n \"def __len__(self):\\n return self.length\",\n \"def __len__(self):\\n return self.length\",\n \"def __len__(self):\\n return self.length\",\n \"def __len__(self):\\n return self.length\",\n \"def __len__(self):\\n return self.length\",\n \"def __len__(self) -> int:\\n return len(self.value)\",\n \"def test_empty_tree_size(empty_trie):\\n assert empty_trie.size == 0\",\n \"def __len__(self):\\n return self.__length\",\n \"def get_n_leaves(clf):\\n leaves = clf.tree_.children_left == -1\\n leaves = np.arange(0,clf.tree_.node_count)[leaves]\\n return len(leaves)\",\n \"def __len__(self):\\n return len(self.stack)\",\n \"def get_tree_size(self, node):\\n\\n # If the tree has not been created yet.\\n if node == None:\\n return 0\\n n_nodes = 1\\n for child in node.children:\\n n_nodes += self.get_tree_size(node.children[child])\\n return n_nodes\",\n \"def len(self):\\n return self.__len__()\",\n \"def test_level_width_2(self):\\n root = Node(0)\\n root.add(1)\\n root.children[0].add(2)\\n root.children[0].add(3)\\n root.children[0].children[0].add(4)\\n self.assertEqual(level_width(root), [1, 1, 2, 1])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7968297","0.7580855","0.74269414","0.73743844","0.7341332","0.716077","0.71163964","0.69386286","0.69055265","0.6814265","0.67931795","0.6781239","0.67347807","0.666625","0.65411854","0.65411854","0.65411854","0.6505981","0.6462519","0.6437713","0.64302945","0.64172965","0.6411295","0.64035785","0.6394743","0.63875186","0.6377204","0.637528","0.63713264","0.635327","0.6346605","0.63347864","0.63187534","0.6315963","0.63072115","0.63061756","0.63034284","0.6300497","0.6300497","0.6300497","0.6299648","0.62954277","0.6289345","0.62888134","0.6286701","0.6286701","0.62860084","0.6283027","0.6280324","0.6278207","0.62775934","0.6258791","0.62525445","0.6251809","0.62496865","0.6244756","0.6244756","0.62406987","0.6236281","0.6235186","0.6233452","0.6228211","0.62275785","0.62275785","0.62275785","0.62275785","0.62275785","0.6225305","0.6213693","0.6208039","0.6208039","0.6201224","0.6201224","0.6193285","0.61870486","0.61842513","0.61822957","0.61818665","0.6181592","0.6181592","0.6181592","0.61803085","0.617811","0.6172103","0.6169209","0.61679614","0.61677814","0.61677814","0.61677814","0.61677814","0.61677814","0.61677814","0.6167393","0.61657214","0.61627156","0.6162509","0.6158674","0.61584926","0.61566484","0.61539596"],"string":"[\n \"0.7968297\",\n \"0.7580855\",\n \"0.74269414\",\n \"0.73743844\",\n \"0.7341332\",\n \"0.716077\",\n \"0.71163964\",\n \"0.69386286\",\n \"0.69055265\",\n \"0.6814265\",\n \"0.67931795\",\n \"0.6781239\",\n \"0.67347807\",\n \"0.666625\",\n \"0.65411854\",\n \"0.65411854\",\n \"0.65411854\",\n \"0.6505981\",\n \"0.6462519\",\n \"0.6437713\",\n \"0.64302945\",\n \"0.64172965\",\n \"0.6411295\",\n \"0.64035785\",\n \"0.6394743\",\n \"0.63875186\",\n \"0.6377204\",\n \"0.637528\",\n \"0.63713264\",\n \"0.635327\",\n \"0.6346605\",\n \"0.63347864\",\n \"0.63187534\",\n \"0.6315963\",\n \"0.63072115\",\n \"0.63061756\",\n \"0.63034284\",\n \"0.6300497\",\n \"0.6300497\",\n \"0.6300497\",\n \"0.6299648\",\n \"0.62954277\",\n \"0.6289345\",\n \"0.62888134\",\n \"0.6286701\",\n \"0.6286701\",\n \"0.62860084\",\n \"0.6283027\",\n \"0.6280324\",\n \"0.6278207\",\n \"0.62775934\",\n \"0.6258791\",\n \"0.62525445\",\n \"0.6251809\",\n \"0.62496865\",\n \"0.6244756\",\n \"0.6244756\",\n \"0.62406987\",\n \"0.6236281\",\n \"0.6235186\",\n \"0.6233452\",\n \"0.6228211\",\n \"0.62275785\",\n \"0.62275785\",\n \"0.62275785\",\n \"0.62275785\",\n \"0.62275785\",\n \"0.6225305\",\n \"0.6213693\",\n \"0.6208039\",\n \"0.6208039\",\n \"0.6201224\",\n \"0.6201224\",\n \"0.6193285\",\n \"0.61870486\",\n \"0.61842513\",\n \"0.61822957\",\n \"0.61818665\",\n \"0.6181592\",\n \"0.6181592\",\n \"0.6181592\",\n \"0.61803085\",\n \"0.617811\",\n \"0.6172103\",\n \"0.6169209\",\n \"0.61679614\",\n \"0.61677814\",\n \"0.61677814\",\n \"0.61677814\",\n \"0.61677814\",\n \"0.61677814\",\n \"0.61677814\",\n \"0.6167393\",\n \"0.61657214\",\n \"0.61627156\",\n \"0.6162509\",\n \"0.6158674\",\n \"0.61584926\",\n \"0.61566484\",\n \"0.61539596\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65768653"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":92887,"cells":{"query":{"kind":"string","value":"Test __str__ on a singlenode tree."},"document":{"kind":"string","value":"def test03(self):\n\n t = tree(\"a\");\n s = str(t)\n self.assertEqual(re.sub(\"\\s+\", \"\", s), \"a;\") # Remove spaces and test equality"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_node_str():\n a_left = Node(7, data='pl left')\n a_right = Node(42, data='pl right')\n a = Node(13, data='pl a', left=a_left, right=a_right)\n string_a = str(a)\n expect_string = '13'\n assert string_a == expect_string","def __str__(self):\n # Tricky to do iteratively so we do it recursively.\n return BST._str(\"\", self.root)","def __str__(self):\n return self._tree.toString()","def test_str():\n # Test for string special method with scalar Rnode objects\n x = Rnode(1.0)\n try:\n assert str(x) == 'Reverse-mode Rnode Object ( Values: 1.0 )'\n except AssertionError as e:\n print(e)\n raise AssertionError","def test_node_to_str(self):\n f = lws.node_to_str\n # normal\n assert f(('a', 'b')) == 'a: b'\n # exception\n assert f(('a',),) == \"('a',): \"\n assert f('a') == 'a: '","def test_binarytree_str_as_expected():\n input = (13, 42, 7)\n expected = 'BinaryTree | Root: 13'\n s = BinaryTree(input)\n actual = str(s)\n assert expected == actual","def test_node_str_return():\n input_a = [7, 13, 42]\n input_b = 42\n expected_a = str(input_a)\n expected_b = str(input_b)\n actual_a = str(Node(input_a))\n actual_b = str(Node(input_b))\n assert expected_a == actual_a\n assert expected_b == actual_b","def __str__(self):\n return self.str_parse_tree(0)","def __str__(self):\n return self.root_node","def test_node_str():\n node_a = Node({'name':['list','of','vertex']})\n assert str(node_a) == \"{'name':['list','of','vertex']}\"","def __str__(self):\n return str(self.root)","def leaf_str(self, value, depth, available):\n r = repr(value)\n if r[0]==\"'\":\n r = '\"' + r[1:-1].replace('\"', '\\\\\"').replace(\"\\\\'\", \"'\") + '\"'\n return r, False","def tree_string(self, indent=0): # pragma: no cover\r\n return \"\"","def test_str_method(self):\n s1 = Square(4, 6, 2, 12)\n self.assertEqual(s1.__str__(), '[Square] (12) 6/2 - 4')","def test__str__method(self):\n Rectangle.reset_objects()\n s1 = Square(5)\n self.assertEqual(str(s1), \"[Square] (1) 0/0 - 5\")\n s2 = Square(2, 2)\n self.assertEqual(str(s2), \"[Square] (2) 2/0 - 2\")\n s3 = Square(3, 1, 3)\n self.assertEqual(str(s3), \"[Square] (3) 1/3 - 3\")","def test_str(self):\n s1 = Square(4, 2, 3, 47)\n self.assertEqual(str(s1), \"[Square] (47) 2/3 - 4\")","def test_child_str(self):\n leaf = ChildRouteFactory.create(slug='leaf')\n\n self.assertEqual(str(leaf), 'Route @ /leaf/')","def test_str():\n c = Circle(4) \n assert c.__str__() == 'Circle with radius: 4.000000'","def __str__(self):\n pieces = [] # sequence of piecewise strings to compose\n self._parenthesize_recur(self.root(), pieces)\n return ''.join(pieces)","def __str__(self):\n pieces = [] # sequence of piecewise strings to compose\n self._parenthesize_recur(self.root(), pieces)\n return ''.join(pieces)","def _str(indent, root):\n if root is None:\n return \"\"\n else:\n return (BST._str(indent + \"\\t\", root.right) +\n indent + repr(root.item) + \"\\n\" +\n BST._str(indent + \"\\t\", root.left))","def visit_Struct(self, node):\n return str_node(node)","def test_node__repr():\n a_left = Node(7, data='pl left')\n a_right = Node(42, data='pl right')\n a = Node(13, data='pl a', left=a_left, right=a_right)\n repr_a = repr(a)\n expect_repr = '<Node | Val: 13 | Data: pl a | Left: 7 | Right: 42>'\n assert expect_repr == repr_a","def __str__(self):\n\n\t\tif not self.root:\n\t\t\treturn str([])\n\n\t\tQ = [self.root]\n\t\tvals = []\n\t\twhile Q:\n\t\t\tnode = Q.pop(0)\n\t\t\tif node:\n\t\t\t\tvals.append(node.val)\n\t\t\t\tQ.append(node.left)\n\t\t\t\tQ.append(node.right)\n\t\t\telse:\n\t\t\t\tvals.append(None)\n\t\treturn str(vals)","def __str__(self):\n def recurse(node, level):\n s = \"\"\n if type(node) == LeafNode:\n return (\"| \" * level) + str(node) + \"\\n\"\n if node != None:\n s += recurse(node.rightOperand, level + 1)\n s += \"| \" * level\n s += str(node.operator) + \"\\n\"\n s += recurse(node.leftOperand, level + 1)\n return s\n return recurse(self, 0)","def __str__(self):\n outstr = ''\n if self._leftchild:\n outstr = outstr + str(self._leftchild)\n outstr = outstr + ' ' + str(self._element)\n if self._rightchild:\n outstr = outstr + str(self._rightchild)\n return outstr","def __str__(self):\n return str(self._root)","def __str__(self):\n string = \"\"\n cur_node = self.head\n while cur_node is not None:\n string += cur_node.data.__str__()\n cur_node = cur_node.next\n return string","def __repr__(self: 'StarTree') -> str:\n return 'StarTree({})'.format(repr(self.children[0]))","def test___str__(self):\n self.assertEqual(\n str(self.mineral),\n 'mineralxy')","def __str__(self):\r\n T = Btree(2)\r\n T.root = Node(self.keys, [Node(child.keys, []) for child in self.children])\r\n return str(T)","def __str__(self):\r\n return Assert(self.obj.__str__())","def test_children_tree(depth_one_tree):\n assert str(depth_one_tree.root.children) == str([1, 2, 3, 4])","def test_str(self):\n self.assertEqual(str(self.bs), str(self.wbs))\n self.assertEqual(str(self.be), str(self.be))\n # str(us) fails in Python 2\n self.assertEqual(str, type(str(self.wus)))\n # str(ue) fails in Python 2\n self.assertEqual(str, type(str(self.wue)))","def test_str(self):\n step = G(Step, display_name='test1')\n self.assertEqual('test1', str(step))","def test04(self):\n\n s = \"a;\"\n t = parse_newick(s);\n self.assertTrue(self.isTree(t) and t.label == \"a\" and t.isLeaf())","def __str__(self) -> str:\n\t\treturn get_node_description(self.name)","def __str__(self):\n\t\tself._synchronize_attributes()\n\t\ts = \"\"\n\t\tqueue = c3.Queue()\n\t\tlevel = 0\n\t\tqueue.enqueue((1, self._root))\n\t\twhile queue.peek():\n\t\t\tnodelev, node = queue.dequeue()._data\n\t\t\tif (not node):\n\n\t\t\t\t#NODE IS NOT THERE - just a placeholder\n\t\t\t\t#print spacing and enqueue fake left and right children\n\t\t\t\t#but stops if they would be past the max depth of the tree\n\t\t\t\tif ((self._depth - nodelev + 1) <= 0):\n\t\t\t\t\tcontinue\n\n\t\t\t\tif (nodelev != level):\n\t\t\t\t\ts += \"\\n\"\n\t\t\t\t\t#PRINT THE INDENT\n\t\t\t\t\tindent = \" \"*int((self._max_chars)*(2**(self._depth - nodelev) - 1))\n\t\t\t\t\ts += indent\n\t\t\t\t\tlevel = nodelev\n\n\t\t\t\t#PRINT THE SPACING\n\t\t\t\ts += \" \"*(self._max_chars)*(2**(self._depth - nodelev + 1) - 1)\n\n\t\t\t\t#PRINT SPACES TO REPLACE DATA\n\t\t\t\ts += \" \"*self._max_chars\n\n\t\t\t\t#Enqueue fake children\n\t\t\t\tqueue.enqueue((nodelev + 1, None))\n\t\t\t\tqueue.enqueue((nodelev + 1, None))\n\t\t\t\tcontinue\n\n\t\t\tif (nodelev != level):\n\t\t\t\ts += \"\\n\"\n\t\t\t\t#PRINT THE INDENT\n\t\t\t\tindent = \" \"*(self._max_chars)*(2**(self._depth - nodelev) - 1)\n\t\t\t\ts += indent\n\t\t\t\tlevel = nodelev\n\n\t\t\t#adds preceding \"|\"s if the str length of the data is smaller than the max\n\t\t\tfor i in range(int(self._max_chars - len(str(node.value())))):\n\t\t\t\ts += \"|\"\n\t\t\ts += str(node.value()) \n\n\t\t\t#PRINT THE SPACING\n\t\t\tspacing = \" \"*(self._max_chars)*(2**(self._depth - nodelev + 1) - 1)\n\t\t\ts += spacing\n\n\t\t\t#Enqueues\n\t\t\tif node.lchild():\n\t\t\t\tqueue.enqueue((nodelev + 1, node.lchild()))\n\t\t\telse:\n\t\t\t\t#ENQUEUES A FAKE NODE IN ORDER TO FORMAT THE TREE FOR MISSING NODES\n\t\t\t\tqueue.enqueue((nodelev + 1, None))\n\t\t\tif node.rchild():\n\t\t\t\tqueue.enqueue((nodelev + 1, node.rchild()))\n\t\t\telse:\n\t\t\t\t#ENQUEUES A FAKE NODE IN ORDER TO FORMAT THE TREE FOR MISSING NODES\n\t\t\t\tqueue.enqueue((nodelev + 1, None))\n\t\ts += \"\\n\"\n\t\treturn s","def _str_helper(self, cur, values):\n # base case\n if cur is None:\n return\n # recursive case for left subtree\n self._str_helper(cur.left, values)\n # store value of current node\n values.append(str(cur.value))\n # recursive case for right subtree\n self._str_helper(cur.right, values)","def as_str(node):\n node_string = ' '.join(k for k, _ in node.leaves())\n return u' '.join(node_string.split())","def test_K_str(self):\n r = Rectangle(5, 2)\n s = '[Rectangle] (1) 0/0 - 5/2'\n self.assertEqual(str(r), s)\n r = Rectangle(1, 1, 1)\n s = '[Rectangle] (2) 1/0 - 1/1'\n self.assertEqual(str(r), s)\n r = Rectangle(3, 4, 5, 6)\n s = '[Rectangle] (3) 5/6 - 3/4'\n self.assertEqual(str(r), s)\n\n Base._Base__nb_objects = 0\n r1 = Rectangle(4, 6, 2, 1, 12)\n self.assertEqual(str(r1), \"[Rectangle] (12) 2/1 - 4/6\")\n\n r2 = Rectangle(5, 5, 1)\n self.assertEqual(str(r2), \"[Rectangle] (1) 1/0 - 5/5\")","def __str__(self):\n return 'BinarySearchTreeNode(' + str(self.element) + ')'","def serialize(node, tree=\"\"):\n \n \n if (not node): #Base case\n tree += \"# \"\n return tree\n tree += (str(node.val) + \" \")\n tree = serialize(node.left, tree)\n tree = serialize(node.right, tree)\n\n return tree","def _str_helper(self, cur, values):\n # base case\n if cur is None:\n return\n # recursive case for left subtree\n if cur.left:\n self._str_helper(cur.left, values)\n # store value of current node\n values.append(str(cur.value))\n # recursive case for right subtree\n if cur.right:\n self._str_helper(cur.right, values)","def test_str_(self):\n str(self.standardcode)\n repr(self.standardcode)","def test_node_repr_return():\n input = 42\n expected = f'<Node | Val: {input} | Next: None>'\n actual = repr(Node(input))\n assert expected == actual","def test_str(self):\n user = User()\n string = \"[User] ({}) {}\".format(user.id, user.__dict__)\n self.assertEqual(user.__str__(), string)","def test_str(self):\n tour = G(Tour, display_name='test1')\n self.assertEqual('test1', str(tour))","def test01(self):\n\n t = tree(\"a\", [tree(\"b\"), tree(\"c\")]);\n self.assertTrue(self.isTree(t))","def str_recursive(node):\n\n if node == None:\n return \"\"\n else:\n return str(node.item) + \" \" + LinkedList.str_recursive(node.next)","def str_single_path(self, node, _path_str=\"\"):\r\n while node.parent:\r\n _path_str = self.str_single_path(node.parent, _path_str)\r\n break\r\n\r\n _path_str += \" -> \"\r\n _path_str += str(node.get_info_in_tuple())\r\n\r\n return _path_str","def simple_str(self):\n pass","def testStringRepresentationOnInstantiation(self):\r\n self.assertEqual(str(self.tv), 'table')","def test_str_method(self):\n b1 = BaseModel()\n b1printed = b1.__str__()\n self.assertEqual(b1printed,\n \"[BaseModel] ({}) {}\".format(b1.id, b1.__dict__))","def __str__(self) -> str:\n values = []\n self._str_helper(self.root, values)\n return \"TREE in order { \" + \", \".join(values) + \" }\"","def __str__(self) -> str:\n values = []\n self._str_helper(self.root, values)\n return \"TREE in order { \" + \", \".join(values) + \" }\"","def __repr__(self: 'UnaryTree') -> str:\n return 'UnaryTree({}, {})'.format(\n repr(self.symbol), repr(self.children[0]))","def __str__(self):\n return _libsbml.string___str__(self)","def __str__(self):\n\n return LinkedList.str_recursive(self.front)","def print_tree(self):\n return \"\"","def test_str_method(self):\n _name = 'test-name'\n el = MarkerId(_name)\n self.assertEqual(el.__str__(), _name)","def view_tree(expr):\n print (srepr(expr))","def test_strmethod(self):\n b1 = BaseModel()\n self.assertEqual(type(str(b1)), str)","def __str__(self) -> str:","def __str__(self) -> str:","def __str__(self) -> str:","def __str__(self) -> str:","def __str__(self):\n s = \"--\\n\"\n for node in self:\n s += node.__str__() + \"\\n\"\n return s + \"--\"","def serialize(obj: TreeNode) -> str:\n operators = set(\",:_;()[]\")\n current_depth = 0\n nodes_left = [(obj, 0)]\n fh = ''\n while len(nodes_left) > 0:\n entry = nodes_left.pop()\n node, node_depth = entry\n if node.children and node_depth >= current_depth:\n fh += '('\n nodes_left.append(entry)\n nodes_left += ((child, node_depth + 1) for child in\n reversed(node.children))\n current_depth = node_depth + 1\n else:\n if node_depth < current_depth:\n fh += ')'\n current_depth -= 1\n\n # Note we don't check for None because there is no way to represent\n # an empty string as a label in Newick. Therefore, both None and ''\n # are considered to be the absence of a label.\n lblst = []\n if node.support is not None: # prevents support of NoneType\n lblst.append(str(node.support))\n if node.name: # prevents name of NoneType\n lblst.append(node.name)\n label = ':'.join(lblst)\n if label:\n escaped = \"%s\" % label.replace(\"'\", \"''\")\n if any(t in operators for t in label):\n fh += \"'\"\n fh += escaped\n fh += \"'\"\n else:\n fh += escaped.replace(\" \", \"_\")\n if nodes_left and nodes_left[-1][1] == current_depth:\n fh += ','\n\n fh += ';\\n'\n return fh","def test_repr(self):\n\n node = Node(\n {\n 'healthchecks': [],\n 'host': 'iwa-ait.org',\n 'port': 22,\n 'user': 'adm-technical',\n 'password': 'oh-some-secret'\n },\n {},\n mock.Mock()\n )\n\n self.assertIn('iwa-ait.org', str(node))\n self.assertIn('22', str(node))\n self.assertIn('adm-technical', str(node))\n self.assertNotIn('oh-some-secret', str(node))","def __str__(self) -> str:\n # The default str() for Function includes the arity, which is redundant\n # here. Just use the symbol's name.\n root_str = self.root.name\n children_str = ', '.join(str(child) for child in self.children)\n return f'{root_str}({children_str})'","def __repr__(self) ->str:\n # Our __repr__ is recursive, because it can also be called\n # via repr...!\n return ('{}({}, {})'.format(self.__class__.__name__,\n repr(self.value),\n repr(self.children))\n if self.children\n else 'Tree({})'.format(repr(self.value)))","def __str__(self):\n stubs = ['' for _ in range(self.nChildren())]\n label = dist = ''\n for i in range(self.nChildren()):\n stubs[i] = str(self.children[i])\n if self.dist or self.dist == 0.0:\n dist = ':' + str(self.dist)\n if self.label != None:\n label = str(self.label)\n if self.nChildren() == 0:\n return label + dist\n else:\n stubstr = '('\n for i in range(len(stubs) - 1):\n stubstr += stubs[i] + ','\n return stubstr + stubs[-1] + ')' + label + dist\n # there is no label\n '''\n if not self.left and self.right:\n return ',' + right\n elif self.left and not self.right:\n return left + ','\n elif self.left and self.right:\n return '(' + left + ',' + right + ')' + dist\n '''","def test_binarytree_repr_as_expected():\n input = [13, 42, 7]\n expected = '<BinaryTree | Root: 13>'\n r = BinaryTree(input)\n actual = repr(r)\n assert expected == actual","def __str__(self):\n result = xml.dom.minidom.parseString(\n xml.etree.ElementTree.tostring(\n self.ToXMLElement(), encoding='utf-8')).toprettyxml(indent=' ')\n\n return result","def test_graphid_str():\n id1 = _ir.GraphId(\"g1\")\n assert id1.str() == \"g1\"\n id2 = _ir.GraphId(\"foobar\")\n assert id2.str() == \"foobar\"","def __str__(self):\n raise NotImplementedError(\"__str__ not implemented for \"+str(type(self)))","def test_child_str(self):\n child = models.Child.objects.create(\n user=sample_user(),\n name=\"test name\"\n )\n self.assertEqual(str(child), child.name)","def test_is_str_rep_string(self):\n self.assertIsInstance(cardutils.Card(10,1).__str__(), str)","def test_parent_str(self):\n parent = models.Parent.objects.create(\n user=sample_user(),\n address=\"test add 1\",\n age=34,\n job=\"test 1\"\n )\n self.assertEqual(str(parent), parent.name)","def test_root_str(self):\n route = RouteFactory.create()\n\n self.assertEqual(str(route), 'Route @ /')","def test_repr():\n c = Circle(4) \n assert c.__repr__() == 'Circle(4)'","def __repr__(self: 'BinaryTree') -> str:\n return 'BinaryTree({}, {}, {})'.format(repr(self.symbol), \n repr(self.children[0]), \n repr(self.children[1]))","def test_string_representation(self) -> None:\n item = Item(text=\"some text\")\n self.assertEqual(str(item), \"some text\")","def __str__(self):\n current = self.root\n nodes = [self.root]\n final = str(self.root) + \"\\n\"\n count = 0\n while len(nodes) != 0:\n count += 1\n if count == 10:\n return \"\"\n temp = []\n for node in nodes:\n if node.left != None:\n temp.append(node.left)\n final += str(node.left) + \" \"\n else:\n final += \"_ \"\n if node.right != None:\n temp.append(node.right)\n final += str(node.right) + \" \"\n else:\n final += \"_ \"\n if temp == []:\n if node == nodes[len(nodes) - 1]:\n break\n final += \"\\n\"\n nodes = temp\n self.in_order_traversal()\n for item in self.traverse:\n final += str(item.key) + \" \"\n final += \"\\n\"\n return final","def rcontainer_tree_str(obj):\n tree_task = ContainerTreePrintTask()\n the_recurser = ObjectRecursion(tasks=[tree_task])\n return the_recurser.recurse(obj)[0][0]","def test_str(self):\r\n statobj = inputtypes.Status('test')\r\n self.assertEqual(str(statobj), 'test')\r\n self.assertEqual(unicode(statobj), u'test')","def test_str(self, r, rep):\n assert str(r) == rep","def get_tree_str(self, depth: int = 0) -> str:\n temp = \" \" * depth + str(self.head) + \"\\n\"\n for son in self.sons:\n temp += son.get_tree_str(depth + 1)\n return temp","def __str__(self):\n return str(self.__s)","def test_string_representation(self):\n entry = Meal(name=\"Foo Meal\")\n self.assertEqual(str(entry), 'Foo Meal')","def writetree(self, string):\n self.treebuf.write(string)\n if self.animal != None:\n self.animal.writetree(string)","def test_str(self):\n account = AccountFactory(username=\"bill\")\n self.assertEqual(account.__str__(), \"bill\")","def test_str(self):\n self.assertEqual(str(self.bioe), str(self.wbioe))\n self.assertEqual(str(self.uioe), str(self.wuioe))\n self.assertEqual(str(self.bose), str(self.wbose))\n self.assertEqual(str(self.uose), str(self.wuose))","def __unicode__(self):\n for n in self.children:\n if isinstance(n, StringType):\n return n\n return u\"\"","def __str__(self):\n _str = \"\"\n current_node = self._head\n while(current_node != None):\n _str += str(current_node.value)\n _str += \" -> \"\n current_node = current_node.next\n _str += \"None\"\n return _str","def is_simple(self):\n return self.upper_binary_tree() == self.lower_binary_tree()","def tree_to_string(tree):\n if type(tree) == Tree:\n return sum(list(map(tree_to_string, tree.children)), [])\n else:\n return [str(tree)]","def test_str(self):\n character = self.character\n\n self.assertEqual(str(character), self.character_raw['name'])","def tree2str(self, root: Optional[TreeNode]) -> str:\n if not root:\n return \"\"\n if not root.left and not root.right:\n return str(root.val)\n if not root.right:\n return f'{root.val}({self.tree2str(root.left)})'\n return f'{root.val}({self.tree2str(root.left)})({self.tree2str(root.right)})'"],"string":"[\n \"def test_node_str():\\n a_left = Node(7, data='pl left')\\n a_right = Node(42, data='pl right')\\n a = Node(13, data='pl a', left=a_left, right=a_right)\\n string_a = str(a)\\n expect_string = '13'\\n assert string_a == expect_string\",\n \"def __str__(self):\\n # Tricky to do iteratively so we do it recursively.\\n return BST._str(\\\"\\\", self.root)\",\n \"def __str__(self):\\n return self._tree.toString()\",\n \"def test_str():\\n # Test for string special method with scalar Rnode objects\\n x = Rnode(1.0)\\n try:\\n assert str(x) == 'Reverse-mode Rnode Object ( Values: 1.0 )'\\n except AssertionError as e:\\n print(e)\\n raise AssertionError\",\n \"def test_node_to_str(self):\\n f = lws.node_to_str\\n # normal\\n assert f(('a', 'b')) == 'a: b'\\n # exception\\n assert f(('a',),) == \\\"('a',): \\\"\\n assert f('a') == 'a: '\",\n \"def test_binarytree_str_as_expected():\\n input = (13, 42, 7)\\n expected = 'BinaryTree | Root: 13'\\n s = BinaryTree(input)\\n actual = str(s)\\n assert expected == actual\",\n \"def test_node_str_return():\\n input_a = [7, 13, 42]\\n input_b = 42\\n expected_a = str(input_a)\\n expected_b = str(input_b)\\n actual_a = str(Node(input_a))\\n actual_b = str(Node(input_b))\\n assert expected_a == actual_a\\n assert expected_b == actual_b\",\n \"def __str__(self):\\n return self.str_parse_tree(0)\",\n \"def __str__(self):\\n return self.root_node\",\n \"def test_node_str():\\n node_a = Node({'name':['list','of','vertex']})\\n assert str(node_a) == \\\"{'name':['list','of','vertex']}\\\"\",\n \"def __str__(self):\\n return str(self.root)\",\n \"def leaf_str(self, value, depth, available):\\n r = repr(value)\\n if r[0]==\\\"'\\\":\\n r = '\\\"' + r[1:-1].replace('\\\"', '\\\\\\\\\\\"').replace(\\\"\\\\\\\\'\\\", \\\"'\\\") + '\\\"'\\n return r, False\",\n \"def tree_string(self, indent=0): # pragma: no cover\\r\\n return \\\"\\\"\",\n \"def test_str_method(self):\\n s1 = Square(4, 6, 2, 12)\\n self.assertEqual(s1.__str__(), '[Square] (12) 6/2 - 4')\",\n \"def test__str__method(self):\\n Rectangle.reset_objects()\\n s1 = Square(5)\\n self.assertEqual(str(s1), \\\"[Square] (1) 0/0 - 5\\\")\\n s2 = Square(2, 2)\\n self.assertEqual(str(s2), \\\"[Square] (2) 2/0 - 2\\\")\\n s3 = Square(3, 1, 3)\\n self.assertEqual(str(s3), \\\"[Square] (3) 1/3 - 3\\\")\",\n \"def test_str(self):\\n s1 = Square(4, 2, 3, 47)\\n self.assertEqual(str(s1), \\\"[Square] (47) 2/3 - 4\\\")\",\n \"def test_child_str(self):\\n leaf = ChildRouteFactory.create(slug='leaf')\\n\\n self.assertEqual(str(leaf), 'Route @ /leaf/')\",\n \"def test_str():\\n c = Circle(4) \\n assert c.__str__() == 'Circle with radius: 4.000000'\",\n \"def __str__(self):\\n pieces = [] # sequence of piecewise strings to compose\\n self._parenthesize_recur(self.root(), pieces)\\n return ''.join(pieces)\",\n \"def __str__(self):\\n pieces = [] # sequence of piecewise strings to compose\\n self._parenthesize_recur(self.root(), pieces)\\n return ''.join(pieces)\",\n \"def _str(indent, root):\\n if root is None:\\n return \\\"\\\"\\n else:\\n return (BST._str(indent + \\\"\\\\t\\\", root.right) +\\n indent + repr(root.item) + \\\"\\\\n\\\" +\\n BST._str(indent + \\\"\\\\t\\\", root.left))\",\n \"def visit_Struct(self, node):\\n return str_node(node)\",\n \"def test_node__repr():\\n a_left = Node(7, data='pl left')\\n a_right = Node(42, data='pl right')\\n a = Node(13, data='pl a', left=a_left, right=a_right)\\n repr_a = repr(a)\\n expect_repr = '<Node | Val: 13 | Data: pl a | Left: 7 | Right: 42>'\\n assert expect_repr == repr_a\",\n \"def __str__(self):\\n\\n\\t\\tif not self.root:\\n\\t\\t\\treturn str([])\\n\\n\\t\\tQ = [self.root]\\n\\t\\tvals = []\\n\\t\\twhile Q:\\n\\t\\t\\tnode = Q.pop(0)\\n\\t\\t\\tif node:\\n\\t\\t\\t\\tvals.append(node.val)\\n\\t\\t\\t\\tQ.append(node.left)\\n\\t\\t\\t\\tQ.append(node.right)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tvals.append(None)\\n\\t\\treturn str(vals)\",\n \"def __str__(self):\\n def recurse(node, level):\\n s = \\\"\\\"\\n if type(node) == LeafNode:\\n return (\\\"| \\\" * level) + str(node) + \\\"\\\\n\\\"\\n if node != None:\\n s += recurse(node.rightOperand, level + 1)\\n s += \\\"| \\\" * level\\n s += str(node.operator) + \\\"\\\\n\\\"\\n s += recurse(node.leftOperand, level + 1)\\n return s\\n return recurse(self, 0)\",\n \"def __str__(self):\\n outstr = ''\\n if self._leftchild:\\n outstr = outstr + str(self._leftchild)\\n outstr = outstr + ' ' + str(self._element)\\n if self._rightchild:\\n outstr = outstr + str(self._rightchild)\\n return outstr\",\n \"def __str__(self):\\n return str(self._root)\",\n \"def __str__(self):\\n string = \\\"\\\"\\n cur_node = self.head\\n while cur_node is not None:\\n string += cur_node.data.__str__()\\n cur_node = cur_node.next\\n return string\",\n \"def __repr__(self: 'StarTree') -> str:\\n return 'StarTree({})'.format(repr(self.children[0]))\",\n \"def test___str__(self):\\n self.assertEqual(\\n str(self.mineral),\\n 'mineralxy')\",\n \"def __str__(self):\\r\\n T = Btree(2)\\r\\n T.root = Node(self.keys, [Node(child.keys, []) for child in self.children])\\r\\n return str(T)\",\n \"def __str__(self):\\r\\n return Assert(self.obj.__str__())\",\n \"def test_children_tree(depth_one_tree):\\n assert str(depth_one_tree.root.children) == str([1, 2, 3, 4])\",\n \"def test_str(self):\\n self.assertEqual(str(self.bs), str(self.wbs))\\n self.assertEqual(str(self.be), str(self.be))\\n # str(us) fails in Python 2\\n self.assertEqual(str, type(str(self.wus)))\\n # str(ue) fails in Python 2\\n self.assertEqual(str, type(str(self.wue)))\",\n \"def test_str(self):\\n step = G(Step, display_name='test1')\\n self.assertEqual('test1', str(step))\",\n \"def test04(self):\\n\\n s = \\\"a;\\\"\\n t = parse_newick(s);\\n self.assertTrue(self.isTree(t) and t.label == \\\"a\\\" and t.isLeaf())\",\n \"def __str__(self) -> str:\\n\\t\\treturn get_node_description(self.name)\",\n \"def __str__(self):\\n\\t\\tself._synchronize_attributes()\\n\\t\\ts = \\\"\\\"\\n\\t\\tqueue = c3.Queue()\\n\\t\\tlevel = 0\\n\\t\\tqueue.enqueue((1, self._root))\\n\\t\\twhile queue.peek():\\n\\t\\t\\tnodelev, node = queue.dequeue()._data\\n\\t\\t\\tif (not node):\\n\\n\\t\\t\\t\\t#NODE IS NOT THERE - just a placeholder\\n\\t\\t\\t\\t#print spacing and enqueue fake left and right children\\n\\t\\t\\t\\t#but stops if they would be past the max depth of the tree\\n\\t\\t\\t\\tif ((self._depth - nodelev + 1) <= 0):\\n\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t\\tif (nodelev != level):\\n\\t\\t\\t\\t\\ts += \\\"\\\\n\\\"\\n\\t\\t\\t\\t\\t#PRINT THE INDENT\\n\\t\\t\\t\\t\\tindent = \\\" \\\"*int((self._max_chars)*(2**(self._depth - nodelev) - 1))\\n\\t\\t\\t\\t\\ts += indent\\n\\t\\t\\t\\t\\tlevel = nodelev\\n\\n\\t\\t\\t\\t#PRINT THE SPACING\\n\\t\\t\\t\\ts += \\\" \\\"*(self._max_chars)*(2**(self._depth - nodelev + 1) - 1)\\n\\n\\t\\t\\t\\t#PRINT SPACES TO REPLACE DATA\\n\\t\\t\\t\\ts += \\\" \\\"*self._max_chars\\n\\n\\t\\t\\t\\t#Enqueue fake children\\n\\t\\t\\t\\tqueue.enqueue((nodelev + 1, None))\\n\\t\\t\\t\\tqueue.enqueue((nodelev + 1, None))\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\tif (nodelev != level):\\n\\t\\t\\t\\ts += \\\"\\\\n\\\"\\n\\t\\t\\t\\t#PRINT THE INDENT\\n\\t\\t\\t\\tindent = \\\" \\\"*(self._max_chars)*(2**(self._depth - nodelev) - 1)\\n\\t\\t\\t\\ts += indent\\n\\t\\t\\t\\tlevel = nodelev\\n\\n\\t\\t\\t#adds preceding \\\"|\\\"s if the str length of the data is smaller than the max\\n\\t\\t\\tfor i in range(int(self._max_chars - len(str(node.value())))):\\n\\t\\t\\t\\ts += \\\"|\\\"\\n\\t\\t\\ts += str(node.value()) \\n\\n\\t\\t\\t#PRINT THE SPACING\\n\\t\\t\\tspacing = \\\" \\\"*(self._max_chars)*(2**(self._depth - nodelev + 1) - 1)\\n\\t\\t\\ts += spacing\\n\\n\\t\\t\\t#Enqueues\\n\\t\\t\\tif node.lchild():\\n\\t\\t\\t\\tqueue.enqueue((nodelev + 1, node.lchild()))\\n\\t\\t\\telse:\\n\\t\\t\\t\\t#ENQUEUES A FAKE NODE IN ORDER TO FORMAT THE TREE FOR MISSING NODES\\n\\t\\t\\t\\tqueue.enqueue((nodelev + 1, None))\\n\\t\\t\\tif node.rchild():\\n\\t\\t\\t\\tqueue.enqueue((nodelev + 1, node.rchild()))\\n\\t\\t\\telse:\\n\\t\\t\\t\\t#ENQUEUES A FAKE NODE IN ORDER TO FORMAT THE TREE FOR MISSING NODES\\n\\t\\t\\t\\tqueue.enqueue((nodelev + 1, None))\\n\\t\\ts += \\\"\\\\n\\\"\\n\\t\\treturn s\",\n \"def _str_helper(self, cur, values):\\n # base case\\n if cur is None:\\n return\\n # recursive case for left subtree\\n self._str_helper(cur.left, values)\\n # store value of current node\\n values.append(str(cur.value))\\n # recursive case for right subtree\\n self._str_helper(cur.right, values)\",\n \"def as_str(node):\\n node_string = ' '.join(k for k, _ in node.leaves())\\n return u' '.join(node_string.split())\",\n \"def test_K_str(self):\\n r = Rectangle(5, 2)\\n s = '[Rectangle] (1) 0/0 - 5/2'\\n self.assertEqual(str(r), s)\\n r = Rectangle(1, 1, 1)\\n s = '[Rectangle] (2) 1/0 - 1/1'\\n self.assertEqual(str(r), s)\\n r = Rectangle(3, 4, 5, 6)\\n s = '[Rectangle] (3) 5/6 - 3/4'\\n self.assertEqual(str(r), s)\\n\\n Base._Base__nb_objects = 0\\n r1 = Rectangle(4, 6, 2, 1, 12)\\n self.assertEqual(str(r1), \\\"[Rectangle] (12) 2/1 - 4/6\\\")\\n\\n r2 = Rectangle(5, 5, 1)\\n self.assertEqual(str(r2), \\\"[Rectangle] (1) 1/0 - 5/5\\\")\",\n \"def __str__(self):\\n return 'BinarySearchTreeNode(' + str(self.element) + ')'\",\n \"def serialize(node, tree=\\\"\\\"):\\n \\n \\n if (not node): #Base case\\n tree += \\\"# \\\"\\n return tree\\n tree += (str(node.val) + \\\" \\\")\\n tree = serialize(node.left, tree)\\n tree = serialize(node.right, tree)\\n\\n return tree\",\n \"def _str_helper(self, cur, values):\\n # base case\\n if cur is None:\\n return\\n # recursive case for left subtree\\n if cur.left:\\n self._str_helper(cur.left, values)\\n # store value of current node\\n values.append(str(cur.value))\\n # recursive case for right subtree\\n if cur.right:\\n self._str_helper(cur.right, values)\",\n \"def test_str_(self):\\n str(self.standardcode)\\n repr(self.standardcode)\",\n \"def test_node_repr_return():\\n input = 42\\n expected = f'<Node | Val: {input} | Next: None>'\\n actual = repr(Node(input))\\n assert expected == actual\",\n \"def test_str(self):\\n user = User()\\n string = \\\"[User] ({}) {}\\\".format(user.id, user.__dict__)\\n self.assertEqual(user.__str__(), string)\",\n \"def test_str(self):\\n tour = G(Tour, display_name='test1')\\n self.assertEqual('test1', str(tour))\",\n \"def test01(self):\\n\\n t = tree(\\\"a\\\", [tree(\\\"b\\\"), tree(\\\"c\\\")]);\\n self.assertTrue(self.isTree(t))\",\n \"def str_recursive(node):\\n\\n if node == None:\\n return \\\"\\\"\\n else:\\n return str(node.item) + \\\" \\\" + LinkedList.str_recursive(node.next)\",\n \"def str_single_path(self, node, _path_str=\\\"\\\"):\\r\\n while node.parent:\\r\\n _path_str = self.str_single_path(node.parent, _path_str)\\r\\n break\\r\\n\\r\\n _path_str += \\\" -> \\\"\\r\\n _path_str += str(node.get_info_in_tuple())\\r\\n\\r\\n return _path_str\",\n \"def simple_str(self):\\n pass\",\n \"def testStringRepresentationOnInstantiation(self):\\r\\n self.assertEqual(str(self.tv), 'table')\",\n \"def test_str_method(self):\\n b1 = BaseModel()\\n b1printed = b1.__str__()\\n self.assertEqual(b1printed,\\n \\\"[BaseModel] ({}) {}\\\".format(b1.id, b1.__dict__))\",\n \"def __str__(self) -> str:\\n values = []\\n self._str_helper(self.root, values)\\n return \\\"TREE in order { \\\" + \\\", \\\".join(values) + \\\" }\\\"\",\n \"def __str__(self) -> str:\\n values = []\\n self._str_helper(self.root, values)\\n return \\\"TREE in order { \\\" + \\\", \\\".join(values) + \\\" }\\\"\",\n \"def __repr__(self: 'UnaryTree') -> str:\\n return 'UnaryTree({}, {})'.format(\\n repr(self.symbol), repr(self.children[0]))\",\n \"def __str__(self):\\n return _libsbml.string___str__(self)\",\n \"def __str__(self):\\n\\n return LinkedList.str_recursive(self.front)\",\n \"def print_tree(self):\\n return \\\"\\\"\",\n \"def test_str_method(self):\\n _name = 'test-name'\\n el = MarkerId(_name)\\n self.assertEqual(el.__str__(), _name)\",\n \"def view_tree(expr):\\n print (srepr(expr))\",\n \"def test_strmethod(self):\\n b1 = BaseModel()\\n self.assertEqual(type(str(b1)), str)\",\n \"def __str__(self) -> str:\",\n \"def __str__(self) -> str:\",\n \"def __str__(self) -> str:\",\n \"def __str__(self) -> str:\",\n \"def __str__(self):\\n s = \\\"--\\\\n\\\"\\n for node in self:\\n s += node.__str__() + \\\"\\\\n\\\"\\n return s + \\\"--\\\"\",\n \"def serialize(obj: TreeNode) -> str:\\n operators = set(\\\",:_;()[]\\\")\\n current_depth = 0\\n nodes_left = [(obj, 0)]\\n fh = ''\\n while len(nodes_left) > 0:\\n entry = nodes_left.pop()\\n node, node_depth = entry\\n if node.children and node_depth >= current_depth:\\n fh += '('\\n nodes_left.append(entry)\\n nodes_left += ((child, node_depth + 1) for child in\\n reversed(node.children))\\n current_depth = node_depth + 1\\n else:\\n if node_depth < current_depth:\\n fh += ')'\\n current_depth -= 1\\n\\n # Note we don't check for None because there is no way to represent\\n # an empty string as a label in Newick. Therefore, both None and ''\\n # are considered to be the absence of a label.\\n lblst = []\\n if node.support is not None: # prevents support of NoneType\\n lblst.append(str(node.support))\\n if node.name: # prevents name of NoneType\\n lblst.append(node.name)\\n label = ':'.join(lblst)\\n if label:\\n escaped = \\\"%s\\\" % label.replace(\\\"'\\\", \\\"''\\\")\\n if any(t in operators for t in label):\\n fh += \\\"'\\\"\\n fh += escaped\\n fh += \\\"'\\\"\\n else:\\n fh += escaped.replace(\\\" \\\", \\\"_\\\")\\n if nodes_left and nodes_left[-1][1] == current_depth:\\n fh += ','\\n\\n fh += ';\\\\n'\\n return fh\",\n \"def test_repr(self):\\n\\n node = Node(\\n {\\n 'healthchecks': [],\\n 'host': 'iwa-ait.org',\\n 'port': 22,\\n 'user': 'adm-technical',\\n 'password': 'oh-some-secret'\\n },\\n {},\\n mock.Mock()\\n )\\n\\n self.assertIn('iwa-ait.org', str(node))\\n self.assertIn('22', str(node))\\n self.assertIn('adm-technical', str(node))\\n self.assertNotIn('oh-some-secret', str(node))\",\n \"def __str__(self) -> str:\\n # The default str() for Function includes the arity, which is redundant\\n # here. Just use the symbol's name.\\n root_str = self.root.name\\n children_str = ', '.join(str(child) for child in self.children)\\n return f'{root_str}({children_str})'\",\n \"def __repr__(self) ->str:\\n # Our __repr__ is recursive, because it can also be called\\n # via repr...!\\n return ('{}({}, {})'.format(self.__class__.__name__,\\n repr(self.value),\\n repr(self.children))\\n if self.children\\n else 'Tree({})'.format(repr(self.value)))\",\n \"def __str__(self):\\n stubs = ['' for _ in range(self.nChildren())]\\n label = dist = ''\\n for i in range(self.nChildren()):\\n stubs[i] = str(self.children[i])\\n if self.dist or self.dist == 0.0:\\n dist = ':' + str(self.dist)\\n if self.label != None:\\n label = str(self.label)\\n if self.nChildren() == 0:\\n return label + dist\\n else:\\n stubstr = '('\\n for i in range(len(stubs) - 1):\\n stubstr += stubs[i] + ','\\n return stubstr + stubs[-1] + ')' + label + dist\\n # there is no label\\n '''\\n if not self.left and self.right:\\n return ',' + right\\n elif self.left and not self.right:\\n return left + ','\\n elif self.left and self.right:\\n return '(' + left + ',' + right + ')' + dist\\n '''\",\n \"def test_binarytree_repr_as_expected():\\n input = [13, 42, 7]\\n expected = '<BinaryTree | Root: 13>'\\n r = BinaryTree(input)\\n actual = repr(r)\\n assert expected == actual\",\n \"def __str__(self):\\n result = xml.dom.minidom.parseString(\\n xml.etree.ElementTree.tostring(\\n self.ToXMLElement(), encoding='utf-8')).toprettyxml(indent=' ')\\n\\n return result\",\n \"def test_graphid_str():\\n id1 = _ir.GraphId(\\\"g1\\\")\\n assert id1.str() == \\\"g1\\\"\\n id2 = _ir.GraphId(\\\"foobar\\\")\\n assert id2.str() == \\\"foobar\\\"\",\n \"def __str__(self):\\n raise NotImplementedError(\\\"__str__ not implemented for \\\"+str(type(self)))\",\n \"def test_child_str(self):\\n child = models.Child.objects.create(\\n user=sample_user(),\\n name=\\\"test name\\\"\\n )\\n self.assertEqual(str(child), child.name)\",\n \"def test_is_str_rep_string(self):\\n self.assertIsInstance(cardutils.Card(10,1).__str__(), str)\",\n \"def test_parent_str(self):\\n parent = models.Parent.objects.create(\\n user=sample_user(),\\n address=\\\"test add 1\\\",\\n age=34,\\n job=\\\"test 1\\\"\\n )\\n self.assertEqual(str(parent), parent.name)\",\n \"def test_root_str(self):\\n route = RouteFactory.create()\\n\\n self.assertEqual(str(route), 'Route @ /')\",\n \"def test_repr():\\n c = Circle(4) \\n assert c.__repr__() == 'Circle(4)'\",\n \"def __repr__(self: 'BinaryTree') -> str:\\n return 'BinaryTree({}, {}, {})'.format(repr(self.symbol), \\n repr(self.children[0]), \\n repr(self.children[1]))\",\n \"def test_string_representation(self) -> None:\\n item = Item(text=\\\"some text\\\")\\n self.assertEqual(str(item), \\\"some text\\\")\",\n \"def __str__(self):\\n current = self.root\\n nodes = [self.root]\\n final = str(self.root) + \\\"\\\\n\\\"\\n count = 0\\n while len(nodes) != 0:\\n count += 1\\n if count == 10:\\n return \\\"\\\"\\n temp = []\\n for node in nodes:\\n if node.left != None:\\n temp.append(node.left)\\n final += str(node.left) + \\\" \\\"\\n else:\\n final += \\\"_ \\\"\\n if node.right != None:\\n temp.append(node.right)\\n final += str(node.right) + \\\" \\\"\\n else:\\n final += \\\"_ \\\"\\n if temp == []:\\n if node == nodes[len(nodes) - 1]:\\n break\\n final += \\\"\\\\n\\\"\\n nodes = temp\\n self.in_order_traversal()\\n for item in self.traverse:\\n final += str(item.key) + \\\" \\\"\\n final += \\\"\\\\n\\\"\\n return final\",\n \"def rcontainer_tree_str(obj):\\n tree_task = ContainerTreePrintTask()\\n the_recurser = ObjectRecursion(tasks=[tree_task])\\n return the_recurser.recurse(obj)[0][0]\",\n \"def test_str(self):\\r\\n statobj = inputtypes.Status('test')\\r\\n self.assertEqual(str(statobj), 'test')\\r\\n self.assertEqual(unicode(statobj), u'test')\",\n \"def test_str(self, r, rep):\\n assert str(r) == rep\",\n \"def get_tree_str(self, depth: int = 0) -> str:\\n temp = \\\" \\\" * depth + str(self.head) + \\\"\\\\n\\\"\\n for son in self.sons:\\n temp += son.get_tree_str(depth + 1)\\n return temp\",\n \"def __str__(self):\\n return str(self.__s)\",\n \"def test_string_representation(self):\\n entry = Meal(name=\\\"Foo Meal\\\")\\n self.assertEqual(str(entry), 'Foo Meal')\",\n \"def writetree(self, string):\\n self.treebuf.write(string)\\n if self.animal != None:\\n self.animal.writetree(string)\",\n \"def test_str(self):\\n account = AccountFactory(username=\\\"bill\\\")\\n self.assertEqual(account.__str__(), \\\"bill\\\")\",\n \"def test_str(self):\\n self.assertEqual(str(self.bioe), str(self.wbioe))\\n self.assertEqual(str(self.uioe), str(self.wuioe))\\n self.assertEqual(str(self.bose), str(self.wbose))\\n self.assertEqual(str(self.uose), str(self.wuose))\",\n \"def __unicode__(self):\\n for n in self.children:\\n if isinstance(n, StringType):\\n return n\\n return u\\\"\\\"\",\n \"def __str__(self):\\n _str = \\\"\\\"\\n current_node = self._head\\n while(current_node != None):\\n _str += str(current_node.value)\\n _str += \\\" -> \\\"\\n current_node = current_node.next\\n _str += \\\"None\\\"\\n return _str\",\n \"def is_simple(self):\\n return self.upper_binary_tree() == self.lower_binary_tree()\",\n \"def tree_to_string(tree):\\n if type(tree) == Tree:\\n return sum(list(map(tree_to_string, tree.children)), [])\\n else:\\n return [str(tree)]\",\n \"def test_str(self):\\n character = self.character\\n\\n self.assertEqual(str(character), self.character_raw['name'])\",\n \"def tree2str(self, root: Optional[TreeNode]) -> str:\\n if not root:\\n return \\\"\\\"\\n if not root.left and not root.right:\\n return str(root.val)\\n if not root.right:\\n return f'{root.val}({self.tree2str(root.left)})'\\n return f'{root.val}({self.tree2str(root.left)})({self.tree2str(root.right)})'\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7350977","0.68626225","0.66907823","0.6621794","0.66000634","0.6573606","0.642054","0.63686234","0.62550914","0.62465364","0.61168313","0.6109845","0.61042523","0.61012125","0.6084556","0.60727394","0.6066159","0.6063924","0.6031296","0.6014376","0.60042584","0.599862","0.5989938","0.59866005","0.5977432","0.5957739","0.59539247","0.5942632","0.5902395","0.5900235","0.5876567","0.5857195","0.5832446","0.582099","0.58101577","0.5791477","0.5783585","0.5781893","0.5754815","0.57493657","0.5738496","0.57295406","0.5727618","0.5726806","0.5717675","0.570154","0.5682821","0.56782925","0.56673515","0.56663597","0.56488305","0.5647803","0.5644125","0.56261903","0.5622913","0.5622913","0.56038964","0.5603711","0.5600572","0.55840784","0.5577185","0.55760646","0.55642027","0.5559933","0.5559933","0.5559933","0.5559933","0.5555707","0.5549027","0.55477554","0.5529271","0.5521624","0.5520402","0.5516199","0.5508304","0.54950845","0.54891664","0.5484518","0.54844236","0.54779327","0.5473543","0.5467454","0.54660654","0.5462069","0.54572755","0.5450877","0.5447163","0.54449666","0.5442137","0.5433158","0.54331213","0.54328185","0.54317087","0.54305047","0.5426871","0.5426316","0.54221123","0.54194766","0.54171824","0.5412109"],"string":"[\n \"0.7350977\",\n \"0.68626225\",\n \"0.66907823\",\n \"0.6621794\",\n \"0.66000634\",\n \"0.6573606\",\n \"0.642054\",\n \"0.63686234\",\n \"0.62550914\",\n \"0.62465364\",\n \"0.61168313\",\n \"0.6109845\",\n \"0.61042523\",\n \"0.61012125\",\n \"0.6084556\",\n \"0.60727394\",\n \"0.6066159\",\n \"0.6063924\",\n \"0.6031296\",\n \"0.6014376\",\n \"0.60042584\",\n \"0.599862\",\n \"0.5989938\",\n \"0.59866005\",\n \"0.5977432\",\n \"0.5957739\",\n \"0.59539247\",\n \"0.5942632\",\n \"0.5902395\",\n \"0.5900235\",\n \"0.5876567\",\n \"0.5857195\",\n \"0.5832446\",\n \"0.582099\",\n \"0.58101577\",\n \"0.5791477\",\n \"0.5783585\",\n \"0.5781893\",\n \"0.5754815\",\n \"0.57493657\",\n \"0.5738496\",\n \"0.57295406\",\n \"0.5727618\",\n \"0.5726806\",\n \"0.5717675\",\n \"0.570154\",\n \"0.5682821\",\n \"0.56782925\",\n \"0.56673515\",\n \"0.56663597\",\n \"0.56488305\",\n \"0.5647803\",\n \"0.5644125\",\n \"0.56261903\",\n \"0.5622913\",\n \"0.5622913\",\n \"0.56038964\",\n \"0.5603711\",\n \"0.5600572\",\n \"0.55840784\",\n \"0.5577185\",\n \"0.55760646\",\n \"0.55642027\",\n \"0.5559933\",\n \"0.5559933\",\n \"0.5559933\",\n \"0.5559933\",\n \"0.5555707\",\n \"0.5549027\",\n \"0.55477554\",\n \"0.5529271\",\n \"0.5521624\",\n \"0.5520402\",\n \"0.5516199\",\n \"0.5508304\",\n \"0.54950845\",\n \"0.54891664\",\n \"0.5484518\",\n \"0.54844236\",\n \"0.54779327\",\n \"0.5473543\",\n \"0.5467454\",\n \"0.54660654\",\n \"0.5462069\",\n \"0.54572755\",\n \"0.5450877\",\n \"0.5447163\",\n \"0.54449666\",\n \"0.5442137\",\n \"0.5433158\",\n \"0.54331213\",\n \"0.54328185\",\n \"0.54317087\",\n \"0.54305047\",\n \"0.5426871\",\n \"0.5426316\",\n \"0.54221123\",\n \"0.54194766\",\n \"0.54171824\",\n \"0.5412109\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67876506"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":92888,"cells":{"query":{"kind":"string","value":"Test parse_newick on a singlenode tree representation."},"document":{"kind":"string","value":"def test04(self):\n\n s = \"a;\"\n t = parse_newick(s);\n self.assertTrue(self.isTree(t) and t.label == \"a\" and t.isLeaf())"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_tree_support(self):\r\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\r\n \"\"\"\r\n /-------.5 /-a\r\n ---1| \\-b\r\n \\------.5 /-c\r\n \\-d\r\n \"\"\"\r\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\r\n\r\n tc.tree_support(master_tree, t2)\r\n assert_almost_equal(\r\n master_tree.getNodeMatchingName('rt').bootstrap_support, 1.0)","def parseNewickNode(string):\n first = string.find('(')\n last = string[::-1].find(')') # look from the back\n if first == -1 and last == -1: # we are at leaf\n y = string.split(':')\n node = PhyloNode(label=y[0])\n if len(y) >= 2:\n node.dist = float(y[1])\n return node\n elif first >= 0 and last >= 0:\n # remove parentheses\n last = len(string) - last - 1 # correct index to refer from start instead of end of string\n embed = string[first + 1:last]\n tail = string[last + 1:]\n # find where corresp comma is\n commas = _findComma(embed)\n if len(commas) < 1:\n raise RuntimeError('Invalid format: invalid placement of \",\" in sub-string \"' + embed + '\"')\n prev_comma = 0\n child_tokens = []\n for comma in commas:\n child_tokens.append(embed[prev_comma:comma].strip())\n prev_comma = comma + 1\n child_tokens.append(embed[prev_comma:].strip())\n y = tail.split(':')\n node = PhyloNode(label=y[0]) # node is an instance of the PhyloNode() class\n if len(y) >= 2:\n node.dist = float(y[1])\n node.children = []\n for tok in child_tokens:\n child = parseNewickNode(tok)\n child.parent = node\n node.children.append(child)\n return node\n else:\n raise RuntimeError('Invalid format: unbalanced parentheses in sub-string \"' + string + '\"')","def test_parse_newick(self):\r\n # confirm that it works without escaped names\r\n t1 = ('((((tax7:0.1,tax3:0.2):.98,tax8:.3, tax4:.3):.4,'\r\n '((tax1:0.3, tax6:.09):0.43,tax2:0.4):0.5):.2,'\r\n '(tax9:0.3, endbigtaxon:.08));')\r\n expected1 = ['tax7', 'tax3', 'tax8', 'tax4', 'tax1',\r\n 'tax6', 'tax2', 'tax9', 'endbigtaxon']\r\n self.assertEqual(set(parse_newick(t1).getTipNames()), set(expected1))\r\n self.assertEqual(set([tip.Name for tip in parse_newick(t1).tips()]),\r\n set(expected1))\r\n\r\n # throw some screwed up names in\r\n t2 = ('((((tax7:0.1,tax3:0.2):.98,tax8:.3, \\'tax4\\':.3):.4,'\r\n \"(('ta_______ x1':0.3, tax6:.09):0.43,tax2:0.4):0.5):.2,\"\r\n '(tax9:0.3, endbigtaxon:.08));')\r\n expected2 = ['tax7', 'tax3', 'tax8', 'tax4', 'ta_______ x1',\r\n 'tax6', 'tax2', 'tax9', 'endbigtaxon']\r\n self.assertEqual(set(parse_newick(t2).getTipNames()), set(expected2))\r\n self.assertEqual(set([tip.Name for tip in parse_newick(t2).tips()]),\r\n set(expected2))","def buildTree(self,newick):\n\t\tfor i in range(len(newick)):\n\t\t\tif newick[i] == \"(\":\n\t\t\t\tself.currNode.children.append(node.node(self.currNode))\n\t\t\t\tself.currNode=self.currNode.children[0]\n\t\t\t#polytomy support enabled\n\t\t\telif newick[i] == \",\":\n\t\t\t\tself.currNode=self.currNode.parent\n\t\t\t\tself.currNode.children.append(node.node(self.currNode))\n\t\t\t\tself.currNode=self.currNode.children[-1]\n\t\t\telif newick[i] == \")\":\n\t\t\t\tself.currNode=self.currNode.parent\n\t\t\telse:\n\t\t\t\tself.currNode.info+=newick[i]","def parse_from_tree(self, parse):\n pass","def parseNewick(string):\n if string.find(';') != -1:\n string = string[:string.find(';')]\n return PhyloTree(parseNewickNode(string))","def test_simple(self):\n exp = [{'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\n {'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'h'},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'p'},\n {'edge_info': '1', 'type': NewickEvents.CLOSE_SUBTREE,\n 'comments': [], 'label': 'hp'},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'g'},\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\n 'comments': [], 'label': 'hpg'}\n ]\n content = '((h,p)hp:1,g)hpg;'\n self._do_test(content, exp)\n content = '((h,[pretest]p[test][posttest])hp,g)hpg;'\n exp = [{'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\n {'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'h'},\n {'edge_info': None, 'type': NewickEvents.TIP,\n 'comments': ['pretest', 'test', 'posttest'], 'label': 'p'},\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\n 'comments': [], 'label': 'hp'},\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'g'},\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\n 'comments': [], 'label': 'hpg'}\n ]\n self._do_test(content, exp)","def parse_newick_file(filename: str, digraph=True):\n tree = newick.read(filename)\n\n if digraph:\n graph_newick = nx.DiGraph()\n else:\n graph_newick = nx.Graph\n\n none_counter = 1\n\n # Adding root node\n graph_newick.add_node(tree[0], child_position=0)\n\n while tree:\n tree_node = tree[0]\n tree_node, none_counter = rename_none_node(tree_node, none_counter)\n graph_newick, descendants, none_counter = add_newick_node_and_edge(graph_newick, tree_node, none_counter)\n tree += descendants\n tree.remove(tree_node)\n\n return graph_newick","def deserialize(st: str, words: Optional[List] = None, convert_underscores: bool = True) -> Tuple[TreeNode, List]:\n tree_stack = []\n current_depth = 0\n last_token = ''\n root = TreeNode()\n tree_stack.append((root, current_depth))\n next_is_distance = False\n\n combo = []\n my_stack = []\n my_stack.append((combo, current_depth))\n\n for token in _tokenize_newick(st, convert_underscores=convert_underscores):\n # Check for a label\n if last_token not in '(,):':\n val = Sequence(words[int(last_token)]) if words else int(last_token)\n if not next_is_distance:\n tree_stack[-1][0].name = val if last_token else None\n else:\n next_is_distance = False\n if last_token:\n my_stack[-1][0].append(val)\n else:\n my_stack[-1][0].append(None)\n\n # Check for a distance\n if token == ':':\n next_is_distance = True\n elif last_token == ':':\n try:\n tree_stack[-1][0].length = float(token)\n except ValueError:\n raise NewickFormatError(\"Could not read length as numeric type\"\n \": %s.\" % token)\n elif token == '(':\n current_depth += 1\n tree_stack.append((TreeNode(), current_depth))\n my_stack.append((list(), current_depth))\n elif token == ',':\n tree_stack.append((TreeNode(), current_depth))\n my_stack.append((list(), current_depth))\n elif token == ')':\n if len(tree_stack) < 2:\n raise NewickFormatError(\"Could not parse file as newick.\"\n \" Parenthesis are unbalanced.\")\n children = []\n my_children = []\n # Pop all nodes at this depth as they belong to the remaining\n # node on the top of the stack as children.\n while current_depth == tree_stack[-1][1]:\n node, _ = tree_stack.pop()\n children.insert(0, node)\n nc, _ = my_stack.pop()\n [my_children.insert(0, c) for c in nc]\n parent = tree_stack[-1][0]\n my_parent = my_stack[-1][0]\n\n if parent.children:\n raise NewickFormatError(\"Could not parse file as newick.\"\n \" Contains unnested children.\")\n # This is much faster than TreeNode.extend\n for child in children:\n child.parent = parent\n parent.children = children\n\n my_parent.append(my_children)\n\n current_depth -= 1\n elif token == ';':\n if len(tree_stack) == 1:\n return root, my_stack\n break\n\n last_token = token\n\n raise NewickFormatError(\"Could not parse file as newick.\"\n \" `(Parenthesis)`, `'single-quotes'`,\"\n \" `[comments]` may be unbalanced, or tree may be\"\n \" missing its root.\")","def test_mergetree(self):\r\n exp = \"(A,B)0;\"\r\n obs = mergetree(['A.biom'], ['B.biom'], 'foo')\r\n self.assertEqual(obs.getNewick(escape_name=False), exp)\r\n\r\n self.assertEqual(obs.Children[0].Name, 'A')\r\n self.assertEqual(obs.Children[0].FilePath, 'A.biom')\r\n self.assertEqual(obs.Children[0].Processed, False)\r\n self.assertEqual(obs.Children[0].PollPath, None)\r\n self.assertEqual(obs.Children[0].FullCommand, None)\r\n\r\n self.assertEqual(obs.Children[1].Name, 'B')\r\n self.assertEqual(obs.Children[1].FilePath, 'B.biom')\r\n self.assertEqual(obs.Children[1].Processed, False)\r\n self.assertEqual(obs.Children[1].PollPath, None)\r\n self.assertEqual(obs.Children[1].FullCommand, None)\r\n\r\n self.assertEqual(obs.Name, '0')\r\n self.assertEqual(obs.FilePath, 'foo/0.biom')\r\n self.assertEqual(obs.Processed, False)\r\n self.assertEqual(obs.PollPath, 'foo/0.biom.poll')\r\n self.assertEqual(obs.FullCommand, None)","def parse_newick(lines, constructor=PhyloNode):\r\n return DndParser(lines, constructor=constructor, unescape_name=True)","def test01(self):\n\n t = tree(\"a\", [tree(\"b\"), tree(\"c\")]);\n self.assertTrue(self.isTree(t))","def test_parse_returns_parse_tree(self):\n lexed = [\n Token(\n value=\"SuS\",\n token_type=KT.VERB,\n line_number=0,\n ),\n Token(\n value=\"be'\",\n token_type=KT.NOUN,\n line_number=1,\n ),\n ]\n node = parse(SimpleKlingonGrammar, lexed)\n self.assertTrue(node is not None)\n self.assertEqual(node.symbol, 'sentence')\n self.assertEqual(node.lchild.symbol, 'verb')\n self.assertEqual(node.lchild.value, lexed[0])\n self.assertEqual(node.rchild.symbol, 'noun')\n self.assertEqual(node.rchild.value, lexed[1])","def as_newick(\n self,\n *,\n root=None,\n precision=None,\n node_labels=None,\n include_branch_lengths=None,\n ):\n if root is None:\n if not self.has_single_root:\n raise ValueError(\n \"Cannot get newick unless a tree has a single root. Try \"\n \"[t.as_newick(root) for root in t.roots] to get a list of \"\n \"newick trees, one for each root.\"\n )\n root = self.root\n\n if precision is None:\n # 17 decimal digits provides the full precision of an IEEE double,\n # as defined by DBL_DECIMAL_DIG macro. If we have discrete time\n # then write out integer branch lengths.\n precision = 0 if self.tree_sequence.discrete_time else 17\n include_branch_lengths = (\n True if include_branch_lengths is None else include_branch_lengths\n )\n # Can we run this through the fast path?\n if include_branch_lengths and node_labels in [LEGACY_MS_LABELS, None]:\n # Note the LEGACY_MS_LABELS code path is not part of the documented\n # interface and should not be depended on by client code.\n return self._as_newick_fast(\n root=root,\n precision=precision,\n legacy_ms_labels=node_labels == LEGACY_MS_LABELS,\n )\n\n # No, we have to use the slower Python code.\n if node_labels is None:\n node_labels = {u: f\"n{u}\" for u in self.tree_sequence.samples()}\n elif node_labels == LEGACY_MS_LABELS:\n # NOTE in the ms format it's the *leaf* nodes we label not\n # necessarily the samples. We keep this behaviour to avoid\n # breaking legacy code that may depend on it.\n node_labels = {u: f\"{u + 1}\" for u in self.leaves()}\n return text_formats.build_newick(\n self,\n root=root,\n precision=precision,\n node_labels=node_labels,\n include_branch_lengths=include_branch_lengths,\n )","def test_Tree():","def parse(handle):\n nex = Nexus.Nexus(handle)\n\n # NB: Once Nexus.Trees is modified to use Tree.Newick objects, do this:\n # return iter(nex.trees)\n # Until then, convert the Nexus.Trees.Tree object hierarchy:\n def node2clade(nxtree, node):\n subclades = [node2clade(nxtree, nxtree.node(n)) for n in node.succ]\n return Newick.Clade(\n branch_length=node.data.branchlength,\n name=node.data.taxon,\n clades=subclades,\n confidence=node.data.support,\n comment=node.data.comment,\n )\n\n for nxtree in nex.trees:\n newroot = node2clade(nxtree, nxtree.node(nxtree.root))\n yield Newick.Tree(\n root=newroot, rooted=nxtree.rooted, name=nxtree.name, weight=nxtree.weight\n )","def testTree(self, valid):\n return testTreeF(self, valid)","def test_parser_parse_empty(patch, parser, magic):\n assert parser.parse('') == Tree('empty', [])","def test_instantiate_leaf_node(self):\n try:\n LeafNode('my_label')\n except Exception:\n message = \"LeafNode instantiation failed\"\n self.fail(message)","def test_compiler_parse_tree(compiler, patch):\n patch.object(Compiler, 'subtree')\n tree = Tree('start', [Tree('command', ['token'])])\n compiler.parse_tree(tree)\n compiler.subtree.assert_called_with(Tree('command', ['token']),\n parent=None)","def testExtractSpanningTree(self):\n prevNewick1 = NXNewick().writeString(self.mcTree1)\n # Check a dead-simple spanning tree with 3 closely related leaves.\n spanHCB = self.mcTree1.extractSpanningTree([\"HUMAN\", \"CHIMP\", \"BABOON\"])\n # Check that the existing tree hasn't been modified (OK, a bit\n # silly, but just in case).\n self.assertEqual(NXNewick().writeString(self.mcTree1), prevNewick1)\n # Check the actual spanning tree.\n self.assertEqual(NXNewick().writeString(spanHCB), \"((HUMAN:0.006969,CHIMP:0.009727)Anc7:0.025291,BABOON:0.044568)Anc3;\")\n\n # Now test a more complicated tree, where we should remove as\n # many of the ancestors as possible (they will add extra\n # losses for no reason!).\n spanHCC = self.mcTree1.extractSpanningTree([\"HUMAN\", \"CHIMP\", \"CAT\"])\n self.assertEqual(NXNewick().writeString(self.mcTree1), prevNewick1)\n self.assertEqual(NXNewick().writeString(spanHCC), \"((HUMAN:0.006969,CHIMP:0.009727)Anc7:0.158551,CAT:0.197381)Anc0;\")","def test_simple_parse(self):\n pass","def test_instantiate_six_nodes():\n input = [13, 42, 7, 3, 9, 99]\n six = BinaryTree(input)\n assert isinstance(six, BinaryTree)","def deserialize(stringTree):\n global i #Global shared index \n\n if (stringTree[i] == \"#\"): #Empty node\n return None \n\n else:\n node = Node(stringTree[i]) #Create node of current index\n i+=1\n node.left = deserialize(stringTree) #Check left child\n i+=1\n node.right = deserialize(stringTree) #Check right child\n return node","def _as_newick_fast(self, *, root, precision, legacy_ms_labels):\n root_time = max(1, self.time(root))\n max_label_size = math.ceil(math.log10(self.tree_sequence.num_nodes))\n single_node_size = (\n 5 + max_label_size + math.ceil(math.log10(root_time)) + precision\n )\n buffer_size = 1 + single_node_size * self.tree_sequence.num_nodes\n return self._ll_tree.get_newick(\n precision=precision,\n root=root,\n buffer_size=buffer_size,\n legacy_ms_labels=legacy_ms_labels,\n )","def test_reroot(self):\n t = DndParser(\"(((a,b)c,(d,e)f)g,(h,i)j);\")\n tips = ['a','b']\n for n in t.traverse():\n n.Length = 1.0\n \n # note, g is lost because it has a single descendent and gets pruned off\n exp = \"((a:1.0,b:1.0)c:0.5,((d:1.0,e:1.0)f:1.0,(h:1.0,i:1.0)j:2.0):0.5);\"\n obs = reroot(t, tips)\n self.assertEqual(obs.getNewick(with_distances=True), exp)","def test_nanny_dynamic_calling():\n\n n = Nanny()\n\n assert n.nanny_child_new(\"/bin/true\")","def test_compare_old_to_new_method_to_create_trees(self):\n nodes = util.generate_sequence_of_points(2, 2)\n tree1 = kdtree.createNewTree(nodes)\n kdtree.visualize(tree1)\n \n sel_axis = (lambda axis: axis)\n tree2 = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\n tree2.split2([0.25, 0.5], axis = 1)\n tree2.split2([0.75, 0.5], axis = 1)\n \n #left\n tree2.split2([0.25, 0.25], axis = 0, sel_axis = sel_axis)\n tree2.split2([0.25, 0.75], axis = 0, sel_axis = sel_axis)\n \n #right\n tree2.split2([0.75, 0.25], axis = 0, sel_axis = sel_axis)\n tree2.split2([0.75, 0.75], axis = 0, sel_axis = sel_axis)\n \n kdtree.visualize(tree2)\n \n for n in zip(kdtree.level_order(tree1), kdtree.level_order(tree2)):\n self.assertEqual(n[0].data, n[1].data, \"elements not equal\")\n \n if n[0].data is not None and n[1].data is not None:\n self.assertEqual(n[0].axis, n[1].axis, \"elements not equal\")","def test_markAsTree(self):\n x = t.Rule(\"foo\", t.List(\n t.Exactly(\"x\")))\n g = t.Grammar(\"TestGrammar\", True, [x])\n self.assertIn(\"\\n tree = True\\n\", writePython(g))","def test_buildTree(self):\r\n root = buildTree()\r\n assert root.getchildren()[0].getchildren()[0].attrib['id'] == 'c-test_crisis'\r\n assert root.getchildren()[1].getchildren()[0].attrib['id'] == 'o-test_org'\r\n assert root.getchildren()[2].getchildren()[0].attrib['id'] == 'p-algore'","def test_label(self):\n nt = NewickTokenizer(newick=\"(a\\n'b',(b,c),(d,e));\")\n self.assertRaises(ValueError, nt.tokens)","def test_add_empty_nodes_with_label_when_splitting(self):\n print \"----- test_add_empty_nodes_with_label_when_splitting -----\"\n sel_axis = (lambda axis: axis)\n \n #create tree, first node splits in x direction\n tree = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\n kdtree.visualize(tree)\n \n point_left = [0.4, 0.5]\n tree.split2(point_left, axis = 0)\n kdtree.visualize(tree)\n \n point1 = [0.3, 0.5]\n found_node = tree.get_path_to_leaf(point1)[-1]\n correct_node1 = 3\n self.assertEqual(found_node.label, correct_node1, \"Not correct node found\")\n \n point_right = [0.6, 0.5]\n tree.split2(point_right, axis = 1)\n kdtree.visualize(tree)\n \n point2 = [0.6, 0.7]\n found_node = tree.get_path_to_leaf(point2)[-1]\n correct_node2 = 6\n self.assertEqual(found_node.label, correct_node2, \"Not correct node found\")\n \n print \"----- end: test_add_empty_nodes_with_label_when_splitting -----\"","def buildTree(self, tree=None):\n if tree is None:\n tree = phylogeny.Tree()\n tree.buildFromString(self.newick, False) # tree descriptions from NCL 2.1 are 1-based not 0-based\n return tree","def _gen_test_tree_1():\n tree = BinaryNode(5)\n tree.left = BinaryNode(5)\n return tree","def __init__(self, path2tree, treeformat='newick'):\r\n self.path2tree = path2tree\r\n self.treeformat = treeformat\r\n self.tree = Phylo.read(self.path2tree, self.treeformat)","def parse_tree(s):\n return parser.parse(lexer=lexer, input=s)","def test_render_tree(self) -> None:\n\n def get_children(node):\n return node.children\n\n node, expect, withtags = self.tree_case_1()\n actual = render_tree(node, get_children)\n assert expect == actual, (expect, actual)\n\n node, expect, withtags = self.tree_case_2()\n actual = render_tree(node, get_children, 1)\n assert expect == actual, (expect, actual)\n\n # Ensure that we can call render_tree on the same Node\n # again. This wasn't possible in version 2.4.1 and earlier\n # due to a bug in render_tree (visited was set to {} as default\n # parameter)\n actual = render_tree(node, get_children, 1)\n assert expect == actual, (expect, actual)","def __call__(self, node):\n if node.children:\n if len(node.children) == 1:\n if self.TagEqual(node.children[0], node):\n #print node.ToString()\n node.tag = self.Tag(node, node.children[0]);\n lst = node.children[0].children;\n node.children = lst;","def __init__(self):\n self.root = self.get_new_node();","def test_bootstrap_support_labeled(self):\r\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\r\n \"\"\"\r\n /-------.5 /-a\r\n ---1| \\-b\r\n \\------.5 /-c\r\n \\-d\r\n \"\"\"\r\n t1 = parse_newick('((a:6,b:8.2)hi:2,(c:1,d:2):7);') # same structure\r\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\r\n new_master, bootstraps = tc.bootstrap_support(master_tree, [t1, t2])\r\n expected = dict([('ab', .5), ('cd', .5), ('rt', 1.0)])\r\n self.assertDictEqual(bootstraps, expected)","def nameToNode(name):\n\n pass","def test_parser_parse(patch, parser):\n patch.many(Parser, ['transformer'])\n result = parser.parse('source')\n parser.lark.parse.assert_called_with('source\\n')\n Parser.transformer().transform.assert_called_with(parser.lark.parse())\n assert result == Parser.transformer().transform()","def test_parser_patch_______(parser):\n pass","def readNewick(filename):\n f = open(filename)\n string = ''.join(f)\n return parseNewick(string)","def test_instantiate_gets_correct_root_and_root_pointers():\n input = [13, 42, 7]\n c = BinaryTree(input)\n root_repr = repr(c.root)\n expected_root_repr = '<Node | Val: 13 | Data: None | Left: 7 | Right: 42>'\n assert root_repr == expected_root_repr","def test_workflow_parse(self):\n\n workflow = [{'job_template': 'sample_job1',\n 'success': [{'job_template': 'sample_job2'}],\n 'always': [{'job_template': 'sample_job3'}]}]\n dry_run = True\n extra_vars_arg = {'sample_vars': 'sample'}\n\n top_node = tree.generate_workflow_tree(workflow, dry_run,\n extra_vars_arg)\n correct = 1\n self.assertEqual(top_node.node_id, correct)","def _gen_test_tree_2():\n tree = BinaryNode(5)\n tree.left = BinaryNode(3)\n tree.left.left = BinaryNode(2)\n tree.left.left.left = BinaryNode(1)\n tree.left.right = BinaryNode(4)\n tree.right = BinaryNode(7)\n tree.right.left = BinaryNode(6)\n tree.right.right = BinaryNode(8)\n tree.right.right.right = BinaryNode(9)\n return tree","def setUp(self):\r\n\r\n self.tree = DndParser(StringIO(TEST_TREE), constructor=PhyloNode)","def test_create_node_with_children(self):\n root = netapp_api.NaElement('root')\n self.mock_object(root, 'add_new_child', return_value='abc')\n\n result_xml = str(root.create_node_with_children(\n 'options', test1=zapi_fakes.FAKE_XML_STR,\n test2=zapi_fakes.FAKE_XML_STR))\n\n # No ordering is guaranteed for elements in this XML.\n self.assertTrue(result_xml.startswith(\"<options>\"), result_xml)\n self.assertIn(\"<test1>abc</test1>\", result_xml)\n self.assertIn(\"<test2>abc</test2>\", result_xml)\n self.assertTrue(result_xml.rstrip().endswith(\"</options>\"), result_xml)","def test_dummy():\n dummyblock = DummyBlockNode(\n name=\"None\",\n parameters=(),\n ancestor=None,\n dirty=False,\n filepath=\"/some/random/path\"\n )\n dummydirective = DummyDirectiveNode(\n name=\"Name\",\n ancestor=None,\n filepath=\"/another/path\"\n )\n dummycomment = DummyCommentNode(\n comment=\"Comment\",\n ancestor=dummyblock,\n filepath=\"/some/file\"\n )","def tree(n, names):\n \n t = Tree()\n t.populate(n, names_library=names.keys(), random_branches=True, support_range=(0.7, 1))\n t.write(format=2, outfile='fake.tree.newick', dist_formatter='%0.4g', support_formatter='%0.4g')\n with open('fake.tree.notation.tsv', 'w') as o:\n o.write('#TaxaID\\tName\\n')\n o.writelines('{}\\t{}\\n'.format(k, v) for k, v in names.items())","def parseNode( self, node ):\n\n if not node:\n return\n\n if ( not node.IsA( 'vtkMRMLModelNode' ) and not node.IsA( 'vtkMRMLModelHierarchyNode' ) ) or ( node.IsA( 'vtkMRMLModelNode' ) and node.GetHideFromEditors() ):\n return\n\n if self.__nodes.has_key( node.GetID() ):\n return\n\n parent_node = \"scene\"\n\n parentNode = None\n hNode = None\n\n if node.IsA( 'vtkMRMLModelNode' ):\n parentNode = slicer.app.applicationLogic().GetModelHierarchyLogic().GetModelHierarchyNode( node.GetID() )\n\n if parentNode:\n parentNode = parentNode.GetParentNode()\n\n elif node.IsA( 'vtkMRMLModelHierarchyNode' ):\n parentNode = node.GetParentNode()\n\n if parentNode:\n if parentNode.GetID() == node.GetID():\n return\n\n parent_node = parentNode.GetID()\n self.parseNode( parentNode )\n\n if not node.IsA( 'vtkMRMLModelHierarchyNode' ) or not node.GetModelNode():\n\n self.__nodes[node.GetID()] = node.GetName()\n self.__tree.create_node( node.GetName(), node.GetID(), parent=parent_node )","def test_open_closed(self):\n nt = NewickTokenizer(newick='(a,(),(d,e));')\n self.assertRaises(ValueError, nt.tokens)","def _gen_test_tree_6():\n tree = BinaryNode(20)\n tree.left = BinaryNode(10)\n tree.right = BinaryNode(30)\n tree.left.right = BinaryNode(25)\n return tree","def test_filter_tree(self):\r\n actual = [e.Name for e in filter_tree(\r\n self.tree1, ['bbb', 'ccc']).tips()]\r\n #(a_a:10,(b_b:2,c_c:4):5);\r\n expected = [\r\n e.Name for e in DndParser(\r\n \"((bbb:2,ccc:4));\",\r\n PhyloNode).tips(\r\n )]\r\n self.assertEqual(actual, expected)\r\n\r\n actual = [e.Name for e in filter_tree(\r\n self.tree2, ['bbb', 'ccc']).tips()]\r\n #(a_a:10,(b_b:2,c_c:4):5);\r\n expected = [\r\n e.Name for e in DndParser(\r\n \"(('bbb':2,ccc:4));\",\r\n PhyloNode).tips(\r\n )]\r\n self.assertEqual(actual, expected)","def test_tree_graph_creation(self):\n # There is little to test here other than simple creation\n # Whether it comes out OK or not ... ¯\\_(ツ)_/¯\n model = FairModel(name='Test')\n model.input_data('Loss Magnitude', mean=50, stdev=5)\n model.input_data('Loss Event Frequency', low=10, mode=20, high=30)\n metamodel = FairMetaModel(name='Test Meta', models=[model, model])\n with warnings.catch_warnings(record=False):\n warnings.simplefilter(\"ignore\")\n fvp = FairViolinPlot(metamodel)\n _, _ = fvp.generate_image()","def test_instantiate_branch_node(self):\n try:\n BranchNode('my_name')\n except Exception:\n message = \"BranchNode instantiation failed\"\n self.fail(message)","def test05(self):\n\n s = \"a\"\n with self.assertRaises(ParserException):\n t = parse_newick(s)","def parse_graphml_file_newick_format(filename: str, digraph=True):\n graphml_graph = nx.read_graphml(filename, node_type=newick.Node)\n if digraph:\n graphml_graph = graphml_graph.to_directed()\n\n for current_node in graphml_graph.nodes:\n graphml_graph.add_node(current_node, name=current_node, child_position=0)\n\n return graphml_graph","def test_findmnt_nodata(self):\n self.assertEqual(parse('', quiet=True), [])","def test_root():\n gnroot = 's51001'\n root = germanet_data.get_synset_by_id(gnroot)\n np.testing.assert_equal(root.is_root(), True)\n np.testing.assert_equal(root.is_leaf(), False)","def _gen_test_tree_5():\n tree = BinaryNode(30)\n tree.right = BinaryNode(30)\n return tree","def test_no_start_open_parens(self):\n self.assertRaises(ValueError, NewickTokenizer, newick='hi')","def __init__(self):\n self.root = SimpleNode()","def __init__(self,treeString):\n\t\tself.treeString=treeString\n\t\tif self.checkString(self.treeString) == True:\n\t\t\tself.root=node.node(None)\n\t\t\tself.currNode=self.root\n\t\t\tself.buildTree(self.treeString)\n\t\t\t\"\"\"once information from buildTree is assigned to individual nodes, \n\t\t\tthe nodes then parse that information into names, branch lengths, etc\n\t\t\trecursive function allows the call to be made only to the root\"\"\"\n\t\t\t#use this step to do likelihood calculation\n\t\t\tself.root.processInfo()\n\t\telse:\n\t\t\t#change to an error in long run\n\t\t\tprint \"improperly formatted newick string\"","def test_unclosed(self):\n nt = NewickTokenizer(newick='(a,(b,c)')\n self.assertRaises(ValueError, nt.tokens)","def test_children_tree(depth_one_tree):\n assert str(depth_one_tree.root.children) == str([1, 2, 3, 4])","def test_binarytree_instantiate_given(given_list):\n assert isinstance(given_list, BinaryTree)","def gen_tree(path):\n # print(\"CALLING.. Tree\")\n parser = etree.XMLParser(remove_blank_text=True)\n tree = etree.parse(path, parser)\n root = tree.getroot() \n return root, tree","def test_tree_two_nodes_right(one_t):\n one_t.insert(5)\n assert one_t.depth() == 1","def test_leafs():\n leafs = ['s6675', 's136315', 's10765', 's106594', 's131']\n for leaf in leafs:\n synset = germanet_data.get_synset_by_id(leaf)\n np.testing.assert_equal(synset.is_root(), False)\n np.testing.assert_equal(synset.is_leaf(), True)","def _gen_test_tree_4():\n tree = BinaryNode(5)\n tree.left = BinaryNode(3)\n tree.left.left = BinaryNode(2)\n tree.left.right = BinaryNode(10)\n tree.right = BinaryNode(9)\n tree.right.left = BinaryNode(6)\n tree.right.right = BinaryNode(8)\n return tree","def test_inset(depth_one_tree):\n depth_one_tree.insert(2, 3)\n print(depth_one_tree.root.children[0].children)\n print(depth_one_tree.root.children[1].children)\n print(depth_one_tree.root.children[2].children)\n print(depth_one_tree.root.children[3].children)\n assert str(depth_one_tree.root.children[2].children) == str([2])","def tree_string_parser(tree_string):\n tree_hash = create_hash(tree_string)\n tree_string = tree_string.replace(\"(\", \"{\")\n tree_string = tree_string.replace(\")\", \"}\")\n tree_string = \"{\" + tree_string + \"}\"\n tree_string = tree_string.replace(\"'\", \"\")\n\n data = re.sub(r'([\\w\\.\\-]+)', r'\"\\1\"', tree_string) # {\"val1\" {\"val2\" {\"d1\" \"d2\" \"d3\"}}}\n data = re.sub(r'\"\\s*{', r'\": {', data) # {\"val1\": {\"val2\": {\"d1\" \"d2\" \"d3\"}}}\n data = re.sub(r'\" \"', r'\", \"', data) # {\"val1\": {\"val2\": {\"d1\", \"d2\", \"d3\"}}}\n data = re.sub(r'{([^{}]*)}', r'[\\1]', data) # {\"val1\": {\"val2\": [\"d1\", \"d2\", \"d3\"]}}\n data = re.sub(r'\\[([\\\"\\:\\, \\w\\.\\-]+:+[\\\"\\:\\, \\w\\.\\-]+)\\]', r'\\1', data)\n data = re.sub(r'({[\\\"\\w\\.\\-]+),', r'\\1: [],', data)\n data = re.sub(r', (\\\"[\\\"\\w\\.\\-]+\\\")}', r', \\1: []}', data)\n data = re.sub(r', (\\\"[\\\"\\w\\.\\-]+\\\"),(?![^\\[]*\\])', r', \\1: [],', data)\n data = re.sub(r', (\\\"[\\\"\\w\\.\\-]+\\\"),(?![^\\[]*\\])', r', \\1: [],', data)\n data = re.sub(r', \\[(.*?)\\]', r', \"ARGS\": [[\\1]]', data)\n try:\n tree_dict = json.loads(data)\n except:\n print(\"Error from json.loads: \" + data)\n try:\n fix_up_tree(tree_dict)\n except:\n print(\"Error from fix_up_tree: \" + data)\n try:\n plot_tree(tree_dict, tree_hash)\n except:\n print(\"Error from plot tree: \" + data)","def test_binarytree_instantiate_single_value():\n b = BinaryTree(42)\n assert isinstance(b, BinaryTree)","def pattern_convert(grammar, raw_node_info):\n type, value, context, children = raw_node_info\n if children or type in grammar.number2symbol:\n return pytree.Node(type, children, context=context)\n else:\n return pytree.Leaf(type, value, context=context)","def _build_tree(self, markup):\n clean_markup = tidy_document(markup,\n options={'numeric-entities':1,\n 'output-xml':1,\n 'output-encoding':'utf8'})[0]\n # Small fix for a cornercase involving invalid characters...\n clean_markup = clean_markup.replace('\\x15', '_')\n etree = self._fix_treetags(ET.fromstring(clean_markup))\n return etree","def test_print_tree(self) -> None:\n\n def get_children(node):\n return node.children\n\n save_stdout = sys.stdout\n\n try:\n node, expect, withtags = self.tree_case_1()\n\n IOStream = io.StringIO\n sys.stdout = IOStream()\n print_tree(node, get_children)\n actual = sys.stdout.getvalue()\n assert expect == actual, (expect, actual)\n\n sys.stdout = IOStream()\n print_tree(node, get_children, showtags=1)\n actual = sys.stdout.getvalue()\n assert withtags == actual, (withtags, actual)\n\n # Test that explicitly setting prune to zero works\n # the same as the default (see above)\n node, expect, withtags = self.tree_case_2(prune=0)\n\n sys.stdout = IOStream()\n print_tree(node, get_children, 0)\n actual = sys.stdout.getvalue()\n assert expect == actual, (expect, actual)\n\n sys.stdout = IOStream()\n print_tree(node, get_children, 0, showtags=1)\n actual = sys.stdout.getvalue()\n assert withtags == actual, (withtags, actual)\n\n # Test output with prune=1\n node, expect, withtags = self.tree_case_2(prune=1)\n\n sys.stdout = IOStream()\n print_tree(node, get_children, 1)\n actual = sys.stdout.getvalue()\n assert expect == actual, (expect, actual)\n\n # Ensure that we can call print_tree on the same Node\n # again. This wasn't possible in version 2.4.1 and earlier\n # due to a bug in print_tree (visited was set to {} as default\n # parameter)\n sys.stdout = IOStream()\n print_tree(node, get_children, 1)\n actual = sys.stdout.getvalue()\n assert expect == actual, (expect, actual)\n\n sys.stdout = IOStream()\n print_tree(node, get_children, 1, showtags=1)\n actual = sys.stdout.getvalue()\n assert withtags == actual, (withtags, actual)\n finally:\n sys.stdout = save_stdout","def test_tree_balace_root():\n result = balance.generate_tree('test_input.txt')\n expected = 'tknk'\n\n assert expected == result['root'][0]","def test_tree_with_one_node_root_no_children(one_t):\n assert not one_t.root.left\n assert not one_t.root.right","def test_dummy3(self):\n xpb = XPathBuilder()\n xp = xpb.dummy()\n self.assertTrue(xp.parenthesize() is xp)","def test_bootstrap_support(self):\r\n master_tree = parse_newick('((a:2,b:3):2,(c:1,d:2):7);')\r\n \"\"\"\r\n /-------.5 /-a\r\n ---1| \\-b\r\n \\------.5 /-c\r\n \\-d\r\n \"\"\"\r\n t1 = parse_newick('((a:6,b:8.2):2,(c:1,d:2):7);') # same structure\r\n t2 = parse_newick('((a:2,b:3,c:33):2,d:7);') # abc are siblings\r\n new_master, bootstraps = tc.bootstrap_support(master_tree, [t1, t2])\r\n assert_almost_equal(\r\n sorted(bootstraps.values()), sorted([1.0, .5, .5]))","def cast_ltree(s, cur):\n if s is not None:\n return Ltree(s)","def get_newick(self):\n tree_list = self.get_cluster_elements_labels\n newick = \"(\"\n \n \n newick = _get_newick_intermediate(tree_list,newick,False)\n\n newick = newick[0] + \");\"\n\n return newick","def test_root_value(small_tree):\n assert small_tree.root.value == 3","def test_tree_two_nodes_left_has_depth_one(one_t):\n one_t.insert(5)\n assert one_t.depth() == 1","def test_left_sided_tree_with_two_nodes_root_has_child(empty_t):\n empty_t.insert(10)\n empty_t.insert(5)\n assert empty_t.root.left\n assert not empty_t.root.right","def test_extra_closed(self):\n nt = NewickTokenizer(newick='(a,(b,c)));')\n self.assertRaises(ValueError, nt.tokens)","def test_multiple_child_nodes():\n result = parse_xml(\"<lol><first>text 1</first><second>text 2</second></lol>\")\n expected = {'lol': {'first': 'text 1', 'second': 'text 2'}}\n\n assert_equals(result, expected)","def _create_node(\n self,\n name,\n ):\n pass","def test03(self):\n\n t = tree(\"a\");\n s = str(t)\n self.assertEqual(re.sub(\"\\s+\", \"\", s), \"a;\") # Remove spaces and test equality","def _gen_test_tree_3():\n tree = BinaryNode(5)\n tree.left = BinaryNode(1)\n tree.left.left = BinaryNode(2)\n tree.left.right = BinaryNode(3)\n tree.right = BinaryNode(7)\n tree.right.left = BinaryNode(8)\n tree.right.right = BinaryNode(9)\n return tree","def test_rs3filewriter_onesegmenttree():\n input_tree = t(\"N\", [\"foo\"])\n expected_output_tree = example2tree('only-one-segment.rs3')\n\n tempfile = NamedTemporaryFile()\n RS3FileWriter(input_tree, output_filepath=tempfile.name)\n produced_output_tree = RSTTree(tempfile.name)\n\n assert produced_output_tree.edu_strings == produced_output_tree.tree.leaves() == ['foo']\n assert input_tree == expected_output_tree.tree == produced_output_tree.tree","def create_nodes(self):","def __init__(self):\n Tree.__init__(self, \"\")","def test02(self):\n\n t = tree(\"a\", [tree(\"b\"), tree(\"c\")]);\n self.assertEqual(len(t), 3)","def test_root_midpt2(self):\r\n from qiime.make_phylogeny import root_midpt\r\n from cogent.core.tree import PhyloNode\r\n from qiime.parse import parse_newick\r\n tree = parse_newick('(a:1,((c:1,d:2.5)n3:1,b:1)n2:1)rt;')\r\n tmid = root_midpt(tree)\r\n self.assertEqual(tmid.getDistances(), tree.getDistances())\r\n tipnames = tree.getTipNames()\r\n nontipnames = [t.Name for t in tree.nontips()]\r\n self.assertTrue(tmid.isRoot())\r\n self.assertEqual(tmid.distance(tmid.getNodeMatchingName('d')), 2.75)","def midpointRooting(infileName, outfileName):\n newickString=open(infileName, 'rb').readline().rstrip().replace('[&R] ', '')\n tree = Tree(newickString);\n \n if tree.get_midpoint_outgroup()!=None:\n tree.set_outgroup( tree.get_midpoint_outgroup() )\n tree.ladderize()\n with open(outfileName, 'wb') as outfile:\n outfile.write(tree.write(format=1))","def deserialize(string):\r\n # For empty string return None, which makes the logic simpler\r\n # at node creation\r\n if len(string) == 0:\r\n return None \r\n\r\n # Simplest case - leaf, no children\r\n if string.count(\"(\") == 0:\r\n return Node(string)\r\n\r\n # Extract parent and children\r\n subs = string.split(\"(\", 1)\r\n root = subs[0]\r\n # Remove closing bracket\r\n rest = subs[1][:-1]\r\n\r\n # Simple case - left child has no children\r\n left, right = rest.split(\"|\", 1)\r\n if left.count(\"(\") == 0:\r\n return Node(root, deserialize(left), deserialize(right))\r\n\r\n # Keep moving right until we find the end of left's children\r\n next_index = rest.index(\"|\", len(left)+1)\r\n left = rest[:next_index]\r\n right = rest[next_index+1:]\r\n while left.count('(') != left.count(')'):\r\n next_index = rest.index(\"|\", next_index+1)\r\n left = rest[:next_index]\r\n right = rest[next_index+1:]\r\n\r\n return Node(root, deserialize(left), deserialize(right))","def create_test_node():\n node = cmds.createNode(\"unknown\")\n _add_test_attrs_to_node(node)\n return node"],"string":"[\n \"def test_tree_support(self):\\r\\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\\r\\n \\\"\\\"\\\"\\r\\n /-------.5 /-a\\r\\n ---1| \\\\-b\\r\\n \\\\------.5 /-c\\r\\n \\\\-d\\r\\n \\\"\\\"\\\"\\r\\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\\r\\n\\r\\n tc.tree_support(master_tree, t2)\\r\\n assert_almost_equal(\\r\\n master_tree.getNodeMatchingName('rt').bootstrap_support, 1.0)\",\n \"def parseNewickNode(string):\\n first = string.find('(')\\n last = string[::-1].find(')') # look from the back\\n if first == -1 and last == -1: # we are at leaf\\n y = string.split(':')\\n node = PhyloNode(label=y[0])\\n if len(y) >= 2:\\n node.dist = float(y[1])\\n return node\\n elif first >= 0 and last >= 0:\\n # remove parentheses\\n last = len(string) - last - 1 # correct index to refer from start instead of end of string\\n embed = string[first + 1:last]\\n tail = string[last + 1:]\\n # find where corresp comma is\\n commas = _findComma(embed)\\n if len(commas) < 1:\\n raise RuntimeError('Invalid format: invalid placement of \\\",\\\" in sub-string \\\"' + embed + '\\\"')\\n prev_comma = 0\\n child_tokens = []\\n for comma in commas:\\n child_tokens.append(embed[prev_comma:comma].strip())\\n prev_comma = comma + 1\\n child_tokens.append(embed[prev_comma:].strip())\\n y = tail.split(':')\\n node = PhyloNode(label=y[0]) # node is an instance of the PhyloNode() class\\n if len(y) >= 2:\\n node.dist = float(y[1])\\n node.children = []\\n for tok in child_tokens:\\n child = parseNewickNode(tok)\\n child.parent = node\\n node.children.append(child)\\n return node\\n else:\\n raise RuntimeError('Invalid format: unbalanced parentheses in sub-string \\\"' + string + '\\\"')\",\n \"def test_parse_newick(self):\\r\\n # confirm that it works without escaped names\\r\\n t1 = ('((((tax7:0.1,tax3:0.2):.98,tax8:.3, tax4:.3):.4,'\\r\\n '((tax1:0.3, tax6:.09):0.43,tax2:0.4):0.5):.2,'\\r\\n '(tax9:0.3, endbigtaxon:.08));')\\r\\n expected1 = ['tax7', 'tax3', 'tax8', 'tax4', 'tax1',\\r\\n 'tax6', 'tax2', 'tax9', 'endbigtaxon']\\r\\n self.assertEqual(set(parse_newick(t1).getTipNames()), set(expected1))\\r\\n self.assertEqual(set([tip.Name for tip in parse_newick(t1).tips()]),\\r\\n set(expected1))\\r\\n\\r\\n # throw some screwed up names in\\r\\n t2 = ('((((tax7:0.1,tax3:0.2):.98,tax8:.3, \\\\'tax4\\\\':.3):.4,'\\r\\n \\\"(('ta_______ x1':0.3, tax6:.09):0.43,tax2:0.4):0.5):.2,\\\"\\r\\n '(tax9:0.3, endbigtaxon:.08));')\\r\\n expected2 = ['tax7', 'tax3', 'tax8', 'tax4', 'ta_______ x1',\\r\\n 'tax6', 'tax2', 'tax9', 'endbigtaxon']\\r\\n self.assertEqual(set(parse_newick(t2).getTipNames()), set(expected2))\\r\\n self.assertEqual(set([tip.Name for tip in parse_newick(t2).tips()]),\\r\\n set(expected2))\",\n \"def buildTree(self,newick):\\n\\t\\tfor i in range(len(newick)):\\n\\t\\t\\tif newick[i] == \\\"(\\\":\\n\\t\\t\\t\\tself.currNode.children.append(node.node(self.currNode))\\n\\t\\t\\t\\tself.currNode=self.currNode.children[0]\\n\\t\\t\\t#polytomy support enabled\\n\\t\\t\\telif newick[i] == \\\",\\\":\\n\\t\\t\\t\\tself.currNode=self.currNode.parent\\n\\t\\t\\t\\tself.currNode.children.append(node.node(self.currNode))\\n\\t\\t\\t\\tself.currNode=self.currNode.children[-1]\\n\\t\\t\\telif newick[i] == \\\")\\\":\\n\\t\\t\\t\\tself.currNode=self.currNode.parent\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.currNode.info+=newick[i]\",\n \"def parse_from_tree(self, parse):\\n pass\",\n \"def parseNewick(string):\\n if string.find(';') != -1:\\n string = string[:string.find(';')]\\n return PhyloTree(parseNewickNode(string))\",\n \"def test_simple(self):\\n exp = [{'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\\n {'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'h'},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'p'},\\n {'edge_info': '1', 'type': NewickEvents.CLOSE_SUBTREE,\\n 'comments': [], 'label': 'hp'},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'g'},\\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\\n 'comments': [], 'label': 'hpg'}\\n ]\\n content = '((h,p)hp:1,g)hpg;'\\n self._do_test(content, exp)\\n content = '((h,[pretest]p[test][posttest])hp,g)hpg;'\\n exp = [{'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\\n {'type': NewickEvents.OPEN_SUBTREE, 'comments': []},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'h'},\\n {'edge_info': None, 'type': NewickEvents.TIP,\\n 'comments': ['pretest', 'test', 'posttest'], 'label': 'p'},\\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\\n 'comments': [], 'label': 'hp'},\\n {'edge_info': None, 'type': NewickEvents.TIP, 'comments': [], 'label': 'g'},\\n {'edge_info': None, 'type': NewickEvents.CLOSE_SUBTREE,\\n 'comments': [], 'label': 'hpg'}\\n ]\\n self._do_test(content, exp)\",\n \"def parse_newick_file(filename: str, digraph=True):\\n tree = newick.read(filename)\\n\\n if digraph:\\n graph_newick = nx.DiGraph()\\n else:\\n graph_newick = nx.Graph\\n\\n none_counter = 1\\n\\n # Adding root node\\n graph_newick.add_node(tree[0], child_position=0)\\n\\n while tree:\\n tree_node = tree[0]\\n tree_node, none_counter = rename_none_node(tree_node, none_counter)\\n graph_newick, descendants, none_counter = add_newick_node_and_edge(graph_newick, tree_node, none_counter)\\n tree += descendants\\n tree.remove(tree_node)\\n\\n return graph_newick\",\n \"def deserialize(st: str, words: Optional[List] = None, convert_underscores: bool = True) -> Tuple[TreeNode, List]:\\n tree_stack = []\\n current_depth = 0\\n last_token = ''\\n root = TreeNode()\\n tree_stack.append((root, current_depth))\\n next_is_distance = False\\n\\n combo = []\\n my_stack = []\\n my_stack.append((combo, current_depth))\\n\\n for token in _tokenize_newick(st, convert_underscores=convert_underscores):\\n # Check for a label\\n if last_token not in '(,):':\\n val = Sequence(words[int(last_token)]) if words else int(last_token)\\n if not next_is_distance:\\n tree_stack[-1][0].name = val if last_token else None\\n else:\\n next_is_distance = False\\n if last_token:\\n my_stack[-1][0].append(val)\\n else:\\n my_stack[-1][0].append(None)\\n\\n # Check for a distance\\n if token == ':':\\n next_is_distance = True\\n elif last_token == ':':\\n try:\\n tree_stack[-1][0].length = float(token)\\n except ValueError:\\n raise NewickFormatError(\\\"Could not read length as numeric type\\\"\\n \\\": %s.\\\" % token)\\n elif token == '(':\\n current_depth += 1\\n tree_stack.append((TreeNode(), current_depth))\\n my_stack.append((list(), current_depth))\\n elif token == ',':\\n tree_stack.append((TreeNode(), current_depth))\\n my_stack.append((list(), current_depth))\\n elif token == ')':\\n if len(tree_stack) < 2:\\n raise NewickFormatError(\\\"Could not parse file as newick.\\\"\\n \\\" Parenthesis are unbalanced.\\\")\\n children = []\\n my_children = []\\n # Pop all nodes at this depth as they belong to the remaining\\n # node on the top of the stack as children.\\n while current_depth == tree_stack[-1][1]:\\n node, _ = tree_stack.pop()\\n children.insert(0, node)\\n nc, _ = my_stack.pop()\\n [my_children.insert(0, c) for c in nc]\\n parent = tree_stack[-1][0]\\n my_parent = my_stack[-1][0]\\n\\n if parent.children:\\n raise NewickFormatError(\\\"Could not parse file as newick.\\\"\\n \\\" Contains unnested children.\\\")\\n # This is much faster than TreeNode.extend\\n for child in children:\\n child.parent = parent\\n parent.children = children\\n\\n my_parent.append(my_children)\\n\\n current_depth -= 1\\n elif token == ';':\\n if len(tree_stack) == 1:\\n return root, my_stack\\n break\\n\\n last_token = token\\n\\n raise NewickFormatError(\\\"Could not parse file as newick.\\\"\\n \\\" `(Parenthesis)`, `'single-quotes'`,\\\"\\n \\\" `[comments]` may be unbalanced, or tree may be\\\"\\n \\\" missing its root.\\\")\",\n \"def test_mergetree(self):\\r\\n exp = \\\"(A,B)0;\\\"\\r\\n obs = mergetree(['A.biom'], ['B.biom'], 'foo')\\r\\n self.assertEqual(obs.getNewick(escape_name=False), exp)\\r\\n\\r\\n self.assertEqual(obs.Children[0].Name, 'A')\\r\\n self.assertEqual(obs.Children[0].FilePath, 'A.biom')\\r\\n self.assertEqual(obs.Children[0].Processed, False)\\r\\n self.assertEqual(obs.Children[0].PollPath, None)\\r\\n self.assertEqual(obs.Children[0].FullCommand, None)\\r\\n\\r\\n self.assertEqual(obs.Children[1].Name, 'B')\\r\\n self.assertEqual(obs.Children[1].FilePath, 'B.biom')\\r\\n self.assertEqual(obs.Children[1].Processed, False)\\r\\n self.assertEqual(obs.Children[1].PollPath, None)\\r\\n self.assertEqual(obs.Children[1].FullCommand, None)\\r\\n\\r\\n self.assertEqual(obs.Name, '0')\\r\\n self.assertEqual(obs.FilePath, 'foo/0.biom')\\r\\n self.assertEqual(obs.Processed, False)\\r\\n self.assertEqual(obs.PollPath, 'foo/0.biom.poll')\\r\\n self.assertEqual(obs.FullCommand, None)\",\n \"def parse_newick(lines, constructor=PhyloNode):\\r\\n return DndParser(lines, constructor=constructor, unescape_name=True)\",\n \"def test01(self):\\n\\n t = tree(\\\"a\\\", [tree(\\\"b\\\"), tree(\\\"c\\\")]);\\n self.assertTrue(self.isTree(t))\",\n \"def test_parse_returns_parse_tree(self):\\n lexed = [\\n Token(\\n value=\\\"SuS\\\",\\n token_type=KT.VERB,\\n line_number=0,\\n ),\\n Token(\\n value=\\\"be'\\\",\\n token_type=KT.NOUN,\\n line_number=1,\\n ),\\n ]\\n node = parse(SimpleKlingonGrammar, lexed)\\n self.assertTrue(node is not None)\\n self.assertEqual(node.symbol, 'sentence')\\n self.assertEqual(node.lchild.symbol, 'verb')\\n self.assertEqual(node.lchild.value, lexed[0])\\n self.assertEqual(node.rchild.symbol, 'noun')\\n self.assertEqual(node.rchild.value, lexed[1])\",\n \"def as_newick(\\n self,\\n *,\\n root=None,\\n precision=None,\\n node_labels=None,\\n include_branch_lengths=None,\\n ):\\n if root is None:\\n if not self.has_single_root:\\n raise ValueError(\\n \\\"Cannot get newick unless a tree has a single root. Try \\\"\\n \\\"[t.as_newick(root) for root in t.roots] to get a list of \\\"\\n \\\"newick trees, one for each root.\\\"\\n )\\n root = self.root\\n\\n if precision is None:\\n # 17 decimal digits provides the full precision of an IEEE double,\\n # as defined by DBL_DECIMAL_DIG macro. If we have discrete time\\n # then write out integer branch lengths.\\n precision = 0 if self.tree_sequence.discrete_time else 17\\n include_branch_lengths = (\\n True if include_branch_lengths is None else include_branch_lengths\\n )\\n # Can we run this through the fast path?\\n if include_branch_lengths and node_labels in [LEGACY_MS_LABELS, None]:\\n # Note the LEGACY_MS_LABELS code path is not part of the documented\\n # interface and should not be depended on by client code.\\n return self._as_newick_fast(\\n root=root,\\n precision=precision,\\n legacy_ms_labels=node_labels == LEGACY_MS_LABELS,\\n )\\n\\n # No, we have to use the slower Python code.\\n if node_labels is None:\\n node_labels = {u: f\\\"n{u}\\\" for u in self.tree_sequence.samples()}\\n elif node_labels == LEGACY_MS_LABELS:\\n # NOTE in the ms format it's the *leaf* nodes we label not\\n # necessarily the samples. We keep this behaviour to avoid\\n # breaking legacy code that may depend on it.\\n node_labels = {u: f\\\"{u + 1}\\\" for u in self.leaves()}\\n return text_formats.build_newick(\\n self,\\n root=root,\\n precision=precision,\\n node_labels=node_labels,\\n include_branch_lengths=include_branch_lengths,\\n )\",\n \"def test_Tree():\",\n \"def parse(handle):\\n nex = Nexus.Nexus(handle)\\n\\n # NB: Once Nexus.Trees is modified to use Tree.Newick objects, do this:\\n # return iter(nex.trees)\\n # Until then, convert the Nexus.Trees.Tree object hierarchy:\\n def node2clade(nxtree, node):\\n subclades = [node2clade(nxtree, nxtree.node(n)) for n in node.succ]\\n return Newick.Clade(\\n branch_length=node.data.branchlength,\\n name=node.data.taxon,\\n clades=subclades,\\n confidence=node.data.support,\\n comment=node.data.comment,\\n )\\n\\n for nxtree in nex.trees:\\n newroot = node2clade(nxtree, nxtree.node(nxtree.root))\\n yield Newick.Tree(\\n root=newroot, rooted=nxtree.rooted, name=nxtree.name, weight=nxtree.weight\\n )\",\n \"def testTree(self, valid):\\n return testTreeF(self, valid)\",\n \"def test_parser_parse_empty(patch, parser, magic):\\n assert parser.parse('') == Tree('empty', [])\",\n \"def test_instantiate_leaf_node(self):\\n try:\\n LeafNode('my_label')\\n except Exception:\\n message = \\\"LeafNode instantiation failed\\\"\\n self.fail(message)\",\n \"def test_compiler_parse_tree(compiler, patch):\\n patch.object(Compiler, 'subtree')\\n tree = Tree('start', [Tree('command', ['token'])])\\n compiler.parse_tree(tree)\\n compiler.subtree.assert_called_with(Tree('command', ['token']),\\n parent=None)\",\n \"def testExtractSpanningTree(self):\\n prevNewick1 = NXNewick().writeString(self.mcTree1)\\n # Check a dead-simple spanning tree with 3 closely related leaves.\\n spanHCB = self.mcTree1.extractSpanningTree([\\\"HUMAN\\\", \\\"CHIMP\\\", \\\"BABOON\\\"])\\n # Check that the existing tree hasn't been modified (OK, a bit\\n # silly, but just in case).\\n self.assertEqual(NXNewick().writeString(self.mcTree1), prevNewick1)\\n # Check the actual spanning tree.\\n self.assertEqual(NXNewick().writeString(spanHCB), \\\"((HUMAN:0.006969,CHIMP:0.009727)Anc7:0.025291,BABOON:0.044568)Anc3;\\\")\\n\\n # Now test a more complicated tree, where we should remove as\\n # many of the ancestors as possible (they will add extra\\n # losses for no reason!).\\n spanHCC = self.mcTree1.extractSpanningTree([\\\"HUMAN\\\", \\\"CHIMP\\\", \\\"CAT\\\"])\\n self.assertEqual(NXNewick().writeString(self.mcTree1), prevNewick1)\\n self.assertEqual(NXNewick().writeString(spanHCC), \\\"((HUMAN:0.006969,CHIMP:0.009727)Anc7:0.158551,CAT:0.197381)Anc0;\\\")\",\n \"def test_simple_parse(self):\\n pass\",\n \"def test_instantiate_six_nodes():\\n input = [13, 42, 7, 3, 9, 99]\\n six = BinaryTree(input)\\n assert isinstance(six, BinaryTree)\",\n \"def deserialize(stringTree):\\n global i #Global shared index \\n\\n if (stringTree[i] == \\\"#\\\"): #Empty node\\n return None \\n\\n else:\\n node = Node(stringTree[i]) #Create node of current index\\n i+=1\\n node.left = deserialize(stringTree) #Check left child\\n i+=1\\n node.right = deserialize(stringTree) #Check right child\\n return node\",\n \"def _as_newick_fast(self, *, root, precision, legacy_ms_labels):\\n root_time = max(1, self.time(root))\\n max_label_size = math.ceil(math.log10(self.tree_sequence.num_nodes))\\n single_node_size = (\\n 5 + max_label_size + math.ceil(math.log10(root_time)) + precision\\n )\\n buffer_size = 1 + single_node_size * self.tree_sequence.num_nodes\\n return self._ll_tree.get_newick(\\n precision=precision,\\n root=root,\\n buffer_size=buffer_size,\\n legacy_ms_labels=legacy_ms_labels,\\n )\",\n \"def test_reroot(self):\\n t = DndParser(\\\"(((a,b)c,(d,e)f)g,(h,i)j);\\\")\\n tips = ['a','b']\\n for n in t.traverse():\\n n.Length = 1.0\\n \\n # note, g is lost because it has a single descendent and gets pruned off\\n exp = \\\"((a:1.0,b:1.0)c:0.5,((d:1.0,e:1.0)f:1.0,(h:1.0,i:1.0)j:2.0):0.5);\\\"\\n obs = reroot(t, tips)\\n self.assertEqual(obs.getNewick(with_distances=True), exp)\",\n \"def test_nanny_dynamic_calling():\\n\\n n = Nanny()\\n\\n assert n.nanny_child_new(\\\"/bin/true\\\")\",\n \"def test_compare_old_to_new_method_to_create_trees(self):\\n nodes = util.generate_sequence_of_points(2, 2)\\n tree1 = kdtree.createNewTree(nodes)\\n kdtree.visualize(tree1)\\n \\n sel_axis = (lambda axis: axis)\\n tree2 = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\\n tree2.split2([0.25, 0.5], axis = 1)\\n tree2.split2([0.75, 0.5], axis = 1)\\n \\n #left\\n tree2.split2([0.25, 0.25], axis = 0, sel_axis = sel_axis)\\n tree2.split2([0.25, 0.75], axis = 0, sel_axis = sel_axis)\\n \\n #right\\n tree2.split2([0.75, 0.25], axis = 0, sel_axis = sel_axis)\\n tree2.split2([0.75, 0.75], axis = 0, sel_axis = sel_axis)\\n \\n kdtree.visualize(tree2)\\n \\n for n in zip(kdtree.level_order(tree1), kdtree.level_order(tree2)):\\n self.assertEqual(n[0].data, n[1].data, \\\"elements not equal\\\")\\n \\n if n[0].data is not None and n[1].data is not None:\\n self.assertEqual(n[0].axis, n[1].axis, \\\"elements not equal\\\")\",\n \"def test_markAsTree(self):\\n x = t.Rule(\\\"foo\\\", t.List(\\n t.Exactly(\\\"x\\\")))\\n g = t.Grammar(\\\"TestGrammar\\\", True, [x])\\n self.assertIn(\\\"\\\\n tree = True\\\\n\\\", writePython(g))\",\n \"def test_buildTree(self):\\r\\n root = buildTree()\\r\\n assert root.getchildren()[0].getchildren()[0].attrib['id'] == 'c-test_crisis'\\r\\n assert root.getchildren()[1].getchildren()[0].attrib['id'] == 'o-test_org'\\r\\n assert root.getchildren()[2].getchildren()[0].attrib['id'] == 'p-algore'\",\n \"def test_label(self):\\n nt = NewickTokenizer(newick=\\\"(a\\\\n'b',(b,c),(d,e));\\\")\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def test_add_empty_nodes_with_label_when_splitting(self):\\n print \\\"----- test_add_empty_nodes_with_label_when_splitting -----\\\"\\n sel_axis = (lambda axis: axis)\\n \\n #create tree, first node splits in x direction\\n tree = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\\n kdtree.visualize(tree)\\n \\n point_left = [0.4, 0.5]\\n tree.split2(point_left, axis = 0)\\n kdtree.visualize(tree)\\n \\n point1 = [0.3, 0.5]\\n found_node = tree.get_path_to_leaf(point1)[-1]\\n correct_node1 = 3\\n self.assertEqual(found_node.label, correct_node1, \\\"Not correct node found\\\")\\n \\n point_right = [0.6, 0.5]\\n tree.split2(point_right, axis = 1)\\n kdtree.visualize(tree)\\n \\n point2 = [0.6, 0.7]\\n found_node = tree.get_path_to_leaf(point2)[-1]\\n correct_node2 = 6\\n self.assertEqual(found_node.label, correct_node2, \\\"Not correct node found\\\")\\n \\n print \\\"----- end: test_add_empty_nodes_with_label_when_splitting -----\\\"\",\n \"def buildTree(self, tree=None):\\n if tree is None:\\n tree = phylogeny.Tree()\\n tree.buildFromString(self.newick, False) # tree descriptions from NCL 2.1 are 1-based not 0-based\\n return tree\",\n \"def _gen_test_tree_1():\\n tree = BinaryNode(5)\\n tree.left = BinaryNode(5)\\n return tree\",\n \"def __init__(self, path2tree, treeformat='newick'):\\r\\n self.path2tree = path2tree\\r\\n self.treeformat = treeformat\\r\\n self.tree = Phylo.read(self.path2tree, self.treeformat)\",\n \"def parse_tree(s):\\n return parser.parse(lexer=lexer, input=s)\",\n \"def test_render_tree(self) -> None:\\n\\n def get_children(node):\\n return node.children\\n\\n node, expect, withtags = self.tree_case_1()\\n actual = render_tree(node, get_children)\\n assert expect == actual, (expect, actual)\\n\\n node, expect, withtags = self.tree_case_2()\\n actual = render_tree(node, get_children, 1)\\n assert expect == actual, (expect, actual)\\n\\n # Ensure that we can call render_tree on the same Node\\n # again. This wasn't possible in version 2.4.1 and earlier\\n # due to a bug in render_tree (visited was set to {} as default\\n # parameter)\\n actual = render_tree(node, get_children, 1)\\n assert expect == actual, (expect, actual)\",\n \"def __call__(self, node):\\n if node.children:\\n if len(node.children) == 1:\\n if self.TagEqual(node.children[0], node):\\n #print node.ToString()\\n node.tag = self.Tag(node, node.children[0]);\\n lst = node.children[0].children;\\n node.children = lst;\",\n \"def __init__(self):\\n self.root = self.get_new_node();\",\n \"def test_bootstrap_support_labeled(self):\\r\\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\\r\\n \\\"\\\"\\\"\\r\\n /-------.5 /-a\\r\\n ---1| \\\\-b\\r\\n \\\\------.5 /-c\\r\\n \\\\-d\\r\\n \\\"\\\"\\\"\\r\\n t1 = parse_newick('((a:6,b:8.2)hi:2,(c:1,d:2):7);') # same structure\\r\\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\\r\\n new_master, bootstraps = tc.bootstrap_support(master_tree, [t1, t2])\\r\\n expected = dict([('ab', .5), ('cd', .5), ('rt', 1.0)])\\r\\n self.assertDictEqual(bootstraps, expected)\",\n \"def nameToNode(name):\\n\\n pass\",\n \"def test_parser_parse(patch, parser):\\n patch.many(Parser, ['transformer'])\\n result = parser.parse('source')\\n parser.lark.parse.assert_called_with('source\\\\n')\\n Parser.transformer().transform.assert_called_with(parser.lark.parse())\\n assert result == Parser.transformer().transform()\",\n \"def test_parser_patch_______(parser):\\n pass\",\n \"def readNewick(filename):\\n f = open(filename)\\n string = ''.join(f)\\n return parseNewick(string)\",\n \"def test_instantiate_gets_correct_root_and_root_pointers():\\n input = [13, 42, 7]\\n c = BinaryTree(input)\\n root_repr = repr(c.root)\\n expected_root_repr = '<Node | Val: 13 | Data: None | Left: 7 | Right: 42>'\\n assert root_repr == expected_root_repr\",\n \"def test_workflow_parse(self):\\n\\n workflow = [{'job_template': 'sample_job1',\\n 'success': [{'job_template': 'sample_job2'}],\\n 'always': [{'job_template': 'sample_job3'}]}]\\n dry_run = True\\n extra_vars_arg = {'sample_vars': 'sample'}\\n\\n top_node = tree.generate_workflow_tree(workflow, dry_run,\\n extra_vars_arg)\\n correct = 1\\n self.assertEqual(top_node.node_id, correct)\",\n \"def _gen_test_tree_2():\\n tree = BinaryNode(5)\\n tree.left = BinaryNode(3)\\n tree.left.left = BinaryNode(2)\\n tree.left.left.left = BinaryNode(1)\\n tree.left.right = BinaryNode(4)\\n tree.right = BinaryNode(7)\\n tree.right.left = BinaryNode(6)\\n tree.right.right = BinaryNode(8)\\n tree.right.right.right = BinaryNode(9)\\n return tree\",\n \"def setUp(self):\\r\\n\\r\\n self.tree = DndParser(StringIO(TEST_TREE), constructor=PhyloNode)\",\n \"def test_create_node_with_children(self):\\n root = netapp_api.NaElement('root')\\n self.mock_object(root, 'add_new_child', return_value='abc')\\n\\n result_xml = str(root.create_node_with_children(\\n 'options', test1=zapi_fakes.FAKE_XML_STR,\\n test2=zapi_fakes.FAKE_XML_STR))\\n\\n # No ordering is guaranteed for elements in this XML.\\n self.assertTrue(result_xml.startswith(\\\"<options>\\\"), result_xml)\\n self.assertIn(\\\"<test1>abc</test1>\\\", result_xml)\\n self.assertIn(\\\"<test2>abc</test2>\\\", result_xml)\\n self.assertTrue(result_xml.rstrip().endswith(\\\"</options>\\\"), result_xml)\",\n \"def test_dummy():\\n dummyblock = DummyBlockNode(\\n name=\\\"None\\\",\\n parameters=(),\\n ancestor=None,\\n dirty=False,\\n filepath=\\\"/some/random/path\\\"\\n )\\n dummydirective = DummyDirectiveNode(\\n name=\\\"Name\\\",\\n ancestor=None,\\n filepath=\\\"/another/path\\\"\\n )\\n dummycomment = DummyCommentNode(\\n comment=\\\"Comment\\\",\\n ancestor=dummyblock,\\n filepath=\\\"/some/file\\\"\\n )\",\n \"def tree(n, names):\\n \\n t = Tree()\\n t.populate(n, names_library=names.keys(), random_branches=True, support_range=(0.7, 1))\\n t.write(format=2, outfile='fake.tree.newick', dist_formatter='%0.4g', support_formatter='%0.4g')\\n with open('fake.tree.notation.tsv', 'w') as o:\\n o.write('#TaxaID\\\\tName\\\\n')\\n o.writelines('{}\\\\t{}\\\\n'.format(k, v) for k, v in names.items())\",\n \"def parseNode( self, node ):\\n\\n if not node:\\n return\\n\\n if ( not node.IsA( 'vtkMRMLModelNode' ) and not node.IsA( 'vtkMRMLModelHierarchyNode' ) ) or ( node.IsA( 'vtkMRMLModelNode' ) and node.GetHideFromEditors() ):\\n return\\n\\n if self.__nodes.has_key( node.GetID() ):\\n return\\n\\n parent_node = \\\"scene\\\"\\n\\n parentNode = None\\n hNode = None\\n\\n if node.IsA( 'vtkMRMLModelNode' ):\\n parentNode = slicer.app.applicationLogic().GetModelHierarchyLogic().GetModelHierarchyNode( node.GetID() )\\n\\n if parentNode:\\n parentNode = parentNode.GetParentNode()\\n\\n elif node.IsA( 'vtkMRMLModelHierarchyNode' ):\\n parentNode = node.GetParentNode()\\n\\n if parentNode:\\n if parentNode.GetID() == node.GetID():\\n return\\n\\n parent_node = parentNode.GetID()\\n self.parseNode( parentNode )\\n\\n if not node.IsA( 'vtkMRMLModelHierarchyNode' ) or not node.GetModelNode():\\n\\n self.__nodes[node.GetID()] = node.GetName()\\n self.__tree.create_node( node.GetName(), node.GetID(), parent=parent_node )\",\n \"def test_open_closed(self):\\n nt = NewickTokenizer(newick='(a,(),(d,e));')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def _gen_test_tree_6():\\n tree = BinaryNode(20)\\n tree.left = BinaryNode(10)\\n tree.right = BinaryNode(30)\\n tree.left.right = BinaryNode(25)\\n return tree\",\n \"def test_filter_tree(self):\\r\\n actual = [e.Name for e in filter_tree(\\r\\n self.tree1, ['bbb', 'ccc']).tips()]\\r\\n #(a_a:10,(b_b:2,c_c:4):5);\\r\\n expected = [\\r\\n e.Name for e in DndParser(\\r\\n \\\"((bbb:2,ccc:4));\\\",\\r\\n PhyloNode).tips(\\r\\n )]\\r\\n self.assertEqual(actual, expected)\\r\\n\\r\\n actual = [e.Name for e in filter_tree(\\r\\n self.tree2, ['bbb', 'ccc']).tips()]\\r\\n #(a_a:10,(b_b:2,c_c:4):5);\\r\\n expected = [\\r\\n e.Name for e in DndParser(\\r\\n \\\"(('bbb':2,ccc:4));\\\",\\r\\n PhyloNode).tips(\\r\\n )]\\r\\n self.assertEqual(actual, expected)\",\n \"def test_tree_graph_creation(self):\\n # There is little to test here other than simple creation\\n # Whether it comes out OK or not ... ¯\\\\_(ツ)_/¯\\n model = FairModel(name='Test')\\n model.input_data('Loss Magnitude', mean=50, stdev=5)\\n model.input_data('Loss Event Frequency', low=10, mode=20, high=30)\\n metamodel = FairMetaModel(name='Test Meta', models=[model, model])\\n with warnings.catch_warnings(record=False):\\n warnings.simplefilter(\\\"ignore\\\")\\n fvp = FairViolinPlot(metamodel)\\n _, _ = fvp.generate_image()\",\n \"def test_instantiate_branch_node(self):\\n try:\\n BranchNode('my_name')\\n except Exception:\\n message = \\\"BranchNode instantiation failed\\\"\\n self.fail(message)\",\n \"def test05(self):\\n\\n s = \\\"a\\\"\\n with self.assertRaises(ParserException):\\n t = parse_newick(s)\",\n \"def parse_graphml_file_newick_format(filename: str, digraph=True):\\n graphml_graph = nx.read_graphml(filename, node_type=newick.Node)\\n if digraph:\\n graphml_graph = graphml_graph.to_directed()\\n\\n for current_node in graphml_graph.nodes:\\n graphml_graph.add_node(current_node, name=current_node, child_position=0)\\n\\n return graphml_graph\",\n \"def test_findmnt_nodata(self):\\n self.assertEqual(parse('', quiet=True), [])\",\n \"def test_root():\\n gnroot = 's51001'\\n root = germanet_data.get_synset_by_id(gnroot)\\n np.testing.assert_equal(root.is_root(), True)\\n np.testing.assert_equal(root.is_leaf(), False)\",\n \"def _gen_test_tree_5():\\n tree = BinaryNode(30)\\n tree.right = BinaryNode(30)\\n return tree\",\n \"def test_no_start_open_parens(self):\\n self.assertRaises(ValueError, NewickTokenizer, newick='hi')\",\n \"def __init__(self):\\n self.root = SimpleNode()\",\n \"def __init__(self,treeString):\\n\\t\\tself.treeString=treeString\\n\\t\\tif self.checkString(self.treeString) == True:\\n\\t\\t\\tself.root=node.node(None)\\n\\t\\t\\tself.currNode=self.root\\n\\t\\t\\tself.buildTree(self.treeString)\\n\\t\\t\\t\\\"\\\"\\\"once information from buildTree is assigned to individual nodes, \\n\\t\\t\\tthe nodes then parse that information into names, branch lengths, etc\\n\\t\\t\\trecursive function allows the call to be made only to the root\\\"\\\"\\\"\\n\\t\\t\\t#use this step to do likelihood calculation\\n\\t\\t\\tself.root.processInfo()\\n\\t\\telse:\\n\\t\\t\\t#change to an error in long run\\n\\t\\t\\tprint \\\"improperly formatted newick string\\\"\",\n \"def test_unclosed(self):\\n nt = NewickTokenizer(newick='(a,(b,c)')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def test_children_tree(depth_one_tree):\\n assert str(depth_one_tree.root.children) == str([1, 2, 3, 4])\",\n \"def test_binarytree_instantiate_given(given_list):\\n assert isinstance(given_list, BinaryTree)\",\n \"def gen_tree(path):\\n # print(\\\"CALLING.. Tree\\\")\\n parser = etree.XMLParser(remove_blank_text=True)\\n tree = etree.parse(path, parser)\\n root = tree.getroot() \\n return root, tree\",\n \"def test_tree_two_nodes_right(one_t):\\n one_t.insert(5)\\n assert one_t.depth() == 1\",\n \"def test_leafs():\\n leafs = ['s6675', 's136315', 's10765', 's106594', 's131']\\n for leaf in leafs:\\n synset = germanet_data.get_synset_by_id(leaf)\\n np.testing.assert_equal(synset.is_root(), False)\\n np.testing.assert_equal(synset.is_leaf(), True)\",\n \"def _gen_test_tree_4():\\n tree = BinaryNode(5)\\n tree.left = BinaryNode(3)\\n tree.left.left = BinaryNode(2)\\n tree.left.right = BinaryNode(10)\\n tree.right = BinaryNode(9)\\n tree.right.left = BinaryNode(6)\\n tree.right.right = BinaryNode(8)\\n return tree\",\n \"def test_inset(depth_one_tree):\\n depth_one_tree.insert(2, 3)\\n print(depth_one_tree.root.children[0].children)\\n print(depth_one_tree.root.children[1].children)\\n print(depth_one_tree.root.children[2].children)\\n print(depth_one_tree.root.children[3].children)\\n assert str(depth_one_tree.root.children[2].children) == str([2])\",\n \"def tree_string_parser(tree_string):\\n tree_hash = create_hash(tree_string)\\n tree_string = tree_string.replace(\\\"(\\\", \\\"{\\\")\\n tree_string = tree_string.replace(\\\")\\\", \\\"}\\\")\\n tree_string = \\\"{\\\" + tree_string + \\\"}\\\"\\n tree_string = tree_string.replace(\\\"'\\\", \\\"\\\")\\n\\n data = re.sub(r'([\\\\w\\\\.\\\\-]+)', r'\\\"\\\\1\\\"', tree_string) # {\\\"val1\\\" {\\\"val2\\\" {\\\"d1\\\" \\\"d2\\\" \\\"d3\\\"}}}\\n data = re.sub(r'\\\"\\\\s*{', r'\\\": {', data) # {\\\"val1\\\": {\\\"val2\\\": {\\\"d1\\\" \\\"d2\\\" \\\"d3\\\"}}}\\n data = re.sub(r'\\\" \\\"', r'\\\", \\\"', data) # {\\\"val1\\\": {\\\"val2\\\": {\\\"d1\\\", \\\"d2\\\", \\\"d3\\\"}}}\\n data = re.sub(r'{([^{}]*)}', r'[\\\\1]', data) # {\\\"val1\\\": {\\\"val2\\\": [\\\"d1\\\", \\\"d2\\\", \\\"d3\\\"]}}\\n data = re.sub(r'\\\\[([\\\\\\\"\\\\:\\\\, \\\\w\\\\.\\\\-]+:+[\\\\\\\"\\\\:\\\\, \\\\w\\\\.\\\\-]+)\\\\]', r'\\\\1', data)\\n data = re.sub(r'({[\\\\\\\"\\\\w\\\\.\\\\-]+),', r'\\\\1: [],', data)\\n data = re.sub(r', (\\\\\\\"[\\\\\\\"\\\\w\\\\.\\\\-]+\\\\\\\")}', r', \\\\1: []}', data)\\n data = re.sub(r', (\\\\\\\"[\\\\\\\"\\\\w\\\\.\\\\-]+\\\\\\\"),(?![^\\\\[]*\\\\])', r', \\\\1: [],', data)\\n data = re.sub(r', (\\\\\\\"[\\\\\\\"\\\\w\\\\.\\\\-]+\\\\\\\"),(?![^\\\\[]*\\\\])', r', \\\\1: [],', data)\\n data = re.sub(r', \\\\[(.*?)\\\\]', r', \\\"ARGS\\\": [[\\\\1]]', data)\\n try:\\n tree_dict = json.loads(data)\\n except:\\n print(\\\"Error from json.loads: \\\" + data)\\n try:\\n fix_up_tree(tree_dict)\\n except:\\n print(\\\"Error from fix_up_tree: \\\" + data)\\n try:\\n plot_tree(tree_dict, tree_hash)\\n except:\\n print(\\\"Error from plot tree: \\\" + data)\",\n \"def test_binarytree_instantiate_single_value():\\n b = BinaryTree(42)\\n assert isinstance(b, BinaryTree)\",\n \"def pattern_convert(grammar, raw_node_info):\\n type, value, context, children = raw_node_info\\n if children or type in grammar.number2symbol:\\n return pytree.Node(type, children, context=context)\\n else:\\n return pytree.Leaf(type, value, context=context)\",\n \"def _build_tree(self, markup):\\n clean_markup = tidy_document(markup,\\n options={'numeric-entities':1,\\n 'output-xml':1,\\n 'output-encoding':'utf8'})[0]\\n # Small fix for a cornercase involving invalid characters...\\n clean_markup = clean_markup.replace('\\\\x15', '_')\\n etree = self._fix_treetags(ET.fromstring(clean_markup))\\n return etree\",\n \"def test_print_tree(self) -> None:\\n\\n def get_children(node):\\n return node.children\\n\\n save_stdout = sys.stdout\\n\\n try:\\n node, expect, withtags = self.tree_case_1()\\n\\n IOStream = io.StringIO\\n sys.stdout = IOStream()\\n print_tree(node, get_children)\\n actual = sys.stdout.getvalue()\\n assert expect == actual, (expect, actual)\\n\\n sys.stdout = IOStream()\\n print_tree(node, get_children, showtags=1)\\n actual = sys.stdout.getvalue()\\n assert withtags == actual, (withtags, actual)\\n\\n # Test that explicitly setting prune to zero works\\n # the same as the default (see above)\\n node, expect, withtags = self.tree_case_2(prune=0)\\n\\n sys.stdout = IOStream()\\n print_tree(node, get_children, 0)\\n actual = sys.stdout.getvalue()\\n assert expect == actual, (expect, actual)\\n\\n sys.stdout = IOStream()\\n print_tree(node, get_children, 0, showtags=1)\\n actual = sys.stdout.getvalue()\\n assert withtags == actual, (withtags, actual)\\n\\n # Test output with prune=1\\n node, expect, withtags = self.tree_case_2(prune=1)\\n\\n sys.stdout = IOStream()\\n print_tree(node, get_children, 1)\\n actual = sys.stdout.getvalue()\\n assert expect == actual, (expect, actual)\\n\\n # Ensure that we can call print_tree on the same Node\\n # again. This wasn't possible in version 2.4.1 and earlier\\n # due to a bug in print_tree (visited was set to {} as default\\n # parameter)\\n sys.stdout = IOStream()\\n print_tree(node, get_children, 1)\\n actual = sys.stdout.getvalue()\\n assert expect == actual, (expect, actual)\\n\\n sys.stdout = IOStream()\\n print_tree(node, get_children, 1, showtags=1)\\n actual = sys.stdout.getvalue()\\n assert withtags == actual, (withtags, actual)\\n finally:\\n sys.stdout = save_stdout\",\n \"def test_tree_balace_root():\\n result = balance.generate_tree('test_input.txt')\\n expected = 'tknk'\\n\\n assert expected == result['root'][0]\",\n \"def test_tree_with_one_node_root_no_children(one_t):\\n assert not one_t.root.left\\n assert not one_t.root.right\",\n \"def test_dummy3(self):\\n xpb = XPathBuilder()\\n xp = xpb.dummy()\\n self.assertTrue(xp.parenthesize() is xp)\",\n \"def test_bootstrap_support(self):\\r\\n master_tree = parse_newick('((a:2,b:3):2,(c:1,d:2):7);')\\r\\n \\\"\\\"\\\"\\r\\n /-------.5 /-a\\r\\n ---1| \\\\-b\\r\\n \\\\------.5 /-c\\r\\n \\\\-d\\r\\n \\\"\\\"\\\"\\r\\n t1 = parse_newick('((a:6,b:8.2):2,(c:1,d:2):7);') # same structure\\r\\n t2 = parse_newick('((a:2,b:3,c:33):2,d:7);') # abc are siblings\\r\\n new_master, bootstraps = tc.bootstrap_support(master_tree, [t1, t2])\\r\\n assert_almost_equal(\\r\\n sorted(bootstraps.values()), sorted([1.0, .5, .5]))\",\n \"def cast_ltree(s, cur):\\n if s is not None:\\n return Ltree(s)\",\n \"def get_newick(self):\\n tree_list = self.get_cluster_elements_labels\\n newick = \\\"(\\\"\\n \\n \\n newick = _get_newick_intermediate(tree_list,newick,False)\\n\\n newick = newick[0] + \\\");\\\"\\n\\n return newick\",\n \"def test_root_value(small_tree):\\n assert small_tree.root.value == 3\",\n \"def test_tree_two_nodes_left_has_depth_one(one_t):\\n one_t.insert(5)\\n assert one_t.depth() == 1\",\n \"def test_left_sided_tree_with_two_nodes_root_has_child(empty_t):\\n empty_t.insert(10)\\n empty_t.insert(5)\\n assert empty_t.root.left\\n assert not empty_t.root.right\",\n \"def test_extra_closed(self):\\n nt = NewickTokenizer(newick='(a,(b,c)));')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def test_multiple_child_nodes():\\n result = parse_xml(\\\"<lol><first>text 1</first><second>text 2</second></lol>\\\")\\n expected = {'lol': {'first': 'text 1', 'second': 'text 2'}}\\n\\n assert_equals(result, expected)\",\n \"def _create_node(\\n self,\\n name,\\n ):\\n pass\",\n \"def test03(self):\\n\\n t = tree(\\\"a\\\");\\n s = str(t)\\n self.assertEqual(re.sub(\\\"\\\\s+\\\", \\\"\\\", s), \\\"a;\\\") # Remove spaces and test equality\",\n \"def _gen_test_tree_3():\\n tree = BinaryNode(5)\\n tree.left = BinaryNode(1)\\n tree.left.left = BinaryNode(2)\\n tree.left.right = BinaryNode(3)\\n tree.right = BinaryNode(7)\\n tree.right.left = BinaryNode(8)\\n tree.right.right = BinaryNode(9)\\n return tree\",\n \"def test_rs3filewriter_onesegmenttree():\\n input_tree = t(\\\"N\\\", [\\\"foo\\\"])\\n expected_output_tree = example2tree('only-one-segment.rs3')\\n\\n tempfile = NamedTemporaryFile()\\n RS3FileWriter(input_tree, output_filepath=tempfile.name)\\n produced_output_tree = RSTTree(tempfile.name)\\n\\n assert produced_output_tree.edu_strings == produced_output_tree.tree.leaves() == ['foo']\\n assert input_tree == expected_output_tree.tree == produced_output_tree.tree\",\n \"def create_nodes(self):\",\n \"def __init__(self):\\n Tree.__init__(self, \\\"\\\")\",\n \"def test02(self):\\n\\n t = tree(\\\"a\\\", [tree(\\\"b\\\"), tree(\\\"c\\\")]);\\n self.assertEqual(len(t), 3)\",\n \"def test_root_midpt2(self):\\r\\n from qiime.make_phylogeny import root_midpt\\r\\n from cogent.core.tree import PhyloNode\\r\\n from qiime.parse import parse_newick\\r\\n tree = parse_newick('(a:1,((c:1,d:2.5)n3:1,b:1)n2:1)rt;')\\r\\n tmid = root_midpt(tree)\\r\\n self.assertEqual(tmid.getDistances(), tree.getDistances())\\r\\n tipnames = tree.getTipNames()\\r\\n nontipnames = [t.Name for t in tree.nontips()]\\r\\n self.assertTrue(tmid.isRoot())\\r\\n self.assertEqual(tmid.distance(tmid.getNodeMatchingName('d')), 2.75)\",\n \"def midpointRooting(infileName, outfileName):\\n newickString=open(infileName, 'rb').readline().rstrip().replace('[&R] ', '')\\n tree = Tree(newickString);\\n \\n if tree.get_midpoint_outgroup()!=None:\\n tree.set_outgroup( tree.get_midpoint_outgroup() )\\n tree.ladderize()\\n with open(outfileName, 'wb') as outfile:\\n outfile.write(tree.write(format=1))\",\n \"def deserialize(string):\\r\\n # For empty string return None, which makes the logic simpler\\r\\n # at node creation\\r\\n if len(string) == 0:\\r\\n return None \\r\\n\\r\\n # Simplest case - leaf, no children\\r\\n if string.count(\\\"(\\\") == 0:\\r\\n return Node(string)\\r\\n\\r\\n # Extract parent and children\\r\\n subs = string.split(\\\"(\\\", 1)\\r\\n root = subs[0]\\r\\n # Remove closing bracket\\r\\n rest = subs[1][:-1]\\r\\n\\r\\n # Simple case - left child has no children\\r\\n left, right = rest.split(\\\"|\\\", 1)\\r\\n if left.count(\\\"(\\\") == 0:\\r\\n return Node(root, deserialize(left), deserialize(right))\\r\\n\\r\\n # Keep moving right until we find the end of left's children\\r\\n next_index = rest.index(\\\"|\\\", len(left)+1)\\r\\n left = rest[:next_index]\\r\\n right = rest[next_index+1:]\\r\\n while left.count('(') != left.count(')'):\\r\\n next_index = rest.index(\\\"|\\\", next_index+1)\\r\\n left = rest[:next_index]\\r\\n right = rest[next_index+1:]\\r\\n\\r\\n return Node(root, deserialize(left), deserialize(right))\",\n \"def create_test_node():\\n node = cmds.createNode(\\\"unknown\\\")\\n _add_test_attrs_to_node(node)\\n return node\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67046046","0.66692567","0.6668407","0.6530691","0.64476365","0.64186615","0.6259178","0.6180899","0.6084381","0.60290694","0.6021466","0.600306","0.5996744","0.5918722","0.5868246","0.58530134","0.57235086","0.56478876","0.5604132","0.55337864","0.55275196","0.5519883","0.5508739","0.54919386","0.54763067","0.54430467","0.541777","0.53776944","0.5375151","0.5361841","0.5341451","0.53196263","0.5298619","0.52969176","0.5268018","0.5256352","0.5237083","0.52334434","0.5229165","0.5225223","0.52012044","0.51970035","0.5189356","0.5146855","0.51239914","0.5122128","0.5119835","0.511572","0.51141596","0.5097617","0.5093165","0.50931185","0.50882363","0.50877285","0.5081493","0.5066013","0.5062034","0.503863","0.50331956","0.50126904","0.50104403","0.500446","0.4996283","0.49958026","0.49876451","0.49733323","0.49713907","0.49709842","0.49705014","0.49692652","0.4958783","0.49523127","0.49488318","0.49428567","0.49399585","0.4932001","0.4923788","0.49138385","0.49059883","0.49016","0.4895541","0.48815313","0.48789397","0.48697758","0.4868097","0.48648468","0.48579597","0.485485","0.48530135","0.48520446","0.4849345","0.48431352","0.4823574","0.48218414","0.48158857","0.4815695","0.48138326","0.48128235","0.48085567","0.48061198"],"string":"[\n \"0.67046046\",\n \"0.66692567\",\n \"0.6668407\",\n \"0.6530691\",\n \"0.64476365\",\n \"0.64186615\",\n \"0.6259178\",\n \"0.6180899\",\n \"0.6084381\",\n \"0.60290694\",\n \"0.6021466\",\n \"0.600306\",\n \"0.5996744\",\n \"0.5918722\",\n \"0.5868246\",\n \"0.58530134\",\n \"0.57235086\",\n \"0.56478876\",\n \"0.5604132\",\n \"0.55337864\",\n \"0.55275196\",\n \"0.5519883\",\n \"0.5508739\",\n \"0.54919386\",\n \"0.54763067\",\n \"0.54430467\",\n \"0.541777\",\n \"0.53776944\",\n \"0.5375151\",\n \"0.5361841\",\n \"0.5341451\",\n \"0.53196263\",\n \"0.5298619\",\n \"0.52969176\",\n \"0.5268018\",\n \"0.5256352\",\n \"0.5237083\",\n \"0.52334434\",\n \"0.5229165\",\n \"0.5225223\",\n \"0.52012044\",\n \"0.51970035\",\n \"0.5189356\",\n \"0.5146855\",\n \"0.51239914\",\n \"0.5122128\",\n \"0.5119835\",\n \"0.511572\",\n \"0.51141596\",\n \"0.5097617\",\n \"0.5093165\",\n \"0.50931185\",\n \"0.50882363\",\n \"0.50877285\",\n \"0.5081493\",\n \"0.5066013\",\n \"0.5062034\",\n \"0.503863\",\n \"0.50331956\",\n \"0.50126904\",\n \"0.50104403\",\n \"0.500446\",\n \"0.4996283\",\n \"0.49958026\",\n \"0.49876451\",\n \"0.49733323\",\n \"0.49713907\",\n \"0.49709842\",\n \"0.49705014\",\n \"0.49692652\",\n \"0.4958783\",\n \"0.49523127\",\n \"0.49488318\",\n \"0.49428567\",\n \"0.49399585\",\n \"0.4932001\",\n \"0.4923788\",\n \"0.49138385\",\n \"0.49059883\",\n \"0.49016\",\n \"0.4895541\",\n \"0.48815313\",\n \"0.48789397\",\n \"0.48697758\",\n \"0.4868097\",\n \"0.48648468\",\n \"0.48579597\",\n \"0.485485\",\n \"0.48530135\",\n \"0.48520446\",\n \"0.4849345\",\n \"0.48431352\",\n \"0.4823574\",\n \"0.48218414\",\n \"0.48158857\",\n \"0.4815695\",\n \"0.48138326\",\n \"0.48128235\",\n \"0.48085567\",\n \"0.48061198\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76883775"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92889,"cells":{"query":{"kind":"string","value":"Test that parse_newick throws the right kind of exception when the ; is missing."},"document":{"kind":"string","value":"def test05(self):\n\n s = \"a\"\n with self.assertRaises(ParserException):\n t = parse_newick(s)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_no_start_open_parens(self):\n self.assertRaises(ValueError, NewickTokenizer, newick='hi')","def test_extra_closed(self):\n nt = NewickTokenizer(newick='(a,(b,c)));')\n self.assertRaises(ValueError, nt.tokens)","def test_unclosed_comment(self):\n nt = NewickTokenizer(newick='(a,(b,c),[(d,e));')\n self.assertRaises(ValueError, nt.tokens)","def test_comma_bef_semicolon(self):\n nt = NewickTokenizer(newick='(a,(b,c),(d,e)),;')\n self.assertRaises(ValueError, nt.tokens)","def test_missing_delim(self):","def test_unclosed(self):\n nt = NewickTokenizer(newick='(a,(b,c)')\n self.assertRaises(ValueError, nt.tokens)","def test_unexpected_comma(self):\n nt = NewickTokenizer(newick='(a,(b,c),,(d,e));')\n self.assertRaises(ValueError, nt.tokens)","def test_parse_newick(self):\r\n # confirm that it works without escaped names\r\n t1 = ('((((tax7:0.1,tax3:0.2):.98,tax8:.3, tax4:.3):.4,'\r\n '((tax1:0.3, tax6:.09):0.43,tax2:0.4):0.5):.2,'\r\n '(tax9:0.3, endbigtaxon:.08));')\r\n expected1 = ['tax7', 'tax3', 'tax8', 'tax4', 'tax1',\r\n 'tax6', 'tax2', 'tax9', 'endbigtaxon']\r\n self.assertEqual(set(parse_newick(t1).getTipNames()), set(expected1))\r\n self.assertEqual(set([tip.Name for tip in parse_newick(t1).tips()]),\r\n set(expected1))\r\n\r\n # throw some screwed up names in\r\n t2 = ('((((tax7:0.1,tax3:0.2):.98,tax8:.3, \\'tax4\\':.3):.4,'\r\n \"(('ta_______ x1':0.3, tax6:.09):0.43,tax2:0.4):0.5):.2,\"\r\n '(tax9:0.3, endbigtaxon:.08));')\r\n expected2 = ['tax7', 'tax3', 'tax8', 'tax4', 'ta_______ x1',\r\n 'tax6', 'tax2', 'tax9', 'endbigtaxon']\r\n self.assertEqual(set(parse_newick(t2).getTipNames()), set(expected2))\r\n self.assertEqual(set([tip.Name for tip in parse_newick(t2).tips()]),\r\n set(expected2))","def test_label(self):\n nt = NewickTokenizer(newick=\"(a\\n'b',(b,c),(d,e));\")\n self.assertRaises(ValueError, nt.tokens)","def test_open_closed(self):\n nt = NewickTokenizer(newick='(a,(),(d,e));')\n self.assertRaises(ValueError, nt.tokens)","def test_extra_suffix(self):\n nt = NewickTokenizer(newick='(a,(b,c));suffix')\n self.assertRaises(ValueError, nt.tokens)","def test_parse_invalid_file(self):\n with pytest.raises(ParserError):\n self.parser.parse(\"invalid csv\")","def test_odd_quotes(self):\n content = \"((h_ ,'p)h p,g()[],:_)hpg;\"\n tok = NewickTokenizer(StringIO(content))\n self.assertRaises(Exception, tok.tokens)\n content = \"((h_ ,'p')h p,'g()[]',:_')hpg;\"\n tok = NewickTokenizer(StringIO(content))\n self.assertRaises(Exception, tok.tokens)","def test_140709_nogeoms(self):\n with self.assertRaises(Exception):\n _ = parser(get_file('PTSDY3_nogeoms.txt'))","def test04(self):\n\n s = \"a;\"\n t = parse_newick(s);\n self.assertTrue(self.isTree(t) and t.label == \"a\" and t.isLeaf())","def test_invalid_pseudo_open(self):\n\n with self.assertRaises(SyntaxError):\n sv.compile(':is(div')","def test():\n\ttry:\n\t\tprint \"Raising ParseErrror.\"\n\t\traise ParseError\n\texcept ParseError:\n\t\tprint \"Caught ParseError.\"","def parseNewick(string):\n if string.find(';') != -1:\n string = string[:string.find(';')]\n return PhyloTree(parseNewickNode(string))","def test_140710_nogeom(self):\n with self.assertRaises(Exception):\n _ = parser(get_file('PTSDY2_nogeom.txt'))","def test_with_bad_lines():\n bad_lines = [\n ')(',\n 'has (open paren only',\n 'has closed) paren only',\n '(two (open one closed)',\n 'two (closed one) open)',\n ]\n for line in bad_lines:\n with pytest.raises(ParseError):\n nest_parens(line)","def test_missing_open_paren():\n svl_string = \"\"\"\n DATASETS bigfoot \"bigfoot.csv\"\n CONCAT\n SCATTER bigfoot X latitude Y temperature_mid\n PIE bigfoot AXIS classification\n )\n \"\"\"\n\n with pytest.raises(SvlMissingParen):\n parse_svl(svl_string)","def main():\n\ttest() #test ParseError","def test_simple_parse(self):\n pass","def test_fetchParserHeaderMissingParentheses(self):\n p = imap4._FetchParser()\n self.assertRaises(Exception,\n p.parseString, b\"BODY[HEADER.FIELDS Missing)]\")\n p = imap4._FetchParser()\n self.assertRaises(Exception,\n p.parseString, b'BODY[HEADER.FIELDS (Missing]')","def test_lexing_error_evaluate_2():\n with pytest.raises(SyntaxError):\n lex._lexer([lex_premades.float], [], \"[[LINE]] [[TEXT]]\")._load_text(\n \"TEST\"\n ).evaluate()","def test_sans_comma(self):\n nt = NewickTokenizer(newick='(a,(b,c)(d,e));')\n self.assertRaises(ValueError, nt.tokens)","def test_invalid_pseudo_close(self):\n\n with self.assertRaises(SyntaxError):\n sv.compile('div)')\n\n with self.assertRaises(SyntaxError):\n sv.compile(':is(div,)')","def test_wrong_type_error(self, parse_input_mocked_metadata):\n with pytest.raises(ValueError, match=\"invalid value\"):\n bb = parse_input_mocked_metadata(\n \"for int m in [1, 4.2, 9]\\n\\tMZgate(0, 1) | [0, 1]\"\n )","def doomed_parser(line):\n raise exceptions.LineParseException('Error occurred')","def test_label_with_non_string():\n svl_string = \"\"\"\n DATASETS bigfoot \"bigfoot.csv\"\n LINE bigfoot\n Y classification COUNT\n SPLIT BY classification\n X date BY YEAR LABEL 1.2\n \"\"\"\n\n # TODO Make this exception more specific if possible.\n with pytest.raises(SvlSyntaxError):\n parse_svl(svl_string)","def test_fetchParserExpectedWhitespace(self):\n p = imap4._FetchParser()\n self.assertRaises(Exception, p.parseString, b\"BODY[HEADER.FIELDS!]\")","def test_trace_parse_handling():\n\n print(\"Testing incorrect parsing:\")\n assert not actions.trace.TraceAction().parse(\"5:4\", logger)\n assert not actions.trace.TraceAction().parse(\"THISHOULDFAIL\", logger)\n assert not actions.trace.TraceAction().parse(\"\", logger)","def test_dataset_file_with_non_string():\n svl_string = \"\"\"\n DATASETS bigfoot 3\n LINE bigfoot X date BY YEAR Y date COUNT\n \"\"\"\n\n # TODO Make this exception more specific if possible.\n with pytest.raises(SvlSyntaxError):\n parse_svl(svl_string)","def test_missing_close_paren():\n svl_string = \"\"\"\n DATASETS bigfoot \"bigfoot.csv\"\n CONCAT(\n HISTOGRAM bigfoot X temperature_mid\n HISTOGRAM bigfoot X temperature_high\n \"\"\"\n\n with pytest.raises(SvlMissingParen):\n parse_svl(svl_string)","def test_errored_parsing(parser_class, raw_file, exception):\n with open(raw_file, \"rb\") as file_obj:\n parser = parser_class(raw=file_obj.read())\n\n with pytest.raises(exception):\n parser.process()","def test_step_with_non_number():\n svl_string = \"\"\"\n DATASETS bigfoot \"bigfoot.csv\"\n HISTOGRAM bigfoot STEP \"hello there\" X temperature_mid\n \"\"\"\n\n # TODO make exception more specific if possible.\n with pytest.raises(SvlSyntaxError):\n parse_svl(svl_string)","def test_no_arg(self):\n self.assertRaises(ValueError, NewickTokenizer)","def test_invalid_regref(self, parse_input_mocked_metadata):\n with pytest.raises(BlackbirdSyntaxError, match=\"reserved for register references\"):\n parse_input_mocked_metadata(\"float q0 = 5\")\n\n with pytest.raises(BlackbirdSyntaxError, match=\"reserved for register references\"):\n parse_input_mocked_metadata(\"float array q4 =\\n\\t-0.1, 0.2\")","def test_lexing_error_evaluate_3():\n with pytest.raises(SyntaxError):\n lex._lexer([lex_premades.float], [], example_function())._load_text(\n \"TEST\"\n ).evaluate()","def test_parse_quotes_no_quote(self):\n with self.assertRaisesRegexp(Exception, 'a quote was not found'):\n api.parse_quote(\"| Author | Publication | tag1, tag2 , tag3 \", simple_format=False)","def test_transform_with_non_string():\n svl_string = \"\"\"\n DATASETS bigfoot \"bigfoot.csv\"\n SCATTER bigfoot X TRANSFORM 1.2 Y temperature_mid\n \"\"\"\n\n with pytest.raises(SvlSyntaxError):\n parse_svl(svl_string)","def test_non_int_value_raises_an_exception():\n test_file = StringIO(\n u'fri,wed\\na,6'\n )\n\n csv_parser = CSVParser(test_file)\n\n with pytest.raises(ValueError):\n csv_parser.parse()","def test_lexing_error_evaluate_1():\n with pytest.raises(SyntaxError):\n lex._lexer([lex_premades.float], [])._load_text(\"TEST\").evaluate()","def test_onlySeparator(self):\n result = self.parser.parse(\"d\")\n\n self.assertIsNone(result)","def test_missing_close_paren_vcat():\n svl_string = \"\"\"\n (\n HISTOGRAM bigfoot X temperature_mid\n HISTOGRAM bigfoot Y temperature_high\n \"\"\"\n\n # TODO Add a more specific exception here.\n with pytest.raises(SvlSyntaxError):\n parse_svl(svl_string)","def test_empty(self):\n self.assertRaises(ParseException, self.flag.parseString, '')","def test_invalid_variable_name(self, parse_input_mocked_metadata):\n with pytest.raises(BlackbirdSyntaxError, match=\"reserved Blackbird keyword\"):\n parse_input_mocked_metadata(\"float name = 5\")\n\n with pytest.raises(BlackbirdSyntaxError, match=\"reserved Blackbird keyword\"):\n parse_input_mocked_metadata(\"float target = 5\")\n\n with pytest.raises(BlackbirdSyntaxError, match=\"reserved Blackbird keyword\"):\n parse_input_mocked_metadata(\"float version = 5\")\n\n with pytest.raises(BlackbirdSyntaxError, match=\"reserved Blackbird keyword\"):\n parse_input_mocked_metadata(\"float array name =\\n\\t-0.1, 0.2\")\n\n with pytest.raises(BlackbirdSyntaxError, match=\"reserved Blackbird keyword\"):\n parse_input_mocked_metadata(\"float array target =\\n\\t-0.1, 0.2\")\n\n with pytest.raises(BlackbirdSyntaxError, match=\"reserved Blackbird keyword\"):\n parse_input_mocked_metadata(\"float array version =\\n\\t-0.1, 0.2\")","def test_whitespace(self):\n self.assertRaises(ParseException, self.flag.parseString, ' ')","def test_empty(self):\n record = ''\n\n self.assertRaises(ParseException, self.grammar.parseString, record)","def test_false_lower(self):\n self.assertRaises(ParseException, self.flag.parseString, 'n')","def test_invalid_parameters_are_invalid(self):\n with self.assertRaises(parser.JavaSyntaxError):\n parse.parse(setup_java_class(\"(a b c) -> {};\"))","def test_parse_simple_quote_with_no_quote(self):\n with self.assertRaisesRegexp(Exception, re.escape(\"a quote was not found\")):\n api.parse_quote(\" - Hamlet \", simple_format=True)","def test_incompatible_rules():\n\n grammar = \"\"\"\n A: B | C;\n B: 'enumeration';\n C: value=INT;\n \"\"\"\n with pytest.raises(TextXSyntaxError):\n metamodel_from_str(grammar)","def test_fetchParserIncompleteStringEndsInWhitespace(self):\n p = imap4._FetchParser()\n self.assertRaises(Exception, p.parseString, b\"BODY[HEADER.FIELDS \")","def test_parse_date_exceptions(\n test_input: typing.Any,\n expected: Exception,\n):\n with pytest.raises(expected):\n tvmaze.parsers.parse_date(test_input)","def test_smoke():\n raise SkipTest\n parse('[8]')\n parse('[show \"hey\"]')\n parse('[frob thing with thong]')\n parse('[\"this\" \"thing\"]')\n parse('[[] []]')\n parse('[key: value key2: value2 orphan]')\n parse('[1 + (2 + 3)]')\n parse('[funcs: [term/on-red 8 \"foo\"]]')","def test_fetchParserUnknownAttribute(self):\n p = imap4._FetchParser()\n self.assertRaises(Exception, p.parseString, b\"UNKNOWN\")","def test_missing_open_paren_vcat():\n svl_string = \"\"\"\n DATASETS bigfoot \"bigfoot.csv\"\n SCATTER bigfoot X latitude Y temperature_mid\n PIE bigfoot AXIS classification HOLE 0.2\n )\n \"\"\"\n\n with pytest.raises(SvlMissingParen):\n parse_svl(svl_string)","def test_hole_with_non_number():\n svl_string = \"\"\"\n DATASETS bigfoot \"bigfoot.csv\"\n PIE bigfoot HOLE hi AXIS classification\n \"\"\"\n\n with pytest.raises(SvlTypeError):\n parse_svl(svl_string)","def test_lexing_error():\n with pytest.raises(SyntaxError):\n lex._lexer(None, None)._load_text(\"TEST\")._throw_lexing_error()","def test_invalid_aggregation():\n svl_string = \"\"\"\n DATASETS bigfoot \"bigfoot.csv\"\n LINE bigfoot X date BY YEAR Y temperature_mid ARGMIN\n \"\"\"\n\n # TODO Make this exception more specific if possible.\n with pytest.raises(SvlSyntaxError):\n parse_svl(svl_string)","def test_missing_split_by_value():\n svl_string = \"\"\"\n DATASETS bigfoot \"bigfoot.csv\"\n HISTOGRAM bigfoot X temperature_mid SPLIT BY\n \"\"\"\n\n # TODO Get a more specific exception here.\n with pytest.raises(SvlSyntaxError):\n parse_svl(svl_string)","def test_data_parse_invalid_json(self):\n lines = ['{\"a\": \"val\" \"b\": \"val2\"}']\n self.assertRaises(TypeError, parser._parse_data, lines)","def test_bogus_newick(self):\n\n x = self.start_request_tests(service.get_request('POST', {u'tree1_nwk': '(a,b)c);',\n u'tree2_nwk': '((a,b)c'}))\n self.assert_response_status(x, 400)\n # json.dump(x.json(), sys.stdout, indent=2)\n mess = x.json()[u'message']\n # Not clear what the message ought to say; be prepared to change the \n # following check to match the message that eventually gets chosen.\n self.assertTrue('yntax' in mess, mess)","def test_invalid_tag(self):\n\n with self.assertRaises(SyntaxError):\n sv.compile(':is(div)p')","def test_parse_tags_invalid(self):\n tagstring = \"tag1, tag2, tag3!\"\n\n with self.assertRaisesRegexp(Exception, \"invalid tag 'tag3!': only numbers, letters, and commas are \"\n \"allowed in tags\"):\n api.parse_tags(tagstring)","def test_missing_hole_value():\n svl_string = \"\"\"PIE bigfoot AXIS classification HOLE\"\"\"\n\n # TODO Get a more specific exception here.\n with pytest.raises(SvlSyntaxError):\n parse_svl(svl_string)","def test_readbadformat(self):\n\n self.assertRaises(ParseError, self.hw, self.badfile)","def test_decode_raises_when_format_unknown(thing):\n with pytest.raises(ValueError):\n decode(thing)","def test_fetchParserUnknownSection(self):\n p = imap4._FetchParser()\n self.assertRaises(Exception, p.parseString, b\"BODY[UNKNOWN]\")","def test_peek_none(self):\n nt = NewickTokenizer(newick='(a,(b,c));')\n nt.tokens()\n self.assertIsNone(nt._peek())","def test_no_brackets_in_words():\n raise SkipTest\n assert_raises(ParseError, grammar['word'].parse, ']')","def test_parse_invalid_df(self):\n mock_scraper = MockCtdScraper()\n mock_scraper.filename = \"sample_corrupt_ctd_db.csv\"\n scrape_gen = mock_scraper.scrape(TEST_CHUNKSIZE)\n with pytest.raises(ParserError):\n self.parser.parse(next(scrape_gen))","def test_parse_devide(self):\n self.assertEqual(parse_input.parse([\"8\", \"/\", \"4\"]), 2)","def testParse_extraLines(self):\n config_path = GetTestFilePath('invalid/config_extra_lines.yaml')\n with self.assertRaises(lab_config.ConfigError):\n with open(config_path, 'r') as f:\n lab_config.Parse(f)","def test_invalid_pseudo(self):\n\n with self.assertRaises(NotImplementedError):\n sv.compile(':before')\n\n with self.assertRaises(SyntaxError):\n sv.compile(':nth-child(a)')","def test_nonsense_decimal(self):\n test_passes = False\n try:\n self.parser.extract_zt(\"ZT.\")\n test_passes = False\n except Exception as e:\n test_passes = True\n self.assertTrue(test_passes)","def test_old_grammar_fails():\n\n strings = [\n 'update schema for test set a = continuous',\n 'update schema for test set a = multinomial',\n # Cyclic is invalid because it should be followed by (min, max) parameters.\n 'update schema for test set a = cyclic'\n ]\n\n for query_string in strings:\n with pytest.raises(ParseException):\n ast = bql_statement.parseString(query_string, parseAll=True)","def test_modifier_parse_exceptions():\n\n parser = ConfigParser(io.StringIO())\n with pytest.raises(ConfigParserException):\n parser._parse_multi_range(u\"A\", u\"potential1 1.0 2.0 3.0 potential2 2.0\")","def test_bad_symbol():\n token = None\n\n with pytest.raises(LythSyntaxError) as err:\n token = Token(\";\", TokenInfo(\"<stdin>\", 0, 1, \";\"))\n\n assert token is None\n assert err.value.msg is LythError.INVALID_CHARACTER\n assert err.value.filename == \"<stdin>\"\n assert err.value.lineno == 0\n assert err.value.offset == 1\n assert err.value.line == \";\"\n\n token = Token(\"+\", TokenInfo(\"<stdin>\", 0, 1, \"+;\"))\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"+\"\n assert token.info.lineno == 0\n assert token.symbol == Symbol.ADD\n assert token.info.line == \"+;\"\n\n with pytest.raises(LythSyntaxError) as err:\n token += \";\"\n\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"+\"\n assert token.info.lineno == 0\n assert token.symbol == Symbol.ADD\n assert token.info.line == \"+;\"\n\n assert err.value.msg is LythError.SYNTAX_ERROR\n assert err.value.filename == \"<stdin>\"\n assert err.value.lineno == 0\n assert err.value.offset == 1\n assert err.value.line == \"+;\"\n\n token = Token(\"6\", TokenInfo(\"<stdin>\", 0, 1, \"6;\"))\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"6\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.VALUE\n assert token.info.line == \"6;\"\n\n with pytest.raises(LythSyntaxError) as err:\n token += \";\"\n\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == \"6\"\n assert token.info.lineno == 0\n assert token.symbol == Literal.VALUE\n assert token.info.line == \"6;\"\n\n assert err.value.msg is LythError.SYNTAX_ERROR\n assert err.value.filename == \"<stdin>\"\n assert err.value.lineno == 0\n assert err.value.offset == 1\n assert err.value.line == \"6;\"\n\n token = token()\n assert token.info.offset == 1\n assert token.info.filename == \"<stdin>\"\n assert token.lexeme == 6\n assert token.info.lineno == 0\n assert token.symbol == Literal.VALUE\n assert token.info.line == \"6;\"","def test_failure(self):\n\n bad_examples = \"\"\"\n[test_date] > date(\"1 day from now\") ->\n\nCan't convert '1 day from now' to a date.\n===\n[test_date] between date(\"2020-01-01\") and 7 ->\nWhen using between, the column (date) and between values (date, num) must be the same data type.\n\n[test_date] between date(\"2020-01-01\") and 7\n ^\n===\n[test_date] between \"potato\" and date(\"2020-01-01\") ->\nCan't convert 'potato' to a date.\n\"\"\"\n\n for field, expected_error in self.bad_examples(bad_examples):\n with self.assertRaises(Exception) as e:\n self.builder.parse(field, debug=True)\n if str(e.exception).strip() != expected_error.strip():\n print(\"===\" * 10)\n print(str(e.exception))\n print(\"vs\")\n print(expected_error)\n print(\"===\" * 10)\n self.assertEqual(str(e.exception).strip(), expected_error.strip())","def test_regexp_chunk_parser():","def test_parse_simple_quote_with_newline(self):\n with self.assertRaisesRegexp(Exception, re.escape(\"the quote included a newline (0x0a) character\")):\n api.parse_quote(\" Quote with \\n character - Author\", simple_format=True)","def test_temporal_with_invalid_specifier():\n svl_string = \"\"\"\n DATASETS bigfoot \"bigfoot.csv\"\n LINE bigfoot Y temporal BY NOPE X classification COUNT\n \"\"\"\n\n # TODO Make this exception more specific if possible.\n with pytest.raises(SvlSyntaxError):\n parse_svl(svl_string)","def test_parser_patch_______(parser):\n pass","def test_psi4_qmefpformat_error_6c():\n\n subject = subject6.replace(' efp h2O', '0 1\\n efp h2O')\n\n with pytest.raises(qcelemental.MoleculeFormatError):\n final, intermed = qcelemental.molparse.from_string(subject, return_processed=True)","def test_parse_output_error(self):\n self.assertRaises(ValueError,\n parse_output,\n hgt_results_fp=self.consel_output_hgt_fp,\n method=\"Consel\")","def test_parseMethodExceptionLogged(self):\n\n class UnhandledException(Exception):\n \"\"\"\n An unhandled exception.\n \"\"\"\n\n def raisesValueError(line):\n raise UnhandledException\n\n self.server.parseState = \"command\"\n self.server.parse_command = raisesValueError\n\n self.server.lineReceived(b\"invalid\")\n\n self.assertTrue(self.flushLoggedErrors(UnhandledException))","def test_sleep_parse_handling():\n\n print(\"Testing incorrect parsing:\")\n assert not actions.sleep.SleepAction().parse(\"THISHSOULDFAIL\", logger)\n\n assert actions.sleep.SleepAction().parse(\"10.5\", logger)","def test_syntax_errors(self):\r\n bad_math_list = [\r\n '11+',\r\n '11*',\r\n 'f((x)',\r\n 'sqrt(x^)',\r\n '3f(x)', # Not 3*f(x)\r\n '3|4',\r\n '3|||4'\r\n ]\r\n bad_exceptions = {}\r\n for math in bad_math_list:\r\n try:\r\n preview.latex_preview(math)\r\n except pyparsing.ParseException:\r\n pass # This is what we were expecting. (not excepting :P)\r\n except Exception as error: # pragma: no cover\r\n bad_exceptions[math] = error\r\n else: # pragma: no cover\r\n # If there is no exception thrown, this is a problem\r\n bad_exceptions[math] = None\r\n\r\n self.assertEquals({}, bad_exceptions)","def test_dataset_sql_with_non_string():\n svl_string = \"\"\"\n DATASETS\n bigfoot \"bigfoot.csv\"\n bigfoot_with_location SQL 3\n PIE bigfoot_with_location AXIS has_location\n \"\"\"\n\n # TODO Make this exception more specific if possible.\n with pytest.raises(SvlSyntaxError):\n parse_svl(svl_string)","def test_explicit_delimiter_specification(self):\n transformer = SplitTransformer()\n transformer.setup(\"test\", {\n \"dateformat\" : \"%Y-%m-%d %H:%M:%S\",\n \"delimiter\" : \"\\.-\\.\",\n \"group_order\" : \"HOST_NAME HOST_ADDRESS PRIORITY FACILITY TIME DATE MESSAGE\" \n })\n teststring = \"test_host.-.42.2.53.52.-.5.-.4.-.11:00:24.-.2012-12-10.-.Testmessage\"\n event = transformer.transform(teststring)\n assert event != None\n assert event[\"host_name\"] == \"test_host\"\n assert event[\"host_address\"] == IPAddress(\"42.2.53.52\")\n assert event[\"priority\"] == \"5\"\n assert event[\"facility\"] == \"4\"\n assert event[\"message\"] == \"Testmessage\"","def testUnparsedImport(self):\n a = 'a.mojom'\n b = 'b.mojom'\n self.WriteFile(a, \"\"\"\\\n module a;\n struct Bar {};\"\"\")\n self.WriteFile(\n b, \"\"\"\\\n module b;\n import \"a.mojom\";\n struct Foo { a.Bar bar; };\"\"\")\n\n # a.mojom has not been parsed yet, so its import will fail when processing\n # b.mojom here.\n with self.assertRaisesRegexp(ValueError, \"does not exist\"):\n self.ParseMojoms([b])","def test_title_with_non_string():\n svl_string = \"\"\"\n DATASETS bigfoot \"bigfoot.csv\"\n LINE bigfoot\n X date BY YEAR\n TITLE 1\n Y date COUNT\n SPLIT BY classification\n \"\"\"\n\n # TODO Make this exception more specific if possible.\n with pytest.raises(SvlSyntaxError):\n parse_svl(svl_string)","def test_unknown_lower(self):\n self.assertRaises(ParseException, self.flag.parseString, 'u')","def test_select_result_parse(\n data: str, format: str, parse_outcome: ParseOutcomeType\n) -> None:\n logging.debug(\"data = %s\", data)\n\n if inspect.isclass(parse_outcome) and issubclass(parse_outcome, Exception):\n with pytest.raises(parse_outcome):\n parsed_result = Result.parse(StringIO(data), format=format)\n else:\n parsed_result = Result.parse(StringIO(data), format=format)\n assert parse_outcome == parsed_result.bindings","def test_schema_invalid_format(self):\n bad_schema = [int, int, float, float, str]\n with self.assertRaisesRegexp(Exception, \"more than one char\"):\n self.context.frame.import_csv(self.dataset, bad_schema)","def test_script_rejects_bad_xml(self):\n maker = Compilers(test_utils.MockMachines(\"mymachine\", \"SomeOS\"), version=2.0)\n with self.assertRaises(ParseError):\n test_utils.get_macros(maker, \"This is not valid XML.\", \"Makefile\")","def test_incorrect_formats(self, text):\n with pytest.raises(ValueError):\n parse_changelog(text)","def test_invalid_expression_type(self, parse_input_mocked_metadata):\n with pytest.raises(TypeError, match=r\"not of declared type int\"):\n parse_input_mocked_metadata(\"int Beta = -0.231e-6+5.21e-2j\")"],"string":"[\n \"def test_no_start_open_parens(self):\\n self.assertRaises(ValueError, NewickTokenizer, newick='hi')\",\n \"def test_extra_closed(self):\\n nt = NewickTokenizer(newick='(a,(b,c)));')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def test_unclosed_comment(self):\\n nt = NewickTokenizer(newick='(a,(b,c),[(d,e));')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def test_comma_bef_semicolon(self):\\n nt = NewickTokenizer(newick='(a,(b,c),(d,e)),;')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def test_missing_delim(self):\",\n \"def test_unclosed(self):\\n nt = NewickTokenizer(newick='(a,(b,c)')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def test_unexpected_comma(self):\\n nt = NewickTokenizer(newick='(a,(b,c),,(d,e));')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def test_parse_newick(self):\\r\\n # confirm that it works without escaped names\\r\\n t1 = ('((((tax7:0.1,tax3:0.2):.98,tax8:.3, tax4:.3):.4,'\\r\\n '((tax1:0.3, tax6:.09):0.43,tax2:0.4):0.5):.2,'\\r\\n '(tax9:0.3, endbigtaxon:.08));')\\r\\n expected1 = ['tax7', 'tax3', 'tax8', 'tax4', 'tax1',\\r\\n 'tax6', 'tax2', 'tax9', 'endbigtaxon']\\r\\n self.assertEqual(set(parse_newick(t1).getTipNames()), set(expected1))\\r\\n self.assertEqual(set([tip.Name for tip in parse_newick(t1).tips()]),\\r\\n set(expected1))\\r\\n\\r\\n # throw some screwed up names in\\r\\n t2 = ('((((tax7:0.1,tax3:0.2):.98,tax8:.3, \\\\'tax4\\\\':.3):.4,'\\r\\n \\\"(('ta_______ x1':0.3, tax6:.09):0.43,tax2:0.4):0.5):.2,\\\"\\r\\n '(tax9:0.3, endbigtaxon:.08));')\\r\\n expected2 = ['tax7', 'tax3', 'tax8', 'tax4', 'ta_______ x1',\\r\\n 'tax6', 'tax2', 'tax9', 'endbigtaxon']\\r\\n self.assertEqual(set(parse_newick(t2).getTipNames()), set(expected2))\\r\\n self.assertEqual(set([tip.Name for tip in parse_newick(t2).tips()]),\\r\\n set(expected2))\",\n \"def test_label(self):\\n nt = NewickTokenizer(newick=\\\"(a\\\\n'b',(b,c),(d,e));\\\")\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def test_open_closed(self):\\n nt = NewickTokenizer(newick='(a,(),(d,e));')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def test_extra_suffix(self):\\n nt = NewickTokenizer(newick='(a,(b,c));suffix')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def test_parse_invalid_file(self):\\n with pytest.raises(ParserError):\\n self.parser.parse(\\\"invalid csv\\\")\",\n \"def test_odd_quotes(self):\\n content = \\\"((h_ ,'p)h p,g()[],:_)hpg;\\\"\\n tok = NewickTokenizer(StringIO(content))\\n self.assertRaises(Exception, tok.tokens)\\n content = \\\"((h_ ,'p')h p,'g()[]',:_')hpg;\\\"\\n tok = NewickTokenizer(StringIO(content))\\n self.assertRaises(Exception, tok.tokens)\",\n \"def test_140709_nogeoms(self):\\n with self.assertRaises(Exception):\\n _ = parser(get_file('PTSDY3_nogeoms.txt'))\",\n \"def test04(self):\\n\\n s = \\\"a;\\\"\\n t = parse_newick(s);\\n self.assertTrue(self.isTree(t) and t.label == \\\"a\\\" and t.isLeaf())\",\n \"def test_invalid_pseudo_open(self):\\n\\n with self.assertRaises(SyntaxError):\\n sv.compile(':is(div')\",\n \"def test():\\n\\ttry:\\n\\t\\tprint \\\"Raising ParseErrror.\\\"\\n\\t\\traise ParseError\\n\\texcept ParseError:\\n\\t\\tprint \\\"Caught ParseError.\\\"\",\n \"def parseNewick(string):\\n if string.find(';') != -1:\\n string = string[:string.find(';')]\\n return PhyloTree(parseNewickNode(string))\",\n \"def test_140710_nogeom(self):\\n with self.assertRaises(Exception):\\n _ = parser(get_file('PTSDY2_nogeom.txt'))\",\n \"def test_with_bad_lines():\\n bad_lines = [\\n ')(',\\n 'has (open paren only',\\n 'has closed) paren only',\\n '(two (open one closed)',\\n 'two (closed one) open)',\\n ]\\n for line in bad_lines:\\n with pytest.raises(ParseError):\\n nest_parens(line)\",\n \"def test_missing_open_paren():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot \\\"bigfoot.csv\\\"\\n CONCAT\\n SCATTER bigfoot X latitude Y temperature_mid\\n PIE bigfoot AXIS classification\\n )\\n \\\"\\\"\\\"\\n\\n with pytest.raises(SvlMissingParen):\\n parse_svl(svl_string)\",\n \"def main():\\n\\ttest() #test ParseError\",\n \"def test_simple_parse(self):\\n pass\",\n \"def test_fetchParserHeaderMissingParentheses(self):\\n p = imap4._FetchParser()\\n self.assertRaises(Exception,\\n p.parseString, b\\\"BODY[HEADER.FIELDS Missing)]\\\")\\n p = imap4._FetchParser()\\n self.assertRaises(Exception,\\n p.parseString, b'BODY[HEADER.FIELDS (Missing]')\",\n \"def test_lexing_error_evaluate_2():\\n with pytest.raises(SyntaxError):\\n lex._lexer([lex_premades.float], [], \\\"[[LINE]] [[TEXT]]\\\")._load_text(\\n \\\"TEST\\\"\\n ).evaluate()\",\n \"def test_sans_comma(self):\\n nt = NewickTokenizer(newick='(a,(b,c)(d,e));')\\n self.assertRaises(ValueError, nt.tokens)\",\n \"def test_invalid_pseudo_close(self):\\n\\n with self.assertRaises(SyntaxError):\\n sv.compile('div)')\\n\\n with self.assertRaises(SyntaxError):\\n sv.compile(':is(div,)')\",\n \"def test_wrong_type_error(self, parse_input_mocked_metadata):\\n with pytest.raises(ValueError, match=\\\"invalid value\\\"):\\n bb = parse_input_mocked_metadata(\\n \\\"for int m in [1, 4.2, 9]\\\\n\\\\tMZgate(0, 1) | [0, 1]\\\"\\n )\",\n \"def doomed_parser(line):\\n raise exceptions.LineParseException('Error occurred')\",\n \"def test_label_with_non_string():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot \\\"bigfoot.csv\\\"\\n LINE bigfoot\\n Y classification COUNT\\n SPLIT BY classification\\n X date BY YEAR LABEL 1.2\\n \\\"\\\"\\\"\\n\\n # TODO Make this exception more specific if possible.\\n with pytest.raises(SvlSyntaxError):\\n parse_svl(svl_string)\",\n \"def test_fetchParserExpectedWhitespace(self):\\n p = imap4._FetchParser()\\n self.assertRaises(Exception, p.parseString, b\\\"BODY[HEADER.FIELDS!]\\\")\",\n \"def test_trace_parse_handling():\\n\\n print(\\\"Testing incorrect parsing:\\\")\\n assert not actions.trace.TraceAction().parse(\\\"5:4\\\", logger)\\n assert not actions.trace.TraceAction().parse(\\\"THISHOULDFAIL\\\", logger)\\n assert not actions.trace.TraceAction().parse(\\\"\\\", logger)\",\n \"def test_dataset_file_with_non_string():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot 3\\n LINE bigfoot X date BY YEAR Y date COUNT\\n \\\"\\\"\\\"\\n\\n # TODO Make this exception more specific if possible.\\n with pytest.raises(SvlSyntaxError):\\n parse_svl(svl_string)\",\n \"def test_missing_close_paren():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot \\\"bigfoot.csv\\\"\\n CONCAT(\\n HISTOGRAM bigfoot X temperature_mid\\n HISTOGRAM bigfoot X temperature_high\\n \\\"\\\"\\\"\\n\\n with pytest.raises(SvlMissingParen):\\n parse_svl(svl_string)\",\n \"def test_errored_parsing(parser_class, raw_file, exception):\\n with open(raw_file, \\\"rb\\\") as file_obj:\\n parser = parser_class(raw=file_obj.read())\\n\\n with pytest.raises(exception):\\n parser.process()\",\n \"def test_step_with_non_number():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot \\\"bigfoot.csv\\\"\\n HISTOGRAM bigfoot STEP \\\"hello there\\\" X temperature_mid\\n \\\"\\\"\\\"\\n\\n # TODO make exception more specific if possible.\\n with pytest.raises(SvlSyntaxError):\\n parse_svl(svl_string)\",\n \"def test_no_arg(self):\\n self.assertRaises(ValueError, NewickTokenizer)\",\n \"def test_invalid_regref(self, parse_input_mocked_metadata):\\n with pytest.raises(BlackbirdSyntaxError, match=\\\"reserved for register references\\\"):\\n parse_input_mocked_metadata(\\\"float q0 = 5\\\")\\n\\n with pytest.raises(BlackbirdSyntaxError, match=\\\"reserved for register references\\\"):\\n parse_input_mocked_metadata(\\\"float array q4 =\\\\n\\\\t-0.1, 0.2\\\")\",\n \"def test_lexing_error_evaluate_3():\\n with pytest.raises(SyntaxError):\\n lex._lexer([lex_premades.float], [], example_function())._load_text(\\n \\\"TEST\\\"\\n ).evaluate()\",\n \"def test_parse_quotes_no_quote(self):\\n with self.assertRaisesRegexp(Exception, 'a quote was not found'):\\n api.parse_quote(\\\"| Author | Publication | tag1, tag2 , tag3 \\\", simple_format=False)\",\n \"def test_transform_with_non_string():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot \\\"bigfoot.csv\\\"\\n SCATTER bigfoot X TRANSFORM 1.2 Y temperature_mid\\n \\\"\\\"\\\"\\n\\n with pytest.raises(SvlSyntaxError):\\n parse_svl(svl_string)\",\n \"def test_non_int_value_raises_an_exception():\\n test_file = StringIO(\\n u'fri,wed\\\\na,6'\\n )\\n\\n csv_parser = CSVParser(test_file)\\n\\n with pytest.raises(ValueError):\\n csv_parser.parse()\",\n \"def test_lexing_error_evaluate_1():\\n with pytest.raises(SyntaxError):\\n lex._lexer([lex_premades.float], [])._load_text(\\\"TEST\\\").evaluate()\",\n \"def test_onlySeparator(self):\\n result = self.parser.parse(\\\"d\\\")\\n\\n self.assertIsNone(result)\",\n \"def test_missing_close_paren_vcat():\\n svl_string = \\\"\\\"\\\"\\n (\\n HISTOGRAM bigfoot X temperature_mid\\n HISTOGRAM bigfoot Y temperature_high\\n \\\"\\\"\\\"\\n\\n # TODO Add a more specific exception here.\\n with pytest.raises(SvlSyntaxError):\\n parse_svl(svl_string)\",\n \"def test_empty(self):\\n self.assertRaises(ParseException, self.flag.parseString, '')\",\n \"def test_invalid_variable_name(self, parse_input_mocked_metadata):\\n with pytest.raises(BlackbirdSyntaxError, match=\\\"reserved Blackbird keyword\\\"):\\n parse_input_mocked_metadata(\\\"float name = 5\\\")\\n\\n with pytest.raises(BlackbirdSyntaxError, match=\\\"reserved Blackbird keyword\\\"):\\n parse_input_mocked_metadata(\\\"float target = 5\\\")\\n\\n with pytest.raises(BlackbirdSyntaxError, match=\\\"reserved Blackbird keyword\\\"):\\n parse_input_mocked_metadata(\\\"float version = 5\\\")\\n\\n with pytest.raises(BlackbirdSyntaxError, match=\\\"reserved Blackbird keyword\\\"):\\n parse_input_mocked_metadata(\\\"float array name =\\\\n\\\\t-0.1, 0.2\\\")\\n\\n with pytest.raises(BlackbirdSyntaxError, match=\\\"reserved Blackbird keyword\\\"):\\n parse_input_mocked_metadata(\\\"float array target =\\\\n\\\\t-0.1, 0.2\\\")\\n\\n with pytest.raises(BlackbirdSyntaxError, match=\\\"reserved Blackbird keyword\\\"):\\n parse_input_mocked_metadata(\\\"float array version =\\\\n\\\\t-0.1, 0.2\\\")\",\n \"def test_whitespace(self):\\n self.assertRaises(ParseException, self.flag.parseString, ' ')\",\n \"def test_empty(self):\\n record = ''\\n\\n self.assertRaises(ParseException, self.grammar.parseString, record)\",\n \"def test_false_lower(self):\\n self.assertRaises(ParseException, self.flag.parseString, 'n')\",\n \"def test_invalid_parameters_are_invalid(self):\\n with self.assertRaises(parser.JavaSyntaxError):\\n parse.parse(setup_java_class(\\\"(a b c) -> {};\\\"))\",\n \"def test_parse_simple_quote_with_no_quote(self):\\n with self.assertRaisesRegexp(Exception, re.escape(\\\"a quote was not found\\\")):\\n api.parse_quote(\\\" - Hamlet \\\", simple_format=True)\",\n \"def test_incompatible_rules():\\n\\n grammar = \\\"\\\"\\\"\\n A: B | C;\\n B: 'enumeration';\\n C: value=INT;\\n \\\"\\\"\\\"\\n with pytest.raises(TextXSyntaxError):\\n metamodel_from_str(grammar)\",\n \"def test_fetchParserIncompleteStringEndsInWhitespace(self):\\n p = imap4._FetchParser()\\n self.assertRaises(Exception, p.parseString, b\\\"BODY[HEADER.FIELDS \\\")\",\n \"def test_parse_date_exceptions(\\n test_input: typing.Any,\\n expected: Exception,\\n):\\n with pytest.raises(expected):\\n tvmaze.parsers.parse_date(test_input)\",\n \"def test_smoke():\\n raise SkipTest\\n parse('[8]')\\n parse('[show \\\"hey\\\"]')\\n parse('[frob thing with thong]')\\n parse('[\\\"this\\\" \\\"thing\\\"]')\\n parse('[[] []]')\\n parse('[key: value key2: value2 orphan]')\\n parse('[1 + (2 + 3)]')\\n parse('[funcs: [term/on-red 8 \\\"foo\\\"]]')\",\n \"def test_fetchParserUnknownAttribute(self):\\n p = imap4._FetchParser()\\n self.assertRaises(Exception, p.parseString, b\\\"UNKNOWN\\\")\",\n \"def test_missing_open_paren_vcat():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot \\\"bigfoot.csv\\\"\\n SCATTER bigfoot X latitude Y temperature_mid\\n PIE bigfoot AXIS classification HOLE 0.2\\n )\\n \\\"\\\"\\\"\\n\\n with pytest.raises(SvlMissingParen):\\n parse_svl(svl_string)\",\n \"def test_hole_with_non_number():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot \\\"bigfoot.csv\\\"\\n PIE bigfoot HOLE hi AXIS classification\\n \\\"\\\"\\\"\\n\\n with pytest.raises(SvlTypeError):\\n parse_svl(svl_string)\",\n \"def test_lexing_error():\\n with pytest.raises(SyntaxError):\\n lex._lexer(None, None)._load_text(\\\"TEST\\\")._throw_lexing_error()\",\n \"def test_invalid_aggregation():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot \\\"bigfoot.csv\\\"\\n LINE bigfoot X date BY YEAR Y temperature_mid ARGMIN\\n \\\"\\\"\\\"\\n\\n # TODO Make this exception more specific if possible.\\n with pytest.raises(SvlSyntaxError):\\n parse_svl(svl_string)\",\n \"def test_missing_split_by_value():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot \\\"bigfoot.csv\\\"\\n HISTOGRAM bigfoot X temperature_mid SPLIT BY\\n \\\"\\\"\\\"\\n\\n # TODO Get a more specific exception here.\\n with pytest.raises(SvlSyntaxError):\\n parse_svl(svl_string)\",\n \"def test_data_parse_invalid_json(self):\\n lines = ['{\\\"a\\\": \\\"val\\\" \\\"b\\\": \\\"val2\\\"}']\\n self.assertRaises(TypeError, parser._parse_data, lines)\",\n \"def test_bogus_newick(self):\\n\\n x = self.start_request_tests(service.get_request('POST', {u'tree1_nwk': '(a,b)c);',\\n u'tree2_nwk': '((a,b)c'}))\\n self.assert_response_status(x, 400)\\n # json.dump(x.json(), sys.stdout, indent=2)\\n mess = x.json()[u'message']\\n # Not clear what the message ought to say; be prepared to change the \\n # following check to match the message that eventually gets chosen.\\n self.assertTrue('yntax' in mess, mess)\",\n \"def test_invalid_tag(self):\\n\\n with self.assertRaises(SyntaxError):\\n sv.compile(':is(div)p')\",\n \"def test_parse_tags_invalid(self):\\n tagstring = \\\"tag1, tag2, tag3!\\\"\\n\\n with self.assertRaisesRegexp(Exception, \\\"invalid tag 'tag3!': only numbers, letters, and commas are \\\"\\n \\\"allowed in tags\\\"):\\n api.parse_tags(tagstring)\",\n \"def test_missing_hole_value():\\n svl_string = \\\"\\\"\\\"PIE bigfoot AXIS classification HOLE\\\"\\\"\\\"\\n\\n # TODO Get a more specific exception here.\\n with pytest.raises(SvlSyntaxError):\\n parse_svl(svl_string)\",\n \"def test_readbadformat(self):\\n\\n self.assertRaises(ParseError, self.hw, self.badfile)\",\n \"def test_decode_raises_when_format_unknown(thing):\\n with pytest.raises(ValueError):\\n decode(thing)\",\n \"def test_fetchParserUnknownSection(self):\\n p = imap4._FetchParser()\\n self.assertRaises(Exception, p.parseString, b\\\"BODY[UNKNOWN]\\\")\",\n \"def test_peek_none(self):\\n nt = NewickTokenizer(newick='(a,(b,c));')\\n nt.tokens()\\n self.assertIsNone(nt._peek())\",\n \"def test_no_brackets_in_words():\\n raise SkipTest\\n assert_raises(ParseError, grammar['word'].parse, ']')\",\n \"def test_parse_invalid_df(self):\\n mock_scraper = MockCtdScraper()\\n mock_scraper.filename = \\\"sample_corrupt_ctd_db.csv\\\"\\n scrape_gen = mock_scraper.scrape(TEST_CHUNKSIZE)\\n with pytest.raises(ParserError):\\n self.parser.parse(next(scrape_gen))\",\n \"def test_parse_devide(self):\\n self.assertEqual(parse_input.parse([\\\"8\\\", \\\"/\\\", \\\"4\\\"]), 2)\",\n \"def testParse_extraLines(self):\\n config_path = GetTestFilePath('invalid/config_extra_lines.yaml')\\n with self.assertRaises(lab_config.ConfigError):\\n with open(config_path, 'r') as f:\\n lab_config.Parse(f)\",\n \"def test_invalid_pseudo(self):\\n\\n with self.assertRaises(NotImplementedError):\\n sv.compile(':before')\\n\\n with self.assertRaises(SyntaxError):\\n sv.compile(':nth-child(a)')\",\n \"def test_nonsense_decimal(self):\\n test_passes = False\\n try:\\n self.parser.extract_zt(\\\"ZT.\\\")\\n test_passes = False\\n except Exception as e:\\n test_passes = True\\n self.assertTrue(test_passes)\",\n \"def test_old_grammar_fails():\\n\\n strings = [\\n 'update schema for test set a = continuous',\\n 'update schema for test set a = multinomial',\\n # Cyclic is invalid because it should be followed by (min, max) parameters.\\n 'update schema for test set a = cyclic'\\n ]\\n\\n for query_string in strings:\\n with pytest.raises(ParseException):\\n ast = bql_statement.parseString(query_string, parseAll=True)\",\n \"def test_modifier_parse_exceptions():\\n\\n parser = ConfigParser(io.StringIO())\\n with pytest.raises(ConfigParserException):\\n parser._parse_multi_range(u\\\"A\\\", u\\\"potential1 1.0 2.0 3.0 potential2 2.0\\\")\",\n \"def test_bad_symbol():\\n token = None\\n\\n with pytest.raises(LythSyntaxError) as err:\\n token = Token(\\\";\\\", TokenInfo(\\\"<stdin>\\\", 0, 1, \\\";\\\"))\\n\\n assert token is None\\n assert err.value.msg is LythError.INVALID_CHARACTER\\n assert err.value.filename == \\\"<stdin>\\\"\\n assert err.value.lineno == 0\\n assert err.value.offset == 1\\n assert err.value.line == \\\";\\\"\\n\\n token = Token(\\\"+\\\", TokenInfo(\\\"<stdin>\\\", 0, 1, \\\"+;\\\"))\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"+\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Symbol.ADD\\n assert token.info.line == \\\"+;\\\"\\n\\n with pytest.raises(LythSyntaxError) as err:\\n token += \\\";\\\"\\n\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"+\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Symbol.ADD\\n assert token.info.line == \\\"+;\\\"\\n\\n assert err.value.msg is LythError.SYNTAX_ERROR\\n assert err.value.filename == \\\"<stdin>\\\"\\n assert err.value.lineno == 0\\n assert err.value.offset == 1\\n assert err.value.line == \\\"+;\\\"\\n\\n token = Token(\\\"6\\\", TokenInfo(\\\"<stdin>\\\", 0, 1, \\\"6;\\\"))\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"6\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.VALUE\\n assert token.info.line == \\\"6;\\\"\\n\\n with pytest.raises(LythSyntaxError) as err:\\n token += \\\";\\\"\\n\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == \\\"6\\\"\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.VALUE\\n assert token.info.line == \\\"6;\\\"\\n\\n assert err.value.msg is LythError.SYNTAX_ERROR\\n assert err.value.filename == \\\"<stdin>\\\"\\n assert err.value.lineno == 0\\n assert err.value.offset == 1\\n assert err.value.line == \\\"6;\\\"\\n\\n token = token()\\n assert token.info.offset == 1\\n assert token.info.filename == \\\"<stdin>\\\"\\n assert token.lexeme == 6\\n assert token.info.lineno == 0\\n assert token.symbol == Literal.VALUE\\n assert token.info.line == \\\"6;\\\"\",\n \"def test_failure(self):\\n\\n bad_examples = \\\"\\\"\\\"\\n[test_date] > date(\\\"1 day from now\\\") ->\\n\\nCan't convert '1 day from now' to a date.\\n===\\n[test_date] between date(\\\"2020-01-01\\\") and 7 ->\\nWhen using between, the column (date) and between values (date, num) must be the same data type.\\n\\n[test_date] between date(\\\"2020-01-01\\\") and 7\\n ^\\n===\\n[test_date] between \\\"potato\\\" and date(\\\"2020-01-01\\\") ->\\nCan't convert 'potato' to a date.\\n\\\"\\\"\\\"\\n\\n for field, expected_error in self.bad_examples(bad_examples):\\n with self.assertRaises(Exception) as e:\\n self.builder.parse(field, debug=True)\\n if str(e.exception).strip() != expected_error.strip():\\n print(\\\"===\\\" * 10)\\n print(str(e.exception))\\n print(\\\"vs\\\")\\n print(expected_error)\\n print(\\\"===\\\" * 10)\\n self.assertEqual(str(e.exception).strip(), expected_error.strip())\",\n \"def test_regexp_chunk_parser():\",\n \"def test_parse_simple_quote_with_newline(self):\\n with self.assertRaisesRegexp(Exception, re.escape(\\\"the quote included a newline (0x0a) character\\\")):\\n api.parse_quote(\\\" Quote with \\\\n character - Author\\\", simple_format=True)\",\n \"def test_temporal_with_invalid_specifier():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot \\\"bigfoot.csv\\\"\\n LINE bigfoot Y temporal BY NOPE X classification COUNT\\n \\\"\\\"\\\"\\n\\n # TODO Make this exception more specific if possible.\\n with pytest.raises(SvlSyntaxError):\\n parse_svl(svl_string)\",\n \"def test_parser_patch_______(parser):\\n pass\",\n \"def test_psi4_qmefpformat_error_6c():\\n\\n subject = subject6.replace(' efp h2O', '0 1\\\\n efp h2O')\\n\\n with pytest.raises(qcelemental.MoleculeFormatError):\\n final, intermed = qcelemental.molparse.from_string(subject, return_processed=True)\",\n \"def test_parse_output_error(self):\\n self.assertRaises(ValueError,\\n parse_output,\\n hgt_results_fp=self.consel_output_hgt_fp,\\n method=\\\"Consel\\\")\",\n \"def test_parseMethodExceptionLogged(self):\\n\\n class UnhandledException(Exception):\\n \\\"\\\"\\\"\\n An unhandled exception.\\n \\\"\\\"\\\"\\n\\n def raisesValueError(line):\\n raise UnhandledException\\n\\n self.server.parseState = \\\"command\\\"\\n self.server.parse_command = raisesValueError\\n\\n self.server.lineReceived(b\\\"invalid\\\")\\n\\n self.assertTrue(self.flushLoggedErrors(UnhandledException))\",\n \"def test_sleep_parse_handling():\\n\\n print(\\\"Testing incorrect parsing:\\\")\\n assert not actions.sleep.SleepAction().parse(\\\"THISHSOULDFAIL\\\", logger)\\n\\n assert actions.sleep.SleepAction().parse(\\\"10.5\\\", logger)\",\n \"def test_syntax_errors(self):\\r\\n bad_math_list = [\\r\\n '11+',\\r\\n '11*',\\r\\n 'f((x)',\\r\\n 'sqrt(x^)',\\r\\n '3f(x)', # Not 3*f(x)\\r\\n '3|4',\\r\\n '3|||4'\\r\\n ]\\r\\n bad_exceptions = {}\\r\\n for math in bad_math_list:\\r\\n try:\\r\\n preview.latex_preview(math)\\r\\n except pyparsing.ParseException:\\r\\n pass # This is what we were expecting. (not excepting :P)\\r\\n except Exception as error: # pragma: no cover\\r\\n bad_exceptions[math] = error\\r\\n else: # pragma: no cover\\r\\n # If there is no exception thrown, this is a problem\\r\\n bad_exceptions[math] = None\\r\\n\\r\\n self.assertEquals({}, bad_exceptions)\",\n \"def test_dataset_sql_with_non_string():\\n svl_string = \\\"\\\"\\\"\\n DATASETS\\n bigfoot \\\"bigfoot.csv\\\"\\n bigfoot_with_location SQL 3\\n PIE bigfoot_with_location AXIS has_location\\n \\\"\\\"\\\"\\n\\n # TODO Make this exception more specific if possible.\\n with pytest.raises(SvlSyntaxError):\\n parse_svl(svl_string)\",\n \"def test_explicit_delimiter_specification(self):\\n transformer = SplitTransformer()\\n transformer.setup(\\\"test\\\", {\\n \\\"dateformat\\\" : \\\"%Y-%m-%d %H:%M:%S\\\",\\n \\\"delimiter\\\" : \\\"\\\\.-\\\\.\\\",\\n \\\"group_order\\\" : \\\"HOST_NAME HOST_ADDRESS PRIORITY FACILITY TIME DATE MESSAGE\\\" \\n })\\n teststring = \\\"test_host.-.42.2.53.52.-.5.-.4.-.11:00:24.-.2012-12-10.-.Testmessage\\\"\\n event = transformer.transform(teststring)\\n assert event != None\\n assert event[\\\"host_name\\\"] == \\\"test_host\\\"\\n assert event[\\\"host_address\\\"] == IPAddress(\\\"42.2.53.52\\\")\\n assert event[\\\"priority\\\"] == \\\"5\\\"\\n assert event[\\\"facility\\\"] == \\\"4\\\"\\n assert event[\\\"message\\\"] == \\\"Testmessage\\\"\",\n \"def testUnparsedImport(self):\\n a = 'a.mojom'\\n b = 'b.mojom'\\n self.WriteFile(a, \\\"\\\"\\\"\\\\\\n module a;\\n struct Bar {};\\\"\\\"\\\")\\n self.WriteFile(\\n b, \\\"\\\"\\\"\\\\\\n module b;\\n import \\\"a.mojom\\\";\\n struct Foo { a.Bar bar; };\\\"\\\"\\\")\\n\\n # a.mojom has not been parsed yet, so its import will fail when processing\\n # b.mojom here.\\n with self.assertRaisesRegexp(ValueError, \\\"does not exist\\\"):\\n self.ParseMojoms([b])\",\n \"def test_title_with_non_string():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot \\\"bigfoot.csv\\\"\\n LINE bigfoot\\n X date BY YEAR\\n TITLE 1\\n Y date COUNT\\n SPLIT BY classification\\n \\\"\\\"\\\"\\n\\n # TODO Make this exception more specific if possible.\\n with pytest.raises(SvlSyntaxError):\\n parse_svl(svl_string)\",\n \"def test_unknown_lower(self):\\n self.assertRaises(ParseException, self.flag.parseString, 'u')\",\n \"def test_select_result_parse(\\n data: str, format: str, parse_outcome: ParseOutcomeType\\n) -> None:\\n logging.debug(\\\"data = %s\\\", data)\\n\\n if inspect.isclass(parse_outcome) and issubclass(parse_outcome, Exception):\\n with pytest.raises(parse_outcome):\\n parsed_result = Result.parse(StringIO(data), format=format)\\n else:\\n parsed_result = Result.parse(StringIO(data), format=format)\\n assert parse_outcome == parsed_result.bindings\",\n \"def test_schema_invalid_format(self):\\n bad_schema = [int, int, float, float, str]\\n with self.assertRaisesRegexp(Exception, \\\"more than one char\\\"):\\n self.context.frame.import_csv(self.dataset, bad_schema)\",\n \"def test_script_rejects_bad_xml(self):\\n maker = Compilers(test_utils.MockMachines(\\\"mymachine\\\", \\\"SomeOS\\\"), version=2.0)\\n with self.assertRaises(ParseError):\\n test_utils.get_macros(maker, \\\"This is not valid XML.\\\", \\\"Makefile\\\")\",\n \"def test_incorrect_formats(self, text):\\n with pytest.raises(ValueError):\\n parse_changelog(text)\",\n \"def test_invalid_expression_type(self, parse_input_mocked_metadata):\\n with pytest.raises(TypeError, match=r\\\"not of declared type int\\\"):\\n parse_input_mocked_metadata(\\\"int Beta = -0.231e-6+5.21e-2j\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71277916","0.6992496","0.6932686","0.69308096","0.67307556","0.6727998","0.6665779","0.65718716","0.6517503","0.63459533","0.6345652","0.62765884","0.6201289","0.6190885","0.61274683","0.6123086","0.6117942","0.61088365","0.6092642","0.6080887","0.604762","0.6047394","0.6027691","0.6007952","0.6006309","0.6006074","0.5989191","0.5977048","0.5952073","0.5920322","0.5920261","0.59131193","0.58734274","0.58596784","0.5839711","0.58350843","0.5808357","0.58009595","0.57904935","0.5789519","0.5781386","0.5761164","0.57536924","0.5749424","0.5748397","0.5746365","0.5729785","0.57142055","0.5706849","0.5703299","0.5690923","0.5678236","0.56688136","0.5644048","0.56133014","0.56034744","0.5602647","0.55925846","0.55898255","0.5589253","0.5581166","0.55518496","0.55466646","0.55387896","0.5527027","0.5520486","0.5518411","0.55172217","0.5500905","0.54965734","0.54917383","0.5490248","0.548547","0.54722154","0.54718506","0.5459576","0.54563177","0.5436663","0.5430929","0.5428737","0.5424667","0.5423937","0.5423211","0.5418658","0.5417588","0.5371806","0.5364058","0.53632337","0.53600377","0.5359667","0.53587747","0.53491294","0.5339676","0.532796","0.53213865","0.5317042","0.53162134","0.53143454","0.5309514","0.53068715"],"string":"[\n \"0.71277916\",\n \"0.6992496\",\n \"0.6932686\",\n \"0.69308096\",\n \"0.67307556\",\n \"0.6727998\",\n \"0.6665779\",\n \"0.65718716\",\n \"0.6517503\",\n \"0.63459533\",\n \"0.6345652\",\n \"0.62765884\",\n \"0.6201289\",\n \"0.6190885\",\n \"0.61274683\",\n \"0.6123086\",\n \"0.6117942\",\n \"0.61088365\",\n \"0.6092642\",\n \"0.6080887\",\n \"0.604762\",\n \"0.6047394\",\n \"0.6027691\",\n \"0.6007952\",\n \"0.6006309\",\n \"0.6006074\",\n \"0.5989191\",\n \"0.5977048\",\n \"0.5952073\",\n \"0.5920322\",\n \"0.5920261\",\n \"0.59131193\",\n \"0.58734274\",\n \"0.58596784\",\n \"0.5839711\",\n \"0.58350843\",\n \"0.5808357\",\n \"0.58009595\",\n \"0.57904935\",\n \"0.5789519\",\n \"0.5781386\",\n \"0.5761164\",\n \"0.57536924\",\n \"0.5749424\",\n \"0.5748397\",\n \"0.5746365\",\n \"0.5729785\",\n \"0.57142055\",\n \"0.5706849\",\n \"0.5703299\",\n \"0.5690923\",\n \"0.5678236\",\n \"0.56688136\",\n \"0.5644048\",\n \"0.56133014\",\n \"0.56034744\",\n \"0.5602647\",\n \"0.55925846\",\n \"0.55898255\",\n \"0.5589253\",\n \"0.5581166\",\n \"0.55518496\",\n \"0.55466646\",\n \"0.55387896\",\n \"0.5527027\",\n \"0.5520486\",\n \"0.5518411\",\n \"0.55172217\",\n \"0.5500905\",\n \"0.54965734\",\n \"0.54917383\",\n \"0.5490248\",\n \"0.548547\",\n \"0.54722154\",\n \"0.54718506\",\n \"0.5459576\",\n \"0.54563177\",\n \"0.5436663\",\n \"0.5430929\",\n \"0.5428737\",\n \"0.5424667\",\n \"0.5423937\",\n \"0.5423211\",\n \"0.5418658\",\n \"0.5417588\",\n \"0.5371806\",\n \"0.5364058\",\n \"0.53632337\",\n \"0.53600377\",\n \"0.5359667\",\n \"0.53587747\",\n \"0.53491294\",\n \"0.5339676\",\n \"0.532796\",\n \"0.53213865\",\n \"0.5317042\",\n \"0.53162134\",\n \"0.53143454\",\n \"0.5309514\",\n \"0.53068715\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75182545"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92890,"cells":{"query":{"kind":"string","value":"This function parses arguments like argv and returns a dictionary with keys action tags"},"document":{"kind":"string","value":"def parse_arguments(args):"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _parse_args(argv):\n result = {}\n for arg in argv:\n k, v = arg.split(\"=\")\n result[k] = v\n return result","def retrieve_args_dict():\n process_args = sys.argv[1:]\n dictionary = dict()\n for process_arg in process_args:\n splitted = process_arg.split(\":\")\n if len(splitted) > 1:\n key = splitted[0]\n value = \"\".join(splitted[1:])\n dictionary[key] = value\n return dictionary","def crude_arg_parser(args=sys.argv):\n args_dict = {}\n key = None\n for e in args[1:]:\n if e[:2] == '--':\n if key:\n args_dict[key] = True # Switch arg\n key = e[2:]\n elif key:\n args_dict[key] = e\n key = None\n\n return args_dict","def parse_arguments(args: list = None) -> Dict[str, str]:\n arg_parser = argparse.ArgumentParser(description=\"Console command to crypt \"\n \"and decrypt texts using \"\n \"classic methods. It also \"\n \"performs crypto attacks \"\n \"against those methods.\\n\",\n epilog=\"Follow cifra development at: \"\n \"<https://github.com/dante-signal31/cifra>\")\n cifra_subparsers = arg_parser.add_subparsers(help=\"Available modes\",\n dest=\"mode\",\n required=True)\n # DICTIONARY MANAGEMENT.\n dictionary_parser = cifra_subparsers.add_parser(name=\"dictionary\",\n help=\"Manage dictionaries to \"\n \"perform crypto attacks.\")\n dictionary_actions_subparser = dictionary_parser.add_subparsers(help=\"Action to perform.\",\n dest=\"action\")\n # DICTIONARY CREATION.\n dictionary_create_parser = dictionary_actions_subparser.add_parser(name=\"create\",\n help=\"Create a dictionary of unique words.\")\n dictionary_create_parser.add_argument(\"dictionary_name\",\n type=str,\n help=\"Name for the dictionary to create.\",\n metavar=\"NEW_DICTIONARY_NAME\")\n dictionary_create_parser.add_argument(\"-i\", \"--initial_words_file\",\n type=_check_is_file,\n help=\"Optionally you can load in the dictionary words located in a text file\",\n metavar=\"PATH_TO FILE_WITH_WORDS\")\n # DICTIONARY REMOVAL.\n dictionary_delete_parser = dictionary_actions_subparser.add_parser(name=\"delete\",\n help=\"Remove an existing dictionary.\")\n dictionary_delete_parser.add_argument(\"dictionary_name\",\n type=str,\n help=\"Name for the dictionary to delete.\",\n metavar=\"DICTIONARY_NAME_TO_DELETE\")\n # DICTIONARY UPDATING.\n dictionary_update_parser = dictionary_actions_subparser.add_parser(name=\"update\",\n help=\"Add words to an existing dictionary.\")\n dictionary_update_parser.add_argument(\"dictionary_name\",\n type=str,\n help=\"Name for the dictionary to update with additional words.\",\n metavar=\"DICTIONARY_NAME_TO_UPDATE\")\n dictionary_update_parser.add_argument(\"words_file\",\n type=_check_is_file,\n help=\"Pathname to a file with words to add to dictionary\",\n metavar=\"PATH_TO_FILE_WITH_WORDS\")\n # DICTIONARY LISTING.\n _ = dictionary_actions_subparser.add_parser(name=\"list\",\n help=\"Show existing dictionaries.\")\n # CIPHER MANAGEMENT.\n cipher_parser = cifra_subparsers.add_parser(name=\"cipher\",\n help=\"Cipher a text using a key.\")\n cipher_parser.add_argument(\"algorithm\",\n choices=CIPHERING_ALGORITHMS,\n type=str,\n help=\"Algorithm to use to cipher.\",\n metavar=\"ALGORITHM_NAME\")\n cipher_parser.add_argument(\"key\",\n type=str,\n help=\"Key to use to cipher.\",\n metavar=\"CIPHERING_KEY\")\n cipher_parser.add_argument(\"file_to_cipher\",\n type=_check_is_file,\n help=\"Path to file with text to cipher.\",\n metavar=\"FILE_TO_CIPHER\")\n cipher_parser.add_argument(\"-o\", \"--ciphered_file\",\n type=str,\n help=\"Path to output file to place ciphered text. If not used then\"\n \"ciphered text will be dumped to console.\",\n metavar=\"OUTPUT_CIPHERED_FILE\")\n cipher_parser.add_argument(\"-c\", \"--charset\",\n type=str,\n help=f\"Default charset is: {cifra.cipher.common.DEFAULT_CHARSET}, but you can set here \"\n f\"another.\",\n metavar=\"CHARSET\")\n # DECIPHERING MANAGEMENT\n decipher_parser = cifra_subparsers.add_parser(name=\"decipher\",\n help=\"Decipher a text using a key.\")\n decipher_parser.add_argument(\"algorithm\",\n choices=CIPHERING_ALGORITHMS,\n type=str,\n help=\"Algorithm to use to decipher.\",\n metavar=\"ALGORITHM_NAME\")\n decipher_parser.add_argument(\"key\",\n type=str,\n help=\"Key to use to decipher.\",\n metavar=\"CIPHERING_KEY\")\n decipher_parser.add_argument(\"file_to_decipher\",\n type=_check_is_file,\n help=\"Path to file with text to decipher.\",\n metavar=\"FILE_TO_DECIPHER\")\n decipher_parser.add_argument(\"-o\", \"--deciphered_file\",\n type=str,\n help=\"Path to output file to place deciphered text. If not used then\"\n \"deciphered text will be dumped to console.\",\n metavar=\"OUTPUT_DECIPHERED_FILE\")\n decipher_parser.add_argument(\"-c\", \"--charset\",\n type=str,\n help=f\"Default charset is: {cifra.cipher.common.DEFAULT_CHARSET}, but you can set here \"\n f\"another.\",\n metavar=\"CHARSET\")\n # ATTACK MANAGEMENT\n attack_parser = cifra_subparsers.add_parser(name=\"attack\",\n help=\"Attack a ciphered text to get its plain text\")\n attack_parser.add_argument(\"algorithm\",\n choices=CIPHERING_ALGORITHMS,\n type=str,\n help=\"Algorithm to attack.\",\n metavar=\"ALGORITHM_NAME\")\n attack_parser.add_argument(\"file_to_attack\",\n type=_check_is_file,\n help=\"Path to file with text to attack.\",\n metavar=\"FILE_TO_ATTACK\")\n attack_parser.add_argument(\"-o\", \"--deciphered_file\",\n type=str,\n help=\"Path to output file to place deciphered text. If not used then\"\n \"deciphered text will be dumped to console.\",\n metavar=\"OUTPUT_DECIPHERED_FILE\")\n attack_parser.add_argument(\"-c\", \"--charset\",\n type=str,\n help=f\"Default charset is: {cifra.cipher.common.DEFAULT_CHARSET}, but you can set here \"\n f\"another.\",\n metavar=\"CHARSET\")\n\n parsed_arguments = vars(arg_parser.parse_args(args))\n filtered_parser_arguments = {key: value for key, value in parsed_arguments.items()\n if value is not None}\n return filtered_parser_arguments","def parseArgs():\n\n def getInput(name: str, *, required=False):\n val = os.environ.get(f'INPUT_{name.replace(\" \", \"_\").upper()}', \"\")\n if not val and required:\n raise ValueError(f\"Missing required parameter: {name}\")\n return val\n\n certificate = getInput(\"certificate\", required=True)\n private_key = getInput(\"private_key\", required=True)\n connectorId = getInput(\"connector_id\", required=True)\n host = getInput(\"host\", required=True)\n body = yaml.load(getInput(\"args\", required=True), yaml.Loader)\n\n with string_to_tempfile(certificate) as cert_file, string_to_tempfile(\n private_key\n ) as key_file:\n yield ActionArgs(\n host=host,\n auth=AuthCert(cert=Path(cert_file.name), private_key=Path(key_file.name)),\n args=AddOrUpdateIncident2Args(**body, connectorId=connectorId),\n )","def parse(argv):\n\n if not argv:\n return None, None\n parser = parsersetup()\n opts, args = parser.parse_args(argv)\n try:\n opts.action = args.pop()\n except IndexError:\n # No action specified\n pass\n\n return opts, args","def parse_args(argv: t.Iterable[str] = None):\n if argv is None:\n argv = sys.argv[1:]\n\n args: t.List[str] = []\n kwargs: t.MutableMapping[str, t.Any] = {}\n\n key = None\n for arg in argv:\n if arg.startswith('--'):\n if arg == '--help':\n print(USAGE)\n raise SystemExit\n if key is not None:\n kwargs[key] = True\n key = arg[2:]\n continue\n\n match = re.match('^(\\\\w+)=(.*)$', arg)\n if match:\n if key is not None:\n kwargs[key] = True\n key = None\n kwargs[match.group(1)] = match.group(2)\n continue\n\n if key is not None:\n kwargs[key] = arg\n key = None\n continue\n\n args.append(arg)\n\n if key is not None:\n kwargs[key] = True\n\n return (tuple(args), kwargs)","def get_input_args():\n parser = argparse.ArgumentParser()\n\n parser.add_argument('--json_path', type=str, default='cat_to_name.json', \n help='Json path of labels to categories')\n parser.add_argument('--use_gpu', type=bool, default=False, \n help='Run with GPU')\n parser.add_argument('--topk', type=int, default=5, \n help='Top N classes that needed to be displayed')\n parser.add_argument('--image_path', type=str, default='C:/Users/TsalikiK/Downloads/Kantar/Kantar_Python_Work/Notebooks/aipnd-project/test/1/image_06743.jpg', \n help='Image which you want to predict')\n\n # returns parsed argument collection\n return parser.parse_args()","def parse_args_dict(args=None):\n return vars(parse_args(args))","def main_parse_args():\n parser = ArgumentParser()\n parser.add_argument('infile', help='path to the file to be mapped.It should\\\n contain one identifer on each line.')\n parser.add_argument('-rh', '--redis_host', default=DEFAULT_REDIS_URL,\n help='url of Redis db')\n parser.add_argument('-rp', '--redis_port', default=DEFAULT_REDIS_PORT,\n help='port for Redis db')\n parser.add_argument('-rps', '--redis_pass', default=DEFAULT_REDIS_PASS,\n help='password for Redis db')\n parser.add_argument('-of', '--outfile', default=None,\n help='path to the output file')\n parser.add_argument('-sh', '--source_hint', help='suggestion for ID source \\\n database used to resolve ambiguities in mapping',\n default=DEFAULT_HINT)\n parser.add_argument('-t', '--taxon', help='taxon id of species of all gene \\\n names', default=DEFAULT_TAXON)\n myargs = parser.parse_args()\n return myargs","def _parse_args(self, args : dict):\n result = {}\n for key, value in args.items():\n if key in self._subparsers:\n # if it's a list, it is because it's a preset\n if isinstance(value, list):\n result[key] = value[0]\n else:\n result[key] = self._subparsers[key]._parse_args(value)\n elif key in self._actions:\n result[key] = self._actions[key](value)\n else:\n raise ValueError(f\"Unknown argument {key}\")\n\n return result","def read_args():\r\n global args\r\n parser = argparse.ArgumentParser(\r\n description='Executes create, list-nodes, list-all, execute, backup, list-backups and rollback tasks on AWS '\r\n 'system')\r\n\r\n # What the code will do? The actions...\r\n parser.add_argument('action', help='Type of work', choices=[\"create\", \"list-nodes\", \"list-all\", \"execute\", \"backup\",\r\n \"list-backups\", \"roll-back\", \"terminate-all\"])\r\n parser.add_argument('--customer-id', help='Shows customer ID', required=False)\r\n parser.add_argument('--node-type', help='Shows node type, values can be \"Manager\" or \"Peer\"',\r\n choices=[\"Manager\", \"Peer\"], required=False)\r\n parser.add_argument('--script', help='Shows the script that will be executed on Aws instance', required=False)\r\n parser.add_argument('--node-id', help='Shows node (Instance) ID on AWS', required=False)\r\n parser.add_argument('--backup-id', help='Shows snapshot ID on AWS', required=False)\r\n\r\n args = parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=\"Bandits algorithms on a click-through \"\n \"rate dataset.\")\n parser.add_argument('--plot', action='store_true')\n return parser.parse_args()","def parse_args():\n\n parser = argparse.ArgumentParser()\n\n subparsers = parser.add_subparsers(dest='operation',\n help='Run AtPKI {command} -h for additional help')\n\n parse_bin_parser = subparsers.add_parser(\"parse_bin\",\n help=\"parse generated PKI bin\")\n parse_bin_parser.add_argument(\"--bin_file\", \"-b\", default=\"PKI.bin\",\n help=\"bin_file which need to be parsed\")\n parse_bin_parser.add_argument(\"--output_path\", \"-o\",\n help=\"output path of parsed bin file in from_bytes mode\")\n\n generate_bin_parser = subparsers.add_parser(\"generate_bin\",\n help=\"create PKI bin\")\n generate_bin_parser.add_argument(\"--bin_file\", \"-b\", default=\"PKI.bin\",\n help=\"bin_file which need to be parsed\")\n generate_bin_parser.add_argument('pki_list', metavar='<type> <file>',\n help='type (ca, cert, key,)'\n ' and file, separated by space',\n action=PKIPairAction)\n\n args = parser.parse_args()\n return args","def get_args():\n parser = argparse.ArgumentParser(\n description = \"Make consensus taxonomy out of a usearch tophits map\")\n # Add arguments\n parser.add_argument(\"input\",\n help = \"input file in usearch's UC format.\")\n parser.add_argument(\"-t\",\n \"--tax_separator\",\n help = \"character separating taxonomic levels.\",\n required = True)\n parser.add_argument(\"-s\",\n \"--tax_sense\",\n choices = ['asc', 'desc'],\n help = \"sense of taxonomic levels in your database. 'asc' for lower to higher levels (e.g. ID_Diatomea_Stramenopiles_SAR_Eukaryota), 'desc' for higher to lower levels (e.g. Eukaryota_SAR_Stramenopiles_Diatomea_ID).\",\n required = True)\n parser.add_argument(\"-p\",\n \"--pair_separator\",\n help = \"pair (forward & reverse) character separator. Use this argument to remove redundancies from your dataset (i.e. reads that are represented for both forward and reverse pairs).\",\n required = False,\n default = None)\n parser.add_argument(\"-o\",\n \"--output_file\",\n help = \"path to output file where filtered map should be written. It defaults to `filtered_map.uc`\",\n required = False,\n default = 'filtered_map.uc')\n # Array for all arguments passed to script\n args = parser.parse_args()\n # Assign args to variables\n input = args.input\n tax_separator = args.tax_separator\n tax_sense = args.tax_sense\n pair_separator = args.pair_separator\n outfile = args.output_file\n # Return all variable values\n return input, tax_separator, tax_sense, pair_separator, outfile","def parseCommandLine(argv):\n parameters = {}\n for p in argv[1:]: # skip 0th element (module name)\n pair = split(p, '=', 1)\n if (2 != len(pair)):\n print 'bad parameter: %s (had no equals sign for pairing)' % p\n sys.exit()\n else:\n parameters[pair[0]] = pair[1]\n return parameters","def get_action_args(self, request_environment):\n args = {}\n if request_environment['PATH_INFO'] == '/':\n args['action'] = 'index'\n else:\n args['action'] = 'multi'\n\n return args","def parse_args(args):\n retv = dict()\n\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\n '--version',\n action='version',\n version='$scriptname {ver}'.format(ver=__version__))\n\n parser.add_argument(\n '-w',\n '--write',\n action='store_true',\n help=\"write the file\")\n\n parser.add_argument(\n '-d',\n '--description',\n help=\"description of the script\")\n\n parser.add_argument(\n '-t',\n '--templates',\n dest='tdirs',\n action='append',\n help=\"location of the templates\")\n\n parser.add_argument('scriptpath', nargs='*')\n\n opts = vars(parser.parse_args(args))\n\n for keyn, keyv in opts.items():\n if keyv is not None:\n retv[keyn] = keyv\n\n retv['scriptpath'] = \" \".join(retv['scriptpath'])\n retv['scriptname'] = os.path.basename(retv['scriptpath'])\n if 'write' not in retv:\n retv['write'] = False\n\n return retv","def get_input_args():\r\n parser = argparse.ArgumentParser()\r\n parser.add_argument(\"image_path\", help= \"Path to image\", type=str)\r\n parser.add_argument(\"checkpoint\", help= \"path to checkpoint\", default=\"checkpoint.pth\", type=str)\r\n parser.add_argument(\"--top_k\", help= \"top k classes of image\", default=5, type=int)\r\n parser.add_argument('--category_names', type=str, default='cat_to_name.json')\r\n parser.add_argument('--gpu', dest='gpu', action='store_true', default = False)\r\n \r\n return parser.parse_args()","def parse_args(self, argv=None):\n return vars(self.parser.parse_args(argv))","def parse_args(args=None):\n return AP.parse_args(args=args)","def analyze_args(self, args):\n args_obj = args.__dict__\n if args_obj.get('add'):\n action = 'bc'\n params = args_obj['add']\n\n elif args_obj.get('prime'):\n action = 'prime'\n params = args_obj['prime']\n else:\n print \"Invalid Arguments...\"\n sys.exit(0)\n\n params_check = self.validate_params(params)\n if params_check is True:\n parsed_args = dict(action=action,\n params=map(int, params))\n return parsed_args","def parse_args():\r\n parser = argparse.ArgumentParser(description=\"Available Options\")\r\n\r\n parser.add_argument('-i'\r\n ,'--input_path'\r\n ,dest='input_path'\r\n ,type=is_valid_path\r\n ,required=True\r\n ,help = \"Enter the path of the image file to process\")\r\n\r\n args = vars(parser.parse_args())\r\n\r\n #To Display The Command Line Arguments\r\n print(\"## Command Arguments #################################################\")\r\n print(\"\\n\".join(\"{}:{}\".format(i,j) for i,j in args.items()))\r\n print(\"######################################################################\")\r\n\r\n return args","def map_arguments():\n arguments = {\n '-c': 'ogg',\n '-d': 'no',\n '-q': '4'\n }\n args = sys.argv[:]\n args.pop(0)\n while len(args) > 1:\n if args[0] == '-c' and re.search('^mp3$|^ogg$', args[1]) or \\\n args[0] == '-d' and re.search('^y(es)?$', args[1]) or \\\n args[0] == '-q' and re.search('^[0-9]$', args[1]):\n arguments[args[0]] = args[1]\n args.pop(0)\n args.pop(0)\n else:\n print_help()\n if len(args) == 1:\n print_help()\n return arguments","def parse_args(args):\n if len(args) == 1:\n return {}","def parse_arguments(self,parser):\r\n return parser.parse_args()","def parse_args():\n import argparse\n\n parser = argparse.ArgumentParser(description=\"Pilot kodi\")\n parser.add_argument(\"--server\",\"-s\",metavar=\"SERVER\",required=True,help=\"Server to connect to\")\n parser.add_argument(\"--port\",\"-p\",metavar=\"PORT\",default=8080,type=int,help=\"Port of the server\")\n parser.add_argument(\"--get-audio\",action=\"store_true\",help=\"Get audio\")\n parser.add_argument(\"--switch-audio\",action=\"store_true\",help=\"Switch Audio\")\n parser.add_argument(\"--valid-audios\",metavar=\"SUBTITLE\",default=[\"fre\",\"eng\"],type=lambda p:p.split(\",\"),help=\"Valid audios\")\n parser.add_argument(\"--get-subtitle\",action=\"store_true\",help=\"Get subtitle\")\n parser.add_argument(\"--toggle-subtitle\",action=\"store_true\",help=\"Toggle subtitles\")\n parser.add_argument(\"--switch-subtitles\",action=\"store_true\",help=\"Switch subtitles\")\n parser.add_argument(\"--valid-subtitles\",metavar=\"SUBTITLE\",default=[\"fre\"],type=lambda p:p.split(\",\"),help=\"Valid subtitles\")\n\n return parser.parse_args()","def parse_known_args(argv):\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--input',\n dest='input',\n required=True,\n help='Path to the text file containing image names.')\n parser.add_argument(\n '--output',\n dest='output',\n required=True,\n help='Path where to save output predictions.'\n ' text file.')\n parser.add_argument(\n '--model_state_dict_path',\n dest='model_state_dict_path',\n required=True,\n help=\"Path to the model's state_dict. \"\n \"Default state_dict would be maskrcnn_resnet50_fpn.\")\n parser.add_argument(\n '--images_dir',\n help='Path to the directory where images are stored.'\n 'Not required if image names in the input file have absolute path.')\n return parser.parse_known_args(argv)","def parse_cmd_arguments():\n parser = argparse.ArgumentParser(description='Process some integers.')\n parser.add_argument('-i', '--input', required=True, help='input JSON file')\n parser.add_argument('-o', '--output', required=True,\n help='ouput JSON file')\n parser.add_argument('-d', '--debug', required=False,\n help='log level. Can be 0-3. Defaults to 0')\n\n return parser.parse_args()","def parse_generate_arguments(arguments):\n return_value = {}\n for key in arguments:\n return_value[key] = CONFIG_KEY_PARSER[key](arguments[key])\n\n return return_value","def parse_args():\n parser = argparse.ArgumentParser(description=\"\"\"\n Generates json files with all the combinations of\n hyperparameter values from a configuratio file.\n \"\"\")\n\n parser.add_argument('outdir', help='output directory')\n parser.add_argument('config', help='configuration file')\n\n return parser.parse_args()","def parse_args():\n\n parser = argparse.ArgumentParser(description='Disk metric sender')\n parser.add_argument('-v', '--verbose', action='store_true', default=None, help='Verbose?')\n parser.add_argument('--debug', action='store_true', default=None, help='Debug?')\n\n return parser.parse_args()","def parse_args(self, argv):\n\t\tself.argv={'user': argv[1]}","def parse_args(argv: Sequence[str]) -> argparse.Namespace:\n parser = argparse.ArgumentParser(\n prog='flagman',\n description='Perform arbitrary actions on signals.',\n epilog=EPILOG_TEXT,\n formatter_class=argparse.RawTextHelpFormatter,\n )\n parser.add_argument(\n '--list', '-l', action='store_true', help='list known actions and exit'\n )\n for signum in HANDLED_SIGNALS:\n name = signum.name\n parser.add_argument(\n '--{}'.format(name[3:].lower()),\n action='append',\n nargs='+',\n default=[],\n help='add an action for {}'.format(name),\n metavar=('ACTION', 'ARGUMENT'),\n )\n parser.add_argument(\n '--successful-empty',\n action='store_false',\n help='if all actions are removed, exit with 0 instead of the default 1',\n )\n parser.add_argument(\n '--no-systemd', action='store_false', help='do not notify systemd about status'\n )\n parser.add_argument(\n '--quiet',\n '-q',\n action='store_true',\n help='only output critial messages; overrides `--verbose`',\n )\n parser.add_argument(\n '--verbose',\n '-v',\n action='count',\n default=0,\n help='increase the loglevel; pass multiple times for more verbosity',\n )\n\n return parser.parse_args(argv[1:])","def parseArguments():\n parser = argparse.ArgumentParser(description=\"AutoMacTC: an Automated macOS forensic triage collection framework.\", add_help=False)\n\n module_filter = parser.add_argument_group('module filter')\n mods = module_filter.add_mutually_exclusive_group(required=False)\n mods.add_argument('-m', '--include_modules', type=str, nargs='+', help='module(s) to use, use \"all\" to run all modules, space separated list only', default=[''], required=False)\n mods.add_argument('-x', '--exclude_modules', type=str, nargs='+', help='assumes you want to run all modules EXCEPT those specified here, space separated list only', default=[''], required=False)\n mods.add_argument('-l', '--list_modules', help='if flag is provided, will list available modules and exit.', default=False, action='store_true', required=False)\n\n general = parser.add_argument_group('general arguments')\n general.add_argument(\"-h\", \"--help\", action=\"help\", help=\"show this help message and exit\")\n general.add_argument(\"-v\", \"--verbose\", default=False, action='store_true', help=\"enable verbose logging\")\n general.add_argument('-i', '--inputdir', default='/', help='input directory; mount dmg with mountdmg.sh script and use -f to analyze mounted HFS or APFS Volume, use volume appended with \"Data\" (e.g. \"Macintosh HD - Data\") for 10.15+ systems', required=False)\n general.add_argument('-is', '--inputsysdir', default='', help='input system drive if using mounted drive from 10.15+ system (e.g. \"Macintosh HD\")', required=False)\n general.add_argument('-o', '--outputdir', default='./', help='output directory', required=False)\n general.add_argument('-p', '--prefix', help='prefix to append to tarball and/or output files', default='automactc-output', required=False)\n general.add_argument('-f', '--forensic_mode', help='if flag is provided, will analyze mounted volume provided as inputdir', default=False, action='store_true', required=False)\n general.add_argument('-nt', '--no_tarball', help='if flag is provided, will NOT package output files into tarball', default=False, action='store_true', required=False)\n general.add_argument('-nl', '--no_logfile', help='if flag is provided, will NOT generate logfile on disk', default=False, action='store_true', required=False)\n general.add_argument('-fmt', '--output_format', help='toggle between csv and json output, defaults to csv', default='csv', action='store', required=False, choices=['csv', 'json'])\n general.add_argument('-np', '--no_low_priority', help='if flag is provided, will NOT run automactc with highest niceness (lowest CPU priority). high niceness is default', default=False, action='store_true', required=False)\n general.add_argument('-b', '--multiprocessing', help='if flag is provided, WILL multiprocess modules [WARNING: Experimental!]', default=False, action='store_true', required=False)\n general.add_argument('-O', '--override_mount', help='if flag is provided, WILL bypass error where inputdir does not contain expected subdirs', default=False, action='store_true', required=False)\n\n console_log_args = parser.add_argument_group('console logging verbosity')\n console_logging_args = console_log_args.add_mutually_exclusive_group(required=False)\n console_logging_args.add_argument('-q', '--quiet', help='if flag is provided, will NOT output to console at all', default=False, action='store_true', required=False)\n console_logging_args.add_argument('-r', '--rtr', help='reduce verbosity to display nicely on RTR console', default=False, action='store_true', required=False)\n console_logging_args.add_argument('-d', '--debug', help='enable debug logging to console', default=False, action='store_true', required=False)\n\n dirlist_args = parser.add_argument_group('specific module arguments')\n dirlist_args.add_argument('-K', '--dir_include_dirs', type=str, nargs='+', help='directory inclusion filter for dirlist module, defaults to volume root, space separated list only', default=[''], required=False)\n dirlist_args.add_argument('-E', '--dir_exclude_dirs', type=str, nargs='+', help='directory and file exclusion filter for dirlist module. defaults are specified in README. space separated list only. \\\n put \\'no-defaults\\' as first item to overwrite default exclusions and then provide your own exclusions', default=[''], required=False)\n dirlist_args.add_argument('-H', '--dir_hash_alg', nargs='+', help='either sha256 or md5 or both or none, at least one is recommended, defaults to sha256. also applies to autoruns module', default='sha256', required=False)\n dirlist_args.add_argument('-S', '--dir_hash_size_limit', type=int, help='file size filter for which files to hash, in megabytes, defaults to 10MB. also applies to autoruns module', default=10, required=False)\n dirlist_args.add_argument('-R', '--dir_recurse_bundles', help='will fully recurse app bundles if flag is provided. this takes much more time and space', default=False, action='store_true', required=False)\n dirlist_args.add_argument('-NC', '--dir_no_code_signatures', help='if flag is provided, will NOT check code signatures for app and kext files. also applies to autoruns module', default=False, action='store_true', required=False)\n dirlist_args.add_argument('-NM', '--dir_no_multithreading', help='if flag is provided, will NOT multithread the dirlist module', default=False, action='store_true', required=False)\n args = parser.parse_args()\n\n return args","def parse_args():\n parser = argparse.ArgumentParser(\n description='Convert CVAT XML annotations to YOLO format'\n )\n\n parser.add_argument(\n '--cvat-xml', metavar='FILE', required=True,\n help='input file with CVAT annotation in xml format'\n )\n\n parser.add_argument(\n '--image-dir', metavar='DIRECTORY', required=False,\n help='directory which contains original images'\n )\n\n parser.add_argument(\n '--output-dir', metavar='DIRECTORY', required=True,\n help='directory for output annotations in YOLO format'\n )\n\n parser.add_argument(\n '--username', metavar='USERNAME', required=False,\n help='Username from CVAT Login page, required to download images'\n )\n\n parser.add_argument(\n '--password', metavar='PASSWORD', required=False,\n help='Password from CVAT Login page, required to download images'\n )\n\n parser.add_argument(\n '--labels', metavar='ILABELS', required=False,\n help='Labels (separated by comma) to extract. Example: car,truck,motorcycle'\n )\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n fromfile_prefix_chars='@',\n description='Convert CVAT XML annotations to masks'\n )\n\n parser.add_argument(\n '--cvat-xml', metavar='FILE', required=True,\n help='input file with CVAT annotation in xml format'\n )\n\n parser.add_argument(\n '--background-color', metavar='COLOR_BGR', default=\"0,0,0\",\n help='specify background color (by default: 0,0,0)'\n )\n\n parser.add_argument(\n '--label-color', metavar='LABEL:COLOR_BGR', action='append',\n default=[],\n help=\"specify a label's color (e.g. 255 or 255,0,0). The color will \" +\n \"be interpreted in accordance with the mask format.\"\n )\n\n parser.add_argument(\n '--mask-bitness', type=int, choices=[8, 24], default=8,\n help='choose bitness for masks'\n )\n\n parser.add_argument(\n '--output-dir', metavar='DIRECTORY', required=True,\n help='directory for output masks'\n )\n\n return parser.parse_args()","def Args(parser):","def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument('-u', '--urls_dirpath', type=unicode)\n parser.add_argument('-r', '--resources_dir', type=unicode)\n parser.add_argument('-t', '--total_docs', type=int)\n parser.add_argument('-m', '--mapping', type=unicode,\n help='File with the yago to lkif mapping')\n\n return parser.parse_args()","def parse_args():\n parser = default_argument_parser()\n parser.add_argument(\"--label-map\",\n dest=\"label_map\",\n type=pathlib.Path,\n help=\"Label map in YAML format which maps from category \"\n \"ID to name.\")\n parser.add_argument(\"--train-csv\",\n dest=\"train_csv\",\n required=True,\n type=pathlib.Path,\n help=\"Path to training data CSV file.\")\n parser.add_argument(\"--valid-csv\",\n dest=\"valid_csv\",\n required=False,\n type=pathlib.Path,\n help=\"Optional path to validation data CSV file.\")\n parser.add_argument(\n \"--image-width\",\n type=int,\n help=\"Image width (optional, used to speed up dataset processing).\")\n parser.add_argument(\n \"--image-height\",\n type=int,\n help=\"Image height (optional, used to speed up dataset processing).\")\n return parser.parse_args()","def parse_arguments():\n parser = ArgumentParser()\n\n # For development/testing\n parser.add_argument(\"--dev\", help=\"run the code of the developers tag\")\n\n return parser.parse_args()","def parse_args():\n from argparse import ArgumentParser\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\n ap.add_argument('session', help='Session Label')\n ap.add_argument('-sd', '--subjects_dir', help='Subjects Dir',\n default='/tmp')\n return ap.parse_args()","def parse_args():\n help_text = \"\"\"\n Analyzer of the frequency of use of nouns in the headings of posts on hubr.com\n \"\"\"\n parser = argparse.ArgumentParser(\n description=help_text\n )\n parser.add_argument(\n '-p',\n '--pages',\n type=int,\n dest='page_count',\n default=PAGE_COUNT,\n help=f'Number of pages to parse, default is {PAGE_COUNT}.'\n )\n parser.add_argument(\n '-s',\n '--start',\n type=int,\n default=PAGE_START,\n dest='start_page',\n help=f'Start page number, default is {PAGE_START}.',\n )\n parser.add_argument(\n '-t',\n '--top',\n type=int,\n default=TOP_SIZE,\n dest='top_size',\n help=f'The size of the top noun, default is {TOP_SIZE}.',\n )\n\n return parser.parse_args()","def parse_args():\n\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", \"--input_path\", required=True)\n parser.add_argument(\"-c\", \"--config\", required=True)\n return parser.parse_args()","def parse_args(args):\n parser = argparse.ArgumentParser(\n description=\"Lookup table generator for Image Comparison\")\n parser.add_argument(\n \"--version\",\n action=\"version\",\n version=\"lookuptable {ver}\".format(ver=__version__))\n parser.add_argument(\n \"-f\",\n \"--folder\",\n dest=\"imagefolder\",\n help=\"path to image folder\",\n type=str,\n metavar=\"STRING\")\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n dest=\"loglevel\",\n help=\"set loglevel to INFO\",\n action=\"store_const\",\n const=logging.INFO)\n parser.add_argument(\n \"-vv\",\n \"--very-verbose\",\n dest=\"loglevel\",\n help=\"set loglevel to DEBUG\",\n action=\"store_const\",\n const=logging.DEBUG)\n return parser.parse_args(args)","def parse_args():\n from argparse import ArgumentParser\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\n ap.add_argument(\n '--host', dest='host', default=None,\n help='Host for XNAT. Default: env XNAT_HOST.')\n ap.add_argument(\n '-u', '--username', dest='username', default=None,\n help='Username for XNAT.')\n ap.add_argument('project', help='Project Label')\n ap.add_argument('session', help='Session Label')\n ap.add_argument(\n 'proc_suffix', help='Proc name suffix', nargs='?', default='')\n ap.add_argument(\n '-sd', '--subjects_dir', dest='subjects_dir',\n help='Subjects Directory',\n default=os.environ.get('SUBJECTS_DIR', '/tmp'))\n return ap.parse_args()","def parsed_args():\n parser = ArgumentParser()\n parser.add_argument(\n \"--input_csv\",\n default=\"bios.csv\",\n type=str,\n help=\"CSV containing the info from the form\",\n )\n parser.add_argument(\n \"--output_yml\",\n default=\"bios.yml\",\n type=str,\n help=\"Output YAML file\",\n )\n parser.add_argument(\n \"--output_photos\",\n default=\"./assets/img/team/team-photos\",\n type=str,\n help=\"List of photos URL\",\n )\n\n return parser.parse_args()","def parse(argv: Sequence[str],\n generator_factory: pagegenerators.GeneratorFactory\n ) -> ARGS_TYPE:\n args = dict(DEFAULT_ARGS)\n argv = pywikibot.handle_args(argv)\n argv = generator_factory.handle_args(argv)\n\n for arg in argv:\n option, _, value = arg.partition(':')\n\n if not value and option in ARG_PROMPT:\n value = pywikibot.input(ARG_PROMPT[option])\n\n if option in ('-text', '-textfile', '-summary'):\n args[option[1:]] = value\n elif option in ('-up', '-always', '-create', '-createonly'):\n args[option[1:]] = True\n elif option in ('-talk', '-talkpage'):\n args['talk_page'] = True\n elif option == '-noreorder':\n args['reorder'] = False\n elif option == '-excepturl':\n args['regex_skip_url'] = value\n elif option == '-major':\n args['minor'] = False\n else:\n raise ValueError(f\"Argument '{option}' is unrecognized\")\n\n if not args['text'] and not args['textfile']:\n raise ValueError(\"Either the '-text' or '-textfile' is required\")\n\n if args['text'] and args['textfile']:\n raise ValueError(\"'-text' and '-textfile' cannot both be used\")\n\n return args","def _parse_arg_list(self):\n\t\targ_list = {}\n\t\tfor arg in getopt.getopt(sys.argv[1:], 'c:r:j:d')[0]:\n\t\t\targ_list[arg[0][1:]] = arg[1]\n\t\n\t\treturn arg_list","def parse_cmdline(argv):\n\n parser = argparse.ArgumentParser(description='Print information about probable hung attempts')\n parser.add_argument('--des_services', action='store', help='')\n parser.add_argument('--section', action='store',\n help='Must be specified if not set in environment')\n parser.add_argument('--days', action='store', default=7, help='finished in last X days')\n parser.add_argument('--file', action='store')\n\n args = vars(parser.parse_args(argv)) # convert to dict\n\n return args","def get_args():\n parser = argparse.ArgumentParser(description='A json parser with filters')\n parser.add_argument('-f', '--filename', help='The Json file to parse')\n parser.add_argument('-v', '--verbosity', action='count', default=0,\n help='Increase verbosity of console log')\n parser.add_argument('-o', '--outfile', type=str, help='File to output to')\n parser.add_argument('-i', '--indent', type=int, default=4,\n help='Number of spaces to indent')\n parser.add_argument('-k', '--keyfilter',\n help=('Key filter for the json output separated by \".\"'\n 'page.module.element.note, use partial string'\n ' or * for all'))\n parser.add_argument('-d', '--datafilter', type=str,\n help=('Data Value filter of the key:value pair. '\n 'NOTE: keyfiltering occurs first.'))\n args = parser.parse_args()\n return args","def _parse_args():\n parser = argparse.ArgumentParser(description='Run DAFI.')\n parser.add_argument('input_file', help='Name (path) of input file')\n return parser.parse_args()","def parse_args():\n sentinel_dict = {}\n\n def _preprocess_sysargv(argv):\n inputs = []\n for arg in argv[1:]:\n # handles case where values contain --, otherwise they will\n # be interpreted as arguments.\n if '--,' in arg or ',--' in arg or arg == '--':\n sentinel = uuid4().hex\n key = '%s' % sentinel\n sentinel_dict[key] = arg\n inputs.append(sentinel)\n else:\n inputs.append(arg)\n return inputs\n\n def _postprocess_sysargv(v):\n if v in sentinel_dict:\n return sentinel_dict.get(v)\n else:\n return v\n\n #----- read input arguments\n for i, arg in enumerate(sys.argv):\n if (arg[0] == '-') and arg[1].isdigit(): sys.argv[i] = ' ' + arg\n parser = argparse.ArgumentParser()\n\n parser.add_argument('-u', action='store_true', dest='helpmenu',help='extended HELP MENU with examples')\n parser.add_argument('-i','--infile',action='store', dest='infile',help='name of file with SAC or mseed file(s)')\n parser.add_argument('-g','--gain',action='store', dest='sensitivity',help='Stage 0 sensitivity')\n parser.add_argument('-N','--net', action='store', dest='network',help='network')\n parser.add_argument('-S','--sta', action='store', dest='station',help='station')\n parser.add_argument('-C','--cha', action='store', dest='chantype',help='chantype')\n parser.add_argument('-s','--start', action='store', dest='startstring',help='start time YYYY-MM-DDTHH:MM:SS')\n parser.add_argument('-e','--end', action='store', dest='endstring',help='end time YYYY-MM-DDTHH:MM:SS')\n parser.add_argument('-d','--duration', action='store', dest='durationinhours',help='duration in hours')\n parser.add_argument('-dc','--dc','--datacenter', action='store', dest='datacenter',default='IRIS',help='FDSN data center (e.g. IRIS, SCEDC, NCEDC)')\n parser.add_argument('-p','--plot',action='store_true',dest='iplot',help='make plots of each hourly trace (NOTE: can be slow)')\n\n helpextended = parser.parse_args(_preprocess_sysargv(sys.argv)).helpmenu\n if ( helpextended is True ):\n print ('')\n print ('portable_pip_squeak: assess a station either using local data or to be downloaded')\n print ('')\n print ('Usage: portable_pip_squeak.py [options]')\n print ('')\n print ('EXAMPLES:')\n print ('portable_pip_squeak.py --infile my_SAC_files.txt')\n print ('portable_pip_squeak.py -N UW -S TKEY -C HH -s 2018-01-01T00:00:00 -d 2 -p')\n print ('portable_pip_squeak.py -N CI -S LEO -C HN -s 2020-01-01T00:00:00 -d 24 -dc SCEDC')\n print ('')\n print ('Inputs if supplying your own data:')\n print (' -i, --infile Name of text file with SAC/mseed file(s) of 3 (Z,N,E) traces.')\n print (' -g, --gain Gain or Stage 0 sensitivity')\n print (' ')\n print ('Inputs if downloading data:')\n print (' -s, --starttime Trace start time (YYYY-MM-DD,HH:MM:SS)')\n print ('')\n print (' One of these:')\n print (' -e, --endtime Trace end time (YYYY-MM-DD,HH:MM:SS)')\n print (' -d, --duration Duration in hours from starttime')\n print (' Note: if duration is neg, starttime becomes endtime')\n print (' N, S, C and a datacenter if other than IRIS')\n print (' -N, --net Network code')\n print (' -S, --sta Station code')\n print (' -C, --cha Channel type, e.g. EN or HH')\n print (' -dc, --datacenter Name of FDSN data center if not IRIS, e.g. SCEDC, NCEDC')\n print (' ')\n print ('Optional flags:')\n print ('-P, --plot Flag to make a figure for each hour. Note: can be slow.')\n print ('-u Print this extended help menu')\n print ('')\n\n\n return parser.parse_args(_preprocess_sysargv(sys.argv))","def parse_args():\n parser = argparse.ArgumentParser(\n description='Aggregate Elasticsearch Log data.')\n parser.add_argument(\n '--host',\n default='https://logging-es',\n type=str,\n action='store',\n help='Host name or IP of the Elasticsearch server.'\n )\n parser.add_argument(\n '--port',\n default=9200,\n type=int,\n action='store',\n help='Port number of the Elasticsearch server.'\n )\n parser.add_argument(\n '--ca_certs',\n default='secret/admin-ca',\n type=str,\n action='store',\n help='Path to the CA certificates file'\n )\n parser.add_argument(\n '--cert',\n default='secret/admin-cert',\n type=str,\n action='store',\n help='Path to the client certificate file'\n )\n parser.add_argument(\n '--key',\n default='secret/admin-key',\n type=str,\n action='store',\n help='Path to the client key file'\n )\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=\"\")\n parser.add_argument(\n \"config_path\",\n type=str,\n help=\"Path to the JSON configuration file containing the image transformation settings.\",\n )\n parser.add_argument(\n \"img_path\",\n type=str,\n help=\"Path to the input image file to apply transformations.\",\n )\n return parser.parse_args()","def parse():\n\n args = sys.argv\n if os.name == 'nt' and args and 'python' in os.path.basename(args[0]).lower():\n args = args[2:]\n else:\n args = args[1:]\n args = vars(parser.parse_args(args))\n \n # set the global verbosity level of the script\n script.set_verbosity(args['verbosity']) \n \n return args","def ParseArgs() -> argparse.Namespace:\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\n '--input', dest='input', help='Japanese phonetic reading file')\n parser.add_argument(\n '--output_token_array',\n dest='output_token_array',\n help='Output token array file.')\n parser.add_argument(\n '--output_string_array',\n dest='output_string_array',\n help='Output string array file.')\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Reads datapacket pcds, interpolates quaternions and generates scans from dataset in config file\")\n parser.add_argument(\"--visualization\", \"-v\", action=\"store_true\", help=\"if generated clouds should be visualized\")\n parser.add_argument(\"--directory\", \"-d\",\n help=\"if only specified directory should be interpolated, e.g. 'fragments/fragment0'\")\n args = parser.parse_args()\n return args.visualization, args.directory","def parse_args():\n usage = (\"Usage: python driver.py k-number-of-output-colors \"\n \"{kmeans, kmeans++} /path/to/image.jpg\")\n assert len(sys.argv) >= 2, \"Too few arguements. \" + usage\n\n # Determine k\n assert sys.argv[1].isdigit(), (\"k-number-of-output-colors needs to be a \"\n \"digit. \" + usage)\n k = int(sys.argv[1])\n\n # Determine algorithm type (optional input)\n try:\n assert sys.argv[2] in {\"kmeans\", \"kmeans++\"}, (\"Invalid algorithm \"\n \"type. \" + usage)\n algorithm_type = sys.argv[2]\n except IndexError:\n print \"No algorithm type given in args; using default algorithm 'kmeans'\"\n algorithm_type = \"kmeans\"\n \n # Determine image path (optional input)\n try:\n img_path = sys.argv[3]\n except IndexError:\n print \"No image path given in args; using default image './park.jpg'\"\n img_path = \"./park.jpg\"\n\n return k, algorithm_type, img_path","def parse_arguments(args: List[Dict]) -> 'Dict[str, Argument]':\n if not args:\n return {}\n result = {}\n for a in args:\n if not a:\n continue\n arg = Argument(a)\n result[arg.name] = arg\n return result","def parse_args():\n parser = argparse.ArgumentParser(description=app_description,\n formatter_class=argparse.RawTextHelpFormatter)\n parser.add_argument(\"--input-json\", dest=\"input_json_path\", required=True,\n help=input_json_help)\n\n args = parser.parse_args()\n return args","def parse_args(argv):\n formatter_class = argparse.RawDescriptionHelpFormatter\n parser = argparse.ArgumentParser(description=\"Run torrent-knowledge cli\",\n formatter_class=formatter_class)\n\n parser.add_argument(\"-i\", \"--input_file\",\n type=argparse.FileType('r'),\n required=True,\n help=\"CSV with torrents in format 'info_hash|torrent_title'\")\n\n parser.add_argument(\"-o\", \"--output_file\",\n required=True,\n type=argparse.FileType('w'),\n default=sys.stdout)\n\n parser.add_argument(\"-v\", \"--verbose\", dest=\"verbose\",\n action=\"count\", default=0,\n help=\"increase log verbosity via -vvv\")\n\n parser.add_argument(\"-t\", \"--train-mode\", dest=\"train_mode\",\n action=\"count\", default=0,\n help=\"update features frequency from dataset\")\n\n parser.add_argument(\"-l\", \"--log-dir\", dest=\"log_dir\",\n action=\"store\", default=None,\n help=\"directory for log files (only for -vvv mode)\")\n\n args = parser.parse_args(argv[1:])\n\n if args.log_dir and args.verbose != 3:\n logger.debug(\"You should use -vvv with option -l\")\n exit(-1)\n\n return parser.parse_args(argv[1:])","def parse_args(argparser_args):\n return {k: v for k, v in vars(argparser_args).items() if v is not None}","def get_arguments():\n\tparser.add_argument('-i', '--interface', help='interface to affect')\n\tparser.add_argument('-m','--mac', help='mac to allocate')\n\n\targs = parser.parse_args()\n\tinterface = args.interface\n\tmac = args.mac\n\treturn (interface, mac)","def parse_args():\n parser = argparse.ArgumentParser(description='Crawl an Android app store for apk files.')\n parser.add_argument('--store', dest='api', choices=['GooglePlay', 'F-Droid'], required=True,\n help='Specifies the store to crawl. At the moment only Google Play is supported.')\n parser.add_argument('--meta', dest='meta', required=False, action='store_const', default=False, const=True,\n help='If set, no apps will be downloaded, but the meta_data will be saved.')\n parser.add_argument('--basedir', dest='base_dir', type=str, default=os.getenv('HOME'),\n required=False, help='Specifies the base path for both logs and apk_downloads.')\n parser.add_argument('--credentials', dest='credentials', type=str, required=False, default=None,\n help='Specifies the path to a credential file in .toml format.')\n parser.add_argument('--limit', dest='limit', type=int, required=False, default=None,\n help='Specifies the maximum number of apks per category to download.')\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=_program_description)\n parser.add_argument('input_file', help=_input_file_description)\n #parser.add_argument('-v', '--verbose', action='store_true', \n # default=False, help='show progress')\n args = parser.parse_args()\n return args","def _parse_args():\n args = sys.argv[1:]\n cmd_parser = argparse.ArgumentParser()\n cmd_parser.add_argument(\n '--produce-sub',\n dest='produce_sub',\n help='Produce submision file',\n default=False,\n action='store_true',\n )\n cmd_parser.add_argument(\n '--search-cv',\n dest='search_cv',\n help='Perform Search of parameters',\n default=False,\n action='store_true',\n )\n cmd_opts = cmd_parser.parse_args(args=args)\n return cmd_opts","def arg_parse():\n p = ap.ArgumentParser()\n p.add_argument('infile',\n help='path to file containing objects')\n p.add_argument('n1',\n help='night 1')\n p.add_argument('n2',\n help='night 2')\n p.add_argument('observatory',\n help='Astropy name of observatory')\n return p.parse_args()","def parseArgs():\n\t\n\tparser = argparse.ArgumentParser(\n\t\tprog='device_sniffer',\n\t\tdescription='spot nearby devices using a wireless sniffer.',\n\t\tusage='%(prog)s <mode> [options]')\n\t\n\tparser.add_argument('--interface','-i', help=\"interface to scan on.\", dest=\"inf\", type=str)\n\tparser.add_argument('--verbse','-v', help=\"show extra output.\", dest=\"verbosity\", action=\"count\")\n\tparser.add_argument('types', help=\"type of devices to scan for.\", choices=['connected', 'scanning','both'], default='both', nargs='?')\n\targs = parser.parse_args()\n\treturn args","def parse_command_line_arguments(argv):\n print(\"reading command line arguments in...\")\n\n parser = argparse.ArgumentParser(description='Description of your program')\n parser.add_argument('-i', '--input', help='Location of input csv file', required=True)\n parser.add_argument('-p', '--predicting', help='The column name containing the category to predict', required=True)\n parser.add_argument('-s', '--scoring', help='The scoring type to be used with model evaluation', required=False)\n parser.add_argument('-c', '--scale', help='List of column names to scale values for', nargs='+', required=False)\n args = parser.parse_args()\n\n return args.input, args.predicting, args.scoring, args.scale","def parse_args():\r\n # label_path: 原始label文件存储位置\r\n # det_path : 生成的bbox的信息文件存储位置\r\n # 下面只是对训练集进行解析，测试机可以得到同样的结果。\r\n parser = argparse.ArgumentParser()\r\n parser.add_argument('--label_path', type=str,default='C:\\\\Users\\\\wangbo\\\\Documents\\\\EGDownloads\\\\bdd100k_labels_release\\\\bdd100k\\\\labels\\\\bdd100k_labels_images_train.json')\r\n parser.add_argument('--det_path', type=str,default='C:\\\\Users\\\\wangbo\\\\Documents\\\\EGDownloads\\\\bdd_dect\\\\detection_train.json ')\r\n args = parser.parse_args()\r\n\r\n return args","def parse_args():\n\n parser = argparse.ArgumentParser(description='CLI to store Actisense-NGT Gateway values to InfluxDB and publish via MQTT')\n parser.add_argument('--config', '-c', type=str, required=True, help='JSON configuraton file with path')\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n description='Convert CVAT XML annotations to PASCAL VOC format'\n )\n\n parser.add_argument(\n '--cvat-xml', metavar='FILE', required=True,\n help='input file with CVAT annotation in xml format'\n )\n\n parser.add_argument(\n '--image-dir', metavar='DIRECTORY', required=True,\n help='directory which contains original images'\n )\n\n parser.add_argument(\n '--output-dir', metavar='DIRECTORY', required=True,\n help='directory for output annotations in PASCAL VOC format'\n )\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser( description='Required: function-name.' )\n parser.add_argument( '--function', '-f', help='function name required', required=True )\n args_dict = vars( parser.parse_args() )\n return args_dict","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"auth\",\n help=\"authentication string for Infermedica API: \"\n \"APP_ID:APP_KEY or path to file containing it.\")\n parser.add_argument(\"--model\",\n help=\"use non-standard Infermedica model/language, \"\n \"e.g. infermedica-es\")\n args = parser.parse_args()\n return args","def get_input_args():\n # Create Parse using ArgumentParser\n\n parser = argparse.ArgumentParser()\n\n # Create command line arguments as mentioned above using add_argument() from ArguementParser method\n\n parser.add_argument('--image_path',type=str,default='flowers/test/10/image_07090.jpg',help='path for image to predict')\n parser.add_argument('--save_dir',type=str,default='fc_checkpoint.pth',help='path for checkpoint')\n parser.add_argument('--topk',type=int,default=5,help='input number of top classes for prediction')\n parser.add_argument('--arch', type = str, default = 'vgg16', help = 'architecure of Model') \n parser.add_argument('--gpu',default=True,help='use GPU to make predictions')\n parser.add_argument('--cat_to_name', default = 'cat_to_name.json',help='enters a path to image.')\n\n in_arg = parser.parse_args()\n\n return in_arg","def arglist2dict(args):\n arg_dict = {}\n\n if len(args) == 0:\n return arg_dict\n\n if not args[0].startswith('--'):\n raise ValueError(f\"Positional keywords are not supported: {args[0]}\")\n\n i = 0\n while i < len(args):\n arg = args[i]\n i = i + 1\n if arg.startswith('--'):\n dest = arg[2:]\n j, arglist = Parser.get_args(args[i:])\n i = i + j\n Parser.update_arg_dict(arg_dict, dest, arglist)\n return arg_dict","def parse_arguments():\n\n parser = argparse.ArgumentParser(\n description=\"生成用户字符串识别的切分字符串\"\n )\n parser.add_argument(\n \"-o\",\n \"--output_dir\",\n type=str,\n nargs=\"?\",\n help=\"The output directory\",\n default=\"output/\"\n )\n parser.add_argument(\n \"-i\",\n \"--input_file\",\n type=str,\n nargs=\"?\",\n help=\"When set, this argument uses a specified text file as source for the text\",\n default=\"\",\n required=True\n )\n parser.add_argument(\n \"-mi\",\n \"--min_char_count\",\n type=int,\n nargs=\"?\",\n help=\"The minimum number of characters per line, Default is 3.\",\n default=3,\n\n )\n parser.add_argument(\n \"-ma\",\n \"--max_char_count\",\n type=int,\n nargs=\"?\",\n help=\"The maximum number of characters per line, Default is 20.\",\n default=20,\n )\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=\"Re-Id\")\n parser.add_argument(\n \"--exp1\", help=\"Name of Camera 1\",\n default=None, required=True)\n parser.add_argument(\n\t \"--exp2\", help=\"Name of Camera 2\",\n\t default=None, required=True)\n\n return parser.parse_args()","def command_line_arguments():\n\n try:\n parser = argparse.ArgumentParser(description='Log Handler/Cleaner/Copier for Idemia DocAuth')\n\n # Add required arguments.\n parser.add_argument('action', choices=['clean', 'download'], type=str, help='clean or download')\n\n # Parse the arguments\n args = parser.parse_args()\n\n return args\n\n except Exception as err:\n print(err)\n return","def parse_args():\n \n parser = argparse.ArgumentParser()\n parser.add_argument(\n 'config',\n help='Config file')\n parser.add_argument(\n '--quiet',\n '-q',\n action='store_true',\n help='do not print to console'\n )\n parser.add_argument(\n '--password',\n '-p',\n action='store_true',\n help='Set password in keyring.'\n )\n parser.add_argument(\n '--update',\n '-u',\n action='store_true',\n help='Only add transactions after last date in database.'\n )\n parser.add_argument(\n '--mark_seen',\n '-m',\n action='store_true',\n help='Mark fetched emails as seen.'\n )\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=\"Deep SORT\")\n parser.add_argument(\n \"--input\", help=\"Path to MOTChallenge sequence directory\",\n default=None, required=True)\n return parser.parse_args()","def parse_args():\n from argparse import ArgumentParser\n ap = ArgumentParser(prog='fsupload', description=\"Upload FreeSurfer edits to subject on XNAT\")\n ap.add_argument('project', help='Project Label')\n ap.add_argument('session', help='Session Label')\n ap.add_argument('proc_suffix', help='Proc name suffix', nargs='?', default='')\n return ap.parse_args()","def parse_arguments():\n # shift away script name\n scriptname=sys.argv[0]\n shift()\n ncl_cmd=list()\n quali_cmd=list()\n id_cmd=list() \n while(len(sys.argv)>0):\n carg = sys.argv[0]\n shift()\n if(carg == \"--nucleotide\"):\n ncl_cmd = mungeArgs(sys.argv)\n elif(carg == \"--quality\"):\n quali_cmd = mungeArgs(sys.argv)\n elif(carg == \"--id\" ):\n id_cmd = mungeArgs(sys.argv)\n elif(carg in [\"-h\", \"--help\"]):\n usage()\n else:\n usage(error=True)\n # Excess arguments which are not processed \n if(len(sys.argv) > 0):\n sys.stdout.write(\"Excess arguments!\\n\")\n sys.stdout.flush()\n usage(error=True)\n\n # external modules rely on non-empty argv array, \n # re-append the script name as first command line argument\n sys.argv.append(scriptname)\n return (id_cmd, ncl_cmd, quali_cmd)","def get_args_from_console(args):\n return {\n \"cleaning_policy\": args.cleaning_policy,\n \"clear\": args.clear,\n \"content\": args.content,\n \"dry_run\": args.dry_run,\n \"force\": args.force,\n \"in_lines\": args.in_lines,\n \"max_size\": args.max_size,\n \"regex\": args.regex,\n \"restore\": args.restore,\n \"rmdir\": args.rmdir,\n \"short\": args.short,\n \"silent\": args.silent,\n \"storage_time\": args.storage_time,\n \"wastebasket_path\": args.wastebasket_path\n }","def _parse_arguments():\n parser = argparse.ArgumentParser(\n prog=\"JSON sorter\",\n description=\"Take a json file, sort the keys and insert 4 spaces for indents.\",\n )\n\n parser.add_argument(\n \"input\", help=\"JSON file to parse.\",\n )\n\n parser.add_argument(\n \"-o\",\n \"--output\",\n default=sys.stdout,\n type=argparse.FileType(mode=\"w\"),\n help=\"File to write to. Defaults to stdout.\",\n )\n\n # Should probably implement this and CSV as subcommands\n parser.add_argument(\n \"-y\",\n \"--yaml\",\n action=\"store_true\",\n help=\"Whether to sort a YAML file provided as the input.\",\n )\n\n # is there a way to have info printed with this from argparse?\n parser.add_argument(\n \"-l\",\n \"--log\",\n action=\"store_true\",\n help=\"Turn logging on and print to console.\",\n )\n\n parser.add_argument(\n \"-ll\",\n \"--log_level\",\n dest=\"log_level\",\n choices=[\"DEBUG\", \"INFO\", \"WARNING\", \"ERROR\", \"CRITICAL\"],\n help=\"Set the logging level\",\n )\n\n parser.add_argument(\n \"-V\", \"--version\", action=\"version\", version=\"%(prog)s\" + __version__\n )\n\n if len(sys.argv[1:]) == 0:\n parser.print_help()\n sys.exit()\n\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser(description=\"Reads in iClicker data from the submission \"\n \"directory, and then writes it to the given \"\n \"remote file.\")\n parser.add_argument(\"submission_directory\", type=str, help=\"Directory of submissions that \"\n \"contain a 'textbox_0.txt' file that references iClicker ID\")\n parser.add_argument(\"remote_id_file\", type=str)\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Nuvoton post build command\"\n )\n\n subparsers = parser.add_subparsers(description=\"The action to perform\")\n\n parser_tfm_sign_image_tgt = subparsers.add_parser(\n \"tfm_sign_image_tgt\",\n help=\"Sign secure and non-secure images together\"\n )\n \n parser_tfm_sign_image_tgt.add_argument(\n \"--tfm-import-path\",\n help=\"Path containing the TF-M bootloader, layouts and signing keys\",\n required=True\n )\n\n parser_tfm_sign_image_tgt.add_argument(\n \"--signing_key\",\n help=\"File name of key for signing secure binary or secure/non-secure binaries together\",\n required=True\n )\n\n parser_tfm_sign_image_tgt.add_argument(\n \"--non-secure-bin\",\n help=\"Path to the non-secure binary\",\n required=True\n )\n\n parser_tfm_sign_image_tgt.set_defaults(func=tfm_sign_image_tgt)\n\n return parser.parse_args()","def _parse_tags(tags: str):\n return dict(item.split(\":\") for item in shlex.split(tags)) # type: ignore","def parse_argv(self, argv):\n machine = ParseMachine(initial=self.initial, contexts=self.contexts)\n for token in argv:\n machine.handle(token)\n machine.finish()\n return machine.result","def arg_parse():\n parser = argparse.ArgumentParser(description=\"Fetches the current ATT&CK content expressed as STIX2 and creates spreadsheet mapping Techniques with Mitigations, Groups or Software.\")\n parser.add_argument(\"-d\", \"--domain\", type=str, required=True, choices=[\"enterprise_attack\", \"mobile_attack\"], help=\"Which ATT&CK domain to use (Enterprise, Mobile).\")\n parser.add_argument(\"-m\", \"--mapping-type\", type=str, required=True, choices=[\"groups\", \"mitigations\", \"software\"], help=\"Which type of object to output mappings for using ATT&CK content.\")\n parser.add_argument(\"-t\", \"--tactic\", type=str, required=False, help=\" Filter based on this tactic name (e.g. initial-access) \" )\n parser.add_argument(\"-s\", \"--save\", type=str, required=False, help=\"Save the CSV file with a different filename.\")\n return parser","def parse_args():\n parser = argparse.ArgumentParser(\"Run arguments for system submitted tasks\")\n\n parser.add_argument(\"-f\", \"--funcs\", type=str, nargs=\"?\", required=True,\n help=\"path to pickle file containing a list of \"\n \"functions/methods that should be run by the \"\n \"submitted process\"\n )\n parser.add_argument(\"-k\", \"--kwargs\", type=str, nargs=\"?\", required=False,\n default=None,\n help=\"path to pickle file containing a dictionary of \"\n \"keyword argumnets that should be passed to the \"\n \"functions\")\n parser.add_argument(\"-e\", \"--environment\", type=str, nargs=\"?\",\n required=False,\n help=\"Optional comma-separated environment variables, \"\n \"which should be given as \"\n \"VARNAME1=value1,VARNAME2=value2 and so on. These \"\n \"will be separated and instantiated into Python's \"\n \"os.environ\")\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"--start\",\n type=str,\n default=\"\",\n required=False,\n help=\"The start square of the agent, in the form row,col. If not specified, this is randomized\"\n )\n parser.add_argument(\n \"--actions\",\n type=str,\n required=True,\n nargs = '+',\n help=\"The actions the agent takes, comma delimited\"\n )\n parser.add_argument(\n \"--observations\",\n type=str,\n required=True,\n nargs = '+',\n help=\"The observations the agent makes, comma delimited\"\n )\n return parser.parse_args()","def get_input_args():\n # Create Parse using ArgumentParser\n parser = ArgumentParser()\n\n # Image file path as --file_path\n # Path to test images\n # image_path = './test_images/hard-leaved_pocket_orchid.jpg'\n # image_path = './test_images/cautleya_spicata.jpg'\n # image_path = './test_images/orange_dahlia.jpg'\n # image_path = './test_images/wild_pansy.jpg'\n parser.add_argument(\"--file_path\",\n type = str,\n default = './test_images/hard-leaved_pocket_orchid.jpg',\n help = \"Image file path.\")\n\n # Model file name as --model_filename\n parser.add_argument(\"--model_filename\",\n type = str,\n default = 'model_20200422_223607.h5',\n help = \"Model path and file name.\")\n\n # Top k classes to be returned as --top_k with default value 5\n parser.add_argument(\"--top_k\",\n type = int,\n default = 5,\n help = \"Number of epochs. Default = 5\")\n\n # json file mapping labels as --category_names\n parser.add_argument(\"--category_names\",\n type = str,\n default = 'label_map.json',\n help = \"json file mapping labels.\")\n\n return parser.parse_args()","def parse_known_args():\n\n parser = argparse.ArgumentParser(\n description= \"\\n\".join([\"HUMAnN Benchmark\\n\",\n \"To run: $ humann_benchmark COMMAND\",\n \"Replacing COMMAND with the command to benchmark\"]),\n formatter_class=argparse.RawTextHelpFormatter)\n\n return parser.parse_known_args()","def parse_args():\n parser = argparse.ArgumentParser(description='Parse flags to configure the json parsing')\n parser.add_argument(\"-f\", \"--format\", help=\"output format: (csv|tsv|json)\", choices=[\"csv\", \"tsv\", \"json\"],\n default=\"tsv\")\n parser.add_argument(\"-p\", \"--parallelized\", help=\"save output in parallelized or single file format\",\n action=\"store_true\")\n parser.add_argument(\"-i\", \"--input\", help=\"folder where input documents are\", default=\"data\")\n parser.add_argument(\"-o\", \"--output\", help=\"folder where output documents are\", default=\"cleaned\")\n parser.add_argument(\"-d\", \"--documentformat\", help=\"combine all features into a single text per post\",\n action=\"store_true\")\n parser.add_argument(\"-pa\", \"--partitions\", help=\"number of spark partitions\",\n default=1)\n args = parser.parse_args()\n return args","def parse_arguments():\n parser = argparse.ArgumentParser(prog='AdapterRunner', description='Adapter Runner Application')\n parser.add_argument('-a', '--application', action='store', dest='app_name', help='Application Name',\n metavar='<application_name>')\n parser.add_argument('-fi', '--fetch_interval', action='store', dest='fetch_stats_interval', help='Fetch Stats Interval',\n metavar='<fetch_interval in seconds>')\n return parser.parse_args()","def command_line_parse(iargs=None):\n\n parser = create_parser()\n inps = parser.parse_args(args=iargs)\n\n return inps","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"auth\",\n help=\"authentication string for Infermedica API: \"\n \"APP_ID:APP_KEY or path to file containing it.\")\n parser.add_argument(\"--model\",\n help=\"use non-standard Infermedica model/language, \"\n \"e.g. infermedica-es\")\n # TODO: Check if `verbose` actually does anything.\n parser.add_argument(\"-v\", \"--verbose\",\n dest=\"verbose\", action=\"store_true\", default=False,\n help=\"dump internal state\")\n args = parser.parse_args()\n return args","def parse_args(self):\n return self.__process_args__(self.parser.parse_args())"],"string":"[\n \"def _parse_args(argv):\\n result = {}\\n for arg in argv:\\n k, v = arg.split(\\\"=\\\")\\n result[k] = v\\n return result\",\n \"def retrieve_args_dict():\\n process_args = sys.argv[1:]\\n dictionary = dict()\\n for process_arg in process_args:\\n splitted = process_arg.split(\\\":\\\")\\n if len(splitted) > 1:\\n key = splitted[0]\\n value = \\\"\\\".join(splitted[1:])\\n dictionary[key] = value\\n return dictionary\",\n \"def crude_arg_parser(args=sys.argv):\\n args_dict = {}\\n key = None\\n for e in args[1:]:\\n if e[:2] == '--':\\n if key:\\n args_dict[key] = True # Switch arg\\n key = e[2:]\\n elif key:\\n args_dict[key] = e\\n key = None\\n\\n return args_dict\",\n \"def parse_arguments(args: list = None) -> Dict[str, str]:\\n arg_parser = argparse.ArgumentParser(description=\\\"Console command to crypt \\\"\\n \\\"and decrypt texts using \\\"\\n \\\"classic methods. It also \\\"\\n \\\"performs crypto attacks \\\"\\n \\\"against those methods.\\\\n\\\",\\n epilog=\\\"Follow cifra development at: \\\"\\n \\\"<https://github.com/dante-signal31/cifra>\\\")\\n cifra_subparsers = arg_parser.add_subparsers(help=\\\"Available modes\\\",\\n dest=\\\"mode\\\",\\n required=True)\\n # DICTIONARY MANAGEMENT.\\n dictionary_parser = cifra_subparsers.add_parser(name=\\\"dictionary\\\",\\n help=\\\"Manage dictionaries to \\\"\\n \\\"perform crypto attacks.\\\")\\n dictionary_actions_subparser = dictionary_parser.add_subparsers(help=\\\"Action to perform.\\\",\\n dest=\\\"action\\\")\\n # DICTIONARY CREATION.\\n dictionary_create_parser = dictionary_actions_subparser.add_parser(name=\\\"create\\\",\\n help=\\\"Create a dictionary of unique words.\\\")\\n dictionary_create_parser.add_argument(\\\"dictionary_name\\\",\\n type=str,\\n help=\\\"Name for the dictionary to create.\\\",\\n metavar=\\\"NEW_DICTIONARY_NAME\\\")\\n dictionary_create_parser.add_argument(\\\"-i\\\", \\\"--initial_words_file\\\",\\n type=_check_is_file,\\n help=\\\"Optionally you can load in the dictionary words located in a text file\\\",\\n metavar=\\\"PATH_TO FILE_WITH_WORDS\\\")\\n # DICTIONARY REMOVAL.\\n dictionary_delete_parser = dictionary_actions_subparser.add_parser(name=\\\"delete\\\",\\n help=\\\"Remove an existing dictionary.\\\")\\n dictionary_delete_parser.add_argument(\\\"dictionary_name\\\",\\n type=str,\\n help=\\\"Name for the dictionary to delete.\\\",\\n metavar=\\\"DICTIONARY_NAME_TO_DELETE\\\")\\n # DICTIONARY UPDATING.\\n dictionary_update_parser = dictionary_actions_subparser.add_parser(name=\\\"update\\\",\\n help=\\\"Add words to an existing dictionary.\\\")\\n dictionary_update_parser.add_argument(\\\"dictionary_name\\\",\\n type=str,\\n help=\\\"Name for the dictionary to update with additional words.\\\",\\n metavar=\\\"DICTIONARY_NAME_TO_UPDATE\\\")\\n dictionary_update_parser.add_argument(\\\"words_file\\\",\\n type=_check_is_file,\\n help=\\\"Pathname to a file with words to add to dictionary\\\",\\n metavar=\\\"PATH_TO_FILE_WITH_WORDS\\\")\\n # DICTIONARY LISTING.\\n _ = dictionary_actions_subparser.add_parser(name=\\\"list\\\",\\n help=\\\"Show existing dictionaries.\\\")\\n # CIPHER MANAGEMENT.\\n cipher_parser = cifra_subparsers.add_parser(name=\\\"cipher\\\",\\n help=\\\"Cipher a text using a key.\\\")\\n cipher_parser.add_argument(\\\"algorithm\\\",\\n choices=CIPHERING_ALGORITHMS,\\n type=str,\\n help=\\\"Algorithm to use to cipher.\\\",\\n metavar=\\\"ALGORITHM_NAME\\\")\\n cipher_parser.add_argument(\\\"key\\\",\\n type=str,\\n help=\\\"Key to use to cipher.\\\",\\n metavar=\\\"CIPHERING_KEY\\\")\\n cipher_parser.add_argument(\\\"file_to_cipher\\\",\\n type=_check_is_file,\\n help=\\\"Path to file with text to cipher.\\\",\\n metavar=\\\"FILE_TO_CIPHER\\\")\\n cipher_parser.add_argument(\\\"-o\\\", \\\"--ciphered_file\\\",\\n type=str,\\n help=\\\"Path to output file to place ciphered text. If not used then\\\"\\n \\\"ciphered text will be dumped to console.\\\",\\n metavar=\\\"OUTPUT_CIPHERED_FILE\\\")\\n cipher_parser.add_argument(\\\"-c\\\", \\\"--charset\\\",\\n type=str,\\n help=f\\\"Default charset is: {cifra.cipher.common.DEFAULT_CHARSET}, but you can set here \\\"\\n f\\\"another.\\\",\\n metavar=\\\"CHARSET\\\")\\n # DECIPHERING MANAGEMENT\\n decipher_parser = cifra_subparsers.add_parser(name=\\\"decipher\\\",\\n help=\\\"Decipher a text using a key.\\\")\\n decipher_parser.add_argument(\\\"algorithm\\\",\\n choices=CIPHERING_ALGORITHMS,\\n type=str,\\n help=\\\"Algorithm to use to decipher.\\\",\\n metavar=\\\"ALGORITHM_NAME\\\")\\n decipher_parser.add_argument(\\\"key\\\",\\n type=str,\\n help=\\\"Key to use to decipher.\\\",\\n metavar=\\\"CIPHERING_KEY\\\")\\n decipher_parser.add_argument(\\\"file_to_decipher\\\",\\n type=_check_is_file,\\n help=\\\"Path to file with text to decipher.\\\",\\n metavar=\\\"FILE_TO_DECIPHER\\\")\\n decipher_parser.add_argument(\\\"-o\\\", \\\"--deciphered_file\\\",\\n type=str,\\n help=\\\"Path to output file to place deciphered text. If not used then\\\"\\n \\\"deciphered text will be dumped to console.\\\",\\n metavar=\\\"OUTPUT_DECIPHERED_FILE\\\")\\n decipher_parser.add_argument(\\\"-c\\\", \\\"--charset\\\",\\n type=str,\\n help=f\\\"Default charset is: {cifra.cipher.common.DEFAULT_CHARSET}, but you can set here \\\"\\n f\\\"another.\\\",\\n metavar=\\\"CHARSET\\\")\\n # ATTACK MANAGEMENT\\n attack_parser = cifra_subparsers.add_parser(name=\\\"attack\\\",\\n help=\\\"Attack a ciphered text to get its plain text\\\")\\n attack_parser.add_argument(\\\"algorithm\\\",\\n choices=CIPHERING_ALGORITHMS,\\n type=str,\\n help=\\\"Algorithm to attack.\\\",\\n metavar=\\\"ALGORITHM_NAME\\\")\\n attack_parser.add_argument(\\\"file_to_attack\\\",\\n type=_check_is_file,\\n help=\\\"Path to file with text to attack.\\\",\\n metavar=\\\"FILE_TO_ATTACK\\\")\\n attack_parser.add_argument(\\\"-o\\\", \\\"--deciphered_file\\\",\\n type=str,\\n help=\\\"Path to output file to place deciphered text. If not used then\\\"\\n \\\"deciphered text will be dumped to console.\\\",\\n metavar=\\\"OUTPUT_DECIPHERED_FILE\\\")\\n attack_parser.add_argument(\\\"-c\\\", \\\"--charset\\\",\\n type=str,\\n help=f\\\"Default charset is: {cifra.cipher.common.DEFAULT_CHARSET}, but you can set here \\\"\\n f\\\"another.\\\",\\n metavar=\\\"CHARSET\\\")\\n\\n parsed_arguments = vars(arg_parser.parse_args(args))\\n filtered_parser_arguments = {key: value for key, value in parsed_arguments.items()\\n if value is not None}\\n return filtered_parser_arguments\",\n \"def parseArgs():\\n\\n def getInput(name: str, *, required=False):\\n val = os.environ.get(f'INPUT_{name.replace(\\\" \\\", \\\"_\\\").upper()}', \\\"\\\")\\n if not val and required:\\n raise ValueError(f\\\"Missing required parameter: {name}\\\")\\n return val\\n\\n certificate = getInput(\\\"certificate\\\", required=True)\\n private_key = getInput(\\\"private_key\\\", required=True)\\n connectorId = getInput(\\\"connector_id\\\", required=True)\\n host = getInput(\\\"host\\\", required=True)\\n body = yaml.load(getInput(\\\"args\\\", required=True), yaml.Loader)\\n\\n with string_to_tempfile(certificate) as cert_file, string_to_tempfile(\\n private_key\\n ) as key_file:\\n yield ActionArgs(\\n host=host,\\n auth=AuthCert(cert=Path(cert_file.name), private_key=Path(key_file.name)),\\n args=AddOrUpdateIncident2Args(**body, connectorId=connectorId),\\n )\",\n \"def parse(argv):\\n\\n if not argv:\\n return None, None\\n parser = parsersetup()\\n opts, args = parser.parse_args(argv)\\n try:\\n opts.action = args.pop()\\n except IndexError:\\n # No action specified\\n pass\\n\\n return opts, args\",\n \"def parse_args(argv: t.Iterable[str] = None):\\n if argv is None:\\n argv = sys.argv[1:]\\n\\n args: t.List[str] = []\\n kwargs: t.MutableMapping[str, t.Any] = {}\\n\\n key = None\\n for arg in argv:\\n if arg.startswith('--'):\\n if arg == '--help':\\n print(USAGE)\\n raise SystemExit\\n if key is not None:\\n kwargs[key] = True\\n key = arg[2:]\\n continue\\n\\n match = re.match('^(\\\\\\\\w+)=(.*)$', arg)\\n if match:\\n if key is not None:\\n kwargs[key] = True\\n key = None\\n kwargs[match.group(1)] = match.group(2)\\n continue\\n\\n if key is not None:\\n kwargs[key] = arg\\n key = None\\n continue\\n\\n args.append(arg)\\n\\n if key is not None:\\n kwargs[key] = True\\n\\n return (tuple(args), kwargs)\",\n \"def get_input_args():\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument('--json_path', type=str, default='cat_to_name.json', \\n help='Json path of labels to categories')\\n parser.add_argument('--use_gpu', type=bool, default=False, \\n help='Run with GPU')\\n parser.add_argument('--topk', type=int, default=5, \\n help='Top N classes that needed to be displayed')\\n parser.add_argument('--image_path', type=str, default='C:/Users/TsalikiK/Downloads/Kantar/Kantar_Python_Work/Notebooks/aipnd-project/test/1/image_06743.jpg', \\n help='Image which you want to predict')\\n\\n # returns parsed argument collection\\n return parser.parse_args()\",\n \"def parse_args_dict(args=None):\\n return vars(parse_args(args))\",\n \"def main_parse_args():\\n parser = ArgumentParser()\\n parser.add_argument('infile', help='path to the file to be mapped.It should\\\\\\n contain one identifer on each line.')\\n parser.add_argument('-rh', '--redis_host', default=DEFAULT_REDIS_URL,\\n help='url of Redis db')\\n parser.add_argument('-rp', '--redis_port', default=DEFAULT_REDIS_PORT,\\n help='port for Redis db')\\n parser.add_argument('-rps', '--redis_pass', default=DEFAULT_REDIS_PASS,\\n help='password for Redis db')\\n parser.add_argument('-of', '--outfile', default=None,\\n help='path to the output file')\\n parser.add_argument('-sh', '--source_hint', help='suggestion for ID source \\\\\\n database used to resolve ambiguities in mapping',\\n default=DEFAULT_HINT)\\n parser.add_argument('-t', '--taxon', help='taxon id of species of all gene \\\\\\n names', default=DEFAULT_TAXON)\\n myargs = parser.parse_args()\\n return myargs\",\n \"def _parse_args(self, args : dict):\\n result = {}\\n for key, value in args.items():\\n if key in self._subparsers:\\n # if it's a list, it is because it's a preset\\n if isinstance(value, list):\\n result[key] = value[0]\\n else:\\n result[key] = self._subparsers[key]._parse_args(value)\\n elif key in self._actions:\\n result[key] = self._actions[key](value)\\n else:\\n raise ValueError(f\\\"Unknown argument {key}\\\")\\n\\n return result\",\n \"def read_args():\\r\\n global args\\r\\n parser = argparse.ArgumentParser(\\r\\n description='Executes create, list-nodes, list-all, execute, backup, list-backups and rollback tasks on AWS '\\r\\n 'system')\\r\\n\\r\\n # What the code will do? The actions...\\r\\n parser.add_argument('action', help='Type of work', choices=[\\\"create\\\", \\\"list-nodes\\\", \\\"list-all\\\", \\\"execute\\\", \\\"backup\\\",\\r\\n \\\"list-backups\\\", \\\"roll-back\\\", \\\"terminate-all\\\"])\\r\\n parser.add_argument('--customer-id', help='Shows customer ID', required=False)\\r\\n parser.add_argument('--node-type', help='Shows node type, values can be \\\"Manager\\\" or \\\"Peer\\\"',\\r\\n choices=[\\\"Manager\\\", \\\"Peer\\\"], required=False)\\r\\n parser.add_argument('--script', help='Shows the script that will be executed on Aws instance', required=False)\\r\\n parser.add_argument('--node-id', help='Shows node (Instance) ID on AWS', required=False)\\r\\n parser.add_argument('--backup-id', help='Shows snapshot ID on AWS', required=False)\\r\\n\\r\\n args = parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Bandits algorithms on a click-through \\\"\\n \\\"rate dataset.\\\")\\n parser.add_argument('--plot', action='store_true')\\n return parser.parse_args()\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser()\\n\\n subparsers = parser.add_subparsers(dest='operation',\\n help='Run AtPKI {command} -h for additional help')\\n\\n parse_bin_parser = subparsers.add_parser(\\\"parse_bin\\\",\\n help=\\\"parse generated PKI bin\\\")\\n parse_bin_parser.add_argument(\\\"--bin_file\\\", \\\"-b\\\", default=\\\"PKI.bin\\\",\\n help=\\\"bin_file which need to be parsed\\\")\\n parse_bin_parser.add_argument(\\\"--output_path\\\", \\\"-o\\\",\\n help=\\\"output path of parsed bin file in from_bytes mode\\\")\\n\\n generate_bin_parser = subparsers.add_parser(\\\"generate_bin\\\",\\n help=\\\"create PKI bin\\\")\\n generate_bin_parser.add_argument(\\\"--bin_file\\\", \\\"-b\\\", default=\\\"PKI.bin\\\",\\n help=\\\"bin_file which need to be parsed\\\")\\n generate_bin_parser.add_argument('pki_list', metavar='<type> <file>',\\n help='type (ca, cert, key,)'\\n ' and file, separated by space',\\n action=PKIPairAction)\\n\\n args = parser.parse_args()\\n return args\",\n \"def get_args():\\n parser = argparse.ArgumentParser(\\n description = \\\"Make consensus taxonomy out of a usearch tophits map\\\")\\n # Add arguments\\n parser.add_argument(\\\"input\\\",\\n help = \\\"input file in usearch's UC format.\\\")\\n parser.add_argument(\\\"-t\\\",\\n \\\"--tax_separator\\\",\\n help = \\\"character separating taxonomic levels.\\\",\\n required = True)\\n parser.add_argument(\\\"-s\\\",\\n \\\"--tax_sense\\\",\\n choices = ['asc', 'desc'],\\n help = \\\"sense of taxonomic levels in your database. 'asc' for lower to higher levels (e.g. ID_Diatomea_Stramenopiles_SAR_Eukaryota), 'desc' for higher to lower levels (e.g. Eukaryota_SAR_Stramenopiles_Diatomea_ID).\\\",\\n required = True)\\n parser.add_argument(\\\"-p\\\",\\n \\\"--pair_separator\\\",\\n help = \\\"pair (forward & reverse) character separator. Use this argument to remove redundancies from your dataset (i.e. reads that are represented for both forward and reverse pairs).\\\",\\n required = False,\\n default = None)\\n parser.add_argument(\\\"-o\\\",\\n \\\"--output_file\\\",\\n help = \\\"path to output file where filtered map should be written. It defaults to `filtered_map.uc`\\\",\\n required = False,\\n default = 'filtered_map.uc')\\n # Array for all arguments passed to script\\n args = parser.parse_args()\\n # Assign args to variables\\n input = args.input\\n tax_separator = args.tax_separator\\n tax_sense = args.tax_sense\\n pair_separator = args.pair_separator\\n outfile = args.output_file\\n # Return all variable values\\n return input, tax_separator, tax_sense, pair_separator, outfile\",\n \"def parseCommandLine(argv):\\n parameters = {}\\n for p in argv[1:]: # skip 0th element (module name)\\n pair = split(p, '=', 1)\\n if (2 != len(pair)):\\n print 'bad parameter: %s (had no equals sign for pairing)' % p\\n sys.exit()\\n else:\\n parameters[pair[0]] = pair[1]\\n return parameters\",\n \"def get_action_args(self, request_environment):\\n args = {}\\n if request_environment['PATH_INFO'] == '/':\\n args['action'] = 'index'\\n else:\\n args['action'] = 'multi'\\n\\n return args\",\n \"def parse_args(args):\\n retv = dict()\\n\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument(\\n '--version',\\n action='version',\\n version='$scriptname {ver}'.format(ver=__version__))\\n\\n parser.add_argument(\\n '-w',\\n '--write',\\n action='store_true',\\n help=\\\"write the file\\\")\\n\\n parser.add_argument(\\n '-d',\\n '--description',\\n help=\\\"description of the script\\\")\\n\\n parser.add_argument(\\n '-t',\\n '--templates',\\n dest='tdirs',\\n action='append',\\n help=\\\"location of the templates\\\")\\n\\n parser.add_argument('scriptpath', nargs='*')\\n\\n opts = vars(parser.parse_args(args))\\n\\n for keyn, keyv in opts.items():\\n if keyv is not None:\\n retv[keyn] = keyv\\n\\n retv['scriptpath'] = \\\" \\\".join(retv['scriptpath'])\\n retv['scriptname'] = os.path.basename(retv['scriptpath'])\\n if 'write' not in retv:\\n retv['write'] = False\\n\\n return retv\",\n \"def get_input_args():\\r\\n parser = argparse.ArgumentParser()\\r\\n parser.add_argument(\\\"image_path\\\", help= \\\"Path to image\\\", type=str)\\r\\n parser.add_argument(\\\"checkpoint\\\", help= \\\"path to checkpoint\\\", default=\\\"checkpoint.pth\\\", type=str)\\r\\n parser.add_argument(\\\"--top_k\\\", help= \\\"top k classes of image\\\", default=5, type=int)\\r\\n parser.add_argument('--category_names', type=str, default='cat_to_name.json')\\r\\n parser.add_argument('--gpu', dest='gpu', action='store_true', default = False)\\r\\n \\r\\n return parser.parse_args()\",\n \"def parse_args(self, argv=None):\\n return vars(self.parser.parse_args(argv))\",\n \"def parse_args(args=None):\\n return AP.parse_args(args=args)\",\n \"def analyze_args(self, args):\\n args_obj = args.__dict__\\n if args_obj.get('add'):\\n action = 'bc'\\n params = args_obj['add']\\n\\n elif args_obj.get('prime'):\\n action = 'prime'\\n params = args_obj['prime']\\n else:\\n print \\\"Invalid Arguments...\\\"\\n sys.exit(0)\\n\\n params_check = self.validate_params(params)\\n if params_check is True:\\n parsed_args = dict(action=action,\\n params=map(int, params))\\n return parsed_args\",\n \"def parse_args():\\r\\n parser = argparse.ArgumentParser(description=\\\"Available Options\\\")\\r\\n\\r\\n parser.add_argument('-i'\\r\\n ,'--input_path'\\r\\n ,dest='input_path'\\r\\n ,type=is_valid_path\\r\\n ,required=True\\r\\n ,help = \\\"Enter the path of the image file to process\\\")\\r\\n\\r\\n args = vars(parser.parse_args())\\r\\n\\r\\n #To Display The Command Line Arguments\\r\\n print(\\\"## Command Arguments #################################################\\\")\\r\\n print(\\\"\\\\n\\\".join(\\\"{}:{}\\\".format(i,j) for i,j in args.items()))\\r\\n print(\\\"######################################################################\\\")\\r\\n\\r\\n return args\",\n \"def map_arguments():\\n arguments = {\\n '-c': 'ogg',\\n '-d': 'no',\\n '-q': '4'\\n }\\n args = sys.argv[:]\\n args.pop(0)\\n while len(args) > 1:\\n if args[0] == '-c' and re.search('^mp3$|^ogg$', args[1]) or \\\\\\n args[0] == '-d' and re.search('^y(es)?$', args[1]) or \\\\\\n args[0] == '-q' and re.search('^[0-9]$', args[1]):\\n arguments[args[0]] = args[1]\\n args.pop(0)\\n args.pop(0)\\n else:\\n print_help()\\n if len(args) == 1:\\n print_help()\\n return arguments\",\n \"def parse_args(args):\\n if len(args) == 1:\\n return {}\",\n \"def parse_arguments(self,parser):\\r\\n return parser.parse_args()\",\n \"def parse_args():\\n import argparse\\n\\n parser = argparse.ArgumentParser(description=\\\"Pilot kodi\\\")\\n parser.add_argument(\\\"--server\\\",\\\"-s\\\",metavar=\\\"SERVER\\\",required=True,help=\\\"Server to connect to\\\")\\n parser.add_argument(\\\"--port\\\",\\\"-p\\\",metavar=\\\"PORT\\\",default=8080,type=int,help=\\\"Port of the server\\\")\\n parser.add_argument(\\\"--get-audio\\\",action=\\\"store_true\\\",help=\\\"Get audio\\\")\\n parser.add_argument(\\\"--switch-audio\\\",action=\\\"store_true\\\",help=\\\"Switch Audio\\\")\\n parser.add_argument(\\\"--valid-audios\\\",metavar=\\\"SUBTITLE\\\",default=[\\\"fre\\\",\\\"eng\\\"],type=lambda p:p.split(\\\",\\\"),help=\\\"Valid audios\\\")\\n parser.add_argument(\\\"--get-subtitle\\\",action=\\\"store_true\\\",help=\\\"Get subtitle\\\")\\n parser.add_argument(\\\"--toggle-subtitle\\\",action=\\\"store_true\\\",help=\\\"Toggle subtitles\\\")\\n parser.add_argument(\\\"--switch-subtitles\\\",action=\\\"store_true\\\",help=\\\"Switch subtitles\\\")\\n parser.add_argument(\\\"--valid-subtitles\\\",metavar=\\\"SUBTITLE\\\",default=[\\\"fre\\\"],type=lambda p:p.split(\\\",\\\"),help=\\\"Valid subtitles\\\")\\n\\n return parser.parse_args()\",\n \"def parse_known_args(argv):\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n '--input',\\n dest='input',\\n required=True,\\n help='Path to the text file containing image names.')\\n parser.add_argument(\\n '--output',\\n dest='output',\\n required=True,\\n help='Path where to save output predictions.'\\n ' text file.')\\n parser.add_argument(\\n '--model_state_dict_path',\\n dest='model_state_dict_path',\\n required=True,\\n help=\\\"Path to the model's state_dict. \\\"\\n \\\"Default state_dict would be maskrcnn_resnet50_fpn.\\\")\\n parser.add_argument(\\n '--images_dir',\\n help='Path to the directory where images are stored.'\\n 'Not required if image names in the input file have absolute path.')\\n return parser.parse_known_args(argv)\",\n \"def parse_cmd_arguments():\\n parser = argparse.ArgumentParser(description='Process some integers.')\\n parser.add_argument('-i', '--input', required=True, help='input JSON file')\\n parser.add_argument('-o', '--output', required=True,\\n help='ouput JSON file')\\n parser.add_argument('-d', '--debug', required=False,\\n help='log level. Can be 0-3. Defaults to 0')\\n\\n return parser.parse_args()\",\n \"def parse_generate_arguments(arguments):\\n return_value = {}\\n for key in arguments:\\n return_value[key] = CONFIG_KEY_PARSER[key](arguments[key])\\n\\n return return_value\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"\\\"\\\"\\n Generates json files with all the combinations of\\n hyperparameter values from a configuratio file.\\n \\\"\\\"\\\")\\n\\n parser.add_argument('outdir', help='output directory')\\n parser.add_argument('config', help='configuration file')\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser(description='Disk metric sender')\\n parser.add_argument('-v', '--verbose', action='store_true', default=None, help='Verbose?')\\n parser.add_argument('--debug', action='store_true', default=None, help='Debug?')\\n\\n return parser.parse_args()\",\n \"def parse_args(self, argv):\\n\\t\\tself.argv={'user': argv[1]}\",\n \"def parse_args(argv: Sequence[str]) -> argparse.Namespace:\\n parser = argparse.ArgumentParser(\\n prog='flagman',\\n description='Perform arbitrary actions on signals.',\\n epilog=EPILOG_TEXT,\\n formatter_class=argparse.RawTextHelpFormatter,\\n )\\n parser.add_argument(\\n '--list', '-l', action='store_true', help='list known actions and exit'\\n )\\n for signum in HANDLED_SIGNALS:\\n name = signum.name\\n parser.add_argument(\\n '--{}'.format(name[3:].lower()),\\n action='append',\\n nargs='+',\\n default=[],\\n help='add an action for {}'.format(name),\\n metavar=('ACTION', 'ARGUMENT'),\\n )\\n parser.add_argument(\\n '--successful-empty',\\n action='store_false',\\n help='if all actions are removed, exit with 0 instead of the default 1',\\n )\\n parser.add_argument(\\n '--no-systemd', action='store_false', help='do not notify systemd about status'\\n )\\n parser.add_argument(\\n '--quiet',\\n '-q',\\n action='store_true',\\n help='only output critial messages; overrides `--verbose`',\\n )\\n parser.add_argument(\\n '--verbose',\\n '-v',\\n action='count',\\n default=0,\\n help='increase the loglevel; pass multiple times for more verbosity',\\n )\\n\\n return parser.parse_args(argv[1:])\",\n \"def parseArguments():\\n parser = argparse.ArgumentParser(description=\\\"AutoMacTC: an Automated macOS forensic triage collection framework.\\\", add_help=False)\\n\\n module_filter = parser.add_argument_group('module filter')\\n mods = module_filter.add_mutually_exclusive_group(required=False)\\n mods.add_argument('-m', '--include_modules', type=str, nargs='+', help='module(s) to use, use \\\"all\\\" to run all modules, space separated list only', default=[''], required=False)\\n mods.add_argument('-x', '--exclude_modules', type=str, nargs='+', help='assumes you want to run all modules EXCEPT those specified here, space separated list only', default=[''], required=False)\\n mods.add_argument('-l', '--list_modules', help='if flag is provided, will list available modules and exit.', default=False, action='store_true', required=False)\\n\\n general = parser.add_argument_group('general arguments')\\n general.add_argument(\\\"-h\\\", \\\"--help\\\", action=\\\"help\\\", help=\\\"show this help message and exit\\\")\\n general.add_argument(\\\"-v\\\", \\\"--verbose\\\", default=False, action='store_true', help=\\\"enable verbose logging\\\")\\n general.add_argument('-i', '--inputdir', default='/', help='input directory; mount dmg with mountdmg.sh script and use -f to analyze mounted HFS or APFS Volume, use volume appended with \\\"Data\\\" (e.g. \\\"Macintosh HD - Data\\\") for 10.15+ systems', required=False)\\n general.add_argument('-is', '--inputsysdir', default='', help='input system drive if using mounted drive from 10.15+ system (e.g. \\\"Macintosh HD\\\")', required=False)\\n general.add_argument('-o', '--outputdir', default='./', help='output directory', required=False)\\n general.add_argument('-p', '--prefix', help='prefix to append to tarball and/or output files', default='automactc-output', required=False)\\n general.add_argument('-f', '--forensic_mode', help='if flag is provided, will analyze mounted volume provided as inputdir', default=False, action='store_true', required=False)\\n general.add_argument('-nt', '--no_tarball', help='if flag is provided, will NOT package output files into tarball', default=False, action='store_true', required=False)\\n general.add_argument('-nl', '--no_logfile', help='if flag is provided, will NOT generate logfile on disk', default=False, action='store_true', required=False)\\n general.add_argument('-fmt', '--output_format', help='toggle between csv and json output, defaults to csv', default='csv', action='store', required=False, choices=['csv', 'json'])\\n general.add_argument('-np', '--no_low_priority', help='if flag is provided, will NOT run automactc with highest niceness (lowest CPU priority). high niceness is default', default=False, action='store_true', required=False)\\n general.add_argument('-b', '--multiprocessing', help='if flag is provided, WILL multiprocess modules [WARNING: Experimental!]', default=False, action='store_true', required=False)\\n general.add_argument('-O', '--override_mount', help='if flag is provided, WILL bypass error where inputdir does not contain expected subdirs', default=False, action='store_true', required=False)\\n\\n console_log_args = parser.add_argument_group('console logging verbosity')\\n console_logging_args = console_log_args.add_mutually_exclusive_group(required=False)\\n console_logging_args.add_argument('-q', '--quiet', help='if flag is provided, will NOT output to console at all', default=False, action='store_true', required=False)\\n console_logging_args.add_argument('-r', '--rtr', help='reduce verbosity to display nicely on RTR console', default=False, action='store_true', required=False)\\n console_logging_args.add_argument('-d', '--debug', help='enable debug logging to console', default=False, action='store_true', required=False)\\n\\n dirlist_args = parser.add_argument_group('specific module arguments')\\n dirlist_args.add_argument('-K', '--dir_include_dirs', type=str, nargs='+', help='directory inclusion filter for dirlist module, defaults to volume root, space separated list only', default=[''], required=False)\\n dirlist_args.add_argument('-E', '--dir_exclude_dirs', type=str, nargs='+', help='directory and file exclusion filter for dirlist module. defaults are specified in README. space separated list only. \\\\\\n put \\\\'no-defaults\\\\' as first item to overwrite default exclusions and then provide your own exclusions', default=[''], required=False)\\n dirlist_args.add_argument('-H', '--dir_hash_alg', nargs='+', help='either sha256 or md5 or both or none, at least one is recommended, defaults to sha256. also applies to autoruns module', default='sha256', required=False)\\n dirlist_args.add_argument('-S', '--dir_hash_size_limit', type=int, help='file size filter for which files to hash, in megabytes, defaults to 10MB. also applies to autoruns module', default=10, required=False)\\n dirlist_args.add_argument('-R', '--dir_recurse_bundles', help='will fully recurse app bundles if flag is provided. this takes much more time and space', default=False, action='store_true', required=False)\\n dirlist_args.add_argument('-NC', '--dir_no_code_signatures', help='if flag is provided, will NOT check code signatures for app and kext files. also applies to autoruns module', default=False, action='store_true', required=False)\\n dirlist_args.add_argument('-NM', '--dir_no_multithreading', help='if flag is provided, will NOT multithread the dirlist module', default=False, action='store_true', required=False)\\n args = parser.parse_args()\\n\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description='Convert CVAT XML annotations to YOLO format'\\n )\\n\\n parser.add_argument(\\n '--cvat-xml', metavar='FILE', required=True,\\n help='input file with CVAT annotation in xml format'\\n )\\n\\n parser.add_argument(\\n '--image-dir', metavar='DIRECTORY', required=False,\\n help='directory which contains original images'\\n )\\n\\n parser.add_argument(\\n '--output-dir', metavar='DIRECTORY', required=True,\\n help='directory for output annotations in YOLO format'\\n )\\n\\n parser.add_argument(\\n '--username', metavar='USERNAME', required=False,\\n help='Username from CVAT Login page, required to download images'\\n )\\n\\n parser.add_argument(\\n '--password', metavar='PASSWORD', required=False,\\n help='Password from CVAT Login page, required to download images'\\n )\\n\\n parser.add_argument(\\n '--labels', metavar='ILABELS', required=False,\\n help='Labels (separated by comma) to extract. Example: car,truck,motorcycle'\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n fromfile_prefix_chars='@',\\n description='Convert CVAT XML annotations to masks'\\n )\\n\\n parser.add_argument(\\n '--cvat-xml', metavar='FILE', required=True,\\n help='input file with CVAT annotation in xml format'\\n )\\n\\n parser.add_argument(\\n '--background-color', metavar='COLOR_BGR', default=\\\"0,0,0\\\",\\n help='specify background color (by default: 0,0,0)'\\n )\\n\\n parser.add_argument(\\n '--label-color', metavar='LABEL:COLOR_BGR', action='append',\\n default=[],\\n help=\\\"specify a label's color (e.g. 255 or 255,0,0). The color will \\\" +\\n \\\"be interpreted in accordance with the mask format.\\\"\\n )\\n\\n parser.add_argument(\\n '--mask-bitness', type=int, choices=[8, 24], default=8,\\n help='choose bitness for masks'\\n )\\n\\n parser.add_argument(\\n '--output-dir', metavar='DIRECTORY', required=True,\\n help='directory for output masks'\\n )\\n\\n return parser.parse_args()\",\n \"def Args(parser):\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-u', '--urls_dirpath', type=unicode)\\n parser.add_argument('-r', '--resources_dir', type=unicode)\\n parser.add_argument('-t', '--total_docs', type=int)\\n parser.add_argument('-m', '--mapping', type=unicode,\\n help='File with the yago to lkif mapping')\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = default_argument_parser()\\n parser.add_argument(\\\"--label-map\\\",\\n dest=\\\"label_map\\\",\\n type=pathlib.Path,\\n help=\\\"Label map in YAML format which maps from category \\\"\\n \\\"ID to name.\\\")\\n parser.add_argument(\\\"--train-csv\\\",\\n dest=\\\"train_csv\\\",\\n required=True,\\n type=pathlib.Path,\\n help=\\\"Path to training data CSV file.\\\")\\n parser.add_argument(\\\"--valid-csv\\\",\\n dest=\\\"valid_csv\\\",\\n required=False,\\n type=pathlib.Path,\\n help=\\\"Optional path to validation data CSV file.\\\")\\n parser.add_argument(\\n \\\"--image-width\\\",\\n type=int,\\n help=\\\"Image width (optional, used to speed up dataset processing).\\\")\\n parser.add_argument(\\n \\\"--image-height\\\",\\n type=int,\\n help=\\\"Image height (optional, used to speed up dataset processing).\\\")\\n return parser.parse_args()\",\n \"def parse_arguments():\\n parser = ArgumentParser()\\n\\n # For development/testing\\n parser.add_argument(\\\"--dev\\\", help=\\\"run the code of the developers tag\\\")\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n from argparse import ArgumentParser\\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\\n ap.add_argument('session', help='Session Label')\\n ap.add_argument('-sd', '--subjects_dir', help='Subjects Dir',\\n default='/tmp')\\n return ap.parse_args()\",\n \"def parse_args():\\n help_text = \\\"\\\"\\\"\\n Analyzer of the frequency of use of nouns in the headings of posts on hubr.com\\n \\\"\\\"\\\"\\n parser = argparse.ArgumentParser(\\n description=help_text\\n )\\n parser.add_argument(\\n '-p',\\n '--pages',\\n type=int,\\n dest='page_count',\\n default=PAGE_COUNT,\\n help=f'Number of pages to parse, default is {PAGE_COUNT}.'\\n )\\n parser.add_argument(\\n '-s',\\n '--start',\\n type=int,\\n default=PAGE_START,\\n dest='start_page',\\n help=f'Start page number, default is {PAGE_START}.',\\n )\\n parser.add_argument(\\n '-t',\\n '--top',\\n type=int,\\n default=TOP_SIZE,\\n dest='top_size',\\n help=f'The size of the top noun, default is {TOP_SIZE}.',\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-i\\\", \\\"--input_path\\\", required=True)\\n parser.add_argument(\\\"-c\\\", \\\"--config\\\", required=True)\\n return parser.parse_args()\",\n \"def parse_args(args):\\n parser = argparse.ArgumentParser(\\n description=\\\"Lookup table generator for Image Comparison\\\")\\n parser.add_argument(\\n \\\"--version\\\",\\n action=\\\"version\\\",\\n version=\\\"lookuptable {ver}\\\".format(ver=__version__))\\n parser.add_argument(\\n \\\"-f\\\",\\n \\\"--folder\\\",\\n dest=\\\"imagefolder\\\",\\n help=\\\"path to image folder\\\",\\n type=str,\\n metavar=\\\"STRING\\\")\\n parser.add_argument(\\n \\\"-v\\\",\\n \\\"--verbose\\\",\\n dest=\\\"loglevel\\\",\\n help=\\\"set loglevel to INFO\\\",\\n action=\\\"store_const\\\",\\n const=logging.INFO)\\n parser.add_argument(\\n \\\"-vv\\\",\\n \\\"--very-verbose\\\",\\n dest=\\\"loglevel\\\",\\n help=\\\"set loglevel to DEBUG\\\",\\n action=\\\"store_const\\\",\\n const=logging.DEBUG)\\n return parser.parse_args(args)\",\n \"def parse_args():\\n from argparse import ArgumentParser\\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\\n ap.add_argument(\\n '--host', dest='host', default=None,\\n help='Host for XNAT. Default: env XNAT_HOST.')\\n ap.add_argument(\\n '-u', '--username', dest='username', default=None,\\n help='Username for XNAT.')\\n ap.add_argument('project', help='Project Label')\\n ap.add_argument('session', help='Session Label')\\n ap.add_argument(\\n 'proc_suffix', help='Proc name suffix', nargs='?', default='')\\n ap.add_argument(\\n '-sd', '--subjects_dir', dest='subjects_dir',\\n help='Subjects Directory',\\n default=os.environ.get('SUBJECTS_DIR', '/tmp'))\\n return ap.parse_args()\",\n \"def parsed_args():\\n parser = ArgumentParser()\\n parser.add_argument(\\n \\\"--input_csv\\\",\\n default=\\\"bios.csv\\\",\\n type=str,\\n help=\\\"CSV containing the info from the form\\\",\\n )\\n parser.add_argument(\\n \\\"--output_yml\\\",\\n default=\\\"bios.yml\\\",\\n type=str,\\n help=\\\"Output YAML file\\\",\\n )\\n parser.add_argument(\\n \\\"--output_photos\\\",\\n default=\\\"./assets/img/team/team-photos\\\",\\n type=str,\\n help=\\\"List of photos URL\\\",\\n )\\n\\n return parser.parse_args()\",\n \"def parse(argv: Sequence[str],\\n generator_factory: pagegenerators.GeneratorFactory\\n ) -> ARGS_TYPE:\\n args = dict(DEFAULT_ARGS)\\n argv = pywikibot.handle_args(argv)\\n argv = generator_factory.handle_args(argv)\\n\\n for arg in argv:\\n option, _, value = arg.partition(':')\\n\\n if not value and option in ARG_PROMPT:\\n value = pywikibot.input(ARG_PROMPT[option])\\n\\n if option in ('-text', '-textfile', '-summary'):\\n args[option[1:]] = value\\n elif option in ('-up', '-always', '-create', '-createonly'):\\n args[option[1:]] = True\\n elif option in ('-talk', '-talkpage'):\\n args['talk_page'] = True\\n elif option == '-noreorder':\\n args['reorder'] = False\\n elif option == '-excepturl':\\n args['regex_skip_url'] = value\\n elif option == '-major':\\n args['minor'] = False\\n else:\\n raise ValueError(f\\\"Argument '{option}' is unrecognized\\\")\\n\\n if not args['text'] and not args['textfile']:\\n raise ValueError(\\\"Either the '-text' or '-textfile' is required\\\")\\n\\n if args['text'] and args['textfile']:\\n raise ValueError(\\\"'-text' and '-textfile' cannot both be used\\\")\\n\\n return args\",\n \"def _parse_arg_list(self):\\n\\t\\targ_list = {}\\n\\t\\tfor arg in getopt.getopt(sys.argv[1:], 'c:r:j:d')[0]:\\n\\t\\t\\targ_list[arg[0][1:]] = arg[1]\\n\\t\\n\\t\\treturn arg_list\",\n \"def parse_cmdline(argv):\\n\\n parser = argparse.ArgumentParser(description='Print information about probable hung attempts')\\n parser.add_argument('--des_services', action='store', help='')\\n parser.add_argument('--section', action='store',\\n help='Must be specified if not set in environment')\\n parser.add_argument('--days', action='store', default=7, help='finished in last X days')\\n parser.add_argument('--file', action='store')\\n\\n args = vars(parser.parse_args(argv)) # convert to dict\\n\\n return args\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description='A json parser with filters')\\n parser.add_argument('-f', '--filename', help='The Json file to parse')\\n parser.add_argument('-v', '--verbosity', action='count', default=0,\\n help='Increase verbosity of console log')\\n parser.add_argument('-o', '--outfile', type=str, help='File to output to')\\n parser.add_argument('-i', '--indent', type=int, default=4,\\n help='Number of spaces to indent')\\n parser.add_argument('-k', '--keyfilter',\\n help=('Key filter for the json output separated by \\\".\\\"'\\n 'page.module.element.note, use partial string'\\n ' or * for all'))\\n parser.add_argument('-d', '--datafilter', type=str,\\n help=('Data Value filter of the key:value pair. '\\n 'NOTE: keyfiltering occurs first.'))\\n args = parser.parse_args()\\n return args\",\n \"def _parse_args():\\n parser = argparse.ArgumentParser(description='Run DAFI.')\\n parser.add_argument('input_file', help='Name (path) of input file')\\n return parser.parse_args()\",\n \"def parse_args():\\n sentinel_dict = {}\\n\\n def _preprocess_sysargv(argv):\\n inputs = []\\n for arg in argv[1:]:\\n # handles case where values contain --, otherwise they will\\n # be interpreted as arguments.\\n if '--,' in arg or ',--' in arg or arg == '--':\\n sentinel = uuid4().hex\\n key = '%s' % sentinel\\n sentinel_dict[key] = arg\\n inputs.append(sentinel)\\n else:\\n inputs.append(arg)\\n return inputs\\n\\n def _postprocess_sysargv(v):\\n if v in sentinel_dict:\\n return sentinel_dict.get(v)\\n else:\\n return v\\n\\n #----- read input arguments\\n for i, arg in enumerate(sys.argv):\\n if (arg[0] == '-') and arg[1].isdigit(): sys.argv[i] = ' ' + arg\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument('-u', action='store_true', dest='helpmenu',help='extended HELP MENU with examples')\\n parser.add_argument('-i','--infile',action='store', dest='infile',help='name of file with SAC or mseed file(s)')\\n parser.add_argument('-g','--gain',action='store', dest='sensitivity',help='Stage 0 sensitivity')\\n parser.add_argument('-N','--net', action='store', dest='network',help='network')\\n parser.add_argument('-S','--sta', action='store', dest='station',help='station')\\n parser.add_argument('-C','--cha', action='store', dest='chantype',help='chantype')\\n parser.add_argument('-s','--start', action='store', dest='startstring',help='start time YYYY-MM-DDTHH:MM:SS')\\n parser.add_argument('-e','--end', action='store', dest='endstring',help='end time YYYY-MM-DDTHH:MM:SS')\\n parser.add_argument('-d','--duration', action='store', dest='durationinhours',help='duration in hours')\\n parser.add_argument('-dc','--dc','--datacenter', action='store', dest='datacenter',default='IRIS',help='FDSN data center (e.g. IRIS, SCEDC, NCEDC)')\\n parser.add_argument('-p','--plot',action='store_true',dest='iplot',help='make plots of each hourly trace (NOTE: can be slow)')\\n\\n helpextended = parser.parse_args(_preprocess_sysargv(sys.argv)).helpmenu\\n if ( helpextended is True ):\\n print ('')\\n print ('portable_pip_squeak: assess a station either using local data or to be downloaded')\\n print ('')\\n print ('Usage: portable_pip_squeak.py [options]')\\n print ('')\\n print ('EXAMPLES:')\\n print ('portable_pip_squeak.py --infile my_SAC_files.txt')\\n print ('portable_pip_squeak.py -N UW -S TKEY -C HH -s 2018-01-01T00:00:00 -d 2 -p')\\n print ('portable_pip_squeak.py -N CI -S LEO -C HN -s 2020-01-01T00:00:00 -d 24 -dc SCEDC')\\n print ('')\\n print ('Inputs if supplying your own data:')\\n print (' -i, --infile Name of text file with SAC/mseed file(s) of 3 (Z,N,E) traces.')\\n print (' -g, --gain Gain or Stage 0 sensitivity')\\n print (' ')\\n print ('Inputs if downloading data:')\\n print (' -s, --starttime Trace start time (YYYY-MM-DD,HH:MM:SS)')\\n print ('')\\n print (' One of these:')\\n print (' -e, --endtime Trace end time (YYYY-MM-DD,HH:MM:SS)')\\n print (' -d, --duration Duration in hours from starttime')\\n print (' Note: if duration is neg, starttime becomes endtime')\\n print (' N, S, C and a datacenter if other than IRIS')\\n print (' -N, --net Network code')\\n print (' -S, --sta Station code')\\n print (' -C, --cha Channel type, e.g. EN or HH')\\n print (' -dc, --datacenter Name of FDSN data center if not IRIS, e.g. SCEDC, NCEDC')\\n print (' ')\\n print ('Optional flags:')\\n print ('-P, --plot Flag to make a figure for each hour. Note: can be slow.')\\n print ('-u Print this extended help menu')\\n print ('')\\n\\n\\n return parser.parse_args(_preprocess_sysargv(sys.argv))\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description='Aggregate Elasticsearch Log data.')\\n parser.add_argument(\\n '--host',\\n default='https://logging-es',\\n type=str,\\n action='store',\\n help='Host name or IP of the Elasticsearch server.'\\n )\\n parser.add_argument(\\n '--port',\\n default=9200,\\n type=int,\\n action='store',\\n help='Port number of the Elasticsearch server.'\\n )\\n parser.add_argument(\\n '--ca_certs',\\n default='secret/admin-ca',\\n type=str,\\n action='store',\\n help='Path to the CA certificates file'\\n )\\n parser.add_argument(\\n '--cert',\\n default='secret/admin-cert',\\n type=str,\\n action='store',\\n help='Path to the client certificate file'\\n )\\n parser.add_argument(\\n '--key',\\n default='secret/admin-key',\\n type=str,\\n action='store',\\n help='Path to the client key file'\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"\\\")\\n parser.add_argument(\\n \\\"config_path\\\",\\n type=str,\\n help=\\\"Path to the JSON configuration file containing the image transformation settings.\\\",\\n )\\n parser.add_argument(\\n \\\"img_path\\\",\\n type=str,\\n help=\\\"Path to the input image file to apply transformations.\\\",\\n )\\n return parser.parse_args()\",\n \"def parse():\\n\\n args = sys.argv\\n if os.name == 'nt' and args and 'python' in os.path.basename(args[0]).lower():\\n args = args[2:]\\n else:\\n args = args[1:]\\n args = vars(parser.parse_args(args))\\n \\n # set the global verbosity level of the script\\n script.set_verbosity(args['verbosity']) \\n \\n return args\",\n \"def ParseArgs() -> argparse.Namespace:\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument(\\n '--input', dest='input', help='Japanese phonetic reading file')\\n parser.add_argument(\\n '--output_token_array',\\n dest='output_token_array',\\n help='Output token array file.')\\n parser.add_argument(\\n '--output_string_array',\\n dest='output_string_array',\\n help='Output string array file.')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Reads datapacket pcds, interpolates quaternions and generates scans from dataset in config file\\\")\\n parser.add_argument(\\\"--visualization\\\", \\\"-v\\\", action=\\\"store_true\\\", help=\\\"if generated clouds should be visualized\\\")\\n parser.add_argument(\\\"--directory\\\", \\\"-d\\\",\\n help=\\\"if only specified directory should be interpolated, e.g. 'fragments/fragment0'\\\")\\n args = parser.parse_args()\\n return args.visualization, args.directory\",\n \"def parse_args():\\n usage = (\\\"Usage: python driver.py k-number-of-output-colors \\\"\\n \\\"{kmeans, kmeans++} /path/to/image.jpg\\\")\\n assert len(sys.argv) >= 2, \\\"Too few arguements. \\\" + usage\\n\\n # Determine k\\n assert sys.argv[1].isdigit(), (\\\"k-number-of-output-colors needs to be a \\\"\\n \\\"digit. \\\" + usage)\\n k = int(sys.argv[1])\\n\\n # Determine algorithm type (optional input)\\n try:\\n assert sys.argv[2] in {\\\"kmeans\\\", \\\"kmeans++\\\"}, (\\\"Invalid algorithm \\\"\\n \\\"type. \\\" + usage)\\n algorithm_type = sys.argv[2]\\n except IndexError:\\n print \\\"No algorithm type given in args; using default algorithm 'kmeans'\\\"\\n algorithm_type = \\\"kmeans\\\"\\n \\n # Determine image path (optional input)\\n try:\\n img_path = sys.argv[3]\\n except IndexError:\\n print \\\"No image path given in args; using default image './park.jpg'\\\"\\n img_path = \\\"./park.jpg\\\"\\n\\n return k, algorithm_type, img_path\",\n \"def parse_arguments(args: List[Dict]) -> 'Dict[str, Argument]':\\n if not args:\\n return {}\\n result = {}\\n for a in args:\\n if not a:\\n continue\\n arg = Argument(a)\\n result[arg.name] = arg\\n return result\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=app_description,\\n formatter_class=argparse.RawTextHelpFormatter)\\n parser.add_argument(\\\"--input-json\\\", dest=\\\"input_json_path\\\", required=True,\\n help=input_json_help)\\n\\n args = parser.parse_args()\\n return args\",\n \"def parse_args(argv):\\n formatter_class = argparse.RawDescriptionHelpFormatter\\n parser = argparse.ArgumentParser(description=\\\"Run torrent-knowledge cli\\\",\\n formatter_class=formatter_class)\\n\\n parser.add_argument(\\\"-i\\\", \\\"--input_file\\\",\\n type=argparse.FileType('r'),\\n required=True,\\n help=\\\"CSV with torrents in format 'info_hash|torrent_title'\\\")\\n\\n parser.add_argument(\\\"-o\\\", \\\"--output_file\\\",\\n required=True,\\n type=argparse.FileType('w'),\\n default=sys.stdout)\\n\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\", dest=\\\"verbose\\\",\\n action=\\\"count\\\", default=0,\\n help=\\\"increase log verbosity via -vvv\\\")\\n\\n parser.add_argument(\\\"-t\\\", \\\"--train-mode\\\", dest=\\\"train_mode\\\",\\n action=\\\"count\\\", default=0,\\n help=\\\"update features frequency from dataset\\\")\\n\\n parser.add_argument(\\\"-l\\\", \\\"--log-dir\\\", dest=\\\"log_dir\\\",\\n action=\\\"store\\\", default=None,\\n help=\\\"directory for log files (only for -vvv mode)\\\")\\n\\n args = parser.parse_args(argv[1:])\\n\\n if args.log_dir and args.verbose != 3:\\n logger.debug(\\\"You should use -vvv with option -l\\\")\\n exit(-1)\\n\\n return parser.parse_args(argv[1:])\",\n \"def parse_args(argparser_args):\\n return {k: v for k, v in vars(argparser_args).items() if v is not None}\",\n \"def get_arguments():\\n\\tparser.add_argument('-i', '--interface', help='interface to affect')\\n\\tparser.add_argument('-m','--mac', help='mac to allocate')\\n\\n\\targs = parser.parse_args()\\n\\tinterface = args.interface\\n\\tmac = args.mac\\n\\treturn (interface, mac)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='Crawl an Android app store for apk files.')\\n parser.add_argument('--store', dest='api', choices=['GooglePlay', 'F-Droid'], required=True,\\n help='Specifies the store to crawl. At the moment only Google Play is supported.')\\n parser.add_argument('--meta', dest='meta', required=False, action='store_const', default=False, const=True,\\n help='If set, no apps will be downloaded, but the meta_data will be saved.')\\n parser.add_argument('--basedir', dest='base_dir', type=str, default=os.getenv('HOME'),\\n required=False, help='Specifies the base path for both logs and apk_downloads.')\\n parser.add_argument('--credentials', dest='credentials', type=str, required=False, default=None,\\n help='Specifies the path to a credential file in .toml format.')\\n parser.add_argument('--limit', dest='limit', type=int, required=False, default=None,\\n help='Specifies the maximum number of apks per category to download.')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=_program_description)\\n parser.add_argument('input_file', help=_input_file_description)\\n #parser.add_argument('-v', '--verbose', action='store_true', \\n # default=False, help='show progress')\\n args = parser.parse_args()\\n return args\",\n \"def _parse_args():\\n args = sys.argv[1:]\\n cmd_parser = argparse.ArgumentParser()\\n cmd_parser.add_argument(\\n '--produce-sub',\\n dest='produce_sub',\\n help='Produce submision file',\\n default=False,\\n action='store_true',\\n )\\n cmd_parser.add_argument(\\n '--search-cv',\\n dest='search_cv',\\n help='Perform Search of parameters',\\n default=False,\\n action='store_true',\\n )\\n cmd_opts = cmd_parser.parse_args(args=args)\\n return cmd_opts\",\n \"def arg_parse():\\n p = ap.ArgumentParser()\\n p.add_argument('infile',\\n help='path to file containing objects')\\n p.add_argument('n1',\\n help='night 1')\\n p.add_argument('n2',\\n help='night 2')\\n p.add_argument('observatory',\\n help='Astropy name of observatory')\\n return p.parse_args()\",\n \"def parseArgs():\\n\\t\\n\\tparser = argparse.ArgumentParser(\\n\\t\\tprog='device_sniffer',\\n\\t\\tdescription='spot nearby devices using a wireless sniffer.',\\n\\t\\tusage='%(prog)s <mode> [options]')\\n\\t\\n\\tparser.add_argument('--interface','-i', help=\\\"interface to scan on.\\\", dest=\\\"inf\\\", type=str)\\n\\tparser.add_argument('--verbse','-v', help=\\\"show extra output.\\\", dest=\\\"verbosity\\\", action=\\\"count\\\")\\n\\tparser.add_argument('types', help=\\\"type of devices to scan for.\\\", choices=['connected', 'scanning','both'], default='both', nargs='?')\\n\\targs = parser.parse_args()\\n\\treturn args\",\n \"def parse_command_line_arguments(argv):\\n print(\\\"reading command line arguments in...\\\")\\n\\n parser = argparse.ArgumentParser(description='Description of your program')\\n parser.add_argument('-i', '--input', help='Location of input csv file', required=True)\\n parser.add_argument('-p', '--predicting', help='The column name containing the category to predict', required=True)\\n parser.add_argument('-s', '--scoring', help='The scoring type to be used with model evaluation', required=False)\\n parser.add_argument('-c', '--scale', help='List of column names to scale values for', nargs='+', required=False)\\n args = parser.parse_args()\\n\\n return args.input, args.predicting, args.scoring, args.scale\",\n \"def parse_args():\\r\\n # label_path: 原始label文件存储位置\\r\\n # det_path : 生成的bbox的信息文件存储位置\\r\\n # 下面只是对训练集进行解析，测试机可以得到同样的结果。\\r\\n parser = argparse.ArgumentParser()\\r\\n parser.add_argument('--label_path', type=str,default='C:\\\\\\\\Users\\\\\\\\wangbo\\\\\\\\Documents\\\\\\\\EGDownloads\\\\\\\\bdd100k_labels_release\\\\\\\\bdd100k\\\\\\\\labels\\\\\\\\bdd100k_labels_images_train.json')\\r\\n parser.add_argument('--det_path', type=str,default='C:\\\\\\\\Users\\\\\\\\wangbo\\\\\\\\Documents\\\\\\\\EGDownloads\\\\\\\\bdd_dect\\\\\\\\detection_train.json ')\\r\\n args = parser.parse_args()\\r\\n\\r\\n return args\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser(description='CLI to store Actisense-NGT Gateway values to InfluxDB and publish via MQTT')\\n parser.add_argument('--config', '-c', type=str, required=True, help='JSON configuraton file with path')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description='Convert CVAT XML annotations to PASCAL VOC format'\\n )\\n\\n parser.add_argument(\\n '--cvat-xml', metavar='FILE', required=True,\\n help='input file with CVAT annotation in xml format'\\n )\\n\\n parser.add_argument(\\n '--image-dir', metavar='DIRECTORY', required=True,\\n help='directory which contains original images'\\n )\\n\\n parser.add_argument(\\n '--output-dir', metavar='DIRECTORY', required=True,\\n help='directory for output annotations in PASCAL VOC format'\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser( description='Required: function-name.' )\\n parser.add_argument( '--function', '-f', help='function name required', required=True )\\n args_dict = vars( parser.parse_args() )\\n return args_dict\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"auth\\\",\\n help=\\\"authentication string for Infermedica API: \\\"\\n \\\"APP_ID:APP_KEY or path to file containing it.\\\")\\n parser.add_argument(\\\"--model\\\",\\n help=\\\"use non-standard Infermedica model/language, \\\"\\n \\\"e.g. infermedica-es\\\")\\n args = parser.parse_args()\\n return args\",\n \"def get_input_args():\\n # Create Parse using ArgumentParser\\n\\n parser = argparse.ArgumentParser()\\n\\n # Create command line arguments as mentioned above using add_argument() from ArguementParser method\\n\\n parser.add_argument('--image_path',type=str,default='flowers/test/10/image_07090.jpg',help='path for image to predict')\\n parser.add_argument('--save_dir',type=str,default='fc_checkpoint.pth',help='path for checkpoint')\\n parser.add_argument('--topk',type=int,default=5,help='input number of top classes for prediction')\\n parser.add_argument('--arch', type = str, default = 'vgg16', help = 'architecure of Model') \\n parser.add_argument('--gpu',default=True,help='use GPU to make predictions')\\n parser.add_argument('--cat_to_name', default = 'cat_to_name.json',help='enters a path to image.')\\n\\n in_arg = parser.parse_args()\\n\\n return in_arg\",\n \"def arglist2dict(args):\\n arg_dict = {}\\n\\n if len(args) == 0:\\n return arg_dict\\n\\n if not args[0].startswith('--'):\\n raise ValueError(f\\\"Positional keywords are not supported: {args[0]}\\\")\\n\\n i = 0\\n while i < len(args):\\n arg = args[i]\\n i = i + 1\\n if arg.startswith('--'):\\n dest = arg[2:]\\n j, arglist = Parser.get_args(args[i:])\\n i = i + j\\n Parser.update_arg_dict(arg_dict, dest, arglist)\\n return arg_dict\",\n \"def parse_arguments():\\n\\n parser = argparse.ArgumentParser(\\n description=\\\"生成用户字符串识别的切分字符串\\\"\\n )\\n parser.add_argument(\\n \\\"-o\\\",\\n \\\"--output_dir\\\",\\n type=str,\\n nargs=\\\"?\\\",\\n help=\\\"The output directory\\\",\\n default=\\\"output/\\\"\\n )\\n parser.add_argument(\\n \\\"-i\\\",\\n \\\"--input_file\\\",\\n type=str,\\n nargs=\\\"?\\\",\\n help=\\\"When set, this argument uses a specified text file as source for the text\\\",\\n default=\\\"\\\",\\n required=True\\n )\\n parser.add_argument(\\n \\\"-mi\\\",\\n \\\"--min_char_count\\\",\\n type=int,\\n nargs=\\\"?\\\",\\n help=\\\"The minimum number of characters per line, Default is 3.\\\",\\n default=3,\\n\\n )\\n parser.add_argument(\\n \\\"-ma\\\",\\n \\\"--max_char_count\\\",\\n type=int,\\n nargs=\\\"?\\\",\\n help=\\\"The maximum number of characters per line, Default is 20.\\\",\\n default=20,\\n )\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Re-Id\\\")\\n parser.add_argument(\\n \\\"--exp1\\\", help=\\\"Name of Camera 1\\\",\\n default=None, required=True)\\n parser.add_argument(\\n\\t \\\"--exp2\\\", help=\\\"Name of Camera 2\\\",\\n\\t default=None, required=True)\\n\\n return parser.parse_args()\",\n \"def command_line_arguments():\\n\\n try:\\n parser = argparse.ArgumentParser(description='Log Handler/Cleaner/Copier for Idemia DocAuth')\\n\\n # Add required arguments.\\n parser.add_argument('action', choices=['clean', 'download'], type=str, help='clean or download')\\n\\n # Parse the arguments\\n args = parser.parse_args()\\n\\n return args\\n\\n except Exception as err:\\n print(err)\\n return\",\n \"def parse_args():\\n \\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n 'config',\\n help='Config file')\\n parser.add_argument(\\n '--quiet',\\n '-q',\\n action='store_true',\\n help='do not print to console'\\n )\\n parser.add_argument(\\n '--password',\\n '-p',\\n action='store_true',\\n help='Set password in keyring.'\\n )\\n parser.add_argument(\\n '--update',\\n '-u',\\n action='store_true',\\n help='Only add transactions after last date in database.'\\n )\\n parser.add_argument(\\n '--mark_seen',\\n '-m',\\n action='store_true',\\n help='Mark fetched emails as seen.'\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Deep SORT\\\")\\n parser.add_argument(\\n \\\"--input\\\", help=\\\"Path to MOTChallenge sequence directory\\\",\\n default=None, required=True)\\n return parser.parse_args()\",\n \"def parse_args():\\n from argparse import ArgumentParser\\n ap = ArgumentParser(prog='fsupload', description=\\\"Upload FreeSurfer edits to subject on XNAT\\\")\\n ap.add_argument('project', help='Project Label')\\n ap.add_argument('session', help='Session Label')\\n ap.add_argument('proc_suffix', help='Proc name suffix', nargs='?', default='')\\n return ap.parse_args()\",\n \"def parse_arguments():\\n # shift away script name\\n scriptname=sys.argv[0]\\n shift()\\n ncl_cmd=list()\\n quali_cmd=list()\\n id_cmd=list() \\n while(len(sys.argv)>0):\\n carg = sys.argv[0]\\n shift()\\n if(carg == \\\"--nucleotide\\\"):\\n ncl_cmd = mungeArgs(sys.argv)\\n elif(carg == \\\"--quality\\\"):\\n quali_cmd = mungeArgs(sys.argv)\\n elif(carg == \\\"--id\\\" ):\\n id_cmd = mungeArgs(sys.argv)\\n elif(carg in [\\\"-h\\\", \\\"--help\\\"]):\\n usage()\\n else:\\n usage(error=True)\\n # Excess arguments which are not processed \\n if(len(sys.argv) > 0):\\n sys.stdout.write(\\\"Excess arguments!\\\\n\\\")\\n sys.stdout.flush()\\n usage(error=True)\\n\\n # external modules rely on non-empty argv array, \\n # re-append the script name as first command line argument\\n sys.argv.append(scriptname)\\n return (id_cmd, ncl_cmd, quali_cmd)\",\n \"def get_args_from_console(args):\\n return {\\n \\\"cleaning_policy\\\": args.cleaning_policy,\\n \\\"clear\\\": args.clear,\\n \\\"content\\\": args.content,\\n \\\"dry_run\\\": args.dry_run,\\n \\\"force\\\": args.force,\\n \\\"in_lines\\\": args.in_lines,\\n \\\"max_size\\\": args.max_size,\\n \\\"regex\\\": args.regex,\\n \\\"restore\\\": args.restore,\\n \\\"rmdir\\\": args.rmdir,\\n \\\"short\\\": args.short,\\n \\\"silent\\\": args.silent,\\n \\\"storage_time\\\": args.storage_time,\\n \\\"wastebasket_path\\\": args.wastebasket_path\\n }\",\n \"def _parse_arguments():\\n parser = argparse.ArgumentParser(\\n prog=\\\"JSON sorter\\\",\\n description=\\\"Take a json file, sort the keys and insert 4 spaces for indents.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"input\\\", help=\\\"JSON file to parse.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-o\\\",\\n \\\"--output\\\",\\n default=sys.stdout,\\n type=argparse.FileType(mode=\\\"w\\\"),\\n help=\\\"File to write to. Defaults to stdout.\\\",\\n )\\n\\n # Should probably implement this and CSV as subcommands\\n parser.add_argument(\\n \\\"-y\\\",\\n \\\"--yaml\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Whether to sort a YAML file provided as the input.\\\",\\n )\\n\\n # is there a way to have info printed with this from argparse?\\n parser.add_argument(\\n \\\"-l\\\",\\n \\\"--log\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Turn logging on and print to console.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-ll\\\",\\n \\\"--log_level\\\",\\n dest=\\\"log_level\\\",\\n choices=[\\\"DEBUG\\\", \\\"INFO\\\", \\\"WARNING\\\", \\\"ERROR\\\", \\\"CRITICAL\\\"],\\n help=\\\"Set the logging level\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-V\\\", \\\"--version\\\", action=\\\"version\\\", version=\\\"%(prog)s\\\" + __version__\\n )\\n\\n if len(sys.argv[1:]) == 0:\\n parser.print_help()\\n sys.exit()\\n\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Reads in iClicker data from the submission \\\"\\n \\\"directory, and then writes it to the given \\\"\\n \\\"remote file.\\\")\\n parser.add_argument(\\\"submission_directory\\\", type=str, help=\\\"Directory of submissions that \\\"\\n \\\"contain a 'textbox_0.txt' file that references iClicker ID\\\")\\n parser.add_argument(\\\"remote_id_file\\\", type=str)\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Nuvoton post build command\\\"\\n )\\n\\n subparsers = parser.add_subparsers(description=\\\"The action to perform\\\")\\n\\n parser_tfm_sign_image_tgt = subparsers.add_parser(\\n \\\"tfm_sign_image_tgt\\\",\\n help=\\\"Sign secure and non-secure images together\\\"\\n )\\n \\n parser_tfm_sign_image_tgt.add_argument(\\n \\\"--tfm-import-path\\\",\\n help=\\\"Path containing the TF-M bootloader, layouts and signing keys\\\",\\n required=True\\n )\\n\\n parser_tfm_sign_image_tgt.add_argument(\\n \\\"--signing_key\\\",\\n help=\\\"File name of key for signing secure binary or secure/non-secure binaries together\\\",\\n required=True\\n )\\n\\n parser_tfm_sign_image_tgt.add_argument(\\n \\\"--non-secure-bin\\\",\\n help=\\\"Path to the non-secure binary\\\",\\n required=True\\n )\\n\\n parser_tfm_sign_image_tgt.set_defaults(func=tfm_sign_image_tgt)\\n\\n return parser.parse_args()\",\n \"def _parse_tags(tags: str):\\n return dict(item.split(\\\":\\\") for item in shlex.split(tags)) # type: ignore\",\n \"def parse_argv(self, argv):\\n machine = ParseMachine(initial=self.initial, contexts=self.contexts)\\n for token in argv:\\n machine.handle(token)\\n machine.finish()\\n return machine.result\",\n \"def arg_parse():\\n parser = argparse.ArgumentParser(description=\\\"Fetches the current ATT&CK content expressed as STIX2 and creates spreadsheet mapping Techniques with Mitigations, Groups or Software.\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--domain\\\", type=str, required=True, choices=[\\\"enterprise_attack\\\", \\\"mobile_attack\\\"], help=\\\"Which ATT&CK domain to use (Enterprise, Mobile).\\\")\\n parser.add_argument(\\\"-m\\\", \\\"--mapping-type\\\", type=str, required=True, choices=[\\\"groups\\\", \\\"mitigations\\\", \\\"software\\\"], help=\\\"Which type of object to output mappings for using ATT&CK content.\\\")\\n parser.add_argument(\\\"-t\\\", \\\"--tactic\\\", type=str, required=False, help=\\\" Filter based on this tactic name (e.g. initial-access) \\\" )\\n parser.add_argument(\\\"-s\\\", \\\"--save\\\", type=str, required=False, help=\\\"Save the CSV file with a different filename.\\\")\\n return parser\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\\"Run arguments for system submitted tasks\\\")\\n\\n parser.add_argument(\\\"-f\\\", \\\"--funcs\\\", type=str, nargs=\\\"?\\\", required=True,\\n help=\\\"path to pickle file containing a list of \\\"\\n \\\"functions/methods that should be run by the \\\"\\n \\\"submitted process\\\"\\n )\\n parser.add_argument(\\\"-k\\\", \\\"--kwargs\\\", type=str, nargs=\\\"?\\\", required=False,\\n default=None,\\n help=\\\"path to pickle file containing a dictionary of \\\"\\n \\\"keyword argumnets that should be passed to the \\\"\\n \\\"functions\\\")\\n parser.add_argument(\\\"-e\\\", \\\"--environment\\\", type=str, nargs=\\\"?\\\",\\n required=False,\\n help=\\\"Optional comma-separated environment variables, \\\"\\n \\\"which should be given as \\\"\\n \\\"VARNAME1=value1,VARNAME2=value2 and so on. These \\\"\\n \\\"will be separated and instantiated into Python's \\\"\\n \\\"os.environ\\\")\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"--start\\\",\\n type=str,\\n default=\\\"\\\",\\n required=False,\\n help=\\\"The start square of the agent, in the form row,col. If not specified, this is randomized\\\"\\n )\\n parser.add_argument(\\n \\\"--actions\\\",\\n type=str,\\n required=True,\\n nargs = '+',\\n help=\\\"The actions the agent takes, comma delimited\\\"\\n )\\n parser.add_argument(\\n \\\"--observations\\\",\\n type=str,\\n required=True,\\n nargs = '+',\\n help=\\\"The observations the agent makes, comma delimited\\\"\\n )\\n return parser.parse_args()\",\n \"def get_input_args():\\n # Create Parse using ArgumentParser\\n parser = ArgumentParser()\\n\\n # Image file path as --file_path\\n # Path to test images\\n # image_path = './test_images/hard-leaved_pocket_orchid.jpg'\\n # image_path = './test_images/cautleya_spicata.jpg'\\n # image_path = './test_images/orange_dahlia.jpg'\\n # image_path = './test_images/wild_pansy.jpg'\\n parser.add_argument(\\\"--file_path\\\",\\n type = str,\\n default = './test_images/hard-leaved_pocket_orchid.jpg',\\n help = \\\"Image file path.\\\")\\n\\n # Model file name as --model_filename\\n parser.add_argument(\\\"--model_filename\\\",\\n type = str,\\n default = 'model_20200422_223607.h5',\\n help = \\\"Model path and file name.\\\")\\n\\n # Top k classes to be returned as --top_k with default value 5\\n parser.add_argument(\\\"--top_k\\\",\\n type = int,\\n default = 5,\\n help = \\\"Number of epochs. Default = 5\\\")\\n\\n # json file mapping labels as --category_names\\n parser.add_argument(\\\"--category_names\\\",\\n type = str,\\n default = 'label_map.json',\\n help = \\\"json file mapping labels.\\\")\\n\\n return parser.parse_args()\",\n \"def parse_known_args():\\n\\n parser = argparse.ArgumentParser(\\n description= \\\"\\\\n\\\".join([\\\"HUMAnN Benchmark\\\\n\\\",\\n \\\"To run: $ humann_benchmark COMMAND\\\",\\n \\\"Replacing COMMAND with the command to benchmark\\\"]),\\n formatter_class=argparse.RawTextHelpFormatter)\\n\\n return parser.parse_known_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='Parse flags to configure the json parsing')\\n parser.add_argument(\\\"-f\\\", \\\"--format\\\", help=\\\"output format: (csv|tsv|json)\\\", choices=[\\\"csv\\\", \\\"tsv\\\", \\\"json\\\"],\\n default=\\\"tsv\\\")\\n parser.add_argument(\\\"-p\\\", \\\"--parallelized\\\", help=\\\"save output in parallelized or single file format\\\",\\n action=\\\"store_true\\\")\\n parser.add_argument(\\\"-i\\\", \\\"--input\\\", help=\\\"folder where input documents are\\\", default=\\\"data\\\")\\n parser.add_argument(\\\"-o\\\", \\\"--output\\\", help=\\\"folder where output documents are\\\", default=\\\"cleaned\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--documentformat\\\", help=\\\"combine all features into a single text per post\\\",\\n action=\\\"store_true\\\")\\n parser.add_argument(\\\"-pa\\\", \\\"--partitions\\\", help=\\\"number of spark partitions\\\",\\n default=1)\\n args = parser.parse_args()\\n return args\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser(prog='AdapterRunner', description='Adapter Runner Application')\\n parser.add_argument('-a', '--application', action='store', dest='app_name', help='Application Name',\\n metavar='<application_name>')\\n parser.add_argument('-fi', '--fetch_interval', action='store', dest='fetch_stats_interval', help='Fetch Stats Interval',\\n metavar='<fetch_interval in seconds>')\\n return parser.parse_args()\",\n \"def command_line_parse(iargs=None):\\n\\n parser = create_parser()\\n inps = parser.parse_args(args=iargs)\\n\\n return inps\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"auth\\\",\\n help=\\\"authentication string for Infermedica API: \\\"\\n \\\"APP_ID:APP_KEY or path to file containing it.\\\")\\n parser.add_argument(\\\"--model\\\",\\n help=\\\"use non-standard Infermedica model/language, \\\"\\n \\\"e.g. infermedica-es\\\")\\n # TODO: Check if `verbose` actually does anything.\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\",\\n dest=\\\"verbose\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"dump internal state\\\")\\n args = parser.parse_args()\\n return args\",\n \"def parse_args(self):\\n return self.__process_args__(self.parser.parse_args())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.656502","0.64459336","0.64356583","0.6318063","0.6279127","0.62615263","0.6145342","0.6143788","0.6119476","0.60930604","0.60857743","0.6077435","0.60595834","0.60482275","0.60474616","0.6030172","0.6011784","0.59997857","0.598045","0.5979317","0.59701324","0.59700465","0.5966798","0.5957258","0.5945406","0.59235233","0.5913724","0.59069276","0.58878016","0.5886743","0.58848953","0.5880163","0.58756053","0.5873717","0.58715856","0.58667976","0.58580935","0.5856997","0.5850652","0.58497053","0.58451796","0.58408195","0.5838872","0.5834457","0.58176434","0.5814648","0.581088","0.5807357","0.5807129","0.5806516","0.5804764","0.58039796","0.5797725","0.5797173","0.5796322","0.57945967","0.57916135","0.57892185","0.5787852","0.5786149","0.57825947","0.57716143","0.5769717","0.5761857","0.5758841","0.5758378","0.57576096","0.5756451","0.5751971","0.57516474","0.57480496","0.57453537","0.57440275","0.5731346","0.5727998","0.5724741","0.5719567","0.57081264","0.5707057","0.5706743","0.5705802","0.57056487","0.5698874","0.56963956","0.56924826","0.5681914","0.5681459","0.5674873","0.5673386","0.5663208","0.56629086","0.5662826","0.56623054","0.56620514","0.5657355","0.56519854","0.5651252","0.565058","0.56504256","0.5649155"],"string":"[\n \"0.656502\",\n \"0.64459336\",\n \"0.64356583\",\n \"0.6318063\",\n \"0.6279127\",\n \"0.62615263\",\n \"0.6145342\",\n \"0.6143788\",\n \"0.6119476\",\n \"0.60930604\",\n \"0.60857743\",\n \"0.6077435\",\n \"0.60595834\",\n \"0.60482275\",\n \"0.60474616\",\n \"0.6030172\",\n \"0.6011784\",\n \"0.59997857\",\n \"0.598045\",\n \"0.5979317\",\n \"0.59701324\",\n \"0.59700465\",\n \"0.5966798\",\n \"0.5957258\",\n \"0.5945406\",\n \"0.59235233\",\n \"0.5913724\",\n \"0.59069276\",\n \"0.58878016\",\n \"0.5886743\",\n \"0.58848953\",\n \"0.5880163\",\n \"0.58756053\",\n \"0.5873717\",\n \"0.58715856\",\n \"0.58667976\",\n \"0.58580935\",\n \"0.5856997\",\n \"0.5850652\",\n \"0.58497053\",\n \"0.58451796\",\n \"0.58408195\",\n \"0.5838872\",\n \"0.5834457\",\n \"0.58176434\",\n \"0.5814648\",\n \"0.581088\",\n \"0.5807357\",\n \"0.5807129\",\n \"0.5806516\",\n \"0.5804764\",\n \"0.58039796\",\n \"0.5797725\",\n \"0.5797173\",\n \"0.5796322\",\n \"0.57945967\",\n \"0.57916135\",\n \"0.57892185\",\n \"0.5787852\",\n \"0.5786149\",\n \"0.57825947\",\n \"0.57716143\",\n \"0.5769717\",\n \"0.5761857\",\n \"0.5758841\",\n \"0.5758378\",\n \"0.57576096\",\n \"0.5756451\",\n \"0.5751971\",\n \"0.57516474\",\n \"0.57480496\",\n \"0.57453537\",\n \"0.57440275\",\n \"0.5731346\",\n \"0.5727998\",\n \"0.5724741\",\n \"0.5719567\",\n \"0.57081264\",\n \"0.5707057\",\n \"0.5706743\",\n \"0.5705802\",\n \"0.57056487\",\n \"0.5698874\",\n \"0.56963956\",\n \"0.56924826\",\n \"0.5681914\",\n \"0.5681459\",\n \"0.5674873\",\n \"0.5673386\",\n \"0.5663208\",\n \"0.56629086\",\n \"0.5662826\",\n \"0.56623054\",\n \"0.56620514\",\n \"0.5657355\",\n \"0.56519854\",\n \"0.5651252\",\n \"0.565058\",\n \"0.56504256\",\n \"0.5649155\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65210056"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":92891,"cells":{"query":{"kind":"string","value":"Try to open the config file if it does not exist, assume default configuration, else exit with an error"},"document":{"kind":"string","value":"def load_config(config=CONFIGFILE):\n\ttry:\n\t\tcfg = open(config, 'r').read()\n\t\treturn sanitize_config(json.loads(cfg))\n\texcept IOError as e:\n\t\t(errno, errstr) = e.args\n\t\tif errno == 2:\n\t\t\treturn DEFAULTCONFIG\n\t\telse:\n\t\t\tprint(\"An error occured opening the configuration file '%s':\"%(config),\n\t\t\t\t\tfile=stderr)\n\t\t\tprint(errstr, file=stderr)\n\t\t\texit(1)\n\texcept ValueError as e:\n\t\tif e.args[0] == 'No JSON object could be decoded':\n\t\t\tprint(\"An error occured reading the configuration file '%s'; please \\\nmake sure it is correct JSON\"%\n\t\t\t\t(config), file=stderr)\n\t\telse:\n\t\t\tprint(e)\n\t\texit(1)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def check_config_file():\n # Locate and init config.\n default_config = \"config.json\"\n if len(sys.argv) == 2:\n # config from command line\n app_config = config_reader(sys.argv[1])\n else:\n # config should be in default\n app_config = config_reader(default_config)\n # fin\n if not app_config:\n print(\"Exiting due to invalid config file.\")\n return False\n # fin\n return app_config","def test_nonexisting_config(self):\n try:\n tempdir = tempfile.mkdtemp()\n filename = os.path.join(tempdir, \"Config.yaml\")\n with self.assertRaises(easydms.config.ErrorNoConfiguration):\n easydms.config.Config(filename)\n\n with self.assertRaises(SystemExit) as cm:\n sys.argv = [\"prog\", \"-c\", filename]\n easydms.cli.main()\n self.assertNotEqual(cm.exception.code, 0)\n\n finally:\n shutil.rmtree(tempdir)","def load(filename, defaultConfig={}, writeIfNonExistent=True, quitIfNonExistent=False):\n global _loaded\n assert filename and isinstance(filename, basestring)\n\n #all keys and values in defaultConfig must be strings\n #(to make it match what would be read in by ConfigParser)\n #lets error out if we find a key or value that isn't a string\n for (key, value) in defaultConfig.iteritems():\n if not isinstance(key, basestring):\n raise KeyError(\"Invalid defaultConfig: key \\\"%s\\\" is not a string\" % str(key))\n if not isinstance(value, basestring):\n raise ValueError(\"Invalid defaultConfig: value of key \\\"%s\\\" (\\\"%s\\\") is not a string\" \n % (str(key), str(value)))\n\n _loaded = defaultConfig.copy()\n \n configFileExists = os.path.exists(filename)\n \n #If we just want to \"load\" the default configuration\n if writeIfNonExistent and not configFileExists:\n log.msg(\"Configuration file \\\"%s\\\" does not exist...\" % filename, lvl='w', ss='ss_configfile')\n try:\n write(filename)\n except:\n raise\n \n #if quitIfNonExistent is set, keep going to the next block of code\n #so we can quit out properly\n if not quitIfNonExistent:\n return\n\n if quitIfNonExistent and not configFileExists:\n #print different messages depending on if the default\n #config file was written or not\n if writeIfNonExistent:\n log.msg(\"Quitting as configuration file did not exist. Please \"\n \"edit the default configuration that has been written \"\n \"to \\\"%s\\\" to suit your environment and start the program \"\n \"again.\" % filename, lvl='c', ss='ss_configfile')\n sys.exit(0)\n else:\n log.msg(\"Quitting as configuration file \\\"%s\\\" does not exist.\"\n \" Please create this file and try again.\" % filename)\n sys.exit(1)\n\n log.msg(\"Reading configuration from \\\"%s\\\"...\" % filename, lvl='i', ss='ss_configfile')\n _loaded = simpleReadConfigFile(filename, useLogging=True,\n level=consts.LOGLVL_DEBUG3)\n \n log.msg(\"ACTIVE CONFIGURATION: \" + str(_loaded),\n lvl='d2', ss='ss_configfile')","def test_load_configuration_fails_gracefully_when_file_does_not_exist():\n config.load_configuration(invalid_configuration_path, graceful=True)\n assert True","def init_config():\n config_file = create_config_file.CreateConfigFile()\n config_file.check_if_config_file_exists()","def _ensure_config_file_exists():\n config_file = Path(ELIBConfig.config_file_path).absolute()\n if not config_file.exists():\n raise ConfigFileNotFoundError(ELIBConfig.config_file_path)","def init_default_config_file_if_nonexistent(package, default_config):\n config_file = os.path.join(conf.PAULA_USER_CONFIG_DIR, package + conf.CONFIG_EXTENSION)\n debug('config_file = ' + config_file)\n if not os.path.exists(config_file):\n debug('making: \\\"' + config_file+ '\\\"')\n shutil.copyfile(default_config, config_file)","def fallback_file(cls, filename):\n file_list = (\n filename,\n path.join(path.expanduser('~'), '.config', 'hiromi.json'),\n path.join(path.expanduser('~'), '.hiromi')\n )\n for a_file in file_list:\n if path.exists(a_file):\n return a_file\n print(\n \"Please given a legal config file, or make a config file at\"\n \"~/.hiromi or ~/.config/hiromi.json\"\n )\n raise ConfigNotFoundException()","def get_config_file(self):\n\n conf_file = self.args.file\n if conf_file is not None:\n if os.path.isfile(conf_file):\n config_file = open(conf_file, \"r\")\n self.main_file = yaml.load(config_file, Loader=yaml.FullLoader)\n elif os.path.isfile(\n os.path.join(get_path(\"DEFAULT\", \"config_file_path\"), conf_file)\n ):\n fpath = get_path(\"DEFAULT\", \"config_file_path\")\n config_file = open(os.path.join(fpath, conf_file), \"r\")\n self.main_file = yaml.load(config_file, Loader=yaml.FullLoader)\n else:\n self.logger.error(\n colorama.Fore.RED\n + \"ERROR!! Config file '%s' is not present \" % conf_file,\n extra=self.log_detail,\n )\n sys.exit(1)\n else:\n if self.args.hostname and self.args.testfiles:\n temp_dict = {\n \"hosts\": [{\"device\": \"\", \"username\": \"\", \"passwd\": \"\"}],\n \"tests\": [],\n }\n temp_dict[\"hosts\"][0][\"device\"] = self.args.hostname\n temp_dict[\"hosts\"][0][\"username\"] = self.args.login\n temp_dict[\"hosts\"][0][\"passwd\"] = self.args.passwd\n for tfile in self.args.testfiles:\n temp_dict[\"tests\"].append(tfile)\n self.main_file = temp_dict\n\n if (\n self.main_file.__contains__(\"sqlite\")\n and self.main_file[\"sqlite\"]\n and self.main_file[\"sqlite\"][0]\n ):\n self.chk_database(\n self.main_file,\n self.args.pre_snapfile,\n self.args.post_snapfile,\n self.args.check,\n self.args.snap,\n )\n else:\n # if --check option is given for sqlite, then snap file name is not compulsory\n # else exit the function saying arguments not correct\n if self.args.check is True and (\n self.args.pre_snapfile is None or self.args.post_snapfile is None\n ):\n self.logger.error(\n colorama.Fore.RED\n + \"Arguments not given correctly, Please refer help message\",\n extra=self.log_detail,\n )\n self.parser.print_help()\n sys.exit(1)","def _findConfig(self, _file = file):\n import errno\n\n config_file = self.runtime.config\n if config_file:\n try:\n return config_file == '-' and sys.stdin or _file(config_file)\n except IOError, exc:\n raise ConfigNotFoundError(\"%s: %s\" % (config_file, str(exc)))\n\n for config_file in self._getDefaultConfigFiles():\n try:\n return _file(config_file)\n except IOError, exc:\n # try next one only if not found\n if exc[0] != errno.ENOENT:\n raise ConfigNotFoundError(\"%s: %s\" % (\n config_file, str(exc)\n ))\n\n raise ConfigMissingError(\"No config file found\")","def default_configfile(self):\r\n config = None\r\n for path in self.searchpaths:\r\n if os.path.exists(path):\r\n config = path\r\n break\r\n if config is None and self.require_configfile:\r\n self.usage('No config file found at default paths (%s); '\r\n 'use the -c option to specify a config file '\r\n 'at a different path' % ', '.join(self.searchpaths))\r\n return config","def get_config(file_name, fallback = True):\n exec_dir = get_exec_path()\n if file_name == 'logging.conf' and not hasattr(sys, \"frozen\"):\n config_path = os.path.join(exec_dir, 'pyfpdb', file_name)\n else:\n config_path = os.path.join(exec_dir, file_name)\n# print \"config_path=\", config_path\n if os.path.exists(config_path): # there is a file in the cwd\n return (config_path,False) # so we use it\n else: # no file in the cwd, look where it should be in the first place\n default_dir = get_default_config_path()\n config_path = os.path.join(default_dir, file_name)\n# print \"config path 2=\", config_path\n if os.path.exists(config_path):\n return (config_path,False)\n\n# No file found\n if not fallback:\n return (False,False)\n\n# OK, fall back to the .example file, should be in the start dir\n if os.path.exists(file_name + \".example\"):\n try:\n print \"\"\n check_dir(default_dir)\n shutil.copyfile(file_name + \".example\", config_path)\n msg = \"No %s found\\n in %s\\n or %s\\n\" % (file_name, exec_dir, default_dir) \\\n + \"Config file has been created at %s.\\n\" % config_path\n print msg\n logging.info(msg)\n file_name = config_path\n except:\n print \"Error copying .example file, cannot fall back. Exiting.\\n\"\n sys.stderr.write(\"Error copying .example file, cannot fall back. Exiting.\\n\")\n sys.stderr.write( str(sys.exc_info()) )\n sys.exit()\n else:\n print \"No %s found, cannot fall back. Exiting.\\n\" % file_name\n sys.stderr.write(\"No %s found, cannot fall back. Exiting.\\n\" % file_name)\n sys.exit()\n return (file_name,True)","def validate_config(location):\n if not os.path.exists(location):\n full_path = os.path.abspath(location)\n logging.fatal('Config not found - expected a configfile at: [{loc}] - exiting.'.format(loc=full_path))\n sys.exit(1)","def test_load_configuration_raises_an_exception_when_file_does_not_exist():\n with pytest.raises(FileNotFoundError):\n config.load_configuration(invalid_configuration_path)","def test_config():\n if not os.path.exists(CONFIG_DIR):\n raise mupub.BadConfiguration('Configuration folder not found.')\n if not os.path.exists(_CONFIG_FNM):\n raise mupub.BadConfiguration('Configuration file not found.')\n if not os.path.exists(getDBPath()):\n raise mupub.BadConfiguration('Local database not found.')\n if len(CONFIG_DICT) == 0:\n raise mupub.BadConfiguration('Configuration was not loaded.')","def test_find_config_nonexist(self):\n with pytest.raises(scuba.config.ConfigError):\n scuba.config.find_config()","def _check(self, config: Dict):\n if 'path' not in config:\n raise FileNotFoundError(\"File not found.\")","def config_reader(config_file):\n if os.path.exists(config_file):\n with open(config_file, 'r') as cfile:\n app_config = json.load(cfile)\n # end with\n return app_config\n else:\n print(\"The config file: {} does not exist, please try again.\".format(config_file))\n return False\n # fin","def init():\n for config_filename in _config_utils.CONFIG_FILENAMES:\n if os.path.isfile(config_filename):\n config_filepath = os.path.abspath(config_filename)\n click.echo(\"found existing config file {}\".format(config_filepath))\n return\n\n config_filepath = _config_utils.create_empty_config_file('.')\n click.echo(\"initialized empty config file {}\".format(config_filepath))","def test_nonexistent_config_options(self, capsys):\n with open(self.config_file, \"w\") as f:\n f.write(\n textwrap.dedent(\n \"\"\"\n [DEFAULT]\n foo=bar\n \"\"\"\n )\n )\n with pytest.raises(SystemExit) as excinfo:\n self.config_parser.parse_config_options(self.namespace, configs=[self.config_file])\n out, err = capsys.readouterr()\n assert not out\n assert \"failed loading config: unknown arguments: --foo=bar\" in err\n assert excinfo.value.code == 2","def _findconfigfile():\n\n # A ordered list of possible config files\n configfiles = [\"~/.githubhooksrc\",\n \"/etc/githubhooks\"]\n\n for configfile in configfiles:\n if os.path.isfile(os.path.expanduser(configfile)):\n return os.path.expanduser(configfile)\n\n # No valid config file found\n print \"ERROR: No valid config file found in any of the following locations:\"\n for configfile in configfiles:\n print \" - %s\" % configfile\n sys.exit(1)","def test_no_default(self):\n with self.assertRaises(ConfigError) as cm:\n imageroller.main.read_config(\n self._cmd_args,\n imageroller.test.get_config_parser(self._no_default))\n # ConcurrentWorkers is the first value that is checked\n self.assertEqual(str(cm.exception),\n \"Config must contain ConcurrentWorkers\")","def try_read_file():\n try:\n logging.info('open config file %s', config_file_path)\n with open(config_file_path) as f:\n logging.info('begin io %s', config_file_path)\n config_file = json.load(f)\n logging.info('end io %s', config_file_path)\n return config_file\n except (OSError, IOError) as error:\n logging.info('try_read error %s', error)\n return {}","def __check_config(self):\n if not os.path.exists(self.__config_path):\n return False\n else:\n return True","def find_config_file(self):\n filename = self.values.get('config_file', Default('noy.json'))\n\n ignore_missing = False\n if isinstance(filename, Default):\n filename = filename.val\n ignore_missing = True\n\n filename = os.path.abspath(filename)\n if os.path.exists(filename):\n return filename\n elif not ignore_missing:\n raise MissingConfigFile(\"Config file doesn't exist at {}\".format(filename))","def get_conf(self, file_name):\n try:\n self.conf = Config(file_name)\n except ImportError:\n s = \"No such file in simulation directory: \" + file_name\n self.abort(ImportError, s)","def read_config(self) -> None:\n\n if self.parsing_finished is True:\n return\n\n default_config_file = self.get_config_file_path(default_config_file_path)\n\n # check if default config file actually exists\n # and add it to the list of files to parse\n if os.path.exists(default_config_file) and len(self.file_list) == 0:\n self.file_list.append(default_config_file)\n\n # check if config file exists\n for f in self.file_list:\n\n # check if file exists\n if not os.path.exists(f):\n self._add_error(f'Config file \"{f}\" not found')\n self.file_list.remove(f)\n continue\n\n # check if it's an actual file\n if not os.path.isfile(f):\n self._add_error(f'Config file \"{f}\" is not an actual file')\n self.file_list.remove(f)\n continue\n\n # check if config file is readable\n if not os.access(f, os.R_OK):\n self._add_error(f'Config file \"{f}\" not readable')\n self.file_list.remove(f)\n continue\n\n for config_file in self.file_list:\n\n config_file_type = ConfigFile.get_file_type(config_file)\n\n if config_file_type is None:\n self._add_error(f\"Unknown/Unsupported config file type \"\n f\"'{ConfigFile.get_suffix(config_file)}' for {config_file}\")\n continue\n\n if config_file_type == ConfigFileINI:\n config_data = self._parse_ini(config_file)\n elif config_file_type == ConfigFileYAML:\n config_data = self._parse_yaml(config_file)\n else:\n continue\n\n self._add_config_data(config_data, config_file)\n\n # parse common and netbox config from env\n for section in [common_config_section_name, netbox_config_section_name]:\n env_config_data = self._parse_section_env_vars(section)\n self._add_config_data(env_config_data)\n\n # parse source data from env\n env_config_data = self._parse_source_env_vars()\n self._add_config_data(env_config_data)\n\n self.parsing_finished = True","def load_configuration_or_abort(app, environ_variable, mandatory_config_keys=[]):\n\n try:\n config_file = load_config_file(environ_variable)\n app.config.from_pyfile(config_file, silent=False)\n except Exception as e:\n print(str(e))\n exit(-1)\n\n assert_configs(app.config, mandatory_config_keys, config_file)\n\n print((\"ZEEGUU: Loaded {0} config from {1}\".format(app.name, config_file)))","def load_config_file(self):\n\n conf_file = config.DEFAULT_CONFIGURATION_FILE\n\n if self.options and getattr(self.options, \"conf_file\"):\n conf_file = self.options.conf_file\n if (\n not os.path.exists(conf_file) and\n not os.path.exists(\"%s.d\" % conf_file)\n ):\n raise Exception(\n (\n \"The specified configuration file \"\n \"does not exist. File=(%s)\"\n ) % self.options.conf_file\n )\n\n self.from_file(conf_file)","def test_readable_error_if_file_not_found(self):\n fake_path = 'this/path/is/not/real'\n self.assertEqual(LoadJsonConfig.read_config_file(LoadJsonConfig(), fake_path), 'File not found at ' + fake_path)","def test_invalid_missing_config(self):\n invalid_config_data = 'test'\n with mock_open(LAMBDA_FILE, invalid_config_data):\n with mock_open(GLOBAL_FILE, invalid_config_data):\n with patch('os.path.exists') as mock_exists:\n mock_exists.return_value = False\n _load_config()","def load_config(configFile):\r\n\r\n # TODO: Implement this\r\n return False","def init():\n file_name = 'config.json'\n home_directory_path = str(Path.home())\n config_file_directory = home_directory_path+\"/.config/files/\"\n full_path = config_file_directory + file_name\n\n if os.path.isfile(full_path) and os.access(full_path, os.R_OK): # Readable Config file exists and is valid\n try:\n with open(full_path) as file:\n json_file = json.load(file)\n load_json_and_arguments(json_file)\n\n except ValueError as exception:\n raise ValueError(\"Invalid JSON configuration file\")\n\n elif not os.path.isfile(full_path): # Config file doesn't exist yet, create it\n\n if not os.path.exists(config_file_directory): # Make the directory if that doesn't exist as well\n os.makedirs(config_file_directory)\n\n get_account_info(full_path)\n\n else:\n raise IOError(\"Config file: \" + full_path + \" not accessible\")","def check_config(self):\n cfgs = self.__get() \n \n for option in Config.FILE_OPTIONS.keys():\n _default = Config.FILE_OPTIONS[option]\n \n if not cfgs.has_key(option):\n self.log.warn(\"Parameter '%s' is missing in '%s', using default('%s')\" % \\\n (option, self.config_file, _default))\n _file = _default\n else:\n _file = cfgs[option]\n Config.FILE_OPTIONS[option] = _file\n\n if not os.path.exists(_file) and not os.path.isfile(_file):\n self.log.error(\"Paramenter '%s' points to non-existing file '%s')\" % \\\n (option, _file))\n raise ConfigError('File Error', \"Paramenter '%s' points to non-existing file '%s')\" % \\\n (option, _file))\n\n\n for option in Config.PATH_OPTIONS.keys():\n _default = Config.PATH_OPTIONS[option]\n \n if not cfgs.has_key(option):\n self.log.warn(\"Parameter '%s' is missing in '%s', using default('%s')\" % \\\n (option, self.config_file, _default))\n _dir = _default\n else:\n _dir = cfgs[option]\n Config.PATH_OPTIONS[option] = _dir\n\n if not os.path.exists(_dir) and not os.path.isdir(_dir):\n self.log.error(\"Paramenter '%s' points to non-existing directory '%s')\" % \\\n (option, _dir))\n raise ConfigError('File Error', \"Paramenter '%s' points to non-existing directory '%s')\" % \\\n (option, _dir))\n\n \n Config.DB_SFT_OPTIONS['sqlalchemy_sft.url'] = cfgs['sqlalchemy_sft.url']\n Config.DB_NAGIOS_OPTIONS['sqlalchemy_nagios.url'] = cfgs['sqlalchemy_nagios.url']\n\n self.log.debug(\"Configuration successfully checked\")","def use_config_file(self):\n self.config_file = self.find_config_file()\n if self.config_file:\n self.apply_config_file(self.config_file)","def test_config_no_file(self):\n if os.path.isfile(\"test_config.conf\"):\n os.remove(\"test_config.conf\")\n self.assertRaises(ConfigError, Config, \"test_config.conf\")","def init_config():\n cf = ConfigParser.ConfigParser()\n try :\n cf.read(CONFIG_FILE)\n except os.errno:\n Log.e(TAG, \"Open configuration file error!\")\n return False\n try :\n SW_CONFIG['7zpath'] = cf.get(\"dir_config\", \"7zpath\")\n SW_CONFIG['sharefolder'] = cf.get(\"dir_config\", \"sharefolder\")\n SW_CONFIG['distpath'] = cf.get(\"dir_config\", \"distpath\")\n SW_CONFIG['sw_version'] = cf.get(\"sw_config\", \"version\")\n SW_CONFIG['startup'] = cf.get(\"sw_config\", \"startup\")\n except ConfigParser.Error:\n Log.e(DEBUG_TAG, \"Config file parse error!\")\n clean()\n return False\n try :\n RUN_CONFIG['backup'] = (cf.get(\"run_config\", \"backup\") == \"True\")\n RUN_CONFIG['pop'] = (cf.get(\"run_config\", \"pop\") == \"True\")\n except ConfigParser.Error:\n Log.e(TAG, \"no run config in config file!\")\n RUN_CONFIG['backup'] = False\n RUN_CONFIG['pop'] = False\n try :\n for option in cf.options(\"hook_config\"): \n HOOK_CONFIG[option] = cf.get(\"hook_config\", option)\n except ConfigParser.Error:\n Log.e(TAG, \"No hook config in config file!\")\n if not os.path.exists(SW_CONFIG['sharefolder']):\n try:\n os.makedirs(SW_CONFIG['sharefolder'])\n except os.error:\n print \"Can't create the local folder:\" + SW_CONFIG['distpath'] + \", Please set another one\"\n clean()\n exit()\n if not os.path.exists(SW_CONFIG['distpath']):\n try:\n os.makedirs(SW_CONFIG['distpath'])\n except os.error:\n print \"Can't create the share folder:\" + SW_CONFIG['sharefolder'] + \" temp directory!\"\n clean()\n os.system(\"pause\")\n exit()\n return True","def test_config_file_empty(get_empty_config, monkeypatch, get_root, conf_obj):\n path = os.path.join(get_root, 'res', 'missing.yml')\n\n with pytest.raises(FileNotFoundError):\n get_empty_config(conf_obj, path)","def test_load_config_no_image(self):\n with open(\".scuba.yml\", \"w\") as f:\n pass\n\n config = scuba.config.load_config(\".scuba.yml\")\n with pytest.raises(scuba.config.ConfigError):\n img = config.image","def test_load_no_backend(self):\n sample_file = os.path.join(os.path.dirname(__file__), \"broken-config-no-backend.yaml\")\n self.assertTrue(os.path.exists(sample_file), \"Did not found {}\".format(sample_file))\n\n def try_it():\n self.configurator.load_yaml_file(sample_file)\n\n self.assertRaises(ConfigurationError, try_it)","def load_config_file(self, suppress_errors=True):\n self.log.debug(\"Searching %s for config files\", self.config_file_paths)\n base_config = 'jupyter_config'\n try:\n super(JupyterApp, self).load_config_file(\n base_config,\n path=self.config_file_paths,\n )\n except ConfigFileNotFound:\n # ignore errors loading parent\n self.log.debug(\"Config file %s not found\", base_config)\n pass\n\n if self.config_file:\n path, config_file_name = os.path.split(self.config_file)\n else:\n path = self.config_file_paths\n config_file_name = self.config_file_name\n\n if not config_file_name or (config_file_name == base_config):\n return\n\n try:\n super(JupyterApp, self).load_config_file(\n config_file_name,\n path=path\n )\n except ConfigFileNotFound:\n self.log.debug(\"Config file not found, skipping: %s\", config_file_name)\n except Exception:\n # Reraise errors for testing purposes, or if set in\n # self.raise_config_file_errors\n if (not suppress_errors) or self.raise_config_file_errors:\n raise\n self.log.warning(\"Error loading config file: %s\" %\n config_file_name, exc_info=True)","def read_config():\n filename = path.join(path.expanduser('~'), '.profrc')\n config = configparser.ConfigParser()\n config.read(filename)\n if 'baseurl' not in config['DEFAULT']:\n print(\"\"\"FATAL : No baseurl found in {0}\nOpen {0} and add the following lines\n\n[DEFAULT]\nBaseurl = https://your-prof-instance\"\"\".format(filename))\n sys.exit()\n try:\n requests.get(config['DEFAULT']['BASEURL'])\n except:\n print(\"{0} does not seems to be reachable. Verify the baseurl set at {1} matches ``https://your-prof-instance``\".format(config['DEFAULT']['BASEURL'], filename))\n sys.exit()\n return config","def initConfig(defaults, filepath=None):\n result = False\n if filepath is None:\n filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), \"res/\", \"config.ini\")\n if not os.path.exists(filepath):\n config = ConfigParser.ConfigParser(defaults)\n result = Helpers.saveConfig(config, filepath)\n return result","def get_config(f_configs, section=None):\n if io.is_file(f_configs) is False:\n warn.warn('configs (INI) file does not exist: ' + f_configs)\n return None","def _load_defaults():\n filename = os.path.expanduser(CONFIG_FILE)\n logging.debug('Loading configuration from {}'.format(filename))\n try:\n with open(filename, 'r') as cfile:\n vals = yaml.load(cfile.read())\n return vals\n except yaml.YAMLError as ex:\n logging.warning('Could not parse configuration file: {}'.format(ex))\n except IOError as ex:\n if ex.errno != errno.ENOENT:\n logging.warning('Could not open configuration file: {}'.format(ex))\n else:\n logging.debug('No config file')\n\n return {}","def read_conf(confilepath):\n\tif os.path.exists(confilepath): \n\t\tconfig = ConfigObj(confilepath) \n\t\treturn config\n\tsys.exit(\"Confile: |%s| does not exist\" %(confilepath))","def init_config(filename):\n config = configparser.ConfigParser()\n try:\n with open(filename, 'r') as config_file:\n config.read(config_file)\n except EnvironmentError:\n print(\"FATAL ERROR: Failed to open config file at \" + filename)\n sys.exit(1)\n return config","def __test_config_file__(parser, path):\n if not os.path.exists(path):\n return False\n else:\n statinfo = os.stat(path)\n if not os.path.isfile(path) or os.path.islink(path):\n parser.error(\"invalid configuration file {} (it must be a regular file)\".format(path))\n elif stat.filemode(statinfo.st_mode) != '-rw-------':\n parser.error(\"invalid configuration file {} (it must have only read and write permissions for user)\".format(path))\n elif statinfo.st_uid != os.getuid():\n parser.error(\"invalid configuration file {} (the owner must be the user)\".format(path))\n return True","def init_configs():\n conf = ExtendedConfigParser()\n try:\n conf.read([vsa_conf_file])\n except ConfigParser.ParsingError, e:\n # non of the services has started, so just exit and print message directly to log file (and to stdout).\n #TODO: loggit\n #fd = open(log_file, 'w+')\n message = \"%s - Configuration file was corrupted.\" %\\\n strftime(\"%Y-%m-%d %X\", localtime())\n #fd.write(message)\n print message\n sys.exit(0)\n else:\n return conf","def find_file(fname):\n etc = os.path.join(SCPIDIR, 'etc')\n downloads = os.path.join(HOME, 'Downloads')\n configfile = os.path.join(downloads, fname)\n if os.access(configfile, os.R_OK):\n try:\n os.mkdir(etc)\n except OSError as e:\n if e.errno != errno.EEXIST:\n raise\n copy(configfile, etc)\n os.remove(configfile)\n configfile = os.path.join(etc, fname)\n try:\n fp = open(configfile)\n except IOError as e:\n if e.errno == errno.EACCES:\n # default data:\n default_file = os.path.join(SCPIDIR, fname)\n print(\"Using default data file in {}\".format(default_file))\n return default_file\n # Not a permission error.\n raise\n else:\n fp.close()\n return configfile","def loadConfig(self, name=None):\n\n configDir = self.mwGlob['configDir']\n # looking for file existence and creating new if necessary\n\n if name is None:\n name = 'config'\n fileName = configDir + '/' + name + '.cfg'\n\n if not os.path.isfile(fileName):\n self.config = self.defaultConfig()\n if name == 'config':\n self.log.warning('Config file {0} not existing'.format(fileName))\n return True\n else:\n return False\n\n # parsing the default file\n try:\n with open(fileName, 'r') as configFile:\n configData = json.load(configFile)\n except Exception as e:\n self.log.critical('Cannot parse: {0}, error: {1}'.format(fileName, e))\n self.config = self.defaultConfig()\n return False\n\n # check if reference ist still to default -> correcting\n if configData.get('reference', '') == 'config':\n del configData['reference']\n elif not configData.get('reference', ''):\n configData['profileName'] = 'config'\n\n # loading default and finishing up\n if configData['profileName'] == 'config':\n self.config = self.convertData(configData)\n return True\n\n # checking if reference to another file is available\n refName = configData.get('reference', 'config')\n if refName != name:\n suc = self.loadConfig(refName)\n else:\n self.config = configData\n return True\n return suc","def read_file():\n require_login = \"Log into KAMONOHASHI first to use 'account login' command.\"\n\n if os.path.exists(config_file_path):\n logging.info('open config file %s', config_file_path)\n with open(config_file_path) as f:\n logging.info('begin io %s', config_file_path)\n config_file = json.load(f)\n logging.info('end io %s', config_file_path)\n if not {'server', 'token'} <= set(config_file.keys()):\n raise Exception('Invalid configuration file {config_file_path}. {require_login}'\n .format(config_file_path=config_file_path, require_login=require_login))\n return config_file\n\n raise Exception('No configuration file {config_file_path}. {require_login}'\n .format(config_file_path=config_file_path, require_login=require_login))","def __check_configuration__(self, parser):\n if not parser.has_section('core'):\n self.logger.error('The config file should contain a core section with at least the module_path specified')\n sys.exit(1)\n\n else:\n if parser.get('core', 'modules_path', fallback=None) is None:\n self.logger.error('The configuration file should contain at least the modules_path value in core section.')\n sys.exit(1)\n\n if not parser.has_section('mysql'):\n self.logger.error('The config file should contain a mysql section.')\n sys.exit(1)\n\n else:\n if parser.get('mysql', 'host', fallback=None) is None:\n self.logger.error('The config file should contain the host value in mysql section.')\n sys.exit(1)\n\n if parser.get('mysql', 'port', fallback=None) is None:\n self.logger.error('The config file should contain the port value in mysql section.')\n sys.exit(1)\n\n if parser.get('mysql', 'user', fallback=None) is None:\n self.logger.error('The config file should contain the user in mysql section.')\n sys.exit(1)\n\n if parser.get('mysql', 'password', fallback=None) is None:\n self.logger.error('The config file should contain the password of the user in mysql section.')\n sys.exit(1)\n\n if parser.get('mysql', 'server_id', fallback=None) is None:\n self.logger.error('The config file should contain the server_id in mysql section.')\n sys.exit(1)\n\n if parser.get('mysql', 'tables', fallback=None) is not None:\n tables = [table.strip() for table in parser.get('mysql', 'tables').split(',')]\n for table in tables:\n if not parser.has_section(table):\n self.logger.error('The config file should contain a section about the table : %s' % table)\n exit(1)\n if parser.get(table, 'index_label', fallback=None) is None :\n self.logger.error('The config file should contain a table section with a index_label value.')\n exit(1)\n else:\n self.logger.error('The config file should contain a tables value with all the tables to replicate.')\n exit(1)","def test_old_config_fails() -> None:\n with pytest.raises(SystemExit):\n fauxmo.main(config_path_str=\"tests/old-config-sample.json\")","def default_configfile():\n dirname=None\n if os.getenv(\"HOME\"):\n dirname=os.getenv(\"HOME\")\n elif os.getenv(\"USERPROFILE\"):\n dirname=os.getenv(\"USERPROFILE\")\n\n else:\n raise FattyException(\"No HOME or USERPROFILE variable set, unable to determine default config file\")\n\n return os.path.join(dirname,\".fattybugs\")","def determine_config() -> str:\n if os.environ.get(PortholeConfig.CONFIG_ENV_NAME) is not None:\n return os.environ.get(PortholeConfig.CONFIG_ENV_NAME)\n if os.path.isfile(PortholeConfig.DEFAULT_CONFIG_FILE):\n return PortholeConfig.DEFAULT_CONFIG_FILE\n for file_path in PortholeConfig.OTHER_ALLOWED_CONFIG_PATHS:\n if os.path.isfile(file_path):\n return file_path\n raise FileNotFoundError(\n \"Porthole is unable to locate a useable config file. \"\n \"Try setting the PORTHOLE_CONFIG environment variable, \"\n \"or creating a porthole.ini file in your main project directory.\"\n )","def test_broken_config(broken_config):\n with pytest.raises(RuntimeError, match=\"Error reading config.yml\"):\n abcconfig.get_config(broken_config)","def testNoConfig(self):\n\n mockOpen = mock.mock_open()\n with mock.patch('__builtin__.open', mockOpen, create=True):\n self.assertRaises(\n IOError,\n tools.Config,\n 'fakeIniFile.ini'\n )\n\n mockOpen.assert_called_once_with('fakeIniFile.ini', 'w')\n mockOpen().write.assert_called_once_with(tools.SAMPLE_CONFIG)","def test_find_config_default(tmpdir, config_dir):\n working_dir = tmpdir.mkdir(\"working\")\n working_dir.join('local.cfg').write('')\n\n with cd(working_dir.strpath):\n found_config = find_config(config_dir.strpath, 'config')\n assert found_config == config_dir.join('config.cfg').strpath\n\n found_config = find_config(config_dir.strpath, 'config.cfg')\n assert found_config == config_dir.join('config.cfg').strpath","def _open_config_file(self):\n try:\n with open(self.config_file_name,encoding='utf-8') as json_data_file:\n conf = json.load(json_data_file)\n return conf\n except FileNotFoundError:\n with open(self.config_file_name, 'w',encoding='utf-8') as json_data_file:\n json.dump({},json_data_file,indent=2)\n return {}","def is_config_exist(self) -> bool:\n pass","def _load_config(file):\n try:\n return bb.parse.handle(os.path.join('conf', file), bb.data.init() )\n except IOError, e:\n return None","def test_blank_config_doesnt_crash(tmpdir):\n config = tmpdir.join(\"config.yml\")\n config.write('')\n util.read_config(tmpdir)","def test_no_config(self):\n exit_code = self.run_beat()\n\n assert exit_code == 1\n assert self.log_contains(\"error loading config file\") is True","def test_invalid_config(self):\n shutil.copy(self.beat_path + \"/tests/files/invalid.yml\",\n os.path.join(self.working_dir, \"invalid.yml\"))\n\n exit_code = self.run_beat(config=\"invalid.yml\")\n\n assert exit_code == 1\n assert self.log_contains(\"error loading config file\") is True","def check_for_config(conf, confs_path):\n if yes_no('Is there a configuration file you would like to load?'):\n options = os.listdir(confs_path)\n if len(options) > 0:\n options.append('Specify a Path')\n option = ask_options(\n 'Pick a configuration file', options, title=False)\n if option == 'Specify a Path':\n conf['config'] = ask_path(\n 'Enter the path for the configuration file')\n else:\n conf['config'] = os.path.join(confs_path, option)\n else:\n conf['config'] = ask_path(\n 'Enter the path for the configuration file')\n conf = get_config_file(conf)\n conf, _ = confirm_conf(conf)\n conf.pop('config')\n return conf","def read_config(self):\n default = \"/usr/local/etc/kattisrc\"\n cfg = configparser.ConfigParser()\n if os.path.exists(default):\n cfg.read(default)\n\n if not cfg.read([os.path.join(os.getenv('HOME'), '.kattisrc'),\n os.path.join(os.path.dirname(os.path.expanduser(\"~\")), '.kattisrc')]):\n raise KattisConfigError(\n \"Could not locate .kattisrc! Make sure it is placed under your home directory!\")\n return cfg","def __create_default_config(self):\n if not os.path.exists(self.__configfile):\n path=os.path.dirname(self.__configfile)\n try:\n os.makedirs(path)\n except:\n pass\n if os.path.exists(path):\n self.save(defaults=True)","def test_read_no_env_config():\n data = \"\"\n with mock.patch(\n \"configparser.open\",\n # \"builtins.open\",\n mock.mock_open(read_data=data),\n ):\n testargs = [\"yessssms\", \"-m\", \"Bilde mir nicht ein was rechts zu wissen\"]\n with (mock.patch.object(sys, \"argv\", testargs)):\n with pytest.raises(SystemExit) as wrapped_e:\n cli = CLI()\n assert cli.read_env_config() is None\n assert wrapped_e.type == SystemExit\n assert wrapped_e.value.code == 2","def read_config_file():\n\tsuccess = config_parser.read([config_file])\n\n\tif not success:\n\t\tprint \"Failed to parse config file '%s'\" % config_file\n\t\treturn False\n\n\treturn True","def test_get_config_does_not_exist():\n with pytest.raises(\n FileNotFoundError, match=\"Oops! I can't seem to find a config.yml\"\n ):\n abcconfig.get_config(\"dirthatdoesntexist\")","def init_cfg(input_path, quiet):\n config_file = getConfigPath(input_path)\n\n if not os.path.exists(config_file) or quiet:\n confirm_overwrite = True\n else:\n confirm_overwrite = click.confirm(\n '\\n{} already exists. Do you want to overwrite it?'.format(config_file))\n if confirm_overwrite:\n configHandler(config_file).resetConfig()\n click.secho('{} created'.format(config_file), fg='green')","def read_config(self, config_filename):","def test_config_filename_not_given_envvar_is_empty(monkeypatch):\n monkeypatch.delenv(ENV_CONFIG_FILE)\n with pytest.raises(ValueError):\n Config()","def create_default_config():\n import codecs\n config = ConfigParser.SafeConfigParser()\n config.readfp(StringIO(DEFAULT_CONFIG))\n\n # Load user settings\n filename = get_user_config_filename()\n if not os.path.exists(filename):\n from wizard import setup_wizard\n setup_wizard(config)\n else:\n try:\n fi = codecs.open(filename, 'r', encoding='utf-8')\n config.readfp(fi)\n finally:\n fi.close()\n return config","def test_bad_config_file_path_or_name():\n cli_result = subprocess.run(\n ['kaiba', 'config.js', 'input.json'],\n capture_output=True,\n )\n assert b'FileNotFoundError' in cli_result.stderr\n assert b'config.js' in cli_result.stderr","def _cfg_path(argv):\n cfg_path = argv[1] if len(argv) > 1 else None\n _is_file = os.path.isfile\n if not cfg_path or not _is_file(cfg_path):\n if cfg_path:\n _info(\"no config at {}, trying the default location\".format(\n cfg_path))\n cfg_path = _DEFAULT_PATH\n if not _is_file(cfg_path):\n _info(\"no config at {}, exiting\".format(cfg_path))\n return None\n return cfg_path","def test_config_filename_given_file_doesnt_exist():\n config_file_name = \"i_dont_exist.ini\"\n assert not os.path.exists(config_file_name)\n\n with pytest.raises(Exception):\n Config(filename=config_file_name)","def get_default_config_file() -> Path:\n return get_path_to_pyflow() / \"pyflow\" / \"conf\" / CONFIG_FILE","def get_config_parser():\n config = configparser.ConfigParser()\n if os.path.exists(CONFIGURATION_FILE_PATH) and os.path.isfile(CONFIGURATION_FILE_PATH):\n config.read(CONFIGURATION_FILE_PATH)\n return config\n else:\n logging.error(\"Config file not found, create %s\" % CONFIGURATION_FILE_PATH)\n exit(1)","def check() -> bool:\n\ttry:\n\t\twith open(configPath, 'r') as file:\n\t\t\tcfg = json.load(file) # load the file\n\texcept FileNotFoundError:\n\t\treturn False\n\t# check if EVERY config exists\n\tfor i in default_config.keys():\n\t\tif i in cfg.keys():\n\t\t\tcontinue\n\t\treturn False\n\t# final check\n\treturn cfg['config_type'] == default_config['config_type']","def require_config(self) -> None:\n if not self.has_config():\n fail(f\"No tzk_config.py found in the current directory. \"\n f\"(Try 'tzk init' if you want to create a new one.)\")","def load_default_config_file(filename: str) -> str:\n try:\n raw_contents = resource_string(__name__, 'configuration/' + filename)\n except FileNotFoundError:\n raise BscanConfigError(\n 'Unable to find default configuration file `' + filename + '`')\n return raw_contents.decode('utf-8')","def read_config() -> dict:\n if not os.path.exists(Vars.default_config_path):\n raise Exception(\"You should run many_pynb.run at first.\")\n\n with open(Vars.default_config_path, \"r\") as f:\n config = json.load(f)\n return(config)","def test_config_filename_not_given_file_doesnt_exist(monkeypatch):\n config_file_name = \"i_dont_exist.ini\"\n assert not os.path.exists(config_file_name)\n\n monkeypatch.setenv(ENV_CONFIG_FILE, config_file_name)\n with pytest.raises(Exception):\n Config()","def is_config_exist(self) -> bool:\n return True","def test_defaultFile(self):\n found = cesmEnvLib.checkFile(\"./test_checkXMLvar.py\", \"read\")\n self.assertTrue(found)","def load_cfg(self, config_path):\n def build_default_cfg():\n \"\"\"\n Restore default config file by writing on file\n :return: default configuration contained in the dictionary DEF_CONF\n \"\"\"\n with open(Daemon.CONFIG_FILEPATH, 'wb') as fo:\n json.dump(Daemon.DEF_CONF, fo, skipkeys=True, ensure_ascii=True, indent=4)\n return Daemon.DEF_CONF\n\n # Search if config directory exists otherwise create it\n if not os.path.isdir(Daemon.CONFIG_DIR):\n try:\n os.makedirs(Daemon.CONFIG_DIR)\n except (OSError, IOError):\n self.stop(1, '\\nImpossible to create \"{}\" directory! Permission denied!\\n'.format(Daemon.CONFIG_DIR))\n\n if os.path.isfile(config_path):\n try:\n with open(config_path, 'r') as fo:\n loaded_config = json.load(fo)\n except ValueError:\n print '\\nImpossible to read \"{0}\"! Config file overwrited and loaded default config!\\n'.format(config_path)\n return build_default_cfg()\n corrupted_config = False\n for k in Daemon.DEF_CONF:\n if k not in loaded_config:\n corrupted_config = True\n # In the case is all gone right run config in loaded_config\n if not corrupted_config:\n return loaded_config\n else:\n print '\\nWarning \"{0}\" corrupted! Config file overwrited and loaded default config!\\n'.format(config_path)\n return build_default_cfg()\n else:\n print '\\nWarning \"{0}\" doesn\\'t exist, Config file overwrited and loaded default config!\\n'.format(config_path)\n return build_default_cfg()","def test_config_device_restore_missing(get_config, config_dict, monkeypatch, write_config_fixture):\n fname = 'will_be_missing.yml'\n # saving normal conf\n is_default = {'test': 'conf'}\n monkeypatch.setattr(DeviceConfig, 'minimal_essential_conf', is_default)\n cfg = get_config(DeviceConfig, config_dict, fname=fname)\n cfg.save()\n path = write_config_fixture('corrupted_string', fname)\n os.remove(path)\n # trying to read from non-existent file\n should_be_default = cfg.read()\n\n assert should_be_default == is_default, 'configs not matched'","def load_config():\n try:\n f = open(Filenames.CONFIG, 'r')\n j = json_load_as_ascii(f)\n except ValueError:\n error_message = (\"ERROR! (terminating...)\\n\" +\n (\"The config file (%s) has invalid/corrupt JSON and can not be read. \" % Filenames.CONFIG) +\n \"Please fix, otherwise delete the file and rerun the daemon \" +\n \"(which will create a default config)\")\n print \"\\n\", error_message\n add_to_error_log(error_message)\n exit()\n except IOError:\n print \"The config file (%s) doesn't exist. Creating a new one with default sample contents:\" % Filenames.CONFIG\n f = open(Filenames.CONFIG, 'w')\n j = {\n ConfigFields.BIN_DURATION: 60,\n ConfigFields.OUTBOX_DATA_LIMIT: 1000,\n ConfigFields.DATABASE_DOMAIN: \"http://test-003.t2.ucsd.edu:8086\",\n ConfigFields.METRICS: [\n {\n MetricsFields.DATABASE_NAME: \"DefaultDB\",\n MetricsFields.MEASUREMENT_NAME: \"num_jobs\",\n MetricsFields.METRIC_TYPE: MetricsFields.MetricTypes.COUNTER,\n MetricsFields.GROUP_FIELDS: [\"User\", \"SUBMIT_SITE\", \"MATCH_EXP_JOB_Site\"],\n MetricsFields.AGGREGATE_OP: CounterMetricFields.AggregationOps.ALL,\n MetricsFields.JOB_STATUSES: [MetricsFields.JobStatuses.RUNNING_OR_RAN],\n MetricsFields.DESCRIPTION: \"The number of jobs which have run across owners and sites\"\n }\n ]\n }\n print stringify(j)\n json.dump(j, f, indent=4)\n f.close()\n return j","def test_config_save_error(self):\n\n config_filename_initial = 'test_configuration2'\n config_filename_save = 'save_bad_configuration'\n\n # Get config path\n local_dir = os.path.dirname(__file__)\n config_path_initial = os.path.join(local_dir, config_filename_initial)\n config_path_save = os.path.join(local_dir, config_filename_save)\n\n # Load initial configuration from file\n config_initial = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,\n neat.DefaultSpeciesSet, neat.DefaultStagnation,\n config_path_initial)\n\n config_initial.genome_config.connection_fraction = 1.5\n\n try:\n config_initial.save(config_path_save)\n except RuntimeError:\n pass\n else:\n raise Exception(\"Did not get RuntimeError on attempt to save bad partial configuration\")","def __init__(self, filename=None):\n if filename:\n if not os.path.exists(filename):\n raise Exception(\"No configuration found at %s\" % filename)\n super(Configuration, self).__init__(filename)","def init_config(env):\n doc = ''\n if env == 'local':\n with open('./config/local.yml', 'r') as f:\n doc = load(f)\n elif env == 'staging':\n with open('./config/staging.yml', 'r') as f:\n doc = load(f)\n elif env == 'prod':\n with open('./config/prod.yml', 'r') as f:\n doc = load(f)\n else:\n with open(env, 'r') as f:\n doc = load(f)\n if doc == '':\n logging.error(\"Couldn't load config properly\")\n return doc","def test_no_config_file(self):\r\n instance = self._makeOne()\r\n\r\n # No default config file search in case they would exist\r\n self.assertTrue(len(instance.searchpaths) > 0)\r\n instance.searchpaths = []\r\n\r\n instance.exit = dummy_exit()\r\n\r\n instance.realize(args=['-s', 'http://localhost:9001', '-u', 'chris',\r\n '-p', '123'])\r\n\r\n self.assertEqual(instance.interactive, 1)\r\n self.assertEqual(instance.serverurl, 'http://localhost:9001')\r\n self.assertEqual(instance.username, 'chris')\r\n self.assertEqual(instance.password, '123')","def load_config(filename):\n filepaths = []\n for dirpath in os.path.expanduser('~'), os.curdir, '':\n try:\n filepath = os.path.join(dirpath, filename)\n filepaths.append(filepath)\n with open(filepath, 'r') as f:\n return Config(yaml.safe_load(f))\n except IOError:\n pass\n raise IOError('Configuration file not found: ' + ', '.join(filepaths))","def _get_config_file(filepath=None):\n if filepath:\n if os.path.isfile(filepath):\n return filepath\n raise ConfigFileNotFound(filepath)\n\n _config_files = (_path / _config_filename for _path in _config_basepaths)\n for _filepath in _config_files:\n if os.path.isfile(_filepath):\n return _filepath\n raise ConfigFileNotFound(_config_files)","def _get_config_parsser(config_file):\n config_parser = Parser()\n # read() return a list of file name that read success\n open_success_file = config_parser.read(config_file)\n if len(open_success_file) == 0:\n return 1, \"can not open file: \" + config_file\n else:\n return 0, config_parser","def read_config():\n config = configparser.ConfigParser()\n if not os.path.exists(\"config.cfg\"):\n raise FileNotFoundError(\"configuration file (config.cfg) not found!\")\n config.read(\"config.cfg\")\n return config","def load_config(config_file: Path) -> Dict[str, Any]:\n config, errors = check_config(config_file)\n if errors is not None:\n raise next(iter(errors))\n # errors is None\n assert config is not None\n return config","def parse_config():\n config_path = Path(\"config.ini\")\n if config_path.exists():\n config.read(config_path)\n else:\n config[\"database\"] = {\"location\": \"image-database.db\"}\n config[\"images\"] = {\"extensions\": \".jpeg,.jpg,.png,.gif,.tiff\"}\n with open(config_path, \"w\") as configfile:\n config.write(configfile)\n config.read(config_path)"],"string":"[\n \"def check_config_file():\\n # Locate and init config.\\n default_config = \\\"config.json\\\"\\n if len(sys.argv) == 2:\\n # config from command line\\n app_config = config_reader(sys.argv[1])\\n else:\\n # config should be in default\\n app_config = config_reader(default_config)\\n # fin\\n if not app_config:\\n print(\\\"Exiting due to invalid config file.\\\")\\n return False\\n # fin\\n return app_config\",\n \"def test_nonexisting_config(self):\\n try:\\n tempdir = tempfile.mkdtemp()\\n filename = os.path.join(tempdir, \\\"Config.yaml\\\")\\n with self.assertRaises(easydms.config.ErrorNoConfiguration):\\n easydms.config.Config(filename)\\n\\n with self.assertRaises(SystemExit) as cm:\\n sys.argv = [\\\"prog\\\", \\\"-c\\\", filename]\\n easydms.cli.main()\\n self.assertNotEqual(cm.exception.code, 0)\\n\\n finally:\\n shutil.rmtree(tempdir)\",\n \"def load(filename, defaultConfig={}, writeIfNonExistent=True, quitIfNonExistent=False):\\n global _loaded\\n assert filename and isinstance(filename, basestring)\\n\\n #all keys and values in defaultConfig must be strings\\n #(to make it match what would be read in by ConfigParser)\\n #lets error out if we find a key or value that isn't a string\\n for (key, value) in defaultConfig.iteritems():\\n if not isinstance(key, basestring):\\n raise KeyError(\\\"Invalid defaultConfig: key \\\\\\\"%s\\\\\\\" is not a string\\\" % str(key))\\n if not isinstance(value, basestring):\\n raise ValueError(\\\"Invalid defaultConfig: value of key \\\\\\\"%s\\\\\\\" (\\\\\\\"%s\\\\\\\") is not a string\\\" \\n % (str(key), str(value)))\\n\\n _loaded = defaultConfig.copy()\\n \\n configFileExists = os.path.exists(filename)\\n \\n #If we just want to \\\"load\\\" the default configuration\\n if writeIfNonExistent and not configFileExists:\\n log.msg(\\\"Configuration file \\\\\\\"%s\\\\\\\" does not exist...\\\" % filename, lvl='w', ss='ss_configfile')\\n try:\\n write(filename)\\n except:\\n raise\\n \\n #if quitIfNonExistent is set, keep going to the next block of code\\n #so we can quit out properly\\n if not quitIfNonExistent:\\n return\\n\\n if quitIfNonExistent and not configFileExists:\\n #print different messages depending on if the default\\n #config file was written or not\\n if writeIfNonExistent:\\n log.msg(\\\"Quitting as configuration file did not exist. Please \\\"\\n \\\"edit the default configuration that has been written \\\"\\n \\\"to \\\\\\\"%s\\\\\\\" to suit your environment and start the program \\\"\\n \\\"again.\\\" % filename, lvl='c', ss='ss_configfile')\\n sys.exit(0)\\n else:\\n log.msg(\\\"Quitting as configuration file \\\\\\\"%s\\\\\\\" does not exist.\\\"\\n \\\" Please create this file and try again.\\\" % filename)\\n sys.exit(1)\\n\\n log.msg(\\\"Reading configuration from \\\\\\\"%s\\\\\\\"...\\\" % filename, lvl='i', ss='ss_configfile')\\n _loaded = simpleReadConfigFile(filename, useLogging=True,\\n level=consts.LOGLVL_DEBUG3)\\n \\n log.msg(\\\"ACTIVE CONFIGURATION: \\\" + str(_loaded),\\n lvl='d2', ss='ss_configfile')\",\n \"def test_load_configuration_fails_gracefully_when_file_does_not_exist():\\n config.load_configuration(invalid_configuration_path, graceful=True)\\n assert True\",\n \"def init_config():\\n config_file = create_config_file.CreateConfigFile()\\n config_file.check_if_config_file_exists()\",\n \"def _ensure_config_file_exists():\\n config_file = Path(ELIBConfig.config_file_path).absolute()\\n if not config_file.exists():\\n raise ConfigFileNotFoundError(ELIBConfig.config_file_path)\",\n \"def init_default_config_file_if_nonexistent(package, default_config):\\n config_file = os.path.join(conf.PAULA_USER_CONFIG_DIR, package + conf.CONFIG_EXTENSION)\\n debug('config_file = ' + config_file)\\n if not os.path.exists(config_file):\\n debug('making: \\\\\\\"' + config_file+ '\\\\\\\"')\\n shutil.copyfile(default_config, config_file)\",\n \"def fallback_file(cls, filename):\\n file_list = (\\n filename,\\n path.join(path.expanduser('~'), '.config', 'hiromi.json'),\\n path.join(path.expanduser('~'), '.hiromi')\\n )\\n for a_file in file_list:\\n if path.exists(a_file):\\n return a_file\\n print(\\n \\\"Please given a legal config file, or make a config file at\\\"\\n \\\"~/.hiromi or ~/.config/hiromi.json\\\"\\n )\\n raise ConfigNotFoundException()\",\n \"def get_config_file(self):\\n\\n conf_file = self.args.file\\n if conf_file is not None:\\n if os.path.isfile(conf_file):\\n config_file = open(conf_file, \\\"r\\\")\\n self.main_file = yaml.load(config_file, Loader=yaml.FullLoader)\\n elif os.path.isfile(\\n os.path.join(get_path(\\\"DEFAULT\\\", \\\"config_file_path\\\"), conf_file)\\n ):\\n fpath = get_path(\\\"DEFAULT\\\", \\\"config_file_path\\\")\\n config_file = open(os.path.join(fpath, conf_file), \\\"r\\\")\\n self.main_file = yaml.load(config_file, Loader=yaml.FullLoader)\\n else:\\n self.logger.error(\\n colorama.Fore.RED\\n + \\\"ERROR!! Config file '%s' is not present \\\" % conf_file,\\n extra=self.log_detail,\\n )\\n sys.exit(1)\\n else:\\n if self.args.hostname and self.args.testfiles:\\n temp_dict = {\\n \\\"hosts\\\": [{\\\"device\\\": \\\"\\\", \\\"username\\\": \\\"\\\", \\\"passwd\\\": \\\"\\\"}],\\n \\\"tests\\\": [],\\n }\\n temp_dict[\\\"hosts\\\"][0][\\\"device\\\"] = self.args.hostname\\n temp_dict[\\\"hosts\\\"][0][\\\"username\\\"] = self.args.login\\n temp_dict[\\\"hosts\\\"][0][\\\"passwd\\\"] = self.args.passwd\\n for tfile in self.args.testfiles:\\n temp_dict[\\\"tests\\\"].append(tfile)\\n self.main_file = temp_dict\\n\\n if (\\n self.main_file.__contains__(\\\"sqlite\\\")\\n and self.main_file[\\\"sqlite\\\"]\\n and self.main_file[\\\"sqlite\\\"][0]\\n ):\\n self.chk_database(\\n self.main_file,\\n self.args.pre_snapfile,\\n self.args.post_snapfile,\\n self.args.check,\\n self.args.snap,\\n )\\n else:\\n # if --check option is given for sqlite, then snap file name is not compulsory\\n # else exit the function saying arguments not correct\\n if self.args.check is True and (\\n self.args.pre_snapfile is None or self.args.post_snapfile is None\\n ):\\n self.logger.error(\\n colorama.Fore.RED\\n + \\\"Arguments not given correctly, Please refer help message\\\",\\n extra=self.log_detail,\\n )\\n self.parser.print_help()\\n sys.exit(1)\",\n \"def _findConfig(self, _file = file):\\n import errno\\n\\n config_file = self.runtime.config\\n if config_file:\\n try:\\n return config_file == '-' and sys.stdin or _file(config_file)\\n except IOError, exc:\\n raise ConfigNotFoundError(\\\"%s: %s\\\" % (config_file, str(exc)))\\n\\n for config_file in self._getDefaultConfigFiles():\\n try:\\n return _file(config_file)\\n except IOError, exc:\\n # try next one only if not found\\n if exc[0] != errno.ENOENT:\\n raise ConfigNotFoundError(\\\"%s: %s\\\" % (\\n config_file, str(exc)\\n ))\\n\\n raise ConfigMissingError(\\\"No config file found\\\")\",\n \"def default_configfile(self):\\r\\n config = None\\r\\n for path in self.searchpaths:\\r\\n if os.path.exists(path):\\r\\n config = path\\r\\n break\\r\\n if config is None and self.require_configfile:\\r\\n self.usage('No config file found at default paths (%s); '\\r\\n 'use the -c option to specify a config file '\\r\\n 'at a different path' % ', '.join(self.searchpaths))\\r\\n return config\",\n \"def get_config(file_name, fallback = True):\\n exec_dir = get_exec_path()\\n if file_name == 'logging.conf' and not hasattr(sys, \\\"frozen\\\"):\\n config_path = os.path.join(exec_dir, 'pyfpdb', file_name)\\n else:\\n config_path = os.path.join(exec_dir, file_name)\\n# print \\\"config_path=\\\", config_path\\n if os.path.exists(config_path): # there is a file in the cwd\\n return (config_path,False) # so we use it\\n else: # no file in the cwd, look where it should be in the first place\\n default_dir = get_default_config_path()\\n config_path = os.path.join(default_dir, file_name)\\n# print \\\"config path 2=\\\", config_path\\n if os.path.exists(config_path):\\n return (config_path,False)\\n\\n# No file found\\n if not fallback:\\n return (False,False)\\n\\n# OK, fall back to the .example file, should be in the start dir\\n if os.path.exists(file_name + \\\".example\\\"):\\n try:\\n print \\\"\\\"\\n check_dir(default_dir)\\n shutil.copyfile(file_name + \\\".example\\\", config_path)\\n msg = \\\"No %s found\\\\n in %s\\\\n or %s\\\\n\\\" % (file_name, exec_dir, default_dir) \\\\\\n + \\\"Config file has been created at %s.\\\\n\\\" % config_path\\n print msg\\n logging.info(msg)\\n file_name = config_path\\n except:\\n print \\\"Error copying .example file, cannot fall back. Exiting.\\\\n\\\"\\n sys.stderr.write(\\\"Error copying .example file, cannot fall back. Exiting.\\\\n\\\")\\n sys.stderr.write( str(sys.exc_info()) )\\n sys.exit()\\n else:\\n print \\\"No %s found, cannot fall back. Exiting.\\\\n\\\" % file_name\\n sys.stderr.write(\\\"No %s found, cannot fall back. Exiting.\\\\n\\\" % file_name)\\n sys.exit()\\n return (file_name,True)\",\n \"def validate_config(location):\\n if not os.path.exists(location):\\n full_path = os.path.abspath(location)\\n logging.fatal('Config not found - expected a configfile at: [{loc}] - exiting.'.format(loc=full_path))\\n sys.exit(1)\",\n \"def test_load_configuration_raises_an_exception_when_file_does_not_exist():\\n with pytest.raises(FileNotFoundError):\\n config.load_configuration(invalid_configuration_path)\",\n \"def test_config():\\n if not os.path.exists(CONFIG_DIR):\\n raise mupub.BadConfiguration('Configuration folder not found.')\\n if not os.path.exists(_CONFIG_FNM):\\n raise mupub.BadConfiguration('Configuration file not found.')\\n if not os.path.exists(getDBPath()):\\n raise mupub.BadConfiguration('Local database not found.')\\n if len(CONFIG_DICT) == 0:\\n raise mupub.BadConfiguration('Configuration was not loaded.')\",\n \"def test_find_config_nonexist(self):\\n with pytest.raises(scuba.config.ConfigError):\\n scuba.config.find_config()\",\n \"def _check(self, config: Dict):\\n if 'path' not in config:\\n raise FileNotFoundError(\\\"File not found.\\\")\",\n \"def config_reader(config_file):\\n if os.path.exists(config_file):\\n with open(config_file, 'r') as cfile:\\n app_config = json.load(cfile)\\n # end with\\n return app_config\\n else:\\n print(\\\"The config file: {} does not exist, please try again.\\\".format(config_file))\\n return False\\n # fin\",\n \"def init():\\n for config_filename in _config_utils.CONFIG_FILENAMES:\\n if os.path.isfile(config_filename):\\n config_filepath = os.path.abspath(config_filename)\\n click.echo(\\\"found existing config file {}\\\".format(config_filepath))\\n return\\n\\n config_filepath = _config_utils.create_empty_config_file('.')\\n click.echo(\\\"initialized empty config file {}\\\".format(config_filepath))\",\n \"def test_nonexistent_config_options(self, capsys):\\n with open(self.config_file, \\\"w\\\") as f:\\n f.write(\\n textwrap.dedent(\\n \\\"\\\"\\\"\\n [DEFAULT]\\n foo=bar\\n \\\"\\\"\\\"\\n )\\n )\\n with pytest.raises(SystemExit) as excinfo:\\n self.config_parser.parse_config_options(self.namespace, configs=[self.config_file])\\n out, err = capsys.readouterr()\\n assert not out\\n assert \\\"failed loading config: unknown arguments: --foo=bar\\\" in err\\n assert excinfo.value.code == 2\",\n \"def _findconfigfile():\\n\\n # A ordered list of possible config files\\n configfiles = [\\\"~/.githubhooksrc\\\",\\n \\\"/etc/githubhooks\\\"]\\n\\n for configfile in configfiles:\\n if os.path.isfile(os.path.expanduser(configfile)):\\n return os.path.expanduser(configfile)\\n\\n # No valid config file found\\n print \\\"ERROR: No valid config file found in any of the following locations:\\\"\\n for configfile in configfiles:\\n print \\\" - %s\\\" % configfile\\n sys.exit(1)\",\n \"def test_no_default(self):\\n with self.assertRaises(ConfigError) as cm:\\n imageroller.main.read_config(\\n self._cmd_args,\\n imageroller.test.get_config_parser(self._no_default))\\n # ConcurrentWorkers is the first value that is checked\\n self.assertEqual(str(cm.exception),\\n \\\"Config must contain ConcurrentWorkers\\\")\",\n \"def try_read_file():\\n try:\\n logging.info('open config file %s', config_file_path)\\n with open(config_file_path) as f:\\n logging.info('begin io %s', config_file_path)\\n config_file = json.load(f)\\n logging.info('end io %s', config_file_path)\\n return config_file\\n except (OSError, IOError) as error:\\n logging.info('try_read error %s', error)\\n return {}\",\n \"def __check_config(self):\\n if not os.path.exists(self.__config_path):\\n return False\\n else:\\n return True\",\n \"def find_config_file(self):\\n filename = self.values.get('config_file', Default('noy.json'))\\n\\n ignore_missing = False\\n if isinstance(filename, Default):\\n filename = filename.val\\n ignore_missing = True\\n\\n filename = os.path.abspath(filename)\\n if os.path.exists(filename):\\n return filename\\n elif not ignore_missing:\\n raise MissingConfigFile(\\\"Config file doesn't exist at {}\\\".format(filename))\",\n \"def get_conf(self, file_name):\\n try:\\n self.conf = Config(file_name)\\n except ImportError:\\n s = \\\"No such file in simulation directory: \\\" + file_name\\n self.abort(ImportError, s)\",\n \"def read_config(self) -> None:\\n\\n if self.parsing_finished is True:\\n return\\n\\n default_config_file = self.get_config_file_path(default_config_file_path)\\n\\n # check if default config file actually exists\\n # and add it to the list of files to parse\\n if os.path.exists(default_config_file) and len(self.file_list) == 0:\\n self.file_list.append(default_config_file)\\n\\n # check if config file exists\\n for f in self.file_list:\\n\\n # check if file exists\\n if not os.path.exists(f):\\n self._add_error(f'Config file \\\"{f}\\\" not found')\\n self.file_list.remove(f)\\n continue\\n\\n # check if it's an actual file\\n if not os.path.isfile(f):\\n self._add_error(f'Config file \\\"{f}\\\" is not an actual file')\\n self.file_list.remove(f)\\n continue\\n\\n # check if config file is readable\\n if not os.access(f, os.R_OK):\\n self._add_error(f'Config file \\\"{f}\\\" not readable')\\n self.file_list.remove(f)\\n continue\\n\\n for config_file in self.file_list:\\n\\n config_file_type = ConfigFile.get_file_type(config_file)\\n\\n if config_file_type is None:\\n self._add_error(f\\\"Unknown/Unsupported config file type \\\"\\n f\\\"'{ConfigFile.get_suffix(config_file)}' for {config_file}\\\")\\n continue\\n\\n if config_file_type == ConfigFileINI:\\n config_data = self._parse_ini(config_file)\\n elif config_file_type == ConfigFileYAML:\\n config_data = self._parse_yaml(config_file)\\n else:\\n continue\\n\\n self._add_config_data(config_data, config_file)\\n\\n # parse common and netbox config from env\\n for section in [common_config_section_name, netbox_config_section_name]:\\n env_config_data = self._parse_section_env_vars(section)\\n self._add_config_data(env_config_data)\\n\\n # parse source data from env\\n env_config_data = self._parse_source_env_vars()\\n self._add_config_data(env_config_data)\\n\\n self.parsing_finished = True\",\n \"def load_configuration_or_abort(app, environ_variable, mandatory_config_keys=[]):\\n\\n try:\\n config_file = load_config_file(environ_variable)\\n app.config.from_pyfile(config_file, silent=False)\\n except Exception as e:\\n print(str(e))\\n exit(-1)\\n\\n assert_configs(app.config, mandatory_config_keys, config_file)\\n\\n print((\\\"ZEEGUU: Loaded {0} config from {1}\\\".format(app.name, config_file)))\",\n \"def load_config_file(self):\\n\\n conf_file = config.DEFAULT_CONFIGURATION_FILE\\n\\n if self.options and getattr(self.options, \\\"conf_file\\\"):\\n conf_file = self.options.conf_file\\n if (\\n not os.path.exists(conf_file) and\\n not os.path.exists(\\\"%s.d\\\" % conf_file)\\n ):\\n raise Exception(\\n (\\n \\\"The specified configuration file \\\"\\n \\\"does not exist. File=(%s)\\\"\\n ) % self.options.conf_file\\n )\\n\\n self.from_file(conf_file)\",\n \"def test_readable_error_if_file_not_found(self):\\n fake_path = 'this/path/is/not/real'\\n self.assertEqual(LoadJsonConfig.read_config_file(LoadJsonConfig(), fake_path), 'File not found at ' + fake_path)\",\n \"def test_invalid_missing_config(self):\\n invalid_config_data = 'test'\\n with mock_open(LAMBDA_FILE, invalid_config_data):\\n with mock_open(GLOBAL_FILE, invalid_config_data):\\n with patch('os.path.exists') as mock_exists:\\n mock_exists.return_value = False\\n _load_config()\",\n \"def load_config(configFile):\\r\\n\\r\\n # TODO: Implement this\\r\\n return False\",\n \"def init():\\n file_name = 'config.json'\\n home_directory_path = str(Path.home())\\n config_file_directory = home_directory_path+\\\"/.config/files/\\\"\\n full_path = config_file_directory + file_name\\n\\n if os.path.isfile(full_path) and os.access(full_path, os.R_OK): # Readable Config file exists and is valid\\n try:\\n with open(full_path) as file:\\n json_file = json.load(file)\\n load_json_and_arguments(json_file)\\n\\n except ValueError as exception:\\n raise ValueError(\\\"Invalid JSON configuration file\\\")\\n\\n elif not os.path.isfile(full_path): # Config file doesn't exist yet, create it\\n\\n if not os.path.exists(config_file_directory): # Make the directory if that doesn't exist as well\\n os.makedirs(config_file_directory)\\n\\n get_account_info(full_path)\\n\\n else:\\n raise IOError(\\\"Config file: \\\" + full_path + \\\" not accessible\\\")\",\n \"def check_config(self):\\n cfgs = self.__get() \\n \\n for option in Config.FILE_OPTIONS.keys():\\n _default = Config.FILE_OPTIONS[option]\\n \\n if not cfgs.has_key(option):\\n self.log.warn(\\\"Parameter '%s' is missing in '%s', using default('%s')\\\" % \\\\\\n (option, self.config_file, _default))\\n _file = _default\\n else:\\n _file = cfgs[option]\\n Config.FILE_OPTIONS[option] = _file\\n\\n if not os.path.exists(_file) and not os.path.isfile(_file):\\n self.log.error(\\\"Paramenter '%s' points to non-existing file '%s')\\\" % \\\\\\n (option, _file))\\n raise ConfigError('File Error', \\\"Paramenter '%s' points to non-existing file '%s')\\\" % \\\\\\n (option, _file))\\n\\n\\n for option in Config.PATH_OPTIONS.keys():\\n _default = Config.PATH_OPTIONS[option]\\n \\n if not cfgs.has_key(option):\\n self.log.warn(\\\"Parameter '%s' is missing in '%s', using default('%s')\\\" % \\\\\\n (option, self.config_file, _default))\\n _dir = _default\\n else:\\n _dir = cfgs[option]\\n Config.PATH_OPTIONS[option] = _dir\\n\\n if not os.path.exists(_dir) and not os.path.isdir(_dir):\\n self.log.error(\\\"Paramenter '%s' points to non-existing directory '%s')\\\" % \\\\\\n (option, _dir))\\n raise ConfigError('File Error', \\\"Paramenter '%s' points to non-existing directory '%s')\\\" % \\\\\\n (option, _dir))\\n\\n \\n Config.DB_SFT_OPTIONS['sqlalchemy_sft.url'] = cfgs['sqlalchemy_sft.url']\\n Config.DB_NAGIOS_OPTIONS['sqlalchemy_nagios.url'] = cfgs['sqlalchemy_nagios.url']\\n\\n self.log.debug(\\\"Configuration successfully checked\\\")\",\n \"def use_config_file(self):\\n self.config_file = self.find_config_file()\\n if self.config_file:\\n self.apply_config_file(self.config_file)\",\n \"def test_config_no_file(self):\\n if os.path.isfile(\\\"test_config.conf\\\"):\\n os.remove(\\\"test_config.conf\\\")\\n self.assertRaises(ConfigError, Config, \\\"test_config.conf\\\")\",\n \"def init_config():\\n cf = ConfigParser.ConfigParser()\\n try :\\n cf.read(CONFIG_FILE)\\n except os.errno:\\n Log.e(TAG, \\\"Open configuration file error!\\\")\\n return False\\n try :\\n SW_CONFIG['7zpath'] = cf.get(\\\"dir_config\\\", \\\"7zpath\\\")\\n SW_CONFIG['sharefolder'] = cf.get(\\\"dir_config\\\", \\\"sharefolder\\\")\\n SW_CONFIG['distpath'] = cf.get(\\\"dir_config\\\", \\\"distpath\\\")\\n SW_CONFIG['sw_version'] = cf.get(\\\"sw_config\\\", \\\"version\\\")\\n SW_CONFIG['startup'] = cf.get(\\\"sw_config\\\", \\\"startup\\\")\\n except ConfigParser.Error:\\n Log.e(DEBUG_TAG, \\\"Config file parse error!\\\")\\n clean()\\n return False\\n try :\\n RUN_CONFIG['backup'] = (cf.get(\\\"run_config\\\", \\\"backup\\\") == \\\"True\\\")\\n RUN_CONFIG['pop'] = (cf.get(\\\"run_config\\\", \\\"pop\\\") == \\\"True\\\")\\n except ConfigParser.Error:\\n Log.e(TAG, \\\"no run config in config file!\\\")\\n RUN_CONFIG['backup'] = False\\n RUN_CONFIG['pop'] = False\\n try :\\n for option in cf.options(\\\"hook_config\\\"): \\n HOOK_CONFIG[option] = cf.get(\\\"hook_config\\\", option)\\n except ConfigParser.Error:\\n Log.e(TAG, \\\"No hook config in config file!\\\")\\n if not os.path.exists(SW_CONFIG['sharefolder']):\\n try:\\n os.makedirs(SW_CONFIG['sharefolder'])\\n except os.error:\\n print \\\"Can't create the local folder:\\\" + SW_CONFIG['distpath'] + \\\", Please set another one\\\"\\n clean()\\n exit()\\n if not os.path.exists(SW_CONFIG['distpath']):\\n try:\\n os.makedirs(SW_CONFIG['distpath'])\\n except os.error:\\n print \\\"Can't create the share folder:\\\" + SW_CONFIG['sharefolder'] + \\\" temp directory!\\\"\\n clean()\\n os.system(\\\"pause\\\")\\n exit()\\n return True\",\n \"def test_config_file_empty(get_empty_config, monkeypatch, get_root, conf_obj):\\n path = os.path.join(get_root, 'res', 'missing.yml')\\n\\n with pytest.raises(FileNotFoundError):\\n get_empty_config(conf_obj, path)\",\n \"def test_load_config_no_image(self):\\n with open(\\\".scuba.yml\\\", \\\"w\\\") as f:\\n pass\\n\\n config = scuba.config.load_config(\\\".scuba.yml\\\")\\n with pytest.raises(scuba.config.ConfigError):\\n img = config.image\",\n \"def test_load_no_backend(self):\\n sample_file = os.path.join(os.path.dirname(__file__), \\\"broken-config-no-backend.yaml\\\")\\n self.assertTrue(os.path.exists(sample_file), \\\"Did not found {}\\\".format(sample_file))\\n\\n def try_it():\\n self.configurator.load_yaml_file(sample_file)\\n\\n self.assertRaises(ConfigurationError, try_it)\",\n \"def load_config_file(self, suppress_errors=True):\\n self.log.debug(\\\"Searching %s for config files\\\", self.config_file_paths)\\n base_config = 'jupyter_config'\\n try:\\n super(JupyterApp, self).load_config_file(\\n base_config,\\n path=self.config_file_paths,\\n )\\n except ConfigFileNotFound:\\n # ignore errors loading parent\\n self.log.debug(\\\"Config file %s not found\\\", base_config)\\n pass\\n\\n if self.config_file:\\n path, config_file_name = os.path.split(self.config_file)\\n else:\\n path = self.config_file_paths\\n config_file_name = self.config_file_name\\n\\n if not config_file_name or (config_file_name == base_config):\\n return\\n\\n try:\\n super(JupyterApp, self).load_config_file(\\n config_file_name,\\n path=path\\n )\\n except ConfigFileNotFound:\\n self.log.debug(\\\"Config file not found, skipping: %s\\\", config_file_name)\\n except Exception:\\n # Reraise errors for testing purposes, or if set in\\n # self.raise_config_file_errors\\n if (not suppress_errors) or self.raise_config_file_errors:\\n raise\\n self.log.warning(\\\"Error loading config file: %s\\\" %\\n config_file_name, exc_info=True)\",\n \"def read_config():\\n filename = path.join(path.expanduser('~'), '.profrc')\\n config = configparser.ConfigParser()\\n config.read(filename)\\n if 'baseurl' not in config['DEFAULT']:\\n print(\\\"\\\"\\\"FATAL : No baseurl found in {0}\\nOpen {0} and add the following lines\\n\\n[DEFAULT]\\nBaseurl = https://your-prof-instance\\\"\\\"\\\".format(filename))\\n sys.exit()\\n try:\\n requests.get(config['DEFAULT']['BASEURL'])\\n except:\\n print(\\\"{0} does not seems to be reachable. Verify the baseurl set at {1} matches ``https://your-prof-instance``\\\".format(config['DEFAULT']['BASEURL'], filename))\\n sys.exit()\\n return config\",\n \"def initConfig(defaults, filepath=None):\\n result = False\\n if filepath is None:\\n filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), \\\"res/\\\", \\\"config.ini\\\")\\n if not os.path.exists(filepath):\\n config = ConfigParser.ConfigParser(defaults)\\n result = Helpers.saveConfig(config, filepath)\\n return result\",\n \"def get_config(f_configs, section=None):\\n if io.is_file(f_configs) is False:\\n warn.warn('configs (INI) file does not exist: ' + f_configs)\\n return None\",\n \"def _load_defaults():\\n filename = os.path.expanduser(CONFIG_FILE)\\n logging.debug('Loading configuration from {}'.format(filename))\\n try:\\n with open(filename, 'r') as cfile:\\n vals = yaml.load(cfile.read())\\n return vals\\n except yaml.YAMLError as ex:\\n logging.warning('Could not parse configuration file: {}'.format(ex))\\n except IOError as ex:\\n if ex.errno != errno.ENOENT:\\n logging.warning('Could not open configuration file: {}'.format(ex))\\n else:\\n logging.debug('No config file')\\n\\n return {}\",\n \"def read_conf(confilepath):\\n\\tif os.path.exists(confilepath): \\n\\t\\tconfig = ConfigObj(confilepath) \\n\\t\\treturn config\\n\\tsys.exit(\\\"Confile: |%s| does not exist\\\" %(confilepath))\",\n \"def init_config(filename):\\n config = configparser.ConfigParser()\\n try:\\n with open(filename, 'r') as config_file:\\n config.read(config_file)\\n except EnvironmentError:\\n print(\\\"FATAL ERROR: Failed to open config file at \\\" + filename)\\n sys.exit(1)\\n return config\",\n \"def __test_config_file__(parser, path):\\n if not os.path.exists(path):\\n return False\\n else:\\n statinfo = os.stat(path)\\n if not os.path.isfile(path) or os.path.islink(path):\\n parser.error(\\\"invalid configuration file {} (it must be a regular file)\\\".format(path))\\n elif stat.filemode(statinfo.st_mode) != '-rw-------':\\n parser.error(\\\"invalid configuration file {} (it must have only read and write permissions for user)\\\".format(path))\\n elif statinfo.st_uid != os.getuid():\\n parser.error(\\\"invalid configuration file {} (the owner must be the user)\\\".format(path))\\n return True\",\n \"def init_configs():\\n conf = ExtendedConfigParser()\\n try:\\n conf.read([vsa_conf_file])\\n except ConfigParser.ParsingError, e:\\n # non of the services has started, so just exit and print message directly to log file (and to stdout).\\n #TODO: loggit\\n #fd = open(log_file, 'w+')\\n message = \\\"%s - Configuration file was corrupted.\\\" %\\\\\\n strftime(\\\"%Y-%m-%d %X\\\", localtime())\\n #fd.write(message)\\n print message\\n sys.exit(0)\\n else:\\n return conf\",\n \"def find_file(fname):\\n etc = os.path.join(SCPIDIR, 'etc')\\n downloads = os.path.join(HOME, 'Downloads')\\n configfile = os.path.join(downloads, fname)\\n if os.access(configfile, os.R_OK):\\n try:\\n os.mkdir(etc)\\n except OSError as e:\\n if e.errno != errno.EEXIST:\\n raise\\n copy(configfile, etc)\\n os.remove(configfile)\\n configfile = os.path.join(etc, fname)\\n try:\\n fp = open(configfile)\\n except IOError as e:\\n if e.errno == errno.EACCES:\\n # default data:\\n default_file = os.path.join(SCPIDIR, fname)\\n print(\\\"Using default data file in {}\\\".format(default_file))\\n return default_file\\n # Not a permission error.\\n raise\\n else:\\n fp.close()\\n return configfile\",\n \"def loadConfig(self, name=None):\\n\\n configDir = self.mwGlob['configDir']\\n # looking for file existence and creating new if necessary\\n\\n if name is None:\\n name = 'config'\\n fileName = configDir + '/' + name + '.cfg'\\n\\n if not os.path.isfile(fileName):\\n self.config = self.defaultConfig()\\n if name == 'config':\\n self.log.warning('Config file {0} not existing'.format(fileName))\\n return True\\n else:\\n return False\\n\\n # parsing the default file\\n try:\\n with open(fileName, 'r') as configFile:\\n configData = json.load(configFile)\\n except Exception as e:\\n self.log.critical('Cannot parse: {0}, error: {1}'.format(fileName, e))\\n self.config = self.defaultConfig()\\n return False\\n\\n # check if reference ist still to default -> correcting\\n if configData.get('reference', '') == 'config':\\n del configData['reference']\\n elif not configData.get('reference', ''):\\n configData['profileName'] = 'config'\\n\\n # loading default and finishing up\\n if configData['profileName'] == 'config':\\n self.config = self.convertData(configData)\\n return True\\n\\n # checking if reference to another file is available\\n refName = configData.get('reference', 'config')\\n if refName != name:\\n suc = self.loadConfig(refName)\\n else:\\n self.config = configData\\n return True\\n return suc\",\n \"def read_file():\\n require_login = \\\"Log into KAMONOHASHI first to use 'account login' command.\\\"\\n\\n if os.path.exists(config_file_path):\\n logging.info('open config file %s', config_file_path)\\n with open(config_file_path) as f:\\n logging.info('begin io %s', config_file_path)\\n config_file = json.load(f)\\n logging.info('end io %s', config_file_path)\\n if not {'server', 'token'} <= set(config_file.keys()):\\n raise Exception('Invalid configuration file {config_file_path}. {require_login}'\\n .format(config_file_path=config_file_path, require_login=require_login))\\n return config_file\\n\\n raise Exception('No configuration file {config_file_path}. {require_login}'\\n .format(config_file_path=config_file_path, require_login=require_login))\",\n \"def __check_configuration__(self, parser):\\n if not parser.has_section('core'):\\n self.logger.error('The config file should contain a core section with at least the module_path specified')\\n sys.exit(1)\\n\\n else:\\n if parser.get('core', 'modules_path', fallback=None) is None:\\n self.logger.error('The configuration file should contain at least the modules_path value in core section.')\\n sys.exit(1)\\n\\n if not parser.has_section('mysql'):\\n self.logger.error('The config file should contain a mysql section.')\\n sys.exit(1)\\n\\n else:\\n if parser.get('mysql', 'host', fallback=None) is None:\\n self.logger.error('The config file should contain the host value in mysql section.')\\n sys.exit(1)\\n\\n if parser.get('mysql', 'port', fallback=None) is None:\\n self.logger.error('The config file should contain the port value in mysql section.')\\n sys.exit(1)\\n\\n if parser.get('mysql', 'user', fallback=None) is None:\\n self.logger.error('The config file should contain the user in mysql section.')\\n sys.exit(1)\\n\\n if parser.get('mysql', 'password', fallback=None) is None:\\n self.logger.error('The config file should contain the password of the user in mysql section.')\\n sys.exit(1)\\n\\n if parser.get('mysql', 'server_id', fallback=None) is None:\\n self.logger.error('The config file should contain the server_id in mysql section.')\\n sys.exit(1)\\n\\n if parser.get('mysql', 'tables', fallback=None) is not None:\\n tables = [table.strip() for table in parser.get('mysql', 'tables').split(',')]\\n for table in tables:\\n if not parser.has_section(table):\\n self.logger.error('The config file should contain a section about the table : %s' % table)\\n exit(1)\\n if parser.get(table, 'index_label', fallback=None) is None :\\n self.logger.error('The config file should contain a table section with a index_label value.')\\n exit(1)\\n else:\\n self.logger.error('The config file should contain a tables value with all the tables to replicate.')\\n exit(1)\",\n \"def test_old_config_fails() -> None:\\n with pytest.raises(SystemExit):\\n fauxmo.main(config_path_str=\\\"tests/old-config-sample.json\\\")\",\n \"def default_configfile():\\n dirname=None\\n if os.getenv(\\\"HOME\\\"):\\n dirname=os.getenv(\\\"HOME\\\")\\n elif os.getenv(\\\"USERPROFILE\\\"):\\n dirname=os.getenv(\\\"USERPROFILE\\\")\\n\\n else:\\n raise FattyException(\\\"No HOME or USERPROFILE variable set, unable to determine default config file\\\")\\n\\n return os.path.join(dirname,\\\".fattybugs\\\")\",\n \"def determine_config() -> str:\\n if os.environ.get(PortholeConfig.CONFIG_ENV_NAME) is not None:\\n return os.environ.get(PortholeConfig.CONFIG_ENV_NAME)\\n if os.path.isfile(PortholeConfig.DEFAULT_CONFIG_FILE):\\n return PortholeConfig.DEFAULT_CONFIG_FILE\\n for file_path in PortholeConfig.OTHER_ALLOWED_CONFIG_PATHS:\\n if os.path.isfile(file_path):\\n return file_path\\n raise FileNotFoundError(\\n \\\"Porthole is unable to locate a useable config file. \\\"\\n \\\"Try setting the PORTHOLE_CONFIG environment variable, \\\"\\n \\\"or creating a porthole.ini file in your main project directory.\\\"\\n )\",\n \"def test_broken_config(broken_config):\\n with pytest.raises(RuntimeError, match=\\\"Error reading config.yml\\\"):\\n abcconfig.get_config(broken_config)\",\n \"def testNoConfig(self):\\n\\n mockOpen = mock.mock_open()\\n with mock.patch('__builtin__.open', mockOpen, create=True):\\n self.assertRaises(\\n IOError,\\n tools.Config,\\n 'fakeIniFile.ini'\\n )\\n\\n mockOpen.assert_called_once_with('fakeIniFile.ini', 'w')\\n mockOpen().write.assert_called_once_with(tools.SAMPLE_CONFIG)\",\n \"def test_find_config_default(tmpdir, config_dir):\\n working_dir = tmpdir.mkdir(\\\"working\\\")\\n working_dir.join('local.cfg').write('')\\n\\n with cd(working_dir.strpath):\\n found_config = find_config(config_dir.strpath, 'config')\\n assert found_config == config_dir.join('config.cfg').strpath\\n\\n found_config = find_config(config_dir.strpath, 'config.cfg')\\n assert found_config == config_dir.join('config.cfg').strpath\",\n \"def _open_config_file(self):\\n try:\\n with open(self.config_file_name,encoding='utf-8') as json_data_file:\\n conf = json.load(json_data_file)\\n return conf\\n except FileNotFoundError:\\n with open(self.config_file_name, 'w',encoding='utf-8') as json_data_file:\\n json.dump({},json_data_file,indent=2)\\n return {}\",\n \"def is_config_exist(self) -> bool:\\n pass\",\n \"def _load_config(file):\\n try:\\n return bb.parse.handle(os.path.join('conf', file), bb.data.init() )\\n except IOError, e:\\n return None\",\n \"def test_blank_config_doesnt_crash(tmpdir):\\n config = tmpdir.join(\\\"config.yml\\\")\\n config.write('')\\n util.read_config(tmpdir)\",\n \"def test_no_config(self):\\n exit_code = self.run_beat()\\n\\n assert exit_code == 1\\n assert self.log_contains(\\\"error loading config file\\\") is True\",\n \"def test_invalid_config(self):\\n shutil.copy(self.beat_path + \\\"/tests/files/invalid.yml\\\",\\n os.path.join(self.working_dir, \\\"invalid.yml\\\"))\\n\\n exit_code = self.run_beat(config=\\\"invalid.yml\\\")\\n\\n assert exit_code == 1\\n assert self.log_contains(\\\"error loading config file\\\") is True\",\n \"def check_for_config(conf, confs_path):\\n if yes_no('Is there a configuration file you would like to load?'):\\n options = os.listdir(confs_path)\\n if len(options) > 0:\\n options.append('Specify a Path')\\n option = ask_options(\\n 'Pick a configuration file', options, title=False)\\n if option == 'Specify a Path':\\n conf['config'] = ask_path(\\n 'Enter the path for the configuration file')\\n else:\\n conf['config'] = os.path.join(confs_path, option)\\n else:\\n conf['config'] = ask_path(\\n 'Enter the path for the configuration file')\\n conf = get_config_file(conf)\\n conf, _ = confirm_conf(conf)\\n conf.pop('config')\\n return conf\",\n \"def read_config(self):\\n default = \\\"/usr/local/etc/kattisrc\\\"\\n cfg = configparser.ConfigParser()\\n if os.path.exists(default):\\n cfg.read(default)\\n\\n if not cfg.read([os.path.join(os.getenv('HOME'), '.kattisrc'),\\n os.path.join(os.path.dirname(os.path.expanduser(\\\"~\\\")), '.kattisrc')]):\\n raise KattisConfigError(\\n \\\"Could not locate .kattisrc! Make sure it is placed under your home directory!\\\")\\n return cfg\",\n \"def __create_default_config(self):\\n if not os.path.exists(self.__configfile):\\n path=os.path.dirname(self.__configfile)\\n try:\\n os.makedirs(path)\\n except:\\n pass\\n if os.path.exists(path):\\n self.save(defaults=True)\",\n \"def test_read_no_env_config():\\n data = \\\"\\\"\\n with mock.patch(\\n \\\"configparser.open\\\",\\n # \\\"builtins.open\\\",\\n mock.mock_open(read_data=data),\\n ):\\n testargs = [\\\"yessssms\\\", \\\"-m\\\", \\\"Bilde mir nicht ein was rechts zu wissen\\\"]\\n with (mock.patch.object(sys, \\\"argv\\\", testargs)):\\n with pytest.raises(SystemExit) as wrapped_e:\\n cli = CLI()\\n assert cli.read_env_config() is None\\n assert wrapped_e.type == SystemExit\\n assert wrapped_e.value.code == 2\",\n \"def read_config_file():\\n\\tsuccess = config_parser.read([config_file])\\n\\n\\tif not success:\\n\\t\\tprint \\\"Failed to parse config file '%s'\\\" % config_file\\n\\t\\treturn False\\n\\n\\treturn True\",\n \"def test_get_config_does_not_exist():\\n with pytest.raises(\\n FileNotFoundError, match=\\\"Oops! I can't seem to find a config.yml\\\"\\n ):\\n abcconfig.get_config(\\\"dirthatdoesntexist\\\")\",\n \"def init_cfg(input_path, quiet):\\n config_file = getConfigPath(input_path)\\n\\n if not os.path.exists(config_file) or quiet:\\n confirm_overwrite = True\\n else:\\n confirm_overwrite = click.confirm(\\n '\\\\n{} already exists. Do you want to overwrite it?'.format(config_file))\\n if confirm_overwrite:\\n configHandler(config_file).resetConfig()\\n click.secho('{} created'.format(config_file), fg='green')\",\n \"def read_config(self, config_filename):\",\n \"def test_config_filename_not_given_envvar_is_empty(monkeypatch):\\n monkeypatch.delenv(ENV_CONFIG_FILE)\\n with pytest.raises(ValueError):\\n Config()\",\n \"def create_default_config():\\n import codecs\\n config = ConfigParser.SafeConfigParser()\\n config.readfp(StringIO(DEFAULT_CONFIG))\\n\\n # Load user settings\\n filename = get_user_config_filename()\\n if not os.path.exists(filename):\\n from wizard import setup_wizard\\n setup_wizard(config)\\n else:\\n try:\\n fi = codecs.open(filename, 'r', encoding='utf-8')\\n config.readfp(fi)\\n finally:\\n fi.close()\\n return config\",\n \"def test_bad_config_file_path_or_name():\\n cli_result = subprocess.run(\\n ['kaiba', 'config.js', 'input.json'],\\n capture_output=True,\\n )\\n assert b'FileNotFoundError' in cli_result.stderr\\n assert b'config.js' in cli_result.stderr\",\n \"def _cfg_path(argv):\\n cfg_path = argv[1] if len(argv) > 1 else None\\n _is_file = os.path.isfile\\n if not cfg_path or not _is_file(cfg_path):\\n if cfg_path:\\n _info(\\\"no config at {}, trying the default location\\\".format(\\n cfg_path))\\n cfg_path = _DEFAULT_PATH\\n if not _is_file(cfg_path):\\n _info(\\\"no config at {}, exiting\\\".format(cfg_path))\\n return None\\n return cfg_path\",\n \"def test_config_filename_given_file_doesnt_exist():\\n config_file_name = \\\"i_dont_exist.ini\\\"\\n assert not os.path.exists(config_file_name)\\n\\n with pytest.raises(Exception):\\n Config(filename=config_file_name)\",\n \"def get_default_config_file() -> Path:\\n return get_path_to_pyflow() / \\\"pyflow\\\" / \\\"conf\\\" / CONFIG_FILE\",\n \"def get_config_parser():\\n config = configparser.ConfigParser()\\n if os.path.exists(CONFIGURATION_FILE_PATH) and os.path.isfile(CONFIGURATION_FILE_PATH):\\n config.read(CONFIGURATION_FILE_PATH)\\n return config\\n else:\\n logging.error(\\\"Config file not found, create %s\\\" % CONFIGURATION_FILE_PATH)\\n exit(1)\",\n \"def check() -> bool:\\n\\ttry:\\n\\t\\twith open(configPath, 'r') as file:\\n\\t\\t\\tcfg = json.load(file) # load the file\\n\\texcept FileNotFoundError:\\n\\t\\treturn False\\n\\t# check if EVERY config exists\\n\\tfor i in default_config.keys():\\n\\t\\tif i in cfg.keys():\\n\\t\\t\\tcontinue\\n\\t\\treturn False\\n\\t# final check\\n\\treturn cfg['config_type'] == default_config['config_type']\",\n \"def require_config(self) -> None:\\n if not self.has_config():\\n fail(f\\\"No tzk_config.py found in the current directory. \\\"\\n f\\\"(Try 'tzk init' if you want to create a new one.)\\\")\",\n \"def load_default_config_file(filename: str) -> str:\\n try:\\n raw_contents = resource_string(__name__, 'configuration/' + filename)\\n except FileNotFoundError:\\n raise BscanConfigError(\\n 'Unable to find default configuration file `' + filename + '`')\\n return raw_contents.decode('utf-8')\",\n \"def read_config() -> dict:\\n if not os.path.exists(Vars.default_config_path):\\n raise Exception(\\\"You should run many_pynb.run at first.\\\")\\n\\n with open(Vars.default_config_path, \\\"r\\\") as f:\\n config = json.load(f)\\n return(config)\",\n \"def test_config_filename_not_given_file_doesnt_exist(monkeypatch):\\n config_file_name = \\\"i_dont_exist.ini\\\"\\n assert not os.path.exists(config_file_name)\\n\\n monkeypatch.setenv(ENV_CONFIG_FILE, config_file_name)\\n with pytest.raises(Exception):\\n Config()\",\n \"def is_config_exist(self) -> bool:\\n return True\",\n \"def test_defaultFile(self):\\n found = cesmEnvLib.checkFile(\\\"./test_checkXMLvar.py\\\", \\\"read\\\")\\n self.assertTrue(found)\",\n \"def load_cfg(self, config_path):\\n def build_default_cfg():\\n \\\"\\\"\\\"\\n Restore default config file by writing on file\\n :return: default configuration contained in the dictionary DEF_CONF\\n \\\"\\\"\\\"\\n with open(Daemon.CONFIG_FILEPATH, 'wb') as fo:\\n json.dump(Daemon.DEF_CONF, fo, skipkeys=True, ensure_ascii=True, indent=4)\\n return Daemon.DEF_CONF\\n\\n # Search if config directory exists otherwise create it\\n if not os.path.isdir(Daemon.CONFIG_DIR):\\n try:\\n os.makedirs(Daemon.CONFIG_DIR)\\n except (OSError, IOError):\\n self.stop(1, '\\\\nImpossible to create \\\"{}\\\" directory! Permission denied!\\\\n'.format(Daemon.CONFIG_DIR))\\n\\n if os.path.isfile(config_path):\\n try:\\n with open(config_path, 'r') as fo:\\n loaded_config = json.load(fo)\\n except ValueError:\\n print '\\\\nImpossible to read \\\"{0}\\\"! Config file overwrited and loaded default config!\\\\n'.format(config_path)\\n return build_default_cfg()\\n corrupted_config = False\\n for k in Daemon.DEF_CONF:\\n if k not in loaded_config:\\n corrupted_config = True\\n # In the case is all gone right run config in loaded_config\\n if not corrupted_config:\\n return loaded_config\\n else:\\n print '\\\\nWarning \\\"{0}\\\" corrupted! Config file overwrited and loaded default config!\\\\n'.format(config_path)\\n return build_default_cfg()\\n else:\\n print '\\\\nWarning \\\"{0}\\\" doesn\\\\'t exist, Config file overwrited and loaded default config!\\\\n'.format(config_path)\\n return build_default_cfg()\",\n \"def test_config_device_restore_missing(get_config, config_dict, monkeypatch, write_config_fixture):\\n fname = 'will_be_missing.yml'\\n # saving normal conf\\n is_default = {'test': 'conf'}\\n monkeypatch.setattr(DeviceConfig, 'minimal_essential_conf', is_default)\\n cfg = get_config(DeviceConfig, config_dict, fname=fname)\\n cfg.save()\\n path = write_config_fixture('corrupted_string', fname)\\n os.remove(path)\\n # trying to read from non-existent file\\n should_be_default = cfg.read()\\n\\n assert should_be_default == is_default, 'configs not matched'\",\n \"def load_config():\\n try:\\n f = open(Filenames.CONFIG, 'r')\\n j = json_load_as_ascii(f)\\n except ValueError:\\n error_message = (\\\"ERROR! (terminating...)\\\\n\\\" +\\n (\\\"The config file (%s) has invalid/corrupt JSON and can not be read. \\\" % Filenames.CONFIG) +\\n \\\"Please fix, otherwise delete the file and rerun the daemon \\\" +\\n \\\"(which will create a default config)\\\")\\n print \\\"\\\\n\\\", error_message\\n add_to_error_log(error_message)\\n exit()\\n except IOError:\\n print \\\"The config file (%s) doesn't exist. Creating a new one with default sample contents:\\\" % Filenames.CONFIG\\n f = open(Filenames.CONFIG, 'w')\\n j = {\\n ConfigFields.BIN_DURATION: 60,\\n ConfigFields.OUTBOX_DATA_LIMIT: 1000,\\n ConfigFields.DATABASE_DOMAIN: \\\"http://test-003.t2.ucsd.edu:8086\\\",\\n ConfigFields.METRICS: [\\n {\\n MetricsFields.DATABASE_NAME: \\\"DefaultDB\\\",\\n MetricsFields.MEASUREMENT_NAME: \\\"num_jobs\\\",\\n MetricsFields.METRIC_TYPE: MetricsFields.MetricTypes.COUNTER,\\n MetricsFields.GROUP_FIELDS: [\\\"User\\\", \\\"SUBMIT_SITE\\\", \\\"MATCH_EXP_JOB_Site\\\"],\\n MetricsFields.AGGREGATE_OP: CounterMetricFields.AggregationOps.ALL,\\n MetricsFields.JOB_STATUSES: [MetricsFields.JobStatuses.RUNNING_OR_RAN],\\n MetricsFields.DESCRIPTION: \\\"The number of jobs which have run across owners and sites\\\"\\n }\\n ]\\n }\\n print stringify(j)\\n json.dump(j, f, indent=4)\\n f.close()\\n return j\",\n \"def test_config_save_error(self):\\n\\n config_filename_initial = 'test_configuration2'\\n config_filename_save = 'save_bad_configuration'\\n\\n # Get config path\\n local_dir = os.path.dirname(__file__)\\n config_path_initial = os.path.join(local_dir, config_filename_initial)\\n config_path_save = os.path.join(local_dir, config_filename_save)\\n\\n # Load initial configuration from file\\n config_initial = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,\\n neat.DefaultSpeciesSet, neat.DefaultStagnation,\\n config_path_initial)\\n\\n config_initial.genome_config.connection_fraction = 1.5\\n\\n try:\\n config_initial.save(config_path_save)\\n except RuntimeError:\\n pass\\n else:\\n raise Exception(\\\"Did not get RuntimeError on attempt to save bad partial configuration\\\")\",\n \"def __init__(self, filename=None):\\n if filename:\\n if not os.path.exists(filename):\\n raise Exception(\\\"No configuration found at %s\\\" % filename)\\n super(Configuration, self).__init__(filename)\",\n \"def init_config(env):\\n doc = ''\\n if env == 'local':\\n with open('./config/local.yml', 'r') as f:\\n doc = load(f)\\n elif env == 'staging':\\n with open('./config/staging.yml', 'r') as f:\\n doc = load(f)\\n elif env == 'prod':\\n with open('./config/prod.yml', 'r') as f:\\n doc = load(f)\\n else:\\n with open(env, 'r') as f:\\n doc = load(f)\\n if doc == '':\\n logging.error(\\\"Couldn't load config properly\\\")\\n return doc\",\n \"def test_no_config_file(self):\\r\\n instance = self._makeOne()\\r\\n\\r\\n # No default config file search in case they would exist\\r\\n self.assertTrue(len(instance.searchpaths) > 0)\\r\\n instance.searchpaths = []\\r\\n\\r\\n instance.exit = dummy_exit()\\r\\n\\r\\n instance.realize(args=['-s', 'http://localhost:9001', '-u', 'chris',\\r\\n '-p', '123'])\\r\\n\\r\\n self.assertEqual(instance.interactive, 1)\\r\\n self.assertEqual(instance.serverurl, 'http://localhost:9001')\\r\\n self.assertEqual(instance.username, 'chris')\\r\\n self.assertEqual(instance.password, '123')\",\n \"def load_config(filename):\\n filepaths = []\\n for dirpath in os.path.expanduser('~'), os.curdir, '':\\n try:\\n filepath = os.path.join(dirpath, filename)\\n filepaths.append(filepath)\\n with open(filepath, 'r') as f:\\n return Config(yaml.safe_load(f))\\n except IOError:\\n pass\\n raise IOError('Configuration file not found: ' + ', '.join(filepaths))\",\n \"def _get_config_file(filepath=None):\\n if filepath:\\n if os.path.isfile(filepath):\\n return filepath\\n raise ConfigFileNotFound(filepath)\\n\\n _config_files = (_path / _config_filename for _path in _config_basepaths)\\n for _filepath in _config_files:\\n if os.path.isfile(_filepath):\\n return _filepath\\n raise ConfigFileNotFound(_config_files)\",\n \"def _get_config_parsser(config_file):\\n config_parser = Parser()\\n # read() return a list of file name that read success\\n open_success_file = config_parser.read(config_file)\\n if len(open_success_file) == 0:\\n return 1, \\\"can not open file: \\\" + config_file\\n else:\\n return 0, config_parser\",\n \"def read_config():\\n config = configparser.ConfigParser()\\n if not os.path.exists(\\\"config.cfg\\\"):\\n raise FileNotFoundError(\\\"configuration file (config.cfg) not found!\\\")\\n config.read(\\\"config.cfg\\\")\\n return config\",\n \"def load_config(config_file: Path) -> Dict[str, Any]:\\n config, errors = check_config(config_file)\\n if errors is not None:\\n raise next(iter(errors))\\n # errors is None\\n assert config is not None\\n return config\",\n \"def parse_config():\\n config_path = Path(\\\"config.ini\\\")\\n if config_path.exists():\\n config.read(config_path)\\n else:\\n config[\\\"database\\\"] = {\\\"location\\\": \\\"image-database.db\\\"}\\n config[\\\"images\\\"] = {\\\"extensions\\\": \\\".jpeg,.jpg,.png,.gif,.tiff\\\"}\\n with open(config_path, \\\"w\\\") as configfile:\\n config.write(configfile)\\n config.read(config_path)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7525276","0.7193444","0.71882033","0.71124953","0.7107984","0.6897188","0.6821535","0.6812968","0.6799228","0.67775863","0.6752519","0.67052954","0.66308767","0.66073364","0.65852654","0.656446","0.65604955","0.654337","0.6540201","0.6525114","0.6507747","0.6499308","0.6484932","0.64663017","0.64485365","0.64374524","0.6409772","0.6364779","0.6342999","0.633413","0.6302656","0.6283569","0.6263754","0.6253682","0.62365204","0.61963147","0.619398","0.617593","0.6171148","0.6164923","0.6161803","0.6160659","0.6157064","0.61541307","0.614076","0.61170965","0.61122835","0.6107191","0.61015135","0.60914576","0.6047493","0.60427773","0.6037922","0.60281396","0.602675","0.60266924","0.60231566","0.60211736","0.60204345","0.60029536","0.60011005","0.5999184","0.59948015","0.5986381","0.5980327","0.5970215","0.59651446","0.59634465","0.5962991","0.59618056","0.59616435","0.5957153","0.59544003","0.59445286","0.5937857","0.5937471","0.59301144","0.5929406","0.5919293","0.59177446","0.5916534","0.5908592","0.5905957","0.5904574","0.59000254","0.5896412","0.5887622","0.58856845","0.58780646","0.5875806","0.58735037","0.58726555","0.5870188","0.58672976","0.5856246","0.58547574","0.58529025","0.58508366","0.5846519","0.5843505"],"string":"[\n \"0.7525276\",\n \"0.7193444\",\n \"0.71882033\",\n \"0.71124953\",\n \"0.7107984\",\n \"0.6897188\",\n \"0.6821535\",\n \"0.6812968\",\n \"0.6799228\",\n \"0.67775863\",\n \"0.6752519\",\n \"0.67052954\",\n \"0.66308767\",\n \"0.66073364\",\n \"0.65852654\",\n \"0.656446\",\n \"0.65604955\",\n \"0.654337\",\n \"0.6540201\",\n \"0.6525114\",\n \"0.6507747\",\n \"0.6499308\",\n \"0.6484932\",\n \"0.64663017\",\n \"0.64485365\",\n \"0.64374524\",\n \"0.6409772\",\n \"0.6364779\",\n \"0.6342999\",\n \"0.633413\",\n \"0.6302656\",\n \"0.6283569\",\n \"0.6263754\",\n \"0.6253682\",\n \"0.62365204\",\n \"0.61963147\",\n \"0.619398\",\n \"0.617593\",\n \"0.6171148\",\n \"0.6164923\",\n \"0.6161803\",\n \"0.6160659\",\n \"0.6157064\",\n \"0.61541307\",\n \"0.614076\",\n \"0.61170965\",\n \"0.61122835\",\n \"0.6107191\",\n \"0.61015135\",\n \"0.60914576\",\n \"0.6047493\",\n \"0.60427773\",\n \"0.6037922\",\n \"0.60281396\",\n \"0.602675\",\n \"0.60266924\",\n \"0.60231566\",\n \"0.60211736\",\n \"0.60204345\",\n \"0.60029536\",\n \"0.60011005\",\n \"0.5999184\",\n \"0.59948015\",\n \"0.5986381\",\n \"0.5980327\",\n \"0.5970215\",\n \"0.59651446\",\n \"0.59634465\",\n \"0.5962991\",\n \"0.59618056\",\n \"0.59616435\",\n \"0.5957153\",\n \"0.59544003\",\n \"0.59445286\",\n \"0.5937857\",\n \"0.5937471\",\n \"0.59301144\",\n \"0.5929406\",\n \"0.5919293\",\n \"0.59177446\",\n \"0.5916534\",\n \"0.5908592\",\n \"0.5905957\",\n \"0.5904574\",\n \"0.59000254\",\n \"0.5896412\",\n \"0.5887622\",\n \"0.58856845\",\n \"0.58780646\",\n \"0.5875806\",\n \"0.58735037\",\n \"0.58726555\",\n \"0.5870188\",\n \"0.58672976\",\n \"0.5856246\",\n \"0.58547574\",\n \"0.58529025\",\n \"0.58508366\",\n \"0.5846519\",\n \"0.5843505\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5841644"},"document_rank":{"kind":"string","value":"100"}}},{"rowIdx":92892,"cells":{"query":{"kind":"string","value":"Check if dbfile is set; else replace with dbfile of default config. Further default values might come. Also expand tilde in filepaths."},"document":{"kind":"string","value":"def sanitize_config(config):\n\tif not 'dbfile' in config.keys():\n\t\tconfig['dbfile'] = DEFAULTCONFIG['dbfile']\n\tfor path in ['dbfile']:\n\t\tconfig[path]=os.path.expanduser(config[path])\n\treturn config"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def set_db_file():\n\n return os.path.join(db_path, db_file)","def default_bug_db(configfile=None):\n\n configs=None\n if not configfile:\n configs=default_configs()\n else:\n configs=configparser.ConfigParser()\n configs.read(configfile)\n\n db_file=os.path.normpath(configs.get(\"bug_db\",\"db_file\"))\n return db_file","def default_db_config():\n return read_json_file(db_config_file)","def get_default_config_path():\n if os.name == 'posix':\n config_path = os.path.join(os.path.expanduser(\"~\"), '.fpdb')\n elif os.name == 'nt':\n config_path = os.path.join(os.environ[\"APPDATA\"], 'fpdb')\n else: config_path = False\n return config_path","def reset_database_to_default(self):\n _src = os.path.abspath(self.default_db)\n _dst = os.path.abspath(self.db_path)\n copyfile(_src, _dst)","def getDefaultDatabaseConnectionParameter(self):\n return { 'path' : os.path.join(self.configPath(), 'databases', 'settings.db') }","def database_file(file):\r\n fpath = path.join('databases', '{0}'.format(file))\r\n db_path = path.join(mod_path, fpath)\r\n return db_path","def get_db_file(config):\n db_file = None\n\n db = config.get_config(\"db\")\n db_config = config.get_config(\"db_config\")\n if db == \"sqlalchemy\":\n db_file = db_config.get(\"uri\")\n\n return db_file","def get_db_file(config):\n db_file = None\n\n db = config.get_config(\"db\")\n db_config = config.get_config(\"db_config\")\n if db == \"sqlalchemy\":\n db_file = db_config.get(\"uri\")\n\n return db_file","def setdefaults(self):\n self.config = {\n 'dbuser': Infopage.DEFAULT_DBUSER,\n 'dbname': Infopage.DEFAULT_DBNAME,\n 'dbpassword': Infopage.DEFAULT_DBPASSWORD,\n 'dbhost': Infopage.DEFAULT_DBHOST\n }","def set_object_database (self, file_name):\n try:\n self.object_database=file_name\n self.filepath_object_database = os.path.join(self.filepath, self.object_database)\n print(\"set object_database filename to\", file_name)\n except:\n print(\"setting object database failed\")\n self.object_database=\"Object_database.db\"\n self.filepath_object_database = os.path.join(self.filepath, self.object_database)\n print(\"set object database name to default:\", self.object_database)\n return","def db_path_with_improper_files():\n return os.path.join(_here, 'fixtures/databases/db-improper/database')","def get_config(file_name, fallback = True):\n exec_dir = get_exec_path()\n if file_name == 'logging.conf' and not hasattr(sys, \"frozen\"):\n config_path = os.path.join(exec_dir, 'pyfpdb', file_name)\n else:\n config_path = os.path.join(exec_dir, file_name)\n# print \"config_path=\", config_path\n if os.path.exists(config_path): # there is a file in the cwd\n return (config_path,False) # so we use it\n else: # no file in the cwd, look where it should be in the first place\n default_dir = get_default_config_path()\n config_path = os.path.join(default_dir, file_name)\n# print \"config path 2=\", config_path\n if os.path.exists(config_path):\n return (config_path,False)\n\n# No file found\n if not fallback:\n return (False,False)\n\n# OK, fall back to the .example file, should be in the start dir\n if os.path.exists(file_name + \".example\"):\n try:\n print \"\"\n check_dir(default_dir)\n shutil.copyfile(file_name + \".example\", config_path)\n msg = \"No %s found\\n in %s\\n or %s\\n\" % (file_name, exec_dir, default_dir) \\\n + \"Config file has been created at %s.\\n\" % config_path\n print msg\n logging.info(msg)\n file_name = config_path\n except:\n print \"Error copying .example file, cannot fall back. Exiting.\\n\"\n sys.stderr.write(\"Error copying .example file, cannot fall back. Exiting.\\n\")\n sys.stderr.write( str(sys.exc_info()) )\n sys.exit()\n else:\n print \"No %s found, cannot fall back. Exiting.\\n\" % file_name\n sys.stderr.write(\"No %s found, cannot fall back. Exiting.\\n\" % file_name)\n sys.exit()\n return (file_name,True)","def get_config_file(self):\n\n conf_file = self.args.file\n if conf_file is not None:\n if os.path.isfile(conf_file):\n config_file = open(conf_file, \"r\")\n self.main_file = yaml.load(config_file, Loader=yaml.FullLoader)\n elif os.path.isfile(\n os.path.join(get_path(\"DEFAULT\", \"config_file_path\"), conf_file)\n ):\n fpath = get_path(\"DEFAULT\", \"config_file_path\")\n config_file = open(os.path.join(fpath, conf_file), \"r\")\n self.main_file = yaml.load(config_file, Loader=yaml.FullLoader)\n else:\n self.logger.error(\n colorama.Fore.RED\n + \"ERROR!! Config file '%s' is not present \" % conf_file,\n extra=self.log_detail,\n )\n sys.exit(1)\n else:\n if self.args.hostname and self.args.testfiles:\n temp_dict = {\n \"hosts\": [{\"device\": \"\", \"username\": \"\", \"passwd\": \"\"}],\n \"tests\": [],\n }\n temp_dict[\"hosts\"][0][\"device\"] = self.args.hostname\n temp_dict[\"hosts\"][0][\"username\"] = self.args.login\n temp_dict[\"hosts\"][0][\"passwd\"] = self.args.passwd\n for tfile in self.args.testfiles:\n temp_dict[\"tests\"].append(tfile)\n self.main_file = temp_dict\n\n if (\n self.main_file.__contains__(\"sqlite\")\n and self.main_file[\"sqlite\"]\n and self.main_file[\"sqlite\"][0]\n ):\n self.chk_database(\n self.main_file,\n self.args.pre_snapfile,\n self.args.post_snapfile,\n self.args.check,\n self.args.snap,\n )\n else:\n # if --check option is given for sqlite, then snap file name is not compulsory\n # else exit the function saying arguments not correct\n if self.args.check is True and (\n self.args.pre_snapfile is None or self.args.post_snapfile is None\n ):\n self.logger.error(\n colorama.Fore.RED\n + \"Arguments not given correctly, Please refer help message\",\n extra=self.log_detail,\n )\n self.parser.print_help()\n sys.exit(1)","def init_default_config_file_if_nonexistent(package, default_config):\n config_file = os.path.join(conf.PAULA_USER_CONFIG_DIR, package + conf.CONFIG_EXTENSION)\n debug('config_file = ' + config_file)\n if not os.path.exists(config_file):\n debug('making: \\\"' + config_file+ '\\\"')\n shutil.copyfile(default_config, config_file)","def set_output_database (self, file_name):\n try:\n self.object_database=file_name\n self.filepath_output_database = os.path.join(self.filepath, self.output_database)\n print(\"set output_database filename to\", file_name)\n except:\n print(\"setting object database failed\")\n self.output_database=\"Output_database.db\"\n self.filepath_output_database = os.path.join(self.filepath, self.output_database)\n print(\"set output database name to default:\", self.object_database)\n return","def restore_default_connections_file():\n if os.path.exists(DEFAULT_CONNECTIONS_FILE_BAK):\n if os.path.exists(DEFAULT_CONNECTIONS_FILE):\n os.remove(DEFAULT_CONNECTIONS_FILE)\n os.rename(DEFAULT_CONNECTIONS_FILE_BAK, DEFAULT_CONNECTIONS_FILE)","def use_config_file(self):\n self.config_file = self.find_config_file()\n if self.config_file:\n self.apply_config_file(self.config_file)","def db_python_only():\n return os.path.join(_here, 'fixtures/databases/db-python-only/database')","def set_render_database_name(self, file_name):\n try:\n self.render_database=file_name\n self.filepath_render_database = os.path.join(self.filepath, self.render_database)\n print(\"set render_database filename to\", file_name)\n except:\n print(\"setting render database failed\")\n self.render_database=\"Render_database.db\"\n self.filepath_object_database = os.path.join(self.filepath, self.render_database)\n print(\"set render database name to default:\", self.render_database)\n return","def db_file():\n return abspath('vmchecker.db')","def getDefaultDBName() -> str:\n return f\"dbname={getpass.getuser()}\"","def set_default_config(self, filename):\n if os.path.isfile(filename):\n os.remove(filename)\n\n config = configparser.ConfigParser()\n default_cfg = {'config': {'database_name': 'manga.db',\n 'volume_limit': 128,\n 'series_per_page': 0,\n 'compact_list': 0,\n 'show_empty_series': False,\n 'default_to_gui': True}}\n\n config.read_dict(default_cfg)\n with open(filename, 'w') as config_ini:\n config.write(config_ini)\n\n # Reset class variables for config object as well\n self.config = config\n self.filename = filename\n self.database_name = 'manga.db'\n self.volume_limit = 128\n self.series_per_page = 0\n self.compact_list = False\n self.show_empty_series = False\n self.default_to_gui = True","def default_configfile(self):\r\n config = None\r\n for path in self.searchpaths:\r\n if os.path.exists(path):\r\n config = path\r\n break\r\n if config is None and self.require_configfile:\r\n self.usage('No config file found at default paths (%s); '\r\n 'use the -c option to specify a config file '\r\n 'at a different path' % ', '.join(self.searchpaths))\r\n return config","def getDBPath():\n return os.path.join(CONFIG_DIR, CONFIG_DICT['common']['local_db'])","def read_db():\n # read config file\n config = configparser.ConfigParser()\n config.read_file(open(\"options.cfg\"))\n\n return config['DEFAULT']['DatabaseFilename']","def _init_database_config(self):\n\n if self._database_config is not None:\n return\n\n self._database_config = frozendict()\n\n if ENVIRONMENT_VARIABLE not in os.environ:\n logger.debug(\"Database configuration not provided\")\n\n elif not (os.environ[ENVIRONMENT_VARIABLE] or \"\").endswith(\".json\"):\n config_path = os.environ[ENVIRONMENT_VARIABLE]\n raise EnvironmentError(f\"Invalid database configuration file: {config_path}\")\n\n else:\n try:\n config_path = os.environ[ENVIRONMENT_VARIABLE]\n config_file = pathlib.Path(config_path).expanduser().resolve(strict=True)\n with open(config_file) as config_json:\n database_config = json.loads(config_json.read())\n\n except FileNotFoundError:\n raise EnvironmentError(f\"Database configuration file does not exist: {config_path}\")\n except ValueError:\n raise EnvironmentError(f\"Database configuration file does not contain JSON: {config_path}\")\n\n # Remove values from overridden configuration if not present in supported configuration\n database_config = {k: v for k, v in database_config.items() if k in SUPPORTED_CONFIG}\n # Assign defaults in supported configuration if not present in overridden configuration\n database_config.update({k: v for k, v in SUPPORTED_CONFIG.items() if k not in database_config})\n\n self._database_config = frozendict(database_config)","def generate_config(args):\n default_config = resource_string('webrpg', 'scripts/templates/default_config.txt').decode('utf-8')\n if args.sqla_connection_string:\n default_config = default_config.replace('%(sqlalchemy_url)s', args.sqla_connection_string)\n else:\n default_config = default_config.replace('%(sqlalchemy_url)s', get_user_parameter('SQL Alchemy Connection String', 'sqlite:///%(here)s/pyire_test.db'))\n\n with open(args.filename, 'w') as out_f:\n out_f.write(default_config)","def setDb(self, db_file):\n self.db_file = db_file\n self.db = sqlite3.connect(self.db_file, isolation_level=None)\n self._initDb()","def choose_database(db):\n config = configparser.ConfigParser()\n config_path = os.path.dirname(os.path.realpath(__file__))\n config.read(os.path.join(config_path, \"config.ini\"))\n\n if db == 'auth':\n db = mysql.connector.connect(\n host=config['MySQL Auth']['host'],\n # port=config['MySQL Auth']['port'],\n user=config['MySQL Auth']['user'],\n passwd=config['MySQL Auth']['passwd'],\n database=config['MySQL Auth']['database']\n )\n\n if db == 'datadb':\n db = mysql.connector.connect(\n host=config['MySQL Data']['host'],\n # port=config['MySQL Data']['port'],\n user=config['MySQL Data']['user'],\n passwd=config['MySQL Data']['passwd'],\n database=config['MySQL Data']['database']\n )\n\n return db","def default_path():\n return os.path.join(os.environ.get('OVERRIDE_ETC', '/etc'), 'auth')","def _load_file_config(self):\n config_value = getattr(self, APPDATA)\n path_value = config_value.AbsolutePaths[0]\n default_cfg_file = os.path.join(path_value, CONFIG_FILE_NAME)\n config_base = None\n if os.path.exists(default_cfg_file):\n config_base = json.load(open(default_cfg_file.lower(), mode='r'), object_hook=ConfigEncoder.class_mapper)\n if config_base is None or self._current_dcc not in config_base:\n self.SaveConfig()\n config_base = type(self)._CURRENT_CONFIG\n return config_base","def _add_db_in_config(self):\n logger.info(f\"Updating configuration file in {self.configfile}\")\n with open(self.configfile, \"a\") as fp:\n print(self.ref_name + \".genome : \" + self.ref_name, file=fp)","def get_db_path():\n \n return(db_run.db_abs_path)","def configure(self, database_dir, storage_dir, search_dir, verbosity):\n tmp_database = ''\n tmp_storage = ''\n tmp_search = ''\n\n if os.path.exists('.config') == True:\n with open('.config', 'r') as f:\n for line in f:\n if 'DATABASE_DIR' in line.split():\n tmp_database = line\n if 'STORAGE_DIR' in line.split():\n tmp_storage = line\n if 'SEARCH_DIR' in line.split():\n tmp_search = line\n\n if os.path.exists(str(database_dir or '')) == True:\n self.database_dir = database_dir\n tmp_database = 'DATABASE_DIR = ' + database_dir + '\\n'\n if verbosity >= 1:\n print 'configure database dir {}'.format(\n str(database_dir or ''))\n else:\n if verbosity >= 1:\n print 'invalid database dir {}'.format(\n str(database_dir or ''))\n\n if os.path.exists(str(storage_dir or '')) == True:\n self.storage_dir = storage_dir\n tmp_storage = 'STORAGE_DIR = ' + storage_dir + '\\n'\n if verbosity >= 1:\n print 'configure storage dir {}'.format(\n str(storage_dir or ''))\n else:\n if verbosity >= 1:\n print 'invalid storage dir {}'.format(\n str(storage_dir or ''))\n\n if os.path.exists(str(search_dir or '')) == True:\n settings.rootdir = search_dir\n tmp_search = 'SEARCH_DIR = ' + search_dir + '\\n'\n if verbosity >= 1:\n print 'configure search dir {}'.format(\n str(search_dir or ''))\n else:\n if verbosity >= 1:\n print 'invalid search dir {}'.format(\n str(search_dir or ''))\n\n with open('.config', 'w') as f:\n f.write(tmp_database)\n f.write(tmp_storage)\n f.write(tmp_search)\n self.add_log('configure database dir {}'.format(\n tmp_database.replace('\\n', '')))\n self.add_log('configure storage dir {}'.format(\n tmp_storage.replace('\\n', '')))\n self.add_log('configure search dir {}'.format(\n tmp_search.replace('\\n', '')))","def is_db_path_correct(self, path):\n\t\tif path is None:\n\t\t\treturn self.file_loc() is None\n\t\telse:\n\t\t\treturn self.file_loc() == os.path.abspath(path)","def _sqlite(self):\n logging.debug(\"Configured to use SQLite for a database\")\n db_name = self.database\n if not len(db_name):\n db_name = \"rootthebox.db\"\n if not db_name.endswith(\".db\"):\n db_name = \"%s.db\" % db_name\n if os.path.exists(\"files/%s\" % db_name):\n path = \"sqlite:///files/%s\" % db_name\n logging.debug(\"Found rootthebox database at: %s\" % path)\n elif os.path.exists(db_name):\n path = \"sqlite:///%s\" % db_name\n logging.debug(\"Found rootthebox database at: %s\" % path)\n else:\n if \"files\" in db_name:\n path = \"sqlite:///%s\" % db_name\n else:\n path = \"sqlite:///files/%s\" % db_name\n logging.debug(\"Created rootthebox database at: %s\" % path)\n return path","def set_config(self, file, prop):\n if file.lower() not in ['config']:\n file = os.path.abspath(file)\n elif file.lower() == 'config':\n file = os.path.join(self.modpath, 'config', self.configfiles[prop])\n return file","def setup_environmentvars(self, path, mydbfilepath):\n\n if not FDB_AVAILABLE:\n print(BColors.WARNING + \"Warning: fdb_embedded couldn't be imported! \" \\\n + \"\\nMake sure you've installed fdb_embedded correctly.\" + BColors.ENDC)\n return False\n\n os.environ['FIREBIRD'] = path\n self.db_filepath = mydbfilepath\n return True","def load_config( self, config_file=None ):\n if config_file is None:\n config_file = os.path.dirname(self.dbfile) + '/final.ini'\n config_parser = ConfigParser.ConfigParser()\n config_parser.read( config_file )\n self.config = config_parser\n return self.config","def parse_databases(default_dbname=\"cal_manager.db\"):\n db_list = []\n calconf = get_calconf()\n if not calconf:\n return db_list\n upload_cookie = calconf.get(\"upload_cookie\")\n # Allow old-format file to be read\n try:\n databases = calconf[\"databases\"]\n except KeyError:\n databases = calconf.get(\"database_dir\")\n if not databases:\n return db_list\n with warnings.catch_warnings():\n warnings.simplefilter(\"always\", DeprecationWarning)\n warnings.warn(\"Use 'databases' instead of 'database_dir' in \"\n \"config file.\",\n DeprecationWarning\n )\n for line in databases.splitlines():\n if not line: # handle blank lines\n continue\n db, *flags = shlex.split(line)\n # \"get\" is default if there are no flags, but if any flags are\n # specified, then \"get\" must be there explicitly\n kwargs = {\"get_cal\": not bool(flags),\n \"store_cal\": False}\n for flag in flags:\n kwarg = f\"{flag}_cal\"\n if kwarg in kwargs:\n kwargs[kwarg] = True\n else:\n raise ValueError(\"{}: Unknown flag {!r}\".format(db, flag))\n\n expanded_db = path.expanduser(db)\n if path.isdir(expanded_db):\n db = path.join(db, default_dbname)\n cls = LocalDB\n elif path.isfile(expanded_db):\n cls = LocalDB\n elif \"/\" in expanded_db and \"//\" not in expanded_db:\n cls = LocalDB\n else: # does not check\n cls = RemoteDB\n kwargs[\"upload_cookie\"] = upload_cookie\n db_list.append((cls, db, kwargs))\n return db_list","def setdefault_path(envvar, default):\n if envvar in os.environ:\n return _strip_slash(os.environ[envvar])\n value = os.environ[envvar] = _strip_slash(default() if callable(default) else default)\n return value","def config_db():","def default_config_file(self):\n return DEFAULT_CONFIG_FILEPATH","def OnSelectDb(self,event):\n\t\tdlg = wx.FileDialog(None,u\"选择数据库文件\",wildcard=\"*.db\")\n\t\tif dlg.ShowModal() != wx.ID_OK:\n\t\t\tdlg.Destroy()\n\t\t\treturn\n\t\tdb_name = dlg.GetPath()\n\t\tif db_name: \n\t\t\tself.refer_sheet.SetDbName(db_name)\n\t\tdlg.Destroy()","def writeDefaultConfig(conffile='default.conf', defaults={}):\n if not os.path.exists(conffile):\n cp = createConfigParserfromDict(defaults, ['base'])\n cp.write(open(conffile,'w'))\n return conffile","def setDB(dbname):\n global DBNAME\n DBNAME = dbname","def get_path_db():\n\taiqc_config = get_config()\n\tif aiqc_config is None:\n\t\t# get_config() will print a null condition.\n\t\tpass\n\telse:\n\t\tdb_path = aiqc_config['db_path']\n\t\treturn db_path","def setdb_params(self, mongouri=None, dbname=\"testrecommender\"):\n if mongouri is not None:\n self._mongouri = mongouri\n if dbname is not None:\n self._dbname = dbname\n self._outputlogfile = self._outputlogfile + dbname + \"_outputlog.txt\"","def _set_config():\n\n\tdebug_msg = \"load default config yaml file\"\n\tlogger.debug(debug_msg)\n\n\tconfig_file_parser(paths.CONFIG_FILE, override_options=True)","def set_db(db):\n global db_run # Imports the DB from the simulator\n db_run=db","def _adjust_connection_URL(self, text):\n dbname = self.options.db\n parts = text.split('/')\n\n # Preserve the quotes if present\n if parts[-1].endswith(\"'\"):\n dbname += \"'\"\n\n parts[-1] = dbname\n return '/'.join(parts)","def save_default_connections_file():\n if os.path.exists(DEFAULT_CONNECTIONS_FILE):\n if os.path.exists(DEFAULT_CONNECTIONS_FILE_BAK):\n os.remove(DEFAULT_CONNECTIONS_FILE_BAK)\n os.rename(DEFAULT_CONNECTIONS_FILE, DEFAULT_CONNECTIONS_FILE_BAK)","def configName(url, file, _name):\n \n try:\n f=open(os.path.join(url, file))\n istr=f.readlines()\n for item in istr:\n if \"DB\" in item:\n last = item.find(\".db\")\n name=item[3:last+3]\n if os.path.isfile(os.path.join(url, 'configFile/'+name)):\n _name=os.path.join(url, 'configFile/'+name)\n else:\n _name=os.path.join(url, 'configFile/'+_name)\n return _name\n except FileNotFoundError:\n return os.path.join(url, 'configFile/'+_name)","def get_db_name(self):\n\t\treturn conf.db_name","def _check_and_mk(self, custom_db_path):\n rayvision_db_env = os.environ.get(RAYVISION_DB, \"\")\n if bool(custom_db_path) and os.path.exists(custom_db_path):\n db_path = custom_db_path\n elif os.path.exists(rayvision_db_env):\n db_path = rayvision_db_env\n else:\n if self.api.user_info['local_os'] == \"windows\":\n db_path = os.path.join(os.environ[WINDOWS_LOCAL_ENV], RENDERFARM_SDK)\n else:\n db_path = os.path.join(os.environ[LINUX_LOCAL_ENV], RENDERFARM_SDK)\n\n return db_path","def _get_default_path(self):\n return os.path.join(cfg.DATA_DIR, 'visual_genome')","def database():\n return conf().database","def get_db_path_from_config():\n if not globalConf.sections():\n raise OSError(\"Cannot read config file.\")\n databases = parse_databases()\n db_path = None\n for db in databases:\n if db[0] == LocalDB:\n if db_path is None:\n db_path = db[1]\n else:\n raise ValueError(\"Multiple local database files are listed \"\n \"in the config file.\")\n if db_path is None:\n raise ValueError(\"No local database file is listed in the config file.\")\n return db_path","def __init__(self, db_file):\n self.db = TinyDB(db_file)\n # TODO: implement db files rotation, for now just replace all data\n self.db.truncate()\n # self.db_path = pathlib.Path(db_file)\n # self.db_file_name = self.db_path.name\n # self.db_dir = self.db_path.parent","def set_config_path(self, new_config_path):\n oldpath = self.get_config_path()\n cdir, cfile = os.path.split(new_config_path)\n \n if not cdir.startswith('/'):\n cdit='/'+cdir\n if not cfile:\n cfile = 'site.yaml'\n\n self.dropbox_base_dir = cdir\n self.dropbox_site_yaml = cfile\n newpath = self.get_config_path()\n if newpath !=oldpath:\n return oldpath","def get_database_filename() -> str:\n config_dir = get_config_dir()\n return os.path.join(config_dir, DATABASE_FILENAME)","def gtfsdb_main(ctx, database):\n ctx.obj = dict()\n if not database and os.path.exists(DEFAULT_CONFIG_FILE):\n conf = json.load(open(DEFAULT_CONFIG_FILE, 'r'))\n database = conf['database']\n ctx.obj.update(dict(conf=conf))\n else:\n click.echo(\"No database selected!!\")\n sys.exit(1)\n ctx.obj.update(dict(database=Database(url=database), db_url=database))","def __init__(self, configfile=None):\n self.withwith = ('2.5' in psycopg2.__version__)\n self.conn = None\n self.setdefaults()\n if configfile is not None:\n self.loadconfig(configfile)","def find_pass_cfg(file_path=None):\n if not file_path:\n file_path = '~/.pass.cfg'\n\n if os.path.isfile(os.path.expanduser(file_path)):\n return file_path\n else:\n return None","def _cfg_path(argv):\n cfg_path = argv[1] if len(argv) > 1 else None\n _is_file = os.path.isfile\n if not cfg_path or not _is_file(cfg_path):\n if cfg_path:\n _info(\"no config at {}, trying the default location\".format(\n cfg_path))\n cfg_path = _DEFAULT_PATH\n if not _is_file(cfg_path):\n _info(\"no config at {}, exiting\".format(cfg_path))\n return None\n return cfg_path","def test_alternate_get_mylogin_cnf_path():\n original_env = None\n if 'MYSQL_TEST_LOGIN_FILE' in os.environ:\n original_env = os.environ.pop('MYSQL_TEST_LOGIN_FILE')\n\n _, temp_path = tempfile.mkstemp()\n os.environ['MYSQL_TEST_LOGIN_FILE'] = temp_path\n\n login_cnf_path = get_mylogin_cnf_path()\n\n if original_env is not None:\n os.environ['MYSQL_TEST_LOGIN_FILE'] = original_env\n\n assert temp_path == login_cnf_path","def _change_file_hosted_location():\n\n # Changes where the file is hosted\n path = (f\"{RPKI_Validator_Wrapper.rpki_package_path}conf\"\n \"/application-defaults.properties\")\n prepend = \"rpki.validator.bgp.ris.dump.urls=\"\n replace = (\"https://www.ris.ripe.net/dumps/riswhoisdump.IPv4.gz,\"\n \"https://www.ris.ripe.net/dumps/riswhoisdump.IPv6.gz\")\n replace_with = (f\"http://localhost:{RPKI_File.port}\"\n f\"/{RPKI_File.hosted_name}\")\n utils.replace_line(path, prepend, replace, replace_with)","def load_rec_conf_dir(self):\n rec_file = select_file(os.getcwd())\n if rec_file is not None:\n self.load_tab_common(rec_file)\n else:\n msg_window('please select valid rec config file')","def get_db_path():\n return os.path.join(sys.path[0], \"my_db.db\")","def get_old_db_details():\n db_conf_prelim = {\n 'host': None,\n 'port': None,\n 'database': None,\n 'username': None,\n 'password': None }\n\n db_conf = codecs.open(\"db.conf\", encoding=\"utf-8\", mode=\"r\")\n db_conf_text = db_conf.read()\n db_conf.close()\n\n prev_host = search_config(\"metastore.connection-postgresql.host\", \"host\", db_conf_text)\n prev_port = search_config(\"metastore.connection-postgresql.port\", \"port\", db_conf_text)\n prev_database = search_config(\"metastore.connection-postgresql.database\", \"database\", db_conf_text)\n prev_username = search_config(\"metastore.connection-postgresql.username\", \"username\", db_conf_text)\n prev_password = search_config(\"metastore.connection-postgresql.password\", \"password\", db_conf_text)\n db_conf_from_file = {\n 'host': prev_host if prev_host else None,\n 'port': prev_port if prev_port else None,\n 'database': prev_database if prev_database else None,\n 'username': prev_username if prev_username else None,\n 'password': prev_password if prev_password else None }\n\n db_conf_prelim.update(db_conf_from_file)\n return db_conf_prelim","def check_config(self):\n cfgs = self.__get() \n \n for option in Config.FILE_OPTIONS.keys():\n _default = Config.FILE_OPTIONS[option]\n \n if not cfgs.has_key(option):\n self.log.warn(\"Parameter '%s' is missing in '%s', using default('%s')\" % \\\n (option, self.config_file, _default))\n _file = _default\n else:\n _file = cfgs[option]\n Config.FILE_OPTIONS[option] = _file\n\n if not os.path.exists(_file) and not os.path.isfile(_file):\n self.log.error(\"Paramenter '%s' points to non-existing file '%s')\" % \\\n (option, _file))\n raise ConfigError('File Error', \"Paramenter '%s' points to non-existing file '%s')\" % \\\n (option, _file))\n\n\n for option in Config.PATH_OPTIONS.keys():\n _default = Config.PATH_OPTIONS[option]\n \n if not cfgs.has_key(option):\n self.log.warn(\"Parameter '%s' is missing in '%s', using default('%s')\" % \\\n (option, self.config_file, _default))\n _dir = _default\n else:\n _dir = cfgs[option]\n Config.PATH_OPTIONS[option] = _dir\n\n if not os.path.exists(_dir) and not os.path.isdir(_dir):\n self.log.error(\"Paramenter '%s' points to non-existing directory '%s')\" % \\\n (option, _dir))\n raise ConfigError('File Error', \"Paramenter '%s' points to non-existing directory '%s')\" % \\\n (option, _dir))\n\n \n Config.DB_SFT_OPTIONS['sqlalchemy_sft.url'] = cfgs['sqlalchemy_sft.url']\n Config.DB_NAGIOS_OPTIONS['sqlalchemy_nagios.url'] = cfgs['sqlalchemy_nagios.url']\n\n self.log.debug(\"Configuration successfully checked\")","def _create_default_config(self):\n self.options.setdefault('options.admin_passwd', '')\n sys.path.append(self.openerp_dir)\n sys.path.extend([egg.location for egg in self.ws])\n from openerp.tools.config import configmanager\n configmanager(self.config_path).save()","def __getattr__(self, name):\n \n # first check for the environment variable for the database\n variable = get_environment_variable(self.vars[name].name)\n \n if not variable:\n # next check for the overall location variable\n base_folder = get_environment_variable(self.base_environment_variable)\n if base_folder:\n variable = os.path.join(base_folder,self.vars[name].default_path)\n \n if variable and not (os.path.isfile(variable) or os.path.isdir(variable)):\n # if this is not a valid folder/file, then resume search\n variable = None\n \n # check in the default folders, if not found with env variables\n if not variable:\n for folder in install_locations():\n if os.path.isdir(folder):\n variable = os.path.join(folder,self.vars[name].default_path)\n if os.path.isfile(variable) or os.path.isdir(variable):\n return variable\n \n if not variable:\n sys.exit(\"ERROR: Unable to find database \"+self.vars[name].name+\n \". \"+self.vars[name].description+\" Unable to find in default\"+\n \" install folders or with environment variables.\")\n \n return variable","def find_default(self, fs_path):\n if os.path.isdir(fs_path):\n default = None\n for name in self.defaults:\n _path = os.path.join(fs_path, name)\n if os.path.isfile(_path):\n default = _path\n break\n if default is None:\n raise Response(403)\n fs_path = default\n return fs_path","def formatdb(fastadata={},fname=\"\"):\n if not fastadata and fname:\n OSsystem(\"%s -i %s\" % (FORMATDB_PATH,fname))\n elif fastadata and fname:\n pass\n else:\n raise \"inproper input\"\n return fname","def test_get_config_file_value(self):\n parser = GbpOptionParser('cmd4')\n self.assertEqual(parser.get_config_file_value('new_overrides_git_option1'),\n 'new_overrides_git_value1')\n self.assertEqual(parser.get_config_file_value('doesnotexist'), None)","def editPostgresConf():\n\n try:\n tempFile = tempfile.mktemp(dir=\"/tmp\")\n\n logging.debug(\"copying %s over %s\", basedefs.FILE_PSQL_CONF, tempFile)\n shutil.copy2(basedefs.FILE_PSQL_CONF, tempFile)\n\n handler = utils.TextConfigFileHandler(tempFile)\n handler.open()\n handler.editParam(\"max_connections\", basedefs.CONST_MAX_PSQL_CONNS)\n handler.close()\n\n logging.debug(\"copying temp file over original file\")\n shutil.copy2(tempFile, basedefs.FILE_PSQL_CONF)\n\n logging.debug(\"setting permissions & file ownership\")\n os.chown(basedefs.FILE_PSQL_CONF, utils.getUsernameId(\"postgres\"), utils.getGroupId(\"postgres\"))\n os.chmod(basedefs.FILE_PSQL_CONF, 0600)\n\n logging.debug(\"removing tempoarary file\")\n os.remove(tempFile)\n\n except:\n logging.error(\"Failed editing %s\" % basedefs.FILE_PSQL_CONF)\n logging.error(traceback.format_exc())\n raise Exception(output_messages.ERR_EXP_EDIT_PSQL_CONF)","def _restore_orig_directory(self):\n if not self._is_temp_dir:\n return\n self._base_data_dir = self._orig_base_data_dir\n del self._orig_base_data_dir\n self._base_logs_dir = self._orig_base_logs_dir\n del self._orig_base_logs_dir\n self.db.change_path(self._base_data_dir / \"projects.db\")\n self.set_current(\"default\", update=False)\n self._is_temp_dir = False","def load_data_conf(self):\n data_file = select_file(os.getcwd())\n if data_file is not None:\n self.load_tab(data_file)\n else:\n msg_window('please select valid data config file')","def get_default_database(self):\n attr_name = mangle_delegate_name(self.__class__, '__default_database_name')\n default_db_name = getattr(self.delegate, attr_name)\n if default_db_name is None:\n raise ConfigurationError('No default database defined')\n\n return self[default_db_name]","def __create_default_config(self):\n if not os.path.exists(self.__configfile):\n path=os.path.dirname(self.__configfile)\n try:\n os.makedirs(path)\n except:\n pass\n if os.path.exists(path):\n self.save(defaults=True)","def settings_db_read_settings(db_name=SETTINGS_DB_NAME):\n paths = local = None\n if os.path.isfile(db_name):\n with lite.connect(db_name) as con:\n cur = con.cursor()\n result = cur.execute(\"SELECT LOGISIM_HOME, GRADING_PATH, IMPORT_PATH, GRADES_DB\\\n FROM PATHS\")\n paths = result.fetchone()\n result = cur.execute(\"SELECT GRADER_NAME, YEAR, SEMESTER, USE_STYLE, SYNC_COMMAND\\\n FROM LOCAL\")\n local = result.fetchone()\n\n return paths, local","def config():\n file_path = None # path to the input file\n db_path = None # path to the output db\n atomic_properties = (\n \"Properties=species:S:1:pos:R:3\"\n ) # atomic properties of the input file\n molecular_properties = [\"energy\"] # molecular properties of the input file\n overwrite = False","def perform_config(self):\n\n super(PidfileApp, self).perform_config()\n\n if ('general' in self.cfg and 'pidfile' in self.cfg['general']):\n # Not set by commandline, but set in configuration\n pidfile = to_str_or_bust(self.cfg['general']['pidfile'])\n if pidfile and (pidfile != self._default_pidfilename):\n log.debug(\n _(\"Setting pidfile to %r by configuration.\"), pidfile)\n self._pidfilename = pidfile","def test_config_overwrites():\n basepath = os.path.abspath(os.path.join(os.path.dirname(__file__), \"..\", '..'))\n temppath = '/tmp/'\n\n conf = core.Config(datapath=temppath)\n\n assert conf.basepath.lower() == basepath.lower()\n assert conf.datapath.lower() == temppath.lower()","def get_database_directory(self):\n pass","def __init__(self, dbfile=\"eom_default_db.sqlite\", init_db=False):\n self.sql = None\n missing = not os.path.exists(dbfile)\n self.sql = sqlite3.connect(dbfile, detect_types = sqlite3.PARSE_DECLTYPES)\n self.sql.text_factory = str\n if missing or init_db:\n self.init_rpki_rtr_tables()\n self.init_rib_tables()\n self.init_analysis_tables()","def get_database_url(self):\n return self.config['dbase_path']","def create_db_ini(self, upload_json_path):\n db_type = self.database_config.get(\"type\", \"sqlite\").strip().lower()\n try:\n # Prevent multi-thread lock-free problems\n if not os.path.exists(self.db_ini):\n os.makedirs(self.db_ini)\n except:\n pass\n time_temp = os.path.split(os.path.dirname(upload_json_path))[-1]\n db_path = os.path.join(self._db, \"%s.db\" % time_temp)\n config_ini = configparser.ConfigParser()\n config_ini['database'] = {\n \"on\": self.database_config.get(\"on\", \"true\"),\n \"platform_id\": self.trans.platform,\n \"type\": db_type\n }\n config_ini['redis'] = {\n \"host\": self.redis_config.get(\"host\", \"127.0.0.1\"),\n \"port\": self.redis_config.get(\"port\", 6379),\n \"password\": self.redis_config.get(\"password\", \"\"),\n \"table_index\": self.redis_config.get(\"table_index\", \"\"),\n \"timeout\": self.redis_config.get(\"timeout\", 5000)\n }\n config_ini['sqlite'] = {\n \"db_path\": db_path,\n \"temporary\": self.sqlite_config.get(\"temporary\", \"false\")\n }\n if db_type == \"redis\":\n db_ini_path = os.path.join(self.db_ini, \"db_redis.ini\")\n elif db_type == \"sqlite\":\n db_ini_path = os.path.join(self.db_ini, \"%s.ini\" % time_temp)\n else:\n error_data_msg = \"{} is not a supported database, only support 'redis' or 'sqlite'\".format(db_type)\n raise UnsupportedDatabaseError(error_data_msg)\n\n with open(db_ini_path, 'w') as configfile:\n config_ini.write(configfile)\n return db_ini_path","def load_file():\n global list_of_table, data_base, new_data\n open_name = askopenfilename()\n\n if Path(open_name).suffix == '.db':\n data_base = open_name\n data_base = str(data_base)\n new_data_base = parse(data_base)\n new_data = update_list_tables(new_data_base)\n new_data.clear()\n\n else:\n mistake_db_file()","def setup_database(config, interactive, logger):\n options = [\n 'django.db.backends.sqlite3',\n 'django.db.backends.mysql',\n 'django.db.backends.oracle',\n 'django.db.backends.postgresql',\n 'django.db.backends.postgresql_psycopg2',\n ]\n selected = config.get('database_engine')\n message = \"\\nSet %s to (%s) \\n\"\n message += '\\n'.join(['%s [%d] %s' % (('*' if selected == options[i] else ' '), i, options[i]) for i in range(len(options))])\n message += '\\nor enter one from the list above:'\n config = set_option(config, 'database_engine', interactive, logger, message)\n \n db = config.get('database_engine')\n try:\n db = options[int(db)]\n config['database_engine'] = db\n except:\n assert(db in options), \"Improper Database Backend\"\n \n # sqlite3 is special\n if db == 'django.db.backends.sqlite3':\n base = config.get('cannula_base')\n config['database_name'] = os.path.join(base, 'cannula.db')\n config = set_option(config, 'database_name', interactive, logger)\n else:\n config['database_name'] = ''\n config = set_option(config, 'database_name', interactive, logger)\n config = set_option(config, 'database_user', interactive, logger)\n config = set_option(config, 'database_password', interactive, logger)\n config = set_option(config, 'database_host', interactive, logger)\n config = set_option(config, 'database_port', interactive, logger)\n \n return config","def default_empty_config_env(monkeypatch):\n monkeypatch.delenv(\"SOPEL_CONFIG\", raising=False)\n monkeypatch.delenv(\"SOPEL_CONFIG_DIR\", raising=False)","def _load_from_conf(self, parser, section, db, conf_dir, cloud_confs, conf_file):\n\n iaas = config_get_or_none(parser, section, \"iaas\", self.iaas)\n iaas_url = config_get_or_none(parser, section, \"iaas_url\", self.iaas_url)\n\n sshkey = config_get_or_none(parser, section, \"sshkeyname\", self.keyname)\n localssh = config_get_or_none(parser, section, \"localsshkeypath\", self.localkey)\n ssh_user = config_get_or_none(parser, section, \"ssh_username\", self.username)\n scp_user = config_get_or_none(parser, section, \"scp_username\", self.scp_username)\n bootconf = config_get_or_none(parser, section, \"bootconf\", self.bootconf)\n bootpgm = config_get_or_none(parser, section, \"bootpgm\", self.bootpgm)\n bootpgm_args = config_get_or_none(parser, section, \"bootpgm_args\", self.bootpgm_args)\n hostname = config_get_or_none(parser, section, \"hostname\", self.hostname)\n readypgm = config_get_or_none(parser, section, \"readypgm\", self.readypgm)\n readypgm_args = config_get_or_none(parser, section, \"readypgm_args\", self.readypgm_args)\n iaas_key = config_get_or_none(parser, section, \"iaas_key\", self.iaas_key)\n iaas_secret = config_get_or_none(parser, section, \"iaas_secret\", self.iaas_secret)\n securitygroups = config_get_or_none(parser, section, \"securitygroups\", self.securitygroups)\n\n terminatepgm = config_get_or_none(parser, section, \"terminatepgm\", self.terminatepgm)\n terminatepgm_args = config_get_or_none(parser, section, \"terminatepgm_args\", self.terminatepgm_args)\n\n pgm_timeout = config_get_or_none(parser, section, \"pgm_timeout\", self.pgm_timeout)\n\n local_exe = config_get_or_none_bool(parser, section, \"local_exe\", self.local_exe)\n\n\n allo = config_get_or_none(parser, section, \"allocation\", self.allocation)\n image = config_get_or_none(parser, section, \"image\", self.image)\n cloudconf = config_get_or_none(parser, section, \"cloud\")\n if cloudconf:\n try:\n conf = cloud_confs[cloudconf]\n except:\n raise APIUsageException(\"%s is not a valud cloud description in this plan\" % (cloudconf))\n\n if not iaas:\n iaas = conf.iaas\n if not iaas_url:\n iaas_url = conf.iaas_url\n if not sshkey:\n sshkey = conf.sshkey\n if not localssh:\n localssh = conf.localssh\n if not ssh_user:\n ssh_user = conf.ssh_user\n if not scp_user:\n scp_user = conf.scp_user\n if not iaas_key:\n iaas_key = conf.iaas_key\n if not iaas_secret:\n iaas_secret = conf.iaas_secret\n if not securitygroups:\n securitygroups = conf.securitygroups\n\n if not iaas:\n iaas = db.default_iaas\n if not iaas_url:\n iaas_url = db.default_iaas_url\n if not allo:\n allo = db.default_allo\n if not sshkey:\n sshkey = db.default_sshkey\n if not localssh:\n localssh = db.default_localssh\n if not ssh_user:\n ssh_user = db.default_ssh_user\n if not scp_user:\n scp_user = db.default_scp_user\n if not iaas_key:\n iaas_key = db.default_iaas_key\n if not iaas_secret:\n iaas_secret = db.default_iaas_secret\n if not securitygroups:\n securitygroups = db.default_securitygroups\n if not image:\n image = db.default_image\n if not bootconf:\n bootconf = db.default_bootconf\n if not bootpgm:\n bootpgm = db.default_bootpgm\n if not bootpgm_args:\n bootpgm_args = db.default_bootpgm_args\n if not readypgm:\n readypgm = db.default_readypgm\n if not readypgm_args:\n readypgm_args = db.default_readypgm_args\n if not terminatepgm:\n terminatepgm = db.default_terminatepgm\n if not terminatepgm_args:\n terminatepgm_args = db.default_terminatepgm_args\n if not pgm_timeout:\n pgm_timeout = db.default_pgm_timeout\n\n if not local_exe:\n local_exe = db.default_local_exe\n\n\n self.image = image\n self.bootconf = _resolve_file_or_none(conf_dir, bootconf, conf_file)\n self.bootpgm = _resolve_file_or_none(conf_dir, bootpgm, conf_file, has_args=True)\n self.bootpgm_args = bootpgm_args\n self.terminatepgm = _resolve_file_or_none(conf_dir, terminatepgm, conf_file, has_args=True)\n self.terminatepgm_args = terminatepgm_args\n self.pgm_timeout = pgm_timeout\n self.local_exe = local_exe\n\n self.hostname = hostname\n self.readypgm = _resolve_file_or_none(conf_dir, readypgm, conf_file, has_args=True)\n self.readypgm_args = readypgm_args\n self.username = ssh_user\n self.scp_username = scp_user\n self.localkey = _resolve_file_or_none(conf_dir, localssh, conf_file)\n self.keyname = sshkey\n self.allocation = allo\n self.iaas = iaas\n self.iaas_url = iaas_url\n\n self.iaas_secret = iaas_secret\n self.iaas_key = iaas_key\n self.securitygroups = securitygroups\n\n x = config_get_or_none(parser, section, \"iaas_launch\")\n if x:\n if x.lower() == 'true':\n self.iaas_launch = True\n else:\n self.iaas_launch = False\n else:\n if self.hostname:\n self.iaas_launch = False\n else:\n self.iaas_launch = True\n\n # allow the plan to over ride the default image if they want to use a hostname\n if self.iaas_launch is False:\n self.image = None\n\n item_list = parser.items(section)\n deps_list = []\n for (ka,val) in item_list:\n ndx = ka.find(\"deps\")\n if ndx == 0:\n deps_list.append(ka)\n deps_list.sort()\n for i in deps_list:\n deps = config_get_or_none(parser, section, i)\n deps_file = _resolve_file_or_none(conf_dir, deps, conf_file)\n if deps_file:\n parser2 = ConfigParser.ConfigParser()\n parser2.read(deps_file)\n keys_val = parser2.items(\"deps\")\n for (ka,val) in keys_val:\n val2 = config_get_or_none(parser2, \"deps\", ka)\n if val2 is not None:\n bao = BagAttrsObject(ka, val2)\n self.attrs.append(bao)","def default_configfile():\n dirname=None\n if os.getenv(\"HOME\"):\n dirname=os.getenv(\"HOME\")\n elif os.getenv(\"USERPROFILE\"):\n dirname=os.getenv(\"USERPROFILE\")\n\n else:\n raise FattyException(\"No HOME or USERPROFILE variable set, unable to determine default config file\")\n\n return os.path.join(dirname,\".fattybugs\")","def get_default_config_file() -> Path:\n return get_path_to_pyflow() / \"pyflow\" / \"conf\" / CONFIG_FILE","def set_file(self, sql_file):\n self.file_type = self.get_file_extension(sql_file)\n self.sql_file = sql_file","def expand_db_path(path):\n if path is None:\n path = join(xdg.BaseDirectory.xdg_data_home, 'khal', 'khal.db')\n return expanduser(expandvars(path))","def getDbStrNone(self, db, key):\n \n value = self.get(db + \".\" + key)\n if value == None:\n value = self.get(\"default.\" + key)\n return value","def set_default_paths(args):\n filename = os.path.join(os.path.expanduser('~'), '.gfail_defaults')\n if os.path.exists(filename):\n D = ConfigObj(filename)\n else:\n D = {}\n if args.data_path is not None:\n if args.data_path == 'reset':\n D.pop('data_path')\n else:\n # check that it's a valid path\n if os.path.exists(args.data_path):\n D.update({'data_path': args.data_path})\n else:\n print('Path given for data_path does not exist: %s'\n % args.data_path)\n if args.output_filepath is not None:\n if args.output_filepath == 'reset':\n D.pop('output_filepath')\n else:\n # check that it's a valid path\n if os.path.exists(args.output_filepath):\n D.update({'output_filepath': args.output_filepath})\n else:\n print('Path given for output_filepath does not exist: %s'\n % args.output_filepath)\n if args.config_filepath is not None:\n if args.config_filepath == 'reset':\n D.pop('config_filepath')\n else:\n # check that it's a valid path\n if os.path.exists(args.config_filepath):\n D.update({'config_filepath': args.config_filepath})\n else:\n print('Path given for config_filepath does not exist: %s'\n % args.config_filepath)\n if args.popfile is not None:\n if args.popfile == 'reset':\n D.pop('popfile')\n else:\n # check that it's a valid path\n if os.path.exists(args.popfile):\n D.update({'popfile': args.popfile})\n else:\n print('Path given for population file does not exist: %s'\n % args.popfile)\n if args.trimfile is not None:\n if args.trimfile == 'reset':\n D.pop('trim')\n else:\n # check that it's a valid path and that it's a shapefile\n if os.path.exists(args.trimfile):\n filename4, fileextension = os.path.splitext(args.trimfile)\n if fileextension == '.shp':\n D.update({'trimfile': args.trimfile})\n else:\n print('Ocean trimming file is not a shapefile: %s'\n % args.trimfile)\n else:\n print('Path given for ocean trimming file does not exist: %s'\n % args.trimfile)\n if args.pdl_config is not None:\n if args.pdl_config == 'reset':\n D.pop('pdl_config')\n else:\n # check that it's a valid path\n if os.path.exists(args.pdl_config):\n D.update({'pdl_config': args.pdl_config})\n else:\n print('Path given for pdl config file does not exist: %s'\n % args.pdl_config)\n if args.log_filepath is not None:\n if args.log_filepath == 'reset':\n D.pop('log_filepath')\n else:\n # check that it's a valid path\n if os.path.exists(args.log_filepath):\n D.update({'log_filepath': args.log_filepath})\n else:\n print('Path given for log file does not exist: %s'\n % args.log_filepath)\n if args.dbfile is not None:\n if args.dbfile == 'reset':\n D.pop('dbfile')\n else:\n # check that it's a valid path (file itself doesnt have to exist)\n if os.path.exists(os.path.dirname(args.dbfile)):\n D.update({'dbfile': args.dbfile})\n else:\n print('Path given for database file does not exist: %s'\n % args.dbfile)\n\n print('New default paths set.\\n')\n\n if D:\n C = ConfigObj(D)\n C.filename = filename\n C.write()\n list_default_paths()\n else:\n print('no defaults set because no paths were input\\n')"],"string":"[\n \"def set_db_file():\\n\\n return os.path.join(db_path, db_file)\",\n \"def default_bug_db(configfile=None):\\n\\n configs=None\\n if not configfile:\\n configs=default_configs()\\n else:\\n configs=configparser.ConfigParser()\\n configs.read(configfile)\\n\\n db_file=os.path.normpath(configs.get(\\\"bug_db\\\",\\\"db_file\\\"))\\n return db_file\",\n \"def default_db_config():\\n return read_json_file(db_config_file)\",\n \"def get_default_config_path():\\n if os.name == 'posix':\\n config_path = os.path.join(os.path.expanduser(\\\"~\\\"), '.fpdb')\\n elif os.name == 'nt':\\n config_path = os.path.join(os.environ[\\\"APPDATA\\\"], 'fpdb')\\n else: config_path = False\\n return config_path\",\n \"def reset_database_to_default(self):\\n _src = os.path.abspath(self.default_db)\\n _dst = os.path.abspath(self.db_path)\\n copyfile(_src, _dst)\",\n \"def getDefaultDatabaseConnectionParameter(self):\\n return { 'path' : os.path.join(self.configPath(), 'databases', 'settings.db') }\",\n \"def database_file(file):\\r\\n fpath = path.join('databases', '{0}'.format(file))\\r\\n db_path = path.join(mod_path, fpath)\\r\\n return db_path\",\n \"def get_db_file(config):\\n db_file = None\\n\\n db = config.get_config(\\\"db\\\")\\n db_config = config.get_config(\\\"db_config\\\")\\n if db == \\\"sqlalchemy\\\":\\n db_file = db_config.get(\\\"uri\\\")\\n\\n return db_file\",\n \"def get_db_file(config):\\n db_file = None\\n\\n db = config.get_config(\\\"db\\\")\\n db_config = config.get_config(\\\"db_config\\\")\\n if db == \\\"sqlalchemy\\\":\\n db_file = db_config.get(\\\"uri\\\")\\n\\n return db_file\",\n \"def setdefaults(self):\\n self.config = {\\n 'dbuser': Infopage.DEFAULT_DBUSER,\\n 'dbname': Infopage.DEFAULT_DBNAME,\\n 'dbpassword': Infopage.DEFAULT_DBPASSWORD,\\n 'dbhost': Infopage.DEFAULT_DBHOST\\n }\",\n \"def set_object_database (self, file_name):\\n try:\\n self.object_database=file_name\\n self.filepath_object_database = os.path.join(self.filepath, self.object_database)\\n print(\\\"set object_database filename to\\\", file_name)\\n except:\\n print(\\\"setting object database failed\\\")\\n self.object_database=\\\"Object_database.db\\\"\\n self.filepath_object_database = os.path.join(self.filepath, self.object_database)\\n print(\\\"set object database name to default:\\\", self.object_database)\\n return\",\n \"def db_path_with_improper_files():\\n return os.path.join(_here, 'fixtures/databases/db-improper/database')\",\n \"def get_config(file_name, fallback = True):\\n exec_dir = get_exec_path()\\n if file_name == 'logging.conf' and not hasattr(sys, \\\"frozen\\\"):\\n config_path = os.path.join(exec_dir, 'pyfpdb', file_name)\\n else:\\n config_path = os.path.join(exec_dir, file_name)\\n# print \\\"config_path=\\\", config_path\\n if os.path.exists(config_path): # there is a file in the cwd\\n return (config_path,False) # so we use it\\n else: # no file in the cwd, look where it should be in the first place\\n default_dir = get_default_config_path()\\n config_path = os.path.join(default_dir, file_name)\\n# print \\\"config path 2=\\\", config_path\\n if os.path.exists(config_path):\\n return (config_path,False)\\n\\n# No file found\\n if not fallback:\\n return (False,False)\\n\\n# OK, fall back to the .example file, should be in the start dir\\n if os.path.exists(file_name + \\\".example\\\"):\\n try:\\n print \\\"\\\"\\n check_dir(default_dir)\\n shutil.copyfile(file_name + \\\".example\\\", config_path)\\n msg = \\\"No %s found\\\\n in %s\\\\n or %s\\\\n\\\" % (file_name, exec_dir, default_dir) \\\\\\n + \\\"Config file has been created at %s.\\\\n\\\" % config_path\\n print msg\\n logging.info(msg)\\n file_name = config_path\\n except:\\n print \\\"Error copying .example file, cannot fall back. Exiting.\\\\n\\\"\\n sys.stderr.write(\\\"Error copying .example file, cannot fall back. Exiting.\\\\n\\\")\\n sys.stderr.write( str(sys.exc_info()) )\\n sys.exit()\\n else:\\n print \\\"No %s found, cannot fall back. Exiting.\\\\n\\\" % file_name\\n sys.stderr.write(\\\"No %s found, cannot fall back. Exiting.\\\\n\\\" % file_name)\\n sys.exit()\\n return (file_name,True)\",\n \"def get_config_file(self):\\n\\n conf_file = self.args.file\\n if conf_file is not None:\\n if os.path.isfile(conf_file):\\n config_file = open(conf_file, \\\"r\\\")\\n self.main_file = yaml.load(config_file, Loader=yaml.FullLoader)\\n elif os.path.isfile(\\n os.path.join(get_path(\\\"DEFAULT\\\", \\\"config_file_path\\\"), conf_file)\\n ):\\n fpath = get_path(\\\"DEFAULT\\\", \\\"config_file_path\\\")\\n config_file = open(os.path.join(fpath, conf_file), \\\"r\\\")\\n self.main_file = yaml.load(config_file, Loader=yaml.FullLoader)\\n else:\\n self.logger.error(\\n colorama.Fore.RED\\n + \\\"ERROR!! Config file '%s' is not present \\\" % conf_file,\\n extra=self.log_detail,\\n )\\n sys.exit(1)\\n else:\\n if self.args.hostname and self.args.testfiles:\\n temp_dict = {\\n \\\"hosts\\\": [{\\\"device\\\": \\\"\\\", \\\"username\\\": \\\"\\\", \\\"passwd\\\": \\\"\\\"}],\\n \\\"tests\\\": [],\\n }\\n temp_dict[\\\"hosts\\\"][0][\\\"device\\\"] = self.args.hostname\\n temp_dict[\\\"hosts\\\"][0][\\\"username\\\"] = self.args.login\\n temp_dict[\\\"hosts\\\"][0][\\\"passwd\\\"] = self.args.passwd\\n for tfile in self.args.testfiles:\\n temp_dict[\\\"tests\\\"].append(tfile)\\n self.main_file = temp_dict\\n\\n if (\\n self.main_file.__contains__(\\\"sqlite\\\")\\n and self.main_file[\\\"sqlite\\\"]\\n and self.main_file[\\\"sqlite\\\"][0]\\n ):\\n self.chk_database(\\n self.main_file,\\n self.args.pre_snapfile,\\n self.args.post_snapfile,\\n self.args.check,\\n self.args.snap,\\n )\\n else:\\n # if --check option is given for sqlite, then snap file name is not compulsory\\n # else exit the function saying arguments not correct\\n if self.args.check is True and (\\n self.args.pre_snapfile is None or self.args.post_snapfile is None\\n ):\\n self.logger.error(\\n colorama.Fore.RED\\n + \\\"Arguments not given correctly, Please refer help message\\\",\\n extra=self.log_detail,\\n )\\n self.parser.print_help()\\n sys.exit(1)\",\n \"def init_default_config_file_if_nonexistent(package, default_config):\\n config_file = os.path.join(conf.PAULA_USER_CONFIG_DIR, package + conf.CONFIG_EXTENSION)\\n debug('config_file = ' + config_file)\\n if not os.path.exists(config_file):\\n debug('making: \\\\\\\"' + config_file+ '\\\\\\\"')\\n shutil.copyfile(default_config, config_file)\",\n \"def set_output_database (self, file_name):\\n try:\\n self.object_database=file_name\\n self.filepath_output_database = os.path.join(self.filepath, self.output_database)\\n print(\\\"set output_database filename to\\\", file_name)\\n except:\\n print(\\\"setting object database failed\\\")\\n self.output_database=\\\"Output_database.db\\\"\\n self.filepath_output_database = os.path.join(self.filepath, self.output_database)\\n print(\\\"set output database name to default:\\\", self.object_database)\\n return\",\n \"def restore_default_connections_file():\\n if os.path.exists(DEFAULT_CONNECTIONS_FILE_BAK):\\n if os.path.exists(DEFAULT_CONNECTIONS_FILE):\\n os.remove(DEFAULT_CONNECTIONS_FILE)\\n os.rename(DEFAULT_CONNECTIONS_FILE_BAK, DEFAULT_CONNECTIONS_FILE)\",\n \"def use_config_file(self):\\n self.config_file = self.find_config_file()\\n if self.config_file:\\n self.apply_config_file(self.config_file)\",\n \"def db_python_only():\\n return os.path.join(_here, 'fixtures/databases/db-python-only/database')\",\n \"def set_render_database_name(self, file_name):\\n try:\\n self.render_database=file_name\\n self.filepath_render_database = os.path.join(self.filepath, self.render_database)\\n print(\\\"set render_database filename to\\\", file_name)\\n except:\\n print(\\\"setting render database failed\\\")\\n self.render_database=\\\"Render_database.db\\\"\\n self.filepath_object_database = os.path.join(self.filepath, self.render_database)\\n print(\\\"set render database name to default:\\\", self.render_database)\\n return\",\n \"def db_file():\\n return abspath('vmchecker.db')\",\n \"def getDefaultDBName() -> str:\\n return f\\\"dbname={getpass.getuser()}\\\"\",\n \"def set_default_config(self, filename):\\n if os.path.isfile(filename):\\n os.remove(filename)\\n\\n config = configparser.ConfigParser()\\n default_cfg = {'config': {'database_name': 'manga.db',\\n 'volume_limit': 128,\\n 'series_per_page': 0,\\n 'compact_list': 0,\\n 'show_empty_series': False,\\n 'default_to_gui': True}}\\n\\n config.read_dict(default_cfg)\\n with open(filename, 'w') as config_ini:\\n config.write(config_ini)\\n\\n # Reset class variables for config object as well\\n self.config = config\\n self.filename = filename\\n self.database_name = 'manga.db'\\n self.volume_limit = 128\\n self.series_per_page = 0\\n self.compact_list = False\\n self.show_empty_series = False\\n self.default_to_gui = True\",\n \"def default_configfile(self):\\r\\n config = None\\r\\n for path in self.searchpaths:\\r\\n if os.path.exists(path):\\r\\n config = path\\r\\n break\\r\\n if config is None and self.require_configfile:\\r\\n self.usage('No config file found at default paths (%s); '\\r\\n 'use the -c option to specify a config file '\\r\\n 'at a different path' % ', '.join(self.searchpaths))\\r\\n return config\",\n \"def getDBPath():\\n return os.path.join(CONFIG_DIR, CONFIG_DICT['common']['local_db'])\",\n \"def read_db():\\n # read config file\\n config = configparser.ConfigParser()\\n config.read_file(open(\\\"options.cfg\\\"))\\n\\n return config['DEFAULT']['DatabaseFilename']\",\n \"def _init_database_config(self):\\n\\n if self._database_config is not None:\\n return\\n\\n self._database_config = frozendict()\\n\\n if ENVIRONMENT_VARIABLE not in os.environ:\\n logger.debug(\\\"Database configuration not provided\\\")\\n\\n elif not (os.environ[ENVIRONMENT_VARIABLE] or \\\"\\\").endswith(\\\".json\\\"):\\n config_path = os.environ[ENVIRONMENT_VARIABLE]\\n raise EnvironmentError(f\\\"Invalid database configuration file: {config_path}\\\")\\n\\n else:\\n try:\\n config_path = os.environ[ENVIRONMENT_VARIABLE]\\n config_file = pathlib.Path(config_path).expanduser().resolve(strict=True)\\n with open(config_file) as config_json:\\n database_config = json.loads(config_json.read())\\n\\n except FileNotFoundError:\\n raise EnvironmentError(f\\\"Database configuration file does not exist: {config_path}\\\")\\n except ValueError:\\n raise EnvironmentError(f\\\"Database configuration file does not contain JSON: {config_path}\\\")\\n\\n # Remove values from overridden configuration if not present in supported configuration\\n database_config = {k: v for k, v in database_config.items() if k in SUPPORTED_CONFIG}\\n # Assign defaults in supported configuration if not present in overridden configuration\\n database_config.update({k: v for k, v in SUPPORTED_CONFIG.items() if k not in database_config})\\n\\n self._database_config = frozendict(database_config)\",\n \"def generate_config(args):\\n default_config = resource_string('webrpg', 'scripts/templates/default_config.txt').decode('utf-8')\\n if args.sqla_connection_string:\\n default_config = default_config.replace('%(sqlalchemy_url)s', args.sqla_connection_string)\\n else:\\n default_config = default_config.replace('%(sqlalchemy_url)s', get_user_parameter('SQL Alchemy Connection String', 'sqlite:///%(here)s/pyire_test.db'))\\n\\n with open(args.filename, 'w') as out_f:\\n out_f.write(default_config)\",\n \"def setDb(self, db_file):\\n self.db_file = db_file\\n self.db = sqlite3.connect(self.db_file, isolation_level=None)\\n self._initDb()\",\n \"def choose_database(db):\\n config = configparser.ConfigParser()\\n config_path = os.path.dirname(os.path.realpath(__file__))\\n config.read(os.path.join(config_path, \\\"config.ini\\\"))\\n\\n if db == 'auth':\\n db = mysql.connector.connect(\\n host=config['MySQL Auth']['host'],\\n # port=config['MySQL Auth']['port'],\\n user=config['MySQL Auth']['user'],\\n passwd=config['MySQL Auth']['passwd'],\\n database=config['MySQL Auth']['database']\\n )\\n\\n if db == 'datadb':\\n db = mysql.connector.connect(\\n host=config['MySQL Data']['host'],\\n # port=config['MySQL Data']['port'],\\n user=config['MySQL Data']['user'],\\n passwd=config['MySQL Data']['passwd'],\\n database=config['MySQL Data']['database']\\n )\\n\\n return db\",\n \"def default_path():\\n return os.path.join(os.environ.get('OVERRIDE_ETC', '/etc'), 'auth')\",\n \"def _load_file_config(self):\\n config_value = getattr(self, APPDATA)\\n path_value = config_value.AbsolutePaths[0]\\n default_cfg_file = os.path.join(path_value, CONFIG_FILE_NAME)\\n config_base = None\\n if os.path.exists(default_cfg_file):\\n config_base = json.load(open(default_cfg_file.lower(), mode='r'), object_hook=ConfigEncoder.class_mapper)\\n if config_base is None or self._current_dcc not in config_base:\\n self.SaveConfig()\\n config_base = type(self)._CURRENT_CONFIG\\n return config_base\",\n \"def _add_db_in_config(self):\\n logger.info(f\\\"Updating configuration file in {self.configfile}\\\")\\n with open(self.configfile, \\\"a\\\") as fp:\\n print(self.ref_name + \\\".genome : \\\" + self.ref_name, file=fp)\",\n \"def get_db_path():\\n \\n return(db_run.db_abs_path)\",\n \"def configure(self, database_dir, storage_dir, search_dir, verbosity):\\n tmp_database = ''\\n tmp_storage = ''\\n tmp_search = ''\\n\\n if os.path.exists('.config') == True:\\n with open('.config', 'r') as f:\\n for line in f:\\n if 'DATABASE_DIR' in line.split():\\n tmp_database = line\\n if 'STORAGE_DIR' in line.split():\\n tmp_storage = line\\n if 'SEARCH_DIR' in line.split():\\n tmp_search = line\\n\\n if os.path.exists(str(database_dir or '')) == True:\\n self.database_dir = database_dir\\n tmp_database = 'DATABASE_DIR = ' + database_dir + '\\\\n'\\n if verbosity >= 1:\\n print 'configure database dir {}'.format(\\n str(database_dir or ''))\\n else:\\n if verbosity >= 1:\\n print 'invalid database dir {}'.format(\\n str(database_dir or ''))\\n\\n if os.path.exists(str(storage_dir or '')) == True:\\n self.storage_dir = storage_dir\\n tmp_storage = 'STORAGE_DIR = ' + storage_dir + '\\\\n'\\n if verbosity >= 1:\\n print 'configure storage dir {}'.format(\\n str(storage_dir or ''))\\n else:\\n if verbosity >= 1:\\n print 'invalid storage dir {}'.format(\\n str(storage_dir or ''))\\n\\n if os.path.exists(str(search_dir or '')) == True:\\n settings.rootdir = search_dir\\n tmp_search = 'SEARCH_DIR = ' + search_dir + '\\\\n'\\n if verbosity >= 1:\\n print 'configure search dir {}'.format(\\n str(search_dir or ''))\\n else:\\n if verbosity >= 1:\\n print 'invalid search dir {}'.format(\\n str(search_dir or ''))\\n\\n with open('.config', 'w') as f:\\n f.write(tmp_database)\\n f.write(tmp_storage)\\n f.write(tmp_search)\\n self.add_log('configure database dir {}'.format(\\n tmp_database.replace('\\\\n', '')))\\n self.add_log('configure storage dir {}'.format(\\n tmp_storage.replace('\\\\n', '')))\\n self.add_log('configure search dir {}'.format(\\n tmp_search.replace('\\\\n', '')))\",\n \"def is_db_path_correct(self, path):\\n\\t\\tif path is None:\\n\\t\\t\\treturn self.file_loc() is None\\n\\t\\telse:\\n\\t\\t\\treturn self.file_loc() == os.path.abspath(path)\",\n \"def _sqlite(self):\\n logging.debug(\\\"Configured to use SQLite for a database\\\")\\n db_name = self.database\\n if not len(db_name):\\n db_name = \\\"rootthebox.db\\\"\\n if not db_name.endswith(\\\".db\\\"):\\n db_name = \\\"%s.db\\\" % db_name\\n if os.path.exists(\\\"files/%s\\\" % db_name):\\n path = \\\"sqlite:///files/%s\\\" % db_name\\n logging.debug(\\\"Found rootthebox database at: %s\\\" % path)\\n elif os.path.exists(db_name):\\n path = \\\"sqlite:///%s\\\" % db_name\\n logging.debug(\\\"Found rootthebox database at: %s\\\" % path)\\n else:\\n if \\\"files\\\" in db_name:\\n path = \\\"sqlite:///%s\\\" % db_name\\n else:\\n path = \\\"sqlite:///files/%s\\\" % db_name\\n logging.debug(\\\"Created rootthebox database at: %s\\\" % path)\\n return path\",\n \"def set_config(self, file, prop):\\n if file.lower() not in ['config']:\\n file = os.path.abspath(file)\\n elif file.lower() == 'config':\\n file = os.path.join(self.modpath, 'config', self.configfiles[prop])\\n return file\",\n \"def setup_environmentvars(self, path, mydbfilepath):\\n\\n if not FDB_AVAILABLE:\\n print(BColors.WARNING + \\\"Warning: fdb_embedded couldn't be imported! \\\" \\\\\\n + \\\"\\\\nMake sure you've installed fdb_embedded correctly.\\\" + BColors.ENDC)\\n return False\\n\\n os.environ['FIREBIRD'] = path\\n self.db_filepath = mydbfilepath\\n return True\",\n \"def load_config( self, config_file=None ):\\n if config_file is None:\\n config_file = os.path.dirname(self.dbfile) + '/final.ini'\\n config_parser = ConfigParser.ConfigParser()\\n config_parser.read( config_file )\\n self.config = config_parser\\n return self.config\",\n \"def parse_databases(default_dbname=\\\"cal_manager.db\\\"):\\n db_list = []\\n calconf = get_calconf()\\n if not calconf:\\n return db_list\\n upload_cookie = calconf.get(\\\"upload_cookie\\\")\\n # Allow old-format file to be read\\n try:\\n databases = calconf[\\\"databases\\\"]\\n except KeyError:\\n databases = calconf.get(\\\"database_dir\\\")\\n if not databases:\\n return db_list\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"always\\\", DeprecationWarning)\\n warnings.warn(\\\"Use 'databases' instead of 'database_dir' in \\\"\\n \\\"config file.\\\",\\n DeprecationWarning\\n )\\n for line in databases.splitlines():\\n if not line: # handle blank lines\\n continue\\n db, *flags = shlex.split(line)\\n # \\\"get\\\" is default if there are no flags, but if any flags are\\n # specified, then \\\"get\\\" must be there explicitly\\n kwargs = {\\\"get_cal\\\": not bool(flags),\\n \\\"store_cal\\\": False}\\n for flag in flags:\\n kwarg = f\\\"{flag}_cal\\\"\\n if kwarg in kwargs:\\n kwargs[kwarg] = True\\n else:\\n raise ValueError(\\\"{}: Unknown flag {!r}\\\".format(db, flag))\\n\\n expanded_db = path.expanduser(db)\\n if path.isdir(expanded_db):\\n db = path.join(db, default_dbname)\\n cls = LocalDB\\n elif path.isfile(expanded_db):\\n cls = LocalDB\\n elif \\\"/\\\" in expanded_db and \\\"//\\\" not in expanded_db:\\n cls = LocalDB\\n else: # does not check\\n cls = RemoteDB\\n kwargs[\\\"upload_cookie\\\"] = upload_cookie\\n db_list.append((cls, db, kwargs))\\n return db_list\",\n \"def setdefault_path(envvar, default):\\n if envvar in os.environ:\\n return _strip_slash(os.environ[envvar])\\n value = os.environ[envvar] = _strip_slash(default() if callable(default) else default)\\n return value\",\n \"def config_db():\",\n \"def default_config_file(self):\\n return DEFAULT_CONFIG_FILEPATH\",\n \"def OnSelectDb(self,event):\\n\\t\\tdlg = wx.FileDialog(None,u\\\"选择数据库文件\\\",wildcard=\\\"*.db\\\")\\n\\t\\tif dlg.ShowModal() != wx.ID_OK:\\n\\t\\t\\tdlg.Destroy()\\n\\t\\t\\treturn\\n\\t\\tdb_name = dlg.GetPath()\\n\\t\\tif db_name: \\n\\t\\t\\tself.refer_sheet.SetDbName(db_name)\\n\\t\\tdlg.Destroy()\",\n \"def writeDefaultConfig(conffile='default.conf', defaults={}):\\n if not os.path.exists(conffile):\\n cp = createConfigParserfromDict(defaults, ['base'])\\n cp.write(open(conffile,'w'))\\n return conffile\",\n \"def setDB(dbname):\\n global DBNAME\\n DBNAME = dbname\",\n \"def get_path_db():\\n\\taiqc_config = get_config()\\n\\tif aiqc_config is None:\\n\\t\\t# get_config() will print a null condition.\\n\\t\\tpass\\n\\telse:\\n\\t\\tdb_path = aiqc_config['db_path']\\n\\t\\treturn db_path\",\n \"def setdb_params(self, mongouri=None, dbname=\\\"testrecommender\\\"):\\n if mongouri is not None:\\n self._mongouri = mongouri\\n if dbname is not None:\\n self._dbname = dbname\\n self._outputlogfile = self._outputlogfile + dbname + \\\"_outputlog.txt\\\"\",\n \"def _set_config():\\n\\n\\tdebug_msg = \\\"load default config yaml file\\\"\\n\\tlogger.debug(debug_msg)\\n\\n\\tconfig_file_parser(paths.CONFIG_FILE, override_options=True)\",\n \"def set_db(db):\\n global db_run # Imports the DB from the simulator\\n db_run=db\",\n \"def _adjust_connection_URL(self, text):\\n dbname = self.options.db\\n parts = text.split('/')\\n\\n # Preserve the quotes if present\\n if parts[-1].endswith(\\\"'\\\"):\\n dbname += \\\"'\\\"\\n\\n parts[-1] = dbname\\n return '/'.join(parts)\",\n \"def save_default_connections_file():\\n if os.path.exists(DEFAULT_CONNECTIONS_FILE):\\n if os.path.exists(DEFAULT_CONNECTIONS_FILE_BAK):\\n os.remove(DEFAULT_CONNECTIONS_FILE_BAK)\\n os.rename(DEFAULT_CONNECTIONS_FILE, DEFAULT_CONNECTIONS_FILE_BAK)\",\n \"def configName(url, file, _name):\\n \\n try:\\n f=open(os.path.join(url, file))\\n istr=f.readlines()\\n for item in istr:\\n if \\\"DB\\\" in item:\\n last = item.find(\\\".db\\\")\\n name=item[3:last+3]\\n if os.path.isfile(os.path.join(url, 'configFile/'+name)):\\n _name=os.path.join(url, 'configFile/'+name)\\n else:\\n _name=os.path.join(url, 'configFile/'+_name)\\n return _name\\n except FileNotFoundError:\\n return os.path.join(url, 'configFile/'+_name)\",\n \"def get_db_name(self):\\n\\t\\treturn conf.db_name\",\n \"def _check_and_mk(self, custom_db_path):\\n rayvision_db_env = os.environ.get(RAYVISION_DB, \\\"\\\")\\n if bool(custom_db_path) and os.path.exists(custom_db_path):\\n db_path = custom_db_path\\n elif os.path.exists(rayvision_db_env):\\n db_path = rayvision_db_env\\n else:\\n if self.api.user_info['local_os'] == \\\"windows\\\":\\n db_path = os.path.join(os.environ[WINDOWS_LOCAL_ENV], RENDERFARM_SDK)\\n else:\\n db_path = os.path.join(os.environ[LINUX_LOCAL_ENV], RENDERFARM_SDK)\\n\\n return db_path\",\n \"def _get_default_path(self):\\n return os.path.join(cfg.DATA_DIR, 'visual_genome')\",\n \"def database():\\n return conf().database\",\n \"def get_db_path_from_config():\\n if not globalConf.sections():\\n raise OSError(\\\"Cannot read config file.\\\")\\n databases = parse_databases()\\n db_path = None\\n for db in databases:\\n if db[0] == LocalDB:\\n if db_path is None:\\n db_path = db[1]\\n else:\\n raise ValueError(\\\"Multiple local database files are listed \\\"\\n \\\"in the config file.\\\")\\n if db_path is None:\\n raise ValueError(\\\"No local database file is listed in the config file.\\\")\\n return db_path\",\n \"def __init__(self, db_file):\\n self.db = TinyDB(db_file)\\n # TODO: implement db files rotation, for now just replace all data\\n self.db.truncate()\\n # self.db_path = pathlib.Path(db_file)\\n # self.db_file_name = self.db_path.name\\n # self.db_dir = self.db_path.parent\",\n \"def set_config_path(self, new_config_path):\\n oldpath = self.get_config_path()\\n cdir, cfile = os.path.split(new_config_path)\\n \\n if not cdir.startswith('/'):\\n cdit='/'+cdir\\n if not cfile:\\n cfile = 'site.yaml'\\n\\n self.dropbox_base_dir = cdir\\n self.dropbox_site_yaml = cfile\\n newpath = self.get_config_path()\\n if newpath !=oldpath:\\n return oldpath\",\n \"def get_database_filename() -> str:\\n config_dir = get_config_dir()\\n return os.path.join(config_dir, DATABASE_FILENAME)\",\n \"def gtfsdb_main(ctx, database):\\n ctx.obj = dict()\\n if not database and os.path.exists(DEFAULT_CONFIG_FILE):\\n conf = json.load(open(DEFAULT_CONFIG_FILE, 'r'))\\n database = conf['database']\\n ctx.obj.update(dict(conf=conf))\\n else:\\n click.echo(\\\"No database selected!!\\\")\\n sys.exit(1)\\n ctx.obj.update(dict(database=Database(url=database), db_url=database))\",\n \"def __init__(self, configfile=None):\\n self.withwith = ('2.5' in psycopg2.__version__)\\n self.conn = None\\n self.setdefaults()\\n if configfile is not None:\\n self.loadconfig(configfile)\",\n \"def find_pass_cfg(file_path=None):\\n if not file_path:\\n file_path = '~/.pass.cfg'\\n\\n if os.path.isfile(os.path.expanduser(file_path)):\\n return file_path\\n else:\\n return None\",\n \"def _cfg_path(argv):\\n cfg_path = argv[1] if len(argv) > 1 else None\\n _is_file = os.path.isfile\\n if not cfg_path or not _is_file(cfg_path):\\n if cfg_path:\\n _info(\\\"no config at {}, trying the default location\\\".format(\\n cfg_path))\\n cfg_path = _DEFAULT_PATH\\n if not _is_file(cfg_path):\\n _info(\\\"no config at {}, exiting\\\".format(cfg_path))\\n return None\\n return cfg_path\",\n \"def test_alternate_get_mylogin_cnf_path():\\n original_env = None\\n if 'MYSQL_TEST_LOGIN_FILE' in os.environ:\\n original_env = os.environ.pop('MYSQL_TEST_LOGIN_FILE')\\n\\n _, temp_path = tempfile.mkstemp()\\n os.environ['MYSQL_TEST_LOGIN_FILE'] = temp_path\\n\\n login_cnf_path = get_mylogin_cnf_path()\\n\\n if original_env is not None:\\n os.environ['MYSQL_TEST_LOGIN_FILE'] = original_env\\n\\n assert temp_path == login_cnf_path\",\n \"def _change_file_hosted_location():\\n\\n # Changes where the file is hosted\\n path = (f\\\"{RPKI_Validator_Wrapper.rpki_package_path}conf\\\"\\n \\\"/application-defaults.properties\\\")\\n prepend = \\\"rpki.validator.bgp.ris.dump.urls=\\\"\\n replace = (\\\"https://www.ris.ripe.net/dumps/riswhoisdump.IPv4.gz,\\\"\\n \\\"https://www.ris.ripe.net/dumps/riswhoisdump.IPv6.gz\\\")\\n replace_with = (f\\\"http://localhost:{RPKI_File.port}\\\"\\n f\\\"/{RPKI_File.hosted_name}\\\")\\n utils.replace_line(path, prepend, replace, replace_with)\",\n \"def load_rec_conf_dir(self):\\n rec_file = select_file(os.getcwd())\\n if rec_file is not None:\\n self.load_tab_common(rec_file)\\n else:\\n msg_window('please select valid rec config file')\",\n \"def get_db_path():\\n return os.path.join(sys.path[0], \\\"my_db.db\\\")\",\n \"def get_old_db_details():\\n db_conf_prelim = {\\n 'host': None,\\n 'port': None,\\n 'database': None,\\n 'username': None,\\n 'password': None }\\n\\n db_conf = codecs.open(\\\"db.conf\\\", encoding=\\\"utf-8\\\", mode=\\\"r\\\")\\n db_conf_text = db_conf.read()\\n db_conf.close()\\n\\n prev_host = search_config(\\\"metastore.connection-postgresql.host\\\", \\\"host\\\", db_conf_text)\\n prev_port = search_config(\\\"metastore.connection-postgresql.port\\\", \\\"port\\\", db_conf_text)\\n prev_database = search_config(\\\"metastore.connection-postgresql.database\\\", \\\"database\\\", db_conf_text)\\n prev_username = search_config(\\\"metastore.connection-postgresql.username\\\", \\\"username\\\", db_conf_text)\\n prev_password = search_config(\\\"metastore.connection-postgresql.password\\\", \\\"password\\\", db_conf_text)\\n db_conf_from_file = {\\n 'host': prev_host if prev_host else None,\\n 'port': prev_port if prev_port else None,\\n 'database': prev_database if prev_database else None,\\n 'username': prev_username if prev_username else None,\\n 'password': prev_password if prev_password else None }\\n\\n db_conf_prelim.update(db_conf_from_file)\\n return db_conf_prelim\",\n \"def check_config(self):\\n cfgs = self.__get() \\n \\n for option in Config.FILE_OPTIONS.keys():\\n _default = Config.FILE_OPTIONS[option]\\n \\n if not cfgs.has_key(option):\\n self.log.warn(\\\"Parameter '%s' is missing in '%s', using default('%s')\\\" % \\\\\\n (option, self.config_file, _default))\\n _file = _default\\n else:\\n _file = cfgs[option]\\n Config.FILE_OPTIONS[option] = _file\\n\\n if not os.path.exists(_file) and not os.path.isfile(_file):\\n self.log.error(\\\"Paramenter '%s' points to non-existing file '%s')\\\" % \\\\\\n (option, _file))\\n raise ConfigError('File Error', \\\"Paramenter '%s' points to non-existing file '%s')\\\" % \\\\\\n (option, _file))\\n\\n\\n for option in Config.PATH_OPTIONS.keys():\\n _default = Config.PATH_OPTIONS[option]\\n \\n if not cfgs.has_key(option):\\n self.log.warn(\\\"Parameter '%s' is missing in '%s', using default('%s')\\\" % \\\\\\n (option, self.config_file, _default))\\n _dir = _default\\n else:\\n _dir = cfgs[option]\\n Config.PATH_OPTIONS[option] = _dir\\n\\n if not os.path.exists(_dir) and not os.path.isdir(_dir):\\n self.log.error(\\\"Paramenter '%s' points to non-existing directory '%s')\\\" % \\\\\\n (option, _dir))\\n raise ConfigError('File Error', \\\"Paramenter '%s' points to non-existing directory '%s')\\\" % \\\\\\n (option, _dir))\\n\\n \\n Config.DB_SFT_OPTIONS['sqlalchemy_sft.url'] = cfgs['sqlalchemy_sft.url']\\n Config.DB_NAGIOS_OPTIONS['sqlalchemy_nagios.url'] = cfgs['sqlalchemy_nagios.url']\\n\\n self.log.debug(\\\"Configuration successfully checked\\\")\",\n \"def _create_default_config(self):\\n self.options.setdefault('options.admin_passwd', '')\\n sys.path.append(self.openerp_dir)\\n sys.path.extend([egg.location for egg in self.ws])\\n from openerp.tools.config import configmanager\\n configmanager(self.config_path).save()\",\n \"def __getattr__(self, name):\\n \\n # first check for the environment variable for the database\\n variable = get_environment_variable(self.vars[name].name)\\n \\n if not variable:\\n # next check for the overall location variable\\n base_folder = get_environment_variable(self.base_environment_variable)\\n if base_folder:\\n variable = os.path.join(base_folder,self.vars[name].default_path)\\n \\n if variable and not (os.path.isfile(variable) or os.path.isdir(variable)):\\n # if this is not a valid folder/file, then resume search\\n variable = None\\n \\n # check in the default folders, if not found with env variables\\n if not variable:\\n for folder in install_locations():\\n if os.path.isdir(folder):\\n variable = os.path.join(folder,self.vars[name].default_path)\\n if os.path.isfile(variable) or os.path.isdir(variable):\\n return variable\\n \\n if not variable:\\n sys.exit(\\\"ERROR: Unable to find database \\\"+self.vars[name].name+\\n \\\". \\\"+self.vars[name].description+\\\" Unable to find in default\\\"+\\n \\\" install folders or with environment variables.\\\")\\n \\n return variable\",\n \"def find_default(self, fs_path):\\n if os.path.isdir(fs_path):\\n default = None\\n for name in self.defaults:\\n _path = os.path.join(fs_path, name)\\n if os.path.isfile(_path):\\n default = _path\\n break\\n if default is None:\\n raise Response(403)\\n fs_path = default\\n return fs_path\",\n \"def formatdb(fastadata={},fname=\\\"\\\"):\\n if not fastadata and fname:\\n OSsystem(\\\"%s -i %s\\\" % (FORMATDB_PATH,fname))\\n elif fastadata and fname:\\n pass\\n else:\\n raise \\\"inproper input\\\"\\n return fname\",\n \"def test_get_config_file_value(self):\\n parser = GbpOptionParser('cmd4')\\n self.assertEqual(parser.get_config_file_value('new_overrides_git_option1'),\\n 'new_overrides_git_value1')\\n self.assertEqual(parser.get_config_file_value('doesnotexist'), None)\",\n \"def editPostgresConf():\\n\\n try:\\n tempFile = tempfile.mktemp(dir=\\\"/tmp\\\")\\n\\n logging.debug(\\\"copying %s over %s\\\", basedefs.FILE_PSQL_CONF, tempFile)\\n shutil.copy2(basedefs.FILE_PSQL_CONF, tempFile)\\n\\n handler = utils.TextConfigFileHandler(tempFile)\\n handler.open()\\n handler.editParam(\\\"max_connections\\\", basedefs.CONST_MAX_PSQL_CONNS)\\n handler.close()\\n\\n logging.debug(\\\"copying temp file over original file\\\")\\n shutil.copy2(tempFile, basedefs.FILE_PSQL_CONF)\\n\\n logging.debug(\\\"setting permissions & file ownership\\\")\\n os.chown(basedefs.FILE_PSQL_CONF, utils.getUsernameId(\\\"postgres\\\"), utils.getGroupId(\\\"postgres\\\"))\\n os.chmod(basedefs.FILE_PSQL_CONF, 0600)\\n\\n logging.debug(\\\"removing tempoarary file\\\")\\n os.remove(tempFile)\\n\\n except:\\n logging.error(\\\"Failed editing %s\\\" % basedefs.FILE_PSQL_CONF)\\n logging.error(traceback.format_exc())\\n raise Exception(output_messages.ERR_EXP_EDIT_PSQL_CONF)\",\n \"def _restore_orig_directory(self):\\n if not self._is_temp_dir:\\n return\\n self._base_data_dir = self._orig_base_data_dir\\n del self._orig_base_data_dir\\n self._base_logs_dir = self._orig_base_logs_dir\\n del self._orig_base_logs_dir\\n self.db.change_path(self._base_data_dir / \\\"projects.db\\\")\\n self.set_current(\\\"default\\\", update=False)\\n self._is_temp_dir = False\",\n \"def load_data_conf(self):\\n data_file = select_file(os.getcwd())\\n if data_file is not None:\\n self.load_tab(data_file)\\n else:\\n msg_window('please select valid data config file')\",\n \"def get_default_database(self):\\n attr_name = mangle_delegate_name(self.__class__, '__default_database_name')\\n default_db_name = getattr(self.delegate, attr_name)\\n if default_db_name is None:\\n raise ConfigurationError('No default database defined')\\n\\n return self[default_db_name]\",\n \"def __create_default_config(self):\\n if not os.path.exists(self.__configfile):\\n path=os.path.dirname(self.__configfile)\\n try:\\n os.makedirs(path)\\n except:\\n pass\\n if os.path.exists(path):\\n self.save(defaults=True)\",\n \"def settings_db_read_settings(db_name=SETTINGS_DB_NAME):\\n paths = local = None\\n if os.path.isfile(db_name):\\n with lite.connect(db_name) as con:\\n cur = con.cursor()\\n result = cur.execute(\\\"SELECT LOGISIM_HOME, GRADING_PATH, IMPORT_PATH, GRADES_DB\\\\\\n FROM PATHS\\\")\\n paths = result.fetchone()\\n result = cur.execute(\\\"SELECT GRADER_NAME, YEAR, SEMESTER, USE_STYLE, SYNC_COMMAND\\\\\\n FROM LOCAL\\\")\\n local = result.fetchone()\\n\\n return paths, local\",\n \"def config():\\n file_path = None # path to the input file\\n db_path = None # path to the output db\\n atomic_properties = (\\n \\\"Properties=species:S:1:pos:R:3\\\"\\n ) # atomic properties of the input file\\n molecular_properties = [\\\"energy\\\"] # molecular properties of the input file\\n overwrite = False\",\n \"def perform_config(self):\\n\\n super(PidfileApp, self).perform_config()\\n\\n if ('general' in self.cfg and 'pidfile' in self.cfg['general']):\\n # Not set by commandline, but set in configuration\\n pidfile = to_str_or_bust(self.cfg['general']['pidfile'])\\n if pidfile and (pidfile != self._default_pidfilename):\\n log.debug(\\n _(\\\"Setting pidfile to %r by configuration.\\\"), pidfile)\\n self._pidfilename = pidfile\",\n \"def test_config_overwrites():\\n basepath = os.path.abspath(os.path.join(os.path.dirname(__file__), \\\"..\\\", '..'))\\n temppath = '/tmp/'\\n\\n conf = core.Config(datapath=temppath)\\n\\n assert conf.basepath.lower() == basepath.lower()\\n assert conf.datapath.lower() == temppath.lower()\",\n \"def get_database_directory(self):\\n pass\",\n \"def __init__(self, dbfile=\\\"eom_default_db.sqlite\\\", init_db=False):\\n self.sql = None\\n missing = not os.path.exists(dbfile)\\n self.sql = sqlite3.connect(dbfile, detect_types = sqlite3.PARSE_DECLTYPES)\\n self.sql.text_factory = str\\n if missing or init_db:\\n self.init_rpki_rtr_tables()\\n self.init_rib_tables()\\n self.init_analysis_tables()\",\n \"def get_database_url(self):\\n return self.config['dbase_path']\",\n \"def create_db_ini(self, upload_json_path):\\n db_type = self.database_config.get(\\\"type\\\", \\\"sqlite\\\").strip().lower()\\n try:\\n # Prevent multi-thread lock-free problems\\n if not os.path.exists(self.db_ini):\\n os.makedirs(self.db_ini)\\n except:\\n pass\\n time_temp = os.path.split(os.path.dirname(upload_json_path))[-1]\\n db_path = os.path.join(self._db, \\\"%s.db\\\" % time_temp)\\n config_ini = configparser.ConfigParser()\\n config_ini['database'] = {\\n \\\"on\\\": self.database_config.get(\\\"on\\\", \\\"true\\\"),\\n \\\"platform_id\\\": self.trans.platform,\\n \\\"type\\\": db_type\\n }\\n config_ini['redis'] = {\\n \\\"host\\\": self.redis_config.get(\\\"host\\\", \\\"127.0.0.1\\\"),\\n \\\"port\\\": self.redis_config.get(\\\"port\\\", 6379),\\n \\\"password\\\": self.redis_config.get(\\\"password\\\", \\\"\\\"),\\n \\\"table_index\\\": self.redis_config.get(\\\"table_index\\\", \\\"\\\"),\\n \\\"timeout\\\": self.redis_config.get(\\\"timeout\\\", 5000)\\n }\\n config_ini['sqlite'] = {\\n \\\"db_path\\\": db_path,\\n \\\"temporary\\\": self.sqlite_config.get(\\\"temporary\\\", \\\"false\\\")\\n }\\n if db_type == \\\"redis\\\":\\n db_ini_path = os.path.join(self.db_ini, \\\"db_redis.ini\\\")\\n elif db_type == \\\"sqlite\\\":\\n db_ini_path = os.path.join(self.db_ini, \\\"%s.ini\\\" % time_temp)\\n else:\\n error_data_msg = \\\"{} is not a supported database, only support 'redis' or 'sqlite'\\\".format(db_type)\\n raise UnsupportedDatabaseError(error_data_msg)\\n\\n with open(db_ini_path, 'w') as configfile:\\n config_ini.write(configfile)\\n return db_ini_path\",\n \"def load_file():\\n global list_of_table, data_base, new_data\\n open_name = askopenfilename()\\n\\n if Path(open_name).suffix == '.db':\\n data_base = open_name\\n data_base = str(data_base)\\n new_data_base = parse(data_base)\\n new_data = update_list_tables(new_data_base)\\n new_data.clear()\\n\\n else:\\n mistake_db_file()\",\n \"def setup_database(config, interactive, logger):\\n options = [\\n 'django.db.backends.sqlite3',\\n 'django.db.backends.mysql',\\n 'django.db.backends.oracle',\\n 'django.db.backends.postgresql',\\n 'django.db.backends.postgresql_psycopg2',\\n ]\\n selected = config.get('database_engine')\\n message = \\\"\\\\nSet %s to (%s) \\\\n\\\"\\n message += '\\\\n'.join(['%s [%d] %s' % (('*' if selected == options[i] else ' '), i, options[i]) for i in range(len(options))])\\n message += '\\\\nor enter one from the list above:'\\n config = set_option(config, 'database_engine', interactive, logger, message)\\n \\n db = config.get('database_engine')\\n try:\\n db = options[int(db)]\\n config['database_engine'] = db\\n except:\\n assert(db in options), \\\"Improper Database Backend\\\"\\n \\n # sqlite3 is special\\n if db == 'django.db.backends.sqlite3':\\n base = config.get('cannula_base')\\n config['database_name'] = os.path.join(base, 'cannula.db')\\n config = set_option(config, 'database_name', interactive, logger)\\n else:\\n config['database_name'] = ''\\n config = set_option(config, 'database_name', interactive, logger)\\n config = set_option(config, 'database_user', interactive, logger)\\n config = set_option(config, 'database_password', interactive, logger)\\n config = set_option(config, 'database_host', interactive, logger)\\n config = set_option(config, 'database_port', interactive, logger)\\n \\n return config\",\n \"def default_empty_config_env(monkeypatch):\\n monkeypatch.delenv(\\\"SOPEL_CONFIG\\\", raising=False)\\n monkeypatch.delenv(\\\"SOPEL_CONFIG_DIR\\\", raising=False)\",\n \"def _load_from_conf(self, parser, section, db, conf_dir, cloud_confs, conf_file):\\n\\n iaas = config_get_or_none(parser, section, \\\"iaas\\\", self.iaas)\\n iaas_url = config_get_or_none(parser, section, \\\"iaas_url\\\", self.iaas_url)\\n\\n sshkey = config_get_or_none(parser, section, \\\"sshkeyname\\\", self.keyname)\\n localssh = config_get_or_none(parser, section, \\\"localsshkeypath\\\", self.localkey)\\n ssh_user = config_get_or_none(parser, section, \\\"ssh_username\\\", self.username)\\n scp_user = config_get_or_none(parser, section, \\\"scp_username\\\", self.scp_username)\\n bootconf = config_get_or_none(parser, section, \\\"bootconf\\\", self.bootconf)\\n bootpgm = config_get_or_none(parser, section, \\\"bootpgm\\\", self.bootpgm)\\n bootpgm_args = config_get_or_none(parser, section, \\\"bootpgm_args\\\", self.bootpgm_args)\\n hostname = config_get_or_none(parser, section, \\\"hostname\\\", self.hostname)\\n readypgm = config_get_or_none(parser, section, \\\"readypgm\\\", self.readypgm)\\n readypgm_args = config_get_or_none(parser, section, \\\"readypgm_args\\\", self.readypgm_args)\\n iaas_key = config_get_or_none(parser, section, \\\"iaas_key\\\", self.iaas_key)\\n iaas_secret = config_get_or_none(parser, section, \\\"iaas_secret\\\", self.iaas_secret)\\n securitygroups = config_get_or_none(parser, section, \\\"securitygroups\\\", self.securitygroups)\\n\\n terminatepgm = config_get_or_none(parser, section, \\\"terminatepgm\\\", self.terminatepgm)\\n terminatepgm_args = config_get_or_none(parser, section, \\\"terminatepgm_args\\\", self.terminatepgm_args)\\n\\n pgm_timeout = config_get_or_none(parser, section, \\\"pgm_timeout\\\", self.pgm_timeout)\\n\\n local_exe = config_get_or_none_bool(parser, section, \\\"local_exe\\\", self.local_exe)\\n\\n\\n allo = config_get_or_none(parser, section, \\\"allocation\\\", self.allocation)\\n image = config_get_or_none(parser, section, \\\"image\\\", self.image)\\n cloudconf = config_get_or_none(parser, section, \\\"cloud\\\")\\n if cloudconf:\\n try:\\n conf = cloud_confs[cloudconf]\\n except:\\n raise APIUsageException(\\\"%s is not a valud cloud description in this plan\\\" % (cloudconf))\\n\\n if not iaas:\\n iaas = conf.iaas\\n if not iaas_url:\\n iaas_url = conf.iaas_url\\n if not sshkey:\\n sshkey = conf.sshkey\\n if not localssh:\\n localssh = conf.localssh\\n if not ssh_user:\\n ssh_user = conf.ssh_user\\n if not scp_user:\\n scp_user = conf.scp_user\\n if not iaas_key:\\n iaas_key = conf.iaas_key\\n if not iaas_secret:\\n iaas_secret = conf.iaas_secret\\n if not securitygroups:\\n securitygroups = conf.securitygroups\\n\\n if not iaas:\\n iaas = db.default_iaas\\n if not iaas_url:\\n iaas_url = db.default_iaas_url\\n if not allo:\\n allo = db.default_allo\\n if not sshkey:\\n sshkey = db.default_sshkey\\n if not localssh:\\n localssh = db.default_localssh\\n if not ssh_user:\\n ssh_user = db.default_ssh_user\\n if not scp_user:\\n scp_user = db.default_scp_user\\n if not iaas_key:\\n iaas_key = db.default_iaas_key\\n if not iaas_secret:\\n iaas_secret = db.default_iaas_secret\\n if not securitygroups:\\n securitygroups = db.default_securitygroups\\n if not image:\\n image = db.default_image\\n if not bootconf:\\n bootconf = db.default_bootconf\\n if not bootpgm:\\n bootpgm = db.default_bootpgm\\n if not bootpgm_args:\\n bootpgm_args = db.default_bootpgm_args\\n if not readypgm:\\n readypgm = db.default_readypgm\\n if not readypgm_args:\\n readypgm_args = db.default_readypgm_args\\n if not terminatepgm:\\n terminatepgm = db.default_terminatepgm\\n if not terminatepgm_args:\\n terminatepgm_args = db.default_terminatepgm_args\\n if not pgm_timeout:\\n pgm_timeout = db.default_pgm_timeout\\n\\n if not local_exe:\\n local_exe = db.default_local_exe\\n\\n\\n self.image = image\\n self.bootconf = _resolve_file_or_none(conf_dir, bootconf, conf_file)\\n self.bootpgm = _resolve_file_or_none(conf_dir, bootpgm, conf_file, has_args=True)\\n self.bootpgm_args = bootpgm_args\\n self.terminatepgm = _resolve_file_or_none(conf_dir, terminatepgm, conf_file, has_args=True)\\n self.terminatepgm_args = terminatepgm_args\\n self.pgm_timeout = pgm_timeout\\n self.local_exe = local_exe\\n\\n self.hostname = hostname\\n self.readypgm = _resolve_file_or_none(conf_dir, readypgm, conf_file, has_args=True)\\n self.readypgm_args = readypgm_args\\n self.username = ssh_user\\n self.scp_username = scp_user\\n self.localkey = _resolve_file_or_none(conf_dir, localssh, conf_file)\\n self.keyname = sshkey\\n self.allocation = allo\\n self.iaas = iaas\\n self.iaas_url = iaas_url\\n\\n self.iaas_secret = iaas_secret\\n self.iaas_key = iaas_key\\n self.securitygroups = securitygroups\\n\\n x = config_get_or_none(parser, section, \\\"iaas_launch\\\")\\n if x:\\n if x.lower() == 'true':\\n self.iaas_launch = True\\n else:\\n self.iaas_launch = False\\n else:\\n if self.hostname:\\n self.iaas_launch = False\\n else:\\n self.iaas_launch = True\\n\\n # allow the plan to over ride the default image if they want to use a hostname\\n if self.iaas_launch is False:\\n self.image = None\\n\\n item_list = parser.items(section)\\n deps_list = []\\n for (ka,val) in item_list:\\n ndx = ka.find(\\\"deps\\\")\\n if ndx == 0:\\n deps_list.append(ka)\\n deps_list.sort()\\n for i in deps_list:\\n deps = config_get_or_none(parser, section, i)\\n deps_file = _resolve_file_or_none(conf_dir, deps, conf_file)\\n if deps_file:\\n parser2 = ConfigParser.ConfigParser()\\n parser2.read(deps_file)\\n keys_val = parser2.items(\\\"deps\\\")\\n for (ka,val) in keys_val:\\n val2 = config_get_or_none(parser2, \\\"deps\\\", ka)\\n if val2 is not None:\\n bao = BagAttrsObject(ka, val2)\\n self.attrs.append(bao)\",\n \"def default_configfile():\\n dirname=None\\n if os.getenv(\\\"HOME\\\"):\\n dirname=os.getenv(\\\"HOME\\\")\\n elif os.getenv(\\\"USERPROFILE\\\"):\\n dirname=os.getenv(\\\"USERPROFILE\\\")\\n\\n else:\\n raise FattyException(\\\"No HOME or USERPROFILE variable set, unable to determine default config file\\\")\\n\\n return os.path.join(dirname,\\\".fattybugs\\\")\",\n \"def get_default_config_file() -> Path:\\n return get_path_to_pyflow() / \\\"pyflow\\\" / \\\"conf\\\" / CONFIG_FILE\",\n \"def set_file(self, sql_file):\\n self.file_type = self.get_file_extension(sql_file)\\n self.sql_file = sql_file\",\n \"def expand_db_path(path):\\n if path is None:\\n path = join(xdg.BaseDirectory.xdg_data_home, 'khal', 'khal.db')\\n return expanduser(expandvars(path))\",\n \"def getDbStrNone(self, db, key):\\n \\n value = self.get(db + \\\".\\\" + key)\\n if value == None:\\n value = self.get(\\\"default.\\\" + key)\\n return value\",\n \"def set_default_paths(args):\\n filename = os.path.join(os.path.expanduser('~'), '.gfail_defaults')\\n if os.path.exists(filename):\\n D = ConfigObj(filename)\\n else:\\n D = {}\\n if args.data_path is not None:\\n if args.data_path == 'reset':\\n D.pop('data_path')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.data_path):\\n D.update({'data_path': args.data_path})\\n else:\\n print('Path given for data_path does not exist: %s'\\n % args.data_path)\\n if args.output_filepath is not None:\\n if args.output_filepath == 'reset':\\n D.pop('output_filepath')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.output_filepath):\\n D.update({'output_filepath': args.output_filepath})\\n else:\\n print('Path given for output_filepath does not exist: %s'\\n % args.output_filepath)\\n if args.config_filepath is not None:\\n if args.config_filepath == 'reset':\\n D.pop('config_filepath')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.config_filepath):\\n D.update({'config_filepath': args.config_filepath})\\n else:\\n print('Path given for config_filepath does not exist: %s'\\n % args.config_filepath)\\n if args.popfile is not None:\\n if args.popfile == 'reset':\\n D.pop('popfile')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.popfile):\\n D.update({'popfile': args.popfile})\\n else:\\n print('Path given for population file does not exist: %s'\\n % args.popfile)\\n if args.trimfile is not None:\\n if args.trimfile == 'reset':\\n D.pop('trim')\\n else:\\n # check that it's a valid path and that it's a shapefile\\n if os.path.exists(args.trimfile):\\n filename4, fileextension = os.path.splitext(args.trimfile)\\n if fileextension == '.shp':\\n D.update({'trimfile': args.trimfile})\\n else:\\n print('Ocean trimming file is not a shapefile: %s'\\n % args.trimfile)\\n else:\\n print('Path given for ocean trimming file does not exist: %s'\\n % args.trimfile)\\n if args.pdl_config is not None:\\n if args.pdl_config == 'reset':\\n D.pop('pdl_config')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.pdl_config):\\n D.update({'pdl_config': args.pdl_config})\\n else:\\n print('Path given for pdl config file does not exist: %s'\\n % args.pdl_config)\\n if args.log_filepath is not None:\\n if args.log_filepath == 'reset':\\n D.pop('log_filepath')\\n else:\\n # check that it's a valid path\\n if os.path.exists(args.log_filepath):\\n D.update({'log_filepath': args.log_filepath})\\n else:\\n print('Path given for log file does not exist: %s'\\n % args.log_filepath)\\n if args.dbfile is not None:\\n if args.dbfile == 'reset':\\n D.pop('dbfile')\\n else:\\n # check that it's a valid path (file itself doesnt have to exist)\\n if os.path.exists(os.path.dirname(args.dbfile)):\\n D.update({'dbfile': args.dbfile})\\n else:\\n print('Path given for database file does not exist: %s'\\n % args.dbfile)\\n\\n print('New default paths set.\\\\n')\\n\\n if D:\\n C = ConfigObj(D)\\n C.filename = filename\\n C.write()\\n list_default_paths()\\n else:\\n print('no defaults set because no paths were input\\\\n')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.724011","0.7007624","0.63317364","0.59065104","0.5838431","0.5786949","0.5773432","0.57708883","0.57708883","0.5744681","0.5727951","0.5716239","0.563708","0.56251484","0.5617629","0.5604145","0.5599592","0.5594931","0.55584013","0.5538118","0.552904","0.55256957","0.5503488","0.5453943","0.54032713","0.5388929","0.5386592","0.53758925","0.5370577","0.53296864","0.5328238","0.53206724","0.5315174","0.5305008","0.53043324","0.5301791","0.52935743","0.5291204","0.52409244","0.52341825","0.5228697","0.5224732","0.52214056","0.5192249","0.51649237","0.513168","0.5110819","0.50877255","0.5046871","0.5039213","0.50260925","0.5016718","0.5013747","0.5012956","0.5009468","0.5008106","0.5002636","0.49894726","0.49877188","0.49865633","0.49841428","0.49825484","0.49794388","0.49663404","0.49620727","0.49526212","0.49476555","0.49403","0.49328846","0.49326086","0.49076414","0.48989728","0.48922437","0.4889519","0.4876359","0.48738068","0.4873719","0.48646754","0.48643166","0.48606268","0.48559764","0.48536244","0.4852836","0.48497605","0.4844325","0.48420972","0.4840115","0.4836178","0.48354545","0.48343864","0.4824863","0.48171407","0.48149937","0.4814929","0.48138177","0.48055404","0.4804118","0.4797478","0.47973704","0.47952744"],"string":"[\n \"0.724011\",\n \"0.7007624\",\n \"0.63317364\",\n \"0.59065104\",\n \"0.5838431\",\n \"0.5786949\",\n \"0.5773432\",\n \"0.57708883\",\n \"0.57708883\",\n \"0.5744681\",\n \"0.5727951\",\n \"0.5716239\",\n \"0.563708\",\n \"0.56251484\",\n \"0.5617629\",\n \"0.5604145\",\n \"0.5599592\",\n \"0.5594931\",\n \"0.55584013\",\n \"0.5538118\",\n \"0.552904\",\n \"0.55256957\",\n \"0.5503488\",\n \"0.5453943\",\n \"0.54032713\",\n \"0.5388929\",\n \"0.5386592\",\n \"0.53758925\",\n \"0.5370577\",\n \"0.53296864\",\n \"0.5328238\",\n \"0.53206724\",\n \"0.5315174\",\n \"0.5305008\",\n \"0.53043324\",\n \"0.5301791\",\n \"0.52935743\",\n \"0.5291204\",\n \"0.52409244\",\n \"0.52341825\",\n \"0.5228697\",\n \"0.5224732\",\n \"0.52214056\",\n \"0.5192249\",\n \"0.51649237\",\n \"0.513168\",\n \"0.5110819\",\n \"0.50877255\",\n \"0.5046871\",\n \"0.5039213\",\n \"0.50260925\",\n \"0.5016718\",\n \"0.5013747\",\n \"0.5012956\",\n \"0.5009468\",\n \"0.5008106\",\n \"0.5002636\",\n \"0.49894726\",\n \"0.49877188\",\n \"0.49865633\",\n \"0.49841428\",\n \"0.49825484\",\n \"0.49794388\",\n \"0.49663404\",\n \"0.49620727\",\n \"0.49526212\",\n \"0.49476555\",\n \"0.49403\",\n \"0.49328846\",\n \"0.49326086\",\n \"0.49076414\",\n \"0.48989728\",\n \"0.48922437\",\n \"0.4889519\",\n \"0.4876359\",\n \"0.48738068\",\n \"0.4873719\",\n \"0.48646754\",\n \"0.48643166\",\n \"0.48606268\",\n \"0.48559764\",\n \"0.48536244\",\n \"0.4852836\",\n \"0.48497605\",\n \"0.4844325\",\n \"0.48420972\",\n \"0.4840115\",\n \"0.4836178\",\n \"0.48354545\",\n \"0.48343864\",\n \"0.4824863\",\n \"0.48171407\",\n \"0.48149937\",\n \"0.4814929\",\n \"0.48138177\",\n \"0.48055404\",\n \"0.4804118\",\n \"0.4797478\",\n \"0.47973704\",\n \"0.47952744\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6772628"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":92893,"cells":{"query":{"kind":"string","value":"requires amount, context and date are optional. If no date is present, assume today."},"document":{"kind":"string","value":"def add(config, args):\n\tif args == []:\n\t\thelp()\n\t\treturn\n\tamount, context, date = 0, \"\", \"\"\n\tfor arg in args:\n\t\tif re.match(\"^[0-9]*([\\.,][0-9]{0,2}){0,1}$\", arg) and not amount:\n\t\t\tamount = float(arg.replace(',', '.'))\n\t\telif arg.startswith(\"@\") and (len(arg) > 1):\n\t\t\tcontext = ','.join([context, arg[1:]])\n\t\telif not date:\n\t\t\ttry:\n\t\t\t\tdate = datetime.datetime.strptime(arg, \"%Y-%m-%d\")\n\t\t\t\tdate = date.strftime(\"%Y-%m-%d\")\n\t\t\texcept(ValueError):\n\t\t\t\thelp()\n\t\t\t\treturn\n\n\tcontext = context.strip(',')\n\tif not date:\n\t\tdate = datetime.date.today().isoformat()\n\tif (amount != 0):\n\t\tw = csv.DictWriter(open(config['dbfile'], 'a'), delimiter=';',\n\t\t\tfieldnames=['date', 'amount', 'context'],\n\t\t\tlineterminator='\\n')\n\t\trow = { 'date' : date, 'amount' : amount, 'context' : context }\n\t\tw.writerow(row)\n\t\tprint(\"added:\", ';'.join([date,str(amount),context]))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_today():\n return datetime.today()","def get_today_date():\n return date.today()","def _today() -> datetime.date:\n return datetime.today().date()","def get_today() -> datetime.date:\n return datetime.date.today()","def today():\n return date.today()","def today():\n return datetime.today()","async def daily(self, ctx):\r\n # TODO: Asssess whether this can be cleaned up. \r\n # As it stands, very similar to inv()\r\n author = ctx.author\r\n with DB() as db:\r\n company = await self.get_active_company(ctx, db, author)\r\n stock = self.iex.get_held_stocks(db, company.id)\r\n inventory = []\r\n for s in stock:\r\n close = await self.get_latest_close(ctx, db, s.symbol)\r\n inventory.append([s.symbol, s.quantity, s.purchase_price, close.close, s.quantity*close.close - s.quantity*s.purchase_price ]) \r\n inv_df = pd.DataFrame(inventory, columns=['Symbol', 'Quantity', 'Purchase Price', 'Close', 'Current Value'])\r\n inv_df['sign'] = np.where(inv_df['Current Value']>=0, '+', '-')\r\n inv_df['%'] = abs(((inv_df['Close'] - inv_df['Purchase Price']) / inv_df['Purchase Price']) * 100)\r\n inv_df['%'] = inv_df['%'].round(1)\r\n inv_df = inv_df.sort_values(['Symbol'])\r\n inv_df = inv_df[['sign', '%', 'Symbol', 'Quantity', 'Purchase Price', 'Close', 'Current Value']]\r\n aggregated = tabulate(inv_df.values.tolist(), headers=['Δ', '%', 'Symbol', 'Quantity', 'Purchase Price', 'Close', 'Current Value'])\r\n await ctx.send(f'```diff\\n{aggregated}```')","def _get_date():\n return datetime.datetime.now()","def __init__(self,\r\n available_balance_amount=None,\r\n posted_date=None,\r\n open_date=None,\r\n period_start_date=None,\r\n period_end_date=None,\r\n period_interest_rate=None,\r\n period_deposit_amount=None,\r\n period_interest_amount=None,\r\n interest_ytd_amount=None,\r\n interest_prior_ytd_amount=None,\r\n maturity_date=None,\r\n interest_rate=None,\r\n credit_available_amount=None,\r\n credit_max_amount=None,\r\n cash_advance_available_amount=None,\r\n cash_advance_max_amount=None,\r\n cash_advance_balance=None,\r\n cash_advance_interest_rate=None,\r\n current_balance=None,\r\n payment_min_amount=None,\r\n payment_due_date=None,\r\n previous_balance=None,\r\n statement_start_date=None,\r\n statement_end_date=None,\r\n statement_purchase_amount=None,\r\n statement_finance_amount=None,\r\n statement_credit_amount=None,\r\n reward_earned_balance=None,\r\n past_due_amount=None,\r\n last_payment_amount=None,\r\n last_payment_date=None,\r\n statement_close_balance=None,\r\n term_of_ml=None,\r\n ml_holder_name=None,\r\n description=None,\r\n late_fee_amount=None,\r\n payoff_amount=None,\r\n payoff_amount_date=None,\r\n original_maturity_date=None,\r\n principal_balance=None,\r\n escrow_balance=None,\r\n interest_period=None,\r\n initial_ml_amount=None,\r\n initial_ml_date=None,\r\n next_payment_principal_amount=None,\r\n next_payment_interest_amount=None,\r\n next_payment=None,\r\n next_payment_date=None,\r\n last_payment_due_date=None,\r\n last_payment_receive_date=None,\r\n last_payment_principal_amount=None,\r\n last_payment_interest_amount=None,\r\n last_payment_escrow_amount=None,\r\n last_payment_last_fee_amount=None,\r\n last_payment_late_charge=None,\r\n ytd_principal_paid=None,\r\n ytd_interest_paid=None,\r\n ytd_insurance_paid=None,\r\n ytd_tax_paid=None,\r\n auto_pay_enrolled=None,\r\n collateral=None,\r\n current_school=None,\r\n first_payment_date=None,\r\n first_mortgage=None,\r\n loan_payment_freq=None,\r\n original_school=None,\r\n recurring_payment_amount=None,\r\n lender=None,\r\n ending_balance_amount=None,\r\n loan_term_type=None,\r\n payments_made=None,\r\n balloon_amount=None,\r\n projected_interest=None,\r\n interest_paid_ltd=None,\r\n interest_rate_type=None,\r\n loan_payment_type=None,\r\n repayment_plan=None,\r\n payments_remaining=None,\r\n interest_margin_balance=None,\r\n short_balance=None,\r\n available_cash_balance=None,\r\n maturity_value_amount=None,\r\n vested_balance=None,\r\n emp_match_amount=None,\r\n emp_pretax_contrib_amount=None,\r\n emp_pretax_contrib_amount_ytd=None,\r\n contrib_total_ytd=None,\r\n cash_balance_amount=None,\r\n pre_tax_amount=None,\r\n after_tax_amount=None,\r\n match_amount=None,\r\n profit_sharing_amount=None,\r\n rollover_amount=None,\r\n other_vest_amount=None,\r\n other_nonvest_amount=None,\r\n current_loan_balance=None,\r\n loan_rate=None,\r\n buy_power=None,\r\n rollover_ltd=None,\r\n additional_properties = {}):\r\n\r\n # Initialize members of the class\r\n self.posted_date = posted_date\r\n self.available_balance_amount = available_balance_amount\r\n self.open_date = open_date\r\n self.period_start_date = period_start_date\r\n self.period_end_date = period_end_date\r\n self.period_interest_rate = period_interest_rate\r\n self.period_deposit_amount = period_deposit_amount\r\n self.period_interest_amount = period_interest_amount\r\n self.interest_ytd_amount = interest_ytd_amount\r\n self.interest_prior_ytd_amount = interest_prior_ytd_amount\r\n self.maturity_date = maturity_date\r\n self.interest_rate = interest_rate\r\n self.credit_available_amount = credit_available_amount\r\n self.credit_max_amount = credit_max_amount\r\n self.cash_advance_available_amount = cash_advance_available_amount\r\n self.cash_advance_max_amount = cash_advance_max_amount\r\n self.cash_advance_balance = cash_advance_balance\r\n self.cash_advance_interest_rate = cash_advance_interest_rate\r\n self.current_balance = current_balance\r\n self.payment_min_amount = payment_min_amount\r\n self.payment_due_date = payment_due_date\r\n self.previous_balance = previous_balance\r\n self.statement_start_date = statement_start_date\r\n self.statement_end_date = statement_end_date\r\n self.statement_purchase_amount = statement_purchase_amount\r\n self.statement_finance_amount = statement_finance_amount\r\n self.statement_credit_amount = statement_credit_amount\r\n self.reward_earned_balance = reward_earned_balance\r\n self.past_due_amount = past_due_amount\r\n self.last_payment_amount = last_payment_amount\r\n self.last_payment_date = last_payment_date\r\n self.statement_close_balance = statement_close_balance\r\n self.term_of_ml = term_of_ml\r\n self.ml_holder_name = ml_holder_name\r\n self.description = description\r\n self.late_fee_amount = late_fee_amount\r\n self.payoff_amount = payoff_amount\r\n self.payoff_amount_date = payoff_amount_date\r\n self.original_maturity_date = original_maturity_date\r\n self.principal_balance = principal_balance\r\n self.escrow_balance = escrow_balance\r\n self.interest_period = interest_period\r\n self.initial_ml_amount = initial_ml_amount\r\n self.initial_ml_date = initial_ml_date\r\n self.next_payment_principal_amount = next_payment_principal_amount\r\n self.next_payment_interest_amount = next_payment_interest_amount\r\n self.next_payment = next_payment\r\n self.next_payment_date = next_payment_date\r\n self.last_payment_due_date = last_payment_due_date\r\n self.last_payment_receive_date = last_payment_receive_date\r\n self.last_payment_principal_amount = last_payment_principal_amount\r\n self.last_payment_interest_amount = last_payment_interest_amount\r\n self.last_payment_escrow_amount = last_payment_escrow_amount\r\n self.last_payment_last_fee_amount = last_payment_last_fee_amount\r\n self.last_payment_late_charge = last_payment_late_charge\r\n self.ytd_principal_paid = ytd_principal_paid\r\n self.ytd_interest_paid = ytd_interest_paid\r\n self.ytd_insurance_paid = ytd_insurance_paid\r\n self.ytd_tax_paid = ytd_tax_paid\r\n self.auto_pay_enrolled = auto_pay_enrolled\r\n self.collateral = collateral\r\n self.current_school = current_school\r\n self.first_payment_date = first_payment_date\r\n self.first_mortgage = first_mortgage\r\n self.loan_payment_freq = loan_payment_freq\r\n self.original_school = original_school\r\n self.recurring_payment_amount = recurring_payment_amount\r\n self.lender = lender\r\n self.ending_balance_amount = ending_balance_amount\r\n self.loan_term_type = loan_term_type\r\n self.payments_made = payments_made\r\n self.balloon_amount = balloon_amount\r\n self.projected_interest = projected_interest\r\n self.interest_paid_ltd = interest_paid_ltd\r\n self.interest_rate_type = interest_rate_type\r\n self.loan_payment_type = loan_payment_type\r\n self.repayment_plan = repayment_plan\r\n self.payments_remaining = payments_remaining\r\n self.interest_margin_balance = interest_margin_balance\r\n self.short_balance = short_balance\r\n self.available_cash_balance = available_cash_balance\r\n self.maturity_value_amount = maturity_value_amount\r\n self.vested_balance = vested_balance\r\n self.emp_match_amount = emp_match_amount\r\n self.emp_pretax_contrib_amount = emp_pretax_contrib_amount\r\n self.emp_pretax_contrib_amount_ytd = emp_pretax_contrib_amount_ytd\r\n self.contrib_total_ytd = contrib_total_ytd\r\n self.cash_balance_amount = cash_balance_amount\r\n self.pre_tax_amount = pre_tax_amount\r\n self.after_tax_amount = after_tax_amount\r\n self.match_amount = match_amount\r\n self.profit_sharing_amount = profit_sharing_amount\r\n self.rollover_amount = rollover_amount\r\n self.other_vest_amount = other_vest_amount\r\n self.other_nonvest_amount = other_nonvest_amount\r\n self.current_loan_balance = current_loan_balance\r\n self.loan_rate = loan_rate\r\n self.buy_power = buy_power\r\n self.rollover_ltd = rollover_ltd\r\n\r\n # Add additional model properties to the instance\r\n self.additional_properties = additional_properties","def get_today(**kwargs: int) -> Date:\n return Date.today().replace(**kwargs)","def __init__(self, start_date=None, end_date=None, currency=None, price=None):\n\n self._start_date = None\n self._end_date = None\n self._currency = None\n self._price = None\n\n self.start_date = start_date\n self.end_date = end_date\n self.currency = currency\n self.price = price","def __init__(self, period: Optional[Period], date: dict = Depends(date_kwargs)) -> None:\n self._given_date = date\n self.date = date\n if period:\n self.period = period\n else:\n if not any(date.values()):\n self.period = Period.FULL\n else:\n self._period_from_date()\n self._fill_date()","def TODAY():\n return datetime.date.today()","def get_date():\n return datetime.datetime.now()","def __init__(self,\n amount=None,\n currency=None,\n **kwargs\n\n ):\n self.amount = amount\n self.currency = currency","def _sel_context(self, cr, uid, billing_id, context=None):\n company_currency = self._get_company_currency(cr, uid, billing_id, context)\n current_currency = self._get_current_currency(cr, uid, billing_id, context)\n if current_currency <> company_currency:\n context_multi_currency = context.copy()\n billing_brw = self.pool.get('account.billing').browse(cr, uid, billing_id, context)\n context_multi_currency.update({'date': billing_brw.date})\n return context_multi_currency\n return context","def default_get(self, cr, uid, fields_list, context=None):\n\t\tif context is None:\n\t\t\tcontext = {}\n\t\tdate_start = datetime.date.today().strftime('%Y-01-01')\n\t\tdate_end = datetime.date.today().strftime('%Y-%m-%d')\n\n\t\tvalues = super(wizard_add_taxes, self).default_get(cr, uid, fields_list, context=context)\n\t\ttax_ids = []\n\t\tif (context.get('active_id',False)):\n\t\t\ttax_payment = self.pool.get('account.tax.payment').browse(cr,uid,context.get('active_id',False))\n\t\t\tcompany_id = tax_payment.company_id and tax_payment.company_id.id or False\n\t\t\ttax_ids = [t.id for t in tax_payment.tax_type]\n\t\t\tdate_end = tax_payment.date_end\n\t\telse:\n\t\t\tuser = self.pool.get('res.users').browse(cr,uid,uid,context)\n\t\t\tcompany_id = user.company_id and user.company_id.id or False\n\t\t\ttax_ids=self.pool.get('account.tax').search(cr,uid,[('company_id','=',company_id)],context=context)\n\t\ttax_account_ids=[]\n\t\ttax_not_returned=[]\n\t\ttax_code_account_ids = []\n\t\ttax_code_unreturned = []\n\t\tfor tax in self.pool.get('account.tax').browse(cr,uid,tax_ids,context):\n\t\t\tif not tax.inside_berikat and not tax.reported_unreturned:\n\t\t\t\tif tax.account_collected_id and tax.account_collected_id.id:\n\t\t\t\t\ttax_account_ids.append(tax.account_collected_id.id)\n\t\t\t\tif tax.account_paid_id and tax.account_paid_id.id:\n\t\t\t\t\ttax_account_ids.append(tax.account_paid_id and tax.account_paid_id.id)\n\t\t\t\tif tax.tax_code_id and tax.tax_code_id.id:\n\t\t\t\t\ttax_code_account_ids.append(tax.tax_code_id.id)\n\t\t\t\tif tax.ref_tax_code_id and tax.ref_tax_code_id.id:\n\t\t\t\t\ttax_code_account_ids.append(tax.ref_tax_code_id.id)\n\t\t\telse:\n\t\t\t\tif tax.account_collected_id and tax.account_collected_id.id:\n\t\t\t\t\ttax_not_returned.append(tax.account_collected_id and tax.account_collected_id.id)\n\t\t\t\tif tax.account_paid_id and tax.account_paid_id.id:\n\t\t\t\t\ttax_not_returned.append(tax.account_paid_id and tax.account_paid_id.id)\n\t\t\t\tif tax.tax_code_id and tax.tax_code_id.id:\n\t\t\t\t\ttax_code_unreturned.append(tax.tax_code_id and tax.tax_code_id.id)\n\t\t\t\tif tax.ref_tax_code_id and tax.ref_tax_code_id.id:\n\t\t\t\t\ttax_code_unreturned.append(tax.ref_tax_code_id and tax.ref_tax_code_id.id)\n\t\t\t\t#print \"tax_not_returned==============\",tax_not_returned\n\t\ttax_account_ids = list(set(tax_account_ids))\n\t\ttax_not_returned = list(set(tax_not_returned))\n\t\ttax_code_account_ids = list(set(tax_code_account_ids))\n\t\ttax_code_unreturned = list(set(tax_code_unreturned))\n\t\tcompany = self.pool.get('res.company').browse(cr,uid,company_id,context)\n\t\tif tax_account_ids or tax_not_returned:\n\t\t\tmove_id = self.pool.get('account.move').search(cr,uid,[('state','=','posted'),('date',\">=\",date_start),('date',\"<=\",date_end)])\n\t\t\texisting_payment_line_ids = self.pool.get('account.tax.payment.line').search(cr,uid,[],context=context)\n\t\t\texisting_payment_lines = [epm.move_line_id.id for epm in self.pool.get('account.tax.payment.line').browse(cr,uid,existing_payment_line_ids)]\n\t\t\texisting_statement_ids = self.pool.get('account.tax.payment').search(cr,uid,[],context=context)\n\t\t\texisting_statements_move = [esm.move_id.id for esm in self.pool.get('account.tax.payment').browse(cr,uid,existing_statement_ids)]\n\t\t\texisting_statement_move_lines = self.pool.get('account.move.line').search(cr,uid,[('move_id','in',existing_statements_move)])\n\t\t\texisting_payment_lines += existing_statement_move_lines\n\n\n\t\ttax_lines_value=[]\n\n\n\t\tif context.get('type',False) == 'tax_lines_cr':\n\t\t\tmove_lines = self.pool.get('account.move.line').search(cr,uid,[('id','not in',existing_payment_lines),\\\n\t\t\t\t('date','>=',date_start),('date','<=',date_end),('tax_code_id','in',tax_code_account_ids),('account_id','in',tax_account_ids),\\\n\t\t\t\t('state','=','valid'),('move_id','in',move_id),('debit','=',0.0),('credit',\">=\",0.0)])\n\t\t\tfor line in self.pool.get('account.move.line').browse(cr,uid,move_lines,context=context):\n\t\t\t\tmoves = line.move_id\n\t\t\t\tinvoice_id=False\n\t\t\t\tfor move_line in line.move_id.line_id:\n\t\t\t\t\tif move_line.invoice and move_line.invoice.id:\n\t\t\t\t\t\tinvoice_id=move_line.invoice.id\n\t\t\t\ttax_lines={\n\t\t\t\t\t\"name\"\t\t\t\t: line.name or line.ref or '/',\n\t\t\t\t\t\"move_line_id\"\t\t: line.id,\n\t\t\t\t\t\"invoice_id\"\t\t: invoice_id,\n\t\t\t\t\t\"amount\"\t\t\t: line.debit or line.credit or 0.0,\n\t\t\t\t\t\"currency_id\"\t\t: line.currency_id and line.currency_id.id or False,\n\t\t\t\t\t\"amount_currency\"\t: line.amount_currency or 0.0,\n\t\t\t\t\t\"effective_date\"\t: line.date or False,\n\t\t\t\t\t\"partner_id\"\t\t: line.partner_id and line.partner_id.id or False,\n\t\t\t\t\t}\n\t\t\t\ttax_lines_value.append(tax_lines)\n\t\telif context.get('type',False) == 'tax_lines_dr':\n\t\t\tmove_lines = self.pool.get('account.move.line').search(cr,uid,[('id','not in',existing_payment_lines),\\\n\t\t\t\t('date','>=',date_start),('date','<=',date_end),('tax_code_id','in',tax_code_account_ids),('account_id','in',tax_account_ids),\\\n\t\t\t\t('state','=','valid'),('move_id','in',move_id),('debit','>=',0.0),('credit',\"=\",0.0)])\n\n\t\t\tfor line in self.pool.get('account.move.line').browse(cr,uid,move_lines,context=context):\n\t\t\t\tmoves = line.move_id\n\t\t\t\tinvoice_id=False\n\t\t\t\tfor move_line in line.move_id.line_id:\n\t\t\t\t\tif move_line.invoice and move_line.invoice.id:\n\t\t\t\t\t\tinvoice_id=move_line.invoice.id\n\t\t\t\ttax_lines={\n\t\t\t\t\t\"name\"\t\t\t\t: line.name or line.ref or '/',\n\t\t\t\t\t\"move_line_id\"\t\t: line.id,\n\t\t\t\t\t\"invoice_id\"\t\t: invoice_id,\n\t\t\t\t\t\"amount\"\t\t\t: line.debit or line.credit or 0.0,\n\t\t\t\t\t\"currency_id\"\t\t: line.currency_id and line.currency_id.id or False,\n\t\t\t\t\t\"amount_currency\"\t: line.amount_currency or 0.0,\n\t\t\t\t\t\"effective_date\"\t: line.date or False,\n\t\t\t\t\t\"partner_id\"\t\t: line.partner_id and line.partner_id.id or False,\n\t\t\t\t\t}\n\t\t\t\ttax_lines_value.append(tax_lines)\n\t\telif context.get('type',False) == 'tax_lines_cr_unr':\n\t\t\tmove_lines_unreturned = self.pool.get('account.move.line').search(cr,uid,[('id','not in',existing_payment_lines),\\\n\t\t\t\t('date','>=',date_start),('date','<=',date_end),('tax_code_id','in',tax_code_unreturned),('account_id','in',tax_not_returned),\\\n\t\t\t\t('state','=','valid'),('move_id','in',move_id),('debit','=',0.0),('credit',\">=\",0.0)])\n\t\t\tfor line in self.pool.get('account.move.line').browse(cr,uid,move_lines_unreturned,context=context):\n\t\t\t\tmoves = line.move_id\n\t\t\t\tinvoice_id=False\n\t\t\t\tfor move_line in line.move_id.line_id:\n\t\t\t\t\tif move_line.invoice and move_line.invoice.id:\n\t\t\t\t\t\tinvoice_id=move_line.invoice.id\n\t\t\t\ttax_lines={\n\t\t\t\t\t\"name\"\t\t\t\t: line.name or line.ref or '/',\n\t\t\t\t\t\"move_line_id\"\t\t: line.id,\n\t\t\t\t\t\"invoice_id\"\t\t: invoice_id,\n\t\t\t\t\t\"amount\"\t\t\t: line.debit or line.credit or 0.0,\n\t\t\t\t\t\"currency_id\"\t\t: line.currency_id and line.currency_id.id or False,\n\t\t\t\t\t\"amount_currency\"\t: line.amount_currency or 0.0,\n\t\t\t\t\t\"effective_date\"\t: line.date or False,\n\t\t\t\t\t\"partner_id\"\t\t: line.partner_id and line.partner_id.id or False,\n\t\t\t\t\t}\n\t\t\t\ttax_lines_value.append(tax_lines)\n\t\telif context.get('type',False) == 'tax_lines_dr_unr':\n\t\t\t#move_lines = self.pool.get('account.move.line').search(cr,uid,[('account_id','not in',tax_not_returned),('id','not in',existing_payment_lines),('credit',\"=\",0.0),('debit',\">=\",0.0),('date',\">=\",date_start),('date',\"<=\",date_end),(\"account_id\",'in',tax_account_ids),('move_id.state','=','posted'),('state','=','valid')],context=context)\n\t\t\t#move_lines_unreturned = self.pool.get('account.move.line').search(cr,uid,[('account_id','in',tax_not_returned),('id','not in',existing_payment_lines),('credit',\"=\",0.0),('debit',\">=\",0.0),('date',\">=\",date_start),('date',\"<=\",date_end),(\"account_id\",'in',tax_account_ids),('move_id.state','=','posted'),('state','=','valid')],context=context)\n\t\t\tmove_lines_unreturned = self.pool.get('account.move.line').search(cr,uid,[('id','not in',existing_payment_lines),\\\n\t\t\t\t('date','>=',date_start),('date','<=',date_end),('tax_code_id','in',tax_code_unreturned),('account_id','in',tax_not_returned),\\\n\t\t\t\t('state','=','valid'),('move_id','in',move_id),('debit','>=',0.0),('credit',\"=\",0.0)])\n\n\t\t\tfor line in self.pool.get('account.move.line').browse(cr,uid,move_lines_unreturned,context=context):\n\t\t\t\tmoves = line.move_id\n\t\t\t\tinvoice_id=False\n\t\t\t\tfor move_line in line.move_id.line_id:\n\t\t\t\t\tif move_line.invoice and move_line.invoice.id:\n\t\t\t\t\t\tinvoice_id=move_line.invoice.id\n\t\t\t\ttax_lines={\n\t\t\t\t\t\"name\"\t\t\t\t: line.name or line.ref or '/',\n\t\t\t\t\t\"move_line_id\"\t\t: line.id,\n\t\t\t\t\t\"invoice_id\"\t\t: invoice_id,\n\t\t\t\t\t\"amount\"\t\t\t: line.debit or line.credit or 0.0,\n\t\t\t\t\t\"currency_id\"\t\t: line.currency_id and line.currency_id.id or False,\n\t\t\t\t\t\"amount_currency\"\t: line.amount_currency or 0.0,\n\t\t\t\t\t\"effective_date\"\t: line.date or False,\n\t\t\t\t\t\"partner_id\"\t\t: line.partner_id and line.partner_id.id or False,\n\t\t\t\t\t}\n\t\t\t\ttax_lines_value.append(tax_lines)\n\t\tvalues.update({'tax_move_line_ids':tax_lines_value})\t\n\t\t\n\t\treturn values","async def _claim_daily_coins(ctx):\n await daily_coins(bot, ctx.message.author.id)","def formalDateToday():\n return dt.date.today().strftime(\"%B %d, %Y\")","def __init__(self, start: datetime.date, balance: float) -> None:\n Contract.__init__(self, start)\n self.balance = balance * (-1)","def today(cls, **kwargs: Any) -> Date:\n return cls.from_date(dt.date.today())","def _fill_date(self):\n if not self.date['year']:\n self.date['year'] = self.DEFAULT_DATE['year']\n if not self.date['month']:\n self.date['month'] = self.DEFAULT_DATE['month']\n if not self.date['day']:\n self.date['day'] = self.DEFAULT_DATE['day']","def test_handler_dates(self):\n\n @intent_handler\n def decorated_test(date_str: str = None, date_date: datetime.date = None):\n return date_str, date_date\n\n r = create_request(\n \"TEST_CONTEXT\",\n date_str=[\n \"2001-12-31\",\n \"2001-12-31\",\n ],\n date_date=[\n \"2001-12-31\",\n \"1001-12-31\",\n ],\n )\n result = decorated_test(r)\n self.assertEqual(result, (\"2001-12-31\", datetime.date(2001, 12, 31)))","def form_DateDifferentEmpty(request):\n schema = schemaish.Structure()\n schema.add('myDateField', schemaish.Date())\n form = formish.Form(schema, 'form')\n form['myDateField'].widget = formish.Input(empty=datetime.date.today())\n return form","def test_date_accept_today(self):\n spi_search = \"find date today\"\n inv_search = \"year:\" + datetime.datetime.strftime(datetime.datetime.today(), '%Y-%m-%d')\n self._compare_searches(inv_search, spi_search)","def default_actual_order_price(context):\n current_type = context.current_parameters.get('current_type')\n default_price = 0\n actual_order_price = 0\n if current_type == 'order':\n project_id = context.current_parameters.get('project_id', None)\n if project_id:\n project = Project.get(project_id)\n default_price = project.price if project else default_price\n actual_order_price = context.current_parameters.get('price', default_price)\n return actual_order_price","def transaction_date(self, value):\n if value:\n self._transaction_date = (\n parse(value).date() if isinstance(value, type_check) else value\n )","def test_today(self):\n self.assertEquals(\n self.builder._today(), date.today().strftime('%Y-%m-%d'))","def date(*args):\n current_date = datetime.now().isoformat(' ').split('.')[0]\n send.system_message(current_date)","def __init__(self, price, date=datetime.datetime.now(), dividend=0., annualDividend=0.):\n self.price = price\n self.date = date\n self.dividend = dividend\n self.annualDividend = annualDividend","def on_book(context, quote_type, quote):\n date, filterTime = str(context.config.trading_date), int(quote.int_time)\n # print(quote.symbol, quote.int_time)\n\n if ((filterTime > 93000000) and (filterTime < 113000000)) or (\n (filterTime > 130000000) and (filterTime < 150000000)):\n # print (\"Trading Time\")\n if str(quote.symbol).__contains__(\"IH\"):\n context.dic[\"IH\"] = [quote.bp_array[0], quote.ap_array[0]]\n context.symboldic[\"IH\"] = quote.symbol\n if str(quote.symbol).__contains__(\"IC\"):\n context.dic[\"IC\"] = [quote.bp_array[0], quote.ap_array[0]]\n context.symboldic[\"IC\"] = quote.symbol\n if len(context.dic.keys()) < 2:\n return\n \"\"\"\n if len(context.dic.keys()) >= 2:\n sql = \"`quoteData insert (%s;%s;%s;%s;%s;%s;%s)\"\n time_sql = '{y+ \"T\"$-9#\"00000000\",string x}[%s;%s]'\n date_time = time_sql % (filterTime, \"%s.%s.%s\" % (date[0:4], date[4:6], date[6:8]))\n context.q.sync(date_time)\n # print(context.dic[\"IC\"][0]*200 -context.dic[\"IH\"][1]*300*2)\n feed_quote = sql % (date_time, context.dic[\"IH\"][0], context.dic[\"IH\"][1], context.dic[\"IC\"][0], context.dic[\"IC\"][1], context.dic[\"IC\"][0]*200 -context.dic[\"IH\"][1]*300*2, context.dic[\"IC\"][1]*200 -context.dic[\"IH\"][0]*300*2)\n context.q.sync(feed_quote)\n\n context.q.sync(\n \"CombinedMainContract: select Date:last Date,BidPrice1Open:first PairBidPrice,BidPrice1High:max PairBidPrice,BidPrice1Low:min PairBidPrice, BidPrice1Close:last PairBidPrice,BidVol1:100,AskPrice1Open:first PairAskPrice,AskPrice1High:max PairAskPrice,AskPrice1Low:min PairAskPrice, AskPrice1Close:last PairAskPrice,AskVol1:last 100,LegOneBidPrice1:last LegOneBidPrice1, LegOneAskPrice1:last LegOneAskPrice1, LegTwoBidPrice1:last LegTwoBidPrice1, LegTwoAskPrice1: last LegTwoAskPrice1 by %s xbar Date.second from `quoteData;\" % (\n context.kindleInterval))\n context.q.sync(\n \"delete date, second from `CombinedMainContract;delete from `CombinedMainContract where Date.second < 09:30:00;delete from `CombinedMainContract where Date.second > 11:30:00, Date.second < 13:00:00;delete from `CombinedMainContract where Date.second > 15:00:00;update TrueRange: {max(x;y;z)}'[(AskPrice1High - BidPrice1Low);(AskPrice1High - (prev BidPrice1Close));((prev AskPrice1High) - BidPrice1Low)] from `CombinedMainContract;\")\n context.q.sync(\"update N: mavg[%s;TrueRange] from `CombinedMainContract;\" % (context.volatilityRange))\n context.q.sync(\"update ShortEntry: prev (%s mmin BidPrice1Low), LongEntry: prev (%s mmax AskPrice1High) from `CombinedMainContract;\"%(context.breakRange, context.breakRange))\n\n Signal = context.q.sync(\"select count Date from CombinedMainContract\")[0]\n \n if (Signal[0] > context.kindleNumber):\n context.kindleNumber = Signal[0]\n PairDataBar = context.q.sync(\"-2#select Date.minute, BidPrice1Close, AskPrice1Close, ShortEntry, LongEntry, N from CombinedMainContract\")[0]\n context.PairDataBarDate = PairDataBar[0]\n context.PairDataBarBidPrice1Close = PairDataBar[1]\n context.PairDataBarAskPrice1Close = PairDataBar[2]\n context.PairDataBarShortEntry = PairDataBar[3]\n context.PairDataBarLongEntry = PairDataBar[4]\n context.PairDataBarN = PairDataBar[5]\n if (context.PairDataBarBidPrice1Close < context.LocalLow):\n context.UpDrawBack = 0.0\n context.LocalLow = context.PairDataBarBidPrice1Close\n elif (context.PairDataBarBidPrice1Close > context.LocalLow):\n context.UpDrawBack = context.PairDataBarBidPrice1Close - context.LocalLow\n\n if (abs(context.PositionAddedTime) > 0 and (context.PairDataBarDate > 898)):\n context.PositionClearPrice = context.dic[\"IC\"][1]\n # print(\"PosClear: \" + str(context.dic[\"IC\"][1]))\n # context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][1], abs(context.PositionAddedTime), Direction.BUY, OpenClose.CLOSE)\n context.PositionAddedTime = 0\n # sendOrderClose PositionAddedTime Amount Contract\n if (context.PositionAddedTime == -1):\n print(context.LegOnePositionEntryPrice[1] - context.PositionClearPrice)\n elif (context.PositionAddedTime == -2):\n print(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[\n 2] - 2 * context.PositionClearPrice)\n elif (context.PositionAddedTime == -3):\n print(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] +\n context.LegOnePositionEntryPrice[3] - 3 * context.PositionClearPrice)\n elif (context.PositionAddedTime == -4):\n print(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] +\n context.LegOnePositionEntryPrice[3] + context.LegOnePositionEntryPrice[\n 4] - 4 * context.PositionClearPrice)\n context.LegOnePositionEntryPrice = {}\n context.PositionEntryPrice = {}\n # context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][1], abs(context.PositionAddedTime), Direction.BUY, OpenClose.CLOSE)\n context.PositionAddedTime = 0\n else:\n if ((abs(context.PositionAddedTime) > 0) and (context.UpDrawBack > context.NStoplossPositionParameter * context.PairDataBarN)):\n # print(\"PosClear: \" + str(context.dic[\"IC\"][1]))\n context.PositionClearPrice = context.dic[\"IC\"][1]\n if (context.PositionAddedTime == -1):\n print (context.LegOnePositionEntryPrice[1] - context.PositionClearPrice)\n elif (context.PositionAddedTime == -2):\n print (context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2]- 2 * context.PositionClearPrice)\n elif (context.PositionAddedTime == -3):\n print (context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] + context.LegOnePositionEntryPrice[3]- 3 * context.PositionClearPrice)\n elif (context.PositionAddedTime == -4):\n print (context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] + context.LegOnePositionEntryPrice[3] + context.LegOnePositionEntryPrice[4] - 4 * context.PositionClearPrice)\n context.LegOnePositionEntryPrice = {}\n context.PositionEntryPrice = {}\n #context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][1], abs(context.PositionAddedTime), Direction.BUY, OpenClose.CLOSE)\n context.PositionAddedTime = 0\n context.q.sync(\"update Position:0 from `CombinedMainContract where Date = max Date\")\n if ((abs(context.PositionAddedTime) == 3) and context.PositionTimesParameter >= 4 and context.PairDataBarBidPrice1Close < context.PositionEntryPrice[1] - 3 * context.NEntryParameter*context.Nvalue):\n context.PositionAddedTime = -4\n context.LegOnePositionEntryPrice[4] = context.dic[\"IC\"][0]\n context.PositionEntryPrice[4] = context.PairDataBarBidPrice1Close\n # print(\"Pos4: \" + str(context.dic[\"IC\"][0]))\n #context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][0], 1, Direction.SELL, OpenClose.OPEN)\n context.q.sync(\"update Position:-4 from `CombinedMainContract where Date = max Date\")\n if ((abs(context.PositionAddedTime) == 2) and context.PositionTimesParameter >= 3 and context.PairDataBarBidPrice1Close < context.PositionEntryPrice[1] - 2 * context.NEntryParameter*context.Nvalue):\n context.PositionAddedTime = -3\n context.LegOnePositionEntryPrice[3] = context.dic[\"IC\"][0]\n context.PositionEntryPrice[3] = context.PairDataBarBidPrice1Close\n # print(\"Pos3: \" + str(context.dic[\"IC\"][0]))\n context.q.sync(\"update Position:-3 from `CombinedMainContract where Date = max Date\")\n #context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][0], 1, Direction.SELL, OpenClose.OPEN)\n if ((abs(context.PositionAddedTime) == 1) and context.PositionTimesParameter >= 2 and context.PairDataBarBidPrice1Close < context.PositionEntryPrice[1] - 1 * context.NEntryParameter*context.Nvalue):\n context.PositionAddedTime = -2\n context.LegOnePositionEntryPrice[2] = context.dic[\"IC\"][0]\n context.PositionEntryPrice[2] = context.PairDataBarBidPrice1Close\n # print(\"Pos2: \" + str(context.dic[\"IC\"][0]))\n #context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][0], 1, Direction.SELL, OpenClose.OPEN)\n context.q.sync(\"update Position:-2 from `CombinedMainContract where Date = max Date\")\n if ((abs(context.PositionAddedTime) == 0) and context.PositionTimesParameter >= 1 and context.PairDataBarBidPrice1Close < context.PairDataBarShortEntry - 0 * context.NEntryParameter*context.Nvalue):\n context.PositionAddedTime = -1\n context.LegOnePositionEntryPrice[1] = context.dic[\"IC\"][0]\n context.PositionEntryPrice[1] = context.PairDataBarBidPrice1Close\n # print(\"Pos1: \" + str(str(context.dic[\"IC\"][0])))\n context.Nvalue = context.PairDataBarN\n context.q.sync(\"update Position:-1 from `CombinedMainContract where Date = max Date\")\n #context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][0], 1, Direction.SELL, OpenClose.OPEN)\n\n \"\"\"\n \"\"\"\n if context.long_position(quote.symbol) > 0 and not context.ORDER_SENT_FLAG:\n context.order.send_single_order(\n quote.symbol, quote.bp_array[0], 5, Direction.SELL, OpenClose.CLOSE\n )\n context.ORDER_SENT_FLAG = True\n elif 90000000 < quote.int_time < 90500000 and not context.ORDER_SENT_FLAG:\n context.order.send_single_order(\n quote.symbol, quote.bp_array[0], 5, Direction.BUY, OpenClose.OPEN\n )\n context.ORDER_SENT_FLAG = True\n else:\n pass\n \"\"\"\n\n if len(context.dic.keys()) >= 2:\n sql = \"`quoteData insert (%s;%s;%s;%s;%s;%s;%s)\"\n time_sql = '{y+ \"T\"$-9#\"00000000\",string x}[%s;%s]'\n date_time = time_sql % (filterTime, \"%s.%s.%s\" % (date[0:4], date[4:6], date[6:8]))\n context.q.sync(date_time)\n # print(context.dic[\"IC\"][0]*200 -context.dic[\"IH\"][1]*300*2)\n feed_quote = sql % (\n date_time, context.dic[\"IH\"][0], context.dic[\"IH\"][1], context.dic[\"IC\"][0], context.dic[\"IC\"][1],\n context.dic[\"IC\"][0] * 200 - context.dic[\"IH\"][1] * 300 * 2,\n context.dic[\"IC\"][1] * 200 - context.dic[\"IH\"][0] * 300 * 2)\n context.q.sync(feed_quote)\n\n context.q.sync(\n \"CombinedMainContract: select Date:last Date,BidPrice1Open:first PairBidPrice,BidPrice1High:max PairBidPrice,BidPrice1Low:min PairBidPrice, BidPrice1Close:last PairBidPrice,BidVol1:100,AskPrice1Open:first PairAskPrice,AskPrice1High:max PairAskPrice,AskPrice1Low:min PairAskPrice, AskPrice1Close:last PairAskPrice,AskVol1:last 100,LegOneBidPrice1:last LegOneBidPrice1, LegOneAskPrice1:last LegOneAskPrice1, LegTwoBidPrice1:last LegTwoBidPrice1, LegTwoAskPrice1: last LegTwoAskPrice1 by %s xbar Date.second from `quoteData;\" % (\n context.kindleInterval))\n context.q.sync(\n \"delete date, second from `CombinedMainContract;delete from `CombinedMainContract where Date.second < 09:30:00;delete from `CombinedMainContract where Date.second > 11:30:00, Date.second < 13:00:00;delete from `CombinedMainContract where Date.second > 15:00:00;update TrueRange: {max(x;y;z)}'[(AskPrice1High - BidPrice1Low);(AskPrice1High - (prev BidPrice1Close));((prev AskPrice1High) - BidPrice1Low)] from `CombinedMainContract;\")\n context.q.sync(\"update N: mavg[%s;TrueRange] from `CombinedMainContract;\" % (context.volatilityRange))\n context.q.sync(\n \"update ShortEntry: prev (%s mmin BidPrice1Low), LongEntry: prev (%s mmax AskPrice1High) from `CombinedMainContract;\" % (\n context.breakRange, context.breakRange))\n\n Signal = context.q.sync(\"select count Date from CombinedMainContract\")[0]\n\n if (Signal[0] > context.kindleNumber):\n context.kindleNumber = Signal[0]\n PairDataBar = context.q.sync(\n \"-2#select Date.minute, BidPrice1Close, AskPrice1Close, ShortEntry, LongEntry, N from CombinedMainContract\")[\n 0]\n context.PairDataBarDate = PairDataBar[0]\n context.PairDataBarBidPrice1Close = PairDataBar[1]\n context.PairDataBarAskPrice1Close = PairDataBar[2]\n context.PairDataBarShortEntry = PairDataBar[3]\n context.PairDataBarLongEntry = PairDataBar[4]\n context.PairDataBarN = PairDataBar[5]\n if (context.PairDataBarAskPrice1Close > context.LocalHigh):\n context.DownDrawBack = 0.0\n context.LocalHigh = context.PairDataBarAskPrice1Close\n elif (context.PairDataBarAskPrice1Close < context.LocalHigh):\n context.DownDrawBack = context.LocalHigh - context.PairDataBarAskPrice1Close\n\n if (abs(context.PositionAddedTime) > 0 and (context.PairDataBarDate > 898)):\n context.PositionClearPrice = context.dic[\"IC\"][0]\n # print(\"PosClear: \" + str(context.dic[\"IC\"][1]))\n # context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][1], abs(context.PositionAddedTime), Direction.BUY, OpenClose.CLOSE)\n\n # sendOrderClose PositionAddedTime Amount Contract\n print(\"PosClear: \" + str(context.dic[\"IC\"][0]))\n context.PositionClearPrice = context.dic[\"IC\"][0]\n if (context.PositionAddedTime == 1):\n print(-(context.LegOnePositionEntryPrice[1] - context.PositionClearPrice))\n elif (context.PositionAddedTime == 2):\n print(-(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[\n 2] - 2 * context.PositionClearPrice))\n elif (context.PositionAddedTime == 3):\n print(-(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] +\n context.LegOnePositionEntryPrice[3] - 3 * context.PositionClearPrice))\n elif (context.PositionAddedTime == 4):\n print(-(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] +\n context.LegOnePositionEntryPrice[3] + context.LegOnePositionEntryPrice[\n 4] - 4 * context.PositionClearPrice))\n context.PositionAddedTime = 0\n context.LegOnePositionEntryPrice = {}\n context.PositionEntryPrice = {}\n # context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][1], abs(context.PositionAddedTime), Direction.BUY, OpenClose.CLOSE)\n context.PositionAddedTime = 0\n else:\n if ((abs(context.PositionAddedTime) > 0) and (\n context.DownDrawBack > context.NStoplossPositionParameter * context.PairDataBarN)):\n print(\"PosClear: \" + str(context.dic[\"IC\"][0]))\n context.PositionClearPrice = context.dic[\"IC\"][0]\n if (context.PositionAddedTime == 1):\n print(-(context.LegOnePositionEntryPrice[1] - context.PositionClearPrice))\n elif (context.PositionAddedTime == 2):\n print(-(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[\n 2] - 2 * context.PositionClearPrice))\n elif (context.PositionAddedTime == 3):\n print(-(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] +\n context.LegOnePositionEntryPrice[3] - 3 * context.PositionClearPrice))\n elif (context.PositionAddedTime == 4):\n print(-(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] +\n context.LegOnePositionEntryPrice[3] + context.LegOnePositionEntryPrice[\n 4] - 4 * context.PositionClearPrice))\n context.LegOnePositionEntryPrice = {}\n context.PositionEntryPrice = {}\n # context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][1], abs(context.PositionAddedTime), Direction.BUY, OpenClose.CLOSE)\n context.PositionAddedTime = 0\n context.q.sync(\"update Position:0 from `CombinedMainContract where Date = max Date\")\n if ((abs(\n context.PositionAddedTime) == 3) and context.PositionTimesParameter >= 4 and context.PairDataBarAskPrice1Close >\n context.PositionEntryPrice[1] + 3 * context.NEntryParameter * context.Nvalue):\n context.PositionAddedTime = 4\n context.LegOnePositionEntryPrice[4] = context.dic[\"IC\"][1]\n context.PositionEntryPrice[4] = context.PairDataBarAskPrice1Close\n print(\"Pos4: \" + str(context.dic[\"IC\"][1]))\n # context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][1], 1, Direction.SELL, OpenClose.OPEN)\n context.q.sync(\"update Position:4 from `CombinedMainContract where Date = max Date\")\n if ((abs(\n context.PositionAddedTime) == 2) and context.PositionTimesParameter >= 3 and context.PairDataBarAskPrice1Close >\n context.PositionEntryPrice[1] + 2 * context.NEntryParameter * context.Nvalue):\n context.PositionAddedTime = 3\n context.LegOnePositionEntryPrice[3] = context.dic[\"IC\"][1]\n context.PositionEntryPrice[3] = context.PairDataBarAskPrice1Close\n print(\"Pos3: \" + str(context.dic[\"IC\"][1]))\n context.q.sync(\"update Position:3 from `CombinedMainContract where Date = max Date\")\n # context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][1], 1, Direction.SELL, OpenClose.OPEN)\n if ((abs(\n context.PositionAddedTime) == 1) and context.PositionTimesParameter >= 2 and context.PairDataBarAskPrice1Close >\n context.PositionEntryPrice[1] + 1 * context.NEntryParameter * context.Nvalue):\n context.PositionAddedTime = 2\n context.LegOnePositionEntryPrice[2] = context.dic[\"IC\"][1]\n context.PositionEntryPrice[2] = context.PairDataBarAskPrice1Close\n print(\"Pos2: \" + str(context.dic[\"IC\"][1]))\n # context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][1], 1, Direction.SELL, OpenClose.OPEN)\n context.q.sync(\"update Position:2 from `CombinedMainContract where Date = max Date\")\n if ((abs(\n context.PositionAddedTime) == 0) and context.PositionTimesParameter >= 1 and context.PairDataBarAskPrice1Close > context.PairDataBarLongEntry + 0 * context.NEntryParameter * context.Nvalue):\n context.PositionAddedTime = 1\n context.LegOnePositionEntryPrice[1] = context.dic[\"IC\"][1]\n context.PositionEntryPrice[1] = context.PairDataBarAskPrice1Close\n print(\"Pos1: \" + str(str(context.dic[\"IC\"][1])))\n context.Nvalue = context.PairDataBarN\n context.q.sync(\"update Position:1 from `CombinedMainContract where Date = max Date\")\n # context.order.send_single_order(context.symboldic[\"IC\"], context.dic[\"IC\"][1], 1, Direction.SELL, OpenClose.OPEN)","def __init__(self,start_date,end_date,param_name,context_name,param_value):\n self.start_date = start_date\n self.end_date = end_date\n self.param_name = param_name\n self.context_name = context_name\n self.param_value = param_value","def get_current_date():\n return datetime.datetime.today().strftime(constants.DATE_FORMAT)","def default_date(self):\n return datetime.datetime.now().strftime('%Y-%m-%d')","def __init__(self, current_user, produce_name, quantity, price_range):\n self.current_user = current_user\n self.produce_name = produce_name\n self.quantity = quantity\n self.price_range = price_range\n self.date_created = datetime.datetime.utcnow()\n self.date_modified = datetime.datetime.utcnow()","def declare_new_budget(date, exp_data):\n\n exp_list = exp_data[env.EXPENSE_DATA_KEY]\n local_budget = {}\n month_total = util.get_float_input(\n f\"Please input your total for the month ending {date}: \", force_pos=True)\n budg_remaining = month_total\n\n for i, exp in enumerate(exp_list):\n if i == len(exp_list) - 1:\n print(\"I got the last one for you :) MATH!\")\n budg_amnt = budg_remaining\n budg_remaining = 0\n\n elif budg_remaining == 0: # elif skips this condition if budget remaining is set above\n budg_amnt = 0\n local_budget[env.BUDGET_TOTAL_KEY] = month_total\n else:\n prompt = f\"Enter your budget for: [{exp}] - Total Budget Re. ${budg_remaining} - Exp's Re. [{len(exp_list) - i - 1}]: \"\n budg_amnt = prompt_for_budget_amnt(\n prompt, budg_remaining, exp_data)\n local_budget.update({exp: budg_amnt})\n budg_remaining = round(month_total - sum_budget(local_budget), 2)\n print(local_budget)\n return local_budget","async def dailytomorrow(self, ctx):\n if ctx.invoked_subcommand is None:\n await ctx.send_help(ctx.command)","def updateToday(tradingDay):\n if date.today() != tradingDay.today:\n tradingDay = TradingDay(tradingDay.contractDetails)\n\n if tradingDay.isMarketOpen():\n if not tradingDay.marketOpen:\n tradingDay.marketOpen = True\n console().info(\"The Market Has Opened\")\n else:\n if tradingDay.marketOpen:\n tradingDay.marketOpen = False\n console().info(\"The Market Has Closed\")\n return tradingDay","def qToday():\n \n return _qDate.todaysDate().ISO()","def test_2_default_start_date(self):\n date = FeaturedCommunity.query.get(2).start_date.date()\n self.assertEqual(date, datetime.date.today())","def date_options(func):\n @click.option(\n '--until', type=Date(), help=\"Only show entries until the given date.\"\n )\n @click.option(\n '--since', type=Date(), help=\"Only show entries starting at the given date.\",\n )\n @click.option(\n '--today/--not-today', default=None, help=\"Only include today's entries (same as --since=today --until=today)\"\n \" or ignore today's entries (same as --until=yesterday)\"\n )\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n since, until, today = kwargs.pop('since'), kwargs.pop('until'), kwargs.pop('today')\n\n if today is not None:\n if today:\n date = datetime.date.today()\n else:\n date = (None, datetime.date.today() - datetime.timedelta(days=1))\n elif since is not None or until is not None:\n date = (since, until)\n else:\n date = None\n\n kwargs['date'] = date\n\n return func(*args, **kwargs)\n\n return wrapper","def _rate_dates(self, common_object):\n if common_object.IsKindOf(acm.FCashFlow):\n start_date = common_object.StartDate()\n elif common_object.IsKindOf(acm.FReset):\n start_date = common_object.Day()\n else:\n message = \"Rate dates for {0} object are not defined\".format(\n type(common_object))\n raise ProvisionHandlerError(message)\n\n end_date = acm.Time().DateAddDelta(start_date, 0, 3, 0)\n end_date = self._adjust_to_banking_day(end_date)\n\n return (start_date, end_date)","def retirement_main(g:argparse.Namespace) -> tuple: \n now = datetime.date.today()\n\n # Only the most cursory checking.\n if not g.birthday < g.hiredate < now: \n print(\"\\n\".join([\"you must have been born before you were hired,\",\n \"and you must have been hired before today.\"]))\n sys.exit(os.EX_DATAERR)\n \n current_age = now - g.birthday\n current_service = now - g.hiredate\n\n old_enough_on = g.birthday + rdelta(years=g.min_age)\n old_enough_now = old_enough_on < now\n long_enough_on = g.hiredate + rdelta(years=g.req_years)\n long_enough_now = long_enough_on < now\n\n if long_enough_now and old_enough_now:\n return now, 0, old_enough_on, long_enough_on, current_age.days, current_service.days\n \n no_earlier_than = max(long_enough_on, old_enough_on)\n magic_date = now + rdelta(rdelta(years=g.magic_number) - rdelta(current_age) - rdelta(current_service))/2\n quit_on = max(magic_date, no_earlier_than)\n\n if old_enough_on < g.hiredate: \n old_enough_on = 'when you started.'\n elif old_enough_on < now: \n old_enough_on = 'now'\n if long_enough_on < now: \n long_enough_on = 'now'\n\n return quit_on, (quit_on - now).days, old_enough_on, long_enough_on, current_age.days, current_service.days","def clean_expiration_date(self):\n expiration_date = self.cleaned_data['expiration_date']\n if expiration_date.date() <= datetime.date.today():\n v_err('elapsed')\n return expiration_date","def get_current_datetime ( ) :\n return datetime.datetime.now( )","def set_from_date_as_current_date(self):\n self.set_value_into_input_field(self.set_from_date_locator, self.get_current_date())","def currentDate(returnType='tuple'):\n from datetime import datetime\n if returnType == 'tuple':\n return (datetime.now().month, datetime.now().day, datetime.now().year)\n elif returnType == 'list':\n return [datetime.now().month, datetime.now().day, datetime.now().year]\n\n return {\n 'day':datetime.now().day,\n 'month':datetime.now().month,\n 'year':datetime.now().year\n }","def __init__(self):\n self.annual_interest_rate = 10.0 / 100.0\n self.initial_loan_date = date(2014, 12, 1)\n self.currency = 'HKD'\n self.total_loan_amount = Money('100000.00', 'HKD')\n self.final_payment_date = self.initial_loan_date + \\\n relativedelta(years=1)","def get_today():\n global endDate\n check_today=date_trans_x(time.strftime(\"%Y.%m.%d\"))\n if(get_article_ammount(check_today,True)>0): \n diff=datetime.strptime(check_today,'%Y.%m.%d')-datetime.strptime(endDate,'%Y.%m.%d')\n if(diff.total_seconds()>=0):\n endDate=check_today\n print \"get_today : \"+ check_today\n return check_today\n else:\n print \"get_today : \"+ endDate\n return endDate","def tickets(number, day, premium_seating):\n #fill in your code here. \n return 0.0","def initialize(context):\n # Rebalance every day, 1 hour after market open.\n set_slippage(slippage.FixedSlippage(spread=0.00))\n set_commission(commission.PerShare(cost=0.0, min_trade_cost=0.0))\n context.lookback = 60\n context.leverage = 0.02\n context.day = 1\n #context.ETFs = []\n context.market = [symbol('SPY')]\n context.bo = 1.25\n context.so = 1.25\n context.bc = 0.75\n context.sc = 0.5\n context.stocks = []\n context.initialized = False\n context.holding_book_shares = None\n context.order_hist = {}\n \n context.xlb = symbol('XLB') #sid(19654) #Materials 101\n context.xly = symbol('XLY') #sid(19662) #Consumer Discretionary 102\n context.xlf = symbol('XLF') #sid(19656) #Financials 103\n context.xlre = symbol('IYR') #sid() #Real estate 104\n context.xlp = symbol('XLP') #sid(19659) #Consumer Staples 205\n context.xlv = symbol('XLV') #sid(19661) #Health Care 206\n context.xlu = symbol('XLU') #sid(19660) #Utilities 207\n context.xtl = symbol('IYZ') #sid() #Communication Services 308\n context.xle = symbol('XLE') #sid(19655) #Energy 309\n context.xli = symbol('XLI') #sid(19657) #Industrials 310\n context.xlk = symbol('XLK') #sid(19658) #Technology 311\n \n context.ETF_lookup = {context.xlb:101, 101:context.xlb,\n context.xly:102, 102:context.xly,\n context.xlf:103, 103:context.xlf,\n context.xlre:104, 104:context.xlre,\n context.xlp:205, 205: context.xlp,\n context.xlv:206, 206: context.xlv,\n context.xlu:207, 207:context.xlu,\n context.xtl:308, 308:context.xtl,\n context.xle:309, 309:context.xle,\n context.xli:310, 310:context.xli,\n context.xlk:311, 311:context.xlk}\n\n context.ETFs = [context.xlb,\n context.xly,\n context.xlf,\n context.xlre,\n context.xlp,\n context.xlv,\n context.xlu,\n context.xtl,\n context.xle,\n context.xli,\n context.xlk\n ]","def test_startdate(self):\n req = create_request(query_string={'dates': '7d'})\n eq_(startdate(req), date.today() - timedelta(days=7))\n\n req = create_request(query_string={'dates': 'today'})\n eq_(startdate(req), date.today())\n\n req = create_request(query_string={'day': '2012-05-24'})\n eq_(startdate(req), datetime(2012, 5, 24))\n\n req = create_request(query_string={'week': '2012-05-24'})\n eq_(startdate(req), datetime(2012, 5, 21))\n\n req = create_request(query_string={'day': 'today'})\n eq_(startdate(req), None)\n\n req = create_request()\n eq_(startdate(req), None)","def current_datetime(self):\n return DateAccessor().today()","def getDate(self): # real signature unknown; restored from __doc__\r\n pass","def onchange_amount(self, cr, uid, ids, amount, rate, partner_id, journal_id, currency_id, ttype, date, payment_rate_currency_id, company_id, context=None):\n if not context:\n context = {}\n default = super(account_voucher, self).onchange_amount(cr, uid, ids, amount, rate, partner_id, journal_id, currency_id, ttype, date, payment_rate_currency_id, company_id, context=context)\n if 'value' in default:\n amount = 'amount' in default['value'] and default['value']['amount'] or amount\n amount_in_word = amount_to_text(amount)\n default['value'].update({'amount_in_word':amount_in_word})\n if journal_id:\n allow_check_writing = self.pool.get('account.journal').browse(cr, uid, journal_id, context=context).allow_check_writing\n default['value'].update({'allow_check':allow_check_writing})\n return default","def get_context_data(self, **kwargs):\n context = super(LoginRequiredMixin, self).get_context_data(**kwargs)\n date = self.get_date()\n context['date'] = date\n context['prev_date'] = date - datetime.timedelta(days=1)\n context['next_date'] = date + datetime.timedelta(days=1)\n form_class = self.get_form_class()\n context['form'] = self.get_form(form_class)\n context['progress'] = self.get_percent_completed()\n return context","def test_handler_date_fail(self):\n\n @intent_handler(False)\n def decorated_test(date: datetime.date):\n return date\n\n r = create_request(\"TEST_CONTEXT\", date=[\"not a date\"])\n with self.assertRaises(EntityValueException):\n result = decorated_test(r)","def EstimateFee(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def __get_settlement_date():\n day_after_tomorrow = datetime.now(timezone.utc).date() + \\\n timedelta(days=2)\n settlement_date = day_after_tomorrow.strftime(\"%Y%m%d\")\n\n return settlement_date","def today(cls):\n return date()","def expense_history(request):\n qs: QuerySet = Expense.objects.by_user(request.user.id)\n file_title: str = \"Latest_150_Expenses\"\n form = ExpenseHistory(request.GET)\n if form.is_valid():\n cd: dict = form.cleaned_data\n target: str = cd[\"target\"]\n user_id = request.user.id\n if target == \"date\":\n qs = Expense.objects.filter(date=cd[\"date1\"], user_id=user_id)\n file_title = f'For_{cd[\"date1\"]}'\n elif target == \"each_month\":\n qs = Expense.objects.filter(date__month=cd[\"month\"], user_id=user_id)\n file_title = f\"Every_{calendar.month_name[cd['month']]}_Month\"\n elif target == \"months\":\n qs = Expense.objects.last_n_months_expense(cd[\"p_months\"], user_id)\n file_title = f\"Last_{cd['p_months']}_months\"\n elif target == \"month\":\n qs = Expense.objects.month_expense(cd[\"month\"], cd[\"year\"], user_id)\n file_title = f'For_{calendar.month_name[cd[\"month\"]]}-{cd[\"year\"]}'\n elif target == \"year\":\n qs = Expense.objects.year_expense(cd[\"year\"], user_id)\n file_title = f\"{cd['year']}\"\n elif target == \"between\":\n qs = Expense.objects.filter(date__gte=cd[\"date1\"], date__lte=cd[\"date2\"],\n user__id=user_id)\n file_title = f'Between_{cd[\"date1\"]}_{cd[\"date2\"]}'\n qs = qs.order_by(\"-date\", \"-id\").values_list(\n \"date\", \"description\", \"category__name\", \"method\", \"app\", \"amount\",\n )\n if not form.is_valid():\n qs = qs[:150]\n qs_list = []\n if qs:\n for q in qs:\n qs_list.append([\n q[0], q[1], q[2], METHOD_DICT[q[3]], APP_DICT.get(q[4], \"Other\"), q[5]\n ])\n file_title = f\"{date.today()}_\" + file_title\n return render(request, \"tracker/history.html\",\n {\"qs\": qs_list, \"file_title\": file_title, \"form\": form})","def _request_current_prices(self) -> None:\n\n self._request_contract_state(\n contract_name=self.token_contract_mapping[self.last],\n callable_=\"get_latest_answer\",\n parameters={},\n )\n if self.last == \"BTC\":\n self.last = \"ETH\"\n else:\n self.last = \"BTC\"","def _set_current_prices(self) -> None:\n strategy = cast(Strategy, self.context.strategy)\n eth_price = strategy.contract_status.get(\n \"priceprovider_get_latest_answer\", None\n )\n btc_price = strategy.contract_status.get(\n \"btcpriceprovider_get_latest_answer\", None\n )\n\n if eth_price is None or btc_price is None:\n self.context.logger.info(\"No price to store.....\")\n return\n self._current_price = {\n ETH: self._get_price(eth_price),\n BTC: self._get_price(btc_price),\n }","async def payday(self, ctx: commands.Context):\r\n author = ctx.author\r\n guild = ctx.guild\r\n\r\n cur_time = calendar.timegm(ctx.message.created_at.utctimetuple())\r\n credits_name = await bank.get_currency_name(ctx.guild)\r\n if await bank.is_global(): # Role payouts will not be used\r\n\r\n # Gets the latest time the user used the command successfully and adds the global payday time\r\n next_payday = (\r\n await self.config.user(author).next_payday() + await self.config.PAYDAY_TIME()\r\n )\r\n if cur_time >= next_payday:\r\n try:\r\n await bank.deposit_credits(author, await self.config.PAYDAY_CREDITS())\r\n except errors.BalanceTooHigh as exc:\r\n await bank.set_balance(author, exc.max_balance)\r\n await ctx.send(\r\n _(\r\n \"You've reached the maximum amount of {currency}!\"\r\n \"Please spend some more \\N{GRIMACING FACE}\\n\\n\"\r\n \"You currently have {new_balance} {currency}.\"\r\n ).format(\r\n currency=credits_name, new_balance=humanize_number(exc.max_balance)\r\n )\r\n )\r\n return\r\n # Sets the current time as the latest payday\r\n await self.config.user(author).next_payday.set(cur_time)\r\n\r\n pos = await bank.get_leaderboard_position(author)\r\n embed = Embed.create(\r\n self, ctx, title=\"<:dollarbag:778687019944771616> Payday!\",\r\n description=(\r\n \"Here you go, {author.name}. \"\r\n \"Don't spend it too quickly!\\n\\n\"\r\n \"<:plus:777167188816560168> {amount} dollars have been added to your bank.\\n\"\r\n \"You now have {new_balance} dollars. <:dollarbag:778687019944771616>\\n\\n\"\r\n \"You are currently #{pos} on the **global** leaderboard!\\n\"\r\n \"Use `dem leaderboard` to review your position further.\\n\"\r\n \"Use `dem slot <bid>` to take a gamble at the slot machine!\"\r\n ).format(\r\n author=author,\r\n currency=credits_name,\r\n amount=humanize_number(await self.config.PAYDAY_CREDITS()),\r\n new_balance=humanize_number(await bank.get_balance(author)),\r\n pos=humanize_number(pos)\r\n )\r\n )\r\n await ctx.send(embed=embed)\r\n\r\n else:\r\n dtime = self.display_time(next_payday - cur_time)\r\n await ctx.send(\r\n _(\r\n \"{author.mention} Too soon. For your next payday you have to wait {time}.\"\r\n ).format(author=author, time=dtime)\r\n )\r\n else:\r\n\r\n # Gets the users latest successfully payday and adds the guilds payday time\r\n next_payday = (\r\n await self.config.member(author).next_payday()\r\n + await self.config.guild(guild).PAYDAY_TIME()\r\n )\r\n if cur_time >= next_payday:\r\n credit_amount = await self.config.guild(guild).PAYDAY_CREDITS()\r\n for role in author.roles:\r\n role_credits = await self.config.role(\r\n role\r\n ).PAYDAY_CREDITS() # Nice variable name\r\n if role_credits > credit_amount:\r\n credit_amount = role_credits\r\n try:\r\n await bank.deposit_credits(author, credit_amount)\r\n except errors.BalanceTooHigh as exc:\r\n await bank.set_balance(author, exc.max_balance)\r\n await ctx.send(\r\n _(\r\n \"You've reached the maximum amount of {currency}! \"\r\n \"Please spend some more \\N{GRIMACING FACE}\\n\\n\"\r\n \"You currently have {new_balance} {currency}.\"\r\n ).format(\r\n currency=credits_name, new_balance=humanize_number(exc.max_balance)\r\n )\r\n )\r\n return\r\n\r\n # Sets the latest payday time to the current time\r\n next_payday = cur_time\r\n\r\n await self.config.member(author).next_payday.set(next_payday)\r\n \r\n pos = await bank.get_leaderboard_position(author)\r\n embed = Embed.create(\r\n self, ctx, title=\"<:dollarbag:778687019944771616> Payday!\",\r\n description=(\r\n \"{author.mention} Take a loada' cash. \"\r\n \"Don't spend it took quick!\\n\\n\"\r\n \"<:plus:777167188816560168> {amount} dollars have been added to your bank.\\n\"\r\n \"You now have {new_balance} dollars. <:dollarbag:778687019944771616>\\n\\n\"\r\n \"You are currently #{pos} on the server leaderboard!\"\r\n ).format(\r\n author=author,\r\n currency=credits_name,\r\n amount=humanize_number(await self.config.PAYDAY_CREDITS()),\r\n new_balance=humanize_number(await bank.get_balance(author)),\r\n pos=humanize_number(pos)\r\n )\r\n )\r\n await ctx.send(embed=embed)\r\n \r\n else:\r\n dtime = self.display_time(next_payday - cur_time)\r\n await ctx.send(\r\n _(\r\n \"{author.mention} Too soon. For your next payday you have to wait {time}.\"\r\n ).format(author=author, time=dtime)\r\n )","def test_GET_startdate(self):\n self.register_user()\n result = self.login_user()\n access_token = json.loads(result.data.decode())['access_token']\n res = self.client().post('/expenses/', headers=dict(Authorization=\"Bearer \" + access_token), data=self.expense)\n self.assertEqual(res.status_code, 201)\n rv = self.client().post('/expenses/', headers=dict(Authorization=\"Bearer \" + access_token), data=\n {'name': 'soda', 'amount': 1122, 'date_of_expense': '10-01-2021'})\n self.assertEqual(rv.status_code, 201)\n resl = self.client().get('/expenses/?start_date=01-01-2021', headers=dict(Authorization=\"Bearer \" + access_token))\n self.assertEqual(resl.status_code, 200)\n results = json.loads(resl.data)\n self.assertEqual(results['items'][0]['date_of_expense'], self.expense['date_of_expense'])","def _get_amount_value(\n self, cr, uid, ids, ifrs_line=None, period_info=None,\n fiscalyear=None, exchange_date=None, currency_wizard=None,\n number_month=None, target_move=None, pdx=None, undefined=None,\n two=None, one_per=False, bag=None, context=None):\n\n context = context and dict(context) or {}\n # TODO: Current Company's Currency shall be used: the one on wizard\n from_currency_id = ifrs_line.ifrs_id.company_id.currency_id.id\n to_currency_id = currency_wizard\n\n if number_month:\n if two:\n context = {\n 'period_from': number_month, 'period_to': number_month}\n else:\n period_id = period_info[number_month][1]\n context = {'period_from': period_id, 'period_to': period_id}\n else:\n context = {'whole_fy': True}\n\n # NOTE: This feature is not yet been implemented\n # context['partner_detail'] = pdx\n context['fiscalyear'] = fiscalyear\n context['state'] = target_move\n\n if ifrs_line.type == 'detail':\n res = self._get_sum_detail(\n cr, uid, ifrs_line.id, number_month,\n context=context)\n elif ifrs_line.type == 'total':\n res = self._get_grand_total(\n cr, uid, ifrs_line.id, number_month,\n one_per=one_per, bag=bag, context=context)\n elif ifrs_line.type == 'constant':\n res = self._get_constant(cr, uid, ifrs_line.id, number_month,\n context=context)\n else:\n res = 0.0\n\n if ifrs_line.type == 'detail':\n res = self.exchange(\n cr, uid, ids, res, to_currency_id, from_currency_id,\n exchange_date, context=context)\n return res","def current_valid_date(self):\r\n return datetime.datetime.now().strftime('%Y-%m-%d')","def getAmount1(*args):","def getAmount2(*args):","def set_non_recurring_charge_begin_date(self, begin_date):\n if begin_date is None:\n statement_summary_begin_date_element = self.wait().until(EC.presence_of_element_located(self.statement_details_begin_date_locator), 'statement details begin date locator not found before specified time out')\n non_recurring_charge_begin_date = str(statement_summary_begin_date_element.text)\n elif begin_date == \"\":\n current_date = datetime.date.today()\n non_recurring_charge_begin_date = \"%d/%d/%d\" % (current_date.month, current_date.day, current_date.year)\n else:\n non_recurring_charge_begin_date = begin_date\n self.set_value_into_input_field(self.non_recurring_charge_begin_date_locator, non_recurring_charge_begin_date)\n return non_recurring_charge_begin_date","async def daily(self, ctx):\n if ctx.invoked_subcommand is None:\n await ctx.send_help(ctx.command)","def __init__(self, period=None, date=None):\r\n self.period = period\r\n self.date = date","def buy_stock(self, stock, amount, date=None):\n if date is None:\n date = self.date\n\n if type(date) is not datetime.datetime and type(date) is not pd.tslib.Timestamp:\n date = datetime.datetime.strptime(date, \"%Y-%m-%d\")\n\n self.order_stock(stock, self.stock_data[stock].position['Position'][date] + amount, date)","def PricingAddSettlementDate(builder, settlementDate):\n return AddSettlementDate(builder, settlementDate)","def post_date(context, *args, **kwargs):\n obj = context['object']\n date_format = kwargs.get('format', \"l j, F\")\n return date(obj.publication_date, date_format)","def getdate():\r\n import datetime\r\n return datetime.datetime.now()","def _determine_types(self):\n try:\n self.date = parse(self.kwargs.get('date'))\n self.description = self.kwargs.get('description').strip()\n self.amount = Decimal(self.kwargs.get('amount'))\n self.checksum = hashlib.md5(u''.join(self.kwargs.values())\n .encode('utf-8')).digest()\n except (ValueError, InvalidOperation) as e:\n raise InvalidTransaction(\"Can't make a transaction from {0} - {1}\"\n .format(self.kwargs, e))","def initialize(context):\n context.stocks = {symbol(\"TMF\"): 0.2, symbol(\"UJB\"): 0.2, symbol(\"TQQQ\"): 0.6}\n\n context.target_leverage = 1\n\n schedule_function(\n rebalance, date_rules.every_day(), time_rules.market_open(minutes=11)\n )","def before_trading_start(context, data):","async def paydayamount(self, ctx: commands.Context, creds: int):\r\n guild = ctx.guild\r\n max_balance = await bank.get_max_balance(ctx.guild)\r\n if creds <= 0 or creds > max_balance:\r\n return await ctx.send(\r\n _(\"Amount must be greater than zero and less than {maxbal}.\").format(\r\n maxbal=humanize_number(max_balance)\r\n )\r\n )\r\n credits_name = await bank.get_currency_name(guild)\r\n if await bank.is_global():\r\n await self.config.PAYDAY_CREDITS.set(creds)\r\n else:\r\n await self.config.guild(guild).PAYDAY_CREDITS.set(creds)\r\n await ctx.send(\r\n _(\"Every payday will now give {num} {currency}.\").format(\r\n num=humanize_number(creds), currency=credits_name\r\n )\r\n )","def test_add_flow_request_only_one_validity_date_provided(self):\n for param in ('start_validity', 'expire_validity'):\n flow_request = self.flow_request.copy()\n del flow_request['start_validity']\n res = self._add_flow_request(flow_request=flow_request)","def date():\r\n try:\r\n curr_date = datetime.datetime.now().strftime(\"%b %d %Y\")\r\n except Exception as e:\r\n print(e)\r\n curr_date = False\r\n return curr_date","def _check_date_not_in_future(self, date):\n if date is None:\n pass\n else:\n assert (\n date <= datetime.datetime.now()\n ), \"Provided date cannot be in the future\"","def check_today(self):\n import time\n _time = time.time\n time.time = lambda: 1003539807.89\n try:\n assert Date(\"today\") == Date(\"10/19/2001\"), \"wrong date\"\n finally:\n time.time = _time","def __init__(self, value=None, date=None):\n self.value = value\n self.date = date","def getDefaultCurrency():","async def daily(self, ctx: commands.Context):\n self.check_if_exist(ctx.guild)\n\n if ctx.invoked_subcommand == None:\n await ctx.reply(\"Options: `channel`, `timezone`, `ping`\")","def today(self):\n return(datetime.date.today().isoformat())","def do_fee(self,args):\n totalamount,fee,howmanyto,nexttier = bitstamp.fee_schedule()\n print \"Your 30 day volume is: %.5f. Your trade fee is: %.2f%%\" % (totalamount,fee)\n print \"You are $%s away from the next tier of: $%s\" % (howmanyto,nexttier)","def date(self):","def db_date():\n return datetime.datetime.now()","def __init__(self, name=\"\", date=None):\n super().__init__(\"date\", name)\n self.date = date","def check_date(date):\n\timport datetime\n\tif date < datetime.date.today():\n\t\treturn date\n\telse:\n\t\treturn datetime.date.today()","def today():\n request_today = request.date\n today = datetime.date.today()\n print(request.headers, request.url)\n print(request_today)\n print(today)\n day = today.day\n month = today.month\n holidays = holidays_date(month, day)\n\n return jsonify({\"day\": day, \"month\": month, \"holidays\": [h.holiday for h in holidays]})","def make_instance(self, include_optional):\n # model = openapi_client.models.todays.Todays() # noqa: E501\n if include_optional :\n return Todays(\n instrumentToken = 56, \n normal = 1.337, \n supermultiple = 1.337, \n mtf = 1.337, \n actualNetTrdValue = 1.337, \n averageStockPrice = 1.337, \n buyOpenQtyLot = 56, \n buyOpenVal = 1.337, \n buyTradedQtyLot = 56, \n buyTradedVal = 1.337, \n buyTrdAvg = 1.337, \n deliveryStatus = 56, \n denominator = 56, \n exchange = '0', \n exposureMargin = 56, \n exposureMarginTotal = 56, \n grossUtilization = 1.337, \n instrumentName = '0', \n lastPrice = 1.337, \n marginType = '0', \n maxCODQty = 56, \n multiplier = 56, \n netTrdQtyLot = 56, \n netTrdValue = 1.337, \n normalSqOffQty = 1.337, \n premium = 1.337, \n rbiRefRate = 56, \n realizedPL = 1.337, \n sellOpenQtyLot = 56, \n sellOpenVal = 56, \n sellTradedQtyLot = 56, \n sellTradedVal = 56, \n sellTrdAvg = 1.337, \n spanMargin = 56, \n spanMarginTotal = 1.337, \n spreadTotal = 1.337, \n totalStock = 56\n )\n else :\n return Todays(\n )","def new_tx(new_trade):\n try:\n assert(len(new_trade) == 2)\n tx_date = dt.date.fromisoformat(new_trade[0])\n amt = float(new_trade[1])\n except:\n raise Exception(\n \"Transaction must be in list format as\"\n + \" an array of string (valid date of transaction\"\n + \" before today) and float (amount invested):\"\n + \" [YYYY-MM-DD, amount].\"\n )\n return [tx_date, amt]","def on_date(self, date):\n print 'This is an empty on_date(date={}) function.\\nThe user must override this.'.format(date)\n return self","def clean_date(self):\r\n from datetime import datetime\r\n\r\n date = self.cleaned_data[\"date\"]\r\n if date < datetime.now():\r\n self.add_error(\"date\", \"You cannot add a date for the past.\")\r\n return date","def withdraw(self, currency, amount, address):\n pass","def __init__(self, amount: int, currency: str):\n self._amount = amount\n self._currency = currency","def get_amount(self):\n\t\tif self.amount is not None:\n\t\t\treturn self.amount\n\t\treturn abort(400, {\"message\" : \"please provide the amount to process\"})"],"string":"[\n \"def get_today():\\n return datetime.today()\",\n \"def get_today_date():\\n return date.today()\",\n \"def _today() -> datetime.date:\\n return datetime.today().date()\",\n \"def get_today() -> datetime.date:\\n return datetime.date.today()\",\n \"def today():\\n return date.today()\",\n \"def today():\\n return datetime.today()\",\n \"async def daily(self, ctx):\\r\\n # TODO: Asssess whether this can be cleaned up. \\r\\n # As it stands, very similar to inv()\\r\\n author = ctx.author\\r\\n with DB() as db:\\r\\n company = await self.get_active_company(ctx, db, author)\\r\\n stock = self.iex.get_held_stocks(db, company.id)\\r\\n inventory = []\\r\\n for s in stock:\\r\\n close = await self.get_latest_close(ctx, db, s.symbol)\\r\\n inventory.append([s.symbol, s.quantity, s.purchase_price, close.close, s.quantity*close.close - s.quantity*s.purchase_price ]) \\r\\n inv_df = pd.DataFrame(inventory, columns=['Symbol', 'Quantity', 'Purchase Price', 'Close', 'Current Value'])\\r\\n inv_df['sign'] = np.where(inv_df['Current Value']>=0, '+', '-')\\r\\n inv_df['%'] = abs(((inv_df['Close'] - inv_df['Purchase Price']) / inv_df['Purchase Price']) * 100)\\r\\n inv_df['%'] = inv_df['%'].round(1)\\r\\n inv_df = inv_df.sort_values(['Symbol'])\\r\\n inv_df = inv_df[['sign', '%', 'Symbol', 'Quantity', 'Purchase Price', 'Close', 'Current Value']]\\r\\n aggregated = tabulate(inv_df.values.tolist(), headers=['Δ', '%', 'Symbol', 'Quantity', 'Purchase Price', 'Close', 'Current Value'])\\r\\n await ctx.send(f'```diff\\\\n{aggregated}```')\",\n \"def _get_date():\\n return datetime.datetime.now()\",\n \"def __init__(self,\\r\\n available_balance_amount=None,\\r\\n posted_date=None,\\r\\n open_date=None,\\r\\n period_start_date=None,\\r\\n period_end_date=None,\\r\\n period_interest_rate=None,\\r\\n period_deposit_amount=None,\\r\\n period_interest_amount=None,\\r\\n interest_ytd_amount=None,\\r\\n interest_prior_ytd_amount=None,\\r\\n maturity_date=None,\\r\\n interest_rate=None,\\r\\n credit_available_amount=None,\\r\\n credit_max_amount=None,\\r\\n cash_advance_available_amount=None,\\r\\n cash_advance_max_amount=None,\\r\\n cash_advance_balance=None,\\r\\n cash_advance_interest_rate=None,\\r\\n current_balance=None,\\r\\n payment_min_amount=None,\\r\\n payment_due_date=None,\\r\\n previous_balance=None,\\r\\n statement_start_date=None,\\r\\n statement_end_date=None,\\r\\n statement_purchase_amount=None,\\r\\n statement_finance_amount=None,\\r\\n statement_credit_amount=None,\\r\\n reward_earned_balance=None,\\r\\n past_due_amount=None,\\r\\n last_payment_amount=None,\\r\\n last_payment_date=None,\\r\\n statement_close_balance=None,\\r\\n term_of_ml=None,\\r\\n ml_holder_name=None,\\r\\n description=None,\\r\\n late_fee_amount=None,\\r\\n payoff_amount=None,\\r\\n payoff_amount_date=None,\\r\\n original_maturity_date=None,\\r\\n principal_balance=None,\\r\\n escrow_balance=None,\\r\\n interest_period=None,\\r\\n initial_ml_amount=None,\\r\\n initial_ml_date=None,\\r\\n next_payment_principal_amount=None,\\r\\n next_payment_interest_amount=None,\\r\\n next_payment=None,\\r\\n next_payment_date=None,\\r\\n last_payment_due_date=None,\\r\\n last_payment_receive_date=None,\\r\\n last_payment_principal_amount=None,\\r\\n last_payment_interest_amount=None,\\r\\n last_payment_escrow_amount=None,\\r\\n last_payment_last_fee_amount=None,\\r\\n last_payment_late_charge=None,\\r\\n ytd_principal_paid=None,\\r\\n ytd_interest_paid=None,\\r\\n ytd_insurance_paid=None,\\r\\n ytd_tax_paid=None,\\r\\n auto_pay_enrolled=None,\\r\\n collateral=None,\\r\\n current_school=None,\\r\\n first_payment_date=None,\\r\\n first_mortgage=None,\\r\\n loan_payment_freq=None,\\r\\n original_school=None,\\r\\n recurring_payment_amount=None,\\r\\n lender=None,\\r\\n ending_balance_amount=None,\\r\\n loan_term_type=None,\\r\\n payments_made=None,\\r\\n balloon_amount=None,\\r\\n projected_interest=None,\\r\\n interest_paid_ltd=None,\\r\\n interest_rate_type=None,\\r\\n loan_payment_type=None,\\r\\n repayment_plan=None,\\r\\n payments_remaining=None,\\r\\n interest_margin_balance=None,\\r\\n short_balance=None,\\r\\n available_cash_balance=None,\\r\\n maturity_value_amount=None,\\r\\n vested_balance=None,\\r\\n emp_match_amount=None,\\r\\n emp_pretax_contrib_amount=None,\\r\\n emp_pretax_contrib_amount_ytd=None,\\r\\n contrib_total_ytd=None,\\r\\n cash_balance_amount=None,\\r\\n pre_tax_amount=None,\\r\\n after_tax_amount=None,\\r\\n match_amount=None,\\r\\n profit_sharing_amount=None,\\r\\n rollover_amount=None,\\r\\n other_vest_amount=None,\\r\\n other_nonvest_amount=None,\\r\\n current_loan_balance=None,\\r\\n loan_rate=None,\\r\\n buy_power=None,\\r\\n rollover_ltd=None,\\r\\n additional_properties = {}):\\r\\n\\r\\n # Initialize members of the class\\r\\n self.posted_date = posted_date\\r\\n self.available_balance_amount = available_balance_amount\\r\\n self.open_date = open_date\\r\\n self.period_start_date = period_start_date\\r\\n self.period_end_date = period_end_date\\r\\n self.period_interest_rate = period_interest_rate\\r\\n self.period_deposit_amount = period_deposit_amount\\r\\n self.period_interest_amount = period_interest_amount\\r\\n self.interest_ytd_amount = interest_ytd_amount\\r\\n self.interest_prior_ytd_amount = interest_prior_ytd_amount\\r\\n self.maturity_date = maturity_date\\r\\n self.interest_rate = interest_rate\\r\\n self.credit_available_amount = credit_available_amount\\r\\n self.credit_max_amount = credit_max_amount\\r\\n self.cash_advance_available_amount = cash_advance_available_amount\\r\\n self.cash_advance_max_amount = cash_advance_max_amount\\r\\n self.cash_advance_balance = cash_advance_balance\\r\\n self.cash_advance_interest_rate = cash_advance_interest_rate\\r\\n self.current_balance = current_balance\\r\\n self.payment_min_amount = payment_min_amount\\r\\n self.payment_due_date = payment_due_date\\r\\n self.previous_balance = previous_balance\\r\\n self.statement_start_date = statement_start_date\\r\\n self.statement_end_date = statement_end_date\\r\\n self.statement_purchase_amount = statement_purchase_amount\\r\\n self.statement_finance_amount = statement_finance_amount\\r\\n self.statement_credit_amount = statement_credit_amount\\r\\n self.reward_earned_balance = reward_earned_balance\\r\\n self.past_due_amount = past_due_amount\\r\\n self.last_payment_amount = last_payment_amount\\r\\n self.last_payment_date = last_payment_date\\r\\n self.statement_close_balance = statement_close_balance\\r\\n self.term_of_ml = term_of_ml\\r\\n self.ml_holder_name = ml_holder_name\\r\\n self.description = description\\r\\n self.late_fee_amount = late_fee_amount\\r\\n self.payoff_amount = payoff_amount\\r\\n self.payoff_amount_date = payoff_amount_date\\r\\n self.original_maturity_date = original_maturity_date\\r\\n self.principal_balance = principal_balance\\r\\n self.escrow_balance = escrow_balance\\r\\n self.interest_period = interest_period\\r\\n self.initial_ml_amount = initial_ml_amount\\r\\n self.initial_ml_date = initial_ml_date\\r\\n self.next_payment_principal_amount = next_payment_principal_amount\\r\\n self.next_payment_interest_amount = next_payment_interest_amount\\r\\n self.next_payment = next_payment\\r\\n self.next_payment_date = next_payment_date\\r\\n self.last_payment_due_date = last_payment_due_date\\r\\n self.last_payment_receive_date = last_payment_receive_date\\r\\n self.last_payment_principal_amount = last_payment_principal_amount\\r\\n self.last_payment_interest_amount = last_payment_interest_amount\\r\\n self.last_payment_escrow_amount = last_payment_escrow_amount\\r\\n self.last_payment_last_fee_amount = last_payment_last_fee_amount\\r\\n self.last_payment_late_charge = last_payment_late_charge\\r\\n self.ytd_principal_paid = ytd_principal_paid\\r\\n self.ytd_interest_paid = ytd_interest_paid\\r\\n self.ytd_insurance_paid = ytd_insurance_paid\\r\\n self.ytd_tax_paid = ytd_tax_paid\\r\\n self.auto_pay_enrolled = auto_pay_enrolled\\r\\n self.collateral = collateral\\r\\n self.current_school = current_school\\r\\n self.first_payment_date = first_payment_date\\r\\n self.first_mortgage = first_mortgage\\r\\n self.loan_payment_freq = loan_payment_freq\\r\\n self.original_school = original_school\\r\\n self.recurring_payment_amount = recurring_payment_amount\\r\\n self.lender = lender\\r\\n self.ending_balance_amount = ending_balance_amount\\r\\n self.loan_term_type = loan_term_type\\r\\n self.payments_made = payments_made\\r\\n self.balloon_amount = balloon_amount\\r\\n self.projected_interest = projected_interest\\r\\n self.interest_paid_ltd = interest_paid_ltd\\r\\n self.interest_rate_type = interest_rate_type\\r\\n self.loan_payment_type = loan_payment_type\\r\\n self.repayment_plan = repayment_plan\\r\\n self.payments_remaining = payments_remaining\\r\\n self.interest_margin_balance = interest_margin_balance\\r\\n self.short_balance = short_balance\\r\\n self.available_cash_balance = available_cash_balance\\r\\n self.maturity_value_amount = maturity_value_amount\\r\\n self.vested_balance = vested_balance\\r\\n self.emp_match_amount = emp_match_amount\\r\\n self.emp_pretax_contrib_amount = emp_pretax_contrib_amount\\r\\n self.emp_pretax_contrib_amount_ytd = emp_pretax_contrib_amount_ytd\\r\\n self.contrib_total_ytd = contrib_total_ytd\\r\\n self.cash_balance_amount = cash_balance_amount\\r\\n self.pre_tax_amount = pre_tax_amount\\r\\n self.after_tax_amount = after_tax_amount\\r\\n self.match_amount = match_amount\\r\\n self.profit_sharing_amount = profit_sharing_amount\\r\\n self.rollover_amount = rollover_amount\\r\\n self.other_vest_amount = other_vest_amount\\r\\n self.other_nonvest_amount = other_nonvest_amount\\r\\n self.current_loan_balance = current_loan_balance\\r\\n self.loan_rate = loan_rate\\r\\n self.buy_power = buy_power\\r\\n self.rollover_ltd = rollover_ltd\\r\\n\\r\\n # Add additional model properties to the instance\\r\\n self.additional_properties = additional_properties\",\n \"def get_today(**kwargs: int) -> Date:\\n return Date.today().replace(**kwargs)\",\n \"def __init__(self, start_date=None, end_date=None, currency=None, price=None):\\n\\n self._start_date = None\\n self._end_date = None\\n self._currency = None\\n self._price = None\\n\\n self.start_date = start_date\\n self.end_date = end_date\\n self.currency = currency\\n self.price = price\",\n \"def __init__(self, period: Optional[Period], date: dict = Depends(date_kwargs)) -> None:\\n self._given_date = date\\n self.date = date\\n if period:\\n self.period = period\\n else:\\n if not any(date.values()):\\n self.period = Period.FULL\\n else:\\n self._period_from_date()\\n self._fill_date()\",\n \"def TODAY():\\n return datetime.date.today()\",\n \"def get_date():\\n return datetime.datetime.now()\",\n \"def __init__(self,\\n amount=None,\\n currency=None,\\n **kwargs\\n\\n ):\\n self.amount = amount\\n self.currency = currency\",\n \"def _sel_context(self, cr, uid, billing_id, context=None):\\n company_currency = self._get_company_currency(cr, uid, billing_id, context)\\n current_currency = self._get_current_currency(cr, uid, billing_id, context)\\n if current_currency <> company_currency:\\n context_multi_currency = context.copy()\\n billing_brw = self.pool.get('account.billing').browse(cr, uid, billing_id, context)\\n context_multi_currency.update({'date': billing_brw.date})\\n return context_multi_currency\\n return context\",\n \"def default_get(self, cr, uid, fields_list, context=None):\\n\\t\\tif context is None:\\n\\t\\t\\tcontext = {}\\n\\t\\tdate_start = datetime.date.today().strftime('%Y-01-01')\\n\\t\\tdate_end = datetime.date.today().strftime('%Y-%m-%d')\\n\\n\\t\\tvalues = super(wizard_add_taxes, self).default_get(cr, uid, fields_list, context=context)\\n\\t\\ttax_ids = []\\n\\t\\tif (context.get('active_id',False)):\\n\\t\\t\\ttax_payment = self.pool.get('account.tax.payment').browse(cr,uid,context.get('active_id',False))\\n\\t\\t\\tcompany_id = tax_payment.company_id and tax_payment.company_id.id or False\\n\\t\\t\\ttax_ids = [t.id for t in tax_payment.tax_type]\\n\\t\\t\\tdate_end = tax_payment.date_end\\n\\t\\telse:\\n\\t\\t\\tuser = self.pool.get('res.users').browse(cr,uid,uid,context)\\n\\t\\t\\tcompany_id = user.company_id and user.company_id.id or False\\n\\t\\t\\ttax_ids=self.pool.get('account.tax').search(cr,uid,[('company_id','=',company_id)],context=context)\\n\\t\\ttax_account_ids=[]\\n\\t\\ttax_not_returned=[]\\n\\t\\ttax_code_account_ids = []\\n\\t\\ttax_code_unreturned = []\\n\\t\\tfor tax in self.pool.get('account.tax').browse(cr,uid,tax_ids,context):\\n\\t\\t\\tif not tax.inside_berikat and not tax.reported_unreturned:\\n\\t\\t\\t\\tif tax.account_collected_id and tax.account_collected_id.id:\\n\\t\\t\\t\\t\\ttax_account_ids.append(tax.account_collected_id.id)\\n\\t\\t\\t\\tif tax.account_paid_id and tax.account_paid_id.id:\\n\\t\\t\\t\\t\\ttax_account_ids.append(tax.account_paid_id and tax.account_paid_id.id)\\n\\t\\t\\t\\tif tax.tax_code_id and tax.tax_code_id.id:\\n\\t\\t\\t\\t\\ttax_code_account_ids.append(tax.tax_code_id.id)\\n\\t\\t\\t\\tif tax.ref_tax_code_id and tax.ref_tax_code_id.id:\\n\\t\\t\\t\\t\\ttax_code_account_ids.append(tax.ref_tax_code_id.id)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif tax.account_collected_id and tax.account_collected_id.id:\\n\\t\\t\\t\\t\\ttax_not_returned.append(tax.account_collected_id and tax.account_collected_id.id)\\n\\t\\t\\t\\tif tax.account_paid_id and tax.account_paid_id.id:\\n\\t\\t\\t\\t\\ttax_not_returned.append(tax.account_paid_id and tax.account_paid_id.id)\\n\\t\\t\\t\\tif tax.tax_code_id and tax.tax_code_id.id:\\n\\t\\t\\t\\t\\ttax_code_unreturned.append(tax.tax_code_id and tax.tax_code_id.id)\\n\\t\\t\\t\\tif tax.ref_tax_code_id and tax.ref_tax_code_id.id:\\n\\t\\t\\t\\t\\ttax_code_unreturned.append(tax.ref_tax_code_id and tax.ref_tax_code_id.id)\\n\\t\\t\\t\\t#print \\\"tax_not_returned==============\\\",tax_not_returned\\n\\t\\ttax_account_ids = list(set(tax_account_ids))\\n\\t\\ttax_not_returned = list(set(tax_not_returned))\\n\\t\\ttax_code_account_ids = list(set(tax_code_account_ids))\\n\\t\\ttax_code_unreturned = list(set(tax_code_unreturned))\\n\\t\\tcompany = self.pool.get('res.company').browse(cr,uid,company_id,context)\\n\\t\\tif tax_account_ids or tax_not_returned:\\n\\t\\t\\tmove_id = self.pool.get('account.move').search(cr,uid,[('state','=','posted'),('date',\\\">=\\\",date_start),('date',\\\"<=\\\",date_end)])\\n\\t\\t\\texisting_payment_line_ids = self.pool.get('account.tax.payment.line').search(cr,uid,[],context=context)\\n\\t\\t\\texisting_payment_lines = [epm.move_line_id.id for epm in self.pool.get('account.tax.payment.line').browse(cr,uid,existing_payment_line_ids)]\\n\\t\\t\\texisting_statement_ids = self.pool.get('account.tax.payment').search(cr,uid,[],context=context)\\n\\t\\t\\texisting_statements_move = [esm.move_id.id for esm in self.pool.get('account.tax.payment').browse(cr,uid,existing_statement_ids)]\\n\\t\\t\\texisting_statement_move_lines = self.pool.get('account.move.line').search(cr,uid,[('move_id','in',existing_statements_move)])\\n\\t\\t\\texisting_payment_lines += existing_statement_move_lines\\n\\n\\n\\t\\ttax_lines_value=[]\\n\\n\\n\\t\\tif context.get('type',False) == 'tax_lines_cr':\\n\\t\\t\\tmove_lines = self.pool.get('account.move.line').search(cr,uid,[('id','not in',existing_payment_lines),\\\\\\n\\t\\t\\t\\t('date','>=',date_start),('date','<=',date_end),('tax_code_id','in',tax_code_account_ids),('account_id','in',tax_account_ids),\\\\\\n\\t\\t\\t\\t('state','=','valid'),('move_id','in',move_id),('debit','=',0.0),('credit',\\\">=\\\",0.0)])\\n\\t\\t\\tfor line in self.pool.get('account.move.line').browse(cr,uid,move_lines,context=context):\\n\\t\\t\\t\\tmoves = line.move_id\\n\\t\\t\\t\\tinvoice_id=False\\n\\t\\t\\t\\tfor move_line in line.move_id.line_id:\\n\\t\\t\\t\\t\\tif move_line.invoice and move_line.invoice.id:\\n\\t\\t\\t\\t\\t\\tinvoice_id=move_line.invoice.id\\n\\t\\t\\t\\ttax_lines={\\n\\t\\t\\t\\t\\t\\\"name\\\"\\t\\t\\t\\t: line.name or line.ref or '/',\\n\\t\\t\\t\\t\\t\\\"move_line_id\\\"\\t\\t: line.id,\\n\\t\\t\\t\\t\\t\\\"invoice_id\\\"\\t\\t: invoice_id,\\n\\t\\t\\t\\t\\t\\\"amount\\\"\\t\\t\\t: line.debit or line.credit or 0.0,\\n\\t\\t\\t\\t\\t\\\"currency_id\\\"\\t\\t: line.currency_id and line.currency_id.id or False,\\n\\t\\t\\t\\t\\t\\\"amount_currency\\\"\\t: line.amount_currency or 0.0,\\n\\t\\t\\t\\t\\t\\\"effective_date\\\"\\t: line.date or False,\\n\\t\\t\\t\\t\\t\\\"partner_id\\\"\\t\\t: line.partner_id and line.partner_id.id or False,\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\ttax_lines_value.append(tax_lines)\\n\\t\\telif context.get('type',False) == 'tax_lines_dr':\\n\\t\\t\\tmove_lines = self.pool.get('account.move.line').search(cr,uid,[('id','not in',existing_payment_lines),\\\\\\n\\t\\t\\t\\t('date','>=',date_start),('date','<=',date_end),('tax_code_id','in',tax_code_account_ids),('account_id','in',tax_account_ids),\\\\\\n\\t\\t\\t\\t('state','=','valid'),('move_id','in',move_id),('debit','>=',0.0),('credit',\\\"=\\\",0.0)])\\n\\n\\t\\t\\tfor line in self.pool.get('account.move.line').browse(cr,uid,move_lines,context=context):\\n\\t\\t\\t\\tmoves = line.move_id\\n\\t\\t\\t\\tinvoice_id=False\\n\\t\\t\\t\\tfor move_line in line.move_id.line_id:\\n\\t\\t\\t\\t\\tif move_line.invoice and move_line.invoice.id:\\n\\t\\t\\t\\t\\t\\tinvoice_id=move_line.invoice.id\\n\\t\\t\\t\\ttax_lines={\\n\\t\\t\\t\\t\\t\\\"name\\\"\\t\\t\\t\\t: line.name or line.ref or '/',\\n\\t\\t\\t\\t\\t\\\"move_line_id\\\"\\t\\t: line.id,\\n\\t\\t\\t\\t\\t\\\"invoice_id\\\"\\t\\t: invoice_id,\\n\\t\\t\\t\\t\\t\\\"amount\\\"\\t\\t\\t: line.debit or line.credit or 0.0,\\n\\t\\t\\t\\t\\t\\\"currency_id\\\"\\t\\t: line.currency_id and line.currency_id.id or False,\\n\\t\\t\\t\\t\\t\\\"amount_currency\\\"\\t: line.amount_currency or 0.0,\\n\\t\\t\\t\\t\\t\\\"effective_date\\\"\\t: line.date or False,\\n\\t\\t\\t\\t\\t\\\"partner_id\\\"\\t\\t: line.partner_id and line.partner_id.id or False,\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\ttax_lines_value.append(tax_lines)\\n\\t\\telif context.get('type',False) == 'tax_lines_cr_unr':\\n\\t\\t\\tmove_lines_unreturned = self.pool.get('account.move.line').search(cr,uid,[('id','not in',existing_payment_lines),\\\\\\n\\t\\t\\t\\t('date','>=',date_start),('date','<=',date_end),('tax_code_id','in',tax_code_unreturned),('account_id','in',tax_not_returned),\\\\\\n\\t\\t\\t\\t('state','=','valid'),('move_id','in',move_id),('debit','=',0.0),('credit',\\\">=\\\",0.0)])\\n\\t\\t\\tfor line in self.pool.get('account.move.line').browse(cr,uid,move_lines_unreturned,context=context):\\n\\t\\t\\t\\tmoves = line.move_id\\n\\t\\t\\t\\tinvoice_id=False\\n\\t\\t\\t\\tfor move_line in line.move_id.line_id:\\n\\t\\t\\t\\t\\tif move_line.invoice and move_line.invoice.id:\\n\\t\\t\\t\\t\\t\\tinvoice_id=move_line.invoice.id\\n\\t\\t\\t\\ttax_lines={\\n\\t\\t\\t\\t\\t\\\"name\\\"\\t\\t\\t\\t: line.name or line.ref or '/',\\n\\t\\t\\t\\t\\t\\\"move_line_id\\\"\\t\\t: line.id,\\n\\t\\t\\t\\t\\t\\\"invoice_id\\\"\\t\\t: invoice_id,\\n\\t\\t\\t\\t\\t\\\"amount\\\"\\t\\t\\t: line.debit or line.credit or 0.0,\\n\\t\\t\\t\\t\\t\\\"currency_id\\\"\\t\\t: line.currency_id and line.currency_id.id or False,\\n\\t\\t\\t\\t\\t\\\"amount_currency\\\"\\t: line.amount_currency or 0.0,\\n\\t\\t\\t\\t\\t\\\"effective_date\\\"\\t: line.date or False,\\n\\t\\t\\t\\t\\t\\\"partner_id\\\"\\t\\t: line.partner_id and line.partner_id.id or False,\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\ttax_lines_value.append(tax_lines)\\n\\t\\telif context.get('type',False) == 'tax_lines_dr_unr':\\n\\t\\t\\t#move_lines = self.pool.get('account.move.line').search(cr,uid,[('account_id','not in',tax_not_returned),('id','not in',existing_payment_lines),('credit',\\\"=\\\",0.0),('debit',\\\">=\\\",0.0),('date',\\\">=\\\",date_start),('date',\\\"<=\\\",date_end),(\\\"account_id\\\",'in',tax_account_ids),('move_id.state','=','posted'),('state','=','valid')],context=context)\\n\\t\\t\\t#move_lines_unreturned = self.pool.get('account.move.line').search(cr,uid,[('account_id','in',tax_not_returned),('id','not in',existing_payment_lines),('credit',\\\"=\\\",0.0),('debit',\\\">=\\\",0.0),('date',\\\">=\\\",date_start),('date',\\\"<=\\\",date_end),(\\\"account_id\\\",'in',tax_account_ids),('move_id.state','=','posted'),('state','=','valid')],context=context)\\n\\t\\t\\tmove_lines_unreturned = self.pool.get('account.move.line').search(cr,uid,[('id','not in',existing_payment_lines),\\\\\\n\\t\\t\\t\\t('date','>=',date_start),('date','<=',date_end),('tax_code_id','in',tax_code_unreturned),('account_id','in',tax_not_returned),\\\\\\n\\t\\t\\t\\t('state','=','valid'),('move_id','in',move_id),('debit','>=',0.0),('credit',\\\"=\\\",0.0)])\\n\\n\\t\\t\\tfor line in self.pool.get('account.move.line').browse(cr,uid,move_lines_unreturned,context=context):\\n\\t\\t\\t\\tmoves = line.move_id\\n\\t\\t\\t\\tinvoice_id=False\\n\\t\\t\\t\\tfor move_line in line.move_id.line_id:\\n\\t\\t\\t\\t\\tif move_line.invoice and move_line.invoice.id:\\n\\t\\t\\t\\t\\t\\tinvoice_id=move_line.invoice.id\\n\\t\\t\\t\\ttax_lines={\\n\\t\\t\\t\\t\\t\\\"name\\\"\\t\\t\\t\\t: line.name or line.ref or '/',\\n\\t\\t\\t\\t\\t\\\"move_line_id\\\"\\t\\t: line.id,\\n\\t\\t\\t\\t\\t\\\"invoice_id\\\"\\t\\t: invoice_id,\\n\\t\\t\\t\\t\\t\\\"amount\\\"\\t\\t\\t: line.debit or line.credit or 0.0,\\n\\t\\t\\t\\t\\t\\\"currency_id\\\"\\t\\t: line.currency_id and line.currency_id.id or False,\\n\\t\\t\\t\\t\\t\\\"amount_currency\\\"\\t: line.amount_currency or 0.0,\\n\\t\\t\\t\\t\\t\\\"effective_date\\\"\\t: line.date or False,\\n\\t\\t\\t\\t\\t\\\"partner_id\\\"\\t\\t: line.partner_id and line.partner_id.id or False,\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\ttax_lines_value.append(tax_lines)\\n\\t\\tvalues.update({'tax_move_line_ids':tax_lines_value})\\t\\n\\t\\t\\n\\t\\treturn values\",\n \"async def _claim_daily_coins(ctx):\\n await daily_coins(bot, ctx.message.author.id)\",\n \"def formalDateToday():\\n return dt.date.today().strftime(\\\"%B %d, %Y\\\")\",\n \"def __init__(self, start: datetime.date, balance: float) -> None:\\n Contract.__init__(self, start)\\n self.balance = balance * (-1)\",\n \"def today(cls, **kwargs: Any) -> Date:\\n return cls.from_date(dt.date.today())\",\n \"def _fill_date(self):\\n if not self.date['year']:\\n self.date['year'] = self.DEFAULT_DATE['year']\\n if not self.date['month']:\\n self.date['month'] = self.DEFAULT_DATE['month']\\n if not self.date['day']:\\n self.date['day'] = self.DEFAULT_DATE['day']\",\n \"def test_handler_dates(self):\\n\\n @intent_handler\\n def decorated_test(date_str: str = None, date_date: datetime.date = None):\\n return date_str, date_date\\n\\n r = create_request(\\n \\\"TEST_CONTEXT\\\",\\n date_str=[\\n \\\"2001-12-31\\\",\\n \\\"2001-12-31\\\",\\n ],\\n date_date=[\\n \\\"2001-12-31\\\",\\n \\\"1001-12-31\\\",\\n ],\\n )\\n result = decorated_test(r)\\n self.assertEqual(result, (\\\"2001-12-31\\\", datetime.date(2001, 12, 31)))\",\n \"def form_DateDifferentEmpty(request):\\n schema = schemaish.Structure()\\n schema.add('myDateField', schemaish.Date())\\n form = formish.Form(schema, 'form')\\n form['myDateField'].widget = formish.Input(empty=datetime.date.today())\\n return form\",\n \"def test_date_accept_today(self):\\n spi_search = \\\"find date today\\\"\\n inv_search = \\\"year:\\\" + datetime.datetime.strftime(datetime.datetime.today(), '%Y-%m-%d')\\n self._compare_searches(inv_search, spi_search)\",\n \"def default_actual_order_price(context):\\n current_type = context.current_parameters.get('current_type')\\n default_price = 0\\n actual_order_price = 0\\n if current_type == 'order':\\n project_id = context.current_parameters.get('project_id', None)\\n if project_id:\\n project = Project.get(project_id)\\n default_price = project.price if project else default_price\\n actual_order_price = context.current_parameters.get('price', default_price)\\n return actual_order_price\",\n \"def transaction_date(self, value):\\n if value:\\n self._transaction_date = (\\n parse(value).date() if isinstance(value, type_check) else value\\n )\",\n \"def test_today(self):\\n self.assertEquals(\\n self.builder._today(), date.today().strftime('%Y-%m-%d'))\",\n \"def date(*args):\\n current_date = datetime.now().isoformat(' ').split('.')[0]\\n send.system_message(current_date)\",\n \"def __init__(self, price, date=datetime.datetime.now(), dividend=0., annualDividend=0.):\\n self.price = price\\n self.date = date\\n self.dividend = dividend\\n self.annualDividend = annualDividend\",\n \"def on_book(context, quote_type, quote):\\n date, filterTime = str(context.config.trading_date), int(quote.int_time)\\n # print(quote.symbol, quote.int_time)\\n\\n if ((filterTime > 93000000) and (filterTime < 113000000)) or (\\n (filterTime > 130000000) and (filterTime < 150000000)):\\n # print (\\\"Trading Time\\\")\\n if str(quote.symbol).__contains__(\\\"IH\\\"):\\n context.dic[\\\"IH\\\"] = [quote.bp_array[0], quote.ap_array[0]]\\n context.symboldic[\\\"IH\\\"] = quote.symbol\\n if str(quote.symbol).__contains__(\\\"IC\\\"):\\n context.dic[\\\"IC\\\"] = [quote.bp_array[0], quote.ap_array[0]]\\n context.symboldic[\\\"IC\\\"] = quote.symbol\\n if len(context.dic.keys()) < 2:\\n return\\n \\\"\\\"\\\"\\n if len(context.dic.keys()) >= 2:\\n sql = \\\"`quoteData insert (%s;%s;%s;%s;%s;%s;%s)\\\"\\n time_sql = '{y+ \\\"T\\\"$-9#\\\"00000000\\\",string x}[%s;%s]'\\n date_time = time_sql % (filterTime, \\\"%s.%s.%s\\\" % (date[0:4], date[4:6], date[6:8]))\\n context.q.sync(date_time)\\n # print(context.dic[\\\"IC\\\"][0]*200 -context.dic[\\\"IH\\\"][1]*300*2)\\n feed_quote = sql % (date_time, context.dic[\\\"IH\\\"][0], context.dic[\\\"IH\\\"][1], context.dic[\\\"IC\\\"][0], context.dic[\\\"IC\\\"][1], context.dic[\\\"IC\\\"][0]*200 -context.dic[\\\"IH\\\"][1]*300*2, context.dic[\\\"IC\\\"][1]*200 -context.dic[\\\"IH\\\"][0]*300*2)\\n context.q.sync(feed_quote)\\n\\n context.q.sync(\\n \\\"CombinedMainContract: select Date:last Date,BidPrice1Open:first PairBidPrice,BidPrice1High:max PairBidPrice,BidPrice1Low:min PairBidPrice, BidPrice1Close:last PairBidPrice,BidVol1:100,AskPrice1Open:first PairAskPrice,AskPrice1High:max PairAskPrice,AskPrice1Low:min PairAskPrice, AskPrice1Close:last PairAskPrice,AskVol1:last 100,LegOneBidPrice1:last LegOneBidPrice1, LegOneAskPrice1:last LegOneAskPrice1, LegTwoBidPrice1:last LegTwoBidPrice1, LegTwoAskPrice1: last LegTwoAskPrice1 by %s xbar Date.second from `quoteData;\\\" % (\\n context.kindleInterval))\\n context.q.sync(\\n \\\"delete date, second from `CombinedMainContract;delete from `CombinedMainContract where Date.second < 09:30:00;delete from `CombinedMainContract where Date.second > 11:30:00, Date.second < 13:00:00;delete from `CombinedMainContract where Date.second > 15:00:00;update TrueRange: {max(x;y;z)}'[(AskPrice1High - BidPrice1Low);(AskPrice1High - (prev BidPrice1Close));((prev AskPrice1High) - BidPrice1Low)] from `CombinedMainContract;\\\")\\n context.q.sync(\\\"update N: mavg[%s;TrueRange] from `CombinedMainContract;\\\" % (context.volatilityRange))\\n context.q.sync(\\\"update ShortEntry: prev (%s mmin BidPrice1Low), LongEntry: prev (%s mmax AskPrice1High) from `CombinedMainContract;\\\"%(context.breakRange, context.breakRange))\\n\\n Signal = context.q.sync(\\\"select count Date from CombinedMainContract\\\")[0]\\n \\n if (Signal[0] > context.kindleNumber):\\n context.kindleNumber = Signal[0]\\n PairDataBar = context.q.sync(\\\"-2#select Date.minute, BidPrice1Close, AskPrice1Close, ShortEntry, LongEntry, N from CombinedMainContract\\\")[0]\\n context.PairDataBarDate = PairDataBar[0]\\n context.PairDataBarBidPrice1Close = PairDataBar[1]\\n context.PairDataBarAskPrice1Close = PairDataBar[2]\\n context.PairDataBarShortEntry = PairDataBar[3]\\n context.PairDataBarLongEntry = PairDataBar[4]\\n context.PairDataBarN = PairDataBar[5]\\n if (context.PairDataBarBidPrice1Close < context.LocalLow):\\n context.UpDrawBack = 0.0\\n context.LocalLow = context.PairDataBarBidPrice1Close\\n elif (context.PairDataBarBidPrice1Close > context.LocalLow):\\n context.UpDrawBack = context.PairDataBarBidPrice1Close - context.LocalLow\\n\\n if (abs(context.PositionAddedTime) > 0 and (context.PairDataBarDate > 898)):\\n context.PositionClearPrice = context.dic[\\\"IC\\\"][1]\\n # print(\\\"PosClear: \\\" + str(context.dic[\\\"IC\\\"][1]))\\n # context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][1], abs(context.PositionAddedTime), Direction.BUY, OpenClose.CLOSE)\\n context.PositionAddedTime = 0\\n # sendOrderClose PositionAddedTime Amount Contract\\n if (context.PositionAddedTime == -1):\\n print(context.LegOnePositionEntryPrice[1] - context.PositionClearPrice)\\n elif (context.PositionAddedTime == -2):\\n print(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[\\n 2] - 2 * context.PositionClearPrice)\\n elif (context.PositionAddedTime == -3):\\n print(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] +\\n context.LegOnePositionEntryPrice[3] - 3 * context.PositionClearPrice)\\n elif (context.PositionAddedTime == -4):\\n print(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] +\\n context.LegOnePositionEntryPrice[3] + context.LegOnePositionEntryPrice[\\n 4] - 4 * context.PositionClearPrice)\\n context.LegOnePositionEntryPrice = {}\\n context.PositionEntryPrice = {}\\n # context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][1], abs(context.PositionAddedTime), Direction.BUY, OpenClose.CLOSE)\\n context.PositionAddedTime = 0\\n else:\\n if ((abs(context.PositionAddedTime) > 0) and (context.UpDrawBack > context.NStoplossPositionParameter * context.PairDataBarN)):\\n # print(\\\"PosClear: \\\" + str(context.dic[\\\"IC\\\"][1]))\\n context.PositionClearPrice = context.dic[\\\"IC\\\"][1]\\n if (context.PositionAddedTime == -1):\\n print (context.LegOnePositionEntryPrice[1] - context.PositionClearPrice)\\n elif (context.PositionAddedTime == -2):\\n print (context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2]- 2 * context.PositionClearPrice)\\n elif (context.PositionAddedTime == -3):\\n print (context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] + context.LegOnePositionEntryPrice[3]- 3 * context.PositionClearPrice)\\n elif (context.PositionAddedTime == -4):\\n print (context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] + context.LegOnePositionEntryPrice[3] + context.LegOnePositionEntryPrice[4] - 4 * context.PositionClearPrice)\\n context.LegOnePositionEntryPrice = {}\\n context.PositionEntryPrice = {}\\n #context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][1], abs(context.PositionAddedTime), Direction.BUY, OpenClose.CLOSE)\\n context.PositionAddedTime = 0\\n context.q.sync(\\\"update Position:0 from `CombinedMainContract where Date = max Date\\\")\\n if ((abs(context.PositionAddedTime) == 3) and context.PositionTimesParameter >= 4 and context.PairDataBarBidPrice1Close < context.PositionEntryPrice[1] - 3 * context.NEntryParameter*context.Nvalue):\\n context.PositionAddedTime = -4\\n context.LegOnePositionEntryPrice[4] = context.dic[\\\"IC\\\"][0]\\n context.PositionEntryPrice[4] = context.PairDataBarBidPrice1Close\\n # print(\\\"Pos4: \\\" + str(context.dic[\\\"IC\\\"][0]))\\n #context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][0], 1, Direction.SELL, OpenClose.OPEN)\\n context.q.sync(\\\"update Position:-4 from `CombinedMainContract where Date = max Date\\\")\\n if ((abs(context.PositionAddedTime) == 2) and context.PositionTimesParameter >= 3 and context.PairDataBarBidPrice1Close < context.PositionEntryPrice[1] - 2 * context.NEntryParameter*context.Nvalue):\\n context.PositionAddedTime = -3\\n context.LegOnePositionEntryPrice[3] = context.dic[\\\"IC\\\"][0]\\n context.PositionEntryPrice[3] = context.PairDataBarBidPrice1Close\\n # print(\\\"Pos3: \\\" + str(context.dic[\\\"IC\\\"][0]))\\n context.q.sync(\\\"update Position:-3 from `CombinedMainContract where Date = max Date\\\")\\n #context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][0], 1, Direction.SELL, OpenClose.OPEN)\\n if ((abs(context.PositionAddedTime) == 1) and context.PositionTimesParameter >= 2 and context.PairDataBarBidPrice1Close < context.PositionEntryPrice[1] - 1 * context.NEntryParameter*context.Nvalue):\\n context.PositionAddedTime = -2\\n context.LegOnePositionEntryPrice[2] = context.dic[\\\"IC\\\"][0]\\n context.PositionEntryPrice[2] = context.PairDataBarBidPrice1Close\\n # print(\\\"Pos2: \\\" + str(context.dic[\\\"IC\\\"][0]))\\n #context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][0], 1, Direction.SELL, OpenClose.OPEN)\\n context.q.sync(\\\"update Position:-2 from `CombinedMainContract where Date = max Date\\\")\\n if ((abs(context.PositionAddedTime) == 0) and context.PositionTimesParameter >= 1 and context.PairDataBarBidPrice1Close < context.PairDataBarShortEntry - 0 * context.NEntryParameter*context.Nvalue):\\n context.PositionAddedTime = -1\\n context.LegOnePositionEntryPrice[1] = context.dic[\\\"IC\\\"][0]\\n context.PositionEntryPrice[1] = context.PairDataBarBidPrice1Close\\n # print(\\\"Pos1: \\\" + str(str(context.dic[\\\"IC\\\"][0])))\\n context.Nvalue = context.PairDataBarN\\n context.q.sync(\\\"update Position:-1 from `CombinedMainContract where Date = max Date\\\")\\n #context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][0], 1, Direction.SELL, OpenClose.OPEN)\\n\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n if context.long_position(quote.symbol) > 0 and not context.ORDER_SENT_FLAG:\\n context.order.send_single_order(\\n quote.symbol, quote.bp_array[0], 5, Direction.SELL, OpenClose.CLOSE\\n )\\n context.ORDER_SENT_FLAG = True\\n elif 90000000 < quote.int_time < 90500000 and not context.ORDER_SENT_FLAG:\\n context.order.send_single_order(\\n quote.symbol, quote.bp_array[0], 5, Direction.BUY, OpenClose.OPEN\\n )\\n context.ORDER_SENT_FLAG = True\\n else:\\n pass\\n \\\"\\\"\\\"\\n\\n if len(context.dic.keys()) >= 2:\\n sql = \\\"`quoteData insert (%s;%s;%s;%s;%s;%s;%s)\\\"\\n time_sql = '{y+ \\\"T\\\"$-9#\\\"00000000\\\",string x}[%s;%s]'\\n date_time = time_sql % (filterTime, \\\"%s.%s.%s\\\" % (date[0:4], date[4:6], date[6:8]))\\n context.q.sync(date_time)\\n # print(context.dic[\\\"IC\\\"][0]*200 -context.dic[\\\"IH\\\"][1]*300*2)\\n feed_quote = sql % (\\n date_time, context.dic[\\\"IH\\\"][0], context.dic[\\\"IH\\\"][1], context.dic[\\\"IC\\\"][0], context.dic[\\\"IC\\\"][1],\\n context.dic[\\\"IC\\\"][0] * 200 - context.dic[\\\"IH\\\"][1] * 300 * 2,\\n context.dic[\\\"IC\\\"][1] * 200 - context.dic[\\\"IH\\\"][0] * 300 * 2)\\n context.q.sync(feed_quote)\\n\\n context.q.sync(\\n \\\"CombinedMainContract: select Date:last Date,BidPrice1Open:first PairBidPrice,BidPrice1High:max PairBidPrice,BidPrice1Low:min PairBidPrice, BidPrice1Close:last PairBidPrice,BidVol1:100,AskPrice1Open:first PairAskPrice,AskPrice1High:max PairAskPrice,AskPrice1Low:min PairAskPrice, AskPrice1Close:last PairAskPrice,AskVol1:last 100,LegOneBidPrice1:last LegOneBidPrice1, LegOneAskPrice1:last LegOneAskPrice1, LegTwoBidPrice1:last LegTwoBidPrice1, LegTwoAskPrice1: last LegTwoAskPrice1 by %s xbar Date.second from `quoteData;\\\" % (\\n context.kindleInterval))\\n context.q.sync(\\n \\\"delete date, second from `CombinedMainContract;delete from `CombinedMainContract where Date.second < 09:30:00;delete from `CombinedMainContract where Date.second > 11:30:00, Date.second < 13:00:00;delete from `CombinedMainContract where Date.second > 15:00:00;update TrueRange: {max(x;y;z)}'[(AskPrice1High - BidPrice1Low);(AskPrice1High - (prev BidPrice1Close));((prev AskPrice1High) - BidPrice1Low)] from `CombinedMainContract;\\\")\\n context.q.sync(\\\"update N: mavg[%s;TrueRange] from `CombinedMainContract;\\\" % (context.volatilityRange))\\n context.q.sync(\\n \\\"update ShortEntry: prev (%s mmin BidPrice1Low), LongEntry: prev (%s mmax AskPrice1High) from `CombinedMainContract;\\\" % (\\n context.breakRange, context.breakRange))\\n\\n Signal = context.q.sync(\\\"select count Date from CombinedMainContract\\\")[0]\\n\\n if (Signal[0] > context.kindleNumber):\\n context.kindleNumber = Signal[0]\\n PairDataBar = context.q.sync(\\n \\\"-2#select Date.minute, BidPrice1Close, AskPrice1Close, ShortEntry, LongEntry, N from CombinedMainContract\\\")[\\n 0]\\n context.PairDataBarDate = PairDataBar[0]\\n context.PairDataBarBidPrice1Close = PairDataBar[1]\\n context.PairDataBarAskPrice1Close = PairDataBar[2]\\n context.PairDataBarShortEntry = PairDataBar[3]\\n context.PairDataBarLongEntry = PairDataBar[4]\\n context.PairDataBarN = PairDataBar[5]\\n if (context.PairDataBarAskPrice1Close > context.LocalHigh):\\n context.DownDrawBack = 0.0\\n context.LocalHigh = context.PairDataBarAskPrice1Close\\n elif (context.PairDataBarAskPrice1Close < context.LocalHigh):\\n context.DownDrawBack = context.LocalHigh - context.PairDataBarAskPrice1Close\\n\\n if (abs(context.PositionAddedTime) > 0 and (context.PairDataBarDate > 898)):\\n context.PositionClearPrice = context.dic[\\\"IC\\\"][0]\\n # print(\\\"PosClear: \\\" + str(context.dic[\\\"IC\\\"][1]))\\n # context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][1], abs(context.PositionAddedTime), Direction.BUY, OpenClose.CLOSE)\\n\\n # sendOrderClose PositionAddedTime Amount Contract\\n print(\\\"PosClear: \\\" + str(context.dic[\\\"IC\\\"][0]))\\n context.PositionClearPrice = context.dic[\\\"IC\\\"][0]\\n if (context.PositionAddedTime == 1):\\n print(-(context.LegOnePositionEntryPrice[1] - context.PositionClearPrice))\\n elif (context.PositionAddedTime == 2):\\n print(-(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[\\n 2] - 2 * context.PositionClearPrice))\\n elif (context.PositionAddedTime == 3):\\n print(-(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] +\\n context.LegOnePositionEntryPrice[3] - 3 * context.PositionClearPrice))\\n elif (context.PositionAddedTime == 4):\\n print(-(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] +\\n context.LegOnePositionEntryPrice[3] + context.LegOnePositionEntryPrice[\\n 4] - 4 * context.PositionClearPrice))\\n context.PositionAddedTime = 0\\n context.LegOnePositionEntryPrice = {}\\n context.PositionEntryPrice = {}\\n # context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][1], abs(context.PositionAddedTime), Direction.BUY, OpenClose.CLOSE)\\n context.PositionAddedTime = 0\\n else:\\n if ((abs(context.PositionAddedTime) > 0) and (\\n context.DownDrawBack > context.NStoplossPositionParameter * context.PairDataBarN)):\\n print(\\\"PosClear: \\\" + str(context.dic[\\\"IC\\\"][0]))\\n context.PositionClearPrice = context.dic[\\\"IC\\\"][0]\\n if (context.PositionAddedTime == 1):\\n print(-(context.LegOnePositionEntryPrice[1] - context.PositionClearPrice))\\n elif (context.PositionAddedTime == 2):\\n print(-(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[\\n 2] - 2 * context.PositionClearPrice))\\n elif (context.PositionAddedTime == 3):\\n print(-(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] +\\n context.LegOnePositionEntryPrice[3] - 3 * context.PositionClearPrice))\\n elif (context.PositionAddedTime == 4):\\n print(-(context.LegOnePositionEntryPrice[1] + context.LegOnePositionEntryPrice[2] +\\n context.LegOnePositionEntryPrice[3] + context.LegOnePositionEntryPrice[\\n 4] - 4 * context.PositionClearPrice))\\n context.LegOnePositionEntryPrice = {}\\n context.PositionEntryPrice = {}\\n # context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][1], abs(context.PositionAddedTime), Direction.BUY, OpenClose.CLOSE)\\n context.PositionAddedTime = 0\\n context.q.sync(\\\"update Position:0 from `CombinedMainContract where Date = max Date\\\")\\n if ((abs(\\n context.PositionAddedTime) == 3) and context.PositionTimesParameter >= 4 and context.PairDataBarAskPrice1Close >\\n context.PositionEntryPrice[1] + 3 * context.NEntryParameter * context.Nvalue):\\n context.PositionAddedTime = 4\\n context.LegOnePositionEntryPrice[4] = context.dic[\\\"IC\\\"][1]\\n context.PositionEntryPrice[4] = context.PairDataBarAskPrice1Close\\n print(\\\"Pos4: \\\" + str(context.dic[\\\"IC\\\"][1]))\\n # context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][1], 1, Direction.SELL, OpenClose.OPEN)\\n context.q.sync(\\\"update Position:4 from `CombinedMainContract where Date = max Date\\\")\\n if ((abs(\\n context.PositionAddedTime) == 2) and context.PositionTimesParameter >= 3 and context.PairDataBarAskPrice1Close >\\n context.PositionEntryPrice[1] + 2 * context.NEntryParameter * context.Nvalue):\\n context.PositionAddedTime = 3\\n context.LegOnePositionEntryPrice[3] = context.dic[\\\"IC\\\"][1]\\n context.PositionEntryPrice[3] = context.PairDataBarAskPrice1Close\\n print(\\\"Pos3: \\\" + str(context.dic[\\\"IC\\\"][1]))\\n context.q.sync(\\\"update Position:3 from `CombinedMainContract where Date = max Date\\\")\\n # context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][1], 1, Direction.SELL, OpenClose.OPEN)\\n if ((abs(\\n context.PositionAddedTime) == 1) and context.PositionTimesParameter >= 2 and context.PairDataBarAskPrice1Close >\\n context.PositionEntryPrice[1] + 1 * context.NEntryParameter * context.Nvalue):\\n context.PositionAddedTime = 2\\n context.LegOnePositionEntryPrice[2] = context.dic[\\\"IC\\\"][1]\\n context.PositionEntryPrice[2] = context.PairDataBarAskPrice1Close\\n print(\\\"Pos2: \\\" + str(context.dic[\\\"IC\\\"][1]))\\n # context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][1], 1, Direction.SELL, OpenClose.OPEN)\\n context.q.sync(\\\"update Position:2 from `CombinedMainContract where Date = max Date\\\")\\n if ((abs(\\n context.PositionAddedTime) == 0) and context.PositionTimesParameter >= 1 and context.PairDataBarAskPrice1Close > context.PairDataBarLongEntry + 0 * context.NEntryParameter * context.Nvalue):\\n context.PositionAddedTime = 1\\n context.LegOnePositionEntryPrice[1] = context.dic[\\\"IC\\\"][1]\\n context.PositionEntryPrice[1] = context.PairDataBarAskPrice1Close\\n print(\\\"Pos1: \\\" + str(str(context.dic[\\\"IC\\\"][1])))\\n context.Nvalue = context.PairDataBarN\\n context.q.sync(\\\"update Position:1 from `CombinedMainContract where Date = max Date\\\")\\n # context.order.send_single_order(context.symboldic[\\\"IC\\\"], context.dic[\\\"IC\\\"][1], 1, Direction.SELL, OpenClose.OPEN)\",\n \"def __init__(self,start_date,end_date,param_name,context_name,param_value):\\n self.start_date = start_date\\n self.end_date = end_date\\n self.param_name = param_name\\n self.context_name = context_name\\n self.param_value = param_value\",\n \"def get_current_date():\\n return datetime.datetime.today().strftime(constants.DATE_FORMAT)\",\n \"def default_date(self):\\n return datetime.datetime.now().strftime('%Y-%m-%d')\",\n \"def __init__(self, current_user, produce_name, quantity, price_range):\\n self.current_user = current_user\\n self.produce_name = produce_name\\n self.quantity = quantity\\n self.price_range = price_range\\n self.date_created = datetime.datetime.utcnow()\\n self.date_modified = datetime.datetime.utcnow()\",\n \"def declare_new_budget(date, exp_data):\\n\\n exp_list = exp_data[env.EXPENSE_DATA_KEY]\\n local_budget = {}\\n month_total = util.get_float_input(\\n f\\\"Please input your total for the month ending {date}: \\\", force_pos=True)\\n budg_remaining = month_total\\n\\n for i, exp in enumerate(exp_list):\\n if i == len(exp_list) - 1:\\n print(\\\"I got the last one for you :) MATH!\\\")\\n budg_amnt = budg_remaining\\n budg_remaining = 0\\n\\n elif budg_remaining == 0: # elif skips this condition if budget remaining is set above\\n budg_amnt = 0\\n local_budget[env.BUDGET_TOTAL_KEY] = month_total\\n else:\\n prompt = f\\\"Enter your budget for: [{exp}] - Total Budget Re. ${budg_remaining} - Exp's Re. [{len(exp_list) - i - 1}]: \\\"\\n budg_amnt = prompt_for_budget_amnt(\\n prompt, budg_remaining, exp_data)\\n local_budget.update({exp: budg_amnt})\\n budg_remaining = round(month_total - sum_budget(local_budget), 2)\\n print(local_budget)\\n return local_budget\",\n \"async def dailytomorrow(self, ctx):\\n if ctx.invoked_subcommand is None:\\n await ctx.send_help(ctx.command)\",\n \"def updateToday(tradingDay):\\n if date.today() != tradingDay.today:\\n tradingDay = TradingDay(tradingDay.contractDetails)\\n\\n if tradingDay.isMarketOpen():\\n if not tradingDay.marketOpen:\\n tradingDay.marketOpen = True\\n console().info(\\\"The Market Has Opened\\\")\\n else:\\n if tradingDay.marketOpen:\\n tradingDay.marketOpen = False\\n console().info(\\\"The Market Has Closed\\\")\\n return tradingDay\",\n \"def qToday():\\n \\n return _qDate.todaysDate().ISO()\",\n \"def test_2_default_start_date(self):\\n date = FeaturedCommunity.query.get(2).start_date.date()\\n self.assertEqual(date, datetime.date.today())\",\n \"def date_options(func):\\n @click.option(\\n '--until', type=Date(), help=\\\"Only show entries until the given date.\\\"\\n )\\n @click.option(\\n '--since', type=Date(), help=\\\"Only show entries starting at the given date.\\\",\\n )\\n @click.option(\\n '--today/--not-today', default=None, help=\\\"Only include today's entries (same as --since=today --until=today)\\\"\\n \\\" or ignore today's entries (same as --until=yesterday)\\\"\\n )\\n @functools.wraps(func)\\n def wrapper(*args, **kwargs):\\n since, until, today = kwargs.pop('since'), kwargs.pop('until'), kwargs.pop('today')\\n\\n if today is not None:\\n if today:\\n date = datetime.date.today()\\n else:\\n date = (None, datetime.date.today() - datetime.timedelta(days=1))\\n elif since is not None or until is not None:\\n date = (since, until)\\n else:\\n date = None\\n\\n kwargs['date'] = date\\n\\n return func(*args, **kwargs)\\n\\n return wrapper\",\n \"def _rate_dates(self, common_object):\\n if common_object.IsKindOf(acm.FCashFlow):\\n start_date = common_object.StartDate()\\n elif common_object.IsKindOf(acm.FReset):\\n start_date = common_object.Day()\\n else:\\n message = \\\"Rate dates for {0} object are not defined\\\".format(\\n type(common_object))\\n raise ProvisionHandlerError(message)\\n\\n end_date = acm.Time().DateAddDelta(start_date, 0, 3, 0)\\n end_date = self._adjust_to_banking_day(end_date)\\n\\n return (start_date, end_date)\",\n \"def retirement_main(g:argparse.Namespace) -> tuple: \\n now = datetime.date.today()\\n\\n # Only the most cursory checking.\\n if not g.birthday < g.hiredate < now: \\n print(\\\"\\\\n\\\".join([\\\"you must have been born before you were hired,\\\",\\n \\\"and you must have been hired before today.\\\"]))\\n sys.exit(os.EX_DATAERR)\\n \\n current_age = now - g.birthday\\n current_service = now - g.hiredate\\n\\n old_enough_on = g.birthday + rdelta(years=g.min_age)\\n old_enough_now = old_enough_on < now\\n long_enough_on = g.hiredate + rdelta(years=g.req_years)\\n long_enough_now = long_enough_on < now\\n\\n if long_enough_now and old_enough_now:\\n return now, 0, old_enough_on, long_enough_on, current_age.days, current_service.days\\n \\n no_earlier_than = max(long_enough_on, old_enough_on)\\n magic_date = now + rdelta(rdelta(years=g.magic_number) - rdelta(current_age) - rdelta(current_service))/2\\n quit_on = max(magic_date, no_earlier_than)\\n\\n if old_enough_on < g.hiredate: \\n old_enough_on = 'when you started.'\\n elif old_enough_on < now: \\n old_enough_on = 'now'\\n if long_enough_on < now: \\n long_enough_on = 'now'\\n\\n return quit_on, (quit_on - now).days, old_enough_on, long_enough_on, current_age.days, current_service.days\",\n \"def clean_expiration_date(self):\\n expiration_date = self.cleaned_data['expiration_date']\\n if expiration_date.date() <= datetime.date.today():\\n v_err('elapsed')\\n return expiration_date\",\n \"def get_current_datetime ( ) :\\n return datetime.datetime.now( )\",\n \"def set_from_date_as_current_date(self):\\n self.set_value_into_input_field(self.set_from_date_locator, self.get_current_date())\",\n \"def currentDate(returnType='tuple'):\\n from datetime import datetime\\n if returnType == 'tuple':\\n return (datetime.now().month, datetime.now().day, datetime.now().year)\\n elif returnType == 'list':\\n return [datetime.now().month, datetime.now().day, datetime.now().year]\\n\\n return {\\n 'day':datetime.now().day,\\n 'month':datetime.now().month,\\n 'year':datetime.now().year\\n }\",\n \"def __init__(self):\\n self.annual_interest_rate = 10.0 / 100.0\\n self.initial_loan_date = date(2014, 12, 1)\\n self.currency = 'HKD'\\n self.total_loan_amount = Money('100000.00', 'HKD')\\n self.final_payment_date = self.initial_loan_date + \\\\\\n relativedelta(years=1)\",\n \"def get_today():\\n global endDate\\n check_today=date_trans_x(time.strftime(\\\"%Y.%m.%d\\\"))\\n if(get_article_ammount(check_today,True)>0): \\n diff=datetime.strptime(check_today,'%Y.%m.%d')-datetime.strptime(endDate,'%Y.%m.%d')\\n if(diff.total_seconds()>=0):\\n endDate=check_today\\n print \\\"get_today : \\\"+ check_today\\n return check_today\\n else:\\n print \\\"get_today : \\\"+ endDate\\n return endDate\",\n \"def tickets(number, day, premium_seating):\\n #fill in your code here. \\n return 0.0\",\n \"def initialize(context):\\n # Rebalance every day, 1 hour after market open.\\n set_slippage(slippage.FixedSlippage(spread=0.00))\\n set_commission(commission.PerShare(cost=0.0, min_trade_cost=0.0))\\n context.lookback = 60\\n context.leverage = 0.02\\n context.day = 1\\n #context.ETFs = []\\n context.market = [symbol('SPY')]\\n context.bo = 1.25\\n context.so = 1.25\\n context.bc = 0.75\\n context.sc = 0.5\\n context.stocks = []\\n context.initialized = False\\n context.holding_book_shares = None\\n context.order_hist = {}\\n \\n context.xlb = symbol('XLB') #sid(19654) #Materials 101\\n context.xly = symbol('XLY') #sid(19662) #Consumer Discretionary 102\\n context.xlf = symbol('XLF') #sid(19656) #Financials 103\\n context.xlre = symbol('IYR') #sid() #Real estate 104\\n context.xlp = symbol('XLP') #sid(19659) #Consumer Staples 205\\n context.xlv = symbol('XLV') #sid(19661) #Health Care 206\\n context.xlu = symbol('XLU') #sid(19660) #Utilities 207\\n context.xtl = symbol('IYZ') #sid() #Communication Services 308\\n context.xle = symbol('XLE') #sid(19655) #Energy 309\\n context.xli = symbol('XLI') #sid(19657) #Industrials 310\\n context.xlk = symbol('XLK') #sid(19658) #Technology 311\\n \\n context.ETF_lookup = {context.xlb:101, 101:context.xlb,\\n context.xly:102, 102:context.xly,\\n context.xlf:103, 103:context.xlf,\\n context.xlre:104, 104:context.xlre,\\n context.xlp:205, 205: context.xlp,\\n context.xlv:206, 206: context.xlv,\\n context.xlu:207, 207:context.xlu,\\n context.xtl:308, 308:context.xtl,\\n context.xle:309, 309:context.xle,\\n context.xli:310, 310:context.xli,\\n context.xlk:311, 311:context.xlk}\\n\\n context.ETFs = [context.xlb,\\n context.xly,\\n context.xlf,\\n context.xlre,\\n context.xlp,\\n context.xlv,\\n context.xlu,\\n context.xtl,\\n context.xle,\\n context.xli,\\n context.xlk\\n ]\",\n \"def test_startdate(self):\\n req = create_request(query_string={'dates': '7d'})\\n eq_(startdate(req), date.today() - timedelta(days=7))\\n\\n req = create_request(query_string={'dates': 'today'})\\n eq_(startdate(req), date.today())\\n\\n req = create_request(query_string={'day': '2012-05-24'})\\n eq_(startdate(req), datetime(2012, 5, 24))\\n\\n req = create_request(query_string={'week': '2012-05-24'})\\n eq_(startdate(req), datetime(2012, 5, 21))\\n\\n req = create_request(query_string={'day': 'today'})\\n eq_(startdate(req), None)\\n\\n req = create_request()\\n eq_(startdate(req), None)\",\n \"def current_datetime(self):\\n return DateAccessor().today()\",\n \"def getDate(self): # real signature unknown; restored from __doc__\\r\\n pass\",\n \"def onchange_amount(self, cr, uid, ids, amount, rate, partner_id, journal_id, currency_id, ttype, date, payment_rate_currency_id, company_id, context=None):\\n if not context:\\n context = {}\\n default = super(account_voucher, self).onchange_amount(cr, uid, ids, amount, rate, partner_id, journal_id, currency_id, ttype, date, payment_rate_currency_id, company_id, context=context)\\n if 'value' in default:\\n amount = 'amount' in default['value'] and default['value']['amount'] or amount\\n amount_in_word = amount_to_text(amount)\\n default['value'].update({'amount_in_word':amount_in_word})\\n if journal_id:\\n allow_check_writing = self.pool.get('account.journal').browse(cr, uid, journal_id, context=context).allow_check_writing\\n default['value'].update({'allow_check':allow_check_writing})\\n return default\",\n \"def get_context_data(self, **kwargs):\\n context = super(LoginRequiredMixin, self).get_context_data(**kwargs)\\n date = self.get_date()\\n context['date'] = date\\n context['prev_date'] = date - datetime.timedelta(days=1)\\n context['next_date'] = date + datetime.timedelta(days=1)\\n form_class = self.get_form_class()\\n context['form'] = self.get_form(form_class)\\n context['progress'] = self.get_percent_completed()\\n return context\",\n \"def test_handler_date_fail(self):\\n\\n @intent_handler(False)\\n def decorated_test(date: datetime.date):\\n return date\\n\\n r = create_request(\\\"TEST_CONTEXT\\\", date=[\\\"not a date\\\"])\\n with self.assertRaises(EntityValueException):\\n result = decorated_test(r)\",\n \"def EstimateFee(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def __get_settlement_date():\\n day_after_tomorrow = datetime.now(timezone.utc).date() + \\\\\\n timedelta(days=2)\\n settlement_date = day_after_tomorrow.strftime(\\\"%Y%m%d\\\")\\n\\n return settlement_date\",\n \"def today(cls):\\n return date()\",\n \"def expense_history(request):\\n qs: QuerySet = Expense.objects.by_user(request.user.id)\\n file_title: str = \\\"Latest_150_Expenses\\\"\\n form = ExpenseHistory(request.GET)\\n if form.is_valid():\\n cd: dict = form.cleaned_data\\n target: str = cd[\\\"target\\\"]\\n user_id = request.user.id\\n if target == \\\"date\\\":\\n qs = Expense.objects.filter(date=cd[\\\"date1\\\"], user_id=user_id)\\n file_title = f'For_{cd[\\\"date1\\\"]}'\\n elif target == \\\"each_month\\\":\\n qs = Expense.objects.filter(date__month=cd[\\\"month\\\"], user_id=user_id)\\n file_title = f\\\"Every_{calendar.month_name[cd['month']]}_Month\\\"\\n elif target == \\\"months\\\":\\n qs = Expense.objects.last_n_months_expense(cd[\\\"p_months\\\"], user_id)\\n file_title = f\\\"Last_{cd['p_months']}_months\\\"\\n elif target == \\\"month\\\":\\n qs = Expense.objects.month_expense(cd[\\\"month\\\"], cd[\\\"year\\\"], user_id)\\n file_title = f'For_{calendar.month_name[cd[\\\"month\\\"]]}-{cd[\\\"year\\\"]}'\\n elif target == \\\"year\\\":\\n qs = Expense.objects.year_expense(cd[\\\"year\\\"], user_id)\\n file_title = f\\\"{cd['year']}\\\"\\n elif target == \\\"between\\\":\\n qs = Expense.objects.filter(date__gte=cd[\\\"date1\\\"], date__lte=cd[\\\"date2\\\"],\\n user__id=user_id)\\n file_title = f'Between_{cd[\\\"date1\\\"]}_{cd[\\\"date2\\\"]}'\\n qs = qs.order_by(\\\"-date\\\", \\\"-id\\\").values_list(\\n \\\"date\\\", \\\"description\\\", \\\"category__name\\\", \\\"method\\\", \\\"app\\\", \\\"amount\\\",\\n )\\n if not form.is_valid():\\n qs = qs[:150]\\n qs_list = []\\n if qs:\\n for q in qs:\\n qs_list.append([\\n q[0], q[1], q[2], METHOD_DICT[q[3]], APP_DICT.get(q[4], \\\"Other\\\"), q[5]\\n ])\\n file_title = f\\\"{date.today()}_\\\" + file_title\\n return render(request, \\\"tracker/history.html\\\",\\n {\\\"qs\\\": qs_list, \\\"file_title\\\": file_title, \\\"form\\\": form})\",\n \"def _request_current_prices(self) -> None:\\n\\n self._request_contract_state(\\n contract_name=self.token_contract_mapping[self.last],\\n callable_=\\\"get_latest_answer\\\",\\n parameters={},\\n )\\n if self.last == \\\"BTC\\\":\\n self.last = \\\"ETH\\\"\\n else:\\n self.last = \\\"BTC\\\"\",\n \"def _set_current_prices(self) -> None:\\n strategy = cast(Strategy, self.context.strategy)\\n eth_price = strategy.contract_status.get(\\n \\\"priceprovider_get_latest_answer\\\", None\\n )\\n btc_price = strategy.contract_status.get(\\n \\\"btcpriceprovider_get_latest_answer\\\", None\\n )\\n\\n if eth_price is None or btc_price is None:\\n self.context.logger.info(\\\"No price to store.....\\\")\\n return\\n self._current_price = {\\n ETH: self._get_price(eth_price),\\n BTC: self._get_price(btc_price),\\n }\",\n \"async def payday(self, ctx: commands.Context):\\r\\n author = ctx.author\\r\\n guild = ctx.guild\\r\\n\\r\\n cur_time = calendar.timegm(ctx.message.created_at.utctimetuple())\\r\\n credits_name = await bank.get_currency_name(ctx.guild)\\r\\n if await bank.is_global(): # Role payouts will not be used\\r\\n\\r\\n # Gets the latest time the user used the command successfully and adds the global payday time\\r\\n next_payday = (\\r\\n await self.config.user(author).next_payday() + await self.config.PAYDAY_TIME()\\r\\n )\\r\\n if cur_time >= next_payday:\\r\\n try:\\r\\n await bank.deposit_credits(author, await self.config.PAYDAY_CREDITS())\\r\\n except errors.BalanceTooHigh as exc:\\r\\n await bank.set_balance(author, exc.max_balance)\\r\\n await ctx.send(\\r\\n _(\\r\\n \\\"You've reached the maximum amount of {currency}!\\\"\\r\\n \\\"Please spend some more \\\\N{GRIMACING FACE}\\\\n\\\\n\\\"\\r\\n \\\"You currently have {new_balance} {currency}.\\\"\\r\\n ).format(\\r\\n currency=credits_name, new_balance=humanize_number(exc.max_balance)\\r\\n )\\r\\n )\\r\\n return\\r\\n # Sets the current time as the latest payday\\r\\n await self.config.user(author).next_payday.set(cur_time)\\r\\n\\r\\n pos = await bank.get_leaderboard_position(author)\\r\\n embed = Embed.create(\\r\\n self, ctx, title=\\\"<:dollarbag:778687019944771616> Payday!\\\",\\r\\n description=(\\r\\n \\\"Here you go, {author.name}. \\\"\\r\\n \\\"Don't spend it too quickly!\\\\n\\\\n\\\"\\r\\n \\\"<:plus:777167188816560168> {amount} dollars have been added to your bank.\\\\n\\\"\\r\\n \\\"You now have {new_balance} dollars. <:dollarbag:778687019944771616>\\\\n\\\\n\\\"\\r\\n \\\"You are currently #{pos} on the **global** leaderboard!\\\\n\\\"\\r\\n \\\"Use `dem leaderboard` to review your position further.\\\\n\\\"\\r\\n \\\"Use `dem slot <bid>` to take a gamble at the slot machine!\\\"\\r\\n ).format(\\r\\n author=author,\\r\\n currency=credits_name,\\r\\n amount=humanize_number(await self.config.PAYDAY_CREDITS()),\\r\\n new_balance=humanize_number(await bank.get_balance(author)),\\r\\n pos=humanize_number(pos)\\r\\n )\\r\\n )\\r\\n await ctx.send(embed=embed)\\r\\n\\r\\n else:\\r\\n dtime = self.display_time(next_payday - cur_time)\\r\\n await ctx.send(\\r\\n _(\\r\\n \\\"{author.mention} Too soon. For your next payday you have to wait {time}.\\\"\\r\\n ).format(author=author, time=dtime)\\r\\n )\\r\\n else:\\r\\n\\r\\n # Gets the users latest successfully payday and adds the guilds payday time\\r\\n next_payday = (\\r\\n await self.config.member(author).next_payday()\\r\\n + await self.config.guild(guild).PAYDAY_TIME()\\r\\n )\\r\\n if cur_time >= next_payday:\\r\\n credit_amount = await self.config.guild(guild).PAYDAY_CREDITS()\\r\\n for role in author.roles:\\r\\n role_credits = await self.config.role(\\r\\n role\\r\\n ).PAYDAY_CREDITS() # Nice variable name\\r\\n if role_credits > credit_amount:\\r\\n credit_amount = role_credits\\r\\n try:\\r\\n await bank.deposit_credits(author, credit_amount)\\r\\n except errors.BalanceTooHigh as exc:\\r\\n await bank.set_balance(author, exc.max_balance)\\r\\n await ctx.send(\\r\\n _(\\r\\n \\\"You've reached the maximum amount of {currency}! \\\"\\r\\n \\\"Please spend some more \\\\N{GRIMACING FACE}\\\\n\\\\n\\\"\\r\\n \\\"You currently have {new_balance} {currency}.\\\"\\r\\n ).format(\\r\\n currency=credits_name, new_balance=humanize_number(exc.max_balance)\\r\\n )\\r\\n )\\r\\n return\\r\\n\\r\\n # Sets the latest payday time to the current time\\r\\n next_payday = cur_time\\r\\n\\r\\n await self.config.member(author).next_payday.set(next_payday)\\r\\n \\r\\n pos = await bank.get_leaderboard_position(author)\\r\\n embed = Embed.create(\\r\\n self, ctx, title=\\\"<:dollarbag:778687019944771616> Payday!\\\",\\r\\n description=(\\r\\n \\\"{author.mention} Take a loada' cash. \\\"\\r\\n \\\"Don't spend it took quick!\\\\n\\\\n\\\"\\r\\n \\\"<:plus:777167188816560168> {amount} dollars have been added to your bank.\\\\n\\\"\\r\\n \\\"You now have {new_balance} dollars. <:dollarbag:778687019944771616>\\\\n\\\\n\\\"\\r\\n \\\"You are currently #{pos} on the server leaderboard!\\\"\\r\\n ).format(\\r\\n author=author,\\r\\n currency=credits_name,\\r\\n amount=humanize_number(await self.config.PAYDAY_CREDITS()),\\r\\n new_balance=humanize_number(await bank.get_balance(author)),\\r\\n pos=humanize_number(pos)\\r\\n )\\r\\n )\\r\\n await ctx.send(embed=embed)\\r\\n \\r\\n else:\\r\\n dtime = self.display_time(next_payday - cur_time)\\r\\n await ctx.send(\\r\\n _(\\r\\n \\\"{author.mention} Too soon. For your next payday you have to wait {time}.\\\"\\r\\n ).format(author=author, time=dtime)\\r\\n )\",\n \"def test_GET_startdate(self):\\n self.register_user()\\n result = self.login_user()\\n access_token = json.loads(result.data.decode())['access_token']\\n res = self.client().post('/expenses/', headers=dict(Authorization=\\\"Bearer \\\" + access_token), data=self.expense)\\n self.assertEqual(res.status_code, 201)\\n rv = self.client().post('/expenses/', headers=dict(Authorization=\\\"Bearer \\\" + access_token), data=\\n {'name': 'soda', 'amount': 1122, 'date_of_expense': '10-01-2021'})\\n self.assertEqual(rv.status_code, 201)\\n resl = self.client().get('/expenses/?start_date=01-01-2021', headers=dict(Authorization=\\\"Bearer \\\" + access_token))\\n self.assertEqual(resl.status_code, 200)\\n results = json.loads(resl.data)\\n self.assertEqual(results['items'][0]['date_of_expense'], self.expense['date_of_expense'])\",\n \"def _get_amount_value(\\n self, cr, uid, ids, ifrs_line=None, period_info=None,\\n fiscalyear=None, exchange_date=None, currency_wizard=None,\\n number_month=None, target_move=None, pdx=None, undefined=None,\\n two=None, one_per=False, bag=None, context=None):\\n\\n context = context and dict(context) or {}\\n # TODO: Current Company's Currency shall be used: the one on wizard\\n from_currency_id = ifrs_line.ifrs_id.company_id.currency_id.id\\n to_currency_id = currency_wizard\\n\\n if number_month:\\n if two:\\n context = {\\n 'period_from': number_month, 'period_to': number_month}\\n else:\\n period_id = period_info[number_month][1]\\n context = {'period_from': period_id, 'period_to': period_id}\\n else:\\n context = {'whole_fy': True}\\n\\n # NOTE: This feature is not yet been implemented\\n # context['partner_detail'] = pdx\\n context['fiscalyear'] = fiscalyear\\n context['state'] = target_move\\n\\n if ifrs_line.type == 'detail':\\n res = self._get_sum_detail(\\n cr, uid, ifrs_line.id, number_month,\\n context=context)\\n elif ifrs_line.type == 'total':\\n res = self._get_grand_total(\\n cr, uid, ifrs_line.id, number_month,\\n one_per=one_per, bag=bag, context=context)\\n elif ifrs_line.type == 'constant':\\n res = self._get_constant(cr, uid, ifrs_line.id, number_month,\\n context=context)\\n else:\\n res = 0.0\\n\\n if ifrs_line.type == 'detail':\\n res = self.exchange(\\n cr, uid, ids, res, to_currency_id, from_currency_id,\\n exchange_date, context=context)\\n return res\",\n \"def current_valid_date(self):\\r\\n return datetime.datetime.now().strftime('%Y-%m-%d')\",\n \"def getAmount1(*args):\",\n \"def getAmount2(*args):\",\n \"def set_non_recurring_charge_begin_date(self, begin_date):\\n if begin_date is None:\\n statement_summary_begin_date_element = self.wait().until(EC.presence_of_element_located(self.statement_details_begin_date_locator), 'statement details begin date locator not found before specified time out')\\n non_recurring_charge_begin_date = str(statement_summary_begin_date_element.text)\\n elif begin_date == \\\"\\\":\\n current_date = datetime.date.today()\\n non_recurring_charge_begin_date = \\\"%d/%d/%d\\\" % (current_date.month, current_date.day, current_date.year)\\n else:\\n non_recurring_charge_begin_date = begin_date\\n self.set_value_into_input_field(self.non_recurring_charge_begin_date_locator, non_recurring_charge_begin_date)\\n return non_recurring_charge_begin_date\",\n \"async def daily(self, ctx):\\n if ctx.invoked_subcommand is None:\\n await ctx.send_help(ctx.command)\",\n \"def __init__(self, period=None, date=None):\\r\\n self.period = period\\r\\n self.date = date\",\n \"def buy_stock(self, stock, amount, date=None):\\n if date is None:\\n date = self.date\\n\\n if type(date) is not datetime.datetime and type(date) is not pd.tslib.Timestamp:\\n date = datetime.datetime.strptime(date, \\\"%Y-%m-%d\\\")\\n\\n self.order_stock(stock, self.stock_data[stock].position['Position'][date] + amount, date)\",\n \"def PricingAddSettlementDate(builder, settlementDate):\\n return AddSettlementDate(builder, settlementDate)\",\n \"def post_date(context, *args, **kwargs):\\n obj = context['object']\\n date_format = kwargs.get('format', \\\"l j, F\\\")\\n return date(obj.publication_date, date_format)\",\n \"def getdate():\\r\\n import datetime\\r\\n return datetime.datetime.now()\",\n \"def _determine_types(self):\\n try:\\n self.date = parse(self.kwargs.get('date'))\\n self.description = self.kwargs.get('description').strip()\\n self.amount = Decimal(self.kwargs.get('amount'))\\n self.checksum = hashlib.md5(u''.join(self.kwargs.values())\\n .encode('utf-8')).digest()\\n except (ValueError, InvalidOperation) as e:\\n raise InvalidTransaction(\\\"Can't make a transaction from {0} - {1}\\\"\\n .format(self.kwargs, e))\",\n \"def initialize(context):\\n context.stocks = {symbol(\\\"TMF\\\"): 0.2, symbol(\\\"UJB\\\"): 0.2, symbol(\\\"TQQQ\\\"): 0.6}\\n\\n context.target_leverage = 1\\n\\n schedule_function(\\n rebalance, date_rules.every_day(), time_rules.market_open(minutes=11)\\n )\",\n \"def before_trading_start(context, data):\",\n \"async def paydayamount(self, ctx: commands.Context, creds: int):\\r\\n guild = ctx.guild\\r\\n max_balance = await bank.get_max_balance(ctx.guild)\\r\\n if creds <= 0 or creds > max_balance:\\r\\n return await ctx.send(\\r\\n _(\\\"Amount must be greater than zero and less than {maxbal}.\\\").format(\\r\\n maxbal=humanize_number(max_balance)\\r\\n )\\r\\n )\\r\\n credits_name = await bank.get_currency_name(guild)\\r\\n if await bank.is_global():\\r\\n await self.config.PAYDAY_CREDITS.set(creds)\\r\\n else:\\r\\n await self.config.guild(guild).PAYDAY_CREDITS.set(creds)\\r\\n await ctx.send(\\r\\n _(\\\"Every payday will now give {num} {currency}.\\\").format(\\r\\n num=humanize_number(creds), currency=credits_name\\r\\n )\\r\\n )\",\n \"def test_add_flow_request_only_one_validity_date_provided(self):\\n for param in ('start_validity', 'expire_validity'):\\n flow_request = self.flow_request.copy()\\n del flow_request['start_validity']\\n res = self._add_flow_request(flow_request=flow_request)\",\n \"def date():\\r\\n try:\\r\\n curr_date = datetime.datetime.now().strftime(\\\"%b %d %Y\\\")\\r\\n except Exception as e:\\r\\n print(e)\\r\\n curr_date = False\\r\\n return curr_date\",\n \"def _check_date_not_in_future(self, date):\\n if date is None:\\n pass\\n else:\\n assert (\\n date <= datetime.datetime.now()\\n ), \\\"Provided date cannot be in the future\\\"\",\n \"def check_today(self):\\n import time\\n _time = time.time\\n time.time = lambda: 1003539807.89\\n try:\\n assert Date(\\\"today\\\") == Date(\\\"10/19/2001\\\"), \\\"wrong date\\\"\\n finally:\\n time.time = _time\",\n \"def __init__(self, value=None, date=None):\\n self.value = value\\n self.date = date\",\n \"def getDefaultCurrency():\",\n \"async def daily(self, ctx: commands.Context):\\n self.check_if_exist(ctx.guild)\\n\\n if ctx.invoked_subcommand == None:\\n await ctx.reply(\\\"Options: `channel`, `timezone`, `ping`\\\")\",\n \"def today(self):\\n return(datetime.date.today().isoformat())\",\n \"def do_fee(self,args):\\n totalamount,fee,howmanyto,nexttier = bitstamp.fee_schedule()\\n print \\\"Your 30 day volume is: %.5f. Your trade fee is: %.2f%%\\\" % (totalamount,fee)\\n print \\\"You are $%s away from the next tier of: $%s\\\" % (howmanyto,nexttier)\",\n \"def date(self):\",\n \"def db_date():\\n return datetime.datetime.now()\",\n \"def __init__(self, name=\\\"\\\", date=None):\\n super().__init__(\\\"date\\\", name)\\n self.date = date\",\n \"def check_date(date):\\n\\timport datetime\\n\\tif date < datetime.date.today():\\n\\t\\treturn date\\n\\telse:\\n\\t\\treturn datetime.date.today()\",\n \"def today():\\n request_today = request.date\\n today = datetime.date.today()\\n print(request.headers, request.url)\\n print(request_today)\\n print(today)\\n day = today.day\\n month = today.month\\n holidays = holidays_date(month, day)\\n\\n return jsonify({\\\"day\\\": day, \\\"month\\\": month, \\\"holidays\\\": [h.holiday for h in holidays]})\",\n \"def make_instance(self, include_optional):\\n # model = openapi_client.models.todays.Todays() # noqa: E501\\n if include_optional :\\n return Todays(\\n instrumentToken = 56, \\n normal = 1.337, \\n supermultiple = 1.337, \\n mtf = 1.337, \\n actualNetTrdValue = 1.337, \\n averageStockPrice = 1.337, \\n buyOpenQtyLot = 56, \\n buyOpenVal = 1.337, \\n buyTradedQtyLot = 56, \\n buyTradedVal = 1.337, \\n buyTrdAvg = 1.337, \\n deliveryStatus = 56, \\n denominator = 56, \\n exchange = '0', \\n exposureMargin = 56, \\n exposureMarginTotal = 56, \\n grossUtilization = 1.337, \\n instrumentName = '0', \\n lastPrice = 1.337, \\n marginType = '0', \\n maxCODQty = 56, \\n multiplier = 56, \\n netTrdQtyLot = 56, \\n netTrdValue = 1.337, \\n normalSqOffQty = 1.337, \\n premium = 1.337, \\n rbiRefRate = 56, \\n realizedPL = 1.337, \\n sellOpenQtyLot = 56, \\n sellOpenVal = 56, \\n sellTradedQtyLot = 56, \\n sellTradedVal = 56, \\n sellTrdAvg = 1.337, \\n spanMargin = 56, \\n spanMarginTotal = 1.337, \\n spreadTotal = 1.337, \\n totalStock = 56\\n )\\n else :\\n return Todays(\\n )\",\n \"def new_tx(new_trade):\\n try:\\n assert(len(new_trade) == 2)\\n tx_date = dt.date.fromisoformat(new_trade[0])\\n amt = float(new_trade[1])\\n except:\\n raise Exception(\\n \\\"Transaction must be in list format as\\\"\\n + \\\" an array of string (valid date of transaction\\\"\\n + \\\" before today) and float (amount invested):\\\"\\n + \\\" [YYYY-MM-DD, amount].\\\"\\n )\\n return [tx_date, amt]\",\n \"def on_date(self, date):\\n print 'This is an empty on_date(date={}) function.\\\\nThe user must override this.'.format(date)\\n return self\",\n \"def clean_date(self):\\r\\n from datetime import datetime\\r\\n\\r\\n date = self.cleaned_data[\\\"date\\\"]\\r\\n if date < datetime.now():\\r\\n self.add_error(\\\"date\\\", \\\"You cannot add a date for the past.\\\")\\r\\n return date\",\n \"def withdraw(self, currency, amount, address):\\n pass\",\n \"def __init__(self, amount: int, currency: str):\\n self._amount = amount\\n self._currency = currency\",\n \"def get_amount(self):\\n\\t\\tif self.amount is not None:\\n\\t\\t\\treturn self.amount\\n\\t\\treturn abort(400, {\\\"message\\\" : \\\"please provide the amount to process\\\"})\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5370315","0.53645146","0.53539944","0.53277975","0.5276431","0.5236099","0.5217637","0.51641953","0.516228","0.51084334","0.5088825","0.50885737","0.5048977","0.5037175","0.5029199","0.5022949","0.5022212","0.5007552","0.49963936","0.4955769","0.4952214","0.49518785","0.49396265","0.49233785","0.49199858","0.49055284","0.48858982","0.486853","0.48668772","0.48662457","0.4854406","0.4848283","0.483706","0.48296806","0.4820917","0.4816664","0.48145282","0.47930947","0.47830567","0.47787192","0.47767282","0.47641128","0.47571516","0.47470975","0.47186407","0.47182763","0.4717845","0.47114888","0.46902537","0.4688986","0.4688374","0.46869305","0.46791553","0.46783724","0.4678034","0.46742323","0.4671851","0.46611345","0.4660916","0.46601057","0.46600372","0.46588403","0.4658221","0.46574932","0.46480927","0.4641583","0.46342027","0.46297976","0.46279067","0.46186024","0.4614374","0.4607183","0.46054262","0.45903578","0.45874363","0.45807","0.45779395","0.4571028","0.4567062","0.45641547","0.45572662","0.45552656","0.4553461","0.45522767","0.45493448","0.4545672","0.45433167","0.454249","0.4540191","0.45399603","0.45358944","0.45333916","0.45280692","0.45176363","0.4515531","0.4514118","0.4512691","0.45106196","0.45079088","0.45055553","0.45013446"],"string":"[\n \"0.5370315\",\n \"0.53645146\",\n \"0.53539944\",\n \"0.53277975\",\n \"0.5276431\",\n \"0.5236099\",\n \"0.5217637\",\n \"0.51641953\",\n \"0.516228\",\n \"0.51084334\",\n \"0.5088825\",\n \"0.50885737\",\n \"0.5048977\",\n \"0.5037175\",\n \"0.5029199\",\n \"0.5022949\",\n \"0.5022212\",\n \"0.5007552\",\n \"0.49963936\",\n \"0.4955769\",\n \"0.4952214\",\n \"0.49518785\",\n \"0.49396265\",\n \"0.49233785\",\n \"0.49199858\",\n \"0.49055284\",\n \"0.48858982\",\n \"0.486853\",\n \"0.48668772\",\n \"0.48662457\",\n \"0.4854406\",\n \"0.4848283\",\n \"0.483706\",\n \"0.48296806\",\n \"0.4820917\",\n \"0.4816664\",\n \"0.48145282\",\n \"0.47930947\",\n \"0.47830567\",\n \"0.47787192\",\n \"0.47767282\",\n \"0.47641128\",\n \"0.47571516\",\n \"0.47470975\",\n \"0.47186407\",\n \"0.47182763\",\n \"0.4717845\",\n \"0.47114888\",\n \"0.46902537\",\n \"0.4688986\",\n \"0.4688374\",\n \"0.46869305\",\n \"0.46791553\",\n \"0.46783724\",\n \"0.4678034\",\n \"0.46742323\",\n \"0.4671851\",\n \"0.46611345\",\n \"0.4660916\",\n \"0.46601057\",\n \"0.46600372\",\n \"0.46588403\",\n \"0.4658221\",\n \"0.46574932\",\n \"0.46480927\",\n \"0.4641583\",\n \"0.46342027\",\n \"0.46297976\",\n \"0.46279067\",\n \"0.46186024\",\n \"0.4614374\",\n \"0.4607183\",\n \"0.46054262\",\n \"0.45903578\",\n \"0.45874363\",\n \"0.45807\",\n \"0.45779395\",\n \"0.4571028\",\n \"0.4567062\",\n \"0.45641547\",\n \"0.45572662\",\n \"0.45552656\",\n \"0.4553461\",\n \"0.45522767\",\n \"0.45493448\",\n \"0.4545672\",\n \"0.45433167\",\n \"0.454249\",\n \"0.4540191\",\n \"0.45399603\",\n \"0.45358944\",\n \"0.45333916\",\n \"0.45280692\",\n \"0.45176363\",\n \"0.4515531\",\n \"0.4514118\",\n \"0.4512691\",\n \"0.45106196\",\n \"0.45079088\",\n \"0.45055553\",\n \"0.45013446\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":92894,"cells":{"query":{"kind":"string","value":"lists all entries, displays the total amount and budgets if defined."},"document":{"kind":"string","value":"def ls(config, args):\n\tresult = read()\n\tif args == []:\n\t\t_prettyprint(result)\n\telse:\n\t\tfor arg in args:\n\t\t\tif \"@\" == arg[0]:\n\t\t\t\tresult = list(filter(lambda x: _is_in(arg[1:], x[\"context\"]),\n\t\t\t\t\tresult))\n\t\tif \"since\" in args:\n\t\t\ttry:\n\t\t\t\tdate = datetime.datetime.strptime(args[args.index(\"since\")+1],\n\t\t\t\t\"%Y-%m-%d\").strftime(\"%Y-%m-%d\")\n\t\t\t\tresult = list(filter(lambda x: _is_newer(x[\"date\"], date), result))\n\t\t\texcept(IndexError, ValueError):\n\t\t\t\tprint(\"You must use a valid date-format after since (YYYY-MM-DD)\")\n\t\t\t\thelp()\n\t\t\t\treturn\n\t\telif \"month\" in args:\n\t\t\ttry:\n\t\t\t\traw_start_date = datetime.datetime.strptime(\n\t\t\t\t\t\targs[args.index(\"month\")+1],\n\t\t\t\t\t\t\"%Y-%m\")\n\t\t\t\tstart_date = raw_start_date.strftime(\"%Y-%m-%d\")\n\t\t\t\tend_date = (raw_start_date +\n\t\t\t\t\t relativedelta(months=1, days=-1)).strftime(\"%Y-%m-%d\")\n\t\t\t\tresult = list(filter(\n\t\t\t\t\tlambda x: _is_newer(x[\"date\"], start_date), result))\n\t\t\t\tresult = list(filter(\n\t\t\t\t\tlambda x: _is_newer(end_date, x[\"date\"]), result))\n\t\t\texcept(IndexError, ValueError):\n\t\t\t\tprint(\"You must use a valid date-format after month (YYYY-MM)\")\n\t\t\t\thelp()\n\t\t\t\treturn\n\t\t_prettyprint(result)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def view_budgets(self) -> None:\n Menu.prompt_view_budgets()\n for budget in self.user.budget_manager:\n print(f\"{budget}\\n\")","def view(self):\n\n print('Here\\'s your expense and income records:\\n'+' '*3+'Category'+' '*7+\\\n 'Description'+' '*4+'Amount\\n'+'='*40)\n line = 1\n amount = self._initial_money\n for n in self._records:\n m = n.split() # m is a list in the form ['category', 'item', 'money']\n print(f'{line:<3}{m[0]:<15}{m[1]:<15}{m[2]}')\n amount += int(m[2])\n line += 1\n print('='*40 + f'\\nNow you have {amount} dollars.')","def print_the_contents_of_all_entries(self):\n\n if len(self.student_list):\n self.print_dataframe(self.student_list)\n else:\n print('There is no contents to show')","def display_all(self) -> None:\n self.display.draw_list(self.read_all_statuses())","def list_all(request):\n\n entries = BlogEntry.objects.all()\n data = {'entries': paginate_objects(request, entries),\n 'blog_info': get_blog_info(), 'action_str': 'All Blogs Shown'}\n\n return render_to_response('blog/list_entries.html', data,\n context_instance=get_rq(request))","def list_entries(entries, search, field):\n clear()\n if entries:\n print(\"Your search results for {}:\\n\".format(search))\n for entry in entries:\n print(getattr(entry, field))\n input(\"Press enter to continue.\")\n view_entries(entries)\n else:\n input(\"No results for {}. Press enter to continue. \".format(search))\n menu_loop()","def summary_list(request):\r\n qs = Summary.objects.all()\r\n context = {'summary_records': qs}\r\n return render(request, 'weather/summary_list.html', context)","def show_all_entries(user_id):\n\n # prevents the public for accessing user specific information\n if not session.get(\"user_id\") or session[\"user_id\"] != user_id:\n return redirect(\"/\")\n\n # grab all the users entries\n user = User.query.get(user_id)\n entries = (\n Entry.query.filter_by(user_id=user_id).order_by(desc(\"date_created\")).all()\n )\n\n page, per_page, offset = get_page_args(\n page_parameter=\"page\", per_page_parameter=\"per_page\"\n )\n\n per_page = 5\n\n offset = (page - 1) * per_page\n total = len(entries)\n\n pagination_entries = entries[offset : offset + per_page]\n pagination = Pagination(\n page=page, per_page=per_page, total=total, css_framework=\"bootstrap4\"\n )\n\n return render_template(\n \"all-entries.html\",\n entries=pagination_entries,\n user=user,\n page=page,\n per_page=per_page,\n pagination=pagination,\n )","def display_list(the_list):\n print(\"\\n===================================\")\n for person in the_list:\n print(\"{name:12s}\\t\\t{phone}\".format(name=person.name, phone=person.phone))\n if the_list == []:\n print(\"\\nNo entries found!\\n\")\n print(\"===================================\\n\")","def show_entries():\n db = get_db()\n cur = db.execute('select id, title, ingredients, steps, tags, \\\n url from entries order by id asc')\n entries = cur.fetchall()\n return render_template('show_entries.html', entries=entries)","def show_all(thing):\n db = get_db()\n cursor = db.cursor()\n cursor.execute(\"select * from %s\" % thing.table_name)\n entries = cursor.fetchall()\n\n add_template_variable('thing', thing)\n add_template_variable('entries', entries)\n return my_render_template('generic/show_all.html')","def show_entries():\n db = get_db()\n cur = db.execute('select distinct name,repo_id,stars, description from python_repos order by stars desc')\n entries = cur.fetchall()\n # get api\n results = get_api()\n # The update operation will consist of deletion and insertion for efficiency\n delete_entry(results)\n add_entry(results)\n return render_template('index.html', entries=entries)","def display_entries(self, entries):\n entries = list(entries)\n if len(entries) == 0:\n print(\"\\nNo results were found.\\n\")\n input(\"Press enter to return to the main menu...\")\n self.main_menu()\n counter = 0\n error = None\n while True:\n self.clear_screen()\n if len(entries) == 0:\n print(\"There are no more entries!\")\n input(\"Press enter to return to the main menu...\")\n self.main_menu()\n if error:\n print(error)\n input(\"Press enter to continue...\")\n self.clear_screen()\n error = None\n self.display_entry(entries[counter])\n print(\"\\nWhat would you like to do?\")\n print(\" N: Next entry (Default)\")\n print(\" p: Previous entry\")\n print(\" e: Edit entry\")\n print(\" d: Delete entry\")\n print(\" q: Quit to main menu\")\n user_input = input(\"Next, previous, edit, delete, quit: \").lower()\n if user_input == 'q':\n self.main_menu()\n elif user_input == 'p':\n if counter <= 0:\n error = \"End of list. Can't go back.\"\n continue\n counter -= 1\n elif user_input == 'd':\n self.delete_entry(entries[counter].id)\n del entries[counter]\n if counter > len(entries) - 1:\n counter -= 1\n print('Entry deleted!')\n input(\"Press enter to continue...\")\n elif user_input == 'e':\n self.edit_entry(entries[counter])\n else:\n counter += 1\n if counter > len(entries) - 1:\n counter -= 1\n error = \"End of list. Can't move forward.\"","def index():\n\n rows = db.execute(\n 'SELECT symbol, SUM(CASE WHEN operation = \"SELL\" THEN -shares ELSE shares END) shares FROM transactions WHERE id = :id GROUP BY symbol;', id=session['user_id'])\n\n cash = db.execute('SELECT cash FROM users WHERE id = :id', id=session['user_id'])[0]['cash']\n\n grand_total = cash\n\n for row in rows:\n stock = lookup(row['symbol'])\n\n row['name'] = stock['name']\n row['price'] = stock['price']\n row['total'] = row['shares'] * stock['price']\n\n grand_total += row['shares'] * stock['price']\n\n rows.append({\n 'symbol': 'CASH',\n 'cash': cash,\n 'total': grand_total\n })\n\n return render_template('index.html', stocks=rows)","def print_entries(self):\n self.print_selected_entries(self.entries)","def display_all(self):\n print(\"Price: \" + str(self.price))\n print(\"Speed: \" + str(self.speed) + \"mph\")\n print(\"Fuel: \" + self.fuel)\n print(\"Mileage: \" + str(self.mileage) + \"mpg\")\n print(\"Tax: \" + str(self.tax))\n return self","def display(self):\r\n\t\tfor each_item in self.items:\r\n\t\t\teach_item.display()","def index():\n holdings = db.execute(\"SELECT symbol, amount FROM stocks WHERE stocks.user_id = :userid AND amount != 0\", userid = session[\"user_id\"])\n total = 0\n\n for row in holdings:\n sDict = lookup(row['symbol'])\n row['name'] = sDict['name']\n row['share_total'] = sDict['price'] * row['amount']\n total += row['share_total']\n\n row['price'] = usd(sDict['price'])\n row['share_total'] = usd(row['share_total'])\n\n cash = db.execute(\"SELECT cash FROM users WHERE id = :userid\", userid = session[\"user_id\"])\n cash = cash[0][\"cash\"]\n total += cash\n\n return render_template(\"index.html\", holdings=holdings, cash=usd(cash), total=usd(total))","def index():\n rows = db.execute(\"SELECT Symbol, SUM(Shares) as totalShares FROM cash WHERE id=:id GROUP BY Symbol HAVING totalShares > 0\", id=session[\"user_id\"])\n transactions=[]\n grand_total = 0\n for row in rows:\n stock = lookup(row[\"Symbol\"])\n transactions.append({\n \"Symbol\": stock[\"symbol\"],\n \"Name\": stock[\"name\"],\n \"Shares\": row[\"totalShares\"],\n \"Price\": usd(stock[\"price\"]),\n \"Total\": usd(stock[\"price\"] * row[\"totalShares\"])\n })\n grand_total += stock[\"price\"] * row[\"totalShares\"]\n rows = db.execute(\"SELECT cash FROM users WHERE id=:id\", id=session[\"user_id\"])\n cash = rows[0][\"cash\"]\n return render_template(\"table.html\", transactions=transactions, cash=usd(cash), grand_total=usd(grand_total))","def index():\n # query database to get cash on hand\n user_cash = db.execute(\"SELECT cash FROM users WHERE id = :user_id\", user_id=session[\"user_id\"])[0][\"cash\"]\n\n # query database to get current holdings from transactions list\n stocks = db.execute(\n \"SELECT symbol, SUM(shares) AS shares, price FROM transactions WHERE user_id = :user_id GROUP BY symbol\", user_id=session[\"user_id\"])\n\n # assign names and totals for stocks\n for stock in stocks:\n stock_lookup = lookup(stock[\"symbol\"])\n stock[\"name\"] = stock_lookup[\"name\"]\n stock[\"total\"] = stock[\"shares\"] * stock_lookup[\"price\"]\n\n stocks[:] = [stock for stock in stocks if stock.get(\"shares\") > 0]\n\n totals = user_cash + sum([stock[\"total\"] for stock in stocks])\n\n return render_template(\"index.html\", user_cash=user_cash, stocks=stocks, total=totals, usd=usd)","def main():\n account1 = Money(87, 15)\n account2 = Money(5, 5)\n account3 = Money(99, 99)\n\n # Display each account balance\n account1.display()\n account2.display()\n account3.display()\n\n # Now add 20 cents to each\n account1.add_cents(20)\n account2.add_cents(20)\n account3.add_cents(20)\n\n # Display each account balance again\n print()\n account1.display()\n account2.display()\n account3.display()","def index():\n rows=db.execute(\"SELECT * FROM portofolio WHERE user_id=:s\",s=session[\"user_id\"])\n row=db.execute(\"SELECT * FROM users WHERE id=:s\",s=session[\"user_id\"])\n overall=0\n for line in rows:\n overall+=line[\"total\"]\n overall+=row[0][\"cash\"]\n return render_template(\"portofolio.html\",rows=rows,cash=usd(row[0][\"cash\"]),overall=usd(overall))","def dashboard_showall():\n tasks = Task.query.all()\n return render_template('home/taskshowall/dashboard_showall.html',\n tasks=tasks, title=\"Tasks\")","def index():\n inventory = db.execute(\"SELECT symbol,quantity FROM inventory WHERE userid = :uid\", uid=session[\"user_id\"])\n cash = float(db.execute(\"SELECT cash FROM users WHERE id = :userid\", userid=session[\"user_id\"])[0][\"cash\"])\n total = cash\n for i in inventory:\n stock = lookup(i[\"symbol\"])\n i[\"price\"] = stock[\"price\"]\n i[\"name\"] = stock[\"name\"]\n i[\"total\"] = usd(stock[\"price\"] * i[\"quantity\"])\n total += stock[\"price\"] * i[\"quantity\"]\n return render_template(\"index.html\", context={\"inventory\":inventory,\"total\":usd(total),\"cash\":usd(cash)})","def index():\n stocks = db.execute(\"SELECT Symbol, Company, SUM(NumberOfShares) AS Shares, UnitPrice, SUM(TotalPrice) AS TotalPrice FROM \"\n \"portfolio WHERE UserID = :userid GROUP BY Symbol\", userid=session.get(\"user_id\"))\n\n symbol = db.execute(\"SELECT Symbol FROM portfolio WHERE UserID = :userid\", userid=session.get(\"user_id\"))\n\n cash = db.execute(\"SELECT cash FROM users WHERE id = :userid\", userid=session.get(\"user_id\"))\n\n balance = cash[0][\"cash\"]\n grandTotal = 0\n for stock in stocks:\n grandTotal = grandTotal + stock[\"TotalPrice\"]\n\n grandTotal = grandTotal + balance\n\n return render_template(\"index.html\", stockList=stocks, cash=balance, totalAssets=grandTotal, currentUser=session.get(\"user_id\"))","def show_result_totals(act_cnt: int, ind_cnt: int, rep_cnt: int, typ_list: list):\n if max([act_cnt, ind_cnt, rep_cnt]):\n totstub = \"\\nTotal\"\n tots = \"\"\n if \"actor\" in typ_list:\n acts = bold(f\"{act_cnt:,}\")\n tots = f\"{tots}{totstub} actors: {acts}\"\n if \"indicator\" in typ_list:\n inds = bold(f\"{ind_cnt:,}\")\n tots = f\"{tots}{totstub} indicators: {inds}\"\n if \"report\" in typ_list:\n reps = bold(f\"{rep_cnt:,}\")\n tots = f\"{tots}{totstub} reports: {reps}\"\n print(tots)","def display_final_results(*args):\n class_interface, investor_picks, listbox, tckr_file = args\n\n for each_pick in range(len(investor_picks)):\n test = tckr_file[tckr_file.Ticker==investor_picks[each_pick][0]]\n if not (test.empty):\n company_name = list(test.Name.values)[0]\n listbox.insert(tk.END, company_name)","def index():\n rows=db.execute(\"SELECT symbol, SUM(transactions) as amount FROM record WHERE userID=? GROUP BY symbol HAVING transactions\",session[\"user_id\"])\n cash=db.execute(\"SELECT cash FROM users WHERE id=?\",session[\"user_id\"])\n cash_=cash[0][\"cash\"]\n\n #store all the data into a dict so its easier to pass in to html\n display=[]\n total_share=0\n for row in rows:\n symbol=str(row[\"symbol\"])\n print(symbol)\n name=lookup(symbol)[\"name\"]\n shares=int(row[\"amount\"])\n price=float(lookup(symbol)[\"price\"])\n total=float(shares) *price\n total_share+=total\n display.append({'symbol':symbol, 'name':name, 'shares':shares, 'price':price, 'total':total})\n\n total_money=total_share+cash[0][\"cash\"]\n return render_template(\"index.html\",display=display,total_money=total_money,cash=cash_)","def __ui_list_all_persons(self):\n persons_list = self.__person_service.service_get_persons_list()\n\n if len(persons_list) == 0:\n print(\"The list of persons is empty!\")\n else:\n print(\"The list of persons in your agenda:\")\n for person in persons_list:\n print(\" \" + str(person))\n print(\"\")","def print_all(self, lim=100):\n for item in islice(weekdays.return_all(), 0, 100):\n print(item)","def index():\n balance = db.execute(\"SELECT cash FROM users WHERE id = :id\",\n id=session['user_id'])\n balance = balance[0][\"cash\"]\n cash_row = [\"CASH\", \"\", \"\", \"\", usd(balance)]\n all_rows = []\n final_total = balance\n\n #update totalvalue with current price from lookup, in totalshares table\n all_shares = db.execute(\"SELECT symbol, numshares FROM totalshares WHERE id = :id\",\n id=session['user_id'])\n if all_shares != None and len(all_shares) > 0:\n for row in all_shares:\n update_totvalue = row[\"numshares\"] * lookup(row[\"symbol\"])[\"price\"]\n db.execute(\"UPDATE totalshares SET totalvalue = :update_totvalue WHERE id = :id AND symbol = :symbol\",\n update_totvalue=update_totvalue, id=session[\"user_id\"], symbol=row[\"symbol\"])\n\n rows = db.execute(\"SELECT symbol, numshares, totalvalue FROM totalshares WHERE id = :id\",\n id=session['user_id'])\n if rows==None or len(rows) < 1:\n all_rows.append(cash_row)\n return render_template(\"index.html\", all_rows=all_rows, final_total=usd(final_total))\n else:\n for row in rows:\n if row[\"numshares\"] > 0:\n share_row = []\n share_row.append(row[\"symbol\"])\n share_row.append(lookup(row[\"symbol\"])[\"name\"])\n share_row.append(row[\"numshares\"])\n share_row.append(usd(lookup(row[\"symbol\"])[\"price\"]))\n share_row.append(usd(row[\"totalvalue\"]))\n final_total = final_total + row[\"totalvalue\"]\n all_rows.append(share_row)\n all_rows.append(cash_row)\n return render_template(\"index.html\", all_rows=all_rows, final_total=usd(final_total))","def full_listing(request, urlname):\n\tif request.user.is_authenticated():\n\t\tblog = Blog.qa_objects.get(urlname=urlname)\n\t\tposts = BlogEntry.qa_objects.filter(blog=blog, posting_time__lte=datetime.now()).order_by('-posting_time')\n\telse:\n\t\tblog = Blog.objects.get(urlname=urlname)\n\t\tposts = BlogEntry.objects.filter(blog=blog).order_by('-posting_time')\n\treturn render_to_response('blogs/full.html', {'blog': blog, 'posts': posts}, context_instance=RequestContext(request))","def index():\n user = Users.query.get(session.get(\"user_id\"))\n query = db.session.query(Records.symbol, Records.company_name,\n db.func.sum(Records.shares).label(\"shares\")).group_by(Records.symbol,\n Records.company_name).filter(Records.user_id==user.id)\n info = [{}] * query.count()\n grand_total = user.cash\n for i, row in enumerate(query):\n try:\n info[i]['price'] = lookup(row.symbol)['price']\n except:\n info[i]['price'] = 1\n\n info[i]['symbol'] = row.symbol\n info[i]['company_name'] = row.company_name\n info[i]['shares'] = row.shares\n info[i]['value'] = round(row.shares * info[i]['price'], 2)\n grand_total += info[i]['value']\n\n return render_template(\"index.html\", cash=user.cash, rows=info, total=round(grand_total, 2))","def add_entries(entries_list):\r\n #| - add_entries\r\n sum_tot = 0.\r\n for entry in entries_list:\r\n if entry is None:\r\n summand = 0.\r\n else:\r\n summand = entry\r\n sum_tot += summand\r\n\r\n return(sum_tot)\r\n #__|\r","def index():\n from managers import banks_manager, rates_manager\n\n # acquiring number of all banks in DB\n banks_count = banks_manager.get_banks_count()\n\n # acquiring last update time\n updated = rates_manager.get_last_update_time()\n last_update = None if updated is None else updated.strftime('%Y %d %b, %H:%M')\n\n # acquiring list of banks with best USD selling rate\n usd_selling_rate = rates_manager.get_usd_selling_min_rate()\n usd_selling_banks = banks_manager.get_usd_selling_best_rate_banks()\n\n # acquiring list of banks with best EUR selling rate\n eur_selling_rate = rates_manager.get_eur_selling_min_rate()\n eur_selling_banks = banks_manager.get_eur_selling_best_rate_banks()\n\n # acquiring list of banks with best USD buying rate\n usd_buying_rate = rates_manager.get_usd_buying_max_rate()\n usd_buying_banks = banks_manager.get_usd_buying_best_rate_banks()\n\n # acquiring list of banks with best EUR buying rate\n eur_buying_rate = rates_manager.get_eur_buying_max_rate()\n eur_buying_banks = banks_manager.get_eur_buying_best_rate_banks()\n\n # initializing banks data map\n data_map = {\n 'usd_selling_rate': usd_selling_rate,\n 'eur_selling_rate': eur_selling_rate,\n 'usd_buying_rate': usd_buying_rate,\n 'eur_buying_rate': eur_buying_rate,\n 'usd_selling_banks': usd_selling_banks,\n 'eur_selling_banks': eur_selling_banks,\n 'usd_buying_banks': usd_buying_banks,\n 'eur_buying_banks': eur_buying_banks\n }\n return render_template(\"index.html\", title='Home', banks_count=banks_count, last_updated=last_update, data=data_map)","def printall():\n print listAll()","def show_all(self):\n cmodules.showModuleData(\n Options.Author,\n Options.Name,\n Options.Call,\n Options.Category,\n Options.Type,\n Options.Version,\n Options.Description,\n Options.License,\n Options.Datecreation,\n Options.Lastmodified\n )\n self.show_commands()\n self.show_opt()","def index(request):\n\n # Fetches the latest 3 listings published\n listings = Listing.objects.order_by('-list_date').filter(is_published=True)[:3]\n context = {\n 'listings': listings,\n 'state_choices': state_choices,\n 'bedroom_choices': bedroom_choices,\n 'price_choices': price_choices\n }\n return render(request, \"pages/index.html\", context)","def func(self):\n from commands.base_commands.guest import census_of_fealty\n\n fealties = census_of_fealty()\n table = PrettyTable([\"{wFealty{n\", \"{w#{n\"])\n for fealty in fealties:\n table.add_row([fealty, fealties[fealty]])\n self.msg(table)","def list(request):\n return EntryView.__index(request)","def list_viewer(listt):\n\tif len(listt) == 0:\n\t\tprint(\"There are no elements\")\n\t\tprint()\n\telse:\n\t\ti = 0\n\t\tfor dictionary in listt:\n\t\t\ti += 1\n\t\t\tprint(f\"Account #{i} »»\")\n\t\t\tprint(\n\t\t\t\t\"\\tService Name: \", dictionary[\"service\"], \"\\n\",\n\t\t\t\t\"\\tUser Name: \", dictionary[\"user\"], \"\\n\",\n\t\t\t\t\"\\tPassword: \", dictionary[\"password\"], \"\\n\",\n\t\t\t\t)","def list_all(request):\n companies = Company.objects.order_by('-created')\n context = dict(companies=companies)\n return render(request, 'companies/all.html', context)","def all():\n Refresh.committees()\n Refresh.legislators()\n Refresh.bills()","def print_donor_totals_report():\n # # Creating list to hold donors info for printing\n update_lists()\n try:\n print()\n title = ['Donor Name', '| Total Given ', '| Num Gifts',\n ' | Average Gift']\n print('{:<20}{:>14}{:^14}{:>14}'.format(title[0], title[1],\n title[2], title[3]))\n print('-'*65)\n print()\n for donor in donor_totals_list:\n average_gift = float(donor.donation_total) / donor.num_donations\n print('{:<22}{}{:>12.2f}{:>10}{:>8}{:>12.2f}'.format(donor.fullname, '$', donor.donation_total,\n donor.num_donations, '$', average_gift))\n print()\n\n except Exception as e:\n logger.info(f'Error printing donor list at {donor.fullname}')\n logger.info(e)","def listall():\n # I like to define the query separately.\n query = db.product\n\n # List of additional links.\n links = []\n \n links.append(\n dict(header = \"Profit\",\n body = lambda row : produce_profit(row)\n )\n )\n links.append(\n dict(header = \"\",\n body = lambda row : produce_star_btn(row.id)\n )\n )\n links.append(\n dict(header = \"\",\n body = lambda row : produce_pls_minus_btn(row)\n )\n )\n links.append(\n dict(header='',\n body = lambda row : produce_poster_btns(row.id)\n \n )\n )\n \n # Let's get rid of some fields in the add form.\n if len(request.args) > 0 and request.args[0] == 'new':\n db.product.prod_poster.readable = False\n db.product.prod_post_time.writable = False\n db.product.prod_sold.writable = False\n db.product.prod_starred.readable, db.product.prod_starred.writable =False, False\n # Grid definition.\n grid = SQLFORM.grid(\n query, \n field_id = db.product.id, # Useful, not mandatory.\n fields = [db.product.id, db.product.prod_name,\n db.product.prod_in_stock, db.product.prod_sold,\n db.product.prod_price, db.product.prod_cost], \n headers = {'product.prod_name': 'Product Name',\n 'product.prod_in_stock':'In Stock',\n 'product.prod_sold':'Sold', \n 'product.prod_price':'Price', \n 'product.prod_cost':'Cost'},\n links = links,\n # And now some generic defaults.\n details=False,\n create=True, editable=False, deletable=False,\n csv=False, \n user_signature=True, # We don't need it as one cannot take actions directly from the form.\n )\n return dict(grid=grid)","def index():\n\n # Create lists containing values for the table\n symbols = []\n names = []\n shares = []\n totals = []\n prices = []\n\n # Query database for the current amount of cash and stocks\n cash = db.execute(\"SELECT cash FROM users WHERE id = :username\", username=session[\"user_id\"] )[0][\"cash\"]\n stocks = db.execute(\"SELECT * FROM summary WHERE id = :username\", username=session[\"user_id\"] )\n grand = cash\n\n # Append to the lists from the database\n for item in stocks:\n symbol = item[\"symbol\"]\n symbols.append(symbol)\n names.append(lookup(symbol)[\"name\"])\n share = db.execute(\"SELECT shares FROM summary WHERE id = :username AND symbol= :symbol\", username=session[\"user_id\"], symbol=symbol)[0][\"shares\"]\n shares.append(share)\n prices.append(lookup(symbol)[\"price\"])\n total = int(share) * lookup(symbol)[\"price\"]\n totals.append(total)\n grand += total\n\n # Obtain list length\n length = len(symbols)\n\n # Direct users to the index page\n return render_template(\"index.html\", symbols = symbols, length = length, cash=cash, names = names, shares = shares, totals = totals, prices = prices, grand = grand)","def display_contents(CurrentList):\n\n print(\"========================Start of display_contents() Method*\")\n print(\"The number of items in list are :\" + str(len(CurrentList)))\n print(\"----- Fl.ID--- ||sub_T|| reqStart||Dur ||Start||End\")\n # Flight ID||sub_Time||reqStart||reqDuration||actualStart||actualEnd\")\n for j in range(len(CurrentList)):\n print(str(j) + \": \" + CurrentList[j].showFlightInfo())\n print(\"========================END of display_contents() Method *\")","def index(request):\n # Attempt to map highest bid amount to each items' ID.\n di = {}\n for obj in Listing.objects.filter(is_active=True):\n try: \n di[obj.id] = sorted([bid.bid_amount for bid in obj.bids.all()])[-1]\n except:\n di[obj.id] = obj.starting_bid\n \n #print(di) - For Debugging \n\n # Return index template\n return render(request, \"auctions/index.html\", {\n \"listings\": Listing.objects.filter(is_active=True),\n \"di\": di\n })","def display_entry(self, entry):\n border = '-' * 50\n print(border)\n print('Employee: {}'.format(entry.employee_name))\n print('Task Name: {}'.format(entry.task_name))\n print(\"Date: {}\".format(entry.date))\n print(\"Time Spent: {}\".format(entry.time_spent))\n if entry.notes != '':\n print(\"Notes:\\n{}\\n{}\".format('----------', entry.notes))\n print(border)","def display_entries(chat_id, entry_type):\r\n\r\n reply = ''\r\n count = 0\r\n\r\n if entry_type == \"habits\":\r\n items = habit.return_all(chat_id)[0]\r\n elif entry_type == \"categories\":\r\n items = category.return_all(chat_id)\r\n\r\n # print(items)\r\n #\r\n # try:\r\n # for x in items:\r\n # name = items[count][0]\r\n # reply += '/' + str(count + 1) + ' ' + name + '\\n'\r\n # count = count + 1\r\n # except:\r\n # reply = 'You have no entries'\r\n\r\n return items","def view_transactions(self) -> None:\n user_choice = Menu.prompt_view_transactions()\n if user_choice == 5:\n print(\"Returning to main menu...\")\n return\n\n budget_category = BudgetManager.category_mapping[user_choice]\n print(f\"\\nTransactions in the {budget_category.value} \"\n f\"category: \")\n for tx in self.user.tx_manager:\n if tx.budget_category == user_choice:\n print(f\"\\n{tx}\")","def print_entries(entries):\n if len(entries) == 0:\n print(\"\\nNo results were found.\\n\")\n input(\"Press enter to return to the main menu...\")\n start()\n counter = 0\n error = None\n while True:\n clear_screen()\n if len(entries) == 0:\n print(\"There are no more entries!\")\n input(\"Press enter to return to the main menu...\")\n start()\n if error:\n print(error)\n input(\"Press enter to continue...\")\n clear_screen()\n error = None\n print_entry(entries[counter])\n print(\"\\nWhat would you like to do?\")\n print(\" n: Next entry (Default)\")\n print(\" p: Previous entry\")\n print(\" e: Edit entry\")\n print(\" d: Delete entry\")\n print(\" q: Quit to main menu\")\n user_input = input(\"> \").lower()\n if user_input == 'q':\n start()\n elif user_input == 'p':\n if counter <= 0:\n error = \"End of list. Can't go back.\"\n continue\n counter -= 1\n elif user_input == 'd':\n delete_entry(entries[counter]['id'])\n del entries[counter]\n if counter > len(entries) - 1:\n counter -= 1\n elif user_input == 'e':\n edit_entry(entries[counter])\n else:\n counter += 1\n if counter > len(entries) - 1:\n counter -= 1\n error = \"End of list. Can't move forward.\"","def display_available_items(self):\n count = 0\n print(\"Available Items:\")\n for item in self.item_list.values():\n if item.check_availability():\n count += 1\n print(item)\n if count == 0:\n print(\"No items are available\")","def list_dams(request):\n dams = get_all_dams()\n table_rows = []\n\n for dam in dams:\n table_rows.append(\n (\n dam['name'], dam['owner'],\n dam['river'], dam['date_built']\n )\n )\n\n dams_table = DataTableView(\n column_names=('Name', 'Owner', 'River', 'Date Built'),\n rows=table_rows,\n searching=False,\n orderClasses=False,\n lengthMenu=[ [10, 25, 50, -1], [10, 25, 50, \"All\"] ],\n )\n\n context = {\n 'dams_table': dams_table\n }\n\n return render(request, 'co_drought/list_dams.html', context)","def show_total(request):\n user_id = request.user\n end_date = datetime.datetime.utcnow()\n start_date = end_date.replace(day=1,\n hour=datetime.time(0, 0, 0).hour,\n minute=datetime.time(0, 0, 0).minute,\n second=datetime.time(0, 0, 0).second)\n total = 0\n incomes_to_date = IncomeHistory.objects.filter(date__range=(start_date, end_date),\n income_id__owner_id=user_id)\n if not incomes_to_date:\n return HttpResponse(0, status=200)\n\n for income in incomes_to_date:\n if income.is_active:\n total = total + income.value\n return HttpResponse(total, status=200)","def list_log_entries():\n manager = LogBookManager()\n log_entries = manager.list()\n\n if log_entries:\n typer.echo(get_table(log_entries))\n else:\n typer.echo(\n typer.style(\n f'You do not have any entries in your log book.',\n fg=typer.colors.MAGENTA,\n bold=True\n )\n )","def view_entries(search_query=None):\n\n # search_query se ha añadido como funcionalidad extra (search_entries)\n # Por defecto es None, por si no se quiere usar la funcionalidad extra\n # Guarda en una lista todas las entrdas del diario recogidas con el select\n entries = Entry.select().order_by(Entry.timestamp.desc())\n\n if search_query:\n # Con where filtramos todas las entries que cumplen la condicion\n entries = entries.where(Entry.content.contains(search_query))\n\n # Ahora toca mostrarlas con un formato adecuado\n for entry in entries:\n # Primero la fecha\n timestamp = entry.timestamp.strftime('%A %b %d, %Y %I:%M%p')\n clear()\n print(timestamp)\n print('+'*len(timestamp))\n print(entry.content)\n print('\\n\\n'+'+'*len(timestamp) + '\\n') # Pone tantos + como caracteres haya\n print('Enter| siguiente entrada')\n print('d| Borrar entrada')\n print('q| Salir al menu')\n\n # Obtener la siguiente entrada del usuario\n next_action = input('Accion a realizar: [Nq]').lower().strip()\n\n if next_action == 'q':\n break\n elif next_action == 'd':\n delete_entry(entry)","def show_all_tasks(self):\n tasks = self.session.query(self.Table).order_by(self.Table.deadline).all()\n print('All tasks:')\n if tasks:\n for n, task in enumerate(tasks, 1):\n print(f'{n}. {task.task}. {task.deadline.strftime(\"%d %b\")}')\n else:\n print('Nothing to do!')\n print()","def __display(self) -> None:\n ligne = 0\n for key, value in self.values.items():\n self.my_data(self.master, key, value, ligne, 0, 1, 1, 2, 2)\n ligne += 2","def index():\n\n # User reached route via GET (as by clicking a link or via redirect)\n if request.method == \"GET\":\n\n # FORM TABLE total SELECT name for lookup(name) of now price, price, total costmoney ,totalshares\n portf = db.execute(\"SELECT name, symbol, price, sharesTotal, costmoneyTotal FROM total WHERE userID = :userID\", userID=session[\"user_id\"])\n\n # Len of portf list, rows\n porLen = len(portf)\n\n # For loop portf index \"nowPrice\" to new dict, costmoneyTotal\n for item in range(porLen):\n e = portf[item][\"symbol\"]\n nowPrice = lookup(e).get(\"price\")\n portf[item]['nowPrice'] = nowPrice\n portf[item]['costmoneyTotal'] = usd(portf[item]['costmoneyTotal'])\n\n # List reversed\n portf = list(reversed(portf))\n\n\n # FORM TABLE users SELECT end cash\n endPrice = db.execute(\"SELECT cash FROM users WHERE id = :userID\", userID=session[\"user_id\"])\n\n endPrice = usd(endPrice[0][\"cash\"])\n return render_template(\"index.html\", portf=portf, endPrice = endPrice, porLen=porLen)","def display_books(self, results):\n # Check if result is blank\n if not results:\n print(\"\\nNo Books found!!\")\n return\n # construct table and print\n book_schema = LMSLibraryDatabase.book_schema\n table = PrettyTable()\n table.field_names = book_schema\n for result in results:\n table.add_row(result)\n print(\"\\n{}\".format(table))\n self.prompt_borrow_book()","def showAllResults(self):\n \n names = self.jobstable.get_selectedRecordNames()\n if len(names)==1:\n ax,mh,x,y=self.showResults()\n\n else:\n tx=[]; ty=[]\n import pylab as plt\n f=plt.figure(figsize=(8,8))\n ax=f.add_subplot(111)\n for n in names:\n a,mh,x,y = self.showResults(n,showtable=False, ax=ax,stats=False)\n tx.extend(x)\n ty.extend(y) \n ax.legend()\n #add stats for summary\n from Correlation import CorrelationAnalyser\n C = CorrelationAnalyser() \n C.addStats(ax,tx,ty)\n f.show()\n \n return","def show_installations(self):\n database = Database('data/database.db')\n installations = database.read_installations()\n view = Template(filename=\"view/template.html\", lookup=lookup)\n \n \n return view.render(\n rows = [[item.number, item.name, item.address, item.zip_code, item.city, item.latitude, item.longitude] for item in installations],\n pageTitle = \"Installations\",\n tableTitle = \"Liste de toutes les installations\",\n ths = [\"Numéro\", \"Nom\", \"Adresse\", \"Code postal\", \"Ville\", \"Latitude\", \"Longitude\"]\n )","def index():\n rows = db.execute(\"SELECT symbol, SUM(shares) as shares FROM 'transaction' WHERE u_id = :user_id GROUP BY symbol\", user_id = session[\"user_id\"])\n user = db.execute(\"SELECT * FROM 'users' WHERE id = :user_id\", user_id = session[\"user_id\"])\n\n if len(rows) == 0:\n return render_template(\"index.html\", rows = 0, username = user[0][\"username\"], cash = user[0][\"cash\"], total = user[0][\"cash\"])\n\n else:\n cur_price = []\n value = []\n names = []\n total = 0\n for row in rows:\n returned_quote = lookup(row[\"symbol\"])\n cur_price.append(returned_quote[\"price\"])\n value.append(round(returned_quote[\"price\"] * row[\"shares\"], 2))\n names.append(returned_quote[\"name\"])\n total = total + round(returned_quote[\"price\"] * row[\"shares\"], 2)\n\t\t\n\t\ttotal = round(total, 2)\n\t\t\n return render_template(\"index.html\", username = user[0][\"username\"], cash = user[0][\"cash\"], total = total, rows = rows, cur_price = cur_price, value = value, names = names)","def print_results(results):\n print(f\"Intial Entries: {results[0]}\")\n print(f\"Added Entries: {results[1]}\")\n print(f\"Final Entries: {results[2]}\")\n print(f\"Total Run Time: {results[3]}\")\n print(\"\\n\")","def amount_gathering(user_recipe):\r\n #Forms Dictionary\r\n sales_stats = dictionary_formation()\r\n amount_list = []\r\n month_list = [\"Nov\", \"Dec\", \"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\",\r\n \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\"]\r\n for month in month_list:\r\n bottles_amount = 0\r\n dicts_read = 2\r\n for dicts_read in sales_stats:\r\n analyse_dict = sales_stats[str(dicts_read)]\r\n if month in analyse_dict[\"date_required\"]:\r\n if analyse_dict[\"recipe\"] == user_recipe:\r\n bottles_amount += analyse_dict[\"quantity_ordered\"]\r\n amount_list.append(bottles_amount)\r\n return amount_list","def show_all_departments():\n\n logger.debug('Function show_all_departments(). Routed to /departments')\n titles = ['Name', 'Average Salary', 'Employees']\n departments = ds.get_all()\n logger.info('Get list of departments, length is %i', len(departments))\n return render_template('departments.html',\n title='Departments',\n table_title='List of Departments',\n headers=titles,\n departments=departments)","def show_all_posts():\n post = Post.query.all()\n\n return render_template('all-posts.html', post=post)","def list(self, request, scope=None):\n\n qs = self.get_queryset()\n if scope == 'summary':\n total = qs.aggregate(total=Sum('total_value'))['total'] or 0.0\n return Response({'total_investment': total}, status=200)\n else:\n serializer = self.get_serializer(qs, many=True)\n return Response(serializer.data, status=status.HTTP_200_OK)","def printAll(self):\n for item in self.items:\n try:\n print(\"=========Post code: \" + item['code'] + \"=============\")\n print(item['caption']['text'])\n except TypeError:\n print(\"(Empty caption text)\")","def list(ctx):\n if ctx.obj.get('NAMESPACE') != 'accounts':\n click.echo(\n click.style('Only account data is available for listing.', fg='red')\n )\n return\n\n swag = create_swag_from_ctx(ctx)\n accounts = swag.get_all()\n _table = [[result['name'], result.get('id')] for result in accounts]\n click.echo(\n tabulate(_table, headers=[\"Account Name\", \"Account Number\"])\n )","def see_all_transfers(request):\n transfers = Transaction.objects.all().order_by('-executed_time')\n return render(request, 'app/allTransfers.html', {'transfers': transfers})","def _display_entries(self, entries):\n uni_print(\"Entries:\\n\\n\")\n for entry in entries:\n uni_print(ordered_yaml_dump(entry))\n uni_print(\"\\n\")","def show_all_habits(self):\n # Clean up the console\n self.clear_console()\n # Prints the name of the application and instructions to the main menu\n self.back_to_menu_info()\n print(\"\"\"\n ALL HABITS REGISTERED\n ________________________________________________\n \"\"\")\n \n # Gets the habits table of the DB\n habits_table = self.analytics.habits_table()\n # IDs of habits without trackings\n ids_without_trackings = self.analytics.ids_without_trackings(\n habits_table,\n # Join of the habits table and the trackings table from the DB\n self.analytics.habits_trackings_table())\n # IDs of habits that have trackings\n ids_with_trackings = self.analytics.ids_with_trackings(habits_table, \n ids_without_trackings)\n if len(ids_with_trackings) != 0:\n # Displays information of tracked habits contained in the habits table in table format\n self.analytics.display_table(\n ('ID', 'HABIT', 'PERIODICITY', 'MOTIVATION', 'DESCRIPTION', 'CREATION DAY'),\n # Gets all the tracked habits\n self.analytics.tracked_habits(\n habits_table,\n # Join of the habits table and the trackings table from the DB\n self.analytics.habits_trackings_table()),\n 'TRACKED HABITS'\n )\n print('')\n\n if len(ids_without_trackings) != 0:\n # Habits without trackings in tabular form\n self.table_untracked_habits(habits_table,\n ids_without_trackings)\n print('')\n # Return to the main menu by selecting the number zero\n self.return_menu()","def index():\n\n stocks_owned = db.execute(\"SELECT DISTINCT stock FROM transaction WHERE id = :id;\", id=session['user_id'])\n\n number_of_rows= len(stocks_owned) - 1\n\n i = 0\n\n total_value=0\n\n for stock in stocks_owned:\n\n stock_list=[]\n stock_list[i]=stock\n\n value = db.execute(\"SELECT SUM(total_amount) FROM transaction WHERE id = :id GROUP BY stock HAVING stock=:stock\", id=session['usestockr_id'], stock=stocks_owned[\"stock\"])\n value_list=[]\n value_list[i] = value\n\n amount_owned = db.execute(\"SELECT SUM(amount) FROM transaction WHERE id = :id GROUP BY stock HAVING stock=:stock\", id=session['user_id'], stock = stocks_owned[\"stock\"])\n amount_list=[]\n amount_list[i]= amount_owned\n\n quote_input = stocks_owned[i]\n quote_info = lookup(quote_input)\n price = quote_info['price']\n price_list=[]\n price_list[i] = price\n\n\n total_value+=value\n\n i+=1\n\n cash = db.execute(\"SELECT cash FROM users WHERE id = :id;\", id=session['user_id'])\n\n grand_total = total_value + cash\n\n ###(\"SELECT stock, SUM(total_amount) FROM transaction WHERE id = :id;, id=session['user_id'] GROUP BY stock\")####\n\n\n return render_template(\"index.html\", number_of_rows=number_of_rows, stock_list=stock_list, amount_list=amount_list, value_list=value_list, price_list=price_list, total_value=total_value, grand_total=grand_total)","def list(projectname):\n backedamount=0\n con = lite.connect(databasefile)\n with con:\n cur = con.cursor() \n cur.execute(\"SELECT Id FROM projects where name=?\", (projectname,))\n exists = cur.fetchone()\n if exists:\n cur.execute(\"SELECT * FROM backers where Projectname=?\", (projectname,))\n rows = cur.fetchall()\n numbackers=len(rows)\n for row in rows:\n backedamount+=row[4]\n click.echo(\"-- %s backed for $%-.2f\" % (row[1],row[4]))\n else:\n click.echo(\"That project doesn't exist!\")\n sys.exit()\n\n cur.execute(\"SELECT Tamount FROM projects where name=?\", (projectname,))\n tamount = cur.fetchone()\n if tamount[0] > backedamount:\n amountneeds = tamount[0] - backedamount\n click.echo(\"%s needs $%-.2f more dollars to be successful. It has %d backers\" % (projectname,amountneeds,numbackers))\n else:\n click.echo(\"%s is successful! It has %d backers\" % (projectname,numbackers))","def show_all_products():\n\n data = cur.execute(\"\"\"SELECT productid, productname, unitcost, stock FROM catalogue\"\"\").fetchall()\n\n print(tabulate(data, headers=[\"Product ID\", \"Name\", \"Cost\", \"Stock\"]))","def all():\n session = session_maker(\n app.config['MYSQL_USER'], app.config['MYSQL_PASS'], app.config['MYSQL_SERVER_PORT_3306_TCP_ADDR'],\n app.config['MYSQL_SERVER_PORT_3306_TCP_PORT'], app.config['DB'])\n\n print(\n tabulate(\n selection_list_all(session),\n headers=['number', 'sqlid', 'name', 'city', 'state']))","def PrintAllCosts():\n\n logs.logger.debug(\"After queries of all costs from database start to print\"\n \" the details (id, reg.date, date of payment, amount,\"\n \" description, category) of the costs to the consol.\")\n try:\n printedCosts = session.query(Cost.Cost).all()\n for cost in printedCosts:\n print(\n f'{cost.id}\\t{cost.registrationDate}\\t{cost.dateOfPayment} \\\n \\t{cost.amount}\\t{cost.description}\\t{cost.category.value}')\n logs.logger.info(\"After queries of all costs from database print\"\n \" the details (id, reg.date, date of payment, amount,\"\n \" description, category) of the costs to the consol.\")\n except Exception as e:\n logs.logger.error(e, exc_info=True)","async def _list(self, ctx):\n server = ctx.message.server\n if server.id not in self.db:\n self.db[server.id] = {}\n self.save_db()\n await self.bot.say(\"List is empty, please add members first using [p]points add <Discord name or nickname>\")\n return\n else:\n db = self.db[server.id]\n try:\n columns = [sorted([y for y in self.db[server.id][x].keys()], reverse=True)\n for x in db if x != \"bookkeeper\"][0]\n i, j = columns.index(columns[1]), columns.index(columns[2])\n columns[i], columns[j] = columns[j], columns[i]\n rows = sorted([[db[x][\"Name\"], db[x][\"Lifetime Gain\"], db[x][\"Lifetime Loss\"], db[x][\"Balance\"]]\n for x in db if x != \"bookkeeper\"], key=itemgetter(3, 0), reverse=True)\n except IndexError:\n await self.bot.say(\"No one has been added to the list, please use points member add\"\n \" <Discord name or nickname> to do so first.\")\n return\n if len(rows) > 15:\n n = 14\n l = 15\n m = 0\n\n for x in range(n, len(rows)+15, l):\n if x == n:\n await self.bot.say(box(tabulate(rows[:x], headers=columns), lang=\"prolog\"))\n else:\n await self.bot.say(box(tabulate(rows[m:x], headers=columns), lang=\"prolog\"))\n m = x\n else:\n await self.bot.say(box(tabulate(rows, headers=columns), lang=\"prolog\"))","def view_all(options, client):\n if options.show_events:\n return display_events(client.events())\n\n return \"\".join([\n display.DisplayServices().format(client.services()),\n '\\n',\n display.DisplayJobs(options).format(client.jobs())\n ])","def show_all_information():\n if not g.user:\n flash(\"Please login to access\", \"danger\")\n return redirect(\"/\")\n if g.user.is_admin == False:\n flash (\"Unauthorized\", \"danger\")\n return redirect(\"/login\")\n\n employees = Employee.query.all()\n all_certs = employee_certification.query.all()\n \n return render_template(\"admin.html\", employees = employees, all_certs = all_certs)","def list_my_contracts(self):\n self.get_my_contracts()\n try:\n for contract in self.my_contracts:\n print('------')\n print(contract.timestamp)\n print(contract.market)\n print(contract.ticker)\n print(contract.shares)\n print(contract.gain_or_loss)\n print(contract.average_price)\n print(contract.buy_price)\n print(contract.sell_price)\n print(contract.estimate_sale_of_current_shares)\n print(contract.implied_odds)\n print(contract.estimate_best_result)\n print('------')\n except TypeError:\n print('You don\\'t have any active contracts!')\n return","def view_bank_account_details(self) -> None:\n Menu.prompt_view_bank_account_details()\n print(\"Bank Account Details:\")\n print(self.user.account)\n\n for tx_num, tx_details in \\\n self.user.tx_manager.transaction_records.items():\n print(f\"\\nTransaction #{tx_num}:\\n\"\n f\"{tx_details}\")\n\n print(f\"\\nSpending Summary:\")\n print(f\" Starting Bank Balance: \"\n f\"{'{:.2f}'.format(self.user.account.starting_balance)}\")\n print(f\" Total Transactions Amount: \"\n f\"{'{:.2f}'.format(self.user.tx_manager.calc_total_spent())}\")\n print(f\" Closing Bank Account Balance: \"\n f\"{'{:.2f}'.format(self.user.account.current_balance)}\")","def all_accounts(request):\n accounts = Account.objects.all()\n return render(request, 'app/home.html', {'accounts': accounts})","def full_table():\n #oen the the file\n list_of_current_account_objects = []\n opened_file = open('customers.txt')\n opened_file.readline()\n for line in opened_file: #get a list of all the customers accounts as objects\n line_array = line.split(\",\")\n customer = Account((line_array[0]+\" \"+line_array[1]),line_array[2],line_array[4])\n list_of_current_account_objects.append(customer)\n #update the savings & current variables for all accounts.\n for i in list_of_current_account_objects:\n i.set_sav_bal(account_bal(i,\"savings\"))\n i.set_cur_bal(account_bal(i,\"current\"))\n\n #print the answer\n print(\"customer customer account number-avings balance-current balance\")\n for i in list_of_current_account_objects:\n print(i.get_name()+\"---\"+i.get_acc_num()+\"---\"+str(i.get_sav_bal())+\"---\"+str(i.get_cur_bal()))\n print()","def index():\n userid = session[\"user_id\"]\n stocks = db.execute(\"SELECT symbol FROM purchase WHERE userid = :userid GROUP BY symbol\",\n userid=userid)\n cash = db.execute(\"SELECT cash FROM users WHERE id = :userid\", userid=userid)\n grand_total = cash[0][\"cash\"]\n if stocks != []:\n storages = list()\n for symbol in stocks:\n stock_data = lookup(symbol[\"symbol\"])\n current_price = stock_data[\"price\"]\n stock_info = dict()\n shares_info = db.execute(\"SELECT SUM(shares) AS shares_sum FROM purchase WHERE userid = :userid\\\n GROUP BY symbol HAVING symbol = :symbol\", userid=userid, symbol=symbol[\"symbol\"])\n current_shares = shares_info[0][\"shares_sum\"]\n if current_shares > 0:\n stock_info[\"symbol\"] = symbol[\"symbol\"]\n stock_info[\"name\"] = stock_data[\"name\"]\n stock_info[\"price\"] = usd(current_price)\n stock_info[\"shares\"] = current_shares\n total = current_price * current_shares\n grand_total += total\n stock_info[\"total\"] = usd(total)\n storages.append(stock_info)\n return render_template(\"index.html\", storages=storages, cash=usd(cash[0][\"cash\"]), grand_total=usd(grand_total))\n else:\n return render_template(\"index.html\", cash=usd(cash[0][\"cash\"]), grand_total=usd(grand_total))\n return render_template(\"index.html\")","def ShowCurrentItemsInList(list_of_rows):\r\n print(\"******* The current items ToDo are: *******\")\r\n for row in list_of_rows:\r\n print(row.product_name + \" (\" + str(row.product_price) + \")\")\r\n print(\"*******************************************\")\r\n print() # Add an extra line for looks\r","def display_fields(self):\r\n\r\n field_text = self.show_fields()\r\n field_text_list = field_text.split(EOL)[0:-1]\r\n\r\n def fld_format (x_temp):\r\n\r\n x_temp = x_temp.split(COLON)[0], x_temp.split(COLON)[1]\r\n\r\n \"\"\"formats output of the list of search results\"\"\"\r\n\r\n if not isinstance(x_temp[1],str):\r\n shown_indexes = rangelist.range_find([int(Index(a_temp))\r\n for a_temp in x_temp[1]],reduce=True)\r\n else:\r\n shown_indexes = x_temp[1]\r\n\r\n if len(shown_indexes) < 20:\r\n return (abridge(x_temp[0]).replace(VERTLINE,SLASH)\r\n +VERTLINE\r\n +shown_indexes)\r\n\r\n\r\n returnlist = []\r\n sp_temp = rangelist.split_up_range(shown_indexes)\r\n\r\n\r\n returnlist.append(x_temp[0].replace(VERTLINE,SLASH)[0:min([60,len(x_temp[0])])]\r\n +VERTLINE+sp_temp[0])\r\n for s_temp in sp_temp[1:]:\r\n returnlist.append(VERTLINE+s_temp)\r\n\r\n return returnlist\r\n\r\n show_list(field_text_list,\r\n alerts.FIELDS[3:],0,40,\r\n func=fld_format,\r\n present=True,\r\n display=display)","def init_totals(self):\r\n for player in range(0, 4):\r\n lbl_total = tk.Label(self.master, text=\"0\", font='courier 10 bold', fg='red',\r\n width=10, borderwidth=2, relief=\"groove\", anchor=\"e\")\r\n lbl_total.grid(row=19, column=player*3+3, sticky=tk.W+tk.E)\r\n self.lbl_totals.append(lbl_total)","def show(self, *args):\n\n super().show(*args)\n\n show_all = len(args) == 0 or args[0] == \"all\"\n\n if show_all or \"entry\" in args:\n self.entry.grid(row=0, column=0, sticky=tk.EW)\n else:\n self.entry.grid_forget()","def display(self):\r\n\t\ts = self.options['space']\r\n\t\tv = self.level\r\n\t\tt = self.options['tab']\r\n\t\tp = self.options['sep']\r\n\t\tb = self.options['bullet']\r\n\t\tprint(v*t+b+s+self.text)\r\n\t\tfor each_item in self.items:\r\n\t\t\teach_item.display()","def index():\n symbols = db.execute(\"SELECT symbol FROM History WHERE id = :id GROUP BY symbol\", id=session['user_id'])\n companies = db.execute(\"SELECT company FROM History WHERE id = :id GROUP BY symbol\", id=session['user_id'])\n get_shares = db.execute(\"SELECT SUM(shares) FROM History WHERE id = :id GROUP BY symbol\", id=session['user_id'])\n shares = [share['SUM(shares)'] for share in get_shares]\n cash = db.execute(\"SELECT cash FROM users WHERE id = :id\", id=session['user_id'])\n\n return render_template(\"index.html\", symbols_companies_shares=zip(symbols, companies, shares), lookup=lookup, cash=cash)","def print_results(flight_info_list, departure_airport, return_airport):\n flight_info_list = sorted(flight_info_list, key=lambda k: k[\"price($)\"])\n\n print \"*********************************************************\"\n print \"Top 10 Cheapest Flights From {} to {}\".format(\n departure_airport,\n return_airport\n )\n print \"*********************************************************\"\n\n for i in flight_info_list[:10]:\n print \"----------------------------------\"\n print json.dumps(i, indent=4)\n\n flight_info_list = sorted(flight_info_list, key=lambda k: k[\"flight_duration(hours)\"])\n\n print \"*********************************************************\"\n print \"Top 10 Shortest Flights From {} to {}\".format(\n departure_airport,\n return_airport\n )\n print \"*********************************************************\"\n \n for i in flight_info_list[:10]:\n print \"----------------------------------\"\n print json.dumps(i, indent=4)\n\n print \"--------------------------------------\"\n print \"Total of %s flights were found\" % len(flight_info_list)\n print \"--------------------------------------\"","def print_all_donor_donations():\n print(\"\\nList of Donors and Donations\")\n print(\"\\nDonor Name - Donation Date - Donation Amount:\")\n print(\"-\"*40)\n for donation in donor_donations_list:\n print(f'{donation.fullname} - {donation.donation_date} - ${donation.donation_amount:,.2f}')\n print()","def display(self):\r\n os.system('cls')\r\n index = 0\r\n for i in self.list:\r\n print(str(index) + \" \" + i.showRule())\r\n index += 1","def index():\n\n # Get user's cash\n user = db.execute(\"SELECT cash FROM users WHERE id = ?\", session[\"user_id\"])\n\n # Get portfolio\n portfolios = db.execute(\"SELECT * FROM portfolios WHERE user_id = ?\", session[\"user_id\"])\n\n # Get symbol for each stock\n length = len(portfolios)\n for i in range(length):\n symbol = portfolios[i]['stocks']\n\n # Lookup stock price and add to portfolio information\n portfolios[i]['price'] = lookup(symbol)['price']\n portfolios[i]['total'] = float(portfolios[i]['price']) * portfolios[i]['shares']\n\n # Calculate total value of stocks\n value = 0\n for j in range(length):\n value += portfolios[j]['price']\n\n # Calculate grand total of stocks plus cash\n g_total = user[0][\"cash\"] + value\n\n return render_template(\"index.html\", portfolios=portfolios, cash=user[0][\"cash\"], g_total=g_total)","def list(self):\n\n for name in self.projects:\n self.projects[name].show()\n print(\"\\n\")","def print_transactions_for_review(self, budget: Budget) -> None:\n print(f'Please review the following transactions in the {budget.name} '\n f'budget:')\n transactions = self.get_transactions_by_budget(budget.category)\n for transaction in transactions:\n print(transaction)","def manage_all():\n user = Staff.is_login()\n if user is None:\n return redirect(url_for('auth.login'))\n\n if user.get_unit_role() == 'staff':\n return redirect(url_for('pengusulan.table'))\n\n pengusulans = Pengusulan.get_by_unit(\n unit_id=user.unit_id,\n status=None\n )\n ranks = Pengusulan.calculate_averages(pengusulans)\n return render_template(\"pengusulan/kelola-table.html\", pengusulans=pengusulans, ranks=ranks, pengusulan_code=pengusulan_code, status=None)","def main():\n \n welcome()\n myBill = get_bill_amt()\n pct = get_tip_pct()\n tip = calc_tip(myBill, pct)\n show_results(myBill, tip, pct)"],"string":"[\n \"def view_budgets(self) -> None:\\n Menu.prompt_view_budgets()\\n for budget in self.user.budget_manager:\\n print(f\\\"{budget}\\\\n\\\")\",\n \"def view(self):\\n\\n print('Here\\\\'s your expense and income records:\\\\n'+' '*3+'Category'+' '*7+\\\\\\n 'Description'+' '*4+'Amount\\\\n'+'='*40)\\n line = 1\\n amount = self._initial_money\\n for n in self._records:\\n m = n.split() # m is a list in the form ['category', 'item', 'money']\\n print(f'{line:<3}{m[0]:<15}{m[1]:<15}{m[2]}')\\n amount += int(m[2])\\n line += 1\\n print('='*40 + f'\\\\nNow you have {amount} dollars.')\",\n \"def print_the_contents_of_all_entries(self):\\n\\n if len(self.student_list):\\n self.print_dataframe(self.student_list)\\n else:\\n print('There is no contents to show')\",\n \"def display_all(self) -> None:\\n self.display.draw_list(self.read_all_statuses())\",\n \"def list_all(request):\\n\\n entries = BlogEntry.objects.all()\\n data = {'entries': paginate_objects(request, entries),\\n 'blog_info': get_blog_info(), 'action_str': 'All Blogs Shown'}\\n\\n return render_to_response('blog/list_entries.html', data,\\n context_instance=get_rq(request))\",\n \"def list_entries(entries, search, field):\\n clear()\\n if entries:\\n print(\\\"Your search results for {}:\\\\n\\\".format(search))\\n for entry in entries:\\n print(getattr(entry, field))\\n input(\\\"Press enter to continue.\\\")\\n view_entries(entries)\\n else:\\n input(\\\"No results for {}. Press enter to continue. \\\".format(search))\\n menu_loop()\",\n \"def summary_list(request):\\r\\n qs = Summary.objects.all()\\r\\n context = {'summary_records': qs}\\r\\n return render(request, 'weather/summary_list.html', context)\",\n \"def show_all_entries(user_id):\\n\\n # prevents the public for accessing user specific information\\n if not session.get(\\\"user_id\\\") or session[\\\"user_id\\\"] != user_id:\\n return redirect(\\\"/\\\")\\n\\n # grab all the users entries\\n user = User.query.get(user_id)\\n entries = (\\n Entry.query.filter_by(user_id=user_id).order_by(desc(\\\"date_created\\\")).all()\\n )\\n\\n page, per_page, offset = get_page_args(\\n page_parameter=\\\"page\\\", per_page_parameter=\\\"per_page\\\"\\n )\\n\\n per_page = 5\\n\\n offset = (page - 1) * per_page\\n total = len(entries)\\n\\n pagination_entries = entries[offset : offset + per_page]\\n pagination = Pagination(\\n page=page, per_page=per_page, total=total, css_framework=\\\"bootstrap4\\\"\\n )\\n\\n return render_template(\\n \\\"all-entries.html\\\",\\n entries=pagination_entries,\\n user=user,\\n page=page,\\n per_page=per_page,\\n pagination=pagination,\\n )\",\n \"def display_list(the_list):\\n print(\\\"\\\\n===================================\\\")\\n for person in the_list:\\n print(\\\"{name:12s}\\\\t\\\\t{phone}\\\".format(name=person.name, phone=person.phone))\\n if the_list == []:\\n print(\\\"\\\\nNo entries found!\\\\n\\\")\\n print(\\\"===================================\\\\n\\\")\",\n \"def show_entries():\\n db = get_db()\\n cur = db.execute('select id, title, ingredients, steps, tags, \\\\\\n url from entries order by id asc')\\n entries = cur.fetchall()\\n return render_template('show_entries.html', entries=entries)\",\n \"def show_all(thing):\\n db = get_db()\\n cursor = db.cursor()\\n cursor.execute(\\\"select * from %s\\\" % thing.table_name)\\n entries = cursor.fetchall()\\n\\n add_template_variable('thing', thing)\\n add_template_variable('entries', entries)\\n return my_render_template('generic/show_all.html')\",\n \"def show_entries():\\n db = get_db()\\n cur = db.execute('select distinct name,repo_id,stars, description from python_repos order by stars desc')\\n entries = cur.fetchall()\\n # get api\\n results = get_api()\\n # The update operation will consist of deletion and insertion for efficiency\\n delete_entry(results)\\n add_entry(results)\\n return render_template('index.html', entries=entries)\",\n \"def display_entries(self, entries):\\n entries = list(entries)\\n if len(entries) == 0:\\n print(\\\"\\\\nNo results were found.\\\\n\\\")\\n input(\\\"Press enter to return to the main menu...\\\")\\n self.main_menu()\\n counter = 0\\n error = None\\n while True:\\n self.clear_screen()\\n if len(entries) == 0:\\n print(\\\"There are no more entries!\\\")\\n input(\\\"Press enter to return to the main menu...\\\")\\n self.main_menu()\\n if error:\\n print(error)\\n input(\\\"Press enter to continue...\\\")\\n self.clear_screen()\\n error = None\\n self.display_entry(entries[counter])\\n print(\\\"\\\\nWhat would you like to do?\\\")\\n print(\\\" N: Next entry (Default)\\\")\\n print(\\\" p: Previous entry\\\")\\n print(\\\" e: Edit entry\\\")\\n print(\\\" d: Delete entry\\\")\\n print(\\\" q: Quit to main menu\\\")\\n user_input = input(\\\"Next, previous, edit, delete, quit: \\\").lower()\\n if user_input == 'q':\\n self.main_menu()\\n elif user_input == 'p':\\n if counter <= 0:\\n error = \\\"End of list. Can't go back.\\\"\\n continue\\n counter -= 1\\n elif user_input == 'd':\\n self.delete_entry(entries[counter].id)\\n del entries[counter]\\n if counter > len(entries) - 1:\\n counter -= 1\\n print('Entry deleted!')\\n input(\\\"Press enter to continue...\\\")\\n elif user_input == 'e':\\n self.edit_entry(entries[counter])\\n else:\\n counter += 1\\n if counter > len(entries) - 1:\\n counter -= 1\\n error = \\\"End of list. Can't move forward.\\\"\",\n \"def index():\\n\\n rows = db.execute(\\n 'SELECT symbol, SUM(CASE WHEN operation = \\\"SELL\\\" THEN -shares ELSE shares END) shares FROM transactions WHERE id = :id GROUP BY symbol;', id=session['user_id'])\\n\\n cash = db.execute('SELECT cash FROM users WHERE id = :id', id=session['user_id'])[0]['cash']\\n\\n grand_total = cash\\n\\n for row in rows:\\n stock = lookup(row['symbol'])\\n\\n row['name'] = stock['name']\\n row['price'] = stock['price']\\n row['total'] = row['shares'] * stock['price']\\n\\n grand_total += row['shares'] * stock['price']\\n\\n rows.append({\\n 'symbol': 'CASH',\\n 'cash': cash,\\n 'total': grand_total\\n })\\n\\n return render_template('index.html', stocks=rows)\",\n \"def print_entries(self):\\n self.print_selected_entries(self.entries)\",\n \"def display_all(self):\\n print(\\\"Price: \\\" + str(self.price))\\n print(\\\"Speed: \\\" + str(self.speed) + \\\"mph\\\")\\n print(\\\"Fuel: \\\" + self.fuel)\\n print(\\\"Mileage: \\\" + str(self.mileage) + \\\"mpg\\\")\\n print(\\\"Tax: \\\" + str(self.tax))\\n return self\",\n \"def display(self):\\r\\n\\t\\tfor each_item in self.items:\\r\\n\\t\\t\\teach_item.display()\",\n \"def index():\\n holdings = db.execute(\\\"SELECT symbol, amount FROM stocks WHERE stocks.user_id = :userid AND amount != 0\\\", userid = session[\\\"user_id\\\"])\\n total = 0\\n\\n for row in holdings:\\n sDict = lookup(row['symbol'])\\n row['name'] = sDict['name']\\n row['share_total'] = sDict['price'] * row['amount']\\n total += row['share_total']\\n\\n row['price'] = usd(sDict['price'])\\n row['share_total'] = usd(row['share_total'])\\n\\n cash = db.execute(\\\"SELECT cash FROM users WHERE id = :userid\\\", userid = session[\\\"user_id\\\"])\\n cash = cash[0][\\\"cash\\\"]\\n total += cash\\n\\n return render_template(\\\"index.html\\\", holdings=holdings, cash=usd(cash), total=usd(total))\",\n \"def index():\\n rows = db.execute(\\\"SELECT Symbol, SUM(Shares) as totalShares FROM cash WHERE id=:id GROUP BY Symbol HAVING totalShares > 0\\\", id=session[\\\"user_id\\\"])\\n transactions=[]\\n grand_total = 0\\n for row in rows:\\n stock = lookup(row[\\\"Symbol\\\"])\\n transactions.append({\\n \\\"Symbol\\\": stock[\\\"symbol\\\"],\\n \\\"Name\\\": stock[\\\"name\\\"],\\n \\\"Shares\\\": row[\\\"totalShares\\\"],\\n \\\"Price\\\": usd(stock[\\\"price\\\"]),\\n \\\"Total\\\": usd(stock[\\\"price\\\"] * row[\\\"totalShares\\\"])\\n })\\n grand_total += stock[\\\"price\\\"] * row[\\\"totalShares\\\"]\\n rows = db.execute(\\\"SELECT cash FROM users WHERE id=:id\\\", id=session[\\\"user_id\\\"])\\n cash = rows[0][\\\"cash\\\"]\\n return render_template(\\\"table.html\\\", transactions=transactions, cash=usd(cash), grand_total=usd(grand_total))\",\n \"def index():\\n # query database to get cash on hand\\n user_cash = db.execute(\\\"SELECT cash FROM users WHERE id = :user_id\\\", user_id=session[\\\"user_id\\\"])[0][\\\"cash\\\"]\\n\\n # query database to get current holdings from transactions list\\n stocks = db.execute(\\n \\\"SELECT symbol, SUM(shares) AS shares, price FROM transactions WHERE user_id = :user_id GROUP BY symbol\\\", user_id=session[\\\"user_id\\\"])\\n\\n # assign names and totals for stocks\\n for stock in stocks:\\n stock_lookup = lookup(stock[\\\"symbol\\\"])\\n stock[\\\"name\\\"] = stock_lookup[\\\"name\\\"]\\n stock[\\\"total\\\"] = stock[\\\"shares\\\"] * stock_lookup[\\\"price\\\"]\\n\\n stocks[:] = [stock for stock in stocks if stock.get(\\\"shares\\\") > 0]\\n\\n totals = user_cash + sum([stock[\\\"total\\\"] for stock in stocks])\\n\\n return render_template(\\\"index.html\\\", user_cash=user_cash, stocks=stocks, total=totals, usd=usd)\",\n \"def main():\\n account1 = Money(87, 15)\\n account2 = Money(5, 5)\\n account3 = Money(99, 99)\\n\\n # Display each account balance\\n account1.display()\\n account2.display()\\n account3.display()\\n\\n # Now add 20 cents to each\\n account1.add_cents(20)\\n account2.add_cents(20)\\n account3.add_cents(20)\\n\\n # Display each account balance again\\n print()\\n account1.display()\\n account2.display()\\n account3.display()\",\n \"def index():\\n rows=db.execute(\\\"SELECT * FROM portofolio WHERE user_id=:s\\\",s=session[\\\"user_id\\\"])\\n row=db.execute(\\\"SELECT * FROM users WHERE id=:s\\\",s=session[\\\"user_id\\\"])\\n overall=0\\n for line in rows:\\n overall+=line[\\\"total\\\"]\\n overall+=row[0][\\\"cash\\\"]\\n return render_template(\\\"portofolio.html\\\",rows=rows,cash=usd(row[0][\\\"cash\\\"]),overall=usd(overall))\",\n \"def dashboard_showall():\\n tasks = Task.query.all()\\n return render_template('home/taskshowall/dashboard_showall.html',\\n tasks=tasks, title=\\\"Tasks\\\")\",\n \"def index():\\n inventory = db.execute(\\\"SELECT symbol,quantity FROM inventory WHERE userid = :uid\\\", uid=session[\\\"user_id\\\"])\\n cash = float(db.execute(\\\"SELECT cash FROM users WHERE id = :userid\\\", userid=session[\\\"user_id\\\"])[0][\\\"cash\\\"])\\n total = cash\\n for i in inventory:\\n stock = lookup(i[\\\"symbol\\\"])\\n i[\\\"price\\\"] = stock[\\\"price\\\"]\\n i[\\\"name\\\"] = stock[\\\"name\\\"]\\n i[\\\"total\\\"] = usd(stock[\\\"price\\\"] * i[\\\"quantity\\\"])\\n total += stock[\\\"price\\\"] * i[\\\"quantity\\\"]\\n return render_template(\\\"index.html\\\", context={\\\"inventory\\\":inventory,\\\"total\\\":usd(total),\\\"cash\\\":usd(cash)})\",\n \"def index():\\n stocks = db.execute(\\\"SELECT Symbol, Company, SUM(NumberOfShares) AS Shares, UnitPrice, SUM(TotalPrice) AS TotalPrice FROM \\\"\\n \\\"portfolio WHERE UserID = :userid GROUP BY Symbol\\\", userid=session.get(\\\"user_id\\\"))\\n\\n symbol = db.execute(\\\"SELECT Symbol FROM portfolio WHERE UserID = :userid\\\", userid=session.get(\\\"user_id\\\"))\\n\\n cash = db.execute(\\\"SELECT cash FROM users WHERE id = :userid\\\", userid=session.get(\\\"user_id\\\"))\\n\\n balance = cash[0][\\\"cash\\\"]\\n grandTotal = 0\\n for stock in stocks:\\n grandTotal = grandTotal + stock[\\\"TotalPrice\\\"]\\n\\n grandTotal = grandTotal + balance\\n\\n return render_template(\\\"index.html\\\", stockList=stocks, cash=balance, totalAssets=grandTotal, currentUser=session.get(\\\"user_id\\\"))\",\n \"def show_result_totals(act_cnt: int, ind_cnt: int, rep_cnt: int, typ_list: list):\\n if max([act_cnt, ind_cnt, rep_cnt]):\\n totstub = \\\"\\\\nTotal\\\"\\n tots = \\\"\\\"\\n if \\\"actor\\\" in typ_list:\\n acts = bold(f\\\"{act_cnt:,}\\\")\\n tots = f\\\"{tots}{totstub} actors: {acts}\\\"\\n if \\\"indicator\\\" in typ_list:\\n inds = bold(f\\\"{ind_cnt:,}\\\")\\n tots = f\\\"{tots}{totstub} indicators: {inds}\\\"\\n if \\\"report\\\" in typ_list:\\n reps = bold(f\\\"{rep_cnt:,}\\\")\\n tots = f\\\"{tots}{totstub} reports: {reps}\\\"\\n print(tots)\",\n \"def display_final_results(*args):\\n class_interface, investor_picks, listbox, tckr_file = args\\n\\n for each_pick in range(len(investor_picks)):\\n test = tckr_file[tckr_file.Ticker==investor_picks[each_pick][0]]\\n if not (test.empty):\\n company_name = list(test.Name.values)[0]\\n listbox.insert(tk.END, company_name)\",\n \"def index():\\n rows=db.execute(\\\"SELECT symbol, SUM(transactions) as amount FROM record WHERE userID=? GROUP BY symbol HAVING transactions\\\",session[\\\"user_id\\\"])\\n cash=db.execute(\\\"SELECT cash FROM users WHERE id=?\\\",session[\\\"user_id\\\"])\\n cash_=cash[0][\\\"cash\\\"]\\n\\n #store all the data into a dict so its easier to pass in to html\\n display=[]\\n total_share=0\\n for row in rows:\\n symbol=str(row[\\\"symbol\\\"])\\n print(symbol)\\n name=lookup(symbol)[\\\"name\\\"]\\n shares=int(row[\\\"amount\\\"])\\n price=float(lookup(symbol)[\\\"price\\\"])\\n total=float(shares) *price\\n total_share+=total\\n display.append({'symbol':symbol, 'name':name, 'shares':shares, 'price':price, 'total':total})\\n\\n total_money=total_share+cash[0][\\\"cash\\\"]\\n return render_template(\\\"index.html\\\",display=display,total_money=total_money,cash=cash_)\",\n \"def __ui_list_all_persons(self):\\n persons_list = self.__person_service.service_get_persons_list()\\n\\n if len(persons_list) == 0:\\n print(\\\"The list of persons is empty!\\\")\\n else:\\n print(\\\"The list of persons in your agenda:\\\")\\n for person in persons_list:\\n print(\\\" \\\" + str(person))\\n print(\\\"\\\")\",\n \"def print_all(self, lim=100):\\n for item in islice(weekdays.return_all(), 0, 100):\\n print(item)\",\n \"def index():\\n balance = db.execute(\\\"SELECT cash FROM users WHERE id = :id\\\",\\n id=session['user_id'])\\n balance = balance[0][\\\"cash\\\"]\\n cash_row = [\\\"CASH\\\", \\\"\\\", \\\"\\\", \\\"\\\", usd(balance)]\\n all_rows = []\\n final_total = balance\\n\\n #update totalvalue with current price from lookup, in totalshares table\\n all_shares = db.execute(\\\"SELECT symbol, numshares FROM totalshares WHERE id = :id\\\",\\n id=session['user_id'])\\n if all_shares != None and len(all_shares) > 0:\\n for row in all_shares:\\n update_totvalue = row[\\\"numshares\\\"] * lookup(row[\\\"symbol\\\"])[\\\"price\\\"]\\n db.execute(\\\"UPDATE totalshares SET totalvalue = :update_totvalue WHERE id = :id AND symbol = :symbol\\\",\\n update_totvalue=update_totvalue, id=session[\\\"user_id\\\"], symbol=row[\\\"symbol\\\"])\\n\\n rows = db.execute(\\\"SELECT symbol, numshares, totalvalue FROM totalshares WHERE id = :id\\\",\\n id=session['user_id'])\\n if rows==None or len(rows) < 1:\\n all_rows.append(cash_row)\\n return render_template(\\\"index.html\\\", all_rows=all_rows, final_total=usd(final_total))\\n else:\\n for row in rows:\\n if row[\\\"numshares\\\"] > 0:\\n share_row = []\\n share_row.append(row[\\\"symbol\\\"])\\n share_row.append(lookup(row[\\\"symbol\\\"])[\\\"name\\\"])\\n share_row.append(row[\\\"numshares\\\"])\\n share_row.append(usd(lookup(row[\\\"symbol\\\"])[\\\"price\\\"]))\\n share_row.append(usd(row[\\\"totalvalue\\\"]))\\n final_total = final_total + row[\\\"totalvalue\\\"]\\n all_rows.append(share_row)\\n all_rows.append(cash_row)\\n return render_template(\\\"index.html\\\", all_rows=all_rows, final_total=usd(final_total))\",\n \"def full_listing(request, urlname):\\n\\tif request.user.is_authenticated():\\n\\t\\tblog = Blog.qa_objects.get(urlname=urlname)\\n\\t\\tposts = BlogEntry.qa_objects.filter(blog=blog, posting_time__lte=datetime.now()).order_by('-posting_time')\\n\\telse:\\n\\t\\tblog = Blog.objects.get(urlname=urlname)\\n\\t\\tposts = BlogEntry.objects.filter(blog=blog).order_by('-posting_time')\\n\\treturn render_to_response('blogs/full.html', {'blog': blog, 'posts': posts}, context_instance=RequestContext(request))\",\n \"def index():\\n user = Users.query.get(session.get(\\\"user_id\\\"))\\n query = db.session.query(Records.symbol, Records.company_name,\\n db.func.sum(Records.shares).label(\\\"shares\\\")).group_by(Records.symbol,\\n Records.company_name).filter(Records.user_id==user.id)\\n info = [{}] * query.count()\\n grand_total = user.cash\\n for i, row in enumerate(query):\\n try:\\n info[i]['price'] = lookup(row.symbol)['price']\\n except:\\n info[i]['price'] = 1\\n\\n info[i]['symbol'] = row.symbol\\n info[i]['company_name'] = row.company_name\\n info[i]['shares'] = row.shares\\n info[i]['value'] = round(row.shares * info[i]['price'], 2)\\n grand_total += info[i]['value']\\n\\n return render_template(\\\"index.html\\\", cash=user.cash, rows=info, total=round(grand_total, 2))\",\n \"def add_entries(entries_list):\\r\\n #| - add_entries\\r\\n sum_tot = 0.\\r\\n for entry in entries_list:\\r\\n if entry is None:\\r\\n summand = 0.\\r\\n else:\\r\\n summand = entry\\r\\n sum_tot += summand\\r\\n\\r\\n return(sum_tot)\\r\\n #__|\\r\",\n \"def index():\\n from managers import banks_manager, rates_manager\\n\\n # acquiring number of all banks in DB\\n banks_count = banks_manager.get_banks_count()\\n\\n # acquiring last update time\\n updated = rates_manager.get_last_update_time()\\n last_update = None if updated is None else updated.strftime('%Y %d %b, %H:%M')\\n\\n # acquiring list of banks with best USD selling rate\\n usd_selling_rate = rates_manager.get_usd_selling_min_rate()\\n usd_selling_banks = banks_manager.get_usd_selling_best_rate_banks()\\n\\n # acquiring list of banks with best EUR selling rate\\n eur_selling_rate = rates_manager.get_eur_selling_min_rate()\\n eur_selling_banks = banks_manager.get_eur_selling_best_rate_banks()\\n\\n # acquiring list of banks with best USD buying rate\\n usd_buying_rate = rates_manager.get_usd_buying_max_rate()\\n usd_buying_banks = banks_manager.get_usd_buying_best_rate_banks()\\n\\n # acquiring list of banks with best EUR buying rate\\n eur_buying_rate = rates_manager.get_eur_buying_max_rate()\\n eur_buying_banks = banks_manager.get_eur_buying_best_rate_banks()\\n\\n # initializing banks data map\\n data_map = {\\n 'usd_selling_rate': usd_selling_rate,\\n 'eur_selling_rate': eur_selling_rate,\\n 'usd_buying_rate': usd_buying_rate,\\n 'eur_buying_rate': eur_buying_rate,\\n 'usd_selling_banks': usd_selling_banks,\\n 'eur_selling_banks': eur_selling_banks,\\n 'usd_buying_banks': usd_buying_banks,\\n 'eur_buying_banks': eur_buying_banks\\n }\\n return render_template(\\\"index.html\\\", title='Home', banks_count=banks_count, last_updated=last_update, data=data_map)\",\n \"def printall():\\n print listAll()\",\n \"def show_all(self):\\n cmodules.showModuleData(\\n Options.Author,\\n Options.Name,\\n Options.Call,\\n Options.Category,\\n Options.Type,\\n Options.Version,\\n Options.Description,\\n Options.License,\\n Options.Datecreation,\\n Options.Lastmodified\\n )\\n self.show_commands()\\n self.show_opt()\",\n \"def index(request):\\n\\n # Fetches the latest 3 listings published\\n listings = Listing.objects.order_by('-list_date').filter(is_published=True)[:3]\\n context = {\\n 'listings': listings,\\n 'state_choices': state_choices,\\n 'bedroom_choices': bedroom_choices,\\n 'price_choices': price_choices\\n }\\n return render(request, \\\"pages/index.html\\\", context)\",\n \"def func(self):\\n from commands.base_commands.guest import census_of_fealty\\n\\n fealties = census_of_fealty()\\n table = PrettyTable([\\\"{wFealty{n\\\", \\\"{w#{n\\\"])\\n for fealty in fealties:\\n table.add_row([fealty, fealties[fealty]])\\n self.msg(table)\",\n \"def list(request):\\n return EntryView.__index(request)\",\n \"def list_viewer(listt):\\n\\tif len(listt) == 0:\\n\\t\\tprint(\\\"There are no elements\\\")\\n\\t\\tprint()\\n\\telse:\\n\\t\\ti = 0\\n\\t\\tfor dictionary in listt:\\n\\t\\t\\ti += 1\\n\\t\\t\\tprint(f\\\"Account #{i} »»\\\")\\n\\t\\t\\tprint(\\n\\t\\t\\t\\t\\\"\\\\tService Name: \\\", dictionary[\\\"service\\\"], \\\"\\\\n\\\",\\n\\t\\t\\t\\t\\\"\\\\tUser Name: \\\", dictionary[\\\"user\\\"], \\\"\\\\n\\\",\\n\\t\\t\\t\\t\\\"\\\\tPassword: \\\", dictionary[\\\"password\\\"], \\\"\\\\n\\\",\\n\\t\\t\\t\\t)\",\n \"def list_all(request):\\n companies = Company.objects.order_by('-created')\\n context = dict(companies=companies)\\n return render(request, 'companies/all.html', context)\",\n \"def all():\\n Refresh.committees()\\n Refresh.legislators()\\n Refresh.bills()\",\n \"def print_donor_totals_report():\\n # # Creating list to hold donors info for printing\\n update_lists()\\n try:\\n print()\\n title = ['Donor Name', '| Total Given ', '| Num Gifts',\\n ' | Average Gift']\\n print('{:<20}{:>14}{:^14}{:>14}'.format(title[0], title[1],\\n title[2], title[3]))\\n print('-'*65)\\n print()\\n for donor in donor_totals_list:\\n average_gift = float(donor.donation_total) / donor.num_donations\\n print('{:<22}{}{:>12.2f}{:>10}{:>8}{:>12.2f}'.format(donor.fullname, '$', donor.donation_total,\\n donor.num_donations, '$', average_gift))\\n print()\\n\\n except Exception as e:\\n logger.info(f'Error printing donor list at {donor.fullname}')\\n logger.info(e)\",\n \"def listall():\\n # I like to define the query separately.\\n query = db.product\\n\\n # List of additional links.\\n links = []\\n \\n links.append(\\n dict(header = \\\"Profit\\\",\\n body = lambda row : produce_profit(row)\\n )\\n )\\n links.append(\\n dict(header = \\\"\\\",\\n body = lambda row : produce_star_btn(row.id)\\n )\\n )\\n links.append(\\n dict(header = \\\"\\\",\\n body = lambda row : produce_pls_minus_btn(row)\\n )\\n )\\n links.append(\\n dict(header='',\\n body = lambda row : produce_poster_btns(row.id)\\n \\n )\\n )\\n \\n # Let's get rid of some fields in the add form.\\n if len(request.args) > 0 and request.args[0] == 'new':\\n db.product.prod_poster.readable = False\\n db.product.prod_post_time.writable = False\\n db.product.prod_sold.writable = False\\n db.product.prod_starred.readable, db.product.prod_starred.writable =False, False\\n # Grid definition.\\n grid = SQLFORM.grid(\\n query, \\n field_id = db.product.id, # Useful, not mandatory.\\n fields = [db.product.id, db.product.prod_name,\\n db.product.prod_in_stock, db.product.prod_sold,\\n db.product.prod_price, db.product.prod_cost], \\n headers = {'product.prod_name': 'Product Name',\\n 'product.prod_in_stock':'In Stock',\\n 'product.prod_sold':'Sold', \\n 'product.prod_price':'Price', \\n 'product.prod_cost':'Cost'},\\n links = links,\\n # And now some generic defaults.\\n details=False,\\n create=True, editable=False, deletable=False,\\n csv=False, \\n user_signature=True, # We don't need it as one cannot take actions directly from the form.\\n )\\n return dict(grid=grid)\",\n \"def index():\\n\\n # Create lists containing values for the table\\n symbols = []\\n names = []\\n shares = []\\n totals = []\\n prices = []\\n\\n # Query database for the current amount of cash and stocks\\n cash = db.execute(\\\"SELECT cash FROM users WHERE id = :username\\\", username=session[\\\"user_id\\\"] )[0][\\\"cash\\\"]\\n stocks = db.execute(\\\"SELECT * FROM summary WHERE id = :username\\\", username=session[\\\"user_id\\\"] )\\n grand = cash\\n\\n # Append to the lists from the database\\n for item in stocks:\\n symbol = item[\\\"symbol\\\"]\\n symbols.append(symbol)\\n names.append(lookup(symbol)[\\\"name\\\"])\\n share = db.execute(\\\"SELECT shares FROM summary WHERE id = :username AND symbol= :symbol\\\", username=session[\\\"user_id\\\"], symbol=symbol)[0][\\\"shares\\\"]\\n shares.append(share)\\n prices.append(lookup(symbol)[\\\"price\\\"])\\n total = int(share) * lookup(symbol)[\\\"price\\\"]\\n totals.append(total)\\n grand += total\\n\\n # Obtain list length\\n length = len(symbols)\\n\\n # Direct users to the index page\\n return render_template(\\\"index.html\\\", symbols = symbols, length = length, cash=cash, names = names, shares = shares, totals = totals, prices = prices, grand = grand)\",\n \"def display_contents(CurrentList):\\n\\n print(\\\"========================Start of display_contents() Method*\\\")\\n print(\\\"The number of items in list are :\\\" + str(len(CurrentList)))\\n print(\\\"----- Fl.ID--- ||sub_T|| reqStart||Dur ||Start||End\\\")\\n # Flight ID||sub_Time||reqStart||reqDuration||actualStart||actualEnd\\\")\\n for j in range(len(CurrentList)):\\n print(str(j) + \\\": \\\" + CurrentList[j].showFlightInfo())\\n print(\\\"========================END of display_contents() Method *\\\")\",\n \"def index(request):\\n # Attempt to map highest bid amount to each items' ID.\\n di = {}\\n for obj in Listing.objects.filter(is_active=True):\\n try: \\n di[obj.id] = sorted([bid.bid_amount for bid in obj.bids.all()])[-1]\\n except:\\n di[obj.id] = obj.starting_bid\\n \\n #print(di) - For Debugging \\n\\n # Return index template\\n return render(request, \\\"auctions/index.html\\\", {\\n \\\"listings\\\": Listing.objects.filter(is_active=True),\\n \\\"di\\\": di\\n })\",\n \"def display_entry(self, entry):\\n border = '-' * 50\\n print(border)\\n print('Employee: {}'.format(entry.employee_name))\\n print('Task Name: {}'.format(entry.task_name))\\n print(\\\"Date: {}\\\".format(entry.date))\\n print(\\\"Time Spent: {}\\\".format(entry.time_spent))\\n if entry.notes != '':\\n print(\\\"Notes:\\\\n{}\\\\n{}\\\".format('----------', entry.notes))\\n print(border)\",\n \"def display_entries(chat_id, entry_type):\\r\\n\\r\\n reply = ''\\r\\n count = 0\\r\\n\\r\\n if entry_type == \\\"habits\\\":\\r\\n items = habit.return_all(chat_id)[0]\\r\\n elif entry_type == \\\"categories\\\":\\r\\n items = category.return_all(chat_id)\\r\\n\\r\\n # print(items)\\r\\n #\\r\\n # try:\\r\\n # for x in items:\\r\\n # name = items[count][0]\\r\\n # reply += '/' + str(count + 1) + ' ' + name + '\\\\n'\\r\\n # count = count + 1\\r\\n # except:\\r\\n # reply = 'You have no entries'\\r\\n\\r\\n return items\",\n \"def view_transactions(self) -> None:\\n user_choice = Menu.prompt_view_transactions()\\n if user_choice == 5:\\n print(\\\"Returning to main menu...\\\")\\n return\\n\\n budget_category = BudgetManager.category_mapping[user_choice]\\n print(f\\\"\\\\nTransactions in the {budget_category.value} \\\"\\n f\\\"category: \\\")\\n for tx in self.user.tx_manager:\\n if tx.budget_category == user_choice:\\n print(f\\\"\\\\n{tx}\\\")\",\n \"def print_entries(entries):\\n if len(entries) == 0:\\n print(\\\"\\\\nNo results were found.\\\\n\\\")\\n input(\\\"Press enter to return to the main menu...\\\")\\n start()\\n counter = 0\\n error = None\\n while True:\\n clear_screen()\\n if len(entries) == 0:\\n print(\\\"There are no more entries!\\\")\\n input(\\\"Press enter to return to the main menu...\\\")\\n start()\\n if error:\\n print(error)\\n input(\\\"Press enter to continue...\\\")\\n clear_screen()\\n error = None\\n print_entry(entries[counter])\\n print(\\\"\\\\nWhat would you like to do?\\\")\\n print(\\\" n: Next entry (Default)\\\")\\n print(\\\" p: Previous entry\\\")\\n print(\\\" e: Edit entry\\\")\\n print(\\\" d: Delete entry\\\")\\n print(\\\" q: Quit to main menu\\\")\\n user_input = input(\\\"> \\\").lower()\\n if user_input == 'q':\\n start()\\n elif user_input == 'p':\\n if counter <= 0:\\n error = \\\"End of list. Can't go back.\\\"\\n continue\\n counter -= 1\\n elif user_input == 'd':\\n delete_entry(entries[counter]['id'])\\n del entries[counter]\\n if counter > len(entries) - 1:\\n counter -= 1\\n elif user_input == 'e':\\n edit_entry(entries[counter])\\n else:\\n counter += 1\\n if counter > len(entries) - 1:\\n counter -= 1\\n error = \\\"End of list. Can't move forward.\\\"\",\n \"def display_available_items(self):\\n count = 0\\n print(\\\"Available Items:\\\")\\n for item in self.item_list.values():\\n if item.check_availability():\\n count += 1\\n print(item)\\n if count == 0:\\n print(\\\"No items are available\\\")\",\n \"def list_dams(request):\\n dams = get_all_dams()\\n table_rows = []\\n\\n for dam in dams:\\n table_rows.append(\\n (\\n dam['name'], dam['owner'],\\n dam['river'], dam['date_built']\\n )\\n )\\n\\n dams_table = DataTableView(\\n column_names=('Name', 'Owner', 'River', 'Date Built'),\\n rows=table_rows,\\n searching=False,\\n orderClasses=False,\\n lengthMenu=[ [10, 25, 50, -1], [10, 25, 50, \\\"All\\\"] ],\\n )\\n\\n context = {\\n 'dams_table': dams_table\\n }\\n\\n return render(request, 'co_drought/list_dams.html', context)\",\n \"def show_total(request):\\n user_id = request.user\\n end_date = datetime.datetime.utcnow()\\n start_date = end_date.replace(day=1,\\n hour=datetime.time(0, 0, 0).hour,\\n minute=datetime.time(0, 0, 0).minute,\\n second=datetime.time(0, 0, 0).second)\\n total = 0\\n incomes_to_date = IncomeHistory.objects.filter(date__range=(start_date, end_date),\\n income_id__owner_id=user_id)\\n if not incomes_to_date:\\n return HttpResponse(0, status=200)\\n\\n for income in incomes_to_date:\\n if income.is_active:\\n total = total + income.value\\n return HttpResponse(total, status=200)\",\n \"def list_log_entries():\\n manager = LogBookManager()\\n log_entries = manager.list()\\n\\n if log_entries:\\n typer.echo(get_table(log_entries))\\n else:\\n typer.echo(\\n typer.style(\\n f'You do not have any entries in your log book.',\\n fg=typer.colors.MAGENTA,\\n bold=True\\n )\\n )\",\n \"def view_entries(search_query=None):\\n\\n # search_query se ha añadido como funcionalidad extra (search_entries)\\n # Por defecto es None, por si no se quiere usar la funcionalidad extra\\n # Guarda en una lista todas las entrdas del diario recogidas con el select\\n entries = Entry.select().order_by(Entry.timestamp.desc())\\n\\n if search_query:\\n # Con where filtramos todas las entries que cumplen la condicion\\n entries = entries.where(Entry.content.contains(search_query))\\n\\n # Ahora toca mostrarlas con un formato adecuado\\n for entry in entries:\\n # Primero la fecha\\n timestamp = entry.timestamp.strftime('%A %b %d, %Y %I:%M%p')\\n clear()\\n print(timestamp)\\n print('+'*len(timestamp))\\n print(entry.content)\\n print('\\\\n\\\\n'+'+'*len(timestamp) + '\\\\n') # Pone tantos + como caracteres haya\\n print('Enter| siguiente entrada')\\n print('d| Borrar entrada')\\n print('q| Salir al menu')\\n\\n # Obtener la siguiente entrada del usuario\\n next_action = input('Accion a realizar: [Nq]').lower().strip()\\n\\n if next_action == 'q':\\n break\\n elif next_action == 'd':\\n delete_entry(entry)\",\n \"def show_all_tasks(self):\\n tasks = self.session.query(self.Table).order_by(self.Table.deadline).all()\\n print('All tasks:')\\n if tasks:\\n for n, task in enumerate(tasks, 1):\\n print(f'{n}. {task.task}. {task.deadline.strftime(\\\"%d %b\\\")}')\\n else:\\n print('Nothing to do!')\\n print()\",\n \"def __display(self) -> None:\\n ligne = 0\\n for key, value in self.values.items():\\n self.my_data(self.master, key, value, ligne, 0, 1, 1, 2, 2)\\n ligne += 2\",\n \"def index():\\n\\n # User reached route via GET (as by clicking a link or via redirect)\\n if request.method == \\\"GET\\\":\\n\\n # FORM TABLE total SELECT name for lookup(name) of now price, price, total costmoney ,totalshares\\n portf = db.execute(\\\"SELECT name, symbol, price, sharesTotal, costmoneyTotal FROM total WHERE userID = :userID\\\", userID=session[\\\"user_id\\\"])\\n\\n # Len of portf list, rows\\n porLen = len(portf)\\n\\n # For loop portf index \\\"nowPrice\\\" to new dict, costmoneyTotal\\n for item in range(porLen):\\n e = portf[item][\\\"symbol\\\"]\\n nowPrice = lookup(e).get(\\\"price\\\")\\n portf[item]['nowPrice'] = nowPrice\\n portf[item]['costmoneyTotal'] = usd(portf[item]['costmoneyTotal'])\\n\\n # List reversed\\n portf = list(reversed(portf))\\n\\n\\n # FORM TABLE users SELECT end cash\\n endPrice = db.execute(\\\"SELECT cash FROM users WHERE id = :userID\\\", userID=session[\\\"user_id\\\"])\\n\\n endPrice = usd(endPrice[0][\\\"cash\\\"])\\n return render_template(\\\"index.html\\\", portf=portf, endPrice = endPrice, porLen=porLen)\",\n \"def display_books(self, results):\\n # Check if result is blank\\n if not results:\\n print(\\\"\\\\nNo Books found!!\\\")\\n return\\n # construct table and print\\n book_schema = LMSLibraryDatabase.book_schema\\n table = PrettyTable()\\n table.field_names = book_schema\\n for result in results:\\n table.add_row(result)\\n print(\\\"\\\\n{}\\\".format(table))\\n self.prompt_borrow_book()\",\n \"def showAllResults(self):\\n \\n names = self.jobstable.get_selectedRecordNames()\\n if len(names)==1:\\n ax,mh,x,y=self.showResults()\\n\\n else:\\n tx=[]; ty=[]\\n import pylab as plt\\n f=plt.figure(figsize=(8,8))\\n ax=f.add_subplot(111)\\n for n in names:\\n a,mh,x,y = self.showResults(n,showtable=False, ax=ax,stats=False)\\n tx.extend(x)\\n ty.extend(y) \\n ax.legend()\\n #add stats for summary\\n from Correlation import CorrelationAnalyser\\n C = CorrelationAnalyser() \\n C.addStats(ax,tx,ty)\\n f.show()\\n \\n return\",\n \"def show_installations(self):\\n database = Database('data/database.db')\\n installations = database.read_installations()\\n view = Template(filename=\\\"view/template.html\\\", lookup=lookup)\\n \\n \\n return view.render(\\n rows = [[item.number, item.name, item.address, item.zip_code, item.city, item.latitude, item.longitude] for item in installations],\\n pageTitle = \\\"Installations\\\",\\n tableTitle = \\\"Liste de toutes les installations\\\",\\n ths = [\\\"Numéro\\\", \\\"Nom\\\", \\\"Adresse\\\", \\\"Code postal\\\", \\\"Ville\\\", \\\"Latitude\\\", \\\"Longitude\\\"]\\n )\",\n \"def index():\\n rows = db.execute(\\\"SELECT symbol, SUM(shares) as shares FROM 'transaction' WHERE u_id = :user_id GROUP BY symbol\\\", user_id = session[\\\"user_id\\\"])\\n user = db.execute(\\\"SELECT * FROM 'users' WHERE id = :user_id\\\", user_id = session[\\\"user_id\\\"])\\n\\n if len(rows) == 0:\\n return render_template(\\\"index.html\\\", rows = 0, username = user[0][\\\"username\\\"], cash = user[0][\\\"cash\\\"], total = user[0][\\\"cash\\\"])\\n\\n else:\\n cur_price = []\\n value = []\\n names = []\\n total = 0\\n for row in rows:\\n returned_quote = lookup(row[\\\"symbol\\\"])\\n cur_price.append(returned_quote[\\\"price\\\"])\\n value.append(round(returned_quote[\\\"price\\\"] * row[\\\"shares\\\"], 2))\\n names.append(returned_quote[\\\"name\\\"])\\n total = total + round(returned_quote[\\\"price\\\"] * row[\\\"shares\\\"], 2)\\n\\t\\t\\n\\t\\ttotal = round(total, 2)\\n\\t\\t\\n return render_template(\\\"index.html\\\", username = user[0][\\\"username\\\"], cash = user[0][\\\"cash\\\"], total = total, rows = rows, cur_price = cur_price, value = value, names = names)\",\n \"def print_results(results):\\n print(f\\\"Intial Entries: {results[0]}\\\")\\n print(f\\\"Added Entries: {results[1]}\\\")\\n print(f\\\"Final Entries: {results[2]}\\\")\\n print(f\\\"Total Run Time: {results[3]}\\\")\\n print(\\\"\\\\n\\\")\",\n \"def amount_gathering(user_recipe):\\r\\n #Forms Dictionary\\r\\n sales_stats = dictionary_formation()\\r\\n amount_list = []\\r\\n month_list = [\\\"Nov\\\", \\\"Dec\\\", \\\"Jan\\\", \\\"Feb\\\", \\\"Mar\\\", \\\"Apr\\\", \\\"May\\\",\\r\\n \\\"Jun\\\", \\\"Jul\\\", \\\"Aug\\\", \\\"Sep\\\", \\\"Oct\\\"]\\r\\n for month in month_list:\\r\\n bottles_amount = 0\\r\\n dicts_read = 2\\r\\n for dicts_read in sales_stats:\\r\\n analyse_dict = sales_stats[str(dicts_read)]\\r\\n if month in analyse_dict[\\\"date_required\\\"]:\\r\\n if analyse_dict[\\\"recipe\\\"] == user_recipe:\\r\\n bottles_amount += analyse_dict[\\\"quantity_ordered\\\"]\\r\\n amount_list.append(bottles_amount)\\r\\n return amount_list\",\n \"def show_all_departments():\\n\\n logger.debug('Function show_all_departments(). Routed to /departments')\\n titles = ['Name', 'Average Salary', 'Employees']\\n departments = ds.get_all()\\n logger.info('Get list of departments, length is %i', len(departments))\\n return render_template('departments.html',\\n title='Departments',\\n table_title='List of Departments',\\n headers=titles,\\n departments=departments)\",\n \"def show_all_posts():\\n post = Post.query.all()\\n\\n return render_template('all-posts.html', post=post)\",\n \"def list(self, request, scope=None):\\n\\n qs = self.get_queryset()\\n if scope == 'summary':\\n total = qs.aggregate(total=Sum('total_value'))['total'] or 0.0\\n return Response({'total_investment': total}, status=200)\\n else:\\n serializer = self.get_serializer(qs, many=True)\\n return Response(serializer.data, status=status.HTTP_200_OK)\",\n \"def printAll(self):\\n for item in self.items:\\n try:\\n print(\\\"=========Post code: \\\" + item['code'] + \\\"=============\\\")\\n print(item['caption']['text'])\\n except TypeError:\\n print(\\\"(Empty caption text)\\\")\",\n \"def list(ctx):\\n if ctx.obj.get('NAMESPACE') != 'accounts':\\n click.echo(\\n click.style('Only account data is available for listing.', fg='red')\\n )\\n return\\n\\n swag = create_swag_from_ctx(ctx)\\n accounts = swag.get_all()\\n _table = [[result['name'], result.get('id')] for result in accounts]\\n click.echo(\\n tabulate(_table, headers=[\\\"Account Name\\\", \\\"Account Number\\\"])\\n )\",\n \"def see_all_transfers(request):\\n transfers = Transaction.objects.all().order_by('-executed_time')\\n return render(request, 'app/allTransfers.html', {'transfers': transfers})\",\n \"def _display_entries(self, entries):\\n uni_print(\\\"Entries:\\\\n\\\\n\\\")\\n for entry in entries:\\n uni_print(ordered_yaml_dump(entry))\\n uni_print(\\\"\\\\n\\\")\",\n \"def show_all_habits(self):\\n # Clean up the console\\n self.clear_console()\\n # Prints the name of the application and instructions to the main menu\\n self.back_to_menu_info()\\n print(\\\"\\\"\\\"\\n ALL HABITS REGISTERED\\n ________________________________________________\\n \\\"\\\"\\\")\\n \\n # Gets the habits table of the DB\\n habits_table = self.analytics.habits_table()\\n # IDs of habits without trackings\\n ids_without_trackings = self.analytics.ids_without_trackings(\\n habits_table,\\n # Join of the habits table and the trackings table from the DB\\n self.analytics.habits_trackings_table())\\n # IDs of habits that have trackings\\n ids_with_trackings = self.analytics.ids_with_trackings(habits_table, \\n ids_without_trackings)\\n if len(ids_with_trackings) != 0:\\n # Displays information of tracked habits contained in the habits table in table format\\n self.analytics.display_table(\\n ('ID', 'HABIT', 'PERIODICITY', 'MOTIVATION', 'DESCRIPTION', 'CREATION DAY'),\\n # Gets all the tracked habits\\n self.analytics.tracked_habits(\\n habits_table,\\n # Join of the habits table and the trackings table from the DB\\n self.analytics.habits_trackings_table()),\\n 'TRACKED HABITS'\\n )\\n print('')\\n\\n if len(ids_without_trackings) != 0:\\n # Habits without trackings in tabular form\\n self.table_untracked_habits(habits_table,\\n ids_without_trackings)\\n print('')\\n # Return to the main menu by selecting the number zero\\n self.return_menu()\",\n \"def index():\\n\\n stocks_owned = db.execute(\\\"SELECT DISTINCT stock FROM transaction WHERE id = :id;\\\", id=session['user_id'])\\n\\n number_of_rows= len(stocks_owned) - 1\\n\\n i = 0\\n\\n total_value=0\\n\\n for stock in stocks_owned:\\n\\n stock_list=[]\\n stock_list[i]=stock\\n\\n value = db.execute(\\\"SELECT SUM(total_amount) FROM transaction WHERE id = :id GROUP BY stock HAVING stock=:stock\\\", id=session['usestockr_id'], stock=stocks_owned[\\\"stock\\\"])\\n value_list=[]\\n value_list[i] = value\\n\\n amount_owned = db.execute(\\\"SELECT SUM(amount) FROM transaction WHERE id = :id GROUP BY stock HAVING stock=:stock\\\", id=session['user_id'], stock = stocks_owned[\\\"stock\\\"])\\n amount_list=[]\\n amount_list[i]= amount_owned\\n\\n quote_input = stocks_owned[i]\\n quote_info = lookup(quote_input)\\n price = quote_info['price']\\n price_list=[]\\n price_list[i] = price\\n\\n\\n total_value+=value\\n\\n i+=1\\n\\n cash = db.execute(\\\"SELECT cash FROM users WHERE id = :id;\\\", id=session['user_id'])\\n\\n grand_total = total_value + cash\\n\\n ###(\\\"SELECT stock, SUM(total_amount) FROM transaction WHERE id = :id;, id=session['user_id'] GROUP BY stock\\\")####\\n\\n\\n return render_template(\\\"index.html\\\", number_of_rows=number_of_rows, stock_list=stock_list, amount_list=amount_list, value_list=value_list, price_list=price_list, total_value=total_value, grand_total=grand_total)\",\n \"def list(projectname):\\n backedamount=0\\n con = lite.connect(databasefile)\\n with con:\\n cur = con.cursor() \\n cur.execute(\\\"SELECT Id FROM projects where name=?\\\", (projectname,))\\n exists = cur.fetchone()\\n if exists:\\n cur.execute(\\\"SELECT * FROM backers where Projectname=?\\\", (projectname,))\\n rows = cur.fetchall()\\n numbackers=len(rows)\\n for row in rows:\\n backedamount+=row[4]\\n click.echo(\\\"-- %s backed for $%-.2f\\\" % (row[1],row[4]))\\n else:\\n click.echo(\\\"That project doesn't exist!\\\")\\n sys.exit()\\n\\n cur.execute(\\\"SELECT Tamount FROM projects where name=?\\\", (projectname,))\\n tamount = cur.fetchone()\\n if tamount[0] > backedamount:\\n amountneeds = tamount[0] - backedamount\\n click.echo(\\\"%s needs $%-.2f more dollars to be successful. It has %d backers\\\" % (projectname,amountneeds,numbackers))\\n else:\\n click.echo(\\\"%s is successful! It has %d backers\\\" % (projectname,numbackers))\",\n \"def show_all_products():\\n\\n data = cur.execute(\\\"\\\"\\\"SELECT productid, productname, unitcost, stock FROM catalogue\\\"\\\"\\\").fetchall()\\n\\n print(tabulate(data, headers=[\\\"Product ID\\\", \\\"Name\\\", \\\"Cost\\\", \\\"Stock\\\"]))\",\n \"def all():\\n session = session_maker(\\n app.config['MYSQL_USER'], app.config['MYSQL_PASS'], app.config['MYSQL_SERVER_PORT_3306_TCP_ADDR'],\\n app.config['MYSQL_SERVER_PORT_3306_TCP_PORT'], app.config['DB'])\\n\\n print(\\n tabulate(\\n selection_list_all(session),\\n headers=['number', 'sqlid', 'name', 'city', 'state']))\",\n \"def PrintAllCosts():\\n\\n logs.logger.debug(\\\"After queries of all costs from database start to print\\\"\\n \\\" the details (id, reg.date, date of payment, amount,\\\"\\n \\\" description, category) of the costs to the consol.\\\")\\n try:\\n printedCosts = session.query(Cost.Cost).all()\\n for cost in printedCosts:\\n print(\\n f'{cost.id}\\\\t{cost.registrationDate}\\\\t{cost.dateOfPayment} \\\\\\n \\\\t{cost.amount}\\\\t{cost.description}\\\\t{cost.category.value}')\\n logs.logger.info(\\\"After queries of all costs from database print\\\"\\n \\\" the details (id, reg.date, date of payment, amount,\\\"\\n \\\" description, category) of the costs to the consol.\\\")\\n except Exception as e:\\n logs.logger.error(e, exc_info=True)\",\n \"async def _list(self, ctx):\\n server = ctx.message.server\\n if server.id not in self.db:\\n self.db[server.id] = {}\\n self.save_db()\\n await self.bot.say(\\\"List is empty, please add members first using [p]points add <Discord name or nickname>\\\")\\n return\\n else:\\n db = self.db[server.id]\\n try:\\n columns = [sorted([y for y in self.db[server.id][x].keys()], reverse=True)\\n for x in db if x != \\\"bookkeeper\\\"][0]\\n i, j = columns.index(columns[1]), columns.index(columns[2])\\n columns[i], columns[j] = columns[j], columns[i]\\n rows = sorted([[db[x][\\\"Name\\\"], db[x][\\\"Lifetime Gain\\\"], db[x][\\\"Lifetime Loss\\\"], db[x][\\\"Balance\\\"]]\\n for x in db if x != \\\"bookkeeper\\\"], key=itemgetter(3, 0), reverse=True)\\n except IndexError:\\n await self.bot.say(\\\"No one has been added to the list, please use points member add\\\"\\n \\\" <Discord name or nickname> to do so first.\\\")\\n return\\n if len(rows) > 15:\\n n = 14\\n l = 15\\n m = 0\\n\\n for x in range(n, len(rows)+15, l):\\n if x == n:\\n await self.bot.say(box(tabulate(rows[:x], headers=columns), lang=\\\"prolog\\\"))\\n else:\\n await self.bot.say(box(tabulate(rows[m:x], headers=columns), lang=\\\"prolog\\\"))\\n m = x\\n else:\\n await self.bot.say(box(tabulate(rows, headers=columns), lang=\\\"prolog\\\"))\",\n \"def view_all(options, client):\\n if options.show_events:\\n return display_events(client.events())\\n\\n return \\\"\\\".join([\\n display.DisplayServices().format(client.services()),\\n '\\\\n',\\n display.DisplayJobs(options).format(client.jobs())\\n ])\",\n \"def show_all_information():\\n if not g.user:\\n flash(\\\"Please login to access\\\", \\\"danger\\\")\\n return redirect(\\\"/\\\")\\n if g.user.is_admin == False:\\n flash (\\\"Unauthorized\\\", \\\"danger\\\")\\n return redirect(\\\"/login\\\")\\n\\n employees = Employee.query.all()\\n all_certs = employee_certification.query.all()\\n \\n return render_template(\\\"admin.html\\\", employees = employees, all_certs = all_certs)\",\n \"def list_my_contracts(self):\\n self.get_my_contracts()\\n try:\\n for contract in self.my_contracts:\\n print('------')\\n print(contract.timestamp)\\n print(contract.market)\\n print(contract.ticker)\\n print(contract.shares)\\n print(contract.gain_or_loss)\\n print(contract.average_price)\\n print(contract.buy_price)\\n print(contract.sell_price)\\n print(contract.estimate_sale_of_current_shares)\\n print(contract.implied_odds)\\n print(contract.estimate_best_result)\\n print('------')\\n except TypeError:\\n print('You don\\\\'t have any active contracts!')\\n return\",\n \"def view_bank_account_details(self) -> None:\\n Menu.prompt_view_bank_account_details()\\n print(\\\"Bank Account Details:\\\")\\n print(self.user.account)\\n\\n for tx_num, tx_details in \\\\\\n self.user.tx_manager.transaction_records.items():\\n print(f\\\"\\\\nTransaction #{tx_num}:\\\\n\\\"\\n f\\\"{tx_details}\\\")\\n\\n print(f\\\"\\\\nSpending Summary:\\\")\\n print(f\\\" Starting Bank Balance: \\\"\\n f\\\"{'{:.2f}'.format(self.user.account.starting_balance)}\\\")\\n print(f\\\" Total Transactions Amount: \\\"\\n f\\\"{'{:.2f}'.format(self.user.tx_manager.calc_total_spent())}\\\")\\n print(f\\\" Closing Bank Account Balance: \\\"\\n f\\\"{'{:.2f}'.format(self.user.account.current_balance)}\\\")\",\n \"def all_accounts(request):\\n accounts = Account.objects.all()\\n return render(request, 'app/home.html', {'accounts': accounts})\",\n \"def full_table():\\n #oen the the file\\n list_of_current_account_objects = []\\n opened_file = open('customers.txt')\\n opened_file.readline()\\n for line in opened_file: #get a list of all the customers accounts as objects\\n line_array = line.split(\\\",\\\")\\n customer = Account((line_array[0]+\\\" \\\"+line_array[1]),line_array[2],line_array[4])\\n list_of_current_account_objects.append(customer)\\n #update the savings & current variables for all accounts.\\n for i in list_of_current_account_objects:\\n i.set_sav_bal(account_bal(i,\\\"savings\\\"))\\n i.set_cur_bal(account_bal(i,\\\"current\\\"))\\n\\n #print the answer\\n print(\\\"customer customer account number-avings balance-current balance\\\")\\n for i in list_of_current_account_objects:\\n print(i.get_name()+\\\"---\\\"+i.get_acc_num()+\\\"---\\\"+str(i.get_sav_bal())+\\\"---\\\"+str(i.get_cur_bal()))\\n print()\",\n \"def index():\\n userid = session[\\\"user_id\\\"]\\n stocks = db.execute(\\\"SELECT symbol FROM purchase WHERE userid = :userid GROUP BY symbol\\\",\\n userid=userid)\\n cash = db.execute(\\\"SELECT cash FROM users WHERE id = :userid\\\", userid=userid)\\n grand_total = cash[0][\\\"cash\\\"]\\n if stocks != []:\\n storages = list()\\n for symbol in stocks:\\n stock_data = lookup(symbol[\\\"symbol\\\"])\\n current_price = stock_data[\\\"price\\\"]\\n stock_info = dict()\\n shares_info = db.execute(\\\"SELECT SUM(shares) AS shares_sum FROM purchase WHERE userid = :userid\\\\\\n GROUP BY symbol HAVING symbol = :symbol\\\", userid=userid, symbol=symbol[\\\"symbol\\\"])\\n current_shares = shares_info[0][\\\"shares_sum\\\"]\\n if current_shares > 0:\\n stock_info[\\\"symbol\\\"] = symbol[\\\"symbol\\\"]\\n stock_info[\\\"name\\\"] = stock_data[\\\"name\\\"]\\n stock_info[\\\"price\\\"] = usd(current_price)\\n stock_info[\\\"shares\\\"] = current_shares\\n total = current_price * current_shares\\n grand_total += total\\n stock_info[\\\"total\\\"] = usd(total)\\n storages.append(stock_info)\\n return render_template(\\\"index.html\\\", storages=storages, cash=usd(cash[0][\\\"cash\\\"]), grand_total=usd(grand_total))\\n else:\\n return render_template(\\\"index.html\\\", cash=usd(cash[0][\\\"cash\\\"]), grand_total=usd(grand_total))\\n return render_template(\\\"index.html\\\")\",\n \"def ShowCurrentItemsInList(list_of_rows):\\r\\n print(\\\"******* The current items ToDo are: *******\\\")\\r\\n for row in list_of_rows:\\r\\n print(row.product_name + \\\" (\\\" + str(row.product_price) + \\\")\\\")\\r\\n print(\\\"*******************************************\\\")\\r\\n print() # Add an extra line for looks\\r\",\n \"def display_fields(self):\\r\\n\\r\\n field_text = self.show_fields()\\r\\n field_text_list = field_text.split(EOL)[0:-1]\\r\\n\\r\\n def fld_format (x_temp):\\r\\n\\r\\n x_temp = x_temp.split(COLON)[0], x_temp.split(COLON)[1]\\r\\n\\r\\n \\\"\\\"\\\"formats output of the list of search results\\\"\\\"\\\"\\r\\n\\r\\n if not isinstance(x_temp[1],str):\\r\\n shown_indexes = rangelist.range_find([int(Index(a_temp))\\r\\n for a_temp in x_temp[1]],reduce=True)\\r\\n else:\\r\\n shown_indexes = x_temp[1]\\r\\n\\r\\n if len(shown_indexes) < 20:\\r\\n return (abridge(x_temp[0]).replace(VERTLINE,SLASH)\\r\\n +VERTLINE\\r\\n +shown_indexes)\\r\\n\\r\\n\\r\\n returnlist = []\\r\\n sp_temp = rangelist.split_up_range(shown_indexes)\\r\\n\\r\\n\\r\\n returnlist.append(x_temp[0].replace(VERTLINE,SLASH)[0:min([60,len(x_temp[0])])]\\r\\n +VERTLINE+sp_temp[0])\\r\\n for s_temp in sp_temp[1:]:\\r\\n returnlist.append(VERTLINE+s_temp)\\r\\n\\r\\n return returnlist\\r\\n\\r\\n show_list(field_text_list,\\r\\n alerts.FIELDS[3:],0,40,\\r\\n func=fld_format,\\r\\n present=True,\\r\\n display=display)\",\n \"def init_totals(self):\\r\\n for player in range(0, 4):\\r\\n lbl_total = tk.Label(self.master, text=\\\"0\\\", font='courier 10 bold', fg='red',\\r\\n width=10, borderwidth=2, relief=\\\"groove\\\", anchor=\\\"e\\\")\\r\\n lbl_total.grid(row=19, column=player*3+3, sticky=tk.W+tk.E)\\r\\n self.lbl_totals.append(lbl_total)\",\n \"def show(self, *args):\\n\\n super().show(*args)\\n\\n show_all = len(args) == 0 or args[0] == \\\"all\\\"\\n\\n if show_all or \\\"entry\\\" in args:\\n self.entry.grid(row=0, column=0, sticky=tk.EW)\\n else:\\n self.entry.grid_forget()\",\n \"def display(self):\\r\\n\\t\\ts = self.options['space']\\r\\n\\t\\tv = self.level\\r\\n\\t\\tt = self.options['tab']\\r\\n\\t\\tp = self.options['sep']\\r\\n\\t\\tb = self.options['bullet']\\r\\n\\t\\tprint(v*t+b+s+self.text)\\r\\n\\t\\tfor each_item in self.items:\\r\\n\\t\\t\\teach_item.display()\",\n \"def index():\\n symbols = db.execute(\\\"SELECT symbol FROM History WHERE id = :id GROUP BY symbol\\\", id=session['user_id'])\\n companies = db.execute(\\\"SELECT company FROM History WHERE id = :id GROUP BY symbol\\\", id=session['user_id'])\\n get_shares = db.execute(\\\"SELECT SUM(shares) FROM History WHERE id = :id GROUP BY symbol\\\", id=session['user_id'])\\n shares = [share['SUM(shares)'] for share in get_shares]\\n cash = db.execute(\\\"SELECT cash FROM users WHERE id = :id\\\", id=session['user_id'])\\n\\n return render_template(\\\"index.html\\\", symbols_companies_shares=zip(symbols, companies, shares), lookup=lookup, cash=cash)\",\n \"def print_results(flight_info_list, departure_airport, return_airport):\\n flight_info_list = sorted(flight_info_list, key=lambda k: k[\\\"price($)\\\"])\\n\\n print \\\"*********************************************************\\\"\\n print \\\"Top 10 Cheapest Flights From {} to {}\\\".format(\\n departure_airport,\\n return_airport\\n )\\n print \\\"*********************************************************\\\"\\n\\n for i in flight_info_list[:10]:\\n print \\\"----------------------------------\\\"\\n print json.dumps(i, indent=4)\\n\\n flight_info_list = sorted(flight_info_list, key=lambda k: k[\\\"flight_duration(hours)\\\"])\\n\\n print \\\"*********************************************************\\\"\\n print \\\"Top 10 Shortest Flights From {} to {}\\\".format(\\n departure_airport,\\n return_airport\\n )\\n print \\\"*********************************************************\\\"\\n \\n for i in flight_info_list[:10]:\\n print \\\"----------------------------------\\\"\\n print json.dumps(i, indent=4)\\n\\n print \\\"--------------------------------------\\\"\\n print \\\"Total of %s flights were found\\\" % len(flight_info_list)\\n print \\\"--------------------------------------\\\"\",\n \"def print_all_donor_donations():\\n print(\\\"\\\\nList of Donors and Donations\\\")\\n print(\\\"\\\\nDonor Name - Donation Date - Donation Amount:\\\")\\n print(\\\"-\\\"*40)\\n for donation in donor_donations_list:\\n print(f'{donation.fullname} - {donation.donation_date} - ${donation.donation_amount:,.2f}')\\n print()\",\n \"def display(self):\\r\\n os.system('cls')\\r\\n index = 0\\r\\n for i in self.list:\\r\\n print(str(index) + \\\" \\\" + i.showRule())\\r\\n index += 1\",\n \"def index():\\n\\n # Get user's cash\\n user = db.execute(\\\"SELECT cash FROM users WHERE id = ?\\\", session[\\\"user_id\\\"])\\n\\n # Get portfolio\\n portfolios = db.execute(\\\"SELECT * FROM portfolios WHERE user_id = ?\\\", session[\\\"user_id\\\"])\\n\\n # Get symbol for each stock\\n length = len(portfolios)\\n for i in range(length):\\n symbol = portfolios[i]['stocks']\\n\\n # Lookup stock price and add to portfolio information\\n portfolios[i]['price'] = lookup(symbol)['price']\\n portfolios[i]['total'] = float(portfolios[i]['price']) * portfolios[i]['shares']\\n\\n # Calculate total value of stocks\\n value = 0\\n for j in range(length):\\n value += portfolios[j]['price']\\n\\n # Calculate grand total of stocks plus cash\\n g_total = user[0][\\\"cash\\\"] + value\\n\\n return render_template(\\\"index.html\\\", portfolios=portfolios, cash=user[0][\\\"cash\\\"], g_total=g_total)\",\n \"def list(self):\\n\\n for name in self.projects:\\n self.projects[name].show()\\n print(\\\"\\\\n\\\")\",\n \"def print_transactions_for_review(self, budget: Budget) -> None:\\n print(f'Please review the following transactions in the {budget.name} '\\n f'budget:')\\n transactions = self.get_transactions_by_budget(budget.category)\\n for transaction in transactions:\\n print(transaction)\",\n \"def manage_all():\\n user = Staff.is_login()\\n if user is None:\\n return redirect(url_for('auth.login'))\\n\\n if user.get_unit_role() == 'staff':\\n return redirect(url_for('pengusulan.table'))\\n\\n pengusulans = Pengusulan.get_by_unit(\\n unit_id=user.unit_id,\\n status=None\\n )\\n ranks = Pengusulan.calculate_averages(pengusulans)\\n return render_template(\\\"pengusulan/kelola-table.html\\\", pengusulans=pengusulans, ranks=ranks, pengusulan_code=pengusulan_code, status=None)\",\n \"def main():\\n \\n welcome()\\n myBill = get_bill_amt()\\n pct = get_tip_pct()\\n tip = calc_tip(myBill, pct)\\n show_results(myBill, tip, pct)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6818141","0.6373648","0.6282395","0.6123618","0.5956045","0.5908045","0.587244","0.58472174","0.58132833","0.5761324","0.57453924","0.5715379","0.57048655","0.5656268","0.5623658","0.5612284","0.5593725","0.55616355","0.55489856","0.55394465","0.5528048","0.5525896","0.54977864","0.5489402","0.5483476","0.54710567","0.5454062","0.54322153","0.54308444","0.54179245","0.5409253","0.5393394","0.53721434","0.5366639","0.535678","0.5341636","0.5340305","0.533862","0.5337897","0.53368634","0.5325031","0.5318795","0.5296872","0.5286867","0.52819186","0.5277214","0.5272164","0.5270105","0.5260658","0.5252854","0.52433985","0.5235415","0.52240914","0.52198493","0.52169895","0.5215214","0.5208136","0.51947016","0.5194392","0.51938707","0.51868916","0.51827216","0.5180301","0.51800543","0.5178068","0.51764923","0.5175919","0.51757336","0.51629496","0.51605713","0.5157476","0.5156055","0.5153464","0.51482487","0.51413774","0.514042","0.5130311","0.51285887","0.5125066","0.51084614","0.509836","0.5083547","0.5079016","0.5077672","0.5075019","0.50741434","0.50716215","0.5070945","0.5070436","0.50619894","0.50612915","0.5060966","0.50565773","0.505112","0.50410026","0.5034272","0.50340116","0.50302005","0.502564","0.5022318","0.5017857"],"string":"[\n \"0.6818141\",\n \"0.6373648\",\n \"0.6282395\",\n \"0.6123618\",\n \"0.5956045\",\n \"0.5908045\",\n \"0.587244\",\n \"0.58472174\",\n \"0.58132833\",\n \"0.5761324\",\n \"0.57453924\",\n \"0.5715379\",\n \"0.57048655\",\n \"0.5656268\",\n \"0.5623658\",\n \"0.5612284\",\n \"0.5593725\",\n \"0.55616355\",\n \"0.55489856\",\n \"0.55394465\",\n \"0.5528048\",\n \"0.5525896\",\n \"0.54977864\",\n \"0.5489402\",\n \"0.5483476\",\n \"0.54710567\",\n \"0.5454062\",\n \"0.54322153\",\n \"0.54308444\",\n \"0.54179245\",\n \"0.5409253\",\n \"0.5393394\",\n \"0.53721434\",\n \"0.5366639\",\n \"0.535678\",\n \"0.5341636\",\n \"0.5340305\",\n \"0.533862\",\n \"0.5337897\",\n \"0.53368634\",\n \"0.5325031\",\n \"0.5318795\",\n \"0.5296872\",\n \"0.5286867\",\n \"0.52819186\",\n \"0.5277214\",\n \"0.5272164\",\n \"0.5270105\",\n \"0.5260658\",\n \"0.5252854\",\n \"0.52433985\",\n \"0.5235415\",\n \"0.52240914\",\n \"0.52198493\",\n \"0.52169895\",\n \"0.5215214\",\n \"0.5208136\",\n \"0.51947016\",\n \"0.5194392\",\n \"0.51938707\",\n \"0.51868916\",\n \"0.51827216\",\n \"0.5180301\",\n \"0.51800543\",\n \"0.5178068\",\n \"0.51764923\",\n \"0.5175919\",\n \"0.51757336\",\n \"0.51629496\",\n \"0.51605713\",\n \"0.5157476\",\n \"0.5156055\",\n \"0.5153464\",\n \"0.51482487\",\n \"0.51413774\",\n \"0.514042\",\n \"0.5130311\",\n \"0.51285887\",\n \"0.5125066\",\n \"0.51084614\",\n \"0.509836\",\n \"0.5083547\",\n \"0.5079016\",\n \"0.5077672\",\n \"0.5075019\",\n \"0.50741434\",\n \"0.50716215\",\n \"0.5070945\",\n \"0.5070436\",\n \"0.50619894\",\n \"0.50612915\",\n \"0.5060966\",\n \"0.50565773\",\n \"0.505112\",\n \"0.50410026\",\n \"0.5034272\",\n \"0.50340116\",\n \"0.50302005\",\n \"0.502564\",\n \"0.5022318\",\n \"0.5017857\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":92895,"cells":{"query":{"kind":"string","value":"returns the budget for the defined tag"},"document":{"kind":"string","value":"def budget(config, tag):\n\tif tag in config[\"budget\"].keys():\n\t\tprint(tag)\n\telse:\n\t\tprint(config[\"budget\"].keys())"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def budget(self):\n return self._budget","def getBudget(movieInfo):\n if \"budget\" in movieInfo:\n return int(movieInfo[\"budget\"])\n else:\n raise AttributeError(\"%s instance has no attribute budget\" % movieInfo)","def get_budget(self, category: BudgetCategory) -> Budget:\n return self.budgets.get(category, None)","def get_expenses(budget):\n return sum(expense['bgt'] for expense in budget['spend'])","def budget(self):\n\n budget = (_House.closing_cost*self.vars['after_repair_value']) - self.vars['purchase_price'] - self.vars['profit'] - _House.broker_fee\n return float(round(budget, 2))","def GetCampaignBudget(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def budget_name(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"budget_name\")","def budget_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"budget_name\")","def find_balanced_budget_tax(c):\n def steady_state_budget(t):\n e, u, w = compute_steady_state_quantities(c, t)\n return t - u * c\n\n tau = brentq(steady_state_budget, 0.0, 0.9 * c)\n return tau","def get_unit(self,tag):","def getBudgetBalance(self, budgetName):\r\n assert budgetName in self.budgets, \"Specified budget doesn't exist\"\r\n return \"%.2f\" % float(self.budgets[budgetName])","def budget_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"budget_name\")","def get_budget_by_name(self, budget_name):\n return next((budget for budget in self.budgets\n if budget.name.lower() == budget_name.lower()), None)","def budget_balance(self):\n budget_balance = round(self.budget() - self.total_spent(), 2)\n budget_balance_degree = round( (9000 * self.total_spent()) / (self.budget()), 4) #convert to degrees and round to four decimal places\n return (budget_balance, budget_balance_degree)","def getBid(self):\r\n\t\treturn self.data['bid']","def budget_used(self):\n return int(self.total_spent() / self.budget() * 100.0)","def amount(self) -> Optional[pulumi.Input['BudgetAmountArgs']]:\n return pulumi.get(self, \"amount\")","def amount(self) -> pulumi.Input['BudgetAmountArgs']:\n return pulumi.get(self, \"amount\")","def budget_filter(self) -> pulumi.Output['outputs.BudgetBudgetFilter']:\n return pulumi.get(self, \"budget_filter\")","def getBid(self):\r\n\t\tdata = self.pair.data\r\n\t\tif data['ask'] == None:\r\n\t\t\treturn None\r\n\t\treturn 1. / data['ask']","async def read_concurrency_limit_by_tag(\n self,\n tag: str,\n ):\n try:\n response = await self._client.get(\n f\"/concurrency_limits/tag/{tag}\",\n )\n except httpx.HTTPStatusError as e:\n if e.response.status_code == status.HTTP_404_NOT_FOUND:\n raise prefect.exceptions.ObjectNotFound(http_exc=e) from e\n else:\n raise\n\n concurrency_limit_id = response.json().get(\"id\")\n\n if not concurrency_limit_id:\n raise httpx.RequestError(f\"Malformed response: {response}\")\n\n concurrency_limit = ConcurrencyLimit.parse_obj(response.json())\n return concurrency_limit","def amount(self) -> pulumi.Output['outputs.BudgetAmount']:\n return pulumi.get(self, \"amount\")","def amount(self) -> pulumi.Output['outputs.BudgetAmount']:\n return pulumi.get(self, \"amount\")","def get_budget_fixture(thing_being_farmed: int):\n if thing_being_farmed == 1:\n path = os.path.join(BASE_DIR, 'fixtures', 'tomato-budget.json')\n elif thing_being_farmed == 2:\n path = os.path.join(BASE_DIR, 'fixtures', 'broiler-budget.json')\n else:\n return None\n\n with open(path, 'r') as budget_fixture:\n budget = json.load(budget_fixture)\n\n return budget","def budget_filter(self) -> Optional[pulumi.Input['BudgetBudgetFilterArgs']]:\n return pulumi.get(self, \"budget_filter\")","def budget_filter(self) -> Optional[pulumi.Input['BudgetBudgetFilterArgs']]:\n return pulumi.get(self, \"budget_filter\")","def getTagStats(graph, tag):\n r = graph.getroot()\n s = graphToStatCount(r, tag)\n if ':' in tag:\n getExactBranch(s, tag)\n else:\n pruneStatCountBranches(s, tag)\n sendUpStatCountTagCounts(s, tag)\n return s","def get_debt(self):\n sum_import = self.invoice_set.filter(\n expiration_date__lte=date.today(),\n paid=False,\n debited=False,\n canceled=False,\n uncollectible=False,\n ).aggregate(Sum(\"amount\"))\n return sum_import.get(\"amount__sum\", None)","def get_budgets(self) -> list:\n return list(self.budgets.values())","def budget_filter(self) -> pulumi.Output[Optional['outputs.BudgetBudgetFilter']]:\n return pulumi.get(self, \"budget_filter\")","def create_budget(budget_category: BudgetCategory) -> Budget:\n amount = -1\n while amount <= 0:\n amount = float(input(f'Enter {budget_category.value} budget: '))\n if amount <= 0:\n print('Budget amount must be greater than 0! Please enter '\n 'again!')\n return Budget(budget_category, amount)","def getMoney(self):\n if 1 in self.money:\n return self.money[1]\n else:\n return 0","async def future_budget(budget: Budget):\n\n # Get the JSON object from the request body and cast it to a dictionary\n input_dict = budget.to_dict()\n bank_account_id = input_dict['bank_account_id']\n monthly_savings_goal = input_dict['monthly_savings_goal']\n\n transactions = load_user_data(bank_account_id)\n\n # instantiate the user\n user = User(transactions)\n\n # predict budget using time series model\n pred_bud = user.predict_budget()\n\n # if a fatal error was encountered while generating the budget,\n # return no budget along with the warning list\n if user.warning == 2:\n return json.dumps([None, user.warning_list])\n\n # modify budget based on savings goal\n modified_budget = user.budget_modifier(\n pred_bud, monthly_savings_goal=monthly_savings_goal)\n\n # if a fatal error was encountered while modifying the budget,\n # return no budget along with the warning list\n if user.warning == 2:\n return json.dumps([None, user.warning_list])\n\n # if a non-fatal warning was encountered in predict_budget() or\n # budget_modifier(), return the budget along with the warning list\n elif user.warning == 1:\n return json.dumps([modified_budget, user.warning_list])\n\n return modified_budget","def get_billed_amount(self):\n return Leg.objects.filter(transaction__recurred_cost__recurring_cost=self, amount__gt=0).sum_to_balance()","def declare_new_budget(date, exp_data):\n\n exp_list = exp_data[env.EXPENSE_DATA_KEY]\n local_budget = {}\n month_total = util.get_float_input(\n f\"Please input your total for the month ending {date}: \", force_pos=True)\n budg_remaining = month_total\n\n for i, exp in enumerate(exp_list):\n if i == len(exp_list) - 1:\n print(\"I got the last one for you :) MATH!\")\n budg_amnt = budg_remaining\n budg_remaining = 0\n\n elif budg_remaining == 0: # elif skips this condition if budget remaining is set above\n budg_amnt = 0\n local_budget[env.BUDGET_TOTAL_KEY] = month_total\n else:\n prompt = f\"Enter your budget for: [{exp}] - Total Budget Re. ${budg_remaining} - Exp's Re. [{len(exp_list) - i - 1}]: \"\n budg_amnt = prompt_for_budget_amnt(\n prompt, budg_remaining, exp_data)\n local_budget.update({exp: budg_amnt})\n budg_remaining = round(month_total - sum_budget(local_budget), 2)\n print(local_budget)\n return local_budget","def get_tag(self, tag, filename):\n return self.get_tag_batch(tag, [filename])[0]","def get_bucket_tagging(Bucket=None):\n pass","def get_tag(self, scope, key):\r\n print 'GETTING', scope, key, self._tags\r\n return self._tags[scope].get(key)","def budget_spent_with_commission(self):\n return self.budget_spent + self.budget_spent_commission","def get_money(self):\n return self.money","def get_tag_stats(self, tag):\n resp = self.get(_u.build_uri(\"tag.stats\", domain=self.domain),\n data={'tag': tag})\n return utils.handle_response(resp)","def sum_budget(monthly_budget: dict):\n sum = 0\n for k, v in monthly_budget.items():\n if v is not None and k != env.BUDGET_TOTAL_KEY:\n sum += v\n\n return sum","def select(self, budget):\n probs = self.predict_prob_dropout(self.unlabeled_x, self.n_drop)\n probs_sorted, idxs = probs.sort(descending=True)\n U = probs_sorted[:, 0] - probs_sorted[:,1]\n U_idx = U.sort()[1][:budget]\n return U_idx","def get_baggage_item(self, key):\n return None","def add_budget(self, budget: Budget) -> None:\n self.budgets[budget.category] = budget","def budget_problem3(balance, annualInterestRate):\r\n remaining = balance\r\n\r\n # creating the following bounds assists with bisection search\r\n lo = balance/12\r\n hi = ((balance * (annualInterestRate/12))**12)/12\r\n payment = (lo + hi)/2\r\n\r\n while remaining != 0:\r\n for month in range(12):\r\n remaining = (remaining - payment) * (1 + (annualInterestRate/12))\r\n if remaining > 0:\r\n lo = payment\r\n elif round(remaining,2) < -0.11:\r\n hi = payment\r\n else:\r\n break\r\n payment = (lo + hi)/2\r\n remaining = balance\r\n print 'Lowest Payment: ' + str(round(payment,2))\r\n return round(payment,2)","def __getitem__(self, tag):\n return self.__tags.get(tag.lower(), 0)","def assets(self) -> float:\n return self._money","def query_bid_price(market_data):\n print(\"Consultando BID\")\n if market_data[\"marketData\"][\"BI\"]:\n bid_price = market_data[\"marketData\"][\"BI\"][0][\"price\"]\n print(f\"Precio de BID: ${bid_price:,.2f}\".replace('.', ','))\n return bid_price\n print(\"No hay BIDs activos\")\n return None","def get_tag(self, tag):\n resp = self.get(_u.build_uri(\"tag\", domain=self.domain),\n data={'tag': tag})\n return utils.handle_response(resp)","def get_budgets(self) -> list:\n return self.budget_manager.get_budgets()","def matchBudget(toPredictBudget, toCompareBudget):\n\n #Calculate the % difference\n diff = abs(int(toPredictBudget) - int(toCompareBudget)) / int(toPredictBudget) * 100\n\n #Lookup the interval to return the correct number of points\n if diff <= 10:\n distance = BUDGET_DIST.get(\"1\")\n elif diff <= 15:\n distance = BUDGET_DIST.get(\"2\")\n elif diff <= 20:\n distance = BUDGET_DIST.get(\"3\")\n else:\n distance = BUDGET_DIST.get(\"4\")\n\n return distance","def get_budget_from_api(type_of_thing: int, qty: int):\n payload = {\"multiplier\": qty}\n if type_of_thing == 1:\n payload[\"commodity\"] = \"tomatoes\"\n elif type_of_thing == 2:\n payload[\"commodity\"] = \"broiler-chickens\"\n else:\n return None\n\n cache_key = f\"{type_of_thing}-{qty}\"\n\n val_from_cache = cache.get(cache_key)\n if val_from_cache:\n return val_from_cache\n\n json_payload = json.dumps(payload)\n\n r = requests.post(BUDGET_API_URL, json_payload)\n\n if r.status_code == 200:\n result = r.json()['data']\n cache.set(\n cache_key,\n result,\n BUDGET_CACHE_DURATION\n )\n return result\n\n return None","def _get_tag(self):\n return self.__tag","def calc_agent_budget(self, agent, assignment):\n budget_spent = sum([self.agent_cost(agent, t) for t in assignment[agent]])\n return self.agent_budget(agent) - budget_spent","def get_limb(life, limb):\n\treturn life['body'][limb]","def get_higest_bid(self):\n orders = self.returnOrderBook(1)\n return orders[\"bids\"][0]","def calc_task_budget(self, task, assignment):\n # Get the agents assigned to this task\n agents_assigned = {a for a, tasks in assignment.items() if task in tasks}\n budget_spent = sum([self.task_cost(a, task) for a in agents_assigned])\n return self.task_budget(task) - budget_spent","def _cost_based_distribution_ttl(self, budget):\n return int(max(self.DELAYS) + self._DELAY_GRACE + 60 + budget)","def get_tag(self) -> int:\n return self.tag","def get_config(self, budget):\n\t\traise NotImplementedError('This function needs to be overwritten in %s.'%(self.__class__.__name__))","def get_price():\n return uniform(1.0, 350.0)","def __init__(self, name, budget=100.00, bid_probability=0.35, bid_increase_perc=1.1):\n self.name = name\n self.bid_probability = bid_probability\n self.budget = budget\n self.bid_increase_perc = bid_increase_perc\n self.highest_bid = 0","def sum_monthly_budget(self):\n\n my_sumbud = 0\n \n month_bud = self.data['Monthly Budget']\n for i in month_bud:\n my_sumbud = my_sumbud + float(i)\n\n return my_sumbud","def fixedRateRelease(self, period):\n return self.parameters[0]","def getB(self, idx):\n if isinstance(idx, int):\n return self.dB[[idx]]\n else:\n return self.dB[idx]","def get_bet(self) -> int:\n return int(input(f\"How much money would you like to place? \"\n f\"(input an integer between {MINIMUM_BET()}-{self.balance}): \"))","def _get_max_expense(self):\n pass","def getBP(vt):\n vt['indivo_prefix'] = 'bp_' + vt['name']\n return getVital(vt)","def tag(self,name):\n return self._tags.get(name,None)","def get_broilers_budget(chickens: int = 1):\n budget = get_budget_fixture(thing_being_farmed=2)\n\n for i, segment in enumerate(budget['segments']):\n for i2, activity in enumerate(segment['activities']):\n for i3, item in enumerate(activity['inputs']):\n new_price = chickens * item['price']\n item['estimated_price'] = new_price\n item['price'] = new_price\n\n return budget","def balance(self, acct_id):\n acct = self.data.get(acct_id)\n if acct:\n bal = float(acct[\"due\"]) - float(acct[\"paid\"])\n return f\"${bal:.2f}\"\n return None","def box_budget(da_i, da_j, left_i, right_i, lower_j, upper_j, bs=None):\n\n upper = da_j.isel(XC=slice(left_i, right_i), YG=upper_j).rename('upper')\n lower = da_j.isel(XC=slice(left_i, right_i), YG=lower_j).rename('lower')\n right = da_i.isel(XG=right_i, YC=slice(lower_j, upper_j)).rename('right')\n left = da_i.isel(XG=left_i, YC=slice(lower_j, upper_j)).rename('left')\n \n if bs=='upper':\n return upper\n elif bs=='lower':\n return lower\n elif bs=='right':\n return right\n elif bs=='left':\n return left\n else:\n None \n \n return -upper.sum(('Z', 'XC')) + lower.sum(('Z', 'XC')) - right.sum(('Z', 'YC')) + left.sum(('Z', 'YC'))","def getPortfolioValue(self, start_t, t):\n sum_tmp=0\n for item in self.portfolio.keys():\n if \"DJI_\" in item:\n t_tmp=datetime.strftime(pd.date_range(end=t,periods=1,freq='B')[0],'%Y-%m-%d')\n price=universe.get_price_in_currency(item,t_tmp,'CAD')\n elif 'rf_rate' in item:\n price=universe.get_security(item).get_cc_return(start_t,t) \n else:\n price=universe.get_price_in_currency(item,t,'CAD')\n #price=universe.get_security(item).price[t]\n amount=self.portfolio[item]\n sum_tmp=sum_tmp+price*amount\n \n return sum_tmp","def calculate_value(self):\n base = self.balance\n bag = self.bag * self.state['price'] * (1-self.gap)\n value = base + bag\n self.value = value\n return value","def get_transfer_bid(self):\n return self._connect.post(constants.GET_TRANSFER_BID)","def get_spend_by_campaign_custom(self, budget_id, aw_account_id):\n try:\n budget = Budget.objects.get(id=budget_id)\n google_ads_account = DependentAccount.objects.get(id=aw_account_id)\n except (Budget.DoesNotExist, DependentAccount.DoesNotExist):\n return\n\n client = get_client()\n client.client_customer_id = google_ads_account.dependent_account_id\n\n aw_campaigns = budget.aw_campaigns.filter(account=google_ads_account)\n aw_campaign_ids = list(set([aw_campaign.campaign_id for aw_campaign in aw_campaigns]))\n\n report_downloader = client.GetReportDownloader(version=settings.API_VERSION)\n\n campaign_report_selector = {\n 'fields': ['Cost', 'CampaignId', 'CampaignStatus', 'CampaignName', 'Labels', 'Impressions'],\n 'predicates': [\n {\n 'field': 'Cost',\n 'operator': 'GREATER_THAN',\n 'values': '0'\n },\n {\n 'field': 'CampaignId',\n 'operator': 'IN',\n 'values': aw_campaign_ids\n }\n ]\n }\n\n campaign_report_query = {\n 'reportName': 'CAMPAIGN_PERFORMANCE_REPORT',\n 'dateRangeType': 'CUSTOM_DATE',\n 'reportType': 'CAMPAIGN_PERFORMANCE_REPORT',\n 'downloadFormat': 'CSV',\n 'selector': campaign_report_selector\n }\n\n start_date = budget.start_date\n end_date = budget.end_date\n\n campaign_report_selector['dateRange'] = {\n 'min': start_date.strftime('%Y%m%d'),\n 'max': end_date.strftime('%Y%m%d')\n }\n\n campaign_report = Reporting.parse_report_csv_new(report_downloader.DownloadReportAsString(campaign_report_query))\n for campaign_row in campaign_report:\n print(campaign_row)\n campaign_id = campaign_row['campaign_id']\n campaign, created = Campaign.objects.get_or_create(campaign_id=campaign_id, account=google_ads_account)\n campaign.campaign_name = campaign_row['campaign']\n campaign.save()\n campaign_spend_object, created = CampaignSpendDateRange.objects.get_or_create(campaign=campaign,\n start_date=start_date,\n end_date=end_date)\n\n campaign_spend_object.spend = int(campaign_row['cost']) / 1000000\n campaign_spend_object.save()\n\n yest_campaign_report_selector = {\n 'fields': ['Cost', 'CampaignId', 'CampaignStatus', 'CampaignName', 'Labels', 'Impressions'],\n 'predicates': [\n {\n 'field': 'Cost',\n 'operator': 'GREATER_THAN',\n 'values': '0'\n },\n {\n 'field': 'CampaignId',\n 'operator': 'IN',\n 'values': aw_campaign_ids\n }\n ]\n }\n\n yest_campaign_report_query = {\n 'reportName': 'CAMPAIGN_PERFORMANCE_REPORT',\n 'dateRangeType': 'CUSTOM_DATE',\n 'reportType': 'CAMPAIGN_PERFORMANCE_REPORT',\n 'downloadFormat': 'CSV',\n 'selector': yest_campaign_report_selector\n }\n\n start_date = budget.start_date\n yest_end_date = datetime.datetime.now() - datetime.timedelta(1)\n\n yest_campaign_report_selector['dateRange'] = {\n 'min': start_date.strftime('%Y%m%d'),\n 'max': yest_end_date.strftime('%Y%m%d')\n }\n\n campaign_report = Reporting.parse_report_csv_new(\n report_downloader.DownloadReportAsString(yest_campaign_report_query))\n for campaign_row in campaign_report:\n campaign_id = campaign_row['campaign_id']\n campaign, created = Campaign.objects.get_or_create(campaign_id=campaign_id, account=google_ads_account)\n campaign.campaign_name = campaign_row['campaign']\n campaign.save()\n campaign_spend_object, created = CampaignSpendDateRange.objects.get_or_create(campaign=campaign,\n start_date=start_date,\n end_date=end_date)\n\n campaign_spend_object.spend_until_yesterday = int(campaign_row['cost']) / 1000000\n campaign_spend_object.save()\n\n # try:\n # campaign_report = \\\n # Reporting.parse_report_csv_new(report_downloader.DownloadReportAsString(yest_campaign_report_query))[0]\n # except IndexError:\n # return\n #\n # campaign_spend_object, created = CampaignSpendDateRange.objects.get_or_create(campaign=campaign,\n # start_date=budget.start_date,\n # end_date=budget.end_date)\n #\n # campaign_spend_object.spend_until_yesterday = int(campaign_report['cost']) / 1000000\n # campaign_spend_object.save()\n\n return 'get_spend_by_campaign_custom'","def bid(self, tf=None):\n if self._ticks:\n return self._ticks[-1][1]\n else:\n candles = None\n if tf and self._candles.get(tf):\n candles = self._candles[tf]\n elif self._candles.get(Instrument.TF_SEC):\n candles = self._candles[Instrument.TF_SEC]\n elif self._candles.get(Instrument.TF_MIN):\n candles = self._candles[Instrument.TF_MIN]\n\n if candles:\n return candles[-1].bid_close\n \n return None","def view_budgets(self) -> None:\n Menu.prompt_view_budgets()\n for budget in self.user.budget_manager:\n print(f\"{budget}\\n\")","def getGemPrice():\n return Gw2Spidy._request('gem-price')","def get_tag(tag):\r\n from tagging.models import Tag\r\n if isinstance(tag, Tag):\r\n return tag\r\n\r\n try:\r\n if isinstance(tag, types.StringTypes):\r\n return Tag.objects.get(name=tag)\r\n elif isinstance(tag, (types.IntType, types.LongType)):\r\n return Tag.objects.get(id=tag)\r\n except Tag.DoesNotExist:\r\n pass\r\n\r\n return None","def GetFromTag(cls, tag):\n parent_key = cls._GetParentKeyFromTag(tag)\n return cls.query(ancestor=parent_key).get()","def __getitem__(self, tag):\n return self.get(tag)","def get_level(tag: str) -> int:\n return TAG_LEVELS[tag]","def get(self):\n return self.tag.get()","def baggage(self):\n return SpanContext.EMPTY_BAGGAGE","def buoyancy_factor(self, fac):\n return fac","async def __getBBL_async(self, account, projectedBillData) -> dict:\n _LOGGER.info(\"Getting budget billing data\")\n data = {}\n\n try:\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(\n URL_BUDGET_BILLING_PREMISE_DETAILS.format(account=account)\n )\n if response.status == 200:\n r = (await response.json())[\"data\"]\n dataList = r[\"graphData\"]\n\n # startIndex = len(dataList) - 1\n\n billingCharge = 0\n budgetBillDeferBalance = r[\"defAmt\"]\n\n projectedBill = projectedBillData[\"projected_bill\"]\n asOfDays = projectedBillData[\"as_of_days\"]\n\n for det in dataList:\n billingCharge += det[\"actuallBillAmt\"]\n\n calc1 = (projectedBill + billingCharge) / 12\n calc2 = (1 / 12) * (budgetBillDeferBalance)\n\n projectedBudgetBill = round(calc1 + calc2, 2)\n bbDailyAvg = round(projectedBudgetBill / 30, 2)\n bbAsOfDateAmt = round(projectedBudgetBill / 30 * asOfDays, 2)\n\n data[\"budget_billing_daily_avg\"] = bbDailyAvg\n data[\"budget_billing_bill_to_date\"] = bbAsOfDateAmt\n\n data[\"budget_billing_projected_bill\"] = float(projectedBudgetBill)\n\n async with async_timeout.timeout(TIMEOUT):\n response = await self.session.get(\n URL_BUDGET_BILLING_GRAPH.format(account=account)\n )\n if response.status == 200:\n r = (await response.json())[\"data\"]\n data[\"bill_to_date\"] = float(r[\"eleAmt\"])\n data[\"defered_amount\"] = float(r[\"defAmt\"])\n except Exception as e:\n _LOGGER.error(e)\n\n return data","def _get_tagged_value(self, key):\n return self._tagged_values_dict[key]","def _get_optuna_time_budget(self):\n self._validate_optuna_time_budget()\n\n if self.optuna_time_budget is None:\n if self._get_mode() == \"Optuna\":\n return 3600\n return None\n else:\n if self._get_mode() != \"Optuna\":\n # use only for mode Optuna\n return None\n return deepcopy(self.optuna_time_budget)","def highest_bid(self):\n (price_eur, volume, _) = self._order_book['bids'][0]\n price_usd = Decimal(price_eur) * self._eurusd_rate\n return {\n 'price': Decimal(price_usd),\n 'volume': Decimal(volume),\n }","def amount_bet(self, user):\n try:\n return Bet.objects.get(group_match = self, user=user).amount\n except Bet.DoesNotExist:\n return Decimal(0)","def tag_word(self, w): \n if self.unknown(w):\n return self.default_tag\n else:\n return max(self.word_tags[w], key=self.word_tags[w].get)","def get_sample_badge(self):\n\n badgr = self.get_badgr_setup()\n with vcr.use_cassette('tests/vcr_cassettes/badge_retrieval.yaml'):\n return badgr.badges[0]","async def get_trending_tags(start_tag: str = '', limit: int = 250):\n assert start_tag == '', 'tags pagination not supported'\n assert limit == 250, 'only returns exactly 250 tags'\n sql = \"\"\"\n SELECT category,\n COUNT(*) AS total_posts,\n SUM(CASE WHEN depth = 0 THEN 1 ELSE 0 END) AS top_posts,\n SUM(payout) AS total_payouts\n FROM hive_posts_cache\n WHERE is_paidout = '0'\n GROUP BY category\n ORDER BY SUM(payout) DESC\n LIMIT 250\n \"\"\"\n out = []\n for row in query_all(sql):\n out.append({\n 'comments': row['total_posts'] - row['top_posts'],\n 'name': row['category'],\n 'top_posts': row['top_posts'],\n 'total_payouts': \"%.3f SBD\" % row['total_payouts']})\n\n return out","def read_tag(\n *,\n db: Session = Depends(get_db),\n id: int,\n current_user: DBUser = Depends(get_current_active_user),\n):\n tag = crud.tag.get(db_session=db, id=id)\n if not tag:\n raise HTTPException(status_code=404, detail=\"Tag not found\")\n if not crud.user.is_superuser(current_user) and (tag.owner_id != current_user.id):\n raise HTTPException(status_code=400, detail=\"Not enough permissions\")\n return tag","def _get_tag(self, tag):\n return self.prefix + tag","def get_tag(self):\n return self.tag","def _bidding_function(self):\n return self._bid_value","def getValue(tree, tag):\n try:\n return tree.find(tag).text\n except AttributeError:\n return None"],"string":"[\n \"def budget(self):\\n return self._budget\",\n \"def getBudget(movieInfo):\\n if \\\"budget\\\" in movieInfo:\\n return int(movieInfo[\\\"budget\\\"])\\n else:\\n raise AttributeError(\\\"%s instance has no attribute budget\\\" % movieInfo)\",\n \"def get_budget(self, category: BudgetCategory) -> Budget:\\n return self.budgets.get(category, None)\",\n \"def get_expenses(budget):\\n return sum(expense['bgt'] for expense in budget['spend'])\",\n \"def budget(self):\\n\\n budget = (_House.closing_cost*self.vars['after_repair_value']) - self.vars['purchase_price'] - self.vars['profit'] - _House.broker_fee\\n return float(round(budget, 2))\",\n \"def GetCampaignBudget(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def budget_name(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"budget_name\\\")\",\n \"def budget_name(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"budget_name\\\")\",\n \"def find_balanced_budget_tax(c):\\n def steady_state_budget(t):\\n e, u, w = compute_steady_state_quantities(c, t)\\n return t - u * c\\n\\n tau = brentq(steady_state_budget, 0.0, 0.9 * c)\\n return tau\",\n \"def get_unit(self,tag):\",\n \"def getBudgetBalance(self, budgetName):\\r\\n assert budgetName in self.budgets, \\\"Specified budget doesn't exist\\\"\\r\\n return \\\"%.2f\\\" % float(self.budgets[budgetName])\",\n \"def budget_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"budget_name\\\")\",\n \"def get_budget_by_name(self, budget_name):\\n return next((budget for budget in self.budgets\\n if budget.name.lower() == budget_name.lower()), None)\",\n \"def budget_balance(self):\\n budget_balance = round(self.budget() - self.total_spent(), 2)\\n budget_balance_degree = round( (9000 * self.total_spent()) / (self.budget()), 4) #convert to degrees and round to four decimal places\\n return (budget_balance, budget_balance_degree)\",\n \"def getBid(self):\\r\\n\\t\\treturn self.data['bid']\",\n \"def budget_used(self):\\n return int(self.total_spent() / self.budget() * 100.0)\",\n \"def amount(self) -> Optional[pulumi.Input['BudgetAmountArgs']]:\\n return pulumi.get(self, \\\"amount\\\")\",\n \"def amount(self) -> pulumi.Input['BudgetAmountArgs']:\\n return pulumi.get(self, \\\"amount\\\")\",\n \"def budget_filter(self) -> pulumi.Output['outputs.BudgetBudgetFilter']:\\n return pulumi.get(self, \\\"budget_filter\\\")\",\n \"def getBid(self):\\r\\n\\t\\tdata = self.pair.data\\r\\n\\t\\tif data['ask'] == None:\\r\\n\\t\\t\\treturn None\\r\\n\\t\\treturn 1. / data['ask']\",\n \"async def read_concurrency_limit_by_tag(\\n self,\\n tag: str,\\n ):\\n try:\\n response = await self._client.get(\\n f\\\"/concurrency_limits/tag/{tag}\\\",\\n )\\n except httpx.HTTPStatusError as e:\\n if e.response.status_code == status.HTTP_404_NOT_FOUND:\\n raise prefect.exceptions.ObjectNotFound(http_exc=e) from e\\n else:\\n raise\\n\\n concurrency_limit_id = response.json().get(\\\"id\\\")\\n\\n if not concurrency_limit_id:\\n raise httpx.RequestError(f\\\"Malformed response: {response}\\\")\\n\\n concurrency_limit = ConcurrencyLimit.parse_obj(response.json())\\n return concurrency_limit\",\n \"def amount(self) -> pulumi.Output['outputs.BudgetAmount']:\\n return pulumi.get(self, \\\"amount\\\")\",\n \"def amount(self) -> pulumi.Output['outputs.BudgetAmount']:\\n return pulumi.get(self, \\\"amount\\\")\",\n \"def get_budget_fixture(thing_being_farmed: int):\\n if thing_being_farmed == 1:\\n path = os.path.join(BASE_DIR, 'fixtures', 'tomato-budget.json')\\n elif thing_being_farmed == 2:\\n path = os.path.join(BASE_DIR, 'fixtures', 'broiler-budget.json')\\n else:\\n return None\\n\\n with open(path, 'r') as budget_fixture:\\n budget = json.load(budget_fixture)\\n\\n return budget\",\n \"def budget_filter(self) -> Optional[pulumi.Input['BudgetBudgetFilterArgs']]:\\n return pulumi.get(self, \\\"budget_filter\\\")\",\n \"def budget_filter(self) -> Optional[pulumi.Input['BudgetBudgetFilterArgs']]:\\n return pulumi.get(self, \\\"budget_filter\\\")\",\n \"def getTagStats(graph, tag):\\n r = graph.getroot()\\n s = graphToStatCount(r, tag)\\n if ':' in tag:\\n getExactBranch(s, tag)\\n else:\\n pruneStatCountBranches(s, tag)\\n sendUpStatCountTagCounts(s, tag)\\n return s\",\n \"def get_debt(self):\\n sum_import = self.invoice_set.filter(\\n expiration_date__lte=date.today(),\\n paid=False,\\n debited=False,\\n canceled=False,\\n uncollectible=False,\\n ).aggregate(Sum(\\\"amount\\\"))\\n return sum_import.get(\\\"amount__sum\\\", None)\",\n \"def get_budgets(self) -> list:\\n return list(self.budgets.values())\",\n \"def budget_filter(self) -> pulumi.Output[Optional['outputs.BudgetBudgetFilter']]:\\n return pulumi.get(self, \\\"budget_filter\\\")\",\n \"def create_budget(budget_category: BudgetCategory) -> Budget:\\n amount = -1\\n while amount <= 0:\\n amount = float(input(f'Enter {budget_category.value} budget: '))\\n if amount <= 0:\\n print('Budget amount must be greater than 0! Please enter '\\n 'again!')\\n return Budget(budget_category, amount)\",\n \"def getMoney(self):\\n if 1 in self.money:\\n return self.money[1]\\n else:\\n return 0\",\n \"async def future_budget(budget: Budget):\\n\\n # Get the JSON object from the request body and cast it to a dictionary\\n input_dict = budget.to_dict()\\n bank_account_id = input_dict['bank_account_id']\\n monthly_savings_goal = input_dict['monthly_savings_goal']\\n\\n transactions = load_user_data(bank_account_id)\\n\\n # instantiate the user\\n user = User(transactions)\\n\\n # predict budget using time series model\\n pred_bud = user.predict_budget()\\n\\n # if a fatal error was encountered while generating the budget,\\n # return no budget along with the warning list\\n if user.warning == 2:\\n return json.dumps([None, user.warning_list])\\n\\n # modify budget based on savings goal\\n modified_budget = user.budget_modifier(\\n pred_bud, monthly_savings_goal=monthly_savings_goal)\\n\\n # if a fatal error was encountered while modifying the budget,\\n # return no budget along with the warning list\\n if user.warning == 2:\\n return json.dumps([None, user.warning_list])\\n\\n # if a non-fatal warning was encountered in predict_budget() or\\n # budget_modifier(), return the budget along with the warning list\\n elif user.warning == 1:\\n return json.dumps([modified_budget, user.warning_list])\\n\\n return modified_budget\",\n \"def get_billed_amount(self):\\n return Leg.objects.filter(transaction__recurred_cost__recurring_cost=self, amount__gt=0).sum_to_balance()\",\n \"def declare_new_budget(date, exp_data):\\n\\n exp_list = exp_data[env.EXPENSE_DATA_KEY]\\n local_budget = {}\\n month_total = util.get_float_input(\\n f\\\"Please input your total for the month ending {date}: \\\", force_pos=True)\\n budg_remaining = month_total\\n\\n for i, exp in enumerate(exp_list):\\n if i == len(exp_list) - 1:\\n print(\\\"I got the last one for you :) MATH!\\\")\\n budg_amnt = budg_remaining\\n budg_remaining = 0\\n\\n elif budg_remaining == 0: # elif skips this condition if budget remaining is set above\\n budg_amnt = 0\\n local_budget[env.BUDGET_TOTAL_KEY] = month_total\\n else:\\n prompt = f\\\"Enter your budget for: [{exp}] - Total Budget Re. ${budg_remaining} - Exp's Re. [{len(exp_list) - i - 1}]: \\\"\\n budg_amnt = prompt_for_budget_amnt(\\n prompt, budg_remaining, exp_data)\\n local_budget.update({exp: budg_amnt})\\n budg_remaining = round(month_total - sum_budget(local_budget), 2)\\n print(local_budget)\\n return local_budget\",\n \"def get_tag(self, tag, filename):\\n return self.get_tag_batch(tag, [filename])[0]\",\n \"def get_bucket_tagging(Bucket=None):\\n pass\",\n \"def get_tag(self, scope, key):\\r\\n print 'GETTING', scope, key, self._tags\\r\\n return self._tags[scope].get(key)\",\n \"def budget_spent_with_commission(self):\\n return self.budget_spent + self.budget_spent_commission\",\n \"def get_money(self):\\n return self.money\",\n \"def get_tag_stats(self, tag):\\n resp = self.get(_u.build_uri(\\\"tag.stats\\\", domain=self.domain),\\n data={'tag': tag})\\n return utils.handle_response(resp)\",\n \"def sum_budget(monthly_budget: dict):\\n sum = 0\\n for k, v in monthly_budget.items():\\n if v is not None and k != env.BUDGET_TOTAL_KEY:\\n sum += v\\n\\n return sum\",\n \"def select(self, budget):\\n probs = self.predict_prob_dropout(self.unlabeled_x, self.n_drop)\\n probs_sorted, idxs = probs.sort(descending=True)\\n U = probs_sorted[:, 0] - probs_sorted[:,1]\\n U_idx = U.sort()[1][:budget]\\n return U_idx\",\n \"def get_baggage_item(self, key):\\n return None\",\n \"def add_budget(self, budget: Budget) -> None:\\n self.budgets[budget.category] = budget\",\n \"def budget_problem3(balance, annualInterestRate):\\r\\n remaining = balance\\r\\n\\r\\n # creating the following bounds assists with bisection search\\r\\n lo = balance/12\\r\\n hi = ((balance * (annualInterestRate/12))**12)/12\\r\\n payment = (lo + hi)/2\\r\\n\\r\\n while remaining != 0:\\r\\n for month in range(12):\\r\\n remaining = (remaining - payment) * (1 + (annualInterestRate/12))\\r\\n if remaining > 0:\\r\\n lo = payment\\r\\n elif round(remaining,2) < -0.11:\\r\\n hi = payment\\r\\n else:\\r\\n break\\r\\n payment = (lo + hi)/2\\r\\n remaining = balance\\r\\n print 'Lowest Payment: ' + str(round(payment,2))\\r\\n return round(payment,2)\",\n \"def __getitem__(self, tag):\\n return self.__tags.get(tag.lower(), 0)\",\n \"def assets(self) -> float:\\n return self._money\",\n \"def query_bid_price(market_data):\\n print(\\\"Consultando BID\\\")\\n if market_data[\\\"marketData\\\"][\\\"BI\\\"]:\\n bid_price = market_data[\\\"marketData\\\"][\\\"BI\\\"][0][\\\"price\\\"]\\n print(f\\\"Precio de BID: ${bid_price:,.2f}\\\".replace('.', ','))\\n return bid_price\\n print(\\\"No hay BIDs activos\\\")\\n return None\",\n \"def get_tag(self, tag):\\n resp = self.get(_u.build_uri(\\\"tag\\\", domain=self.domain),\\n data={'tag': tag})\\n return utils.handle_response(resp)\",\n \"def get_budgets(self) -> list:\\n return self.budget_manager.get_budgets()\",\n \"def matchBudget(toPredictBudget, toCompareBudget):\\n\\n #Calculate the % difference\\n diff = abs(int(toPredictBudget) - int(toCompareBudget)) / int(toPredictBudget) * 100\\n\\n #Lookup the interval to return the correct number of points\\n if diff <= 10:\\n distance = BUDGET_DIST.get(\\\"1\\\")\\n elif diff <= 15:\\n distance = BUDGET_DIST.get(\\\"2\\\")\\n elif diff <= 20:\\n distance = BUDGET_DIST.get(\\\"3\\\")\\n else:\\n distance = BUDGET_DIST.get(\\\"4\\\")\\n\\n return distance\",\n \"def get_budget_from_api(type_of_thing: int, qty: int):\\n payload = {\\\"multiplier\\\": qty}\\n if type_of_thing == 1:\\n payload[\\\"commodity\\\"] = \\\"tomatoes\\\"\\n elif type_of_thing == 2:\\n payload[\\\"commodity\\\"] = \\\"broiler-chickens\\\"\\n else:\\n return None\\n\\n cache_key = f\\\"{type_of_thing}-{qty}\\\"\\n\\n val_from_cache = cache.get(cache_key)\\n if val_from_cache:\\n return val_from_cache\\n\\n json_payload = json.dumps(payload)\\n\\n r = requests.post(BUDGET_API_URL, json_payload)\\n\\n if r.status_code == 200:\\n result = r.json()['data']\\n cache.set(\\n cache_key,\\n result,\\n BUDGET_CACHE_DURATION\\n )\\n return result\\n\\n return None\",\n \"def _get_tag(self):\\n return self.__tag\",\n \"def calc_agent_budget(self, agent, assignment):\\n budget_spent = sum([self.agent_cost(agent, t) for t in assignment[agent]])\\n return self.agent_budget(agent) - budget_spent\",\n \"def get_limb(life, limb):\\n\\treturn life['body'][limb]\",\n \"def get_higest_bid(self):\\n orders = self.returnOrderBook(1)\\n return orders[\\\"bids\\\"][0]\",\n \"def calc_task_budget(self, task, assignment):\\n # Get the agents assigned to this task\\n agents_assigned = {a for a, tasks in assignment.items() if task in tasks}\\n budget_spent = sum([self.task_cost(a, task) for a in agents_assigned])\\n return self.task_budget(task) - budget_spent\",\n \"def _cost_based_distribution_ttl(self, budget):\\n return int(max(self.DELAYS) + self._DELAY_GRACE + 60 + budget)\",\n \"def get_tag(self) -> int:\\n return self.tag\",\n \"def get_config(self, budget):\\n\\t\\traise NotImplementedError('This function needs to be overwritten in %s.'%(self.__class__.__name__))\",\n \"def get_price():\\n return uniform(1.0, 350.0)\",\n \"def __init__(self, name, budget=100.00, bid_probability=0.35, bid_increase_perc=1.1):\\n self.name = name\\n self.bid_probability = bid_probability\\n self.budget = budget\\n self.bid_increase_perc = bid_increase_perc\\n self.highest_bid = 0\",\n \"def sum_monthly_budget(self):\\n\\n my_sumbud = 0\\n \\n month_bud = self.data['Monthly Budget']\\n for i in month_bud:\\n my_sumbud = my_sumbud + float(i)\\n\\n return my_sumbud\",\n \"def fixedRateRelease(self, period):\\n return self.parameters[0]\",\n \"def getB(self, idx):\\n if isinstance(idx, int):\\n return self.dB[[idx]]\\n else:\\n return self.dB[idx]\",\n \"def get_bet(self) -> int:\\n return int(input(f\\\"How much money would you like to place? \\\"\\n f\\\"(input an integer between {MINIMUM_BET()}-{self.balance}): \\\"))\",\n \"def _get_max_expense(self):\\n pass\",\n \"def getBP(vt):\\n vt['indivo_prefix'] = 'bp_' + vt['name']\\n return getVital(vt)\",\n \"def tag(self,name):\\n return self._tags.get(name,None)\",\n \"def get_broilers_budget(chickens: int = 1):\\n budget = get_budget_fixture(thing_being_farmed=2)\\n\\n for i, segment in enumerate(budget['segments']):\\n for i2, activity in enumerate(segment['activities']):\\n for i3, item in enumerate(activity['inputs']):\\n new_price = chickens * item['price']\\n item['estimated_price'] = new_price\\n item['price'] = new_price\\n\\n return budget\",\n \"def balance(self, acct_id):\\n acct = self.data.get(acct_id)\\n if acct:\\n bal = float(acct[\\\"due\\\"]) - float(acct[\\\"paid\\\"])\\n return f\\\"${bal:.2f}\\\"\\n return None\",\n \"def box_budget(da_i, da_j, left_i, right_i, lower_j, upper_j, bs=None):\\n\\n upper = da_j.isel(XC=slice(left_i, right_i), YG=upper_j).rename('upper')\\n lower = da_j.isel(XC=slice(left_i, right_i), YG=lower_j).rename('lower')\\n right = da_i.isel(XG=right_i, YC=slice(lower_j, upper_j)).rename('right')\\n left = da_i.isel(XG=left_i, YC=slice(lower_j, upper_j)).rename('left')\\n \\n if bs=='upper':\\n return upper\\n elif bs=='lower':\\n return lower\\n elif bs=='right':\\n return right\\n elif bs=='left':\\n return left\\n else:\\n None \\n \\n return -upper.sum(('Z', 'XC')) + lower.sum(('Z', 'XC')) - right.sum(('Z', 'YC')) + left.sum(('Z', 'YC'))\",\n \"def getPortfolioValue(self, start_t, t):\\n sum_tmp=0\\n for item in self.portfolio.keys():\\n if \\\"DJI_\\\" in item:\\n t_tmp=datetime.strftime(pd.date_range(end=t,periods=1,freq='B')[0],'%Y-%m-%d')\\n price=universe.get_price_in_currency(item,t_tmp,'CAD')\\n elif 'rf_rate' in item:\\n price=universe.get_security(item).get_cc_return(start_t,t) \\n else:\\n price=universe.get_price_in_currency(item,t,'CAD')\\n #price=universe.get_security(item).price[t]\\n amount=self.portfolio[item]\\n sum_tmp=sum_tmp+price*amount\\n \\n return sum_tmp\",\n \"def calculate_value(self):\\n base = self.balance\\n bag = self.bag * self.state['price'] * (1-self.gap)\\n value = base + bag\\n self.value = value\\n return value\",\n \"def get_transfer_bid(self):\\n return self._connect.post(constants.GET_TRANSFER_BID)\",\n \"def get_spend_by_campaign_custom(self, budget_id, aw_account_id):\\n try:\\n budget = Budget.objects.get(id=budget_id)\\n google_ads_account = DependentAccount.objects.get(id=aw_account_id)\\n except (Budget.DoesNotExist, DependentAccount.DoesNotExist):\\n return\\n\\n client = get_client()\\n client.client_customer_id = google_ads_account.dependent_account_id\\n\\n aw_campaigns = budget.aw_campaigns.filter(account=google_ads_account)\\n aw_campaign_ids = list(set([aw_campaign.campaign_id for aw_campaign in aw_campaigns]))\\n\\n report_downloader = client.GetReportDownloader(version=settings.API_VERSION)\\n\\n campaign_report_selector = {\\n 'fields': ['Cost', 'CampaignId', 'CampaignStatus', 'CampaignName', 'Labels', 'Impressions'],\\n 'predicates': [\\n {\\n 'field': 'Cost',\\n 'operator': 'GREATER_THAN',\\n 'values': '0'\\n },\\n {\\n 'field': 'CampaignId',\\n 'operator': 'IN',\\n 'values': aw_campaign_ids\\n }\\n ]\\n }\\n\\n campaign_report_query = {\\n 'reportName': 'CAMPAIGN_PERFORMANCE_REPORT',\\n 'dateRangeType': 'CUSTOM_DATE',\\n 'reportType': 'CAMPAIGN_PERFORMANCE_REPORT',\\n 'downloadFormat': 'CSV',\\n 'selector': campaign_report_selector\\n }\\n\\n start_date = budget.start_date\\n end_date = budget.end_date\\n\\n campaign_report_selector['dateRange'] = {\\n 'min': start_date.strftime('%Y%m%d'),\\n 'max': end_date.strftime('%Y%m%d')\\n }\\n\\n campaign_report = Reporting.parse_report_csv_new(report_downloader.DownloadReportAsString(campaign_report_query))\\n for campaign_row in campaign_report:\\n print(campaign_row)\\n campaign_id = campaign_row['campaign_id']\\n campaign, created = Campaign.objects.get_or_create(campaign_id=campaign_id, account=google_ads_account)\\n campaign.campaign_name = campaign_row['campaign']\\n campaign.save()\\n campaign_spend_object, created = CampaignSpendDateRange.objects.get_or_create(campaign=campaign,\\n start_date=start_date,\\n end_date=end_date)\\n\\n campaign_spend_object.spend = int(campaign_row['cost']) / 1000000\\n campaign_spend_object.save()\\n\\n yest_campaign_report_selector = {\\n 'fields': ['Cost', 'CampaignId', 'CampaignStatus', 'CampaignName', 'Labels', 'Impressions'],\\n 'predicates': [\\n {\\n 'field': 'Cost',\\n 'operator': 'GREATER_THAN',\\n 'values': '0'\\n },\\n {\\n 'field': 'CampaignId',\\n 'operator': 'IN',\\n 'values': aw_campaign_ids\\n }\\n ]\\n }\\n\\n yest_campaign_report_query = {\\n 'reportName': 'CAMPAIGN_PERFORMANCE_REPORT',\\n 'dateRangeType': 'CUSTOM_DATE',\\n 'reportType': 'CAMPAIGN_PERFORMANCE_REPORT',\\n 'downloadFormat': 'CSV',\\n 'selector': yest_campaign_report_selector\\n }\\n\\n start_date = budget.start_date\\n yest_end_date = datetime.datetime.now() - datetime.timedelta(1)\\n\\n yest_campaign_report_selector['dateRange'] = {\\n 'min': start_date.strftime('%Y%m%d'),\\n 'max': yest_end_date.strftime('%Y%m%d')\\n }\\n\\n campaign_report = Reporting.parse_report_csv_new(\\n report_downloader.DownloadReportAsString(yest_campaign_report_query))\\n for campaign_row in campaign_report:\\n campaign_id = campaign_row['campaign_id']\\n campaign, created = Campaign.objects.get_or_create(campaign_id=campaign_id, account=google_ads_account)\\n campaign.campaign_name = campaign_row['campaign']\\n campaign.save()\\n campaign_spend_object, created = CampaignSpendDateRange.objects.get_or_create(campaign=campaign,\\n start_date=start_date,\\n end_date=end_date)\\n\\n campaign_spend_object.spend_until_yesterday = int(campaign_row['cost']) / 1000000\\n campaign_spend_object.save()\\n\\n # try:\\n # campaign_report = \\\\\\n # Reporting.parse_report_csv_new(report_downloader.DownloadReportAsString(yest_campaign_report_query))[0]\\n # except IndexError:\\n # return\\n #\\n # campaign_spend_object, created = CampaignSpendDateRange.objects.get_or_create(campaign=campaign,\\n # start_date=budget.start_date,\\n # end_date=budget.end_date)\\n #\\n # campaign_spend_object.spend_until_yesterday = int(campaign_report['cost']) / 1000000\\n # campaign_spend_object.save()\\n\\n return 'get_spend_by_campaign_custom'\",\n \"def bid(self, tf=None):\\n if self._ticks:\\n return self._ticks[-1][1]\\n else:\\n candles = None\\n if tf and self._candles.get(tf):\\n candles = self._candles[tf]\\n elif self._candles.get(Instrument.TF_SEC):\\n candles = self._candles[Instrument.TF_SEC]\\n elif self._candles.get(Instrument.TF_MIN):\\n candles = self._candles[Instrument.TF_MIN]\\n\\n if candles:\\n return candles[-1].bid_close\\n \\n return None\",\n \"def view_budgets(self) -> None:\\n Menu.prompt_view_budgets()\\n for budget in self.user.budget_manager:\\n print(f\\\"{budget}\\\\n\\\")\",\n \"def getGemPrice():\\n return Gw2Spidy._request('gem-price')\",\n \"def get_tag(tag):\\r\\n from tagging.models import Tag\\r\\n if isinstance(tag, Tag):\\r\\n return tag\\r\\n\\r\\n try:\\r\\n if isinstance(tag, types.StringTypes):\\r\\n return Tag.objects.get(name=tag)\\r\\n elif isinstance(tag, (types.IntType, types.LongType)):\\r\\n return Tag.objects.get(id=tag)\\r\\n except Tag.DoesNotExist:\\r\\n pass\\r\\n\\r\\n return None\",\n \"def GetFromTag(cls, tag):\\n parent_key = cls._GetParentKeyFromTag(tag)\\n return cls.query(ancestor=parent_key).get()\",\n \"def __getitem__(self, tag):\\n return self.get(tag)\",\n \"def get_level(tag: str) -> int:\\n return TAG_LEVELS[tag]\",\n \"def get(self):\\n return self.tag.get()\",\n \"def baggage(self):\\n return SpanContext.EMPTY_BAGGAGE\",\n \"def buoyancy_factor(self, fac):\\n return fac\",\n \"async def __getBBL_async(self, account, projectedBillData) -> dict:\\n _LOGGER.info(\\\"Getting budget billing data\\\")\\n data = {}\\n\\n try:\\n async with async_timeout.timeout(TIMEOUT):\\n response = await self.session.get(\\n URL_BUDGET_BILLING_PREMISE_DETAILS.format(account=account)\\n )\\n if response.status == 200:\\n r = (await response.json())[\\\"data\\\"]\\n dataList = r[\\\"graphData\\\"]\\n\\n # startIndex = len(dataList) - 1\\n\\n billingCharge = 0\\n budgetBillDeferBalance = r[\\\"defAmt\\\"]\\n\\n projectedBill = projectedBillData[\\\"projected_bill\\\"]\\n asOfDays = projectedBillData[\\\"as_of_days\\\"]\\n\\n for det in dataList:\\n billingCharge += det[\\\"actuallBillAmt\\\"]\\n\\n calc1 = (projectedBill + billingCharge) / 12\\n calc2 = (1 / 12) * (budgetBillDeferBalance)\\n\\n projectedBudgetBill = round(calc1 + calc2, 2)\\n bbDailyAvg = round(projectedBudgetBill / 30, 2)\\n bbAsOfDateAmt = round(projectedBudgetBill / 30 * asOfDays, 2)\\n\\n data[\\\"budget_billing_daily_avg\\\"] = bbDailyAvg\\n data[\\\"budget_billing_bill_to_date\\\"] = bbAsOfDateAmt\\n\\n data[\\\"budget_billing_projected_bill\\\"] = float(projectedBudgetBill)\\n\\n async with async_timeout.timeout(TIMEOUT):\\n response = await self.session.get(\\n URL_BUDGET_BILLING_GRAPH.format(account=account)\\n )\\n if response.status == 200:\\n r = (await response.json())[\\\"data\\\"]\\n data[\\\"bill_to_date\\\"] = float(r[\\\"eleAmt\\\"])\\n data[\\\"defered_amount\\\"] = float(r[\\\"defAmt\\\"])\\n except Exception as e:\\n _LOGGER.error(e)\\n\\n return data\",\n \"def _get_tagged_value(self, key):\\n return self._tagged_values_dict[key]\",\n \"def _get_optuna_time_budget(self):\\n self._validate_optuna_time_budget()\\n\\n if self.optuna_time_budget is None:\\n if self._get_mode() == \\\"Optuna\\\":\\n return 3600\\n return None\\n else:\\n if self._get_mode() != \\\"Optuna\\\":\\n # use only for mode Optuna\\n return None\\n return deepcopy(self.optuna_time_budget)\",\n \"def highest_bid(self):\\n (price_eur, volume, _) = self._order_book['bids'][0]\\n price_usd = Decimal(price_eur) * self._eurusd_rate\\n return {\\n 'price': Decimal(price_usd),\\n 'volume': Decimal(volume),\\n }\",\n \"def amount_bet(self, user):\\n try:\\n return Bet.objects.get(group_match = self, user=user).amount\\n except Bet.DoesNotExist:\\n return Decimal(0)\",\n \"def tag_word(self, w): \\n if self.unknown(w):\\n return self.default_tag\\n else:\\n return max(self.word_tags[w], key=self.word_tags[w].get)\",\n \"def get_sample_badge(self):\\n\\n badgr = self.get_badgr_setup()\\n with vcr.use_cassette('tests/vcr_cassettes/badge_retrieval.yaml'):\\n return badgr.badges[0]\",\n \"async def get_trending_tags(start_tag: str = '', limit: int = 250):\\n assert start_tag == '', 'tags pagination not supported'\\n assert limit == 250, 'only returns exactly 250 tags'\\n sql = \\\"\\\"\\\"\\n SELECT category,\\n COUNT(*) AS total_posts,\\n SUM(CASE WHEN depth = 0 THEN 1 ELSE 0 END) AS top_posts,\\n SUM(payout) AS total_payouts\\n FROM hive_posts_cache\\n WHERE is_paidout = '0'\\n GROUP BY category\\n ORDER BY SUM(payout) DESC\\n LIMIT 250\\n \\\"\\\"\\\"\\n out = []\\n for row in query_all(sql):\\n out.append({\\n 'comments': row['total_posts'] - row['top_posts'],\\n 'name': row['category'],\\n 'top_posts': row['top_posts'],\\n 'total_payouts': \\\"%.3f SBD\\\" % row['total_payouts']})\\n\\n return out\",\n \"def read_tag(\\n *,\\n db: Session = Depends(get_db),\\n id: int,\\n current_user: DBUser = Depends(get_current_active_user),\\n):\\n tag = crud.tag.get(db_session=db, id=id)\\n if not tag:\\n raise HTTPException(status_code=404, detail=\\\"Tag not found\\\")\\n if not crud.user.is_superuser(current_user) and (tag.owner_id != current_user.id):\\n raise HTTPException(status_code=400, detail=\\\"Not enough permissions\\\")\\n return tag\",\n \"def _get_tag(self, tag):\\n return self.prefix + tag\",\n \"def get_tag(self):\\n return self.tag\",\n \"def _bidding_function(self):\\n return self._bid_value\",\n \"def getValue(tree, tag):\\n try:\\n return tree.find(tag).text\\n except AttributeError:\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7083501","0.65791714","0.6482024","0.63894933","0.6077988","0.58800274","0.5838075","0.58222085","0.5746922","0.5691997","0.5674798","0.56654537","0.5650313","0.56176656","0.55753535","0.55744225","0.5489822","0.53618115","0.53394234","0.5320373","0.5319216","0.5281898","0.5281898","0.52783805","0.525624","0.525624","0.52536136","0.52148205","0.52018553","0.51856655","0.51593196","0.5155952","0.5146735","0.50923836","0.5068276","0.5061704","0.50573903","0.5056302","0.50369275","0.5012894","0.5007564","0.4993471","0.49906042","0.49876553","0.49860927","0.4981378","0.49761862","0.49668533","0.49625382","0.49556476","0.4938783","0.49383867","0.49250737","0.49233362","0.4914355","0.4899568","0.48967704","0.48902446","0.48761973","0.48604438","0.48539945","0.48424512","0.4827478","0.4799502","0.47966814","0.47962874","0.47924364","0.47872296","0.47756228","0.47729728","0.47708967","0.47701553","0.47692326","0.47633246","0.47606635","0.47566316","0.47558376","0.4755353","0.47521555","0.47404894","0.47297916","0.47179142","0.47121462","0.46989596","0.46969375","0.46842498","0.46841684","0.46835256","0.46620205","0.4653836","0.46507618","0.46467543","0.46451503","0.46441254","0.46418813","0.46282077","0.4619844","0.4614034","0.46109062","0.46090186"],"string":"[\n \"0.7083501\",\n \"0.65791714\",\n \"0.6482024\",\n \"0.63894933\",\n \"0.6077988\",\n \"0.58800274\",\n \"0.5838075\",\n \"0.58222085\",\n \"0.5746922\",\n \"0.5691997\",\n \"0.5674798\",\n \"0.56654537\",\n \"0.5650313\",\n \"0.56176656\",\n \"0.55753535\",\n \"0.55744225\",\n \"0.5489822\",\n \"0.53618115\",\n \"0.53394234\",\n \"0.5320373\",\n \"0.5319216\",\n \"0.5281898\",\n \"0.5281898\",\n \"0.52783805\",\n \"0.525624\",\n \"0.525624\",\n \"0.52536136\",\n \"0.52148205\",\n \"0.52018553\",\n \"0.51856655\",\n \"0.51593196\",\n \"0.5155952\",\n \"0.5146735\",\n \"0.50923836\",\n \"0.5068276\",\n \"0.5061704\",\n \"0.50573903\",\n \"0.5056302\",\n \"0.50369275\",\n \"0.5012894\",\n \"0.5007564\",\n \"0.4993471\",\n \"0.49906042\",\n \"0.49876553\",\n \"0.49860927\",\n \"0.4981378\",\n \"0.49761862\",\n \"0.49668533\",\n \"0.49625382\",\n \"0.49556476\",\n \"0.4938783\",\n \"0.49383867\",\n \"0.49250737\",\n \"0.49233362\",\n \"0.4914355\",\n \"0.4899568\",\n \"0.48967704\",\n \"0.48902446\",\n \"0.48761973\",\n \"0.48604438\",\n \"0.48539945\",\n \"0.48424512\",\n \"0.4827478\",\n \"0.4799502\",\n \"0.47966814\",\n \"0.47962874\",\n \"0.47924364\",\n \"0.47872296\",\n \"0.47756228\",\n \"0.47729728\",\n \"0.47708967\",\n \"0.47701553\",\n \"0.47692326\",\n \"0.47633246\",\n \"0.47606635\",\n \"0.47566316\",\n \"0.47558376\",\n \"0.4755353\",\n \"0.47521555\",\n \"0.47404894\",\n \"0.47297916\",\n \"0.47179142\",\n \"0.47121462\",\n \"0.46989596\",\n \"0.46969375\",\n \"0.46842498\",\n \"0.46841684\",\n \"0.46835256\",\n \"0.46620205\",\n \"0.4653836\",\n \"0.46507618\",\n \"0.46467543\",\n \"0.46451503\",\n \"0.46441254\",\n \"0.46418813\",\n \"0.46282077\",\n \"0.4619844\",\n \"0.4614034\",\n \"0.46109062\",\n \"0.46090186\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.719083"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92896,"cells":{"query":{"kind":"string","value":"Classification model that does the mapping of"},"document":{"kind":"string","value":"def __init__(self,\n names,\n data,\n embedding_fns,\n encoder_fns_1,\n encoder_fns_2,\n logits_fns,\n evaluation_fns,\n # MTL\n mixing_ratios,\n L2_coefficient=None,\n is_distill=False,\n distill_coefficient_loc=None,\n distill_coefficient_scale=None,\n distill_temperature=1.0,\n # optimization\n optimizer=\"Adam\",\n learning_rate=0.001,\n gradient_clipping_norm=2.0,\n # misc\n graph=None,\n logdir=None,\n main_model_index=0,\n debug_mode=False):\n \n super(MultitaskBaseModel, self).__init__(\n logdir=logdir, graph=graph,\n saver_max_to_keep=MAX_CHECKPOINTS_TO_KEEP)\n\n num_models = len(names)\n _check_list_compatability(data, num_models)\n _check_fn_list_compatability(embedding_fns, num_models, True)\n _check_fn_list_compatability(encoder_fns_1, num_models, True)\n _check_fn_list_compatability(encoder_fns_2, num_models, True)\n _check_fn_list_compatability(logits_fns, num_models, False)\n _check_fn_list_compatability(evaluation_fns, num_models, False)\n\n # check mixing ratios and MTL\n if len(names) == 1:\n raise ValueError(\"Not supported\")\n _mr_compatible(mixing_ratios, num_models, print_out=True)\n if main_model_index != 0:\n raise ValueError(\"`main_model_index` must be set to `0`\")\n\n self._names = names\n self._data = data\n self._embedding_fns = embedding_fns\n self._encoder_fns_1 = encoder_fns_1\n self._encoder_fns_2 = encoder_fns_2\n self._logits_fns = logits_fns\n self._evaluation_fns = evaluation_fns\n\n # MTL\n self._mixing_ratios = mixing_ratios\n self._L2_coefficient = L2_coefficient\n self._is_disill = is_distill\n self._distill_temperature = distill_temperature\n self._distill_coefficient_loc = distill_coefficient_loc\n self._distill_coefficient_scale = distill_coefficient_scale\n\n self._optimizer = optimizer\n self._learning_rate = learning_rate\n self._gradient_clipping_norm = gradient_clipping_norm\n\n self._main_model_index = main_model_index\n self._debug = collections.defaultdict(list)\n self._debug_mode = debug_mode"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def predict_category(self):\n pass","def classify(self, data):\n \"*** YOUR CODE HERE ***\"\n return self.sklearn_classifier.predict(data)","def model(self):\n filePath = self.config['data_path']['train_data']\n data = self.loadCSV(filePath)\n cleandata = self.preprocess(data)\n X, y = self.dataSplit(cleandata)\n X = self.CountVect(X, self.config['transform_path']['transform_model_path'])\n X_train, X_test, y_train, y_test = self.TrainTestSplit(X, y)\n self.MultinomialNB(X_train, X_test, y_train, y_test, self.config['nlp_path']['model_path'])","def classify(self, data):\n abstract","def predict_only(self):","def trainModel( self, featureTrain, classTrain):","def predict(self, instances):\r\n raise NotImplementedError","def classify(self, data):\n \"*** YOUR CODE HERE ***\"\n return self.sklearn_svm.predict(data)","def classifier(model):\n \n model.classifier = nn.Sequential(OrderedDict([\n ('fc1', nn.Linear(model.classifier[0].in_features, 4096)),\n ('fc2', nn.Linear(4096, 102)),\n ('relu', nn.ReLU()),\n ('output', nn.LogSoftmax(dim=1))\n ]))\n return model","def apply_classifier(self):\n for detected_object in self.detected_objects:\n detected_object.predict_class(self.original_image)","def classification(self,a_train,a_test,c_train,c_test,classifier):\n le =LabelEncoder()\n le.fit(c_train)\n c_train = le.transform(c_train)\n c_test = le.transform(c_test)\n if classifier==\"GNB\": #Gaussian Naive Bayes\n gnb = GaussianNB()\n gnb.fit(a_train, c_train)\n c_pred = gnb.predict(a_test)\n elif classifier==\"DT\": #Decision Tree\n dt=DecisionTreeClassifier()\n dt.fit(a_train, c_train)\n c_pred = dt.predict(a_test)\n elif classifier==\"KNN\": #K-Next-Neighbors\n kn=KNeighborsClassifier(n_neighbors=5)\n kn.fit(a_train, c_train)\n c_pred = kn.predict(a_test)\n elif classifier==\"RF\": #Random Forest\n rf=RandomForestClassifier()\n rf.fit(a_train, c_train)\n c_pred = rf.predict(a_test)\n elif classifier==\"SVC\": # Support Vector Classifier\n \"\"\"\n SVC needs normalisation of Feature Values to scale of [-1,1] or [0,1] depending on sign of them\n \"\"\"\n if a_train.min()<0:\n mms = MinMaxScaler(feature_range=(-1,1))\n else:\n mms = MinMaxScaler()\n mms.fit(a_train)\n a_train = mms.transform(a_train)\n a_test = mms.transform(a_test)\n svc=SVC(cache_size=2000,C=1, probability=True,kernel='rbf')\n svc.fit(a_train,c_train)\n #c_pred = svc.predict(a_test) did not work, that's why it is predicted manual\n new_prob = svc.predict_proba(a_test)\n samples=new_prob.shape[0]\n c_pred= np.array\n for k in range(samples):\n c_pred=np.append(c_pred,new_prob[k].argmax())\n c_pred = c_pred[1:samples+1]\n elif classifier==\"DC\": #Dummy Classifier\n dc=DummyClassifier(strategy=\"uniform\")\n dc.fit(a_train, c_train)\n c_pred = dc.predict(a_test)\n elif classifier==\"GMM\": #Gaussian Mixture Modell\n #number of existing classes get passed to the GMM (n_classes)\n n_classes_train = len(np.unique(c_train))\n n_classes_test = len(np.unique(c_test))\n if n_classes_train>n_classes_test:\n n_classes = n_classes_train\n else:\n n_classes = n_classes_test\n #init_params='', because initial values get calculated manual\n gmm = GMM(n_components=n_classes,init_params='')\n #array of feature values of class i get extracted for further process\n gmm.means_=np.array([a_train[c_train==i,:].mean(axis=0) for i in xrange(n_classes)])\n gmm.weights_=np.array([a_train[c_train==i,:].shape[0]/float(c_train.shape[0]) for i in xrange(n_classes)])\n \n gmm_covars = np.zeros((a_train.shape[1]))\n for i in xrange(n_classes):\n valuesOfClassi = a_train[c_train==i,:]\n valuesOfClassi = np.asarray(valuesOfClassi).T\n matrixOfCov = np.cov(valuesOfClassi)+gmm.min_covar*np.eye(valuesOfClassi.shape[0])\n variance = np.array([matrixOfCov[j,j] for j in xrange(matrixOfCov.shape[0])])\n gmm_covars=np.vstack((gmm_covars,variance))\n gmm_covars=gmm_covars[1:,:] #deletes initial row with zeros\n \n gmm.covars_=gmm_covars\n c_pred = gmm.predict(a_test)\n \n c_pred=le.inverse_transform(c_pred)\n return c_pred","def calculate_MAP(self):\n testing_images = open('./digitdata/testimages', 'r')\n with testing_images as ti:\n data = list(csv.reader(ti))\n data = [i for i in data if i]\n count = 0\n #loop through all the test images\n for j in range(0,1000):\n classification_dict = {0:0,1:0,2:0,3:0,4:0,5:0,6:0,7:0,8:0,9:0} \n for l in range(0,28):\n coord = count + l\n for w in range(0,28):\n if data[coord][0][w] == \"+\":\n #iterate through each class. z is the class [0-9]\n for z in range(0,10):\n classification_dict[z] += math.log(self.class_probabilities[z][l][w][0]) \n elif data[coord][0][w] == \"#\":\n for z in range(0,10):\n classification_dict[z] += math.log(self.class_probabilities[z][l][w][1])\n elif data[coord][0][w] == \" \":\n for z in range(0,10):\n classification_dict[z] += math.log(self.class_probabilities[z][l][w][2])\n count += 28\n self.solutions.append(max(classification_dict, key=classification_dict.get))","def predict_labels(model):\n test_datagen = ImageDataGenerator(featurewise_center=True,\n featurewise_std_normalization=True\n #rescale=1. / 255,\n #samplewise_center=True,\n #samplewise_std_normalization=True\n )\n test_datagen.fit(test_data)\n # datagen.fit(val_data)\n # create generator for train data\n test_generator = test_datagen.flow(\n test_data,\n batch_size=batch_size,\n shuffle=False)\n pred_prob=model.predict_generator(test_generator,test_data.shape[0])\n pred_prob=pred_prob[:,0]\n def pre_class(x):\n \tif x<0.5:\n return 0\n else:\n return 1\n #def true_label(id):\n #\tif 'f0' in id:\n #\t return 0\n # elif 'f1' in id: \n # return 1\n #\telse:\n #\t pass\n #pred_true=map(true_label,test_id)\n #pred_true=np.array(pred_true)\n #print roc_auc_score(val_target, pred_prob)\n #prediction=map(pre_class,pred_prob)\n #print confusion_matrix(val_target,prediction)\n with open(\"prediction.csv\", \"w\") as f: \n\tp_writer = csv.writer(f, delimiter=',', lineterminator='\\n')\n for id,label in zip(test_id,pred_prob):\n\t p_writer.writerow([id, label])\n\t\n #base_path = \"PZ/test/test/\"\n\n #with open(\"prediction.csv\", \"w\") as f:\n # p_writer = csv.writer(f, delimiter=',', lineterminator='\\n')\n # for _, _, imgs in os.walk(base_path):\n # for im in imgs:\n # pic_id = im.split(\".\")[0]\n #img = cv2.imread(base_path+im)\n #img = cv2.resize(img, (img_width, img_height), cv2.INTER_LINEAR)\n #img = img.transpose((2,0,1))\n #img = np.expand_dims(img,axis=0)\n #img = load_img(base_path + im)\n #img = imresize(img, size=(img_height, img_width))\n #test_x = img_to_array(img).reshape(3, img_height, img_width)\n #test_x = test_x.reshape((1,) + test_x.shape)\n #test_datagen.fit(img)\n #test_generator = test_datagen.flow(img,\n # batch_size=1,\n # shuffle=False)\n #prediction = model.predict_generator(test_generator, 1)\n #p_writer.writerow([pic_id, prediction])","def classify(img, c_model):\n #global class_graph\n\n #img = load_img(im_path,target_size=(input_height, input_width))\n #img = img_to_array(img)\n im_size = 128\n # resize \n\n img = cv2.resize(img, (im_size,im_size))\n\n img = img.astype(\"float\") / 255.0\n img = np.expand_dims(img, axis=0)\n with class_graph.as_default():\n predictions = c_model.predict(img)[0]\n\n return predictions","def build_classify(self, num_classes: int = 10) -> KM.Model:\n input_tensor = KL.Input(shape=(32, 32, 3))\n # if self.train_mode == \"classifier\":\n # # Use the pretrained encoder for classifier only training\n # self.encoder_model = KM.load_model(\"ae_model/ae_model.h5\").get_layer(\n # \"encoder\"\n # )\n if self.train_mode != \"both\":\n # build the encoder model\n self.encoder_model = self.encoder(\n features=self.encoder_features, name=\"encoder\"\n )\n encoded_features = self.encoder_model(input_tensor)\n contrastive_features = KL.Lambda(lambda x: K.mean(x, [1, 2]), name=\"contrast\")(\n encoded_features[-1]\n )\n # Calculate class probs from multiple latent representations\n probs = classifier_block(encoded_features, num_classes=num_classes)\n\n return KM.Model(\n inputs=input_tensor,\n outputs=[probs, contrastive_features],\n name=\"classifier\",\n )","def predict(model, images):\n return model.predict_classes(images)","def predict_proba(self):\n ...","def predict_from(self, inputs, to_layers):","def predict(self):\n raise NotImplementedError","def keras_inference(input_image, model_type, labels, return_image):\r\n # Loading the image\r\n img = image.load_img(input_image, target_size=(50, 50))\r\n # Converting the image to numpy array\r\n x = image.img_to_array(img) \r\n # convert 3D tensor to 4D tensor with shape (1, 512, 512, 3)\r\n x = np.expand_dims(x, axis=0)\r\n\r\n image_to_predict = x.astype('float32')/255\r\n \r\n # image_to_plot = path_to_tensor(input_image)\r\n\r\n # model's weight for localization\r\n model = load_model(model_type)\r\n prediction = model.predict(image_to_predict)\r\n # print(\"X shape : \", x.shape)\r\n # prediction_final = \"Not_cancer: \" + str(np.round(prediction[0][0]*100, decimals = 2)) + \"%\" + \\\r\n # \" | Cancer: \" + str(np.round(prediction[0][1]*100, decimals = 2)) + \"%\"\r\n print(\"Prediction : \",prediction[0])\r\n print(\"Argmax : \", np.argmax(prediction[0]))\r\n confidence = np.max(prediction[0]) * 100\r\n classify = labeled_class[int(np.argmax(prediction[0]))]\r\n print(\"classify :\", classify)\r\n output = {\r\n \"label\": \"{}\".format(task),\r\n \"type\" : \"classification\",\r\n \"output\" : {\r\n \"confidence\" : \"{0:.2f}\".format(round(confidence,2)),\r\n \"results\" : classify,\r\n \"image\" : return_image\r\n }\r\n } \r\n \r\n return output","def classify(im, model):\n\n classe = model.predict(im)\n classe = classe.argmax(axis=-1) # taking index of the maximum %\n return classe[0]","def predict(self, X):","def predict(self, X):","def __init__(self, num_classed= 100):\n self.model = Sequential()\n self.num_classed = num_classed\n self.categories = ['apples', 'aquarium fish', 'baby', 'bear', 'beaver',\n 'bed', 'bee', 'beetle', 'bicycle', 'bottles',\n 'bowls','boy', 'bridge', 'bus', 'butterfly', \n 'camel', 'cans', 'castle', 'caterpillar', 'cattle', \n 'chair', 'chimpanzee', 'clock', 'cloud', 'cockroach', \n 'couch', 'crab', 'crocodile', 'cups', \n 'dinosaur', 'dolphin', 'elephant', 'flatfish', 'forest', \n 'fox', 'girl', 'hamster', 'house', 'kangaroo', 'computer keyboard', 'lamp', \n 'lawn-mower', 'leopard', 'lion', 'lizard', 'lobster', \n 'man', 'maple', 'motorcycle', 'mountain', 'mouse', \n 'mushrooms', 'oak', 'oranges', 'orchids', 'otter', \n 'palm', 'pears', 'pickup truck', 'pine', 'plain', \n 'plates', 'poppies', 'porcupine', 'possum', 'rabbit', \n 'raccoon', 'ray', 'road', 'rocket', 'roses', 'sea', \n 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', \n 'snail', 'snake', 'spider', 'squirrel', 'streetcar', \n 'sunflowers', 'sweet peppers', 'table', 'tank', 'telephone', \n 'television', 'tiger', 'tractor', 'train', 'trout', \n 'tulips', 'turtle', 'wardrobe', 'whale', 'willow', \n 'wolf', 'woman', 'worm']","def predict_car():\n img = open_image(request.files['image'])\n pred_class, pred_idx, outputs = learn.predict(img)\n return str(pred_class)","def predict(self, testData=[]):\n result = []\n for classValue in self._classAttrs:\n #print(f'Computing Label: {classValue}, {self._classLabelMap[classValue]}')\n result.append(self._computeCondProb(testData, classValue))\n return self._classLabelMap[result.index(max(result))]","def name(self):\n return 'Predict model (classification map)'","def predict_label(self, src): # real signature unknown; restored from __doc__\n pass","def model_predict(img_path):\n img = open_image(img_path)\n pred_class, pred_idx, outputs = learn.predict(img)\n print(pred_class)\n return pred_class","def default_classification_model(num_classes, num_anchors, pyramid_feature_size=256, prior_probability=0.01, classification_feature_size=256,name='classification_submodel'):\n options = {\n 'kernel_size' : 3,\n 'strides' : 1,\n 'padding' : 'same',\n }\n\n if keras.backend.image_data_format() == 'channels_first':\n inputs = keras.layers.Input(shape=(pyramid_feature_size, None, None))\n else:\n inputs = keras.layers.Input(shape=(None, None, pyramid_feature_size))\n outputs = inputs\n for i in range(4):\n outputs = keras.layers.Conv2D(\n filters=classification_feature_size,\n activation='relu',\n name='pyramid_classification_{}'.format(i),\n kernel_initializer=keras.initializers.normal(mean=0.0, stddev=0.01, seed=None),\n bias_initializer='zeros',\n **options\n )(outputs)\n\n outputs = keras.layers.Conv2D(\n filters=num_classes * num_anchors,\n kernel_initializer=keras.initializers.normal(mean=0.0, stddev=0.01, seed=None),\n bias_initializer=initializers.PriorProbability(probability=prior_probability),\n name='pyramid_classification',\n **options\n )(outputs)\n\n # reshape output and apply sigmoid\n if keras.backend.image_data_format() == 'channels_first':\n outputs = keras.layers.Permute((2, 3, 1), name='pyramid_classification_permute')(outputs)\n outputs = keras.layers.Reshape((-1, num_classes), name='pyramid_classification_reshape')(outputs)\n outputs = keras.layers.Activation('sigmoid', name='pyramid_classification_sigmoid')(outputs)\n\n return keras.models.Model(inputs=inputs, outputs=outputs, name=name)","def predict(self, x):\n # *** START CODE HERE ***\n return self.clf.predict_classes(x.reshape(x.shape[0], 28, 28, 1))\n # *** END CODE HERE ***","def image_model_predict(input_ms_image_filename, input_pan_image_filename, pan_img_height_size, pan_img_width_size, \r\n fitted_model, write, output_filename):\r\n \r\n with rasterio.open(input_ms_image_filename) as f:\r\n metadata = f.profile\r\n ms_img = np.transpose(f.read(tuple(np.arange(metadata['count']) + 1)), [1, 2, 0])\r\n \r\n with rasterio.open(input_pan_image_filename) as g:\r\n metadata_pan = g.profile\r\n pan_img = g.read(1)\r\n \r\n pan_img = np.expand_dims(pan_img, axis = 2)\r\n \r\n ms_to_pan_ratio = metadata['transform'][0] / metadata_pan['transform'][0]\r\n \r\n class_layer = np.zeros((pan_img.shape[0], pan_img.shape[1]))\r\n \r\n img_pan_holder = []\r\n img_ms_holder = []\r\n \r\n for i in range(0, pan_img.shape[0] - pan_img_height_size, int(ms_to_pan_ratio)):\r\n for j in range(0, pan_img.shape[1] - pan_img_width_size, int(ms_to_pan_ratio)):\r\n img_pan_iter = pan_img[i : i + pan_img_height_size, j : j + pan_img_width_size, 0]\r\n img_pan_holder.append(img_pan_iter)\r\n \r\n for i in range(0, int(ms_img.shape[0] - (pan_img_height_size / ms_to_pan_ratio)), int(ms_to_pan_ratio)):\r\n for j in range(0, int(pan_img.shape[1] - (pan_img_width_size / ms_to_pan_ratio)), int(ms_to_pan_ratio)):\r\n img_ms_iter = ms_img[i : int(i + (pan_img_height_size / ms_to_pan_ratio)), \r\n j : int(j + (pan_img_width_size / ms_to_pan_ratio)), \r\n 0 : metadata['count']]\r\n img_ms_holder.append(img_ms_iter)\r\n \r\n img_pan_array = np.concatenate(img_pan_holder, axis = 0)\r\n img_ms_array = np.concatenate(img_ms_holder, axis = 0)\r\n \r\n pred_array = np.argmax(fitted_model.predict([img_ms_array, img_pan_array]), axis = 1)\r\n \r\n n = 0 \r\n for i in range(int(pan_img_height_size / 2), pan_img.shape[0] - int(pan_img_height_size / 2), int(ms_to_pan_ratio)):\r\n for j in range(int(pan_img_width_size / 2), pan_img.shape[1] - int(pan_img_width_size / 2), int(ms_to_pan_ratio)):\r\n class_layer[i, j] = pred_array[n]\r\n n += 1\r\n \r\n if write:\r\n with rasterio.open(output_filename, 'w', **metadata_pan) as dst:\r\n dst.write(class_layer)\r\n \r\n return class_layer","def _classifier(self, classes):\n # Initialize key variables\n pseudo = np.linalg.pinv(self.data)\n result = np.dot(pseudo, classes)\n return result","def classify(text):\n # TODO Wonder if there's a better way of doing this so the model persists across fucn calls. Will see once I get\n # Heroku running\n\n sentences = sent_tokenize(text)\n clean_sentences = list(map(clean_text, sentences))\n word_tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')\n # tokenize\n _input = word_tokenizer(clean_sentences, padding=True, return_tensors='pt', return_attention_mask=True, return_length=True)\n\n # pass tokenized text thru model\n model = LSTM(dr=.3)\n state_dict = torch.load(os.path.join('model', 'model.pt'), map_location=torch.device('cpu'))\n model.load_state_dict(state_dict['model_state_dict'])\n\n model.eval()\n with torch.no_grad():\n model_output = model(_input['input_ids'], _input['length'], _input['attention_mask'])\n\n # We start with: A list of command names, a list of sentences, a matrix with\n # each row corresponding to a sentence and each column corresponding to a label's probability of being\n # represented in the sentence The list of command names is parallel to the columns of the matrix\n\n # We want to end with a nested dict with sentences as keys and dicts of label : probability pairs as values\n labels = model_output.topk(3)\n\n label_indices = labels[0].tolist()\n probabilities = labels[1].tolist()\n\n with open(os.path.join('resources', 'label_names.txt')) as f:\n command_names = f.read().splitlines()\n\n output = dict()\n for i, row in enumerate(probabilities): # TODO vectorize this if possible\n sent = sentences[i]\n output[sent] = {command_names[idx]: label_indices[i][j] for j, idx in enumerate(row)}\n\n return output","def get_classification(self, image):\n # Image pre-processing pipeline\n img = cv2.resize(image, None, fx=0.5, fy=0.5)\n img = img.astype(np.float32)\n img = keras.applications.vgg16.preprocess_input(img)\n # Execute prediction\n probs = self.model.predict(np.array([img]), batch_size=1, verbose=1)[0]\n # get label with max probability\n g_x = np.argmax(probs)\n\n # reject if model is not confident\n if probs[g_x] < CONFIDENCE_THRESHOLD:\n return TrafficLight.UNKNOWN\n\n label = self.predictionary[g_x]\n rospy.loginfo(\"label: %d, conf: %f, %f, %f, %f\", g_x, probs[0], probs[1], probs[2], probs[3])\n return label","def map_objects_classifier_evaluation(self):\n df = self.results[(self.results['iou'] > 0.7)]\n y_true = df['true_class']\n y_pred = df['pred_class']\n print(classification_report(y_true, y_pred))\n matrix = confusion_matrix(y_true, y_pred)\n matrix = matrix.astype('float') / matrix.sum(axis=1)[:, np.newaxis]\n import seaborn as sns\n\n plt.figure(figsize=(10, 7))\n sns.set(font_scale=2.4)\n sns.heatmap(matrix, annot=True, annot_kws={'size': 25},\n cmap=plt.cm.Reds)\n # Add labels to the plot\n class_names = ['background', 'building', 'water']\n tick_marks = np.arange(len(class_names))\n tick_marks2 = tick_marks + 0.28\n tick_marks2[0] = tick_marks2[0] - 0.2\n tick_marks = tick_marks + 0.5\n plt.xticks(tick_marks, class_names, rotation=0)\n plt.yticks(tick_marks2, class_names, rotation=90)\n plt.xlabel('Predicted label', labelpad=13)\n plt.ylabel('True label', labelpad=13)\n plt.show()","def predict(x):\n\n scores = np.zeros(shape=(len(classes_def), len(x)))\n\n for idx, c in enumerate(classes_def):\n\n model_name = model_name_pre + c + model_name_post\n print('Loading model', model_name, 'and making predictions..')\n model = load_model(model_name)\n\n scores[idx] = model.predict(x).reshape(len(x))\n\n out = []\n\n for predictions in scores.T:\n # Majority vote\n max_idx_for_sample = 0\n max_prob_for_sample = 0\n for i, prediction in enumerate(predictions):\n if prediction > max_prob_for_sample:\n max_idx_for_sample = i\n\n out.append(classes_def[max_idx_for_sample])\n\n return out","def build_model_mobilenet(num_classes):","def predict(self, x):\n\n x_ = self.scaler_s1.transform(x)\n s1_df = self.basemodel.decision_function(x_)\n s2_df = self.confidencemodel.decision_function(x_)\n\n '''\n hc_df = np.max(dfs, 1)\n\n # high confidence vector\n hc_df[(dfs > 0).sum(1) > 1] = np.min(dfs, 1)[(dfs > 0).sum(1) > 1]\n '''\n\n hc_df = -np.ones((s2_df.shape[0], 1))\n y_pred1 = self.basemodel.predict(x_)\n\n unique_labels = range(s2_df.shape[1])\n for label in unique_labels:\n hc_df[y_pred1 == label, :] = s2_df[y_pred1 == label, label][:, np.newaxis]\n\n '''\n # TODO modif this to be compatible with multilabel classifiers (currently only binary classifier)\n xor_mask = np.logical_xor(s2_df[:, 0] > 0, s2_df[:, 1] > 0)\n\n if xor_mask.sum() > 0:\n hc_df[xor_mask, 0] = np.max(s2_df, 1)[xor_mask]\n hc_df[~xor_mask, 0] = -np.abs(np.max(s2_df, 1)[~xor_mask])\n #hc_labels = np.greater(s2_df[:, 1], s2_df[:, 0]).astype(int)\n '''\n\n hit_proba_estimate = self.hitproba.predict(x_)\n joint_hc = self.joint_class_hc.predict(x_)\n\n data_array = []\n dict_array = []\n if len(joint_hc.shape):\n\n dict_array = {'s1_df': s1_df[:, np.newaxis],\n 'hcdf': hc_df,\n 's2_df': s2_df,\n 'hitproba': hit_proba_estimate[:, np.newaxis],\n 'hcjoint': joint_hc[:, np.newaxis],\n 's1_hat': self.ohe.transform((s1_df[:, np.newaxis]>0).astype(int)),\n 's2_hat': ((self.ohe.transform((s1_df.reshape(-1, 1)>0).astype(int))>0) & (s2_df>0)).astype(int),\n }\n data_array = np.hstack(\n [s1_df[:, np.newaxis], hc_df, s2_df, hit_proba_estimate[:, np.newaxis], joint_hc[:, np.newaxis]])\n else:\n # multiclass\n data_array = np.hstack([s1_df, hc_df, s2_df, hit_proba_estimate, joint_hc])\n dict_array = {'s1_df': s1_df,\n 'hc_df': hc_df,\n 's2_df': s2_df,\n 'hitproba': hit_proba_estimate,\n 'hcjoint': joint_hc,\n 's1_hat': self.ohe.transform((s1_df > 0).astype(int)),\n 's2_hat': ((self.ohe.transform((s1_df > 0).astype(int)) > 0) & (s2_df > 0)).astype(int)\n }\n\n return data_array, dict_array","def _classification(text_path_list, id_list, label_list):\n textnum = len(text_path_list)\n batched_num = ((textnum - 1) // classify.BATCH_SIZE + 1) * classify.BATCH_SIZE\n for i in range(batched_num - textnum):\n text_path_list.append(text_path_list[0])\n id_list.append(id_list[0])\n annotations = classify_obj.inference(text_path_list, id_list, label_list) #\n return annotations[0:textnum]","def get_classification(self, image):\n #TODO implement light color prediction\n max_idx = 4\n with self.detection_graph.as_default():\n with tf.Session(graph=self.detection_graph) as sess:\n # Definite input and output Tensors for detection_graph\n image_tensor = self.detection_graph.get_tensor_by_name('image_tensor:0')\n \n # Each box represents a part of the image where a particular object was detected.\n detection_boxes = self.detection_graph.get_tensor_by_name('detection_boxes:0')\n \n # Each score represent how level of confidence for each of the objects.\n # Score is shown on the result image, together with the class label.\n detection_scores = self.detection_graph.get_tensor_by_name('detection_scores:0')\n detection_classes = self.detection_graph.get_tensor_by_name('detection_classes:0')\n num_detections = self.detection_graph.get_tensor_by_name('num_detections:0')\n # Expand dimensions since the model expects images to have shape: [1, None, None, 3]\n image_np_expanded = np.expand_dims(image, axis=0)\n # Actual detection.\n (boxes, scores, classes, num) = sess.run(\n [detection_boxes, detection_scores, detection_classes, num_detections],\n feed_dict={image_tensor: image_np_expanded})\n\n boxes = np.squeeze(boxes)\n scores = np.squeeze(scores)\n classes = np.squeeze(classes).astype(np.int32)\n min_score_thresh = .50\n # find majority light state\n counter = [0, 0, 0, 0, 0]\n for i in range(boxes.shape[0]):\n if scores is None or scores[i] > min_score_thresh:\n counter[classes[i]] += 1\n for i in range(1, 5):\n if counter[i] > counter[max_idx]:\n max_idx = i\n return self.classmap[max_idx]","def classify_type(self):\n a = model_classifier(self.model_filepath)\n\n size = os.stat(self.model_filepath).st_size\n size = size / 1000000 # in MB\n print('Model size in MB: {}'.format(size))\n self.model_size = size\n\n if abs(size - a.resnet50_size) < abs(size - a.inceptionv3_size):\n if abs(size - a.resnet50_size) < abs(size - a.densenet121_size):\n print('RESNET 50 Model is analyzed')\n model_type = 1\n min_model_size_delta = a.resnet50_size - size\n else:\n print('DENSENET 121 Model is analyzed')\n model_type = 3\n min_model_size_delta = a.densenet121_size - size\n elif abs(size - a.inceptionv3_size) < abs(size - a.densenet121_size):\n print('INCEPTIONV3 Model is analyzed')\n model_type = 2\n min_model_size_delta = a.inceptionv3_size - size\n else:\n print('DENSENET Model is analyzed')\n model_type = 3\n min_model_size_delta = a.densenet121_size - size\n\n #print('classified the model as:\\t', a.switch_architecture(model_type))\n return model_type, min_model_size_delta","def classify_images():\n\n # Load the desired image\n img_path = 'dataset/colorize_images/n02085782_919.jpg'\n img = image.load_img(img_path, target_size=(299, 299))\n x = image.img_to_array(img)\n x = np.expand_dims(x, axis=0)\n x = preprocess_input(x)\n\n model = InceptionV3(weights=\"imagenet\")\n preds = model.predict(x)\n # decode the results into a list of tuples (class, description, probability)\n # (one such list for each sample in the batch)\n print('Predicted:', decode_predictions(preds, top=3)[0])","def classify_data(data, **kwargs):\r\n\r\n if 'mode' not in kwargs:\r\n kwargs['mode'] = 'log_reg'\r\n if 'threshold' not in kwargs:\r\n kwargs['threshold'] = 0.5\r\n if 'encode' not in kwargs:\r\n kwargs['encode'] = True\r\n if 'impute' not in kwargs:\r\n kwargs['impute'] = True\r\n data_copy = data.copy()\r\n if kwargs['impute']:\r\n data_copy = impute_missing_values_nominal(data)\r\n if kwargs['encode']:\r\n data_copy = encode_data_numerical(data)\r\n X_train, X_test, y_train, y_test = get_train_test(data_copy)\r\n model = train_model(X_train, y_train, kwargs['mode'])\r\n y_prob, y_pred = get_y_prob_pred(X_test, model, threshold=kwargs['threshold'])\r\n return X_train, X_test, y_train, y_test, model, y_prob, y_pred","def classification_score(self, x, y):\t\n\t\tpass","def discrete_model():\n return {\"x\": np.random.randint(10, size=100), \"y\": np.random.randint(10, size=100)}","def testModel( self, classTest, classPred):","def predict(self, xs, **kwargs):","def predict(self, datafile):","def model_predict(img_path, model_path):\n learn = load_model(model_path)\n img = open_image(img_path)\n # get the outputs from the model\n pred_class,pred_idx,outputs = learn.predict(img)\n # return the classification the model returns\n return pred_class","def do_classify(img,mask,n_sigmas,multichannel,intensity,edges,texture,sigma_min,sigma_max, downsample_value):\n if np.ndim(img)==3:\n features = extract_features(\n img,\n n_sigmas,\n multichannel=multichannel,\n intensity=intensity,\n edges=edges,\n texture=texture,\n sigma_min=sigma_min,\n sigma_max=sigma_max,\n )\n else:\n features = extract_features(\n np.dstack((img,img,img)),\n n_sigmas,\n multichannel=multichannel,\n intensity=intensity,\n edges=edges,\n texture=texture,\n sigma_min=sigma_min,\n sigma_max=sigma_max,\n )\n\n if mask is None:\n raise ValueError(\"If no classifier clf is passed, you must specify a mask.\")\n training_data = features[:, mask > 0].T\n\n training_data = memmap_feats(training_data)\n\n training_labels = mask[mask > 0].ravel()\n\n training_data = training_data[::downsample_value]\n training_labels = training_labels[::downsample_value]\n\n lim_samples = 100000 #200000\n\n if training_data.shape[0]>lim_samples:\n logging.info('Number of samples exceeds %i'% lim_samples)\n ind = np.round(np.linspace(0,training_data.shape[0]-1,lim_samples)).astype('int')\n training_data = training_data[ind,:]\n training_labels = training_labels[ind]\n logging.info('Samples have been subsampled')\n logging.info('Number of samples in training data: %i' % (training_data.shape[0]))\n print(training_data.shape)\n\n clf = make_pipeline(\n StandardScaler(),\n MLPClassifier(\n solver='adam', alpha=1, random_state=1, max_iter=2000,\n early_stopping=True, hidden_layer_sizes=[100, 60],\n ))\n logging.info(datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\"))\n logging.info('Initializing MLP model')\n\n clf.fit(training_data, training_labels)\n logging.info(datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\"))\n logging.info('MLP model fit to data')\n\n del training_data, training_labels\n\n logging.info('Create and memory map model input data')\n\n data = features[:, mask == 0].T\n logging.info('percent RAM usage: %f' % (psutil.virtual_memory()[2]))\n\n data = memmap_feats(data)\n logging.info('Memory mapped model input data')\n logging.info('percent RAM usage: %f' % (psutil.virtual_memory()[2]))\n\n labels = clf.predict(data)\n logging.info(datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\"))\n logging.info('Model used on data to estimate labels')\n\n if mask is None:\n result = labels.reshape(img.shape[:2])\n result2 = result.copy()\n else:\n result = np.copy(mask)#+1\n result[mask == 0] = labels\n del labels, mask\n result2 = result.copy()\n del result\n\n logging.info(datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\"))\n logging.info('RF feature extraction and model fitting complete')\n logging.info('percent RAM usage: %f' % (psutil.virtual_memory()[2]))\n\n return result2","def classify():\n excerpt = request.form.get('data')\n if excerpt is None or not excerpt:\n return jsonify(message='Bad request'), 400\n return jsonify(clf.predict(excerpt))","def predict(self, X):\n ...","def predict(self, X):\n ...","def predict(self, X):\n ...","def __existence_classification__(self,task_id,shape,aggregations):\n\n # aggregations = {}\n\n # raw_classifications and clustering_results have different hierarchy orderings- raw_classifications\n # is better for processing data and clustering_results is better for showing the end result\n # technically we only need to look at the data from clustering_results right now but its\n # hierarchy is really inefficient so use raw_classifications to help\n\n # each shape is done independently\n\n # set - so if multiple tools create the same shape - we only do that shape once\n # for shape in set(marking_tasks[task_id]):\n\n\n # pretentious name but basically whether each person who has seen a subject thinks it is a true\n # positive or not\n existence_classification = {\"param\":\"subject_id\"}\n\n global_cluster_index = 0\n # clusters_per_subject = []\n\n # look at the individual points in the cluster\n for subject_id in aggregations.keys():\n if subject_id == \"param\":\n continue\n\n # gold standard pts may not match up perfectly with the given clusters -\n # for example, we could have a gold penguin at 10,10 but the users' cluster\n # is centered at 10.1,9.8 - same penguin though\n # so as we go through the clusters, we need to see which ones match up more closely\n # with the gold standard\n # if subject_id in gold_standard_clustering[0]:\n # # closest cluster and distance\n # gold_to_cluster = {pt:(None,float(\"inf\")) for pt in gold_standard_clustering[0][subject_id]}\n # else:\n # gold_to_cluster = None\n\n\n # clusters_per_subject.append([])\n\n # # in either case probably an empty image\n # if subject_id not in clustering_results:\n # continue\n # if task_id not in clustering_results[subject_id]:\n # continue\n\n if (shape+ \" clusters\") not in aggregations[subject_id][task_id]:\n # if none of the relevant markings were made on this subject, skip it\n continue\n\n all_users = aggregations[subject_id][task_id][shape+ \" clusters\"][\"all_users\"]\n\n for local_cluster_index in aggregations[subject_id][task_id][shape+ \" clusters\"]:\n if local_cluster_index == \"all_users\":\n continue\n\n # extract the users who marked this cluster\n cluster = aggregations[subject_id][task_id][shape+ \" clusters\"][local_cluster_index]\n\n # todo - put this back when we support gold standard clustering\n # # is this user cluster close to any gold standard pt?\n # if subject_id in gold_standard_clustering[0]:\n # x,y = cluster[\"center\"]\n # for (gold_x,gold_y) in gold_to_cluster:\n # dist = math.sqrt((x-gold_x)**2+(y-gold_y)**2)\n # if dist < gold_to_cluster[(gold_x,gold_y)][1]:\n # gold_to_cluster[(gold_x,gold_y)] = local_cluster_index,dist\n #\n # # now repeat for negative gold standards\n # if subject_id in gold_standard_clustering[1]:\n # x,y = cluster[\"center\"]\n # min_dist = float(\"inf\")\n # closest= None\n # for x2,y2 in gold_standard_clustering[1][subject_id]:\n # dist = math.sqrt((x-x2)**2+(y-y2)**2)\n # if dist < min_dist:\n # min_dist = min(dist,min_dist)\n # closest = (x2,y2)\n # if min_dist == 0.:\n # assert (x,y) == closest\n # mapped_gold_standard[(subject_id,local_cluster_index)] = 0\n\n users = cluster[\"users\"]\n\n ballots = []\n\n # todo - the 15 hard coded value - might want to change that at some point\n for u in all_users:\n if u in users:\n ballots.append((u,1))\n else:\n ballots.append((u,0))\n\n existence_classification[(subject_id,local_cluster_index)] = ballots\n # clusters_per_subject[-1].append(global_cluster_index)\n # global_cluster_index += 1\n\n # # note we don't care about why a cluster corresponds to a gold standard pt - that is\n # # it could be really close to given gold standards - the point is that it is close\n # # to at least one of them\n # if gold_to_cluster is not None:\n # for (local_cluster_index,dist) in gold_to_cluster.values():\n # # arbitrary threshold but seems reasonable\n # if dist < 1:\n # mapped_gold_standard[(subject_id,local_cluster_index)] = 1\n\n existence_results = self.__task_aggregation__(existence_classification,task_id,{})#,mapped_gold_standard)\n assert isinstance(existence_results,dict)\n\n for subject_id,cluster_index in existence_results:\n new_results = existence_results[(subject_id,cluster_index)][task_id]\n # new_agg = {subject_id: {task_id: {shape + \" clusters\": {cluster_index: {\"existence\": new_results}}}}}\n # aggregations = self.__merge_results__(aggregations,new_agg)\n aggregations[subject_id][task_id][shape + \" clusters\"][cluster_index][\"existence\"] = new_results\n # if subject_id not in aggregations:\n # aggregations[subject_id] = {}\n # if task_id not in aggregations[subject_id]:\n # aggregations[subject_id][task_id] = {}\n # if (shape + \" clusters\") not in aggregations[subject_id][task_id]:\n # aggregations[subject_id][task_id][shape+ \" clusters\"] = {}\n # # this part is probably redundant\n # if cluster_index not in aggregations[subject_id][task_id][shape+ \" clusters\"]:\n # aggregations[subject_id][task_id][shape+ \" clusters\"][cluster_index] = {}\n #\n # aggregations[subject_id][task_id][shape+ \" clusters\"][cluster_index][\"existence\"] = existence_results[(subject_id,cluster_index)]\n\n return aggregations","def get_classification(self, image):\n # return TrafficLight.RED\n # TODO implement light color prediction\n # creating an image object \n img_np = np.array(image) \n\n # convert np array to tensor\n input_tensor = tf.convert_to_tensor(img_np)\n\n # The model expects a batch of images, so add an axis with `tf.newaxis`.\n input_tensor = input_tensor[tf.newaxis, ...]\n\n\n detections = self.loaded(input_tensor)\n\n num_detections = int(detections.pop('num_detections'))\n\n # detection_classes should be ints.\n detections_dict = {key: value[0, :num_detections].numpy() for key, value in detections.items()}\n\n\n # detection_classes should be ints.\n detections_dict['detection_classes'] = detections_dict['detection_classes'].astype(np.int64)\n\n label_id_offset = 1\n\n # DEBUG - can do it in a cleaner way :0\n tl_classes = {3: 'green', 2: 'red'}\n top_classes_prediction = list(detections_dict['detection_classes']+label_id_offset)[:5] \n #print(top_classes_prediction)\n for i in range(len(top_classes_prediction)):\n if top_classes_prediction[i] == 2:\n top_classes_prediction[i] = 'green'\n elif top_classes_prediction[i] == 3:\n top_classes_prediction[i] = 'red'\n\n\n #print(\"--------->\", image_path, \"<-----------\")\n #print( top_classes_prediction ) \n #print(detections_dict['detection_scores'][:5], '\\n' )\n\n # basic red tl logic\n if top_classes_prediction[0] == 'red' and detections_dict['detection_scores'][0] >= 0.60:\n #print(\"-------------> RED TRAFFIC LIGHT <----------------\\n\")\n self.current_light = TrafficLight.RED\n #rospy.logwarn( \"----------------- Taffic light is RED !!! -------------------- \" )\n self.display_predictions_scores( top_classes_prediction, detections_dict['detection_scores'] )\n else:\n #print(\"No red traffic is detected\\n\")\n self.current_light = TrafficLight.GREEN\n #rospy.logwarn( \"----------------- You're good to go !!! --------: {0} - {1} \".format(top_classes_prediction[0], detections_dict['detection_scores'][0]) )\n self.display_predictions_scores( top_classes_prediction, detections_dict['detection_scores'] )\n\n return self.current_light","def classify_features(self, feature_layer, labeled_tiles_directory, input_label_field, output_label_field, confidence_field=None):\r\n\r\n ALLOWED_FILE_FORMATS = ['tif', 'jpg', 'png']\r\n IMAGES_FOLDER = 'images/'\r\n LABELS_FOLDER = 'labels/'\r\n\r\n files = []\r\n\r\n for ext in ALLOWED_FILE_FORMATS:\r\n files.extend(glob.glob(os.path.join(labeled_tiles_directory, IMAGES_FOLDER + '*.' + ext)))\r\n\r\n predictions = {}\r\n for file in files:\r\n xml_path = os.path.join(os.path.dirname(os.path.dirname(file)),\r\n os.path.join(LABELS_FOLDER, os.path.basename(file).split('.')[0] + '.xml'))\r\n\r\n if not os.path.exists(xml_path):\r\n continue\r\n\r\n tree = ElementTree.parse(xml_path)\r\n root = tree.getroot()\r\n\r\n name_field = root.findall('object/name')\r\n if len(name_field) != 1:\r\n continue\r\n\r\n file_prediction = self.predict(file)\r\n\r\n predictions[name_field[0].text] = {\r\n 'prediction': file_prediction[0].obj,\r\n 'score': str(file_prediction[2].data.max().tolist())\r\n }\r\n\r\n features = feature_layer.query().features\r\n features_to_update = []\r\n for feature in features:\r\n if predictions.get(str(feature.attributes[input_label_field])):\r\n feature.attributes[output_label_field] = predictions.get(str(feature.attributes[input_label_field]))['prediction']\r\n if confidence_field:\r\n feature.attributes[confidence_field] = predictions.get(str(feature.attributes[input_label_field]))['score']\r\n\r\n features_to_update.append(feature)\r\n\r\n field_template = {\r\n \"name\": output_label_field,\r\n \"type\": \"esriFieldTypeString\",\r\n \"alias\": output_label_field,\r\n \"sqlType\": \"sqlTypeOther\",\r\n \"length\": 256,\r\n \"nullable\": True,\r\n \"editable\": True,\r\n \"visible\": True,\r\n \"domain\": None,\r\n \"defaultValue\": ''\r\n }\r\n\r\n confidence_field_template = {\r\n \"name\": confidence_field,\r\n \"type\": \"esriFieldTypeString\",\r\n \"alias\": confidence_field,\r\n \"sqlType\": \"sqlTypeOther\",\r\n \"length\": 256,\r\n \"nullable\": True,\r\n \"editable\": True,\r\n \"visible\": True,\r\n \"domain\": None,\r\n \"defaultValue\": ''\r\n }\r\n\r\n feature_layer.manager.add_to_definition({'fields': [field_template]})\r\n\r\n if confidence_field:\r\n feature_layer.manager.add_to_definition({'fields': [confidence_field_template]})\r\n\r\n try:\r\n start = 0\r\n stop = 100\r\n count = 100\r\n\r\n features_updated = features_to_update[start:stop]\r\n feature_layer.edit_features(updates=features_updated)\r\n\r\n time.sleep(2)\r\n while count == len(features_updated):\r\n start = stop\r\n stop = stop + 100\r\n features_updated = features_to_update[start:stop]\r\n feature_layer.edit_features(updates=features_updated)\r\n time.sleep(2)\r\n except Exception as e:\r\n feature_layer.manager.delete_from_definition({'fields': [field_template]})\r\n if confidence_field:\r\n feature_layer.manager.delete_from_definition({'fields': [confidence_field_template]})\r\n\r\n return False\r\n\r\n return True","def classify(self,X):\n return int(self.classifier.predict(self.scaler.transform(X)))","def classify(self,X):\n return int(self.classifier.predict(self.scaler.transform(X)))","def get_classification(self, image):\n\n # Convert image to PIL RGB image\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n # add a fourth batch dimension to array\n image = np.expand_dims(image, axis=0)\n\n ## Predict images class\n if image.shape==(1, self.img_height, self.img_width, self.img_channels):\n y_pred = self.model.predict(image)\n else:\n rospy.logwarn(\"tl_classifier: Wrong image shape: {},{},{},{}\".format(image.shape[0],image.shape[1],image.shape[2],image.shape[3]))\n return TrafficLight.UNKNOWN\n\n # Filter predictions\n confidence_threshold = 0.7\n y_pred_thresh = [y_pred[k][y_pred[k,:,1] > confidence_threshold] for k in range(y_pred.shape[0])]\n\n # Output predicted classes and scores\n #rospy.loginfo(\"tl_classifier: class conf xmin ymin xmax ymax\")\n \n # Filter classes prediction\n tl_pred_classes = y_pred_thresh[0][:,0]\n tl_pred_scores = y_pred_thresh[0][:,1]\n # Find classes that contains tl's\n tl_pred_classes = [cl for cl in tl_pred_classes if 1<=cl<=3]\n\n\n # Test light state (if prediction is not empty)\n if len(tl_pred_classes) > 0:\n if (tl_pred_classes[0]==1):\n tl_return = TrafficLight.GREEN\n rospy.loginfo(\"tl_classifier: Green detected, score {:.2f}\".format(tl_pred_scores[0]))\n elif (tl_pred_classes[0]==2):\n tl_return = TrafficLight.YELLOW\n rospy.loginfo(\"tl_classifier: Yellow detected, score {:.2f}\".format(tl_pred_scores[0]))\n elif (tl_pred_classes[0]==3):\n tl_return = TrafficLight.RED\n rospy.loginfo(\"tl_classifier: Red detected, score {:.2f}\".format(tl_pred_scores[0]))\n else:\n tl_return = TrafficLight.UNKNOWN\n rospy.loginfo(\"tl_classifier: Other class detected!\")\n else:\n tl_return = TrafficLight.UNKNOWN\n rospy.loginfo(\"tl_classifier: Unknown detected!\")\n\n\n return tl_return","def classify(self, filename):\n tokens = preprocess.parse_book(filename)\n perplexities = [m.perplexity(tokens) for m in self.models]\n print('-> perplexities = {}'.format([round(p) for p in perplexities]))\n over_baseline = [p - b for p, b in zip(perplexities, self.baselines)]\n print('-> over_baseline = {}'.format([round(o) for o in over_baseline]))\n min_index = over_baseline.index(min(over_baseline))\n return self.genres[min_index]","def model(features, test_features, encoding='ohe', n_folds=5):\n\n # Extract the ids\n train_ids = features['SK_ID_CURR']\n test_ids = test_features['SK_ID_CURR']\n\n # Extract the labels for training\n labels = features['TARGET']\n\n # Remove the ids and target\n features = features.drop(columns=['SK_ID_CURR', 'TARGET'])\n test_features = test_features.drop(columns=['SK_ID_CURR'])\n\n # One Hot Encoding\n if encoding == 'ohe':\n features = pd.get_dummies(features)\n test_features = pd.get_dummies(test_features)\n\n # Align the dataframes by the columns\n features, test_features = features.align(test_features, join='inner', axis=1)\n\n # No categorical indices to record\n cat_indices = 'auto'\n\n # Integer label encoding\n elif encoding == 'le':\n\n # Create a label encoder\n label_encoder = LabelEncoder()\n\n # List for storing categorical indices\n cat_indices = []\n\n # Iterate through each column\n for i, col in enumerate(features):\n if features[col].dtype == 'object':\n # Map the categorical features to integers\n features[col] = label_encoder.fit_transform(np.array(features[col].astype(str)).reshape((-1,)))\n test_features[col] = label_encoder.transform(np.array(test_features[col].astype(str)).reshape((-1,)))\n\n # Record the categorical indices\n cat_indices.append(i)\n\n # Catch error if label encoding scheme is not valid\n else:\n raise ValueError(\"Encoding must be either 'ohe' or 'le'\")\n\n print('Training Data Shape: ', features.shape)\n print('Testing Data Shape: ', test_features.shape)\n\n # Extract feature names\n feature_names = list(features.columns)\n\n # Convert to np arrays\n features = np.array(features)\n test_features = np.array(test_features)\n\n # Create the kfold object\n k_fold = KFold(n_splits=n_folds, shuffle=True, random_state=50)\n\n # Empty array for feature importances\n feature_importance_values = np.zeros(len(feature_names))\n\n # Empty array for test predictions\n test_predictions = np.zeros(test_features.shape[0])\n\n # Empty array for out of fold validation predictions\n out_of_fold = np.zeros(features.shape[0])\n\n # Lists for recording validation and training scores\n valid_scores = []\n train_scores = []\n\n # Iterate through each fold\n for train_indices, valid_indices in k_fold.split(features):\n # Training data for the fold\n train_features, train_labels = features[train_indices], labels[train_indices]\n # Validation data for the fold\n valid_features, valid_labels = features[valid_indices], labels[valid_indices]\n\n # Create the model\n model = lgb.LGBMClassifier(n_estimators=10000, objective='binary',\n class_weight='balanced', learning_rate=0.05,\n reg_alpha=0.1, reg_lambda=0.1,\n subsample=0.8, n_jobs=-1, random_state=50)\n\n # Train the model\n model.fit(train_features, train_labels, eval_metric='auc',\n eval_set=[(valid_features, valid_labels), (train_features, train_labels)],\n eval_names=['valid', 'train'], categorical_feature=cat_indices,\n early_stopping_rounds=100, verbose=200)\n\n # Record the best iteration\n best_iteration = model.best_iteration_\n\n # Record the feature importances\n feature_importance_values += model.feature_importances_ / k_fold.n_splits\n\n # Make predictions\n test_predictions += model.predict_proba(test_features, num_iteration=best_iteration)[:, 1] / k_fold.n_splits\n\n # Record the out of fold predictions\n out_of_fold[valid_indices] = model.predict_proba(valid_features, num_iteration=best_iteration)[:, 1]\n\n # Record the best score\n valid_score = model.best_score_['valid']['auc']\n train_score = model.best_score_['train']['auc']\n\n valid_scores.append(valid_score)\n train_scores.append(train_score)\n\n # Clean up memory\n gc.enable()\n del model, train_features, valid_features\n gc.collect()\n\n # Make the submission dataframe\n submission = pd.DataFrame({'SK_ID_CURR': test_ids, 'TARGET': test_predictions})\n\n # Make the feature importance dataframe\n feature_importances = pd.DataFrame({'feature': feature_names, 'importance': feature_importance_values})\n\n # Overall validation score\n valid_auc = roc_auc_score(labels, out_of_fold)\n\n # Add the overall scores to the metrics\n valid_scores.append(valid_auc)\n train_scores.append(np.mean(train_scores))\n\n # Needed for creating dataframe of validation scores\n fold_names = list(range(n_folds))\n fold_names.append('overall')\n\n # Dataframe of validation scores\n metrics = pd.DataFrame({'fold': fold_names,\n 'train': train_scores,\n 'valid': valid_scores})\n\n return submission, feature_importances, metrics","def build_model(train_inputs,train_labels,model_params,model_mode='classification',\n model_type='naive_bayes'):\n if model_mode == \"classification\":\n if model_type == \"naive_bayes\":\n model = GaussianNB()\n if model_type == \"knn\":\n model = KNeighborsClassifier(n_neighbors=50)\n if model_type == \"svm\":\n model = SVC(kernel='poly', degree =27, coef0 =1, C=5)\n if model_type == \"decision_tree\":\n model = DecisionTreeClassifier(min_samples_split=45,min_samples_leaf=45,criterion=\"gini\")\n #model = RandomForestClassifier(n_estimators=500, n_jobs=-1)\n\n if model_mode == \"regression\":\n if model_type == \"knn\":\n model = KNeighborsRegressor()\n if model_type == \"svm\":\n model = SVR()\n if model_type == \"decision_tree\":\n model = DecisionTreeRegressor()\n\n\n model.fit(train_inputs, train_labels)\n # for name, score in zip(train_inputs.columns,model.feature_importances_):\n # print(name, score)\n\n return model","def predict():\n if (not request.json):\n abort(400)\n \n product = {\n 'brand': request.json['brand'],\n 'category-1': request.json['category-1'],\n 'category-2': request.json['category-2'],\n 'category-3': request.json['category-3'],\n 'colour': request.json['colour'],\n 'fabric_type': request.json['fabric_type'],\n 'ftp_acrylic': request.json['ftp_acrylic'],\n 'ftp_cotton': request.json['ftp_cotton'],\n 'ftp_elastane': request.json['ftp_elastane'],\n 'ftp_linen': request.json['ftp_linen'],\n 'ftp_other': request.json['ftp_other'],\n 'ftp_polyamide': request.json['ftp_polyamide'],\n 'ftp_polyester': request.json['ftp_polyester'],\n 'ftp_polypropylene': request.json['ftp_polypropylene'],\n 'ftp_silk': request.json['ftp_silk'],\n 'ftp_viscose': request.json['ftp_viscose'],\n 'ftp_wool': request.json['ftp_wool'],\n 'gender': request.json['gender'],\n 'label': request.json['label'],\n 'made_in': request.json['made_in'],\n 'season': request.json['season'],\n 'size': request.json['size'],\n 'unspsc_code': request.json['unspsc_code'],\n 'weight': request.json['weight'],\n 'ML-model': request.json['ML-model']\n }\n\n product['co2_total'] = None\n ml_model = product.pop('ML-model', None)\n if (ml_model == None or ml_model == ''):\n print('Loading default model: LGBM')\n ml_model = 'lgbm_default'\n else:\n print(f'Loading model: {ml_model}')\n model = load_model(ml_model)\n print('Model loaded')\n \n pred_with_intervals = do_prediction_with_params(model, product, intervals=True)\n \n prediction = pred_with_intervals[0][0]\n percentile_5 = pred_with_intervals[0][1] if len(pred_with_intervals[0]) == 3 and pred_with_intervals[0][1] is not None else None\n percentile_95 = pred_with_intervals[0][2] if len(pred_with_intervals[0]) == 3 and pred_with_intervals[0][2] is not None else None\n result = {\n \"prediction\": prediction,\n \"5-percentile\": percentile_5,\n \"95-percentile\": percentile_95\n }\n \n print('CO2e prediction complete, returning result')\n print(result)\n \n resp = jsonify(result)\n resp.status_code = 201\n return resp","def predict(self, data):\n\t\traise NotImplementedError","def model_evaluate(query):\n engine = create_engine('sqlite:///data/DisasterResponse.db')\n df = pd.read_sql_table('Messages', engine)\n\n model = joblib.load(\"models/model.pkl\")\n \n classification_labels = model.predict([query])[0]\n classification_results = dict(zip(df.columns[4:], classification_labels))\n\n return classification_labels, classification_results","def classify(neural_net, image_file):\n\timg = Image.open(image_file)\n\timg.load()\n\timg_array = np.asarray(img)\n\timg_array.shape = (1, 100, 100, 3)\n\n\tprediction = model.predict(img_array)[0][0]\n\treturn prediction","def mlp_model2():\n model = Sequential()\n model.add(Dense(256, activation='relu', input_shape=(X_train_scaled.shape[1], )))\n model.add(Dropout(0.2))\n model.add(Dense(128, activation='relu'))\n model.add(Dropout(0.2))\n model.add(Dense(64, activation='relu'))\n model.add(Dropout(0.2))\n model.add(Dense(32, activation='relu'))\n model.add(Dropout(0.2))\n model.add(Dense(FLAGS.nb_classes, activation='softmax'))\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n\n model.summary()\n return model","def test_multifield_classify(self):\n self.model.fit(self.text_data_train, self.train_targets)\n self.assertTrue(self.model.is_classification)\n predictions = self.model.predict(self.text_data_valid)\n self.model.save(self.save_file)\n model = LanguageModelGeneralAPI.load(self.save_file)\n new_predictions = model.predict(self.text_data_valid)\n for new_pred, old_pred in zip(new_predictions, predictions):\n self.assertEqual(new_pred, old_pred)","def read_labelmap_vidor(labelmap_file):\n\n labelmap = []\n class_ids = set()\n name = \"\"\n class_id = \"\"\n\n with open('idx_to_pred.pkl', 'rb') as f:\n idx_to_pred = pickle.load(f)\n\n # with PathManager.open(labelmap_file, \"r\") as f:\n # import pdb; pdb.set_trace()\n # for line in f:\n # if line.startswith(\" name:\"):\n # name = line.split('\"')[1]\n # elif line.startswith(\" id:\") or line.startswith(\" label_id:\"):\n # class_id = int(line.strip().split(\" \")[-1])\n # labelmap.append({\"id\": class_id, \"name\": name})\n # class_ids.add(class_id)\n # return labelmap, class_ids\n\n \"\"\"\n (Pdb) categories\n [{'id': 1, 'name': 'bend/bow (at the waist)'}, {'id': 3, 'name': 'crouch/kneel'}, {'id': 4, 'name': 'dance'}, {'id': 5, 'name': 'fall down'}, {'id': 6, 'name': 'get up'}, {'id': 7, 'name': 'jump/leap'}, {'id': 8, 'name': 'lie/sleep'}, {'id': 9, 'name': 'martial art'}, {'id': 10, 'name': 'run/jog'}, {'id': 11, 'name': 'sit'}, {'id': 12, 'name': 'stand'}, {'id': 13, 'name': 'swim'}, {'id': 14, 'name': 'walk'}, {'id': 15, 'name': 'answer phone'}, {'id': 17, 'name': 'carry/hold (an object)'}, {'id': 20, 'name': 'climb (e.g., a mountain)'}, {'id': 22, 'name': 'close (e.g., a door, a box)'}, {'id': 24, 'name': 'cut'}, {'id': 26, 'name': 'dress/put on clothing'}, {'id': 27, 'name': 'drink'}, {'id': 28, 'name': 'drive (e.g., a car, a truck)'}, {'id': 29, 'name': 'eat'}, {'id': 30, 'name': 'enter'}, {'id': 34, 'name': 'hit (an object)'}, {'id': 36, 'name': 'lift/pick up'}, {'id': 37, 'name': 'listen (e.g., to music)'}, {'id': 38, 'name': 'open (e.g., a window, a car door)'}, {'id': 41, 'name': 'play musical instrument'}, {'id': 43, 'name': 'point to (an object)'}, {'id': 45, 'name': 'pull (an object)'}, {'id': 46, 'name': 'push (an object)'}, {'id': 47, 'name': 'put down'}, {'id': 48, 'name': 'read'}, {'id': 49, 'name': 'ride (e.g., a bike, a car, a horse)'}, {'id': 51, 'name': 'sail boat'}, {'id': 52, 'name': 'shoot'}, {'id': 54, 'name': 'smoke'}, {'id': 56, 'name': 'take a photo'}, {'id': 57, 'name': 'text on/look at a cellphone'}, {'id': 58, 'name': 'throw'}, {'id': 59, 'name': 'touch (an object)'}, {'id': 60, 'name': 'turn (e.g., a screwdriver)'}, {'id': 61, 'name': 'watch (e.g., TV)'}, {'id': 62, 'name': 'work on a computer'}, {'id': 63, 'name': 'write'}, {'id': 64, 'name': 'fight/hit (a person)'}, {'id': 65, 'name': 'give/serve (an object) to (a person)'}, {'id': 66, 'name': 'grab (a person)'}, {'id': 67, 'name': 'hand clap'}, {'id': 68, 'name': 'hand shake'}, {'id': 69, 'name': 'hand wave'}, {'id': 70, 'name': 'hug (a person)'}, {'id': 72, 'name': 'kiss (a person)'}, {'id': 73, 'name': 'lift (a person)'}, {'id': 74, 'name': 'listen to (a person)'}, {'id': 76, 'name': 'push (another person)'}, {'id': 77, 'name': 'sing to (e.g., self, a person, a group)'}, {'id': 78, 'name': 'take (an object) from (a person)'}, {'id': 79, 'name': 'talk to (e.g., self, a person, a group)'}, {'id': 80, 'name': 'watch (a person)'}]\n (Pdb) class_whitelist\n {1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 20, 22, 24, 26, 27, 28, 29, 30, 34, 36, 37, 38, 41, 43, 45, 46, 47, 48, 49, 51, 52, 54, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 72, 73, 74, 76, 77, 78, 79, 80}\n \"\"\"","def predict_class(self, original_image_numpy: np.ndarray) -> None:\n from app.dl_model.image import ClassifierInput\n # scale up coordinates\n self.scale_up_coordinates()\n x1, y1, x2, y2 = [int(coord) for coord in self.scale_coordinates.round()]\n # crop original numpy image\n numpy_image = original_image_numpy[y1:y2, x1:x2, :].copy()\n # create classifier input object\n classifier_input = ClassifierInput(numpy_image, new_shape=(224, 224))\n # classify input\n prediction = classifier_input.predict_class()\n # set attributes\n self.class_name = prediction.class_name # update class_name\n self.conf = prediction.conf # update probability\n self.product_id = prediction.product_id # set product external id\n self.detection_index = prediction.detection_index # set detection index\n self.top_k_names = prediction.top_k_names # set top k names list\n self.top_k_indices = prediction.top_k_indices # set top k detection index\n self.top_k_confidences = prediction.top_k_confidences # set top k confidieces values\n self.top_k_product_ids = prediction.top_k_product_ids # set top k product external ids","def get_classification(self, image):\n # Image pre-processing pipleine\n img = np.float32(image)\n img = preprocess_input(img)\n img = cv2.resize(img, (299, 299))\n img = np.expand_dims(img, 0)\n # Execute model's predictions - return probability value for each of 4 classes\n probs = self.model.predict(img)[0]\n # get class with max probability\n g_x = np.argmax(probs)\n\n # reject if model is not confident about the prediction\n if probs[g_x] < CONFIDENCE_THRESHOLD:\n return TrafficLight.UNKNOWN\n\n # Swap label values as model was trained with different label values\n if g_x == 2:\n prediction = 0 # Red\n elif g_x == 0:\n prediction = 2 # Green\n elif g_x == 3:\n prediction = 1 # Yellow\n else:\n prediction = 3 # No light\n\n # Log the message\n rospy.loginfo(\"The label returned is %d\", prediction)\n\n # Return the light state corresponding to the index\n return prediction","def prediction_on_a_image(self, input, output,model_saved_path):\n\n # load the saved model\n if os.path.isfile(model_saved_path) is False:\n raise IOError('trained model: %s not exist' % model_saved_path)\n\n clf = joblib.load(model_saved_path)\n\n # split a large image to many small ones\n patch_w = 500 # parameters.get_digit_parameters(\"\", \"train_patch_width\", None, 'int')\n patch_h = 500 # parameters.get_digit_parameters(\"\", \"train_patch_height\", None, 'int')\n overlay_x = 0 # parameters.get_digit_parameters(\"\", \"train_pixel_overlay_x\", None, 'int')\n overlay_y = 0 # parameters.get_digit_parameters(\"\", \"train_pixel_overlay_y\", None, 'int')\n\n img_folder = os.path.dirname(input)\n img_name = os.path.basename(input)\n inf_list_txt = 'inf_image_list.txt'\n with open(inf_list_txt, 'w') as txt_obj:\n txt_obj.writelines(img_name + '\\n')\n\n img_patches = build_RS_data.make_dataset(img_folder, inf_list_txt, patch_w, patch_h, overlay_x, overlay_y,\n train=False)\n\n for img_idx, aImg_patches in enumerate(img_patches):\n inf_output_dir = 'inf_results' #os.path.splitext(img_name)[0]\n os.system('mkdir -p '+inf_output_dir)\n os.system('rm '+inf_output_dir+'/*')\n\n ## parallel inference patches\n # but it turns out not work due to the Pickle.PicklingError\n # not working due to mulitple parameters. Jan 9, 2019, hlc\n # use multiple thread\n num_cores = multiprocessing.cpu_count()\n print('number of thread %d' % num_cores)\n # theadPool = mp.Pool(num_cores) # multi threads, can not utilize all the CPUs? not sure hlc 2018-4-19\n theadPool = Pool(num_cores) # multi processes\n\n # inference_one_patch_svm(img_idx, image_count, p_idx, patch_count, inf_output_dir, img_patch, scaler,clf)\n\n parameters_list = [\n (img_idx, len(img_patches), idx, len(aImg_patches), inf_output_dir, img_patch, self._scaler, clf)\n for (idx, img_patch) in enumerate(aImg_patches)]\n # results = theadPool.map(inference_one_patch_svm, parameters_list) # not working\n results = theadPool.starmap(inference_one_patch_svm, parameters_list) # need python3\n print('result_list', results)\n\n # for p_idx, img_patch in enumerate(aImg_patches):\n # # read images\n # patch_data = build_RS_data.read_patch(img_patch) # read_whole_x_pixels(input)\n #\n # nbands, height, width = patch_data.shape\n #\n # X_predit = patch_data.reshape(nbands, -1)\n # X_predit = np.transpose(X_predit, (1, 0))\n #\n # if os.path.isfile(scaler_saved_path) and self._scaler is None:\n # self._scaler = joblib.load(scaler_saved_path)\n # result = self._scaler.transform(X_predit)\n # X = result.tolist()\n # elif self._scaler is not None:\n # result = self._scaler.transform(X_predit)\n # X = result.tolist()\n # else:\n # X = X_predit\n # basic.outputlogMessage('warning, no pre-processing of data before prediction')\n #\n # # more method on prediction can be foudn in :\n # # https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html\n # pre_result = clf.predict(X)\n # result_img = pre_result.reshape((height, width))\n #\n # # save results\n # print('Save patch:%d/%d on Image:%d/%d , shape:(%d,%d)' %\n # (p_idx,len(aImg_patches), img_idx,len(img_patches), result_img.shape[0], result_img.shape[1]))\n #\n # # short the file name to avoid error of \" Argument list too long\", hlc 2018-Oct-29\n # file_name = \"I%d_%d\" % (img_idx, p_idx)\n #\n # save_path = os.path.join(inf_output_dir, file_name + '.tif')\n # build_RS_data.save_patch_oneband_8bit(img_patch,result_img.astype(np.uint8),save_path)\n #\n # with rasterio.open(input) as src_obj:\n # # Set spatial characteristics of the output object to mirror the input\n # kwargs = src_obj.meta\n # kwargs.update(\n # dtype=rasterio.uint8,\n # count=1)\n # # Create the file\n # with rasterio.open(output, 'w', **kwargs) as dst:\n # dst.write_band(1, result_img.astype(rasterio.uint8))\n # basic.outputlogMessage(\"save to %s\" % output)\n\n return True","def mlp_model():\n\tmodel = Sequential()\n\tmodel.add(Dense(256, activation='relu', input_shape=(X_train_scaled.shape[1], )))\n\tmodel.add(Dropout(0.4))\n\tmodel.add(Dense(256, activation='relu'))\n\tmodel.add(Dropout(0.4))\n\tmodel.add(Dense(FLAGS.nb_classes, activation='softmax'))\n\tmodel.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n\n\tmodel.summary()\n\treturn model","def predict_classification_net(X_test, image_name):\n\t# Load training data mean \n\tmeans = np.load(PATH + 'Datasets/means_classification.npy')\n\t# Zero center\n\tX_test -= means\n\t# Create model\n\tmodel = build_classif_net()\n\t# Load weights\n\tmodel.load_weights(PATH + 'Weights/weights_classification_net.hdf5')\n\t# Compile model\n\tmodel.compile(loss='categorical_crossentropy', optimizer='Adam', metrics=['accuracy'])\n\t# Predict model\n\tscores = model.predict(X_test)\n\t# Get indexes of the windows labeled as sealions (0 because sealions are [1 0])\n\tprediction = np.argmax(scores, axis=1)\n\n\tnp.save(PATH + 'Results/classification_'+ image_name + '.npy', prediction)\n\treturn prediction","def make_predictions(self):\n if is_classification(self.model):\n if self.ct == None:\n prediction = self.model.predict(self.input_data.to_numpy())\n probabilities = self.model.predict_proba(self.input_data.to_numpy())\n return prediction, probabilities\n elif self.ct != None: \n prediction = self.model.predict(self.data_into_model())\n probabilities = self.model.predict_proba(self.data_into_model())\n return prediction, probabilities\n else:\n raise Exception((\"{} not supported. Please create an issue on Github\").format(self.model))\n \n else:\n if self.ct == None:\n prediction = self.model.predict(self.input_data)\n return prediction\n elif self.ct != None: \n prediction = self.model.predict(self.data_into_model())\n return prediction\n else:\n raise Exception((\"{} not supported. Please create an issue on Github\").format(self.self.model))","def run_mapper():\n print(blue + \"\\n>>> \" + reset + \"Executing the model mapper...\")\n\n cmdb_ci_types = cmdb_data_model.cmdb_data_model.get(\"ci_types\")\n cmdb_rel_types = cmdb_data_model.cmdb_data_model.get(\"rel_types\")\n cmdb_ci_attributes = cmdb_data_model.cmdb_data_model.get(\"ci_attributes\")\n cmdb_rel_attributes = cmdb_data_model.cmdb_data_model.get(\"rel_attributes\")\n\n db_ci_types = db_data_model.db_data_model.get(\"ci_types\")\n db_rel_types = db_data_model.db_data_model.get(\"rel_types\")\n db_ci_attributes = db_data_model.db_data_model.get(\"ci_attributes\")\n db_rel_attributes = db_data_model.db_data_model.get(\"rel_attributes\")\n\n print(blue + \"\\n>>> \" + reset +\n \"Calculating configuration item types similarity...\")\n ci_similarity = calculate_class_similarity(cmdb_ci_types, db_ci_types)\n\n new_ci_similarity = {}\n for key in ci_similarity:\n new_ci_similarity[key] = {k: v for k, v in sorted(\n ci_similarity.get(key).items(), key=lambda item: item[1], reverse=True)}\n order = {}\n for key in new_ci_similarity:\n if len(new_ci_similarity.get(key)) > 0:\n order[key] = new_ci_similarity.get(key).get(\n list(new_ci_similarity.get(key).keys())[0])\n order = {k: v for k, v in sorted(\n order.items(), key=lambda item: item[1], reverse=True)}\n ci_similarity = {}\n for key in order:\n ci_similarity[key] = new_ci_similarity.get(key)\n\n similar_ci = select_most_similar(ci_similarity, {}, [])\n new_similar_ci = {}\n for key in similar_ci:\n if len(similar_ci.get(key)) > 0:\n new_similar_ci[key] = similar_ci.get(key)\n similar_ci = new_similar_ci\n\n print(blue + \"\\n>>> \" + reset + \"Calculating relationship types similarity...\")\n rel_similarity = calculate_class_similarity(cmdb_rel_types, db_rel_types)\n\n new_rel_similarity = {}\n for key in rel_similarity:\n new_rel_similarity[key] = {k: v for k, v in sorted(\n rel_similarity.get(key).items(), key=lambda item: item[1], reverse=True)}\n order = {}\n for key in new_rel_similarity:\n if len(new_rel_similarity.get(key)) > 0:\n order[key] = new_rel_similarity.get(key).get(\n list(new_rel_similarity.get(key).keys())[0])\n order = {k: v for k, v in sorted(\n order.items(), key=lambda item: item[1], reverse=True)}\n rel_similarity = {}\n for key in order:\n rel_similarity[key] = new_rel_similarity.get(key)\n\n similar_rel = select_most_similar(rel_similarity, {}, [])\n new_similar_rel = {}\n for key in similar_rel:\n if len(similar_rel.get(key)) > 0:\n new_similar_rel[key] = similar_rel.get(key)\n similar_rel = new_similar_rel\n\n print(blue + \"\\n>>> \" + reset +\n \"Calculating configuration item attributes similarity...\")\n attr_ci_similarity = calculate_attribute_similarity(\n similar_ci, cmdb_ci_attributes, db_ci_attributes)\n\n new_attr_ci_similarity = {}\n for cmdb_t in attr_ci_similarity:\n new_attr_ci_similarity[cmdb_t] = {}\n for key in attr_ci_similarity.get(cmdb_t):\n new_attr_ci_similarity[cmdb_t][key] = {k: v for k, v in sorted(\n attr_ci_similarity.get(cmdb_t).get(key).items(), key=lambda item: item[1], reverse=True)}\n\n order = {}\n for cmdb_t in new_attr_ci_similarity:\n order[cmdb_t] = {}\n for key in new_attr_ci_similarity.get(cmdb_t):\n if len(new_attr_ci_similarity.get(cmdb_t).get(key)) > 0:\n order[cmdb_t][key] = new_attr_ci_similarity.get(cmdb_t).get(key).get(\n list(new_attr_ci_similarity.get(cmdb_t).get(key).keys())[0])\n for o in order:\n order[o] = {k: v for k, v in sorted(\n order.get(o).items(), key=lambda item: item[1], reverse=True)}\n\n attr_ci_similarity = {}\n for o in order:\n attr_ci_similarity[o] = {}\n for key in order.get(o):\n attr_ci_similarity[o][key] = new_attr_ci_similarity.get(o).get(key)\n\n similar_attr_ci = {x: select_most_similar(\n attr_ci_similarity.get(x), {}, []) for x in attr_ci_similarity}\n\n new_similar_attr_ci = {}\n for key in similar_attr_ci:\n if len(similar_attr_ci.get(key)) > 0:\n new_similar_attr_ci[key] = similar_attr_ci.get(key)\n similar_attr_ci = new_similar_attr_ci\n\n print(blue + \"\\n>>> \" + reset +\n \"Calculating relationship attributes similarity...\")\n attr_rel_similarity = calculate_attribute_similarity(\n similar_rel, cmdb_rel_attributes, db_rel_attributes)\n\n new_attr_rel_similarity = {}\n for cmdb_t in attr_rel_similarity:\n new_attr_rel_similarity[cmdb_t] = {}\n for key in attr_rel_similarity.get(cmdb_t):\n new_attr_rel_similarity[cmdb_t][key] = {k: v for k, v in sorted(\n attr_rel_similarity.get(cmdb_t).get(key).items(), key=lambda item: item[1], reverse=True)}\n\n order = {}\n for cmdb_t in new_attr_rel_similarity:\n order[cmdb_t] = {}\n for key in new_attr_rel_similarity.get(cmdb_t):\n if len(new_attr_rel_similarity.get(cmdb_t).get(key)) > 0:\n order[cmdb_t][key] = new_attr_rel_similarity.get(cmdb_t).get(key).get(\n list(new_attr_rel_similarity.get(cmdb_t).get(key).keys())[0])\n for o in order:\n order[o] = {k: v for k, v in sorted(\n order.get(o).items(), key=lambda item: item[1], reverse=True)}\n\n attr_rel_similarity = {}\n for o in order:\n attr_rel_similarity[o] = {}\n for key in order.get(o):\n attr_rel_similarity[o][key] = new_attr_rel_similarity.get(\n o).get(key)\n\n similar_attr_rel = {x: select_most_similar(\n attr_rel_similarity.get(x), {}, []) for x in attr_rel_similarity}\n\n new_similar_attr_rel = {}\n for key in similar_attr_rel:\n if len(similar_attr_rel.get(key)) > 0:\n new_similar_attr_rel[key] = similar_attr_rel.get(key)\n similar_attr_rel = new_similar_attr_rel\n\n present_map(cmdb_ci_types, db_ci_types, cmdb_rel_types, db_rel_types, cmdb_ci_attributes, db_ci_attributes, cmdb_rel_attributes, db_rel_attributes, similar_ci, similar_rel,\n similar_attr_ci, similar_attr_rel)\n\n threshold = ask_for_threshold()\n\n define_rules(float(threshold), similar_ci, similar_rel,\n similar_attr_ci, similar_attr_rel)","def main(image, model_dir):\n model_file, signature = get_model_and_sig(model_dir)\n interpreter = load_model(model_dir + model_file)\n prediction = get_prediction(image, interpreter, signature)\n # get list of confidences from prediction\n confidences = list(prediction.values())[0]\n # get the label name for the predicted class\n labels = signature.get(\"classes\").get(\"Label\")\n max_confidence = max(confidences)\n prediction[\"Prediction\"] = labels[confidences.index(max_confidence)]\n return prediction","def proba_redefined_predict(model,X,weigh,classes=string.ascii_lowercase):\n\n y_proba=model.predict_proba(X)\n tuned=renorm(y_proba,weigh)\n y_max_arg=tuned.argmax(axis=1)\n predict=to_class(y_max_arg,classes)\n \n return predict","def main():\n # initialize the class labels and set the seed of the pseudorandom\n # number generator so we can reproduce our results\n labels = [\"dog\", \"cat\", \"panda\"]\n np.random.seed(1)\n\n # be * learned * by our model, but for the sake of this example, let's use random values\n W = np.random.randn(3, 3072)\n b = np.random.randn(3)\n\n # load our example image, resize it, and then flatten it into our\n # \"feature vector\" representation\n orig = cv2.imread(\"beagle.png\")\n image = cv2.resize(orig, (32, 32)).flatten()\n\n # compute the output scores by taking the dot product between the\n # weight matrix and image pixels, followed by adding in the b\n scores = W.dot(image) + b\n\n # loop over the scores + labels and display them\n for (label, score) in zip(labels, scores):\n print(\"[INFO] {}: {:.2f}\".format(label, score))\n\n # draw the label with the highest score on the image as our prediction\n cv2.putText(\n orig, \"Label: {}\".format(labels[np.argmax(scores)]), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2\n )\n\n # display our input image\n cv2.imshow(\"Image\", orig)\n cv2.waitKey(0)","def mid_term_file_classification(input_file, model_name, model_type,\n plot_results=False, gt_file=\"\"):\n labels = []\n accuracy = 0.0\n class_names = []\n cm = np.array([])\n if not os.path.isfile(model_name):\n print(\"mtFileClassificationError: input model_type not found!\")\n return labels, class_names, accuracy, cm\n\n # Load classifier:\n if model_type == \"knn\":\n classifier, mean, std, class_names, mt_win, mid_step, st_win, \\\n st_step, compute_beat = at.load_model_knn(model_name)\n else:\n classifier, mean, std, class_names, mt_win, mid_step, st_win, \\\n st_step, compute_beat = at.load_model(model_name)\n if compute_beat:\n print(\"Model \" + model_name + \" contains long-term music features \"\n \"(beat etc) and cannot be used in \"\n \"segmentation\")\n return labels, class_names, accuracy, cm\n # load input file\n sampling_rate, signal = audioBasicIO.read_audio_file(input_file)\n\n # could not read file\n if sampling_rate == 0:\n return labels, class_names, accuracy, cm\n\n # convert stereo (if) to mono\n signal = audioBasicIO.stereo_to_mono(signal)\n\n # mid-term feature extraction:\n mt_feats, _, _ = \\\n mtf.mid_feature_extraction(signal, sampling_rate,\n mt_win * sampling_rate,\n mid_step * sampling_rate,\n round(sampling_rate * st_win),\n round(sampling_rate * st_step))\n posterior_matrix = []\n\n # for each feature vector (i.e. for each fix-sized segment):\n for col_index in range(mt_feats.shape[1]):\n # normalize current feature v\n feature_vector = (mt_feats[:, col_index] - mean) / std\n\n # classify vector:\n label_predicted, posterior = \\\n at.classifier_wrapper(classifier, model_type, feature_vector)\n labels.append(label_predicted)\n\n # update probability matrix\n posterior_matrix.append(np.max(posterior))\n labels = np.array(labels)\n\n # convert fix-sized flags to segments and classes\n segs, classes = labels_to_segments(labels, mid_step)\n segs[-1] = len(signal) / float(sampling_rate)\n # Load grount-truth:\n labels_gt, class_names_gt, accuracy, cm = \\\n load_ground_truth(gt_file, labels, class_names, mid_step, plot_results)\n\n return labels, class_names, accuracy, cm","def predict_dense(train_xml_dir):\n\n cfg = configparser.ConfigParser()\n cfg.read(sys.argv[1])\n base = os.environ['DATA_ROOT']\n alphabet_pickle=cfg.get('data', 'alphabet_pickle')\n test_xml_dir = os.path.join(base, cfg.get('data', 'test_xml_dir'))\n test_cui_dir = os.path.join(base, cfg.get('data', 'test_cui_dir'))\n\n # load pre-trained model\n model = load_model(cfg.get('data', 'model_file'))\n interm_layer_model = Model(\n inputs=model.input,\n outputs=model.get_layer('HL').output)\n\n for f in os.listdir(test_cui_dir):\n file_path = os.path.join(test_cui_dir, f)\n int_seq = dataset.load_one_file_for_keras(file_path, alphabet_pickle)\n\n category2label = {}\n # run this file through the model for each selection criterion\n for category in n2b2.get_category_names(train_xml_dir):\n\n # could not train model; always predict 'not met'\n if category == 'KETO-1YR':\n category2label[category] = 'not met'\n print('file: %s, crit: %s, label: %s' % (f, category, 'not met'))\n continue\n\n maxlen = cfg.getint('data', 'maxlen')\n x = pad_sequences([int_seq], maxlen=maxlen)\n x = interm_layer_model.predict(x)\n\n classifier_pickle = 'Model/%s.clf' % category\n classifier = pickle.load(open(classifier_pickle, 'rb'))\n prediction = classifier.predict(x)\n label = dataset.INT2LABEL[prediction[0]]\n\n category2label[category] = label\n print('file: %s, crit: %s, label: %s' % (f, category, label))\n\n xml_file_name = f.split('.')[0] + '.xml'\n xml_file_path = os.path.join(test_xml_dir, xml_file_name)\n n2b2.write_category_labels(xml_file_path, category2label)\n print()","def predict():\n\n\n json_payload = request.json\n #LOG.info(f\"JSON payload: %s\" %json_payload)\n inference_payload = pd.DataFrame(json_payload)\n #LOG.info(\"inference payload DataFrame: %s\" %inference_payload)\n scaled_payload = scale(inference_payload)\n prediction = list(clf.predict(scaled_payload))\n return jsonify({'prediction': prediction})","def _classify(tree, x):\n # YOUR CODE HERE\n # begin answer\n feature_name=list(tree.keys())[0] #first element\n secondDict=tree[feature_name] \n key=x.loc[feature_name] #extract value from x\n for key_val in secondDict:\n feature_val=key_val[0]\n valueOfKey=secondDict[(feature_val, key>=feature_val)]\n if isinstance(valueOfKey,dict):\n label=_classify(valueOfKey,x)\n else:\n label=valueOfKey\n return label\n # end answer","def predict(self, datum):\r\n probs = {}\r\n for class_ in set(self.train_classes):\r\n probs[class_] = self.distribution.class_prob[class_] * reduce(lambda x,y:x*y, [self.distribution.prob(feat_ind_feat[0],feat_ind_feat[1],class_) for feat_ind_feat in enumerate(datum)])\r\n return max(probs, key=lambda x:probs[x])","def make_model():\n \n model = models.Sequential()\n model.add(layers.Conv2D(32, (3, 3), activation='relu',\n input_shape=(150, 150, 3)))\n model.add(layers.MaxPooling2D((2, 2)))\n model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n model.add(layers.MaxPooling2D((2, 2)))\n model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n model.add(layers.MaxPooling2D((2, 2)))\n model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n model.add(layers.MaxPooling2D((2, 2)))\n model.add(layers.Flatten())\n model.add(layers.Dense(512, activation='relu'))\n model.add(layers.Dense(37, activation='softmax'))\n \n #model.add(layers.Dense(1, activation='sigmoid'))\n \n\n model.compile(loss='sparse_categorical_crossentropy',\n optimizer=optimizers.RMSprop(lr=1e-4),\n metrics=['acc'])\n return model","def classify(self, example):\n raise NotImplementedError()","def multiclass_model_dict(num_class: int) -> dict:\n return {\n \"LogisticRegression\": createModel(\n \"LogisticRegression\",\n \"multiclass\",\n num_class=num_class,\n multi_class=\"multinomial\",\n solver=\"lbfgs\",\n max_iter=1000,\n ),\n \"GaussianNB\": createModel(\"GaussianNB\", \"multiclass\", num_class=num_class),\n \"KNeighborsClassifier\": createModel(\n \"KNeighborsClassifier\", \"multiclass\", num_class=num_class\n ),\n \"DecisionTreeClassifier\": createModel(\n \"DecisionTreeClassifier\", \"multiclass\", num_class=num_class\n ),\n \"ExtraTreesClassifier\": createModel(\n \"ExtraTreesClassifier\", \"multiclass\", num_class=num_class, n_estimators=100\n ),\n \"RandomForestClassifier\": createModel(\n \"RandomForestClassifier\",\n \"multiclass\",\n num_class=num_class,\n n_estimators=100,\n ),\n \"XGBoost\": createModel(\n \"XGBoostBinary\", \"multiclass\", num_class=num_class, num_boost_round=100\n ),\n \"LightGBM\": createModel(\n \"LightGBMBinary\", \"multiclass\", num_class=num_class, num_boost_round=100\n ),\n }","def classification(original_training_data):\n\n ''' Storing the dataframe as numpy array '''\n original_training_data_values = original_training_data.values\n\n ''' Storing the values of target attribute for finding out the counts of each recipetype'''\n target_column = original_training_data_values[:, -1]\n\n ''' Recipe_type stores the unique values of target attribute in the form of a list [Muffin Cupcake] \n cupcake_muffin_count stores the count of muffin and cupcakes in the form of a list [451 451]'''\n recipe_type, cupcake_muffin_count = np.unique(target_column, return_counts=True)\n\n ''' cupcake_muffin_count.argmax() returns the index of the highest value. In this case, it will return the index of \n muffin or cupcake count. '''\n majority_class = recipe_type[cupcake_muffin_count.argmax()]\n\n return majority_class","def classify(strings: List[str], params: Any) -> List[str]:\n \n # ############################ REPLACE THIS WITH YOUR CODE #############################\n def predict_one_sample(sample, train_dict, ngram_lvl=1):\n ngrams = [sample[i:i+ngram_lvl] for i in","def _predict(self, X):\n predictions = np.asarray([clf.predict(X) for clf in self.clfs_]).T\n predicted_labels = self.combiner.combine(predictions)\n return predicted_labels","def train_self(self):\n # for each numeric column, we need to record mean and std for both classes\n for col in self.num_cols:\n self.prob_hub[col] = {}\n for claz in self.class_list:\n mean, std = get_mean_std(self.data[self.data[self.class_column] == claz][col])\n self.prob_hub[col][claz] = (mean, std)\n\n # for each categorical columns, we need to record P(X=x|Y=y)\n for col in self.cat_cols:\n ulist = unique_list(self.data[col])\n self.prob_hub[col] = {}\n stat = self.data.groupby(self.class_column)[col].value_counts() / self.data.groupby(self.class_column)[col].count()\n # for each class\n for claz in self.class_list:\n self.prob_hub[col][claz] = {}\n for uni_element in ulist:\n self.prob_hub[col][claz][uni_element] = stat[claz][uni_element]\n\n self.predict(self.data, True)","def predict(self, data):\n xdata, _ = self.array_from_cases(data)\n preds = self.model.predict(xdata)\n label_preds = [dict(zip(self.binarizer.classes_, pred)) for pred in preds]\n return label_preds","def svc_classify(self, filename):\n tokens = preprocess.parse_book(filename)\n perplexities = [m.perplexity(tokens) for m in self.models]\n return self.genres[self.svc.predict(perplexities)]","def classify(new_music,fit):\n\tr = robjects.r\n\tp = prob_category(new_music,fit)\n\trobjects.globalenv[\"pred\"] = p\n\tr(\"\"\"\n\ttmp3 = vector()\n\tfor(i in 1:length(pred[,1])){\n\t\txx <- unlist(pred[i,])\n\t\ttmp3 <- append(tmp3,which(xx==max(xx)))\n\t}\n\tclasses <- names(tmp3)\n\t\"\"\")\n\treturn list(robjects.globalenv[\"classes\"])","def classify(self):\n\n if self.classifier is None:\n raise ValueError('self.classifier is None')\n if self.df is None:\n raise ValueError('self.df is None')\n if self.features is None:\n raise ValueError('self.features is None')\n\n train_set = self.df[self.df[self.label_col] != CLASSIFIER_NAN]\n test_set = self.df[self.df[self.label_col] == CLASSIFIER_NAN]\n\n test_set_timestamps = list(test_set.index.strftime('%Y-%m-%d %H:%M:%S.%f'))\n\n self.classifier.fit(\n train_set[self.features],\n train_set[self.label_col]\n )\n\n preds = self.classifier.predict(test_set[self.features])\n probs = self.classifier.predict_proba(test_set[self.features])\n\n res = []\n\n for i in range(0, len(preds)):\n probability = max(probs[i])\n res.append([test_set_timestamps[i], preds[i], probability])\n\n return res","def classify(data, labels, (train_idx, test_idx), classifier=None):\r\n\r\n assert classifier is not None, \"Why would you pass not classifier?\"\r\n\r\n # Data scaling based on training set\r\n scaler = SupervisedStdScaler() #SupervisedRobustScaler() # # \r\n scaler.fit(data[train_idx,:], labels[train_idx], label=-1)\r\n #scaler.fit(data[train_idx,:], labels[train_idx])\r\n data_train = scaler.transform(data[train_idx,:])\r\n data_test = scaler.transform(data[test_idx,:])\r\n try:\r\n classifier.fit(data_train, labels[train_idx])\r\n \r\n \r\n confMat = confusion_matrix(labels[test_idx],\r\n classifier.predict(data_test))\r\n if confMat.shape == (1,1):\r\n if all(labels[test_idx] == -1):\r\n confMat = np.array([[confMat[0], 0], [0, 0]], dtype=confMat.dtype)\r\n else:\r\n confMat = np.array([[0, 0], [0, confMat[0]]], dtype=confMat.dtype)\r\n confMatRate = confMat / np.tile(np.sum(confMat, axis=1).astype('float'), (2,1)).transpose()\r\n totalErr = (confMat[0, 1] + confMat[1, 0]) / float(confMat.sum())\r\n #if type(classifier) not in [type(None), DummyClassifier]:\r\n if hasattr(classifier,'param_grid'): \r\n #isinstance(classifier, GridSearchCV) or \\\r\n # isinstance(classifier, RandomizedSearchCV):\r\n fitted_model = classifier.best_estimator_\r\n else:\r\n fitted_model = copy.copy(classifier) \r\n return confMatRate, totalErr, fitted_model\r\n except np.linalg.linalg.LinAlgError as e:\r\n # sahil added statement to raise the error instead of returning nun values\r\n print e.message\r\n raise e\r\n # return np.array([[np.nan, np.nan], [np.nan, np.nan]]), np.nan, None\r","def gen_latent( model, dset, data_class ):\n dd = {}\n\n for dpath, dnames, fnames in os.walk( dset ):\n for f in fnames:\n if f.endswith( '.jpg' ) and data_class in f:\n n = f.split( '.' )[ 0 ] # code name of frame\n l = ts.pred_image( model, os.path.join( dpath, f ) ) # output of encoder\n dd[ n ] = l\n if DEBUG: print( n )\n\n return dd","def predict(self, X):\n\n ### TODO: YOUR CODE HERE\n D = shape(X)\n if self.isLeaf:\n return self.label\n else:\n if ( X[self.feature] <= 0.5 ):\n return self.left.predict(X)\n else:\n return self.right.predict(X)","def trainNet():"],"string":"[\n \"def predict_category(self):\\n pass\",\n \"def classify(self, data):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return self.sklearn_classifier.predict(data)\",\n \"def model(self):\\n filePath = self.config['data_path']['train_data']\\n data = self.loadCSV(filePath)\\n cleandata = self.preprocess(data)\\n X, y = self.dataSplit(cleandata)\\n X = self.CountVect(X, self.config['transform_path']['transform_model_path'])\\n X_train, X_test, y_train, y_test = self.TrainTestSplit(X, y)\\n self.MultinomialNB(X_train, X_test, y_train, y_test, self.config['nlp_path']['model_path'])\",\n \"def classify(self, data):\\n abstract\",\n \"def predict_only(self):\",\n \"def trainModel( self, featureTrain, classTrain):\",\n \"def predict(self, instances):\\r\\n raise NotImplementedError\",\n \"def classify(self, data):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return self.sklearn_svm.predict(data)\",\n \"def classifier(model):\\n \\n model.classifier = nn.Sequential(OrderedDict([\\n ('fc1', nn.Linear(model.classifier[0].in_features, 4096)),\\n ('fc2', nn.Linear(4096, 102)),\\n ('relu', nn.ReLU()),\\n ('output', nn.LogSoftmax(dim=1))\\n ]))\\n return model\",\n \"def apply_classifier(self):\\n for detected_object in self.detected_objects:\\n detected_object.predict_class(self.original_image)\",\n \"def classification(self,a_train,a_test,c_train,c_test,classifier):\\n le =LabelEncoder()\\n le.fit(c_train)\\n c_train = le.transform(c_train)\\n c_test = le.transform(c_test)\\n if classifier==\\\"GNB\\\": #Gaussian Naive Bayes\\n gnb = GaussianNB()\\n gnb.fit(a_train, c_train)\\n c_pred = gnb.predict(a_test)\\n elif classifier==\\\"DT\\\": #Decision Tree\\n dt=DecisionTreeClassifier()\\n dt.fit(a_train, c_train)\\n c_pred = dt.predict(a_test)\\n elif classifier==\\\"KNN\\\": #K-Next-Neighbors\\n kn=KNeighborsClassifier(n_neighbors=5)\\n kn.fit(a_train, c_train)\\n c_pred = kn.predict(a_test)\\n elif classifier==\\\"RF\\\": #Random Forest\\n rf=RandomForestClassifier()\\n rf.fit(a_train, c_train)\\n c_pred = rf.predict(a_test)\\n elif classifier==\\\"SVC\\\": # Support Vector Classifier\\n \\\"\\\"\\\"\\n SVC needs normalisation of Feature Values to scale of [-1,1] or [0,1] depending on sign of them\\n \\\"\\\"\\\"\\n if a_train.min()<0:\\n mms = MinMaxScaler(feature_range=(-1,1))\\n else:\\n mms = MinMaxScaler()\\n mms.fit(a_train)\\n a_train = mms.transform(a_train)\\n a_test = mms.transform(a_test)\\n svc=SVC(cache_size=2000,C=1, probability=True,kernel='rbf')\\n svc.fit(a_train,c_train)\\n #c_pred = svc.predict(a_test) did not work, that's why it is predicted manual\\n new_prob = svc.predict_proba(a_test)\\n samples=new_prob.shape[0]\\n c_pred= np.array\\n for k in range(samples):\\n c_pred=np.append(c_pred,new_prob[k].argmax())\\n c_pred = c_pred[1:samples+1]\\n elif classifier==\\\"DC\\\": #Dummy Classifier\\n dc=DummyClassifier(strategy=\\\"uniform\\\")\\n dc.fit(a_train, c_train)\\n c_pred = dc.predict(a_test)\\n elif classifier==\\\"GMM\\\": #Gaussian Mixture Modell\\n #number of existing classes get passed to the GMM (n_classes)\\n n_classes_train = len(np.unique(c_train))\\n n_classes_test = len(np.unique(c_test))\\n if n_classes_train>n_classes_test:\\n n_classes = n_classes_train\\n else:\\n n_classes = n_classes_test\\n #init_params='', because initial values get calculated manual\\n gmm = GMM(n_components=n_classes,init_params='')\\n #array of feature values of class i get extracted for further process\\n gmm.means_=np.array([a_train[c_train==i,:].mean(axis=0) for i in xrange(n_classes)])\\n gmm.weights_=np.array([a_train[c_train==i,:].shape[0]/float(c_train.shape[0]) for i in xrange(n_classes)])\\n \\n gmm_covars = np.zeros((a_train.shape[1]))\\n for i in xrange(n_classes):\\n valuesOfClassi = a_train[c_train==i,:]\\n valuesOfClassi = np.asarray(valuesOfClassi).T\\n matrixOfCov = np.cov(valuesOfClassi)+gmm.min_covar*np.eye(valuesOfClassi.shape[0])\\n variance = np.array([matrixOfCov[j,j] for j in xrange(matrixOfCov.shape[0])])\\n gmm_covars=np.vstack((gmm_covars,variance))\\n gmm_covars=gmm_covars[1:,:] #deletes initial row with zeros\\n \\n gmm.covars_=gmm_covars\\n c_pred = gmm.predict(a_test)\\n \\n c_pred=le.inverse_transform(c_pred)\\n return c_pred\",\n \"def calculate_MAP(self):\\n testing_images = open('./digitdata/testimages', 'r')\\n with testing_images as ti:\\n data = list(csv.reader(ti))\\n data = [i for i in data if i]\\n count = 0\\n #loop through all the test images\\n for j in range(0,1000):\\n classification_dict = {0:0,1:0,2:0,3:0,4:0,5:0,6:0,7:0,8:0,9:0} \\n for l in range(0,28):\\n coord = count + l\\n for w in range(0,28):\\n if data[coord][0][w] == \\\"+\\\":\\n #iterate through each class. z is the class [0-9]\\n for z in range(0,10):\\n classification_dict[z] += math.log(self.class_probabilities[z][l][w][0]) \\n elif data[coord][0][w] == \\\"#\\\":\\n for z in range(0,10):\\n classification_dict[z] += math.log(self.class_probabilities[z][l][w][1])\\n elif data[coord][0][w] == \\\" \\\":\\n for z in range(0,10):\\n classification_dict[z] += math.log(self.class_probabilities[z][l][w][2])\\n count += 28\\n self.solutions.append(max(classification_dict, key=classification_dict.get))\",\n \"def predict_labels(model):\\n test_datagen = ImageDataGenerator(featurewise_center=True,\\n featurewise_std_normalization=True\\n #rescale=1. / 255,\\n #samplewise_center=True,\\n #samplewise_std_normalization=True\\n )\\n test_datagen.fit(test_data)\\n # datagen.fit(val_data)\\n # create generator for train data\\n test_generator = test_datagen.flow(\\n test_data,\\n batch_size=batch_size,\\n shuffle=False)\\n pred_prob=model.predict_generator(test_generator,test_data.shape[0])\\n pred_prob=pred_prob[:,0]\\n def pre_class(x):\\n \\tif x<0.5:\\n return 0\\n else:\\n return 1\\n #def true_label(id):\\n #\\tif 'f0' in id:\\n #\\t return 0\\n # elif 'f1' in id: \\n # return 1\\n #\\telse:\\n #\\t pass\\n #pred_true=map(true_label,test_id)\\n #pred_true=np.array(pred_true)\\n #print roc_auc_score(val_target, pred_prob)\\n #prediction=map(pre_class,pred_prob)\\n #print confusion_matrix(val_target,prediction)\\n with open(\\\"prediction.csv\\\", \\\"w\\\") as f: \\n\\tp_writer = csv.writer(f, delimiter=',', lineterminator='\\\\n')\\n for id,label in zip(test_id,pred_prob):\\n\\t p_writer.writerow([id, label])\\n\\t\\n #base_path = \\\"PZ/test/test/\\\"\\n\\n #with open(\\\"prediction.csv\\\", \\\"w\\\") as f:\\n # p_writer = csv.writer(f, delimiter=',', lineterminator='\\\\n')\\n # for _, _, imgs in os.walk(base_path):\\n # for im in imgs:\\n # pic_id = im.split(\\\".\\\")[0]\\n #img = cv2.imread(base_path+im)\\n #img = cv2.resize(img, (img_width, img_height), cv2.INTER_LINEAR)\\n #img = img.transpose((2,0,1))\\n #img = np.expand_dims(img,axis=0)\\n #img = load_img(base_path + im)\\n #img = imresize(img, size=(img_height, img_width))\\n #test_x = img_to_array(img).reshape(3, img_height, img_width)\\n #test_x = test_x.reshape((1,) + test_x.shape)\\n #test_datagen.fit(img)\\n #test_generator = test_datagen.flow(img,\\n # batch_size=1,\\n # shuffle=False)\\n #prediction = model.predict_generator(test_generator, 1)\\n #p_writer.writerow([pic_id, prediction])\",\n \"def classify(img, c_model):\\n #global class_graph\\n\\n #img = load_img(im_path,target_size=(input_height, input_width))\\n #img = img_to_array(img)\\n im_size = 128\\n # resize \\n\\n img = cv2.resize(img, (im_size,im_size))\\n\\n img = img.astype(\\\"float\\\") / 255.0\\n img = np.expand_dims(img, axis=0)\\n with class_graph.as_default():\\n predictions = c_model.predict(img)[0]\\n\\n return predictions\",\n \"def build_classify(self, num_classes: int = 10) -> KM.Model:\\n input_tensor = KL.Input(shape=(32, 32, 3))\\n # if self.train_mode == \\\"classifier\\\":\\n # # Use the pretrained encoder for classifier only training\\n # self.encoder_model = KM.load_model(\\\"ae_model/ae_model.h5\\\").get_layer(\\n # \\\"encoder\\\"\\n # )\\n if self.train_mode != \\\"both\\\":\\n # build the encoder model\\n self.encoder_model = self.encoder(\\n features=self.encoder_features, name=\\\"encoder\\\"\\n )\\n encoded_features = self.encoder_model(input_tensor)\\n contrastive_features = KL.Lambda(lambda x: K.mean(x, [1, 2]), name=\\\"contrast\\\")(\\n encoded_features[-1]\\n )\\n # Calculate class probs from multiple latent representations\\n probs = classifier_block(encoded_features, num_classes=num_classes)\\n\\n return KM.Model(\\n inputs=input_tensor,\\n outputs=[probs, contrastive_features],\\n name=\\\"classifier\\\",\\n )\",\n \"def predict(model, images):\\n return model.predict_classes(images)\",\n \"def predict_proba(self):\\n ...\",\n \"def predict_from(self, inputs, to_layers):\",\n \"def predict(self):\\n raise NotImplementedError\",\n \"def keras_inference(input_image, model_type, labels, return_image):\\r\\n # Loading the image\\r\\n img = image.load_img(input_image, target_size=(50, 50))\\r\\n # Converting the image to numpy array\\r\\n x = image.img_to_array(img) \\r\\n # convert 3D tensor to 4D tensor with shape (1, 512, 512, 3)\\r\\n x = np.expand_dims(x, axis=0)\\r\\n\\r\\n image_to_predict = x.astype('float32')/255\\r\\n \\r\\n # image_to_plot = path_to_tensor(input_image)\\r\\n\\r\\n # model's weight for localization\\r\\n model = load_model(model_type)\\r\\n prediction = model.predict(image_to_predict)\\r\\n # print(\\\"X shape : \\\", x.shape)\\r\\n # prediction_final = \\\"Not_cancer: \\\" + str(np.round(prediction[0][0]*100, decimals = 2)) + \\\"%\\\" + \\\\\\r\\n # \\\" | Cancer: \\\" + str(np.round(prediction[0][1]*100, decimals = 2)) + \\\"%\\\"\\r\\n print(\\\"Prediction : \\\",prediction[0])\\r\\n print(\\\"Argmax : \\\", np.argmax(prediction[0]))\\r\\n confidence = np.max(prediction[0]) * 100\\r\\n classify = labeled_class[int(np.argmax(prediction[0]))]\\r\\n print(\\\"classify :\\\", classify)\\r\\n output = {\\r\\n \\\"label\\\": \\\"{}\\\".format(task),\\r\\n \\\"type\\\" : \\\"classification\\\",\\r\\n \\\"output\\\" : {\\r\\n \\\"confidence\\\" : \\\"{0:.2f}\\\".format(round(confidence,2)),\\r\\n \\\"results\\\" : classify,\\r\\n \\\"image\\\" : return_image\\r\\n }\\r\\n } \\r\\n \\r\\n return output\",\n \"def classify(im, model):\\n\\n classe = model.predict(im)\\n classe = classe.argmax(axis=-1) # taking index of the maximum %\\n return classe[0]\",\n \"def predict(self, X):\",\n \"def predict(self, X):\",\n \"def __init__(self, num_classed= 100):\\n self.model = Sequential()\\n self.num_classed = num_classed\\n self.categories = ['apples', 'aquarium fish', 'baby', 'bear', 'beaver',\\n 'bed', 'bee', 'beetle', 'bicycle', 'bottles',\\n 'bowls','boy', 'bridge', 'bus', 'butterfly', \\n 'camel', 'cans', 'castle', 'caterpillar', 'cattle', \\n 'chair', 'chimpanzee', 'clock', 'cloud', 'cockroach', \\n 'couch', 'crab', 'crocodile', 'cups', \\n 'dinosaur', 'dolphin', 'elephant', 'flatfish', 'forest', \\n 'fox', 'girl', 'hamster', 'house', 'kangaroo', 'computer keyboard', 'lamp', \\n 'lawn-mower', 'leopard', 'lion', 'lizard', 'lobster', \\n 'man', 'maple', 'motorcycle', 'mountain', 'mouse', \\n 'mushrooms', 'oak', 'oranges', 'orchids', 'otter', \\n 'palm', 'pears', 'pickup truck', 'pine', 'plain', \\n 'plates', 'poppies', 'porcupine', 'possum', 'rabbit', \\n 'raccoon', 'ray', 'road', 'rocket', 'roses', 'sea', \\n 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', \\n 'snail', 'snake', 'spider', 'squirrel', 'streetcar', \\n 'sunflowers', 'sweet peppers', 'table', 'tank', 'telephone', \\n 'television', 'tiger', 'tractor', 'train', 'trout', \\n 'tulips', 'turtle', 'wardrobe', 'whale', 'willow', \\n 'wolf', 'woman', 'worm']\",\n \"def predict_car():\\n img = open_image(request.files['image'])\\n pred_class, pred_idx, outputs = learn.predict(img)\\n return str(pred_class)\",\n \"def predict(self, testData=[]):\\n result = []\\n for classValue in self._classAttrs:\\n #print(f'Computing Label: {classValue}, {self._classLabelMap[classValue]}')\\n result.append(self._computeCondProb(testData, classValue))\\n return self._classLabelMap[result.index(max(result))]\",\n \"def name(self):\\n return 'Predict model (classification map)'\",\n \"def predict_label(self, src): # real signature unknown; restored from __doc__\\n pass\",\n \"def model_predict(img_path):\\n img = open_image(img_path)\\n pred_class, pred_idx, outputs = learn.predict(img)\\n print(pred_class)\\n return pred_class\",\n \"def default_classification_model(num_classes, num_anchors, pyramid_feature_size=256, prior_probability=0.01, classification_feature_size=256,name='classification_submodel'):\\n options = {\\n 'kernel_size' : 3,\\n 'strides' : 1,\\n 'padding' : 'same',\\n }\\n\\n if keras.backend.image_data_format() == 'channels_first':\\n inputs = keras.layers.Input(shape=(pyramid_feature_size, None, None))\\n else:\\n inputs = keras.layers.Input(shape=(None, None, pyramid_feature_size))\\n outputs = inputs\\n for i in range(4):\\n outputs = keras.layers.Conv2D(\\n filters=classification_feature_size,\\n activation='relu',\\n name='pyramid_classification_{}'.format(i),\\n kernel_initializer=keras.initializers.normal(mean=0.0, stddev=0.01, seed=None),\\n bias_initializer='zeros',\\n **options\\n )(outputs)\\n\\n outputs = keras.layers.Conv2D(\\n filters=num_classes * num_anchors,\\n kernel_initializer=keras.initializers.normal(mean=0.0, stddev=0.01, seed=None),\\n bias_initializer=initializers.PriorProbability(probability=prior_probability),\\n name='pyramid_classification',\\n **options\\n )(outputs)\\n\\n # reshape output and apply sigmoid\\n if keras.backend.image_data_format() == 'channels_first':\\n outputs = keras.layers.Permute((2, 3, 1), name='pyramid_classification_permute')(outputs)\\n outputs = keras.layers.Reshape((-1, num_classes), name='pyramid_classification_reshape')(outputs)\\n outputs = keras.layers.Activation('sigmoid', name='pyramid_classification_sigmoid')(outputs)\\n\\n return keras.models.Model(inputs=inputs, outputs=outputs, name=name)\",\n \"def predict(self, x):\\n # *** START CODE HERE ***\\n return self.clf.predict_classes(x.reshape(x.shape[0], 28, 28, 1))\\n # *** END CODE HERE ***\",\n \"def image_model_predict(input_ms_image_filename, input_pan_image_filename, pan_img_height_size, pan_img_width_size, \\r\\n fitted_model, write, output_filename):\\r\\n \\r\\n with rasterio.open(input_ms_image_filename) as f:\\r\\n metadata = f.profile\\r\\n ms_img = np.transpose(f.read(tuple(np.arange(metadata['count']) + 1)), [1, 2, 0])\\r\\n \\r\\n with rasterio.open(input_pan_image_filename) as g:\\r\\n metadata_pan = g.profile\\r\\n pan_img = g.read(1)\\r\\n \\r\\n pan_img = np.expand_dims(pan_img, axis = 2)\\r\\n \\r\\n ms_to_pan_ratio = metadata['transform'][0] / metadata_pan['transform'][0]\\r\\n \\r\\n class_layer = np.zeros((pan_img.shape[0], pan_img.shape[1]))\\r\\n \\r\\n img_pan_holder = []\\r\\n img_ms_holder = []\\r\\n \\r\\n for i in range(0, pan_img.shape[0] - pan_img_height_size, int(ms_to_pan_ratio)):\\r\\n for j in range(0, pan_img.shape[1] - pan_img_width_size, int(ms_to_pan_ratio)):\\r\\n img_pan_iter = pan_img[i : i + pan_img_height_size, j : j + pan_img_width_size, 0]\\r\\n img_pan_holder.append(img_pan_iter)\\r\\n \\r\\n for i in range(0, int(ms_img.shape[0] - (pan_img_height_size / ms_to_pan_ratio)), int(ms_to_pan_ratio)):\\r\\n for j in range(0, int(pan_img.shape[1] - (pan_img_width_size / ms_to_pan_ratio)), int(ms_to_pan_ratio)):\\r\\n img_ms_iter = ms_img[i : int(i + (pan_img_height_size / ms_to_pan_ratio)), \\r\\n j : int(j + (pan_img_width_size / ms_to_pan_ratio)), \\r\\n 0 : metadata['count']]\\r\\n img_ms_holder.append(img_ms_iter)\\r\\n \\r\\n img_pan_array = np.concatenate(img_pan_holder, axis = 0)\\r\\n img_ms_array = np.concatenate(img_ms_holder, axis = 0)\\r\\n \\r\\n pred_array = np.argmax(fitted_model.predict([img_ms_array, img_pan_array]), axis = 1)\\r\\n \\r\\n n = 0 \\r\\n for i in range(int(pan_img_height_size / 2), pan_img.shape[0] - int(pan_img_height_size / 2), int(ms_to_pan_ratio)):\\r\\n for j in range(int(pan_img_width_size / 2), pan_img.shape[1] - int(pan_img_width_size / 2), int(ms_to_pan_ratio)):\\r\\n class_layer[i, j] = pred_array[n]\\r\\n n += 1\\r\\n \\r\\n if write:\\r\\n with rasterio.open(output_filename, 'w', **metadata_pan) as dst:\\r\\n dst.write(class_layer)\\r\\n \\r\\n return class_layer\",\n \"def _classifier(self, classes):\\n # Initialize key variables\\n pseudo = np.linalg.pinv(self.data)\\n result = np.dot(pseudo, classes)\\n return result\",\n \"def classify(text):\\n # TODO Wonder if there's a better way of doing this so the model persists across fucn calls. Will see once I get\\n # Heroku running\\n\\n sentences = sent_tokenize(text)\\n clean_sentences = list(map(clean_text, sentences))\\n word_tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')\\n # tokenize\\n _input = word_tokenizer(clean_sentences, padding=True, return_tensors='pt', return_attention_mask=True, return_length=True)\\n\\n # pass tokenized text thru model\\n model = LSTM(dr=.3)\\n state_dict = torch.load(os.path.join('model', 'model.pt'), map_location=torch.device('cpu'))\\n model.load_state_dict(state_dict['model_state_dict'])\\n\\n model.eval()\\n with torch.no_grad():\\n model_output = model(_input['input_ids'], _input['length'], _input['attention_mask'])\\n\\n # We start with: A list of command names, a list of sentences, a matrix with\\n # each row corresponding to a sentence and each column corresponding to a label's probability of being\\n # represented in the sentence The list of command names is parallel to the columns of the matrix\\n\\n # We want to end with a nested dict with sentences as keys and dicts of label : probability pairs as values\\n labels = model_output.topk(3)\\n\\n label_indices = labels[0].tolist()\\n probabilities = labels[1].tolist()\\n\\n with open(os.path.join('resources', 'label_names.txt')) as f:\\n command_names = f.read().splitlines()\\n\\n output = dict()\\n for i, row in enumerate(probabilities): # TODO vectorize this if possible\\n sent = sentences[i]\\n output[sent] = {command_names[idx]: label_indices[i][j] for j, idx in enumerate(row)}\\n\\n return output\",\n \"def get_classification(self, image):\\n # Image pre-processing pipeline\\n img = cv2.resize(image, None, fx=0.5, fy=0.5)\\n img = img.astype(np.float32)\\n img = keras.applications.vgg16.preprocess_input(img)\\n # Execute prediction\\n probs = self.model.predict(np.array([img]), batch_size=1, verbose=1)[0]\\n # get label with max probability\\n g_x = np.argmax(probs)\\n\\n # reject if model is not confident\\n if probs[g_x] < CONFIDENCE_THRESHOLD:\\n return TrafficLight.UNKNOWN\\n\\n label = self.predictionary[g_x]\\n rospy.loginfo(\\\"label: %d, conf: %f, %f, %f, %f\\\", g_x, probs[0], probs[1], probs[2], probs[3])\\n return label\",\n \"def map_objects_classifier_evaluation(self):\\n df = self.results[(self.results['iou'] > 0.7)]\\n y_true = df['true_class']\\n y_pred = df['pred_class']\\n print(classification_report(y_true, y_pred))\\n matrix = confusion_matrix(y_true, y_pred)\\n matrix = matrix.astype('float') / matrix.sum(axis=1)[:, np.newaxis]\\n import seaborn as sns\\n\\n plt.figure(figsize=(10, 7))\\n sns.set(font_scale=2.4)\\n sns.heatmap(matrix, annot=True, annot_kws={'size': 25},\\n cmap=plt.cm.Reds)\\n # Add labels to the plot\\n class_names = ['background', 'building', 'water']\\n tick_marks = np.arange(len(class_names))\\n tick_marks2 = tick_marks + 0.28\\n tick_marks2[0] = tick_marks2[0] - 0.2\\n tick_marks = tick_marks + 0.5\\n plt.xticks(tick_marks, class_names, rotation=0)\\n plt.yticks(tick_marks2, class_names, rotation=90)\\n plt.xlabel('Predicted label', labelpad=13)\\n plt.ylabel('True label', labelpad=13)\\n plt.show()\",\n \"def predict(x):\\n\\n scores = np.zeros(shape=(len(classes_def), len(x)))\\n\\n for idx, c in enumerate(classes_def):\\n\\n model_name = model_name_pre + c + model_name_post\\n print('Loading model', model_name, 'and making predictions..')\\n model = load_model(model_name)\\n\\n scores[idx] = model.predict(x).reshape(len(x))\\n\\n out = []\\n\\n for predictions in scores.T:\\n # Majority vote\\n max_idx_for_sample = 0\\n max_prob_for_sample = 0\\n for i, prediction in enumerate(predictions):\\n if prediction > max_prob_for_sample:\\n max_idx_for_sample = i\\n\\n out.append(classes_def[max_idx_for_sample])\\n\\n return out\",\n \"def build_model_mobilenet(num_classes):\",\n \"def predict(self, x):\\n\\n x_ = self.scaler_s1.transform(x)\\n s1_df = self.basemodel.decision_function(x_)\\n s2_df = self.confidencemodel.decision_function(x_)\\n\\n '''\\n hc_df = np.max(dfs, 1)\\n\\n # high confidence vector\\n hc_df[(dfs > 0).sum(1) > 1] = np.min(dfs, 1)[(dfs > 0).sum(1) > 1]\\n '''\\n\\n hc_df = -np.ones((s2_df.shape[0], 1))\\n y_pred1 = self.basemodel.predict(x_)\\n\\n unique_labels = range(s2_df.shape[1])\\n for label in unique_labels:\\n hc_df[y_pred1 == label, :] = s2_df[y_pred1 == label, label][:, np.newaxis]\\n\\n '''\\n # TODO modif this to be compatible with multilabel classifiers (currently only binary classifier)\\n xor_mask = np.logical_xor(s2_df[:, 0] > 0, s2_df[:, 1] > 0)\\n\\n if xor_mask.sum() > 0:\\n hc_df[xor_mask, 0] = np.max(s2_df, 1)[xor_mask]\\n hc_df[~xor_mask, 0] = -np.abs(np.max(s2_df, 1)[~xor_mask])\\n #hc_labels = np.greater(s2_df[:, 1], s2_df[:, 0]).astype(int)\\n '''\\n\\n hit_proba_estimate = self.hitproba.predict(x_)\\n joint_hc = self.joint_class_hc.predict(x_)\\n\\n data_array = []\\n dict_array = []\\n if len(joint_hc.shape):\\n\\n dict_array = {'s1_df': s1_df[:, np.newaxis],\\n 'hcdf': hc_df,\\n 's2_df': s2_df,\\n 'hitproba': hit_proba_estimate[:, np.newaxis],\\n 'hcjoint': joint_hc[:, np.newaxis],\\n 's1_hat': self.ohe.transform((s1_df[:, np.newaxis]>0).astype(int)),\\n 's2_hat': ((self.ohe.transform((s1_df.reshape(-1, 1)>0).astype(int))>0) & (s2_df>0)).astype(int),\\n }\\n data_array = np.hstack(\\n [s1_df[:, np.newaxis], hc_df, s2_df, hit_proba_estimate[:, np.newaxis], joint_hc[:, np.newaxis]])\\n else:\\n # multiclass\\n data_array = np.hstack([s1_df, hc_df, s2_df, hit_proba_estimate, joint_hc])\\n dict_array = {'s1_df': s1_df,\\n 'hc_df': hc_df,\\n 's2_df': s2_df,\\n 'hitproba': hit_proba_estimate,\\n 'hcjoint': joint_hc,\\n 's1_hat': self.ohe.transform((s1_df > 0).astype(int)),\\n 's2_hat': ((self.ohe.transform((s1_df > 0).astype(int)) > 0) & (s2_df > 0)).astype(int)\\n }\\n\\n return data_array, dict_array\",\n \"def _classification(text_path_list, id_list, label_list):\\n textnum = len(text_path_list)\\n batched_num = ((textnum - 1) // classify.BATCH_SIZE + 1) * classify.BATCH_SIZE\\n for i in range(batched_num - textnum):\\n text_path_list.append(text_path_list[0])\\n id_list.append(id_list[0])\\n annotations = classify_obj.inference(text_path_list, id_list, label_list) #\\n return annotations[0:textnum]\",\n \"def get_classification(self, image):\\n #TODO implement light color prediction\\n max_idx = 4\\n with self.detection_graph.as_default():\\n with tf.Session(graph=self.detection_graph) as sess:\\n # Definite input and output Tensors for detection_graph\\n image_tensor = self.detection_graph.get_tensor_by_name('image_tensor:0')\\n \\n # Each box represents a part of the image where a particular object was detected.\\n detection_boxes = self.detection_graph.get_tensor_by_name('detection_boxes:0')\\n \\n # Each score represent how level of confidence for each of the objects.\\n # Score is shown on the result image, together with the class label.\\n detection_scores = self.detection_graph.get_tensor_by_name('detection_scores:0')\\n detection_classes = self.detection_graph.get_tensor_by_name('detection_classes:0')\\n num_detections = self.detection_graph.get_tensor_by_name('num_detections:0')\\n # Expand dimensions since the model expects images to have shape: [1, None, None, 3]\\n image_np_expanded = np.expand_dims(image, axis=0)\\n # Actual detection.\\n (boxes, scores, classes, num) = sess.run(\\n [detection_boxes, detection_scores, detection_classes, num_detections],\\n feed_dict={image_tensor: image_np_expanded})\\n\\n boxes = np.squeeze(boxes)\\n scores = np.squeeze(scores)\\n classes = np.squeeze(classes).astype(np.int32)\\n min_score_thresh = .50\\n # find majority light state\\n counter = [0, 0, 0, 0, 0]\\n for i in range(boxes.shape[0]):\\n if scores is None or scores[i] > min_score_thresh:\\n counter[classes[i]] += 1\\n for i in range(1, 5):\\n if counter[i] > counter[max_idx]:\\n max_idx = i\\n return self.classmap[max_idx]\",\n \"def classify_type(self):\\n a = model_classifier(self.model_filepath)\\n\\n size = os.stat(self.model_filepath).st_size\\n size = size / 1000000 # in MB\\n print('Model size in MB: {}'.format(size))\\n self.model_size = size\\n\\n if abs(size - a.resnet50_size) < abs(size - a.inceptionv3_size):\\n if abs(size - a.resnet50_size) < abs(size - a.densenet121_size):\\n print('RESNET 50 Model is analyzed')\\n model_type = 1\\n min_model_size_delta = a.resnet50_size - size\\n else:\\n print('DENSENET 121 Model is analyzed')\\n model_type = 3\\n min_model_size_delta = a.densenet121_size - size\\n elif abs(size - a.inceptionv3_size) < abs(size - a.densenet121_size):\\n print('INCEPTIONV3 Model is analyzed')\\n model_type = 2\\n min_model_size_delta = a.inceptionv3_size - size\\n else:\\n print('DENSENET Model is analyzed')\\n model_type = 3\\n min_model_size_delta = a.densenet121_size - size\\n\\n #print('classified the model as:\\\\t', a.switch_architecture(model_type))\\n return model_type, min_model_size_delta\",\n \"def classify_images():\\n\\n # Load the desired image\\n img_path = 'dataset/colorize_images/n02085782_919.jpg'\\n img = image.load_img(img_path, target_size=(299, 299))\\n x = image.img_to_array(img)\\n x = np.expand_dims(x, axis=0)\\n x = preprocess_input(x)\\n\\n model = InceptionV3(weights=\\\"imagenet\\\")\\n preds = model.predict(x)\\n # decode the results into a list of tuples (class, description, probability)\\n # (one such list for each sample in the batch)\\n print('Predicted:', decode_predictions(preds, top=3)[0])\",\n \"def classify_data(data, **kwargs):\\r\\n\\r\\n if 'mode' not in kwargs:\\r\\n kwargs['mode'] = 'log_reg'\\r\\n if 'threshold' not in kwargs:\\r\\n kwargs['threshold'] = 0.5\\r\\n if 'encode' not in kwargs:\\r\\n kwargs['encode'] = True\\r\\n if 'impute' not in kwargs:\\r\\n kwargs['impute'] = True\\r\\n data_copy = data.copy()\\r\\n if kwargs['impute']:\\r\\n data_copy = impute_missing_values_nominal(data)\\r\\n if kwargs['encode']:\\r\\n data_copy = encode_data_numerical(data)\\r\\n X_train, X_test, y_train, y_test = get_train_test(data_copy)\\r\\n model = train_model(X_train, y_train, kwargs['mode'])\\r\\n y_prob, y_pred = get_y_prob_pred(X_test, model, threshold=kwargs['threshold'])\\r\\n return X_train, X_test, y_train, y_test, model, y_prob, y_pred\",\n \"def classification_score(self, x, y):\\t\\n\\t\\tpass\",\n \"def discrete_model():\\n return {\\\"x\\\": np.random.randint(10, size=100), \\\"y\\\": np.random.randint(10, size=100)}\",\n \"def testModel( self, classTest, classPred):\",\n \"def predict(self, xs, **kwargs):\",\n \"def predict(self, datafile):\",\n \"def model_predict(img_path, model_path):\\n learn = load_model(model_path)\\n img = open_image(img_path)\\n # get the outputs from the model\\n pred_class,pred_idx,outputs = learn.predict(img)\\n # return the classification the model returns\\n return pred_class\",\n \"def do_classify(img,mask,n_sigmas,multichannel,intensity,edges,texture,sigma_min,sigma_max, downsample_value):\\n if np.ndim(img)==3:\\n features = extract_features(\\n img,\\n n_sigmas,\\n multichannel=multichannel,\\n intensity=intensity,\\n edges=edges,\\n texture=texture,\\n sigma_min=sigma_min,\\n sigma_max=sigma_max,\\n )\\n else:\\n features = extract_features(\\n np.dstack((img,img,img)),\\n n_sigmas,\\n multichannel=multichannel,\\n intensity=intensity,\\n edges=edges,\\n texture=texture,\\n sigma_min=sigma_min,\\n sigma_max=sigma_max,\\n )\\n\\n if mask is None:\\n raise ValueError(\\\"If no classifier clf is passed, you must specify a mask.\\\")\\n training_data = features[:, mask > 0].T\\n\\n training_data = memmap_feats(training_data)\\n\\n training_labels = mask[mask > 0].ravel()\\n\\n training_data = training_data[::downsample_value]\\n training_labels = training_labels[::downsample_value]\\n\\n lim_samples = 100000 #200000\\n\\n if training_data.shape[0]>lim_samples:\\n logging.info('Number of samples exceeds %i'% lim_samples)\\n ind = np.round(np.linspace(0,training_data.shape[0]-1,lim_samples)).astype('int')\\n training_data = training_data[ind,:]\\n training_labels = training_labels[ind]\\n logging.info('Samples have been subsampled')\\n logging.info('Number of samples in training data: %i' % (training_data.shape[0]))\\n print(training_data.shape)\\n\\n clf = make_pipeline(\\n StandardScaler(),\\n MLPClassifier(\\n solver='adam', alpha=1, random_state=1, max_iter=2000,\\n early_stopping=True, hidden_layer_sizes=[100, 60],\\n ))\\n logging.info(datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\"))\\n logging.info('Initializing MLP model')\\n\\n clf.fit(training_data, training_labels)\\n logging.info(datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\"))\\n logging.info('MLP model fit to data')\\n\\n del training_data, training_labels\\n\\n logging.info('Create and memory map model input data')\\n\\n data = features[:, mask == 0].T\\n logging.info('percent RAM usage: %f' % (psutil.virtual_memory()[2]))\\n\\n data = memmap_feats(data)\\n logging.info('Memory mapped model input data')\\n logging.info('percent RAM usage: %f' % (psutil.virtual_memory()[2]))\\n\\n labels = clf.predict(data)\\n logging.info(datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\"))\\n logging.info('Model used on data to estimate labels')\\n\\n if mask is None:\\n result = labels.reshape(img.shape[:2])\\n result2 = result.copy()\\n else:\\n result = np.copy(mask)#+1\\n result[mask == 0] = labels\\n del labels, mask\\n result2 = result.copy()\\n del result\\n\\n logging.info(datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\"))\\n logging.info('RF feature extraction and model fitting complete')\\n logging.info('percent RAM usage: %f' % (psutil.virtual_memory()[2]))\\n\\n return result2\",\n \"def classify():\\n excerpt = request.form.get('data')\\n if excerpt is None or not excerpt:\\n return jsonify(message='Bad request'), 400\\n return jsonify(clf.predict(excerpt))\",\n \"def predict(self, X):\\n ...\",\n \"def predict(self, X):\\n ...\",\n \"def predict(self, X):\\n ...\",\n \"def __existence_classification__(self,task_id,shape,aggregations):\\n\\n # aggregations = {}\\n\\n # raw_classifications and clustering_results have different hierarchy orderings- raw_classifications\\n # is better for processing data and clustering_results is better for showing the end result\\n # technically we only need to look at the data from clustering_results right now but its\\n # hierarchy is really inefficient so use raw_classifications to help\\n\\n # each shape is done independently\\n\\n # set - so if multiple tools create the same shape - we only do that shape once\\n # for shape in set(marking_tasks[task_id]):\\n\\n\\n # pretentious name but basically whether each person who has seen a subject thinks it is a true\\n # positive or not\\n existence_classification = {\\\"param\\\":\\\"subject_id\\\"}\\n\\n global_cluster_index = 0\\n # clusters_per_subject = []\\n\\n # look at the individual points in the cluster\\n for subject_id in aggregations.keys():\\n if subject_id == \\\"param\\\":\\n continue\\n\\n # gold standard pts may not match up perfectly with the given clusters -\\n # for example, we could have a gold penguin at 10,10 but the users' cluster\\n # is centered at 10.1,9.8 - same penguin though\\n # so as we go through the clusters, we need to see which ones match up more closely\\n # with the gold standard\\n # if subject_id in gold_standard_clustering[0]:\\n # # closest cluster and distance\\n # gold_to_cluster = {pt:(None,float(\\\"inf\\\")) for pt in gold_standard_clustering[0][subject_id]}\\n # else:\\n # gold_to_cluster = None\\n\\n\\n # clusters_per_subject.append([])\\n\\n # # in either case probably an empty image\\n # if subject_id not in clustering_results:\\n # continue\\n # if task_id not in clustering_results[subject_id]:\\n # continue\\n\\n if (shape+ \\\" clusters\\\") not in aggregations[subject_id][task_id]:\\n # if none of the relevant markings were made on this subject, skip it\\n continue\\n\\n all_users = aggregations[subject_id][task_id][shape+ \\\" clusters\\\"][\\\"all_users\\\"]\\n\\n for local_cluster_index in aggregations[subject_id][task_id][shape+ \\\" clusters\\\"]:\\n if local_cluster_index == \\\"all_users\\\":\\n continue\\n\\n # extract the users who marked this cluster\\n cluster = aggregations[subject_id][task_id][shape+ \\\" clusters\\\"][local_cluster_index]\\n\\n # todo - put this back when we support gold standard clustering\\n # # is this user cluster close to any gold standard pt?\\n # if subject_id in gold_standard_clustering[0]:\\n # x,y = cluster[\\\"center\\\"]\\n # for (gold_x,gold_y) in gold_to_cluster:\\n # dist = math.sqrt((x-gold_x)**2+(y-gold_y)**2)\\n # if dist < gold_to_cluster[(gold_x,gold_y)][1]:\\n # gold_to_cluster[(gold_x,gold_y)] = local_cluster_index,dist\\n #\\n # # now repeat for negative gold standards\\n # if subject_id in gold_standard_clustering[1]:\\n # x,y = cluster[\\\"center\\\"]\\n # min_dist = float(\\\"inf\\\")\\n # closest= None\\n # for x2,y2 in gold_standard_clustering[1][subject_id]:\\n # dist = math.sqrt((x-x2)**2+(y-y2)**2)\\n # if dist < min_dist:\\n # min_dist = min(dist,min_dist)\\n # closest = (x2,y2)\\n # if min_dist == 0.:\\n # assert (x,y) == closest\\n # mapped_gold_standard[(subject_id,local_cluster_index)] = 0\\n\\n users = cluster[\\\"users\\\"]\\n\\n ballots = []\\n\\n # todo - the 15 hard coded value - might want to change that at some point\\n for u in all_users:\\n if u in users:\\n ballots.append((u,1))\\n else:\\n ballots.append((u,0))\\n\\n existence_classification[(subject_id,local_cluster_index)] = ballots\\n # clusters_per_subject[-1].append(global_cluster_index)\\n # global_cluster_index += 1\\n\\n # # note we don't care about why a cluster corresponds to a gold standard pt - that is\\n # # it could be really close to given gold standards - the point is that it is close\\n # # to at least one of them\\n # if gold_to_cluster is not None:\\n # for (local_cluster_index,dist) in gold_to_cluster.values():\\n # # arbitrary threshold but seems reasonable\\n # if dist < 1:\\n # mapped_gold_standard[(subject_id,local_cluster_index)] = 1\\n\\n existence_results = self.__task_aggregation__(existence_classification,task_id,{})#,mapped_gold_standard)\\n assert isinstance(existence_results,dict)\\n\\n for subject_id,cluster_index in existence_results:\\n new_results = existence_results[(subject_id,cluster_index)][task_id]\\n # new_agg = {subject_id: {task_id: {shape + \\\" clusters\\\": {cluster_index: {\\\"existence\\\": new_results}}}}}\\n # aggregations = self.__merge_results__(aggregations,new_agg)\\n aggregations[subject_id][task_id][shape + \\\" clusters\\\"][cluster_index][\\\"existence\\\"] = new_results\\n # if subject_id not in aggregations:\\n # aggregations[subject_id] = {}\\n # if task_id not in aggregations[subject_id]:\\n # aggregations[subject_id][task_id] = {}\\n # if (shape + \\\" clusters\\\") not in aggregations[subject_id][task_id]:\\n # aggregations[subject_id][task_id][shape+ \\\" clusters\\\"] = {}\\n # # this part is probably redundant\\n # if cluster_index not in aggregations[subject_id][task_id][shape+ \\\" clusters\\\"]:\\n # aggregations[subject_id][task_id][shape+ \\\" clusters\\\"][cluster_index] = {}\\n #\\n # aggregations[subject_id][task_id][shape+ \\\" clusters\\\"][cluster_index][\\\"existence\\\"] = existence_results[(subject_id,cluster_index)]\\n\\n return aggregations\",\n \"def get_classification(self, image):\\n # return TrafficLight.RED\\n # TODO implement light color prediction\\n # creating an image object \\n img_np = np.array(image) \\n\\n # convert np array to tensor\\n input_tensor = tf.convert_to_tensor(img_np)\\n\\n # The model expects a batch of images, so add an axis with `tf.newaxis`.\\n input_tensor = input_tensor[tf.newaxis, ...]\\n\\n\\n detections = self.loaded(input_tensor)\\n\\n num_detections = int(detections.pop('num_detections'))\\n\\n # detection_classes should be ints.\\n detections_dict = {key: value[0, :num_detections].numpy() for key, value in detections.items()}\\n\\n\\n # detection_classes should be ints.\\n detections_dict['detection_classes'] = detections_dict['detection_classes'].astype(np.int64)\\n\\n label_id_offset = 1\\n\\n # DEBUG - can do it in a cleaner way :0\\n tl_classes = {3: 'green', 2: 'red'}\\n top_classes_prediction = list(detections_dict['detection_classes']+label_id_offset)[:5] \\n #print(top_classes_prediction)\\n for i in range(len(top_classes_prediction)):\\n if top_classes_prediction[i] == 2:\\n top_classes_prediction[i] = 'green'\\n elif top_classes_prediction[i] == 3:\\n top_classes_prediction[i] = 'red'\\n\\n\\n #print(\\\"--------->\\\", image_path, \\\"<-----------\\\")\\n #print( top_classes_prediction ) \\n #print(detections_dict['detection_scores'][:5], '\\\\n' )\\n\\n # basic red tl logic\\n if top_classes_prediction[0] == 'red' and detections_dict['detection_scores'][0] >= 0.60:\\n #print(\\\"-------------> RED TRAFFIC LIGHT <----------------\\\\n\\\")\\n self.current_light = TrafficLight.RED\\n #rospy.logwarn( \\\"----------------- Taffic light is RED !!! -------------------- \\\" )\\n self.display_predictions_scores( top_classes_prediction, detections_dict['detection_scores'] )\\n else:\\n #print(\\\"No red traffic is detected\\\\n\\\")\\n self.current_light = TrafficLight.GREEN\\n #rospy.logwarn( \\\"----------------- You're good to go !!! --------: {0} - {1} \\\".format(top_classes_prediction[0], detections_dict['detection_scores'][0]) )\\n self.display_predictions_scores( top_classes_prediction, detections_dict['detection_scores'] )\\n\\n return self.current_light\",\n \"def classify_features(self, feature_layer, labeled_tiles_directory, input_label_field, output_label_field, confidence_field=None):\\r\\n\\r\\n ALLOWED_FILE_FORMATS = ['tif', 'jpg', 'png']\\r\\n IMAGES_FOLDER = 'images/'\\r\\n LABELS_FOLDER = 'labels/'\\r\\n\\r\\n files = []\\r\\n\\r\\n for ext in ALLOWED_FILE_FORMATS:\\r\\n files.extend(glob.glob(os.path.join(labeled_tiles_directory, IMAGES_FOLDER + '*.' + ext)))\\r\\n\\r\\n predictions = {}\\r\\n for file in files:\\r\\n xml_path = os.path.join(os.path.dirname(os.path.dirname(file)),\\r\\n os.path.join(LABELS_FOLDER, os.path.basename(file).split('.')[0] + '.xml'))\\r\\n\\r\\n if not os.path.exists(xml_path):\\r\\n continue\\r\\n\\r\\n tree = ElementTree.parse(xml_path)\\r\\n root = tree.getroot()\\r\\n\\r\\n name_field = root.findall('object/name')\\r\\n if len(name_field) != 1:\\r\\n continue\\r\\n\\r\\n file_prediction = self.predict(file)\\r\\n\\r\\n predictions[name_field[0].text] = {\\r\\n 'prediction': file_prediction[0].obj,\\r\\n 'score': str(file_prediction[2].data.max().tolist())\\r\\n }\\r\\n\\r\\n features = feature_layer.query().features\\r\\n features_to_update = []\\r\\n for feature in features:\\r\\n if predictions.get(str(feature.attributes[input_label_field])):\\r\\n feature.attributes[output_label_field] = predictions.get(str(feature.attributes[input_label_field]))['prediction']\\r\\n if confidence_field:\\r\\n feature.attributes[confidence_field] = predictions.get(str(feature.attributes[input_label_field]))['score']\\r\\n\\r\\n features_to_update.append(feature)\\r\\n\\r\\n field_template = {\\r\\n \\\"name\\\": output_label_field,\\r\\n \\\"type\\\": \\\"esriFieldTypeString\\\",\\r\\n \\\"alias\\\": output_label_field,\\r\\n \\\"sqlType\\\": \\\"sqlTypeOther\\\",\\r\\n \\\"length\\\": 256,\\r\\n \\\"nullable\\\": True,\\r\\n \\\"editable\\\": True,\\r\\n \\\"visible\\\": True,\\r\\n \\\"domain\\\": None,\\r\\n \\\"defaultValue\\\": ''\\r\\n }\\r\\n\\r\\n confidence_field_template = {\\r\\n \\\"name\\\": confidence_field,\\r\\n \\\"type\\\": \\\"esriFieldTypeString\\\",\\r\\n \\\"alias\\\": confidence_field,\\r\\n \\\"sqlType\\\": \\\"sqlTypeOther\\\",\\r\\n \\\"length\\\": 256,\\r\\n \\\"nullable\\\": True,\\r\\n \\\"editable\\\": True,\\r\\n \\\"visible\\\": True,\\r\\n \\\"domain\\\": None,\\r\\n \\\"defaultValue\\\": ''\\r\\n }\\r\\n\\r\\n feature_layer.manager.add_to_definition({'fields': [field_template]})\\r\\n\\r\\n if confidence_field:\\r\\n feature_layer.manager.add_to_definition({'fields': [confidence_field_template]})\\r\\n\\r\\n try:\\r\\n start = 0\\r\\n stop = 100\\r\\n count = 100\\r\\n\\r\\n features_updated = features_to_update[start:stop]\\r\\n feature_layer.edit_features(updates=features_updated)\\r\\n\\r\\n time.sleep(2)\\r\\n while count == len(features_updated):\\r\\n start = stop\\r\\n stop = stop + 100\\r\\n features_updated = features_to_update[start:stop]\\r\\n feature_layer.edit_features(updates=features_updated)\\r\\n time.sleep(2)\\r\\n except Exception as e:\\r\\n feature_layer.manager.delete_from_definition({'fields': [field_template]})\\r\\n if confidence_field:\\r\\n feature_layer.manager.delete_from_definition({'fields': [confidence_field_template]})\\r\\n\\r\\n return False\\r\\n\\r\\n return True\",\n \"def classify(self,X):\\n return int(self.classifier.predict(self.scaler.transform(X)))\",\n \"def classify(self,X):\\n return int(self.classifier.predict(self.scaler.transform(X)))\",\n \"def get_classification(self, image):\\n\\n # Convert image to PIL RGB image\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n # add a fourth batch dimension to array\\n image = np.expand_dims(image, axis=0)\\n\\n ## Predict images class\\n if image.shape==(1, self.img_height, self.img_width, self.img_channels):\\n y_pred = self.model.predict(image)\\n else:\\n rospy.logwarn(\\\"tl_classifier: Wrong image shape: {},{},{},{}\\\".format(image.shape[0],image.shape[1],image.shape[2],image.shape[3]))\\n return TrafficLight.UNKNOWN\\n\\n # Filter predictions\\n confidence_threshold = 0.7\\n y_pred_thresh = [y_pred[k][y_pred[k,:,1] > confidence_threshold] for k in range(y_pred.shape[0])]\\n\\n # Output predicted classes and scores\\n #rospy.loginfo(\\\"tl_classifier: class conf xmin ymin xmax ymax\\\")\\n \\n # Filter classes prediction\\n tl_pred_classes = y_pred_thresh[0][:,0]\\n tl_pred_scores = y_pred_thresh[0][:,1]\\n # Find classes that contains tl's\\n tl_pred_classes = [cl for cl in tl_pred_classes if 1<=cl<=3]\\n\\n\\n # Test light state (if prediction is not empty)\\n if len(tl_pred_classes) > 0:\\n if (tl_pred_classes[0]==1):\\n tl_return = TrafficLight.GREEN\\n rospy.loginfo(\\\"tl_classifier: Green detected, score {:.2f}\\\".format(tl_pred_scores[0]))\\n elif (tl_pred_classes[0]==2):\\n tl_return = TrafficLight.YELLOW\\n rospy.loginfo(\\\"tl_classifier: Yellow detected, score {:.2f}\\\".format(tl_pred_scores[0]))\\n elif (tl_pred_classes[0]==3):\\n tl_return = TrafficLight.RED\\n rospy.loginfo(\\\"tl_classifier: Red detected, score {:.2f}\\\".format(tl_pred_scores[0]))\\n else:\\n tl_return = TrafficLight.UNKNOWN\\n rospy.loginfo(\\\"tl_classifier: Other class detected!\\\")\\n else:\\n tl_return = TrafficLight.UNKNOWN\\n rospy.loginfo(\\\"tl_classifier: Unknown detected!\\\")\\n\\n\\n return tl_return\",\n \"def classify(self, filename):\\n tokens = preprocess.parse_book(filename)\\n perplexities = [m.perplexity(tokens) for m in self.models]\\n print('-> perplexities = {}'.format([round(p) for p in perplexities]))\\n over_baseline = [p - b for p, b in zip(perplexities, self.baselines)]\\n print('-> over_baseline = {}'.format([round(o) for o in over_baseline]))\\n min_index = over_baseline.index(min(over_baseline))\\n return self.genres[min_index]\",\n \"def model(features, test_features, encoding='ohe', n_folds=5):\\n\\n # Extract the ids\\n train_ids = features['SK_ID_CURR']\\n test_ids = test_features['SK_ID_CURR']\\n\\n # Extract the labels for training\\n labels = features['TARGET']\\n\\n # Remove the ids and target\\n features = features.drop(columns=['SK_ID_CURR', 'TARGET'])\\n test_features = test_features.drop(columns=['SK_ID_CURR'])\\n\\n # One Hot Encoding\\n if encoding == 'ohe':\\n features = pd.get_dummies(features)\\n test_features = pd.get_dummies(test_features)\\n\\n # Align the dataframes by the columns\\n features, test_features = features.align(test_features, join='inner', axis=1)\\n\\n # No categorical indices to record\\n cat_indices = 'auto'\\n\\n # Integer label encoding\\n elif encoding == 'le':\\n\\n # Create a label encoder\\n label_encoder = LabelEncoder()\\n\\n # List for storing categorical indices\\n cat_indices = []\\n\\n # Iterate through each column\\n for i, col in enumerate(features):\\n if features[col].dtype == 'object':\\n # Map the categorical features to integers\\n features[col] = label_encoder.fit_transform(np.array(features[col].astype(str)).reshape((-1,)))\\n test_features[col] = label_encoder.transform(np.array(test_features[col].astype(str)).reshape((-1,)))\\n\\n # Record the categorical indices\\n cat_indices.append(i)\\n\\n # Catch error if label encoding scheme is not valid\\n else:\\n raise ValueError(\\\"Encoding must be either 'ohe' or 'le'\\\")\\n\\n print('Training Data Shape: ', features.shape)\\n print('Testing Data Shape: ', test_features.shape)\\n\\n # Extract feature names\\n feature_names = list(features.columns)\\n\\n # Convert to np arrays\\n features = np.array(features)\\n test_features = np.array(test_features)\\n\\n # Create the kfold object\\n k_fold = KFold(n_splits=n_folds, shuffle=True, random_state=50)\\n\\n # Empty array for feature importances\\n feature_importance_values = np.zeros(len(feature_names))\\n\\n # Empty array for test predictions\\n test_predictions = np.zeros(test_features.shape[0])\\n\\n # Empty array for out of fold validation predictions\\n out_of_fold = np.zeros(features.shape[0])\\n\\n # Lists for recording validation and training scores\\n valid_scores = []\\n train_scores = []\\n\\n # Iterate through each fold\\n for train_indices, valid_indices in k_fold.split(features):\\n # Training data for the fold\\n train_features, train_labels = features[train_indices], labels[train_indices]\\n # Validation data for the fold\\n valid_features, valid_labels = features[valid_indices], labels[valid_indices]\\n\\n # Create the model\\n model = lgb.LGBMClassifier(n_estimators=10000, objective='binary',\\n class_weight='balanced', learning_rate=0.05,\\n reg_alpha=0.1, reg_lambda=0.1,\\n subsample=0.8, n_jobs=-1, random_state=50)\\n\\n # Train the model\\n model.fit(train_features, train_labels, eval_metric='auc',\\n eval_set=[(valid_features, valid_labels), (train_features, train_labels)],\\n eval_names=['valid', 'train'], categorical_feature=cat_indices,\\n early_stopping_rounds=100, verbose=200)\\n\\n # Record the best iteration\\n best_iteration = model.best_iteration_\\n\\n # Record the feature importances\\n feature_importance_values += model.feature_importances_ / k_fold.n_splits\\n\\n # Make predictions\\n test_predictions += model.predict_proba(test_features, num_iteration=best_iteration)[:, 1] / k_fold.n_splits\\n\\n # Record the out of fold predictions\\n out_of_fold[valid_indices] = model.predict_proba(valid_features, num_iteration=best_iteration)[:, 1]\\n\\n # Record the best score\\n valid_score = model.best_score_['valid']['auc']\\n train_score = model.best_score_['train']['auc']\\n\\n valid_scores.append(valid_score)\\n train_scores.append(train_score)\\n\\n # Clean up memory\\n gc.enable()\\n del model, train_features, valid_features\\n gc.collect()\\n\\n # Make the submission dataframe\\n submission = pd.DataFrame({'SK_ID_CURR': test_ids, 'TARGET': test_predictions})\\n\\n # Make the feature importance dataframe\\n feature_importances = pd.DataFrame({'feature': feature_names, 'importance': feature_importance_values})\\n\\n # Overall validation score\\n valid_auc = roc_auc_score(labels, out_of_fold)\\n\\n # Add the overall scores to the metrics\\n valid_scores.append(valid_auc)\\n train_scores.append(np.mean(train_scores))\\n\\n # Needed for creating dataframe of validation scores\\n fold_names = list(range(n_folds))\\n fold_names.append('overall')\\n\\n # Dataframe of validation scores\\n metrics = pd.DataFrame({'fold': fold_names,\\n 'train': train_scores,\\n 'valid': valid_scores})\\n\\n return submission, feature_importances, metrics\",\n \"def build_model(train_inputs,train_labels,model_params,model_mode='classification',\\n model_type='naive_bayes'):\\n if model_mode == \\\"classification\\\":\\n if model_type == \\\"naive_bayes\\\":\\n model = GaussianNB()\\n if model_type == \\\"knn\\\":\\n model = KNeighborsClassifier(n_neighbors=50)\\n if model_type == \\\"svm\\\":\\n model = SVC(kernel='poly', degree =27, coef0 =1, C=5)\\n if model_type == \\\"decision_tree\\\":\\n model = DecisionTreeClassifier(min_samples_split=45,min_samples_leaf=45,criterion=\\\"gini\\\")\\n #model = RandomForestClassifier(n_estimators=500, n_jobs=-1)\\n\\n if model_mode == \\\"regression\\\":\\n if model_type == \\\"knn\\\":\\n model = KNeighborsRegressor()\\n if model_type == \\\"svm\\\":\\n model = SVR()\\n if model_type == \\\"decision_tree\\\":\\n model = DecisionTreeRegressor()\\n\\n\\n model.fit(train_inputs, train_labels)\\n # for name, score in zip(train_inputs.columns,model.feature_importances_):\\n # print(name, score)\\n\\n return model\",\n \"def predict():\\n if (not request.json):\\n abort(400)\\n \\n product = {\\n 'brand': request.json['brand'],\\n 'category-1': request.json['category-1'],\\n 'category-2': request.json['category-2'],\\n 'category-3': request.json['category-3'],\\n 'colour': request.json['colour'],\\n 'fabric_type': request.json['fabric_type'],\\n 'ftp_acrylic': request.json['ftp_acrylic'],\\n 'ftp_cotton': request.json['ftp_cotton'],\\n 'ftp_elastane': request.json['ftp_elastane'],\\n 'ftp_linen': request.json['ftp_linen'],\\n 'ftp_other': request.json['ftp_other'],\\n 'ftp_polyamide': request.json['ftp_polyamide'],\\n 'ftp_polyester': request.json['ftp_polyester'],\\n 'ftp_polypropylene': request.json['ftp_polypropylene'],\\n 'ftp_silk': request.json['ftp_silk'],\\n 'ftp_viscose': request.json['ftp_viscose'],\\n 'ftp_wool': request.json['ftp_wool'],\\n 'gender': request.json['gender'],\\n 'label': request.json['label'],\\n 'made_in': request.json['made_in'],\\n 'season': request.json['season'],\\n 'size': request.json['size'],\\n 'unspsc_code': request.json['unspsc_code'],\\n 'weight': request.json['weight'],\\n 'ML-model': request.json['ML-model']\\n }\\n\\n product['co2_total'] = None\\n ml_model = product.pop('ML-model', None)\\n if (ml_model == None or ml_model == ''):\\n print('Loading default model: LGBM')\\n ml_model = 'lgbm_default'\\n else:\\n print(f'Loading model: {ml_model}')\\n model = load_model(ml_model)\\n print('Model loaded')\\n \\n pred_with_intervals = do_prediction_with_params(model, product, intervals=True)\\n \\n prediction = pred_with_intervals[0][0]\\n percentile_5 = pred_with_intervals[0][1] if len(pred_with_intervals[0]) == 3 and pred_with_intervals[0][1] is not None else None\\n percentile_95 = pred_with_intervals[0][2] if len(pred_with_intervals[0]) == 3 and pred_with_intervals[0][2] is not None else None\\n result = {\\n \\\"prediction\\\": prediction,\\n \\\"5-percentile\\\": percentile_5,\\n \\\"95-percentile\\\": percentile_95\\n }\\n \\n print('CO2e prediction complete, returning result')\\n print(result)\\n \\n resp = jsonify(result)\\n resp.status_code = 201\\n return resp\",\n \"def predict(self, data):\\n\\t\\traise NotImplementedError\",\n \"def model_evaluate(query):\\n engine = create_engine('sqlite:///data/DisasterResponse.db')\\n df = pd.read_sql_table('Messages', engine)\\n\\n model = joblib.load(\\\"models/model.pkl\\\")\\n \\n classification_labels = model.predict([query])[0]\\n classification_results = dict(zip(df.columns[4:], classification_labels))\\n\\n return classification_labels, classification_results\",\n \"def classify(neural_net, image_file):\\n\\timg = Image.open(image_file)\\n\\timg.load()\\n\\timg_array = np.asarray(img)\\n\\timg_array.shape = (1, 100, 100, 3)\\n\\n\\tprediction = model.predict(img_array)[0][0]\\n\\treturn prediction\",\n \"def mlp_model2():\\n model = Sequential()\\n model.add(Dense(256, activation='relu', input_shape=(X_train_scaled.shape[1], )))\\n model.add(Dropout(0.2))\\n model.add(Dense(128, activation='relu'))\\n model.add(Dropout(0.2))\\n model.add(Dense(64, activation='relu'))\\n model.add(Dropout(0.2))\\n model.add(Dense(32, activation='relu'))\\n model.add(Dropout(0.2))\\n model.add(Dense(FLAGS.nb_classes, activation='softmax'))\\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\\n\\n model.summary()\\n return model\",\n \"def test_multifield_classify(self):\\n self.model.fit(self.text_data_train, self.train_targets)\\n self.assertTrue(self.model.is_classification)\\n predictions = self.model.predict(self.text_data_valid)\\n self.model.save(self.save_file)\\n model = LanguageModelGeneralAPI.load(self.save_file)\\n new_predictions = model.predict(self.text_data_valid)\\n for new_pred, old_pred in zip(new_predictions, predictions):\\n self.assertEqual(new_pred, old_pred)\",\n \"def read_labelmap_vidor(labelmap_file):\\n\\n labelmap = []\\n class_ids = set()\\n name = \\\"\\\"\\n class_id = \\\"\\\"\\n\\n with open('idx_to_pred.pkl', 'rb') as f:\\n idx_to_pred = pickle.load(f)\\n\\n # with PathManager.open(labelmap_file, \\\"r\\\") as f:\\n # import pdb; pdb.set_trace()\\n # for line in f:\\n # if line.startswith(\\\" name:\\\"):\\n # name = line.split('\\\"')[1]\\n # elif line.startswith(\\\" id:\\\") or line.startswith(\\\" label_id:\\\"):\\n # class_id = int(line.strip().split(\\\" \\\")[-1])\\n # labelmap.append({\\\"id\\\": class_id, \\\"name\\\": name})\\n # class_ids.add(class_id)\\n # return labelmap, class_ids\\n\\n \\\"\\\"\\\"\\n (Pdb) categories\\n [{'id': 1, 'name': 'bend/bow (at the waist)'}, {'id': 3, 'name': 'crouch/kneel'}, {'id': 4, 'name': 'dance'}, {'id': 5, 'name': 'fall down'}, {'id': 6, 'name': 'get up'}, {'id': 7, 'name': 'jump/leap'}, {'id': 8, 'name': 'lie/sleep'}, {'id': 9, 'name': 'martial art'}, {'id': 10, 'name': 'run/jog'}, {'id': 11, 'name': 'sit'}, {'id': 12, 'name': 'stand'}, {'id': 13, 'name': 'swim'}, {'id': 14, 'name': 'walk'}, {'id': 15, 'name': 'answer phone'}, {'id': 17, 'name': 'carry/hold (an object)'}, {'id': 20, 'name': 'climb (e.g., a mountain)'}, {'id': 22, 'name': 'close (e.g., a door, a box)'}, {'id': 24, 'name': 'cut'}, {'id': 26, 'name': 'dress/put on clothing'}, {'id': 27, 'name': 'drink'}, {'id': 28, 'name': 'drive (e.g., a car, a truck)'}, {'id': 29, 'name': 'eat'}, {'id': 30, 'name': 'enter'}, {'id': 34, 'name': 'hit (an object)'}, {'id': 36, 'name': 'lift/pick up'}, {'id': 37, 'name': 'listen (e.g., to music)'}, {'id': 38, 'name': 'open (e.g., a window, a car door)'}, {'id': 41, 'name': 'play musical instrument'}, {'id': 43, 'name': 'point to (an object)'}, {'id': 45, 'name': 'pull (an object)'}, {'id': 46, 'name': 'push (an object)'}, {'id': 47, 'name': 'put down'}, {'id': 48, 'name': 'read'}, {'id': 49, 'name': 'ride (e.g., a bike, a car, a horse)'}, {'id': 51, 'name': 'sail boat'}, {'id': 52, 'name': 'shoot'}, {'id': 54, 'name': 'smoke'}, {'id': 56, 'name': 'take a photo'}, {'id': 57, 'name': 'text on/look at a cellphone'}, {'id': 58, 'name': 'throw'}, {'id': 59, 'name': 'touch (an object)'}, {'id': 60, 'name': 'turn (e.g., a screwdriver)'}, {'id': 61, 'name': 'watch (e.g., TV)'}, {'id': 62, 'name': 'work on a computer'}, {'id': 63, 'name': 'write'}, {'id': 64, 'name': 'fight/hit (a person)'}, {'id': 65, 'name': 'give/serve (an object) to (a person)'}, {'id': 66, 'name': 'grab (a person)'}, {'id': 67, 'name': 'hand clap'}, {'id': 68, 'name': 'hand shake'}, {'id': 69, 'name': 'hand wave'}, {'id': 70, 'name': 'hug (a person)'}, {'id': 72, 'name': 'kiss (a person)'}, {'id': 73, 'name': 'lift (a person)'}, {'id': 74, 'name': 'listen to (a person)'}, {'id': 76, 'name': 'push (another person)'}, {'id': 77, 'name': 'sing to (e.g., self, a person, a group)'}, {'id': 78, 'name': 'take (an object) from (a person)'}, {'id': 79, 'name': 'talk to (e.g., self, a person, a group)'}, {'id': 80, 'name': 'watch (a person)'}]\\n (Pdb) class_whitelist\\n {1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 20, 22, 24, 26, 27, 28, 29, 30, 34, 36, 37, 38, 41, 43, 45, 46, 47, 48, 49, 51, 52, 54, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 72, 73, 74, 76, 77, 78, 79, 80}\\n \\\"\\\"\\\"\",\n \"def predict_class(self, original_image_numpy: np.ndarray) -> None:\\n from app.dl_model.image import ClassifierInput\\n # scale up coordinates\\n self.scale_up_coordinates()\\n x1, y1, x2, y2 = [int(coord) for coord in self.scale_coordinates.round()]\\n # crop original numpy image\\n numpy_image = original_image_numpy[y1:y2, x1:x2, :].copy()\\n # create classifier input object\\n classifier_input = ClassifierInput(numpy_image, new_shape=(224, 224))\\n # classify input\\n prediction = classifier_input.predict_class()\\n # set attributes\\n self.class_name = prediction.class_name # update class_name\\n self.conf = prediction.conf # update probability\\n self.product_id = prediction.product_id # set product external id\\n self.detection_index = prediction.detection_index # set detection index\\n self.top_k_names = prediction.top_k_names # set top k names list\\n self.top_k_indices = prediction.top_k_indices # set top k detection index\\n self.top_k_confidences = prediction.top_k_confidences # set top k confidieces values\\n self.top_k_product_ids = prediction.top_k_product_ids # set top k product external ids\",\n \"def get_classification(self, image):\\n # Image pre-processing pipleine\\n img = np.float32(image)\\n img = preprocess_input(img)\\n img = cv2.resize(img, (299, 299))\\n img = np.expand_dims(img, 0)\\n # Execute model's predictions - return probability value for each of 4 classes\\n probs = self.model.predict(img)[0]\\n # get class with max probability\\n g_x = np.argmax(probs)\\n\\n # reject if model is not confident about the prediction\\n if probs[g_x] < CONFIDENCE_THRESHOLD:\\n return TrafficLight.UNKNOWN\\n\\n # Swap label values as model was trained with different label values\\n if g_x == 2:\\n prediction = 0 # Red\\n elif g_x == 0:\\n prediction = 2 # Green\\n elif g_x == 3:\\n prediction = 1 # Yellow\\n else:\\n prediction = 3 # No light\\n\\n # Log the message\\n rospy.loginfo(\\\"The label returned is %d\\\", prediction)\\n\\n # Return the light state corresponding to the index\\n return prediction\",\n \"def prediction_on_a_image(self, input, output,model_saved_path):\\n\\n # load the saved model\\n if os.path.isfile(model_saved_path) is False:\\n raise IOError('trained model: %s not exist' % model_saved_path)\\n\\n clf = joblib.load(model_saved_path)\\n\\n # split a large image to many small ones\\n patch_w = 500 # parameters.get_digit_parameters(\\\"\\\", \\\"train_patch_width\\\", None, 'int')\\n patch_h = 500 # parameters.get_digit_parameters(\\\"\\\", \\\"train_patch_height\\\", None, 'int')\\n overlay_x = 0 # parameters.get_digit_parameters(\\\"\\\", \\\"train_pixel_overlay_x\\\", None, 'int')\\n overlay_y = 0 # parameters.get_digit_parameters(\\\"\\\", \\\"train_pixel_overlay_y\\\", None, 'int')\\n\\n img_folder = os.path.dirname(input)\\n img_name = os.path.basename(input)\\n inf_list_txt = 'inf_image_list.txt'\\n with open(inf_list_txt, 'w') as txt_obj:\\n txt_obj.writelines(img_name + '\\\\n')\\n\\n img_patches = build_RS_data.make_dataset(img_folder, inf_list_txt, patch_w, patch_h, overlay_x, overlay_y,\\n train=False)\\n\\n for img_idx, aImg_patches in enumerate(img_patches):\\n inf_output_dir = 'inf_results' #os.path.splitext(img_name)[0]\\n os.system('mkdir -p '+inf_output_dir)\\n os.system('rm '+inf_output_dir+'/*')\\n\\n ## parallel inference patches\\n # but it turns out not work due to the Pickle.PicklingError\\n # not working due to mulitple parameters. Jan 9, 2019, hlc\\n # use multiple thread\\n num_cores = multiprocessing.cpu_count()\\n print('number of thread %d' % num_cores)\\n # theadPool = mp.Pool(num_cores) # multi threads, can not utilize all the CPUs? not sure hlc 2018-4-19\\n theadPool = Pool(num_cores) # multi processes\\n\\n # inference_one_patch_svm(img_idx, image_count, p_idx, patch_count, inf_output_dir, img_patch, scaler,clf)\\n\\n parameters_list = [\\n (img_idx, len(img_patches), idx, len(aImg_patches), inf_output_dir, img_patch, self._scaler, clf)\\n for (idx, img_patch) in enumerate(aImg_patches)]\\n # results = theadPool.map(inference_one_patch_svm, parameters_list) # not working\\n results = theadPool.starmap(inference_one_patch_svm, parameters_list) # need python3\\n print('result_list', results)\\n\\n # for p_idx, img_patch in enumerate(aImg_patches):\\n # # read images\\n # patch_data = build_RS_data.read_patch(img_patch) # read_whole_x_pixels(input)\\n #\\n # nbands, height, width = patch_data.shape\\n #\\n # X_predit = patch_data.reshape(nbands, -1)\\n # X_predit = np.transpose(X_predit, (1, 0))\\n #\\n # if os.path.isfile(scaler_saved_path) and self._scaler is None:\\n # self._scaler = joblib.load(scaler_saved_path)\\n # result = self._scaler.transform(X_predit)\\n # X = result.tolist()\\n # elif self._scaler is not None:\\n # result = self._scaler.transform(X_predit)\\n # X = result.tolist()\\n # else:\\n # X = X_predit\\n # basic.outputlogMessage('warning, no pre-processing of data before prediction')\\n #\\n # # more method on prediction can be foudn in :\\n # # https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html\\n # pre_result = clf.predict(X)\\n # result_img = pre_result.reshape((height, width))\\n #\\n # # save results\\n # print('Save patch:%d/%d on Image:%d/%d , shape:(%d,%d)' %\\n # (p_idx,len(aImg_patches), img_idx,len(img_patches), result_img.shape[0], result_img.shape[1]))\\n #\\n # # short the file name to avoid error of \\\" Argument list too long\\\", hlc 2018-Oct-29\\n # file_name = \\\"I%d_%d\\\" % (img_idx, p_idx)\\n #\\n # save_path = os.path.join(inf_output_dir, file_name + '.tif')\\n # build_RS_data.save_patch_oneband_8bit(img_patch,result_img.astype(np.uint8),save_path)\\n #\\n # with rasterio.open(input) as src_obj:\\n # # Set spatial characteristics of the output object to mirror the input\\n # kwargs = src_obj.meta\\n # kwargs.update(\\n # dtype=rasterio.uint8,\\n # count=1)\\n # # Create the file\\n # with rasterio.open(output, 'w', **kwargs) as dst:\\n # dst.write_band(1, result_img.astype(rasterio.uint8))\\n # basic.outputlogMessage(\\\"save to %s\\\" % output)\\n\\n return True\",\n \"def mlp_model():\\n\\tmodel = Sequential()\\n\\tmodel.add(Dense(256, activation='relu', input_shape=(X_train_scaled.shape[1], )))\\n\\tmodel.add(Dropout(0.4))\\n\\tmodel.add(Dense(256, activation='relu'))\\n\\tmodel.add(Dropout(0.4))\\n\\tmodel.add(Dense(FLAGS.nb_classes, activation='softmax'))\\n\\tmodel.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\\n\\n\\tmodel.summary()\\n\\treturn model\",\n \"def predict_classification_net(X_test, image_name):\\n\\t# Load training data mean \\n\\tmeans = np.load(PATH + 'Datasets/means_classification.npy')\\n\\t# Zero center\\n\\tX_test -= means\\n\\t# Create model\\n\\tmodel = build_classif_net()\\n\\t# Load weights\\n\\tmodel.load_weights(PATH + 'Weights/weights_classification_net.hdf5')\\n\\t# Compile model\\n\\tmodel.compile(loss='categorical_crossentropy', optimizer='Adam', metrics=['accuracy'])\\n\\t# Predict model\\n\\tscores = model.predict(X_test)\\n\\t# Get indexes of the windows labeled as sealions (0 because sealions are [1 0])\\n\\tprediction = np.argmax(scores, axis=1)\\n\\n\\tnp.save(PATH + 'Results/classification_'+ image_name + '.npy', prediction)\\n\\treturn prediction\",\n \"def make_predictions(self):\\n if is_classification(self.model):\\n if self.ct == None:\\n prediction = self.model.predict(self.input_data.to_numpy())\\n probabilities = self.model.predict_proba(self.input_data.to_numpy())\\n return prediction, probabilities\\n elif self.ct != None: \\n prediction = self.model.predict(self.data_into_model())\\n probabilities = self.model.predict_proba(self.data_into_model())\\n return prediction, probabilities\\n else:\\n raise Exception((\\\"{} not supported. Please create an issue on Github\\\").format(self.model))\\n \\n else:\\n if self.ct == None:\\n prediction = self.model.predict(self.input_data)\\n return prediction\\n elif self.ct != None: \\n prediction = self.model.predict(self.data_into_model())\\n return prediction\\n else:\\n raise Exception((\\\"{} not supported. Please create an issue on Github\\\").format(self.self.model))\",\n \"def run_mapper():\\n print(blue + \\\"\\\\n>>> \\\" + reset + \\\"Executing the model mapper...\\\")\\n\\n cmdb_ci_types = cmdb_data_model.cmdb_data_model.get(\\\"ci_types\\\")\\n cmdb_rel_types = cmdb_data_model.cmdb_data_model.get(\\\"rel_types\\\")\\n cmdb_ci_attributes = cmdb_data_model.cmdb_data_model.get(\\\"ci_attributes\\\")\\n cmdb_rel_attributes = cmdb_data_model.cmdb_data_model.get(\\\"rel_attributes\\\")\\n\\n db_ci_types = db_data_model.db_data_model.get(\\\"ci_types\\\")\\n db_rel_types = db_data_model.db_data_model.get(\\\"rel_types\\\")\\n db_ci_attributes = db_data_model.db_data_model.get(\\\"ci_attributes\\\")\\n db_rel_attributes = db_data_model.db_data_model.get(\\\"rel_attributes\\\")\\n\\n print(blue + \\\"\\\\n>>> \\\" + reset +\\n \\\"Calculating configuration item types similarity...\\\")\\n ci_similarity = calculate_class_similarity(cmdb_ci_types, db_ci_types)\\n\\n new_ci_similarity = {}\\n for key in ci_similarity:\\n new_ci_similarity[key] = {k: v for k, v in sorted(\\n ci_similarity.get(key).items(), key=lambda item: item[1], reverse=True)}\\n order = {}\\n for key in new_ci_similarity:\\n if len(new_ci_similarity.get(key)) > 0:\\n order[key] = new_ci_similarity.get(key).get(\\n list(new_ci_similarity.get(key).keys())[0])\\n order = {k: v for k, v in sorted(\\n order.items(), key=lambda item: item[1], reverse=True)}\\n ci_similarity = {}\\n for key in order:\\n ci_similarity[key] = new_ci_similarity.get(key)\\n\\n similar_ci = select_most_similar(ci_similarity, {}, [])\\n new_similar_ci = {}\\n for key in similar_ci:\\n if len(similar_ci.get(key)) > 0:\\n new_similar_ci[key] = similar_ci.get(key)\\n similar_ci = new_similar_ci\\n\\n print(blue + \\\"\\\\n>>> \\\" + reset + \\\"Calculating relationship types similarity...\\\")\\n rel_similarity = calculate_class_similarity(cmdb_rel_types, db_rel_types)\\n\\n new_rel_similarity = {}\\n for key in rel_similarity:\\n new_rel_similarity[key] = {k: v for k, v in sorted(\\n rel_similarity.get(key).items(), key=lambda item: item[1], reverse=True)}\\n order = {}\\n for key in new_rel_similarity:\\n if len(new_rel_similarity.get(key)) > 0:\\n order[key] = new_rel_similarity.get(key).get(\\n list(new_rel_similarity.get(key).keys())[0])\\n order = {k: v for k, v in sorted(\\n order.items(), key=lambda item: item[1], reverse=True)}\\n rel_similarity = {}\\n for key in order:\\n rel_similarity[key] = new_rel_similarity.get(key)\\n\\n similar_rel = select_most_similar(rel_similarity, {}, [])\\n new_similar_rel = {}\\n for key in similar_rel:\\n if len(similar_rel.get(key)) > 0:\\n new_similar_rel[key] = similar_rel.get(key)\\n similar_rel = new_similar_rel\\n\\n print(blue + \\\"\\\\n>>> \\\" + reset +\\n \\\"Calculating configuration item attributes similarity...\\\")\\n attr_ci_similarity = calculate_attribute_similarity(\\n similar_ci, cmdb_ci_attributes, db_ci_attributes)\\n\\n new_attr_ci_similarity = {}\\n for cmdb_t in attr_ci_similarity:\\n new_attr_ci_similarity[cmdb_t] = {}\\n for key in attr_ci_similarity.get(cmdb_t):\\n new_attr_ci_similarity[cmdb_t][key] = {k: v for k, v in sorted(\\n attr_ci_similarity.get(cmdb_t).get(key).items(), key=lambda item: item[1], reverse=True)}\\n\\n order = {}\\n for cmdb_t in new_attr_ci_similarity:\\n order[cmdb_t] = {}\\n for key in new_attr_ci_similarity.get(cmdb_t):\\n if len(new_attr_ci_similarity.get(cmdb_t).get(key)) > 0:\\n order[cmdb_t][key] = new_attr_ci_similarity.get(cmdb_t).get(key).get(\\n list(new_attr_ci_similarity.get(cmdb_t).get(key).keys())[0])\\n for o in order:\\n order[o] = {k: v for k, v in sorted(\\n order.get(o).items(), key=lambda item: item[1], reverse=True)}\\n\\n attr_ci_similarity = {}\\n for o in order:\\n attr_ci_similarity[o] = {}\\n for key in order.get(o):\\n attr_ci_similarity[o][key] = new_attr_ci_similarity.get(o).get(key)\\n\\n similar_attr_ci = {x: select_most_similar(\\n attr_ci_similarity.get(x), {}, []) for x in attr_ci_similarity}\\n\\n new_similar_attr_ci = {}\\n for key in similar_attr_ci:\\n if len(similar_attr_ci.get(key)) > 0:\\n new_similar_attr_ci[key] = similar_attr_ci.get(key)\\n similar_attr_ci = new_similar_attr_ci\\n\\n print(blue + \\\"\\\\n>>> \\\" + reset +\\n \\\"Calculating relationship attributes similarity...\\\")\\n attr_rel_similarity = calculate_attribute_similarity(\\n similar_rel, cmdb_rel_attributes, db_rel_attributes)\\n\\n new_attr_rel_similarity = {}\\n for cmdb_t in attr_rel_similarity:\\n new_attr_rel_similarity[cmdb_t] = {}\\n for key in attr_rel_similarity.get(cmdb_t):\\n new_attr_rel_similarity[cmdb_t][key] = {k: v for k, v in sorted(\\n attr_rel_similarity.get(cmdb_t).get(key).items(), key=lambda item: item[1], reverse=True)}\\n\\n order = {}\\n for cmdb_t in new_attr_rel_similarity:\\n order[cmdb_t] = {}\\n for key in new_attr_rel_similarity.get(cmdb_t):\\n if len(new_attr_rel_similarity.get(cmdb_t).get(key)) > 0:\\n order[cmdb_t][key] = new_attr_rel_similarity.get(cmdb_t).get(key).get(\\n list(new_attr_rel_similarity.get(cmdb_t).get(key).keys())[0])\\n for o in order:\\n order[o] = {k: v for k, v in sorted(\\n order.get(o).items(), key=lambda item: item[1], reverse=True)}\\n\\n attr_rel_similarity = {}\\n for o in order:\\n attr_rel_similarity[o] = {}\\n for key in order.get(o):\\n attr_rel_similarity[o][key] = new_attr_rel_similarity.get(\\n o).get(key)\\n\\n similar_attr_rel = {x: select_most_similar(\\n attr_rel_similarity.get(x), {}, []) for x in attr_rel_similarity}\\n\\n new_similar_attr_rel = {}\\n for key in similar_attr_rel:\\n if len(similar_attr_rel.get(key)) > 0:\\n new_similar_attr_rel[key] = similar_attr_rel.get(key)\\n similar_attr_rel = new_similar_attr_rel\\n\\n present_map(cmdb_ci_types, db_ci_types, cmdb_rel_types, db_rel_types, cmdb_ci_attributes, db_ci_attributes, cmdb_rel_attributes, db_rel_attributes, similar_ci, similar_rel,\\n similar_attr_ci, similar_attr_rel)\\n\\n threshold = ask_for_threshold()\\n\\n define_rules(float(threshold), similar_ci, similar_rel,\\n similar_attr_ci, similar_attr_rel)\",\n \"def main(image, model_dir):\\n model_file, signature = get_model_and_sig(model_dir)\\n interpreter = load_model(model_dir + model_file)\\n prediction = get_prediction(image, interpreter, signature)\\n # get list of confidences from prediction\\n confidences = list(prediction.values())[0]\\n # get the label name for the predicted class\\n labels = signature.get(\\\"classes\\\").get(\\\"Label\\\")\\n max_confidence = max(confidences)\\n prediction[\\\"Prediction\\\"] = labels[confidences.index(max_confidence)]\\n return prediction\",\n \"def proba_redefined_predict(model,X,weigh,classes=string.ascii_lowercase):\\n\\n y_proba=model.predict_proba(X)\\n tuned=renorm(y_proba,weigh)\\n y_max_arg=tuned.argmax(axis=1)\\n predict=to_class(y_max_arg,classes)\\n \\n return predict\",\n \"def main():\\n # initialize the class labels and set the seed of the pseudorandom\\n # number generator so we can reproduce our results\\n labels = [\\\"dog\\\", \\\"cat\\\", \\\"panda\\\"]\\n np.random.seed(1)\\n\\n # be * learned * by our model, but for the sake of this example, let's use random values\\n W = np.random.randn(3, 3072)\\n b = np.random.randn(3)\\n\\n # load our example image, resize it, and then flatten it into our\\n # \\\"feature vector\\\" representation\\n orig = cv2.imread(\\\"beagle.png\\\")\\n image = cv2.resize(orig, (32, 32)).flatten()\\n\\n # compute the output scores by taking the dot product between the\\n # weight matrix and image pixels, followed by adding in the b\\n scores = W.dot(image) + b\\n\\n # loop over the scores + labels and display them\\n for (label, score) in zip(labels, scores):\\n print(\\\"[INFO] {}: {:.2f}\\\".format(label, score))\\n\\n # draw the label with the highest score on the image as our prediction\\n cv2.putText(\\n orig, \\\"Label: {}\\\".format(labels[np.argmax(scores)]), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2\\n )\\n\\n # display our input image\\n cv2.imshow(\\\"Image\\\", orig)\\n cv2.waitKey(0)\",\n \"def mid_term_file_classification(input_file, model_name, model_type,\\n plot_results=False, gt_file=\\\"\\\"):\\n labels = []\\n accuracy = 0.0\\n class_names = []\\n cm = np.array([])\\n if not os.path.isfile(model_name):\\n print(\\\"mtFileClassificationError: input model_type not found!\\\")\\n return labels, class_names, accuracy, cm\\n\\n # Load classifier:\\n if model_type == \\\"knn\\\":\\n classifier, mean, std, class_names, mt_win, mid_step, st_win, \\\\\\n st_step, compute_beat = at.load_model_knn(model_name)\\n else:\\n classifier, mean, std, class_names, mt_win, mid_step, st_win, \\\\\\n st_step, compute_beat = at.load_model(model_name)\\n if compute_beat:\\n print(\\\"Model \\\" + model_name + \\\" contains long-term music features \\\"\\n \\\"(beat etc) and cannot be used in \\\"\\n \\\"segmentation\\\")\\n return labels, class_names, accuracy, cm\\n # load input file\\n sampling_rate, signal = audioBasicIO.read_audio_file(input_file)\\n\\n # could not read file\\n if sampling_rate == 0:\\n return labels, class_names, accuracy, cm\\n\\n # convert stereo (if) to mono\\n signal = audioBasicIO.stereo_to_mono(signal)\\n\\n # mid-term feature extraction:\\n mt_feats, _, _ = \\\\\\n mtf.mid_feature_extraction(signal, sampling_rate,\\n mt_win * sampling_rate,\\n mid_step * sampling_rate,\\n round(sampling_rate * st_win),\\n round(sampling_rate * st_step))\\n posterior_matrix = []\\n\\n # for each feature vector (i.e. for each fix-sized segment):\\n for col_index in range(mt_feats.shape[1]):\\n # normalize current feature v\\n feature_vector = (mt_feats[:, col_index] - mean) / std\\n\\n # classify vector:\\n label_predicted, posterior = \\\\\\n at.classifier_wrapper(classifier, model_type, feature_vector)\\n labels.append(label_predicted)\\n\\n # update probability matrix\\n posterior_matrix.append(np.max(posterior))\\n labels = np.array(labels)\\n\\n # convert fix-sized flags to segments and classes\\n segs, classes = labels_to_segments(labels, mid_step)\\n segs[-1] = len(signal) / float(sampling_rate)\\n # Load grount-truth:\\n labels_gt, class_names_gt, accuracy, cm = \\\\\\n load_ground_truth(gt_file, labels, class_names, mid_step, plot_results)\\n\\n return labels, class_names, accuracy, cm\",\n \"def predict_dense(train_xml_dir):\\n\\n cfg = configparser.ConfigParser()\\n cfg.read(sys.argv[1])\\n base = os.environ['DATA_ROOT']\\n alphabet_pickle=cfg.get('data', 'alphabet_pickle')\\n test_xml_dir = os.path.join(base, cfg.get('data', 'test_xml_dir'))\\n test_cui_dir = os.path.join(base, cfg.get('data', 'test_cui_dir'))\\n\\n # load pre-trained model\\n model = load_model(cfg.get('data', 'model_file'))\\n interm_layer_model = Model(\\n inputs=model.input,\\n outputs=model.get_layer('HL').output)\\n\\n for f in os.listdir(test_cui_dir):\\n file_path = os.path.join(test_cui_dir, f)\\n int_seq = dataset.load_one_file_for_keras(file_path, alphabet_pickle)\\n\\n category2label = {}\\n # run this file through the model for each selection criterion\\n for category in n2b2.get_category_names(train_xml_dir):\\n\\n # could not train model; always predict 'not met'\\n if category == 'KETO-1YR':\\n category2label[category] = 'not met'\\n print('file: %s, crit: %s, label: %s' % (f, category, 'not met'))\\n continue\\n\\n maxlen = cfg.getint('data', 'maxlen')\\n x = pad_sequences([int_seq], maxlen=maxlen)\\n x = interm_layer_model.predict(x)\\n\\n classifier_pickle = 'Model/%s.clf' % category\\n classifier = pickle.load(open(classifier_pickle, 'rb'))\\n prediction = classifier.predict(x)\\n label = dataset.INT2LABEL[prediction[0]]\\n\\n category2label[category] = label\\n print('file: %s, crit: %s, label: %s' % (f, category, label))\\n\\n xml_file_name = f.split('.')[0] + '.xml'\\n xml_file_path = os.path.join(test_xml_dir, xml_file_name)\\n n2b2.write_category_labels(xml_file_path, category2label)\\n print()\",\n \"def predict():\\n\\n\\n json_payload = request.json\\n #LOG.info(f\\\"JSON payload: %s\\\" %json_payload)\\n inference_payload = pd.DataFrame(json_payload)\\n #LOG.info(\\\"inference payload DataFrame: %s\\\" %inference_payload)\\n scaled_payload = scale(inference_payload)\\n prediction = list(clf.predict(scaled_payload))\\n return jsonify({'prediction': prediction})\",\n \"def _classify(tree, x):\\n # YOUR CODE HERE\\n # begin answer\\n feature_name=list(tree.keys())[0] #first element\\n secondDict=tree[feature_name] \\n key=x.loc[feature_name] #extract value from x\\n for key_val in secondDict:\\n feature_val=key_val[0]\\n valueOfKey=secondDict[(feature_val, key>=feature_val)]\\n if isinstance(valueOfKey,dict):\\n label=_classify(valueOfKey,x)\\n else:\\n label=valueOfKey\\n return label\\n # end answer\",\n \"def predict(self, datum):\\r\\n probs = {}\\r\\n for class_ in set(self.train_classes):\\r\\n probs[class_] = self.distribution.class_prob[class_] * reduce(lambda x,y:x*y, [self.distribution.prob(feat_ind_feat[0],feat_ind_feat[1],class_) for feat_ind_feat in enumerate(datum)])\\r\\n return max(probs, key=lambda x:probs[x])\",\n \"def make_model():\\n \\n model = models.Sequential()\\n model.add(layers.Conv2D(32, (3, 3), activation='relu',\\n input_shape=(150, 150, 3)))\\n model.add(layers.MaxPooling2D((2, 2)))\\n model.add(layers.Conv2D(64, (3, 3), activation='relu'))\\n model.add(layers.MaxPooling2D((2, 2)))\\n model.add(layers.Conv2D(128, (3, 3), activation='relu'))\\n model.add(layers.MaxPooling2D((2, 2)))\\n model.add(layers.Conv2D(128, (3, 3), activation='relu'))\\n model.add(layers.MaxPooling2D((2, 2)))\\n model.add(layers.Flatten())\\n model.add(layers.Dense(512, activation='relu'))\\n model.add(layers.Dense(37, activation='softmax'))\\n \\n #model.add(layers.Dense(1, activation='sigmoid'))\\n \\n\\n model.compile(loss='sparse_categorical_crossentropy',\\n optimizer=optimizers.RMSprop(lr=1e-4),\\n metrics=['acc'])\\n return model\",\n \"def classify(self, example):\\n raise NotImplementedError()\",\n \"def multiclass_model_dict(num_class: int) -> dict:\\n return {\\n \\\"LogisticRegression\\\": createModel(\\n \\\"LogisticRegression\\\",\\n \\\"multiclass\\\",\\n num_class=num_class,\\n multi_class=\\\"multinomial\\\",\\n solver=\\\"lbfgs\\\",\\n max_iter=1000,\\n ),\\n \\\"GaussianNB\\\": createModel(\\\"GaussianNB\\\", \\\"multiclass\\\", num_class=num_class),\\n \\\"KNeighborsClassifier\\\": createModel(\\n \\\"KNeighborsClassifier\\\", \\\"multiclass\\\", num_class=num_class\\n ),\\n \\\"DecisionTreeClassifier\\\": createModel(\\n \\\"DecisionTreeClassifier\\\", \\\"multiclass\\\", num_class=num_class\\n ),\\n \\\"ExtraTreesClassifier\\\": createModel(\\n \\\"ExtraTreesClassifier\\\", \\\"multiclass\\\", num_class=num_class, n_estimators=100\\n ),\\n \\\"RandomForestClassifier\\\": createModel(\\n \\\"RandomForestClassifier\\\",\\n \\\"multiclass\\\",\\n num_class=num_class,\\n n_estimators=100,\\n ),\\n \\\"XGBoost\\\": createModel(\\n \\\"XGBoostBinary\\\", \\\"multiclass\\\", num_class=num_class, num_boost_round=100\\n ),\\n \\\"LightGBM\\\": createModel(\\n \\\"LightGBMBinary\\\", \\\"multiclass\\\", num_class=num_class, num_boost_round=100\\n ),\\n }\",\n \"def classification(original_training_data):\\n\\n ''' Storing the dataframe as numpy array '''\\n original_training_data_values = original_training_data.values\\n\\n ''' Storing the values of target attribute for finding out the counts of each recipetype'''\\n target_column = original_training_data_values[:, -1]\\n\\n ''' Recipe_type stores the unique values of target attribute in the form of a list [Muffin Cupcake] \\n cupcake_muffin_count stores the count of muffin and cupcakes in the form of a list [451 451]'''\\n recipe_type, cupcake_muffin_count = np.unique(target_column, return_counts=True)\\n\\n ''' cupcake_muffin_count.argmax() returns the index of the highest value. In this case, it will return the index of \\n muffin or cupcake count. '''\\n majority_class = recipe_type[cupcake_muffin_count.argmax()]\\n\\n return majority_class\",\n \"def classify(strings: List[str], params: Any) -> List[str]:\\n \\n # ############################ REPLACE THIS WITH YOUR CODE #############################\\n def predict_one_sample(sample, train_dict, ngram_lvl=1):\\n ngrams = [sample[i:i+ngram_lvl] for i in\",\n \"def _predict(self, X):\\n predictions = np.asarray([clf.predict(X) for clf in self.clfs_]).T\\n predicted_labels = self.combiner.combine(predictions)\\n return predicted_labels\",\n \"def train_self(self):\\n # for each numeric column, we need to record mean and std for both classes\\n for col in self.num_cols:\\n self.prob_hub[col] = {}\\n for claz in self.class_list:\\n mean, std = get_mean_std(self.data[self.data[self.class_column] == claz][col])\\n self.prob_hub[col][claz] = (mean, std)\\n\\n # for each categorical columns, we need to record P(X=x|Y=y)\\n for col in self.cat_cols:\\n ulist = unique_list(self.data[col])\\n self.prob_hub[col] = {}\\n stat = self.data.groupby(self.class_column)[col].value_counts() / self.data.groupby(self.class_column)[col].count()\\n # for each class\\n for claz in self.class_list:\\n self.prob_hub[col][claz] = {}\\n for uni_element in ulist:\\n self.prob_hub[col][claz][uni_element] = stat[claz][uni_element]\\n\\n self.predict(self.data, True)\",\n \"def predict(self, data):\\n xdata, _ = self.array_from_cases(data)\\n preds = self.model.predict(xdata)\\n label_preds = [dict(zip(self.binarizer.classes_, pred)) for pred in preds]\\n return label_preds\",\n \"def svc_classify(self, filename):\\n tokens = preprocess.parse_book(filename)\\n perplexities = [m.perplexity(tokens) for m in self.models]\\n return self.genres[self.svc.predict(perplexities)]\",\n \"def classify(new_music,fit):\\n\\tr = robjects.r\\n\\tp = prob_category(new_music,fit)\\n\\trobjects.globalenv[\\\"pred\\\"] = p\\n\\tr(\\\"\\\"\\\"\\n\\ttmp3 = vector()\\n\\tfor(i in 1:length(pred[,1])){\\n\\t\\txx <- unlist(pred[i,])\\n\\t\\ttmp3 <- append(tmp3,which(xx==max(xx)))\\n\\t}\\n\\tclasses <- names(tmp3)\\n\\t\\\"\\\"\\\")\\n\\treturn list(robjects.globalenv[\\\"classes\\\"])\",\n \"def classify(self):\\n\\n if self.classifier is None:\\n raise ValueError('self.classifier is None')\\n if self.df is None:\\n raise ValueError('self.df is None')\\n if self.features is None:\\n raise ValueError('self.features is None')\\n\\n train_set = self.df[self.df[self.label_col] != CLASSIFIER_NAN]\\n test_set = self.df[self.df[self.label_col] == CLASSIFIER_NAN]\\n\\n test_set_timestamps = list(test_set.index.strftime('%Y-%m-%d %H:%M:%S.%f'))\\n\\n self.classifier.fit(\\n train_set[self.features],\\n train_set[self.label_col]\\n )\\n\\n preds = self.classifier.predict(test_set[self.features])\\n probs = self.classifier.predict_proba(test_set[self.features])\\n\\n res = []\\n\\n for i in range(0, len(preds)):\\n probability = max(probs[i])\\n res.append([test_set_timestamps[i], preds[i], probability])\\n\\n return res\",\n \"def classify(data, labels, (train_idx, test_idx), classifier=None):\\r\\n\\r\\n assert classifier is not None, \\\"Why would you pass not classifier?\\\"\\r\\n\\r\\n # Data scaling based on training set\\r\\n scaler = SupervisedStdScaler() #SupervisedRobustScaler() # # \\r\\n scaler.fit(data[train_idx,:], labels[train_idx], label=-1)\\r\\n #scaler.fit(data[train_idx,:], labels[train_idx])\\r\\n data_train = scaler.transform(data[train_idx,:])\\r\\n data_test = scaler.transform(data[test_idx,:])\\r\\n try:\\r\\n classifier.fit(data_train, labels[train_idx])\\r\\n \\r\\n \\r\\n confMat = confusion_matrix(labels[test_idx],\\r\\n classifier.predict(data_test))\\r\\n if confMat.shape == (1,1):\\r\\n if all(labels[test_idx] == -1):\\r\\n confMat = np.array([[confMat[0], 0], [0, 0]], dtype=confMat.dtype)\\r\\n else:\\r\\n confMat = np.array([[0, 0], [0, confMat[0]]], dtype=confMat.dtype)\\r\\n confMatRate = confMat / np.tile(np.sum(confMat, axis=1).astype('float'), (2,1)).transpose()\\r\\n totalErr = (confMat[0, 1] + confMat[1, 0]) / float(confMat.sum())\\r\\n #if type(classifier) not in [type(None), DummyClassifier]:\\r\\n if hasattr(classifier,'param_grid'): \\r\\n #isinstance(classifier, GridSearchCV) or \\\\\\r\\n # isinstance(classifier, RandomizedSearchCV):\\r\\n fitted_model = classifier.best_estimator_\\r\\n else:\\r\\n fitted_model = copy.copy(classifier) \\r\\n return confMatRate, totalErr, fitted_model\\r\\n except np.linalg.linalg.LinAlgError as e:\\r\\n # sahil added statement to raise the error instead of returning nun values\\r\\n print e.message\\r\\n raise e\\r\\n # return np.array([[np.nan, np.nan], [np.nan, np.nan]]), np.nan, None\\r\",\n \"def gen_latent( model, dset, data_class ):\\n dd = {}\\n\\n for dpath, dnames, fnames in os.walk( dset ):\\n for f in fnames:\\n if f.endswith( '.jpg' ) and data_class in f:\\n n = f.split( '.' )[ 0 ] # code name of frame\\n l = ts.pred_image( model, os.path.join( dpath, f ) ) # output of encoder\\n dd[ n ] = l\\n if DEBUG: print( n )\\n\\n return dd\",\n \"def predict(self, X):\\n\\n ### TODO: YOUR CODE HERE\\n D = shape(X)\\n if self.isLeaf:\\n return self.label\\n else:\\n if ( X[self.feature] <= 0.5 ):\\n return self.left.predict(X)\\n else:\\n return self.right.predict(X)\",\n \"def trainNet():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6690187","0.64756536","0.6441268","0.6374809","0.63580745","0.6353296","0.6329436","0.6312559","0.6221688","0.6219069","0.6196666","0.618929","0.6177566","0.61771584","0.6163415","0.6138004","0.6116106","0.6072633","0.60633653","0.6055231","0.60338527","0.60123473","0.60123473","0.59956723","0.5969741","0.5956196","0.5955052","0.59507334","0.59500355","0.5949682","0.5948381","0.5943787","0.5939479","0.59213114","0.5896959","0.58790636","0.5872547","0.58615947","0.5858837","0.58531165","0.58526385","0.5836624","0.58350515","0.5829671","0.5826851","0.5826698","0.5826687","0.58105975","0.58061486","0.5800202","0.57986355","0.57909983","0.5777208","0.5777208","0.5777208","0.5773893","0.5772153","0.57695454","0.5764254","0.5764254","0.5759726","0.57591015","0.57507473","0.5749179","0.5747206","0.5743086","0.57374233","0.5730754","0.57219243","0.5718653","0.5713717","0.57123256","0.57098854","0.57061315","0.5699848","0.56960905","0.5695655","0.5692597","0.5692537","0.56922895","0.56912535","0.56902933","0.5675411","0.56727105","0.56715715","0.5670365","0.5669546","0.5669135","0.5660767","0.5656856","0.56536454","0.5652254","0.5652111","0.56508857","0.56499803","0.56493795","0.5648627","0.56417316","0.5639635","0.5634452","0.56292117"],"string":"[\n \"0.6690187\",\n \"0.64756536\",\n \"0.6441268\",\n \"0.6374809\",\n \"0.63580745\",\n \"0.6353296\",\n \"0.6329436\",\n \"0.6312559\",\n \"0.6221688\",\n \"0.6219069\",\n \"0.6196666\",\n \"0.618929\",\n \"0.6177566\",\n \"0.61771584\",\n \"0.6163415\",\n \"0.6138004\",\n \"0.6116106\",\n \"0.6072633\",\n \"0.60633653\",\n \"0.6055231\",\n \"0.60338527\",\n \"0.60123473\",\n \"0.60123473\",\n \"0.59956723\",\n \"0.5969741\",\n \"0.5956196\",\n \"0.5955052\",\n \"0.59507334\",\n \"0.59500355\",\n \"0.5949682\",\n \"0.5948381\",\n \"0.5943787\",\n \"0.5939479\",\n \"0.59213114\",\n \"0.5896959\",\n \"0.58790636\",\n \"0.5872547\",\n \"0.58615947\",\n \"0.5858837\",\n \"0.58531165\",\n \"0.58526385\",\n \"0.5836624\",\n \"0.58350515\",\n \"0.5829671\",\n \"0.5826851\",\n \"0.5826698\",\n \"0.5826687\",\n \"0.58105975\",\n \"0.58061486\",\n \"0.5800202\",\n \"0.57986355\",\n \"0.57909983\",\n \"0.5777208\",\n \"0.5777208\",\n \"0.5777208\",\n \"0.5773893\",\n \"0.5772153\",\n \"0.57695454\",\n \"0.5764254\",\n \"0.5764254\",\n \"0.5759726\",\n \"0.57591015\",\n \"0.57507473\",\n \"0.5749179\",\n \"0.5747206\",\n \"0.5743086\",\n \"0.57374233\",\n \"0.5730754\",\n \"0.57219243\",\n \"0.5718653\",\n \"0.5713717\",\n \"0.57123256\",\n \"0.57098854\",\n \"0.57061315\",\n \"0.5699848\",\n \"0.56960905\",\n \"0.5695655\",\n \"0.5692597\",\n \"0.5692537\",\n \"0.56922895\",\n \"0.56912535\",\n \"0.56902933\",\n \"0.5675411\",\n \"0.56727105\",\n \"0.56715715\",\n \"0.5670365\",\n \"0.5669546\",\n \"0.5669135\",\n \"0.5660767\",\n \"0.5656856\",\n \"0.56536454\",\n \"0.5652254\",\n \"0.5652111\",\n \"0.56508857\",\n \"0.56499803\",\n \"0.56493795\",\n \"0.5648627\",\n \"0.56417316\",\n \"0.5639635\",\n \"0.5634452\",\n \"0.56292117\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":92897,"cells":{"query":{"kind":"string","value":"Initialize data generators. This function assumes the wrapped model to have `._data` field."},"document":{"kind":"string","value":"def initialize_data_iterator(self, model_idx=None):\n if model_idx and not isinstance(model_idx, (list, tuple)):\n raise TypeError(\"`model_idx` must be list-like structure\")\n\n model_indices = (\n # if model_idx is None\n # model_idx = [all_models_indices]\n model_idx if model_idx is not None\n else range(self.num_models))\n\n for idx in model_indices:\n try:\n print(\"Initializing %d data\" % idx)\n self._sess.run(self._data[idx].initializer)\n except AttributeError:\n # wraps the error with more informative message\n raise AttributeError(\"Model #%d has no `_data` attribute\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def init_model(self):\n pass","def initialize_model(self):\n pass","def initialize(self, model):\n pass","def init_from_data(self, data):\n self.data = data\n self.norm_data()","def __init__(self, model: Any, data: Iterable[Any]):\n super().__init__(model, data)\n\n self.__score = None\n self.__summary = None\n\n self.calculate_scores()","def initialize(self):\n LOG.info(\"Initializing Model.\")\n self.model = self.convert(df=self.training_df)\n if self.bootstraps is not None:\n LOG.info(\"Bootstrapping Data.\")\n self.bootstrap_data()","def __init__(self, data):\n self.data = data\n self.columns = Columns(data)\n self.rows = Rows(data)","def __init__(self, **kwargs):\n DataLoader.__init__(self, **kwargs)","def setUpTestData(cls):\n data_gen.run()","def setUpTestData(cls):\n data_gen.run()","def setUpTestData(cls):\n data_gen.run()","def setUpTestData(cls):\n data_gen.run()","def __init__(\n self,\n values: Mapping[str, ATTRIBUTE_TYPES],\n data_model: Optional[DataModel] = None,\n data_model_name: str = \"\",\n ):\n _values = deepcopy(values)\n self._values = _values\n if data_model is not None:\n self.data_model = data_model\n else:\n self.data_model = generate_data_model(data_model_name, values)\n self._check_consistency()","def __init__(self):\n\n self._datamappers = {\n '*/*': DataMapper()\n }","def __init__(self, **kwargs):\n DataLoader.__init__(self, **kwargs)\n \n self._results_ = None","def _init_data_generators(self, ephase, list_iterstore, dict_iterstore):\n # Fetch input data generators\n Xin_gen, Xin_val_gen = \\\n self.callbacks['get_input_data_generators'](ephase, list_iterstore, dict_iterstore)\n\n # Fetch target data generators\n Xt_gen, Xt_val_gen = \\\n self.callbacks['get_target_data_generators'](ephase, list_iterstore, dict_iterstore)\n\n if Xin_gen is None:\n raise Exception('Required data generators are unavailable')\n\n if (ephase == NNModelPhase.PREDICT or ephase == NNModelPhase.TEST):\n if Xin_val_gen is not None or Xt_val_gen is not None:\n raise Exception('In NNModelPhase.PREDICT|TEST, `X2_gen` is unused. But it is not None.')\n\n # Sync the data generators (input, target)\n Xin_gen.sync_tgt_generator(Xt_gen)\n if (Xin_val_gen is not None):\n Xin_val_gen.sync_tgt_generator(Xt_val_gen)\n\n return Xin_gen, Xin_val_gen","def __init__(self, dataloader):\n self._dataloader = dataloader\n\n self._iterator = iter(self._dataloader)","def __init__(self, data_model: DataModel) -> None:\n\n # DataModel\n self._data_model = data_model\n\n # Dict[ParameterName, Any]\n self._param_to_value: Dict[ParameterName, Any] = {}\n\n # Dict[ParameterName, Dict[ParameterName, Any]]\n self._numbered_objects: Dict[ParameterName, Dict[ParameterName, Any]] = {}\n # If adding a PLMN object, then you would set something like\n # self._numbered_objects['PLMN_1'] = {'PLMN_1_ENABLED': True}","def initialize(self):\n for key in self.parameter_dict:\n self.models[key] = self._create_model(key)","def init_data(self):\n fields = SeriesRepository.get_available_series().exclude(identifier=None)\n\n if self.catalog:\n try:\n catalog = Catalog.objects.get(identifier=self.catalog)\n except Catalog.DoesNotExist:\n return\n\n fields = fields.filter(\n distribution__dataset__catalog=catalog\n )\n\n fields = fields.prefetch_related(\n 'distribution',\n 'distribution__dataset',\n 'distribution__dataset__catalog',\n 'enhanced_meta',\n )\n all_meta = Metadata.objects.all()\n field_ct = ContentType.objects.get_for_model(Field)\n for field in fields:\n meta = json.loads(field.metadata)\n dist_meta = json.loads(field.distribution.metadata)\n dataset_meta = json.loads(field.distribution.dataset.metadata)\n themes = field.distribution.dataset.themes\n theme_labels = get_theme_labels(json.loads(themes)) if themes else ''\n\n self.fields[field.identifier] = {\n 'dataset': field.distribution.dataset,\n 'distribution': field.distribution,\n 'serie': field,\n 'serie_titulo': field.title,\n 'serie_unidades': meta.get('units'),\n 'serie_descripcion': meta.get('description'),\n 'distribucion_titulo': dist_meta.get('title'),\n 'distribucion_descripcion': dist_meta.get('description'),\n 'distribucion_url_descarga': field.distribution.download_url,\n 'dataset_responsable': dataset_meta.get('publisher', {}).get('name'),\n 'dataset_fuente': dataset_meta.get('source'),\n 'dataset_titulo': field.distribution.dataset.title,\n 'dataset_descripcion': dataset_meta.get('description'),\n 'dataset_tema': theme_labels,\n 'metadata': {o.key: o.value for o in list(all_meta.filter(content_type=field_ct, object_id=field.id))},\n 'frequency': self.serie_periodicity(field),\n }","def prepare_data(self):","def setUp(self):\n self.dataset = self.dataset_cls()","def apply_initial_data(model, initial_data):\n for item in initial_data:\n value = initial_data[item]\n if hasattr(model, item):\n setattr(model, item, value)\n elif hasattr(model, 'extra_data') and isinstance(model.extra_data, dict):\n model.extra_data[item] = value\n\n return model","def setUp(self):\n self.aoSamples = [ModelDataBase(),];","def __init__(self, data):\n self.data = data\n return","def dataset_initializer_hook(self):\n iterator = self._dataset.make_initializable_iterator()\n # pylint: disable=protected-access\n hook = estimator_lib._DatasetInitializerHook(iterator)\n self._iterator = iterator\n return hook","def __init__(self):\n self.__dataset = None","def __post_init__(self):\n # Only do this if source_data already exists (not during its own initialization)\n if \"SOURCE_DATA\" in globals():\n for data_field in fields(self):\n setattr(self, data_field.name, getattr(SOURCE_DATA, data_field.name))","def _initialize(self) -> None:\n p = self.params\n # We make self.input public so that users can access its methods like\n # IdsToStrings if needed.\n with py_utils.infeed_context_scope(\n infeed_host_index=p.infeed_host_index,\n num_infeed_hosts=p.num_infeed_hosts):\n self.input = p.input.Instantiate()\n\n if hasattr(self.input, 'datasource') and isinstance(\n self.input.datasource, datasource.TFDatasetSource):\n # For the special case when the input is implemented by a tf.data.Dataset,\n # use it directly. Otherwise roundtrip adaptions may result in returning\n # duplciate batches.\n self._get_next_fn = self.input.datasource.GetNext\n else:\n self._get_next_fn = tf.function(self._get_batch)\n self._num_batches_produced = 0","def __init__(self, data=None):\n self.data = data","def __init__( self\n , _o_data\n ):\n self.o_data = _o_data","def setUpClass(cls) -> None:\n cls.DATA_MODEL = cls.load_data_model()","def populate_initial_valid_metadata(self):\n pass","def __init__(self, data):\n self.data = data","def __init__(self, data):\n self.data = data","def __init__(self, data):\n self.data = data","def __init__(self, data):\n self.data = data","def get_data(self):\n if self.random_seeds: \n self._validate_random_seeds()\n seed_iter = list(map(iter,self.random_seeds))\n nsamples = len(self.random_seeds[0])\n else:\n seed_iter = None\n nsamples = self.numsamples\n self._set_meta_features()\n for _ in tqdm(range(nsamples)):\n self._update_meta_features(seed_iter)\n self._sample()\n yield self._extract_features()","def __init__(self, dao):\n RAMSTKDataModel.__init__(self, dao)\n\n # Initialize private dictionary attributes.\n\n # Initialize private list attributes.\n\n # Initialize private scalar attributes.\n\n # Initialize public dictionary attributes.\n\n # Initialize public list attributes.\n\n # Initialize public scalar attributes.","def __init__(self, model):\n self._model = model","def __init__(self, dat):\n self.data = dat","def create_model(self, data):\n model = nodeitemmodel.NodeItemModel(self.parent.nodedatamanager)\n root = model.invisibleRootItem()\n for attr, value in data.iteritems():\n # components will be initialized separately later\n if attr == 'components':\n self.init_row(model, attr, None, root)\n else:\n self.init_row(model, attr, value, root)\n # end for attr, value in data.iteritems()\n return model","def initialize(self) -> None:\n self.model = load(self.path)","def _initialize_generator(self,gen,obj=None):\n # CEBALERT: use a dictionary to hold these things.\n if hasattr(obj,\"_Dynamic_time_fn\"):\n gen._Dynamic_time_fn = obj._Dynamic_time_fn\n\n gen._Dynamic_last = None\n # CEB: I'd use None for this, except can't compare a fixedpoint\n # number with None (e.g. 1>None but FixedPoint(1)>None can't be done)\n gen._Dynamic_time = -1\n\n gen._saved_Dynamic_last = []\n gen._saved_Dynamic_time = []","def __init__(self, **kwargs):\n super(Model, self).__init__(**kwargs)\n\n for (key, value) in kwargs.iteritems():\n # use setattr so that validation is triggered\n setattr(self, key, value)","def __init__(self):\n super().__init__()\n self.data = None","def init(self):\n # IMPORTANT: create a new gob database model entry for this object\n self.gobify()","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self):\n self._data = []","def __init__(self, data):\n self.__data = data\n self.__next = None","def __init__(self, *args, **kwargs):\n super(DeepSpeakerDataLoader, self).__init__(*args, **kwargs)","def __init__(self, **kwargs):\n super(Model, self).__init__(**kwargs)","def populate(self):\n raise NotImplementedError","def prepare_data(self, config: TreeConfigParser) -> None:\n self.data = Data(config)\n self.data.prepare_input()\n self.data.prepare_output()","def populate(cls):\n raise NotImplementedError","def to_DataLoader(self, **kwargs):\r\n return DataLoader(self, **kwargs)","def auto_populate(self, model):\n for name, val in self._fields.iteritems():\n setattr(model, name, val.data)","def initialize(self):\n self.data = None\n self.errors = []","def __init__(self, json_data, id_mappings):\n self._data = json_data\n self._id_mappings = id_mappings\n self._driven_routes = []\n self._invoices = []","def __init__(self, dataset):\n self._dataset = dataset","def __init__(self,data):\n\n self.data = data","def __init__( self, generator):\n DictObject.__init__( self, generator.generate_dict())","def setUp(self):\n self.data = DatabaseIntermediary()","def initialize_model(self):\n model = self.model_class()\n return model","def init_batch(self):\n pass","def __init__(self):\n\n data_extract=DataExtracter()\n self.data = tuple()","def __init__(self, data=None, next=None):\r\n pass","def initialize_model(self, initial_data):\n # EDIT THIS METHOD TO RETURN A MINIMAX MODEL ###\n return None","def initialize(self, ctx):\n\n super().initialize(ctx)\n\n self._csv_reader = CsvReader()\n self._csv_reader.data = ctx.interpolate(self.data)\n self._csv_reader.strip = True\n ctx.comp.initialize(self._csv_reader)\n\n for m in self._csv_reader.process(ctx, None):\n self.insert(ctx, m)","def initialize(self, **kwargs):","def _init_data(self) -> None:\n self.dtype = dict()\n self.shape = dict()\n self.size = dict()\n self.attrs = dict()\n self.data_ptr = dict()\n\n if self.mode == 'r':\n for k in self.fp.keys():\n self.dtype[k] = self.fp[k].dtype\n self.shape[k] = self.fp[k].shape\n self.size[k] = self.fp[k].shape[0]\n self.data_ptr[k] = 0","def populate(self):\n pass","def __init__(self):\n self._data = PositionalList() # list of _Item instances","def __init__(self, data=None, next=None):\n self.data = data\n self.next = next","def __init__(self, dataset_name, teacher_model, students_model):\n self.data_manager = DataManager(dataset_name)\n self.dataset_name = dataset_name\n self.teacher_model = teacher_model\n self.student_model = students_model","def __init__(self, _id: Generator[str, None, None], data: dict, obs: OBS) -> None:\r\n\r\n self.id: Generator[str, None, None] = _id\r\n self.data: dict = data\r\n self.obs: OBS = obs","def __init__(self):\r\n super(DataTarget, self).__init__()","def __init__(self, *args, **kwargs):\n self._d = Deferred()\n self.__rows = [] # likely a superlcass might have this?","def create(self, validated_data):\n ModelClass = self.Meta.model\n instance = ModelClass()\n self.instance = instance\n for key, value in validated_data.items():\n setattr(instance, key, value)\n return super().create(validated_data)","def __init__(self, data, next=None):\n self.data = data\n self.next = next","def __init__(self, raw_data: Dict) -> None:\n self.raw_data = raw_data\n self.__extract_common_attrs(raw_data)\n\n # Fetch data with DATA_KEY or simply use the initial data.\n # In some cases the DATA_KEY is the same as the object attribute.\n # For example:\n # \"comments\": [{\n # \"comment_id\": 44444,\n # \"comment\": \"Hello, world!\"\n # }]\n # This object has a `comment` attribute but its DATA_KEY is also `comment`:\n # \"comment\": {\"comment_id\": 44444,\n # \"key_id\": 12345,\n # \"comment\": \"This is a test.\"}\n # This is an edge case happening only twice, so to overcome it\n # just check the value type under the given key.\n if self.DATA_KEY in raw_data and \\\n (isinstance(raw_data[self.DATA_KEY], dict)):\n data = raw_data[self.DATA_KEY]\n else:\n data = raw_data\n\n for attr in self.ATTRS:\n setattr(self, attr, data.get(attr, None))","def __init__(self, **kwargs):\n assert self.__class__.get_primary() != None\n for field in self.fields()+self.tables():\n value = object.__getattribute__(self, field)\n instance = value.__class__(*value.args, **value.kwargs)\n instance.model = self\n object.__setattr__(self, field, instance)\n \n for key, val in kwargs.iteritems():\n self.__setattr__(key, val)\n \n self._retrieved = False","def __init__(self):\n self.data = []","def __init__(self):\n self.data = []","def generator(self, data):\n for instance in data:\n yield (0, [str(instance.string)])","def init(self):\n raise NotImplementedError","def init(self):\n raise NotImplementedError","def __init__(self):\n self.model = None\n self.joined_datasets = None\n self.id_col = None\n self.val_col = None\n self.pop_col = None\n self.total_population_per_unit = None\n self.centroids_of_areal_data = None\n self.prepared_data = None\n self.unknown_area_id = None\n\n # Parameters\n self.lags = None\n self.step = None\n self.min_no_of_observations = None\n self.max_search_radius = None","def init_context_data(self):\n pass","def __init__(self, models, neg_sample_generator, lookup):\n super(ModelSelector, self).__init__(None, neg_sample_generator)\n self.models = models\n self.lookup = lookup","def _init_train_loader(self):\n # Choose the right dataset type\n if self.config_args[\"num_members\"] > 1:\n class_dataset_wrapper = dataset_wrapper.MixMoDataset\n else:\n class_dataset_wrapper = dataset_wrapper.MSDADataset\n\n # Load augmentations\n self.traindatasetwrapper = class_dataset_wrapper(\n dataset=self.train_dataset,\n num_classes=int(self.config_args[\"data\"][\"num_classes\"]),\n num_members=self.config_args[\"num_members\"],\n dict_config=self.config_args[\"training\"][\"dataset_wrapper\"],\n properties=self.properties\n )\n\n # Build standard sampler\n _train_sampler = torch.utils.data.sampler.RandomSampler(\n data_source=self.traindatasetwrapper, ## only needed for its length\n num_samples=None,\n replacement=False,\n )\n\n # Wrap it with the repeating sampler used for multi-input models\n batch_sampler = batch_repetition_sampler.BatchRepetitionSampler(\n sampler=_train_sampler,\n batch_size=self.batch_size,\n num_members=self.config_args[\"num_members\"],\n drop_last=True,\n config_batch_sampler=self.config_args[\"training\"][\"batch_sampler\"]\n )\n\n self.train_loader = torch.utils.data.DataLoader(\n self.traindatasetwrapper,\n batch_sampler=batch_sampler,\n num_workers=self.num_workers,\n batch_size=1,\n shuffle=False,\n sampler=None,\n drop_last=False,\n pin_memory=True,\n )","def __init__(self, data={}):\n self._update_(data)","def prepopulate(self, model, exclude=[]):\n for col in model.columns():\n if col not in exclude and hasattr(self, col):\n setattr(getattr(self, col), 'data', getattr(model, col))","def make_instance(self, data, **kwargs):\n instance = self.instance or self.get_instance(data)\n if instance is not None:\n for key, value in iteritems(data):\n setattr(instance, key, value)\n return instance\n kwargs, association_attrs = self._split_model_kwargs_association(data)\n instance = self.opts.model(**kwargs)\n for attr, value in iteritems(association_attrs):\n setattr(instance, attr, value)\n return instance","def _init_data(self, data):\n assert type(data) is dict, \"dict expected: %r\" % type(data)\n assert len(data) is 1, \"size of dict should be 1: %r\" % len(data)\n self._name = data.keys()[0]\n self._data = np.asarray(data[self._name])\n self._set = True","def _custom_data_loader(self) -> DataLoader:\n dataloaders = DataLoader(self.dataset, batch_size=1)\n return dataloaders"],"string":"[\n \"def init_model(self):\\n pass\",\n \"def initialize_model(self):\\n pass\",\n \"def initialize(self, model):\\n pass\",\n \"def init_from_data(self, data):\\n self.data = data\\n self.norm_data()\",\n \"def __init__(self, model: Any, data: Iterable[Any]):\\n super().__init__(model, data)\\n\\n self.__score = None\\n self.__summary = None\\n\\n self.calculate_scores()\",\n \"def initialize(self):\\n LOG.info(\\\"Initializing Model.\\\")\\n self.model = self.convert(df=self.training_df)\\n if self.bootstraps is not None:\\n LOG.info(\\\"Bootstrapping Data.\\\")\\n self.bootstrap_data()\",\n \"def __init__(self, data):\\n self.data = data\\n self.columns = Columns(data)\\n self.rows = Rows(data)\",\n \"def __init__(self, **kwargs):\\n DataLoader.__init__(self, **kwargs)\",\n \"def setUpTestData(cls):\\n data_gen.run()\",\n \"def setUpTestData(cls):\\n data_gen.run()\",\n \"def setUpTestData(cls):\\n data_gen.run()\",\n \"def setUpTestData(cls):\\n data_gen.run()\",\n \"def __init__(\\n self,\\n values: Mapping[str, ATTRIBUTE_TYPES],\\n data_model: Optional[DataModel] = None,\\n data_model_name: str = \\\"\\\",\\n ):\\n _values = deepcopy(values)\\n self._values = _values\\n if data_model is not None:\\n self.data_model = data_model\\n else:\\n self.data_model = generate_data_model(data_model_name, values)\\n self._check_consistency()\",\n \"def __init__(self):\\n\\n self._datamappers = {\\n '*/*': DataMapper()\\n }\",\n \"def __init__(self, **kwargs):\\n DataLoader.__init__(self, **kwargs)\\n \\n self._results_ = None\",\n \"def _init_data_generators(self, ephase, list_iterstore, dict_iterstore):\\n # Fetch input data generators\\n Xin_gen, Xin_val_gen = \\\\\\n self.callbacks['get_input_data_generators'](ephase, list_iterstore, dict_iterstore)\\n\\n # Fetch target data generators\\n Xt_gen, Xt_val_gen = \\\\\\n self.callbacks['get_target_data_generators'](ephase, list_iterstore, dict_iterstore)\\n\\n if Xin_gen is None:\\n raise Exception('Required data generators are unavailable')\\n\\n if (ephase == NNModelPhase.PREDICT or ephase == NNModelPhase.TEST):\\n if Xin_val_gen is not None or Xt_val_gen is not None:\\n raise Exception('In NNModelPhase.PREDICT|TEST, `X2_gen` is unused. But it is not None.')\\n\\n # Sync the data generators (input, target)\\n Xin_gen.sync_tgt_generator(Xt_gen)\\n if (Xin_val_gen is not None):\\n Xin_val_gen.sync_tgt_generator(Xt_val_gen)\\n\\n return Xin_gen, Xin_val_gen\",\n \"def __init__(self, dataloader):\\n self._dataloader = dataloader\\n\\n self._iterator = iter(self._dataloader)\",\n \"def __init__(self, data_model: DataModel) -> None:\\n\\n # DataModel\\n self._data_model = data_model\\n\\n # Dict[ParameterName, Any]\\n self._param_to_value: Dict[ParameterName, Any] = {}\\n\\n # Dict[ParameterName, Dict[ParameterName, Any]]\\n self._numbered_objects: Dict[ParameterName, Dict[ParameterName, Any]] = {}\\n # If adding a PLMN object, then you would set something like\\n # self._numbered_objects['PLMN_1'] = {'PLMN_1_ENABLED': True}\",\n \"def initialize(self):\\n for key in self.parameter_dict:\\n self.models[key] = self._create_model(key)\",\n \"def init_data(self):\\n fields = SeriesRepository.get_available_series().exclude(identifier=None)\\n\\n if self.catalog:\\n try:\\n catalog = Catalog.objects.get(identifier=self.catalog)\\n except Catalog.DoesNotExist:\\n return\\n\\n fields = fields.filter(\\n distribution__dataset__catalog=catalog\\n )\\n\\n fields = fields.prefetch_related(\\n 'distribution',\\n 'distribution__dataset',\\n 'distribution__dataset__catalog',\\n 'enhanced_meta',\\n )\\n all_meta = Metadata.objects.all()\\n field_ct = ContentType.objects.get_for_model(Field)\\n for field in fields:\\n meta = json.loads(field.metadata)\\n dist_meta = json.loads(field.distribution.metadata)\\n dataset_meta = json.loads(field.distribution.dataset.metadata)\\n themes = field.distribution.dataset.themes\\n theme_labels = get_theme_labels(json.loads(themes)) if themes else ''\\n\\n self.fields[field.identifier] = {\\n 'dataset': field.distribution.dataset,\\n 'distribution': field.distribution,\\n 'serie': field,\\n 'serie_titulo': field.title,\\n 'serie_unidades': meta.get('units'),\\n 'serie_descripcion': meta.get('description'),\\n 'distribucion_titulo': dist_meta.get('title'),\\n 'distribucion_descripcion': dist_meta.get('description'),\\n 'distribucion_url_descarga': field.distribution.download_url,\\n 'dataset_responsable': dataset_meta.get('publisher', {}).get('name'),\\n 'dataset_fuente': dataset_meta.get('source'),\\n 'dataset_titulo': field.distribution.dataset.title,\\n 'dataset_descripcion': dataset_meta.get('description'),\\n 'dataset_tema': theme_labels,\\n 'metadata': {o.key: o.value for o in list(all_meta.filter(content_type=field_ct, object_id=field.id))},\\n 'frequency': self.serie_periodicity(field),\\n }\",\n \"def prepare_data(self):\",\n \"def setUp(self):\\n self.dataset = self.dataset_cls()\",\n \"def apply_initial_data(model, initial_data):\\n for item in initial_data:\\n value = initial_data[item]\\n if hasattr(model, item):\\n setattr(model, item, value)\\n elif hasattr(model, 'extra_data') and isinstance(model.extra_data, dict):\\n model.extra_data[item] = value\\n\\n return model\",\n \"def setUp(self):\\n self.aoSamples = [ModelDataBase(),];\",\n \"def __init__(self, data):\\n self.data = data\\n return\",\n \"def dataset_initializer_hook(self):\\n iterator = self._dataset.make_initializable_iterator()\\n # pylint: disable=protected-access\\n hook = estimator_lib._DatasetInitializerHook(iterator)\\n self._iterator = iterator\\n return hook\",\n \"def __init__(self):\\n self.__dataset = None\",\n \"def __post_init__(self):\\n # Only do this if source_data already exists (not during its own initialization)\\n if \\\"SOURCE_DATA\\\" in globals():\\n for data_field in fields(self):\\n setattr(self, data_field.name, getattr(SOURCE_DATA, data_field.name))\",\n \"def _initialize(self) -> None:\\n p = self.params\\n # We make self.input public so that users can access its methods like\\n # IdsToStrings if needed.\\n with py_utils.infeed_context_scope(\\n infeed_host_index=p.infeed_host_index,\\n num_infeed_hosts=p.num_infeed_hosts):\\n self.input = p.input.Instantiate()\\n\\n if hasattr(self.input, 'datasource') and isinstance(\\n self.input.datasource, datasource.TFDatasetSource):\\n # For the special case when the input is implemented by a tf.data.Dataset,\\n # use it directly. Otherwise roundtrip adaptions may result in returning\\n # duplciate batches.\\n self._get_next_fn = self.input.datasource.GetNext\\n else:\\n self._get_next_fn = tf.function(self._get_batch)\\n self._num_batches_produced = 0\",\n \"def __init__(self, data=None):\\n self.data = data\",\n \"def __init__( self\\n , _o_data\\n ):\\n self.o_data = _o_data\",\n \"def setUpClass(cls) -> None:\\n cls.DATA_MODEL = cls.load_data_model()\",\n \"def populate_initial_valid_metadata(self):\\n pass\",\n \"def __init__(self, data):\\n self.data = data\",\n \"def __init__(self, data):\\n self.data = data\",\n \"def __init__(self, data):\\n self.data = data\",\n \"def __init__(self, data):\\n self.data = data\",\n \"def get_data(self):\\n if self.random_seeds: \\n self._validate_random_seeds()\\n seed_iter = list(map(iter,self.random_seeds))\\n nsamples = len(self.random_seeds[0])\\n else:\\n seed_iter = None\\n nsamples = self.numsamples\\n self._set_meta_features()\\n for _ in tqdm(range(nsamples)):\\n self._update_meta_features(seed_iter)\\n self._sample()\\n yield self._extract_features()\",\n \"def __init__(self, dao):\\n RAMSTKDataModel.__init__(self, dao)\\n\\n # Initialize private dictionary attributes.\\n\\n # Initialize private list attributes.\\n\\n # Initialize private scalar attributes.\\n\\n # Initialize public dictionary attributes.\\n\\n # Initialize public list attributes.\\n\\n # Initialize public scalar attributes.\",\n \"def __init__(self, model):\\n self._model = model\",\n \"def __init__(self, dat):\\n self.data = dat\",\n \"def create_model(self, data):\\n model = nodeitemmodel.NodeItemModel(self.parent.nodedatamanager)\\n root = model.invisibleRootItem()\\n for attr, value in data.iteritems():\\n # components will be initialized separately later\\n if attr == 'components':\\n self.init_row(model, attr, None, root)\\n else:\\n self.init_row(model, attr, value, root)\\n # end for attr, value in data.iteritems()\\n return model\",\n \"def initialize(self) -> None:\\n self.model = load(self.path)\",\n \"def _initialize_generator(self,gen,obj=None):\\n # CEBALERT: use a dictionary to hold these things.\\n if hasattr(obj,\\\"_Dynamic_time_fn\\\"):\\n gen._Dynamic_time_fn = obj._Dynamic_time_fn\\n\\n gen._Dynamic_last = None\\n # CEB: I'd use None for this, except can't compare a fixedpoint\\n # number with None (e.g. 1>None but FixedPoint(1)>None can't be done)\\n gen._Dynamic_time = -1\\n\\n gen._saved_Dynamic_last = []\\n gen._saved_Dynamic_time = []\",\n \"def __init__(self, **kwargs):\\n super(Model, self).__init__(**kwargs)\\n\\n for (key, value) in kwargs.iteritems():\\n # use setattr so that validation is triggered\\n setattr(self, key, value)\",\n \"def __init__(self):\\n super().__init__()\\n self.data = None\",\n \"def init(self):\\n # IMPORTANT: create a new gob database model entry for this object\\n self.gobify()\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self):\\n self._data = []\",\n \"def __init__(self, data):\\n self.__data = data\\n self.__next = None\",\n \"def __init__(self, *args, **kwargs):\\n super(DeepSpeakerDataLoader, self).__init__(*args, **kwargs)\",\n \"def __init__(self, **kwargs):\\n super(Model, self).__init__(**kwargs)\",\n \"def populate(self):\\n raise NotImplementedError\",\n \"def prepare_data(self, config: TreeConfigParser) -> None:\\n self.data = Data(config)\\n self.data.prepare_input()\\n self.data.prepare_output()\",\n \"def populate(cls):\\n raise NotImplementedError\",\n \"def to_DataLoader(self, **kwargs):\\r\\n return DataLoader(self, **kwargs)\",\n \"def auto_populate(self, model):\\n for name, val in self._fields.iteritems():\\n setattr(model, name, val.data)\",\n \"def initialize(self):\\n self.data = None\\n self.errors = []\",\n \"def __init__(self, json_data, id_mappings):\\n self._data = json_data\\n self._id_mappings = id_mappings\\n self._driven_routes = []\\n self._invoices = []\",\n \"def __init__(self, dataset):\\n self._dataset = dataset\",\n \"def __init__(self,data):\\n\\n self.data = data\",\n \"def __init__( self, generator):\\n DictObject.__init__( self, generator.generate_dict())\",\n \"def setUp(self):\\n self.data = DatabaseIntermediary()\",\n \"def initialize_model(self):\\n model = self.model_class()\\n return model\",\n \"def init_batch(self):\\n pass\",\n \"def __init__(self):\\n\\n data_extract=DataExtracter()\\n self.data = tuple()\",\n \"def __init__(self, data=None, next=None):\\r\\n pass\",\n \"def initialize_model(self, initial_data):\\n # EDIT THIS METHOD TO RETURN A MINIMAX MODEL ###\\n return None\",\n \"def initialize(self, ctx):\\n\\n super().initialize(ctx)\\n\\n self._csv_reader = CsvReader()\\n self._csv_reader.data = ctx.interpolate(self.data)\\n self._csv_reader.strip = True\\n ctx.comp.initialize(self._csv_reader)\\n\\n for m in self._csv_reader.process(ctx, None):\\n self.insert(ctx, m)\",\n \"def initialize(self, **kwargs):\",\n \"def _init_data(self) -> None:\\n self.dtype = dict()\\n self.shape = dict()\\n self.size = dict()\\n self.attrs = dict()\\n self.data_ptr = dict()\\n\\n if self.mode == 'r':\\n for k in self.fp.keys():\\n self.dtype[k] = self.fp[k].dtype\\n self.shape[k] = self.fp[k].shape\\n self.size[k] = self.fp[k].shape[0]\\n self.data_ptr[k] = 0\",\n \"def populate(self):\\n pass\",\n \"def __init__(self):\\n self._data = PositionalList() # list of _Item instances\",\n \"def __init__(self, data=None, next=None):\\n self.data = data\\n self.next = next\",\n \"def __init__(self, dataset_name, teacher_model, students_model):\\n self.data_manager = DataManager(dataset_name)\\n self.dataset_name = dataset_name\\n self.teacher_model = teacher_model\\n self.student_model = students_model\",\n \"def __init__(self, _id: Generator[str, None, None], data: dict, obs: OBS) -> None:\\r\\n\\r\\n self.id: Generator[str, None, None] = _id\\r\\n self.data: dict = data\\r\\n self.obs: OBS = obs\",\n \"def __init__(self):\\r\\n super(DataTarget, self).__init__()\",\n \"def __init__(self, *args, **kwargs):\\n self._d = Deferred()\\n self.__rows = [] # likely a superlcass might have this?\",\n \"def create(self, validated_data):\\n ModelClass = self.Meta.model\\n instance = ModelClass()\\n self.instance = instance\\n for key, value in validated_data.items():\\n setattr(instance, key, value)\\n return super().create(validated_data)\",\n \"def __init__(self, data, next=None):\\n self.data = data\\n self.next = next\",\n \"def __init__(self, raw_data: Dict) -> None:\\n self.raw_data = raw_data\\n self.__extract_common_attrs(raw_data)\\n\\n # Fetch data with DATA_KEY or simply use the initial data.\\n # In some cases the DATA_KEY is the same as the object attribute.\\n # For example:\\n # \\\"comments\\\": [{\\n # \\\"comment_id\\\": 44444,\\n # \\\"comment\\\": \\\"Hello, world!\\\"\\n # }]\\n # This object has a `comment` attribute but its DATA_KEY is also `comment`:\\n # \\\"comment\\\": {\\\"comment_id\\\": 44444,\\n # \\\"key_id\\\": 12345,\\n # \\\"comment\\\": \\\"This is a test.\\\"}\\n # This is an edge case happening only twice, so to overcome it\\n # just check the value type under the given key.\\n if self.DATA_KEY in raw_data and \\\\\\n (isinstance(raw_data[self.DATA_KEY], dict)):\\n data = raw_data[self.DATA_KEY]\\n else:\\n data = raw_data\\n\\n for attr in self.ATTRS:\\n setattr(self, attr, data.get(attr, None))\",\n \"def __init__(self, **kwargs):\\n assert self.__class__.get_primary() != None\\n for field in self.fields()+self.tables():\\n value = object.__getattribute__(self, field)\\n instance = value.__class__(*value.args, **value.kwargs)\\n instance.model = self\\n object.__setattr__(self, field, instance)\\n \\n for key, val in kwargs.iteritems():\\n self.__setattr__(key, val)\\n \\n self._retrieved = False\",\n \"def __init__(self):\\n self.data = []\",\n \"def __init__(self):\\n self.data = []\",\n \"def generator(self, data):\\n for instance in data:\\n yield (0, [str(instance.string)])\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n self.model = None\\n self.joined_datasets = None\\n self.id_col = None\\n self.val_col = None\\n self.pop_col = None\\n self.total_population_per_unit = None\\n self.centroids_of_areal_data = None\\n self.prepared_data = None\\n self.unknown_area_id = None\\n\\n # Parameters\\n self.lags = None\\n self.step = None\\n self.min_no_of_observations = None\\n self.max_search_radius = None\",\n \"def init_context_data(self):\\n pass\",\n \"def __init__(self, models, neg_sample_generator, lookup):\\n super(ModelSelector, self).__init__(None, neg_sample_generator)\\n self.models = models\\n self.lookup = lookup\",\n \"def _init_train_loader(self):\\n # Choose the right dataset type\\n if self.config_args[\\\"num_members\\\"] > 1:\\n class_dataset_wrapper = dataset_wrapper.MixMoDataset\\n else:\\n class_dataset_wrapper = dataset_wrapper.MSDADataset\\n\\n # Load augmentations\\n self.traindatasetwrapper = class_dataset_wrapper(\\n dataset=self.train_dataset,\\n num_classes=int(self.config_args[\\\"data\\\"][\\\"num_classes\\\"]),\\n num_members=self.config_args[\\\"num_members\\\"],\\n dict_config=self.config_args[\\\"training\\\"][\\\"dataset_wrapper\\\"],\\n properties=self.properties\\n )\\n\\n # Build standard sampler\\n _train_sampler = torch.utils.data.sampler.RandomSampler(\\n data_source=self.traindatasetwrapper, ## only needed for its length\\n num_samples=None,\\n replacement=False,\\n )\\n\\n # Wrap it with the repeating sampler used for multi-input models\\n batch_sampler = batch_repetition_sampler.BatchRepetitionSampler(\\n sampler=_train_sampler,\\n batch_size=self.batch_size,\\n num_members=self.config_args[\\\"num_members\\\"],\\n drop_last=True,\\n config_batch_sampler=self.config_args[\\\"training\\\"][\\\"batch_sampler\\\"]\\n )\\n\\n self.train_loader = torch.utils.data.DataLoader(\\n self.traindatasetwrapper,\\n batch_sampler=batch_sampler,\\n num_workers=self.num_workers,\\n batch_size=1,\\n shuffle=False,\\n sampler=None,\\n drop_last=False,\\n pin_memory=True,\\n )\",\n \"def __init__(self, data={}):\\n self._update_(data)\",\n \"def prepopulate(self, model, exclude=[]):\\n for col in model.columns():\\n if col not in exclude and hasattr(self, col):\\n setattr(getattr(self, col), 'data', getattr(model, col))\",\n \"def make_instance(self, data, **kwargs):\\n instance = self.instance or self.get_instance(data)\\n if instance is not None:\\n for key, value in iteritems(data):\\n setattr(instance, key, value)\\n return instance\\n kwargs, association_attrs = self._split_model_kwargs_association(data)\\n instance = self.opts.model(**kwargs)\\n for attr, value in iteritems(association_attrs):\\n setattr(instance, attr, value)\\n return instance\",\n \"def _init_data(self, data):\\n assert type(data) is dict, \\\"dict expected: %r\\\" % type(data)\\n assert len(data) is 1, \\\"size of dict should be 1: %r\\\" % len(data)\\n self._name = data.keys()[0]\\n self._data = np.asarray(data[self._name])\\n self._set = True\",\n \"def _custom_data_loader(self) -> DataLoader:\\n dataloaders = DataLoader(self.dataset, batch_size=1)\\n return dataloaders\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6300777","0.62807715","0.6212327","0.61153483","0.61078835","0.6094563","0.60931665","0.6075413","0.59868747","0.59868747","0.59868747","0.59868747","0.5954239","0.5919463","0.5886439","0.58657","0.58602965","0.5820341","0.58048314","0.5776811","0.5767657","0.57443345","0.5741701","0.57413435","0.57213074","0.5717546","0.5700324","0.5690915","0.5687048","0.56644076","0.5647008","0.5644539","0.56404114","0.5640152","0.5640152","0.5640152","0.5640152","0.56305826","0.5629516","0.5621836","0.5619624","0.5618798","0.5607713","0.56003094","0.5599612","0.55964655","0.55955875","0.55937654","0.55937654","0.55937654","0.55937654","0.55937654","0.55937654","0.55879074","0.5563475","0.5562388","0.5551611","0.5541105","0.5536056","0.5530712","0.5529328","0.5527838","0.55225384","0.55224","0.55204356","0.5517248","0.55170524","0.5513682","0.5512605","0.5510765","0.5503239","0.54943305","0.54866195","0.5472257","0.5466404","0.54647386","0.5459293","0.54421616","0.5439698","0.54345036","0.5430169","0.5422975","0.5419388","0.5416952","0.5414275","0.54109526","0.5402858","0.5402858","0.53999174","0.539942","0.539942","0.53960377","0.5394284","0.5394172","0.5392553","0.5391464","0.53896207","0.53886503","0.53880614","0.5383042"],"string":"[\n \"0.6300777\",\n \"0.62807715\",\n \"0.6212327\",\n \"0.61153483\",\n \"0.61078835\",\n \"0.6094563\",\n \"0.60931665\",\n \"0.6075413\",\n \"0.59868747\",\n \"0.59868747\",\n \"0.59868747\",\n \"0.59868747\",\n \"0.5954239\",\n \"0.5919463\",\n \"0.5886439\",\n \"0.58657\",\n \"0.58602965\",\n \"0.5820341\",\n \"0.58048314\",\n \"0.5776811\",\n \"0.5767657\",\n \"0.57443345\",\n \"0.5741701\",\n \"0.57413435\",\n \"0.57213074\",\n \"0.5717546\",\n \"0.5700324\",\n \"0.5690915\",\n \"0.5687048\",\n \"0.56644076\",\n \"0.5647008\",\n \"0.5644539\",\n \"0.56404114\",\n \"0.5640152\",\n \"0.5640152\",\n \"0.5640152\",\n \"0.5640152\",\n \"0.56305826\",\n \"0.5629516\",\n \"0.5621836\",\n \"0.5619624\",\n \"0.5618798\",\n \"0.5607713\",\n \"0.56003094\",\n \"0.5599612\",\n \"0.55964655\",\n \"0.55955875\",\n \"0.55937654\",\n \"0.55937654\",\n \"0.55937654\",\n \"0.55937654\",\n \"0.55937654\",\n \"0.55937654\",\n \"0.55879074\",\n \"0.5563475\",\n \"0.5562388\",\n \"0.5551611\",\n \"0.5541105\",\n \"0.5536056\",\n \"0.5530712\",\n \"0.5529328\",\n \"0.5527838\",\n \"0.55225384\",\n \"0.55224\",\n \"0.55204356\",\n \"0.5517248\",\n \"0.55170524\",\n \"0.5513682\",\n \"0.5512605\",\n \"0.5510765\",\n \"0.5503239\",\n \"0.54943305\",\n \"0.54866195\",\n \"0.5472257\",\n \"0.5466404\",\n \"0.54647386\",\n \"0.5459293\",\n \"0.54421616\",\n \"0.5439698\",\n \"0.54345036\",\n \"0.5430169\",\n \"0.5422975\",\n \"0.5419388\",\n \"0.5416952\",\n \"0.5414275\",\n \"0.54109526\",\n \"0.5402858\",\n \"0.5402858\",\n \"0.53999174\",\n \"0.539942\",\n \"0.539942\",\n \"0.53960377\",\n \"0.5394284\",\n \"0.5394172\",\n \"0.5392553\",\n \"0.5391464\",\n \"0.53896207\",\n \"0.53886503\",\n \"0.53880614\",\n \"0.5383042\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.660022"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92898,"cells":{"query":{"kind":"string","value":"Fetch Data and Predictions"},"document":{"kind":"string","value":"def _fetch_data_batch(self, logits, predictions, data=None):\n if data is not None:\n # this will explicitly avoid data.initializer\n (fetched_target,\n fetched_logits,\n fetched_predictions) = self._sess.run(\n [data.target, logits, predictions])\n\n fetched_logits = fetched_logits.tolist()\n fetched_predictions = fetched_predictions.tolist()\n fetched_data = {\"target\": fetched_target.tolist()}\n\n else:\n fetched_data = None\n (fetched_logits,\n fetched_predictions) = self._sess.run(\n [logits, predictions])\n \n fetched_logits = fetched_logits.tolist()\n fetched_predictions = fetched_predictions.tolist()\n\n return fetched_logits, fetched_predictions, fetched_data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _fetch_data(self):\n pass","def fetch_data():\n for category in CHEATSHEETS.items():\n subprocess.call(f'curl -o {PATH}{category[0] + \".csv\"} {category[1]}', shell=True)\n\n index = -1\n for filename in os.listdir(PATH):\n for idx, row in pd.read_csv(PATH + filename, on_bad_lines='skip').replace(np.nan, '').iterrows():\n name = row['Model']\n url = REDIRECT_URL + name.lower()\n category = filename.split('.')[0]\n featurizers = row['Acceptable Featurizers'].split(' ') if row['Acceptable Featurizers'] != '' else []\n backends = ['PyTorch' if item in {\"PTorch\", \"Torch\", \"PyTorch \"} else item for item in row['Backend'].split('/')]\n types = row['Type'] if filename != 'general.csv' else row['Classifier/Regressor']\n types = types.split('/') if filename == 'material.csv' else types.split('/ ')\n index += 1\n\n backend_list.append(backends)\n type_list.append(types)\n featurizer_list.append(featurizers)\n model_list.append(Model(name, url, category, featurizers, backends, types, index))","def fetch_data(self):","def _get_data(self):\n\n # Grab the data. Note, the separator is actually ', ', not just a\n # comma, so specify. Also, recognize the \"?\" as an NA value\n # (I think it is easier to have pandas catch the NA values instead\n # of manually searching for and parsing these in the future).\n # Finally, set the engine to python, since having a separator greater\n # than one character automatically does this, and prints a warning\n # message. By explicitly telling it to use python, we suppress the\n # warning.\n self.train_df = pd.read_csv(self.train_url, sep=', ', header=None,\n na_values='?', engine='python')\n\n # For the training data, have one comment row, so need to ignore\n self.test_df = pd.read_csv(self.test_url, sep=', ', header=None,\n skiprows=1, na_values='?', engine='python')\n\n # Get the header data\n response = requests.get(self.head_url)\n header = response.text.split('\\n')\n\n # Now, filter to grab the header lines:\n # First, make sure there is at least one character for the line, and\n # ignore lines that start with the comment character for the file \"|\"\n header = [row for row in header if len(row) > 0 and row[0] != '|']\n\n # Ignore the first row, since it is just identifying the classifier\n # task and, get just the header values\n header = [head.split(':')[0] for head in header[1:]]\n\n # Finally, we need to add a header name for the last column (if <= or >\n # income of 50k)\n header.append('income')\n\n # Now, set the header for the data sets\n self.train_df.columns = header\n self.test_df.columns = header","def do_training(self):\n json_data = request.data\n global g_list_of_classifier\n\n datas = json.loads(json_data.decode('UTF-8')) #datas = liste\n\n for ite_clf in g_list_of_classifier:\n for data in datas:\n ite_clf.add_data(data['score'], data['answer'])\n print(ite_clf.get_info())\n return ''","def _fetch_data(self, samples):\n pass","def fetch_data():\n data.fetch_data()\n data.start_updating()","def do_fetch(self):\n pass","def run(self):\n results = self.fetch()\n return results","def train(self, force=False):\n return self._fetch_base_data(force)","def download_all_data(self) -> None:\n print(\"Download in progress.\")\n self.download_data(os.environ[\"NC_TOKEN_TRAIN_CHARACTERS\"], \"nextcloud\")\n self.download_data(os.environ[\"NC_TOKEN_TRAIN_FRAGMENTS\"], \"nextcloud\")\n self.download_data(os.environ[\"HABBAKUK_URL\"], \"generic_url\")\n print(\"Download complete!\")","def apicall():\n try:\n test_json = request.get_json()\n test = pd.read_json(test_json, orient='records')\n\n # To resolve the issue of TypeError: Cannot compare types 'ndarray(dtype=int64)' and 'str'\n # test['Dependents'] = [str(x) for x in list(test['Dependents'])]\n\n # Getting the Loan_IDs separated out\n # loan_ids = test['Loan_ID']\n\n except Exception as e:\n raise e\n\n clf = 'model_1.pk'\n\n if test.empty:\n return(bad_request())\n else:\n print('Loading the model ..')\n loaded_model = None\n with open('models/'+clf, 'rb') as f:\n loaded_model = pickle.load(f)\n print(\"The model has been loaded...doing predictions now...\")\n predictions = loaded_model.predict(test)\n\n prediction_series = list(pd.Series(predictions))\n final_predictions = pd.DataFrame(list(zip(loan_ids, prediction_series)))\n\n \"\"\"We can be as creative in sending the responses.\n But we need to send the response codes as well.\n \"\"\"\n responses = jsonify(predictions=final_predictions.to_json(orient=\"records\"))\n responses.status_code = 200\n\n return (responses)","def prediction():\n # retweets_only = request.args.get('retweets_only')\n # api.set_retweet_checking(strtobool(retweets_only.lower()))\n # with_sentiment = request.args.get('with_sentiment')\n # api.set_with_sentiment(strtobool(with_sentiment.lower()))\n # query = request.args.get('query')\n # api.set_query(query)\n\n # tweets = api.get_tweets()\n perdiction = api.get_perdiction()\n\n return perdiction","def _load_data(self):\n self.mapper = Mapper()\n self.mapper.generate_vocabulary(self.review_summary_file)\n self.X_fwd, self.X_bwd, self.Y = self.mapper.get_tensor(reverseflag=True)\n # Store all the mapper values in a dict for later recovery\n self.mapper_dict = dict()\n self.mapper_dict['seq_length'] = self.mapper.get_seq_length()\n self.mapper_dict['vocab_size'] = self.mapper.get_vocabulary_size()\n self.mapper_dict['rev_map'] = self.mapper.get_reverse_map()\n # Split into test and train data\n self._split_train_tst()","def get_dataset(FOLD, AR_PERCENTAGE, d_type='yelp', AUTHOR='inf', POST='inf'):\n global AR_TYPE\n\n # dataset = loader.load(d_type, AUTHOR, POST)\n first_dataset = loader.unimportant_load(AUTHOR, POST * FOLD, AR_TYPE)\n datasets = first_dataset.fold_to(FOLD)\n \n for i in range(0, len(datasets)):\n dataset = datasets[i]\n dataset.divide_ar_ir(AR_PERCENTAGE)\n texts = []\n\n # check if we have this dataset already calculated.\n \n ir_filename = 'processed/' + get_ir_identifier(d_type, i, AUTHOR, POST)\n ar_filename = 'processed/' + get_ar_identifier(d_type, i, AUTHOR, POST)\n\n ir_features = None\n if os.path.isfile(ir_filename):\n print '@get: we have the file', ir_filename, 'and going to load it.'\n with open(ir_filename, 'rb') as fp:\n ir_features = pickle.load(fp)\n \n ar_features = None\n if os.path.isfile(ar_filename):\n print '@get: we have the file', ar_filename, 'and going to load it.'\n with open(ar_filename, 'rb') as fp:\n ar_features = pickle.load(fp)\n\n\n if ir_features is not None:\n for author in dataset.authors:\n dataset.features[author][-1] = ir_features[author]\n\n if ar_features is not None:\n for author in dataset.authors:\n dataset.features[author][:-1] = ar_features[author]\n\n for author in dataset.authors:\n if ar_features is None:\n texts.extend(dataset.get_ars(author))\n if ir_features is None: \n texts.append(dataset.get_ir(author))\n\n print '@getting_features, #dataset'#, index_fold\n pool = Pool(processes=NUMBER_OF_CORES)\n it = pool.imap(get_dataset_features, texts)\n pool.close()\n pool.join()\n\n print '@getting_features FINISHED, adding features to dictionary'\n for author in dataset.authors:\n # for each ar + ir, get back the features\n if ar_features is None:\n for i in range(0, dataset.get_ar_size(author)):\n dataset.put_feature(author, i, it.next())\n if ir_features is None:\n dataset.put_feature(author, dataset.get_ar_size(author), it.next())\n\n if ir_features is None:\n print '@get: we DONOT have the file', ir_filename, 'is going to be created and saved.'\n with open(ir_filename, 'wb') as fp:\n tmp = dict()\n for key, value in dataset.features.iteritems():\n tmp[key] = value[-1]\n pickle.dump(tmp, fp)\n\n if ar_features is None:\n print '@get: we DONOT have the file', ar_filename, 'is going to be created and saved.'\n with open(ar_filename, 'wb') as fp:\n tmp = defaultdict(list)\n for key, value in dataset.features.iteritems():\n tmp[key] = value[:-1]\n pickle.dump(tmp, fp)\n\n return datasets","def predict_api():\n pass","def load_data():\n t = time()\n print 'loading tweets, please wait...'\n trained_tweets = load_tweets('training_dataset')\n eval_tweets = load_tweets('evaluation_dataset')\n print 'Time taken {}'.format(time() - t)\n t = time()\n print 'loading w2v model, please wait...'\n model = w2v_load_model('GoogleNews-vectors-negative300.bin')\n print 'Time taken {}'.format(time() - t)\n return trained_tweets, eval_tweets, model","def _load_data(self):\n if self._api_response.status_code == 200:\n self._dataset = self._api_response.json()\n self._fill_day_dicts()","def test_api_predictors_get(self):\n pass","def get_predictions():\n\n print(\"OK1\");\n print(\"OK2\");\n return;","def download_models_and_data():\n\n for file in DATA_FILES:\n download_file(file[\"url\"], file[\"path\"])","def get_predictions(self, sess, dSet=None, dataX=None, dataY=None):\n \n feed_dict = {self.isTraining : False}\n\n if dataX is not None and dataY is not None:\n feed_dict[self.features] = dataX\n feed_dict[self.labels] = dataY\n return sess.run([self.prediction], feed_dict) \n\n if dSet is \"train\":\n sess.run(self.train_iter.initializer)\n feed_dict[self.handle] = self.train_handle\n elif dSet is \"val\":\n sess.run(self.valid_iter.initializer)\n feed_dict[self.handle] = self.valid_handle\n elif dSet is \"test\":\n sess.run(self.test_iter.initializer)\n feed_dict[self.handle] = self.test_handle\n else:\n print(\"ERROR: Do not recognize dataset {}\".format(dSet))\n raise RuntimeError\n\n if feed_dict[self.handle] is None:\n raise RuntimeError(\"Cannot evaluate with handle = None\")\n\n try:\n runningPredictions = sess.run([self.prediction], feed_dict)\n except tf.errors.OutOfRangeError:\n print(\"Error: Cannot get predictions because dataset is empty\")\n raise RuntimeError\n\n while True:\n # Get batch data\n try :\n runningPredictions.concatenate(\n sess.run([self.prediction], feed_dict), \n axis=0)\n except tf.errors.OutOfRangeError:\n break\n\n return runningPredictions","def get(self):\n from models.prediction import Prediction\n from models.feedback import Feedback\n\n prediction_collection = Prediction._get_collection()\n feedback_collection = Feedback._get_collection()\n statistical_data = copy.deepcopy(CONSTANTS['STATISTICAL_DATA'])\n\n # initial statistical_data based on age and ascending order\n total_age = []\n for i in range(21):\n total_age.append(str(i * 5) + '+')\n\n for each_age in total_age:\n statistical_data['prediction_data']['age'][each_age] = 0\n statistical_data['feedback_data']['age']['wrong'][each_age] = 0\n statistical_data['feedback_data']['age']['correct'][each_age] = 0\n\n # photo by date\n today = datetime.datetime.today().replace(hour=0, minute=0, second=0, microsecond=0)\n total_number_of_photo_within_one_week = {\n (today - datetime.timedelta(days=6)).strftime('%d/%m/%Y'): prediction_collection.count_documents(\n {'date': {'$lt': today - datetime.timedelta(days=5), '$gte': today - datetime.timedelta(days=6)}}),\n (today - datetime.timedelta(days=5)).strftime('%d/%m/%Y'): prediction_collection.count_documents(\n {'date': {'$lt': today - datetime.timedelta(days=4), '$gte': today - datetime.timedelta(days=5)}}),\n (today - datetime.timedelta(days=4)).strftime('%d/%m/%Y'): prediction_collection.count_documents(\n {'date': {'$lt': today - datetime.timedelta(days=3), '$gte': today - datetime.timedelta(days=4)}}),\n (today - datetime.timedelta(days=3)).strftime('%d/%m/%Y'): prediction_collection.count_documents(\n {'date': {'$lt': today - datetime.timedelta(days=2), '$gte': today - datetime.timedelta(days=3)}}),\n (today - datetime.timedelta(days=2)).strftime('%d/%m/%Y'): prediction_collection.count_documents(\n {'date': {'$lt': today - datetime.timedelta(days=1), '$gte': today - datetime.timedelta(days=2)}}),\n (today - datetime.timedelta(days=1)).strftime('%d/%m/%Y'): prediction_collection.count_documents(\n {'date': {'$lt': today, '$gte': today - datetime.timedelta(days=1)}}),\n today.strftime('%d/%m/%Y'): prediction_collection.count_documents(\n {'date': {'$gte': today}}),\n }\n\n # prediction\n total_prediction = prediction_collection.find({})\n\n for each_prediction in total_prediction:\n prediction_results = each_prediction['predictionResults']\n for each_result in prediction_results:\n statistical_data['prediction_number'] = statistical_data.get(\n 'prediction_number', 0) + 1\n\n # age, gender, emotion\n each_age = str(5*math.floor(each_result['age'] / 5)) + '+'\n\n statistical_data['prediction_data']['age'][each_age] = \\\n statistical_data['prediction_data']['age'].get(each_age, 0) + 1\n statistical_data['prediction_data']['gender'][each_result['gender']] = \\\n statistical_data['prediction_data']['gender'].get(each_result['gender'], 0) + 1\n statistical_data['prediction_data']['emotion'][each_result['emotion']] = \\\n statistical_data['prediction_data']['emotion'].get(each_result['emotion'], 0) + 1\n\n # feedback\n total_feedback = feedback_collection.find({})\n\n for each_feedback in total_feedback:\n feedback_content = each_feedback['content']\n for each_content in feedback_content:\n statistical_data['feedback_number'] = statistical_data.get(\n 'feedback_number', 0) + 1\n\n # age\n if each_content['ageCorrectness'] == False:\n statistical_data['feedback_data']['age']['wrong'][\n each_content['ageFeedback']] = \\\n statistical_data['feedback_data']['age'][\n 'wrong'].get(each_content['ageFeedback'], 0) + 1\n else:\n statistical_data['feedback_data']['age']['correct'][\n each_content['ageFeedback']] = \\\n statistical_data['feedback_data']['age']['correct'].get(\n each_content['ageFeedback'], 0) + 1\n\n # gender\n if each_content['genderCorrectness'] == False:\n statistical_data['feedback_data']['gender']['wrong'][\n each_content['genderFeedback']] = \\\n statistical_data['feedback_data']['gender'][\n 'wrong'].get(each_content['genderFeedback'], 0) + 1\n else:\n statistical_data['feedback_data']['gender']['correct'][\n each_content['genderFeedback']] = \\\n statistical_data['feedback_data']['gender']['correct'].get(\n each_content['genderFeedback'], 0) + 1\n\n if each_content['emotionCorrectness'] == False:\n statistical_data['feedback_data']['emotion']['wrong'][\n each_content['emotionFeedback']] = \\\n statistical_data['feedback_data']['emotion']['wrong'].get(\n each_content['emotionFeedback'], 0) + 1\n else:\n statistical_data['feedback_data']['emotion']['correct'][\n each_content['emotionFeedback']] = \\\n statistical_data['feedback_data']['emotion']['correct'].get(\n each_content['emotionFeedback'], 0) + 1\n\n result = {\n 'totalNumberOfPhotoUploaded': prediction_collection.count_documents({}),\n\n 'totalNumberOfPrediction': statistical_data['prediction_number'],\n 'totalNumberOfFeedback': statistical_data['feedback_number'],\n\n 'totalNumberOfAgePrediction': statistical_data['prediction_data']['age'],\n 'totalNumberOfAgeCorrectFeedback': statistical_data['feedback_data']['age']['correct'],\n 'totalNumberOfAgeWrongFeedback': statistical_data['feedback_data']['age']['wrong'],\n\n 'totalNumberOfGenderPrediction': statistical_data['prediction_data']['gender'],\n 'totalNumberOfGenderCorrectFeedback': statistical_data['feedback_data']['gender']['correct'],\n 'totalNumberOfGenderWrongFeedback': statistical_data['feedback_data']['gender']['wrong'],\n\n 'totalNumberOfEmotionPrediction': statistical_data['prediction_data']['emotion'],\n 'totalNumberOfEmotionCorrectFeedback': statistical_data['feedback_data']['emotion']['correct'],\n 'totalNumberOfEmotionWrongFeedback': statistical_data['feedback_data']['emotion']['wrong'],\n\n 'numberOfPhotoByDate': total_number_of_photo_within_one_week\n }\n\n return send_json_response(result, 200)","def fetch_data(self):\n\n data_dict = {\n 'price': self.get_current_price(),\n }\n\n return self.save_data(data_dict)","def load_data(nlp, cue_verbs, poly):\n train_dicts, _ = load_quote_authors(nlp)\n author_prediction_dataset = AuthorPredictionDataset(train_dicts, cue_verbs, poly)\n return np.array(train_dicts), author_prediction_dataset","def prepare_data(self):\n try:\n self.train_dataset = self.datasets['train']\n self.val_dataset = self.datasets['val']\n try:\n self.test_dataset = self.datasets['test']\n except:\n pass\n except Exception as e:\n print('Data was not succesfully prepared:', e)","def fetch(self):\n pass","def fetch(self):\n pass","def get_data():\n log = common.LogFile('', LOGFILE)\n settings = load_settings()\n keywords = settings[\"keywords\"]\n api_key = settings[\"api_key\"]\n for keyword in keywords:\n print(\"[{}] : fetching data.\".format(keyword))\n filename = \"results_{0}.json\".format(keyword)\n results = {}\n hits_limit = 500\n start_at = 1\n counter = 0\n while True:\n url = create_url(keyword, hits_limit, start_at, api_key)\n records = get_records_from_url(url)\n total_results = get_total_hits(records)\n records = split_records(records)\n records_on_page = len(records)\n if records_on_page == 0:\n break\n else:\n for record in records:\n counter += 1\n id_no = extract_id_number(record)\n processed_dict = {'ID': id_no, 'problem': []}\n processed_record = parse_record(\n record, processed_dict, log)\n if id_no not in results:\n results[id_no] = processed_record\n if counter % 100 == 0:\n print(\"Processed {} out of {}\".format(\n counter, total_results))\n start_at += hits_limit\n time.sleep(THROTTLE)\n print(\"[{}] : fetched {} records to {}.\".format(\n keyword, len(results), filename))\n save_data(results, filename)","def run_all():\n db = DBInterface()\n year = Config.get_property(\"league_year\")\n session = Session(bind=db.engine)\n\n scraper.scrape_all(db, session, year)\n session.commit()\n\n bets.predict_all(db, session)\n session.commit()\n session.close()","def _get_predictions(self, data, break_ties=\"random\", return_probs=False, **kwargs):\n data_loader = self._create_data_loader(data)\n Y_p = []\n Y = []\n Y_s = []\n\n # Do batch evaluation by default, getting the predictions and labels\n for batch_num, data in enumerate(data_loader):\n Xb, Yb = data\n Y.append(self._to_numpy(Yb))\n\n # Optionally move to device\n if self.config[\"device\"] != \"cpu\":\n Xb = place_on_gpu(Xb)\n\n # Append predictions and labels from DataLoader\n Y_pb, Y_sb = self.predict(\n Xb, break_ties=break_ties, return_probs=True, **kwargs\n )\n Y_p.append(self._to_numpy(Y_pb))\n Y_s.append(self._to_numpy(Y_sb))\n Y_p, Y, Y_s = map(self._stack_batches, [Y_p, Y, Y_s])\n if return_probs:\n return Y_p, Y, Y_s\n else:\n return Y_p, Y","def fetch(self) -> None:\n pass","def fetch_data():\n log = logging.getLogger(__name__)\n log.info('Checking data files...')\n if not os.path.isfile('CGN.txt'):\n params_cgn = {\n 'institute.code': ['NLD037'],\n # 'crops': ['tomato'],\n 'taxonomy.genus': ['Solanum', 'Lycopersicon'],\n 'taxonomy.species': species\n }\n cgn = GenesysParser(params_cgn)\n cgn.fetch2json('CGN.txt')\n log.info('CGN data has been saved.')\n else:\n log.info('CGN data file already exists.')\n\n if not os.path.isfile('USDA.txt'):\n params_usda = {\n 'institute.code': usda_all,\n # 'crops': ['tomato'],\n 'taxonomy.genus': ['Solanum', 'Lycopersicon'],\n 'taxonomy.species': species\n }\n usda = GenesysParser(params_usda)\n usda.fetch2json('USDA.txt')\n log.info('USDA data has been saved.')\n else:\n log.info('USDA data file already exists.')","def evaluate():\n log.info('Loading dev data...')\n if args.version_2:\n dev_data = SQuAD('dev', version='2.0')\n else:\n dev_data = SQuAD('dev', version='1.1')\n (_, _), (data_file_name, _) \\\n = dev_data._data_file[dev_data._version][dev_data._segment]\n dev_data_path = os.path.join(dev_data._root, data_file_name)\n\n if args.debug:\n sampled_data = [dev_data[0], dev_data[1], dev_data[2]]\n dev_data = mx.gluon.data.SimpleDataset(sampled_data)\n log.info('Number of records in dev data: %d', len(dev_data))\n\n dev_data_features = preprocess_dataset(\n tokenizer, dev_data, vocab=vocab, max_seq_length=args.max_seq_length,\n doc_stride=args.doc_stride, num_workers=args.num_workers,\n max_query_length=args.max_query_length, load_from_pickle=args.load_pickle,\n feature_file=args.dev_dataset_file)\n\n dev_data_input = convert_full_features_to_input_features(dev_data_features)\n log.info('The number of examples after preprocessing: %d', len(dev_data_input))\n\n dev_dataloader = mx.gluon.data.DataLoader(dev_data_input, batchify_fn=batchify_fn,\n num_workers=4, batch_size=args.test_batch_size,\n shuffle=False, last_batch='keep')\n\n log.info('start prediction')\n\n all_results = collections.defaultdict(list)\n\n epoch_tic = time.time()\n total_num = 0\n for (batch_id, data) in enumerate(dev_dataloader):\n data_list = list(split_and_load(data, ctx))\n for splited_data in data_list:\n example_ids, inputs, token_types, valid_length, p_mask, _, _, _ = splited_data\n total_num += len(inputs)\n outputs = net_eval(inputs, token_types, valid_length, p_mask=p_mask)\n example_ids = example_ids.asnumpy().tolist()\n for c, example_ids in enumerate(example_ids):\n result = RawResultExtended(start_top_log_probs=outputs[0][c].asnumpy().tolist(),\n start_top_index=outputs[1][c].asnumpy().tolist(),\n end_top_log_probs=outputs[2][c].asnumpy().tolist(),\n end_top_index=outputs[3][c].asnumpy().tolist(),\n cls_logits=outputs[4][c].asnumpy().tolist())\n all_results[example_ids].append(result)\n if batch_id % args.log_interval == 0:\n log.info('Batch: %d/%d', batch_id + 1, len(dev_dataloader))\n\n epoch_toc = time.time()\n log.info('Time cost=%2f s, Thoughput=%.2f samples/s', epoch_toc - epoch_tic,\n total_num / (epoch_toc - epoch_tic))\n\n log.info('Get prediction results...')\n\n all_predictions = collections.OrderedDict()\n all_nbest_json = collections.OrderedDict()\n scores_diff_json = collections.OrderedDict()\n for features in dev_data_features:\n results = all_results[features[0].example_id]\n example_qas_id = features[0].qas_id\n score_diff, best_non_null_entry, nbest_json = predict_extended(\n features=features, results=results, n_best_size=args.n_best_size,\n max_answer_length=args.max_answer_length, start_n_top=args.start_top_n,\n end_n_top=args.end_top_n)\n scores_diff_json[example_qas_id] = score_diff\n all_predictions[example_qas_id] = best_non_null_entry\n all_nbest_json[example_qas_id] = nbest_json\n\n output_prediction_file = os.path.join(args.output_dir, 'predictions.json')\n output_nbest_file = os.path.join(args.output_dir, 'nbest_predictions.json')\n output_null_log_odds_file = os.path.join(args.output_dir, 'null_odds.json')\n\n with open(output_prediction_file, 'w') as writer:\n writer.write(json.dumps(all_predictions, indent=4) + '\\n')\n with open(output_nbest_file, 'w') as writer:\n writer.write(json.dumps(all_nbest_json, indent=4) + '\\n')\n with open(output_null_log_odds_file, 'w') as writer:\n writer.write(json.dumps(scores_diff_json, indent=4) + '\\n')\n\n if os.path.exists(sys.path[0] + '/evaluate-v2.0.py'):\n arguments = [\n dev_data_path, output_prediction_file, '--na-prob-thresh',\n str(args.null_score_diff_threshold)\n ]\n if args.version_2:\n arguments += ['--na-prob-file', output_null_log_odds_file]\n subprocess.call([sys.executable, sys.path[0] + '/evaluate-v2.0.py'] + arguments)\n else:\n log.info('Please download evaluate-v2.0.py to get evaluation results for SQuAD. '\n 'Check index.rst for the detail.')","def get_data_loaders():\n dataset_path = \"\"\n dataset_cache = None\n personachat = get_dataset(dataset_path, dataset_cache)\n\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\n logger.info(\"Build inputs and labels\")\n datasets = {\"train\": defaultdict(list), \"valid\": defaultdict(list)}\n personality = []\n history_complete = []\n count_persona = 0\n with open('data_faiss_pegasus_2sentences_finalgenerated.pkl', 'rb') as f:\n persona_selected_list = pickle.load(f)\n for dataset_name, dataset in personachat.items():\n num_candidates = len(dataset[0][\"utterances\"][0][\"candidates\"])\n if num_candidates > 0 and dataset_name == 'train':\n num_candidates = min(1, num_candidates)\n for dialog in dataset:\n persona = dialog[\"persona_info\"].copy()\n #datasets[personality].append(persona)\n count_history = 0\n for utterance in dialog[\"utterances\"]:\n count_history = count_history + 1\n history = utterance[\"history\"][-(2*2+5):]\n \n #history_complete.append(history)\n if len(persona) == 4:\n if len(history) > (len(persona)+3):\n history_chatbot = history[1::2]\n persona_selected = persona_selected_list[count_persona]\n instance = build_input_from_segments_faiss_2(persona, history_chatbot) \n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n count_persona = count_persona + 1\n return datasets","def get_data(self):\n has_next_page = True\n page = 1\n while has_next_page:\n print(f'Getting page {page}')\n response = self.get_articles(\n page=page,\n size=200,\n order_by='extracted_at',\n order_type='asc'\n )\n pagination = response.get('pagination')\n has_next_page = pagination.get('has_next')\n self.save_articles(response.get('articles'))\n page += 1\n time.sleep(2.5)","def get_real_and_pred_data():\n if request.method == 'POST':\n \n entry = json.loads(request.data)\n \n date = entry['date']\n\n res = {}\n\n time_series, time_series_pred = make_predictions(time_series_logs, forecasting_models, \n FORECASTING_TARGETS, date)\n \n for target in FORECASTING_TARGETS:\n \n target_val = list(time_series[target])\n target_pred_val = list(time_series_pred[target])\n res[target] = target_val\n res[target + '_pred'] = target_pred_val\n \n xticks = list(map(str, time_series_pred['date']))\n \n \n \n res['xticks'] = xticks\n \n json_data = json.dumps(res)\n resp = Response(json_data, status=200, mimetype='application/json')\n resp.headers = {'Access-Control-Allow-Origin': '*'}\n\n return resp\n \n else:\n return 'only get request is allowed'","def predict_all():\n\n # need train dir to list category names\n cfg = configparser.ConfigParser()\n cfg.read(sys.argv[1])\n base = os.environ['DATA_ROOT']\n eval_type = cfg.get('args', 'eval_type')\n train_xml_dir = os.path.join(base, cfg.get('data', 'train_xml_dir'))\n\n if eval_type == 'sparse':\n predict_sparse(train_xml_dir)\n else:\n predict_dense(train_xml_dir)","def load_data(self):\n\n self._load_train_data()\n self._load_test_data()","def fetch(self,url=URL):\n\t\tlog.info('downloading latest PHE case data')\n#\t\tself.data=lookup_json(url)\n\t\tself.fetch_csv() #JSON discontinued; switched back to CSV\n\t\tself.edition=self.latest_samples\n\t\tlog.info(f'Last samples from {self.edition}')","def trainAndPredict(self):\r\n print(\"train\")\r\n filename= 'finalized_model.sav'\r\n # train the algorithm on training data and predict using the testing data\r\n model = self.svc_model.fit(self.X.T, self.Y)\r\n pickle.dump(model, open(filename, 'wb'))\r\n #model = pickle.load(open(filename, 'rb'))\r\n pred1 =model.predict(self.TestSet.T)\r\n # print the accuracy score of the model\r\n print(\"LinearSVC accuracy : \", accuracy_score(self.TestSetY, pred1, normalize=True))","def predict(self, **options):\n dependent_dataset = \"/\".join(self.api_path.split(\"/\")[:-1])\n op_json = self.client.post(dependent_dataset + \":refresh\").successful().json()\n op = Operation.from_json(self.client, op_json)\n return op.apply_options(**options)","def load_data(self):\r\n self.logger.log(self.log_file, 'Loading prediction data!')\r\n try:\r\n prediction_data = self.aws_operations.read_csv(self.prediction_file_path)\r\n if prediction_data is None:\r\n return None\r\n self.logger.log(self.log_file, 'Prediction data loaded successfully!')\r\n return prediction_data\r\n except Exception as e:\r\n self.logger.log(self.log_file, 'Error occurred while loading prediction data: %s' % e)\r\n raise e","def load_data():\n print(\"PARSING TRAIN\")\n ys_train, x_train, ids_train = load_pickle_data(\"ys_train\"), load_pickle_data(\"x_train\"), load_pickle_data(\n \"ids_train\")\n if ys_train is None or x_train is None or ids_train is None:\n ys_train, x_train, ids_train = load_csv_data(\"{}/train.csv\".format(DATA_DIR))\n dump_pickle_data(ys_train, \"ys_train\")\n dump_pickle_data(x_train, \"x_train\")\n dump_pickle_data(ids_train, \"ids_train\")\n\n print(\"PARSING TEST\")\n x_test, ids_test = load_pickle_data(\"x_test\"), load_pickle_data(\"ids_test\")\n if x_test is None or ids_test is None:\n _, x_test, ids_test = load_csv_data(\"{}/test.csv\".format(DATA_DIR))\n dump_pickle_data(x_test, \"x_test\")\n dump_pickle_data(ids_test, \"ids_test\")\n\n return ys_train, x_train, ids_train, x_test, ids_test","def main():\n df = prepro_last()\n X, y = train_build(df)\n fit_store(X, y)","def prepare_data():\n user_name = os.environ.get('USER')\n traintest_corpus = ResumeCorpus('/Users/' + user_name + '/Documents/Data')\n random.shuffle(traintest_corpus.resumes)\n\n for resume in traintest_corpus.resumes:\n try:\n review_text = pre_processing(resume[0])\n review_text = \" \".join(review_text)\n data_dict['data'].append(review_text)\n data_dict['label'].append(resume[1])\n except:\n pass","def download_and_preprocess(self):\n print('Preparing steering angle database.')\n print('Downloading...')\n self.download()\n print('Preprocessing...')\n self.preprocess()","def prepare_data(self):\n import subprocess\n # Download coco data set into dir specified by config then /data/coco\n subprocess.call([f\"{get_original_cwd()}/bin/fetch_dataset.sh\", f\"{self.dir}/data/coco\", f\"{get_original_cwd()}\"])\n # subprocess.call([f\"bin/fetch_dataset.sh\", f\"{self.dir}/data/coco\"])\n task = \"instances\" if self.instance else \"person_keypoints\"\n register_coco_instances(\"train\", {}, f\"{self.dir}/data/coco/{task}_train2014.json\",\n f\"{self.dir}/data/coco/train2014\")\n register_coco_instances(\"val\", {}, f\"{self.dir}/data/coco/{task}_minival2014.json\",\n f\"{self.dir}/data/coco/val2014\")\n register_coco_instances(\"test\", {}, f\"{self.dir}/data/coco/{task}_valminusminival2014.json\",\n f\"{self.dir}/data/coco/val2014\")","def fetch_data():\n if request.method == 'GET':\n return (\"Use this endpoint with POST method to fetch data\", 200)\n elif request.method == 'POST':\n # request data\n app.logger.info(\"Requesting data\")\n data = get_data('regulatorydecision')\n\n # write to file\n app.logger.info(\"Writing to file\")\n write_to_file(data)\n\n # upload to cloud storage\n app.logger.info(\"Uploading to GCS\")\n upload_to_gcs('data.json', 'health-ca-data-staging')\n\n # publish message to pubsub\n app.logger.info(\"Publishing status message to Pubsub\")\n message = \"Data uploaded to GCS\"\n pubsub_publish('projects/health-ca-data/topics/gcs_load', message, \"\")\n\n return (\"Fetching data\", 200)","def load_predicted_results(self):\n print(\"\\n\\nLoad prediction answers : \")\n with open(\"predicted_results\", \"rb\") as predicted_results:\n self.predicted_results = pickle.load(predicted_results)","def do_predict(self):\n answer = []\n response = []\n\n for it_predictions in json.loads(request.data.decode('UTF-8')):\n prediction = it_predictions['score']\n for ite_clf in g_list_of_classifier:\n answer.append(ite_clf.predict(prediction))\n if answer.count(True) > answer.count(False):\n response.append({'answer' : True})\n else:\n response.append({'answer' : False})\n return json.dumps(response, indent=4)","def predict(self, stories, queries):\n feed_dict = {self._stories: stories, self._queries: queries}\n return self._sess.run(self.predict_op, feed_dict=feed_dict)","def main():\n datasets = {}\n for dataset_name in tqdm(SOURCE_DATASET_NAMES, desc=\"Processing datasets and fitting base models\"):\n logger.info(f\"processing dataset {dataset_name}\")\n clusters_path: Optional[str] = None\n if dataset_name not in PAIRWISE_ONLY_DATASETS:\n clusters_path = os.path.join(DATA_DIR, dataset_name, dataset_name + \"_clusters.json\")\n train_pairs_path = None\n val_pairs_path = None\n test_pairs_path = None\n else:\n train_pairs_path = os.path.join(DATA_DIR, dataset_name, \"train_pairs.csv\")\n val_pairs_path = os.path.join(DATA_DIR, dataset_name, \"val_pairs.csv\")\n if not os.path.exists(val_pairs_path):\n val_pairs_path = None\n test_pairs_path = os.path.join(DATA_DIR, dataset_name, \"test_pairs.csv\")\n\n logger.info(f\"loading dataset {dataset_name}\")\n anddata = ANDData(\n signatures=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_signatures.json\"),\n papers=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_papers.json\"),\n name=dataset_name,\n mode=\"train\",\n specter_embeddings=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_specter.pickle\"),\n clusters=clusters_path,\n block_type=BLOCK_TYPE,\n train_pairs=train_pairs_path,\n val_pairs=val_pairs_path,\n test_pairs=test_pairs_path,\n train_pairs_size=N_TRAIN_PAIRS_SIZE,\n val_pairs_size=N_VAL_TEST_SIZE,\n test_pairs_size=N_VAL_TEST_SIZE,\n preprocess=True,\n )\n\n logger.info(f\"featurizing {dataset_name}\")\n train, val, test = featurize(\n anddata,\n FEATURIZER_INFO,\n n_jobs=N_JOBS,\n use_cache=True,\n chunk_size=100,\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO,\n nan_value=NAN_VALUE,\n )\n X_train, y_train, nameless_X_train = train\n X_val, y_val, nameless_X_val = val\n X_test, y_test, nameless_X_test = test\n\n dataset = {}\n dataset[\"anddata\"] = anddata\n dataset[\"X_train\"] = X_train\n dataset[\"y_train\"] = y_train\n dataset[\"X_val\"] = X_val\n dataset[\"y_val\"] = y_val\n dataset[\"X_test\"] = X_test\n dataset[\"y_test\"] = y_test\n dataset[\"nameless_X_train\"] = nameless_X_train\n dataset[\"nameless_X_val\"] = nameless_X_val\n dataset[\"nameless_X_test\"] = nameless_X_test\n dataset[\"name\"] = anddata.name\n datasets[dataset_name] = dataset\n\n anddatas = [\n datasets[dataset_name][\"anddata\"]\n for dataset_name in SOURCE_DATASET_NAMES\n if dataset_name not in PAIRWISE_ONLY_DATASETS\n ]\n\n X_train = np.vstack([datasets[dataset_name][\"X_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n y_train = np.hstack([datasets[dataset_name][\"y_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n X_val = np.vstack(\n [datasets[dataset_name][\"X_val\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\"augmented\"}]\n )\n y_val = np.hstack(\n [datasets[dataset_name][\"y_val\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\"augmented\"}]\n )\n\n nameless_X_train = np.vstack([datasets[dataset_name][\"nameless_X_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n nameless_X_val = np.vstack(\n [\n datasets[dataset_name][\"nameless_X_val\"]\n for dataset_name in SOURCE_DATASET_NAMES\n if dataset_name not in {\"augmented\"}\n ]\n )\n\n logger.info(\"fitting pairwise\")\n union_classifier = PairwiseModeler(n_iter=N_ITER, monotone_constraints=MONOTONE_CONSTRAINTS)\n union_classifier.fit(X_train, y_train, X_val, y_val)\n\n nameless_union_classifier = None\n if USE_NAMELESS_MODEL:\n logger.info(\"nameless fitting pairwise for \" + str(SOURCE_DATASET_NAMES))\n nameless_union_classifier = PairwiseModeler(\n n_iter=N_ITER,\n monotone_constraints=NAMELESS_MONOTONE_CONSTRAINTS,\n )\n nameless_union_classifier.fit(nameless_X_train, y_train, nameless_X_val, y_val)\n logger.info(\"nameless pairwise fit for \" + str(SOURCE_DATASET_NAMES))\n\n logger.info(\"fitting clusterer for\")\n union_clusterer = Clusterer(\n FEATURIZER_INFO,\n union_classifier.classifier,\n cluster_model=FastCluster(),\n search_space=search_space,\n n_jobs=N_JOBS,\n nameless_classifier=nameless_union_classifier.classifier if nameless_union_classifier is not None else None,\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO if nameless_union_classifier is not None else None,\n )\n union_clusterer.fit(anddatas)\n print(\n \"best clustering parameters:\",\n union_clusterer.best_params,\n )\n\n models = {}\n models[\"clusterer\"] = union_clusterer\n\n with open(\n f\"full_union_model_script_dump_average_{FEATURIZER_VERSION}.pickle\",\n \"wb\",\n ) as _pickle_file:\n pickle.dump(models, _pickle_file)\n logger.info(\"Done.\")","def fetch_training_data(filename, output, db_url=None):\n r2dt.write_training_data(filename, db_url, output)","def predict():\n \n ## input checking\n if not request.json:\n print(\"ERROR: API (predict): did not receive request data\")\n return jsonify([])\n\n if 'query' not in request.json:\n print(\"ERROR: API (predict): received request, but no 'query' found within\")\n return jsonify([])\n\n ## set the test flag\n test = False\n if 'mode' in request.json and request.json['mode'] == 'test':\n test = True\n\n ## extract the query\n query = request.json['query']\n \n ## load model\n if test:\n data, models = model_load(prefix='test')\n else:\n data, models = model_load()\n \n if not models:\n print(\"ERROR: API (predict): models not available\")\n return jsonify([])\n\n _result = model_predict(**query,all_models=models,test=test)\n result = {}\n \n ## convert numpy objects to ensure they are serializable\n for key,item in _result.items():\n if isinstance(item,np.ndarray):\n result[key] = item.tolist()\n else:\n result[key] = item\n \n return(jsonify(result))","def predict(self, data):\n\t\tres = self.neuralNetworks.inference(self.dataCenter.process_inference_data(data))\n\t\tprint(res)","def dataloader(self):\n\n # load / split data\n train_data = self.data.get_train_data()\n if self.args.use_dev:\n train_data, dev_data = self.data.split_data(train_data)\n test_data = self.data.get_test_data()\n\n #print(train_data[0])\n #print(dev_data[0])\n #print(test_data[0])\n\n # build dataset\n train_dataset = self.loader.build_dataset(\n train_data, \n self.args.train_max_seq_len)\n train_loader = self.loader.build_dataloader(\n train_dataset, 'train')\n\n test_dataset = self.loader.build_dataset(\n test_data,\n self.args.eval_max_seq_len)\n test_loader = self.loader.build_dataloader(\n test_dataset, 'test')\n\n if self.args.use_dev:\n dev_dataset = self.loader.build_dataset(\n dev_data,\n self.args.eval_max_seq_len)\n dev_loader = self.loader.build_dataloader(\n dev_dataset, 'dev')\n return train_loader, dev_loader, test_loader\n else:\n return train_loader, test_loader","def load_raw_data(self):\n if self.trendfile:\n self.raw_data = self.get_ap_file()\n else:\n report_params = self.format_api_request_params()\n report_params['test'] = self.testresults\n\n self.raw_data = self.get_ap_report(params=report_params)","def predict():\n\n\n json_payload = request.json\n #LOG.info(f\"JSON payload: %s\" %json_payload)\n inference_payload = pd.DataFrame(json_payload)\n #LOG.info(\"inference payload DataFrame: %s\" %inference_payload)\n scaled_payload = scale(inference_payload)\n prediction = list(clf.predict(scaled_payload))\n return jsonify({'prediction': prediction})","def train_predict_and_results(data, clf):\n tra_x, tst_x, tra_y, tst_y = data\n clf.fit(tra_x, tra_y)\n prd_y = clf.predict(tst_x)\n cnf = confusion_matrix(tst_y, prd_y)\n print (\"Classifier: %s \\tAccuracy score:%7.2f %%\"\n \"\\tTN:%5d FP:%5d FN:%5d TP:%5d\"\n % (clf.name, accuracy_score(tst_y, prd_y) * 100,\n cnf[0][0], cnf[0][1], cnf[1][0], cnf[1][1]))","def predict():\n\n if request.is_json:\n req = request.get_json(force=True)\n df = pd.read_json(req, orient='records')\n return pd.DataFrame(clf_loaded.predict(df).round()).to_json(orient='records')","def get_prediction(data):\n # load cannabis data\n strains = pd.read_csv(URL)\n # Combine the Effects and Flavors in one column\n strains['Criteria'] = strains['Effects'] + ',' + strains['Flavor']\n\n # Train model on dtm\n nn = NearestNeighbors(n_neighbors=5, algorithm='ball_tree')\n nn.fit(dtm)\n\n # load request data\n # r = data.args\n entry = [v for k,v in data.items()][1:]\n #print(entry)\n # transform\n new = tf.transform(entry)\n #print(new)\n results = nn.kneighbors(new.todense())\n #print(results)\n # extract top 5 results\n output = [strains['Strain'][results[1][0][i]] for i in range(5)]\n\n return output","def main():\n\n # Start and import data\n print('>>>>> START')\n dates, prices, price_diff = get_data('data.csv')\n indices = [i for i in range(0, len(prices))]\n \n # Quick filtering to enable good visualization\n # This section can be commented if wished\n delete_outlayers(dates, price_diff)\n delete_outlayers(prices, price_diff)\n delete_outlayers(indices, price_diff)\n price_diff.remove(max(price_diff))\n price_diff.remove(min(price_diff))\n print('>>>>> STATUS: DATA FORMATTING DONE')\n\n # Model and prediction\n predicted_price = predict_price(indices, dates, price_diff, 1829)\n print('RESULTING PREDICTION = ', (predicted_price * -1) + prices[0])\n print('>>>>> DONE')","def do_inferences(driver, infer_url, path_to_preds, column_names, test_dict_ord):\n\n save_each = 100\n len_of_list = len(test_dict_ord)\n counter = 0\n \n driver.get(infer_url)\n \n predictions = []\n time1 = time.time()\n for row in test_dict_ord:\n \n text_model = WebDriverWait(driver, 20).until(\\\n EC.presence_of_element_located((By.ID, 'text_model')))\n\n text_model.clear()\n text_model.send_keys(MODEL)\n\n infer_types = driver.find_element_by_id('btn_infer_types')\n infer_types.click()\n WebDriverWait(driver, 20).until(\\\n EC.visibility_of_element_located((By.ID, 'values')))\n\n for name in column_names:\n _input = WebDriverWait(driver, 20).until(\\\n EC.presence_of_element_located((By.NAME, name)))\n _input.clear()\n _input.send_keys(str(row[name]))\n \n btn_infer = driver.find_element_by_id('btn_infer')\n btn_infer.click()\n \n prediction_box = WebDriverWait(driver, 20).until(\\\n EC.visibility_of_element_located((By.ID, 'new-prediction')))\n prediction = prediction_box.text\n predictions.append(prediction)\n driver.refresh()\n \n counter+=1\n if counter % save_each == 0:\n time2 = time.time()\n batch_time = time2 - time1\n print(\"Progress: {}/{}\".format(counter, len_of_list))\n print(\"Time elapsed: {}/{}\".format(str((batch_time)*(counter//save_each)), \n str(batch_time)*(len_of_list//save_each)))\n time1 = time2\n with open(path_to_preds, 'a') as f:\n for pred in predictions:\n f.write(str(pred)+'\\n')\n predictions = []\n \n with open(path_to_preds, 'a') as f:\n for pred in predictions:\n f.write(str(pred)+'\\n')","def main(self, data):\n\t\ttokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\", do_lower_case=True)\n\t\teval_features = self.get_features(data, self.labels, tokenizer, self.max_seq_length)\n\t\tlabel, prob = self.predict(eval_features)\n\t\treturn label, prob","def prepareData(mdl, X_train, X_val, X_test, Y_train, Y_val, Y_test):\n\t\n\tX2_train = []\n\n\tX2_val = []\n\n\tX2_test = []\n\n\n\tYPs = mdl.predict(X_train)\n\n\tfor i in tqdm(range(len(X_train))):\n\n\t\tX2_train.append(np.array(YPs[i]))\n\n\n\n\tYPs = mdl.predict(X_val)\n\n\tfor i in tqdm(range(len(X_val))):\n\n\t\tX2_val.append(np.array(YPs[i]))\n\n\n\n\tYPs = mdl.predict(X_test)\n\n\tfor i in tqdm(range(len(X_test))):\n\n\t\tX2_test.append(np.array(YPs[i]))\n\n\n\tX2_train = np.array(X2_train)\n\n\tX2_val = np.array(X2_val)\n\n\tX2_test = np.array(X2_test)\n\n\treturn (X2_train, X2_val, X2_test)","def execute(self, requests):\n responses = []\n for request in requests:\n infer_outputs = pb_utils.get_input_tensor_by_name(\n request, self.input_names[0])\n im_infos = pb_utils.get_input_tensor_by_name(request,\n self.input_names[1])\n ori_imgs = pb_utils.get_input_tensor_by_name(request,\n self.input_names[2])\n\n infer_outputs = infer_outputs.as_numpy()\n im_infos = im_infos.as_numpy()\n ori_imgs = ori_imgs.as_numpy()\n\n results = self.postprocessor.run([infer_outputs], im_infos)\n batch_rec_texts = []\n batch_rec_scores = []\n batch_box_list = []\n for i_batch in range(len(results)):\n\n cls_labels = []\n cls_scores = []\n rec_texts = []\n rec_scores = []\n\n box_list = fd.vision.ocr.sort_boxes(results[i_batch])\n image_list = []\n if len(box_list) == 0:\n image_list.append(ori_imgs[i_batch])\n else:\n for box in box_list:\n crop_img = get_rotate_crop_image(ori_imgs[i_batch], box)\n image_list.append(crop_img)\n\n batch_box_list.append(box_list)\n\n cls_pre_tensors = self.cls_preprocessor.run(image_list)\n cls_dlpack_tensor = cls_pre_tensors[0].to_dlpack()\n cls_input_tensor = pb_utils.Tensor.from_dlpack(\n \"x\", cls_dlpack_tensor)\n\n inference_request = pb_utils.InferenceRequest(\n model_name='cls_pp',\n requested_output_names=['cls_labels', 'cls_scores'],\n inputs=[cls_input_tensor])\n inference_response = inference_request.exec()\n if inference_response.has_error():\n raise pb_utils.TritonModelException(\n inference_response.error().message())\n else:\n # Extract the output tensors from the inference response.\n cls_labels = pb_utils.get_output_tensor_by_name(\n inference_response, 'cls_labels')\n cls_labels = cls_labels.as_numpy()\n\n cls_scores = pb_utils.get_output_tensor_by_name(\n inference_response, 'cls_scores')\n cls_scores = cls_scores.as_numpy()\n\n for index in range(len(image_list)):\n if cls_labels[index] == 1 and cls_scores[\n index] > self.cls_threshold:\n image_list[index] = cv2.rotate(\n image_list[index].astype(np.float32), 1)\n image_list[index] = np.astype(np.uint8)\n\n rec_pre_tensors = self.rec_preprocessor.run(image_list)\n rec_dlpack_tensor = rec_pre_tensors[0].to_dlpack()\n rec_input_tensor = pb_utils.Tensor.from_dlpack(\n \"x\", rec_dlpack_tensor)\n\n inference_request = pb_utils.InferenceRequest(\n model_name='rec_pp',\n requested_output_names=['rec_texts', 'rec_scores'],\n inputs=[rec_input_tensor])\n inference_response = inference_request.exec()\n if inference_response.has_error():\n raise pb_utils.TritonModelException(\n inference_response.error().message())\n else:\n # Extract the output tensors from the inference response.\n rec_texts = pb_utils.get_output_tensor_by_name(\n inference_response, 'rec_texts')\n rec_texts = rec_texts.as_numpy()\n\n rec_scores = pb_utils.get_output_tensor_by_name(\n inference_response, 'rec_scores')\n rec_scores = rec_scores.as_numpy()\n\n batch_rec_texts.append(rec_texts)\n batch_rec_scores.append(rec_scores)\n\n out_tensor_0 = pb_utils.Tensor(\n self.output_names[0],\n np.array(\n batch_rec_texts, dtype=np.object_))\n out_tensor_1 = pb_utils.Tensor(self.output_names[1],\n np.array(batch_rec_scores))\n out_tensor_2 = pb_utils.Tensor(self.output_names[2],\n np.array(batch_box_list))\n inference_response = pb_utils.InferenceResponse(\n output_tensors=[out_tensor_0, out_tensor_1, out_tensor_2])\n responses.append(inference_response)\n return responses","def _load_processed_data(self):\n with open(os.path.join(self._data_root_path, self._processed_train_data_file_name),\n 'r') as f:\n train_examples = json.load(f)\n\n with open(os.path.join(self._data_root_path, self._processed_dev_data_file_name), 'r') as f:\n dev_examples = json.load(f)\n\n with open(os.path.join(self._data_root_path, self._word_vocab_file_name), 'r') as f:\n word_vocab = Vocab.from_json(json.load(f))\n\n with open(os.path.join(self._data_root_path, self._char_vocab_file_name), 'r') as f:\n char_vocab = Vocab.from_json(json.load(f))\n\n return train_examples, dev_examples, word_vocab, char_vocab","def set_training_fetches(self, fetched):\n self_fetched = fetched[self._name]\n self._loss = self_fetched['loss']\n\n names = ['loss', 'output', 'target', 'degraded']\n\n if self._hparams.use_batch_transformer:\n names = names + ['bt_input', 'bt_output']\n\n self._dual.set_fetches(fetched, names)\n\n if self._summary_op is not None:\n self._summary_values = fetched[self._name]['summaries']","def dataset_difficulty():\n results = []\n datasets = [ data_2007, data_2012, data_indoor, data_easy ] \n \n for data in datasets:\n \n #Let the user know where we are\n print data\n X,Y = load_csv(data)\n \n # Training/testing split + LDA fit\n X_train, X_test, Y_train, Y_test = cross_validation.train_test_split(X, Y)\n lda = LDA()\n lda.fit(X_train, Y_train)\n \n # Use linear SVC\n clf = svm.SVC(kernel=\"linear\")\n clf.fit(lda.transform(X_train), Y_train)\n \n # Predictions\n train_predict = clf.predict(lda.transform(X_train))\n test_predict = clf.predict(lda.transform(X_test))\n \n #Compute accuracy\n train_acc = 1.*sum(train_predict == Y_train)/len(train_predict)\n test_acc = 1.*sum(test_predict == Y_test)/len(test_predict)\n \n # Append results for that dataset\n results += [ [ data, train_acc, test_acc, clf, lda ] ]\n \n return results","def load_data(self):\n with open('data/fordTrain.csv') as f:\n data = csv.reader(f, delimiter=',')\n train = [x for i, x in enumerate(data) if i > 0] \n # Extract features and target variable separately\n trainx = [x[3:] for x in train]\n trainy = [x[2] for x in train]\n\n with open('data/fordTest.csv') as f:\n data = csv.reader(f, delimiter=',')\n testx = [x[3:] for i, x in enumerate(data) if i > 0] \n\n with open('data/Solution.csv') as f:\n data = csv.reader(f, delimiter=',')\n testy = [x[2] for i, x in enumerate(data) if i > 0] \n\n # Extract features and target variable, convert to numpy array\n trainx = np.asarray(trainx, dtype=np.float32)\n trainy = np.asarray(trainy, dtype=np.int8)\n testx = np.asarray(testx, dtype=np.float32)\n testy = np.asarray(testy, dtype=np.int8)\n\n # Return training and test sets\n trainSet = Dataset(trainx, trainy)\n testSet = Dataset(testx, testy)\n return trainSet, testSet","def fetch_self(self):\r\n self.parsed_doc['names'] = self.fetch_candidate_name() \r\n self.parsed_doc['phones'] = self.fetch_phone_numbers() \r\n self.parsed_doc['emails'] = self.fetch_emails() \r\n self.parsed_doc['github'] = self.fetch_github() \r\n self.parsed_doc['linkedin'] = self.fetch_linkedin() \r\n self.parsed_doc['degrees'] = self.fetch_degrees() \r\n self.parsed_doc['skills'] = self.fetch_skills() \r\n self.parsed_doc['education'] = self.fetch_education() \r\n self.parsed_doc['languages'] = self.fetch_languages() \r\n self.parsed_doc['addresses'] = self.fetch_address() \r\n self.parsed_doc['raw_resume'] = self.stringtext","def predict_multiple():\n req = request.json\n values = pd.DataFrame(data=req['data'])\n pred = clf2.predict(values)\n responses = {}\n for i, rep in enumerate(pred):\n if rep:\n responses[f\"Customer {i + 1}\"] = f\"Input: {', '.join([str(values.loc[i, :][j]) for j in range(values.shape[1])])}, Output: is likely to churn\"\n\n else:\n responses[f\"Customer {i + 1}\"] = f\"Input: {', '.join([str(values.loc[i, :][j]) for j in range(values.shape[1])])}, Output: is a loyal customer\"\n\n return make_response(jsonify(responses))","def main():\n data = load_data()\n analyze_features(data['full_features'])\n model = train(data)\n\n with open('model.pickle', 'wb') as f:\n pickle.dump(model, f)\n evaluate(model, data)","async def predict(input_data: schemas.MultipleUserDataInputs) -> Any:\n print(input_data.inputs)\n input_df = jsonable_encoder(input_data.inputs)[0][\"user_handle\"]\n print(input_df)\n logger.info(f\"Making prediction on inputs: {input_data.inputs}\")\n results = make_prediction(input_df)\n\n logger.info(f\"Prediction results: {results.get('predictions')}\")\n\n return results","async def fetch_data(self) -> T:","def _fetch(self):\n self._data = self._get(self.url)\n\n if self._data['released_errata'] is not None:\n self._released_errata = Erratum(errata_id=self._data[\n 'released_errata']['id'])\n\n for errata_dict in self._data['all_errata']:\n errata = Erratum(errata_id=errata_dict['id'])\n self._all_errata.append(errata)\n\n self._signed_rpms = self._data.get('rpms_signed')\n\n for et_file in self._data['files']:\n self._files.append(et_file['path'])","def main():\n season_2019_preds_for_tipresias_2020 = Q(ml_model__name=\"tipresias_2020\") & Q(\n match__start_date_time__year=2019\n )\n season_2020_preds_for_round_1 = Q(match__start_date_time__year=2020) & (\n Q(match__round_number=1)\n )\n\n prediction_records = Prediction.objects.filter(\n season_2019_preds_for_tipresias_2020 | season_2020_preds_for_round_1\n ).values(*_get_fields_for(Prediction))\n\n prediction_dump = [\n _reshape_record_fields(\"prediction\", record) for record in prediction_records\n ]\n dump_filepath = os.path.join(\n settings.BASE_DIR, APP_NAME, \"fixtures\", f\"{date.today()}-prediction-dump.json\",\n )\n\n with open(dump_filepath, \"w\") as file:\n json.dump(prediction_dump, file, indent=2)","def test():\n # load dataset and model\n X, observed_y = load_data('../data/dev.txt')\n\n model = pickle.load(open('test.model', 'rb'))\n model.traverse()\n\n # predict labels for dataset\n preds = model.predict(X)\n\n # print(preds)\n # output model predictions\n np.savetxt('test.predictions', preds, fmt='%s')","def setup(self):\n # TODO check if need both dataset together\n self.train_dataset = ABSADataset(data_path=self.train_path, mode=self.in_mode, task=self.task, \n tokenizer=self.tokenizer, vocab=\"bert\")\n self.vocabulary = self.train_dataset.vocabulary\n\n self.eval_dataset = ABSADataset(data_path=self.dev_path, mode=self.in_mode, task=self.task,\n tokenizer=self.tokenizer, vocab=self.vocabulary)\n #self.train_restaurant = ABSADataset(data_path=RESTAURANT_TRAIN)\n #self.eval_restaurant = ABSADataset(data_path=RESTAURANT_DEV)","def model_data():\n x_train, y_train, x_val, y_val, x_test, y_test = read_data(\"src/tests/dataclassificationmodel/ferPlus_processed.pbz2\", False)\n return x_train, y_train, x_val, y_val, x_test, y_test","def _get_result(self):\n try:\n # get test data\n test_id = self._feature_processor.test_data_id\n test_feature = self._feature_processor.test_data_feature\n test_target = self._feature_processor.test_data_target\n\n # process data\n test_feature = test_feature.astype(\"float64\", errors='ignore')\n\n # predict\n predict_res = self._model.predict(test_feature)\n predict_res_df = pd.DataFrame(predict_res, columns=[PredictConstance.PRE])\n proba_res = self._model.predict_proba(test_feature)\n proba_res_df = pd.DataFrame([str(x) for x in proba_res],\n columns=[PredictConstance.PROBA])\n\n res = [test_id, predict_res_df, proba_res_df]\n # get model score\n if test_target is not None:\n res.append(test_target)\n model_auc = pre_utils.PredictUtils.get_roc_score(test_target, proba_res)\n model_score = pre_utils.PredictUtils.get_model_score(test_target, predict_res)\n model_score.update(model_auc)\n with open(os.path.join(self._result_path, PredictConstance.TEST_SCORE), \"w\") as ftp:\n ftp.write(str(model_score))\n\n # joint predict result\n self._joint_predict_result(res)\n\n return True\n except Exception as err:\n self.managerlogger.logger.error(\"base ml get result error: %s\" % err)\n self.errorlogger.logger.error(\"base ml get result error:\\n %s\" % traceback.format_exc())\n return False","def _load_training_data(self):\n self._save_training_data()","def fetch_inspect_data(filename, output, db_url=None):\n r2dt.write_training_data(filename, db_url, output)","def prepare_data(raw=False, round_ratings=False):\n print('Downloading input data...')\n if raw:\n # read data\n review = get_input(\n 'https://www.dropbox.com/s/mtln9b6udoydn2h/yelp_academic \\\n _dataset_review_sample.csv?dl=1')\n user = get_input(\n 'https://www.dropbox.com/s/pngrptljotqm4ds/yelp_academic \\\n _dataset_user.json?dl=1')\n business = get_input(\n 'https://www.dropbox.com/s/w0wy854u5swrhmc/yelp_academic \\\n _dataset_business.json?dl=1')\n\n # join datasets\n review_user = pd.merge(\n review, user, on=\"user_id\",\n how=\"left\", suffixes=(\"\", \"_user\"))\n review_user_business = pd.merge(\n review_user, business, on=\"business_id\",\n how=\"left\", suffixes=(\"\", \"_business\"))\n review_user_business = review_user_business[[\n 'user_id', 'business_id',\n 'stars', 'text',\n 'name', 'average_stars',\n 'name_business', 'stars_business',\n 'categories', 'state', 'city']]\n else:\n review_user_business = get_input(\n 'https://www.dropbox.com/s/sj445d95lljuc4p/small_sample.parquet?dl=1'\n )\n if round_ratings:\n # bucketize numeric features to reduce dimensions\n review_user_business['average_stars'] = review_user_business[\n 'average_stars'].apply(lambda x: round_of_rating(x))\n review_user_business['stars_business'] = review_user_business[\n 'stars_business'].apply(lambda x: round_of_rating(x))\n return review_user_business","def main():\n \n logging.info('Loading classification dataset from db')\n # start_time = dt.datetime.strptime(options.start_time, \"%Y%m%d%H%M\")\n # end_time = dt.datetime.strptime(options.end_time, \"%Y%m%d%H%M\")\n\n a = mlfb.mlfb(1, logging_level=options.logging_level)\n metadata, header, data = a.get_rows(options.dataset, rowtype=options.type)\n\n logging.debug('Length of metadata: {}'.format(len(metadata)))\n logging.debug('Shape of data {}'.format(data.shape))\n logging.debug('Header is: {}'.format(','.join(header)))\n\n print(header)\n print(np.array(metadata))\n print(data)\n \n # TODO saving as csv\n \n # Serialize model to disc\n # logging.info('Serializing dataset to disc: {}'.format(options.save_path))\n \n # csv = dataset.as_csv()\n # with open(options.save_path, \"w\") as f: \n # f.write(csv)","def predict(self, data_dict, label_dict, phases=[\"test\"]):\n loaders = self.init_loaders_predict(data_dict, label_dict)\n loss_dict = self.init_loss_dict(phases=phases)\n performance_dict = self.init_performance_dict(phases=phases)\n self.model.train(False)\n with torch.no_grad():\n output_dict_dict = {}\n for phase in phases:\n i = 0\n running_loss_dict = self.init_running_loss_dict(\n list(loss_dict[phase].keys())\n )\n output_dict = self.init_output_dict()\n for the_data in loaders[phase]:\n i += 1\n inputs, labels = self.transform_batch(the_data)\n outputs = self.model(inputs)\n output_dict = self.update_output_dict(output_dict, outputs, labels)\n loss_dict[\"loss\"] = self.criterion(outputs, labels)\n running_loss_dict[\"loss\"] += loss_dict[\"loss\"].item()\n\n # Compute epoch losses and update loss dict\n epoch_loss_dict = {\n key: running_loss_dict[key] / i for key in running_loss_dict.keys()\n }\n loss_dict[phase] = self.update_metric_dict(\n loss_dict[phase], epoch_loss_dict\n )\n # Compute epoch performance and update performance dict\n epoch_statistics = self.compute_epoch_statistics(output_dict)\n performance_dict[phase] = self.update_metric_dict(\n performance_dict[phase], epoch_statistics\n )\n output_dict_dict[phase] = self.finalize_output_dict(output_dict)\n result_dict = {\n phase: {**performance_dict[phase], **loss_dict[phase]}\n for phase in performance_dict.keys()\n }\n return output_dict_dict, result_dict","def make_predictions(self):\n if is_classification(self.model):\n if self.ct == None:\n prediction = self.model.predict(self.input_data.to_numpy())\n probabilities = self.model.predict_proba(self.input_data.to_numpy())\n return prediction, probabilities\n elif self.ct != None: \n prediction = self.model.predict(self.data_into_model())\n probabilities = self.model.predict_proba(self.data_into_model())\n return prediction, probabilities\n else:\n raise Exception((\"{} not supported. Please create an issue on Github\").format(self.model))\n \n else:\n if self.ct == None:\n prediction = self.model.predict(self.input_data)\n return prediction\n elif self.ct != None: \n prediction = self.model.predict(self.data_into_model())\n return prediction\n else:\n raise Exception((\"{} not supported. Please create an issue on Github\").format(self.self.model))","def get_predictions(year, month):\n \n start_date = str(year)+\"-\"+str(month)+\"-01\"\n end_date = str(year)+\"-\"+str(month)+\"-\"+str(monthrange(year, month)[1])\n\n date_range = pd.date_range(start_date,end_date, freq='D').strftime(\"%Y-%m-%d\").tolist()\n\n # predictfunction \n # do predictions\n pred_arr = []\n file_name = '../predictions/model_'+str(year)+'_'+str(month)+'.csv'\n \n try:\n predictions = load_predictions(file_name)\n predictions = predictions.round()\n except:\n print(\"An exception occurred\")\n predictions = pd.DataFrame(data = date_range,columns=['Datum'])\n \n \n for index,row in predictions.iterrows():\n \n pred_mail = 0\n pred_counter = 0\n pred_tel = 0\n \n # check predictions dataframe for 'Datum'\n if 'Datum' in predictions.columns:\n date = row['Datum']\n else:\n break;\n\n # check predictions dataframe for 'Mail'\n if 'Mail' in predictions.columns:\n pred_mail = row['Mail']\n\n # check predictions dataframe for 'Schalter'\n if 'Schalter' in predictions.columns:\n pred_counter = row['Schalter']\n\n # check predictions dataframe for 'Tel'\n if 'Tel' in predictions.columns:\n pred_tel = row['Tel']\n \n \n pred_dict = {'date': date, \n 'predictions':{'mail' : pred_mail, \n 'tel' : pred_tel, \n 'counter' : pred_counter\n }\n }\n\n pred_arr.append(pred_dict)\n\n print(pred_arr) \n \n return pred_arr","def _predict_all(self, data):\n preds = np.zeros(len(data))\n for row in data.itertuples():\n index, item, _, user = row\n preds[index] = self.predict(user, item)\n return preds","def fetch(self):\n\n\n # Update Prometheus metrics with application metrics\n self.current_requests.set(get_current_requests())\n self.total_uptime.set(get_uptime())\n self.health.state(get_health())","def download_training_data(data_dir, task):\n\n COMMENTS_FILE = \"%s_annotated_comments.tsv\" % task\n LABELS_FILE = \"%s_annotations.tsv\" % task\n\n if task == \"attack\":\n download_file(ATTACK_ANNOTATED_COMMENTS_URL,\n os.path.join(data_dir, COMMENTS_FILE))\n download_file(ATTACK_ANNOTATIONS_URL, os.path.join(data_dir,\n LABELS_FILE))\n elif task == \"recipient_attack\":\n download_file(ATTACK_ANNOTATED_COMMENTS_URL,\n os.path.join(data_dir, COMMENTS_FILE))\n download_file(ATTACK_ANNOTATIONS_URL, os.path.join(data_dir,\n LABELS_FILE))\n elif task == \"aggression\":\n download_file(AGGRESSION_ANNOTATED_COMMENTS_URL,\n os.path.join(data_dir, COMMENTS_FILE))\n download_file(AGGRESSION_ANNOTATIONS_URL,\n os.path.join(data_dir, LABELS_FILE))\n elif task == \"toxicity\":\n download_file(TOXICITY_ANNOTATED_COMMENTS_URL,\n os.path.join(data_dir, COMMENTS_FILE))\n download_file(TOXICITY_ANNOTATIONS_URL,\n os.path.join(data_dir, LABELS_FILE))\n else:\n print(\"No training data for task: \", task)","def load_data_raw(source='local'):\n import os\n\n if source == 'kaggle':\n # Download the Ames Housing Dataset\n # Set the enviroment variables\n import zipfile\n os.environ['KAGGLE_USERNAME'] = \"lubomrstraka\"\n os.environ['KAGGLE_KEY'] = \"c7347462ef834e6645ce238c2f2fa561\"\n \n # Import dependencies\n os.system(\"pip install kaggle --upgrade --quiet\")\n\n # Download datasets\n os.system(\"kaggle competitions download -c house-prices-advanced-regression-techniques --quiet\")\n \n # Extract data\n with zipfile.ZipFile('house-prices-advanced-regression-techniques.zip', 'r') as archive:\n archive.extractall()\n\n # Read Train & Test Baseline Data\n train_bl = pd.read_csv('train.csv', index_col='Id')\n test_bl = pd.read_csv('test.csv', index_col='Id')\n \n # Using local data used while registering dataset\n # prevents \"Too many requests\" response from Kaggle\n elif source == 'local': \n train_bl = pd.read_csv('train.csv', index_col='Id')\n test_bl = pd.read_csv('test.csv', index_col='Id')\n \n else:\n print('Missing data!')\n train_bl = pd.DataFrame()\n test_bl = pd.DataFrame()\n\n\n return train_bl, test_bl","def setup(self):\n in_dataset, out_dataset = self.get_datasets()","def setup(self):\n in_dataset, out_dataset = self.get_datasets()","def iterate_data(self):\n if \"single\" in self.dataset_name:\n # Index 0 for list of sentence lengths, index 1 for list of token lengths\n self.stat_dict = {'question': [[], []], 'summary': [[], []], 'article': [[], []]}\n for answer_id in self.data:\n summary = self.data[answer_id]['summary']\n articles = self.data[answer_id]['articles']\n question = self.data[answer_id]['question']\n if args.tokenize:\n self._get_token_cnts(summary, 'summary')\n self._get_token_cnts(articles, 'article')\n self._get_token_cnts(question, 'question')\n self._write_stats(\"token_counts\")\n\n if \"multi\" in self.dataset_name:\n self.stat_dict = {'question': [[], []], 'summary': [[], []], 'article': [[], []]}\n for q_id in self.data:\n summary = self.data[q_id]['summary']\n question = self.data[q_id]['question']\n if args.tokenize:\n self._get_token_cnts(summary, 'summary')\n self._get_token_cnts(question, 'question')\n question = self.data[q_id]['question']\n for answer_id in self.data[q_id]['articles']:\n articles = self.data[q_id]['articles'][answer_id][0]\n if args.tokenize:\n self._get_token_cnts(articles, 'article')\n self._write_stats(\"token_counts\")\n\n if self.dataset_name == \"complete_dataset\":\n self.stat_dict = {'urls': [], 'sites': []}\n article_dict = {}\n print(\"Counting answers, sites, unique urls, and tokenized counts of unique articles\")\n answer_cnt = 0\n for q_id in self.data:\n for a_id in self.data[q_id]['answers']:\n answer_cnt += 1\n url = self.data[q_id]['answers'][a_id]['url']\n article = self.data[q_id]['answers'][a_id]['article']\n if url not in article_dict:\n article_dict[url] = article\n self.stat_dict['urls'].append(url)\n assert \"//\" in url, url\n site = url.split(\"//\")[1].split(\"/\")\n self.stat_dict['sites'].append(site[0])\n print(\"# of Answers:\", answer_cnt)\n print(\"Unique articles: \", len(article_dict)) # This should match up with count written to file\n self._write_stats(\"full collection\")\n\n # Get token/sent averages of unique articles\n if args.tokenize:\n self.stat_dict = {'article': [[], []]}\n for a in article_dict:\n self._get_token_cnts(article_dict[a], 'article')\n self._write_stats(\"token_counts\")","def run_prediction(data, sess, placeholders, scores): \r\n \r\n X, Y = data\r\n source_pl, target_pl, training_pl = placeholders\r\n split_set = int(math.floor(0.9*len(X))) # Value for spliting the set in 90% training / 10% test \r\n \r\n X_batch, Y_batch = batch(X[:split_set:], Y[:split_set:]) # Take a batch of sentences from the training set\r\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\r\n prediction = sess.run(scores, feed_dict=feed_dict) \r\n X_batch = np.squeeze(X_batch) \r\n prediction = np.squeeze(prediction)\r\n \r\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\r\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\r\n\r\n\t# Print the pairs source -> target\r\n for source, target in zip(source_sentences, target_sentences): \r\n print(source + \" --> \" + target)\r\n \r\n print(\"================================================================\")\r\n \r\n X_batch, Y_batch = batch(X[split_set+1:], Y[split_set+1:]) # Take a batch of sentences from the test set\r\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\r\n prediction = sess.run(scores, feed_dict=feed_dict) \r\n \r\n X_batch = np.squeeze(X_batch) \r\n prediction = np.squeeze(prediction)\r\n \r\n \r\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\r\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\r\n\r\n\t# Print the pairs source -> target\r\n for source, target in zip(source_sentences, target_sentences): \r\n print(source + \" --> \" + target)","def process_dataset(self):\n\n logger.info('\\n')\n logger.info('=' * 40)\n logger.info('=\\t DeepRank Data Set')\n logger.info('=')\n logger.info('=\\t Training data')\n for f in self.train_database:\n logger.info(f'=\\t -> {f}')\n logger.info('=')\n if self.valid_database:\n logger.info('=\\t Validation data')\n for f in self.valid_database:\n logger.info(f'=\\t -> {f}')\n logger.info('=')\n if self.test_database:\n logger.info('=\\t Test data')\n for f in self.test_database:\n logger.info(f'=\\t -> {f}')\n logger.info('=')\n logger.info('=' * 40 + '\\n')\n sys.stdout.flush()\n\n # check if the files are ok\n self.check_hdf5_files(self.train_database)\n\n if self.valid_database:\n self.valid_database = self.check_hdf5_files(\n self.valid_database)\n\n if self.test_database:\n self.test_database = self.check_hdf5_files(\n self.test_database)\n\n # create the indexing system\n # alows to associate each mol to an index\n # and get fname and mol name from the index\n self.create_index_molecules()\n\n # get the actual feature name\n if self.mapfly:\n self.get_raw_feature_name()\n else:\n self.get_mapped_feature_name()\n\n # get the pairing\n self.get_pairing_feature()\n\n # get grid shape\n self.get_grid_shape()\n\n # get the input shape\n self.get_input_shape()\n\n # get renormalization factor\n if self.normalize_features or self.normalize_targets or self.clip_features:\n if self.mapfly:\n self.compute_norm()\n else:\n self.get_norm()\n\n logger.info('\\n')\n logger.info(\" Data Set Info:\")\n logger.info(\n f' Augmentation : {self.use_rotation} rotations')\n logger.info(\n f' Training set : {self.ntrain} conformations')\n logger.info(\n f' Validation set : {self.nvalid} conformations')\n logger.info(\n f' Test set : {self.ntest} conformations')\n logger.info(f' Number of channels : {self.input_shape[0]}')\n logger.info(f' Grid Size : {self.data_shape[1]}, '\n f'{self.data_shape[2]}, {self.data_shape[3]}')\n sys.stdout.flush()","def get_initial_predictions(tuner, input_data, output_path, model_save_name):\n\n best_model = tuner.best_estimator()\n batch_job = best_model.transformer(1, \"ml.m5.large\", output_path=output_path.as_uri(),\n model_name=model_save_name)\n batch_job.transform(input_data.as_uri())\n # TODO: Do an ls first so we can get any/all files\n output_file = output_path / 'validation.csv.out'\n with smart.open(output_file.as_uri(), 'r', transport_params={'session': boto_session}) as f:\n predictions = pd.read_csv(f, header=None)\n return predictions","def get_data(n = None):\n files = download_data()\n for path in files.values():\n extract_data(path)\n class_fnames, labelmap = explore_data()\n X, y = load_data(class_fnames)\n return prepare_data(X, y, n = n)"],"string":"[\n \"def _fetch_data(self):\\n pass\",\n \"def fetch_data():\\n for category in CHEATSHEETS.items():\\n subprocess.call(f'curl -o {PATH}{category[0] + \\\".csv\\\"} {category[1]}', shell=True)\\n\\n index = -1\\n for filename in os.listdir(PATH):\\n for idx, row in pd.read_csv(PATH + filename, on_bad_lines='skip').replace(np.nan, '').iterrows():\\n name = row['Model']\\n url = REDIRECT_URL + name.lower()\\n category = filename.split('.')[0]\\n featurizers = row['Acceptable Featurizers'].split(' ') if row['Acceptable Featurizers'] != '' else []\\n backends = ['PyTorch' if item in {\\\"PTorch\\\", \\\"Torch\\\", \\\"PyTorch \\\"} else item for item in row['Backend'].split('/')]\\n types = row['Type'] if filename != 'general.csv' else row['Classifier/Regressor']\\n types = types.split('/') if filename == 'material.csv' else types.split('/ ')\\n index += 1\\n\\n backend_list.append(backends)\\n type_list.append(types)\\n featurizer_list.append(featurizers)\\n model_list.append(Model(name, url, category, featurizers, backends, types, index))\",\n \"def fetch_data(self):\",\n \"def _get_data(self):\\n\\n # Grab the data. Note, the separator is actually ', ', not just a\\n # comma, so specify. Also, recognize the \\\"?\\\" as an NA value\\n # (I think it is easier to have pandas catch the NA values instead\\n # of manually searching for and parsing these in the future).\\n # Finally, set the engine to python, since having a separator greater\\n # than one character automatically does this, and prints a warning\\n # message. By explicitly telling it to use python, we suppress the\\n # warning.\\n self.train_df = pd.read_csv(self.train_url, sep=', ', header=None,\\n na_values='?', engine='python')\\n\\n # For the training data, have one comment row, so need to ignore\\n self.test_df = pd.read_csv(self.test_url, sep=', ', header=None,\\n skiprows=1, na_values='?', engine='python')\\n\\n # Get the header data\\n response = requests.get(self.head_url)\\n header = response.text.split('\\\\n')\\n\\n # Now, filter to grab the header lines:\\n # First, make sure there is at least one character for the line, and\\n # ignore lines that start with the comment character for the file \\\"|\\\"\\n header = [row for row in header if len(row) > 0 and row[0] != '|']\\n\\n # Ignore the first row, since it is just identifying the classifier\\n # task and, get just the header values\\n header = [head.split(':')[0] for head in header[1:]]\\n\\n # Finally, we need to add a header name for the last column (if <= or >\\n # income of 50k)\\n header.append('income')\\n\\n # Now, set the header for the data sets\\n self.train_df.columns = header\\n self.test_df.columns = header\",\n \"def do_training(self):\\n json_data = request.data\\n global g_list_of_classifier\\n\\n datas = json.loads(json_data.decode('UTF-8')) #datas = liste\\n\\n for ite_clf in g_list_of_classifier:\\n for data in datas:\\n ite_clf.add_data(data['score'], data['answer'])\\n print(ite_clf.get_info())\\n return ''\",\n \"def _fetch_data(self, samples):\\n pass\",\n \"def fetch_data():\\n data.fetch_data()\\n data.start_updating()\",\n \"def do_fetch(self):\\n pass\",\n \"def run(self):\\n results = self.fetch()\\n return results\",\n \"def train(self, force=False):\\n return self._fetch_base_data(force)\",\n \"def download_all_data(self) -> None:\\n print(\\\"Download in progress.\\\")\\n self.download_data(os.environ[\\\"NC_TOKEN_TRAIN_CHARACTERS\\\"], \\\"nextcloud\\\")\\n self.download_data(os.environ[\\\"NC_TOKEN_TRAIN_FRAGMENTS\\\"], \\\"nextcloud\\\")\\n self.download_data(os.environ[\\\"HABBAKUK_URL\\\"], \\\"generic_url\\\")\\n print(\\\"Download complete!\\\")\",\n \"def apicall():\\n try:\\n test_json = request.get_json()\\n test = pd.read_json(test_json, orient='records')\\n\\n # To resolve the issue of TypeError: Cannot compare types 'ndarray(dtype=int64)' and 'str'\\n # test['Dependents'] = [str(x) for x in list(test['Dependents'])]\\n\\n # Getting the Loan_IDs separated out\\n # loan_ids = test['Loan_ID']\\n\\n except Exception as e:\\n raise e\\n\\n clf = 'model_1.pk'\\n\\n if test.empty:\\n return(bad_request())\\n else:\\n print('Loading the model ..')\\n loaded_model = None\\n with open('models/'+clf, 'rb') as f:\\n loaded_model = pickle.load(f)\\n print(\\\"The model has been loaded...doing predictions now...\\\")\\n predictions = loaded_model.predict(test)\\n\\n prediction_series = list(pd.Series(predictions))\\n final_predictions = pd.DataFrame(list(zip(loan_ids, prediction_series)))\\n\\n \\\"\\\"\\\"We can be as creative in sending the responses.\\n But we need to send the response codes as well.\\n \\\"\\\"\\\"\\n responses = jsonify(predictions=final_predictions.to_json(orient=\\\"records\\\"))\\n responses.status_code = 200\\n\\n return (responses)\",\n \"def prediction():\\n # retweets_only = request.args.get('retweets_only')\\n # api.set_retweet_checking(strtobool(retweets_only.lower()))\\n # with_sentiment = request.args.get('with_sentiment')\\n # api.set_with_sentiment(strtobool(with_sentiment.lower()))\\n # query = request.args.get('query')\\n # api.set_query(query)\\n\\n # tweets = api.get_tweets()\\n perdiction = api.get_perdiction()\\n\\n return perdiction\",\n \"def _load_data(self):\\n self.mapper = Mapper()\\n self.mapper.generate_vocabulary(self.review_summary_file)\\n self.X_fwd, self.X_bwd, self.Y = self.mapper.get_tensor(reverseflag=True)\\n # Store all the mapper values in a dict for later recovery\\n self.mapper_dict = dict()\\n self.mapper_dict['seq_length'] = self.mapper.get_seq_length()\\n self.mapper_dict['vocab_size'] = self.mapper.get_vocabulary_size()\\n self.mapper_dict['rev_map'] = self.mapper.get_reverse_map()\\n # Split into test and train data\\n self._split_train_tst()\",\n \"def get_dataset(FOLD, AR_PERCENTAGE, d_type='yelp', AUTHOR='inf', POST='inf'):\\n global AR_TYPE\\n\\n # dataset = loader.load(d_type, AUTHOR, POST)\\n first_dataset = loader.unimportant_load(AUTHOR, POST * FOLD, AR_TYPE)\\n datasets = first_dataset.fold_to(FOLD)\\n \\n for i in range(0, len(datasets)):\\n dataset = datasets[i]\\n dataset.divide_ar_ir(AR_PERCENTAGE)\\n texts = []\\n\\n # check if we have this dataset already calculated.\\n \\n ir_filename = 'processed/' + get_ir_identifier(d_type, i, AUTHOR, POST)\\n ar_filename = 'processed/' + get_ar_identifier(d_type, i, AUTHOR, POST)\\n\\n ir_features = None\\n if os.path.isfile(ir_filename):\\n print '@get: we have the file', ir_filename, 'and going to load it.'\\n with open(ir_filename, 'rb') as fp:\\n ir_features = pickle.load(fp)\\n \\n ar_features = None\\n if os.path.isfile(ar_filename):\\n print '@get: we have the file', ar_filename, 'and going to load it.'\\n with open(ar_filename, 'rb') as fp:\\n ar_features = pickle.load(fp)\\n\\n\\n if ir_features is not None:\\n for author in dataset.authors:\\n dataset.features[author][-1] = ir_features[author]\\n\\n if ar_features is not None:\\n for author in dataset.authors:\\n dataset.features[author][:-1] = ar_features[author]\\n\\n for author in dataset.authors:\\n if ar_features is None:\\n texts.extend(dataset.get_ars(author))\\n if ir_features is None: \\n texts.append(dataset.get_ir(author))\\n\\n print '@getting_features, #dataset'#, index_fold\\n pool = Pool(processes=NUMBER_OF_CORES)\\n it = pool.imap(get_dataset_features, texts)\\n pool.close()\\n pool.join()\\n\\n print '@getting_features FINISHED, adding features to dictionary'\\n for author in dataset.authors:\\n # for each ar + ir, get back the features\\n if ar_features is None:\\n for i in range(0, dataset.get_ar_size(author)):\\n dataset.put_feature(author, i, it.next())\\n if ir_features is None:\\n dataset.put_feature(author, dataset.get_ar_size(author), it.next())\\n\\n if ir_features is None:\\n print '@get: we DONOT have the file', ir_filename, 'is going to be created and saved.'\\n with open(ir_filename, 'wb') as fp:\\n tmp = dict()\\n for key, value in dataset.features.iteritems():\\n tmp[key] = value[-1]\\n pickle.dump(tmp, fp)\\n\\n if ar_features is None:\\n print '@get: we DONOT have the file', ar_filename, 'is going to be created and saved.'\\n with open(ar_filename, 'wb') as fp:\\n tmp = defaultdict(list)\\n for key, value in dataset.features.iteritems():\\n tmp[key] = value[:-1]\\n pickle.dump(tmp, fp)\\n\\n return datasets\",\n \"def predict_api():\\n pass\",\n \"def load_data():\\n t = time()\\n print 'loading tweets, please wait...'\\n trained_tweets = load_tweets('training_dataset')\\n eval_tweets = load_tweets('evaluation_dataset')\\n print 'Time taken {}'.format(time() - t)\\n t = time()\\n print 'loading w2v model, please wait...'\\n model = w2v_load_model('GoogleNews-vectors-negative300.bin')\\n print 'Time taken {}'.format(time() - t)\\n return trained_tweets, eval_tweets, model\",\n \"def _load_data(self):\\n if self._api_response.status_code == 200:\\n self._dataset = self._api_response.json()\\n self._fill_day_dicts()\",\n \"def test_api_predictors_get(self):\\n pass\",\n \"def get_predictions():\\n\\n print(\\\"OK1\\\");\\n print(\\\"OK2\\\");\\n return;\",\n \"def download_models_and_data():\\n\\n for file in DATA_FILES:\\n download_file(file[\\\"url\\\"], file[\\\"path\\\"])\",\n \"def get_predictions(self, sess, dSet=None, dataX=None, dataY=None):\\n \\n feed_dict = {self.isTraining : False}\\n\\n if dataX is not None and dataY is not None:\\n feed_dict[self.features] = dataX\\n feed_dict[self.labels] = dataY\\n return sess.run([self.prediction], feed_dict) \\n\\n if dSet is \\\"train\\\":\\n sess.run(self.train_iter.initializer)\\n feed_dict[self.handle] = self.train_handle\\n elif dSet is \\\"val\\\":\\n sess.run(self.valid_iter.initializer)\\n feed_dict[self.handle] = self.valid_handle\\n elif dSet is \\\"test\\\":\\n sess.run(self.test_iter.initializer)\\n feed_dict[self.handle] = self.test_handle\\n else:\\n print(\\\"ERROR: Do not recognize dataset {}\\\".format(dSet))\\n raise RuntimeError\\n\\n if feed_dict[self.handle] is None:\\n raise RuntimeError(\\\"Cannot evaluate with handle = None\\\")\\n\\n try:\\n runningPredictions = sess.run([self.prediction], feed_dict)\\n except tf.errors.OutOfRangeError:\\n print(\\\"Error: Cannot get predictions because dataset is empty\\\")\\n raise RuntimeError\\n\\n while True:\\n # Get batch data\\n try :\\n runningPredictions.concatenate(\\n sess.run([self.prediction], feed_dict), \\n axis=0)\\n except tf.errors.OutOfRangeError:\\n break\\n\\n return runningPredictions\",\n \"def get(self):\\n from models.prediction import Prediction\\n from models.feedback import Feedback\\n\\n prediction_collection = Prediction._get_collection()\\n feedback_collection = Feedback._get_collection()\\n statistical_data = copy.deepcopy(CONSTANTS['STATISTICAL_DATA'])\\n\\n # initial statistical_data based on age and ascending order\\n total_age = []\\n for i in range(21):\\n total_age.append(str(i * 5) + '+')\\n\\n for each_age in total_age:\\n statistical_data['prediction_data']['age'][each_age] = 0\\n statistical_data['feedback_data']['age']['wrong'][each_age] = 0\\n statistical_data['feedback_data']['age']['correct'][each_age] = 0\\n\\n # photo by date\\n today = datetime.datetime.today().replace(hour=0, minute=0, second=0, microsecond=0)\\n total_number_of_photo_within_one_week = {\\n (today - datetime.timedelta(days=6)).strftime('%d/%m/%Y'): prediction_collection.count_documents(\\n {'date': {'$lt': today - datetime.timedelta(days=5), '$gte': today - datetime.timedelta(days=6)}}),\\n (today - datetime.timedelta(days=5)).strftime('%d/%m/%Y'): prediction_collection.count_documents(\\n {'date': {'$lt': today - datetime.timedelta(days=4), '$gte': today - datetime.timedelta(days=5)}}),\\n (today - datetime.timedelta(days=4)).strftime('%d/%m/%Y'): prediction_collection.count_documents(\\n {'date': {'$lt': today - datetime.timedelta(days=3), '$gte': today - datetime.timedelta(days=4)}}),\\n (today - datetime.timedelta(days=3)).strftime('%d/%m/%Y'): prediction_collection.count_documents(\\n {'date': {'$lt': today - datetime.timedelta(days=2), '$gte': today - datetime.timedelta(days=3)}}),\\n (today - datetime.timedelta(days=2)).strftime('%d/%m/%Y'): prediction_collection.count_documents(\\n {'date': {'$lt': today - datetime.timedelta(days=1), '$gte': today - datetime.timedelta(days=2)}}),\\n (today - datetime.timedelta(days=1)).strftime('%d/%m/%Y'): prediction_collection.count_documents(\\n {'date': {'$lt': today, '$gte': today - datetime.timedelta(days=1)}}),\\n today.strftime('%d/%m/%Y'): prediction_collection.count_documents(\\n {'date': {'$gte': today}}),\\n }\\n\\n # prediction\\n total_prediction = prediction_collection.find({})\\n\\n for each_prediction in total_prediction:\\n prediction_results = each_prediction['predictionResults']\\n for each_result in prediction_results:\\n statistical_data['prediction_number'] = statistical_data.get(\\n 'prediction_number', 0) + 1\\n\\n # age, gender, emotion\\n each_age = str(5*math.floor(each_result['age'] / 5)) + '+'\\n\\n statistical_data['prediction_data']['age'][each_age] = \\\\\\n statistical_data['prediction_data']['age'].get(each_age, 0) + 1\\n statistical_data['prediction_data']['gender'][each_result['gender']] = \\\\\\n statistical_data['prediction_data']['gender'].get(each_result['gender'], 0) + 1\\n statistical_data['prediction_data']['emotion'][each_result['emotion']] = \\\\\\n statistical_data['prediction_data']['emotion'].get(each_result['emotion'], 0) + 1\\n\\n # feedback\\n total_feedback = feedback_collection.find({})\\n\\n for each_feedback in total_feedback:\\n feedback_content = each_feedback['content']\\n for each_content in feedback_content:\\n statistical_data['feedback_number'] = statistical_data.get(\\n 'feedback_number', 0) + 1\\n\\n # age\\n if each_content['ageCorrectness'] == False:\\n statistical_data['feedback_data']['age']['wrong'][\\n each_content['ageFeedback']] = \\\\\\n statistical_data['feedback_data']['age'][\\n 'wrong'].get(each_content['ageFeedback'], 0) + 1\\n else:\\n statistical_data['feedback_data']['age']['correct'][\\n each_content['ageFeedback']] = \\\\\\n statistical_data['feedback_data']['age']['correct'].get(\\n each_content['ageFeedback'], 0) + 1\\n\\n # gender\\n if each_content['genderCorrectness'] == False:\\n statistical_data['feedback_data']['gender']['wrong'][\\n each_content['genderFeedback']] = \\\\\\n statistical_data['feedback_data']['gender'][\\n 'wrong'].get(each_content['genderFeedback'], 0) + 1\\n else:\\n statistical_data['feedback_data']['gender']['correct'][\\n each_content['genderFeedback']] = \\\\\\n statistical_data['feedback_data']['gender']['correct'].get(\\n each_content['genderFeedback'], 0) + 1\\n\\n if each_content['emotionCorrectness'] == False:\\n statistical_data['feedback_data']['emotion']['wrong'][\\n each_content['emotionFeedback']] = \\\\\\n statistical_data['feedback_data']['emotion']['wrong'].get(\\n each_content['emotionFeedback'], 0) + 1\\n else:\\n statistical_data['feedback_data']['emotion']['correct'][\\n each_content['emotionFeedback']] = \\\\\\n statistical_data['feedback_data']['emotion']['correct'].get(\\n each_content['emotionFeedback'], 0) + 1\\n\\n result = {\\n 'totalNumberOfPhotoUploaded': prediction_collection.count_documents({}),\\n\\n 'totalNumberOfPrediction': statistical_data['prediction_number'],\\n 'totalNumberOfFeedback': statistical_data['feedback_number'],\\n\\n 'totalNumberOfAgePrediction': statistical_data['prediction_data']['age'],\\n 'totalNumberOfAgeCorrectFeedback': statistical_data['feedback_data']['age']['correct'],\\n 'totalNumberOfAgeWrongFeedback': statistical_data['feedback_data']['age']['wrong'],\\n\\n 'totalNumberOfGenderPrediction': statistical_data['prediction_data']['gender'],\\n 'totalNumberOfGenderCorrectFeedback': statistical_data['feedback_data']['gender']['correct'],\\n 'totalNumberOfGenderWrongFeedback': statistical_data['feedback_data']['gender']['wrong'],\\n\\n 'totalNumberOfEmotionPrediction': statistical_data['prediction_data']['emotion'],\\n 'totalNumberOfEmotionCorrectFeedback': statistical_data['feedback_data']['emotion']['correct'],\\n 'totalNumberOfEmotionWrongFeedback': statistical_data['feedback_data']['emotion']['wrong'],\\n\\n 'numberOfPhotoByDate': total_number_of_photo_within_one_week\\n }\\n\\n return send_json_response(result, 200)\",\n \"def fetch_data(self):\\n\\n data_dict = {\\n 'price': self.get_current_price(),\\n }\\n\\n return self.save_data(data_dict)\",\n \"def load_data(nlp, cue_verbs, poly):\\n train_dicts, _ = load_quote_authors(nlp)\\n author_prediction_dataset = AuthorPredictionDataset(train_dicts, cue_verbs, poly)\\n return np.array(train_dicts), author_prediction_dataset\",\n \"def prepare_data(self):\\n try:\\n self.train_dataset = self.datasets['train']\\n self.val_dataset = self.datasets['val']\\n try:\\n self.test_dataset = self.datasets['test']\\n except:\\n pass\\n except Exception as e:\\n print('Data was not succesfully prepared:', e)\",\n \"def fetch(self):\\n pass\",\n \"def fetch(self):\\n pass\",\n \"def get_data():\\n log = common.LogFile('', LOGFILE)\\n settings = load_settings()\\n keywords = settings[\\\"keywords\\\"]\\n api_key = settings[\\\"api_key\\\"]\\n for keyword in keywords:\\n print(\\\"[{}] : fetching data.\\\".format(keyword))\\n filename = \\\"results_{0}.json\\\".format(keyword)\\n results = {}\\n hits_limit = 500\\n start_at = 1\\n counter = 0\\n while True:\\n url = create_url(keyword, hits_limit, start_at, api_key)\\n records = get_records_from_url(url)\\n total_results = get_total_hits(records)\\n records = split_records(records)\\n records_on_page = len(records)\\n if records_on_page == 0:\\n break\\n else:\\n for record in records:\\n counter += 1\\n id_no = extract_id_number(record)\\n processed_dict = {'ID': id_no, 'problem': []}\\n processed_record = parse_record(\\n record, processed_dict, log)\\n if id_no not in results:\\n results[id_no] = processed_record\\n if counter % 100 == 0:\\n print(\\\"Processed {} out of {}\\\".format(\\n counter, total_results))\\n start_at += hits_limit\\n time.sleep(THROTTLE)\\n print(\\\"[{}] : fetched {} records to {}.\\\".format(\\n keyword, len(results), filename))\\n save_data(results, filename)\",\n \"def run_all():\\n db = DBInterface()\\n year = Config.get_property(\\\"league_year\\\")\\n session = Session(bind=db.engine)\\n\\n scraper.scrape_all(db, session, year)\\n session.commit()\\n\\n bets.predict_all(db, session)\\n session.commit()\\n session.close()\",\n \"def _get_predictions(self, data, break_ties=\\\"random\\\", return_probs=False, **kwargs):\\n data_loader = self._create_data_loader(data)\\n Y_p = []\\n Y = []\\n Y_s = []\\n\\n # Do batch evaluation by default, getting the predictions and labels\\n for batch_num, data in enumerate(data_loader):\\n Xb, Yb = data\\n Y.append(self._to_numpy(Yb))\\n\\n # Optionally move to device\\n if self.config[\\\"device\\\"] != \\\"cpu\\\":\\n Xb = place_on_gpu(Xb)\\n\\n # Append predictions and labels from DataLoader\\n Y_pb, Y_sb = self.predict(\\n Xb, break_ties=break_ties, return_probs=True, **kwargs\\n )\\n Y_p.append(self._to_numpy(Y_pb))\\n Y_s.append(self._to_numpy(Y_sb))\\n Y_p, Y, Y_s = map(self._stack_batches, [Y_p, Y, Y_s])\\n if return_probs:\\n return Y_p, Y, Y_s\\n else:\\n return Y_p, Y\",\n \"def fetch(self) -> None:\\n pass\",\n \"def fetch_data():\\n log = logging.getLogger(__name__)\\n log.info('Checking data files...')\\n if not os.path.isfile('CGN.txt'):\\n params_cgn = {\\n 'institute.code': ['NLD037'],\\n # 'crops': ['tomato'],\\n 'taxonomy.genus': ['Solanum', 'Lycopersicon'],\\n 'taxonomy.species': species\\n }\\n cgn = GenesysParser(params_cgn)\\n cgn.fetch2json('CGN.txt')\\n log.info('CGN data has been saved.')\\n else:\\n log.info('CGN data file already exists.')\\n\\n if not os.path.isfile('USDA.txt'):\\n params_usda = {\\n 'institute.code': usda_all,\\n # 'crops': ['tomato'],\\n 'taxonomy.genus': ['Solanum', 'Lycopersicon'],\\n 'taxonomy.species': species\\n }\\n usda = GenesysParser(params_usda)\\n usda.fetch2json('USDA.txt')\\n log.info('USDA data has been saved.')\\n else:\\n log.info('USDA data file already exists.')\",\n \"def evaluate():\\n log.info('Loading dev data...')\\n if args.version_2:\\n dev_data = SQuAD('dev', version='2.0')\\n else:\\n dev_data = SQuAD('dev', version='1.1')\\n (_, _), (data_file_name, _) \\\\\\n = dev_data._data_file[dev_data._version][dev_data._segment]\\n dev_data_path = os.path.join(dev_data._root, data_file_name)\\n\\n if args.debug:\\n sampled_data = [dev_data[0], dev_data[1], dev_data[2]]\\n dev_data = mx.gluon.data.SimpleDataset(sampled_data)\\n log.info('Number of records in dev data: %d', len(dev_data))\\n\\n dev_data_features = preprocess_dataset(\\n tokenizer, dev_data, vocab=vocab, max_seq_length=args.max_seq_length,\\n doc_stride=args.doc_stride, num_workers=args.num_workers,\\n max_query_length=args.max_query_length, load_from_pickle=args.load_pickle,\\n feature_file=args.dev_dataset_file)\\n\\n dev_data_input = convert_full_features_to_input_features(dev_data_features)\\n log.info('The number of examples after preprocessing: %d', len(dev_data_input))\\n\\n dev_dataloader = mx.gluon.data.DataLoader(dev_data_input, batchify_fn=batchify_fn,\\n num_workers=4, batch_size=args.test_batch_size,\\n shuffle=False, last_batch='keep')\\n\\n log.info('start prediction')\\n\\n all_results = collections.defaultdict(list)\\n\\n epoch_tic = time.time()\\n total_num = 0\\n for (batch_id, data) in enumerate(dev_dataloader):\\n data_list = list(split_and_load(data, ctx))\\n for splited_data in data_list:\\n example_ids, inputs, token_types, valid_length, p_mask, _, _, _ = splited_data\\n total_num += len(inputs)\\n outputs = net_eval(inputs, token_types, valid_length, p_mask=p_mask)\\n example_ids = example_ids.asnumpy().tolist()\\n for c, example_ids in enumerate(example_ids):\\n result = RawResultExtended(start_top_log_probs=outputs[0][c].asnumpy().tolist(),\\n start_top_index=outputs[1][c].asnumpy().tolist(),\\n end_top_log_probs=outputs[2][c].asnumpy().tolist(),\\n end_top_index=outputs[3][c].asnumpy().tolist(),\\n cls_logits=outputs[4][c].asnumpy().tolist())\\n all_results[example_ids].append(result)\\n if batch_id % args.log_interval == 0:\\n log.info('Batch: %d/%d', batch_id + 1, len(dev_dataloader))\\n\\n epoch_toc = time.time()\\n log.info('Time cost=%2f s, Thoughput=%.2f samples/s', epoch_toc - epoch_tic,\\n total_num / (epoch_toc - epoch_tic))\\n\\n log.info('Get prediction results...')\\n\\n all_predictions = collections.OrderedDict()\\n all_nbest_json = collections.OrderedDict()\\n scores_diff_json = collections.OrderedDict()\\n for features in dev_data_features:\\n results = all_results[features[0].example_id]\\n example_qas_id = features[0].qas_id\\n score_diff, best_non_null_entry, nbest_json = predict_extended(\\n features=features, results=results, n_best_size=args.n_best_size,\\n max_answer_length=args.max_answer_length, start_n_top=args.start_top_n,\\n end_n_top=args.end_top_n)\\n scores_diff_json[example_qas_id] = score_diff\\n all_predictions[example_qas_id] = best_non_null_entry\\n all_nbest_json[example_qas_id] = nbest_json\\n\\n output_prediction_file = os.path.join(args.output_dir, 'predictions.json')\\n output_nbest_file = os.path.join(args.output_dir, 'nbest_predictions.json')\\n output_null_log_odds_file = os.path.join(args.output_dir, 'null_odds.json')\\n\\n with open(output_prediction_file, 'w') as writer:\\n writer.write(json.dumps(all_predictions, indent=4) + '\\\\n')\\n with open(output_nbest_file, 'w') as writer:\\n writer.write(json.dumps(all_nbest_json, indent=4) + '\\\\n')\\n with open(output_null_log_odds_file, 'w') as writer:\\n writer.write(json.dumps(scores_diff_json, indent=4) + '\\\\n')\\n\\n if os.path.exists(sys.path[0] + '/evaluate-v2.0.py'):\\n arguments = [\\n dev_data_path, output_prediction_file, '--na-prob-thresh',\\n str(args.null_score_diff_threshold)\\n ]\\n if args.version_2:\\n arguments += ['--na-prob-file', output_null_log_odds_file]\\n subprocess.call([sys.executable, sys.path[0] + '/evaluate-v2.0.py'] + arguments)\\n else:\\n log.info('Please download evaluate-v2.0.py to get evaluation results for SQuAD. '\\n 'Check index.rst for the detail.')\",\n \"def get_data_loaders():\\n dataset_path = \\\"\\\"\\n dataset_cache = None\\n personachat = get_dataset(dataset_path, dataset_cache)\\n\\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\\n logger.info(\\\"Build inputs and labels\\\")\\n datasets = {\\\"train\\\": defaultdict(list), \\\"valid\\\": defaultdict(list)}\\n personality = []\\n history_complete = []\\n count_persona = 0\\n with open('data_faiss_pegasus_2sentences_finalgenerated.pkl', 'rb') as f:\\n persona_selected_list = pickle.load(f)\\n for dataset_name, dataset in personachat.items():\\n num_candidates = len(dataset[0][\\\"utterances\\\"][0][\\\"candidates\\\"])\\n if num_candidates > 0 and dataset_name == 'train':\\n num_candidates = min(1, num_candidates)\\n for dialog in dataset:\\n persona = dialog[\\\"persona_info\\\"].copy()\\n #datasets[personality].append(persona)\\n count_history = 0\\n for utterance in dialog[\\\"utterances\\\"]:\\n count_history = count_history + 1\\n history = utterance[\\\"history\\\"][-(2*2+5):]\\n \\n #history_complete.append(history)\\n if len(persona) == 4:\\n if len(history) > (len(persona)+3):\\n history_chatbot = history[1::2]\\n persona_selected = persona_selected_list[count_persona]\\n instance = build_input_from_segments_faiss_2(persona, history_chatbot) \\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n count_persona = count_persona + 1\\n return datasets\",\n \"def get_data(self):\\n has_next_page = True\\n page = 1\\n while has_next_page:\\n print(f'Getting page {page}')\\n response = self.get_articles(\\n page=page,\\n size=200,\\n order_by='extracted_at',\\n order_type='asc'\\n )\\n pagination = response.get('pagination')\\n has_next_page = pagination.get('has_next')\\n self.save_articles(response.get('articles'))\\n page += 1\\n time.sleep(2.5)\",\n \"def get_real_and_pred_data():\\n if request.method == 'POST':\\n \\n entry = json.loads(request.data)\\n \\n date = entry['date']\\n\\n res = {}\\n\\n time_series, time_series_pred = make_predictions(time_series_logs, forecasting_models, \\n FORECASTING_TARGETS, date)\\n \\n for target in FORECASTING_TARGETS:\\n \\n target_val = list(time_series[target])\\n target_pred_val = list(time_series_pred[target])\\n res[target] = target_val\\n res[target + '_pred'] = target_pred_val\\n \\n xticks = list(map(str, time_series_pred['date']))\\n \\n \\n \\n res['xticks'] = xticks\\n \\n json_data = json.dumps(res)\\n resp = Response(json_data, status=200, mimetype='application/json')\\n resp.headers = {'Access-Control-Allow-Origin': '*'}\\n\\n return resp\\n \\n else:\\n return 'only get request is allowed'\",\n \"def predict_all():\\n\\n # need train dir to list category names\\n cfg = configparser.ConfigParser()\\n cfg.read(sys.argv[1])\\n base = os.environ['DATA_ROOT']\\n eval_type = cfg.get('args', 'eval_type')\\n train_xml_dir = os.path.join(base, cfg.get('data', 'train_xml_dir'))\\n\\n if eval_type == 'sparse':\\n predict_sparse(train_xml_dir)\\n else:\\n predict_dense(train_xml_dir)\",\n \"def load_data(self):\\n\\n self._load_train_data()\\n self._load_test_data()\",\n \"def fetch(self,url=URL):\\n\\t\\tlog.info('downloading latest PHE case data')\\n#\\t\\tself.data=lookup_json(url)\\n\\t\\tself.fetch_csv() #JSON discontinued; switched back to CSV\\n\\t\\tself.edition=self.latest_samples\\n\\t\\tlog.info(f'Last samples from {self.edition}')\",\n \"def trainAndPredict(self):\\r\\n print(\\\"train\\\")\\r\\n filename= 'finalized_model.sav'\\r\\n # train the algorithm on training data and predict using the testing data\\r\\n model = self.svc_model.fit(self.X.T, self.Y)\\r\\n pickle.dump(model, open(filename, 'wb'))\\r\\n #model = pickle.load(open(filename, 'rb'))\\r\\n pred1 =model.predict(self.TestSet.T)\\r\\n # print the accuracy score of the model\\r\\n print(\\\"LinearSVC accuracy : \\\", accuracy_score(self.TestSetY, pred1, normalize=True))\",\n \"def predict(self, **options):\\n dependent_dataset = \\\"/\\\".join(self.api_path.split(\\\"/\\\")[:-1])\\n op_json = self.client.post(dependent_dataset + \\\":refresh\\\").successful().json()\\n op = Operation.from_json(self.client, op_json)\\n return op.apply_options(**options)\",\n \"def load_data(self):\\r\\n self.logger.log(self.log_file, 'Loading prediction data!')\\r\\n try:\\r\\n prediction_data = self.aws_operations.read_csv(self.prediction_file_path)\\r\\n if prediction_data is None:\\r\\n return None\\r\\n self.logger.log(self.log_file, 'Prediction data loaded successfully!')\\r\\n return prediction_data\\r\\n except Exception as e:\\r\\n self.logger.log(self.log_file, 'Error occurred while loading prediction data: %s' % e)\\r\\n raise e\",\n \"def load_data():\\n print(\\\"PARSING TRAIN\\\")\\n ys_train, x_train, ids_train = load_pickle_data(\\\"ys_train\\\"), load_pickle_data(\\\"x_train\\\"), load_pickle_data(\\n \\\"ids_train\\\")\\n if ys_train is None or x_train is None or ids_train is None:\\n ys_train, x_train, ids_train = load_csv_data(\\\"{}/train.csv\\\".format(DATA_DIR))\\n dump_pickle_data(ys_train, \\\"ys_train\\\")\\n dump_pickle_data(x_train, \\\"x_train\\\")\\n dump_pickle_data(ids_train, \\\"ids_train\\\")\\n\\n print(\\\"PARSING TEST\\\")\\n x_test, ids_test = load_pickle_data(\\\"x_test\\\"), load_pickle_data(\\\"ids_test\\\")\\n if x_test is None or ids_test is None:\\n _, x_test, ids_test = load_csv_data(\\\"{}/test.csv\\\".format(DATA_DIR))\\n dump_pickle_data(x_test, \\\"x_test\\\")\\n dump_pickle_data(ids_test, \\\"ids_test\\\")\\n\\n return ys_train, x_train, ids_train, x_test, ids_test\",\n \"def main():\\n df = prepro_last()\\n X, y = train_build(df)\\n fit_store(X, y)\",\n \"def prepare_data():\\n user_name = os.environ.get('USER')\\n traintest_corpus = ResumeCorpus('/Users/' + user_name + '/Documents/Data')\\n random.shuffle(traintest_corpus.resumes)\\n\\n for resume in traintest_corpus.resumes:\\n try:\\n review_text = pre_processing(resume[0])\\n review_text = \\\" \\\".join(review_text)\\n data_dict['data'].append(review_text)\\n data_dict['label'].append(resume[1])\\n except:\\n pass\",\n \"def download_and_preprocess(self):\\n print('Preparing steering angle database.')\\n print('Downloading...')\\n self.download()\\n print('Preprocessing...')\\n self.preprocess()\",\n \"def prepare_data(self):\\n import subprocess\\n # Download coco data set into dir specified by config then /data/coco\\n subprocess.call([f\\\"{get_original_cwd()}/bin/fetch_dataset.sh\\\", f\\\"{self.dir}/data/coco\\\", f\\\"{get_original_cwd()}\\\"])\\n # subprocess.call([f\\\"bin/fetch_dataset.sh\\\", f\\\"{self.dir}/data/coco\\\"])\\n task = \\\"instances\\\" if self.instance else \\\"person_keypoints\\\"\\n register_coco_instances(\\\"train\\\", {}, f\\\"{self.dir}/data/coco/{task}_train2014.json\\\",\\n f\\\"{self.dir}/data/coco/train2014\\\")\\n register_coco_instances(\\\"val\\\", {}, f\\\"{self.dir}/data/coco/{task}_minival2014.json\\\",\\n f\\\"{self.dir}/data/coco/val2014\\\")\\n register_coco_instances(\\\"test\\\", {}, f\\\"{self.dir}/data/coco/{task}_valminusminival2014.json\\\",\\n f\\\"{self.dir}/data/coco/val2014\\\")\",\n \"def fetch_data():\\n if request.method == 'GET':\\n return (\\\"Use this endpoint with POST method to fetch data\\\", 200)\\n elif request.method == 'POST':\\n # request data\\n app.logger.info(\\\"Requesting data\\\")\\n data = get_data('regulatorydecision')\\n\\n # write to file\\n app.logger.info(\\\"Writing to file\\\")\\n write_to_file(data)\\n\\n # upload to cloud storage\\n app.logger.info(\\\"Uploading to GCS\\\")\\n upload_to_gcs('data.json', 'health-ca-data-staging')\\n\\n # publish message to pubsub\\n app.logger.info(\\\"Publishing status message to Pubsub\\\")\\n message = \\\"Data uploaded to GCS\\\"\\n pubsub_publish('projects/health-ca-data/topics/gcs_load', message, \\\"\\\")\\n\\n return (\\\"Fetching data\\\", 200)\",\n \"def load_predicted_results(self):\\n print(\\\"\\\\n\\\\nLoad prediction answers : \\\")\\n with open(\\\"predicted_results\\\", \\\"rb\\\") as predicted_results:\\n self.predicted_results = pickle.load(predicted_results)\",\n \"def do_predict(self):\\n answer = []\\n response = []\\n\\n for it_predictions in json.loads(request.data.decode('UTF-8')):\\n prediction = it_predictions['score']\\n for ite_clf in g_list_of_classifier:\\n answer.append(ite_clf.predict(prediction))\\n if answer.count(True) > answer.count(False):\\n response.append({'answer' : True})\\n else:\\n response.append({'answer' : False})\\n return json.dumps(response, indent=4)\",\n \"def predict(self, stories, queries):\\n feed_dict = {self._stories: stories, self._queries: queries}\\n return self._sess.run(self.predict_op, feed_dict=feed_dict)\",\n \"def main():\\n datasets = {}\\n for dataset_name in tqdm(SOURCE_DATASET_NAMES, desc=\\\"Processing datasets and fitting base models\\\"):\\n logger.info(f\\\"processing dataset {dataset_name}\\\")\\n clusters_path: Optional[str] = None\\n if dataset_name not in PAIRWISE_ONLY_DATASETS:\\n clusters_path = os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_clusters.json\\\")\\n train_pairs_path = None\\n val_pairs_path = None\\n test_pairs_path = None\\n else:\\n train_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"train_pairs.csv\\\")\\n val_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"val_pairs.csv\\\")\\n if not os.path.exists(val_pairs_path):\\n val_pairs_path = None\\n test_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"test_pairs.csv\\\")\\n\\n logger.info(f\\\"loading dataset {dataset_name}\\\")\\n anddata = ANDData(\\n signatures=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_signatures.json\\\"),\\n papers=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_papers.json\\\"),\\n name=dataset_name,\\n mode=\\\"train\\\",\\n specter_embeddings=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_specter.pickle\\\"),\\n clusters=clusters_path,\\n block_type=BLOCK_TYPE,\\n train_pairs=train_pairs_path,\\n val_pairs=val_pairs_path,\\n test_pairs=test_pairs_path,\\n train_pairs_size=N_TRAIN_PAIRS_SIZE,\\n val_pairs_size=N_VAL_TEST_SIZE,\\n test_pairs_size=N_VAL_TEST_SIZE,\\n preprocess=True,\\n )\\n\\n logger.info(f\\\"featurizing {dataset_name}\\\")\\n train, val, test = featurize(\\n anddata,\\n FEATURIZER_INFO,\\n n_jobs=N_JOBS,\\n use_cache=True,\\n chunk_size=100,\\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO,\\n nan_value=NAN_VALUE,\\n )\\n X_train, y_train, nameless_X_train = train\\n X_val, y_val, nameless_X_val = val\\n X_test, y_test, nameless_X_test = test\\n\\n dataset = {}\\n dataset[\\\"anddata\\\"] = anddata\\n dataset[\\\"X_train\\\"] = X_train\\n dataset[\\\"y_train\\\"] = y_train\\n dataset[\\\"X_val\\\"] = X_val\\n dataset[\\\"y_val\\\"] = y_val\\n dataset[\\\"X_test\\\"] = X_test\\n dataset[\\\"y_test\\\"] = y_test\\n dataset[\\\"nameless_X_train\\\"] = nameless_X_train\\n dataset[\\\"nameless_X_val\\\"] = nameless_X_val\\n dataset[\\\"nameless_X_test\\\"] = nameless_X_test\\n dataset[\\\"name\\\"] = anddata.name\\n datasets[dataset_name] = dataset\\n\\n anddatas = [\\n datasets[dataset_name][\\\"anddata\\\"]\\n for dataset_name in SOURCE_DATASET_NAMES\\n if dataset_name not in PAIRWISE_ONLY_DATASETS\\n ]\\n\\n X_train = np.vstack([datasets[dataset_name][\\\"X_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n y_train = np.hstack([datasets[dataset_name][\\\"y_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n X_val = np.vstack(\\n [datasets[dataset_name][\\\"X_val\\\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\\\"augmented\\\"}]\\n )\\n y_val = np.hstack(\\n [datasets[dataset_name][\\\"y_val\\\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\\\"augmented\\\"}]\\n )\\n\\n nameless_X_train = np.vstack([datasets[dataset_name][\\\"nameless_X_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n nameless_X_val = np.vstack(\\n [\\n datasets[dataset_name][\\\"nameless_X_val\\\"]\\n for dataset_name in SOURCE_DATASET_NAMES\\n if dataset_name not in {\\\"augmented\\\"}\\n ]\\n )\\n\\n logger.info(\\\"fitting pairwise\\\")\\n union_classifier = PairwiseModeler(n_iter=N_ITER, monotone_constraints=MONOTONE_CONSTRAINTS)\\n union_classifier.fit(X_train, y_train, X_val, y_val)\\n\\n nameless_union_classifier = None\\n if USE_NAMELESS_MODEL:\\n logger.info(\\\"nameless fitting pairwise for \\\" + str(SOURCE_DATASET_NAMES))\\n nameless_union_classifier = PairwiseModeler(\\n n_iter=N_ITER,\\n monotone_constraints=NAMELESS_MONOTONE_CONSTRAINTS,\\n )\\n nameless_union_classifier.fit(nameless_X_train, y_train, nameless_X_val, y_val)\\n logger.info(\\\"nameless pairwise fit for \\\" + str(SOURCE_DATASET_NAMES))\\n\\n logger.info(\\\"fitting clusterer for\\\")\\n union_clusterer = Clusterer(\\n FEATURIZER_INFO,\\n union_classifier.classifier,\\n cluster_model=FastCluster(),\\n search_space=search_space,\\n n_jobs=N_JOBS,\\n nameless_classifier=nameless_union_classifier.classifier if nameless_union_classifier is not None else None,\\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO if nameless_union_classifier is not None else None,\\n )\\n union_clusterer.fit(anddatas)\\n print(\\n \\\"best clustering parameters:\\\",\\n union_clusterer.best_params,\\n )\\n\\n models = {}\\n models[\\\"clusterer\\\"] = union_clusterer\\n\\n with open(\\n f\\\"full_union_model_script_dump_average_{FEATURIZER_VERSION}.pickle\\\",\\n \\\"wb\\\",\\n ) as _pickle_file:\\n pickle.dump(models, _pickle_file)\\n logger.info(\\\"Done.\\\")\",\n \"def fetch_training_data(filename, output, db_url=None):\\n r2dt.write_training_data(filename, db_url, output)\",\n \"def predict():\\n \\n ## input checking\\n if not request.json:\\n print(\\\"ERROR: API (predict): did not receive request data\\\")\\n return jsonify([])\\n\\n if 'query' not in request.json:\\n print(\\\"ERROR: API (predict): received request, but no 'query' found within\\\")\\n return jsonify([])\\n\\n ## set the test flag\\n test = False\\n if 'mode' in request.json and request.json['mode'] == 'test':\\n test = True\\n\\n ## extract the query\\n query = request.json['query']\\n \\n ## load model\\n if test:\\n data, models = model_load(prefix='test')\\n else:\\n data, models = model_load()\\n \\n if not models:\\n print(\\\"ERROR: API (predict): models not available\\\")\\n return jsonify([])\\n\\n _result = model_predict(**query,all_models=models,test=test)\\n result = {}\\n \\n ## convert numpy objects to ensure they are serializable\\n for key,item in _result.items():\\n if isinstance(item,np.ndarray):\\n result[key] = item.tolist()\\n else:\\n result[key] = item\\n \\n return(jsonify(result))\",\n \"def predict(self, data):\\n\\t\\tres = self.neuralNetworks.inference(self.dataCenter.process_inference_data(data))\\n\\t\\tprint(res)\",\n \"def dataloader(self):\\n\\n # load / split data\\n train_data = self.data.get_train_data()\\n if self.args.use_dev:\\n train_data, dev_data = self.data.split_data(train_data)\\n test_data = self.data.get_test_data()\\n\\n #print(train_data[0])\\n #print(dev_data[0])\\n #print(test_data[0])\\n\\n # build dataset\\n train_dataset = self.loader.build_dataset(\\n train_data, \\n self.args.train_max_seq_len)\\n train_loader = self.loader.build_dataloader(\\n train_dataset, 'train')\\n\\n test_dataset = self.loader.build_dataset(\\n test_data,\\n self.args.eval_max_seq_len)\\n test_loader = self.loader.build_dataloader(\\n test_dataset, 'test')\\n\\n if self.args.use_dev:\\n dev_dataset = self.loader.build_dataset(\\n dev_data,\\n self.args.eval_max_seq_len)\\n dev_loader = self.loader.build_dataloader(\\n dev_dataset, 'dev')\\n return train_loader, dev_loader, test_loader\\n else:\\n return train_loader, test_loader\",\n \"def load_raw_data(self):\\n if self.trendfile:\\n self.raw_data = self.get_ap_file()\\n else:\\n report_params = self.format_api_request_params()\\n report_params['test'] = self.testresults\\n\\n self.raw_data = self.get_ap_report(params=report_params)\",\n \"def predict():\\n\\n\\n json_payload = request.json\\n #LOG.info(f\\\"JSON payload: %s\\\" %json_payload)\\n inference_payload = pd.DataFrame(json_payload)\\n #LOG.info(\\\"inference payload DataFrame: %s\\\" %inference_payload)\\n scaled_payload = scale(inference_payload)\\n prediction = list(clf.predict(scaled_payload))\\n return jsonify({'prediction': prediction})\",\n \"def train_predict_and_results(data, clf):\\n tra_x, tst_x, tra_y, tst_y = data\\n clf.fit(tra_x, tra_y)\\n prd_y = clf.predict(tst_x)\\n cnf = confusion_matrix(tst_y, prd_y)\\n print (\\\"Classifier: %s \\\\tAccuracy score:%7.2f %%\\\"\\n \\\"\\\\tTN:%5d FP:%5d FN:%5d TP:%5d\\\"\\n % (clf.name, accuracy_score(tst_y, prd_y) * 100,\\n cnf[0][0], cnf[0][1], cnf[1][0], cnf[1][1]))\",\n \"def predict():\\n\\n if request.is_json:\\n req = request.get_json(force=True)\\n df = pd.read_json(req, orient='records')\\n return pd.DataFrame(clf_loaded.predict(df).round()).to_json(orient='records')\",\n \"def get_prediction(data):\\n # load cannabis data\\n strains = pd.read_csv(URL)\\n # Combine the Effects and Flavors in one column\\n strains['Criteria'] = strains['Effects'] + ',' + strains['Flavor']\\n\\n # Train model on dtm\\n nn = NearestNeighbors(n_neighbors=5, algorithm='ball_tree')\\n nn.fit(dtm)\\n\\n # load request data\\n # r = data.args\\n entry = [v for k,v in data.items()][1:]\\n #print(entry)\\n # transform\\n new = tf.transform(entry)\\n #print(new)\\n results = nn.kneighbors(new.todense())\\n #print(results)\\n # extract top 5 results\\n output = [strains['Strain'][results[1][0][i]] for i in range(5)]\\n\\n return output\",\n \"def main():\\n\\n # Start and import data\\n print('>>>>> START')\\n dates, prices, price_diff = get_data('data.csv')\\n indices = [i for i in range(0, len(prices))]\\n \\n # Quick filtering to enable good visualization\\n # This section can be commented if wished\\n delete_outlayers(dates, price_diff)\\n delete_outlayers(prices, price_diff)\\n delete_outlayers(indices, price_diff)\\n price_diff.remove(max(price_diff))\\n price_diff.remove(min(price_diff))\\n print('>>>>> STATUS: DATA FORMATTING DONE')\\n\\n # Model and prediction\\n predicted_price = predict_price(indices, dates, price_diff, 1829)\\n print('RESULTING PREDICTION = ', (predicted_price * -1) + prices[0])\\n print('>>>>> DONE')\",\n \"def do_inferences(driver, infer_url, path_to_preds, column_names, test_dict_ord):\\n\\n save_each = 100\\n len_of_list = len(test_dict_ord)\\n counter = 0\\n \\n driver.get(infer_url)\\n \\n predictions = []\\n time1 = time.time()\\n for row in test_dict_ord:\\n \\n text_model = WebDriverWait(driver, 20).until(\\\\\\n EC.presence_of_element_located((By.ID, 'text_model')))\\n\\n text_model.clear()\\n text_model.send_keys(MODEL)\\n\\n infer_types = driver.find_element_by_id('btn_infer_types')\\n infer_types.click()\\n WebDriverWait(driver, 20).until(\\\\\\n EC.visibility_of_element_located((By.ID, 'values')))\\n\\n for name in column_names:\\n _input = WebDriverWait(driver, 20).until(\\\\\\n EC.presence_of_element_located((By.NAME, name)))\\n _input.clear()\\n _input.send_keys(str(row[name]))\\n \\n btn_infer = driver.find_element_by_id('btn_infer')\\n btn_infer.click()\\n \\n prediction_box = WebDriverWait(driver, 20).until(\\\\\\n EC.visibility_of_element_located((By.ID, 'new-prediction')))\\n prediction = prediction_box.text\\n predictions.append(prediction)\\n driver.refresh()\\n \\n counter+=1\\n if counter % save_each == 0:\\n time2 = time.time()\\n batch_time = time2 - time1\\n print(\\\"Progress: {}/{}\\\".format(counter, len_of_list))\\n print(\\\"Time elapsed: {}/{}\\\".format(str((batch_time)*(counter//save_each)), \\n str(batch_time)*(len_of_list//save_each)))\\n time1 = time2\\n with open(path_to_preds, 'a') as f:\\n for pred in predictions:\\n f.write(str(pred)+'\\\\n')\\n predictions = []\\n \\n with open(path_to_preds, 'a') as f:\\n for pred in predictions:\\n f.write(str(pred)+'\\\\n')\",\n \"def main(self, data):\\n\\t\\ttokenizer = BertTokenizer.from_pretrained(\\\"bert-base-uncased\\\", do_lower_case=True)\\n\\t\\teval_features = self.get_features(data, self.labels, tokenizer, self.max_seq_length)\\n\\t\\tlabel, prob = self.predict(eval_features)\\n\\t\\treturn label, prob\",\n \"def prepareData(mdl, X_train, X_val, X_test, Y_train, Y_val, Y_test):\\n\\t\\n\\tX2_train = []\\n\\n\\tX2_val = []\\n\\n\\tX2_test = []\\n\\n\\n\\tYPs = mdl.predict(X_train)\\n\\n\\tfor i in tqdm(range(len(X_train))):\\n\\n\\t\\tX2_train.append(np.array(YPs[i]))\\n\\n\\n\\n\\tYPs = mdl.predict(X_val)\\n\\n\\tfor i in tqdm(range(len(X_val))):\\n\\n\\t\\tX2_val.append(np.array(YPs[i]))\\n\\n\\n\\n\\tYPs = mdl.predict(X_test)\\n\\n\\tfor i in tqdm(range(len(X_test))):\\n\\n\\t\\tX2_test.append(np.array(YPs[i]))\\n\\n\\n\\tX2_train = np.array(X2_train)\\n\\n\\tX2_val = np.array(X2_val)\\n\\n\\tX2_test = np.array(X2_test)\\n\\n\\treturn (X2_train, X2_val, X2_test)\",\n \"def execute(self, requests):\\n responses = []\\n for request in requests:\\n infer_outputs = pb_utils.get_input_tensor_by_name(\\n request, self.input_names[0])\\n im_infos = pb_utils.get_input_tensor_by_name(request,\\n self.input_names[1])\\n ori_imgs = pb_utils.get_input_tensor_by_name(request,\\n self.input_names[2])\\n\\n infer_outputs = infer_outputs.as_numpy()\\n im_infos = im_infos.as_numpy()\\n ori_imgs = ori_imgs.as_numpy()\\n\\n results = self.postprocessor.run([infer_outputs], im_infos)\\n batch_rec_texts = []\\n batch_rec_scores = []\\n batch_box_list = []\\n for i_batch in range(len(results)):\\n\\n cls_labels = []\\n cls_scores = []\\n rec_texts = []\\n rec_scores = []\\n\\n box_list = fd.vision.ocr.sort_boxes(results[i_batch])\\n image_list = []\\n if len(box_list) == 0:\\n image_list.append(ori_imgs[i_batch])\\n else:\\n for box in box_list:\\n crop_img = get_rotate_crop_image(ori_imgs[i_batch], box)\\n image_list.append(crop_img)\\n\\n batch_box_list.append(box_list)\\n\\n cls_pre_tensors = self.cls_preprocessor.run(image_list)\\n cls_dlpack_tensor = cls_pre_tensors[0].to_dlpack()\\n cls_input_tensor = pb_utils.Tensor.from_dlpack(\\n \\\"x\\\", cls_dlpack_tensor)\\n\\n inference_request = pb_utils.InferenceRequest(\\n model_name='cls_pp',\\n requested_output_names=['cls_labels', 'cls_scores'],\\n inputs=[cls_input_tensor])\\n inference_response = inference_request.exec()\\n if inference_response.has_error():\\n raise pb_utils.TritonModelException(\\n inference_response.error().message())\\n else:\\n # Extract the output tensors from the inference response.\\n cls_labels = pb_utils.get_output_tensor_by_name(\\n inference_response, 'cls_labels')\\n cls_labels = cls_labels.as_numpy()\\n\\n cls_scores = pb_utils.get_output_tensor_by_name(\\n inference_response, 'cls_scores')\\n cls_scores = cls_scores.as_numpy()\\n\\n for index in range(len(image_list)):\\n if cls_labels[index] == 1 and cls_scores[\\n index] > self.cls_threshold:\\n image_list[index] = cv2.rotate(\\n image_list[index].astype(np.float32), 1)\\n image_list[index] = np.astype(np.uint8)\\n\\n rec_pre_tensors = self.rec_preprocessor.run(image_list)\\n rec_dlpack_tensor = rec_pre_tensors[0].to_dlpack()\\n rec_input_tensor = pb_utils.Tensor.from_dlpack(\\n \\\"x\\\", rec_dlpack_tensor)\\n\\n inference_request = pb_utils.InferenceRequest(\\n model_name='rec_pp',\\n requested_output_names=['rec_texts', 'rec_scores'],\\n inputs=[rec_input_tensor])\\n inference_response = inference_request.exec()\\n if inference_response.has_error():\\n raise pb_utils.TritonModelException(\\n inference_response.error().message())\\n else:\\n # Extract the output tensors from the inference response.\\n rec_texts = pb_utils.get_output_tensor_by_name(\\n inference_response, 'rec_texts')\\n rec_texts = rec_texts.as_numpy()\\n\\n rec_scores = pb_utils.get_output_tensor_by_name(\\n inference_response, 'rec_scores')\\n rec_scores = rec_scores.as_numpy()\\n\\n batch_rec_texts.append(rec_texts)\\n batch_rec_scores.append(rec_scores)\\n\\n out_tensor_0 = pb_utils.Tensor(\\n self.output_names[0],\\n np.array(\\n batch_rec_texts, dtype=np.object_))\\n out_tensor_1 = pb_utils.Tensor(self.output_names[1],\\n np.array(batch_rec_scores))\\n out_tensor_2 = pb_utils.Tensor(self.output_names[2],\\n np.array(batch_box_list))\\n inference_response = pb_utils.InferenceResponse(\\n output_tensors=[out_tensor_0, out_tensor_1, out_tensor_2])\\n responses.append(inference_response)\\n return responses\",\n \"def _load_processed_data(self):\\n with open(os.path.join(self._data_root_path, self._processed_train_data_file_name),\\n 'r') as f:\\n train_examples = json.load(f)\\n\\n with open(os.path.join(self._data_root_path, self._processed_dev_data_file_name), 'r') as f:\\n dev_examples = json.load(f)\\n\\n with open(os.path.join(self._data_root_path, self._word_vocab_file_name), 'r') as f:\\n word_vocab = Vocab.from_json(json.load(f))\\n\\n with open(os.path.join(self._data_root_path, self._char_vocab_file_name), 'r') as f:\\n char_vocab = Vocab.from_json(json.load(f))\\n\\n return train_examples, dev_examples, word_vocab, char_vocab\",\n \"def set_training_fetches(self, fetched):\\n self_fetched = fetched[self._name]\\n self._loss = self_fetched['loss']\\n\\n names = ['loss', 'output', 'target', 'degraded']\\n\\n if self._hparams.use_batch_transformer:\\n names = names + ['bt_input', 'bt_output']\\n\\n self._dual.set_fetches(fetched, names)\\n\\n if self._summary_op is not None:\\n self._summary_values = fetched[self._name]['summaries']\",\n \"def dataset_difficulty():\\n results = []\\n datasets = [ data_2007, data_2012, data_indoor, data_easy ] \\n \\n for data in datasets:\\n \\n #Let the user know where we are\\n print data\\n X,Y = load_csv(data)\\n \\n # Training/testing split + LDA fit\\n X_train, X_test, Y_train, Y_test = cross_validation.train_test_split(X, Y)\\n lda = LDA()\\n lda.fit(X_train, Y_train)\\n \\n # Use linear SVC\\n clf = svm.SVC(kernel=\\\"linear\\\")\\n clf.fit(lda.transform(X_train), Y_train)\\n \\n # Predictions\\n train_predict = clf.predict(lda.transform(X_train))\\n test_predict = clf.predict(lda.transform(X_test))\\n \\n #Compute accuracy\\n train_acc = 1.*sum(train_predict == Y_train)/len(train_predict)\\n test_acc = 1.*sum(test_predict == Y_test)/len(test_predict)\\n \\n # Append results for that dataset\\n results += [ [ data, train_acc, test_acc, clf, lda ] ]\\n \\n return results\",\n \"def load_data(self):\\n with open('data/fordTrain.csv') as f:\\n data = csv.reader(f, delimiter=',')\\n train = [x for i, x in enumerate(data) if i > 0] \\n # Extract features and target variable separately\\n trainx = [x[3:] for x in train]\\n trainy = [x[2] for x in train]\\n\\n with open('data/fordTest.csv') as f:\\n data = csv.reader(f, delimiter=',')\\n testx = [x[3:] for i, x in enumerate(data) if i > 0] \\n\\n with open('data/Solution.csv') as f:\\n data = csv.reader(f, delimiter=',')\\n testy = [x[2] for i, x in enumerate(data) if i > 0] \\n\\n # Extract features and target variable, convert to numpy array\\n trainx = np.asarray(trainx, dtype=np.float32)\\n trainy = np.asarray(trainy, dtype=np.int8)\\n testx = np.asarray(testx, dtype=np.float32)\\n testy = np.asarray(testy, dtype=np.int8)\\n\\n # Return training and test sets\\n trainSet = Dataset(trainx, trainy)\\n testSet = Dataset(testx, testy)\\n return trainSet, testSet\",\n \"def fetch_self(self):\\r\\n self.parsed_doc['names'] = self.fetch_candidate_name() \\r\\n self.parsed_doc['phones'] = self.fetch_phone_numbers() \\r\\n self.parsed_doc['emails'] = self.fetch_emails() \\r\\n self.parsed_doc['github'] = self.fetch_github() \\r\\n self.parsed_doc['linkedin'] = self.fetch_linkedin() \\r\\n self.parsed_doc['degrees'] = self.fetch_degrees() \\r\\n self.parsed_doc['skills'] = self.fetch_skills() \\r\\n self.parsed_doc['education'] = self.fetch_education() \\r\\n self.parsed_doc['languages'] = self.fetch_languages() \\r\\n self.parsed_doc['addresses'] = self.fetch_address() \\r\\n self.parsed_doc['raw_resume'] = self.stringtext\",\n \"def predict_multiple():\\n req = request.json\\n values = pd.DataFrame(data=req['data'])\\n pred = clf2.predict(values)\\n responses = {}\\n for i, rep in enumerate(pred):\\n if rep:\\n responses[f\\\"Customer {i + 1}\\\"] = f\\\"Input: {', '.join([str(values.loc[i, :][j]) for j in range(values.shape[1])])}, Output: is likely to churn\\\"\\n\\n else:\\n responses[f\\\"Customer {i + 1}\\\"] = f\\\"Input: {', '.join([str(values.loc[i, :][j]) for j in range(values.shape[1])])}, Output: is a loyal customer\\\"\\n\\n return make_response(jsonify(responses))\",\n \"def main():\\n data = load_data()\\n analyze_features(data['full_features'])\\n model = train(data)\\n\\n with open('model.pickle', 'wb') as f:\\n pickle.dump(model, f)\\n evaluate(model, data)\",\n \"async def predict(input_data: schemas.MultipleUserDataInputs) -> Any:\\n print(input_data.inputs)\\n input_df = jsonable_encoder(input_data.inputs)[0][\\\"user_handle\\\"]\\n print(input_df)\\n logger.info(f\\\"Making prediction on inputs: {input_data.inputs}\\\")\\n results = make_prediction(input_df)\\n\\n logger.info(f\\\"Prediction results: {results.get('predictions')}\\\")\\n\\n return results\",\n \"async def fetch_data(self) -> T:\",\n \"def _fetch(self):\\n self._data = self._get(self.url)\\n\\n if self._data['released_errata'] is not None:\\n self._released_errata = Erratum(errata_id=self._data[\\n 'released_errata']['id'])\\n\\n for errata_dict in self._data['all_errata']:\\n errata = Erratum(errata_id=errata_dict['id'])\\n self._all_errata.append(errata)\\n\\n self._signed_rpms = self._data.get('rpms_signed')\\n\\n for et_file in self._data['files']:\\n self._files.append(et_file['path'])\",\n \"def main():\\n season_2019_preds_for_tipresias_2020 = Q(ml_model__name=\\\"tipresias_2020\\\") & Q(\\n match__start_date_time__year=2019\\n )\\n season_2020_preds_for_round_1 = Q(match__start_date_time__year=2020) & (\\n Q(match__round_number=1)\\n )\\n\\n prediction_records = Prediction.objects.filter(\\n season_2019_preds_for_tipresias_2020 | season_2020_preds_for_round_1\\n ).values(*_get_fields_for(Prediction))\\n\\n prediction_dump = [\\n _reshape_record_fields(\\\"prediction\\\", record) for record in prediction_records\\n ]\\n dump_filepath = os.path.join(\\n settings.BASE_DIR, APP_NAME, \\\"fixtures\\\", f\\\"{date.today()}-prediction-dump.json\\\",\\n )\\n\\n with open(dump_filepath, \\\"w\\\") as file:\\n json.dump(prediction_dump, file, indent=2)\",\n \"def test():\\n # load dataset and model\\n X, observed_y = load_data('../data/dev.txt')\\n\\n model = pickle.load(open('test.model', 'rb'))\\n model.traverse()\\n\\n # predict labels for dataset\\n preds = model.predict(X)\\n\\n # print(preds)\\n # output model predictions\\n np.savetxt('test.predictions', preds, fmt='%s')\",\n \"def setup(self):\\n # TODO check if need both dataset together\\n self.train_dataset = ABSADataset(data_path=self.train_path, mode=self.in_mode, task=self.task, \\n tokenizer=self.tokenizer, vocab=\\\"bert\\\")\\n self.vocabulary = self.train_dataset.vocabulary\\n\\n self.eval_dataset = ABSADataset(data_path=self.dev_path, mode=self.in_mode, task=self.task,\\n tokenizer=self.tokenizer, vocab=self.vocabulary)\\n #self.train_restaurant = ABSADataset(data_path=RESTAURANT_TRAIN)\\n #self.eval_restaurant = ABSADataset(data_path=RESTAURANT_DEV)\",\n \"def model_data():\\n x_train, y_train, x_val, y_val, x_test, y_test = read_data(\\\"src/tests/dataclassificationmodel/ferPlus_processed.pbz2\\\", False)\\n return x_train, y_train, x_val, y_val, x_test, y_test\",\n \"def _get_result(self):\\n try:\\n # get test data\\n test_id = self._feature_processor.test_data_id\\n test_feature = self._feature_processor.test_data_feature\\n test_target = self._feature_processor.test_data_target\\n\\n # process data\\n test_feature = test_feature.astype(\\\"float64\\\", errors='ignore')\\n\\n # predict\\n predict_res = self._model.predict(test_feature)\\n predict_res_df = pd.DataFrame(predict_res, columns=[PredictConstance.PRE])\\n proba_res = self._model.predict_proba(test_feature)\\n proba_res_df = pd.DataFrame([str(x) for x in proba_res],\\n columns=[PredictConstance.PROBA])\\n\\n res = [test_id, predict_res_df, proba_res_df]\\n # get model score\\n if test_target is not None:\\n res.append(test_target)\\n model_auc = pre_utils.PredictUtils.get_roc_score(test_target, proba_res)\\n model_score = pre_utils.PredictUtils.get_model_score(test_target, predict_res)\\n model_score.update(model_auc)\\n with open(os.path.join(self._result_path, PredictConstance.TEST_SCORE), \\\"w\\\") as ftp:\\n ftp.write(str(model_score))\\n\\n # joint predict result\\n self._joint_predict_result(res)\\n\\n return True\\n except Exception as err:\\n self.managerlogger.logger.error(\\\"base ml get result error: %s\\\" % err)\\n self.errorlogger.logger.error(\\\"base ml get result error:\\\\n %s\\\" % traceback.format_exc())\\n return False\",\n \"def _load_training_data(self):\\n self._save_training_data()\",\n \"def fetch_inspect_data(filename, output, db_url=None):\\n r2dt.write_training_data(filename, db_url, output)\",\n \"def prepare_data(raw=False, round_ratings=False):\\n print('Downloading input data...')\\n if raw:\\n # read data\\n review = get_input(\\n 'https://www.dropbox.com/s/mtln9b6udoydn2h/yelp_academic \\\\\\n _dataset_review_sample.csv?dl=1')\\n user = get_input(\\n 'https://www.dropbox.com/s/pngrptljotqm4ds/yelp_academic \\\\\\n _dataset_user.json?dl=1')\\n business = get_input(\\n 'https://www.dropbox.com/s/w0wy854u5swrhmc/yelp_academic \\\\\\n _dataset_business.json?dl=1')\\n\\n # join datasets\\n review_user = pd.merge(\\n review, user, on=\\\"user_id\\\",\\n how=\\\"left\\\", suffixes=(\\\"\\\", \\\"_user\\\"))\\n review_user_business = pd.merge(\\n review_user, business, on=\\\"business_id\\\",\\n how=\\\"left\\\", suffixes=(\\\"\\\", \\\"_business\\\"))\\n review_user_business = review_user_business[[\\n 'user_id', 'business_id',\\n 'stars', 'text',\\n 'name', 'average_stars',\\n 'name_business', 'stars_business',\\n 'categories', 'state', 'city']]\\n else:\\n review_user_business = get_input(\\n 'https://www.dropbox.com/s/sj445d95lljuc4p/small_sample.parquet?dl=1'\\n )\\n if round_ratings:\\n # bucketize numeric features to reduce dimensions\\n review_user_business['average_stars'] = review_user_business[\\n 'average_stars'].apply(lambda x: round_of_rating(x))\\n review_user_business['stars_business'] = review_user_business[\\n 'stars_business'].apply(lambda x: round_of_rating(x))\\n return review_user_business\",\n \"def main():\\n \\n logging.info('Loading classification dataset from db')\\n # start_time = dt.datetime.strptime(options.start_time, \\\"%Y%m%d%H%M\\\")\\n # end_time = dt.datetime.strptime(options.end_time, \\\"%Y%m%d%H%M\\\")\\n\\n a = mlfb.mlfb(1, logging_level=options.logging_level)\\n metadata, header, data = a.get_rows(options.dataset, rowtype=options.type)\\n\\n logging.debug('Length of metadata: {}'.format(len(metadata)))\\n logging.debug('Shape of data {}'.format(data.shape))\\n logging.debug('Header is: {}'.format(','.join(header)))\\n\\n print(header)\\n print(np.array(metadata))\\n print(data)\\n \\n # TODO saving as csv\\n \\n # Serialize model to disc\\n # logging.info('Serializing dataset to disc: {}'.format(options.save_path))\\n \\n # csv = dataset.as_csv()\\n # with open(options.save_path, \\\"w\\\") as f: \\n # f.write(csv)\",\n \"def predict(self, data_dict, label_dict, phases=[\\\"test\\\"]):\\n loaders = self.init_loaders_predict(data_dict, label_dict)\\n loss_dict = self.init_loss_dict(phases=phases)\\n performance_dict = self.init_performance_dict(phases=phases)\\n self.model.train(False)\\n with torch.no_grad():\\n output_dict_dict = {}\\n for phase in phases:\\n i = 0\\n running_loss_dict = self.init_running_loss_dict(\\n list(loss_dict[phase].keys())\\n )\\n output_dict = self.init_output_dict()\\n for the_data in loaders[phase]:\\n i += 1\\n inputs, labels = self.transform_batch(the_data)\\n outputs = self.model(inputs)\\n output_dict = self.update_output_dict(output_dict, outputs, labels)\\n loss_dict[\\\"loss\\\"] = self.criterion(outputs, labels)\\n running_loss_dict[\\\"loss\\\"] += loss_dict[\\\"loss\\\"].item()\\n\\n # Compute epoch losses and update loss dict\\n epoch_loss_dict = {\\n key: running_loss_dict[key] / i for key in running_loss_dict.keys()\\n }\\n loss_dict[phase] = self.update_metric_dict(\\n loss_dict[phase], epoch_loss_dict\\n )\\n # Compute epoch performance and update performance dict\\n epoch_statistics = self.compute_epoch_statistics(output_dict)\\n performance_dict[phase] = self.update_metric_dict(\\n performance_dict[phase], epoch_statistics\\n )\\n output_dict_dict[phase] = self.finalize_output_dict(output_dict)\\n result_dict = {\\n phase: {**performance_dict[phase], **loss_dict[phase]}\\n for phase in performance_dict.keys()\\n }\\n return output_dict_dict, result_dict\",\n \"def make_predictions(self):\\n if is_classification(self.model):\\n if self.ct == None:\\n prediction = self.model.predict(self.input_data.to_numpy())\\n probabilities = self.model.predict_proba(self.input_data.to_numpy())\\n return prediction, probabilities\\n elif self.ct != None: \\n prediction = self.model.predict(self.data_into_model())\\n probabilities = self.model.predict_proba(self.data_into_model())\\n return prediction, probabilities\\n else:\\n raise Exception((\\\"{} not supported. Please create an issue on Github\\\").format(self.model))\\n \\n else:\\n if self.ct == None:\\n prediction = self.model.predict(self.input_data)\\n return prediction\\n elif self.ct != None: \\n prediction = self.model.predict(self.data_into_model())\\n return prediction\\n else:\\n raise Exception((\\\"{} not supported. Please create an issue on Github\\\").format(self.self.model))\",\n \"def get_predictions(year, month):\\n \\n start_date = str(year)+\\\"-\\\"+str(month)+\\\"-01\\\"\\n end_date = str(year)+\\\"-\\\"+str(month)+\\\"-\\\"+str(monthrange(year, month)[1])\\n\\n date_range = pd.date_range(start_date,end_date, freq='D').strftime(\\\"%Y-%m-%d\\\").tolist()\\n\\n # predictfunction \\n # do predictions\\n pred_arr = []\\n file_name = '../predictions/model_'+str(year)+'_'+str(month)+'.csv'\\n \\n try:\\n predictions = load_predictions(file_name)\\n predictions = predictions.round()\\n except:\\n print(\\\"An exception occurred\\\")\\n predictions = pd.DataFrame(data = date_range,columns=['Datum'])\\n \\n \\n for index,row in predictions.iterrows():\\n \\n pred_mail = 0\\n pred_counter = 0\\n pred_tel = 0\\n \\n # check predictions dataframe for 'Datum'\\n if 'Datum' in predictions.columns:\\n date = row['Datum']\\n else:\\n break;\\n\\n # check predictions dataframe for 'Mail'\\n if 'Mail' in predictions.columns:\\n pred_mail = row['Mail']\\n\\n # check predictions dataframe for 'Schalter'\\n if 'Schalter' in predictions.columns:\\n pred_counter = row['Schalter']\\n\\n # check predictions dataframe for 'Tel'\\n if 'Tel' in predictions.columns:\\n pred_tel = row['Tel']\\n \\n \\n pred_dict = {'date': date, \\n 'predictions':{'mail' : pred_mail, \\n 'tel' : pred_tel, \\n 'counter' : pred_counter\\n }\\n }\\n\\n pred_arr.append(pred_dict)\\n\\n print(pred_arr) \\n \\n return pred_arr\",\n \"def _predict_all(self, data):\\n preds = np.zeros(len(data))\\n for row in data.itertuples():\\n index, item, _, user = row\\n preds[index] = self.predict(user, item)\\n return preds\",\n \"def fetch(self):\\n\\n\\n # Update Prometheus metrics with application metrics\\n self.current_requests.set(get_current_requests())\\n self.total_uptime.set(get_uptime())\\n self.health.state(get_health())\",\n \"def download_training_data(data_dir, task):\\n\\n COMMENTS_FILE = \\\"%s_annotated_comments.tsv\\\" % task\\n LABELS_FILE = \\\"%s_annotations.tsv\\\" % task\\n\\n if task == \\\"attack\\\":\\n download_file(ATTACK_ANNOTATED_COMMENTS_URL,\\n os.path.join(data_dir, COMMENTS_FILE))\\n download_file(ATTACK_ANNOTATIONS_URL, os.path.join(data_dir,\\n LABELS_FILE))\\n elif task == \\\"recipient_attack\\\":\\n download_file(ATTACK_ANNOTATED_COMMENTS_URL,\\n os.path.join(data_dir, COMMENTS_FILE))\\n download_file(ATTACK_ANNOTATIONS_URL, os.path.join(data_dir,\\n LABELS_FILE))\\n elif task == \\\"aggression\\\":\\n download_file(AGGRESSION_ANNOTATED_COMMENTS_URL,\\n os.path.join(data_dir, COMMENTS_FILE))\\n download_file(AGGRESSION_ANNOTATIONS_URL,\\n os.path.join(data_dir, LABELS_FILE))\\n elif task == \\\"toxicity\\\":\\n download_file(TOXICITY_ANNOTATED_COMMENTS_URL,\\n os.path.join(data_dir, COMMENTS_FILE))\\n download_file(TOXICITY_ANNOTATIONS_URL,\\n os.path.join(data_dir, LABELS_FILE))\\n else:\\n print(\\\"No training data for task: \\\", task)\",\n \"def load_data_raw(source='local'):\\n import os\\n\\n if source == 'kaggle':\\n # Download the Ames Housing Dataset\\n # Set the enviroment variables\\n import zipfile\\n os.environ['KAGGLE_USERNAME'] = \\\"lubomrstraka\\\"\\n os.environ['KAGGLE_KEY'] = \\\"c7347462ef834e6645ce238c2f2fa561\\\"\\n \\n # Import dependencies\\n os.system(\\\"pip install kaggle --upgrade --quiet\\\")\\n\\n # Download datasets\\n os.system(\\\"kaggle competitions download -c house-prices-advanced-regression-techniques --quiet\\\")\\n \\n # Extract data\\n with zipfile.ZipFile('house-prices-advanced-regression-techniques.zip', 'r') as archive:\\n archive.extractall()\\n\\n # Read Train & Test Baseline Data\\n train_bl = pd.read_csv('train.csv', index_col='Id')\\n test_bl = pd.read_csv('test.csv', index_col='Id')\\n \\n # Using local data used while registering dataset\\n # prevents \\\"Too many requests\\\" response from Kaggle\\n elif source == 'local': \\n train_bl = pd.read_csv('train.csv', index_col='Id')\\n test_bl = pd.read_csv('test.csv', index_col='Id')\\n \\n else:\\n print('Missing data!')\\n train_bl = pd.DataFrame()\\n test_bl = pd.DataFrame()\\n\\n\\n return train_bl, test_bl\",\n \"def setup(self):\\n in_dataset, out_dataset = self.get_datasets()\",\n \"def setup(self):\\n in_dataset, out_dataset = self.get_datasets()\",\n \"def iterate_data(self):\\n if \\\"single\\\" in self.dataset_name:\\n # Index 0 for list of sentence lengths, index 1 for list of token lengths\\n self.stat_dict = {'question': [[], []], 'summary': [[], []], 'article': [[], []]}\\n for answer_id in self.data:\\n summary = self.data[answer_id]['summary']\\n articles = self.data[answer_id]['articles']\\n question = self.data[answer_id]['question']\\n if args.tokenize:\\n self._get_token_cnts(summary, 'summary')\\n self._get_token_cnts(articles, 'article')\\n self._get_token_cnts(question, 'question')\\n self._write_stats(\\\"token_counts\\\")\\n\\n if \\\"multi\\\" in self.dataset_name:\\n self.stat_dict = {'question': [[], []], 'summary': [[], []], 'article': [[], []]}\\n for q_id in self.data:\\n summary = self.data[q_id]['summary']\\n question = self.data[q_id]['question']\\n if args.tokenize:\\n self._get_token_cnts(summary, 'summary')\\n self._get_token_cnts(question, 'question')\\n question = self.data[q_id]['question']\\n for answer_id in self.data[q_id]['articles']:\\n articles = self.data[q_id]['articles'][answer_id][0]\\n if args.tokenize:\\n self._get_token_cnts(articles, 'article')\\n self._write_stats(\\\"token_counts\\\")\\n\\n if self.dataset_name == \\\"complete_dataset\\\":\\n self.stat_dict = {'urls': [], 'sites': []}\\n article_dict = {}\\n print(\\\"Counting answers, sites, unique urls, and tokenized counts of unique articles\\\")\\n answer_cnt = 0\\n for q_id in self.data:\\n for a_id in self.data[q_id]['answers']:\\n answer_cnt += 1\\n url = self.data[q_id]['answers'][a_id]['url']\\n article = self.data[q_id]['answers'][a_id]['article']\\n if url not in article_dict:\\n article_dict[url] = article\\n self.stat_dict['urls'].append(url)\\n assert \\\"//\\\" in url, url\\n site = url.split(\\\"//\\\")[1].split(\\\"/\\\")\\n self.stat_dict['sites'].append(site[0])\\n print(\\\"# of Answers:\\\", answer_cnt)\\n print(\\\"Unique articles: \\\", len(article_dict)) # This should match up with count written to file\\n self._write_stats(\\\"full collection\\\")\\n\\n # Get token/sent averages of unique articles\\n if args.tokenize:\\n self.stat_dict = {'article': [[], []]}\\n for a in article_dict:\\n self._get_token_cnts(article_dict[a], 'article')\\n self._write_stats(\\\"token_counts\\\")\",\n \"def run_prediction(data, sess, placeholders, scores): \\r\\n \\r\\n X, Y = data\\r\\n source_pl, target_pl, training_pl = placeholders\\r\\n split_set = int(math.floor(0.9*len(X))) # Value for spliting the set in 90% training / 10% test \\r\\n \\r\\n X_batch, Y_batch = batch(X[:split_set:], Y[:split_set:]) # Take a batch of sentences from the training set\\r\\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\\r\\n prediction = sess.run(scores, feed_dict=feed_dict) \\r\\n X_batch = np.squeeze(X_batch) \\r\\n prediction = np.squeeze(prediction)\\r\\n \\r\\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\\r\\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\\r\\n\\r\\n\\t# Print the pairs source -> target\\r\\n for source, target in zip(source_sentences, target_sentences): \\r\\n print(source + \\\" --> \\\" + target)\\r\\n \\r\\n print(\\\"================================================================\\\")\\r\\n \\r\\n X_batch, Y_batch = batch(X[split_set+1:], Y[split_set+1:]) # Take a batch of sentences from the test set\\r\\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\\r\\n prediction = sess.run(scores, feed_dict=feed_dict) \\r\\n \\r\\n X_batch = np.squeeze(X_batch) \\r\\n prediction = np.squeeze(prediction)\\r\\n \\r\\n \\r\\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\\r\\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\\r\\n\\r\\n\\t# Print the pairs source -> target\\r\\n for source, target in zip(source_sentences, target_sentences): \\r\\n print(source + \\\" --> \\\" + target)\",\n \"def process_dataset(self):\\n\\n logger.info('\\\\n')\\n logger.info('=' * 40)\\n logger.info('=\\\\t DeepRank Data Set')\\n logger.info('=')\\n logger.info('=\\\\t Training data')\\n for f in self.train_database:\\n logger.info(f'=\\\\t -> {f}')\\n logger.info('=')\\n if self.valid_database:\\n logger.info('=\\\\t Validation data')\\n for f in self.valid_database:\\n logger.info(f'=\\\\t -> {f}')\\n logger.info('=')\\n if self.test_database:\\n logger.info('=\\\\t Test data')\\n for f in self.test_database:\\n logger.info(f'=\\\\t -> {f}')\\n logger.info('=')\\n logger.info('=' * 40 + '\\\\n')\\n sys.stdout.flush()\\n\\n # check if the files are ok\\n self.check_hdf5_files(self.train_database)\\n\\n if self.valid_database:\\n self.valid_database = self.check_hdf5_files(\\n self.valid_database)\\n\\n if self.test_database:\\n self.test_database = self.check_hdf5_files(\\n self.test_database)\\n\\n # create the indexing system\\n # alows to associate each mol to an index\\n # and get fname and mol name from the index\\n self.create_index_molecules()\\n\\n # get the actual feature name\\n if self.mapfly:\\n self.get_raw_feature_name()\\n else:\\n self.get_mapped_feature_name()\\n\\n # get the pairing\\n self.get_pairing_feature()\\n\\n # get grid shape\\n self.get_grid_shape()\\n\\n # get the input shape\\n self.get_input_shape()\\n\\n # get renormalization factor\\n if self.normalize_features or self.normalize_targets or self.clip_features:\\n if self.mapfly:\\n self.compute_norm()\\n else:\\n self.get_norm()\\n\\n logger.info('\\\\n')\\n logger.info(\\\" Data Set Info:\\\")\\n logger.info(\\n f' Augmentation : {self.use_rotation} rotations')\\n logger.info(\\n f' Training set : {self.ntrain} conformations')\\n logger.info(\\n f' Validation set : {self.nvalid} conformations')\\n logger.info(\\n f' Test set : {self.ntest} conformations')\\n logger.info(f' Number of channels : {self.input_shape[0]}')\\n logger.info(f' Grid Size : {self.data_shape[1]}, '\\n f'{self.data_shape[2]}, {self.data_shape[3]}')\\n sys.stdout.flush()\",\n \"def get_initial_predictions(tuner, input_data, output_path, model_save_name):\\n\\n best_model = tuner.best_estimator()\\n batch_job = best_model.transformer(1, \\\"ml.m5.large\\\", output_path=output_path.as_uri(),\\n model_name=model_save_name)\\n batch_job.transform(input_data.as_uri())\\n # TODO: Do an ls first so we can get any/all files\\n output_file = output_path / 'validation.csv.out'\\n with smart.open(output_file.as_uri(), 'r', transport_params={'session': boto_session}) as f:\\n predictions = pd.read_csv(f, header=None)\\n return predictions\",\n \"def get_data(n = None):\\n files = download_data()\\n for path in files.values():\\n extract_data(path)\\n class_fnames, labelmap = explore_data()\\n X, y = load_data(class_fnames)\\n return prepare_data(X, y, n = n)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67397493","0.66788644","0.65545076","0.64402926","0.6339428","0.63302475","0.63217604","0.62826043","0.6261717","0.62599313","0.62335795","0.61924237","0.6142523","0.61279005","0.61167353","0.6081533","0.60656494","0.60575473","0.6055011","0.6031515","0.5996507","0.59810406","0.59686196","0.59573746","0.5954341","0.595363","0.5926263","0.5926263","0.59048843","0.59044904","0.58848524","0.5873448","0.58520466","0.5836435","0.5836336","0.5835842","0.5834115","0.5823973","0.5820319","0.58115715","0.58025557","0.5794198","0.57918996","0.57807165","0.5774857","0.57736546","0.57729477","0.57673895","0.57616866","0.57598174","0.5755086","0.57490015","0.57447606","0.572272","0.5716855","0.57152665","0.5711503","0.56992495","0.56965727","0.569522","0.5684993","0.56606555","0.5655707","0.56515795","0.56509244","0.5637257","0.56337136","0.56174266","0.5615267","0.56109214","0.560216","0.5599338","0.559457","0.5590768","0.5588909","0.55881435","0.55881095","0.558091","0.5578332","0.55741775","0.55735594","0.5573014","0.55724716","0.5569718","0.5569316","0.5567177","0.55669165","0.5565302","0.5561101","0.55607873","0.55559045","0.55495006","0.5543259","0.5537944","0.5537944","0.5537833","0.5535035","0.5534795","0.55250263","0.55230355"],"string":"[\n \"0.67397493\",\n \"0.66788644\",\n \"0.65545076\",\n \"0.64402926\",\n \"0.6339428\",\n \"0.63302475\",\n \"0.63217604\",\n \"0.62826043\",\n \"0.6261717\",\n \"0.62599313\",\n \"0.62335795\",\n \"0.61924237\",\n \"0.6142523\",\n \"0.61279005\",\n \"0.61167353\",\n \"0.6081533\",\n \"0.60656494\",\n \"0.60575473\",\n \"0.6055011\",\n \"0.6031515\",\n \"0.5996507\",\n \"0.59810406\",\n \"0.59686196\",\n \"0.59573746\",\n \"0.5954341\",\n \"0.595363\",\n \"0.5926263\",\n \"0.5926263\",\n \"0.59048843\",\n \"0.59044904\",\n \"0.58848524\",\n \"0.5873448\",\n \"0.58520466\",\n \"0.5836435\",\n \"0.5836336\",\n \"0.5835842\",\n \"0.5834115\",\n \"0.5823973\",\n \"0.5820319\",\n \"0.58115715\",\n \"0.58025557\",\n \"0.5794198\",\n \"0.57918996\",\n \"0.57807165\",\n \"0.5774857\",\n \"0.57736546\",\n \"0.57729477\",\n \"0.57673895\",\n \"0.57616866\",\n \"0.57598174\",\n \"0.5755086\",\n \"0.57490015\",\n \"0.57447606\",\n \"0.572272\",\n \"0.5716855\",\n \"0.57152665\",\n \"0.5711503\",\n \"0.56992495\",\n \"0.56965727\",\n \"0.569522\",\n \"0.5684993\",\n \"0.56606555\",\n \"0.5655707\",\n \"0.56515795\",\n \"0.56509244\",\n \"0.5637257\",\n \"0.56337136\",\n \"0.56174266\",\n \"0.5615267\",\n \"0.56109214\",\n \"0.560216\",\n \"0.5599338\",\n \"0.559457\",\n \"0.5590768\",\n \"0.5588909\",\n \"0.55881435\",\n \"0.55881095\",\n \"0.558091\",\n \"0.5578332\",\n \"0.55741775\",\n \"0.55735594\",\n \"0.5573014\",\n \"0.55724716\",\n \"0.5569718\",\n \"0.5569316\",\n \"0.5567177\",\n \"0.55669165\",\n \"0.5565302\",\n \"0.5561101\",\n \"0.55607873\",\n \"0.55559045\",\n \"0.55495006\",\n \"0.5543259\",\n \"0.5537944\",\n \"0.5537944\",\n \"0.5537833\",\n \"0.5535035\",\n \"0.5534795\",\n \"0.55250263\",\n \"0.55230355\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.666906"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":92899,"cells":{"query":{"kind":"string","value":"Sample from model predictions, and evaluate outputs"},"document":{"kind":"string","value":"def _evaluate(self,\n logits,\n predictions,\n data, evaluation_fn,\n max_eval_batches=None,\n calculate_scores=True,\n write_results=False):\n # counting the evaluation batches\n num_eval_batches = 0\n # logits and predictions from the model\n all_logits = []\n all_predictions = []\n # fetched data that led to the predictions\n # dictionary of {seq_1: [], seq_2: [], target: []}\n all_fetched_data = collections.defaultdict(list)\n try:\n while True:\n # sample predictions\n (fetched_logits,\n fetched_predictions,\n fetched_data) = self._fetch_data_batch(\n logits=logits, predictions=predictions, data=data)\n\n # Cache the data\n all_logits += fetched_logits\n all_predictions += fetched_predictions\n all_fetched_data[\"target\"] += fetched_data[\"target\"]\n\n # break the loop if max_eval_batches is set\n num_eval_batches += 1\n if (max_eval_batches and\n num_eval_batches >= max_eval_batches):\n break\n\n except tf.errors.OutOfRangeError:\n pass\n\n # Evaluate\n scores = None\n if calculate_scores:\n scores = evaluation_fn(\n all_predictions,\n all_fetched_data[\"seq_1\"], # Should be empty\n all_fetched_data[\"seq_2\"], # Should be empty\n all_fetched_data[\"target\"])\n\n if write_results:\n _write_results_to_csv(\n all_logits,\n all_predictions,\n all_fetched_data,\n output_dir=os.path.join(\n self._logdir, RESULTS_CSV_FNAME))\n\n return len(all_predictions), scores"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def evaluate(model, test_files):\n print(\"Running predictions.\")\n models = load_model(model)\n predictions = predict(models, test_files)\n\n # # write predictions to file\n # write_predictions(\"evaluate_out.json\",predictions)\n evaluate_individual(predictions, test_files, models)\n evaluate_overall(predictions)","def eval(self): \n inputs,enc_input_weights, outputs, dec_input_weights = self.get_batch()\n predicted_ids = self.model.step(self.sess, inputs, enc_input_weights) \n print(\"=\"*20)\n for i in range(FLAGS.batch_size):\n print(\"* %dth sample target: %s\" % (i,str(outputs[i,1:]-2)))\n for predict in predicted_ids[i]:\n print(\"prediction: \"+str(predict)) \n print(\"=\"*20)","def evaluate():\n\tmodel.eval()\n\tstddev = 1 # And mean=0\n\tfor batch_idx, (data, _) in enumerate(syn_test_loader):\n\t\tdata = data.cuda()\n\t\tif batch_idx == 0:\n\t\t\tnoise = torch.autograd.Variable(torch.randn(batch_size, bottleneck).cuda() * stddev)\n\t\t\tsample_representation(\"orig_nat\", data, noise)\n\t\t\tsample_representation(\"natural\", data, noise)\n\t\t\tsample_representation(\"orig_syn\", data, noise)\n\t\t\tsample_representation(\"synth\", data, noise)","def evaluate_model_random(self, model_eval_samples): \n neval = len(model_eval_samples)\n task_horizon = len(model_eval_samples[0]['ac'])\n # construct evaluation samples \n\n true_obs = [[] for _ in range(neval)]\n inputs = []\n \n for j in range(neval):\n for k in range(task_horizon ):\n obs = model_eval_samples[j]['obs'][k]\n ac = model_eval_samples[j]['ac'][k]\n inputs.append( np.concatenate(( obs,ac)) ) \n true_obs[j].append( model_eval_samples[j]['obs'][k] )\n true_obs[j].append( model_eval_samples[j]['obs'][task_horizon] )\n \n \n \n inputs = np.array([ inputs for _ in range(5)])\n\n \n # Evaluation [ensemble_size, batch_size, obs + acs]\n pred = self.policy.model.predict( inputs)\n error = [0 for _ in range(neval)]\n for j in range(neval):\n for k in range(task_horizon):\n for i in range(5):\n error[j] += np.linalg.norm( true_obs[j][k+1] - true_obs[j][k] - pred[0][i][j*task_horizon+k])\n error = np.array(error) / (5*task_horizon)\n print(\"model error: \", np.mean(error), np.std(error))\n return np.mean(error), np.std(error)","def predict(x_tst, model):\n\n predictions = model.predict(x_tst)\n return predictions","def evaluate_model(self, predictions, expected, bypass_data_to_eval):\n\n result = []\n for i, unique_id in enumerate(np.squeeze(expected[\"unique_ids\"])):\n start_logits = predictions['tf_electra_for_question_answering'][i]\n start_top_index = predictions['tf_electra_for_question_answering_1'\n ][i]\n end_logits = predictions['tf_electra_for_question_answering_2'][i]\n end_top_index = predictions['tf_electra_for_question_answering_3'][i\n ]\n cls_logits = predictions['tf_electra_for_question_answering_4'][i]\n\n result.append(\n SquadResult(\n unique_id,\n start_logits.tolist(),\n end_logits.tolist(),\n start_top_index=start_top_index.tolist(),\n end_top_index=end_top_index.tolist(),\n cls_logits=cls_logits.tolist(),\n )\n )\n\n dev_features = bypass_data_to_eval[\"dev_features\"]\n dev_examples = bypass_data_to_eval[\"dev_examples\"]\n\n answers, nbest_answers = get_answers(\n dev_examples, dev_features, result, self._args\n )\n\n output_prediction_file = os.path.join(\n self._args.output_dir, \"predictions.json\"\n )\n output_nbest_file = os.path.join(\n self._args.output_dir, \"nbest_predictions.json\"\n )\n\n with open(output_prediction_file, \"w\") as f:\n f.write(json.dumps(answers, indent=4) + \"\\n\")\n with open(output_nbest_file, \"w\") as f:\n f.write(json.dumps(nbest_answers, indent=4) + \"\\n\")\n\n if self._args.version_2_with_negative:\n dev_file = \"dev-v2.0.json\"\n eval_file = \"evaluate-v2.0.py\"\n else:\n dev_file = \"dev-v1.1.json\"\n eval_file = \"evaluate-v1.1.py\"\n\n command_str = (\n f\"{sys.executable} {os.path.join(self._args.data_dir, eval_file)} \"\n f\"{os.path.join(self._args.data_dir, dev_file)} \"\n f\"{output_prediction_file}\"\n )\n\n logging.debug(f\"\\nExecuting: `{command_str}`\\n\")\n\n eval_out = subprocess.check_output(shlex.split(command_str))\n\n # scores: {'exact_match': 87.06717123935667, 'f1': 92.78048326711645}\n scores = json.loads(eval_out.decode(\"UTF-8\").strip())\n\n logging.debug(\"scores:\", scores)\n\n metric_units = \"f1\"\n\n return scores[metric_units], metric_units","def __call__(self, predictor_model) -> None:\n self.save_result(self.evaluate(predictor_model))","def test(self) -> None:\n\n self._predictions = self._lr.predict(self._X_test)","def evaluate(self):\n\n\t\t## We should be evaluating on dev dataset as well, so commenting x_test\n\t\t#self.model_score = self.model.evaluate(self.x_test, self.y_test_oh, batch_size=2048)\n\t\tself.model_score = self.model.evaluate(self.x_dev, self.y_dev_oh, batch_size=2048)\n\t\tprint(\"%s score = %f\\n\" %(self.modelName, self.model_score[1]))\n\n\t\t##Saving atucal vs predicted predictions\n\t\t##np.argmax returns the index where it see's 1 in the row\n\t\t#y_pred = np.argmax(self.model.predict(self.x_test, batch_size=2048), axis=1)\n\t\ty_pred = np.argmax(self.model.predict(self.x_dev, batch_size=2048), axis=1)\n\n\t\t## vstack will stack them in 2 rows, so we use Trasnpose to get them in column stack\n\t\t#output_predict = np.vstack((np.argmax(self.y_test_oh, axis=1), y_pred)).T\n\t\toutput_predict = np.vstack((np.argmax(self.y_dev_oh, axis=1), y_pred)).T\n\t\toutputFile = self.resultDir + \"/outputPredict.csv\" \n\t\tnp.savetxt(outputFile, output_predict, fmt=\"%5.0f\", delimiter=\",\")\n\n\t\t##Error Analysis of the prediction\n\t\terrorAnalysis(outputFile)\n\n\t\treturn self.model_score","def evaluate_model(model, X_test, Y_test): \n #Make predictions with the model\n Y_pred = model.predict(X_test)\n #convert numpy output to dataframe and add columns\n Y_pred_df = pd.DataFrame(Y_pred)\n Y_pred_df.columns = Y_test.columns\n #Convert predictions and correct y values to float for faciliate comparison\n Y_pred_df = Y_pred_df.astype('float64')\n Y_test = Y_test.astype('float64')\n print_score(Y_test, Y_pred_df, 'weighted avg')","def test():\n # load dataset and model\n X, observed_y = load_data('../data/dev.txt')\n\n model = pickle.load(open('test.model', 'rb'))\n model.traverse()\n\n # predict labels for dataset\n preds = model.predict(X)\n\n # print(preds)\n # output model predictions\n np.savetxt('test.predictions', preds, fmt='%s')","def evaluate(model, eval_data, num_labels): \n # Turn on the evaluation state to ignore dropouts\n model.eval()\n results = [predict(model, x) for x, y in eval_data]\n f1_score, accuracy = get_metrics(np.array([y for x, y in eval_data]), results, num_labels)\n return f1_score, accuracy","def evaluate(self):\n predictions = self.model.predict(self.test[0])\n accuracy = accuracy_score(self.test[1], predictions)\n print(\"Accuracy:\", str(accuracy * 100) + \"%\")\n self.plot_results(predictions)","def test_and_predict_on_batch(model, x, y, sample_weight=None):\n\n x, y, sample_weights = model._standardize_user_data(\n x, y,\n sample_weight=sample_weight)\n if model._uses_dynamic_learning_phase():\n ins = x + y + sample_weights + [0.]\n else:\n ins = x + y + sample_weights\n\n _make_test_and_predict_function(model)\n outputs = model.test_and_predict_function(ins)\n if len(outputs) == 1:\n return outputs[0]\n return outputs","def predict(self, sample, **kwargs):\r\n return self.model.predict(sample, **kwargs)","def evaluate_model(model_name, y_true, y_pred):\n\n # Calculate performance metrics\n rmse_eval = evaluate_rmse(y_true, y_pred)\n mae_eval = evaluate_mae(y_true, y_pred) \n r2_eval = evaluate_r2(y_true, y_pred)\n\n # Print results\n print_evaluation(model_name, mae_eval, rmse_eval, r2_eval)","def test(self):\r\n \r\n args = self.args\r\n model = self.model\r\n dataset = self.dataset\r\n \r\n dataset.set_split('test')\r\n batch_generator = generate_nmt_batches(dataset, \r\n batch_size=len(dataset), \r\n device=args.device)\r\n\r\n acc_sum = 0.0\r\n model.eval()\r\n \r\n for batch_index, batch_dict in enumerate(batch_generator):\r\n # step 1. compute the output\r\n if isinstance(model,NMTModelWithMLTM):\r\n y_pred = model(batch_dict['x_source'], \r\n batch_dict['x_source_mltm_vector'],\r\n batch_dict['x_source_length'], \r\n batch_dict['x_target'])\r\n else:\r\n y_pred = model(batch_dict['x_source'], \r\n batch_dict['x_source_length'], \r\n batch_dict['x_target'])\r\n\r\n acc_t = compute_accuracy(y_pred, batch_dict['y_target'], self.mask_index)\r\n acc_sum += acc_t\r\n \r\n return acc_sum / (batch_index+1)","def get_predictions():\n\n print(\"OK1\");\n print(\"OK2\");\n return;","def testSample(self):\n val_idx = np.load(self.validation_set)\n val_sampler = SubsetRandomSampler(val_idx)\n pose_dataset = PoseDataset(self.dataset_path)\n val_loader = DataLoader(dataset=pose_dataset, batch_size=1,\\\n sampler=val_sampler)\n for i in range(5):\n data_iter = iter(val_loader)\n skel_2d, skel_z = next(data_iter)\n\n # inference\n skel_2d = skel_2d.to(self.device)\n z_out = self.net(skel_2d)\n\n # show\n skel_2d = skel_2d.cpu().numpy()\n skel_2d = skel_2d.reshape((2, -1), order='F') # [(x,y) x n_joint]\n z_out = z_out.detach().cpu().numpy()\n z_out = z_out.reshape(-1)\n z_gt = skel_z.numpy().reshape(-1)\n self.show_skeletons(skel_2d, z_out, z_gt)","def run_sample(self):\n # there will be validation failures for sample data\n self.validate_req(ignore_failure=True)\n runner_fn = self.model_runner.execute_model_for_sample_data\n return self.do_handle_request(runner_fn)","def evaluate(self, predictor_model) -> Any:\n raise NotImplementedError()","def evaluate_prediction(self, model_output, reference):\n with torch.no_grad():\n cross_entropy = self._criterion(\n model_output.view(-1, self.model.ntokens), reference.contiguous().view(-1))\n return {\n \"cross_entropy\": cross_entropy.detach(),\n \"perplexity\": torch.exp(cross_entropy).detach(),\n }","def predict(self): \n return self.model.predict(self.test_x)","def test_predict(self):\n\n docs = self.docs\n for m in self.models:\n preds = m.predict(docs)\n self.assertTrue(isinstance(preds, turicreate.SArray))\n self.assertEqual(len(preds), len(docs))\n self.assertEqual(preds.dtype, int)\n\n preds = m.predict(docs, output_type=\"probability\")\n self.assertTrue(isinstance(preds, turicreate.SArray))\n self.assertTrue(len(preds) == len(docs))\n s = preds.apply(lambda x: sum(x))\n self.assertTrue((s.apply(lambda x: abs(x - 1)) < 0.000001).all())\n\n # Test predictions when docs have new words\n new_docs = turicreate.SArray([{\"-1,-1\": 3.0, \"0,4\": 5.0, \"0,3\": 2.0}])\n preds = m.predict(new_docs)\n self.assertEqual(len(preds), len(new_docs))\n\n # Test additional burnin. Ideally we could show that things\n # converge as you increase burnin.\n preds_no_burnin = m.predict(docs, output_type=\"probability\", num_burnin=0)\n self.assertEqual(len(preds_no_burnin), len(docs))","def predict(self, model, x_test):\n pass","def test_predictor():","def postprocess_model_outputs(self, predictions, expected):\n\n predictions = {k: t.numpy() for k, t in predictions.items()}\n\n return predictions, expected","def evaluate_model(args, eval_runs, warm_runs, metrics=['psnr', 'ssim', 'fps']):\n upsampler = Upsampler(args)\n if warm_runs > 0:\n print(\"Warming up for evaluation\")\n for i in range(warm_runs):\n print(\"Performing warm-up run\", str(i+1))\n for sequence in ['foliage', 'walk', 'calendar', 'city']:\n bix_dir = os.path.join(VID4_DIR, 'BIx4', sequence)\n upsampler.run_dir(bix_dir, reset=False)\n \n time = 0.\n psnrs = []\n ssims = []\n for i in range(eval_runs):\n run_psnrs = []\n run_ssims = []\n print(\"Performing evaluation run\", str(i+1))\n for sequence in ['foliage', 'walk', 'calendar', 'city']:\n bix_dir = os.path.join(VID4_DIR, 'BIx4', sequence)\n gt_dir = os.path.join(VID4_DIR, 'GT', sequence)\n print(\"Evaluating on\", bix_dir)\n time += upsampler.run_dir(bix_dir, reset=False)\n vid_psnrs, vid_ssims = _eval_sr_perf(os.path.join(bix_dir, 'up'), gt_dir)\n run_psnrs += vid_psnrs\n run_ssims += vid_ssims\n if i == eval_runs-1:\n with open(os.path.join(upsampler.get_model_dir(), \"psnr.txt\"), \"w\") as f:\n f.writelines(str(psnr) + '\\n' for psnr in run_psnrs)\n with open(os.path.join(upsampler.get_model_dir(), \"ssim.txt\"), \"w\") as f:\n f.writelines(str(ssim) + '\\n' for ssim in run_ssims)\n psnrs += run_psnrs\n ssims += run_ssims\n\n fps = VID4_LENGTH/ (time/eval_runs)\n return Performance(psnr=psnrs, ssim=ssims, fps=fps)","def evaluate(self, batch):\n images, labels, projs, planes = [], [], [], []\n for serialized in batch:\n example = tf.train.Example.FromString(serialized)\n image, label = self.encoder.parse_example(example)\n images.append(image)\n labels.append(label)\n proj, _ = self.encoder.parse_camera(example)\n projs.append(proj)\n plane = self.encoder.parse_plane(example)\n planes.append(plane)\n\n\n #pred = self.model.predict(np.asarray(images), batch_size=len(batch))\n results = self.predict(np.asarray(images), batch_size=len(batch))\n \n # Creating some fake results for testing as well as example of what the \n # the results should look like.\n # results = []\n # for label in labels:\n # instances = label['2d_instance']\n # instances_3d = label['3d_instance']\n # boxes = []\n # for i in range(len(instances)):\n # point_2d = np.copy(instances[i])\n # point_3d = np.copy(instances_3d[i])\n # for j in range(9):\n # # Translating the box in 3D, this will have a large impact on 3D IoU.\n # point_3d[j] += np.array([0.01, 0.02, 0.5])\n # boxes.append((point_2d, point_3d))\n # results.append(boxes)\n\n for boxes, label, plane in zip(results, labels, planes): \n instances = label['2d_instance']\n instances_3d = label['3d_instance']\n visibilities = label['visibility']\n num_instances = 0\n for instance, instance_3d, visibility in zip(\n instances, instances_3d, visibilities):\n if (visibility > self._vis_thresh and\n self._is_visible(instance[0]) and instance_3d[0, 2] < 0):\n num_instances += 1\n # We don't have negative examples in evaluation.\n if num_instances == 0:\n continue\n\n iou_hit_miss = metrics.HitMiss(self._iou_thresholds)\n azimuth_hit_miss = metrics.HitMiss(self._azimuth_thresholds)\n polar_hit_miss = metrics.HitMiss(self._polar_thresholds)\n pixel_hit_miss = metrics.HitMiss(self._pixel_thresholds)\n\n num_matched = 0\n for box in boxes:\n box_point_2d, box_point_3d = box\n index = self.match_box(box_point_2d, instances, visibilities)\n if index >= 0:\n num_matched += 1\n pixel_error = self.evaluate_2d(box_point_2d, instances[index])\n\n # If you only compute the 3D bounding boxes from RGB images, \n # your 3D keypoints may be upto scale. However the ground truth\n # is at metric scale. There is a hack to re-scale your box using \n # the ground planes (assuming your box is sitting on the ground).\n # However many models learn to predict depths and scale correctly.\n #scale = self.compute_scale(box_point_3d, plane)\n #box_point_3d = box_point_3d * scale\n azimuth_error, polar_error, iou = self.evaluate_3d(box_point_3d, instances_3d[index])\n iou_hit_miss.record_hit_miss(iou)\n pixel_hit_miss.record_hit_miss(pixel_error, greater=False)\n azimuth_hit_miss.record_hit_miss(azimuth_error, greater=False)\n polar_hit_miss.record_hit_miss(polar_error, greater=False)\n\n if num_matched > 0:\n self._iou_ap.append(iou_hit_miss, num_instances)\n self._pixel_ap.append(pixel_hit_miss, num_instances)\n self._azimuth_ap.append(azimuth_hit_miss, num_instances)\n self._polar_ap.append(polar_hit_miss, num_instances)\n self._matched += num_matched","def predict(self, instances):\r\n raise NotImplementedError","def evaluate_prediction(self):\n\n # ratio_train = self.evaluate_data(self.train_x, self.train_y)\n ratio_test = self.evaluate_data(self.test_x, self.test_y)\n\n print(\"\\n*NAIVE BAYES:\")\n # print(\"Test1: {}%\".format(ratio_dev*100))\n print(\"Test: {} %\".format(ratio_test*100))","def test_predict_from_examples():\n examples = []\n for i in range(len(DATA)):\n (value, attribute_map) = DATA[i]\n print 'tuple created : \\n1:' + str(value) + \"\\n2:\" + str(attribute_map)\n ex = VowpalExample(i, value)\n #Extracting the features from all of the namespaces in the map. \n for (featureNamespace, features) in attribute_map.items():\n #Each \"section\" is \n ex.add_section(featureNamespace, features)\n examples.append(ex)\n train = examples[:-2]\n test = examples[-2:]\n vw = Vowpal(PATH_VW, './vw.%s', {'--passes' : '10' })\n preds = vw.predict_from_examples(train, test)\n for (id, value) in preds:\n print 'prediction for %s is %s' % (id, value)","def evaluate(X_test, y_test):\n # batch size is 16 for evaluation\n batch_size = 16\n\n # Load Model\n model = load_model('model/model.h5')\n return model.evaluate(X_test, y_test, batch_size, verbose = 1)","def evaluate(model, tokenizer, dataset, lines, output_test_file, batch_size=32):\n sampler = SequentialSampler(dataset)\n dataloader = DataLoader(dataset, sampler=eval_sampler, batch_size=batch_size)\n\n print(\"*** Evaluating ***\")\n eval_loss = 0.0\n num_steps = 0\n preds = None\n out_label_ids = None\n for i, batch in enumerate(dataloader):\n if i % 200 == 199:\n print(\"=\", end=\"\")\n if i % 5000 == 4999:\n print(\"[Step \" + str(i+1) + \" / \" + str(len(dataloader)) + \"] \" )\n model.eval()\n batch = tuple(t.to(device) for t in batch)\n\n with torch.no_grad():\n labels = batch[3]\n outputs = model(input_ids=batch[0], attention_mask=batch[1], labels=labels)\n tmp_eval_loss, logits = outputs[:2]\n eval_loss += tmp_eval_loss.mean().item()\n \n num_steps += 1\n if preds is None:\n preds = logits.detach().cpu().numpy()\n out_label_ids = labels.detach().cpu().numpy()\n else:\n preds = np.append(preds, logits.detach().cpu().numpy(), axis=0)\n out_label_ids = np.append(out_label_ids, labels.detach().cpu().numpy(), axis=0)\n \n eval_loss = eval_loss / num_steps\n \n preds_label = np.argmax(preds, axis=1)\n \n accuracy = (preds_label == out_label_ids).mean()\n output_dir = os.path.dirname(output_test_file)\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n with open(output_test_file, \"w\") as writer:\n all_logits = preds.tolist()\n for i, logit in enumerate(all_logits):\n line = '<CODESPLIT>'.join(\n [item.encode('ascii', 'ignore').decode('ascii') for item in lines[i]])\n\n writer.write(line + '<CODESPLIT>' + '<CODESPLIT>'.join([str(l) for l in logit]) + '\\n')\n print(\"Accuracy =\", str(accuracy))\n\n return accuracy","def evaluate(dataset, model, args):\n device = None\n if torch.cuda.is_available():\n device = torch.cuda.current_device()\n\n model.to(device)\n model.train(False)\n\n test_loader = DataLoader(dataset, num_workers=4)\n average_mse = 0\n average_psnr = 0\n\n for batch in tqdm(test_loader):\n # Preprocess the data\n image, camera_pose = batch\n batch_size = len(image)\n\n image = torch.as_tensor(image, device=device)\n image = image[..., :3].permute(0, 3, 1, 2)\n camera_pose = torch.as_tensor(camera_pose, device=device)\n camera_pose = camera_pose[:, :3, :]\n\n # Run the inference\n with torch.no_grad():\n prediction = model(camera_pose)\n predicted_pixels = prediction[\"rgb_map\"]\n target_pixels = image.reshape(batch_size, 3, -1).transpose(1, 2)\n\n mse = mse_loss(predicted_pixels[-1], target_pixels)\n average_mse += mse\n\n psnr = mse_to_psnr(mse)\n average_psnr += psnr\n\n average_mse /= len(dataset)\n average_psnr /= len(dataset)\n\n output = {\n \"average_mse\": float(average_mse),\n \"average_psnr\": float(average_psnr),\n }\n print(output)\n\n with open(args.output_file, \"w\") as json_file:\n json.dump(output, json_file)\n print(\"Saved results to:\", args.output_file)","def test(self):\n with torch.no_grad():\n self.model.eval()\n p10_forecast, p10_forecast, p90_forecast, target = None, None, None, None\n\n t = time()\n for step, sample in enumerate(self.test_loader):\n\n # Hide future predictions from input vector, set to 0 (or 1) values where timestep > encoder_steps\n steps = self.cnf.all_params['num_encoder_steps']\n pred_len = sample['outputs'].shape[1]\n x = sample['inputs'].float().to(self.cnf.device)\n x[:, steps:, 0] = 1\n\n # Feed input to the model\n if self.cnf.all_params[\"model\"] == \"transformer\" or self.cnf.all_params[\"model\"] == \"grn_transformer\":\n\n # Auto-regressive prediction\n for i in range(pred_len):\n output = self.model.forward(x)\n x[:, steps + i, 0] = output[:, i, 1]\n output = self.model.forward(x)\n\n elif self.cnf.all_params[\"model\"] == \"tf_transformer\":\n output, _, _ = self.model.forward(x)\n else:\n raise NameError\n\n output = output.squeeze()\n y, y_pred = sample['outputs'].squeeze().float().to(self.cnf.device), output\n\n # Compute loss\n loss, _ = self.loss(y_pred, y)\n smape = symmetric_mean_absolute_percentage_error(output[:, :, 1].detach().cpu().numpy(),\n sample['outputs'][:, :, 0].detach().cpu().numpy())\n\n # De-Normalize to compute metrics\n target = unnormalize_tensor(self.data_formatter, y, sample['identifier'][0][0])\n p10_forecast = unnormalize_tensor(self.data_formatter, y_pred[..., 0], sample['identifier'][0][0])\n p50_forecast = unnormalize_tensor(self.data_formatter, y_pred[..., 1], sample['identifier'][0][0])\n p90_forecast = unnormalize_tensor(self.data_formatter, y_pred[..., 2], sample['identifier'][0][0])\n\n # Compute metrics\n self.test_losses['p10'].append(self.loss.numpy_normalised_quantile_loss(p10_forecast, target, 0.1))\n self.test_losses['p50'].append(self.loss.numpy_normalised_quantile_loss(p50_forecast, target, 0.5))\n self.test_losses['p90'].append(self.loss.numpy_normalised_quantile_loss(p90_forecast, target, 0.9))\n\n self.test_loss.append(loss.item())\n self.test_smape.append(smape)\n\n # Plot serie prediction\n p1, p2, p3, target = np.expand_dims(p10_forecast, axis=-1), np.expand_dims(p50_forecast, axis=-1), \\\n np.expand_dims(p90_forecast, axis=-1), np.expand_dims(target, axis=-1)\n p = np.concatenate((p1, p2, p3), axis=-1)\n plot_temporal_serie(p, target)\n\n # Log stuff\n for k in self.test_losses.keys():\n mean_test_loss = np.mean(self.test_losses[k])\n print(f'\\t● AVG {k} Loss on TEST-set: {mean_test_loss:.6f} │ T: {time() - t:.2f} s')\n\n # log log log\n mean_test_loss = np.mean(self.test_loss)\n mean_smape = np.mean(self.test_smape)\n print(f'\\t● AVG Loss on TEST-set: {mean_test_loss:.6f} │ T: {time() - t:.2f} s')\n print(f'\\t● AVG SMAPE on TEST-set: {mean_smape:.6f} │ T: {time() - t:.2f} s')","def get_predictions(fitted_model_filename):\n click.echo(\"Mode: predicting probabilities.\\n\")\n defaults = get_defaults()\n\n fitted_model_filename = add_extension(fitted_model_filename)\n fitted_model_path = os.path.join(defaults.OUTPUT.FITTED_MODELS_PATH, fitted_model_filename)\n new_options = [\"OUTPUT.FITTED_MODEL_PATH\", fitted_model_path]\n\n # boot_data = bootstrap(new_options, mode=\"internal_test\")\n # model = boot_data['model']\n #\n # X_test_int, y_test_int = boot_data['data']\n # internal_test_proba = model.predict_proba(X_test_int)\n # internal_test_proba = np.c_[y_test_int, internal_test_proba[:, 1]]\n\n boot_data = bootstrap(new_options, mode=\"external_test\")\n model = boot_data['model']\n X_test_ext, y_test_ext = boot_data['data']\n\n # fit scaler on train data and transform test data\n scaler = StandardScaler()\n X_train, y_train = load_data(defaults, which='train')\n\n numeric_cols = X_train.select_dtypes(include=np.float64).columns.tolist()\n scaler.fit(X_train[numeric_cols])\n X_test_ext.loc[:, numeric_cols] = scaler.transform(X_test_ext[numeric_cols])\n\n external_test_proba = model.predict_proba(X_test_ext)\n external_test_proba = np.c_[y_test_ext, external_test_proba[:, 1]]\n\n # internal_test_results_path = os.path.join(defaults.OUTPUT.PREDS_PATH, \"internal_test_preds.csv\")\n external_test_results_path = os.path.join(defaults.OUTPUT.PREDS_PATH,\n f\"external_test_preds_{fitted_model_filename.replace('.pkl', '')}.csv\")\n # pd.DataFrame(internal_test_proba, columns=['target', 'proba']).to_csv(internal_test_results_path, index=False)\n pd.DataFrame(external_test_proba, columns=['target', 'proba']).to_csv(external_test_results_path, index=False)","def test_predict(self):\n self.regression_single.predict(self.X_test)\n self.assertTrue(len(self.regression_single.y_pred))\n self.regression_boston.predict(self.boston_x_test)\n self.assertTrue(len(self.regression_boston.y_pred))","def test_prediction(model, raw_data):\n data = PredictionData(**raw_data)\n formated_data = {}\n for key, value in data.dict().items():\n formated_data[key] = [value]\n df = pd.DataFrame(formated_data)\n res = model.predict(df)[0]\n assert type(res) == np.float64","def evaluate_model(valp):\n\n a = valp.predict(data_inputs[\"Test\"], [], new=True)[0]\n\n m2e = np.mean(mse(a[\"o0\"], data_outputs[\"Test\"][\"o0\"]))\n acc = 1 - acc_err(a[\"o1\"][:, 0], np.argmax(data_outputs[\"Test\"][\"o1\"], axis=1))\n i_d = 50-np.mean(inception_score(a[\"o2\"][:100]))\n\n return np.array([m2e, acc, i_d])","def evaluate_model(model, X_test, Y_test, category_names): \n \n Y_pred = model.predict(X_test)\n print(classification_report(Y_test, Y_pred))\n display_results(Y_test, Y_pred)","def test(self):\n self.model.eval()\n\n for step, sample in enumerate(self.test_loader):\n x, _, _ = sample\n x = x.to(self.device)\n\n y_pred = self.model.forward(x)\n loss = nn.MSELoss()(y_pred, x)\n self.test_losses.append(loss.item())\n\n if step % (max(8, len(self.test_loader)) // 8) == 0:\n out_img = torch.cat([x[0], torch.clamp(y_pred[0], 0, 1)], dim=2)\n self.sw.add_image(tag=f'sample_{step}', img_tensor=out_img, global_step=self.epoch)\n\n # log average loss on test set\n mean_test_loss = np.mean(self.test_losses)\n self.test_losses = []\n print(f'\\t● AVG Loss on TEST-set: {mean_test_loss:.6f} │ patience: ', end='')\n self.sw.add_scalar(tag='test_loss', scalar_value=mean_test_loss, global_step=self.epoch)\n\n # save best model and update training patience\n if self.best_test_loss is None or mean_test_loss < self.best_test_loss:\n self.best_test_loss = mean_test_loss\n self.patience = conf.FX_PATIENCE\n torch.save(self.model.state_dict(), self.log_path / 'best.pth')\n else:\n self.patience = self.patience - 1\n print(f'{self.patience}/{conf.FX_PATIENCE}')\n\n if self.patience == 0:\n self.show_completion_msg()","def predict(self, test_batch_size=64, device='cuda', load=False, model_path=None, dataloader_num_workers=4, save_prediction=True):\n self.model.eval()\n self.device = device\n self.test_batch_size = test_batch_size\n if load:\n if model_path:\n self.load(model_path, device=self.device)\n else:\n model_path = os.path.join(path_checkpoints_dir, f\"{self.experiment_id}.pth\")\n print(f\"loaded model={model_path}\")\n self.load(model_path, device=self.device)\n if self.model is None:\n raise Exception(\"model cannot be None. Load or train the model before inference\")\n dataloader = self.data_module.get_test_dataloader(batch_size=self.test_batch_size, shuffle=False, num_workers=dataloader_num_workers)\n all_outputs = []\n tk0 = tqdm(enumerate(dataloader, 1), total=len(dataloader))\n for batch_id, data in tk0:\n for key, value in data.items():\n data[key] = value.to(self.device)\n # batch_outputs, batch_loss = self.model(**data)\n batch_outputs, batch_loss= self.validate_one_batch(data)\n all_outputs.append(batch_outputs.detach().cpu().numpy())\n predictions = np.concatenate(all_outputs, axis=0)\n if save_prediction:\n submission = pd.read_csv(path_sample_submission_file)\n assert submission.shape[0] == predictions.shape[0], \"unexpected behavior.code fix required\"\n submission.iloc[:, 1:] = predictions\n\n if not os.path.isdir(path_submissions_dir):\n os.mkdir(path_submissions_dir)\n submission.to_csv(os.path.join(path_submissions_dir, f\"{self.experiment_id}.csv\"), index=False)\n tk0.close()\n return predictions","def fit_predict(self):\n self.classifier = self.model\n self.classifier.fit(self.X_sample, self.y_sample)\n self.y_pred = self.classifier.predict(self.X_test)","def predict():\n\n predict_cfg = get_predict_args()\n device = get_device()\n print(device)\n\n # load checkpoint\n ckpt_path = find_ckpt_in_directory(predict_cfg.ckpt)\n ckpt = torch.load(ckpt_path, map_location=device)\n best_iter = ckpt[\"best_iter\"]\n cfg = ckpt[\"cfg\"]\n aspect = cfg[\"aspect\"]\n\n for k, v in cfg.items():\n print(\"{:20} : {:10}\".format(k, str(v)))\n\n eval_batch_size = 64\n\n print(\"Loading data\")\n dev_data = list(beer_reader(cfg[\"dev_path\"]))\n test_data = beer_annotations_reader(cfg[\"test_path\"], aspect=aspect)\n\n print(\"dev\", len(dev_data))\n print(\"test\", len(test_data))\n\n print(\"Loading pre-trained word embeddings\")\n vocab = Vocabulary()\n vectors = load_embeddings(cfg[\"embeddings\"], vocab) # required for vocab\n\n # build model\n model = build_model(cfg[\"model\"], vocab, cfg=cfg)\n\n # load parameters from checkpoint into model\n print(\"Loading saved model..\")\n model.load_state_dict(ckpt[\"state_dict\"])\n model.to(device)\n print(\"Done\")\n\n print(model)\n print_parameters(model)\n\n print(\"Evaluating\")\n dev_eval = evaluate_loss(\n model, dev_data, batch_size=eval_batch_size,\n device=device, cfg=cfg)\n test_eval = evaluate_loss(\n model, test_data, batch_size=eval_batch_size,\n device=device, cfg=cfg)\n\n if hasattr(model, \"z\"):\n path = os.path.join(\n cfg[\"save_path\"], \"final_rationales.txt\")\n test_precision, test_macro_prec = evaluate_rationale(\n model, test_data, aspect=aspect, device=device,\n batch_size=eval_batch_size, path=path)\n else:\n test_precision = 0.\n test_macro_prec = 0.\n test_eval[\"precision\"] = test_precision\n test_eval[\"macro_precision\"] = test_macro_prec\n\n dev_s = make_kv_string(dev_eval)\n test_s = make_kv_string(test_eval)\n\n print(\"best model iter {:d} dev {} test {}\".format(\n best_iter, dev_s, test_s))","def test_test_regression_model(self):\n model = RegressionTestModel()\n example = {'x_1': 3, 'x_2': 2}\n pred = list(model.predict([example]))[0]\n self.assertEqual(pred['score'], 20)","def evaluate(self, model, y_test, y_pred, softmax_predictions,\n config_dict, y_paths):\n print('Model metrics: ', model.metrics_names)\n assert(y_test.shape == y_pred.shape)\n\n if len(y_pred.shape) > 2: # If sequential data\n y_pred, paths = get_majority_vote_3d(y_pred, y_paths)\n softmax_predictions, _ = get_majority_vote_3d(softmax_predictions, y_paths)\n y_test, _ = get_majority_vote_3d(y_test, y_paths)\n # self.look_at_classifications(y_test, y_pred, paths, softmax_predictions)\n nb_preds = len(y_pred)\n nb_tests = len(y_test)\n\n if nb_preds != nb_tests:\n print(\"Warning, number of predictions not the same as the length of the y_test vector.\")\n print(\"Y test length: \", nb_tests)\n print(\"Y pred length: \", nb_preds)\n if nb_preds < nb_tests:\n y_test = y_test[:nb_preds]\n else:\n y_pred = y_pred[:nb_tests]\n\n # Print labels and predictions.\n print('y_test.shape: ', y_test.shape)\n print('y_pred.shape: ', y_pred.shape)\n # print('y_test and y_test.shape: ', y_test, y_test.shape)\n # print('y_pred and y_pred.shape: ', y_pred, y_pred.shape)\n\n self.print_and_save_evaluations(y_test, y_pred, softmax_predictions, config_dict)","def evaluate(self, test_instance):\n return self.classifier.predict([test_instance])[0]","def predict(model, X_testing):\n predictions = model.predict(X_testing)\n\n return predictions","def predict(self, samples): \n return self.random_forest.predict(samples)","def evaluate_model(model, X_test, y_test):\n # run prediction with test data\n y_pred = model.predict(X_test)\n\n # print precision, recall and f1-score\n i = 0\n for col in y_test:\n print('Evaluation for \"{}\": \\n {} \\n\\n'.format(col, classification_report(y_test[col], y_pred[:,i])))\n i += 1","def predict(self, sample, **kwargs):\n return self.model.predict(sample, **kwargs)","def evaluate_model(model, X_train, y_train, X_test, y_test):\n model = model\n model.fit(X_train, y_train)\n\n y_pred = model.predict(X_test)\n\n report = classificationreport(y_test, y_pred, target_names= [\"0\", \"1\"], output_dict=True)\n\n return report","def sample_pointpredictions(model: 'BaseModel', data: Dict[str, torch.Tensor], n_samples: int,\n scaler: Dict[str, Union[pd.Series, xarray.Dataset]]) -> Dict[str, torch.Tensor]:\n\n if model.cfg.head.lower() == \"gmm\":\n samples = sample_gmm(model, data, n_samples, scaler)\n elif model.cfg.head.lower() == \"cmal\":\n samples = sample_cmal(model, data, n_samples, scaler)\n elif model.cfg.head.lower() == \"umal\":\n samples = sample_umal(model, data, n_samples, scaler)\n elif model.cfg.head.lower() == \"regression\":\n samples = sample_mcd(model, data, n_samples, scaler) # regression head assumes mcd\n else:\n raise NotImplementedError(f\"Sampling mode not supported for head {model.cfg.head.lower()}!\")\n\n return samples","def evaluate_model_with_test_data(model, generator, iterations_count, label_name=''):\n y_predicted, y_etalon = [], []\n for i in range(0,iterations_count):\n x,y = next(generator)\n y_result = model.predict(x, y.shape[0])\n y_predicted.extend(y_result)\n y_etalon.extend(y)\n\n\n # corner1, bridge start, b_end, Big Left, BL-end, Sharp Right, end, Last left, end\n way_points = [69, 183, 276, 309, 348, 410, 456, 514, 612]\n wp_total = 819\n plt_pt_length = len(y_etalon)\n\n\n plt.figure(figsize=(24,6))\n plt.plot(y_predicted, 'r-')\n plt.plot(y_etalon, 'g--')\n plt.title('Predicted angle vs sample')\n plt.ylabel('Angle')\n plt.xlabel('Sample #')\n plt.legend(['Predicted', 'Initial'], loc='upper right')\n\n #add vertical lines to define critical regions on the plot\n for p in way_points:\n px = p / wp_total * plt_pt_length\n plt.axvline(px, ls='--', color='k')\n\n plt.gca().invert_yaxis()\n\n lbl = ''\n if len(label_name):\n lbl = '-' + label_name\n plt.savefig('test_vs_recorded_angle{}.png'.format(lbl), bbox_inches='tight')","def assess_model(model, test_data, label):\n return model.score(test_data,label)","def evaluate(self, X_test, y_test):\n self.run(self)\n self.y_pred = self.pipeline.predict(X_test)\n self.rmse = compute_rmse(self.y_pred, y_test)","def evaluate_model(model, X_test, Y_test, category_names):\n y_pred = model.predict(X_test)\n print(classification_report(Y_test, y_pred, target_names=Y_test.keys()))","def evaluate_random_forest(y_test, y_pred):","def predict():\n import trace\n trace.predict()","def evaluate_model(model, X_test, Y_test, category_names):\n y_pred = model.predict(X_test)\n y_actu = Y_test.values\n\n results_dict = {}\n for i in range(1, 37):\n predicted = \"pred_\" + str(i)\n actual = \"actu_\" + str(i)\n pred_values = []\n actu_values = []\n for ii in range(len(y_pred)):\n\n pred_values.append(int(y_pred[ii][i-1]))\n actu_values.append(int(y_actu[ii][i-1]))\n\n results_dict[predicted] = pred_values\n results_dict[actual] = actu_values\n\n for i in range(1, 37):\n pred = results_dict['pred_' + str(i)]\n actu = results_dict['actu_' + str(i)]\n\n print(\"\\n### \" + category_names[i-1] + \" ###\\n\")\n print(classification_report(pred, actu))","def evaluate_model(model, X_test, Y_test, category_names):\n \n Y_pred = model.predict(X_test)\n \n print(classification_report(Y_test.values, Y_pred, target_names=category_names))","def get_predictions(self, model, inputs=None):\n if inputs is None:\n inputs = self.inputs\n\n refl_id = BaseModel.get_refl_id(inputs)\n iobs = BaseModel.get_intensities(inputs).flatten()\n sig_iobs = BaseModel.get_uncertainties(inputs).flatten()\n asu_id,H = self.asu_collection.to_asu_id_and_miller_index(refl_id)\n #ipred = model(inputs)\n ipred,sigipred = model.prediction_mean_stddev(inputs)\n\n h,k,l = H.T\n results = ()\n for i,asu in enumerate(self.asu_collection):\n idx = asu_id == i\n idx = idx.flatten()\n output = rs.DataSet({\n 'H' : h[idx],\n 'K' : k[idx],\n 'L' : l[idx],\n 'Iobs' : iobs[idx],\n 'SigIobs' : sig_iobs[idx],\n 'Ipred' : ipred[idx],\n 'SigIpred' : sigipred[idx],\n }, \n cell=asu.cell, \n spacegroup=asu.spacegroup,\n merged=False,\n ).infer_mtz_dtypes().set_index(['H', 'K', 'L'])\n results += (output, )\n return results","def evaluate_model(model, X_test, y_test, category_names):\n y_pred = model.predict(X_test)\n labels = np.unique(y_pred)\n print(labels)\n #print out score for each class and mean scores, including precision, recall, f1 score\n print(classification_report(y_test.values, y_pred, target_names=category_names.values))","def evaluate_model(model, instances, labels):\n prediction = model.predict(np.array(instances))\n\n prediction_inv = inverse_normalization(prediction)\n labels_inv = inverse_normalization(labels)\n mse = mean_squared_error(labels_inv, prediction_inv)\n\n return mse","def test_predict():\n args = get_layer('predict', 'manual', 'temporal', False, False, window=2, step_size=3)\n run_layer(*args)","def generate(self, models, sample, **kwargs):\n net_input = sample['net_input']\n\n def batch_for_softmax(dec_out, target):\n # assumes decoder_out[0] is the only thing needed (may not be correct for future models!)\n first, rest = dec_out[0], dec_out[1:]\n bsz, tsz, dim = first.shape\n if bsz * tsz < self.softmax_batch:\n yield dec_out, target, True\n else:\n flat = first.contiguous().view(1, -1, dim)\n flat_tgt = target.contiguous().view(flat.shape[:-1])\n s = 0\n while s < flat.size(1):\n e = s + self.softmax_batch\n yield (flat[:, s:e],) + rest, flat_tgt[:, s:e], False\n s = e\n\n def gather_target_probs(probs, target):\n probs = probs.gather(\n dim=2,\n index=target.unsqueeze(-1),\n )\n return probs\n\n orig_target = sample['target']\n\n # compute scores for each model in the ensemble\n avg_probs = None\n avg_attn = None\n for model in models:\n model.eval()\n decoder_out = model(**net_input)\n attn = decoder_out[1]\n if type(attn) is dict:\n attn = attn.get('attn', None)\n\n batched = batch_for_softmax(decoder_out, orig_target)\n probs, idx = None, 0\n for bd, tgt, is_single in batched:\n sample['target'] = tgt\n curr_prob = model.get_normalized_probs(bd, log_probs=len(models) == 1, sample=sample).data\n if is_single:\n probs = gather_target_probs(curr_prob, orig_target)\n else:\n if probs is None:\n probs = curr_prob.new(orig_target.numel())\n step = curr_prob.size(0) * curr_prob.size(1)\n end = step + idx\n tgt_probs = gather_target_probs(curr_prob.view(tgt.shape + (curr_prob.size(-1),)), tgt)\n probs[idx:end] = tgt_probs.view(-1)\n idx = end\n sample['target'] = orig_target\n\n probs = probs.view(sample['target'].shape)\n\n if avg_probs is None:\n avg_probs = probs\n else:\n avg_probs.add_(probs)\n if attn is not None and torch.is_tensor(attn):\n attn = attn.data\n if avg_attn is None:\n avg_attn = attn\n else:\n avg_attn.add_(attn)\n if len(models) > 1:\n avg_probs.div_(len(models))\n avg_probs.log_()\n if avg_attn is not None:\n avg_attn.div_(len(models))\n\n bsz = avg_probs.size(0)\n hypos = []\n start_idxs = sample['start_indices'] if 'start_indices' in sample else [0] * bsz\n for i in range(bsz):\n # remove padding from ref\n ref = utils.strip_pad(sample['target'][i, start_idxs[i]:], self.pad) \\\n if sample['target'] is not None else None\n tgt_len = ref.numel()\n avg_probs_i = avg_probs[i][start_idxs[i]:start_idxs[i] + tgt_len]\n score_i = avg_probs_i.sum() / tgt_len\n if avg_attn is not None:\n avg_attn_i = avg_attn[i]\n alignment = utils.extract_hard_alignment(\n avg_attn_i,\n sample['net_input']['src_tokens'][i],\n sample['target'][i],\n self.pad,\n self.eos,\n )\n else:\n avg_attn_i = alignment = None\n hypos.append([{\n 'tokens': ref,\n 'score': score_i,\n 'attention': avg_attn_i,\n 'alignment': alignment,\n 'positional_scores': avg_probs_i,\n }])\n return hypos","def evaluate_model(model, X_test, Y_test, category_names):\n \n y_preds = model.predict(X_test)\n predictions = pd.DataFrame(data=y_preds, columns=Y_test.columns, index=Y_test.index)\n for col in Y_test.columns:\n print(classification_report(predictions[col],Y_test[col]))","def evaluate_model(model, X_test_input, y_test_input):\r\n pred_class = [model.classes_[i] for i in model.predict_proba(X_test_input).argmax(axis=-1)]\r\n pred_accuracy = np.sum(np.array(y_test_input)==np.array(pred_class))/len(pred_class)\r\n return pred_class, pred_accuracy","def evaluate(inputs, labels):\n # Your code here.\n _, probs = forward(inputs)\n preds = predict(probs)\n trues = np.argmax(labels, axis=1)\n return np.mean(preds == trues)","def evaluate(self,\n model,\n x=None,\n y=None,\n batch_size=None,\n verbose=1,\n sample_weight=None,\n steps=None,\n callbacks=None,\n **kwargs):\n raise NotImplementedError()","def predict(self, batch_inputs: dict,\n batch_data_samples: SampleList) -> SampleList:\n pass","def _predict(self, testX):\n pass","def predict_and_sample(inference_model,x_initializer,a_initializer,c_initializer):\n # Step 1: Use your inference model to predict an output sequence given x_initializer, a_initializer and c_initializer.\n pred = inference_model.predict([x_initializer,a_initializer,c_initializer])\n \n # Step 2: Convert \"pred\" into an np.array() of indices with the maximum probabilities\n indices = np.argmax(pred,axis=-1)\n \n # Step 3: Convert indices to one-hot vectors, the shape of the results should be (1, )\n results = to_categorical(indices,num_classes=x_initializer.shape[-1])\n \n return results,indices","def evaluate(self, model, data):\n model.eval()\n\n loss = self.loss\n loss.reset()\n match = 0\n total = 0\n correct_spk = 0\n total_response = 0\n y_true = np.array([])\n y_pred = np.array([])\n\n device = None if torch.cuda.is_available() else -1\n batch_iterator = torchtext.data.BucketIterator(\n dataset=data, batch_size=self.batch_size,\n sort=True, sort_key=lambda x: len(x.src),\n device=device, train=False)\n tgt_vocab = data.fields[seq2seq.tgt_field_name].vocab\n pad = tgt_vocab.stoi[data.fields[seq2seq.tgt_field_name].pad_token]\n\n for batch in batch_iterator:\n input_variables, input_lengths = getattr(batch, seq2seq.src_field_name)\n target_variables, target_lengths = getattr(batch, seq2seq.tgt_field_name)\n spk_inputs = [getattr(batch, str(i)) for i in range(self.args.num_sentence)]\n\n decoder_outputs, decoder_hidden, other = model(input_variables, input_lengths.tolist(),\n target_variables, input_spk=spk_inputs)\n\n # Predict Speaker:\n target_spk = spk_inputs[-1]\n target_lengths = target_lengths.cpu().numpy()\n prob_per_spk = []\n for i in range(self.args.num_spk):\n spk_inputs_predict = Variable(torch.LongTensor(np.full((1,batch.batch_size), i)).clone())\n if self.args.cuda: spk_inputs_predict = spk_inputs_predict.cuda()\n spk_inputs_ = [getattr(batch, str(idx)) for idx in range(self.args.num_sentence-1)]\n spk_inputs_.append(spk_inputs_predict)\n decoder_outputs, decoder_hidden, other = model(input_variables, input_lengths.tolist(),\n target_variables, input_spk=spk_inputs_)\n prob_per_responce = []\n target = target_variables.transpose(0,1)\n for word, prob in zip(target[1:], decoder_outputs):\n word, prob = word.data.cpu().numpy(), prob.data.cpu().numpy()\n indices = zip(np.arange(len(word)), word)\n prob_per_word = [prob[i] for i in indices] # select the prob for *sentence_len* times\n prob_per_responce.append(prob_per_word)\n prob_per_spk.append([np.sum(prob_per_responce[:i]) for i in target_lengths])\n prob_per_spk = np.transpose(prob_per_spk) # output: (batch_size, num_spk), every element is the log prob for responce\n\n predicts = np.argmax(prob_per_spk, axis=1)\n correct_spk += (predicts == target_spk.data.cpu().numpy()).sum()\n total_response += len(batch.tgt[0])\n\n # Evaluation\n seqlist = other['sequence']\n for step, step_output in enumerate(decoder_outputs):\n target = target_variables[:, step + 1]\n loss.eval_batch(step_output.view(target_variables.size(0), -1), target)\n\n non_padding = target.ne(pad)\n correct = seqlist[step].view(-1).eq(target).masked_select(non_padding).sum().data[0]\n match += correct\n total += non_padding.sum().data[0]\n\n y_pred = np.append(y_pred, predicts)\n y_true = np.append(y_true, target_spk.data.cpu().numpy())\n\n print(y_pred.shape)\n\n print(accuracy_score(y_true, y_pred))\n print(confusion_matrix(y_true, y_pred))\n\n if total == 0:\n accuracy = float('nan')\n else:\n accuracy = match / total\n\n if total_response == 0:\n accuracy_spk = float('nan')\n else:\n accuracy_spk = correct_spk / total_response\n\n return loss.get_loss(), accuracy, accuracy_spk","def evaluate_model(model, X_test, Y_test, category_names):\n\n print(\"Testing Performance\")\n print(classification_report(Y_test, model.predict(X_test), target_names=category_names))\n\n #Todo cat names","def test(self, samples):\n prediction_errors = np.zeros(len(samples), int)\n predictions = np.zeros(len(samples), int)\n class_predictions = np.zeros(self.class_count)\n \n for i in range(len(samples)): # Loop over each sample\n for j in range(self.class_count): # Loop over each class\n class_predictions[j] = self.p_ys[j] # Get p(y) for class j\n for k in range(self.feature_count): # Loop over each feature \n # Multiply p(y) by p(xi|y) \n if(samples[i][k] == 1):\n class_predictions[j] *= self.p_xi_given_ys[j][k] \n else:\n class_predictions[j] *= 1 - self.p_xi_given_ys[j][k] \n \n predictions[i] = np.argmax(class_predictions) # Prediction is class with highest probability.\n \n # Check if the predicted class doesn't match the true class.\n if(predictions[i] != samples[i][-1]):\n prediction_errors[i] = 1 \n \n # Compute accuracy\n accuracy = 1.0 - (np.sum(prediction_errors) * 1.0 / len(prediction_errors)) \n \n return prediction_errors, predictions, accuracy","def test_evaluate_model(sequential_model, model_data):\n _, _, _, _, x_test, y_test = model_data\n compile_model(sequential_model)\n output = evaluate_model(sequential_model, x_test, y_test, 64)\n assert len(output) == 2","def ApplyModel(testData, modelname, model):\n testData=testData.astype('float32')\n \n if modelname=='Support Vector Machine (Sklearn)':\n a,result = model.predict(testData, cv2.ml.ROW_SAMPLE)\n\n if modelname=='Random Forest Classifier (Sklearn)':\n result = model.predict(testData)\n \n if modelname=='Classification and Regression Tree (Sklearn)':\n result = model.predict(testData)\n\n \n result2=result.reshape(np.shape(result)[0])\n result2=result2.astype('int')\n return result2","def evaluate():\n\n # seed provides the mechanism to control the shuffling which takes place reading input\n seed = tf.placeholder(tf.int64, shape=())\n \n # Generate placeholders for the images and labels.\n iterator = input_data.input_pipeline_binary(FLAGS.data_dir,\n FLAGS.batch_size,\n fake_data=FLAGS.fake_data,\n num_epochs=1,\n read_threads=FLAGS.read_threads,\n shuffle_size=FLAGS.shuffle_size,\n num_expected_examples=FLAGS.num_examples,\n seed=seed)\n image_path, label_path, images, labels = iterator.get_next()\n\n if FLAGS.verbose:\n print_op = tf.print(\"images and labels this batch: \", \n image_path, label_path, labels)\n else:\n print_op = tf.constant('No printing')\n\n if FLAGS.random_rotation:\n images, labels = harmonics.apply_random_rotation(images, labels)\n\n # Build a Graph that computes predictions from the inference model.\n logits = topology.inference(images, FLAGS.network_pattern)\n \n # Add to the Graph the Ops for loss calculation.\n loss = topology.binary_loss(logits, labels)\n \n # Set up some prediction statistics\n predicted = tf.round(tf.nn.sigmoid(logits))\n correct_pred = tf.equal(predicted, labels)\n accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))\n\n saver = tf.train.Saver()\n\n with tf.Session() as sess:\n \n while True:\n eval_once(sess, iterator, saver, seed, labels, loss, accuracy, predicted)\n if FLAGS.run_once:\n break\n time.sleep(FLAGS.eval_interval_secs)","def test_new_data(model, data_folder='testData'):\n\n size = (120, 120) # target img dimensions\n x_train = ssd_dataloader.load_ssd(size, data_folder)\n\n for sample in range(0, len(x_train)):\n\n image = x_train[None, sample, :, :, :] # None to retain dimensionality\n\n prediction = model.predict(image)\n print('Sample {} Probabilities:'.format(int(sample)))\n print(prediction)\n prediction = int(np.argmax(prediction))\n\n if prediction == 0:\n print('Left')\n elif prediction == 1:\n print('Right')\n else:\n print('Error')\n\n if show_plots:\n plt.imshow(image[0, :, :, 0])\n plt.draw()\n plt.show()","def generate_predictions(inputs, model, tokenizer):\n # Generate model results\n outputs = model(**inputs)\n\n # Convert logit outputs into predictions for table cells and aggregation operators\n predicted_table_cell_coords, predicted_aggregation_operators = tokenizer.convert_logits_to_predictions(\n inputs,\n outputs.logits.detach(),\n outputs.logits_aggregation.detach()\n )\n\n print(predicted_table_cell_coords)\n print(predicted_aggregation_operators)\n\n # Return values\n return predicted_table_cell_coords, predicted_aggregation_operators","def run_prediction(question_texts, context_text):\r\n examples = []\r\n\r\n for i, question_text in enumerate(question_texts):\r\n example = SquadExample(\r\n qas_id=str(i),\r\n question_text=question_text,\r\n context_text=context_text,\r\n answer_text=None,\r\n start_position_character=None,\r\n title=\"Predict\",\r\n is_impossible=False,\r\n answers=None,\r\n )\r\n\r\n examples.append(example)\r\n\r\n features, dataset = squad_convert_examples_to_features(\r\n examples=examples,\r\n tokenizer=tokenizer,\r\n max_seq_length=384,\r\n doc_stride=128,\r\n max_query_length=64,\r\n is_training=False,\r\n return_dataset=\"pt\",\r\n threads=1,\r\n )\r\n\r\n eval_sampler = SequentialSampler(dataset)\r\n eval_dataloader = DataLoader(dataset, sampler=eval_sampler, batch_size=10)\r\n\r\n all_results = []\r\n\r\n for batch in eval_dataloader:\r\n model.eval()\r\n batch = tuple(t.to(device) for t in batch)\r\n\r\n with torch.no_grad():\r\n inputs = {\r\n \"input_ids\": batch[0],\r\n \"attention_mask\": batch[1],\r\n \"token_type_ids\": batch[2],\r\n }\r\n\r\n example_indices = batch[3]\r\n\r\n outputs = model(**inputs)\r\n\r\n for i, example_index in enumerate(example_indices):\r\n eval_feature = features[example_index.item()]\r\n unique_id = int(eval_feature.unique_id)\r\n\r\n output = [to_list(output[i]) for output in outputs]\r\n\r\n start_logits, end_logits = output\r\n result = SquadResult(unique_id, start_logits, end_logits)\r\n all_results.append(result)\r\n\r\n output_prediction_file = \"predictions.json\"\r\n output_nbest_file = \"nbest_predictions.json\"\r\n output_null_log_odds_file = \"null_predictions.json\"\r\n\r\n predictions = compute_predictions_logits(\r\n examples,\r\n features,\r\n all_results,\r\n n_best_size,\r\n max_answer_length,\r\n do_lower_case,\r\n output_prediction_file,\r\n output_nbest_file,\r\n output_null_log_odds_file,\r\n False, # verbose_logging\r\n True, # version_2_with_negative\r\n null_score_diff_threshold,\r\n tokenizer,\r\n )\r\n\r\n return predictions","def test_prepare_sample_to_forward(self):\n sample = [\n {\"src\": \"ola mundo\", \"ref\": \"hi world\", \"mt\": \"hey world!\", \"score\": 0.8},\n {\"src\": \"ola mundo\", \"ref\": \"hi world\", \"mt\": \"hey world!\", \"score\": 0.8},\n ]\n\n model_input, target = self.estimator.prepare_sample(sample)\n model_output = self.estimator(**model_input)\n self.assertTrue(model_output[\"score\"].shape[0] == 2)\n self.assertTrue(model_output[\"score\"].shape[1] == 1)","def predict(self, X_test, **kwargs):\n\n # Normalize inputs\n if self.normalize_input:\n X_, _, _ = zero_mean_unit_var_normalization(X_test, self.X_mean, self.X_std)\n else:\n X_ = X_test\n\n # Sample a number of predictions for each given point\n # Generate mean and variance for each given point from sampled predictions\n\n X_ = torch.Tensor(X_)\n self.model.eval()\n Yt_hat = self.model(X_).data.cpu().numpy()\n\n if self.normalize_output:\n Yt_hat = zero_mean_unit_var_denormalization(Yt_hat, self.y_mean, self.y_std)\n\n logger.debug(f\"Generated final outputs array of shape {Yt_hat.shape}\")\n\n return Yt_hat","def __test_model(self, test, model, expected):\n prediction = model.predict(test)\n message = \"Prediction:\", *prediction, \"| Actual:\", expected\n self.__logger.info(message)","def evaluate_model(model, X_test, Y_test, category_names):\n y_pred = model.predict(X_test)\n print(classification_report(Y_test, y_pred, target_names=category_names))\n pass","def test_predict_from_example_stream():\n stream = ExampleStream('vw.stream.txt')\n examples = []\n for i in xrange(len(DATA)):\n (value, all_sections) = DATA[i]\n ex = VowpalExample(i, value)\n for (namespace, section) in all_sections.items():\n ex.add_section(namespace, section)\n stream.add_example(ex)\n train = examples[:-2]\n test = examples[-2:]\n vw = Vowpal(PATH_VW, './vw.%s', {'--passes' : '10' })\n preds = vw.predict_from_example_stream(stream)\n for (id, value) in preds:\n print 'prediction for %s is %s' % (id, value)","def evaluate_predictions(self, input_predictions, run_type, override_tags_roles=None):\n out_dict = self.results[run_type]\n # outer evaluation tags: model instances\n outer = [t for t in self.tags if t.startswith(\"model\") and not t.endswith(defs.roles.inputs)]\n inner = [t for t in self.tags if t in [defs.roles.train, defs.roles.val, defs.roles.test]]\n\n # collect indexes to across outer tags to produce, e.g. total <train> performance\n total_idxs_inner = defaultdict(list)\n has_multiple_models = len(outer) > 1\n\n for outer_tag in outer:\n out_idx = self.indexes[self.tags.index(outer_tag)]\n out_dict[outer_tag] = {}\n\n for inner_tag in inner:\n # get prediction indexes\n in_idx = self.indexes[self.tags.index(inner_tag)]\n joint_idx = np.intersect1d(out_idx, in_idx)\n current_predictions = input_predictions[joint_idx]\n if len(current_predictions) == 0:\n continue\n\n total_idxs_inner[inner_tag].append(joint_idx)\n\n out_dict[outer_tag][inner_tag] = {}\n\n for measure in self.available_measures:\n result = self.evaluate_measure(current_predictions, joint_idx, measure, tag_info=(outer_tag, inner_tag))\n out_dict[outer_tag][inner_tag][measure] = result\n do_print = (not has_multiple_models) or self.should_print_this(run_type, outer_tag)\n self.compute_additional_info(current_predictions, joint_idx, f\"{run_type}-{outer_tag}-{inner_tag}\", do_print=do_print)\n\n if has_multiple_models:\n # aggregate\n out_dict[\"all_tags\"] = {}\n self.aggregate_tags(outer, inner, out_dict)\n for o in total_idxs_inner:\n self.compute_additional_info(input_predictions, np.concatenate(total_idxs_inner[o]), f\"{run_type}-{o}-all_tags\", do_print=not self.is_baseline_run(run_type))\n print()","def evaluate():\n global_step = tf.Variable(0, name='global_step', trainable=False)\n\n # randomize the inputs look\n x, y_, data, keep_prob = blood_model.prepare_input()\n # Get images and labels for blood_model.\n conv_output, W_conv1, W_conv2, h_conv1, h_conv2 = blood_model.inference(data, keep_prob)\n conv_predictions = blood_model.predictions(conv_output)\n\n sess = tf.InteractiveSession()\n\n sess.run(tf.initialize_all_variables())\n\n saver = tf.train.Saver()\n\n ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)\n if ckpt and ckpt.model_checkpoint_path:\n # Restores from checkpoint\n saver.restore(sess, ckpt.model_checkpoint_path)\n # extract global_step from it.\n global_step_number = int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])\n print(\"checkpoint found at step %d\", global_step_number)\n else:\n print('No checkpoint file found')\n return\n\n blood_dataset = np.load('../../labeller/data/wbc_p4-1_p.npy')\n blood_dataset = np.transpose(blood_dataset, (0, 2, 3, 1))\n predictions = sess.run(conv_predictions, feed_dict={x: blood_dataset, keep_prob: 1.0})\n np.save('../results/predictions.npy', np.argmax(predictions, 1))\n display_predictions(blood_dataset, np.argmax(predictions, 1))","def postprocess_model_outputs(self, predictions, expected):\n\n for key, val in predictions.items():\n predictions[key] = val.numpy()\n\n for key, val in expected.items():\n expected[key] = val.numpy()\n\n return predictions, expected","def ensemble_predictions(sampled_x,sampled_y,x_to_predict,top_models_name,top_models_params,n_to_average):\n preds=[None for _ in range(n_to_average)]\n for i in tqdm(range(n_to_average),desc=\"Ensemble models training\",\n position=0,total=n_to_average,\n leave=False, disable=False):\n major_model,specific_model=top_models_name[i].split(';')\n model = MldeModel(major_model, specific_model,\n model_params=top_models_params[i],\n training_params=DEFAULT_TRAINING_PARAMS[major_model],\n eval_metric=mse)\n model.train(sampled_x,sampled_y)\n preds[i],_= model.predict(x_to_predict)\n preds=np.array(preds)\n # preds=np.mean(preds,axis=0)\n return preds","def predict(self, model, context, data):\n pass","def test_predict(self):\n\t\tMY_TEST_MODEL = \"v1_rm500\"\n\t\tx_test = np.genfromtxt(\"tests/data/ensg_input.txt\",delimiter=\"\\t\")\n\t\tquery_localdirs = cancerscope.get_models.findmodel(os.path.dirname(cancerscope.__file__),MY_TEST_MODEL)\n\t\tif query_localdirs is not None:\n\t\t\tmodel_in = query_localdirs[MY_TEST_MODEL]\n\t\telse:\n\t\t\tmodel_in = cancerscope.get_models.downloadmodel(model_label=MY_TEST_MODEL)\n\t\t\n\t\t\"\"\"Compare results with what you get from 'getmodel()'\"\"\"\n\t\tmodeldir_v1_rm500 = cancerscope.get_models.getmodel(model_label = MY_TEST_MODEL)\n\t\tself.assertEqual(modeldir_v1_rm500[MY_TEST_MODEL][MY_TEST_MODEL], model_in)\n\t\t\n\t\t\"\"\"Test prediction\"\"\"\n\t\tlmodel = cancerscope.scopemodel(model_in)\n\t\tlmodel.fit()\n\t\trandom_sample = np.nan_to_num(x_test[0:17688, 1].reshape(1,17688))\n\t\tpred_testX = lmodel.predict(random_sample)[0][0][0]\n\t\tself.assertEqual(pred_testX, \"ESCA_TS\")\n\t\t\n\t\tallpreds_testX = lmodel.predict(random_sample, get_all_predictions=True, get_numeric=False,get_predictions_dict=False)[0]\n\t\tallpredsNumeric_testX = lmodel.predict(random_sample, get_all_predictions=True, get_numeric=True, get_predictions_dict=False)[0]\n\t\t\n\t\tself.assertEqual(len(allpreds_testX), 66)\n\t\tself.assertEqual(len(allpredsNumeric_testX), 66)\n\t\tself.assertEqual(allpreds_testX[0], \"BRCA_TS\")\n\t\tself.assertTrue(isinstance(allpredsNumeric_testX[0], Number))\n\t\t\n\t\t\"\"\"Test if normalization works and is evaluated to correct floatpoint\"\"\"\n\t\tnormalized_testX = lmodel.get_normalized_input(random_sample)[0]\n\t\tself.assertEqual(normalized_testX[0],0.60640558591378269)\t\n\t\t\n\t\t\"\"\"Test if Jacobian is evaluated correctly\"\"\"\n\t\t#Mar19 keras noncompat#jacobian_test = lmodel.get_jacobian(random_sample)\n\t\t#class0_highestjacobian = np.amax(jacobian_test[0,:])\n\t\t#self.assertEqual(jacobian_test.shape[0], 66) ## Num rows = classes\n\t\t#self.assertEqual(jacobian_test.shape[1], 17688) ## Num columns = genes\n\t\t#self.assertAlmostEqual(class0_highestjacobian, 0.00012377805544766)\n\t\t#END OF #Mar19 keras noncompat#","def evaluate(x_sample, y_sample, batch_size=512):\n\n n = x_sample.shape[0]\n correct_sample = 0\n\n for i in range(0, n, batch_size):\n x_batch = x_sample[i: i + batch_size]\n y_batch = y_sample[i: i + batch_size]\n n_batch = x_batch.shape[0]\n\n feed = {\n x: x_batch,\n y: y_batch,\n keep_prob: 1\n }\n\n correct_sample += sess.run(accuracy, feed_dict=feed) * n_batch\n\n return correct_sample / n","def evaluate_model(model,test_inputs,test_labels,model_mode):\n\n if model_mode == \"classification\":\n y_pred = model.predict(test_inputs)\n print(\"Accuracy score: \", accuracy_score(test_labels, y_pred))\n #print(\"F1 score: \", f1_score(test_labels,y_pred, average='weighted'))\n\n conf_mx = confusion_matrix(test_labels, y_pred)\n #print(conf_mx)\n plt.matshow(conf_mx, cmap = plt.cm.jet)\n plt.show()\n\n if model_mode == \"regression\":\n y_pred = model.predict(test_inputs)\n print(\"Mean absolute error: \", mean_absolute_error(test_labels, y_pred))","def eval_model(data, model):\n f = model.forward(data['image'])\n loss = model.loss(f,data['label'])\n\n y_predict = model.predict(f)\n\n count = 0\n for i in range(len(data['label'])):\n if data['label'][i] == y_predict[i]:\n count = count + 1\n\n acc = (count/len(data['label']))*100\n\n return loss, acc","def evaluate_model(model, X_test, y_test, category_names):\n # Predict for test set\n y_pred = model.predict(X_test)\n \n print(\"**** Scores for each category *****\\n\")\n for i in range(36):\n print(\"Scores for '{}':\".format(category_names[i]))\n print(classification_report(y_test.values[:,i], y_pred[:,i]))","def sample_estimator(model, num_classes, train_loader):\n import sklearn.covariance\n\n model.eval()\n with torch.no_grad():\n group_lasso = sklearn.covariance.EmpiricalCovariance(assume_centered=False)\n correct, total = 0, 0\n num_output = 1\n num_sample_per_class = np.empty(num_classes)\n num_sample_per_class.fill(0)\n list_features = []\n for i in range(num_output):\n temp_list = []\n for j in range(num_classes):\n temp_list.append(0)\n list_features.append(temp_list)\n\n for data, target in train_loader:\n total += data.size(0)\n data = data.cuda()\n data = Variable(data)\n output = model(data)['logits']\n # output, out_features = out['logits'], out['logits']\n\n out_features = output.view(output.size(0), output.size(1), -1)\n out_features = torch.mean(out_features, dim=2)\n\n # compute the accuracy\n pred = output.data.max(1)[1]\n equal_flag = pred.eq(target.cuda()).cpu()\n correct += equal_flag.sum()\n\n # construct the sample matrix\n for i in range(data.size(0)):\n label = target[i]\n out_count = 0\n if num_sample_per_class[label] == 0:\n list_features[out_count][label] = out_features[i].view(1, -1)\n else:\n list_features[out_count][label] \\\n = torch.cat((list_features[out_count][label], out_features[i].view(1, -1)), 0)\n num_sample_per_class[label] += 1\n\n sample_class_mean = []\n out_count = 0\n num_feature = num_classes\n temp_list = torch.Tensor(num_classes, num_feature).cuda()\n for j in range(num_classes):\n temp_list[j] = torch.mean(list_features[out_count][j], dim=0)\n sample_class_mean.append(temp_list)\n\n precision = []\n for k in range(num_output):\n X = 0\n for i in range(num_classes):\n if i == 0:\n X = list_features[k][i] - sample_class_mean[k][i]\n else:\n X = torch.cat((X, list_features[k][i] - sample_class_mean[k][i]), dim=0)\n\n # find inverse\n group_lasso.fit(X.cpu().numpy())\n temp_precision = group_lasso.precision_\n temp_precision = torch.from_numpy(temp_precision).float().cuda()\n precision.append(temp_precision)\n\n print('\\n Training Accuracy:({:.2f}%)\\n'.format(100. * correct / total))\n\n return sample_class_mean, precision","def run_prediction(data, sess, placeholders, scores): \r\n \r\n X, Y = data\r\n source_pl, target_pl, training_pl = placeholders\r\n split_set = int(math.floor(0.9*len(X))) # Value for spliting the set in 90% training / 10% test \r\n \r\n X_batch, Y_batch = batch(X[:split_set:], Y[:split_set:]) # Take a batch of sentences from the training set\r\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\r\n prediction = sess.run(scores, feed_dict=feed_dict) \r\n X_batch = np.squeeze(X_batch) \r\n prediction = np.squeeze(prediction)\r\n \r\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\r\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\r\n\r\n\t# Print the pairs source -> target\r\n for source, target in zip(source_sentences, target_sentences): \r\n print(source + \" --> \" + target)\r\n \r\n print(\"================================================================\")\r\n \r\n X_batch, Y_batch = batch(X[split_set+1:], Y[split_set+1:]) # Take a batch of sentences from the test set\r\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\r\n prediction = sess.run(scores, feed_dict=feed_dict) \r\n \r\n X_batch = np.squeeze(X_batch) \r\n prediction = np.squeeze(prediction)\r\n \r\n \r\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\r\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\r\n\r\n\t# Print the pairs source -> target\r\n for source, target in zip(source_sentences, target_sentences): \r\n print(source + \" --> \" + target)","def evaluate_model(model, X_test, Y_test, category_names):\n y_pred_grid = model.predict(X_test)\n print(\n classification_report(Y_test.values, y_pred_grid, target_names=category_names)\n )"],"string":"[\n \"def evaluate(model, test_files):\\n print(\\\"Running predictions.\\\")\\n models = load_model(model)\\n predictions = predict(models, test_files)\\n\\n # # write predictions to file\\n # write_predictions(\\\"evaluate_out.json\\\",predictions)\\n evaluate_individual(predictions, test_files, models)\\n evaluate_overall(predictions)\",\n \"def eval(self): \\n inputs,enc_input_weights, outputs, dec_input_weights = self.get_batch()\\n predicted_ids = self.model.step(self.sess, inputs, enc_input_weights) \\n print(\\\"=\\\"*20)\\n for i in range(FLAGS.batch_size):\\n print(\\\"* %dth sample target: %s\\\" % (i,str(outputs[i,1:]-2)))\\n for predict in predicted_ids[i]:\\n print(\\\"prediction: \\\"+str(predict)) \\n print(\\\"=\\\"*20)\",\n \"def evaluate():\\n\\tmodel.eval()\\n\\tstddev = 1 # And mean=0\\n\\tfor batch_idx, (data, _) in enumerate(syn_test_loader):\\n\\t\\tdata = data.cuda()\\n\\t\\tif batch_idx == 0:\\n\\t\\t\\tnoise = torch.autograd.Variable(torch.randn(batch_size, bottleneck).cuda() * stddev)\\n\\t\\t\\tsample_representation(\\\"orig_nat\\\", data, noise)\\n\\t\\t\\tsample_representation(\\\"natural\\\", data, noise)\\n\\t\\t\\tsample_representation(\\\"orig_syn\\\", data, noise)\\n\\t\\t\\tsample_representation(\\\"synth\\\", data, noise)\",\n \"def evaluate_model_random(self, model_eval_samples): \\n neval = len(model_eval_samples)\\n task_horizon = len(model_eval_samples[0]['ac'])\\n # construct evaluation samples \\n\\n true_obs = [[] for _ in range(neval)]\\n inputs = []\\n \\n for j in range(neval):\\n for k in range(task_horizon ):\\n obs = model_eval_samples[j]['obs'][k]\\n ac = model_eval_samples[j]['ac'][k]\\n inputs.append( np.concatenate(( obs,ac)) ) \\n true_obs[j].append( model_eval_samples[j]['obs'][k] )\\n true_obs[j].append( model_eval_samples[j]['obs'][task_horizon] )\\n \\n \\n \\n inputs = np.array([ inputs for _ in range(5)])\\n\\n \\n # Evaluation [ensemble_size, batch_size, obs + acs]\\n pred = self.policy.model.predict( inputs)\\n error = [0 for _ in range(neval)]\\n for j in range(neval):\\n for k in range(task_horizon):\\n for i in range(5):\\n error[j] += np.linalg.norm( true_obs[j][k+1] - true_obs[j][k] - pred[0][i][j*task_horizon+k])\\n error = np.array(error) / (5*task_horizon)\\n print(\\\"model error: \\\", np.mean(error), np.std(error))\\n return np.mean(error), np.std(error)\",\n \"def predict(x_tst, model):\\n\\n predictions = model.predict(x_tst)\\n return predictions\",\n \"def evaluate_model(self, predictions, expected, bypass_data_to_eval):\\n\\n result = []\\n for i, unique_id in enumerate(np.squeeze(expected[\\\"unique_ids\\\"])):\\n start_logits = predictions['tf_electra_for_question_answering'][i]\\n start_top_index = predictions['tf_electra_for_question_answering_1'\\n ][i]\\n end_logits = predictions['tf_electra_for_question_answering_2'][i]\\n end_top_index = predictions['tf_electra_for_question_answering_3'][i\\n ]\\n cls_logits = predictions['tf_electra_for_question_answering_4'][i]\\n\\n result.append(\\n SquadResult(\\n unique_id,\\n start_logits.tolist(),\\n end_logits.tolist(),\\n start_top_index=start_top_index.tolist(),\\n end_top_index=end_top_index.tolist(),\\n cls_logits=cls_logits.tolist(),\\n )\\n )\\n\\n dev_features = bypass_data_to_eval[\\\"dev_features\\\"]\\n dev_examples = bypass_data_to_eval[\\\"dev_examples\\\"]\\n\\n answers, nbest_answers = get_answers(\\n dev_examples, dev_features, result, self._args\\n )\\n\\n output_prediction_file = os.path.join(\\n self._args.output_dir, \\\"predictions.json\\\"\\n )\\n output_nbest_file = os.path.join(\\n self._args.output_dir, \\\"nbest_predictions.json\\\"\\n )\\n\\n with open(output_prediction_file, \\\"w\\\") as f:\\n f.write(json.dumps(answers, indent=4) + \\\"\\\\n\\\")\\n with open(output_nbest_file, \\\"w\\\") as f:\\n f.write(json.dumps(nbest_answers, indent=4) + \\\"\\\\n\\\")\\n\\n if self._args.version_2_with_negative:\\n dev_file = \\\"dev-v2.0.json\\\"\\n eval_file = \\\"evaluate-v2.0.py\\\"\\n else:\\n dev_file = \\\"dev-v1.1.json\\\"\\n eval_file = \\\"evaluate-v1.1.py\\\"\\n\\n command_str = (\\n f\\\"{sys.executable} {os.path.join(self._args.data_dir, eval_file)} \\\"\\n f\\\"{os.path.join(self._args.data_dir, dev_file)} \\\"\\n f\\\"{output_prediction_file}\\\"\\n )\\n\\n logging.debug(f\\\"\\\\nExecuting: `{command_str}`\\\\n\\\")\\n\\n eval_out = subprocess.check_output(shlex.split(command_str))\\n\\n # scores: {'exact_match': 87.06717123935667, 'f1': 92.78048326711645}\\n scores = json.loads(eval_out.decode(\\\"UTF-8\\\").strip())\\n\\n logging.debug(\\\"scores:\\\", scores)\\n\\n metric_units = \\\"f1\\\"\\n\\n return scores[metric_units], metric_units\",\n \"def __call__(self, predictor_model) -> None:\\n self.save_result(self.evaluate(predictor_model))\",\n \"def test(self) -> None:\\n\\n self._predictions = self._lr.predict(self._X_test)\",\n \"def evaluate(self):\\n\\n\\t\\t## We should be evaluating on dev dataset as well, so commenting x_test\\n\\t\\t#self.model_score = self.model.evaluate(self.x_test, self.y_test_oh, batch_size=2048)\\n\\t\\tself.model_score = self.model.evaluate(self.x_dev, self.y_dev_oh, batch_size=2048)\\n\\t\\tprint(\\\"%s score = %f\\\\n\\\" %(self.modelName, self.model_score[1]))\\n\\n\\t\\t##Saving atucal vs predicted predictions\\n\\t\\t##np.argmax returns the index where it see's 1 in the row\\n\\t\\t#y_pred = np.argmax(self.model.predict(self.x_test, batch_size=2048), axis=1)\\n\\t\\ty_pred = np.argmax(self.model.predict(self.x_dev, batch_size=2048), axis=1)\\n\\n\\t\\t## vstack will stack them in 2 rows, so we use Trasnpose to get them in column stack\\n\\t\\t#output_predict = np.vstack((np.argmax(self.y_test_oh, axis=1), y_pred)).T\\n\\t\\toutput_predict = np.vstack((np.argmax(self.y_dev_oh, axis=1), y_pred)).T\\n\\t\\toutputFile = self.resultDir + \\\"/outputPredict.csv\\\" \\n\\t\\tnp.savetxt(outputFile, output_predict, fmt=\\\"%5.0f\\\", delimiter=\\\",\\\")\\n\\n\\t\\t##Error Analysis of the prediction\\n\\t\\terrorAnalysis(outputFile)\\n\\n\\t\\treturn self.model_score\",\n \"def evaluate_model(model, X_test, Y_test): \\n #Make predictions with the model\\n Y_pred = model.predict(X_test)\\n #convert numpy output to dataframe and add columns\\n Y_pred_df = pd.DataFrame(Y_pred)\\n Y_pred_df.columns = Y_test.columns\\n #Convert predictions and correct y values to float for faciliate comparison\\n Y_pred_df = Y_pred_df.astype('float64')\\n Y_test = Y_test.astype('float64')\\n print_score(Y_test, Y_pred_df, 'weighted avg')\",\n \"def test():\\n # load dataset and model\\n X, observed_y = load_data('../data/dev.txt')\\n\\n model = pickle.load(open('test.model', 'rb'))\\n model.traverse()\\n\\n # predict labels for dataset\\n preds = model.predict(X)\\n\\n # print(preds)\\n # output model predictions\\n np.savetxt('test.predictions', preds, fmt='%s')\",\n \"def evaluate(model, eval_data, num_labels): \\n # Turn on the evaluation state to ignore dropouts\\n model.eval()\\n results = [predict(model, x) for x, y in eval_data]\\n f1_score, accuracy = get_metrics(np.array([y for x, y in eval_data]), results, num_labels)\\n return f1_score, accuracy\",\n \"def evaluate(self):\\n predictions = self.model.predict(self.test[0])\\n accuracy = accuracy_score(self.test[1], predictions)\\n print(\\\"Accuracy:\\\", str(accuracy * 100) + \\\"%\\\")\\n self.plot_results(predictions)\",\n \"def test_and_predict_on_batch(model, x, y, sample_weight=None):\\n\\n x, y, sample_weights = model._standardize_user_data(\\n x, y,\\n sample_weight=sample_weight)\\n if model._uses_dynamic_learning_phase():\\n ins = x + y + sample_weights + [0.]\\n else:\\n ins = x + y + sample_weights\\n\\n _make_test_and_predict_function(model)\\n outputs = model.test_and_predict_function(ins)\\n if len(outputs) == 1:\\n return outputs[0]\\n return outputs\",\n \"def predict(self, sample, **kwargs):\\r\\n return self.model.predict(sample, **kwargs)\",\n \"def evaluate_model(model_name, y_true, y_pred):\\n\\n # Calculate performance metrics\\n rmse_eval = evaluate_rmse(y_true, y_pred)\\n mae_eval = evaluate_mae(y_true, y_pred) \\n r2_eval = evaluate_r2(y_true, y_pred)\\n\\n # Print results\\n print_evaluation(model_name, mae_eval, rmse_eval, r2_eval)\",\n \"def test(self):\\r\\n \\r\\n args = self.args\\r\\n model = self.model\\r\\n dataset = self.dataset\\r\\n \\r\\n dataset.set_split('test')\\r\\n batch_generator = generate_nmt_batches(dataset, \\r\\n batch_size=len(dataset), \\r\\n device=args.device)\\r\\n\\r\\n acc_sum = 0.0\\r\\n model.eval()\\r\\n \\r\\n for batch_index, batch_dict in enumerate(batch_generator):\\r\\n # step 1. compute the output\\r\\n if isinstance(model,NMTModelWithMLTM):\\r\\n y_pred = model(batch_dict['x_source'], \\r\\n batch_dict['x_source_mltm_vector'],\\r\\n batch_dict['x_source_length'], \\r\\n batch_dict['x_target'])\\r\\n else:\\r\\n y_pred = model(batch_dict['x_source'], \\r\\n batch_dict['x_source_length'], \\r\\n batch_dict['x_target'])\\r\\n\\r\\n acc_t = compute_accuracy(y_pred, batch_dict['y_target'], self.mask_index)\\r\\n acc_sum += acc_t\\r\\n \\r\\n return acc_sum / (batch_index+1)\",\n \"def get_predictions():\\n\\n print(\\\"OK1\\\");\\n print(\\\"OK2\\\");\\n return;\",\n \"def testSample(self):\\n val_idx = np.load(self.validation_set)\\n val_sampler = SubsetRandomSampler(val_idx)\\n pose_dataset = PoseDataset(self.dataset_path)\\n val_loader = DataLoader(dataset=pose_dataset, batch_size=1,\\\\\\n sampler=val_sampler)\\n for i in range(5):\\n data_iter = iter(val_loader)\\n skel_2d, skel_z = next(data_iter)\\n\\n # inference\\n skel_2d = skel_2d.to(self.device)\\n z_out = self.net(skel_2d)\\n\\n # show\\n skel_2d = skel_2d.cpu().numpy()\\n skel_2d = skel_2d.reshape((2, -1), order='F') # [(x,y) x n_joint]\\n z_out = z_out.detach().cpu().numpy()\\n z_out = z_out.reshape(-1)\\n z_gt = skel_z.numpy().reshape(-1)\\n self.show_skeletons(skel_2d, z_out, z_gt)\",\n \"def run_sample(self):\\n # there will be validation failures for sample data\\n self.validate_req(ignore_failure=True)\\n runner_fn = self.model_runner.execute_model_for_sample_data\\n return self.do_handle_request(runner_fn)\",\n \"def evaluate(self, predictor_model) -> Any:\\n raise NotImplementedError()\",\n \"def evaluate_prediction(self, model_output, reference):\\n with torch.no_grad():\\n cross_entropy = self._criterion(\\n model_output.view(-1, self.model.ntokens), reference.contiguous().view(-1))\\n return {\\n \\\"cross_entropy\\\": cross_entropy.detach(),\\n \\\"perplexity\\\": torch.exp(cross_entropy).detach(),\\n }\",\n \"def predict(self): \\n return self.model.predict(self.test_x)\",\n \"def test_predict(self):\\n\\n docs = self.docs\\n for m in self.models:\\n preds = m.predict(docs)\\n self.assertTrue(isinstance(preds, turicreate.SArray))\\n self.assertEqual(len(preds), len(docs))\\n self.assertEqual(preds.dtype, int)\\n\\n preds = m.predict(docs, output_type=\\\"probability\\\")\\n self.assertTrue(isinstance(preds, turicreate.SArray))\\n self.assertTrue(len(preds) == len(docs))\\n s = preds.apply(lambda x: sum(x))\\n self.assertTrue((s.apply(lambda x: abs(x - 1)) < 0.000001).all())\\n\\n # Test predictions when docs have new words\\n new_docs = turicreate.SArray([{\\\"-1,-1\\\": 3.0, \\\"0,4\\\": 5.0, \\\"0,3\\\": 2.0}])\\n preds = m.predict(new_docs)\\n self.assertEqual(len(preds), len(new_docs))\\n\\n # Test additional burnin. Ideally we could show that things\\n # converge as you increase burnin.\\n preds_no_burnin = m.predict(docs, output_type=\\\"probability\\\", num_burnin=0)\\n self.assertEqual(len(preds_no_burnin), len(docs))\",\n \"def predict(self, model, x_test):\\n pass\",\n \"def test_predictor():\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n predictions = {k: t.numpy() for k, t in predictions.items()}\\n\\n return predictions, expected\",\n \"def evaluate_model(args, eval_runs, warm_runs, metrics=['psnr', 'ssim', 'fps']):\\n upsampler = Upsampler(args)\\n if warm_runs > 0:\\n print(\\\"Warming up for evaluation\\\")\\n for i in range(warm_runs):\\n print(\\\"Performing warm-up run\\\", str(i+1))\\n for sequence in ['foliage', 'walk', 'calendar', 'city']:\\n bix_dir = os.path.join(VID4_DIR, 'BIx4', sequence)\\n upsampler.run_dir(bix_dir, reset=False)\\n \\n time = 0.\\n psnrs = []\\n ssims = []\\n for i in range(eval_runs):\\n run_psnrs = []\\n run_ssims = []\\n print(\\\"Performing evaluation run\\\", str(i+1))\\n for sequence in ['foliage', 'walk', 'calendar', 'city']:\\n bix_dir = os.path.join(VID4_DIR, 'BIx4', sequence)\\n gt_dir = os.path.join(VID4_DIR, 'GT', sequence)\\n print(\\\"Evaluating on\\\", bix_dir)\\n time += upsampler.run_dir(bix_dir, reset=False)\\n vid_psnrs, vid_ssims = _eval_sr_perf(os.path.join(bix_dir, 'up'), gt_dir)\\n run_psnrs += vid_psnrs\\n run_ssims += vid_ssims\\n if i == eval_runs-1:\\n with open(os.path.join(upsampler.get_model_dir(), \\\"psnr.txt\\\"), \\\"w\\\") as f:\\n f.writelines(str(psnr) + '\\\\n' for psnr in run_psnrs)\\n with open(os.path.join(upsampler.get_model_dir(), \\\"ssim.txt\\\"), \\\"w\\\") as f:\\n f.writelines(str(ssim) + '\\\\n' for ssim in run_ssims)\\n psnrs += run_psnrs\\n ssims += run_ssims\\n\\n fps = VID4_LENGTH/ (time/eval_runs)\\n return Performance(psnr=psnrs, ssim=ssims, fps=fps)\",\n \"def evaluate(self, batch):\\n images, labels, projs, planes = [], [], [], []\\n for serialized in batch:\\n example = tf.train.Example.FromString(serialized)\\n image, label = self.encoder.parse_example(example)\\n images.append(image)\\n labels.append(label)\\n proj, _ = self.encoder.parse_camera(example)\\n projs.append(proj)\\n plane = self.encoder.parse_plane(example)\\n planes.append(plane)\\n\\n\\n #pred = self.model.predict(np.asarray(images), batch_size=len(batch))\\n results = self.predict(np.asarray(images), batch_size=len(batch))\\n \\n # Creating some fake results for testing as well as example of what the \\n # the results should look like.\\n # results = []\\n # for label in labels:\\n # instances = label['2d_instance']\\n # instances_3d = label['3d_instance']\\n # boxes = []\\n # for i in range(len(instances)):\\n # point_2d = np.copy(instances[i])\\n # point_3d = np.copy(instances_3d[i])\\n # for j in range(9):\\n # # Translating the box in 3D, this will have a large impact on 3D IoU.\\n # point_3d[j] += np.array([0.01, 0.02, 0.5])\\n # boxes.append((point_2d, point_3d))\\n # results.append(boxes)\\n\\n for boxes, label, plane in zip(results, labels, planes): \\n instances = label['2d_instance']\\n instances_3d = label['3d_instance']\\n visibilities = label['visibility']\\n num_instances = 0\\n for instance, instance_3d, visibility in zip(\\n instances, instances_3d, visibilities):\\n if (visibility > self._vis_thresh and\\n self._is_visible(instance[0]) and instance_3d[0, 2] < 0):\\n num_instances += 1\\n # We don't have negative examples in evaluation.\\n if num_instances == 0:\\n continue\\n\\n iou_hit_miss = metrics.HitMiss(self._iou_thresholds)\\n azimuth_hit_miss = metrics.HitMiss(self._azimuth_thresholds)\\n polar_hit_miss = metrics.HitMiss(self._polar_thresholds)\\n pixel_hit_miss = metrics.HitMiss(self._pixel_thresholds)\\n\\n num_matched = 0\\n for box in boxes:\\n box_point_2d, box_point_3d = box\\n index = self.match_box(box_point_2d, instances, visibilities)\\n if index >= 0:\\n num_matched += 1\\n pixel_error = self.evaluate_2d(box_point_2d, instances[index])\\n\\n # If you only compute the 3D bounding boxes from RGB images, \\n # your 3D keypoints may be upto scale. However the ground truth\\n # is at metric scale. There is a hack to re-scale your box using \\n # the ground planes (assuming your box is sitting on the ground).\\n # However many models learn to predict depths and scale correctly.\\n #scale = self.compute_scale(box_point_3d, plane)\\n #box_point_3d = box_point_3d * scale\\n azimuth_error, polar_error, iou = self.evaluate_3d(box_point_3d, instances_3d[index])\\n iou_hit_miss.record_hit_miss(iou)\\n pixel_hit_miss.record_hit_miss(pixel_error, greater=False)\\n azimuth_hit_miss.record_hit_miss(azimuth_error, greater=False)\\n polar_hit_miss.record_hit_miss(polar_error, greater=False)\\n\\n if num_matched > 0:\\n self._iou_ap.append(iou_hit_miss, num_instances)\\n self._pixel_ap.append(pixel_hit_miss, num_instances)\\n self._azimuth_ap.append(azimuth_hit_miss, num_instances)\\n self._polar_ap.append(polar_hit_miss, num_instances)\\n self._matched += num_matched\",\n \"def predict(self, instances):\\r\\n raise NotImplementedError\",\n \"def evaluate_prediction(self):\\n\\n # ratio_train = self.evaluate_data(self.train_x, self.train_y)\\n ratio_test = self.evaluate_data(self.test_x, self.test_y)\\n\\n print(\\\"\\\\n*NAIVE BAYES:\\\")\\n # print(\\\"Test1: {}%\\\".format(ratio_dev*100))\\n print(\\\"Test: {} %\\\".format(ratio_test*100))\",\n \"def test_predict_from_examples():\\n examples = []\\n for i in range(len(DATA)):\\n (value, attribute_map) = DATA[i]\\n print 'tuple created : \\\\n1:' + str(value) + \\\"\\\\n2:\\\" + str(attribute_map)\\n ex = VowpalExample(i, value)\\n #Extracting the features from all of the namespaces in the map. \\n for (featureNamespace, features) in attribute_map.items():\\n #Each \\\"section\\\" is \\n ex.add_section(featureNamespace, features)\\n examples.append(ex)\\n train = examples[:-2]\\n test = examples[-2:]\\n vw = Vowpal(PATH_VW, './vw.%s', {'--passes' : '10' })\\n preds = vw.predict_from_examples(train, test)\\n for (id, value) in preds:\\n print 'prediction for %s is %s' % (id, value)\",\n \"def evaluate(X_test, y_test):\\n # batch size is 16 for evaluation\\n batch_size = 16\\n\\n # Load Model\\n model = load_model('model/model.h5')\\n return model.evaluate(X_test, y_test, batch_size, verbose = 1)\",\n \"def evaluate(model, tokenizer, dataset, lines, output_test_file, batch_size=32):\\n sampler = SequentialSampler(dataset)\\n dataloader = DataLoader(dataset, sampler=eval_sampler, batch_size=batch_size)\\n\\n print(\\\"*** Evaluating ***\\\")\\n eval_loss = 0.0\\n num_steps = 0\\n preds = None\\n out_label_ids = None\\n for i, batch in enumerate(dataloader):\\n if i % 200 == 199:\\n print(\\\"=\\\", end=\\\"\\\")\\n if i % 5000 == 4999:\\n print(\\\"[Step \\\" + str(i+1) + \\\" / \\\" + str(len(dataloader)) + \\\"] \\\" )\\n model.eval()\\n batch = tuple(t.to(device) for t in batch)\\n\\n with torch.no_grad():\\n labels = batch[3]\\n outputs = model(input_ids=batch[0], attention_mask=batch[1], labels=labels)\\n tmp_eval_loss, logits = outputs[:2]\\n eval_loss += tmp_eval_loss.mean().item()\\n \\n num_steps += 1\\n if preds is None:\\n preds = logits.detach().cpu().numpy()\\n out_label_ids = labels.detach().cpu().numpy()\\n else:\\n preds = np.append(preds, logits.detach().cpu().numpy(), axis=0)\\n out_label_ids = np.append(out_label_ids, labels.detach().cpu().numpy(), axis=0)\\n \\n eval_loss = eval_loss / num_steps\\n \\n preds_label = np.argmax(preds, axis=1)\\n \\n accuracy = (preds_label == out_label_ids).mean()\\n output_dir = os.path.dirname(output_test_file)\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n with open(output_test_file, \\\"w\\\") as writer:\\n all_logits = preds.tolist()\\n for i, logit in enumerate(all_logits):\\n line = '<CODESPLIT>'.join(\\n [item.encode('ascii', 'ignore').decode('ascii') for item in lines[i]])\\n\\n writer.write(line + '<CODESPLIT>' + '<CODESPLIT>'.join([str(l) for l in logit]) + '\\\\n')\\n print(\\\"Accuracy =\\\", str(accuracy))\\n\\n return accuracy\",\n \"def evaluate(dataset, model, args):\\n device = None\\n if torch.cuda.is_available():\\n device = torch.cuda.current_device()\\n\\n model.to(device)\\n model.train(False)\\n\\n test_loader = DataLoader(dataset, num_workers=4)\\n average_mse = 0\\n average_psnr = 0\\n\\n for batch in tqdm(test_loader):\\n # Preprocess the data\\n image, camera_pose = batch\\n batch_size = len(image)\\n\\n image = torch.as_tensor(image, device=device)\\n image = image[..., :3].permute(0, 3, 1, 2)\\n camera_pose = torch.as_tensor(camera_pose, device=device)\\n camera_pose = camera_pose[:, :3, :]\\n\\n # Run the inference\\n with torch.no_grad():\\n prediction = model(camera_pose)\\n predicted_pixels = prediction[\\\"rgb_map\\\"]\\n target_pixels = image.reshape(batch_size, 3, -1).transpose(1, 2)\\n\\n mse = mse_loss(predicted_pixels[-1], target_pixels)\\n average_mse += mse\\n\\n psnr = mse_to_psnr(mse)\\n average_psnr += psnr\\n\\n average_mse /= len(dataset)\\n average_psnr /= len(dataset)\\n\\n output = {\\n \\\"average_mse\\\": float(average_mse),\\n \\\"average_psnr\\\": float(average_psnr),\\n }\\n print(output)\\n\\n with open(args.output_file, \\\"w\\\") as json_file:\\n json.dump(output, json_file)\\n print(\\\"Saved results to:\\\", args.output_file)\",\n \"def test(self):\\n with torch.no_grad():\\n self.model.eval()\\n p10_forecast, p10_forecast, p90_forecast, target = None, None, None, None\\n\\n t = time()\\n for step, sample in enumerate(self.test_loader):\\n\\n # Hide future predictions from input vector, set to 0 (or 1) values where timestep > encoder_steps\\n steps = self.cnf.all_params['num_encoder_steps']\\n pred_len = sample['outputs'].shape[1]\\n x = sample['inputs'].float().to(self.cnf.device)\\n x[:, steps:, 0] = 1\\n\\n # Feed input to the model\\n if self.cnf.all_params[\\\"model\\\"] == \\\"transformer\\\" or self.cnf.all_params[\\\"model\\\"] == \\\"grn_transformer\\\":\\n\\n # Auto-regressive prediction\\n for i in range(pred_len):\\n output = self.model.forward(x)\\n x[:, steps + i, 0] = output[:, i, 1]\\n output = self.model.forward(x)\\n\\n elif self.cnf.all_params[\\\"model\\\"] == \\\"tf_transformer\\\":\\n output, _, _ = self.model.forward(x)\\n else:\\n raise NameError\\n\\n output = output.squeeze()\\n y, y_pred = sample['outputs'].squeeze().float().to(self.cnf.device), output\\n\\n # Compute loss\\n loss, _ = self.loss(y_pred, y)\\n smape = symmetric_mean_absolute_percentage_error(output[:, :, 1].detach().cpu().numpy(),\\n sample['outputs'][:, :, 0].detach().cpu().numpy())\\n\\n # De-Normalize to compute metrics\\n target = unnormalize_tensor(self.data_formatter, y, sample['identifier'][0][0])\\n p10_forecast = unnormalize_tensor(self.data_formatter, y_pred[..., 0], sample['identifier'][0][0])\\n p50_forecast = unnormalize_tensor(self.data_formatter, y_pred[..., 1], sample['identifier'][0][0])\\n p90_forecast = unnormalize_tensor(self.data_formatter, y_pred[..., 2], sample['identifier'][0][0])\\n\\n # Compute metrics\\n self.test_losses['p10'].append(self.loss.numpy_normalised_quantile_loss(p10_forecast, target, 0.1))\\n self.test_losses['p50'].append(self.loss.numpy_normalised_quantile_loss(p50_forecast, target, 0.5))\\n self.test_losses['p90'].append(self.loss.numpy_normalised_quantile_loss(p90_forecast, target, 0.9))\\n\\n self.test_loss.append(loss.item())\\n self.test_smape.append(smape)\\n\\n # Plot serie prediction\\n p1, p2, p3, target = np.expand_dims(p10_forecast, axis=-1), np.expand_dims(p50_forecast, axis=-1), \\\\\\n np.expand_dims(p90_forecast, axis=-1), np.expand_dims(target, axis=-1)\\n p = np.concatenate((p1, p2, p3), axis=-1)\\n plot_temporal_serie(p, target)\\n\\n # Log stuff\\n for k in self.test_losses.keys():\\n mean_test_loss = np.mean(self.test_losses[k])\\n print(f'\\\\t● AVG {k} Loss on TEST-set: {mean_test_loss:.6f} │ T: {time() - t:.2f} s')\\n\\n # log log log\\n mean_test_loss = np.mean(self.test_loss)\\n mean_smape = np.mean(self.test_smape)\\n print(f'\\\\t● AVG Loss on TEST-set: {mean_test_loss:.6f} │ T: {time() - t:.2f} s')\\n print(f'\\\\t● AVG SMAPE on TEST-set: {mean_smape:.6f} │ T: {time() - t:.2f} s')\",\n \"def get_predictions(fitted_model_filename):\\n click.echo(\\\"Mode: predicting probabilities.\\\\n\\\")\\n defaults = get_defaults()\\n\\n fitted_model_filename = add_extension(fitted_model_filename)\\n fitted_model_path = os.path.join(defaults.OUTPUT.FITTED_MODELS_PATH, fitted_model_filename)\\n new_options = [\\\"OUTPUT.FITTED_MODEL_PATH\\\", fitted_model_path]\\n\\n # boot_data = bootstrap(new_options, mode=\\\"internal_test\\\")\\n # model = boot_data['model']\\n #\\n # X_test_int, y_test_int = boot_data['data']\\n # internal_test_proba = model.predict_proba(X_test_int)\\n # internal_test_proba = np.c_[y_test_int, internal_test_proba[:, 1]]\\n\\n boot_data = bootstrap(new_options, mode=\\\"external_test\\\")\\n model = boot_data['model']\\n X_test_ext, y_test_ext = boot_data['data']\\n\\n # fit scaler on train data and transform test data\\n scaler = StandardScaler()\\n X_train, y_train = load_data(defaults, which='train')\\n\\n numeric_cols = X_train.select_dtypes(include=np.float64).columns.tolist()\\n scaler.fit(X_train[numeric_cols])\\n X_test_ext.loc[:, numeric_cols] = scaler.transform(X_test_ext[numeric_cols])\\n\\n external_test_proba = model.predict_proba(X_test_ext)\\n external_test_proba = np.c_[y_test_ext, external_test_proba[:, 1]]\\n\\n # internal_test_results_path = os.path.join(defaults.OUTPUT.PREDS_PATH, \\\"internal_test_preds.csv\\\")\\n external_test_results_path = os.path.join(defaults.OUTPUT.PREDS_PATH,\\n f\\\"external_test_preds_{fitted_model_filename.replace('.pkl', '')}.csv\\\")\\n # pd.DataFrame(internal_test_proba, columns=['target', 'proba']).to_csv(internal_test_results_path, index=False)\\n pd.DataFrame(external_test_proba, columns=['target', 'proba']).to_csv(external_test_results_path, index=False)\",\n \"def test_predict(self):\\n self.regression_single.predict(self.X_test)\\n self.assertTrue(len(self.regression_single.y_pred))\\n self.regression_boston.predict(self.boston_x_test)\\n self.assertTrue(len(self.regression_boston.y_pred))\",\n \"def test_prediction(model, raw_data):\\n data = PredictionData(**raw_data)\\n formated_data = {}\\n for key, value in data.dict().items():\\n formated_data[key] = [value]\\n df = pd.DataFrame(formated_data)\\n res = model.predict(df)[0]\\n assert type(res) == np.float64\",\n \"def evaluate_model(valp):\\n\\n a = valp.predict(data_inputs[\\\"Test\\\"], [], new=True)[0]\\n\\n m2e = np.mean(mse(a[\\\"o0\\\"], data_outputs[\\\"Test\\\"][\\\"o0\\\"]))\\n acc = 1 - acc_err(a[\\\"o1\\\"][:, 0], np.argmax(data_outputs[\\\"Test\\\"][\\\"o1\\\"], axis=1))\\n i_d = 50-np.mean(inception_score(a[\\\"o2\\\"][:100]))\\n\\n return np.array([m2e, acc, i_d])\",\n \"def evaluate_model(model, X_test, Y_test, category_names): \\n \\n Y_pred = model.predict(X_test)\\n print(classification_report(Y_test, Y_pred))\\n display_results(Y_test, Y_pred)\",\n \"def test(self):\\n self.model.eval()\\n\\n for step, sample in enumerate(self.test_loader):\\n x, _, _ = sample\\n x = x.to(self.device)\\n\\n y_pred = self.model.forward(x)\\n loss = nn.MSELoss()(y_pred, x)\\n self.test_losses.append(loss.item())\\n\\n if step % (max(8, len(self.test_loader)) // 8) == 0:\\n out_img = torch.cat([x[0], torch.clamp(y_pred[0], 0, 1)], dim=2)\\n self.sw.add_image(tag=f'sample_{step}', img_tensor=out_img, global_step=self.epoch)\\n\\n # log average loss on test set\\n mean_test_loss = np.mean(self.test_losses)\\n self.test_losses = []\\n print(f'\\\\t● AVG Loss on TEST-set: {mean_test_loss:.6f} │ patience: ', end='')\\n self.sw.add_scalar(tag='test_loss', scalar_value=mean_test_loss, global_step=self.epoch)\\n\\n # save best model and update training patience\\n if self.best_test_loss is None or mean_test_loss < self.best_test_loss:\\n self.best_test_loss = mean_test_loss\\n self.patience = conf.FX_PATIENCE\\n torch.save(self.model.state_dict(), self.log_path / 'best.pth')\\n else:\\n self.patience = self.patience - 1\\n print(f'{self.patience}/{conf.FX_PATIENCE}')\\n\\n if self.patience == 0:\\n self.show_completion_msg()\",\n \"def predict(self, test_batch_size=64, device='cuda', load=False, model_path=None, dataloader_num_workers=4, save_prediction=True):\\n self.model.eval()\\n self.device = device\\n self.test_batch_size = test_batch_size\\n if load:\\n if model_path:\\n self.load(model_path, device=self.device)\\n else:\\n model_path = os.path.join(path_checkpoints_dir, f\\\"{self.experiment_id}.pth\\\")\\n print(f\\\"loaded model={model_path}\\\")\\n self.load(model_path, device=self.device)\\n if self.model is None:\\n raise Exception(\\\"model cannot be None. Load or train the model before inference\\\")\\n dataloader = self.data_module.get_test_dataloader(batch_size=self.test_batch_size, shuffle=False, num_workers=dataloader_num_workers)\\n all_outputs = []\\n tk0 = tqdm(enumerate(dataloader, 1), total=len(dataloader))\\n for batch_id, data in tk0:\\n for key, value in data.items():\\n data[key] = value.to(self.device)\\n # batch_outputs, batch_loss = self.model(**data)\\n batch_outputs, batch_loss= self.validate_one_batch(data)\\n all_outputs.append(batch_outputs.detach().cpu().numpy())\\n predictions = np.concatenate(all_outputs, axis=0)\\n if save_prediction:\\n submission = pd.read_csv(path_sample_submission_file)\\n assert submission.shape[0] == predictions.shape[0], \\\"unexpected behavior.code fix required\\\"\\n submission.iloc[:, 1:] = predictions\\n\\n if not os.path.isdir(path_submissions_dir):\\n os.mkdir(path_submissions_dir)\\n submission.to_csv(os.path.join(path_submissions_dir, f\\\"{self.experiment_id}.csv\\\"), index=False)\\n tk0.close()\\n return predictions\",\n \"def fit_predict(self):\\n self.classifier = self.model\\n self.classifier.fit(self.X_sample, self.y_sample)\\n self.y_pred = self.classifier.predict(self.X_test)\",\n \"def predict():\\n\\n predict_cfg = get_predict_args()\\n device = get_device()\\n print(device)\\n\\n # load checkpoint\\n ckpt_path = find_ckpt_in_directory(predict_cfg.ckpt)\\n ckpt = torch.load(ckpt_path, map_location=device)\\n best_iter = ckpt[\\\"best_iter\\\"]\\n cfg = ckpt[\\\"cfg\\\"]\\n aspect = cfg[\\\"aspect\\\"]\\n\\n for k, v in cfg.items():\\n print(\\\"{:20} : {:10}\\\".format(k, str(v)))\\n\\n eval_batch_size = 64\\n\\n print(\\\"Loading data\\\")\\n dev_data = list(beer_reader(cfg[\\\"dev_path\\\"]))\\n test_data = beer_annotations_reader(cfg[\\\"test_path\\\"], aspect=aspect)\\n\\n print(\\\"dev\\\", len(dev_data))\\n print(\\\"test\\\", len(test_data))\\n\\n print(\\\"Loading pre-trained word embeddings\\\")\\n vocab = Vocabulary()\\n vectors = load_embeddings(cfg[\\\"embeddings\\\"], vocab) # required for vocab\\n\\n # build model\\n model = build_model(cfg[\\\"model\\\"], vocab, cfg=cfg)\\n\\n # load parameters from checkpoint into model\\n print(\\\"Loading saved model..\\\")\\n model.load_state_dict(ckpt[\\\"state_dict\\\"])\\n model.to(device)\\n print(\\\"Done\\\")\\n\\n print(model)\\n print_parameters(model)\\n\\n print(\\\"Evaluating\\\")\\n dev_eval = evaluate_loss(\\n model, dev_data, batch_size=eval_batch_size,\\n device=device, cfg=cfg)\\n test_eval = evaluate_loss(\\n model, test_data, batch_size=eval_batch_size,\\n device=device, cfg=cfg)\\n\\n if hasattr(model, \\\"z\\\"):\\n path = os.path.join(\\n cfg[\\\"save_path\\\"], \\\"final_rationales.txt\\\")\\n test_precision, test_macro_prec = evaluate_rationale(\\n model, test_data, aspect=aspect, device=device,\\n batch_size=eval_batch_size, path=path)\\n else:\\n test_precision = 0.\\n test_macro_prec = 0.\\n test_eval[\\\"precision\\\"] = test_precision\\n test_eval[\\\"macro_precision\\\"] = test_macro_prec\\n\\n dev_s = make_kv_string(dev_eval)\\n test_s = make_kv_string(test_eval)\\n\\n print(\\\"best model iter {:d} dev {} test {}\\\".format(\\n best_iter, dev_s, test_s))\",\n \"def test_test_regression_model(self):\\n model = RegressionTestModel()\\n example = {'x_1': 3, 'x_2': 2}\\n pred = list(model.predict([example]))[0]\\n self.assertEqual(pred['score'], 20)\",\n \"def evaluate(self, model, y_test, y_pred, softmax_predictions,\\n config_dict, y_paths):\\n print('Model metrics: ', model.metrics_names)\\n assert(y_test.shape == y_pred.shape)\\n\\n if len(y_pred.shape) > 2: # If sequential data\\n y_pred, paths = get_majority_vote_3d(y_pred, y_paths)\\n softmax_predictions, _ = get_majority_vote_3d(softmax_predictions, y_paths)\\n y_test, _ = get_majority_vote_3d(y_test, y_paths)\\n # self.look_at_classifications(y_test, y_pred, paths, softmax_predictions)\\n nb_preds = len(y_pred)\\n nb_tests = len(y_test)\\n\\n if nb_preds != nb_tests:\\n print(\\\"Warning, number of predictions not the same as the length of the y_test vector.\\\")\\n print(\\\"Y test length: \\\", nb_tests)\\n print(\\\"Y pred length: \\\", nb_preds)\\n if nb_preds < nb_tests:\\n y_test = y_test[:nb_preds]\\n else:\\n y_pred = y_pred[:nb_tests]\\n\\n # Print labels and predictions.\\n print('y_test.shape: ', y_test.shape)\\n print('y_pred.shape: ', y_pred.shape)\\n # print('y_test and y_test.shape: ', y_test, y_test.shape)\\n # print('y_pred and y_pred.shape: ', y_pred, y_pred.shape)\\n\\n self.print_and_save_evaluations(y_test, y_pred, softmax_predictions, config_dict)\",\n \"def evaluate(self, test_instance):\\n return self.classifier.predict([test_instance])[0]\",\n \"def predict(model, X_testing):\\n predictions = model.predict(X_testing)\\n\\n return predictions\",\n \"def predict(self, samples): \\n return self.random_forest.predict(samples)\",\n \"def evaluate_model(model, X_test, y_test):\\n # run prediction with test data\\n y_pred = model.predict(X_test)\\n\\n # print precision, recall and f1-score\\n i = 0\\n for col in y_test:\\n print('Evaluation for \\\"{}\\\": \\\\n {} \\\\n\\\\n'.format(col, classification_report(y_test[col], y_pred[:,i])))\\n i += 1\",\n \"def predict(self, sample, **kwargs):\\n return self.model.predict(sample, **kwargs)\",\n \"def evaluate_model(model, X_train, y_train, X_test, y_test):\\n model = model\\n model.fit(X_train, y_train)\\n\\n y_pred = model.predict(X_test)\\n\\n report = classificationreport(y_test, y_pred, target_names= [\\\"0\\\", \\\"1\\\"], output_dict=True)\\n\\n return report\",\n \"def sample_pointpredictions(model: 'BaseModel', data: Dict[str, torch.Tensor], n_samples: int,\\n scaler: Dict[str, Union[pd.Series, xarray.Dataset]]) -> Dict[str, torch.Tensor]:\\n\\n if model.cfg.head.lower() == \\\"gmm\\\":\\n samples = sample_gmm(model, data, n_samples, scaler)\\n elif model.cfg.head.lower() == \\\"cmal\\\":\\n samples = sample_cmal(model, data, n_samples, scaler)\\n elif model.cfg.head.lower() == \\\"umal\\\":\\n samples = sample_umal(model, data, n_samples, scaler)\\n elif model.cfg.head.lower() == \\\"regression\\\":\\n samples = sample_mcd(model, data, n_samples, scaler) # regression head assumes mcd\\n else:\\n raise NotImplementedError(f\\\"Sampling mode not supported for head {model.cfg.head.lower()}!\\\")\\n\\n return samples\",\n \"def evaluate_model_with_test_data(model, generator, iterations_count, label_name=''):\\n y_predicted, y_etalon = [], []\\n for i in range(0,iterations_count):\\n x,y = next(generator)\\n y_result = model.predict(x, y.shape[0])\\n y_predicted.extend(y_result)\\n y_etalon.extend(y)\\n\\n\\n # corner1, bridge start, b_end, Big Left, BL-end, Sharp Right, end, Last left, end\\n way_points = [69, 183, 276, 309, 348, 410, 456, 514, 612]\\n wp_total = 819\\n plt_pt_length = len(y_etalon)\\n\\n\\n plt.figure(figsize=(24,6))\\n plt.plot(y_predicted, 'r-')\\n plt.plot(y_etalon, 'g--')\\n plt.title('Predicted angle vs sample')\\n plt.ylabel('Angle')\\n plt.xlabel('Sample #')\\n plt.legend(['Predicted', 'Initial'], loc='upper right')\\n\\n #add vertical lines to define critical regions on the plot\\n for p in way_points:\\n px = p / wp_total * plt_pt_length\\n plt.axvline(px, ls='--', color='k')\\n\\n plt.gca().invert_yaxis()\\n\\n lbl = ''\\n if len(label_name):\\n lbl = '-' + label_name\\n plt.savefig('test_vs_recorded_angle{}.png'.format(lbl), bbox_inches='tight')\",\n \"def assess_model(model, test_data, label):\\n return model.score(test_data,label)\",\n \"def evaluate(self, X_test, y_test):\\n self.run(self)\\n self.y_pred = self.pipeline.predict(X_test)\\n self.rmse = compute_rmse(self.y_pred, y_test)\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n y_pred = model.predict(X_test)\\n print(classification_report(Y_test, y_pred, target_names=Y_test.keys()))\",\n \"def evaluate_random_forest(y_test, y_pred):\",\n \"def predict():\\n import trace\\n trace.predict()\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n y_pred = model.predict(X_test)\\n y_actu = Y_test.values\\n\\n results_dict = {}\\n for i in range(1, 37):\\n predicted = \\\"pred_\\\" + str(i)\\n actual = \\\"actu_\\\" + str(i)\\n pred_values = []\\n actu_values = []\\n for ii in range(len(y_pred)):\\n\\n pred_values.append(int(y_pred[ii][i-1]))\\n actu_values.append(int(y_actu[ii][i-1]))\\n\\n results_dict[predicted] = pred_values\\n results_dict[actual] = actu_values\\n\\n for i in range(1, 37):\\n pred = results_dict['pred_' + str(i)]\\n actu = results_dict['actu_' + str(i)]\\n\\n print(\\\"\\\\n### \\\" + category_names[i-1] + \\\" ###\\\\n\\\")\\n print(classification_report(pred, actu))\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n \\n Y_pred = model.predict(X_test)\\n \\n print(classification_report(Y_test.values, Y_pred, target_names=category_names))\",\n \"def get_predictions(self, model, inputs=None):\\n if inputs is None:\\n inputs = self.inputs\\n\\n refl_id = BaseModel.get_refl_id(inputs)\\n iobs = BaseModel.get_intensities(inputs).flatten()\\n sig_iobs = BaseModel.get_uncertainties(inputs).flatten()\\n asu_id,H = self.asu_collection.to_asu_id_and_miller_index(refl_id)\\n #ipred = model(inputs)\\n ipred,sigipred = model.prediction_mean_stddev(inputs)\\n\\n h,k,l = H.T\\n results = ()\\n for i,asu in enumerate(self.asu_collection):\\n idx = asu_id == i\\n idx = idx.flatten()\\n output = rs.DataSet({\\n 'H' : h[idx],\\n 'K' : k[idx],\\n 'L' : l[idx],\\n 'Iobs' : iobs[idx],\\n 'SigIobs' : sig_iobs[idx],\\n 'Ipred' : ipred[idx],\\n 'SigIpred' : sigipred[idx],\\n }, \\n cell=asu.cell, \\n spacegroup=asu.spacegroup,\\n merged=False,\\n ).infer_mtz_dtypes().set_index(['H', 'K', 'L'])\\n results += (output, )\\n return results\",\n \"def evaluate_model(model, X_test, y_test, category_names):\\n y_pred = model.predict(X_test)\\n labels = np.unique(y_pred)\\n print(labels)\\n #print out score for each class and mean scores, including precision, recall, f1 score\\n print(classification_report(y_test.values, y_pred, target_names=category_names.values))\",\n \"def evaluate_model(model, instances, labels):\\n prediction = model.predict(np.array(instances))\\n\\n prediction_inv = inverse_normalization(prediction)\\n labels_inv = inverse_normalization(labels)\\n mse = mean_squared_error(labels_inv, prediction_inv)\\n\\n return mse\",\n \"def test_predict():\\n args = get_layer('predict', 'manual', 'temporal', False, False, window=2, step_size=3)\\n run_layer(*args)\",\n \"def generate(self, models, sample, **kwargs):\\n net_input = sample['net_input']\\n\\n def batch_for_softmax(dec_out, target):\\n # assumes decoder_out[0] is the only thing needed (may not be correct for future models!)\\n first, rest = dec_out[0], dec_out[1:]\\n bsz, tsz, dim = first.shape\\n if bsz * tsz < self.softmax_batch:\\n yield dec_out, target, True\\n else:\\n flat = first.contiguous().view(1, -1, dim)\\n flat_tgt = target.contiguous().view(flat.shape[:-1])\\n s = 0\\n while s < flat.size(1):\\n e = s + self.softmax_batch\\n yield (flat[:, s:e],) + rest, flat_tgt[:, s:e], False\\n s = e\\n\\n def gather_target_probs(probs, target):\\n probs = probs.gather(\\n dim=2,\\n index=target.unsqueeze(-1),\\n )\\n return probs\\n\\n orig_target = sample['target']\\n\\n # compute scores for each model in the ensemble\\n avg_probs = None\\n avg_attn = None\\n for model in models:\\n model.eval()\\n decoder_out = model(**net_input)\\n attn = decoder_out[1]\\n if type(attn) is dict:\\n attn = attn.get('attn', None)\\n\\n batched = batch_for_softmax(decoder_out, orig_target)\\n probs, idx = None, 0\\n for bd, tgt, is_single in batched:\\n sample['target'] = tgt\\n curr_prob = model.get_normalized_probs(bd, log_probs=len(models) == 1, sample=sample).data\\n if is_single:\\n probs = gather_target_probs(curr_prob, orig_target)\\n else:\\n if probs is None:\\n probs = curr_prob.new(orig_target.numel())\\n step = curr_prob.size(0) * curr_prob.size(1)\\n end = step + idx\\n tgt_probs = gather_target_probs(curr_prob.view(tgt.shape + (curr_prob.size(-1),)), tgt)\\n probs[idx:end] = tgt_probs.view(-1)\\n idx = end\\n sample['target'] = orig_target\\n\\n probs = probs.view(sample['target'].shape)\\n\\n if avg_probs is None:\\n avg_probs = probs\\n else:\\n avg_probs.add_(probs)\\n if attn is not None and torch.is_tensor(attn):\\n attn = attn.data\\n if avg_attn is None:\\n avg_attn = attn\\n else:\\n avg_attn.add_(attn)\\n if len(models) > 1:\\n avg_probs.div_(len(models))\\n avg_probs.log_()\\n if avg_attn is not None:\\n avg_attn.div_(len(models))\\n\\n bsz = avg_probs.size(0)\\n hypos = []\\n start_idxs = sample['start_indices'] if 'start_indices' in sample else [0] * bsz\\n for i in range(bsz):\\n # remove padding from ref\\n ref = utils.strip_pad(sample['target'][i, start_idxs[i]:], self.pad) \\\\\\n if sample['target'] is not None else None\\n tgt_len = ref.numel()\\n avg_probs_i = avg_probs[i][start_idxs[i]:start_idxs[i] + tgt_len]\\n score_i = avg_probs_i.sum() / tgt_len\\n if avg_attn is not None:\\n avg_attn_i = avg_attn[i]\\n alignment = utils.extract_hard_alignment(\\n avg_attn_i,\\n sample['net_input']['src_tokens'][i],\\n sample['target'][i],\\n self.pad,\\n self.eos,\\n )\\n else:\\n avg_attn_i = alignment = None\\n hypos.append([{\\n 'tokens': ref,\\n 'score': score_i,\\n 'attention': avg_attn_i,\\n 'alignment': alignment,\\n 'positional_scores': avg_probs_i,\\n }])\\n return hypos\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n \\n y_preds = model.predict(X_test)\\n predictions = pd.DataFrame(data=y_preds, columns=Y_test.columns, index=Y_test.index)\\n for col in Y_test.columns:\\n print(classification_report(predictions[col],Y_test[col]))\",\n \"def evaluate_model(model, X_test_input, y_test_input):\\r\\n pred_class = [model.classes_[i] for i in model.predict_proba(X_test_input).argmax(axis=-1)]\\r\\n pred_accuracy = np.sum(np.array(y_test_input)==np.array(pred_class))/len(pred_class)\\r\\n return pred_class, pred_accuracy\",\n \"def evaluate(inputs, labels):\\n # Your code here.\\n _, probs = forward(inputs)\\n preds = predict(probs)\\n trues = np.argmax(labels, axis=1)\\n return np.mean(preds == trues)\",\n \"def evaluate(self,\\n model,\\n x=None,\\n y=None,\\n batch_size=None,\\n verbose=1,\\n sample_weight=None,\\n steps=None,\\n callbacks=None,\\n **kwargs):\\n raise NotImplementedError()\",\n \"def predict(self, batch_inputs: dict,\\n batch_data_samples: SampleList) -> SampleList:\\n pass\",\n \"def _predict(self, testX):\\n pass\",\n \"def predict_and_sample(inference_model,x_initializer,a_initializer,c_initializer):\\n # Step 1: Use your inference model to predict an output sequence given x_initializer, a_initializer and c_initializer.\\n pred = inference_model.predict([x_initializer,a_initializer,c_initializer])\\n \\n # Step 2: Convert \\\"pred\\\" into an np.array() of indices with the maximum probabilities\\n indices = np.argmax(pred,axis=-1)\\n \\n # Step 3: Convert indices to one-hot vectors, the shape of the results should be (1, )\\n results = to_categorical(indices,num_classes=x_initializer.shape[-1])\\n \\n return results,indices\",\n \"def evaluate(self, model, data):\\n model.eval()\\n\\n loss = self.loss\\n loss.reset()\\n match = 0\\n total = 0\\n correct_spk = 0\\n total_response = 0\\n y_true = np.array([])\\n y_pred = np.array([])\\n\\n device = None if torch.cuda.is_available() else -1\\n batch_iterator = torchtext.data.BucketIterator(\\n dataset=data, batch_size=self.batch_size,\\n sort=True, sort_key=lambda x: len(x.src),\\n device=device, train=False)\\n tgt_vocab = data.fields[seq2seq.tgt_field_name].vocab\\n pad = tgt_vocab.stoi[data.fields[seq2seq.tgt_field_name].pad_token]\\n\\n for batch in batch_iterator:\\n input_variables, input_lengths = getattr(batch, seq2seq.src_field_name)\\n target_variables, target_lengths = getattr(batch, seq2seq.tgt_field_name)\\n spk_inputs = [getattr(batch, str(i)) for i in range(self.args.num_sentence)]\\n\\n decoder_outputs, decoder_hidden, other = model(input_variables, input_lengths.tolist(),\\n target_variables, input_spk=spk_inputs)\\n\\n # Predict Speaker:\\n target_spk = spk_inputs[-1]\\n target_lengths = target_lengths.cpu().numpy()\\n prob_per_spk = []\\n for i in range(self.args.num_spk):\\n spk_inputs_predict = Variable(torch.LongTensor(np.full((1,batch.batch_size), i)).clone())\\n if self.args.cuda: spk_inputs_predict = spk_inputs_predict.cuda()\\n spk_inputs_ = [getattr(batch, str(idx)) for idx in range(self.args.num_sentence-1)]\\n spk_inputs_.append(spk_inputs_predict)\\n decoder_outputs, decoder_hidden, other = model(input_variables, input_lengths.tolist(),\\n target_variables, input_spk=spk_inputs_)\\n prob_per_responce = []\\n target = target_variables.transpose(0,1)\\n for word, prob in zip(target[1:], decoder_outputs):\\n word, prob = word.data.cpu().numpy(), prob.data.cpu().numpy()\\n indices = zip(np.arange(len(word)), word)\\n prob_per_word = [prob[i] for i in indices] # select the prob for *sentence_len* times\\n prob_per_responce.append(prob_per_word)\\n prob_per_spk.append([np.sum(prob_per_responce[:i]) for i in target_lengths])\\n prob_per_spk = np.transpose(prob_per_spk) # output: (batch_size, num_spk), every element is the log prob for responce\\n\\n predicts = np.argmax(prob_per_spk, axis=1)\\n correct_spk += (predicts == target_spk.data.cpu().numpy()).sum()\\n total_response += len(batch.tgt[0])\\n\\n # Evaluation\\n seqlist = other['sequence']\\n for step, step_output in enumerate(decoder_outputs):\\n target = target_variables[:, step + 1]\\n loss.eval_batch(step_output.view(target_variables.size(0), -1), target)\\n\\n non_padding = target.ne(pad)\\n correct = seqlist[step].view(-1).eq(target).masked_select(non_padding).sum().data[0]\\n match += correct\\n total += non_padding.sum().data[0]\\n\\n y_pred = np.append(y_pred, predicts)\\n y_true = np.append(y_true, target_spk.data.cpu().numpy())\\n\\n print(y_pred.shape)\\n\\n print(accuracy_score(y_true, y_pred))\\n print(confusion_matrix(y_true, y_pred))\\n\\n if total == 0:\\n accuracy = float('nan')\\n else:\\n accuracy = match / total\\n\\n if total_response == 0:\\n accuracy_spk = float('nan')\\n else:\\n accuracy_spk = correct_spk / total_response\\n\\n return loss.get_loss(), accuracy, accuracy_spk\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n\\n print(\\\"Testing Performance\\\")\\n print(classification_report(Y_test, model.predict(X_test), target_names=category_names))\\n\\n #Todo cat names\",\n \"def test(self, samples):\\n prediction_errors = np.zeros(len(samples), int)\\n predictions = np.zeros(len(samples), int)\\n class_predictions = np.zeros(self.class_count)\\n \\n for i in range(len(samples)): # Loop over each sample\\n for j in range(self.class_count): # Loop over each class\\n class_predictions[j] = self.p_ys[j] # Get p(y) for class j\\n for k in range(self.feature_count): # Loop over each feature \\n # Multiply p(y) by p(xi|y) \\n if(samples[i][k] == 1):\\n class_predictions[j] *= self.p_xi_given_ys[j][k] \\n else:\\n class_predictions[j] *= 1 - self.p_xi_given_ys[j][k] \\n \\n predictions[i] = np.argmax(class_predictions) # Prediction is class with highest probability.\\n \\n # Check if the predicted class doesn't match the true class.\\n if(predictions[i] != samples[i][-1]):\\n prediction_errors[i] = 1 \\n \\n # Compute accuracy\\n accuracy = 1.0 - (np.sum(prediction_errors) * 1.0 / len(prediction_errors)) \\n \\n return prediction_errors, predictions, accuracy\",\n \"def test_evaluate_model(sequential_model, model_data):\\n _, _, _, _, x_test, y_test = model_data\\n compile_model(sequential_model)\\n output = evaluate_model(sequential_model, x_test, y_test, 64)\\n assert len(output) == 2\",\n \"def ApplyModel(testData, modelname, model):\\n testData=testData.astype('float32')\\n \\n if modelname=='Support Vector Machine (Sklearn)':\\n a,result = model.predict(testData, cv2.ml.ROW_SAMPLE)\\n\\n if modelname=='Random Forest Classifier (Sklearn)':\\n result = model.predict(testData)\\n \\n if modelname=='Classification and Regression Tree (Sklearn)':\\n result = model.predict(testData)\\n\\n \\n result2=result.reshape(np.shape(result)[0])\\n result2=result2.astype('int')\\n return result2\",\n \"def evaluate():\\n\\n # seed provides the mechanism to control the shuffling which takes place reading input\\n seed = tf.placeholder(tf.int64, shape=())\\n \\n # Generate placeholders for the images and labels.\\n iterator = input_data.input_pipeline_binary(FLAGS.data_dir,\\n FLAGS.batch_size,\\n fake_data=FLAGS.fake_data,\\n num_epochs=1,\\n read_threads=FLAGS.read_threads,\\n shuffle_size=FLAGS.shuffle_size,\\n num_expected_examples=FLAGS.num_examples,\\n seed=seed)\\n image_path, label_path, images, labels = iterator.get_next()\\n\\n if FLAGS.verbose:\\n print_op = tf.print(\\\"images and labels this batch: \\\", \\n image_path, label_path, labels)\\n else:\\n print_op = tf.constant('No printing')\\n\\n if FLAGS.random_rotation:\\n images, labels = harmonics.apply_random_rotation(images, labels)\\n\\n # Build a Graph that computes predictions from the inference model.\\n logits = topology.inference(images, FLAGS.network_pattern)\\n \\n # Add to the Graph the Ops for loss calculation.\\n loss = topology.binary_loss(logits, labels)\\n \\n # Set up some prediction statistics\\n predicted = tf.round(tf.nn.sigmoid(logits))\\n correct_pred = tf.equal(predicted, labels)\\n accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))\\n\\n saver = tf.train.Saver()\\n\\n with tf.Session() as sess:\\n \\n while True:\\n eval_once(sess, iterator, saver, seed, labels, loss, accuracy, predicted)\\n if FLAGS.run_once:\\n break\\n time.sleep(FLAGS.eval_interval_secs)\",\n \"def test_new_data(model, data_folder='testData'):\\n\\n size = (120, 120) # target img dimensions\\n x_train = ssd_dataloader.load_ssd(size, data_folder)\\n\\n for sample in range(0, len(x_train)):\\n\\n image = x_train[None, sample, :, :, :] # None to retain dimensionality\\n\\n prediction = model.predict(image)\\n print('Sample {} Probabilities:'.format(int(sample)))\\n print(prediction)\\n prediction = int(np.argmax(prediction))\\n\\n if prediction == 0:\\n print('Left')\\n elif prediction == 1:\\n print('Right')\\n else:\\n print('Error')\\n\\n if show_plots:\\n plt.imshow(image[0, :, :, 0])\\n plt.draw()\\n plt.show()\",\n \"def generate_predictions(inputs, model, tokenizer):\\n # Generate model results\\n outputs = model(**inputs)\\n\\n # Convert logit outputs into predictions for table cells and aggregation operators\\n predicted_table_cell_coords, predicted_aggregation_operators = tokenizer.convert_logits_to_predictions(\\n inputs,\\n outputs.logits.detach(),\\n outputs.logits_aggregation.detach()\\n )\\n\\n print(predicted_table_cell_coords)\\n print(predicted_aggregation_operators)\\n\\n # Return values\\n return predicted_table_cell_coords, predicted_aggregation_operators\",\n \"def run_prediction(question_texts, context_text):\\r\\n examples = []\\r\\n\\r\\n for i, question_text in enumerate(question_texts):\\r\\n example = SquadExample(\\r\\n qas_id=str(i),\\r\\n question_text=question_text,\\r\\n context_text=context_text,\\r\\n answer_text=None,\\r\\n start_position_character=None,\\r\\n title=\\\"Predict\\\",\\r\\n is_impossible=False,\\r\\n answers=None,\\r\\n )\\r\\n\\r\\n examples.append(example)\\r\\n\\r\\n features, dataset = squad_convert_examples_to_features(\\r\\n examples=examples,\\r\\n tokenizer=tokenizer,\\r\\n max_seq_length=384,\\r\\n doc_stride=128,\\r\\n max_query_length=64,\\r\\n is_training=False,\\r\\n return_dataset=\\\"pt\\\",\\r\\n threads=1,\\r\\n )\\r\\n\\r\\n eval_sampler = SequentialSampler(dataset)\\r\\n eval_dataloader = DataLoader(dataset, sampler=eval_sampler, batch_size=10)\\r\\n\\r\\n all_results = []\\r\\n\\r\\n for batch in eval_dataloader:\\r\\n model.eval()\\r\\n batch = tuple(t.to(device) for t in batch)\\r\\n\\r\\n with torch.no_grad():\\r\\n inputs = {\\r\\n \\\"input_ids\\\": batch[0],\\r\\n \\\"attention_mask\\\": batch[1],\\r\\n \\\"token_type_ids\\\": batch[2],\\r\\n }\\r\\n\\r\\n example_indices = batch[3]\\r\\n\\r\\n outputs = model(**inputs)\\r\\n\\r\\n for i, example_index in enumerate(example_indices):\\r\\n eval_feature = features[example_index.item()]\\r\\n unique_id = int(eval_feature.unique_id)\\r\\n\\r\\n output = [to_list(output[i]) for output in outputs]\\r\\n\\r\\n start_logits, end_logits = output\\r\\n result = SquadResult(unique_id, start_logits, end_logits)\\r\\n all_results.append(result)\\r\\n\\r\\n output_prediction_file = \\\"predictions.json\\\"\\r\\n output_nbest_file = \\\"nbest_predictions.json\\\"\\r\\n output_null_log_odds_file = \\\"null_predictions.json\\\"\\r\\n\\r\\n predictions = compute_predictions_logits(\\r\\n examples,\\r\\n features,\\r\\n all_results,\\r\\n n_best_size,\\r\\n max_answer_length,\\r\\n do_lower_case,\\r\\n output_prediction_file,\\r\\n output_nbest_file,\\r\\n output_null_log_odds_file,\\r\\n False, # verbose_logging\\r\\n True, # version_2_with_negative\\r\\n null_score_diff_threshold,\\r\\n tokenizer,\\r\\n )\\r\\n\\r\\n return predictions\",\n \"def test_prepare_sample_to_forward(self):\\n sample = [\\n {\\\"src\\\": \\\"ola mundo\\\", \\\"ref\\\": \\\"hi world\\\", \\\"mt\\\": \\\"hey world!\\\", \\\"score\\\": 0.8},\\n {\\\"src\\\": \\\"ola mundo\\\", \\\"ref\\\": \\\"hi world\\\", \\\"mt\\\": \\\"hey world!\\\", \\\"score\\\": 0.8},\\n ]\\n\\n model_input, target = self.estimator.prepare_sample(sample)\\n model_output = self.estimator(**model_input)\\n self.assertTrue(model_output[\\\"score\\\"].shape[0] == 2)\\n self.assertTrue(model_output[\\\"score\\\"].shape[1] == 1)\",\n \"def predict(self, X_test, **kwargs):\\n\\n # Normalize inputs\\n if self.normalize_input:\\n X_, _, _ = zero_mean_unit_var_normalization(X_test, self.X_mean, self.X_std)\\n else:\\n X_ = X_test\\n\\n # Sample a number of predictions for each given point\\n # Generate mean and variance for each given point from sampled predictions\\n\\n X_ = torch.Tensor(X_)\\n self.model.eval()\\n Yt_hat = self.model(X_).data.cpu().numpy()\\n\\n if self.normalize_output:\\n Yt_hat = zero_mean_unit_var_denormalization(Yt_hat, self.y_mean, self.y_std)\\n\\n logger.debug(f\\\"Generated final outputs array of shape {Yt_hat.shape}\\\")\\n\\n return Yt_hat\",\n \"def __test_model(self, test, model, expected):\\n prediction = model.predict(test)\\n message = \\\"Prediction:\\\", *prediction, \\\"| Actual:\\\", expected\\n self.__logger.info(message)\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n y_pred = model.predict(X_test)\\n print(classification_report(Y_test, y_pred, target_names=category_names))\\n pass\",\n \"def test_predict_from_example_stream():\\n stream = ExampleStream('vw.stream.txt')\\n examples = []\\n for i in xrange(len(DATA)):\\n (value, all_sections) = DATA[i]\\n ex = VowpalExample(i, value)\\n for (namespace, section) in all_sections.items():\\n ex.add_section(namespace, section)\\n stream.add_example(ex)\\n train = examples[:-2]\\n test = examples[-2:]\\n vw = Vowpal(PATH_VW, './vw.%s', {'--passes' : '10' })\\n preds = vw.predict_from_example_stream(stream)\\n for (id, value) in preds:\\n print 'prediction for %s is %s' % (id, value)\",\n \"def evaluate_predictions(self, input_predictions, run_type, override_tags_roles=None):\\n out_dict = self.results[run_type]\\n # outer evaluation tags: model instances\\n outer = [t for t in self.tags if t.startswith(\\\"model\\\") and not t.endswith(defs.roles.inputs)]\\n inner = [t for t in self.tags if t in [defs.roles.train, defs.roles.val, defs.roles.test]]\\n\\n # collect indexes to across outer tags to produce, e.g. total <train> performance\\n total_idxs_inner = defaultdict(list)\\n has_multiple_models = len(outer) > 1\\n\\n for outer_tag in outer:\\n out_idx = self.indexes[self.tags.index(outer_tag)]\\n out_dict[outer_tag] = {}\\n\\n for inner_tag in inner:\\n # get prediction indexes\\n in_idx = self.indexes[self.tags.index(inner_tag)]\\n joint_idx = np.intersect1d(out_idx, in_idx)\\n current_predictions = input_predictions[joint_idx]\\n if len(current_predictions) == 0:\\n continue\\n\\n total_idxs_inner[inner_tag].append(joint_idx)\\n\\n out_dict[outer_tag][inner_tag] = {}\\n\\n for measure in self.available_measures:\\n result = self.evaluate_measure(current_predictions, joint_idx, measure, tag_info=(outer_tag, inner_tag))\\n out_dict[outer_tag][inner_tag][measure] = result\\n do_print = (not has_multiple_models) or self.should_print_this(run_type, outer_tag)\\n self.compute_additional_info(current_predictions, joint_idx, f\\\"{run_type}-{outer_tag}-{inner_tag}\\\", do_print=do_print)\\n\\n if has_multiple_models:\\n # aggregate\\n out_dict[\\\"all_tags\\\"] = {}\\n self.aggregate_tags(outer, inner, out_dict)\\n for o in total_idxs_inner:\\n self.compute_additional_info(input_predictions, np.concatenate(total_idxs_inner[o]), f\\\"{run_type}-{o}-all_tags\\\", do_print=not self.is_baseline_run(run_type))\\n print()\",\n \"def evaluate():\\n global_step = tf.Variable(0, name='global_step', trainable=False)\\n\\n # randomize the inputs look\\n x, y_, data, keep_prob = blood_model.prepare_input()\\n # Get images and labels for blood_model.\\n conv_output, W_conv1, W_conv2, h_conv1, h_conv2 = blood_model.inference(data, keep_prob)\\n conv_predictions = blood_model.predictions(conv_output)\\n\\n sess = tf.InteractiveSession()\\n\\n sess.run(tf.initialize_all_variables())\\n\\n saver = tf.train.Saver()\\n\\n ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)\\n if ckpt and ckpt.model_checkpoint_path:\\n # Restores from checkpoint\\n saver.restore(sess, ckpt.model_checkpoint_path)\\n # extract global_step from it.\\n global_step_number = int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])\\n print(\\\"checkpoint found at step %d\\\", global_step_number)\\n else:\\n print('No checkpoint file found')\\n return\\n\\n blood_dataset = np.load('../../labeller/data/wbc_p4-1_p.npy')\\n blood_dataset = np.transpose(blood_dataset, (0, 2, 3, 1))\\n predictions = sess.run(conv_predictions, feed_dict={x: blood_dataset, keep_prob: 1.0})\\n np.save('../results/predictions.npy', np.argmax(predictions, 1))\\n display_predictions(blood_dataset, np.argmax(predictions, 1))\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n for key, val in predictions.items():\\n predictions[key] = val.numpy()\\n\\n for key, val in expected.items():\\n expected[key] = val.numpy()\\n\\n return predictions, expected\",\n \"def ensemble_predictions(sampled_x,sampled_y,x_to_predict,top_models_name,top_models_params,n_to_average):\\n preds=[None for _ in range(n_to_average)]\\n for i in tqdm(range(n_to_average),desc=\\\"Ensemble models training\\\",\\n position=0,total=n_to_average,\\n leave=False, disable=False):\\n major_model,specific_model=top_models_name[i].split(';')\\n model = MldeModel(major_model, specific_model,\\n model_params=top_models_params[i],\\n training_params=DEFAULT_TRAINING_PARAMS[major_model],\\n eval_metric=mse)\\n model.train(sampled_x,sampled_y)\\n preds[i],_= model.predict(x_to_predict)\\n preds=np.array(preds)\\n # preds=np.mean(preds,axis=0)\\n return preds\",\n \"def predict(self, model, context, data):\\n pass\",\n \"def test_predict(self):\\n\\t\\tMY_TEST_MODEL = \\\"v1_rm500\\\"\\n\\t\\tx_test = np.genfromtxt(\\\"tests/data/ensg_input.txt\\\",delimiter=\\\"\\\\t\\\")\\n\\t\\tquery_localdirs = cancerscope.get_models.findmodel(os.path.dirname(cancerscope.__file__),MY_TEST_MODEL)\\n\\t\\tif query_localdirs is not None:\\n\\t\\t\\tmodel_in = query_localdirs[MY_TEST_MODEL]\\n\\t\\telse:\\n\\t\\t\\tmodel_in = cancerscope.get_models.downloadmodel(model_label=MY_TEST_MODEL)\\n\\t\\t\\n\\t\\t\\\"\\\"\\\"Compare results with what you get from 'getmodel()'\\\"\\\"\\\"\\n\\t\\tmodeldir_v1_rm500 = cancerscope.get_models.getmodel(model_label = MY_TEST_MODEL)\\n\\t\\tself.assertEqual(modeldir_v1_rm500[MY_TEST_MODEL][MY_TEST_MODEL], model_in)\\n\\t\\t\\n\\t\\t\\\"\\\"\\\"Test prediction\\\"\\\"\\\"\\n\\t\\tlmodel = cancerscope.scopemodel(model_in)\\n\\t\\tlmodel.fit()\\n\\t\\trandom_sample = np.nan_to_num(x_test[0:17688, 1].reshape(1,17688))\\n\\t\\tpred_testX = lmodel.predict(random_sample)[0][0][0]\\n\\t\\tself.assertEqual(pred_testX, \\\"ESCA_TS\\\")\\n\\t\\t\\n\\t\\tallpreds_testX = lmodel.predict(random_sample, get_all_predictions=True, get_numeric=False,get_predictions_dict=False)[0]\\n\\t\\tallpredsNumeric_testX = lmodel.predict(random_sample, get_all_predictions=True, get_numeric=True, get_predictions_dict=False)[0]\\n\\t\\t\\n\\t\\tself.assertEqual(len(allpreds_testX), 66)\\n\\t\\tself.assertEqual(len(allpredsNumeric_testX), 66)\\n\\t\\tself.assertEqual(allpreds_testX[0], \\\"BRCA_TS\\\")\\n\\t\\tself.assertTrue(isinstance(allpredsNumeric_testX[0], Number))\\n\\t\\t\\n\\t\\t\\\"\\\"\\\"Test if normalization works and is evaluated to correct floatpoint\\\"\\\"\\\"\\n\\t\\tnormalized_testX = lmodel.get_normalized_input(random_sample)[0]\\n\\t\\tself.assertEqual(normalized_testX[0],0.60640558591378269)\\t\\n\\t\\t\\n\\t\\t\\\"\\\"\\\"Test if Jacobian is evaluated correctly\\\"\\\"\\\"\\n\\t\\t#Mar19 keras noncompat#jacobian_test = lmodel.get_jacobian(random_sample)\\n\\t\\t#class0_highestjacobian = np.amax(jacobian_test[0,:])\\n\\t\\t#self.assertEqual(jacobian_test.shape[0], 66) ## Num rows = classes\\n\\t\\t#self.assertEqual(jacobian_test.shape[1], 17688) ## Num columns = genes\\n\\t\\t#self.assertAlmostEqual(class0_highestjacobian, 0.00012377805544766)\\n\\t\\t#END OF #Mar19 keras noncompat#\",\n \"def evaluate(x_sample, y_sample, batch_size=512):\\n\\n n = x_sample.shape[0]\\n correct_sample = 0\\n\\n for i in range(0, n, batch_size):\\n x_batch = x_sample[i: i + batch_size]\\n y_batch = y_sample[i: i + batch_size]\\n n_batch = x_batch.shape[0]\\n\\n feed = {\\n x: x_batch,\\n y: y_batch,\\n keep_prob: 1\\n }\\n\\n correct_sample += sess.run(accuracy, feed_dict=feed) * n_batch\\n\\n return correct_sample / n\",\n \"def evaluate_model(model,test_inputs,test_labels,model_mode):\\n\\n if model_mode == \\\"classification\\\":\\n y_pred = model.predict(test_inputs)\\n print(\\\"Accuracy score: \\\", accuracy_score(test_labels, y_pred))\\n #print(\\\"F1 score: \\\", f1_score(test_labels,y_pred, average='weighted'))\\n\\n conf_mx = confusion_matrix(test_labels, y_pred)\\n #print(conf_mx)\\n plt.matshow(conf_mx, cmap = plt.cm.jet)\\n plt.show()\\n\\n if model_mode == \\\"regression\\\":\\n y_pred = model.predict(test_inputs)\\n print(\\\"Mean absolute error: \\\", mean_absolute_error(test_labels, y_pred))\",\n \"def eval_model(data, model):\\n f = model.forward(data['image'])\\n loss = model.loss(f,data['label'])\\n\\n y_predict = model.predict(f)\\n\\n count = 0\\n for i in range(len(data['label'])):\\n if data['label'][i] == y_predict[i]:\\n count = count + 1\\n\\n acc = (count/len(data['label']))*100\\n\\n return loss, acc\",\n \"def evaluate_model(model, X_test, y_test, category_names):\\n # Predict for test set\\n y_pred = model.predict(X_test)\\n \\n print(\\\"**** Scores for each category *****\\\\n\\\")\\n for i in range(36):\\n print(\\\"Scores for '{}':\\\".format(category_names[i]))\\n print(classification_report(y_test.values[:,i], y_pred[:,i]))\",\n \"def sample_estimator(model, num_classes, train_loader):\\n import sklearn.covariance\\n\\n model.eval()\\n with torch.no_grad():\\n group_lasso = sklearn.covariance.EmpiricalCovariance(assume_centered=False)\\n correct, total = 0, 0\\n num_output = 1\\n num_sample_per_class = np.empty(num_classes)\\n num_sample_per_class.fill(0)\\n list_features = []\\n for i in range(num_output):\\n temp_list = []\\n for j in range(num_classes):\\n temp_list.append(0)\\n list_features.append(temp_list)\\n\\n for data, target in train_loader:\\n total += data.size(0)\\n data = data.cuda()\\n data = Variable(data)\\n output = model(data)['logits']\\n # output, out_features = out['logits'], out['logits']\\n\\n out_features = output.view(output.size(0), output.size(1), -1)\\n out_features = torch.mean(out_features, dim=2)\\n\\n # compute the accuracy\\n pred = output.data.max(1)[1]\\n equal_flag = pred.eq(target.cuda()).cpu()\\n correct += equal_flag.sum()\\n\\n # construct the sample matrix\\n for i in range(data.size(0)):\\n label = target[i]\\n out_count = 0\\n if num_sample_per_class[label] == 0:\\n list_features[out_count][label] = out_features[i].view(1, -1)\\n else:\\n list_features[out_count][label] \\\\\\n = torch.cat((list_features[out_count][label], out_features[i].view(1, -1)), 0)\\n num_sample_per_class[label] += 1\\n\\n sample_class_mean = []\\n out_count = 0\\n num_feature = num_classes\\n temp_list = torch.Tensor(num_classes, num_feature).cuda()\\n for j in range(num_classes):\\n temp_list[j] = torch.mean(list_features[out_count][j], dim=0)\\n sample_class_mean.append(temp_list)\\n\\n precision = []\\n for k in range(num_output):\\n X = 0\\n for i in range(num_classes):\\n if i == 0:\\n X = list_features[k][i] - sample_class_mean[k][i]\\n else:\\n X = torch.cat((X, list_features[k][i] - sample_class_mean[k][i]), dim=0)\\n\\n # find inverse\\n group_lasso.fit(X.cpu().numpy())\\n temp_precision = group_lasso.precision_\\n temp_precision = torch.from_numpy(temp_precision).float().cuda()\\n precision.append(temp_precision)\\n\\n print('\\\\n Training Accuracy:({:.2f}%)\\\\n'.format(100. * correct / total))\\n\\n return sample_class_mean, precision\",\n \"def run_prediction(data, sess, placeholders, scores): \\r\\n \\r\\n X, Y = data\\r\\n source_pl, target_pl, training_pl = placeholders\\r\\n split_set = int(math.floor(0.9*len(X))) # Value for spliting the set in 90% training / 10% test \\r\\n \\r\\n X_batch, Y_batch = batch(X[:split_set:], Y[:split_set:]) # Take a batch of sentences from the training set\\r\\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\\r\\n prediction = sess.run(scores, feed_dict=feed_dict) \\r\\n X_batch = np.squeeze(X_batch) \\r\\n prediction = np.squeeze(prediction)\\r\\n \\r\\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\\r\\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\\r\\n\\r\\n\\t# Print the pairs source -> target\\r\\n for source, target in zip(source_sentences, target_sentences): \\r\\n print(source + \\\" --> \\\" + target)\\r\\n \\r\\n print(\\\"================================================================\\\")\\r\\n \\r\\n X_batch, Y_batch = batch(X[split_set+1:], Y[split_set+1:]) # Take a batch of sentences from the test set\\r\\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\\r\\n prediction = sess.run(scores, feed_dict=feed_dict) \\r\\n \\r\\n X_batch = np.squeeze(X_batch) \\r\\n prediction = np.squeeze(prediction)\\r\\n \\r\\n \\r\\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\\r\\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\\r\\n\\r\\n\\t# Print the pairs source -> target\\r\\n for source, target in zip(source_sentences, target_sentences): \\r\\n print(source + \\\" --> \\\" + target)\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n y_pred_grid = model.predict(X_test)\\n print(\\n classification_report(Y_test.values, y_pred_grid, target_names=category_names)\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7101648","0.6955216","0.6852982","0.6852803","0.6742147","0.6641561","0.66390866","0.65709037","0.6543093","0.64913476","0.64873594","0.64872164","0.6486736","0.64565843","0.6448053","0.6428368","0.64260185","0.6417553","0.6416274","0.6413926","0.6411224","0.6409698","0.64068776","0.6378496","0.63699883","0.6369558","0.63618046","0.6350721","0.6322405","0.6316654","0.6316259","0.63148713","0.63130593","0.6308377","0.6307523","0.6304725","0.6302404","0.62917024","0.62859637","0.6281743","0.62745595","0.62731075","0.62663215","0.6264477","0.6263791","0.62615377","0.625348","0.62399757","0.62399673","0.6232015","0.6221754","0.6219247","0.62142766","0.6207796","0.6206931","0.61983335","0.61969364","0.6196437","0.6194695","0.61890894","0.6187917","0.6180852","0.6178034","0.6174983","0.61724466","0.61698943","0.6166503","0.6160151","0.6158405","0.6156335","0.6156004","0.61535394","0.6149943","0.6144615","0.6142966","0.6132847","0.6132709","0.6128929","0.6123742","0.61212707","0.6118991","0.6114514","0.61094725","0.61091363","0.61004025","0.6097638","0.6097243","0.60972005","0.6097079","0.6091813","0.6088396","0.60873675","0.60867137","0.6082232","0.60808545","0.6080677","0.60725254","0.6062745","0.60624725","0.60615635","0.6061246"],"string":"[\n \"0.7101648\",\n \"0.6955216\",\n \"0.6852982\",\n \"0.6852803\",\n \"0.6742147\",\n \"0.6641561\",\n \"0.66390866\",\n \"0.65709037\",\n \"0.6543093\",\n \"0.64913476\",\n \"0.64873594\",\n \"0.64872164\",\n \"0.6486736\",\n \"0.64565843\",\n \"0.6448053\",\n \"0.6428368\",\n \"0.64260185\",\n \"0.6417553\",\n \"0.6416274\",\n \"0.6413926\",\n \"0.6411224\",\n \"0.6409698\",\n \"0.64068776\",\n \"0.6378496\",\n \"0.63699883\",\n \"0.6369558\",\n \"0.63618046\",\n \"0.6350721\",\n \"0.6322405\",\n \"0.6316654\",\n \"0.6316259\",\n \"0.63148713\",\n \"0.63130593\",\n \"0.6308377\",\n \"0.6307523\",\n \"0.6304725\",\n \"0.6302404\",\n \"0.62917024\",\n \"0.62859637\",\n \"0.6281743\",\n \"0.62745595\",\n \"0.62731075\",\n \"0.62663215\",\n \"0.6264477\",\n \"0.6263791\",\n \"0.62615377\",\n \"0.625348\",\n \"0.62399757\",\n \"0.62399673\",\n \"0.6232015\",\n \"0.6221754\",\n \"0.6219247\",\n \"0.62142766\",\n \"0.6207796\",\n \"0.6206931\",\n \"0.61983335\",\n \"0.61969364\",\n \"0.6196437\",\n \"0.6194695\",\n \"0.61890894\",\n \"0.6187917\",\n \"0.6180852\",\n \"0.6178034\",\n \"0.6174983\",\n \"0.61724466\",\n \"0.61698943\",\n \"0.6166503\",\n \"0.6160151\",\n \"0.6158405\",\n \"0.6156335\",\n \"0.6156004\",\n \"0.61535394\",\n \"0.6149943\",\n \"0.6144615\",\n \"0.6142966\",\n \"0.6132847\",\n \"0.6132709\",\n \"0.6128929\",\n \"0.6123742\",\n \"0.61212707\",\n \"0.6118991\",\n \"0.6114514\",\n \"0.61094725\",\n \"0.61091363\",\n \"0.61004025\",\n \"0.6097638\",\n \"0.6097243\",\n \"0.60972005\",\n \"0.6097079\",\n \"0.6091813\",\n \"0.6088396\",\n \"0.60873675\",\n \"0.60867137\",\n \"0.6082232\",\n \"0.60808545\",\n \"0.6080677\",\n \"0.60725254\",\n \"0.6062745\",\n \"0.60624725\",\n \"0.60615635\",\n \"0.6061246\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":928,"numItemsPerPage":100,"numTotalItems":95772,"offset":92800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTU2MDc5NywianRpIjoiZDc3YzdmMzAtNThlZC00MjRmLWFjMTYtMTFjMWE0NWM0NmQzIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU1NjQzOTcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.LGgwacFn_aVXapOpXWVgEKXOEAscon3Wtq3v4laWO5zVAMP0KQQ2X0kVNqwntxuRX8v4dE4iupurjpOqFPlZCA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Update all of the properties of the lines to match those specified by the lines dictionaries. | def update_lines(self):
self._checkfigure()
for ld in self.lines:
line = ld['line']
color = ld['color']
line.set_color(color)
lw = ld['linewidth']
hlf = ld['highlight factor']
highlight = hlf if ld['highlighted'] else 1.0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_dict(self, lines):\n for line in lines:\n line = line.rstrip()\n split_line = line.split(\"\\t\")\n old_gene_id = split_line[0]\n new_gene_id = split_line[2]\n conv_dict = self.conversion_dict\n conv_dict[old_gene_id] = new_gene_id\n ... | [
"0.6635039",
"0.6558961",
"0.61416423",
"0.6050221",
"0.60437894",
"0.59587663",
"0.59425133",
"0.59164494",
"0.5850133",
"0.5814374",
"0.57916486",
"0.56902176",
"0.5680567",
"0.5630113",
"0.56012625",
"0.5566768",
"0.5527338",
"0.5511613",
"0.54785407",
"0.5465747",
"0.5459... | 0.66452 | 0 |
Change the scale of the x axis. | def xscale(self, newscale, linthreshx=1.e-4):
self._checkfigure()
if newscale == 'symlog':
self.axes.set_xscale(newscale, linthreshx=linthreshx)
else:
self.axes.set_xscale(newscale) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xscale(self, kind):\n self._xscale = str(kind).strip() # remove whitespace eventually\n if self._xscale not in self.xscaling():\n self._xscale = self.xscaling(1)",
"def setScaleX(self,startx,endx):\r\n if startx == endx:\r\n endx += 1\r\n self.scaleLock.acqui... | [
"0.75162244",
"0.749704",
"0.74579763",
"0.7220122",
"0.69459987",
"0.6915198",
"0.6820812",
"0.6799988",
"0.6794418",
"0.6695604",
"0.6602468",
"0.6586427",
"0.653044",
"0.65237784",
"0.6494618",
"0.6494618",
"0.6425369",
"0.64223045",
"0.6365275",
"0.63600373",
"0.63461554"... | 0.7631463 | 0 |
Change the scale of the y axis. | def yscale(self, newscale, linthreshy=1.e-4):
self._checkfigure()
if newscale == 'symlog':
self.axes.set_yscale(newscale, linthreshy=linthreshy)
else:
self.axes.set_yscale(newscale) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yscale(self, value='linear'):\r\n for ax in self._subaxes:\r\n ax.set_yscale(value)\r\n self.figure.canvas.draw()",
"def setScaleY(self,starty,endy):\r\n if starty == endy:# Prevent /0 errors when scaling\r\n endy += 0.1\r\n self.scaleLock.acquire()\r\n ... | [
"0.83540624",
"0.7639247",
"0.76304406",
"0.7609599",
"0.7424399",
"0.7308757",
"0.7259377",
"0.72316325",
"0.7127579",
"0.7097566",
"0.7009638",
"0.6943726",
"0.69134957",
"0.6899598",
"0.6857216",
"0.6814696",
"0.67792916",
"0.6751122",
"0.6750558",
"0.67136586",
"0.6713658... | 0.77396965 | 1 |
Automatically adjusts the range of the x and y axes to fit the data. | def autorange(self):
self._checkfigure()
self.axes.autoscale_view(True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _use_data_bounds_changed_for_axes(self):\n self.update_pipeline()",
"def auto_adjust_axes(self, *args):\n\n xmin, xmax = self.axes.get_xlim()\n ymin, ymax = self.axes.get_ylim()\n self.adjust_axes(xmin, ymin, xmax, ymax)",
"def fix_auto(self):\n if self.share_x:\n ... | [
"0.73429817",
"0.7191217",
"0.6581325",
"0.6449581",
"0.6447283",
"0.6441026",
"0.6410359",
"0.63285774",
"0.63280755",
"0.6320955",
"0.63067925",
"0.6260221",
"0.62177235",
"0.61656487",
"0.6165544",
"0.6160994",
"0.6160898",
"0.6155022",
"0.61368674",
"0.6122708",
"0.606950... | 0.0 | -1 |
Set the x label. | def xlabel(self, xlabel):
self._checkfigure()
self.axes.set_xlabel(xlabel) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xlabel(self, xlabel: str):\n\n self.ax.set_xlabel(xlabel)\n self.canvas.draw()",
"def set_label(self, x=None, y=None):\n\n if x:\n self.axes.set_xlabel(x)\n if y:\n self.axes.set_ylabel(y)",
"def xaxis(self,label,units):\r\n if units != \"\": label =... | [
"0.83227915",
"0.78510827",
"0.768761",
"0.763404",
"0.71824145",
"0.71818656",
"0.71470004",
"0.71255195",
"0.7057654",
"0.7001613",
"0.6981948",
"0.6973022",
"0.6868358",
"0.68305385",
"0.68288565",
"0.68243974",
"0.6804483",
"0.67813873",
"0.67813873",
"0.67813873",
"0.676... | 0.8380205 | 0 |
Set the y label. | def ylabel(self, ylabel):
self._checkfigure()
self.axes.set_ylabel(ylabel) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setYLabel(self, label):\n self.__y_label__ = label",
"def ylabel(self, ylabel: str):\n self.ax.set_ylabel(ylabel)\n self.canvas.draw()",
"def yaxis(self,label,units):\n if units != \"\": label = label + \" (\" + units + \")\"\n self.subplot.set_ylabel(label)\n pass... | [
"0.9190329",
"0.86456215",
"0.79426026",
"0.78730667",
"0.7797612",
"0.7762227",
"0.7726272",
"0.7642364",
"0.7614121",
"0.7587614",
"0.7587614",
"0.75765777",
"0.75309575",
"0.7481715",
"0.7420434",
"0.7352702",
"0.72147393",
"0.71600896",
"0.71437305",
"0.71182877",
"0.7114... | 0.8489198 | 2 |
Save a figure to disk with the specified filename. | def savefig(self, filename, dpi=300):
self._checkfigure()
self.figure.savefig(filename, dpi=dpi) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_fig(fig, filename):\n fig_filepath = figures_path / filename\n fig.write_image(str(fig_filepath))\n logging.info(f\"Written figure to {fig_filepath.resolve()}\")",
"def save(file_name):\n setup()\n plt.savefig(file_name)",
"def _save_mpl_figure(self, fig, filename, **kwargs):\n\n ... | [
"0.83919364",
"0.81133604",
"0.803917",
"0.7967601",
"0.7860805",
"0.7696905",
"0.7623614",
"0.758016",
"0.7493179",
"0.74178004",
"0.7385424",
"0.7373886",
"0.7336211",
"0.7331587",
"0.732086",
"0.7289239",
"0.7277271",
"0.72658956",
"0.72639364",
"0.7245444",
"0.7184908",
... | 0.7356999 | 12 |
Show and redraw the figure. Generally not useful if HKEPlotter is being used to serve up figures to a different frontend, but is useful for interactive use of HKEPlotter on its own. | def draw(self):
self.figure.show()
self.figure.canvas.draw() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_figure(self):\n\n self.draw()",
"def show_figure(self):\n pylab.show()",
"def redraw(self):\n dummy_figure = plt.figure()\n new_manager = dummy_figure.canvas.manager\n new_manager.canvas.figure = self.figure\n self.figure.set_canvas(new_manager.canvas)\n ... | [
"0.7442054",
"0.72985405",
"0.72740227",
"0.7139864",
"0.7054566",
"0.70101815",
"0.6959752",
"0.6950756",
"0.68631804",
"0.68610996",
"0.68610996",
"0.68610996",
"0.6855939",
"0.66993093",
"0.668948",
"0.668948",
"0.65383893",
"0.64258283",
"0.6350744",
"0.63269967",
"0.6323... | 0.7369711 | 1 |
Create and get database session. | async def get_db_session(request: Request) -> AsyncGenerator[AsyncSession, None]:
session: AsyncSession = request.app.state.db_session_factory()
try: # noqa: WPS501
yield session
finally:
await session.commit()
await session.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dbsession(cls):\n sqlahelper = cls.dbsqlahelper\n return sqlahelper.getmake_session()",
"def get_or_create_session(db):",
"def get_db():\n if not hasattr(g, 'Session'):\n Session, engine = db_connect(database_path=app.config['DATABASE_PATH'],\n en... | [
"0.8232138",
"0.81293833",
"0.78142273",
"0.7806508",
"0.77904016",
"0.7696183",
"0.7656676",
"0.76449305",
"0.7638493",
"0.76233536",
"0.7606411",
"0.7503729",
"0.7498254",
"0.7467674",
"0.745921",
"0.7457411",
"0.7410705",
"0.7404447",
"0.7404092",
"0.7368332",
"0.73582894"... | 0.68070346 | 63 |
Grabbing category pages from UPD. | def parse(self, response, **kwargs):
categories = response.xpath("//ul[@id='navcat']//a[contains(@href,'catid')]/@href").extract()
yield from response.follow_all(categories, self.parse_details) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_category(self, response):\n print(response.url)\n \n yield None\n #current_url = response.url\n #for i in range(1, number_of_pages + 1):\n # yield scrapy.Request(url='%s?page=%d' % (current_url, i), callback=self.parse_page)",
"def category_index(request, sl... | [
"0.64237756",
"0.63790303",
"0.6375456",
"0.6321574",
"0.62103164",
"0.6167238",
"0.60869426",
"0.6016122",
"0.592989",
"0.5928638",
"0.59256095",
"0.5907109",
"0.58935356",
"0.5876387",
"0.5860246",
"0.58479667",
"0.5836295",
"0.57793176",
"0.5769943",
"0.57407695",
"0.57292... | 0.5636073 | 24 |
Grabbing items from a category page. | def parse_details(self, response):
items = response.xpath("//*[@id='all']//div[@class='prdct-box']")
for i in items:
image_url = response.urljoin(i.xpath(".//div[@class='prdct-box1']/a[1]/@href").get())
description = i.xpath(".//div[@class='prdct-box2']//a[1]/text()").get()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_parsing_category(self, response):\n # ### First thing to do is to get the # of pages in the category.\n # Note: suppose a category has 189 entries. There are 48 entries per page.\n # 189 / 48 = 3.93. There are 4 pages. Therefore, deploy a ceil() function.\n #\n path_to_... | [
"0.6977426",
"0.6966306",
"0.69649124",
"0.6818274",
"0.675134",
"0.6723163",
"0.67167073",
"0.66166425",
"0.65816635",
"0.6577138",
"0.65685225",
"0.65192044",
"0.6517263",
"0.6489112",
"0.64841604",
"0.6424634",
"0.6419997",
"0.63991076",
"0.6374411",
"0.63453954",
"0.63298... | 0.0 | -1 |
Parse a string containing a CIGAR string. Converts it into a suitable format for the other functions of this module >>> CIGAR.fromString("5M20I2M5D").toList() [(5, 'M'), (20, 'I'), (2, 'M'), (5, 'D')] >>> CIGAR.fromString("").toList() [''] >>> CIGAR.fromString("").toList() [] >>> CIGAR.fromString("4F") | def fromString(cls, string):
# From SAM specification v1.5, slightly adapted for single-token parsing
pattern = r"^[0-9]+[MIDNSHPX=]"
string = string.strip()
if string == '*':
return CIGAR.fromList(['*'])
parsed = []
s = string
# Parse string token (e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_string_to_listint(string):\n\tstring = string.split()\n\tlength = len(string)\n\tnewlist = []\n\tfirst = int (string[0])\n\tsecond = int (string[1])\n\tthird = int (string[2])\n\tforth = int (string[3])\n\tfifth = int (string[4])\n\tnewlist.append(first)\n\tnewlist.append(second)\n\tnewlist.append(third)... | [
"0.61173743",
"0.5562493",
"0.5561425",
"0.550409",
"0.5474138",
"0.5468441",
"0.54449433",
"0.54384106",
"0.54120386",
"0.54009825",
"0.5395243",
"0.5395102",
"0.535296",
"0.53439724",
"0.52883965",
"0.52763444",
"0.5264064",
"0.52568686",
"0.5254977",
"0.52531236",
"0.52431... | 0.71512187 | 0 |
>>> str(CIGAR.fromList([(4,'M')])) '4M' >>> str(CIGAR.fromList([(4,'M'),(3,'I')])) '4M3I' >>> str(CIGAR.fromList([(3,'M'),(3,'M')])) '6M' | def fromList(cls, list):
obj = CIGAR()
if list == ['*']:
obj._tokens = '*'
else:
if not all( type(e) == tuple
and len(e) == 2
and type(e[0]) == int
and e[0] >= 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_string(self):\n\n return '[%s], [%s]' % \\\n (', '.join(str(x) for x in self.pot),\n ', '.join(INT2STRING_CARD[p] for p in self.pub))",
"def get_atril_string(self):\n return \", \".join(str(item) for item in self.atril)",
"def convert_int_encoded_cards_to_str_encoded... | [
"0.59029216",
"0.56521",
"0.56327",
"0.5588273",
"0.55033386",
"0.54973626",
"0.5496627",
"0.5454236",
"0.544231",
"0.53954923",
"0.5380563",
"0.5378427",
"0.53657615",
"0.5361758",
"0.5347632",
"0.534503",
"0.530223",
"0.526734",
"0.52624476",
"0.52619827",
"0.52292615",
"... | 0.52328736 | 20 |
Convert a CIGAR string object >>> str(CIGAR.fromList([(3,'I'),(14,'M')])) '3I14M' >>> str(CIGAR.fromString('')) '' | def __str__(self):
if self._tokens == '*' or self._tokens == '':
return self._tokens
self.compact()
return "".join(str(s[0])+s[1] for s in self._tokens) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fromString(cls, string):\n # From SAM specification v1.5, slightly adapted for single-token parsing\n pattern = r\"^[0-9]+[MIDNSHPX=]\" \n string = string.strip()\n if string == '*':\n return CIGAR.fromList(['*'])\n parsed = []\n s = string\n # Parse ... | [
"0.64767164",
"0.5503787",
"0.54652095",
"0.51764154",
"0.49903855",
"0.49820456",
"0.48756266",
"0.47967613",
"0.47786036",
"0.47597682",
"0.4754142",
"0.47428882",
"0.47245598",
"0.47059748",
"0.4688669",
"0.46815938",
"0.46791205",
"0.4638526",
"0.4637253",
"0.4633566",
"0... | 0.0 | -1 |
Join duplicate tokens together. This is done automatically before printing and does not need to be explicitly called in normal operation >>> c = CIGAR.fromList([]) >>> c._tokens = [(2,'M'),(3,'I'),(4,'M'),(3,'M')] >>> c.compact() >>> c._tokens [(2, 'M'), (3, 'I'), (7, 'M')] >>> c = CIGAR.fromList([]) >>> c._tokens = [(... | def compact(self):
if self._changed == False:
return
t = self._tokens
if t in [[], '*']:
return
# Tokens which can be reordered and joined if juxtapoxed.
# E.g. 3I3D3I --> 3D6I
freeToks = ['I','D']
iFirstFree = None
for i in rang... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def CompactTokens(self):\n map = {}\n for token_ in self.tokens_:\n hash_string = token_.EncodeForHash()\n try: map[hash_string].append(token_)\n except KeyError: map[hash_string] = [token_]\n ntokens = []\n keys = map.keys()\n keys.sort()\n for k in keys:\n token_ = map[k][0]... | [
"0.6678322",
"0.59820163",
"0.56799006",
"0.5620844",
"0.5576293",
"0.55237937",
"0.5503982",
"0.52999336",
"0.5281514",
"0.520811",
"0.520811",
"0.520811",
"0.520811",
"0.5125486",
"0.5053332",
"0.5034395",
"0.5030067",
"0.5002936",
"0.49746132",
"0.49096557",
"0.48882848",
... | 0.7703922 | 0 |
Change this CIGAR string, starting at base `at` (integer) by | def operationAt(self, op, n, at):
self._changed = True
bpTokenStart = 0 # in bp (base pairs)
# iToken and tokenLength are used ouside of loop
for iStartToken,tokenLength in enumerate(t[0] for t in self._tokens):
if bpTokenStart + tokenLength > at: break
bpTokenSt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def str_fill(i, n):\r\n return str(i).zfill(n)",
"def string(self,pos_0,pos_1,n):\r\n n=int(n)\r\n if pos_0 <10:\r\n pos_0=\"00\"+str(pos_0)\r\n elif pos_0<100:\r\n pos_0=\"0\"+str(pos_0)\r\n\r\n if n <10:\r\n n=\"0\"+str((n))\r\n \r\n\r\n\r\... | [
"0.59899414",
"0.58692604",
"0.5826843",
"0.5657849",
"0.55905974",
"0.5525048",
"0.54885286",
"0.5405841",
"0.53604394",
"0.53604394",
"0.53569674",
"0.53217363",
"0.5308425",
"0.52913743",
"0.5268704",
"0.5261682",
"0.52560335",
"0.5253637",
"0.52421796",
"0.5230379",
"0.52... | 0.49945837 | 44 |
Changes the token t1 by an operation t2. Both t1 and t2 are of the format (N, X) where N is an integer and X is a onechar string out of "MIDNSHPX=". Its meaning is that of a CIGAR string 'NX' p is an integer giving the position (relative to t1) where to change the CIGAR string t1 by the operation t2. The function retur... | def _mutateToken(t1, p, t2):
if not isinstance(p, int):
raise ValueError("p must be integer")
if(p < 0):
raise ValueError("p may not be smaller than 0")
if(p > t1[0]-1):
raise ValueError("p may not be larger than t1 length - 1")
x1 = t1[1] # Type o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def operationAt(self, op, n, at):\n self._changed = True\n\n bpTokenStart = 0 # in bp (base pairs)\n # iToken and tokenLength are used ouside of loop\n for iStartToken,tokenLength in enumerate(t[0] for t in self._tokens):\n if bpTokenStart + tokenLength > at: break\n ... | [
"0.5909464",
"0.54508114",
"0.5353232",
"0.53109324",
"0.5183065",
"0.5157569",
"0.51135975",
"0.50226814",
"0.4987378",
"0.49470899",
"0.49032512",
"0.48813334",
"0.48719415",
"0.4846766",
"0.48339766",
"0.47886705",
"0.47811374",
"0.47744894",
"0.47724745",
"0.4759226",
"0.... | 0.80241114 | 0 |
normalize col and row number for all board size by taking the floor of event's x and y coords as col and row, respectively | def floor_of_row_col(self, col, rw):
col_flr = col // self.sq_size
rw_flr = rw // self.sq_size
return col_flr, rw_flr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resizeEvent(self, event):\n # gets nearest width/height divisible by cell length\n nearest_w = event.size().width() // Config.CELL_LENGTH\n nearest_h = event.size().height() // Config.CELL_LENGTH - 1\n \n Config.NUM_CELLS_X = nearest_w\n Config.NUM_CELLS_Y = nearest_h\... | [
"0.6193175",
"0.61367476",
"0.59963244",
"0.59421545",
"0.57849133",
"0.5775196",
"0.57631814",
"0.57459",
"0.5720018",
"0.5627904",
"0.5625103",
"0.56076854",
"0.55925536",
"0.55625093",
"0.5556446",
"0.5548683",
"0.5542725",
"0.553251",
"0.55263674",
"0.54682046",
"0.545060... | 0.5631687 | 9 |
finding coords in a 9sq grid | def find_coords_of_selected_sq(self, evt):
# saves row and col tuple into two variables
column, row = self.get_row_col(evt)
# normalize for all square size by keeping the floor
column_floor, row_floor = self.floor_of_row_col(column, row)
corner_column = (column_floor * self.sq_s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def grid_points(self):\n for i in range(self.rows):\n for j in range(self.cols):\n min_lat,max_lat,min_lon,max_lon = self.coords_to_min_max_lat_lon((i,j))\n if i == 0:\n print_gps(max_lat,max_lon,\"grid\")\n if j == 0:\n ... | [
"0.7066006",
"0.6986872",
"0.6782247",
"0.67565817",
"0.6611911",
"0.6550267",
"0.65442395",
"0.65442395",
"0.6534613",
"0.6534613",
"0.6530289",
"0.65220416",
"0.6475809",
"0.6464717",
"0.64588034",
"0.64530015",
"0.6443492",
"0.6440157",
"0.64399004",
"0.64394623",
"0.64171... | 0.0 | -1 |
No sigmoid in forward because we are going to use BCEWithLogitsLoss Which applies sigmoid for us when calculating a loss | def forward(self, inputs):
x, meta = inputs
features = self.arch(x)
if self.n_meta_features:
meta_features = self.meta(meta)
features = torch.cat((cnn_features, meta_features), dim=1)
return self.ouput(features) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward_propagate(self, x):\n self.z_h = np.dot( x, self.w_ih ) + self.b_h\n #Activations of hidden layer\n self.a_h = self.sigmoid( self.z_h )\n self.z_o = np.dot( self.a_h, self.w_ho ) + self.b_o\n #yEst = activations of output layer\n yEst = self.sigmoid( self.z_o )... | [
"0.718558",
"0.7111254",
"0.70874214",
"0.70765215",
"0.7072784",
"0.703616",
"0.7004094",
"0.70040655",
"0.6996144",
"0.69507974",
"0.69271636",
"0.69134355",
"0.68908584",
"0.6888275",
"0.68787265",
"0.6857336",
"0.68468887",
"0.68463176",
"0.6829951",
"0.6828119",
"0.68076... | 0.0 | -1 |
Set the default values for the configs sections. | def build_config(self, config):
config.setdefaults('Makesmith Settings', {'COMport': 'COM5', 'xPitch': 20, 'openFile': " "}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_config_all_to_defaults():\n logging.debug(\"Creating default config\")\n for section in all_defaults:\n set_config_section_to_defaults(section)\n global config_changed\n config_changed = True",
"def set_default_configs(self):\n\n raise Exception(\"Child classes must override set... | [
"0.7351159",
"0.7339281",
"0.72598445",
"0.7222325",
"0.7089661",
"0.70572126",
"0.6905622",
"0.6813617",
"0.6731078",
"0.6685258",
"0.6658991",
"0.6594983",
"0.659285",
"0.6589595",
"0.6574724",
"0.65554917",
"0.65229684",
"0.6500052",
"0.64604515",
"0.6447857",
"0.6442133",... | 0.5929824 | 68 |
Add custom section to the default configuration object. | def build_settings(self, settings):
settings.add_json_panel('Makesmith Settings', self.config, data=self.json) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def configure(self, section):",
"def add_section(self, name, **defaults):\n if name in self._config_obj and not isinstance(self._config_obj[name], Section):\n raise SectionError(\"Cannot override value with section.\")\n if name not in self._config_obj:\n self._config_obj[name... | [
"0.6948539",
"0.6916051",
"0.65798974",
"0.65221095",
"0.64149725",
"0.6406309",
"0.6323181",
"0.6323181",
"0.6278571",
"0.61800945",
"0.61796504",
"0.61749244",
"0.60594046",
"0.5995549",
"0.59369934",
"0.59015507",
"0.58119464",
"0.572047",
"0.57180816",
"0.56477875",
"0.56... | 0.0 | -1 |
Respond to changes in the configuration. | def on_config_change(self, config, section, key, value):
if section == "Makesmith Settings":
if key == "COMport":
self.data.comport = value
elif key == 'xPitch':
print "xPitch changed" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conf_update(self):\n pass",
"def _on_config_changed(self, _):\n self._configure_pod()",
"def check_update(self):\r\n with open('new_config.json', 'rt') as jsonfile:\r\n configuration = jsonfile.read()\r\n configuration_data = json.loads(configuration)\r\n with ... | [
"0.72056526",
"0.66558397",
"0.6500768",
"0.64954627",
"0.6412859",
"0.6325383",
"0.62285906",
"0.61843014",
"0.6140129",
"0.61337703",
"0.6130938",
"0.6104602",
"0.6017188",
"0.60130835",
"0.5995604",
"0.5976737",
"0.59728676",
"0.595852",
"0.5947268",
"0.5928649",
"0.589380... | 0.555047 | 59 |
Finds the minimum number of points required so that each segment contains at least one marked point. | def optimal_points(segments):
points = []
segments.sort(key=lambda x: x.end)
while len(segments) != 0:
s = segments[0]
points.append(s.end)
j = 0
while j < len(segments):
temp = segments[j]
if temp.start <= s.end and temp.end >= s.end:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def required_points(self):\n req_points = self.min_performance * self.initial_available_points()\n return np.maximum(0, np.int64(np.ceil(req_points)))",
"def get_minimum_number_of_data_points(cls):\n return cls._MINIMUM_NUMBER_OF_DATA_POINTS",
"def count_segments(markers) -> int:\n cnt = ... | [
"0.6540888",
"0.6392515",
"0.6236526",
"0.6167579",
"0.61282146",
"0.61146337",
"0.60847116",
"0.60146016",
"0.5985607",
"0.5973496",
"0.5965992",
"0.5892332",
"0.5892332",
"0.58477896",
"0.58179706",
"0.5793226",
"0.57863146",
"0.5763089",
"0.57490504",
"0.57437086",
"0.5736... | 0.61889994 | 3 |
Set up 1Wire integrations. | async def async_setup(hass, config):
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.raw_wires = PyWires.WireNetwork();\n self.__initialize_wires();",
"def startup( self ):\n # ---- Setup UPNPC ----\n if self.config.neuron.use_upnpc:\n bittensor.logging.success(prefix = 'Set upnpc', sufix = '<green>ON</green>')\n try:\n... | [
"0.60688394",
"0.5936431",
"0.58194745",
"0.58194745",
"0.5771031",
"0.5715141",
"0.5670098",
"0.5669543",
"0.5668779",
"0.5655381",
"0.56505156",
"0.5618671",
"0.56069756",
"0.55828696",
"0.55751944",
"0.55751944",
"0.55751944",
"0.55751944",
"0.55751944",
"0.55751944",
"0.5... | 0.0 | -1 |
Set up a 1Wire proxy for a config entry. | async def async_setup_entry(hass: HomeAssistantType, config_entry: ConfigEntry):
hass.data.setdefault(DOMAIN, {})
onewirehub = OneWireHub(hass)
try:
await onewirehub.initialize(config_entry)
except CannotConnect as exc:
raise ConfigEntryNotReady() from exc
hass.data[DOMAIN][config_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def configureProxy():\n # config\n port = config.get(\"proxy\", \"port\")\n allowedDomains = config.get(\"proxy\", \"alloweddomains\")\n listeningIP = config.get(\"hotspot\", \"ip\")\n # wan dns\n proxyNSConfig = \"\"\n for dnsServer in wandns:\n proxyNSConfig = f\"{proxyNSConfig}nserve... | [
"0.66180223",
"0.62802416",
"0.61690414",
"0.6010491",
"0.5921584",
"0.5850278",
"0.57319605",
"0.57271814",
"0.57271814",
"0.5701102",
"0.56759375",
"0.56625265",
"0.5626089",
"0.5621118",
"0.5605153",
"0.5568972",
"0.5554984",
"0.55459726",
"0.55438066",
"0.55358803",
"0.55... | 0.0 | -1 |
Unload a config entry. | async def async_unload_entry(hass: HomeAssistantType, config_entry: ConfigEntry):
unload_ok = all(
await asyncio.gather(
*[
hass.config_entries.async_forward_entry_unload(config_entry, component)
for component in SUPPORTED_PLATFORMS
]
)
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def async_unload_entry(hass, config_entry):\n unload_ok = await hass.config_entries.async_forward_entry_unload(\n config_entry, \"climate\"\n )\n return unload_ok",
"async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:\n hass.data.pop(DOMAIN)\n return True",
... | [
"0.697284",
"0.6888074",
"0.6779855",
"0.6747459",
"0.6689002",
"0.6657831",
"0.66162205",
"0.6603433",
"0.65925974",
"0.65595686",
"0.65411645",
"0.6507643",
"0.6507643",
"0.6507643",
"0.6507643",
"0.64977276",
"0.64931643",
"0.6486601",
"0.6486601",
"0.6486601",
"0.6486601"... | 0.64135826 | 39 |
Select peaks that follow a particular pattern for merge The table passed in will be cut in place. | def chopnod_sort(self, table):
if not isinstance(table, Table):
return
elif None in [self.chopdist, self.noddist]:
return
elif 'xcentroid' not in table.columns or \
'ycentroid' not in table.columns:
return
dist = np.sqrt((self.chopdist ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_peaks(peak_table, ref_distance_map, ref_distance_indexmap, output='./extend_100_10/'):\n peaks = open(peak_table, 'r')\n info = peaks.readlines()\n peaks.close()\n\n results = []\n\n for line in info:\n line = line.strip()\n line = line.split('\\t')\n if line[1] == \"... | [
"0.63739586",
"0.605613",
"0.5531051",
"0.54668343",
"0.5459717",
"0.5381175",
"0.5375321",
"0.5363828",
"0.53531426",
"0.5348113",
"0.5344547",
"0.53287023",
"0.5325218",
"0.5281158",
"0.5273783",
"0.5266891",
"0.52546704",
"0.5208344",
"0.51937574",
"0.5186177",
"0.51843375... | 0.0 | -1 |
Initial search for peaks in the image | def search_peaks(self, image):
table = Table()
if not isinstance(image, np.ndarray):
return table
search_image = image
if self.smooth:
with catch_warnings():
simplefilter('ignore')
search_image = convolve_fft(
s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def detect_peaks(image):\r\n\r\n # define an 8-connected neighborhood\r\n neighborhood = ndimage.morphology.generate_binary_structure(2,2)\r\n\r\n #apply the local maximum filter; all pixel of maximal value \r\n #in their neighborhood are set to 1\r\n local_max = ndimage.filters.maximum_filter(image... | [
"0.7422308",
"0.7376325",
"0.7278992",
"0.71904063",
"0.71288425",
"0.6954977",
"0.690354",
"0.68966377",
"0.67058456",
"0.66651887",
"0.6639898",
"0.66282046",
"0.6626508",
"0.6614091",
"0.65927845",
"0.6578624",
"0.65582496",
"0.65490305",
"0.651271",
"0.6481589",
"0.64671"... | 0.736257 | 2 |
Refine table contents with a fit on the image The table is modified in place. | def refine_table(self, image, table):
if table is None or len(table) == 0 or \
not isinstance(image, np.ndarray):
return
x0, y0 = np.mgrid[-self.ncut:self.ncut, -self.ncut:self.ncut]
model_g = models.Gaussian2D(
1.0, self.ncut, self.ncut,
x_st... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def complete_images_table(self, table):\r\n # Variable initialization\r\n cmp_double = 0\r\n cmp_img = 0\r\n\r\n # Connection to database\r\n conn, cursor = connection_database(self.db_name, self.host, self.user, self.password, self.local, self.ssl_ca)\r\n\r\n # Get images... | [
"0.5431792",
"0.5344389",
"0.51285285",
"0.5111027",
"0.5101912",
"0.5088771",
"0.5080382",
"0.50031626",
"0.49684134",
"0.4954868",
"0.49354628",
"0.4919202",
"0.4917076",
"0.48899812",
"0.48867348",
"0.48697388",
"0.48675102",
"0.48475635",
"0.4847346",
"0.48268786",
"0.481... | 0.7310207 | 0 |
Find peaks (stars) in FORCAST images Identifies the desired number of peaks in the image using the DAO search algorithm followed by optional (default=True) Levenberg Marquardt least squares fitting of a gaussian psf to refine the fit. | def peakfind(coadded, newimage=None,
refine=True, npeaks=4, fwhm=4.5,
sharplo=0.2, sharphi=1.0,
roundlo=-0.75, roundhi=0.75,
silent=False, maxiter=1000,
epsilon=5, eps=1e-7, ncut=30,
chopnoddist=None,
positive=False,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def peakFinder(self, fit_peaks_image):\n if self.check_mode:\n tifffile.imsave(\"fit_peaks.tif\", fit_peaks_image.astype(numpy.float32))\n\n # Calculate background variance.\n #\n # Notes:\n #\n # 1. The assumption here is that we are working in units of photo-e... | [
"0.6971431",
"0.695021",
"0.6889149",
"0.6687948",
"0.6558322",
"0.62923485",
"0.6172872",
"0.6101547",
"0.6086589",
"0.60263014",
"0.60255814",
"0.5992918",
"0.5991013",
"0.5968996",
"0.5959041",
"0.59579647",
"0.5947159",
"0.5904097",
"0.5867966",
"0.58373225",
"0.58348125"... | 0.5402981 | 66 |
Initialize the RAMSTKWorkView metaclass. | def __init__(self, controller, **kwargs):
_module = kwargs['module']
gtk.HBox.__init__(self)
ramstk.RAMSTKBaseView.__init__(self, controller, module=_module)
self._module = None
for __, char in enumerate(_module):
if char.isalpha():
self._module = _mo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, controller, **kwargs): # pylint: disable=unused-argument\n RAMSTKWorkView.__init__(self, controller, module='Function')\n\n # Initialize private dictionary attributes.\n\n # Initialize private list attributes.\n self._lst_assess_labels[1].append(_(u\"Total Mode Count... | [
"0.6240101",
"0.59596485",
"0.579034",
"0.5773658",
"0.5769354",
"0.5749818",
"0.56876385",
"0.56521547",
"0.5582976",
"0.555983",
"0.55574834",
"0.5523128",
"0.5515693",
"0.5504477",
"0.55011004",
"0.54869395",
"0.5480955",
"0.5474198",
"0.5460474",
"0.54480135",
"0.5437854"... | 0.64453584 | 0 |
Create the gtk.Notebook() page for displaying assessment results. | def _make_assessment_results_page(self):
_hbox = gtk.HBox()
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# Build the left half of the page. #
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
_fx... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_assessment_results_page(self, notebook):\r\n\r\n _hbox = gtk.HBox()\r\n\r\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\r\n # Build the left half of the page. #\r\n # +++++++++++++++++++++++++++++++++++++++++++++... | [
"0.8329622",
"0.7571663",
"0.72755533",
"0.71898496",
"0.7028935",
"0.6892961",
"0.6792773",
"0.6667084",
"0.66336125",
"0.64590913",
"0.64258105",
"0.6100222",
"0.6006352",
"0.59311277",
"0.58841544",
"0.5749062",
"0.5729164",
"0.5685445",
"0.5673195",
"0.5663004",
"0.563122... | 0.76316273 | 1 |
Respond to load the Work View gtk.Notebook() widgets. This method handles the results of the an individual module's _on_select() method. It sets the title of the RAMSTK Work Book and raises an error dialog if needed. | def on_select(self, **kwargs):
_title = kwargs['title']
_error_code = kwargs['error_code']
_user_msg = kwargs['user_msg']
_debug_msg = kwargs['debug_msg']
try:
_workbook = self.get_parent().get_parent()
_workbook.set_title(_title)
except Attribute... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, controller, **kwargs):\n _module = kwargs['module']\n gtk.HBox.__init__(self)\n ramstk.RAMSTKBaseView.__init__(self, controller, module=_module)\n\n self._module = None\n for __, char in enumerate(_module):\n if char.isalpha():\n self.... | [
"0.5903212",
"0.5611034",
"0.5532166",
"0.5440121",
"0.5369993",
"0.5311868",
"0.52511024",
"0.5176978",
"0.51719844",
"0.51626706",
"0.51476216",
"0.5146475",
"0.5130871",
"0.51127416",
"0.50981665",
"0.5091824",
"0.50823027",
"0.5081134",
"0.50551033",
"0.5042717",
"0.50361... | 0.6752174 | 0 |
Respond to the `selectedRevision` signal from pypubsub. | def _on_select_revision(self, **kwargs):
self._revision_id = kwargs['module_id']
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def svn_notify(self,event):\n # pysvn.wc_notify_action.update_completed\n if event['action'] == pysvn.wc_notify_action.update_completed:\n revision = event['revision']\n self.revision = revision",
"def onSelected(self):\n pass",
"def selection_changed(self):\n ... | [
"0.62416744",
"0.60654837",
"0.59142613",
"0.58489025",
"0.58353555",
"0.5674044",
"0.54842246",
"0.54825467",
"0.5423293",
"0.53679717",
"0.53676856",
"0.5355891",
"0.5354404",
"0.53491926",
"0.53078157",
"0.53046656",
"0.5300872",
"0.5299296",
"0.52821183",
"0.5278814",
"0.... | 0.670077 | 0 |
Get the translation for a string using Qt translation API. We implement this ourselves since we do not inherit QObject. | def tr(self, message):
# noinspection PyTypeChecker,PyArgumentList,PyCallByClass
return QCoreApplication.translate('Orthodem2xyzrgb', message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gettext(self, string):\n return self._translations.gettext(string)",
"def gettext_translate(string):\n # Try default translation first\n translation = localizer.old_translate(i18n.TranslationString(string))\n if translation == string:\n # translation failed then use For... | [
"0.7165638",
"0.68708587",
"0.65502787",
"0.64578044",
"0.6359209",
"0.6349498",
"0.6337029",
"0.62444365",
"0.6222953",
"0.6222953",
"0.6210399",
"0.61061776",
"0.60911477",
"0.59815615",
"0.5970113",
"0.5915851",
"0.59141165",
"0.5894791",
"0.58896285",
"0.5876152",
"0.5869... | 0.0 | -1 |
Add a toolbar icon to the toolbar. | def add_action(
self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_to_toolbar ( self, toolbar_item ):\r\n pass",
"def AddIcon(*args, **kwargs):\n return _gdi_.IconBundle_AddIcon(*args, **kwargs)",
"def icon(self, icon):\n self._icon = icon",
"def add_toolbar(self, title=None, toolbar=None):\n if 1 != bool(toolbar) + bool(title):\n ... | [
"0.69304866",
"0.66122353",
"0.6507136",
"0.6479284",
"0.64467525",
"0.6425615",
"0.64154416",
"0.6344951",
"0.6340648",
"0.6300516",
"0.62950766",
"0.62950766",
"0.6277065",
"0.6277065",
"0.6277065",
"0.62653816",
"0.62580323",
"0.6251146",
"0.6251146",
"0.6251146",
"0.62511... | 0.6272122 | 21 |
Removes the plugin menu item and icon from QGIS GUI. | def unload(self):
for action in self.actions:
self.iface.removePluginMenu(
self.tr(u'&Create xyzrgb from Mosaic/DSM'),
action)
self.iface.removeToolBarIcon(action) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unload(self):\n self.iface.removePluginRasterMenu(self.menu, self.action)\n self.iface.removeRasterToolBarIcon(self.action)",
"def unload(self):\n for action in self.actions:\n self.iface.removePluginWebMenu(\n self.tr(u'&Buienradar Plugin'),\n ac... | [
"0.75985533",
"0.7490045",
"0.74875885",
"0.74644965",
"0.74293286",
"0.73977417",
"0.7351217",
"0.7302819",
"0.72957236",
"0.7280735",
"0.72645974",
"0.7254971",
"0.7249904",
"0.7242769",
"0.7236294",
"0.7224091",
"0.7221227",
"0.7193434",
"0.7174475",
"0.7174303",
"0.706305... | 0.73383284 | 7 |
clean up the worker and thread | def workerExceptionThrown(self, exc, tb):
self.worker.deleteLater()
self.thread.quit()
self.thread.wait()
self.thread.deleteLater()
print str(tb)
self.iface.messageBar().pushMessage('Error:' + str(tb), level=QgsMessageBar.CRITICAL, duration=3) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cleanup_threading(self):\n self.pids = []\n self.receiver_thread = None\n self.manager_thread = None\n self.workflows_executed = 0\n self.threading_is_initialized = False\n self.load_balancer = None\n self.receiver = None",
"def cleanup():",
"def clean_up(se... | [
"0.7617214",
"0.75679314",
"0.7493909",
"0.7443149",
"0.7439993",
"0.7439993",
"0.7439993",
"0.7412886",
"0.7412886",
"0.740551",
"0.73626775",
"0.73626775",
"0.73626775",
"0.73626775",
"0.73626775",
"0.73626775",
"0.73626775",
"0.73626775",
"0.73626775",
"0.73626775",
"0.736... | 0.0 | -1 |
clean up the worker and thread | def workerFinished(self, ret):
self.worker.deleteLater()
self.thread.quit()
self.thread.wait()
self.thread.deleteLater()
# remove widget from message bar
self.iface.messageBar().popWidget(self.messageBar)
if ret is not None:
# report the result
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cleanup_threading(self):\n self.pids = []\n self.receiver_thread = None\n self.manager_thread = None\n self.workflows_executed = 0\n self.threading_is_initialized = False\n self.load_balancer = None\n self.receiver = None",
"def cleanup():",
"def clean_up(se... | [
"0.7618245",
"0.756773",
"0.74941987",
"0.7443747",
"0.74397534",
"0.74397534",
"0.74397534",
"0.7412843",
"0.7412843",
"0.7405907",
"0.7362572",
"0.7362572",
"0.7362572",
"0.7362572",
"0.7362572",
"0.7362572",
"0.7362572",
"0.7362572",
"0.7362572",
"0.7362572",
"0.7362572",
... | 0.0 | -1 |
Start task in a separate worker thread | def startWorker(self):
worker = Worker(self)
# configure the QgsMessageBar
messageBar = self.iface.messageBar().createMessage('Started to create file', )
progressBar = self.dlg.progressBar
cancelButton = self.dlg.pbCancel
cancelButton.clicked.connect(worker.kill)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def execute_task(self, task):\n t = threading.Thread(target=task)\n t.start()",
"def start(self):\n if self.threadPool:\n self.threadPool.addTask(self)\n\n # Lets other threads have a chance to run\n time.sleep(0)\n else:\n raise TaskError(\... | [
"0.72511715",
"0.7200598",
"0.7173589",
"0.7115231",
"0.7037704",
"0.701224",
"0.701224",
"0.69576657",
"0.693258",
"0.6605127",
"0.65964097",
"0.656866",
"0.6543169",
"0.6533425",
"0.648766",
"0.64696765",
"0.6452332",
"0.6406273",
"0.63960487",
"0.63709843",
"0.63425493",
... | 0.6265067 | 24 |
file chooser for orthomosaic | def choosefilenameortho(self, e):
filename = QFileDialog.getOpenFileName(self.dlg,"Select TIFF file",
"/home", "TIF files (*.tif);;All files (*.*)")
if filename:
self.dlg.leOrthomosaic.setText(filename) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def choose_file(self):\n pass",
"def fileCmd(self):\n filename = askopenfilename() \n self.cnvImgOrig.displayImage(filename)\n self.cnvImgTest.displayImage(filename)",
"def chooseOpenFile(self):\n fname = QFileDialog.getOpenFileName(self, 'Open file',\n ... | [
"0.68460006",
"0.6781604",
"0.6464207",
"0.6318979",
"0.6274876",
"0.6174504",
"0.6145747",
"0.6051645",
"0.6024273",
"0.6023101",
"0.58995837",
"0.5868736",
"0.5868575",
"0.58656466",
"0.5854936",
"0.58537596",
"0.58488727",
"0.58395654",
"0.58267856",
"0.5804377",
"0.577666... | 0.7535651 | 0 |
file chooser for DSM file | def choosefilenamedsm(self, e):
filename = QFileDialog.getOpenFileName(self.dlg,"Select TIFF file",
"/home", "TIF files (*.tif);;All files (*.*)")
if filename:
self.dlg.leDem.setText(filename) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def choose_file(self):\n pass",
"def choosefile():\r\n\r\n # get filename\r\n filename = tkFileDialog.askopenfilename(**options)\r\n #print filename, '*****'\r\n\r\n # open file on your own\r\n if filename:\r\n #return open(filename, 'r')\r\n tasks.upload_chosen = filename",
... | [
"0.7694681",
"0.6940432",
"0.6824514",
"0.6824514",
"0.67526436",
"0.67517835",
"0.6737426",
"0.6693227",
"0.6636667",
"0.6618639",
"0.6614086",
"0.65942067",
"0.65742457",
"0.65133035",
"0.65074074",
"0.65001905",
"0.64629984",
"0.64560777",
"0.64248145",
"0.642477",
"0.6422... | 0.69285095 | 2 |
Wire in the event bindings | def run(self):
# show the dialog
self.dlg.pbOrtho.clicked.connect(self.choosefilenameortho)
self.dlg.pbDem.clicked.connect(self.choosefilenamedsm)
self.dlg.pbStart.clicked.connect(self.startWorker)
self.dlg.show()
# Run the dialog event loop
result = self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def events(self):",
"def bind( self, context ):\n if not self.bound:\n self.bound = True\n context.addEventHandler(\n 'mousein', node=self, \n function = self.OnMouseIn,\n )\n context.addEventHandler(\n 'mouseout', no... | [
"0.70708",
"0.68839735",
"0.6836781",
"0.66658187",
"0.65025246",
"0.6466312",
"0.64557165",
"0.6414354",
"0.64101064",
"0.6395929",
"0.63834065",
"0.6380132",
"0.63736653",
"0.6305454",
"0.627618",
"0.62598383",
"0.6257808",
"0.6153896",
"0.6099257",
"0.60847014",
"0.6074706... | 0.0 | -1 |
Turn debugging on or off. flag (boolean) True means output debugging, False means no. | def set_debug(flag):
global debug
debug = flag
XLM.XLM_Object.debug = flag
XLM.xlm_library.debug = flag
XLM.ms_stack_transformer.debug = flag
XLM.stack_transformer.debug = flag
XLM.excel2007.debug = flag | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _pma_set_debug_flag(flag):\n global _pma_debug\n\n if not isinstance(flag, (bool)):\n raise Exception(\"flag argument must be of class bool\")\n _pma_debug = flag\n if flag is True:\n print(\"Debug flag enabled. You will receive extra feedback and messages from pma_python (like this o... | [
"0.8442389",
"0.8004203",
"0.7552657",
"0.7459034",
"0.74430126",
"0.7386035",
"0.7369075",
"0.733531",
"0.73233885",
"0.72165483",
"0.71832865",
"0.7181144",
"0.71762866",
"0.711174",
"0.6919977",
"0.69111127",
"0.6909054",
"0.68787426",
"0.68384385",
"0.6745519",
"0.6719568... | 0.773577 | 2 |
Run olevba on the given file and extract the XLM macro code lines. maldoc (str) The fully qualified name of the Excel file to analyze. (str) The XLM macro cells extracted from running olevba on the given file. None will be returned on error. | def _extract_xlm(maldoc):
# Run olevba on the given file.
olevba_out = None
FNULL = open(os.devnull, 'w')
try:
cmd = "timeout 30 olevba -c \"" + str(maldoc) + "\""
olevba_out = subprocess.check_output(cmd, shell=True, stderr=FNULL)
except Exception as e:
color_print.output('... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_workbook_97(maldoc):\n\n # Run olevba on the file and extract the XLM macro code lines.\n color_print.output('g', \"Analyzing Excel 97 file ...\")\n xlm_code = _extract_xlm(maldoc)\n color_print.output('g', \"Extracted XLM with olevba.\")\n if debug:\n print(\"=========== START RAW ... | [
"0.6144289",
"0.6018125",
"0.57654345",
"0.4963401",
"0.49541065",
"0.48330134",
"0.46645972",
"0.45865145",
"0.45475653",
"0.4467187",
"0.44324526",
"0.4419184",
"0.441069",
"0.44008112",
"0.43970215",
"0.4365387",
"0.43541402",
"0.43446854",
"0.42940488",
"0.42849368",
"0.4... | 0.733833 | 0 |
Guess the sheet containing the XLM macros by finding the sheet with the most unresolved "NAME" cells. workbook (ExcelSheet object) The Excel spreadsheet to check. (str) The name of the sheet that might contain the XLM macros. | def _guess_xlm_sheet(workbook):
# TODO: If plugin_biff.py used by olevba to dump XLM includes sheet names this
# function will no longer be needed.
# Look at each sheet.
xlm_sheet = None
unresolved_count = -1
for curr_sheet_name in workbook.sheet_names():
curr_sheet = workbook.sheet_by... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_workbook_2007(maldoc):\n\n # Read in the 2007+ cells.\n color_print.output('g', \"Analyzing Excel 2007+ file ...\")\n workbook_info = XLM.excel2007.read_excel_2007_XLM(maldoc) \n color_print.output('g', \"Extracted XLM from ZIP archive.\")\n if (workbook_info is None):\n return (... | [
"0.6036669",
"0.60088015",
"0.5607725",
"0.56071246",
"0.5354856",
"0.52406216",
"0.518099",
"0.51746696",
"0.50699383",
"0.5010548",
"0.49969032",
"0.49915874",
"0.49154997",
"0.48782837",
"0.48635158",
"0.48627582",
"0.48588476",
"0.48369735",
"0.47476253",
"0.46648648",
"0... | 0.82565725 | 0 |
Merge the given XLM cells into the value cells read from the given Excel file. maldoc (str) The fully qualified name of the Excel file to analyze. xlm_cells (dict) A dict of XLM formula objects (XLM_Object objects) where dict[ROW][COL] gives the XLM cell at (ROW, COL). (tuple) A 3 element tuple where the 1st element is... | def _merge_XLM_cells(maldoc, xlm_cells):
# Read in the Excel workbook data.
color_print.output('g', "Merging XLM macro cells with data cells ...")
workbook = excel.read_excel_sheets(maldoc)
if (workbook is None):
color_print.output('r', "ERROR: Reading in Excel file " + str(maldoc) + " failed."... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_workbook_2007(maldoc):\n\n # Read in the 2007+ cells.\n color_print.output('g', \"Analyzing Excel 2007+ file ...\")\n workbook_info = XLM.excel2007.read_excel_2007_XLM(maldoc) \n color_print.output('g', \"Extracted XLM from ZIP archive.\")\n if (workbook_info is None):\n return (... | [
"0.604738",
"0.6008518",
"0.5825835",
"0.5649459",
"0.55426455",
"0.52557373",
"0.48428568",
"0.48080117",
"0.475572",
"0.4632839",
"0.4576498",
"0.45346174",
"0.4532015",
"0.4509528",
"0.44865486",
"0.4460298",
"0.444932",
"0.44257683",
"0.44192648",
"0.44060838",
"0.4393537... | 0.8173978 | 0 |
Read in an Excel 2007+ workbook and the XLM macros in the workbook. maldoc (str) The fully qualified name of the Excel file to analyze. (tuple) A 3 element tuple where the 1st element is the workbook object, the 2nd element is a list of XLM cell indices ((row, column) tuples) and the 3rd element is a sheet element for ... | def _read_workbook_2007(maldoc):
# Read in the 2007+ cells.
color_print.output('g', "Analyzing Excel 2007+ file ...")
workbook_info = XLM.excel2007.read_excel_2007_XLM(maldoc)
color_print.output('g', "Extracted XLM from ZIP archive.")
if (workbook_info is None):
return (None, None, None... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_workbook_97(maldoc):\n\n # Run olevba on the file and extract the XLM macro code lines.\n color_print.output('g', \"Analyzing Excel 97 file ...\")\n xlm_code = _extract_xlm(maldoc)\n color_print.output('g', \"Extracted XLM with olevba.\")\n if debug:\n print(\"=========== START RAW ... | [
"0.72741294",
"0.7015034",
"0.69145006",
"0.5732033",
"0.5640195",
"0.55930376",
"0.5567607",
"0.556654",
"0.5291013",
"0.5264286",
"0.510124",
"0.5087777",
"0.503987",
"0.50384337",
"0.5029056",
"0.50221443",
"0.5013305",
"0.5012877",
"0.50087535",
"0.49634397",
"0.49184382"... | 0.7939801 | 0 |
Read in an Excel 97 workbook and the XLM macros in the workbook. maldoc (str) The fully qualified name of the Excel file to analyze. (tuple) A 3 element tuple where the 1st element is the workbook object, the 2nd element is a list of XLM cell indices ((row, column) tuples) and the 3rd element is a sheet element for the... | def _read_workbook_97(maldoc):
# Run olevba on the file and extract the XLM macro code lines.
color_print.output('g', "Analyzing Excel 97 file ...")
xlm_code = _extract_xlm(maldoc)
color_print.output('g', "Extracted XLM with olevba.")
if debug:
print("=========== START RAW XLM =============... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_workbook_2007(maldoc):\n\n # Read in the 2007+ cells.\n color_print.output('g', \"Analyzing Excel 2007+ file ...\")\n workbook_info = XLM.excel2007.read_excel_2007_XLM(maldoc) \n color_print.output('g', \"Extracted XLM from ZIP archive.\")\n if (workbook_info is None):\n return (... | [
"0.79433113",
"0.72427917",
"0.7036231",
"0.5774751",
"0.57168466",
"0.5638217",
"0.563626",
"0.5588673",
"0.53787875",
"0.5337786",
"0.5189825",
"0.5149428",
"0.51007754",
"0.5068647",
"0.5065638",
"0.5052728",
"0.5047861",
"0.5045103",
"0.5043639",
"0.5033287",
"0.49730438"... | 0.7649732 | 1 |
Emulate the behavior of a given Excel file containing XLM macros. maldoc (str) The fully qualified name of the Excel file to analyze. (tuple) 1st element is a list of 3 element tuples containing the actions performed by the sheet, 2nd element is the human readable XLM code. | def emulate(maldoc):
# Excel 97 file?
if (XLM.utils.is_excel_file_97(maldoc)):
workbook, xlm_cell_indices, xlm_sheet = _read_workbook_97(maldoc)
if (workbook is None):
color_print.output('r', "ERROR: Reading Excel 97 file failed. Emulation aborted.")
return ([], "")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_workbook_2007(maldoc):\n\n # Read in the 2007+ cells.\n color_print.output('g', \"Analyzing Excel 2007+ file ...\")\n workbook_info = XLM.excel2007.read_excel_2007_XLM(maldoc) \n color_print.output('g', \"Extracted XLM from ZIP archive.\")\n if (workbook_info is None):\n return (... | [
"0.6723555",
"0.6653062",
"0.6573594",
"0.5674583",
"0.50879794",
"0.4930489",
"0.49133873",
"0.47957298",
"0.4716508",
"0.4700348",
"0.46856138",
"0.46792737",
"0.46772945",
"0.45869985",
"0.4560465",
"0.45124787",
"0.4482203",
"0.44816422",
"0.44635886",
"0.44590777",
"0.44... | 0.74941033 | 0 |
restores the previous value that appeared on screen before the current value | def undo():
# pressing undo twice restores the original value
global current_value, operations
# solution: since there are only 2 values stored, swap
operations[0], operations[1] = operations[1], operations[0]
current_value = operations[-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def previous(self, _event):\n self.set_val(self.val - 1)",
"def _reset(self):\n self._value = self._default",
"def reset(self):\n if np.any(self.val != self.valinit):\n self.set_val(self.valinit)",
"def reset(self):\n self.value = self.min_value",
"def back( self ... | [
"0.7064052",
"0.67926604",
"0.6779316",
"0.67684746",
"0.6731488",
"0.6712456",
"0.66832244",
"0.6680013",
"0.6603748",
"0.66011363",
"0.6588475",
"0.64831895",
"0.64447075",
"0.6402228",
"0.63306135",
"0.6300861",
"0.6258527",
"0.6232558",
"0.62290627",
"0.62260324",
"0.6209... | 0.6586685 | 11 |
export the object as a DOM node | def _exportNode(self):
node = self._extractProperties()
self._logger.info('settings exported.')
return node | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dom_element(self, doc):\n string = \"This should never be printed. - EGCryptoSystem.py\"\n return self.to_stub(string, string).to_dom_element(doc)",
"def saveToXml(self) -> org.jdom.Element:\n ...",
"def dom(self):\n raise NotImplementedError(\"base class called\")",
"def t... | [
"0.6095584",
"0.6086931",
"0.60766387",
"0.5632199",
"0.55993336",
"0.5587957",
"0.5569819",
"0.55200905",
"0.55086356",
"0.54823077",
"0.5463836",
"0.5459833",
"0.5445634",
"0.54350054",
"0.5427114",
"0.54055375",
"0.5374137",
"0.53687066",
"0.53391767",
"0.53107303",
"0.530... | 0.53783166 | 16 |
import the object from the DOM node | def _importNode(self, node):
if self.environ.shouldPurge():
self._purgeProperties()
self._initProperties(node)
self._logger.info('settings imported.') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loads(src):\n return Document(src).root()",
"def loadFromDom(self, root):\n if hasattr(root, \"documentElement\"):\n self.xml = root\n else:\n # Encase the given tree fragment in a Document\n self.xml = createRootNode()\n self.xml.appendChild(self.... | [
"0.56948936",
"0.5567659",
"0.541593",
"0.5304131",
"0.52615625",
"0.5225738",
"0.521192",
"0.5209291",
"0.5179152",
"0.5168463",
"0.51372474",
"0.5137079",
"0.51219136",
"0.51199913",
"0.51124996",
"0.5111796",
"0.5098951",
"0.5096477",
"0.50870323",
"0.5080122",
"0.506883",... | 0.5070543 | 20 |
import settings for websocket client integration from an XML file | def importWebSocketClientSettings(context):
site = context.getSite()
utility = queryUtility(IWebSocketConnectionConfig, context=site)
if utility is None:
logger = context.getLogger('collective.websocketclient')
logger.info('Nothing to import.')
return
if IPersistent.providedBy(ut... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_settings(self):\n # Set the default settings. In case in a later version of this script the settings change, new default variables will be added automatically\n self.settings = {\n # Connection settings to OBS Studio websockets plugin\n \"host\": \"localhost\",\... | [
"0.58948606",
"0.57333976",
"0.5718949",
"0.54858726",
"0.54734534",
"0.5444267",
"0.5406738",
"0.53434104",
"0.52570355",
"0.525459",
"0.52514964",
"0.5226953",
"0.5206524",
"0.520246",
"0.5165548",
"0.50997484",
"0.50673604",
"0.50673604",
"0.5064736",
"0.50557166",
"0.5043... | 0.6708304 | 0 |
export settings for websocket client integration as an XML file | def exportWebSocketClientSettings(context):
site = context.getSite()
utility = queryUtility(IWebSocketConnectionConfig, context=site)
if utility is None:
logger = context.getLogger('collective.websocketclient')
logger.info('Nothing to export.')
return
if IPersistent.providedBy(ut... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_config_xml_to_broker(self):\n xmlObject = xml.dom.minidom.parse(\"config_setup.xml\")\n pretty_xml_as_string = xmlObject.toprettyxml()\n self.client.publish(\"users/everyone/inbox/server/deviceList\", pretty_xml_as_string)\n print(\"XML config sent.\")",
"def write_config(sel... | [
"0.6345738",
"0.59505016",
"0.5862077",
"0.5750333",
"0.5711413",
"0.566478",
"0.5633414",
"0.55401486",
"0.5536291",
"0.5536282",
"0.5519001",
"0.5490517",
"0.54668343",
"0.54395074",
"0.5418738",
"0.54035866",
"0.5395367",
"0.5363175",
"0.5324485",
"0.5318015",
"0.5297074",... | 0.7233053 | 0 |
A function to react to key being pressed on an image canvas. | def doSomething(imp, keyEvent):
IJ.log("clicked keyCode " + str(keyEvent.getKeyCode()) + " on image " + | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _onKeyPress(self, widget, event):\n\t\t#print event.hardware_keycode\n\t\tif event.hardware_keycode in [102,100,98,104] and self.fullscreenToggle:\n\t\t\t# Binding: arrow keys: move image (Fs)\n\t\t\t# Binding: arrow keys+Shift: move image faster (Fs)\n\t\t\tif event.state & gtk.gdk.SHIFT_MASK:\n\t\t\t\tamount... | [
"0.6845082",
"0.68138224",
"0.68048865",
"0.6795043",
"0.6732254",
"0.66485685",
"0.6618535",
"0.65895975",
"0.65495425",
"0.65127254",
"0.64510345",
"0.64482975",
"0.6427912",
"0.6411434",
"0.64104617",
"0.63843274",
"0.6371269",
"0.6336644",
"0.63249564",
"0.63180494",
"0.6... | 0.70632905 | 0 |
Borra una asignatura Borra una asignatura y todas sus notas. | def borra_asignatura(id):
try:
cnx = mysql.connector.connect(user=user, password=password, database=database)
cursor = cnx.cursor()
#cursor.execute("DELETE FROM `calificacion` WHERE `calificacion`.`id_asignatura` = {}".format(id))
cursor.execute("DELETE FROM `asignatura` WHERE `a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def archivos_de_texto():\n palabra = \"\" \n palabras_candidatas = [] #lista donde se guardara las palabras candidatas de cada linea\n palabra_cantidad = {} #diccionario con la palabra candidata de clave y las veces que esta repetida en cada texto de valor\n with open(\"Cuentos.txt\",\"r\") as Cuentos:... | [
"0.6330623",
"0.6197294",
"0.61444724",
"0.61302763",
"0.60686797",
"0.60686797",
"0.60686797",
"0.60686797",
"0.60686797",
"0.599808",
"0.59829855",
"0.5942891",
"0.5915584",
"0.5878275",
"0.5834363",
"0.5825661",
"0.5819315",
"0.58142996",
"0.57805777",
"0.5764775",
"0.5745... | 0.5463605 | 42 |
Returns whether a metric is considered healthy Function compares the metric mapped to by key it was initialized with | def is_healthy(self, metric_results):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def check_health():\n return {\"healthy\": True}",
"def is_healthy(self) -> bool:\n try:\n self.health()\n except MeiliSearchError:\n return False\n return True",
"def is_healthy(self) -> bool:\n return False",
"def healthy(self) -> bool:\n re... | [
"0.6246055",
"0.6168581",
"0.60983115",
"0.6049883",
"0.6007633",
"0.5973169",
"0.59227043",
"0.5918034",
"0.58422655",
"0.5830914",
"0.5814101",
"0.58081686",
"0.5798145",
"0.5791956",
"0.57410717",
"0.57409346",
"0.56640285",
"0.56574523",
"0.5646705",
"0.56458324",
"0.5634... | 0.67867005 | 0 |
This method will return the closest point index for a given point P from list of points given in centers | def closestCluster(p, centers):
bestIndex = 0
closest = float("+inf")
for i in range(len(centers)):
distance = np.sqrt(np.sum((np.array(p) - centers[i]) ** 2))
if distance < closest:
closest = distance
bestIndex = i
return bestIndex | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def closestClusterAndDistance(p, centers):\n\tbestIndex = 0\n closest = float(\"+inf\")\n for i in range(len(centers)):\n distance = np.sqrt(np.sum((np.array(p) - centers[i]) ** 2))\n if distance < closest:\n closest = distance\n bestIndex = i\n ... | [
"0.81604385",
"0.7818576",
"0.76468176",
"0.7452406",
"0.7312577",
"0.7209503",
"0.7146841",
"0.7022789",
"0.7015073",
"0.69740677",
"0.69587153",
"0.69570583",
"0.6940364",
"0.6904534",
"0.6889646",
"0.68861485",
"0.685346",
"0.68314093",
"0.6825442",
"0.6790361",
"0.6773268... | 0.8303884 | 0 |
This method will return the closest point index and its ditance for a given point P from list of points given in centers | def closestClusterAndDistance(p, centers):
bestIndex = 0
closest = float("+inf")
for i in range(len(centers)):
distance = np.sqrt(np.sum((np.array(p) - centers[i]) ** 2))
if distance < closest:
closest = distance
bestIndex = i
return (best... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def closestCluster(p, centers):\n\tbestIndex = 0\n closest = float(\"+inf\")\n for i in range(len(centers)):\n distance = np.sqrt(np.sum((np.array(p) - centers[i]) ** 2))\n if distance < closest:\n closest = distance\n bestIndex = i\n\treturn bestIn... | [
"0.80020124",
"0.7691775",
"0.7506859",
"0.7360311",
"0.7189735",
"0.71564335",
"0.71380126",
"0.71302176",
"0.69669247",
"0.6954315",
"0.6937151",
"0.6917281",
"0.6860945",
"0.6839078",
"0.67988765",
"0.67920554",
"0.6790271",
"0.6789571",
"0.6771405",
"0.67593086",
"0.67492... | 0.80924296 | 0 |
train method will take dataframe as an input and returns centers using kmeans algorithm with L2 distance | def train(self, data):
epsilon = self.epsilon
tempDist = 1.0
k = self.k
centers = data.rdd.takeSample(False, k, 1)
i = 0
while tempDist > epsilon or self.maxNoOfIteration > i:
i+=1
closest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))
pointStats = closest.reduceByK... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def k_means_model(df, numOfClusters):\n # Perform scaling on the dataframe containing the selected features\n data = scale(df)\n\n # Train a model\n model = KMeans(init=\"k-means++\", n_clusters=numOfClusters, n_init=20).fit(data)\n return model",
"def calculate_kmeans(df, clusters=10):\r\n kme... | [
"0.71723557",
"0.691053",
"0.6901916",
"0.6852868",
"0.68385345",
"0.68138105",
"0.67475885",
"0.6669792",
"0.65544796",
"0.6422493",
"0.64189833",
"0.6411663",
"0.63902324",
"0.6388245",
"0.63098115",
"0.6305227",
"0.6287323",
"0.6283454",
"0.62477034",
"0.62462896",
"0.6237... | 0.7532827 | 0 |
returns the index of the closest cluster for a given data point data | def predict(self, data):
return closestCluster(data, self.centers) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clusterAndDistance(self, data):\n\t\treturn closestClusterAndDistance(data, self.centers)",
"def closest_cluster(cluster_averages, example):\n\n # just do a normal search for a minimum\n best_index = -1\n best_distance = 10000000\n for (i, cluster_average) in enumerate(cluster_averages):\n ... | [
"0.76343995",
"0.74881965",
"0.7465451",
"0.7393315",
"0.73417085",
"0.71406156",
"0.70573294",
"0.7044991",
"0.68879014",
"0.68158907",
"0.675538",
"0.66819733",
"0.66790366",
"0.66746634",
"0.6630393",
"0.65902525",
"0.6589684",
"0.65885776",
"0.65667975",
"0.6524308",
"0.6... | 0.7158905 | 5 |
returns the index of the closest cluster and its distance for a given data point data | def clusterAndDistance(self, data):
return closestClusterAndDistance(data, self.centers) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def closestClusterAndDistance(p, centers):\n\tbestIndex = 0\n closest = float(\"+inf\")\n for i in range(len(centers)):\n distance = np.sqrt(np.sum((np.array(p) - centers[i]) ** 2))\n if distance < closest:\n closest = distance\n bestIndex = i\n ... | [
"0.7288707",
"0.7270212",
"0.72385883",
"0.71241885",
"0.7107449",
"0.70917314",
"0.7035779",
"0.6971508",
"0.6815752",
"0.65985656",
"0.65984434",
"0.6574564",
"0.6555377",
"0.6491588",
"0.6482346",
"0.6465322",
"0.6464889",
"0.6460569",
"0.64458454",
"0.64357096",
"0.643149... | 0.8121391 | 0 |
Filter annsets to annotations overlapping candidate. | def filter_to_candidate(self):
filtered = { k: [] for k in self.annsets }
for key, annset in self.annsets.items():
for a in annset:
if a.overlaps(self.candidate):
filtered[key].append(a)
self.annsets = filtered | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def overlap(annotations1, annotations2):\n return [val for val in annotations1 if val in annotations2]",
"def overlapping_aids(self, gid, region, visible_thresh=0.0):\n overlap_aids = self.isect_index.overlapping_aids(gid, region)\n if visible_thresh > 0 and len(overlap_aids) > 0:\n #... | [
"0.6370355",
"0.58862954",
"0.56585723",
"0.5642055",
"0.5398902",
"0.5389672",
"0.5317603",
"0.5258657",
"0.5253353",
"0.5193474",
"0.5176536",
"0.51494116",
"0.51470774",
"0.5127493",
"0.51185286",
"0.51145107",
"0.5083101",
"0.50759697",
"0.5057774",
"0.50500035",
"0.50029... | 0.77305436 | 0 |
Get collection contents organized by file extension. | def _get_contents_by_ext(self, collection):
contents_by_ext = defaultdict(list)
collection_dir = os.path.join(self.root_dir, collection)
for name in sorted(os.listdir(collection_dir)):
path = os.path.join(collection_dir, name)
if os.path.isfile(path):
root... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def file_contents_with_ext(self, ext):\n for filename in self.project.namelist():\n if filename.endswith('.'+ext):\n contents = self.project.open(filename, 'r')\n return contents\n return None",
"def content(self, extensionFilter=[]):\r\n\r\n if self.... | [
"0.6799076",
"0.6698243",
"0.62939227",
"0.5981953",
"0.597571",
"0.5942609",
"0.5938336",
"0.5910077",
"0.5861005",
"0.5847813",
"0.58334965",
"0.58313465",
"0.5780494",
"0.5774376",
"0.57720035",
"0.57720035",
"0.57720035",
"0.5757031",
"0.5736017",
"0.5729282",
"0.57288516... | 0.84675837 | 0 |
Atomic write using os.rename(). | def safe_write_file(self, fn, text):
fd, tmpfn = mkstemp(dir=self.temp_dir)
with open(fd, 'wt') as f:
f.write(text)
# https://stackoverflow.com/a/2333979
f.flush()
os.fsync(f.fileno())
os.rename(tmpfn, fn) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _rename_ondisk(self):\n if not self.has_moved or not self.renames_remaining:\n return\n\n try:\n os.rename(self.rename_phase_src, self.rename_phase_dst)\n except Exception:\n sys.stderr.write(\"Failed to renamed '%s' to '%s'\\n\" %\n ... | [
"0.6895058",
"0.65596277",
"0.6537626",
"0.64969563",
"0.62407434",
"0.62288344",
"0.621589",
"0.621589",
"0.61950946",
"0.61240774",
"0.6068798",
"0.60534745",
"0.6049205",
"0.60448855",
"0.60263747",
"0.6019295",
"0.599629",
"0.5951231",
"0.59394264",
"0.59154314",
"0.5915"... | 0.60334814 | 14 |
Run one epoch of supervised training. | def train(args, model, data_loader, optimizer):
# Keep track of average accuracy and loss
avg_loss = utils.AverageMeter()
# Set training mode
model.train()
# for inputs, target in tqdm(data_loader):
for inputs, targets in tqdm(data_loader):
# Prep
inputs = utils.wrap_variables(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_one_epoch(self):\n raise NotImplementedError",
"def train_one_epoch(self):\n\t\tself.model.train()\n\t\ttrain_loss = 0\n\n\t\tfor batch_idx, data in enumerate(self.data_loader.train_loader):\n\t\t\tInput = data[0].float().to(self.device)\n\t\t\tOutput = data[1].float().to(self.device)\n\n\t\t\ts... | [
"0.80954355",
"0.75742745",
"0.75505626",
"0.743583",
"0.743583",
"0.743583",
"0.743583",
"0.7434428",
"0.7377287",
"0.7295083",
"0.72670895",
"0.7232734",
"0.72042525",
"0.71757835",
"0.7169562",
"0.70450747",
"0.70069456",
"0.6976382",
"0.6933775",
"0.6905024",
"0.6881554",... | 0.0 | -1 |
Make and score predictions over a validation set. | def validate(args, gold, model, data_loader, test=False):
# Keep track of average accuracy and loss
avg_loss = utils.AverageMeter()
# Set eval mode
model.eval()
tags = []
# for inputs, target in tqdm(data_loader):
for inputs, targets in tqdm(data_loader):
# Prep
inputs = ut... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_predictions(model, test_set, val_set):\n \n ## Uses model to predict some amount of images\n predict = model.predict_classes(test_set, batch_size=5, verbose=1)\n \n ## We use the length of these two arrays when we sift through the data to find\n ## the right predictions and wrong predic... | [
"0.7228824",
"0.7145484",
"0.70474017",
"0.69962245",
"0.6961123",
"0.69058377",
"0.6893376",
"0.6873761",
"0.68471813",
"0.6821834",
"0.6819396",
"0.66773593",
"0.66623193",
"0.66238314",
"0.6610336",
"0.6605166",
"0.65586555",
"0.65393037",
"0.6513405",
"0.6509343",
"0.6506... | 0.0 | -1 |
Set up optimizer with appropriate hyper parameters. | def initialize_optimizer(model, args):
parameters = [p for p in model.parameters() if p.requires_grad]
if args.optimizer == 'sgd':
optimizer = optim.SGD(parameters, args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(self): \n self.optimizer = torch.optim.Adam(self.model.parameters(), lr=config.LR)",
"def setup_optims(self):\n lr = self.train_config['lr']\n b1 = self.train_config['b1']\n b2 = self.train_config['b2']\n weight_decay = self.train_config['weight_decay']\n ... | [
"0.7506818",
"0.7411478",
"0.72629744",
"0.7237952",
"0.72072446",
"0.72070575",
"0.7093286",
"0.70762485",
"0.7066376",
"0.7042463",
"0.7042463",
"0.69938517",
"0.693997",
"0.693997",
"0.69101626",
"0.69048315",
"0.68350106",
"0.6829197",
"0.6809148",
"0.6802163",
"0.6789328... | 0.6327329 | 58 |
Since EXPN isn't implemented by aiosmtpd, it raises an exception by default. | async def test_expn_error(
smtp_client: SMTP, smtpd_server: asyncio.AbstractServer
) -> None:
async with smtp_client:
with pytest.raises(SMTPResponseException):
await smtp_client.expn("a-list") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_connect_fail(self):\n with pytest.raises(InstrumentGatewayError):\n with InstrumentGateway(addr='an invalid ip!'):\n pass",
"def test_invalid_host_expression_prop(self):\n block = SNMPBase()\n block._create_data = MagicMock()\n block.execute_request ... | [
"0.5509301",
"0.54383117",
"0.5364098",
"0.5273363",
"0.5237218",
"0.52316636",
"0.5167674",
"0.5159681",
"0.5133844",
"0.51326466",
"0.51005864",
"0.5098053",
"0.5096402",
"0.50824183",
"0.50808847",
"0.5040562",
"0.5016725",
"0.4992853",
"0.49822763",
"0.4979743",
"0.495856... | 0.5898231 | 0 |
Test destination name if valid. | def valid_destination_name(destination):
regex = "^[a-zA-Z0-9_ ]{1,}$"
return re.match(regex, destination) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _validate_name(name):\r\n\tif HOST_NAME != name and len(name) > 0 and ZOOM_PHRASES[0] not in name and name not in WAITING_ROOM:\r\n\t\treturn True\r\n\treturn False",
"def _check_name(self):\n\t\tpass",
"def check_name(self, name: str):\n if name[0] == \"/\" or self.check_end_streaming(name):\n ... | [
"0.6535112",
"0.6483265",
"0.645965",
"0.643167",
"0.64052624",
"0.6389805",
"0.6371145",
"0.6364668",
"0.6258072",
"0.61742145",
"0.61726576",
"0.614411",
"0.61119163",
"0.6093495",
"0.60323554",
"0.60181886",
"0.60100025",
"0.6006968",
"0.59973705",
"0.5990156",
"0.5984307"... | 0.8409464 | 0 |
Takes in a pandas df with columns as symbols and vals representing those symbol close values | def calcBollinger(df_data, lBack):
df_rollingMean = pd.DataFrame(index = df_data.index)
df_rollingStd = pd.DataFrame(index = df_data.index)
df_bollinger = pd.DataFrame(index = df_data.index)
for sym in df_data.columns:
rollingSeries = df_data[sym].rolling(window = lBack, center = False)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def price_dataframe(symbols=('sne',),\n start=datetime.datetime(2008, 1, 1),\n end=datetime.datetime(2009, 12, 31),\n price_type='actual_close',\n cleaner=util.clean_dataframe,\n ):\n if isinstance(price_type, basestring):\n price_type = [price_type]\n start = nlp.util.normalize_date(st... | [
"0.5885016",
"0.58074105",
"0.5763836",
"0.5630117",
"0.5587682",
"0.55351543",
"0.5534801",
"0.5518426",
"0.5350534",
"0.533454",
"0.5312944",
"0.52825993",
"0.5211557",
"0.520425",
"0.51822555",
"0.5174227",
"0.5174091",
"0.5152903",
"0.5138558",
"0.51347065",
"0.5122696",
... | 0.0 | -1 |
Load the model, training and evaluation configs for PET from the given command line arguments. | def load_pet_configs(args) -> Tuple[WrapperConfig, pet.TrainConfig, pet.EvalConfig]:
model_cfg = WrapperConfig(model_type=args.model_type, model_name_or_path=args.model_name_or_path,
wrapper_type=args.wrapper_type, task_name=args.task_name, label_list=args.label_list,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_args():\n hpo_warning = 'Flag overwrites config value if set, used for HPO and PBT runs primarily'\n parser = argparse.ArgumentParser('train.py')\n add_arg = parser.add_argument\n add_arg('config', nargs='?', default='configs/hello.yaml')\n add_arg('-d', '--distributed', choices=['ddp-file... | [
"0.64883953",
"0.6423853",
"0.6339392",
"0.63173246",
"0.63055223",
"0.6296296",
"0.6258348",
"0.6205302",
"0.6176762",
"0.61579216",
"0.61514276",
"0.61273324",
"0.6091553",
"0.6090854",
"0.60844326",
"0.608109",
"0.6078909",
"0.607694",
"0.6071167",
"0.60487896",
"0.6036241... | 0.6690745 | 0 |
Load the model, training and evaluation configs for a regular sequence classifier from the given command line arguments. This classifier can either be used as a standalone model or as the final classifier for PET/iPET. | def load_sequence_classifier_configs(args) -> Tuple[WrapperConfig, pet.TrainConfig, pet.EvalConfig]:
model_cfg = WrapperConfig(model_type=args.model_type, model_name_or_path=args.model_name_or_path,
wrapper_type=SEQUENCE_CLASSIFIER_WRAPPER, task_name=args.task_name,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(command_line_parameters=None):\n args = command_line_arguments(command_line_parameters)\n\n logger.debug(\"Loading preprocessor\")\n preprocessor = bob.bio.base.load_resource(' '.join(args.preprocessor), \"preprocessor\")\n logger.debug(\"Loading extractor\")\n extractor = bob.bio.base.load_resource(... | [
"0.6719115",
"0.64597875",
"0.64026177",
"0.6383858",
"0.6353411",
"0.6342971",
"0.6329676",
"0.62917",
"0.61846244",
"0.6178162",
"0.61706626",
"0.6156029",
"0.61509514",
"0.61228794",
"0.61039567",
"0.6080009",
"0.6074509",
"0.60659707",
"0.603283",
"0.602758",
"0.59777206"... | 0.67100024 | 1 |
Load the iPET config from the given command line arguments. | def load_ipet_config(args) -> pet.IPetConfig:
ipet_cfg = pet.IPetConfig(generations=args.ipet_generations, logits_percentage=args.ipet_logits_percentage,
scale_factor=args.ipet_scale_factor, n_most_likely=args.ipet_n_most_likely)
return ipet_cfg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_config(args):\n load_args={}\n with open(args.config, 'r') as f:\n for line in f:\n key, value = line.strip().split('=')\n try:\n value = int(value)\n except ValueError:\n try:\n value = float(value)\n ... | [
"0.6620625",
"0.65885556",
"0.65620697",
"0.6530543",
"0.65282035",
"0.65250957",
"0.63654464",
"0.63244563",
"0.62861556",
"0.6278691",
"0.62023723",
"0.6184847",
"0.61702293",
"0.61346585",
"0.6072536",
"0.6040853",
"0.6028272",
"0.6002226",
"0.5997254",
"0.59311545",
"0.59... | 0.6928259 | 0 |
Generate result lists (image names and list with scores) | def build_retrieved_list(self, scores):
res = self.index.rank(scores)
tmp_res = []
# keep scores too
tmp_scores = []
# build the list
tmp_res = []
#print rank, "<--"
for i, k in res:
tmp_res.append( self.indices[i] )
tmp_scores.ap... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yolo_show(image_path_list, batch_list):\n font = cv2.FONT_HERSHEY_SIMPLEX\n for img_path, batch in zip(image_path_list, batch_list):\n result_list = batch.tolist()\n img = cv2.imread(img_path)\n for result in result_list:\n cls = int(result[0])\n bbox = result[1... | [
"0.6683602",
"0.65201557",
"0.64013934",
"0.6362181",
"0.62997663",
"0.62602174",
"0.6209405",
"0.6145581",
"0.61233777",
"0.61121494",
"0.6098388",
"0.60845476",
"0.60814047",
"0.6066887",
"0.6045889",
"0.6020761",
"0.5991178",
"0.598916",
"0.5951274",
"0.5938158",
"0.593636... | 0.5793339 | 40 |
Load the STS Benchmark csv format. | def load_file(fpath):
sick_data = {'X_A': [], 'X_B': [], 'y': []}
with open(fpath, 'r', encoding='utf-8') as f:
for line in f:
text = line.strip().split('\t')
sick_data['X_A'].append(text[5].split())
sick_data['X_B'].append(text[6].split())
sick_data['y'].... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def runs_loader(path):\n files = sorted(glob.glob(f\"{path}/*_runs.csv\"))\n df_lis = list(range(len(files)))\n for i, f in enumerate(files):\n try:\n df_lis[i] = pd.read_csv(f, sep=\",\", header=0)\n print('Read runs.csv\\n', f, df_lis[i].shape,\n df_lis[i]['... | [
"0.61960995",
"0.6105455",
"0.5986365",
"0.5912232",
"0.58732283",
"0.5808441",
"0.57353777",
"0.5726986",
"0.5686586",
"0.568514",
"0.5670385",
"0.56530213",
"0.5645176",
"0.5643989",
"0.56404597",
"0.5638081",
"0.562153",
"0.5615256",
"0.5598542",
"0.5506595",
"0.550397",
... | 0.0 | -1 |
Label encoding from Tree LSTM paper (Tai, Socher, Manning). | def encode_labels(labels, nclass=5):
y = np.zeros((len(labels), nclass)).astype('float32')
for j, yj in enumerate(labels):
for i in range(nclass):
if i+1 == np.floor(yj) + 1:
y[j, i] = yj - np.floor(yj)
if i+1 == np.floor(yj):
y[j, i] = np.floor(yj... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getLabelEncoder():\n classes = list(string.letters + string.digits)\n classes.append('')\n le = LabelEncoder()\n le.fit(classes)\n\n return le",
"def build_label_transform():\n\n return NALabelEncoder()",
"def lblencoder(self):\n for i in self.data.columns:\n if self.dat... | [
"0.70767474",
"0.702532",
"0.6875088",
"0.6661352",
"0.6608816",
"0.651388",
"0.64687127",
"0.6330287",
"0.63131607",
"0.62710196",
"0.6238585",
"0.62264204",
"0.62100923",
"0.620349",
"0.6152642",
"0.61374915",
"0.60997736",
"0.60554326",
"0.601872",
"0.6012537",
"0.59937024... | 0.62131274 | 12 |
Transform probs to logprobs for KLdivergence. | def prepare_data(train_x, train_y, dev_x, dev_y, test_x, testy):
train_x = torch.FloatTensor(train_x).cuda()
train_y = torch.FloatTensor(train_y).cuda()
dev_x = torch.FloatTensor(dev_x).cuda()
dev_y = torch.FloatTensor(dev_y).cuda()
test_x = torch.FloatTensor(test_x).cuda()
test_y = torch.FloatT... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_probs(self):\n return np.array([m['log_probs'] for m in self.model_outs], dtype=np.float32)",
"def to_logprobs(x):\n N = x.size(0)\n sid_bins = x.size(1)//2\n H, W = x.size()[-2:]\n A = x[:, ::2, :, :].clone()\n B = x[:, 1::2, :, :].clone()\n\n A = A.view(N, 1, -1)\n B = B.vie... | [
"0.69283354",
"0.66957754",
"0.65397966",
"0.637631",
"0.6367839",
"0.63648623",
"0.63648623",
"0.63457084",
"0.63122123",
"0.6291868",
"0.62705356",
"0.61518747",
"0.6108963",
"0.6101549",
"0.6047805",
"0.6036303",
"0.6034293",
"0.59642345",
"0.5948823",
"0.5943543",
"0.5934... | 0.0 | -1 |
Assumes that 'hand' has all the letters in word. In other words, this assumes that however many times a letter appears in 'word', 'hand' has at least as many of that letter in it. | def updateHand(hand, word):
# TO DO ... <-- Remove this comment when you code this function
handCopy = hand.copy()
for l in word:
if handCopy[l] >= 1:
handCopy[l] -= 1
print handCopy | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isValidWord(word, hand, wordList):\n myHand = hand.copy() \n for letter in word:\n if letter not in hand or myHand[letter] <= 0:\n return False\n else:\n myHand[letter] -= 1 \n if word not in wordList:\n return False\n else:\n return T... | [
"0.7523875",
"0.7382198",
"0.7290641",
"0.7285861",
"0.7223651",
"0.72069925",
"0.7139263",
"0.7120952",
"0.70973337",
"0.70633984",
"0.6983601",
"0.6970582",
"0.69672215",
"0.69574076",
"0.6905207",
"0.6899507",
"0.68932843",
"0.6694957",
"0.66840017",
"0.66779584",
"0.66185... | 0.59908813 | 61 |
Train or update a spaCy model. Requires data to be formatted in spaCy's JSON format. To convert data from other formats, use the `spacy convert` command. | def train(
# fmt: off
lang: ("Model language", "positional", None, str),
output_path: ("Output directory to store model in", "positional", None, Path),
train_path: ("Location of JSON-formatted training data", "positional", None, Path),
dev_path: ("Location of JSON-formatted development data", "posit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_nlu(data, config, model_dir):\n # Read the config_spacy.json as JSON \n with open(config) as f: config = json.load(f)\n\n training_data = load_data(data)\n trainer = Trainer(RasaNLUModelConfig(config))\n trainer.train(training_data)\n\n model_directory = trainer.persist(model_dir, fixed... | [
"0.6168623",
"0.60145473",
"0.59643066",
"0.59500396",
"0.59390277",
"0.5891947",
"0.58586216",
"0.58549035",
"0.5753519",
"0.569553",
"0.5639808",
"0.5621899",
"0.56205606",
"0.561257",
"0.56034636",
"0.55959255",
"0.559412",
"0.5584512",
"0.55254185",
"0.54839414",
"0.54839... | 0.7009214 | 0 |
Returns mean score between tasks in pipeline that can be used for early stopping. | def _score_for_model(meta):
mean_acc = list()
pipes = meta["pipeline"]
acc = meta["accuracy"]
if "tagger" in pipes:
mean_acc.append(acc["tags_acc"])
if "morphologizer" in pipes:
mean_acc.append((acc["morphs_acc"] + acc["pos_acc"]) / 2)
if "parser" in pipes:
mean_acc.appen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def avgcpu(self):\n return (self._total_cpu['value'] / self._total_cpu['count']) if self._total_cpu['count'] else 0",
"def score(self, task):\n raise NotImplementedError(\"must subclass and implement score(task)\")",
"def getAverage(self):\n return sum(self.scores) / len(self.scores)",
"... | [
"0.6135161",
"0.60931313",
"0.60613865",
"0.5927177",
"0.5919117",
"0.59168655",
"0.58380854",
"0.58222544",
"0.5811924",
"0.57893497",
"0.5779506",
"0.57702696",
"0.5763837",
"0.5745407",
"0.57277334",
"0.5717946",
"0.571239",
"0.568665",
"0.567822",
"0.567822",
"0.567822",
... | 0.6233691 | 0 |
Load pretrained weights for the 'tokentovector' part of the component models, which is typically a CNN. See 'spacy pretrain'. Experimental. | def _load_pretrained_tok2vec(nlp, loc):
with loc.open("rb") as file_:
weights_data = file_.read()
loaded = []
for name, component in nlp.pipeline:
if hasattr(component, "model") and component.model.has_ref("tok2vec"):
component.get_ref("tok2vec").from_bytes(weights_data)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_model(self):\n if self.ckpt_flag:\n LOG('Skip Loading Pre-trained Model......')\n else:\n if self.params.pre_trained_from is not None and os.path.exists(self.params.pre_trained_from):\n try:\n LOG('Loading Pre-trained Model at %s' % sel... | [
"0.6386861",
"0.63678175",
"0.6225031",
"0.62216717",
"0.61162937",
"0.6101295",
"0.6054075",
"0.6042603",
"0.6018365",
"0.59910965",
"0.59458715",
"0.5943918",
"0.59387076",
"0.5920058",
"0.5915071",
"0.59099936",
"0.59086907",
"0.5901546",
"0.59015244",
"0.58882916",
"0.588... | 0.6853876 | 0 |
Check that t is a tree, with the correct interla structure. (Helper function not a unit test.) | def isTree(self, t):
if type(t) != tree:
return False;
if not hasattr(t, "label"):
return False;
if type(t.label) != str:
return False;
if not hasattr(t, "children"):
return False;
if type(t.children) != list:
return Fa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_tree(t):\n if type(t) != list or len(t) < 1:\n return False\n elif is_leaf(t):\n return True\n else:\n return all([is_tree(b) for b in t[1:]])",
"def test01(self):\n\n t = tree(\"a\", [tree(\"b\"), tree(\"c\")]);\n self.assertTrue(self.isTree(t))",
"def test_t... | [
"0.7773105",
"0.7650496",
"0.7045109",
"0.7035572",
"0.6966886",
"0.6953431",
"0.69326895",
"0.68154866",
"0.680478",
"0.6793031",
"0.66768706",
"0.6661258",
"0.6602542",
"0.6554972",
"0.6527791",
"0.6508529",
"0.65084046",
"0.65048134",
"0.64875036",
"0.6486214",
"0.64814633... | 0.7827654 | 0 |
Test that a tree has the correct internal structure | def test01(self):
t = tree("a", [tree("b"), tree("c")]);
self.assertTrue(self.isTree(t)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_Tree():",
"def test_tree_with_one_node_has_correct_value(one_t):\n assert one_t.root.value == 10",
"def test_small_tree_has_root_value(small_tree):\n assert small_tree.root.right.value == 11",
"def test_children_tree(depth_one_tree):\n assert str(depth_one_tree.root.children) == str([1, 2, ... | [
"0.8074132",
"0.75645053",
"0.75372213",
"0.75328934",
"0.7508595",
"0.74147695",
"0.7401527",
"0.73936456",
"0.7295448",
"0.7258387",
"0.72362375",
"0.7197044",
"0.7170132",
"0.71507156",
"0.7150426",
"0.71499306",
"0.71315193",
"0.70960915",
"0.708435",
"0.7022881",
"0.7012... | 0.80878603 | 0 |
Test __len__ on a threenode tree. | def test02(self):
t = tree("a", [tree("b"), tree("c")]);
self.assertEqual(len(t), 3) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __len__(self):\n return len(self.subtrees())",
"def __len__(self):\n return len(self.node)",
"def __len__(self):\n return self.tree.filled_size()",
"def __len__(self) -> int:\n return len(self.nodes)",
"def __len__(self) -> int:\r\n return len(self._nodes)",
"def __... | [
"0.7968297",
"0.7580855",
"0.74269414",
"0.73743844",
"0.7341332",
"0.716077",
"0.71163964",
"0.69386286",
"0.69055265",
"0.6814265",
"0.67931795",
"0.6781239",
"0.67347807",
"0.666625",
"0.65411854",
"0.65411854",
"0.65411854",
"0.6505981",
"0.6462519",
"0.6437713",
"0.64302... | 0.65768653 | 14 |
Test __str__ on a singlenode tree. | def test03(self):
t = tree("a");
s = str(t)
self.assertEqual(re.sub("\s+", "", s), "a;") # Remove spaces and test equality | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_node_str():\n a_left = Node(7, data='pl left')\n a_right = Node(42, data='pl right')\n a = Node(13, data='pl a', left=a_left, right=a_right)\n string_a = str(a)\n expect_string = '13'\n assert string_a == expect_string",
"def __str__(self):\n # Tricky to do iteratively so we do ... | [
"0.7350977",
"0.68626225",
"0.66907823",
"0.6621794",
"0.66000634",
"0.6573606",
"0.642054",
"0.63686234",
"0.62550914",
"0.62465364",
"0.61168313",
"0.6109845",
"0.61042523",
"0.61012125",
"0.6084556",
"0.60727394",
"0.6066159",
"0.6063924",
"0.6031296",
"0.6014376",
"0.6004... | 0.67876506 | 2 |
Test parse_newick on a singlenode tree representation. | def test04(self):
s = "a;"
t = parse_newick(s);
self.assertTrue(self.isTree(t) and t.label == "a" and t.isLeaf()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_tree_support(self):\r\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\r\n \"\"\"\r\n /-------.5 /-a\r\n ---1| \\-b\r\n \\------.5 /-c\r\n \\-d\r\n \"\"\"\r\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d... | [
"0.67046046",
"0.66692567",
"0.6668407",
"0.6530691",
"0.64476365",
"0.64186615",
"0.6259178",
"0.6180899",
"0.6084381",
"0.60290694",
"0.6021466",
"0.600306",
"0.5996744",
"0.5918722",
"0.5868246",
"0.58530134",
"0.57235086",
"0.56478876",
"0.5604132",
"0.55337864",
"0.55275... | 0.76883775 | 0 |
Test that parse_newick throws the right kind of exception when the ; is missing. | def test05(self):
s = "a"
with self.assertRaises(ParserException):
t = parse_newick(s) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_no_start_open_parens(self):\n self.assertRaises(ValueError, NewickTokenizer, newick='hi')",
"def test_extra_closed(self):\n nt = NewickTokenizer(newick='(a,(b,c)));')\n self.assertRaises(ValueError, nt.tokens)",
"def test_unclosed_comment(self):\n nt = NewickTokenizer(newic... | [
"0.71277916",
"0.6992496",
"0.6932686",
"0.69308096",
"0.67307556",
"0.6727998",
"0.6665779",
"0.65718716",
"0.6517503",
"0.63459533",
"0.6345652",
"0.62765884",
"0.6201289",
"0.6190885",
"0.61274683",
"0.6123086",
"0.6117942",
"0.61088365",
"0.6092642",
"0.6080887",
"0.60476... | 0.75182545 | 0 |
This function parses arguments like argv and returns a dictionary with keys action tags | def parse_arguments(args): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_args(argv):\n result = {}\n for arg in argv:\n k, v = arg.split(\"=\")\n result[k] = v\n return result",
"def retrieve_args_dict():\n process_args = sys.argv[1:]\n dictionary = dict()\n for process_arg in process_args:\n splitted = process_arg.split(\":\")\n if len(spli... | [
"0.656502",
"0.64459336",
"0.64356583",
"0.6318063",
"0.6279127",
"0.62615263",
"0.6145342",
"0.6143788",
"0.6119476",
"0.60930604",
"0.60857743",
"0.6077435",
"0.60595834",
"0.60482275",
"0.60474616",
"0.6030172",
"0.6011784",
"0.59997857",
"0.598045",
"0.5979317",
"0.597013... | 0.65210056 | 1 |
Try to open the config file if it does not exist, assume default configuration, else exit with an error | def load_config(config=CONFIGFILE):
try:
cfg = open(config, 'r').read()
return sanitize_config(json.loads(cfg))
except IOError as e:
(errno, errstr) = e.args
if errno == 2:
return DEFAULTCONFIG
else:
print("An error occured opening the configuration file '%s':"%(config),
file=stderr)
print(err... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_config_file():\n # Locate and init config.\n default_config = \"config.json\"\n if len(sys.argv) == 2:\n # config from command line\n app_config = config_reader(sys.argv[1])\n else:\n # config should be in default\n app_config = config_reader(default_config)\n #... | [
"0.7525276",
"0.7193444",
"0.71882033",
"0.71124953",
"0.7107984",
"0.6897188",
"0.6821535",
"0.6812968",
"0.6799228",
"0.67775863",
"0.6752519",
"0.67052954",
"0.66308767",
"0.66073364",
"0.65852654",
"0.656446",
"0.65604955",
"0.654337",
"0.6540201",
"0.6525114",
"0.6507747... | 0.5841644 | 100 |
Check if dbfile is set; else replace with dbfile of default config. Further default values might come. Also expand tilde in filepaths. | def sanitize_config(config):
if not 'dbfile' in config.keys():
config['dbfile'] = DEFAULTCONFIG['dbfile']
for path in ['dbfile']:
config[path]=os.path.expanduser(config[path])
return config | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_db_file():\n\n return os.path.join(db_path, db_file)",
"def default_bug_db(configfile=None):\n\n configs=None\n if not configfile:\n configs=default_configs()\n else:\n configs=configparser.ConfigParser()\n configs.read(configfile)\n\n db_file=os.path.normpath(configs.... | [
"0.724011",
"0.7007624",
"0.63317364",
"0.59065104",
"0.5838431",
"0.5786949",
"0.5773432",
"0.57708883",
"0.57708883",
"0.5744681",
"0.5727951",
"0.5716239",
"0.563708",
"0.56251484",
"0.5617629",
"0.5604145",
"0.5599592",
"0.5594931",
"0.55584013",
"0.5538118",
"0.552904",
... | 0.6772628 | 2 |
requires amount, context and date are optional. If no date is present, assume today. | def add(config, args):
if args == []:
help()
return
amount, context, date = 0, "", ""
for arg in args:
if re.match("^[0-9]*([\.,][0-9]{0,2}){0,1}$", arg) and not amount:
amount = float(arg.replace(',', '.'))
elif arg.startswith("@") and (len(arg) > 1):
context = ','.join([context, arg[1:]])
elif not ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_today():\n return datetime.today()",
"def get_today_date():\n return date.today()",
"def _today() -> datetime.date:\n return datetime.today().date()",
"def get_today() -> datetime.date:\n return datetime.date.today()",
"def today():\n return date.today()",
"def today():\n return... | [
"0.5370315",
"0.53645146",
"0.53539944",
"0.53277975",
"0.5276431",
"0.5236099",
"0.5217637",
"0.51641953",
"0.516228",
"0.51084334",
"0.5088825",
"0.50885737",
"0.5048977",
"0.5037175",
"0.5029199",
"0.5022949",
"0.5022212",
"0.5007552",
"0.49963936",
"0.4955769",
"0.4952214... | 0.0 | -1 |
lists all entries, displays the total amount and budgets if defined. | def ls(config, args):
result = read()
if args == []:
_prettyprint(result)
else:
for arg in args:
if "@" == arg[0]:
result = list(filter(lambda x: _is_in(arg[1:], x["context"]),
result))
if "since" in args:
try:
date = datetime.datetime.strptime(args[args.index("since")+1],
"%Y-%m-%d").st... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def view_budgets(self) -> None:\n Menu.prompt_view_budgets()\n for budget in self.user.budget_manager:\n print(f\"{budget}\\n\")",
"def view(self):\n\n print('Here\\'s your expense and income records:\\n'+' '*3+'Category'+' '*7+\\\n 'Description'+' '*4+'Amount\\n'+'='*4... | [
"0.6818141",
"0.6373648",
"0.6282395",
"0.6123618",
"0.5956045",
"0.5908045",
"0.587244",
"0.58472174",
"0.58132833",
"0.5761324",
"0.57453924",
"0.5715379",
"0.57048655",
"0.5656268",
"0.5623658",
"0.5612284",
"0.5593725",
"0.55616355",
"0.55489856",
"0.55394465",
"0.5528048... | 0.0 | -1 |
returns the budget for the defined tag | def budget(config, tag):
if tag in config["budget"].keys():
print(tag)
else:
print(config["budget"].keys()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def budget(self):\n return self._budget",
"def getBudget(movieInfo):\n if \"budget\" in movieInfo:\n return int(movieInfo[\"budget\"])\n else:\n raise AttributeError(\"%s instance has no attribute budget\" % movieInfo)",
"def get_budget(self, category: BudgetCategory) -> Budget:\n ... | [
"0.7083501",
"0.65791714",
"0.6482024",
"0.63894933",
"0.6077988",
"0.58800274",
"0.5838075",
"0.58222085",
"0.5746922",
"0.5691997",
"0.5674798",
"0.56654537",
"0.5650313",
"0.56176656",
"0.55753535",
"0.55744225",
"0.5489822",
"0.53618115",
"0.53394234",
"0.5320373",
"0.531... | 0.719083 | 0 |
Classification model that does the mapping of | def __init__(self,
names,
data,
embedding_fns,
encoder_fns_1,
encoder_fns_2,
logits_fns,
evaluation_fns,
# MTL
mixing_ratios,
L2_coefficient=None,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_category(self):\n pass",
"def classify(self, data):\n \"*** YOUR CODE HERE ***\"\n return self.sklearn_classifier.predict(data)",
"def model(self):\n filePath = self.config['data_path']['train_data']\n data = self.loadCSV(filePath)\n cleandata = self.prepro... | [
"0.6690187",
"0.64756536",
"0.6441268",
"0.6374809",
"0.63580745",
"0.6353296",
"0.6329436",
"0.6312559",
"0.6221688",
"0.6219069",
"0.6196666",
"0.618929",
"0.6177566",
"0.61771584",
"0.6163415",
"0.6138004",
"0.6116106",
"0.6072633",
"0.60633653",
"0.6055231",
"0.60338527",... | 0.0 | -1 |
Initialize data generators. This function assumes the wrapped model to have `._data` field. | def initialize_data_iterator(self, model_idx=None):
if model_idx and not isinstance(model_idx, (list, tuple)):
raise TypeError("`model_idx` must be list-like structure")
model_indices = (
# if model_idx is None
# model_idx = [all_models_indices]
model_idx... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_model(self):\n pass",
"def initialize_model(self):\n pass",
"def initialize(self, model):\n pass",
"def init_from_data(self, data):\n self.data = data\n self.norm_data()",
"def __init__(self, model: Any, data: Iterable[Any]):\n super().__init__(model, data... | [
"0.6300777",
"0.62807715",
"0.6212327",
"0.61153483",
"0.61078835",
"0.6094563",
"0.60931665",
"0.6075413",
"0.59868747",
"0.59868747",
"0.59868747",
"0.59868747",
"0.5954239",
"0.5919463",
"0.5886439",
"0.58657",
"0.58602965",
"0.5820341",
"0.58048314",
"0.5776811",
"0.57676... | 0.660022 | 0 |
Fetch Data and Predictions | def _fetch_data_batch(self, logits, predictions, data=None):
if data is not None:
# this will explicitly avoid data.initializer
(fetched_target,
fetched_logits,
fetched_predictions) = self._sess.run(
[data.target, logits, predictions])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _fetch_data(self):\n pass",
"def fetch_data():\n for category in CHEATSHEETS.items():\n subprocess.call(f'curl -o {PATH}{category[0] + \".csv\"} {category[1]}', shell=True)\n\n index = -1\n for filename in os.listdir(PATH):\n for idx, row in pd.read_csv(PATH + filename, on_bad_l... | [
"0.67397493",
"0.66788644",
"0.65545076",
"0.64402926",
"0.6339428",
"0.63302475",
"0.63217604",
"0.62826043",
"0.6261717",
"0.62599313",
"0.62335795",
"0.61924237",
"0.6142523",
"0.61279005",
"0.61167353",
"0.6081533",
"0.60656494",
"0.60575473",
"0.6055011",
"0.6031515",
"0... | 0.666906 | 2 |
Sample from model predictions, and evaluate outputs | def _evaluate(self,
logits,
predictions,
data, evaluation_fn,
max_eval_batches=None,
calculate_scores=True,
write_results=False):
# counting the evaluation batches
num_eval_batches = 0
# l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(model, test_files):\n print(\"Running predictions.\")\n models = load_model(model)\n predictions = predict(models, test_files)\n\n # # write predictions to file\n # write_predictions(\"evaluate_out.json\",predictions)\n evaluate_individual(predictions, test_files, models)\n evalua... | [
"0.7101648",
"0.6955216",
"0.6852982",
"0.6852803",
"0.6742147",
"0.6641561",
"0.66390866",
"0.65709037",
"0.6543093",
"0.64913476",
"0.64873594",
"0.64872164",
"0.6486736",
"0.64565843",
"0.6448053",
"0.6428368",
"0.64260185",
"0.6417553",
"0.6416274",
"0.6413926",
"0.641122... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.